e2sim/e2apv1sim/src/ASN1/generated/X2AP-IEs.hpp

   1 /*****************************************************************************
   2 # Copyright 2019 AT&T Intellectual Property                                  *
   3 #                                                                            *
   4 # Licensed under the Apache License, Version 2.0 (the "License");            *
   5 # you may not use this file except in compliance with the License.           *
   6 # You may obtain a copy of the License at                                    *
   7 #                                                                            *
   8 #      http://www.apache.org/licenses/LICENSE-2.0                            *
   9 #                                                                            *
  10 # Unless required by applicable law or agreed to in writing, software        *
  11 # distributed under the License is distributed on an "AS IS" BASIS,          *
  12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   *
  13 # See the License for the specific language governing permissions and        *
  14 # limitations under the License.                                             *
  15 #                                                                            *
  16 ******************************************************************************/
  17
  18 #pragma once
  19
  20 #include "asn/asn.hpp"
  21 static_assert(ASN_API_VERSION_MAJOR == 5, "re-generate the ASN parser's code using 'make regen-asn' (do not use -j option)");
  22
  23 #include "X2AP-Constants.hpp"
  24 #include "X2AP-CommonDataTypes.hpp"
  25 #include "X2AP-Containers.hpp"
  26
  27 /*
  28 DL-ABS-status::= INTEGER (0..100)
  29 */
  30
  31 struct DL_ABS_status : asn::integer<>
  32 {
  33         using constraint_t = asn::constraints<false,asn::span<0, 100>>;
  34         static constexpr const char* name() {return "DL-ABS-status";}
  35         using parent_t = asn::integer<>;
  36
  37 };
  38
  39 /*
  40 UsableABSInformationFDD-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
  41         ...
  42 }
  43 */
  44
  45 struct UsableABSInformationFDD_ExtIEs
  46 {
  47         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
  48         {
  49                 size_t get_index() const {return type;}
  50                 bool is_unknown() const { return type == 1; }
  51                 void clear() {type = 0;}
  52                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
  53                 template<typename V>  bool decode(V& v)
  54                 {
  55                         clear();
  56                         if(!v(ref_nested())) return false;
  57                         { type = 1; return true;}
  58                         return false;
  59
  60                 }
  61                 template<typename V> bool encode(V& v) const
  62                 {
  63                         return v(ref_nested());
  64
  65                 }
  66                 protected:
  67                 template<typename V>  bool decode(size_t index, V& v)
  68                 {
  69                         clear();
  70                         switch(index)
  71                         {
  72                         case 1: type = 1; return v(ref_nested());
  73                         ref_nested().clear();
  74                         }
  75                         return false;
  76
  77                 }
  78                 template<typename V> bool encode(size_t index, V& v) const
  79                 {
  80                         if(index != type) {return false;} return v(ref_nested());
  81
  82                 }
  83                 private:
  84                 size_t type {0};
  85
  86         };
  87         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
  88         {
  89                 size_t get_index() const {return type;}
  90                 bool is_unknown() const { return type == 1; }
  91                 void clear() {type = 0;}
  92                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
  93                 template<typename V>  bool decode(V& v)
  94                 {
  95                         clear();
  96                         if(!v(ref_nested())) return false;
  97                         { type = 1; return true;}
  98                         return false;
  99
 100                 }
 101                 template<typename V> bool encode(V& v) const
 102                 {
 103                         return v(ref_nested());
 104
 105                 }
 106                 protected:
 107                 template<typename V>  bool decode(size_t index, V& v)
 108                 {
 109                         clear();
 110                         switch(index)
 111                         {
 112                         case 1: type = 1; return v(ref_nested());
 113                         ref_nested().clear();
 114                         }
 115                         return false;
 116
 117                 }
 118                 template<typename V> bool encode(size_t index, V& v) const
 119                 {
 120                         if(index != type) {return false;} return v(ref_nested());
 121
 122                 }
 123                 private:
 124                 size_t type {0};
 125
 126         };
 127         struct Extension_t : asn::typefield<true>
 128         {
 129                 ~Extension_t()  {clear();}
 130                 size_t get_index() const {return type;}
 131                 bool is_unknown() const { return type == 1; }
 132                 void clear()
 133                 {
 134                         type = 0; ref_nested().clear();
 135                 }
 136                 template<typename V> static inline void enumerate(V& v)
 137                 {
 138
 139                 }
 140                 protected:
 141                 template<typename V> bool decode(size_t index, V& v)
 142                 {
 143                         clear();
 144                         switch(index)
 145                         {
 146                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
 147                         }
 148                         return false;
 149
 150                 }
 151                 template<typename V> bool encode(size_t index, V& v) const
 152                 {
 153                         if(index != type) return false;
 154                         return false;
 155
 156                 }
 157                 private:
 158                 size_t type {0};
 159
 160         };
 161         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
 162         {
 163                 size_t get_index() const {return type;}
 164                 bool is_unknown() const { return type == 1; }
 165                 void clear() {type = 0;}
 166                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
 167                 template<typename V>  bool decode(V& v)
 168                 {
 169                         clear();
 170                         if(!v(ref_nested())) return false;
 171                         { type = 1; return true;}
 172                         return false;
 173
 174                 }
 175                 template<typename V> bool encode(V& v) const
 176                 {
 177                         return v(ref_nested());
 178
 179                 }
 180                 protected:
 181                 template<typename V>  bool decode(size_t index, V& v)
 182                 {
 183                         clear();
 184                         switch(index)
 185                         {
 186                         case 1: type = 1; return v(ref_nested());
 187                         ref_nested().clear();
 188                         }
 189                         return false;
 190
 191                 }
 192                 template<typename V> bool encode(size_t index, V& v) const
 193                 {
 194                         if(index != type) {return false;} return v(ref_nested());
 195
 196                 }
 197                 private:
 198                 size_t type {0};
 199
 200         };
 201
 202 };
 203 /*
 204 UsableABSInformationFDD ::= SEQUENCE {
 205         usable-abs-pattern-info                         BIT STRING (SIZE(40)),
 206         iE-Extensions                                           ProtocolExtensionContainer { {UsableABSInformationFDD-ExtIEs} } OPTIONAL,
 207         ...
 208 }
 209 */
 210
 211 struct UsableABSInformationFDD : asn::sequence<2, 0, true, 1>
 212 {
 213         static constexpr const char* name() {return "UsableABSInformationFDD";}
 214         using parent_t = asn::sequence<2, 0, true, 1>;
 215         struct usable_abs_pattern_info_t : asn::bstring<>
 216         {
 217                 using constraint_t = asn::constraints<false,asn::one<40>>;
 218                 static constexpr const char* name() {return "usable_abs_pattern_info_t";}
 219                 using parent_t = asn::bstring<>;
 220
 221         };
 222
 223         usable_abs_pattern_info_t& ref_usable_abs_pattern_info() {return usable_abs_pattern_info;}
 224         usable_abs_pattern_info_t const& ref_usable_abs_pattern_info() const {return usable_abs_pattern_info;}
 225         struct iE_Extensions_t : ProtocolExtensionContainer<UsableABSInformationFDD_ExtIEs>
 226         {
 227                 static constexpr const char* name() {return "iE_Extensions_t";}
 228                 using parent_t = ProtocolExtensionContainer<UsableABSInformationFDD_ExtIEs>;
 229                 static constexpr bool optional = true;
 230
 231         };
 232         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
 233         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
 234         template<typename V> void decode(V& v)
 235         {
 236                 v(usable_abs_pattern_info);
 237                 v(iE_Extensions);
 238
 239         };
 240         template<typename V> void encode(V& v) const
 241         {
 242                 v(usable_abs_pattern_info);
 243                 v(iE_Extensions);
 244
 245         };
 246         void clear()
 247         {
 248                 usable_abs_pattern_info.clear();
 249                 iE_Extensions.clear();
 250
 251         };
 252         private:
 253         usable_abs_pattern_info_t       usable_abs_pattern_info;
 254         iE_Extensions_t iE_Extensions;
 255
 256 };
 257 /*
 258 UsableABSInformationTDD-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
 259         ...
 260 }
 261 */
 262
 263 struct UsableABSInformationTDD_ExtIEs
 264 {
 265         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
 266         {
 267                 size_t get_index() const {return type;}
 268                 bool is_unknown() const { return type == 1; }
 269                 void clear() {type = 0;}
 270                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
 271                 template<typename V>  bool decode(V& v)
 272                 {
 273                         clear();
 274                         if(!v(ref_nested())) return false;
 275                         { type = 1; return true;}
 276                         return false;
 277
 278                 }
 279                 template<typename V> bool encode(V& v) const
 280                 {
 281                         return v(ref_nested());
 282
 283                 }
 284                 protected:
 285                 template<typename V>  bool decode(size_t index, V& v)
 286                 {
 287                         clear();
 288                         switch(index)
 289                         {
 290                         case 1: type = 1; return v(ref_nested());
 291                         ref_nested().clear();
 292                         }
 293                         return false;
 294
 295                 }
 296                 template<typename V> bool encode(size_t index, V& v) const
 297                 {
 298                         if(index != type) {return false;} return v(ref_nested());
 299
 300                 }
 301                 private:
 302                 size_t type {0};
 303
 304         };
 305         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
 306         {
 307                 size_t get_index() const {return type;}
 308                 bool is_unknown() const { return type == 1; }
 309                 void clear() {type = 0;}
 310                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
 311                 template<typename V>  bool decode(V& v)
 312                 {
 313                         clear();
 314                         if(!v(ref_nested())) return false;
 315                         { type = 1; return true;}
 316                         return false;
 317
 318                 }
 319                 template<typename V> bool encode(V& v) const
 320                 {
 321                         return v(ref_nested());
 322
 323                 }
 324                 protected:
 325                 template<typename V>  bool decode(size_t index, V& v)
 326                 {
 327                         clear();
 328                         switch(index)
 329                         {
 330                         case 1: type = 1; return v(ref_nested());
 331                         ref_nested().clear();
 332                         }
 333                         return false;
 334
 335                 }
 336                 template<typename V> bool encode(size_t index, V& v) const
 337                 {
 338                         if(index != type) {return false;} return v(ref_nested());
 339
 340                 }
 341                 private:
 342                 size_t type {0};
 343
 344         };
 345         struct Extension_t : asn::typefield<true>
 346         {
 347                 ~Extension_t()  {clear();}
 348                 size_t get_index() const {return type;}
 349                 bool is_unknown() const { return type == 1; }
 350                 void clear()
 351                 {
 352                         type = 0; ref_nested().clear();
 353                 }
 354                 template<typename V> static inline void enumerate(V& v)
 355                 {
 356
 357                 }
 358                 protected:
 359                 template<typename V> bool decode(size_t index, V& v)
 360                 {
 361                         clear();
 362                         switch(index)
 363                         {
 364                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
 365                         }
 366                         return false;
 367
 368                 }
 369                 template<typename V> bool encode(size_t index, V& v) const
 370                 {
 371                         if(index != type) return false;
 372                         return false;
 373
 374                 }
 375                 private:
 376                 size_t type {0};
 377
 378         };
 379         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
 380         {
 381                 size_t get_index() const {return type;}
 382                 bool is_unknown() const { return type == 1; }
 383                 void clear() {type = 0;}
 384                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
 385                 template<typename V>  bool decode(V& v)
 386                 {
 387                         clear();
 388                         if(!v(ref_nested())) return false;
 389                         { type = 1; return true;}
 390                         return false;
 391
 392                 }
 393                 template<typename V> bool encode(V& v) const
 394                 {
 395                         return v(ref_nested());
 396
 397                 }
 398                 protected:
 399                 template<typename V>  bool decode(size_t index, V& v)
 400                 {
 401                         clear();
 402                         switch(index)
 403                         {
 404                         case 1: type = 1; return v(ref_nested());
 405                         ref_nested().clear();
 406                         }
 407                         return false;
 408
 409                 }
 410                 template<typename V> bool encode(size_t index, V& v) const
 411                 {
 412                         if(index != type) {return false;} return v(ref_nested());
 413
 414                 }
 415                 private:
 416                 size_t type {0};
 417
 418         };
 419
 420 };
 421 /*
 422 UsableABSInformationTDD ::= SEQUENCE {
 423         usaable-abs-pattern-info                        BIT STRING (SIZE(1..70, ...)),
 424         iE-Extensions                                           ProtocolExtensionContainer { {UsableABSInformationTDD-ExtIEs} } OPTIONAL,
 425         ...
 426 }
 427 */
 428
 429 struct UsableABSInformationTDD : asn::sequence<2, 0, true, 1>
 430 {
 431         static constexpr const char* name() {return "UsableABSInformationTDD";}
 432         using parent_t = asn::sequence<2, 0, true, 1>;
 433         struct usaable_abs_pattern_info_t : asn::bstring<>
 434         {
 435                 using constraint_t = asn::constraints<true,asn::span<1, 70>>;
 436                 static constexpr const char* name() {return "usaable_abs_pattern_info_t";}
 437                 using parent_t = asn::bstring<>;
 438
 439         };
 440
 441         usaable_abs_pattern_info_t& ref_usaable_abs_pattern_info() {return usaable_abs_pattern_info;}
 442         usaable_abs_pattern_info_t const& ref_usaable_abs_pattern_info() const {return usaable_abs_pattern_info;}
 443         struct iE_Extensions_t : ProtocolExtensionContainer<UsableABSInformationTDD_ExtIEs>
 444         {
 445                 static constexpr const char* name() {return "iE_Extensions_t";}
 446                 using parent_t = ProtocolExtensionContainer<UsableABSInformationTDD_ExtIEs>;
 447                 static constexpr bool optional = true;
 448
 449         };
 450         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
 451         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
 452         template<typename V> void decode(V& v)
 453         {
 454                 v(usaable_abs_pattern_info);
 455                 v(iE_Extensions);
 456
 457         };
 458         template<typename V> void encode(V& v) const
 459         {
 460                 v(usaable_abs_pattern_info);
 461                 v(iE_Extensions);
 462
 463         };
 464         void clear()
 465         {
 466                 usaable_abs_pattern_info.clear();
 467                 iE_Extensions.clear();
 468
 469         };
 470         private:
 471         usaable_abs_pattern_info_t      usaable_abs_pattern_info;
 472         iE_Extensions_t iE_Extensions;
 473
 474 };
 475 /*
 476 UsableABSInformation ::= CHOICE {
 477         fdd                                     UsableABSInformationFDD,
 478         tdd                                     UsableABSInformationTDD,
 479         ...
 480 }
 481 */
 482
 483 struct UsableABSInformation : asn::choice<2, 0, true>
 484 {
 485         static constexpr const char* name() {return "UsableABSInformation";}
 486         using parent_t = asn::choice<2, 0, true>;
 487         index_type get_index() const {return index;}
 488         bool is_unknown() const {return index == 3;}
 489         void set_unknown() { set_index(3);  }
 490         ~UsableABSInformation() {clear();}
 491         struct fdd_t : UsableABSInformationFDD
 492         {
 493                 static constexpr const char* name() {return "fdd_t";}
 494                 using parent_t = UsableABSInformationFDD;
 495
 496         };
 497         struct tdd_t : UsableABSInformationTDD
 498         {
 499                 static constexpr const char* name() {return "tdd_t";}
 500                 using parent_t = UsableABSInformationTDD;
 501
 502         };
 503         void clear()
 504         {
 505                 switch(get_index())
 506                 {
 507                 case 1: var.destroy<fdd_t>(); break;
 508                 case 2: var.destroy<tdd_t>(); break;
 509                 }
 510                 index = 0;
 511                 base::clear();
 512         }
 513         template<typename V> bool decode(size_t idx, V& v)
 514         {
 515                 clear();
 516                 switch(idx)
 517                 {
 518                 case 1: set_index(1); return v(var.build<fdd_t>());
 519                 case 2: set_index(2); return v(var.build<tdd_t>());
 520                 }
 521                 return false;
 522
 523         }
 524         template<typename V> bool encode(V& v) const
 525         {
 526                 switch(get_index())
 527                 {
 528                 case 1: return v(var.as<fdd_t>());
 529                 case 2: return v(var.as<tdd_t>());
 530                 }
 531                 return false;
 532         }
 533         template<typename V> static inline void enumerate(V& v)
 534         {
 535                 v.template operator()<fdd_t>(1);
 536                 v.template operator()<tdd_t>(2);
 537
 538         }
 539         fdd_t& select_fdd() { if(get_index() != 1) { clear(); set_index(1); return var.build<fdd_t>();} return var.as<fdd_t>();}
 540         fdd_t const* get_fdd() const { if(get_index() == 1) { return &var.as<fdd_t>();} return nullptr; }
 541         tdd_t& select_tdd() { if(get_index() != 2) { clear(); set_index(2); return var.build<tdd_t>();} return var.as<tdd_t>();}
 542         tdd_t const* get_tdd() const { if(get_index() == 2) { return &var.as<tdd_t>();} return nullptr; }
 543         private:
 544         void set_index(index_type i) {index = i; base::set();}
 545         union union_type
 546         {
 547                 char dummy1[sizeof(fdd_t)];
 548                 char dummy2[sizeof(tdd_t)];
 549
 550         };
 551         asn::variant<sizeof(union_type)>        var;
 552         index_type      index {0};
 553 };
 554 /*
 555 ABS-Status-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
 556         ...
 557 }
 558 */
 559
 560 struct ABS_Status_ExtIEs
 561 {
 562         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
 563         {
 564                 size_t get_index() const {return type;}
 565                 bool is_unknown() const { return type == 1; }
 566                 void clear() {type = 0;}
 567                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
 568                 template<typename V>  bool decode(V& v)
 569                 {
 570                         clear();
 571                         if(!v(ref_nested())) return false;
 572                         { type = 1; return true;}
 573                         return false;
 574
 575                 }
 576                 template<typename V> bool encode(V& v) const
 577                 {
 578                         return v(ref_nested());
 579
 580                 }
 581                 protected:
 582                 template<typename V>  bool decode(size_t index, V& v)
 583                 {
 584                         clear();
 585                         switch(index)
 586                         {
 587                         case 1: type = 1; return v(ref_nested());
 588                         ref_nested().clear();
 589                         }
 590                         return false;
 591
 592                 }
 593                 template<typename V> bool encode(size_t index, V& v) const
 594                 {
 595                         if(index != type) {return false;} return v(ref_nested());
 596
 597                 }
 598                 private:
 599                 size_t type {0};
 600
 601         };
 602         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
 603         {
 604                 size_t get_index() const {return type;}
 605                 bool is_unknown() const { return type == 1; }
 606                 void clear() {type = 0;}
 607                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
 608                 template<typename V>  bool decode(V& v)
 609                 {
 610                         clear();
 611                         if(!v(ref_nested())) return false;
 612                         { type = 1; return true;}
 613                         return false;
 614
 615                 }
 616                 template<typename V> bool encode(V& v) const
 617                 {
 618                         return v(ref_nested());
 619
 620                 }
 621                 protected:
 622                 template<typename V>  bool decode(size_t index, V& v)
 623                 {
 624                         clear();
 625                         switch(index)
 626                         {
 627                         case 1: type = 1; return v(ref_nested());
 628                         ref_nested().clear();
 629                         }
 630                         return false;
 631
 632                 }
 633                 template<typename V> bool encode(size_t index, V& v) const
 634                 {
 635                         if(index != type) {return false;} return v(ref_nested());
 636
 637                 }
 638                 private:
 639                 size_t type {0};
 640
 641         };
 642         struct Extension_t : asn::typefield<true>
 643         {
 644                 ~Extension_t()  {clear();}
 645                 size_t get_index() const {return type;}
 646                 bool is_unknown() const { return type == 1; }
 647                 void clear()
 648                 {
 649                         type = 0; ref_nested().clear();
 650                 }
 651                 template<typename V> static inline void enumerate(V& v)
 652                 {
 653
 654                 }
 655                 protected:
 656                 template<typename V> bool decode(size_t index, V& v)
 657                 {
 658                         clear();
 659                         switch(index)
 660                         {
 661                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
 662                         }
 663                         return false;
 664
 665                 }
 666                 template<typename V> bool encode(size_t index, V& v) const
 667                 {
 668                         if(index != type) return false;
 669                         return false;
 670
 671                 }
 672                 private:
 673                 size_t type {0};
 674
 675         };
 676         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
 677         {
 678                 size_t get_index() const {return type;}
 679                 bool is_unknown() const { return type == 1; }
 680                 void clear() {type = 0;}
 681                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
 682                 template<typename V>  bool decode(V& v)
 683                 {
 684                         clear();
 685                         if(!v(ref_nested())) return false;
 686                         { type = 1; return true;}
 687                         return false;
 688
 689                 }
 690                 template<typename V> bool encode(V& v) const
 691                 {
 692                         return v(ref_nested());
 693
 694                 }
 695                 protected:
 696                 template<typename V>  bool decode(size_t index, V& v)
 697                 {
 698                         clear();
 699                         switch(index)
 700                         {
 701                         case 1: type = 1; return v(ref_nested());
 702                         ref_nested().clear();
 703                         }
 704                         return false;
 705
 706                 }
 707                 template<typename V> bool encode(size_t index, V& v) const
 708                 {
 709                         if(index != type) {return false;} return v(ref_nested());
 710
 711                 }
 712                 private:
 713                 size_t type {0};
 714
 715         };
 716
 717 };
 718 /*
 719 ABS-Status ::= SEQUENCE {
 720         dL-ABS-status                                                           DL-ABS-status,
 721         usableABSInformation                                            UsableABSInformation,
 722         iE-Extensions                                                           ProtocolExtensionContainer { {ABS-Status-ExtIEs} } OPTIONAL,
 723         ...
 724 }
 725 */
 726
 727 struct ABS_Status : asn::sequence<3, 0, true, 1>
 728 {
 729         static constexpr const char* name() {return "ABS-Status";}
 730         using parent_t = asn::sequence<3, 0, true, 1>;
 731         struct dL_ABS_status_t : DL_ABS_status
 732         {
 733                 static constexpr const char* name() {return "dL_ABS_status_t";}
 734                 using parent_t = DL_ABS_status;
 735
 736         };
 737         dL_ABS_status_t& ref_dL_ABS_status() {return dL_ABS_status;}
 738         dL_ABS_status_t const& ref_dL_ABS_status() const {return dL_ABS_status;}
 739         struct usableABSInformation_t : UsableABSInformation
 740         {
 741                 static constexpr const char* name() {return "usableABSInformation_t";}
 742                 using parent_t = UsableABSInformation;
 743
 744         };
 745         usableABSInformation_t& ref_usableABSInformation() {return usableABSInformation;}
 746         usableABSInformation_t const& ref_usableABSInformation() const {return usableABSInformation;}
 747         struct iE_Extensions_t : ProtocolExtensionContainer<ABS_Status_ExtIEs>
 748         {
 749                 static constexpr const char* name() {return "iE_Extensions_t";}
 750                 using parent_t = ProtocolExtensionContainer<ABS_Status_ExtIEs>;
 751                 static constexpr bool optional = true;
 752
 753         };
 754         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
 755         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
 756         template<typename V> void decode(V& v)
 757         {
 758                 v(dL_ABS_status);
 759                 v(usableABSInformation);
 760                 v(iE_Extensions);
 761
 762         };
 763         template<typename V> void encode(V& v) const
 764         {
 765                 v(dL_ABS_status);
 766                 v(usableABSInformation);
 767                 v(iE_Extensions);
 768
 769         };
 770         void clear()
 771         {
 772                 dL_ABS_status.clear();
 773                 usableABSInformation.clear();
 774                 iE_Extensions.clear();
 775
 776         };
 777         private:
 778         dL_ABS_status_t dL_ABS_status;
 779         usableABSInformation_t  usableABSInformation;
 780         iE_Extensions_t iE_Extensions;
 781
 782 };
 783 /*
 784 ABSInformationFDD-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
 785         ...
 786 }
 787 */
 788
 789 struct ABSInformationFDD_ExtIEs
 790 {
 791         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
 792         {
 793                 size_t get_index() const {return type;}
 794                 bool is_unknown() const { return type == 1; }
 795                 void clear() {type = 0;}
 796                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
 797                 template<typename V>  bool decode(V& v)
 798                 {
 799                         clear();
 800                         if(!v(ref_nested())) return false;
 801                         { type = 1; return true;}
 802                         return false;
 803
 804                 }
 805                 template<typename V> bool encode(V& v) const
 806                 {
 807                         return v(ref_nested());
 808
 809                 }
 810                 protected:
 811                 template<typename V>  bool decode(size_t index, V& v)
 812                 {
 813                         clear();
 814                         switch(index)
 815                         {
 816                         case 1: type = 1; return v(ref_nested());
 817                         ref_nested().clear();
 818                         }
 819                         return false;
 820
 821                 }
 822                 template<typename V> bool encode(size_t index, V& v) const
 823                 {
 824                         if(index != type) {return false;} return v(ref_nested());
 825
 826                 }
 827                 private:
 828                 size_t type {0};
 829
 830         };
 831         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
 832         {
 833                 size_t get_index() const {return type;}
 834                 bool is_unknown() const { return type == 1; }
 835                 void clear() {type = 0;}
 836                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
 837                 template<typename V>  bool decode(V& v)
 838                 {
 839                         clear();
 840                         if(!v(ref_nested())) return false;
 841                         { type = 1; return true;}
 842                         return false;
 843
 844                 }
 845                 template<typename V> bool encode(V& v) const
 846                 {
 847                         return v(ref_nested());
 848
 849                 }
 850                 protected:
 851                 template<typename V>  bool decode(size_t index, V& v)
 852                 {
 853                         clear();
 854                         switch(index)
 855                         {
 856                         case 1: type = 1; return v(ref_nested());
 857                         ref_nested().clear();
 858                         }
 859                         return false;
 860
 861                 }
 862                 template<typename V> bool encode(size_t index, V& v) const
 863                 {
 864                         if(index != type) {return false;} return v(ref_nested());
 865
 866                 }
 867                 private:
 868                 size_t type {0};
 869
 870         };
 871         struct Extension_t : asn::typefield<true>
 872         {
 873                 ~Extension_t()  {clear();}
 874                 size_t get_index() const {return type;}
 875                 bool is_unknown() const { return type == 1; }
 876                 void clear()
 877                 {
 878                         type = 0; ref_nested().clear();
 879                 }
 880                 template<typename V> static inline void enumerate(V& v)
 881                 {
 882
 883                 }
 884                 protected:
 885                 template<typename V> bool decode(size_t index, V& v)
 886                 {
 887                         clear();
 888                         switch(index)
 889                         {
 890                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
 891                         }
 892                         return false;
 893
 894                 }
 895                 template<typename V> bool encode(size_t index, V& v) const
 896                 {
 897                         if(index != type) return false;
 898                         return false;
 899
 900                 }
 901                 private:
 902                 size_t type {0};
 903
 904         };
 905         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
 906         {
 907                 size_t get_index() const {return type;}
 908                 bool is_unknown() const { return type == 1; }
 909                 void clear() {type = 0;}
 910                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
 911                 template<typename V>  bool decode(V& v)
 912                 {
 913                         clear();
 914                         if(!v(ref_nested())) return false;
 915                         { type = 1; return true;}
 916                         return false;
 917
 918                 }
 919                 template<typename V> bool encode(V& v) const
 920                 {
 921                         return v(ref_nested());
 922
 923                 }
 924                 protected:
 925                 template<typename V>  bool decode(size_t index, V& v)
 926                 {
 927                         clear();
 928                         switch(index)
 929                         {
 930                         case 1: type = 1; return v(ref_nested());
 931                         ref_nested().clear();
 932                         }
 933                         return false;
 934
 935                 }
 936                 template<typename V> bool encode(size_t index, V& v) const
 937                 {
 938                         if(index != type) {return false;} return v(ref_nested());
 939
 940                 }
 941                 private:
 942                 size_t type {0};
 943
 944         };
 945
 946 };
 947 /*
 948 ABSInformationFDD ::= SEQUENCE {
 949         abs-pattern-info                                        BIT STRING (SIZE(40)),
 950         numberOfCellSpecificAntennaPorts        ENUMERATED {one, two, four, ...},
 951         measurement-subset                                      BIT STRING (SIZE(40)),
 952         iE-Extensions                                           ProtocolExtensionContainer { {ABSInformationFDD-ExtIEs} } OPTIONAL,
 953         ...
 954 }
 955 */
 956
 957 struct ABSInformationFDD : asn::sequence<4, 0, true, 1>
 958 {
 959         static constexpr const char* name() {return "ABSInformationFDD";}
 960         using parent_t = asn::sequence<4, 0, true, 1>;
 961         struct abs_pattern_info_t : asn::bstring<>
 962         {
 963                 using constraint_t = asn::constraints<false,asn::one<40>>;
 964                 static constexpr const char* name() {return "abs_pattern_info_t";}
 965                 using parent_t = asn::bstring<>;
 966
 967         };
 968
 969         abs_pattern_info_t& ref_abs_pattern_info() {return abs_pattern_info;}
 970         abs_pattern_info_t const& ref_abs_pattern_info() const {return abs_pattern_info;}
 971         struct numberOfCellSpecificAntennaPorts_t : asn::enumerated<3, 0, true>
 972         {
 973                 static constexpr const char* name() {return "numberOfCellSpecificAntennaPorts_t";}
 974                 using parent_t = asn::enumerated<3, 0, true>;
 975                 typedef enum {
 976                         one
 977                         ,two
 978                         ,four
 979                 } index_t;
 980
 981         };
 982
 983         numberOfCellSpecificAntennaPorts_t& ref_numberOfCellSpecificAntennaPorts() {return numberOfCellSpecificAntennaPorts;}
 984         numberOfCellSpecificAntennaPorts_t const& ref_numberOfCellSpecificAntennaPorts() const {return numberOfCellSpecificAntennaPorts;}
 985         struct measurement_subset_t : asn::bstring<>
 986         {
 987                 using constraint_t = asn::constraints<false,asn::one<40>>;
 988                 static constexpr const char* name() {return "measurement_subset_t";}
 989                 using parent_t = asn::bstring<>;
 990
 991         };
 992
 993         measurement_subset_t& ref_measurement_subset() {return measurement_subset;}
 994         measurement_subset_t const& ref_measurement_subset() const {return measurement_subset;}
 995         struct iE_Extensions_t : ProtocolExtensionContainer<ABSInformationFDD_ExtIEs>
 996         {
 997                 static constexpr const char* name() {return "iE_Extensions_t";}
 998                 using parent_t = ProtocolExtensionContainer<ABSInformationFDD_ExtIEs>;
 999                 static constexpr bool optional = true;
1000
1001         };
1002         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
1003         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
1004         template<typename V> void decode(V& v)
1005         {
1006                 v(abs_pattern_info);
1007                 v(numberOfCellSpecificAntennaPorts);
1008                 v(measurement_subset);
1009                 v(iE_Extensions);
1010
1011         };
1012         template<typename V> void encode(V& v) const
1013         {
1014                 v(abs_pattern_info);
1015                 v(numberOfCellSpecificAntennaPorts);
1016                 v(measurement_subset);
1017                 v(iE_Extensions);
1018
1019         };
1020         void clear()
1021         {
1022                 abs_pattern_info.clear();
1023                 numberOfCellSpecificAntennaPorts.clear();
1024                 measurement_subset.clear();
1025                 iE_Extensions.clear();
1026
1027         };
1028         private:
1029         abs_pattern_info_t      abs_pattern_info;
1030         numberOfCellSpecificAntennaPorts_t      numberOfCellSpecificAntennaPorts;
1031         measurement_subset_t    measurement_subset;
1032         iE_Extensions_t iE_Extensions;
1033
1034 };
1035 /*
1036 ABSInformationTDD-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
1037         ...
1038 }
1039 */
1040
1041 struct ABSInformationTDD_ExtIEs
1042 {
1043         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
1044         {
1045                 size_t get_index() const {return type;}
1046                 bool is_unknown() const { return type == 1; }
1047                 void clear() {type = 0;}
1048                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
1049                 template<typename V>  bool decode(V& v)
1050                 {
1051                         clear();
1052                         if(!v(ref_nested())) return false;
1053                         { type = 1; return true;}
1054                         return false;
1055
1056                 }
1057                 template<typename V> bool encode(V& v) const
1058                 {
1059                         return v(ref_nested());
1060
1061                 }
1062                 protected:
1063                 template<typename V>  bool decode(size_t index, V& v)
1064                 {
1065                         clear();
1066                         switch(index)
1067                         {
1068                         case 1: type = 1; return v(ref_nested());
1069                         ref_nested().clear();
1070                         }
1071                         return false;
1072
1073                 }
1074                 template<typename V> bool encode(size_t index, V& v) const
1075                 {
1076                         if(index != type) {return false;} return v(ref_nested());
1077
1078                 }
1079                 private:
1080                 size_t type {0};
1081
1082         };
1083         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
1084         {
1085                 size_t get_index() const {return type;}
1086                 bool is_unknown() const { return type == 1; }
1087                 void clear() {type = 0;}
1088                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
1089                 template<typename V>  bool decode(V& v)
1090                 {
1091                         clear();
1092                         if(!v(ref_nested())) return false;
1093                         { type = 1; return true;}
1094                         return false;
1095
1096                 }
1097                 template<typename V> bool encode(V& v) const
1098                 {
1099                         return v(ref_nested());
1100
1101                 }
1102                 protected:
1103                 template<typename V>  bool decode(size_t index, V& v)
1104                 {
1105                         clear();
1106                         switch(index)
1107                         {
1108                         case 1: type = 1; return v(ref_nested());
1109                         ref_nested().clear();
1110                         }
1111                         return false;
1112
1113                 }
1114                 template<typename V> bool encode(size_t index, V& v) const
1115                 {
1116                         if(index != type) {return false;} return v(ref_nested());
1117
1118                 }
1119                 private:
1120                 size_t type {0};
1121
1122         };
1123         struct Extension_t : asn::typefield<true>
1124         {
1125                 ~Extension_t()  {clear();}
1126                 size_t get_index() const {return type;}
1127                 bool is_unknown() const { return type == 1; }
1128                 void clear()
1129                 {
1130                         type = 0; ref_nested().clear();
1131                 }
1132                 template<typename V> static inline void enumerate(V& v)
1133                 {
1134
1135                 }
1136                 protected:
1137                 template<typename V> bool decode(size_t index, V& v)
1138                 {
1139                         clear();
1140                         switch(index)
1141                         {
1142                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
1143                         }
1144                         return false;
1145
1146                 }
1147                 template<typename V> bool encode(size_t index, V& v) const
1148                 {
1149                         if(index != type) return false;
1150                         return false;
1151
1152                 }
1153                 private:
1154                 size_t type {0};
1155
1156         };
1157         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
1158         {
1159                 size_t get_index() const {return type;}
1160                 bool is_unknown() const { return type == 1; }
1161                 void clear() {type = 0;}
1162                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
1163                 template<typename V>  bool decode(V& v)
1164                 {
1165                         clear();
1166                         if(!v(ref_nested())) return false;
1167                         { type = 1; return true;}
1168                         return false;
1169
1170                 }
1171                 template<typename V> bool encode(V& v) const
1172                 {
1173                         return v(ref_nested());
1174
1175                 }
1176                 protected:
1177                 template<typename V>  bool decode(size_t index, V& v)
1178                 {
1179                         clear();
1180                         switch(index)
1181                         {
1182                         case 1: type = 1; return v(ref_nested());
1183                         ref_nested().clear();
1184                         }
1185                         return false;
1186
1187                 }
1188                 template<typename V> bool encode(size_t index, V& v) const
1189                 {
1190                         if(index != type) {return false;} return v(ref_nested());
1191
1192                 }
1193                 private:
1194                 size_t type {0};
1195
1196         };
1197
1198 };
1199 /*
1200 ABSInformationTDD ::= SEQUENCE {
1201         abs-pattern-info                                        BIT STRING (SIZE(1..70, ...)),
1202         numberOfCellSpecificAntennaPorts        ENUMERATED {one, two, four, ...},
1203         measurement-subset                                      BIT STRING (SIZE(1..70, ...)),
1204         iE-Extensions                                           ProtocolExtensionContainer { {ABSInformationTDD-ExtIEs} } OPTIONAL,
1205         ...
1206 }
1207 */
1208
1209 struct ABSInformationTDD : asn::sequence<4, 0, true, 1>
1210 {
1211         static constexpr const char* name() {return "ABSInformationTDD";}
1212         using parent_t = asn::sequence<4, 0, true, 1>;
1213         struct abs_pattern_info_t : asn::bstring<>
1214         {
1215                 using constraint_t = asn::constraints<true,asn::span<1, 70>>;
1216                 static constexpr const char* name() {return "abs_pattern_info_t";}
1217                 using parent_t = asn::bstring<>;
1218
1219         };
1220
1221         abs_pattern_info_t& ref_abs_pattern_info() {return abs_pattern_info;}
1222         abs_pattern_info_t const& ref_abs_pattern_info() const {return abs_pattern_info;}
1223         struct numberOfCellSpecificAntennaPorts_t : asn::enumerated<3, 0, true>
1224         {
1225                 static constexpr const char* name() {return "numberOfCellSpecificAntennaPorts_t";}
1226                 using parent_t = asn::enumerated<3, 0, true>;
1227                 typedef enum {
1228                         one
1229                         ,two
1230                         ,four
1231                 } index_t;
1232
1233         };
1234
1235         numberOfCellSpecificAntennaPorts_t& ref_numberOfCellSpecificAntennaPorts() {return numberOfCellSpecificAntennaPorts;}
1236         numberOfCellSpecificAntennaPorts_t const& ref_numberOfCellSpecificAntennaPorts() const {return numberOfCellSpecificAntennaPorts;}
1237         struct measurement_subset_t : asn::bstring<>
1238         {
1239                 using constraint_t = asn::constraints<true,asn::span<1, 70>>;
1240                 static constexpr const char* name() {return "measurement_subset_t";}
1241                 using parent_t = asn::bstring<>;
1242
1243         };
1244
1245         measurement_subset_t& ref_measurement_subset() {return measurement_subset;}
1246         measurement_subset_t const& ref_measurement_subset() const {return measurement_subset;}
1247         struct iE_Extensions_t : ProtocolExtensionContainer<ABSInformationTDD_ExtIEs>
1248         {
1249                 static constexpr const char* name() {return "iE_Extensions_t";}
1250                 using parent_t = ProtocolExtensionContainer<ABSInformationTDD_ExtIEs>;
1251                 static constexpr bool optional = true;
1252
1253         };
1254         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
1255         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
1256         template<typename V> void decode(V& v)
1257         {
1258                 v(abs_pattern_info);
1259                 v(numberOfCellSpecificAntennaPorts);
1260                 v(measurement_subset);
1261                 v(iE_Extensions);
1262
1263         };
1264         template<typename V> void encode(V& v) const
1265         {
1266                 v(abs_pattern_info);
1267                 v(numberOfCellSpecificAntennaPorts);
1268                 v(measurement_subset);
1269                 v(iE_Extensions);
1270
1271         };
1272         void clear()
1273         {
1274                 abs_pattern_info.clear();
1275                 numberOfCellSpecificAntennaPorts.clear();
1276                 measurement_subset.clear();
1277                 iE_Extensions.clear();
1278
1279         };
1280         private:
1281         abs_pattern_info_t      abs_pattern_info;
1282         numberOfCellSpecificAntennaPorts_t      numberOfCellSpecificAntennaPorts;
1283         measurement_subset_t    measurement_subset;
1284         iE_Extensions_t iE_Extensions;
1285
1286 };
1287 /*
1288 ABSInformation ::= CHOICE {
1289         fdd                                     ABSInformationFDD,
1290         tdd                                     ABSInformationTDD,
1291         abs-inactive            NULL,
1292         ...
1293 }
1294 */
1295
1296 struct ABSInformation : asn::choice<3, 0, true>
1297 {
1298         static constexpr const char* name() {return "ABSInformation";}
1299         using parent_t = asn::choice<3, 0, true>;
1300         index_type get_index() const {return index;}
1301         bool is_unknown() const {return index == 4;}
1302         void set_unknown() { set_index(4);  }
1303         ~ABSInformation() {clear();}
1304         struct fdd_t : ABSInformationFDD
1305         {
1306                 static constexpr const char* name() {return "fdd_t";}
1307                 using parent_t = ABSInformationFDD;
1308
1309         };
1310         struct tdd_t : ABSInformationTDD
1311         {
1312                 static constexpr const char* name() {return "tdd_t";}
1313                 using parent_t = ABSInformationTDD;
1314
1315         };
1316         struct abs_inactive_t : asn::nulltype
1317         {
1318                 static constexpr const char* name() {return "abs_inactive_t";}
1319                 using parent_t = asn::nulltype;
1320
1321         };
1322         void clear()
1323         {
1324                 switch(get_index())
1325                 {
1326                 case 1: var.destroy<fdd_t>(); break;
1327                 case 2: var.destroy<tdd_t>(); break;
1328                 case 3: var.destroy<abs_inactive_t>(); break;
1329                 }
1330                 index = 0;
1331                 base::clear();
1332         }
1333         template<typename V> bool decode(size_t idx, V& v)
1334         {
1335                 clear();
1336                 switch(idx)
1337                 {
1338                 case 1: set_index(1); return v(var.build<fdd_t>());
1339                 case 2: set_index(2); return v(var.build<tdd_t>());
1340                 case 3: set_index(3); return v(var.build<abs_inactive_t>());
1341                 }
1342                 return false;
1343
1344         }
1345         template<typename V> bool encode(V& v) const
1346         {
1347                 switch(get_index())
1348                 {
1349                 case 1: return v(var.as<fdd_t>());
1350                 case 2: return v(var.as<tdd_t>());
1351                 case 3: return v(var.as<abs_inactive_t>());
1352                 }
1353                 return false;
1354         }
1355         template<typename V> static inline void enumerate(V& v)
1356         {
1357                 v.template operator()<fdd_t>(1);
1358                 v.template operator()<tdd_t>(2);
1359                 v.template operator()<abs_inactive_t>(3);
1360
1361         }
1362         fdd_t& select_fdd() { if(get_index() != 1) { clear(); set_index(1); return var.build<fdd_t>();} return var.as<fdd_t>();}
1363         fdd_t const* get_fdd() const { if(get_index() == 1) { return &var.as<fdd_t>();} return nullptr; }
1364         tdd_t& select_tdd() { if(get_index() != 2) { clear(); set_index(2); return var.build<tdd_t>();} return var.as<tdd_t>();}
1365         tdd_t const* get_tdd() const { if(get_index() == 2) { return &var.as<tdd_t>();} return nullptr; }
1366         abs_inactive_t& select_abs_inactive() { if(get_index() != 3) { clear(); set_index(3); return var.build<abs_inactive_t>();} return var.as<abs_inactive_t>();}
1367         abs_inactive_t const* get_abs_inactive() const { if(get_index() == 3) { return &var.as<abs_inactive_t>();} return nullptr; }
1368         private:
1369         void set_index(index_type i) {index = i; base::set();}
1370         union union_type
1371         {
1372                 char dummy1[sizeof(fdd_t)];
1373                 char dummy2[sizeof(tdd_t)];
1374                 char dummy3[sizeof(abs_inactive_t)];
1375
1376         };
1377         asn::variant<sizeof(union_type)>        var;
1378         index_type      index {0};
1379 };
1380 /*
1381 Key-eNodeB-Star ::= BIT STRING (SIZE(256))
1382 */
1383
1384 struct Key_eNodeB_Star : asn::bstring<>
1385 {
1386         using constraint_t = asn::constraints<false,asn::one<256>>;
1387         static constexpr const char* name() {return "Key-eNodeB-Star";}
1388         using parent_t = asn::bstring<>;
1389
1390 };
1391
1392 /*
1393 NextHopChainingCount ::= INTEGER (0..7)
1394 */
1395
1396 struct NextHopChainingCount : asn::integer<>
1397 {
1398         using constraint_t = asn::constraints<false,asn::span<0, 7>>;
1399         static constexpr const char* name() {return "NextHopChainingCount";}
1400         using parent_t = asn::integer<>;
1401
1402 };
1403
1404 /*
1405 AS-SecurityInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
1406         ...
1407 }
1408 */
1409
1410 struct AS_SecurityInformation_ExtIEs
1411 {
1412         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
1413         {
1414                 size_t get_index() const {return type;}
1415                 bool is_unknown() const { return type == 1; }
1416                 void clear() {type = 0;}
1417                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
1418                 template<typename V>  bool decode(V& v)
1419                 {
1420                         clear();
1421                         if(!v(ref_nested())) return false;
1422                         { type = 1; return true;}
1423                         return false;
1424
1425                 }
1426                 template<typename V> bool encode(V& v) const
1427                 {
1428                         return v(ref_nested());
1429
1430                 }
1431                 protected:
1432                 template<typename V>  bool decode(size_t index, V& v)
1433                 {
1434                         clear();
1435                         switch(index)
1436                         {
1437                         case 1: type = 1; return v(ref_nested());
1438                         ref_nested().clear();
1439                         }
1440                         return false;
1441
1442                 }
1443                 template<typename V> bool encode(size_t index, V& v) const
1444                 {
1445                         if(index != type) {return false;} return v(ref_nested());
1446
1447                 }
1448                 private:
1449                 size_t type {0};
1450
1451         };
1452         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
1453         {
1454                 size_t get_index() const {return type;}
1455                 bool is_unknown() const { return type == 1; }
1456                 void clear() {type = 0;}
1457                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
1458                 template<typename V>  bool decode(V& v)
1459                 {
1460                         clear();
1461                         if(!v(ref_nested())) return false;
1462                         { type = 1; return true;}
1463                         return false;
1464
1465                 }
1466                 template<typename V> bool encode(V& v) const
1467                 {
1468                         return v(ref_nested());
1469
1470                 }
1471                 protected:
1472                 template<typename V>  bool decode(size_t index, V& v)
1473                 {
1474                         clear();
1475                         switch(index)
1476                         {
1477                         case 1: type = 1; return v(ref_nested());
1478                         ref_nested().clear();
1479                         }
1480                         return false;
1481
1482                 }
1483                 template<typename V> bool encode(size_t index, V& v) const
1484                 {
1485                         if(index != type) {return false;} return v(ref_nested());
1486
1487                 }
1488                 private:
1489                 size_t type {0};
1490
1491         };
1492         struct Extension_t : asn::typefield<true>
1493         {
1494                 ~Extension_t()  {clear();}
1495                 size_t get_index() const {return type;}
1496                 bool is_unknown() const { return type == 1; }
1497                 void clear()
1498                 {
1499                         type = 0; ref_nested().clear();
1500                 }
1501                 template<typename V> static inline void enumerate(V& v)
1502                 {
1503
1504                 }
1505                 protected:
1506                 template<typename V> bool decode(size_t index, V& v)
1507                 {
1508                         clear();
1509                         switch(index)
1510                         {
1511                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
1512                         }
1513                         return false;
1514
1515                 }
1516                 template<typename V> bool encode(size_t index, V& v) const
1517                 {
1518                         if(index != type) return false;
1519                         return false;
1520
1521                 }
1522                 private:
1523                 size_t type {0};
1524
1525         };
1526         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
1527         {
1528                 size_t get_index() const {return type;}
1529                 bool is_unknown() const { return type == 1; }
1530                 void clear() {type = 0;}
1531                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
1532                 template<typename V>  bool decode(V& v)
1533                 {
1534                         clear();
1535                         if(!v(ref_nested())) return false;
1536                         { type = 1; return true;}
1537                         return false;
1538
1539                 }
1540                 template<typename V> bool encode(V& v) const
1541                 {
1542                         return v(ref_nested());
1543
1544                 }
1545                 protected:
1546                 template<typename V>  bool decode(size_t index, V& v)
1547                 {
1548                         clear();
1549                         switch(index)
1550                         {
1551                         case 1: type = 1; return v(ref_nested());
1552                         ref_nested().clear();
1553                         }
1554                         return false;
1555
1556                 }
1557                 template<typename V> bool encode(size_t index, V& v) const
1558                 {
1559                         if(index != type) {return false;} return v(ref_nested());
1560
1561                 }
1562                 private:
1563                 size_t type {0};
1564
1565         };
1566
1567 };
1568 /*
1569 AS-SecurityInformation ::= SEQUENCE {
1570         key-eNodeB-star         Key-eNodeB-Star,
1571         nextHopChainingCount                    NextHopChainingCount,
1572         iE-Extensions                                           ProtocolExtensionContainer { {AS-SecurityInformation-ExtIEs} } OPTIONAL,
1573         ...
1574 }
1575 */
1576
1577 struct AS_SecurityInformation : asn::sequence<3, 0, true, 1>
1578 {
1579         static constexpr const char* name() {return "AS-SecurityInformation";}
1580         using parent_t = asn::sequence<3, 0, true, 1>;
1581         struct key_eNodeB_star_t : Key_eNodeB_Star
1582         {
1583                 static constexpr const char* name() {return "key_eNodeB_star_t";}
1584                 using parent_t = Key_eNodeB_Star;
1585
1586         };
1587         key_eNodeB_star_t& ref_key_eNodeB_star() {return key_eNodeB_star;}
1588         key_eNodeB_star_t const& ref_key_eNodeB_star() const {return key_eNodeB_star;}
1589         struct nextHopChainingCount_t : NextHopChainingCount
1590         {
1591                 static constexpr const char* name() {return "nextHopChainingCount_t";}
1592                 using parent_t = NextHopChainingCount;
1593
1594         };
1595         nextHopChainingCount_t& ref_nextHopChainingCount() {return nextHopChainingCount;}
1596         nextHopChainingCount_t const& ref_nextHopChainingCount() const {return nextHopChainingCount;}
1597         struct iE_Extensions_t : ProtocolExtensionContainer<AS_SecurityInformation_ExtIEs>
1598         {
1599                 static constexpr const char* name() {return "iE_Extensions_t";}
1600                 using parent_t = ProtocolExtensionContainer<AS_SecurityInformation_ExtIEs>;
1601                 static constexpr bool optional = true;
1602
1603         };
1604         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
1605         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
1606         template<typename V> void decode(V& v)
1607         {
1608                 v(key_eNodeB_star);
1609                 v(nextHopChainingCount);
1610                 v(iE_Extensions);
1611
1612         };
1613         template<typename V> void encode(V& v) const
1614         {
1615                 v(key_eNodeB_star);
1616                 v(nextHopChainingCount);
1617                 v(iE_Extensions);
1618
1619         };
1620         void clear()
1621         {
1622                 key_eNodeB_star.clear();
1623                 nextHopChainingCount.clear();
1624                 iE_Extensions.clear();
1625
1626         };
1627         private:
1628         key_eNodeB_star_t       key_eNodeB_star;
1629         nextHopChainingCount_t  nextHopChainingCount;
1630         iE_Extensions_t iE_Extensions;
1631
1632 };
1633 /*
1634 ActivationID ::= INTEGER (0..255)
1635 */
1636
1637 struct ActivationID : asn::integer<>
1638 {
1639         using constraint_t = asn::constraints<false,asn::span<0, 255>>;
1640         static constexpr const char* name() {return "ActivationID";}
1641         using parent_t = asn::integer<>;
1642
1643 };
1644
1645 /*
1646 AdditionalSpecialSubframePatterns ::= ENUMERATED {
1647         ssp0,
1648         ssp1,
1649         ssp2,
1650         ssp3,
1651         ssp4,
1652         ssp5,
1653         ssp6,
1654         ssp7,
1655         ssp8,
1656         ssp9,
1657         ...
1658 }
1659 */
1660
1661 struct AdditionalSpecialSubframePatterns : asn::enumerated<10, 0, true>
1662 {
1663         static constexpr const char* name() {return "AdditionalSpecialSubframePatterns";}
1664         using parent_t = asn::enumerated<10, 0, true>;
1665         typedef enum {
1666                 ssp0
1667                 ,ssp1
1668                 ,ssp2
1669                 ,ssp3
1670                 ,ssp4
1671                 ,ssp5
1672                 ,ssp6
1673                 ,ssp7
1674                 ,ssp8
1675                 ,ssp9
1676         } index_t;
1677
1678 };
1679
1680 /*
1681 CyclicPrefixDL ::= ENUMERATED {
1682         normal,
1683         extended,
1684         ...
1685 }
1686 */
1687
1688 struct CyclicPrefixDL : asn::enumerated<2, 0, true>
1689 {
1690         static constexpr const char* name() {return "CyclicPrefixDL";}
1691         using parent_t = asn::enumerated<2, 0, true>;
1692         typedef enum {
1693                 normal
1694                 ,extended
1695         } index_t;
1696
1697 };
1698
1699 /*
1700 CyclicPrefixUL ::= ENUMERATED {
1701         normal,
1702         extended,
1703         ...
1704 }
1705 */
1706
1707 struct CyclicPrefixUL : asn::enumerated<2, 0, true>
1708 {
1709         static constexpr const char* name() {return "CyclicPrefixUL";}
1710         using parent_t = asn::enumerated<2, 0, true>;
1711         typedef enum {
1712                 normal
1713                 ,extended
1714         } index_t;
1715
1716 };
1717
1718 /*
1719 AdditionalSpecialSubframe-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
1720         ...
1721 }
1722 */
1723
1724 struct AdditionalSpecialSubframe_Info_ExtIEs
1725 {
1726         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
1727         {
1728                 size_t get_index() const {return type;}
1729                 bool is_unknown() const { return type == 1; }
1730                 void clear() {type = 0;}
1731                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
1732                 template<typename V>  bool decode(V& v)
1733                 {
1734                         clear();
1735                         if(!v(ref_nested())) return false;
1736                         { type = 1; return true;}
1737                         return false;
1738
1739                 }
1740                 template<typename V> bool encode(V& v) const
1741                 {
1742                         return v(ref_nested());
1743
1744                 }
1745                 protected:
1746                 template<typename V>  bool decode(size_t index, V& v)
1747                 {
1748                         clear();
1749                         switch(index)
1750                         {
1751                         case 1: type = 1; return v(ref_nested());
1752                         ref_nested().clear();
1753                         }
1754                         return false;
1755
1756                 }
1757                 template<typename V> bool encode(size_t index, V& v) const
1758                 {
1759                         if(index != type) {return false;} return v(ref_nested());
1760
1761                 }
1762                 private:
1763                 size_t type {0};
1764
1765         };
1766         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
1767         {
1768                 size_t get_index() const {return type;}
1769                 bool is_unknown() const { return type == 1; }
1770                 void clear() {type = 0;}
1771                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
1772                 template<typename V>  bool decode(V& v)
1773                 {
1774                         clear();
1775                         if(!v(ref_nested())) return false;
1776                         { type = 1; return true;}
1777                         return false;
1778
1779                 }
1780                 template<typename V> bool encode(V& v) const
1781                 {
1782                         return v(ref_nested());
1783
1784                 }
1785                 protected:
1786                 template<typename V>  bool decode(size_t index, V& v)
1787                 {
1788                         clear();
1789                         switch(index)
1790                         {
1791                         case 1: type = 1; return v(ref_nested());
1792                         ref_nested().clear();
1793                         }
1794                         return false;
1795
1796                 }
1797                 template<typename V> bool encode(size_t index, V& v) const
1798                 {
1799                         if(index != type) {return false;} return v(ref_nested());
1800
1801                 }
1802                 private:
1803                 size_t type {0};
1804
1805         };
1806         struct Extension_t : asn::typefield<true>
1807         {
1808                 ~Extension_t()  {clear();}
1809                 size_t get_index() const {return type;}
1810                 bool is_unknown() const { return type == 1; }
1811                 void clear()
1812                 {
1813                         type = 0; ref_nested().clear();
1814                 }
1815                 template<typename V> static inline void enumerate(V& v)
1816                 {
1817
1818                 }
1819                 protected:
1820                 template<typename V> bool decode(size_t index, V& v)
1821                 {
1822                         clear();
1823                         switch(index)
1824                         {
1825                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
1826                         }
1827                         return false;
1828
1829                 }
1830                 template<typename V> bool encode(size_t index, V& v) const
1831                 {
1832                         if(index != type) return false;
1833                         return false;
1834
1835                 }
1836                 private:
1837                 size_t type {0};
1838
1839         };
1840         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
1841         {
1842                 size_t get_index() const {return type;}
1843                 bool is_unknown() const { return type == 1; }
1844                 void clear() {type = 0;}
1845                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
1846                 template<typename V>  bool decode(V& v)
1847                 {
1848                         clear();
1849                         if(!v(ref_nested())) return false;
1850                         { type = 1; return true;}
1851                         return false;
1852
1853                 }
1854                 template<typename V> bool encode(V& v) const
1855                 {
1856                         return v(ref_nested());
1857
1858                 }
1859                 protected:
1860                 template<typename V>  bool decode(size_t index, V& v)
1861                 {
1862                         clear();
1863                         switch(index)
1864                         {
1865                         case 1: type = 1; return v(ref_nested());
1866                         ref_nested().clear();
1867                         }
1868                         return false;
1869
1870                 }
1871                 template<typename V> bool encode(size_t index, V& v) const
1872                 {
1873                         if(index != type) {return false;} return v(ref_nested());
1874
1875                 }
1876                 private:
1877                 size_t type {0};
1878
1879         };
1880
1881 };
1882 /*
1883 AdditionalSpecialSubframe-Info ::=              SEQUENCE {
1884         additionalspecialSubframePatterns               AdditionalSpecialSubframePatterns,
1885         cyclicPrefixDL                                                  CyclicPrefixDL,
1886         cyclicPrefixUL                                                  CyclicPrefixUL,
1887         iE-Extensions                                                   ProtocolExtensionContainer { {AdditionalSpecialSubframe-Info-ExtIEs} } OPTIONAL,
1888         ...
1889 }
1890 */
1891
1892 struct AdditionalSpecialSubframe_Info : asn::sequence<4, 0, true, 1>
1893 {
1894         static constexpr const char* name() {return "AdditionalSpecialSubframe-Info";}
1895         using parent_t = asn::sequence<4, 0, true, 1>;
1896         struct additionalspecialSubframePatterns_t : AdditionalSpecialSubframePatterns
1897         {
1898                 static constexpr const char* name() {return "additionalspecialSubframePatterns_t";}
1899                 using parent_t = AdditionalSpecialSubframePatterns;
1900
1901         };
1902         additionalspecialSubframePatterns_t& ref_additionalspecialSubframePatterns() {return additionalspecialSubframePatterns;}
1903         additionalspecialSubframePatterns_t const& ref_additionalspecialSubframePatterns() const {return additionalspecialSubframePatterns;}
1904         struct cyclicPrefixDL_t : CyclicPrefixDL
1905         {
1906                 static constexpr const char* name() {return "cyclicPrefixDL_t";}
1907                 using parent_t = CyclicPrefixDL;
1908
1909         };
1910         cyclicPrefixDL_t& ref_cyclicPrefixDL() {return cyclicPrefixDL;}
1911         cyclicPrefixDL_t const& ref_cyclicPrefixDL() const {return cyclicPrefixDL;}
1912         struct cyclicPrefixUL_t : CyclicPrefixUL
1913         {
1914                 static constexpr const char* name() {return "cyclicPrefixUL_t";}
1915                 using parent_t = CyclicPrefixUL;
1916
1917         };
1918         cyclicPrefixUL_t& ref_cyclicPrefixUL() {return cyclicPrefixUL;}
1919         cyclicPrefixUL_t const& ref_cyclicPrefixUL() const {return cyclicPrefixUL;}
1920         struct iE_Extensions_t : ProtocolExtensionContainer<AdditionalSpecialSubframe_Info_ExtIEs>
1921         {
1922                 static constexpr const char* name() {return "iE_Extensions_t";}
1923                 using parent_t = ProtocolExtensionContainer<AdditionalSpecialSubframe_Info_ExtIEs>;
1924                 static constexpr bool optional = true;
1925
1926         };
1927         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
1928         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
1929         template<typename V> void decode(V& v)
1930         {
1931                 v(additionalspecialSubframePatterns);
1932                 v(cyclicPrefixDL);
1933                 v(cyclicPrefixUL);
1934                 v(iE_Extensions);
1935
1936         };
1937         template<typename V> void encode(V& v) const
1938         {
1939                 v(additionalspecialSubframePatterns);
1940                 v(cyclicPrefixDL);
1941                 v(cyclicPrefixUL);
1942                 v(iE_Extensions);
1943
1944         };
1945         void clear()
1946         {
1947                 additionalspecialSubframePatterns.clear();
1948                 cyclicPrefixDL.clear();
1949                 cyclicPrefixUL.clear();
1950                 iE_Extensions.clear();
1951
1952         };
1953         private:
1954         additionalspecialSubframePatterns_t     additionalspecialSubframePatterns;
1955         cyclicPrefixDL_t        cyclicPrefixDL;
1956         cyclicPrefixUL_t        cyclicPrefixUL;
1957         iE_Extensions_t iE_Extensions;
1958
1959 };
1960 /*
1961 AdditionalSpecialSubframePatternsExtension ::= ENUMERATED {
1962         ssp10,
1963         ...
1964 }
1965 */
1966
1967 struct AdditionalSpecialSubframePatternsExtension : asn::enumerated<1, 0, true>
1968 {
1969         static constexpr const char* name() {return "AdditionalSpecialSubframePatternsExtension";}
1970         using parent_t = asn::enumerated<1, 0, true>;
1971         typedef enum {
1972                 ssp10
1973         } index_t;
1974
1975 };
1976
1977 /*
1978 AdditionalSpecialSubframeExtension-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
1979         ...
1980 }
1981 */
1982
1983 struct AdditionalSpecialSubframeExtension_Info_ExtIEs
1984 {
1985         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
1986         {
1987                 size_t get_index() const {return type;}
1988                 bool is_unknown() const { return type == 1; }
1989                 void clear() {type = 0;}
1990                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
1991                 template<typename V>  bool decode(V& v)
1992                 {
1993                         clear();
1994                         if(!v(ref_nested())) return false;
1995                         { type = 1; return true;}
1996                         return false;
1997
1998                 }
1999                 template<typename V> bool encode(V& v) const
2000                 {
2001                         return v(ref_nested());
2002
2003                 }
2004                 protected:
2005                 template<typename V>  bool decode(size_t index, V& v)
2006                 {
2007                         clear();
2008                         switch(index)
2009                         {
2010                         case 1: type = 1; return v(ref_nested());
2011                         ref_nested().clear();
2012                         }
2013                         return false;
2014
2015                 }
2016                 template<typename V> bool encode(size_t index, V& v) const
2017                 {
2018                         if(index != type) {return false;} return v(ref_nested());
2019
2020                 }
2021                 private:
2022                 size_t type {0};
2023
2024         };
2025         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
2026         {
2027                 size_t get_index() const {return type;}
2028                 bool is_unknown() const { return type == 1; }
2029                 void clear() {type = 0;}
2030                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
2031                 template<typename V>  bool decode(V& v)
2032                 {
2033                         clear();
2034                         if(!v(ref_nested())) return false;
2035                         { type = 1; return true;}
2036                         return false;
2037
2038                 }
2039                 template<typename V> bool encode(V& v) const
2040                 {
2041                         return v(ref_nested());
2042
2043                 }
2044                 protected:
2045                 template<typename V>  bool decode(size_t index, V& v)
2046                 {
2047                         clear();
2048                         switch(index)
2049                         {
2050                         case 1: type = 1; return v(ref_nested());
2051                         ref_nested().clear();
2052                         }
2053                         return false;
2054
2055                 }
2056                 template<typename V> bool encode(size_t index, V& v) const
2057                 {
2058                         if(index != type) {return false;} return v(ref_nested());
2059
2060                 }
2061                 private:
2062                 size_t type {0};
2063
2064         };
2065         struct Extension_t : asn::typefield<true>
2066         {
2067                 ~Extension_t()  {clear();}
2068                 size_t get_index() const {return type;}
2069                 bool is_unknown() const { return type == 1; }
2070                 void clear()
2071                 {
2072                         type = 0; ref_nested().clear();
2073                 }
2074                 template<typename V> static inline void enumerate(V& v)
2075                 {
2076
2077                 }
2078                 protected:
2079                 template<typename V> bool decode(size_t index, V& v)
2080                 {
2081                         clear();
2082                         switch(index)
2083                         {
2084                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
2085                         }
2086                         return false;
2087
2088                 }
2089                 template<typename V> bool encode(size_t index, V& v) const
2090                 {
2091                         if(index != type) return false;
2092                         return false;
2093
2094                 }
2095                 private:
2096                 size_t type {0};
2097
2098         };
2099         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
2100         {
2101                 size_t get_index() const {return type;}
2102                 bool is_unknown() const { return type == 1; }
2103                 void clear() {type = 0;}
2104                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
2105                 template<typename V>  bool decode(V& v)
2106                 {
2107                         clear();
2108                         if(!v(ref_nested())) return false;
2109                         { type = 1; return true;}
2110                         return false;
2111
2112                 }
2113                 template<typename V> bool encode(V& v) const
2114                 {
2115                         return v(ref_nested());
2116
2117                 }
2118                 protected:
2119                 template<typename V>  bool decode(size_t index, V& v)
2120                 {
2121                         clear();
2122                         switch(index)
2123                         {
2124                         case 1: type = 1; return v(ref_nested());
2125                         ref_nested().clear();
2126                         }
2127                         return false;
2128
2129                 }
2130                 template<typename V> bool encode(size_t index, V& v) const
2131                 {
2132                         if(index != type) {return false;} return v(ref_nested());
2133
2134                 }
2135                 private:
2136                 size_t type {0};
2137
2138         };
2139
2140 };
2141 /*
2142 AdditionalSpecialSubframeExtension-Info ::=             SEQUENCE {
2143         additionalspecialSubframePatternsExtension      AdditionalSpecialSubframePatternsExtension,
2144         cyclicPrefixDL                                                          CyclicPrefixDL,
2145         cyclicPrefixUL                                                          CyclicPrefixUL,
2146         iE-Extensions                                                           ProtocolExtensionContainer { {AdditionalSpecialSubframeExtension-Info-ExtIEs} } OPTIONAL,
2147         ...
2148 }
2149 */
2150
2151 struct AdditionalSpecialSubframeExtension_Info : asn::sequence<4, 0, true, 1>
2152 {
2153         static constexpr const char* name() {return "AdditionalSpecialSubframeExtension-Info";}
2154         using parent_t = asn::sequence<4, 0, true, 1>;
2155         struct additionalspecialSubframePatternsExtension_t : AdditionalSpecialSubframePatternsExtension
2156         {
2157                 static constexpr const char* name() {return "additionalspecialSubframePatternsExtension_t";}
2158                 using parent_t = AdditionalSpecialSubframePatternsExtension;
2159
2160         };
2161         additionalspecialSubframePatternsExtension_t& ref_additionalspecialSubframePatternsExtension() {return additionalspecialSubframePatternsExtension;}
2162         additionalspecialSubframePatternsExtension_t const& ref_additionalspecialSubframePatternsExtension() const {return additionalspecialSubframePatternsExtension;}
2163         struct cyclicPrefixDL_t : CyclicPrefixDL
2164         {
2165                 static constexpr const char* name() {return "cyclicPrefixDL_t";}
2166                 using parent_t = CyclicPrefixDL;
2167
2168         };
2169         cyclicPrefixDL_t& ref_cyclicPrefixDL() {return cyclicPrefixDL;}
2170         cyclicPrefixDL_t const& ref_cyclicPrefixDL() const {return cyclicPrefixDL;}
2171         struct cyclicPrefixUL_t : CyclicPrefixUL
2172         {
2173                 static constexpr const char* name() {return "cyclicPrefixUL_t";}
2174                 using parent_t = CyclicPrefixUL;
2175
2176         };
2177         cyclicPrefixUL_t& ref_cyclicPrefixUL() {return cyclicPrefixUL;}
2178         cyclicPrefixUL_t const& ref_cyclicPrefixUL() const {return cyclicPrefixUL;}
2179         struct iE_Extensions_t : ProtocolExtensionContainer<AdditionalSpecialSubframeExtension_Info_ExtIEs>
2180         {
2181                 static constexpr const char* name() {return "iE_Extensions_t";}
2182                 using parent_t = ProtocolExtensionContainer<AdditionalSpecialSubframeExtension_Info_ExtIEs>;
2183                 static constexpr bool optional = true;
2184
2185         };
2186         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
2187         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
2188         template<typename V> void decode(V& v)
2189         {
2190                 v(additionalspecialSubframePatternsExtension);
2191                 v(cyclicPrefixDL);
2192                 v(cyclicPrefixUL);
2193                 v(iE_Extensions);
2194
2195         };
2196         template<typename V> void encode(V& v) const
2197         {
2198                 v(additionalspecialSubframePatternsExtension);
2199                 v(cyclicPrefixDL);
2200                 v(cyclicPrefixUL);
2201                 v(iE_Extensions);
2202
2203         };
2204         void clear()
2205         {
2206                 additionalspecialSubframePatternsExtension.clear();
2207                 cyclicPrefixDL.clear();
2208                 cyclicPrefixUL.clear();
2209                 iE_Extensions.clear();
2210
2211         };
2212         private:
2213         additionalspecialSubframePatternsExtension_t    additionalspecialSubframePatternsExtension;
2214         cyclicPrefixDL_t        cyclicPrefixDL;
2215         cyclicPrefixUL_t        cyclicPrefixUL;
2216         iE_Extensions_t iE_Extensions;
2217
2218 };
2219 /*
2220 AerialUEsubscriptionInformation ::= ENUMERATED {
2221         allowed,
2222         not-allowed,
2223         ...
2224 }
2225 */
2226
2227 struct AerialUEsubscriptionInformation : asn::enumerated<2, 0, true>
2228 {
2229         static constexpr const char* name() {return "AerialUEsubscriptionInformation";}
2230         using parent_t = asn::enumerated<2, 0, true>;
2231         typedef enum {
2232                 allowed
2233                 ,not_allowed
2234         } index_t;
2235
2236 };
2237
2238 /*
2239 PriorityLevel                           ::= INTEGER { spare (0), highest (1), lowest (14), no-priority (15) } (0..15)
2240 */
2241
2242 struct PriorityLevel : asn::integer<>
2243 {
2244         using constraint_t = asn::constraints<false,asn::span<0, 15>>;
2245         static constexpr const char* name() {return "PriorityLevel";}
2246         using parent_t = asn::integer<>;
2247         enum {spare = 0, highest = 1, lowest = 14, no_priority = 15};
2248
2249 };
2250
2251 /*
2252 Pre-emptionCapability ::= ENUMERATED {
2253         shall-not-trigger-pre-emption,
2254         may-trigger-pre-emption
2255 }
2256 */
2257
2258 struct Pre_emptionCapability : asn::enumerated<2, 0, false>
2259 {
2260         static constexpr const char* name() {return "Pre-emptionCapability";}
2261         using parent_t = asn::enumerated<2, 0, false>;
2262         typedef enum {
2263                 shall_not_trigger_pre_emption
2264                 ,may_trigger_pre_emption
2265         } index_t;
2266
2267 };
2268
2269 /*
2270 Pre-emptionVulnerability ::= ENUMERATED {
2271         not-pre-emptable,
2272         pre-emptable
2273 }
2274 */
2275
2276 struct Pre_emptionVulnerability : asn::enumerated<2, 0, false>
2277 {
2278         static constexpr const char* name() {return "Pre-emptionVulnerability";}
2279         using parent_t = asn::enumerated<2, 0, false>;
2280         typedef enum {
2281                 not_pre_emptable
2282                 ,pre_emptable
2283         } index_t;
2284
2285 };
2286
2287 /*
2288 AllocationAndRetentionPriority-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
2289         ...
2290 }
2291 */
2292
2293 struct AllocationAndRetentionPriority_ExtIEs
2294 {
2295         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
2296         {
2297                 size_t get_index() const {return type;}
2298                 bool is_unknown() const { return type == 1; }
2299                 void clear() {type = 0;}
2300                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
2301                 template<typename V>  bool decode(V& v)
2302                 {
2303                         clear();
2304                         if(!v(ref_nested())) return false;
2305                         { type = 1; return true;}
2306                         return false;
2307
2308                 }
2309                 template<typename V> bool encode(V& v) const
2310                 {
2311                         return v(ref_nested());
2312
2313                 }
2314                 protected:
2315                 template<typename V>  bool decode(size_t index, V& v)
2316                 {
2317                         clear();
2318                         switch(index)
2319                         {
2320                         case 1: type = 1; return v(ref_nested());
2321                         ref_nested().clear();
2322                         }
2323                         return false;
2324
2325                 }
2326                 template<typename V> bool encode(size_t index, V& v) const
2327                 {
2328                         if(index != type) {return false;} return v(ref_nested());
2329
2330                 }
2331                 private:
2332                 size_t type {0};
2333
2334         };
2335         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
2336         {
2337                 size_t get_index() const {return type;}
2338                 bool is_unknown() const { return type == 1; }
2339                 void clear() {type = 0;}
2340                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
2341                 template<typename V>  bool decode(V& v)
2342                 {
2343                         clear();
2344                         if(!v(ref_nested())) return false;
2345                         { type = 1; return true;}
2346                         return false;
2347
2348                 }
2349                 template<typename V> bool encode(V& v) const
2350                 {
2351                         return v(ref_nested());
2352
2353                 }
2354                 protected:
2355                 template<typename V>  bool decode(size_t index, V& v)
2356                 {
2357                         clear();
2358                         switch(index)
2359                         {
2360                         case 1: type = 1; return v(ref_nested());
2361                         ref_nested().clear();
2362                         }
2363                         return false;
2364
2365                 }
2366                 template<typename V> bool encode(size_t index, V& v) const
2367                 {
2368                         if(index != type) {return false;} return v(ref_nested());
2369
2370                 }
2371                 private:
2372                 size_t type {0};
2373
2374         };
2375         struct Extension_t : asn::typefield<true>
2376         {
2377                 ~Extension_t()  {clear();}
2378                 size_t get_index() const {return type;}
2379                 bool is_unknown() const { return type == 1; }
2380                 void clear()
2381                 {
2382                         type = 0; ref_nested().clear();
2383                 }
2384                 template<typename V> static inline void enumerate(V& v)
2385                 {
2386
2387                 }
2388                 protected:
2389                 template<typename V> bool decode(size_t index, V& v)
2390                 {
2391                         clear();
2392                         switch(index)
2393                         {
2394                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
2395                         }
2396                         return false;
2397
2398                 }
2399                 template<typename V> bool encode(size_t index, V& v) const
2400                 {
2401                         if(index != type) return false;
2402                         return false;
2403
2404                 }
2405                 private:
2406                 size_t type {0};
2407
2408         };
2409         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
2410         {
2411                 size_t get_index() const {return type;}
2412                 bool is_unknown() const { return type == 1; }
2413                 void clear() {type = 0;}
2414                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
2415                 template<typename V>  bool decode(V& v)
2416                 {
2417                         clear();
2418                         if(!v(ref_nested())) return false;
2419                         { type = 1; return true;}
2420                         return false;
2421
2422                 }
2423                 template<typename V> bool encode(V& v) const
2424                 {
2425                         return v(ref_nested());
2426
2427                 }
2428                 protected:
2429                 template<typename V>  bool decode(size_t index, V& v)
2430                 {
2431                         clear();
2432                         switch(index)
2433                         {
2434                         case 1: type = 1; return v(ref_nested());
2435                         ref_nested().clear();
2436                         }
2437                         return false;
2438
2439                 }
2440                 template<typename V> bool encode(size_t index, V& v) const
2441                 {
2442                         if(index != type) {return false;} return v(ref_nested());
2443
2444                 }
2445                 private:
2446                 size_t type {0};
2447
2448         };
2449
2450 };
2451 /*
2452 AllocationAndRetentionPriority ::= SEQUENCE {
2453         priorityLevel                           PriorityLevel,
2454         pre-emptionCapability           Pre-emptionCapability,
2455         pre-emptionVulnerability        Pre-emptionVulnerability,
2456         iE-Extensions                           ProtocolExtensionContainer { {AllocationAndRetentionPriority-ExtIEs} } OPTIONAL,
2457         ...
2458 }
2459 */
2460
2461 struct AllocationAndRetentionPriority : asn::sequence<4, 0, true, 1>
2462 {
2463         static constexpr const char* name() {return "AllocationAndRetentionPriority";}
2464         using parent_t = asn::sequence<4, 0, true, 1>;
2465         struct priorityLevel_t : PriorityLevel
2466         {
2467                 static constexpr const char* name() {return "priorityLevel_t";}
2468                 using parent_t = PriorityLevel;
2469
2470         };
2471         priorityLevel_t& ref_priorityLevel() {return priorityLevel;}
2472         priorityLevel_t const& ref_priorityLevel() const {return priorityLevel;}
2473         struct pre_emptionCapability_t : Pre_emptionCapability
2474         {
2475                 static constexpr const char* name() {return "pre_emptionCapability_t";}
2476                 using parent_t = Pre_emptionCapability;
2477
2478         };
2479         pre_emptionCapability_t& ref_pre_emptionCapability() {return pre_emptionCapability;}
2480         pre_emptionCapability_t const& ref_pre_emptionCapability() const {return pre_emptionCapability;}
2481         struct pre_emptionVulnerability_t : Pre_emptionVulnerability
2482         {
2483                 static constexpr const char* name() {return "pre_emptionVulnerability_t";}
2484                 using parent_t = Pre_emptionVulnerability;
2485
2486         };
2487         pre_emptionVulnerability_t& ref_pre_emptionVulnerability() {return pre_emptionVulnerability;}
2488         pre_emptionVulnerability_t const& ref_pre_emptionVulnerability() const {return pre_emptionVulnerability;}
2489         struct iE_Extensions_t : ProtocolExtensionContainer<AllocationAndRetentionPriority_ExtIEs>
2490         {
2491                 static constexpr const char* name() {return "iE_Extensions_t";}
2492                 using parent_t = ProtocolExtensionContainer<AllocationAndRetentionPriority_ExtIEs>;
2493                 static constexpr bool optional = true;
2494
2495         };
2496         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
2497         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
2498         template<typename V> void decode(V& v)
2499         {
2500                 v(priorityLevel);
2501                 v(pre_emptionCapability);
2502                 v(pre_emptionVulnerability);
2503                 v(iE_Extensions);
2504
2505         };
2506         template<typename V> void encode(V& v) const
2507         {
2508                 v(priorityLevel);
2509                 v(pre_emptionCapability);
2510                 v(pre_emptionVulnerability);
2511                 v(iE_Extensions);
2512
2513         };
2514         void clear()
2515         {
2516                 priorityLevel.clear();
2517                 pre_emptionCapability.clear();
2518                 pre_emptionVulnerability.clear();
2519                 iE_Extensions.clear();
2520
2521         };
2522         private:
2523         priorityLevel_t priorityLevel;
2524         pre_emptionCapability_t pre_emptionCapability;
2525         pre_emptionVulnerability_t      pre_emptionVulnerability;
2526         iE_Extensions_t iE_Extensions;
2527
2528 };
2529 /*
2530 PLMN-Identity ::= OCTET STRING (SIZE(3))
2531 */
2532
2533 struct PLMN_Identity : asn::ostring<>
2534 {
2535         using constraint_t = asn::constraints<false,asn::one<3>>;
2536         static constexpr const char* name() {return "PLMN-Identity";}
2537         using parent_t = asn::ostring<>;
2538
2539 };
2540
2541 /*
2542 EUTRANCellIdentifier ::= BIT STRING (SIZE (28))
2543 */
2544
2545 struct EUTRANCellIdentifier : asn::bstring<>
2546 {
2547         using constraint_t = asn::constraints<false,asn::one<28>>;
2548         static constexpr const char* name() {return "EUTRANCellIdentifier";}
2549         using parent_t = asn::bstring<>;
2550
2551 };
2552
2553 /*
2554 ECGI-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
2555         ...
2556 }
2557 */
2558
2559 struct ECGI_ExtIEs
2560 {
2561         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
2562         {
2563                 size_t get_index() const {return type;}
2564                 bool is_unknown() const { return type == 1; }
2565                 void clear() {type = 0;}
2566                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
2567                 template<typename V>  bool decode(V& v)
2568                 {
2569                         clear();
2570                         if(!v(ref_nested())) return false;
2571                         { type = 1; return true;}
2572                         return false;
2573
2574                 }
2575                 template<typename V> bool encode(V& v) const
2576                 {
2577                         return v(ref_nested());
2578
2579                 }
2580                 protected:
2581                 template<typename V>  bool decode(size_t index, V& v)
2582                 {
2583                         clear();
2584                         switch(index)
2585                         {
2586                         case 1: type = 1; return v(ref_nested());
2587                         ref_nested().clear();
2588                         }
2589                         return false;
2590
2591                 }
2592                 template<typename V> bool encode(size_t index, V& v) const
2593                 {
2594                         if(index != type) {return false;} return v(ref_nested());
2595
2596                 }
2597                 private:
2598                 size_t type {0};
2599
2600         };
2601         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
2602         {
2603                 size_t get_index() const {return type;}
2604                 bool is_unknown() const { return type == 1; }
2605                 void clear() {type = 0;}
2606                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
2607                 template<typename V>  bool decode(V& v)
2608                 {
2609                         clear();
2610                         if(!v(ref_nested())) return false;
2611                         { type = 1; return true;}
2612                         return false;
2613
2614                 }
2615                 template<typename V> bool encode(V& v) const
2616                 {
2617                         return v(ref_nested());
2618
2619                 }
2620                 protected:
2621                 template<typename V>  bool decode(size_t index, V& v)
2622                 {
2623                         clear();
2624                         switch(index)
2625                         {
2626                         case 1: type = 1; return v(ref_nested());
2627                         ref_nested().clear();
2628                         }
2629                         return false;
2630
2631                 }
2632                 template<typename V> bool encode(size_t index, V& v) const
2633                 {
2634                         if(index != type) {return false;} return v(ref_nested());
2635
2636                 }
2637                 private:
2638                 size_t type {0};
2639
2640         };
2641         struct Extension_t : asn::typefield<true>
2642         {
2643                 ~Extension_t()  {clear();}
2644                 size_t get_index() const {return type;}
2645                 bool is_unknown() const { return type == 1; }
2646                 void clear()
2647                 {
2648                         type = 0; ref_nested().clear();
2649                 }
2650                 template<typename V> static inline void enumerate(V& v)
2651                 {
2652
2653                 }
2654                 protected:
2655                 template<typename V> bool decode(size_t index, V& v)
2656                 {
2657                         clear();
2658                         switch(index)
2659                         {
2660                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
2661                         }
2662                         return false;
2663
2664                 }
2665                 template<typename V> bool encode(size_t index, V& v) const
2666                 {
2667                         if(index != type) return false;
2668                         return false;
2669
2670                 }
2671                 private:
2672                 size_t type {0};
2673
2674         };
2675         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
2676         {
2677                 size_t get_index() const {return type;}
2678                 bool is_unknown() const { return type == 1; }
2679                 void clear() {type = 0;}
2680                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
2681                 template<typename V>  bool decode(V& v)
2682                 {
2683                         clear();
2684                         if(!v(ref_nested())) return false;
2685                         { type = 1; return true;}
2686                         return false;
2687
2688                 }
2689                 template<typename V> bool encode(V& v) const
2690                 {
2691                         return v(ref_nested());
2692
2693                 }
2694                 protected:
2695                 template<typename V>  bool decode(size_t index, V& v)
2696                 {
2697                         clear();
2698                         switch(index)
2699                         {
2700                         case 1: type = 1; return v(ref_nested());
2701                         ref_nested().clear();
2702                         }
2703                         return false;
2704
2705                 }
2706                 template<typename V> bool encode(size_t index, V& v) const
2707                 {
2708                         if(index != type) {return false;} return v(ref_nested());
2709
2710                 }
2711                 private:
2712                 size_t type {0};
2713
2714         };
2715
2716 };
2717 /*
2718 ECGI ::= SEQUENCE {
2719         pLMN-Identity                           PLMN-Identity,
2720         eUTRANcellIdentifier            EUTRANCellIdentifier,
2721         iE-Extensions                           ProtocolExtensionContainer { {ECGI-ExtIEs} } OPTIONAL,
2722         ...
2723 }
2724 */
2725
2726 struct ECGI : asn::sequence<3, 0, true, 1>
2727 {
2728         static constexpr const char* name() {return "ECGI";}
2729         using parent_t = asn::sequence<3, 0, true, 1>;
2730         struct pLMN_Identity_t : PLMN_Identity
2731         {
2732                 static constexpr const char* name() {return "pLMN_Identity_t";}
2733                 using parent_t = PLMN_Identity;
2734
2735         };
2736         pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
2737         pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
2738         struct eUTRANcellIdentifier_t : EUTRANCellIdentifier
2739         {
2740                 static constexpr const char* name() {return "eUTRANcellIdentifier_t";}
2741                 using parent_t = EUTRANCellIdentifier;
2742
2743         };
2744         eUTRANcellIdentifier_t& ref_eUTRANcellIdentifier() {return eUTRANcellIdentifier;}
2745         eUTRANcellIdentifier_t const& ref_eUTRANcellIdentifier() const {return eUTRANcellIdentifier;}
2746         struct iE_Extensions_t : ProtocolExtensionContainer<ECGI_ExtIEs>
2747         {
2748                 static constexpr const char* name() {return "iE_Extensions_t";}
2749                 using parent_t = ProtocolExtensionContainer<ECGI_ExtIEs>;
2750                 static constexpr bool optional = true;
2751
2752         };
2753         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
2754         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
2755         template<typename V> void decode(V& v)
2756         {
2757                 v(pLMN_Identity);
2758                 v(eUTRANcellIdentifier);
2759                 v(iE_Extensions);
2760
2761         };
2762         template<typename V> void encode(V& v) const
2763         {
2764                 v(pLMN_Identity);
2765                 v(eUTRANcellIdentifier);
2766                 v(iE_Extensions);
2767
2768         };
2769         void clear()
2770         {
2771                 pLMN_Identity.clear();
2772                 eUTRANcellIdentifier.clear();
2773                 iE_Extensions.clear();
2774
2775         };
2776         private:
2777         pLMN_Identity_t pLMN_Identity;
2778         eUTRANcellIdentifier_t  eUTRANcellIdentifier;
2779         iE_Extensions_t iE_Extensions;
2780
2781 };
2782 /*
2783 CellIdListforMDT ::= SEQUENCE (SIZE(1..maxnoofCellIDforMDT)) OF ECGI
2784 */
2785
2786 struct CellIdListforMDT_elm : ECGI
2787 {
2788         static constexpr const char* name() {return "CellIdListforMDT_elm";}
2789         using parent_t = ECGI;
2790
2791 };
2792 struct CellIdListforMDT : asn::sequenceof<CellIdListforMDT_elm>
2793 {
2794         static constexpr const char* name() {return "CellIdListforMDT";}
2795         using parent_t = asn::sequenceof<CellIdListforMDT_elm>;
2796         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofCellIDforMDT >>;
2797
2798 };
2799 /*
2800 CellBasedMDT-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
2801         ...
2802 }
2803 */
2804
2805 struct CellBasedMDT_ExtIEs
2806 {
2807         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
2808         {
2809                 size_t get_index() const {return type;}
2810                 bool is_unknown() const { return type == 1; }
2811                 void clear() {type = 0;}
2812                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
2813                 template<typename V>  bool decode(V& v)
2814                 {
2815                         clear();
2816                         if(!v(ref_nested())) return false;
2817                         { type = 1; return true;}
2818                         return false;
2819
2820                 }
2821                 template<typename V> bool encode(V& v) const
2822                 {
2823                         return v(ref_nested());
2824
2825                 }
2826                 protected:
2827                 template<typename V>  bool decode(size_t index, V& v)
2828                 {
2829                         clear();
2830                         switch(index)
2831                         {
2832                         case 1: type = 1; return v(ref_nested());
2833                         ref_nested().clear();
2834                         }
2835                         return false;
2836
2837                 }
2838                 template<typename V> bool encode(size_t index, V& v) const
2839                 {
2840                         if(index != type) {return false;} return v(ref_nested());
2841
2842                 }
2843                 private:
2844                 size_t type {0};
2845
2846         };
2847         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
2848         {
2849                 size_t get_index() const {return type;}
2850                 bool is_unknown() const { return type == 1; }
2851                 void clear() {type = 0;}
2852                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
2853                 template<typename V>  bool decode(V& v)
2854                 {
2855                         clear();
2856                         if(!v(ref_nested())) return false;
2857                         { type = 1; return true;}
2858                         return false;
2859
2860                 }
2861                 template<typename V> bool encode(V& v) const
2862                 {
2863                         return v(ref_nested());
2864
2865                 }
2866                 protected:
2867                 template<typename V>  bool decode(size_t index, V& v)
2868                 {
2869                         clear();
2870                         switch(index)
2871                         {
2872                         case 1: type = 1; return v(ref_nested());
2873                         ref_nested().clear();
2874                         }
2875                         return false;
2876
2877                 }
2878                 template<typename V> bool encode(size_t index, V& v) const
2879                 {
2880                         if(index != type) {return false;} return v(ref_nested());
2881
2882                 }
2883                 private:
2884                 size_t type {0};
2885
2886         };
2887         struct Extension_t : asn::typefield<true>
2888         {
2889                 ~Extension_t()  {clear();}
2890                 size_t get_index() const {return type;}
2891                 bool is_unknown() const { return type == 1; }
2892                 void clear()
2893                 {
2894                         type = 0; ref_nested().clear();
2895                 }
2896                 template<typename V> static inline void enumerate(V& v)
2897                 {
2898
2899                 }
2900                 protected:
2901                 template<typename V> bool decode(size_t index, V& v)
2902                 {
2903                         clear();
2904                         switch(index)
2905                         {
2906                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
2907                         }
2908                         return false;
2909
2910                 }
2911                 template<typename V> bool encode(size_t index, V& v) const
2912                 {
2913                         if(index != type) return false;
2914                         return false;
2915
2916                 }
2917                 private:
2918                 size_t type {0};
2919
2920         };
2921         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
2922         {
2923                 size_t get_index() const {return type;}
2924                 bool is_unknown() const { return type == 1; }
2925                 void clear() {type = 0;}
2926                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
2927                 template<typename V>  bool decode(V& v)
2928                 {
2929                         clear();
2930                         if(!v(ref_nested())) return false;
2931                         { type = 1; return true;}
2932                         return false;
2933
2934                 }
2935                 template<typename V> bool encode(V& v) const
2936                 {
2937                         return v(ref_nested());
2938
2939                 }
2940                 protected:
2941                 template<typename V>  bool decode(size_t index, V& v)
2942                 {
2943                         clear();
2944                         switch(index)
2945                         {
2946                         case 1: type = 1; return v(ref_nested());
2947                         ref_nested().clear();
2948                         }
2949                         return false;
2950
2951                 }
2952                 template<typename V> bool encode(size_t index, V& v) const
2953                 {
2954                         if(index != type) {return false;} return v(ref_nested());
2955
2956                 }
2957                 private:
2958                 size_t type {0};
2959
2960         };
2961
2962 };
2963 /*
2964 CellBasedMDT::= SEQUENCE {
2965         cellIdListforMDT        CellIdListforMDT,
2966         iE-Extensions           ProtocolExtensionContainer { {CellBasedMDT-ExtIEs} } OPTIONAL,
2967         ...
2968 }
2969 */
2970
2971 struct CellBasedMDT : asn::sequence<2, 0, true, 1>
2972 {
2973         static constexpr const char* name() {return "CellBasedMDT";}
2974         using parent_t = asn::sequence<2, 0, true, 1>;
2975         struct cellIdListforMDT_t : CellIdListforMDT
2976         {
2977                 static constexpr const char* name() {return "cellIdListforMDT_t";}
2978                 using parent_t = CellIdListforMDT;
2979
2980         };
2981         cellIdListforMDT_t& ref_cellIdListforMDT() {return cellIdListforMDT;}
2982         cellIdListforMDT_t const& ref_cellIdListforMDT() const {return cellIdListforMDT;}
2983         struct iE_Extensions_t : ProtocolExtensionContainer<CellBasedMDT_ExtIEs>
2984         {
2985                 static constexpr const char* name() {return "iE_Extensions_t";}
2986                 using parent_t = ProtocolExtensionContainer<CellBasedMDT_ExtIEs>;
2987                 static constexpr bool optional = true;
2988
2989         };
2990         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
2991         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
2992         template<typename V> void decode(V& v)
2993         {
2994                 v(cellIdListforMDT);
2995                 v(iE_Extensions);
2996
2997         };
2998         template<typename V> void encode(V& v) const
2999         {
3000                 v(cellIdListforMDT);
3001                 v(iE_Extensions);
3002
3003         };
3004         void clear()
3005         {
3006                 cellIdListforMDT.clear();
3007                 iE_Extensions.clear();
3008
3009         };
3010         private:
3011         cellIdListforMDT_t      cellIdListforMDT;
3012         iE_Extensions_t iE_Extensions;
3013
3014 };
3015 /*
3016 TAC ::= OCTET STRING (SIZE (2))
3017 */
3018
3019 struct TAC : asn::ostring<>
3020 {
3021         using constraint_t = asn::constraints<false,asn::one<2>>;
3022         static constexpr const char* name() {return "TAC";}
3023         using parent_t = asn::ostring<>;
3024
3025 };
3026
3027 /*
3028 TAListforMDT ::= SEQUENCE (SIZE(1..maxnoofTAforMDT)) OF TAC
3029 */
3030
3031 struct TAListforMDT_elm : TAC
3032 {
3033         static constexpr const char* name() {return "TAListforMDT_elm";}
3034         using parent_t = TAC;
3035
3036 };
3037 struct TAListforMDT : asn::sequenceof<TAListforMDT_elm>
3038 {
3039         static constexpr const char* name() {return "TAListforMDT";}
3040         using parent_t = asn::sequenceof<TAListforMDT_elm>;
3041         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofTAforMDT >>;
3042
3043 };
3044 /*
3045 TABasedMDT-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
3046         ...
3047 }
3048 */
3049
3050 struct TABasedMDT_ExtIEs
3051 {
3052         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
3053         {
3054                 size_t get_index() const {return type;}
3055                 bool is_unknown() const { return type == 1; }
3056                 void clear() {type = 0;}
3057                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
3058                 template<typename V>  bool decode(V& v)
3059                 {
3060                         clear();
3061                         if(!v(ref_nested())) return false;
3062                         { type = 1; return true;}
3063                         return false;
3064
3065                 }
3066                 template<typename V> bool encode(V& v) const
3067                 {
3068                         return v(ref_nested());
3069
3070                 }
3071                 protected:
3072                 template<typename V>  bool decode(size_t index, V& v)
3073                 {
3074                         clear();
3075                         switch(index)
3076                         {
3077                         case 1: type = 1; return v(ref_nested());
3078                         ref_nested().clear();
3079                         }
3080                         return false;
3081
3082                 }
3083                 template<typename V> bool encode(size_t index, V& v) const
3084                 {
3085                         if(index != type) {return false;} return v(ref_nested());
3086
3087                 }
3088                 private:
3089                 size_t type {0};
3090
3091         };
3092         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
3093         {
3094                 size_t get_index() const {return type;}
3095                 bool is_unknown() const { return type == 1; }
3096                 void clear() {type = 0;}
3097                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
3098                 template<typename V>  bool decode(V& v)
3099                 {
3100                         clear();
3101                         if(!v(ref_nested())) return false;
3102                         { type = 1; return true;}
3103                         return false;
3104
3105                 }
3106                 template<typename V> bool encode(V& v) const
3107                 {
3108                         return v(ref_nested());
3109
3110                 }
3111                 protected:
3112                 template<typename V>  bool decode(size_t index, V& v)
3113                 {
3114                         clear();
3115                         switch(index)
3116                         {
3117                         case 1: type = 1; return v(ref_nested());
3118                         ref_nested().clear();
3119                         }
3120                         return false;
3121
3122                 }
3123                 template<typename V> bool encode(size_t index, V& v) const
3124                 {
3125                         if(index != type) {return false;} return v(ref_nested());
3126
3127                 }
3128                 private:
3129                 size_t type {0};
3130
3131         };
3132         struct Extension_t : asn::typefield<true>
3133         {
3134                 ~Extension_t()  {clear();}
3135                 size_t get_index() const {return type;}
3136                 bool is_unknown() const { return type == 1; }
3137                 void clear()
3138                 {
3139                         type = 0; ref_nested().clear();
3140                 }
3141                 template<typename V> static inline void enumerate(V& v)
3142                 {
3143
3144                 }
3145                 protected:
3146                 template<typename V> bool decode(size_t index, V& v)
3147                 {
3148                         clear();
3149                         switch(index)
3150                         {
3151                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
3152                         }
3153                         return false;
3154
3155                 }
3156                 template<typename V> bool encode(size_t index, V& v) const
3157                 {
3158                         if(index != type) return false;
3159                         return false;
3160
3161                 }
3162                 private:
3163                 size_t type {0};
3164
3165         };
3166         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
3167         {
3168                 size_t get_index() const {return type;}
3169                 bool is_unknown() const { return type == 1; }
3170                 void clear() {type = 0;}
3171                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
3172                 template<typename V>  bool decode(V& v)
3173                 {
3174                         clear();
3175                         if(!v(ref_nested())) return false;
3176                         { type = 1; return true;}
3177                         return false;
3178
3179                 }
3180                 template<typename V> bool encode(V& v) const
3181                 {
3182                         return v(ref_nested());
3183
3184                 }
3185                 protected:
3186                 template<typename V>  bool decode(size_t index, V& v)
3187                 {
3188                         clear();
3189                         switch(index)
3190                         {
3191                         case 1: type = 1; return v(ref_nested());
3192                         ref_nested().clear();
3193                         }
3194                         return false;
3195
3196                 }
3197                 template<typename V> bool encode(size_t index, V& v) const
3198                 {
3199                         if(index != type) {return false;} return v(ref_nested());
3200
3201                 }
3202                 private:
3203                 size_t type {0};
3204
3205         };
3206
3207 };
3208 /*
3209 TABasedMDT::= SEQUENCE {
3210         tAListforMDT            TAListforMDT,
3211         iE-Extensions           ProtocolExtensionContainer { {TABasedMDT-ExtIEs} } OPTIONAL,
3212         ...
3213 }
3214 */
3215
3216 struct TABasedMDT : asn::sequence<2, 0, true, 1>
3217 {
3218         static constexpr const char* name() {return "TABasedMDT";}
3219         using parent_t = asn::sequence<2, 0, true, 1>;
3220         struct tAListforMDT_t : TAListforMDT
3221         {
3222                 static constexpr const char* name() {return "tAListforMDT_t";}
3223                 using parent_t = TAListforMDT;
3224
3225         };
3226         tAListforMDT_t& ref_tAListforMDT() {return tAListforMDT;}
3227         tAListforMDT_t const& ref_tAListforMDT() const {return tAListforMDT;}
3228         struct iE_Extensions_t : ProtocolExtensionContainer<TABasedMDT_ExtIEs>
3229         {
3230                 static constexpr const char* name() {return "iE_Extensions_t";}
3231                 using parent_t = ProtocolExtensionContainer<TABasedMDT_ExtIEs>;
3232                 static constexpr bool optional = true;
3233
3234         };
3235         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
3236         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
3237         template<typename V> void decode(V& v)
3238         {
3239                 v(tAListforMDT);
3240                 v(iE_Extensions);
3241
3242         };
3243         template<typename V> void encode(V& v) const
3244         {
3245                 v(tAListforMDT);
3246                 v(iE_Extensions);
3247
3248         };
3249         void clear()
3250         {
3251                 tAListforMDT.clear();
3252                 iE_Extensions.clear();
3253
3254         };
3255         private:
3256         tAListforMDT_t  tAListforMDT;
3257         iE_Extensions_t iE_Extensions;
3258
3259 };
3260 /*
3261 TAI-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
3262         ...
3263 }
3264 */
3265
3266 struct TAI_Item_ExtIEs
3267 {
3268         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
3269         {
3270                 size_t get_index() const {return type;}
3271                 bool is_unknown() const { return type == 1; }
3272                 void clear() {type = 0;}
3273                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
3274                 template<typename V>  bool decode(V& v)
3275                 {
3276                         clear();
3277                         if(!v(ref_nested())) return false;
3278                         { type = 1; return true;}
3279                         return false;
3280
3281                 }
3282                 template<typename V> bool encode(V& v) const
3283                 {
3284                         return v(ref_nested());
3285
3286                 }
3287                 protected:
3288                 template<typename V>  bool decode(size_t index, V& v)
3289                 {
3290                         clear();
3291                         switch(index)
3292                         {
3293                         case 1: type = 1; return v(ref_nested());
3294                         ref_nested().clear();
3295                         }
3296                         return false;
3297
3298                 }
3299                 template<typename V> bool encode(size_t index, V& v) const
3300                 {
3301                         if(index != type) {return false;} return v(ref_nested());
3302
3303                 }
3304                 private:
3305                 size_t type {0};
3306
3307         };
3308         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
3309         {
3310                 size_t get_index() const {return type;}
3311                 bool is_unknown() const { return type == 1; }
3312                 void clear() {type = 0;}
3313                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
3314                 template<typename V>  bool decode(V& v)
3315                 {
3316                         clear();
3317                         if(!v(ref_nested())) return false;
3318                         { type = 1; return true;}
3319                         return false;
3320
3321                 }
3322                 template<typename V> bool encode(V& v) const
3323                 {
3324                         return v(ref_nested());
3325
3326                 }
3327                 protected:
3328                 template<typename V>  bool decode(size_t index, V& v)
3329                 {
3330                         clear();
3331                         switch(index)
3332                         {
3333                         case 1: type = 1; return v(ref_nested());
3334                         ref_nested().clear();
3335                         }
3336                         return false;
3337
3338                 }
3339                 template<typename V> bool encode(size_t index, V& v) const
3340                 {
3341                         if(index != type) {return false;} return v(ref_nested());
3342
3343                 }
3344                 private:
3345                 size_t type {0};
3346
3347         };
3348         struct Extension_t : asn::typefield<true>
3349         {
3350                 ~Extension_t()  {clear();}
3351                 size_t get_index() const {return type;}
3352                 bool is_unknown() const { return type == 1; }
3353                 void clear()
3354                 {
3355                         type = 0; ref_nested().clear();
3356                 }
3357                 template<typename V> static inline void enumerate(V& v)
3358                 {
3359
3360                 }
3361                 protected:
3362                 template<typename V> bool decode(size_t index, V& v)
3363                 {
3364                         clear();
3365                         switch(index)
3366                         {
3367                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
3368                         }
3369                         return false;
3370
3371                 }
3372                 template<typename V> bool encode(size_t index, V& v) const
3373                 {
3374                         if(index != type) return false;
3375                         return false;
3376
3377                 }
3378                 private:
3379                 size_t type {0};
3380
3381         };
3382         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
3383         {
3384                 size_t get_index() const {return type;}
3385                 bool is_unknown() const { return type == 1; }
3386                 void clear() {type = 0;}
3387                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
3388                 template<typename V>  bool decode(V& v)
3389                 {
3390                         clear();
3391                         if(!v(ref_nested())) return false;
3392                         { type = 1; return true;}
3393                         return false;
3394
3395                 }
3396                 template<typename V> bool encode(V& v) const
3397                 {
3398                         return v(ref_nested());
3399
3400                 }
3401                 protected:
3402                 template<typename V>  bool decode(size_t index, V& v)
3403                 {
3404                         clear();
3405                         switch(index)
3406                         {
3407                         case 1: type = 1; return v(ref_nested());
3408                         ref_nested().clear();
3409                         }
3410                         return false;
3411
3412                 }
3413                 template<typename V> bool encode(size_t index, V& v) const
3414                 {
3415                         if(index != type) {return false;} return v(ref_nested());
3416
3417                 }
3418                 private:
3419                 size_t type {0};
3420
3421         };
3422
3423 };
3424 /*
3425 TAI-Item ::= SEQUENCE {
3426         tAC                                     TAC,
3427         pLMN-Identity           PLMN-Identity,
3428         iE-Extensions           ProtocolExtensionContainer { {TAI-Item-ExtIEs} } OPTIONAL,
3429         ...
3430 }
3431 */
3432
3433 struct TAI_Item : asn::sequence<3, 0, true, 1>
3434 {
3435         static constexpr const char* name() {return "TAI-Item";}
3436         using parent_t = asn::sequence<3, 0, true, 1>;
3437         struct tAC_t : TAC
3438         {
3439                 static constexpr const char* name() {return "tAC_t";}
3440                 using parent_t = TAC;
3441
3442         };
3443         tAC_t& ref_tAC() {return tAC;}
3444         tAC_t const& ref_tAC() const {return tAC;}
3445         struct pLMN_Identity_t : PLMN_Identity
3446         {
3447                 static constexpr const char* name() {return "pLMN_Identity_t";}
3448                 using parent_t = PLMN_Identity;
3449
3450         };
3451         pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
3452         pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
3453         struct iE_Extensions_t : ProtocolExtensionContainer<TAI_Item_ExtIEs>
3454         {
3455                 static constexpr const char* name() {return "iE_Extensions_t";}
3456                 using parent_t = ProtocolExtensionContainer<TAI_Item_ExtIEs>;
3457                 static constexpr bool optional = true;
3458
3459         };
3460         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
3461         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
3462         template<typename V> void decode(V& v)
3463         {
3464                 v(tAC);
3465                 v(pLMN_Identity);
3466                 v(iE_Extensions);
3467
3468         };
3469         template<typename V> void encode(V& v) const
3470         {
3471                 v(tAC);
3472                 v(pLMN_Identity);
3473                 v(iE_Extensions);
3474
3475         };
3476         void clear()
3477         {
3478                 tAC.clear();
3479                 pLMN_Identity.clear();
3480                 iE_Extensions.clear();
3481
3482         };
3483         private:
3484         tAC_t   tAC;
3485         pLMN_Identity_t pLMN_Identity;
3486         iE_Extensions_t iE_Extensions;
3487
3488 };
3489 /*
3490 TAIListforMDT ::= SEQUENCE (SIZE(1..maxnoofTAforMDT)) OF TAI-Item
3491 */
3492
3493 struct TAIListforMDT_elm : TAI_Item
3494 {
3495         static constexpr const char* name() {return "TAIListforMDT_elm";}
3496         using parent_t = TAI_Item;
3497
3498 };
3499 struct TAIListforMDT : asn::sequenceof<TAIListforMDT_elm>
3500 {
3501         static constexpr const char* name() {return "TAIListforMDT";}
3502         using parent_t = asn::sequenceof<TAIListforMDT_elm>;
3503         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofTAforMDT >>;
3504
3505 };
3506 /*
3507 TAIBasedMDT-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
3508         ...
3509 }
3510 */
3511
3512 struct TAIBasedMDT_ExtIEs
3513 {
3514         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
3515         {
3516                 size_t get_index() const {return type;}
3517                 bool is_unknown() const { return type == 1; }
3518                 void clear() {type = 0;}
3519                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
3520                 template<typename V>  bool decode(V& v)
3521                 {
3522                         clear();
3523                         if(!v(ref_nested())) return false;
3524                         { type = 1; return true;}
3525                         return false;
3526
3527                 }
3528                 template<typename V> bool encode(V& v) const
3529                 {
3530                         return v(ref_nested());
3531
3532                 }
3533                 protected:
3534                 template<typename V>  bool decode(size_t index, V& v)
3535                 {
3536                         clear();
3537                         switch(index)
3538                         {
3539                         case 1: type = 1; return v(ref_nested());
3540                         ref_nested().clear();
3541                         }
3542                         return false;
3543
3544                 }
3545                 template<typename V> bool encode(size_t index, V& v) const
3546                 {
3547                         if(index != type) {return false;} return v(ref_nested());
3548
3549                 }
3550                 private:
3551                 size_t type {0};
3552
3553         };
3554         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
3555         {
3556                 size_t get_index() const {return type;}
3557                 bool is_unknown() const { return type == 1; }
3558                 void clear() {type = 0;}
3559                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
3560                 template<typename V>  bool decode(V& v)
3561                 {
3562                         clear();
3563                         if(!v(ref_nested())) return false;
3564                         { type = 1; return true;}
3565                         return false;
3566
3567                 }
3568                 template<typename V> bool encode(V& v) const
3569                 {
3570                         return v(ref_nested());
3571
3572                 }
3573                 protected:
3574                 template<typename V>  bool decode(size_t index, V& v)
3575                 {
3576                         clear();
3577                         switch(index)
3578                         {
3579                         case 1: type = 1; return v(ref_nested());
3580                         ref_nested().clear();
3581                         }
3582                         return false;
3583
3584                 }
3585                 template<typename V> bool encode(size_t index, V& v) const
3586                 {
3587                         if(index != type) {return false;} return v(ref_nested());
3588
3589                 }
3590                 private:
3591                 size_t type {0};
3592
3593         };
3594         struct Extension_t : asn::typefield<true>
3595         {
3596                 ~Extension_t()  {clear();}
3597                 size_t get_index() const {return type;}
3598                 bool is_unknown() const { return type == 1; }
3599                 void clear()
3600                 {
3601                         type = 0; ref_nested().clear();
3602                 }
3603                 template<typename V> static inline void enumerate(V& v)
3604                 {
3605
3606                 }
3607                 protected:
3608                 template<typename V> bool decode(size_t index, V& v)
3609                 {
3610                         clear();
3611                         switch(index)
3612                         {
3613                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
3614                         }
3615                         return false;
3616
3617                 }
3618                 template<typename V> bool encode(size_t index, V& v) const
3619                 {
3620                         if(index != type) return false;
3621                         return false;
3622
3623                 }
3624                 private:
3625                 size_t type {0};
3626
3627         };
3628         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
3629         {
3630                 size_t get_index() const {return type;}
3631                 bool is_unknown() const { return type == 1; }
3632                 void clear() {type = 0;}
3633                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
3634                 template<typename V>  bool decode(V& v)
3635                 {
3636                         clear();
3637                         if(!v(ref_nested())) return false;
3638                         { type = 1; return true;}
3639                         return false;
3640
3641                 }
3642                 template<typename V> bool encode(V& v) const
3643                 {
3644                         return v(ref_nested());
3645
3646                 }
3647                 protected:
3648                 template<typename V>  bool decode(size_t index, V& v)
3649                 {
3650                         clear();
3651                         switch(index)
3652                         {
3653                         case 1: type = 1; return v(ref_nested());
3654                         ref_nested().clear();
3655                         }
3656                         return false;
3657
3658                 }
3659                 template<typename V> bool encode(size_t index, V& v) const
3660                 {
3661                         if(index != type) {return false;} return v(ref_nested());
3662
3663                 }
3664                 private:
3665                 size_t type {0};
3666
3667         };
3668
3669 };
3670 /*
3671 TAIBasedMDT ::= SEQUENCE {
3672         tAIListforMDT                   TAIListforMDT,
3673         iE-Extensions                   ProtocolExtensionContainer { {TAIBasedMDT-ExtIEs} } OPTIONAL,
3674         ...
3675 }
3676 */
3677
3678 struct TAIBasedMDT : asn::sequence<2, 0, true, 1>
3679 {
3680         static constexpr const char* name() {return "TAIBasedMDT";}
3681         using parent_t = asn::sequence<2, 0, true, 1>;
3682         struct tAIListforMDT_t : TAIListforMDT
3683         {
3684                 static constexpr const char* name() {return "tAIListforMDT_t";}
3685                 using parent_t = TAIListforMDT;
3686
3687         };
3688         tAIListforMDT_t& ref_tAIListforMDT() {return tAIListforMDT;}
3689         tAIListforMDT_t const& ref_tAIListforMDT() const {return tAIListforMDT;}
3690         struct iE_Extensions_t : ProtocolExtensionContainer<TAIBasedMDT_ExtIEs>
3691         {
3692                 static constexpr const char* name() {return "iE_Extensions_t";}
3693                 using parent_t = ProtocolExtensionContainer<TAIBasedMDT_ExtIEs>;
3694                 static constexpr bool optional = true;
3695
3696         };
3697         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
3698         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
3699         template<typename V> void decode(V& v)
3700         {
3701                 v(tAIListforMDT);
3702                 v(iE_Extensions);
3703
3704         };
3705         template<typename V> void encode(V& v) const
3706         {
3707                 v(tAIListforMDT);
3708                 v(iE_Extensions);
3709
3710         };
3711         void clear()
3712         {
3713                 tAIListforMDT.clear();
3714                 iE_Extensions.clear();
3715
3716         };
3717         private:
3718         tAIListforMDT_t tAIListforMDT;
3719         iE_Extensions_t iE_Extensions;
3720
3721 };
3722 /*
3723 AreaScopeOfMDT ::= CHOICE {
3724         cellBased                                       CellBasedMDT,
3725         tABased                                         TABasedMDT,
3726         pLMNWide                                        NULL,
3727         ...,
3728         tAIBased                                        TAIBasedMDT
3729 }
3730 */
3731
3732 struct AreaScopeOfMDT : asn::choice<4, 1, true>
3733 {
3734         static constexpr const char* name() {return "AreaScopeOfMDT";}
3735         using parent_t = asn::choice<4, 1, true>;
3736         index_type get_index() const {return index;}
3737         bool is_unknown() const {return index == 5;}
3738         void set_unknown() { set_index(5);  }
3739         ~AreaScopeOfMDT() {clear();}
3740         struct cellBased_t : CellBasedMDT
3741         {
3742                 static constexpr const char* name() {return "cellBased_t";}
3743                 using parent_t = CellBasedMDT;
3744
3745         };
3746         struct tABased_t : TABasedMDT
3747         {
3748                 static constexpr const char* name() {return "tABased_t";}
3749                 using parent_t = TABasedMDT;
3750
3751         };
3752         struct pLMNWide_t : asn::nulltype
3753         {
3754                 static constexpr const char* name() {return "pLMNWide_t";}
3755                 using parent_t = asn::nulltype;
3756
3757         };
3758         struct tAIBased_t : TAIBasedMDT
3759         {
3760                 static constexpr const char* name() {return "tAIBased_t";}
3761                 using parent_t = TAIBasedMDT;
3762
3763         };
3764         void clear()
3765         {
3766                 switch(get_index())
3767                 {
3768                 case 1: var.destroy<cellBased_t>(); break;
3769                 case 2: var.destroy<tABased_t>(); break;
3770                 case 3: var.destroy<pLMNWide_t>(); break;
3771                 case 4: var.destroy<tAIBased_t>(); break;
3772                 }
3773                 index = 0;
3774                 base::clear();
3775         }
3776         template<typename V> bool decode(size_t idx, V& v)
3777         {
3778                 clear();
3779                 switch(idx)
3780                 {
3781                 case 1: set_index(1); return v(var.build<cellBased_t>());
3782                 case 2: set_index(2); return v(var.build<tABased_t>());
3783                 case 3: set_index(3); return v(var.build<pLMNWide_t>());
3784                 case 4: set_index(4); return v(var.build<tAIBased_t>());
3785                 }
3786                 return false;
3787
3788         }
3789         template<typename V> bool encode(V& v) const
3790         {
3791                 switch(get_index())
3792                 {
3793                 case 1: return v(var.as<cellBased_t>());
3794                 case 2: return v(var.as<tABased_t>());
3795                 case 3: return v(var.as<pLMNWide_t>());
3796                 case 4: return v(var.as<tAIBased_t>());
3797                 }
3798                 return false;
3799         }
3800         template<typename V> static inline void enumerate(V& v)
3801         {
3802                 v.template operator()<cellBased_t>(1);
3803                 v.template operator()<tABased_t>(2);
3804                 v.template operator()<pLMNWide_t>(3);
3805                 v.template operator()<tAIBased_t>(4);
3806
3807         }
3808         cellBased_t& select_cellBased() { if(get_index() != 1) { clear(); set_index(1); return var.build<cellBased_t>();} return var.as<cellBased_t>();}
3809         cellBased_t const* get_cellBased() const { if(get_index() == 1) { return &var.as<cellBased_t>();} return nullptr; }
3810         tABased_t& select_tABased() { if(get_index() != 2) { clear(); set_index(2); return var.build<tABased_t>();} return var.as<tABased_t>();}
3811         tABased_t const* get_tABased() const { if(get_index() == 2) { return &var.as<tABased_t>();} return nullptr; }
3812         pLMNWide_t& select_pLMNWide() { if(get_index() != 3) { clear(); set_index(3); return var.build<pLMNWide_t>();} return var.as<pLMNWide_t>();}
3813         pLMNWide_t const* get_pLMNWide() const { if(get_index() == 3) { return &var.as<pLMNWide_t>();} return nullptr; }
3814         tAIBased_t& select_tAIBased() { if(get_index() != 4) { clear(); set_index(4); return var.build<tAIBased_t>();} return var.as<tAIBased_t>();}
3815         tAIBased_t const* get_tAIBased() const { if(get_index() == 4) { return &var.as<tAIBased_t>();} return nullptr; }
3816         private:
3817         void set_index(index_type i) {index = i; base::set();}
3818         union union_type
3819         {
3820                 char dummy1[sizeof(cellBased_t)];
3821                 char dummy2[sizeof(tABased_t)];
3822                 char dummy3[sizeof(pLMNWide_t)];
3823                 char dummy4[sizeof(tAIBased_t)];
3824
3825         };
3826         asn::variant<sizeof(union_type)>        var;
3827         index_type      index {0};
3828 };
3829 /*
3830 CellIdListforQMC ::= SEQUENCE (SIZE(1..maxnoofCellIDforQMC)) OF ECGI
3831 */
3832
3833 struct CellIdListforQMC_elm : ECGI
3834 {
3835         static constexpr const char* name() {return "CellIdListforQMC_elm";}
3836         using parent_t = ECGI;
3837
3838 };
3839 struct CellIdListforQMC : asn::sequenceof<CellIdListforQMC_elm>
3840 {
3841         static constexpr const char* name() {return "CellIdListforQMC";}
3842         using parent_t = asn::sequenceof<CellIdListforQMC_elm>;
3843         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofCellIDforQMC >>;
3844
3845 };
3846 /*
3847 CellBasedQMC-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
3848         ...
3849 }
3850 */
3851
3852 struct CellBasedQMC_ExtIEs
3853 {
3854         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
3855         {
3856                 size_t get_index() const {return type;}
3857                 bool is_unknown() const { return type == 1; }
3858                 void clear() {type = 0;}
3859                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
3860                 template<typename V>  bool decode(V& v)
3861                 {
3862                         clear();
3863                         if(!v(ref_nested())) return false;
3864                         { type = 1; return true;}
3865                         return false;
3866
3867                 }
3868                 template<typename V> bool encode(V& v) const
3869                 {
3870                         return v(ref_nested());
3871
3872                 }
3873                 protected:
3874                 template<typename V>  bool decode(size_t index, V& v)
3875                 {
3876                         clear();
3877                         switch(index)
3878                         {
3879                         case 1: type = 1; return v(ref_nested());
3880                         ref_nested().clear();
3881                         }
3882                         return false;
3883
3884                 }
3885                 template<typename V> bool encode(size_t index, V& v) const
3886                 {
3887                         if(index != type) {return false;} return v(ref_nested());
3888
3889                 }
3890                 private:
3891                 size_t type {0};
3892
3893         };
3894         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
3895         {
3896                 size_t get_index() const {return type;}
3897                 bool is_unknown() const { return type == 1; }
3898                 void clear() {type = 0;}
3899                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
3900                 template<typename V>  bool decode(V& v)
3901                 {
3902                         clear();
3903                         if(!v(ref_nested())) return false;
3904                         { type = 1; return true;}
3905                         return false;
3906
3907                 }
3908                 template<typename V> bool encode(V& v) const
3909                 {
3910                         return v(ref_nested());
3911
3912                 }
3913                 protected:
3914                 template<typename V>  bool decode(size_t index, V& v)
3915                 {
3916                         clear();
3917                         switch(index)
3918                         {
3919                         case 1: type = 1; return v(ref_nested());
3920                         ref_nested().clear();
3921                         }
3922                         return false;
3923
3924                 }
3925                 template<typename V> bool encode(size_t index, V& v) const
3926                 {
3927                         if(index != type) {return false;} return v(ref_nested());
3928
3929                 }
3930                 private:
3931                 size_t type {0};
3932
3933         };
3934         struct Extension_t : asn::typefield<true>
3935         {
3936                 ~Extension_t()  {clear();}
3937                 size_t get_index() const {return type;}
3938                 bool is_unknown() const { return type == 1; }
3939                 void clear()
3940                 {
3941                         type = 0; ref_nested().clear();
3942                 }
3943                 template<typename V> static inline void enumerate(V& v)
3944                 {
3945
3946                 }
3947                 protected:
3948                 template<typename V> bool decode(size_t index, V& v)
3949                 {
3950                         clear();
3951                         switch(index)
3952                         {
3953                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
3954                         }
3955                         return false;
3956
3957                 }
3958                 template<typename V> bool encode(size_t index, V& v) const
3959                 {
3960                         if(index != type) return false;
3961                         return false;
3962
3963                 }
3964                 private:
3965                 size_t type {0};
3966
3967         };
3968         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
3969         {
3970                 size_t get_index() const {return type;}
3971                 bool is_unknown() const { return type == 1; }
3972                 void clear() {type = 0;}
3973                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
3974                 template<typename V>  bool decode(V& v)
3975                 {
3976                         clear();
3977                         if(!v(ref_nested())) return false;
3978                         { type = 1; return true;}
3979                         return false;
3980
3981                 }
3982                 template<typename V> bool encode(V& v) const
3983                 {
3984                         return v(ref_nested());
3985
3986                 }
3987                 protected:
3988                 template<typename V>  bool decode(size_t index, V& v)
3989                 {
3990                         clear();
3991                         switch(index)
3992                         {
3993                         case 1: type = 1; return v(ref_nested());
3994                         ref_nested().clear();
3995                         }
3996                         return false;
3997
3998                 }
3999                 template<typename V> bool encode(size_t index, V& v) const
4000                 {
4001                         if(index != type) {return false;} return v(ref_nested());
4002
4003                 }
4004                 private:
4005                 size_t type {0};
4006
4007         };
4008
4009 };
4010 /*
4011 CellBasedQMC::= SEQUENCE {
4012         cellIdListforQMC                CellIdListforQMC,
4013         iE-Extensions           ProtocolExtensionContainer { {CellBasedQMC-ExtIEs} } OPTIONAL,
4014         ...
4015 }
4016 */
4017
4018 struct CellBasedQMC : asn::sequence<2, 0, true, 1>
4019 {
4020         static constexpr const char* name() {return "CellBasedQMC";}
4021         using parent_t = asn::sequence<2, 0, true, 1>;
4022         struct cellIdListforQMC_t : CellIdListforQMC
4023         {
4024                 static constexpr const char* name() {return "cellIdListforQMC_t";}
4025                 using parent_t = CellIdListforQMC;
4026
4027         };
4028         cellIdListforQMC_t& ref_cellIdListforQMC() {return cellIdListforQMC;}
4029         cellIdListforQMC_t const& ref_cellIdListforQMC() const {return cellIdListforQMC;}
4030         struct iE_Extensions_t : ProtocolExtensionContainer<CellBasedQMC_ExtIEs>
4031         {
4032                 static constexpr const char* name() {return "iE_Extensions_t";}
4033                 using parent_t = ProtocolExtensionContainer<CellBasedQMC_ExtIEs>;
4034                 static constexpr bool optional = true;
4035
4036         };
4037         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
4038         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
4039         template<typename V> void decode(V& v)
4040         {
4041                 v(cellIdListforQMC);
4042                 v(iE_Extensions);
4043
4044         };
4045         template<typename V> void encode(V& v) const
4046         {
4047                 v(cellIdListforQMC);
4048                 v(iE_Extensions);
4049
4050         };
4051         void clear()
4052         {
4053                 cellIdListforQMC.clear();
4054                 iE_Extensions.clear();
4055
4056         };
4057         private:
4058         cellIdListforQMC_t      cellIdListforQMC;
4059         iE_Extensions_t iE_Extensions;
4060
4061 };
4062 /*
4063 TAListforQMC ::= SEQUENCE (SIZE(1..maxnoofTAforQMC)) OF TAC
4064 */
4065
4066 struct TAListforQMC_elm : TAC
4067 {
4068         static constexpr const char* name() {return "TAListforQMC_elm";}
4069         using parent_t = TAC;
4070
4071 };
4072 struct TAListforQMC : asn::sequenceof<TAListforQMC_elm>
4073 {
4074         static constexpr const char* name() {return "TAListforQMC";}
4075         using parent_t = asn::sequenceof<TAListforQMC_elm>;
4076         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofTAforQMC >>;
4077
4078 };
4079 /*
4080 TABasedQMC-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
4081         ...
4082 }
4083 */
4084
4085 struct TABasedQMC_ExtIEs
4086 {
4087         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
4088         {
4089                 size_t get_index() const {return type;}
4090                 bool is_unknown() const { return type == 1; }
4091                 void clear() {type = 0;}
4092                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
4093                 template<typename V>  bool decode(V& v)
4094                 {
4095                         clear();
4096                         if(!v(ref_nested())) return false;
4097                         { type = 1; return true;}
4098                         return false;
4099
4100                 }
4101                 template<typename V> bool encode(V& v) const
4102                 {
4103                         return v(ref_nested());
4104
4105                 }
4106                 protected:
4107                 template<typename V>  bool decode(size_t index, V& v)
4108                 {
4109                         clear();
4110                         switch(index)
4111                         {
4112                         case 1: type = 1; return v(ref_nested());
4113                         ref_nested().clear();
4114                         }
4115                         return false;
4116
4117                 }
4118                 template<typename V> bool encode(size_t index, V& v) const
4119                 {
4120                         if(index != type) {return false;} return v(ref_nested());
4121
4122                 }
4123                 private:
4124                 size_t type {0};
4125
4126         };
4127         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
4128         {
4129                 size_t get_index() const {return type;}
4130                 bool is_unknown() const { return type == 1; }
4131                 void clear() {type = 0;}
4132                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
4133                 template<typename V>  bool decode(V& v)
4134                 {
4135                         clear();
4136                         if(!v(ref_nested())) return false;
4137                         { type = 1; return true;}
4138                         return false;
4139
4140                 }
4141                 template<typename V> bool encode(V& v) const
4142                 {
4143                         return v(ref_nested());
4144
4145                 }
4146                 protected:
4147                 template<typename V>  bool decode(size_t index, V& v)
4148                 {
4149                         clear();
4150                         switch(index)
4151                         {
4152                         case 1: type = 1; return v(ref_nested());
4153                         ref_nested().clear();
4154                         }
4155                         return false;
4156
4157                 }
4158                 template<typename V> bool encode(size_t index, V& v) const
4159                 {
4160                         if(index != type) {return false;} return v(ref_nested());
4161
4162                 }
4163                 private:
4164                 size_t type {0};
4165
4166         };
4167         struct Extension_t : asn::typefield<true>
4168         {
4169                 ~Extension_t()  {clear();}
4170                 size_t get_index() const {return type;}
4171                 bool is_unknown() const { return type == 1; }
4172                 void clear()
4173                 {
4174                         type = 0; ref_nested().clear();
4175                 }
4176                 template<typename V> static inline void enumerate(V& v)
4177                 {
4178
4179                 }
4180                 protected:
4181                 template<typename V> bool decode(size_t index, V& v)
4182                 {
4183                         clear();
4184                         switch(index)
4185                         {
4186                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
4187                         }
4188                         return false;
4189
4190                 }
4191                 template<typename V> bool encode(size_t index, V& v) const
4192                 {
4193                         if(index != type) return false;
4194                         return false;
4195
4196                 }
4197                 private:
4198                 size_t type {0};
4199
4200         };
4201         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
4202         {
4203                 size_t get_index() const {return type;}
4204                 bool is_unknown() const { return type == 1; }
4205                 void clear() {type = 0;}
4206                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
4207                 template<typename V>  bool decode(V& v)
4208                 {
4209                         clear();
4210                         if(!v(ref_nested())) return false;
4211                         { type = 1; return true;}
4212                         return false;
4213
4214                 }
4215                 template<typename V> bool encode(V& v) const
4216                 {
4217                         return v(ref_nested());
4218
4219                 }
4220                 protected:
4221                 template<typename V>  bool decode(size_t index, V& v)
4222                 {
4223                         clear();
4224                         switch(index)
4225                         {
4226                         case 1: type = 1; return v(ref_nested());
4227                         ref_nested().clear();
4228                         }
4229                         return false;
4230
4231                 }
4232                 template<typename V> bool encode(size_t index, V& v) const
4233                 {
4234                         if(index != type) {return false;} return v(ref_nested());
4235
4236                 }
4237                 private:
4238                 size_t type {0};
4239
4240         };
4241
4242 };
4243 /*
4244 TABasedQMC ::= SEQUENCE {
4245         tAListforQMC            TAListforQMC,
4246         iE-Extensions           ProtocolExtensionContainer { {TABasedQMC-ExtIEs} } OPTIONAL,
4247         ...
4248 }
4249 */
4250
4251 struct TABasedQMC : asn::sequence<2, 0, true, 1>
4252 {
4253         static constexpr const char* name() {return "TABasedQMC";}
4254         using parent_t = asn::sequence<2, 0, true, 1>;
4255         struct tAListforQMC_t : TAListforQMC
4256         {
4257                 static constexpr const char* name() {return "tAListforQMC_t";}
4258                 using parent_t = TAListforQMC;
4259
4260         };
4261         tAListforQMC_t& ref_tAListforQMC() {return tAListforQMC;}
4262         tAListforQMC_t const& ref_tAListforQMC() const {return tAListforQMC;}
4263         struct iE_Extensions_t : ProtocolExtensionContainer<TABasedQMC_ExtIEs>
4264         {
4265                 static constexpr const char* name() {return "iE_Extensions_t";}
4266                 using parent_t = ProtocolExtensionContainer<TABasedQMC_ExtIEs>;
4267                 static constexpr bool optional = true;
4268
4269         };
4270         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
4271         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
4272         template<typename V> void decode(V& v)
4273         {
4274                 v(tAListforQMC);
4275                 v(iE_Extensions);
4276
4277         };
4278         template<typename V> void encode(V& v) const
4279         {
4280                 v(tAListforQMC);
4281                 v(iE_Extensions);
4282
4283         };
4284         void clear()
4285         {
4286                 tAListforQMC.clear();
4287                 iE_Extensions.clear();
4288
4289         };
4290         private:
4291         tAListforQMC_t  tAListforQMC;
4292         iE_Extensions_t iE_Extensions;
4293
4294 };
4295 /*
4296 TAIListforQMC ::= SEQUENCE (SIZE(1..maxnoofTAforQMC)) OF TAI-Item
4297 */
4298
4299 struct TAIListforQMC_elm : TAI_Item
4300 {
4301         static constexpr const char* name() {return "TAIListforQMC_elm";}
4302         using parent_t = TAI_Item;
4303
4304 };
4305 struct TAIListforQMC : asn::sequenceof<TAIListforQMC_elm>
4306 {
4307         static constexpr const char* name() {return "TAIListforQMC";}
4308         using parent_t = asn::sequenceof<TAIListforQMC_elm>;
4309         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofTAforQMC >>;
4310
4311 };
4312 /*
4313 TAIBasedQMC-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
4314         ...
4315 }
4316 */
4317
4318 struct TAIBasedQMC_ExtIEs
4319 {
4320         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
4321         {
4322                 size_t get_index() const {return type;}
4323                 bool is_unknown() const { return type == 1; }
4324                 void clear() {type = 0;}
4325                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
4326                 template<typename V>  bool decode(V& v)
4327                 {
4328                         clear();
4329                         if(!v(ref_nested())) return false;
4330                         { type = 1; return true;}
4331                         return false;
4332
4333                 }
4334                 template<typename V> bool encode(V& v) const
4335                 {
4336                         return v(ref_nested());
4337
4338                 }
4339                 protected:
4340                 template<typename V>  bool decode(size_t index, V& v)
4341                 {
4342                         clear();
4343                         switch(index)
4344                         {
4345                         case 1: type = 1; return v(ref_nested());
4346                         ref_nested().clear();
4347                         }
4348                         return false;
4349
4350                 }
4351                 template<typename V> bool encode(size_t index, V& v) const
4352                 {
4353                         if(index != type) {return false;} return v(ref_nested());
4354
4355                 }
4356                 private:
4357                 size_t type {0};
4358
4359         };
4360         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
4361         {
4362                 size_t get_index() const {return type;}
4363                 bool is_unknown() const { return type == 1; }
4364                 void clear() {type = 0;}
4365                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
4366                 template<typename V>  bool decode(V& v)
4367                 {
4368                         clear();
4369                         if(!v(ref_nested())) return false;
4370                         { type = 1; return true;}
4371                         return false;
4372
4373                 }
4374                 template<typename V> bool encode(V& v) const
4375                 {
4376                         return v(ref_nested());
4377
4378                 }
4379                 protected:
4380                 template<typename V>  bool decode(size_t index, V& v)
4381                 {
4382                         clear();
4383                         switch(index)
4384                         {
4385                         case 1: type = 1; return v(ref_nested());
4386                         ref_nested().clear();
4387                         }
4388                         return false;
4389
4390                 }
4391                 template<typename V> bool encode(size_t index, V& v) const
4392                 {
4393                         if(index != type) {return false;} return v(ref_nested());
4394
4395                 }
4396                 private:
4397                 size_t type {0};
4398
4399         };
4400         struct Extension_t : asn::typefield<true>
4401         {
4402                 ~Extension_t()  {clear();}
4403                 size_t get_index() const {return type;}
4404                 bool is_unknown() const { return type == 1; }
4405                 void clear()
4406                 {
4407                         type = 0; ref_nested().clear();
4408                 }
4409                 template<typename V> static inline void enumerate(V& v)
4410                 {
4411
4412                 }
4413                 protected:
4414                 template<typename V> bool decode(size_t index, V& v)
4415                 {
4416                         clear();
4417                         switch(index)
4418                         {
4419                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
4420                         }
4421                         return false;
4422
4423                 }
4424                 template<typename V> bool encode(size_t index, V& v) const
4425                 {
4426                         if(index != type) return false;
4427                         return false;
4428
4429                 }
4430                 private:
4431                 size_t type {0};
4432
4433         };
4434         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
4435         {
4436                 size_t get_index() const {return type;}
4437                 bool is_unknown() const { return type == 1; }
4438                 void clear() {type = 0;}
4439                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
4440                 template<typename V>  bool decode(V& v)
4441                 {
4442                         clear();
4443                         if(!v(ref_nested())) return false;
4444                         { type = 1; return true;}
4445                         return false;
4446
4447                 }
4448                 template<typename V> bool encode(V& v) const
4449                 {
4450                         return v(ref_nested());
4451
4452                 }
4453                 protected:
4454                 template<typename V>  bool decode(size_t index, V& v)
4455                 {
4456                         clear();
4457                         switch(index)
4458                         {
4459                         case 1: type = 1; return v(ref_nested());
4460                         ref_nested().clear();
4461                         }
4462                         return false;
4463
4464                 }
4465                 template<typename V> bool encode(size_t index, V& v) const
4466                 {
4467                         if(index != type) {return false;} return v(ref_nested());
4468
4469                 }
4470                 private:
4471                 size_t type {0};
4472
4473         };
4474
4475 };
4476 /*
4477 TAIBasedQMC ::= SEQUENCE {
4478         tAIListforQMC           TAIListforQMC,
4479         iE-Extensions           ProtocolExtensionContainer { {TAIBasedQMC-ExtIEs} } OPTIONAL,
4480         ...
4481 }
4482 */
4483
4484 struct TAIBasedQMC : asn::sequence<2, 0, true, 1>
4485 {
4486         static constexpr const char* name() {return "TAIBasedQMC";}
4487         using parent_t = asn::sequence<2, 0, true, 1>;
4488         struct tAIListforQMC_t : TAIListforQMC
4489         {
4490                 static constexpr const char* name() {return "tAIListforQMC_t";}
4491                 using parent_t = TAIListforQMC;
4492
4493         };
4494         tAIListforQMC_t& ref_tAIListforQMC() {return tAIListforQMC;}
4495         tAIListforQMC_t const& ref_tAIListforQMC() const {return tAIListforQMC;}
4496         struct iE_Extensions_t : ProtocolExtensionContainer<TAIBasedQMC_ExtIEs>
4497         {
4498                 static constexpr const char* name() {return "iE_Extensions_t";}
4499                 using parent_t = ProtocolExtensionContainer<TAIBasedQMC_ExtIEs>;
4500                 static constexpr bool optional = true;
4501
4502         };
4503         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
4504         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
4505         template<typename V> void decode(V& v)
4506         {
4507                 v(tAIListforQMC);
4508                 v(iE_Extensions);
4509
4510         };
4511         template<typename V> void encode(V& v) const
4512         {
4513                 v(tAIListforQMC);
4514                 v(iE_Extensions);
4515
4516         };
4517         void clear()
4518         {
4519                 tAIListforQMC.clear();
4520                 iE_Extensions.clear();
4521
4522         };
4523         private:
4524         tAIListforQMC_t tAIListforQMC;
4525         iE_Extensions_t iE_Extensions;
4526
4527 };
4528 /*
4529 PLMNListforQMC ::= SEQUENCE (SIZE(1..maxnoofPLMNforQMC)) OF PLMN-Identity
4530 */
4531
4532 struct PLMNListforQMC_elm : PLMN_Identity
4533 {
4534         static constexpr const char* name() {return "PLMNListforQMC_elm";}
4535         using parent_t = PLMN_Identity;
4536
4537 };
4538 struct PLMNListforQMC : asn::sequenceof<PLMNListforQMC_elm>
4539 {
4540         static constexpr const char* name() {return "PLMNListforQMC";}
4541         using parent_t = asn::sequenceof<PLMNListforQMC_elm>;
4542         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofPLMNforQMC >>;
4543
4544 };
4545 /*
4546 PLMNAreaBasedQMC-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
4547         ...
4548 }
4549 */
4550
4551 struct PLMNAreaBasedQMC_ExtIEs
4552 {
4553         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
4554         {
4555                 size_t get_index() const {return type;}
4556                 bool is_unknown() const { return type == 1; }
4557                 void clear() {type = 0;}
4558                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
4559                 template<typename V>  bool decode(V& v)
4560                 {
4561                         clear();
4562                         if(!v(ref_nested())) return false;
4563                         { type = 1; return true;}
4564                         return false;
4565
4566                 }
4567                 template<typename V> bool encode(V& v) const
4568                 {
4569                         return v(ref_nested());
4570
4571                 }
4572                 protected:
4573                 template<typename V>  bool decode(size_t index, V& v)
4574                 {
4575                         clear();
4576                         switch(index)
4577                         {
4578                         case 1: type = 1; return v(ref_nested());
4579                         ref_nested().clear();
4580                         }
4581                         return false;
4582
4583                 }
4584                 template<typename V> bool encode(size_t index, V& v) const
4585                 {
4586                         if(index != type) {return false;} return v(ref_nested());
4587
4588                 }
4589                 private:
4590                 size_t type {0};
4591
4592         };
4593         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
4594         {
4595                 size_t get_index() const {return type;}
4596                 bool is_unknown() const { return type == 1; }
4597                 void clear() {type = 0;}
4598                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
4599                 template<typename V>  bool decode(V& v)
4600                 {
4601                         clear();
4602                         if(!v(ref_nested())) return false;
4603                         { type = 1; return true;}
4604                         return false;
4605
4606                 }
4607                 template<typename V> bool encode(V& v) const
4608                 {
4609                         return v(ref_nested());
4610
4611                 }
4612                 protected:
4613                 template<typename V>  bool decode(size_t index, V& v)
4614                 {
4615                         clear();
4616                         switch(index)
4617                         {
4618                         case 1: type = 1; return v(ref_nested());
4619                         ref_nested().clear();
4620                         }
4621                         return false;
4622
4623                 }
4624                 template<typename V> bool encode(size_t index, V& v) const
4625                 {
4626                         if(index != type) {return false;} return v(ref_nested());
4627
4628                 }
4629                 private:
4630                 size_t type {0};
4631
4632         };
4633         struct Extension_t : asn::typefield<true>
4634         {
4635                 ~Extension_t()  {clear();}
4636                 size_t get_index() const {return type;}
4637                 bool is_unknown() const { return type == 1; }
4638                 void clear()
4639                 {
4640                         type = 0; ref_nested().clear();
4641                 }
4642                 template<typename V> static inline void enumerate(V& v)
4643                 {
4644
4645                 }
4646                 protected:
4647                 template<typename V> bool decode(size_t index, V& v)
4648                 {
4649                         clear();
4650                         switch(index)
4651                         {
4652                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
4653                         }
4654                         return false;
4655
4656                 }
4657                 template<typename V> bool encode(size_t index, V& v) const
4658                 {
4659                         if(index != type) return false;
4660                         return false;
4661
4662                 }
4663                 private:
4664                 size_t type {0};
4665
4666         };
4667         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
4668         {
4669                 size_t get_index() const {return type;}
4670                 bool is_unknown() const { return type == 1; }
4671                 void clear() {type = 0;}
4672                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
4673                 template<typename V>  bool decode(V& v)
4674                 {
4675                         clear();
4676                         if(!v(ref_nested())) return false;
4677                         { type = 1; return true;}
4678                         return false;
4679
4680                 }
4681                 template<typename V> bool encode(V& v) const
4682                 {
4683                         return v(ref_nested());
4684
4685                 }
4686                 protected:
4687                 template<typename V>  bool decode(size_t index, V& v)
4688                 {
4689                         clear();
4690                         switch(index)
4691                         {
4692                         case 1: type = 1; return v(ref_nested());
4693                         ref_nested().clear();
4694                         }
4695                         return false;
4696
4697                 }
4698                 template<typename V> bool encode(size_t index, V& v) const
4699                 {
4700                         if(index != type) {return false;} return v(ref_nested());
4701
4702                 }
4703                 private:
4704                 size_t type {0};
4705
4706         };
4707
4708 };
4709 /*
4710 PLMNAreaBasedQMC ::= SEQUENCE {
4711         plmnListforQMC          PLMNListforQMC,
4712         iE-Extensions           ProtocolExtensionContainer { {PLMNAreaBasedQMC-ExtIEs} } OPTIONAL,
4713         ...
4714 }
4715 */
4716
4717 struct PLMNAreaBasedQMC : asn::sequence<2, 0, true, 1>
4718 {
4719         static constexpr const char* name() {return "PLMNAreaBasedQMC";}
4720         using parent_t = asn::sequence<2, 0, true, 1>;
4721         struct plmnListforQMC_t : PLMNListforQMC
4722         {
4723                 static constexpr const char* name() {return "plmnListforQMC_t";}
4724                 using parent_t = PLMNListforQMC;
4725
4726         };
4727         plmnListforQMC_t& ref_plmnListforQMC() {return plmnListforQMC;}
4728         plmnListforQMC_t const& ref_plmnListforQMC() const {return plmnListforQMC;}
4729         struct iE_Extensions_t : ProtocolExtensionContainer<PLMNAreaBasedQMC_ExtIEs>
4730         {
4731                 static constexpr const char* name() {return "iE_Extensions_t";}
4732                 using parent_t = ProtocolExtensionContainer<PLMNAreaBasedQMC_ExtIEs>;
4733                 static constexpr bool optional = true;
4734
4735         };
4736         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
4737         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
4738         template<typename V> void decode(V& v)
4739         {
4740                 v(plmnListforQMC);
4741                 v(iE_Extensions);
4742
4743         };
4744         template<typename V> void encode(V& v) const
4745         {
4746                 v(plmnListforQMC);
4747                 v(iE_Extensions);
4748
4749         };
4750         void clear()
4751         {
4752                 plmnListforQMC.clear();
4753                 iE_Extensions.clear();
4754
4755         };
4756         private:
4757         plmnListforQMC_t        plmnListforQMC;
4758         iE_Extensions_t iE_Extensions;
4759
4760 };
4761 /*
4762 AreaScopeOfQMC ::= CHOICE {
4763         cellBased                                       CellBasedQMC,
4764         tABased                                         TABasedQMC,
4765         tAIBased                                        TAIBasedQMC,
4766         pLMNAreaBased                           PLMNAreaBasedQMC,
4767         ...
4768 }
4769 */
4770
4771 struct AreaScopeOfQMC : asn::choice<4, 0, true>
4772 {
4773         static constexpr const char* name() {return "AreaScopeOfQMC";}
4774         using parent_t = asn::choice<4, 0, true>;
4775         index_type get_index() const {return index;}
4776         bool is_unknown() const {return index == 5;}
4777         void set_unknown() { set_index(5);  }
4778         ~AreaScopeOfQMC() {clear();}
4779         struct cellBased_t : CellBasedQMC
4780         {
4781                 static constexpr const char* name() {return "cellBased_t";}
4782                 using parent_t = CellBasedQMC;
4783
4784         };
4785         struct tABased_t : TABasedQMC
4786         {
4787                 static constexpr const char* name() {return "tABased_t";}
4788                 using parent_t = TABasedQMC;
4789
4790         };
4791         struct tAIBased_t : TAIBasedQMC
4792         {
4793                 static constexpr const char* name() {return "tAIBased_t";}
4794                 using parent_t = TAIBasedQMC;
4795
4796         };
4797         struct pLMNAreaBased_t : PLMNAreaBasedQMC
4798         {
4799                 static constexpr const char* name() {return "pLMNAreaBased_t";}
4800                 using parent_t = PLMNAreaBasedQMC;
4801
4802         };
4803         void clear()
4804         {
4805                 switch(get_index())
4806                 {
4807                 case 1: var.destroy<cellBased_t>(); break;
4808                 case 2: var.destroy<tABased_t>(); break;
4809                 case 3: var.destroy<tAIBased_t>(); break;
4810                 case 4: var.destroy<pLMNAreaBased_t>(); break;
4811                 }
4812                 index = 0;
4813                 base::clear();
4814         }
4815         template<typename V> bool decode(size_t idx, V& v)
4816         {
4817                 clear();
4818                 switch(idx)
4819                 {
4820                 case 1: set_index(1); return v(var.build<cellBased_t>());
4821                 case 2: set_index(2); return v(var.build<tABased_t>());
4822                 case 3: set_index(3); return v(var.build<tAIBased_t>());
4823                 case 4: set_index(4); return v(var.build<pLMNAreaBased_t>());
4824                 }
4825                 return false;
4826
4827         }
4828         template<typename V> bool encode(V& v) const
4829         {
4830                 switch(get_index())
4831                 {
4832                 case 1: return v(var.as<cellBased_t>());
4833                 case 2: return v(var.as<tABased_t>());
4834                 case 3: return v(var.as<tAIBased_t>());
4835                 case 4: return v(var.as<pLMNAreaBased_t>());
4836                 }
4837                 return false;
4838         }
4839         template<typename V> static inline void enumerate(V& v)
4840         {
4841                 v.template operator()<cellBased_t>(1);
4842                 v.template operator()<tABased_t>(2);
4843                 v.template operator()<tAIBased_t>(3);
4844                 v.template operator()<pLMNAreaBased_t>(4);
4845
4846         }
4847         cellBased_t& select_cellBased() { if(get_index() != 1) { clear(); set_index(1); return var.build<cellBased_t>();} return var.as<cellBased_t>();}
4848         cellBased_t const* get_cellBased() const { if(get_index() == 1) { return &var.as<cellBased_t>();} return nullptr; }
4849         tABased_t& select_tABased() { if(get_index() != 2) { clear(); set_index(2); return var.build<tABased_t>();} return var.as<tABased_t>();}
4850         tABased_t const* get_tABased() const { if(get_index() == 2) { return &var.as<tABased_t>();} return nullptr; }
4851         tAIBased_t& select_tAIBased() { if(get_index() != 3) { clear(); set_index(3); return var.build<tAIBased_t>();} return var.as<tAIBased_t>();}
4852         tAIBased_t const* get_tAIBased() const { if(get_index() == 3) { return &var.as<tAIBased_t>();} return nullptr; }
4853         pLMNAreaBased_t& select_pLMNAreaBased() { if(get_index() != 4) { clear(); set_index(4); return var.build<pLMNAreaBased_t>();} return var.as<pLMNAreaBased_t>();}
4854         pLMNAreaBased_t const* get_pLMNAreaBased() const { if(get_index() == 4) { return &var.as<pLMNAreaBased_t>();} return nullptr; }
4855         private:
4856         void set_index(index_type i) {index = i; base::set();}
4857         union union_type
4858         {
4859                 char dummy1[sizeof(cellBased_t)];
4860                 char dummy2[sizeof(tABased_t)];
4861                 char dummy3[sizeof(tAIBased_t)];
4862                 char dummy4[sizeof(pLMNAreaBased_t)];
4863
4864         };
4865         asn::variant<sizeof(union_type)>        var;
4866         index_type      index {0};
4867 };
4868 /*
4869 FreqBandIndicator ::= INTEGER (1..256, ...)
4870 */
4871
4872 struct FreqBandIndicator : asn::integer<>
4873 {
4874         using constraint_t = asn::constraints<true,asn::span<1, 256>>;
4875         static constexpr const char* name() {return "FreqBandIndicator";}
4876         using parent_t = asn::integer<>;
4877
4878 };
4879
4880 /*
4881 BandInfo-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
4882         ...
4883 }
4884 */
4885
4886 struct BandInfo_ExtIEs
4887 {
4888         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
4889         {
4890                 size_t get_index() const {return type;}
4891                 bool is_unknown() const { return type == 1; }
4892                 void clear() {type = 0;}
4893                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
4894                 template<typename V>  bool decode(V& v)
4895                 {
4896                         clear();
4897                         if(!v(ref_nested())) return false;
4898                         { type = 1; return true;}
4899                         return false;
4900
4901                 }
4902                 template<typename V> bool encode(V& v) const
4903                 {
4904                         return v(ref_nested());
4905
4906                 }
4907                 protected:
4908                 template<typename V>  bool decode(size_t index, V& v)
4909                 {
4910                         clear();
4911                         switch(index)
4912                         {
4913                         case 1: type = 1; return v(ref_nested());
4914                         ref_nested().clear();
4915                         }
4916                         return false;
4917
4918                 }
4919                 template<typename V> bool encode(size_t index, V& v) const
4920                 {
4921                         if(index != type) {return false;} return v(ref_nested());
4922
4923                 }
4924                 private:
4925                 size_t type {0};
4926
4927         };
4928         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
4929         {
4930                 size_t get_index() const {return type;}
4931                 bool is_unknown() const { return type == 1; }
4932                 void clear() {type = 0;}
4933                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
4934                 template<typename V>  bool decode(V& v)
4935                 {
4936                         clear();
4937                         if(!v(ref_nested())) return false;
4938                         { type = 1; return true;}
4939                         return false;
4940
4941                 }
4942                 template<typename V> bool encode(V& v) const
4943                 {
4944                         return v(ref_nested());
4945
4946                 }
4947                 protected:
4948                 template<typename V>  bool decode(size_t index, V& v)
4949                 {
4950                         clear();
4951                         switch(index)
4952                         {
4953                         case 1: type = 1; return v(ref_nested());
4954                         ref_nested().clear();
4955                         }
4956                         return false;
4957
4958                 }
4959                 template<typename V> bool encode(size_t index, V& v) const
4960                 {
4961                         if(index != type) {return false;} return v(ref_nested());
4962
4963                 }
4964                 private:
4965                 size_t type {0};
4966
4967         };
4968         struct Extension_t : asn::typefield<true>
4969         {
4970                 ~Extension_t()  {clear();}
4971                 size_t get_index() const {return type;}
4972                 bool is_unknown() const { return type == 1; }
4973                 void clear()
4974                 {
4975                         type = 0; ref_nested().clear();
4976                 }
4977                 template<typename V> static inline void enumerate(V& v)
4978                 {
4979
4980                 }
4981                 protected:
4982                 template<typename V> bool decode(size_t index, V& v)
4983                 {
4984                         clear();
4985                         switch(index)
4986                         {
4987                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
4988                         }
4989                         return false;
4990
4991                 }
4992                 template<typename V> bool encode(size_t index, V& v) const
4993                 {
4994                         if(index != type) return false;
4995                         return false;
4996
4997                 }
4998                 private:
4999                 size_t type {0};
5000
5001         };
5002         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
5003         {
5004                 size_t get_index() const {return type;}
5005                 bool is_unknown() const { return type == 1; }
5006                 void clear() {type = 0;}
5007                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
5008                 template<typename V>  bool decode(V& v)
5009                 {
5010                         clear();
5011                         if(!v(ref_nested())) return false;
5012                         { type = 1; return true;}
5013                         return false;
5014
5015                 }
5016                 template<typename V> bool encode(V& v) const
5017                 {
5018                         return v(ref_nested());
5019
5020                 }
5021                 protected:
5022                 template<typename V>  bool decode(size_t index, V& v)
5023                 {
5024                         clear();
5025                         switch(index)
5026                         {
5027                         case 1: type = 1; return v(ref_nested());
5028                         ref_nested().clear();
5029                         }
5030                         return false;
5031
5032                 }
5033                 template<typename V> bool encode(size_t index, V& v) const
5034                 {
5035                         if(index != type) {return false;} return v(ref_nested());
5036
5037                 }
5038                 private:
5039                 size_t type {0};
5040
5041         };
5042
5043 };
5044 /*
5045 BandInfo        ::= SEQUENCE {
5046         freqBandIndicator               FreqBandIndicator,
5047         iE-Extensions                   ProtocolExtensionContainer { {BandInfo-ExtIEs} }        OPTIONAL,
5048         ...
5049 }
5050 */
5051
5052 struct BandInfo : asn::sequence<2, 0, true, 1>
5053 {
5054         static constexpr const char* name() {return "BandInfo";}
5055         using parent_t = asn::sequence<2, 0, true, 1>;
5056         struct freqBandIndicator_t : FreqBandIndicator
5057         {
5058                 static constexpr const char* name() {return "freqBandIndicator_t";}
5059                 using parent_t = FreqBandIndicator;
5060
5061         };
5062         freqBandIndicator_t& ref_freqBandIndicator() {return freqBandIndicator;}
5063         freqBandIndicator_t const& ref_freqBandIndicator() const {return freqBandIndicator;}
5064         struct iE_Extensions_t : ProtocolExtensionContainer<BandInfo_ExtIEs>
5065         {
5066                 static constexpr const char* name() {return "iE_Extensions_t";}
5067                 using parent_t = ProtocolExtensionContainer<BandInfo_ExtIEs>;
5068                 static constexpr bool optional = true;
5069
5070         };
5071         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
5072         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
5073         template<typename V> void decode(V& v)
5074         {
5075                 v(freqBandIndicator);
5076                 v(iE_Extensions);
5077
5078         };
5079         template<typename V> void encode(V& v) const
5080         {
5081                 v(freqBandIndicator);
5082                 v(iE_Extensions);
5083
5084         };
5085         void clear()
5086         {
5087                 freqBandIndicator.clear();
5088                 iE_Extensions.clear();
5089
5090         };
5091         private:
5092         freqBandIndicator_t     freqBandIndicator;
5093         iE_Extensions_t iE_Extensions;
5094
5095 };
5096 /*
5097 BandwidthReducedSI::= ENUMERATED {
5098         scheduled,
5099         ...
5100 }
5101 */
5102
5103 struct BandwidthReducedSI : asn::enumerated<1, 0, true>
5104 {
5105         static constexpr const char* name() {return "BandwidthReducedSI";}
5106         using parent_t = asn::enumerated<1, 0, true>;
5107         typedef enum {
5108                 scheduled
5109         } index_t;
5110
5111 };
5112
5113 /*
5114 BearerType ::= ENUMERATED {
5115         non-IP,
5116         ...
5117 }
5118 */
5119
5120 struct BearerType : asn::enumerated<1, 0, true>
5121 {
5122         static constexpr const char* name() {return "BearerType";}
5123         using parent_t = asn::enumerated<1, 0, true>;
5124         typedef enum {
5125                 non_IP
5126         } index_t;
5127
5128 };
5129
5130 /*
5131 BenefitMetric ::= INTEGER (-101..100, ...)
5132 */
5133
5134 struct BenefitMetric : asn::integer<>
5135 {
5136         using constraint_t = asn::constraints<true,asn::span<-101, 100>>;
5137         static constexpr const char* name() {return "BenefitMetric";}
5138         using parent_t = asn::integer<>;
5139
5140 };
5141
5142 /*
5143 BitRate ::= INTEGER (0..10000000000)
5144 */
5145
5146 struct BitRate : asn::integer<>
5147 {
5148         using constraint_t = asn::constraints<false,asn::span<0, 10000000000>>;
5149         static constexpr const char* name() {return "BitRate";}
5150         using parent_t = asn::integer<>;
5151
5152 };
5153
5154 /*
5155 BluetoothMeasConfig::= ENUMERATED {setup,...}
5156 */
5157
5158 struct BluetoothMeasConfig : asn::enumerated<1, 0, true>
5159 {
5160         static constexpr const char* name() {return "BluetoothMeasConfig";}
5161         using parent_t = asn::enumerated<1, 0, true>;
5162         typedef enum {
5163                 setup
5164         } index_t;
5165
5166 };
5167
5168 /*
5169 BluetoothName ::= OCTET STRING (SIZE (1..248))
5170 */
5171
5172 struct BluetoothName : asn::ostring<>
5173 {
5174         using constraint_t = asn::constraints<false,asn::span<1, 248>>;
5175         static constexpr const char* name() {return "BluetoothName";}
5176         using parent_t = asn::ostring<>;
5177
5178 };
5179
5180 /*
5181 BluetoothMeasConfigNameList ::= SEQUENCE (SIZE(1..maxnoofBluetoothName)) OF BluetoothName
5182 */
5183
5184 struct BluetoothMeasConfigNameList_elm : BluetoothName
5185 {
5186         static constexpr const char* name() {return "BluetoothMeasConfigNameList_elm";}
5187         using parent_t = BluetoothName;
5188
5189 };
5190 struct BluetoothMeasConfigNameList : asn::sequenceof<BluetoothMeasConfigNameList_elm>
5191 {
5192         static constexpr const char* name() {return "BluetoothMeasConfigNameList";}
5193         using parent_t = asn::sequenceof<BluetoothMeasConfigNameList_elm>;
5194         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBluetoothName >>;
5195
5196 };
5197 /*
5198 BluetoothMeasurementConfiguration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
5199         ...
5200 }
5201 */
5202
5203 struct BluetoothMeasurementConfiguration_ExtIEs
5204 {
5205         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
5206         {
5207                 size_t get_index() const {return type;}
5208                 bool is_unknown() const { return type == 1; }
5209                 void clear() {type = 0;}
5210                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
5211                 template<typename V>  bool decode(V& v)
5212                 {
5213                         clear();
5214                         if(!v(ref_nested())) return false;
5215                         { type = 1; return true;}
5216                         return false;
5217
5218                 }
5219                 template<typename V> bool encode(V& v) const
5220                 {
5221                         return v(ref_nested());
5222
5223                 }
5224                 protected:
5225                 template<typename V>  bool decode(size_t index, V& v)
5226                 {
5227                         clear();
5228                         switch(index)
5229                         {
5230                         case 1: type = 1; return v(ref_nested());
5231                         ref_nested().clear();
5232                         }
5233                         return false;
5234
5235                 }
5236                 template<typename V> bool encode(size_t index, V& v) const
5237                 {
5238                         if(index != type) {return false;} return v(ref_nested());
5239
5240                 }
5241                 private:
5242                 size_t type {0};
5243
5244         };
5245         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
5246         {
5247                 size_t get_index() const {return type;}
5248                 bool is_unknown() const { return type == 1; }
5249                 void clear() {type = 0;}
5250                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
5251                 template<typename V>  bool decode(V& v)
5252                 {
5253                         clear();
5254                         if(!v(ref_nested())) return false;
5255                         { type = 1; return true;}
5256                         return false;
5257
5258                 }
5259                 template<typename V> bool encode(V& v) const
5260                 {
5261                         return v(ref_nested());
5262
5263                 }
5264                 protected:
5265                 template<typename V>  bool decode(size_t index, V& v)
5266                 {
5267                         clear();
5268                         switch(index)
5269                         {
5270                         case 1: type = 1; return v(ref_nested());
5271                         ref_nested().clear();
5272                         }
5273                         return false;
5274
5275                 }
5276                 template<typename V> bool encode(size_t index, V& v) const
5277                 {
5278                         if(index != type) {return false;} return v(ref_nested());
5279
5280                 }
5281                 private:
5282                 size_t type {0};
5283
5284         };
5285         struct Extension_t : asn::typefield<true>
5286         {
5287                 ~Extension_t()  {clear();}
5288                 size_t get_index() const {return type;}
5289                 bool is_unknown() const { return type == 1; }
5290                 void clear()
5291                 {
5292                         type = 0; ref_nested().clear();
5293                 }
5294                 template<typename V> static inline void enumerate(V& v)
5295                 {
5296
5297                 }
5298                 protected:
5299                 template<typename V> bool decode(size_t index, V& v)
5300                 {
5301                         clear();
5302                         switch(index)
5303                         {
5304                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
5305                         }
5306                         return false;
5307
5308                 }
5309                 template<typename V> bool encode(size_t index, V& v) const
5310                 {
5311                         if(index != type) return false;
5312                         return false;
5313
5314                 }
5315                 private:
5316                 size_t type {0};
5317
5318         };
5319         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
5320         {
5321                 size_t get_index() const {return type;}
5322                 bool is_unknown() const { return type == 1; }
5323                 void clear() {type = 0;}
5324                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
5325                 template<typename V>  bool decode(V& v)
5326                 {
5327                         clear();
5328                         if(!v(ref_nested())) return false;
5329                         { type = 1; return true;}
5330                         return false;
5331
5332                 }
5333                 template<typename V> bool encode(V& v) const
5334                 {
5335                         return v(ref_nested());
5336
5337                 }
5338                 protected:
5339                 template<typename V>  bool decode(size_t index, V& v)
5340                 {
5341                         clear();
5342                         switch(index)
5343                         {
5344                         case 1: type = 1; return v(ref_nested());
5345                         ref_nested().clear();
5346                         }
5347                         return false;
5348
5349                 }
5350                 template<typename V> bool encode(size_t index, V& v) const
5351                 {
5352                         if(index != type) {return false;} return v(ref_nested());
5353
5354                 }
5355                 private:
5356                 size_t type {0};
5357
5358         };
5359
5360 };
5361 /*
5362 BluetoothMeasurementConfiguration ::= SEQUENCE {
5363         bluetoothMeasConfig                             BluetoothMeasConfig,
5364         bluetoothMeasConfigNameList             BluetoothMeasConfigNameList                     OPTIONAL,
5365         bt-rssi                                                 ENUMERATED {true, ...}                          OPTIONAL,
5366         iE-Extensions           ProtocolExtensionContainer { {BluetoothMeasurementConfiguration-ExtIEs} } OPTIONAL,
5367         ...
5368 }
5369 */
5370
5371 struct BluetoothMeasurementConfiguration : asn::sequence<4, 0, true, 3>
5372 {
5373         static constexpr const char* name() {return "BluetoothMeasurementConfiguration";}
5374         using parent_t = asn::sequence<4, 0, true, 3>;
5375         struct bluetoothMeasConfig_t : BluetoothMeasConfig
5376         {
5377                 static constexpr const char* name() {return "bluetoothMeasConfig_t";}
5378                 using parent_t = BluetoothMeasConfig;
5379
5380         };
5381         bluetoothMeasConfig_t& ref_bluetoothMeasConfig() {return bluetoothMeasConfig;}
5382         bluetoothMeasConfig_t const& ref_bluetoothMeasConfig() const {return bluetoothMeasConfig;}
5383         struct bluetoothMeasConfigNameList_t : BluetoothMeasConfigNameList
5384         {
5385                 static constexpr const char* name() {return "bluetoothMeasConfigNameList_t";}
5386                 using parent_t = BluetoothMeasConfigNameList;
5387                 static constexpr bool optional = true;
5388
5389         };
5390         bluetoothMeasConfigNameList_t& set_bluetoothMeasConfigNameList() { bluetoothMeasConfigNameList.setpresent(true); return bluetoothMeasConfigNameList;}
5391         bluetoothMeasConfigNameList_t const* get_bluetoothMeasConfigNameList() const {return bluetoothMeasConfigNameList.is_valid() ? &bluetoothMeasConfigNameList : nullptr;}
5392         struct bt_rssi_t : asn::enumerated<1, 0, true>
5393         {
5394                 static constexpr const char* name() {return "bt_rssi_t";}
5395                 using parent_t = asn::enumerated<1, 0, true>;
5396                 static constexpr bool optional = true;
5397                 typedef enum {
5398                         True
5399                 } index_t;
5400
5401         };
5402
5403         bt_rssi_t& set_bt_rssi() { bt_rssi.setpresent(true); return bt_rssi;}
5404         bt_rssi_t const* get_bt_rssi() const {return bt_rssi.is_valid() ? &bt_rssi : nullptr;}
5405         struct iE_Extensions_t : ProtocolExtensionContainer<BluetoothMeasurementConfiguration_ExtIEs>
5406         {
5407                 static constexpr const char* name() {return "iE_Extensions_t";}
5408                 using parent_t = ProtocolExtensionContainer<BluetoothMeasurementConfiguration_ExtIEs>;
5409                 static constexpr bool optional = true;
5410
5411         };
5412         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
5413         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
5414         template<typename V> void decode(V& v)
5415         {
5416                 v(bluetoothMeasConfig);
5417                 v(bluetoothMeasConfigNameList);
5418                 v(bt_rssi);
5419                 v(iE_Extensions);
5420
5421         };
5422         template<typename V> void encode(V& v) const
5423         {
5424                 v(bluetoothMeasConfig);
5425                 v(bluetoothMeasConfigNameList);
5426                 v(bt_rssi);
5427                 v(iE_Extensions);
5428
5429         };
5430         void clear()
5431         {
5432                 bluetoothMeasConfig.clear();
5433                 bluetoothMeasConfigNameList.clear();
5434                 bt_rssi.clear();
5435                 iE_Extensions.clear();
5436
5437         };
5438         private:
5439         bluetoothMeasConfig_t   bluetoothMeasConfig;
5440         bluetoothMeasConfigNameList_t   bluetoothMeasConfigNameList;
5441         bt_rssi_t       bt_rssi;
5442         iE_Extensions_t iE_Extensions;
5443
5444 };
5445 /*
5446 BroadcastPLMNs-Item ::= SEQUENCE (SIZE(1..maxnoofBPLMNs)) OF PLMN-Identity
5447 */
5448
5449 struct BroadcastPLMNs_Item_elm : PLMN_Identity
5450 {
5451         static constexpr const char* name() {return "BroadcastPLMNs_Item_elm";}
5452         using parent_t = PLMN_Identity;
5453
5454 };
5455 struct BroadcastPLMNs_Item : asn::sequenceof<BroadcastPLMNs_Item_elm>
5456 {
5457         static constexpr const char* name() {return "BroadcastPLMNs-Item";}
5458         using parent_t = asn::sequenceof<BroadcastPLMNs_Item_elm>;
5459         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBPLMNs >>;
5460
5461 };
5462 /*
5463 CNTypeRestrictionsItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
5464         ...
5465 }
5466 */
5467
5468 struct CNTypeRestrictionsItem_ExtIEs
5469 {
5470         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
5471         {
5472                 size_t get_index() const {return type;}
5473                 bool is_unknown() const { return type == 1; }
5474                 void clear() {type = 0;}
5475                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
5476                 template<typename V>  bool decode(V& v)
5477                 {
5478                         clear();
5479                         if(!v(ref_nested())) return false;
5480                         { type = 1; return true;}
5481                         return false;
5482
5483                 }
5484                 template<typename V> bool encode(V& v) const
5485                 {
5486                         return v(ref_nested());
5487
5488                 }
5489                 protected:
5490                 template<typename V>  bool decode(size_t index, V& v)
5491                 {
5492                         clear();
5493                         switch(index)
5494                         {
5495                         case 1: type = 1; return v(ref_nested());
5496                         ref_nested().clear();
5497                         }
5498                         return false;
5499
5500                 }
5501                 template<typename V> bool encode(size_t index, V& v) const
5502                 {
5503                         if(index != type) {return false;} return v(ref_nested());
5504
5505                 }
5506                 private:
5507                 size_t type {0};
5508
5509         };
5510         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
5511         {
5512                 size_t get_index() const {return type;}
5513                 bool is_unknown() const { return type == 1; }
5514                 void clear() {type = 0;}
5515                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
5516                 template<typename V>  bool decode(V& v)
5517                 {
5518                         clear();
5519                         if(!v(ref_nested())) return false;
5520                         { type = 1; return true;}
5521                         return false;
5522
5523                 }
5524                 template<typename V> bool encode(V& v) const
5525                 {
5526                         return v(ref_nested());
5527
5528                 }
5529                 protected:
5530                 template<typename V>  bool decode(size_t index, V& v)
5531                 {
5532                         clear();
5533                         switch(index)
5534                         {
5535                         case 1: type = 1; return v(ref_nested());
5536                         ref_nested().clear();
5537                         }
5538                         return false;
5539
5540                 }
5541                 template<typename V> bool encode(size_t index, V& v) const
5542                 {
5543                         if(index != type) {return false;} return v(ref_nested());
5544
5545                 }
5546                 private:
5547                 size_t type {0};
5548
5549         };
5550         struct Extension_t : asn::typefield<true>
5551         {
5552                 ~Extension_t()  {clear();}
5553                 size_t get_index() const {return type;}
5554                 bool is_unknown() const { return type == 1; }
5555                 void clear()
5556                 {
5557                         type = 0; ref_nested().clear();
5558                 }
5559                 template<typename V> static inline void enumerate(V& v)
5560                 {
5561
5562                 }
5563                 protected:
5564                 template<typename V> bool decode(size_t index, V& v)
5565                 {
5566                         clear();
5567                         switch(index)
5568                         {
5569                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
5570                         }
5571                         return false;
5572
5573                 }
5574                 template<typename V> bool encode(size_t index, V& v) const
5575                 {
5576                         if(index != type) return false;
5577                         return false;
5578
5579                 }
5580                 private:
5581                 size_t type {0};
5582
5583         };
5584         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
5585         {
5586                 size_t get_index() const {return type;}
5587                 bool is_unknown() const { return type == 1; }
5588                 void clear() {type = 0;}
5589                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
5590                 template<typename V>  bool decode(V& v)
5591                 {
5592                         clear();
5593                         if(!v(ref_nested())) return false;
5594                         { type = 1; return true;}
5595                         return false;
5596
5597                 }
5598                 template<typename V> bool encode(V& v) const
5599                 {
5600                         return v(ref_nested());
5601
5602                 }
5603                 protected:
5604                 template<typename V>  bool decode(size_t index, V& v)
5605                 {
5606                         clear();
5607                         switch(index)
5608                         {
5609                         case 1: type = 1; return v(ref_nested());
5610                         ref_nested().clear();
5611                         }
5612                         return false;
5613
5614                 }
5615                 template<typename V> bool encode(size_t index, V& v) const
5616                 {
5617                         if(index != type) {return false;} return v(ref_nested());
5618
5619                 }
5620                 private:
5621                 size_t type {0};
5622
5623         };
5624
5625 };
5626 /*
5627 CNTypeRestrictionsItem ::= SEQUENCE {
5628         plmn-Id                         PLMN-Identity,
5629         cn-type                         ENUMERATED {fiveGC-forbidden, ...},
5630         iE-Extensions           ProtocolExtensionContainer { {CNTypeRestrictionsItem-ExtIEs} } OPTIONAL,
5631         ...
5632 }
5633 */
5634
5635 struct CNTypeRestrictionsItem : asn::sequence<3, 0, true, 1>
5636 {
5637         static constexpr const char* name() {return "CNTypeRestrictionsItem";}
5638         using parent_t = asn::sequence<3, 0, true, 1>;
5639         struct plmn_Id_t : PLMN_Identity
5640         {
5641                 static constexpr const char* name() {return "plmn_Id_t";}
5642                 using parent_t = PLMN_Identity;
5643
5644         };
5645         plmn_Id_t& ref_plmn_Id() {return plmn_Id;}
5646         plmn_Id_t const& ref_plmn_Id() const {return plmn_Id;}
5647         struct cn_type_t : asn::enumerated<1, 0, true>
5648         {
5649                 static constexpr const char* name() {return "cn_type_t";}
5650                 using parent_t = asn::enumerated<1, 0, true>;
5651                 typedef enum {
5652                         fiveGC_forbidden
5653                 } index_t;
5654
5655         };
5656
5657         cn_type_t& ref_cn_type() {return cn_type;}
5658         cn_type_t const& ref_cn_type() const {return cn_type;}
5659         struct iE_Extensions_t : ProtocolExtensionContainer<CNTypeRestrictionsItem_ExtIEs>
5660         {
5661                 static constexpr const char* name() {return "iE_Extensions_t";}
5662                 using parent_t = ProtocolExtensionContainer<CNTypeRestrictionsItem_ExtIEs>;
5663                 static constexpr bool optional = true;
5664
5665         };
5666         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
5667         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
5668         template<typename V> void decode(V& v)
5669         {
5670                 v(plmn_Id);
5671                 v(cn_type);
5672                 v(iE_Extensions);
5673
5674         };
5675         template<typename V> void encode(V& v) const
5676         {
5677                 v(plmn_Id);
5678                 v(cn_type);
5679                 v(iE_Extensions);
5680
5681         };
5682         void clear()
5683         {
5684                 plmn_Id.clear();
5685                 cn_type.clear();
5686                 iE_Extensions.clear();
5687
5688         };
5689         private:
5690         plmn_Id_t       plmn_Id;
5691         cn_type_t       cn_type;
5692         iE_Extensions_t iE_Extensions;
5693
5694 };
5695 /*
5696 CNTypeRestrictions ::= SEQUENCE (SIZE(1.. maxnoofEPLMNsPlusOne)) OF CNTypeRestrictionsItem
5697 */
5698
5699 struct CNTypeRestrictions_elm : CNTypeRestrictionsItem
5700 {
5701         static constexpr const char* name() {return "CNTypeRestrictions_elm";}
5702         using parent_t = CNTypeRestrictionsItem;
5703
5704 };
5705 struct CNTypeRestrictions : asn::sequenceof<CNTypeRestrictions_elm>
5706 {
5707         static constexpr const char* name() {return "CNTypeRestrictions";}
5708         using parent_t = asn::sequenceof<CNTypeRestrictions_elm>;
5709         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofEPLMNsPlusOne >>;
5710
5711 };
5712 /*
5713 PDCP-SNExtended ::= INTEGER (0..32767)
5714 */
5715
5716 struct PDCP_SNExtended : asn::integer<>
5717 {
5718         using constraint_t = asn::constraints<false,asn::span<0, 32767>>;
5719         static constexpr const char* name() {return "PDCP-SNExtended";}
5720         using parent_t = asn::integer<>;
5721
5722 };
5723
5724 /*
5725 HFNModified ::= INTEGER (0..131071)
5726 */
5727
5728 struct HFNModified : asn::integer<>
5729 {
5730         using constraint_t = asn::constraints<false,asn::span<0, 131071>>;
5731         static constexpr const char* name() {return "HFNModified";}
5732         using parent_t = asn::integer<>;
5733
5734 };
5735
5736 /*
5737 COUNTValueExtended-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
5738         ...
5739 }
5740 */
5741
5742 struct COUNTValueExtended_ExtIEs
5743 {
5744         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
5745         {
5746                 size_t get_index() const {return type;}
5747                 bool is_unknown() const { return type == 1; }
5748                 void clear() {type = 0;}
5749                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
5750                 template<typename V>  bool decode(V& v)
5751                 {
5752                         clear();
5753                         if(!v(ref_nested())) return false;
5754                         { type = 1; return true;}
5755                         return false;
5756
5757                 }
5758                 template<typename V> bool encode(V& v) const
5759                 {
5760                         return v(ref_nested());
5761
5762                 }
5763                 protected:
5764                 template<typename V>  bool decode(size_t index, V& v)
5765                 {
5766                         clear();
5767                         switch(index)
5768                         {
5769                         case 1: type = 1; return v(ref_nested());
5770                         ref_nested().clear();
5771                         }
5772                         return false;
5773
5774                 }
5775                 template<typename V> bool encode(size_t index, V& v) const
5776                 {
5777                         if(index != type) {return false;} return v(ref_nested());
5778
5779                 }
5780                 private:
5781                 size_t type {0};
5782
5783         };
5784         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
5785         {
5786                 size_t get_index() const {return type;}
5787                 bool is_unknown() const { return type == 1; }
5788                 void clear() {type = 0;}
5789                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
5790                 template<typename V>  bool decode(V& v)
5791                 {
5792                         clear();
5793                         if(!v(ref_nested())) return false;
5794                         { type = 1; return true;}
5795                         return false;
5796
5797                 }
5798                 template<typename V> bool encode(V& v) const
5799                 {
5800                         return v(ref_nested());
5801
5802                 }
5803                 protected:
5804                 template<typename V>  bool decode(size_t index, V& v)
5805                 {
5806                         clear();
5807                         switch(index)
5808                         {
5809                         case 1: type = 1; return v(ref_nested());
5810                         ref_nested().clear();
5811                         }
5812                         return false;
5813
5814                 }
5815                 template<typename V> bool encode(size_t index, V& v) const
5816                 {
5817                         if(index != type) {return false;} return v(ref_nested());
5818
5819                 }
5820                 private:
5821                 size_t type {0};
5822
5823         };
5824         struct Extension_t : asn::typefield<true>
5825         {
5826                 ~Extension_t()  {clear();}
5827                 size_t get_index() const {return type;}
5828                 bool is_unknown() const { return type == 1; }
5829                 void clear()
5830                 {
5831                         type = 0; ref_nested().clear();
5832                 }
5833                 template<typename V> static inline void enumerate(V& v)
5834                 {
5835
5836                 }
5837                 protected:
5838                 template<typename V> bool decode(size_t index, V& v)
5839                 {
5840                         clear();
5841                         switch(index)
5842                         {
5843                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
5844                         }
5845                         return false;
5846
5847                 }
5848                 template<typename V> bool encode(size_t index, V& v) const
5849                 {
5850                         if(index != type) return false;
5851                         return false;
5852
5853                 }
5854                 private:
5855                 size_t type {0};
5856
5857         };
5858         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
5859         {
5860                 size_t get_index() const {return type;}
5861                 bool is_unknown() const { return type == 1; }
5862                 void clear() {type = 0;}
5863                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
5864                 template<typename V>  bool decode(V& v)
5865                 {
5866                         clear();
5867                         if(!v(ref_nested())) return false;
5868                         { type = 1; return true;}
5869                         return false;
5870
5871                 }
5872                 template<typename V> bool encode(V& v) const
5873                 {
5874                         return v(ref_nested());
5875
5876                 }
5877                 protected:
5878                 template<typename V>  bool decode(size_t index, V& v)
5879                 {
5880                         clear();
5881                         switch(index)
5882                         {
5883                         case 1: type = 1; return v(ref_nested());
5884                         ref_nested().clear();
5885                         }
5886                         return false;
5887
5888                 }
5889                 template<typename V> bool encode(size_t index, V& v) const
5890                 {
5891                         if(index != type) {return false;} return v(ref_nested());
5892
5893                 }
5894                 private:
5895                 size_t type {0};
5896
5897         };
5898
5899 };
5900 /*
5901 COUNTValueExtended ::= SEQUENCE {
5902         pDCP-SNExtended                 PDCP-SNExtended,
5903         hFNModified                             HFNModified,
5904         iE-Extensions                   ProtocolExtensionContainer { {COUNTValueExtended-ExtIEs} } OPTIONAL,
5905         ...
5906 }
5907 */
5908
5909 struct COUNTValueExtended : asn::sequence<3, 0, true, 1>
5910 {
5911         static constexpr const char* name() {return "COUNTValueExtended";}
5912         using parent_t = asn::sequence<3, 0, true, 1>;
5913         struct pDCP_SNExtended_t : PDCP_SNExtended
5914         {
5915                 static constexpr const char* name() {return "pDCP_SNExtended_t";}
5916                 using parent_t = PDCP_SNExtended;
5917
5918         };
5919         pDCP_SNExtended_t& ref_pDCP_SNExtended() {return pDCP_SNExtended;}
5920         pDCP_SNExtended_t const& ref_pDCP_SNExtended() const {return pDCP_SNExtended;}
5921         struct hFNModified_t : HFNModified
5922         {
5923                 static constexpr const char* name() {return "hFNModified_t";}
5924                 using parent_t = HFNModified;
5925
5926         };
5927         hFNModified_t& ref_hFNModified() {return hFNModified;}
5928         hFNModified_t const& ref_hFNModified() const {return hFNModified;}
5929         struct iE_Extensions_t : ProtocolExtensionContainer<COUNTValueExtended_ExtIEs>
5930         {
5931                 static constexpr const char* name() {return "iE_Extensions_t";}
5932                 using parent_t = ProtocolExtensionContainer<COUNTValueExtended_ExtIEs>;
5933                 static constexpr bool optional = true;
5934
5935         };
5936         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
5937         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
5938         template<typename V> void decode(V& v)
5939         {
5940                 v(pDCP_SNExtended);
5941                 v(hFNModified);
5942                 v(iE_Extensions);
5943
5944         };
5945         template<typename V> void encode(V& v) const
5946         {
5947                 v(pDCP_SNExtended);
5948                 v(hFNModified);
5949                 v(iE_Extensions);
5950
5951         };
5952         void clear()
5953         {
5954                 pDCP_SNExtended.clear();
5955                 hFNModified.clear();
5956                 iE_Extensions.clear();
5957
5958         };
5959         private:
5960         pDCP_SNExtended_t       pDCP_SNExtended;
5961         hFNModified_t   hFNModified;
5962         iE_Extensions_t iE_Extensions;
5963
5964 };
5965 /*
5966 PDCP-SN ::= INTEGER (0..4095)
5967 */
5968
5969 struct PDCP_SN : asn::integer<>
5970 {
5971         using constraint_t = asn::constraints<false,asn::span<0, 4095>>;
5972         static constexpr const char* name() {return "PDCP-SN";}
5973         using parent_t = asn::integer<>;
5974
5975 };
5976
5977 /*
5978 HFN ::= INTEGER (0..1048575)
5979 */
5980
5981 struct HFN : asn::integer<>
5982 {
5983         using constraint_t = asn::constraints<false,asn::span<0, 1048575>>;
5984         static constexpr const char* name() {return "HFN";}
5985         using parent_t = asn::integer<>;
5986
5987 };
5988
5989 /*
5990 COUNTvalue-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
5991         ...
5992 }
5993 */
5994
5995 struct COUNTvalue_ExtIEs
5996 {
5997         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
5998         {
5999                 size_t get_index() const {return type;}
6000                 bool is_unknown() const { return type == 1; }
6001                 void clear() {type = 0;}
6002                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
6003                 template<typename V>  bool decode(V& v)
6004                 {
6005                         clear();
6006                         if(!v(ref_nested())) return false;
6007                         { type = 1; return true;}
6008                         return false;
6009
6010                 }
6011                 template<typename V> bool encode(V& v) const
6012                 {
6013                         return v(ref_nested());
6014
6015                 }
6016                 protected:
6017                 template<typename V>  bool decode(size_t index, V& v)
6018                 {
6019                         clear();
6020                         switch(index)
6021                         {
6022                         case 1: type = 1; return v(ref_nested());
6023                         ref_nested().clear();
6024                         }
6025                         return false;
6026
6027                 }
6028                 template<typename V> bool encode(size_t index, V& v) const
6029                 {
6030                         if(index != type) {return false;} return v(ref_nested());
6031
6032                 }
6033                 private:
6034                 size_t type {0};
6035
6036         };
6037         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
6038         {
6039                 size_t get_index() const {return type;}
6040                 bool is_unknown() const { return type == 1; }
6041                 void clear() {type = 0;}
6042                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
6043                 template<typename V>  bool decode(V& v)
6044                 {
6045                         clear();
6046                         if(!v(ref_nested())) return false;
6047                         { type = 1; return true;}
6048                         return false;
6049
6050                 }
6051                 template<typename V> bool encode(V& v) const
6052                 {
6053                         return v(ref_nested());
6054
6055                 }
6056                 protected:
6057                 template<typename V>  bool decode(size_t index, V& v)
6058                 {
6059                         clear();
6060                         switch(index)
6061                         {
6062                         case 1: type = 1; return v(ref_nested());
6063                         ref_nested().clear();
6064                         }
6065                         return false;
6066
6067                 }
6068                 template<typename V> bool encode(size_t index, V& v) const
6069                 {
6070                         if(index != type) {return false;} return v(ref_nested());
6071
6072                 }
6073                 private:
6074                 size_t type {0};
6075
6076         };
6077         struct Extension_t : asn::typefield<true>
6078         {
6079                 ~Extension_t()  {clear();}
6080                 size_t get_index() const {return type;}
6081                 bool is_unknown() const { return type == 1; }
6082                 void clear()
6083                 {
6084                         type = 0; ref_nested().clear();
6085                 }
6086                 template<typename V> static inline void enumerate(V& v)
6087                 {
6088
6089                 }
6090                 protected:
6091                 template<typename V> bool decode(size_t index, V& v)
6092                 {
6093                         clear();
6094                         switch(index)
6095                         {
6096                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
6097                         }
6098                         return false;
6099
6100                 }
6101                 template<typename V> bool encode(size_t index, V& v) const
6102                 {
6103                         if(index != type) return false;
6104                         return false;
6105
6106                 }
6107                 private:
6108                 size_t type {0};
6109
6110         };
6111         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
6112         {
6113                 size_t get_index() const {return type;}
6114                 bool is_unknown() const { return type == 1; }
6115                 void clear() {type = 0;}
6116                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
6117                 template<typename V>  bool decode(V& v)
6118                 {
6119                         clear();
6120                         if(!v(ref_nested())) return false;
6121                         { type = 1; return true;}
6122                         return false;
6123
6124                 }
6125                 template<typename V> bool encode(V& v) const
6126                 {
6127                         return v(ref_nested());
6128
6129                 }
6130                 protected:
6131                 template<typename V>  bool decode(size_t index, V& v)
6132                 {
6133                         clear();
6134                         switch(index)
6135                         {
6136                         case 1: type = 1; return v(ref_nested());
6137                         ref_nested().clear();
6138                         }
6139                         return false;
6140
6141                 }
6142                 template<typename V> bool encode(size_t index, V& v) const
6143                 {
6144                         if(index != type) {return false;} return v(ref_nested());
6145
6146                 }
6147                 private:
6148                 size_t type {0};
6149
6150         };
6151
6152 };
6153 /*
6154 COUNTvalue ::= SEQUENCE {
6155         pDCP-SN                                 PDCP-SN,
6156         hFN                                             HFN,
6157         iE-Extensions                   ProtocolExtensionContainer { {COUNTvalue-ExtIEs} } OPTIONAL,
6158         ...
6159 }
6160 */
6161
6162 struct COUNTvalue : asn::sequence<3, 0, true, 1>
6163 {
6164         static constexpr const char* name() {return "COUNTvalue";}
6165         using parent_t = asn::sequence<3, 0, true, 1>;
6166         struct pDCP_SN_t : PDCP_SN
6167         {
6168                 static constexpr const char* name() {return "pDCP_SN_t";}
6169                 using parent_t = PDCP_SN;
6170
6171         };
6172         pDCP_SN_t& ref_pDCP_SN() {return pDCP_SN;}
6173         pDCP_SN_t const& ref_pDCP_SN() const {return pDCP_SN;}
6174         struct hFN_t : HFN
6175         {
6176                 static constexpr const char* name() {return "hFN_t";}
6177                 using parent_t = HFN;
6178
6179         };
6180         hFN_t& ref_hFN() {return hFN;}
6181         hFN_t const& ref_hFN() const {return hFN;}
6182         struct iE_Extensions_t : ProtocolExtensionContainer<COUNTvalue_ExtIEs>
6183         {
6184                 static constexpr const char* name() {return "iE_Extensions_t";}
6185                 using parent_t = ProtocolExtensionContainer<COUNTvalue_ExtIEs>;
6186                 static constexpr bool optional = true;
6187
6188         };
6189         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
6190         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
6191         template<typename V> void decode(V& v)
6192         {
6193                 v(pDCP_SN);
6194                 v(hFN);
6195                 v(iE_Extensions);
6196
6197         };
6198         template<typename V> void encode(V& v) const
6199         {
6200                 v(pDCP_SN);
6201                 v(hFN);
6202                 v(iE_Extensions);
6203
6204         };
6205         void clear()
6206         {
6207                 pDCP_SN.clear();
6208                 hFN.clear();
6209                 iE_Extensions.clear();
6210
6211         };
6212         private:
6213         pDCP_SN_t       pDCP_SN;
6214         hFN_t   hFN;
6215         iE_Extensions_t iE_Extensions;
6216
6217 };
6218 /*
6219 PDCP-SNlength18 ::= INTEGER (0..262143)
6220 */
6221
6222 struct PDCP_SNlength18 : asn::integer<>
6223 {
6224         using constraint_t = asn::constraints<false,asn::span<0, 262143>>;
6225         static constexpr const char* name() {return "PDCP-SNlength18";}
6226         using parent_t = asn::integer<>;
6227
6228 };
6229
6230 /*
6231 HFNforPDCP-SNlength18 ::= INTEGER (0..16383)
6232 */
6233
6234 struct HFNforPDCP_SNlength18 : asn::integer<>
6235 {
6236         using constraint_t = asn::constraints<false,asn::span<0, 16383>>;
6237         static constexpr const char* name() {return "HFNforPDCP-SNlength18";}
6238         using parent_t = asn::integer<>;
6239
6240 };
6241
6242 /*
6243 COUNTvaluePDCP-SNlength18-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
6244         ...
6245 }
6246 */
6247
6248 struct COUNTvaluePDCP_SNlength18_ExtIEs
6249 {
6250         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
6251         {
6252                 size_t get_index() const {return type;}
6253                 bool is_unknown() const { return type == 1; }
6254                 void clear() {type = 0;}
6255                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
6256                 template<typename V>  bool decode(V& v)
6257                 {
6258                         clear();
6259                         if(!v(ref_nested())) return false;
6260                         { type = 1; return true;}
6261                         return false;
6262
6263                 }
6264                 template<typename V> bool encode(V& v) const
6265                 {
6266                         return v(ref_nested());
6267
6268                 }
6269                 protected:
6270                 template<typename V>  bool decode(size_t index, V& v)
6271                 {
6272                         clear();
6273                         switch(index)
6274                         {
6275                         case 1: type = 1; return v(ref_nested());
6276                         ref_nested().clear();
6277                         }
6278                         return false;
6279
6280                 }
6281                 template<typename V> bool encode(size_t index, V& v) const
6282                 {
6283                         if(index != type) {return false;} return v(ref_nested());
6284
6285                 }
6286                 private:
6287                 size_t type {0};
6288
6289         };
6290         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
6291         {
6292                 size_t get_index() const {return type;}
6293                 bool is_unknown() const { return type == 1; }
6294                 void clear() {type = 0;}
6295                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
6296                 template<typename V>  bool decode(V& v)
6297                 {
6298                         clear();
6299                         if(!v(ref_nested())) return false;
6300                         { type = 1; return true;}
6301                         return false;
6302
6303                 }
6304                 template<typename V> bool encode(V& v) const
6305                 {
6306                         return v(ref_nested());
6307
6308                 }
6309                 protected:
6310                 template<typename V>  bool decode(size_t index, V& v)
6311                 {
6312                         clear();
6313                         switch(index)
6314                         {
6315                         case 1: type = 1; return v(ref_nested());
6316                         ref_nested().clear();
6317                         }
6318                         return false;
6319
6320                 }
6321                 template<typename V> bool encode(size_t index, V& v) const
6322                 {
6323                         if(index != type) {return false;} return v(ref_nested());
6324
6325                 }
6326                 private:
6327                 size_t type {0};
6328
6329         };
6330         struct Extension_t : asn::typefield<true>
6331         {
6332                 ~Extension_t()  {clear();}
6333                 size_t get_index() const {return type;}
6334                 bool is_unknown() const { return type == 1; }
6335                 void clear()
6336                 {
6337                         type = 0; ref_nested().clear();
6338                 }
6339                 template<typename V> static inline void enumerate(V& v)
6340                 {
6341
6342                 }
6343                 protected:
6344                 template<typename V> bool decode(size_t index, V& v)
6345                 {
6346                         clear();
6347                         switch(index)
6348                         {
6349                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
6350                         }
6351                         return false;
6352
6353                 }
6354                 template<typename V> bool encode(size_t index, V& v) const
6355                 {
6356                         if(index != type) return false;
6357                         return false;
6358
6359                 }
6360                 private:
6361                 size_t type {0};
6362
6363         };
6364         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
6365         {
6366                 size_t get_index() const {return type;}
6367                 bool is_unknown() const { return type == 1; }
6368                 void clear() {type = 0;}
6369                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
6370                 template<typename V>  bool decode(V& v)
6371                 {
6372                         clear();
6373                         if(!v(ref_nested())) return false;
6374                         { type = 1; return true;}
6375                         return false;
6376
6377                 }
6378                 template<typename V> bool encode(V& v) const
6379                 {
6380                         return v(ref_nested());
6381
6382                 }
6383                 protected:
6384                 template<typename V>  bool decode(size_t index, V& v)
6385                 {
6386                         clear();
6387                         switch(index)
6388                         {
6389                         case 1: type = 1; return v(ref_nested());
6390                         ref_nested().clear();
6391                         }
6392                         return false;
6393
6394                 }
6395                 template<typename V> bool encode(size_t index, V& v) const
6396                 {
6397                         if(index != type) {return false;} return v(ref_nested());
6398
6399                 }
6400                 private:
6401                 size_t type {0};
6402
6403         };
6404
6405 };
6406 /*
6407 COUNTvaluePDCP-SNlength18 ::= SEQUENCE {
6408         pDCP-SNlength18                 PDCP-SNlength18,
6409         hFNforPDCP-SNlength18   HFNforPDCP-SNlength18,
6410         iE-Extensions                   ProtocolExtensionContainer { {COUNTvaluePDCP-SNlength18-ExtIEs} } OPTIONAL,
6411         ...
6412 }
6413 */
6414
6415 struct COUNTvaluePDCP_SNlength18 : asn::sequence<3, 0, true, 1>
6416 {
6417         static constexpr const char* name() {return "COUNTvaluePDCP-SNlength18";}
6418         using parent_t = asn::sequence<3, 0, true, 1>;
6419         struct pDCP_SNlength18_t : PDCP_SNlength18
6420         {
6421                 static constexpr const char* name() {return "pDCP_SNlength18_t";}
6422                 using parent_t = PDCP_SNlength18;
6423
6424         };
6425         pDCP_SNlength18_t& ref_pDCP_SNlength18() {return pDCP_SNlength18;}
6426         pDCP_SNlength18_t const& ref_pDCP_SNlength18() const {return pDCP_SNlength18;}
6427         struct hFNforPDCP_SNlength18_t : HFNforPDCP_SNlength18
6428         {
6429                 static constexpr const char* name() {return "hFNforPDCP_SNlength18_t";}
6430                 using parent_t = HFNforPDCP_SNlength18;
6431
6432         };
6433         hFNforPDCP_SNlength18_t& ref_hFNforPDCP_SNlength18() {return hFNforPDCP_SNlength18;}
6434         hFNforPDCP_SNlength18_t const& ref_hFNforPDCP_SNlength18() const {return hFNforPDCP_SNlength18;}
6435         struct iE_Extensions_t : ProtocolExtensionContainer<COUNTvaluePDCP_SNlength18_ExtIEs>
6436         {
6437                 static constexpr const char* name() {return "iE_Extensions_t";}
6438                 using parent_t = ProtocolExtensionContainer<COUNTvaluePDCP_SNlength18_ExtIEs>;
6439                 static constexpr bool optional = true;
6440
6441         };
6442         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
6443         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
6444         template<typename V> void decode(V& v)
6445         {
6446                 v(pDCP_SNlength18);
6447                 v(hFNforPDCP_SNlength18);
6448                 v(iE_Extensions);
6449
6450         };
6451         template<typename V> void encode(V& v) const
6452         {
6453                 v(pDCP_SNlength18);
6454                 v(hFNforPDCP_SNlength18);
6455                 v(iE_Extensions);
6456
6457         };
6458         void clear()
6459         {
6460                 pDCP_SNlength18.clear();
6461                 hFNforPDCP_SNlength18.clear();
6462                 iE_Extensions.clear();
6463
6464         };
6465         private:
6466         pDCP_SNlength18_t       pDCP_SNlength18;
6467         hFNforPDCP_SNlength18_t hFNforPDCP_SNlength18;
6468         iE_Extensions_t iE_Extensions;
6469
6470 };
6471 /*
6472 CRNTI ::= BIT STRING (SIZE (16))
6473 */
6474
6475 struct CRNTI : asn::bstring<>
6476 {
6477         using constraint_t = asn::constraints<false,asn::one<16>>;
6478         static constexpr const char* name() {return "CRNTI";}
6479         using parent_t = asn::bstring<>;
6480
6481 };
6482
6483 /*
6484 CSG-Id ::= BIT STRING (SIZE (27))
6485 */
6486
6487 struct CSG_Id : asn::bstring<>
6488 {
6489         using constraint_t = asn::constraints<false,asn::one<27>>;
6490         static constexpr const char* name() {return "CSG-Id";}
6491         using parent_t = asn::bstring<>;
6492
6493 };
6494
6495 /*
6496 CSGMembershipStatus ::= ENUMERATED {
6497         member,
6498         not-member
6499 }
6500 */
6501
6502 struct CSGMembershipStatus : asn::enumerated<2, 0, false>
6503 {
6504         static constexpr const char* name() {return "CSGMembershipStatus";}
6505         using parent_t = asn::enumerated<2, 0, false>;
6506         typedef enum {
6507                 member
6508                 ,not_member
6509         } index_t;
6510
6511 };
6512
6513 /*
6514 UEID ::= BIT STRING (SIZE (16))
6515 */
6516
6517 struct UEID : asn::bstring<>
6518 {
6519         using constraint_t = asn::constraints<false,asn::one<16>>;
6520         static constexpr const char* name() {return "UEID";}
6521         using parent_t = asn::bstring<>;
6522
6523 };
6524
6525 /*
6526 WidebandCQICodeword1::= CHOICE {
6527         four-bitCQI                                                             INTEGER (0..15, ...),
6528         three-bitSpatialDifferentialCQI                 INTEGER (0..7, ...),
6529         ...
6530 }
6531 */
6532
6533 struct WidebandCQICodeword1 : asn::choice<2, 0, true>
6534 {
6535         static constexpr const char* name() {return "WidebandCQICodeword1";}
6536         using parent_t = asn::choice<2, 0, true>;
6537         index_type get_index() const {return index;}
6538         bool is_unknown() const {return index == 3;}
6539         void set_unknown() { set_index(3);  }
6540         ~WidebandCQICodeword1() {clear();}
6541         struct four_bitCQI_t : asn::integer<>
6542         {
6543                 using constraint_t = asn::constraints<true,asn::span<0, 15>>;
6544                 static constexpr const char* name() {return "four_bitCQI_t";}
6545                 using parent_t = asn::integer<>;
6546
6547         };
6548
6549         struct three_bitSpatialDifferentialCQI_t : asn::integer<>
6550         {
6551                 using constraint_t = asn::constraints<true,asn::span<0, 7>>;
6552                 static constexpr const char* name() {return "three_bitSpatialDifferentialCQI_t";}
6553                 using parent_t = asn::integer<>;
6554
6555         };
6556
6557         void clear()
6558         {
6559                 switch(get_index())
6560                 {
6561                 case 1: var.destroy<four_bitCQI_t>(); break;
6562                 case 2: var.destroy<three_bitSpatialDifferentialCQI_t>(); break;
6563                 }
6564                 index = 0;
6565                 base::clear();
6566         }
6567         template<typename V> bool decode(size_t idx, V& v)
6568         {
6569                 clear();
6570                 switch(idx)
6571                 {
6572                 case 1: set_index(1); return v(var.build<four_bitCQI_t>());
6573                 case 2: set_index(2); return v(var.build<three_bitSpatialDifferentialCQI_t>());
6574                 }
6575                 return false;
6576
6577         }
6578         template<typename V> bool encode(V& v) const
6579         {
6580                 switch(get_index())
6581                 {
6582                 case 1: return v(var.as<four_bitCQI_t>());
6583                 case 2: return v(var.as<three_bitSpatialDifferentialCQI_t>());
6584                 }
6585                 return false;
6586         }
6587         template<typename V> static inline void enumerate(V& v)
6588         {
6589                 v.template operator()<four_bitCQI_t>(1);
6590                 v.template operator()<three_bitSpatialDifferentialCQI_t>(2);
6591
6592         }
6593         four_bitCQI_t& select_four_bitCQI() { if(get_index() != 1) { clear(); set_index(1); return var.build<four_bitCQI_t>();} return var.as<four_bitCQI_t>();}
6594         four_bitCQI_t const* get_four_bitCQI() const { if(get_index() == 1) { return &var.as<four_bitCQI_t>();} return nullptr; }
6595         three_bitSpatialDifferentialCQI_t& select_three_bitSpatialDifferentialCQI() { if(get_index() != 2) { clear(); set_index(2); return var.build<three_bitSpatialDifferentialCQI_t>();} return var.as<three_bitSpatialDifferentialCQI_t>();}
6596         three_bitSpatialDifferentialCQI_t const* get_three_bitSpatialDifferentialCQI() const { if(get_index() == 2) { return &var.as<three_bitSpatialDifferentialCQI_t>();} return nullptr; }
6597         private:
6598         void set_index(index_type i) {index = i; base::set();}
6599         union union_type
6600         {
6601                 char dummy1[sizeof(four_bitCQI_t)];
6602                 char dummy2[sizeof(three_bitSpatialDifferentialCQI_t)];
6603
6604         };
6605         asn::variant<sizeof(union_type)>        var;
6606         index_type      index {0};
6607 };
6608 /*
6609 WidebandCQI-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
6610         ...
6611 }
6612 */
6613
6614 struct WidebandCQI_ExtIEs
6615 {
6616         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
6617         {
6618                 size_t get_index() const {return type;}
6619                 bool is_unknown() const { return type == 1; }
6620                 void clear() {type = 0;}
6621                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
6622                 template<typename V>  bool decode(V& v)
6623                 {
6624                         clear();
6625                         if(!v(ref_nested())) return false;
6626                         { type = 1; return true;}
6627                         return false;
6628
6629                 }
6630                 template<typename V> bool encode(V& v) const
6631                 {
6632                         return v(ref_nested());
6633
6634                 }
6635                 protected:
6636                 template<typename V>  bool decode(size_t index, V& v)
6637                 {
6638                         clear();
6639                         switch(index)
6640                         {
6641                         case 1: type = 1; return v(ref_nested());
6642                         ref_nested().clear();
6643                         }
6644                         return false;
6645
6646                 }
6647                 template<typename V> bool encode(size_t index, V& v) const
6648                 {
6649                         if(index != type) {return false;} return v(ref_nested());
6650
6651                 }
6652                 private:
6653                 size_t type {0};
6654
6655         };
6656         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
6657         {
6658                 size_t get_index() const {return type;}
6659                 bool is_unknown() const { return type == 1; }
6660                 void clear() {type = 0;}
6661                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
6662                 template<typename V>  bool decode(V& v)
6663                 {
6664                         clear();
6665                         if(!v(ref_nested())) return false;
6666                         { type = 1; return true;}
6667                         return false;
6668
6669                 }
6670                 template<typename V> bool encode(V& v) const
6671                 {
6672                         return v(ref_nested());
6673
6674                 }
6675                 protected:
6676                 template<typename V>  bool decode(size_t index, V& v)
6677                 {
6678                         clear();
6679                         switch(index)
6680                         {
6681                         case 1: type = 1; return v(ref_nested());
6682                         ref_nested().clear();
6683                         }
6684                         return false;
6685
6686                 }
6687                 template<typename V> bool encode(size_t index, V& v) const
6688                 {
6689                         if(index != type) {return false;} return v(ref_nested());
6690
6691                 }
6692                 private:
6693                 size_t type {0};
6694
6695         };
6696         struct Extension_t : asn::typefield<true>
6697         {
6698                 ~Extension_t()  {clear();}
6699                 size_t get_index() const {return type;}
6700                 bool is_unknown() const { return type == 1; }
6701                 void clear()
6702                 {
6703                         type = 0; ref_nested().clear();
6704                 }
6705                 template<typename V> static inline void enumerate(V& v)
6706                 {
6707
6708                 }
6709                 protected:
6710                 template<typename V> bool decode(size_t index, V& v)
6711                 {
6712                         clear();
6713                         switch(index)
6714                         {
6715                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
6716                         }
6717                         return false;
6718
6719                 }
6720                 template<typename V> bool encode(size_t index, V& v) const
6721                 {
6722                         if(index != type) return false;
6723                         return false;
6724
6725                 }
6726                 private:
6727                 size_t type {0};
6728
6729         };
6730         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
6731         {
6732                 size_t get_index() const {return type;}
6733                 bool is_unknown() const { return type == 1; }
6734                 void clear() {type = 0;}
6735                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
6736                 template<typename V>  bool decode(V& v)
6737                 {
6738                         clear();
6739                         if(!v(ref_nested())) return false;
6740                         { type = 1; return true;}
6741                         return false;
6742
6743                 }
6744                 template<typename V> bool encode(V& v) const
6745                 {
6746                         return v(ref_nested());
6747
6748                 }
6749                 protected:
6750                 template<typename V>  bool decode(size_t index, V& v)
6751                 {
6752                         clear();
6753                         switch(index)
6754                         {
6755                         case 1: type = 1; return v(ref_nested());
6756                         ref_nested().clear();
6757                         }
6758                         return false;
6759
6760                 }
6761                 template<typename V> bool encode(size_t index, V& v) const
6762                 {
6763                         if(index != type) {return false;} return v(ref_nested());
6764
6765                 }
6766                 private:
6767                 size_t type {0};
6768
6769         };
6770
6771 };
6772 /*
6773 WidebandCQI ::= SEQUENCE {
6774         widebandCQICodeword0            INTEGER (0..15, ...),
6775         widebandCQICodeword1            WidebandCQICodeword1            OPTIONAL,
6776         iE-Extensions                           ProtocolExtensionContainer { {WidebandCQI-ExtIEs} } OPTIONAL,
6777         ...
6778 }
6779 */
6780
6781 struct WidebandCQI : asn::sequence<3, 0, true, 2>
6782 {
6783         static constexpr const char* name() {return "WidebandCQI";}
6784         using parent_t = asn::sequence<3, 0, true, 2>;
6785         struct widebandCQICodeword0_t : asn::integer<>
6786         {
6787                 using constraint_t = asn::constraints<true,asn::span<0, 15>>;
6788                 static constexpr const char* name() {return "widebandCQICodeword0_t";}
6789                 using parent_t = asn::integer<>;
6790
6791         };
6792
6793         widebandCQICodeword0_t& ref_widebandCQICodeword0() {return widebandCQICodeword0;}
6794         widebandCQICodeword0_t const& ref_widebandCQICodeword0() const {return widebandCQICodeword0;}
6795         struct widebandCQICodeword1_t : WidebandCQICodeword1
6796         {
6797                 static constexpr const char* name() {return "widebandCQICodeword1_t";}
6798                 using parent_t = WidebandCQICodeword1;
6799                 static constexpr bool optional = true;
6800
6801         };
6802         widebandCQICodeword1_t& set_widebandCQICodeword1() { widebandCQICodeword1.setpresent(true); return widebandCQICodeword1;}
6803         widebandCQICodeword1_t const* get_widebandCQICodeword1() const {return widebandCQICodeword1.is_valid() ? &widebandCQICodeword1 : nullptr;}
6804         struct iE_Extensions_t : ProtocolExtensionContainer<WidebandCQI_ExtIEs>
6805         {
6806                 static constexpr const char* name() {return "iE_Extensions_t";}
6807                 using parent_t = ProtocolExtensionContainer<WidebandCQI_ExtIEs>;
6808                 static constexpr bool optional = true;
6809
6810         };
6811         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
6812         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
6813         template<typename V> void decode(V& v)
6814         {
6815                 v(widebandCQICodeword0);
6816                 v(widebandCQICodeword1);
6817                 v(iE_Extensions);
6818
6819         };
6820         template<typename V> void encode(V& v) const
6821         {
6822                 v(widebandCQICodeword0);
6823                 v(widebandCQICodeword1);
6824                 v(iE_Extensions);
6825
6826         };
6827         void clear()
6828         {
6829                 widebandCQICodeword0.clear();
6830                 widebandCQICodeword1.clear();
6831                 iE_Extensions.clear();
6832
6833         };
6834         private:
6835         widebandCQICodeword0_t  widebandCQICodeword0;
6836         widebandCQICodeword1_t  widebandCQICodeword1;
6837         iE_Extensions_t iE_Extensions;
6838
6839 };
6840 /*
6841 SubbandSize ::= ENUMERATED {
6842         size2,
6843         size3,
6844         size4,
6845         size6,
6846         size8,
6847         ...
6848 }
6849 */
6850
6851 struct SubbandSize : asn::enumerated<5, 0, true>
6852 {
6853         static constexpr const char* name() {return "SubbandSize";}
6854         using parent_t = asn::enumerated<5, 0, true>;
6855         typedef enum {
6856                 size2
6857                 ,size3
6858                 ,size4
6859                 ,size6
6860                 ,size8
6861         } index_t;
6862
6863 };
6864
6865 /*
6866 SubbandCQICodeword0 ::= CHOICE {
6867         four-bitCQI                                             INTEGER (0..15, ...),
6868         two-bitSubbandDifferentialCQI   INTEGER (0..3, ...),
6869         two-bitDifferentialCQI                  INTEGER (0..3, ...),
6870         ...
6871 }
6872 */
6873
6874 struct SubbandCQICodeword0 : asn::choice<3, 0, true>
6875 {
6876         static constexpr const char* name() {return "SubbandCQICodeword0";}
6877         using parent_t = asn::choice<3, 0, true>;
6878         index_type get_index() const {return index;}
6879         bool is_unknown() const {return index == 4;}
6880         void set_unknown() { set_index(4);  }
6881         ~SubbandCQICodeword0() {clear();}
6882         struct four_bitCQI_t : asn::integer<>
6883         {
6884                 using constraint_t = asn::constraints<true,asn::span<0, 15>>;
6885                 static constexpr const char* name() {return "four_bitCQI_t";}
6886                 using parent_t = asn::integer<>;
6887
6888         };
6889
6890         struct two_bitSubbandDifferentialCQI_t : asn::integer<>
6891         {
6892                 using constraint_t = asn::constraints<true,asn::span<0, 3>>;
6893                 static constexpr const char* name() {return "two_bitSubbandDifferentialCQI_t";}
6894                 using parent_t = asn::integer<>;
6895
6896         };
6897
6898         struct two_bitDifferentialCQI_t : asn::integer<>
6899         {
6900                 using constraint_t = asn::constraints<true,asn::span<0, 3>>;
6901                 static constexpr const char* name() {return "two_bitDifferentialCQI_t";}
6902                 using parent_t = asn::integer<>;
6903
6904         };
6905
6906         void clear()
6907         {
6908                 switch(get_index())
6909                 {
6910                 case 1: var.destroy<four_bitCQI_t>(); break;
6911                 case 2: var.destroy<two_bitSubbandDifferentialCQI_t>(); break;
6912                 case 3: var.destroy<two_bitDifferentialCQI_t>(); break;
6913                 }
6914                 index = 0;
6915                 base::clear();
6916         }
6917         template<typename V> bool decode(size_t idx, V& v)
6918         {
6919                 clear();
6920                 switch(idx)
6921                 {
6922                 case 1: set_index(1); return v(var.build<four_bitCQI_t>());
6923                 case 2: set_index(2); return v(var.build<two_bitSubbandDifferentialCQI_t>());
6924                 case 3: set_index(3); return v(var.build<two_bitDifferentialCQI_t>());
6925                 }
6926                 return false;
6927
6928         }
6929         template<typename V> bool encode(V& v) const
6930         {
6931                 switch(get_index())
6932                 {
6933                 case 1: return v(var.as<four_bitCQI_t>());
6934                 case 2: return v(var.as<two_bitSubbandDifferentialCQI_t>());
6935                 case 3: return v(var.as<two_bitDifferentialCQI_t>());
6936                 }
6937                 return false;
6938         }
6939         template<typename V> static inline void enumerate(V& v)
6940         {
6941                 v.template operator()<four_bitCQI_t>(1);
6942                 v.template operator()<two_bitSubbandDifferentialCQI_t>(2);
6943                 v.template operator()<two_bitDifferentialCQI_t>(3);
6944
6945         }
6946         four_bitCQI_t& select_four_bitCQI() { if(get_index() != 1) { clear(); set_index(1); return var.build<four_bitCQI_t>();} return var.as<four_bitCQI_t>();}
6947         four_bitCQI_t const* get_four_bitCQI() const { if(get_index() == 1) { return &var.as<four_bitCQI_t>();} return nullptr; }
6948         two_bitSubbandDifferentialCQI_t& select_two_bitSubbandDifferentialCQI() { if(get_index() != 2) { clear(); set_index(2); return var.build<two_bitSubbandDifferentialCQI_t>();} return var.as<two_bitSubbandDifferentialCQI_t>();}
6949         two_bitSubbandDifferentialCQI_t const* get_two_bitSubbandDifferentialCQI() const { if(get_index() == 2) { return &var.as<two_bitSubbandDifferentialCQI_t>();} return nullptr; }
6950         two_bitDifferentialCQI_t& select_two_bitDifferentialCQI() { if(get_index() != 3) { clear(); set_index(3); return var.build<two_bitDifferentialCQI_t>();} return var.as<two_bitDifferentialCQI_t>();}
6951         two_bitDifferentialCQI_t const* get_two_bitDifferentialCQI() const { if(get_index() == 3) { return &var.as<two_bitDifferentialCQI_t>();} return nullptr; }
6952         private:
6953         void set_index(index_type i) {index = i; base::set();}
6954         union union_type
6955         {
6956                 char dummy1[sizeof(four_bitCQI_t)];
6957                 char dummy2[sizeof(two_bitSubbandDifferentialCQI_t)];
6958                 char dummy3[sizeof(two_bitDifferentialCQI_t)];
6959
6960         };
6961         asn::variant<sizeof(union_type)>        var;
6962         index_type      index {0};
6963 };
6964 /*
6965 SubbandCQICodeword1 ::= CHOICE {
6966         four-bitCQI                                                     INTEGER (0..15, ...),
6967         three-bitSpatialDifferentialCQI         INTEGER (0..7, ...),
6968         two-bitSubbandDifferentialCQI           INTEGER (0..3, ...),
6969         two-bitDifferentialCQI                          INTEGER (0..3, ...),
6970         ...
6971 }
6972 */
6973
6974 struct SubbandCQICodeword1 : asn::choice<4, 0, true>
6975 {
6976         static constexpr const char* name() {return "SubbandCQICodeword1";}
6977         using parent_t = asn::choice<4, 0, true>;
6978         index_type get_index() const {return index;}
6979         bool is_unknown() const {return index == 5;}
6980         void set_unknown() { set_index(5);  }
6981         ~SubbandCQICodeword1() {clear();}
6982         struct four_bitCQI_t : asn::integer<>
6983         {
6984                 using constraint_t = asn::constraints<true,asn::span<0, 15>>;
6985                 static constexpr const char* name() {return "four_bitCQI_t";}
6986                 using parent_t = asn::integer<>;
6987
6988         };
6989
6990         struct three_bitSpatialDifferentialCQI_t : asn::integer<>
6991         {
6992                 using constraint_t = asn::constraints<true,asn::span<0, 7>>;
6993                 static constexpr const char* name() {return "three_bitSpatialDifferentialCQI_t";}
6994                 using parent_t = asn::integer<>;
6995
6996         };
6997
6998         struct two_bitSubbandDifferentialCQI_t : asn::integer<>
6999         {
7000                 using constraint_t = asn::constraints<true,asn::span<0, 3>>;
7001                 static constexpr const char* name() {return "two_bitSubbandDifferentialCQI_t";}
7002                 using parent_t = asn::integer<>;
7003
7004         };
7005
7006         struct two_bitDifferentialCQI_t : asn::integer<>
7007         {
7008                 using constraint_t = asn::constraints<true,asn::span<0, 3>>;
7009                 static constexpr const char* name() {return "two_bitDifferentialCQI_t";}
7010                 using parent_t = asn::integer<>;
7011
7012         };
7013
7014         void clear()
7015         {
7016                 switch(get_index())
7017                 {
7018                 case 1: var.destroy<four_bitCQI_t>(); break;
7019                 case 2: var.destroy<three_bitSpatialDifferentialCQI_t>(); break;
7020                 case 3: var.destroy<two_bitSubbandDifferentialCQI_t>(); break;
7021                 case 4: var.destroy<two_bitDifferentialCQI_t>(); break;
7022                 }
7023                 index = 0;
7024                 base::clear();
7025         }
7026         template<typename V> bool decode(size_t idx, V& v)
7027         {
7028                 clear();
7029                 switch(idx)
7030                 {
7031                 case 1: set_index(1); return v(var.build<four_bitCQI_t>());
7032                 case 2: set_index(2); return v(var.build<three_bitSpatialDifferentialCQI_t>());
7033                 case 3: set_index(3); return v(var.build<two_bitSubbandDifferentialCQI_t>());
7034                 case 4: set_index(4); return v(var.build<two_bitDifferentialCQI_t>());
7035                 }
7036                 return false;
7037
7038         }
7039         template<typename V> bool encode(V& v) const
7040         {
7041                 switch(get_index())
7042                 {
7043                 case 1: return v(var.as<four_bitCQI_t>());
7044                 case 2: return v(var.as<three_bitSpatialDifferentialCQI_t>());
7045                 case 3: return v(var.as<two_bitSubbandDifferentialCQI_t>());
7046                 case 4: return v(var.as<two_bitDifferentialCQI_t>());
7047                 }
7048                 return false;
7049         }
7050         template<typename V> static inline void enumerate(V& v)
7051         {
7052                 v.template operator()<four_bitCQI_t>(1);
7053                 v.template operator()<three_bitSpatialDifferentialCQI_t>(2);
7054                 v.template operator()<two_bitSubbandDifferentialCQI_t>(3);
7055                 v.template operator()<two_bitDifferentialCQI_t>(4);
7056
7057         }
7058         four_bitCQI_t& select_four_bitCQI() { if(get_index() != 1) { clear(); set_index(1); return var.build<four_bitCQI_t>();} return var.as<four_bitCQI_t>();}
7059         four_bitCQI_t const* get_four_bitCQI() const { if(get_index() == 1) { return &var.as<four_bitCQI_t>();} return nullptr; }
7060         three_bitSpatialDifferentialCQI_t& select_three_bitSpatialDifferentialCQI() { if(get_index() != 2) { clear(); set_index(2); return var.build<three_bitSpatialDifferentialCQI_t>();} return var.as<three_bitSpatialDifferentialCQI_t>();}
7061         three_bitSpatialDifferentialCQI_t const* get_three_bitSpatialDifferentialCQI() const { if(get_index() == 2) { return &var.as<three_bitSpatialDifferentialCQI_t>();} return nullptr; }
7062         two_bitSubbandDifferentialCQI_t& select_two_bitSubbandDifferentialCQI() { if(get_index() != 3) { clear(); set_index(3); return var.build<two_bitSubbandDifferentialCQI_t>();} return var.as<two_bitSubbandDifferentialCQI_t>();}
7063         two_bitSubbandDifferentialCQI_t const* get_two_bitSubbandDifferentialCQI() const { if(get_index() == 3) { return &var.as<two_bitSubbandDifferentialCQI_t>();} return nullptr; }
7064         two_bitDifferentialCQI_t& select_two_bitDifferentialCQI() { if(get_index() != 4) { clear(); set_index(4); return var.build<two_bitDifferentialCQI_t>();} return var.as<two_bitDifferentialCQI_t>();}
7065         two_bitDifferentialCQI_t const* get_two_bitDifferentialCQI() const { if(get_index() == 4) { return &var.as<two_bitDifferentialCQI_t>();} return nullptr; }
7066         private:
7067         void set_index(index_type i) {index = i; base::set();}
7068         union union_type
7069         {
7070                 char dummy1[sizeof(four_bitCQI_t)];
7071                 char dummy2[sizeof(three_bitSpatialDifferentialCQI_t)];
7072                 char dummy3[sizeof(two_bitSubbandDifferentialCQI_t)];
7073                 char dummy4[sizeof(two_bitDifferentialCQI_t)];
7074
7075         };
7076         asn::variant<sizeof(union_type)>        var;
7077         index_type      index {0};
7078 };
7079 /*
7080 SubbandCQI-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
7081         ...
7082 }
7083 */
7084
7085 struct SubbandCQI_ExtIEs
7086 {
7087         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
7088         {
7089                 size_t get_index() const {return type;}
7090                 bool is_unknown() const { return type == 1; }
7091                 void clear() {type = 0;}
7092                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
7093                 template<typename V>  bool decode(V& v)
7094                 {
7095                         clear();
7096                         if(!v(ref_nested())) return false;
7097                         { type = 1; return true;}
7098                         return false;
7099
7100                 }
7101                 template<typename V> bool encode(V& v) const
7102                 {
7103                         return v(ref_nested());
7104
7105                 }
7106                 protected:
7107                 template<typename V>  bool decode(size_t index, V& v)
7108                 {
7109                         clear();
7110                         switch(index)
7111                         {
7112                         case 1: type = 1; return v(ref_nested());
7113                         ref_nested().clear();
7114                         }
7115                         return false;
7116
7117                 }
7118                 template<typename V> bool encode(size_t index, V& v) const
7119                 {
7120                         if(index != type) {return false;} return v(ref_nested());
7121
7122                 }
7123                 private:
7124                 size_t type {0};
7125
7126         };
7127         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
7128         {
7129                 size_t get_index() const {return type;}
7130                 bool is_unknown() const { return type == 1; }
7131                 void clear() {type = 0;}
7132                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
7133                 template<typename V>  bool decode(V& v)
7134                 {
7135                         clear();
7136                         if(!v(ref_nested())) return false;
7137                         { type = 1; return true;}
7138                         return false;
7139
7140                 }
7141                 template<typename V> bool encode(V& v) const
7142                 {
7143                         return v(ref_nested());
7144
7145                 }
7146                 protected:
7147                 template<typename V>  bool decode(size_t index, V& v)
7148                 {
7149                         clear();
7150                         switch(index)
7151                         {
7152                         case 1: type = 1; return v(ref_nested());
7153                         ref_nested().clear();
7154                         }
7155                         return false;
7156
7157                 }
7158                 template<typename V> bool encode(size_t index, V& v) const
7159                 {
7160                         if(index != type) {return false;} return v(ref_nested());
7161
7162                 }
7163                 private:
7164                 size_t type {0};
7165
7166         };
7167         struct Extension_t : asn::typefield<true>
7168         {
7169                 ~Extension_t()  {clear();}
7170                 size_t get_index() const {return type;}
7171                 bool is_unknown() const { return type == 1; }
7172                 void clear()
7173                 {
7174                         type = 0; ref_nested().clear();
7175                 }
7176                 template<typename V> static inline void enumerate(V& v)
7177                 {
7178
7179                 }
7180                 protected:
7181                 template<typename V> bool decode(size_t index, V& v)
7182                 {
7183                         clear();
7184                         switch(index)
7185                         {
7186                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
7187                         }
7188                         return false;
7189
7190                 }
7191                 template<typename V> bool encode(size_t index, V& v) const
7192                 {
7193                         if(index != type) return false;
7194                         return false;
7195
7196                 }
7197                 private:
7198                 size_t type {0};
7199
7200         };
7201         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
7202         {
7203                 size_t get_index() const {return type;}
7204                 bool is_unknown() const { return type == 1; }
7205                 void clear() {type = 0;}
7206                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
7207                 template<typename V>  bool decode(V& v)
7208                 {
7209                         clear();
7210                         if(!v(ref_nested())) return false;
7211                         { type = 1; return true;}
7212                         return false;
7213
7214                 }
7215                 template<typename V> bool encode(V& v) const
7216                 {
7217                         return v(ref_nested());
7218
7219                 }
7220                 protected:
7221                 template<typename V>  bool decode(size_t index, V& v)
7222                 {
7223                         clear();
7224                         switch(index)
7225                         {
7226                         case 1: type = 1; return v(ref_nested());
7227                         ref_nested().clear();
7228                         }
7229                         return false;
7230
7231                 }
7232                 template<typename V> bool encode(size_t index, V& v) const
7233                 {
7234                         if(index != type) {return false;} return v(ref_nested());
7235
7236                 }
7237                 private:
7238                 size_t type {0};
7239
7240         };
7241
7242 };
7243 /*
7244 SubbandCQI ::= SEQUENCE {
7245         subbandCQICodeword0                     SubbandCQICodeword0,
7246         subbandCQICodeword1                     SubbandCQICodeword1             OPTIONAL,
7247         iE-Extensions                           ProtocolExtensionContainer { {SubbandCQI-ExtIEs} } OPTIONAL,
7248         ...
7249 }
7250 */
7251
7252 struct SubbandCQI : asn::sequence<3, 0, true, 2>
7253 {
7254         static constexpr const char* name() {return "SubbandCQI";}
7255         using parent_t = asn::sequence<3, 0, true, 2>;
7256         struct subbandCQICodeword0_t : SubbandCQICodeword0
7257         {
7258                 static constexpr const char* name() {return "subbandCQICodeword0_t";}
7259                 using parent_t = SubbandCQICodeword0;
7260
7261         };
7262         subbandCQICodeword0_t& ref_subbandCQICodeword0() {return subbandCQICodeword0;}
7263         subbandCQICodeword0_t const& ref_subbandCQICodeword0() const {return subbandCQICodeword0;}
7264         struct subbandCQICodeword1_t : SubbandCQICodeword1
7265         {
7266                 static constexpr const char* name() {return "subbandCQICodeword1_t";}
7267                 using parent_t = SubbandCQICodeword1;
7268                 static constexpr bool optional = true;
7269
7270         };
7271         subbandCQICodeword1_t& set_subbandCQICodeword1() { subbandCQICodeword1.setpresent(true); return subbandCQICodeword1;}
7272         subbandCQICodeword1_t const* get_subbandCQICodeword1() const {return subbandCQICodeword1.is_valid() ? &subbandCQICodeword1 : nullptr;}
7273         struct iE_Extensions_t : ProtocolExtensionContainer<SubbandCQI_ExtIEs>
7274         {
7275                 static constexpr const char* name() {return "iE_Extensions_t";}
7276                 using parent_t = ProtocolExtensionContainer<SubbandCQI_ExtIEs>;
7277                 static constexpr bool optional = true;
7278
7279         };
7280         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
7281         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
7282         template<typename V> void decode(V& v)
7283         {
7284                 v(subbandCQICodeword0);
7285                 v(subbandCQICodeword1);
7286                 v(iE_Extensions);
7287
7288         };
7289         template<typename V> void encode(V& v) const
7290         {
7291                 v(subbandCQICodeword0);
7292                 v(subbandCQICodeword1);
7293                 v(iE_Extensions);
7294
7295         };
7296         void clear()
7297         {
7298                 subbandCQICodeword0.clear();
7299                 subbandCQICodeword1.clear();
7300                 iE_Extensions.clear();
7301
7302         };
7303         private:
7304         subbandCQICodeword0_t   subbandCQICodeword0;
7305         subbandCQICodeword1_t   subbandCQICodeword1;
7306         iE_Extensions_t iE_Extensions;
7307
7308 };
7309 /*
7310 SubbandCQIItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
7311         ...
7312 }
7313 */
7314
7315 struct SubbandCQIItem_ExtIEs
7316 {
7317         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
7318         {
7319                 size_t get_index() const {return type;}
7320                 bool is_unknown() const { return type == 1; }
7321                 void clear() {type = 0;}
7322                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
7323                 template<typename V>  bool decode(V& v)
7324                 {
7325                         clear();
7326                         if(!v(ref_nested())) return false;
7327                         { type = 1; return true;}
7328                         return false;
7329
7330                 }
7331                 template<typename V> bool encode(V& v) const
7332                 {
7333                         return v(ref_nested());
7334
7335                 }
7336                 protected:
7337                 template<typename V>  bool decode(size_t index, V& v)
7338                 {
7339                         clear();
7340                         switch(index)
7341                         {
7342                         case 1: type = 1; return v(ref_nested());
7343                         ref_nested().clear();
7344                         }
7345                         return false;
7346
7347                 }
7348                 template<typename V> bool encode(size_t index, V& v) const
7349                 {
7350                         if(index != type) {return false;} return v(ref_nested());
7351
7352                 }
7353                 private:
7354                 size_t type {0};
7355
7356         };
7357         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
7358         {
7359                 size_t get_index() const {return type;}
7360                 bool is_unknown() const { return type == 1; }
7361                 void clear() {type = 0;}
7362                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
7363                 template<typename V>  bool decode(V& v)
7364                 {
7365                         clear();
7366                         if(!v(ref_nested())) return false;
7367                         { type = 1; return true;}
7368                         return false;
7369
7370                 }
7371                 template<typename V> bool encode(V& v) const
7372                 {
7373                         return v(ref_nested());
7374
7375                 }
7376                 protected:
7377                 template<typename V>  bool decode(size_t index, V& v)
7378                 {
7379                         clear();
7380                         switch(index)
7381                         {
7382                         case 1: type = 1; return v(ref_nested());
7383                         ref_nested().clear();
7384                         }
7385                         return false;
7386
7387                 }
7388                 template<typename V> bool encode(size_t index, V& v) const
7389                 {
7390                         if(index != type) {return false;} return v(ref_nested());
7391
7392                 }
7393                 private:
7394                 size_t type {0};
7395
7396         };
7397         struct Extension_t : asn::typefield<true>
7398         {
7399                 ~Extension_t()  {clear();}
7400                 size_t get_index() const {return type;}
7401                 bool is_unknown() const { return type == 1; }
7402                 void clear()
7403                 {
7404                         type = 0; ref_nested().clear();
7405                 }
7406                 template<typename V> static inline void enumerate(V& v)
7407                 {
7408
7409                 }
7410                 protected:
7411                 template<typename V> bool decode(size_t index, V& v)
7412                 {
7413                         clear();
7414                         switch(index)
7415                         {
7416                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
7417                         }
7418                         return false;
7419
7420                 }
7421                 template<typename V> bool encode(size_t index, V& v) const
7422                 {
7423                         if(index != type) return false;
7424                         return false;
7425
7426                 }
7427                 private:
7428                 size_t type {0};
7429
7430         };
7431         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
7432         {
7433                 size_t get_index() const {return type;}
7434                 bool is_unknown() const { return type == 1; }
7435                 void clear() {type = 0;}
7436                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
7437                 template<typename V>  bool decode(V& v)
7438                 {
7439                         clear();
7440                         if(!v(ref_nested())) return false;
7441                         { type = 1; return true;}
7442                         return false;
7443
7444                 }
7445                 template<typename V> bool encode(V& v) const
7446                 {
7447                         return v(ref_nested());
7448
7449                 }
7450                 protected:
7451                 template<typename V>  bool decode(size_t index, V& v)
7452                 {
7453                         clear();
7454                         switch(index)
7455                         {
7456                         case 1: type = 1; return v(ref_nested());
7457                         ref_nested().clear();
7458                         }
7459                         return false;
7460
7461                 }
7462                 template<typename V> bool encode(size_t index, V& v) const
7463                 {
7464                         if(index != type) {return false;} return v(ref_nested());
7465
7466                 }
7467                 private:
7468                 size_t type {0};
7469
7470         };
7471
7472 };
7473 /*
7474 SubbandCQIItem ::= SEQUENCE {
7475         subbandCQI                      SubbandCQI,
7476         subbandIndex            INTEGER (0..27,...),
7477         iE-Extensions           ProtocolExtensionContainer { {SubbandCQIItem-ExtIEs} } OPTIONAL,
7478         ...
7479 }
7480 */
7481
7482 struct SubbandCQIItem : asn::sequence<3, 0, true, 1>
7483 {
7484         static constexpr const char* name() {return "SubbandCQIItem";}
7485         using parent_t = asn::sequence<3, 0, true, 1>;
7486         struct subbandCQI_t : SubbandCQI
7487         {
7488                 static constexpr const char* name() {return "subbandCQI_t";}
7489                 using parent_t = SubbandCQI;
7490
7491         };
7492         subbandCQI_t& ref_subbandCQI() {return subbandCQI;}
7493         subbandCQI_t const& ref_subbandCQI() const {return subbandCQI;}
7494         struct subbandIndex_t : asn::integer<>
7495         {
7496                 using constraint_t = asn::constraints<true,asn::span<0, 27>>;
7497                 static constexpr const char* name() {return "subbandIndex_t";}
7498                 using parent_t = asn::integer<>;
7499
7500         };
7501
7502         subbandIndex_t& ref_subbandIndex() {return subbandIndex;}
7503         subbandIndex_t const& ref_subbandIndex() const {return subbandIndex;}
7504         struct iE_Extensions_t : ProtocolExtensionContainer<SubbandCQIItem_ExtIEs>
7505         {
7506                 static constexpr const char* name() {return "iE_Extensions_t";}
7507                 using parent_t = ProtocolExtensionContainer<SubbandCQIItem_ExtIEs>;
7508                 static constexpr bool optional = true;
7509
7510         };
7511         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
7512         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
7513         template<typename V> void decode(V& v)
7514         {
7515                 v(subbandCQI);
7516                 v(subbandIndex);
7517                 v(iE_Extensions);
7518
7519         };
7520         template<typename V> void encode(V& v) const
7521         {
7522                 v(subbandCQI);
7523                 v(subbandIndex);
7524                 v(iE_Extensions);
7525
7526         };
7527         void clear()
7528         {
7529                 subbandCQI.clear();
7530                 subbandIndex.clear();
7531                 iE_Extensions.clear();
7532
7533         };
7534         private:
7535         subbandCQI_t    subbandCQI;
7536         subbandIndex_t  subbandIndex;
7537         iE_Extensions_t iE_Extensions;
7538
7539 };
7540 /*
7541 SubbandCQIList ::= SEQUENCE (SIZE(1.. maxSubband)) OF SubbandCQIItem
7542 */
7543
7544 struct SubbandCQIList_elm : SubbandCQIItem
7545 {
7546         static constexpr const char* name() {return "SubbandCQIList_elm";}
7547         using parent_t = SubbandCQIItem;
7548
7549 };
7550 struct SubbandCQIList : asn::sequenceof<SubbandCQIList_elm>
7551 {
7552         static constexpr const char* name() {return "SubbandCQIList";}
7553         using parent_t = asn::sequenceof<SubbandCQIList_elm>;
7554         using constraint_t = asn::constraints<false,asn::span<1,  maxSubband >>;
7555
7556 };
7557 /*
7558 CSIReportPerCSIProcessItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
7559         ...
7560 }
7561 */
7562
7563 struct CSIReportPerCSIProcessItem_ExtIEs
7564 {
7565         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
7566         {
7567                 size_t get_index() const {return type;}
7568                 bool is_unknown() const { return type == 1; }
7569                 void clear() {type = 0;}
7570                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
7571                 template<typename V>  bool decode(V& v)
7572                 {
7573                         clear();
7574                         if(!v(ref_nested())) return false;
7575                         { type = 1; return true;}
7576                         return false;
7577
7578                 }
7579                 template<typename V> bool encode(V& v) const
7580                 {
7581                         return v(ref_nested());
7582
7583                 }
7584                 protected:
7585                 template<typename V>  bool decode(size_t index, V& v)
7586                 {
7587                         clear();
7588                         switch(index)
7589                         {
7590                         case 1: type = 1; return v(ref_nested());
7591                         ref_nested().clear();
7592                         }
7593                         return false;
7594
7595                 }
7596                 template<typename V> bool encode(size_t index, V& v) const
7597                 {
7598                         if(index != type) {return false;} return v(ref_nested());
7599
7600                 }
7601                 private:
7602                 size_t type {0};
7603
7604         };
7605         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
7606         {
7607                 size_t get_index() const {return type;}
7608                 bool is_unknown() const { return type == 1; }
7609                 void clear() {type = 0;}
7610                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
7611                 template<typename V>  bool decode(V& v)
7612                 {
7613                         clear();
7614                         if(!v(ref_nested())) return false;
7615                         { type = 1; return true;}
7616                         return false;
7617
7618                 }
7619                 template<typename V> bool encode(V& v) const
7620                 {
7621                         return v(ref_nested());
7622
7623                 }
7624                 protected:
7625                 template<typename V>  bool decode(size_t index, V& v)
7626                 {
7627                         clear();
7628                         switch(index)
7629                         {
7630                         case 1: type = 1; return v(ref_nested());
7631                         ref_nested().clear();
7632                         }
7633                         return false;
7634
7635                 }
7636                 template<typename V> bool encode(size_t index, V& v) const
7637                 {
7638                         if(index != type) {return false;} return v(ref_nested());
7639
7640                 }
7641                 private:
7642                 size_t type {0};
7643
7644         };
7645         struct Extension_t : asn::typefield<true>
7646         {
7647                 ~Extension_t()  {clear();}
7648                 size_t get_index() const {return type;}
7649                 bool is_unknown() const { return type == 1; }
7650                 void clear()
7651                 {
7652                         type = 0; ref_nested().clear();
7653                 }
7654                 template<typename V> static inline void enumerate(V& v)
7655                 {
7656
7657                 }
7658                 protected:
7659                 template<typename V> bool decode(size_t index, V& v)
7660                 {
7661                         clear();
7662                         switch(index)
7663                         {
7664                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
7665                         }
7666                         return false;
7667
7668                 }
7669                 template<typename V> bool encode(size_t index, V& v) const
7670                 {
7671                         if(index != type) return false;
7672                         return false;
7673
7674                 }
7675                 private:
7676                 size_t type {0};
7677
7678         };
7679         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
7680         {
7681                 size_t get_index() const {return type;}
7682                 bool is_unknown() const { return type == 1; }
7683                 void clear() {type = 0;}
7684                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
7685                 template<typename V>  bool decode(V& v)
7686                 {
7687                         clear();
7688                         if(!v(ref_nested())) return false;
7689                         { type = 1; return true;}
7690                         return false;
7691
7692                 }
7693                 template<typename V> bool encode(V& v) const
7694                 {
7695                         return v(ref_nested());
7696
7697                 }
7698                 protected:
7699                 template<typename V>  bool decode(size_t index, V& v)
7700                 {
7701                         clear();
7702                         switch(index)
7703                         {
7704                         case 1: type = 1; return v(ref_nested());
7705                         ref_nested().clear();
7706                         }
7707                         return false;
7708
7709                 }
7710                 template<typename V> bool encode(size_t index, V& v) const
7711                 {
7712                         if(index != type) {return false;} return v(ref_nested());
7713
7714                 }
7715                 private:
7716                 size_t type {0};
7717
7718         };
7719
7720 };
7721 /*
7722 CSIReportPerCSIProcessItem ::= SEQUENCE (SIZE(1.. maxCSIReport)) OF
7723         SEQUENCE {
7724                 rI                                                              INTEGER (1..8, ...),
7725                 widebandCQI                                             WidebandCQI,
7726                 subbandSize                                             SubbandSize,
7727                 subbandCQIList                                  SubbandCQIList  OPTIONAL,
7728                 iE-Extensions                                   ProtocolExtensionContainer { {CSIReportPerCSIProcessItem-ExtIEs} } OPTIONAL,
7729                 ...
7730         }
7731 */
7732
7733 struct CSIReportPerCSIProcessItem_elm : asn::sequence<5, 0, true, 2>
7734 {
7735         static constexpr const char* name() {return "CSIReportPerCSIProcessItem_elm";}
7736         using parent_t = asn::sequence<5, 0, true, 2>;
7737         struct rI_t : asn::integer<>
7738         {
7739                 using constraint_t = asn::constraints<true,asn::span<1, 8>>;
7740                 static constexpr const char* name() {return "rI_t";}
7741                 using parent_t = asn::integer<>;
7742
7743         };
7744
7745         rI_t& ref_rI() {return rI;}
7746         rI_t const& ref_rI() const {return rI;}
7747         struct widebandCQI_t : WidebandCQI
7748         {
7749                 static constexpr const char* name() {return "widebandCQI_t";}
7750                 using parent_t = WidebandCQI;
7751
7752         };
7753         widebandCQI_t& ref_widebandCQI() {return widebandCQI;}
7754         widebandCQI_t const& ref_widebandCQI() const {return widebandCQI;}
7755         struct subbandSize_t : SubbandSize
7756         {
7757                 static constexpr const char* name() {return "subbandSize_t";}
7758                 using parent_t = SubbandSize;
7759
7760         };
7761         subbandSize_t& ref_subbandSize() {return subbandSize;}
7762         subbandSize_t const& ref_subbandSize() const {return subbandSize;}
7763         struct subbandCQIList_t : SubbandCQIList
7764         {
7765                 static constexpr const char* name() {return "subbandCQIList_t";}
7766                 using parent_t = SubbandCQIList;
7767                 static constexpr bool optional = true;
7768
7769         };
7770         subbandCQIList_t& set_subbandCQIList() { subbandCQIList.setpresent(true); return subbandCQIList;}
7771         subbandCQIList_t const* get_subbandCQIList() const {return subbandCQIList.is_valid() ? &subbandCQIList : nullptr;}
7772         struct iE_Extensions_t : ProtocolExtensionContainer<CSIReportPerCSIProcessItem_ExtIEs>
7773         {
7774                 static constexpr const char* name() {return "iE_Extensions_t";}
7775                 using parent_t = ProtocolExtensionContainer<CSIReportPerCSIProcessItem_ExtIEs>;
7776                 static constexpr bool optional = true;
7777
7778         };
7779         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
7780         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
7781         template<typename V> void decode(V& v)
7782         {
7783                 v(rI);
7784                 v(widebandCQI);
7785                 v(subbandSize);
7786                 v(subbandCQIList);
7787                 v(iE_Extensions);
7788
7789         };
7790         template<typename V> void encode(V& v) const
7791         {
7792                 v(rI);
7793                 v(widebandCQI);
7794                 v(subbandSize);
7795                 v(subbandCQIList);
7796                 v(iE_Extensions);
7797
7798         };
7799         void clear()
7800         {
7801                 rI.clear();
7802                 widebandCQI.clear();
7803                 subbandSize.clear();
7804                 subbandCQIList.clear();
7805                 iE_Extensions.clear();
7806
7807         };
7808         private:
7809         rI_t    rI;
7810         widebandCQI_t   widebandCQI;
7811         subbandSize_t   subbandSize;
7812         subbandCQIList_t        subbandCQIList;
7813         iE_Extensions_t iE_Extensions;
7814
7815 };
7816 struct CSIReportPerCSIProcessItem : asn::sequenceof<CSIReportPerCSIProcessItem_elm>
7817 {
7818         static constexpr const char* name() {return "CSIReportPerCSIProcessItem";}
7819         using parent_t = asn::sequenceof<CSIReportPerCSIProcessItem_elm>;
7820         using constraint_t = asn::constraints<false,asn::span<1,  maxCSIReport >>;
7821
7822 };
7823 /*
7824 CSIReportPerCSIProcess-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
7825         ...
7826 }
7827 */
7828
7829 struct CSIReportPerCSIProcess_ExtIEs
7830 {
7831         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
7832         {
7833                 size_t get_index() const {return type;}
7834                 bool is_unknown() const { return type == 1; }
7835                 void clear() {type = 0;}
7836                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
7837                 template<typename V>  bool decode(V& v)
7838                 {
7839                         clear();
7840                         if(!v(ref_nested())) return false;
7841                         { type = 1; return true;}
7842                         return false;
7843
7844                 }
7845                 template<typename V> bool encode(V& v) const
7846                 {
7847                         return v(ref_nested());
7848
7849                 }
7850                 protected:
7851                 template<typename V>  bool decode(size_t index, V& v)
7852                 {
7853                         clear();
7854                         switch(index)
7855                         {
7856                         case 1: type = 1; return v(ref_nested());
7857                         ref_nested().clear();
7858                         }
7859                         return false;
7860
7861                 }
7862                 template<typename V> bool encode(size_t index, V& v) const
7863                 {
7864                         if(index != type) {return false;} return v(ref_nested());
7865
7866                 }
7867                 private:
7868                 size_t type {0};
7869
7870         };
7871         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
7872         {
7873                 size_t get_index() const {return type;}
7874                 bool is_unknown() const { return type == 1; }
7875                 void clear() {type = 0;}
7876                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
7877                 template<typename V>  bool decode(V& v)
7878                 {
7879                         clear();
7880                         if(!v(ref_nested())) return false;
7881                         { type = 1; return true;}
7882                         return false;
7883
7884                 }
7885                 template<typename V> bool encode(V& v) const
7886                 {
7887                         return v(ref_nested());
7888
7889                 }
7890                 protected:
7891                 template<typename V>  bool decode(size_t index, V& v)
7892                 {
7893                         clear();
7894                         switch(index)
7895                         {
7896                         case 1: type = 1; return v(ref_nested());
7897                         ref_nested().clear();
7898                         }
7899                         return false;
7900
7901                 }
7902                 template<typename V> bool encode(size_t index, V& v) const
7903                 {
7904                         if(index != type) {return false;} return v(ref_nested());
7905
7906                 }
7907                 private:
7908                 size_t type {0};
7909
7910         };
7911         struct Extension_t : asn::typefield<true>
7912         {
7913                 ~Extension_t()  {clear();}
7914                 size_t get_index() const {return type;}
7915                 bool is_unknown() const { return type == 1; }
7916                 void clear()
7917                 {
7918                         type = 0; ref_nested().clear();
7919                 }
7920                 template<typename V> static inline void enumerate(V& v)
7921                 {
7922
7923                 }
7924                 protected:
7925                 template<typename V> bool decode(size_t index, V& v)
7926                 {
7927                         clear();
7928                         switch(index)
7929                         {
7930                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
7931                         }
7932                         return false;
7933
7934                 }
7935                 template<typename V> bool encode(size_t index, V& v) const
7936                 {
7937                         if(index != type) return false;
7938                         return false;
7939
7940                 }
7941                 private:
7942                 size_t type {0};
7943
7944         };
7945         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
7946         {
7947                 size_t get_index() const {return type;}
7948                 bool is_unknown() const { return type == 1; }
7949                 void clear() {type = 0;}
7950                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
7951                 template<typename V>  bool decode(V& v)
7952                 {
7953                         clear();
7954                         if(!v(ref_nested())) return false;
7955                         { type = 1; return true;}
7956                         return false;
7957
7958                 }
7959                 template<typename V> bool encode(V& v) const
7960                 {
7961                         return v(ref_nested());
7962
7963                 }
7964                 protected:
7965                 template<typename V>  bool decode(size_t index, V& v)
7966                 {
7967                         clear();
7968                         switch(index)
7969                         {
7970                         case 1: type = 1; return v(ref_nested());
7971                         ref_nested().clear();
7972                         }
7973                         return false;
7974
7975                 }
7976                 template<typename V> bool encode(size_t index, V& v) const
7977                 {
7978                         if(index != type) {return false;} return v(ref_nested());
7979
7980                 }
7981                 private:
7982                 size_t type {0};
7983
7984         };
7985
7986 };
7987 /*
7988 CSIReportPerCSIProcess ::= SEQUENCE (SIZE(1.. maxCSIProcess)) OF
7989         SEQUENCE {
7990                 cSIProcessConfigurationIndex    INTEGER (1..7, ...),
7991                 cSIReportPerCSIProcessItem              CSIReportPerCSIProcessItem,
7992                 iE-Extensions                                   ProtocolExtensionContainer { {CSIReportPerCSIProcess-ExtIEs} } OPTIONAL,
7993                 ...
7994         }
7995 */
7996
7997 struct CSIReportPerCSIProcess_elm : asn::sequence<3, 0, true, 1>
7998 {
7999         static constexpr const char* name() {return "CSIReportPerCSIProcess_elm";}
8000         using parent_t = asn::sequence<3, 0, true, 1>;
8001         struct cSIProcessConfigurationIndex_t : asn::integer<>
8002         {
8003                 using constraint_t = asn::constraints<true,asn::span<1, 7>>;
8004                 static constexpr const char* name() {return "cSIProcessConfigurationIndex_t";}
8005                 using parent_t = asn::integer<>;
8006
8007         };
8008
8009         cSIProcessConfigurationIndex_t& ref_cSIProcessConfigurationIndex() {return cSIProcessConfigurationIndex;}
8010         cSIProcessConfigurationIndex_t const& ref_cSIProcessConfigurationIndex() const {return cSIProcessConfigurationIndex;}
8011         struct cSIReportPerCSIProcessItem_t : CSIReportPerCSIProcessItem
8012         {
8013                 static constexpr const char* name() {return "cSIReportPerCSIProcessItem_t";}
8014                 using parent_t = CSIReportPerCSIProcessItem;
8015
8016         };
8017         cSIReportPerCSIProcessItem_t& ref_cSIReportPerCSIProcessItem() {return cSIReportPerCSIProcessItem;}
8018         cSIReportPerCSIProcessItem_t const& ref_cSIReportPerCSIProcessItem() const {return cSIReportPerCSIProcessItem;}
8019         struct iE_Extensions_t : ProtocolExtensionContainer<CSIReportPerCSIProcess_ExtIEs>
8020         {
8021                 static constexpr const char* name() {return "iE_Extensions_t";}
8022                 using parent_t = ProtocolExtensionContainer<CSIReportPerCSIProcess_ExtIEs>;
8023                 static constexpr bool optional = true;
8024
8025         };
8026         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
8027         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
8028         template<typename V> void decode(V& v)
8029         {
8030                 v(cSIProcessConfigurationIndex);
8031                 v(cSIReportPerCSIProcessItem);
8032                 v(iE_Extensions);
8033
8034         };
8035         template<typename V> void encode(V& v) const
8036         {
8037                 v(cSIProcessConfigurationIndex);
8038                 v(cSIReportPerCSIProcessItem);
8039                 v(iE_Extensions);
8040
8041         };
8042         void clear()
8043         {
8044                 cSIProcessConfigurationIndex.clear();
8045                 cSIReportPerCSIProcessItem.clear();
8046                 iE_Extensions.clear();
8047
8048         };
8049         private:
8050         cSIProcessConfigurationIndex_t  cSIProcessConfigurationIndex;
8051         cSIReportPerCSIProcessItem_t    cSIReportPerCSIProcessItem;
8052         iE_Extensions_t iE_Extensions;
8053
8054 };
8055 struct CSIReportPerCSIProcess : asn::sequenceof<CSIReportPerCSIProcess_elm>
8056 {
8057         static constexpr const char* name() {return "CSIReportPerCSIProcess";}
8058         using parent_t = asn::sequenceof<CSIReportPerCSIProcess_elm>;
8059         using constraint_t = asn::constraints<false,asn::span<1,  maxCSIProcess >>;
8060
8061 };
8062 /*
8063 CSIReportList-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
8064         ...
8065 }
8066 */
8067
8068 struct CSIReportList_ExtIEs
8069 {
8070         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
8071         {
8072                 size_t get_index() const {return type;}
8073                 bool is_unknown() const { return type == 1; }
8074                 void clear() {type = 0;}
8075                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
8076                 template<typename V>  bool decode(V& v)
8077                 {
8078                         clear();
8079                         if(!v(ref_nested())) return false;
8080                         { type = 1; return true;}
8081                         return false;
8082
8083                 }
8084                 template<typename V> bool encode(V& v) const
8085                 {
8086                         return v(ref_nested());
8087
8088                 }
8089                 protected:
8090                 template<typename V>  bool decode(size_t index, V& v)
8091                 {
8092                         clear();
8093                         switch(index)
8094                         {
8095                         case 1: type = 1; return v(ref_nested());
8096                         ref_nested().clear();
8097                         }
8098                         return false;
8099
8100                 }
8101                 template<typename V> bool encode(size_t index, V& v) const
8102                 {
8103                         if(index != type) {return false;} return v(ref_nested());
8104
8105                 }
8106                 private:
8107                 size_t type {0};
8108
8109         };
8110         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
8111         {
8112                 size_t get_index() const {return type;}
8113                 bool is_unknown() const { return type == 1; }
8114                 void clear() {type = 0;}
8115                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
8116                 template<typename V>  bool decode(V& v)
8117                 {
8118                         clear();
8119                         if(!v(ref_nested())) return false;
8120                         { type = 1; return true;}
8121                         return false;
8122
8123                 }
8124                 template<typename V> bool encode(V& v) const
8125                 {
8126                         return v(ref_nested());
8127
8128                 }
8129                 protected:
8130                 template<typename V>  bool decode(size_t index, V& v)
8131                 {
8132                         clear();
8133                         switch(index)
8134                         {
8135                         case 1: type = 1; return v(ref_nested());
8136                         ref_nested().clear();
8137                         }
8138                         return false;
8139
8140                 }
8141                 template<typename V> bool encode(size_t index, V& v) const
8142                 {
8143                         if(index != type) {return false;} return v(ref_nested());
8144
8145                 }
8146                 private:
8147                 size_t type {0};
8148
8149         };
8150         struct Extension_t : asn::typefield<true>
8151         {
8152                 ~Extension_t()  {clear();}
8153                 size_t get_index() const {return type;}
8154                 bool is_unknown() const { return type == 1; }
8155                 void clear()
8156                 {
8157                         type = 0; ref_nested().clear();
8158                 }
8159                 template<typename V> static inline void enumerate(V& v)
8160                 {
8161
8162                 }
8163                 protected:
8164                 template<typename V> bool decode(size_t index, V& v)
8165                 {
8166                         clear();
8167                         switch(index)
8168                         {
8169                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
8170                         }
8171                         return false;
8172
8173                 }
8174                 template<typename V> bool encode(size_t index, V& v) const
8175                 {
8176                         if(index != type) return false;
8177                         return false;
8178
8179                 }
8180                 private:
8181                 size_t type {0};
8182
8183         };
8184         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
8185         {
8186                 size_t get_index() const {return type;}
8187                 bool is_unknown() const { return type == 1; }
8188                 void clear() {type = 0;}
8189                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
8190                 template<typename V>  bool decode(V& v)
8191                 {
8192                         clear();
8193                         if(!v(ref_nested())) return false;
8194                         { type = 1; return true;}
8195                         return false;
8196
8197                 }
8198                 template<typename V> bool encode(V& v) const
8199                 {
8200                         return v(ref_nested());
8201
8202                 }
8203                 protected:
8204                 template<typename V>  bool decode(size_t index, V& v)
8205                 {
8206                         clear();
8207                         switch(index)
8208                         {
8209                         case 1: type = 1; return v(ref_nested());
8210                         ref_nested().clear();
8211                         }
8212                         return false;
8213
8214                 }
8215                 template<typename V> bool encode(size_t index, V& v) const
8216                 {
8217                         if(index != type) {return false;} return v(ref_nested());
8218
8219                 }
8220                 private:
8221                 size_t type {0};
8222
8223         };
8224
8225 };
8226 /*
8227 CSIReportList ::= SEQUENCE (SIZE(1..maxUEReport)) OF
8228         SEQUENCE {
8229                 uEID                                                    UEID,
8230                 cSIReportPerCSIProcess                  CSIReportPerCSIProcess,
8231                 iE-Extensions                                   ProtocolExtensionContainer { {CSIReportList-ExtIEs} } OPTIONAL,
8232                 ...
8233         }
8234 */
8235
8236 struct CSIReportList_elm : asn::sequence<3, 0, true, 1>
8237 {
8238         static constexpr const char* name() {return "CSIReportList_elm";}
8239         using parent_t = asn::sequence<3, 0, true, 1>;
8240         struct uEID_t : UEID
8241         {
8242                 static constexpr const char* name() {return "uEID_t";}
8243                 using parent_t = UEID;
8244
8245         };
8246         uEID_t& ref_uEID() {return uEID;}
8247         uEID_t const& ref_uEID() const {return uEID;}
8248         struct cSIReportPerCSIProcess_t : CSIReportPerCSIProcess
8249         {
8250                 static constexpr const char* name() {return "cSIReportPerCSIProcess_t";}
8251                 using parent_t = CSIReportPerCSIProcess;
8252
8253         };
8254         cSIReportPerCSIProcess_t& ref_cSIReportPerCSIProcess() {return cSIReportPerCSIProcess;}
8255         cSIReportPerCSIProcess_t const& ref_cSIReportPerCSIProcess() const {return cSIReportPerCSIProcess;}
8256         struct iE_Extensions_t : ProtocolExtensionContainer<CSIReportList_ExtIEs>
8257         {
8258                 static constexpr const char* name() {return "iE_Extensions_t";}
8259                 using parent_t = ProtocolExtensionContainer<CSIReportList_ExtIEs>;
8260                 static constexpr bool optional = true;
8261
8262         };
8263         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
8264         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
8265         template<typename V> void decode(V& v)
8266         {
8267                 v(uEID);
8268                 v(cSIReportPerCSIProcess);
8269                 v(iE_Extensions);
8270
8271         };
8272         template<typename V> void encode(V& v) const
8273         {
8274                 v(uEID);
8275                 v(cSIReportPerCSIProcess);
8276                 v(iE_Extensions);
8277
8278         };
8279         void clear()
8280         {
8281                 uEID.clear();
8282                 cSIReportPerCSIProcess.clear();
8283                 iE_Extensions.clear();
8284
8285         };
8286         private:
8287         uEID_t  uEID;
8288         cSIReportPerCSIProcess_t        cSIReportPerCSIProcess;
8289         iE_Extensions_t iE_Extensions;
8290
8291 };
8292 struct CSIReportList : asn::sequenceof<CSIReportList_elm>
8293 {
8294         static constexpr const char* name() {return "CSIReportList";}
8295         using parent_t = asn::sequenceof<CSIReportList_elm>;
8296         using constraint_t = asn::constraints<false,asn::span<1,  maxUEReport >>;
8297
8298 };
8299 /*
8300 CapacityValue ::= INTEGER (0..100)
8301 */
8302
8303 struct CapacityValue : asn::integer<>
8304 {
8305         using constraint_t = asn::constraints<false,asn::span<0, 100>>;
8306         static constexpr const char* name() {return "CapacityValue";}
8307         using parent_t = asn::integer<>;
8308
8309 };
8310
8311 /*
8312 CauseRadioNetwork ::= ENUMERATED {
8313         handover-desirable-for-radio-reasons,
8314         time-critical-handover,
8315         resource-optimisation-handover,
8316         reduce-load-in-serving-cell,
8317         partial-handover,
8318         unknown-new-eNB-UE-X2AP-ID,
8319         unknown-old-eNB-UE-X2AP-ID,
8320         unknown-pair-of-UE-X2AP-ID,
8321         ho-target-not-allowed,
8322         tx2relocoverall-expiry,
8323         trelocprep-expiry,
8324         cell-not-available,
8325         no-radio-resources-available-in-target-cell,
8326         invalid-MME-GroupID,
8327         unknown-MME-Code,
8328         encryption-and-or-integrity-protection-algorithms-not-supported,
8329         reportCharacteristicsEmpty,
8330         noReportPeriodicity,
8331         existingMeasurementID,
8332         unknown-eNB-Measurement-ID,
8333         measurement-temporarily-not-available,
8334         unspecified,
8335         ...,
8336         load-balancing,
8337         handover-optimisation,
8338         value-out-of-allowed-range,
8339         multiple-E-RAB-ID-instances,
8340         switch-off-ongoing,
8341         not-supported-QCI-value,
8342         measurement-not-supported-for-the-object,
8343         tDCoverall-expiry,
8344         tDCprep-expiry,
8345         action-desirable-for-radio-reasons,
8346         reduce-load,
8347         resource-optimisation,
8348         time-critical-action,
8349         target-not-allowed,
8350         no-radio-resources-available,
8351         invalid-QoS-combination,
8352         encryption-algorithms-not-aupported,
8353         procedure-cancelled,
8354         rRM-purpose,
8355         improve-user-bit-rate,
8356         user-inactivity,
8357         radio-connection-with-UE-lost,
8358         failure-in-the-radio-interface-procedure,
8359         bearer-option-not-supported,
8360         mCG-Mobility,
8361         sCG-Mobility,
8362         count-reaches-max-value,
8363         unknown-old-en-gNB-UE-X2AP-ID,
8364         pDCP-Overload
8365
8366 }
8367 */
8368
8369 struct CauseRadioNetwork : asn::enumerated<51, 29, true>
8370 {
8371         static constexpr const char* name() {return "CauseRadioNetwork";}
8372         using parent_t = asn::enumerated<51, 29, true>;
8373         typedef enum {
8374                 handover_desirable_for_radio_reasons
8375                 ,time_critical_handover
8376                 ,resource_optimisation_handover
8377                 ,reduce_load_in_serving_cell
8378                 ,partial_handover
8379                 ,unknown_new_eNB_UE_X2AP_ID
8380                 ,unknown_old_eNB_UE_X2AP_ID
8381                 ,unknown_pair_of_UE_X2AP_ID
8382                 ,ho_target_not_allowed
8383                 ,tx2relocoverall_expiry
8384                 ,trelocprep_expiry
8385                 ,cell_not_available
8386                 ,no_radio_resources_available_in_target_cell
8387                 ,invalid_MME_GroupID
8388                 ,unknown_MME_Code
8389                 ,encryption_and_or_integrity_protection_algorithms_not_supported
8390                 ,reportCharacteristicsEmpty
8391                 ,noReportPeriodicity
8392                 ,existingMeasurementID
8393                 ,unknown_eNB_Measurement_ID
8394                 ,measurement_temporarily_not_available
8395                 ,unspecified
8396                 ,load_balancing
8397                 ,handover_optimisation
8398                 ,value_out_of_allowed_range
8399                 ,multiple_E_RAB_ID_instances
8400                 ,switch_off_ongoing
8401                 ,not_supported_QCI_value
8402                 ,measurement_not_supported_for_the_object
8403                 ,tDCoverall_expiry
8404                 ,tDCprep_expiry
8405                 ,action_desirable_for_radio_reasons
8406                 ,reduce_load
8407                 ,resource_optimisation
8408                 ,time_critical_action
8409                 ,target_not_allowed
8410                 ,no_radio_resources_available
8411                 ,invalid_QoS_combination
8412                 ,encryption_algorithms_not_aupported
8413                 ,procedure_cancelled
8414                 ,rRM_purpose
8415                 ,improve_user_bit_rate
8416                 ,user_inactivity
8417                 ,radio_connection_with_UE_lost
8418                 ,failure_in_the_radio_interface_procedure
8419                 ,bearer_option_not_supported
8420                 ,mCG_Mobility
8421                 ,sCG_Mobility
8422                 ,count_reaches_max_value
8423                 ,unknown_old_en_gNB_UE_X2AP_ID
8424                 ,pDCP_Overload
8425         } index_t;
8426
8427 };
8428
8429 /*
8430 CauseTransport ::= ENUMERATED {
8431         transport-resource-unavailable,
8432         unspecified,
8433         ...
8434 }
8435 */
8436
8437 struct CauseTransport : asn::enumerated<2, 0, true>
8438 {
8439         static constexpr const char* name() {return "CauseTransport";}
8440         using parent_t = asn::enumerated<2, 0, true>;
8441         typedef enum {
8442                 transport_resource_unavailable
8443                 ,unspecified
8444         } index_t;
8445
8446 };
8447
8448 /*
8449 CauseProtocol ::= ENUMERATED {
8450         transfer-syntax-error,
8451         abstract-syntax-error-reject,
8452         abstract-syntax-error-ignore-and-notify,
8453         message-not-compatible-with-receiver-state,
8454         semantic-error,
8455         unspecified,
8456         abstract-syntax-error-falsely-constructed-message,
8457         ...
8458 }
8459 */
8460
8461 struct CauseProtocol : asn::enumerated<7, 0, true>
8462 {
8463         static constexpr const char* name() {return "CauseProtocol";}
8464         using parent_t = asn::enumerated<7, 0, true>;
8465         typedef enum {
8466                 transfer_syntax_error
8467                 ,abstract_syntax_error_reject
8468                 ,abstract_syntax_error_ignore_and_notify
8469                 ,message_not_compatible_with_receiver_state
8470                 ,semantic_error
8471                 ,unspecified
8472                 ,abstract_syntax_error_falsely_constructed_message
8473         } index_t;
8474
8475 };
8476
8477 /*
8478 CauseMisc ::= ENUMERATED {
8479         control-processing-overload,
8480         hardware-failure,
8481         om-intervention,
8482         not-enough-user-plane-processing-resources,
8483         unspecified,
8484         ...
8485 }
8486 */
8487
8488 struct CauseMisc : asn::enumerated<5, 0, true>
8489 {
8490         static constexpr const char* name() {return "CauseMisc";}
8491         using parent_t = asn::enumerated<5, 0, true>;
8492         typedef enum {
8493                 control_processing_overload
8494                 ,hardware_failure
8495                 ,om_intervention
8496                 ,not_enough_user_plane_processing_resources
8497                 ,unspecified
8498         } index_t;
8499
8500 };
8501
8502 /*
8503 Cause ::= CHOICE {
8504         radioNetwork            CauseRadioNetwork,
8505         transport                       CauseTransport,
8506         protocol                        CauseProtocol,
8507         misc                            CauseMisc,
8508         ...
8509 }
8510 */
8511
8512 struct Cause : asn::choice<4, 0, true>
8513 {
8514         static constexpr const char* name() {return "Cause";}
8515         using parent_t = asn::choice<4, 0, true>;
8516         index_type get_index() const {return index;}
8517         bool is_unknown() const {return index == 5;}
8518         void set_unknown() { set_index(5);  }
8519         ~Cause() {clear();}
8520         struct radioNetwork_t : CauseRadioNetwork
8521         {
8522                 static constexpr const char* name() {return "radioNetwork_t";}
8523                 using parent_t = CauseRadioNetwork;
8524
8525         };
8526         struct transport_t : CauseTransport
8527         {
8528                 static constexpr const char* name() {return "transport_t";}
8529                 using parent_t = CauseTransport;
8530
8531         };
8532         struct protocol_t : CauseProtocol
8533         {
8534                 static constexpr const char* name() {return "protocol_t";}
8535                 using parent_t = CauseProtocol;
8536
8537         };
8538         struct misc_t : CauseMisc
8539         {
8540                 static constexpr const char* name() {return "misc_t";}
8541                 using parent_t = CauseMisc;
8542
8543         };
8544         void clear()
8545         {
8546                 switch(get_index())
8547                 {
8548                 case 1: var.destroy<radioNetwork_t>(); break;
8549                 case 2: var.destroy<transport_t>(); break;
8550                 case 3: var.destroy<protocol_t>(); break;
8551                 case 4: var.destroy<misc_t>(); break;
8552                 }
8553                 index = 0;
8554                 base::clear();
8555         }
8556         template<typename V> bool decode(size_t idx, V& v)
8557         {
8558                 clear();
8559                 switch(idx)
8560                 {
8561                 case 1: set_index(1); return v(var.build<radioNetwork_t>());
8562                 case 2: set_index(2); return v(var.build<transport_t>());
8563                 case 3: set_index(3); return v(var.build<protocol_t>());
8564                 case 4: set_index(4); return v(var.build<misc_t>());
8565                 }
8566                 return false;
8567
8568         }
8569         template<typename V> bool encode(V& v) const
8570         {
8571                 switch(get_index())
8572                 {
8573                 case 1: return v(var.as<radioNetwork_t>());
8574                 case 2: return v(var.as<transport_t>());
8575                 case 3: return v(var.as<protocol_t>());
8576                 case 4: return v(var.as<misc_t>());
8577                 }
8578                 return false;
8579         }
8580         template<typename V> static inline void enumerate(V& v)
8581         {
8582                 v.template operator()<radioNetwork_t>(1);
8583                 v.template operator()<transport_t>(2);
8584                 v.template operator()<protocol_t>(3);
8585                 v.template operator()<misc_t>(4);
8586
8587         }
8588         radioNetwork_t& select_radioNetwork() { if(get_index() != 1) { clear(); set_index(1); return var.build<radioNetwork_t>();} return var.as<radioNetwork_t>();}
8589         radioNetwork_t const* get_radioNetwork() const { if(get_index() == 1) { return &var.as<radioNetwork_t>();} return nullptr; }
8590         transport_t& select_transport() { if(get_index() != 2) { clear(); set_index(2); return var.build<transport_t>();} return var.as<transport_t>();}
8591         transport_t const* get_transport() const { if(get_index() == 2) { return &var.as<transport_t>();} return nullptr; }
8592         protocol_t& select_protocol() { if(get_index() != 3) { clear(); set_index(3); return var.build<protocol_t>();} return var.as<protocol_t>();}
8593         protocol_t const* get_protocol() const { if(get_index() == 3) { return &var.as<protocol_t>();} return nullptr; }
8594         misc_t& select_misc() { if(get_index() != 4) { clear(); set_index(4); return var.build<misc_t>();} return var.as<misc_t>();}
8595         misc_t const* get_misc() const { if(get_index() == 4) { return &var.as<misc_t>();} return nullptr; }
8596         private:
8597         void set_index(index_type i) {index = i; base::set();}
8598         union union_type
8599         {
8600                 char dummy1[sizeof(radioNetwork_t)];
8601                 char dummy2[sizeof(transport_t)];
8602                 char dummy3[sizeof(protocol_t)];
8603                 char dummy4[sizeof(misc_t)];
8604
8605         };
8606         asn::variant<sizeof(union_type)>        var;
8607         index_type      index {0};
8608 };
8609 /*
8610 Cell-Size ::= ENUMERATED {verysmall, small, medium, large, ... }
8611 */
8612
8613 struct Cell_Size : asn::enumerated<4, 0, true>
8614 {
8615         static constexpr const char* name() {return "Cell-Size";}
8616         using parent_t = asn::enumerated<4, 0, true>;
8617         typedef enum {
8618                 verysmall
8619                 ,small
8620                 ,medium
8621                 ,large
8622         } index_t;
8623
8624 };
8625
8626 /*
8627 CellCapacityClassValue ::= INTEGER (1..100, ...)
8628 */
8629
8630 struct CellCapacityClassValue : asn::integer<>
8631 {
8632         using constraint_t = asn::constraints<true,asn::span<1, 100>>;
8633         static constexpr const char* name() {return "CellCapacityClassValue";}
8634         using parent_t = asn::integer<>;
8635
8636 };
8637
8638 /*
8639 CellDeploymentStatusIndicator ::= ENUMERATED {pre-change-notification, ...}
8640 */
8641
8642 struct CellDeploymentStatusIndicator : asn::enumerated<1, 0, true>
8643 {
8644         static constexpr const char* name() {return "CellDeploymentStatusIndicator";}
8645         using parent_t = asn::enumerated<1, 0, true>;
8646         typedef enum {
8647                 pre_change_notification
8648         } index_t;
8649
8650 };
8651
8652 /*
8653 ReplacingCellsList-Item ::= SEQUENCE {
8654         eCGI                    ECGI,
8655         ...
8656 }
8657 */
8658
8659 struct ReplacingCellsList_Item : asn::sequence<1, 0, true, 0>
8660 {
8661         static constexpr const char* name() {return "ReplacingCellsList-Item";}
8662         using parent_t = asn::sequence<1, 0, true, 0>;
8663         struct eCGI_t : ECGI
8664         {
8665                 static constexpr const char* name() {return "eCGI_t";}
8666                 using parent_t = ECGI;
8667
8668         };
8669         eCGI_t& ref_eCGI() {return eCGI;}
8670         eCGI_t const& ref_eCGI() const {return eCGI;}
8671         template<typename V> void decode(V& v)
8672         {
8673                 v(eCGI);
8674
8675         };
8676         template<typename V> void encode(V& v) const
8677         {
8678                 v(eCGI);
8679
8680         };
8681         void clear()
8682         {
8683                 eCGI.clear();
8684
8685         };
8686         private:
8687         eCGI_t  eCGI;
8688
8689 };
8690 /*
8691 ReplacingCellsList ::= SEQUENCE (SIZE(0.. maxCellineNB)) OF ReplacingCellsList-Item
8692 */
8693
8694 struct ReplacingCellsList_elm : ReplacingCellsList_Item
8695 {
8696         static constexpr const char* name() {return "ReplacingCellsList_elm";}
8697         using parent_t = ReplacingCellsList_Item;
8698
8699 };
8700 struct ReplacingCellsList : asn::sequenceof<ReplacingCellsList_elm>
8701 {
8702         static constexpr const char* name() {return "ReplacingCellsList";}
8703         using parent_t = asn::sequenceof<ReplacingCellsList_elm>;
8704         using constraint_t = asn::constraints<false,asn::span<0,  maxCellineNB >>;
8705
8706 };
8707 /*
8708 CellReplacingInfo-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
8709         ...
8710 }
8711 */
8712
8713 struct CellReplacingInfo_ExtIEs
8714 {
8715         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
8716         {
8717                 size_t get_index() const {return type;}
8718                 bool is_unknown() const { return type == 1; }
8719                 void clear() {type = 0;}
8720                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
8721                 template<typename V>  bool decode(V& v)
8722                 {
8723                         clear();
8724                         if(!v(ref_nested())) return false;
8725                         { type = 1; return true;}
8726                         return false;
8727
8728                 }
8729                 template<typename V> bool encode(V& v) const
8730                 {
8731                         return v(ref_nested());
8732
8733                 }
8734                 protected:
8735                 template<typename V>  bool decode(size_t index, V& v)
8736                 {
8737                         clear();
8738                         switch(index)
8739                         {
8740                         case 1: type = 1; return v(ref_nested());
8741                         ref_nested().clear();
8742                         }
8743                         return false;
8744
8745                 }
8746                 template<typename V> bool encode(size_t index, V& v) const
8747                 {
8748                         if(index != type) {return false;} return v(ref_nested());
8749
8750                 }
8751                 private:
8752                 size_t type {0};
8753
8754         };
8755         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
8756         {
8757                 size_t get_index() const {return type;}
8758                 bool is_unknown() const { return type == 1; }
8759                 void clear() {type = 0;}
8760                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
8761                 template<typename V>  bool decode(V& v)
8762                 {
8763                         clear();
8764                         if(!v(ref_nested())) return false;
8765                         { type = 1; return true;}
8766                         return false;
8767
8768                 }
8769                 template<typename V> bool encode(V& v) const
8770                 {
8771                         return v(ref_nested());
8772
8773                 }
8774                 protected:
8775                 template<typename V>  bool decode(size_t index, V& v)
8776                 {
8777                         clear();
8778                         switch(index)
8779                         {
8780                         case 1: type = 1; return v(ref_nested());
8781                         ref_nested().clear();
8782                         }
8783                         return false;
8784
8785                 }
8786                 template<typename V> bool encode(size_t index, V& v) const
8787                 {
8788                         if(index != type) {return false;} return v(ref_nested());
8789
8790                 }
8791                 private:
8792                 size_t type {0};
8793
8794         };
8795         struct Extension_t : asn::typefield<true>
8796         {
8797                 ~Extension_t()  {clear();}
8798                 size_t get_index() const {return type;}
8799                 bool is_unknown() const { return type == 1; }
8800                 void clear()
8801                 {
8802                         type = 0; ref_nested().clear();
8803                 }
8804                 template<typename V> static inline void enumerate(V& v)
8805                 {
8806
8807                 }
8808                 protected:
8809                 template<typename V> bool decode(size_t index, V& v)
8810                 {
8811                         clear();
8812                         switch(index)
8813                         {
8814                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
8815                         }
8816                         return false;
8817
8818                 }
8819                 template<typename V> bool encode(size_t index, V& v) const
8820                 {
8821                         if(index != type) return false;
8822                         return false;
8823
8824                 }
8825                 private:
8826                 size_t type {0};
8827
8828         };
8829         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
8830         {
8831                 size_t get_index() const {return type;}
8832                 bool is_unknown() const { return type == 1; }
8833                 void clear() {type = 0;}
8834                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
8835                 template<typename V>  bool decode(V& v)
8836                 {
8837                         clear();
8838                         if(!v(ref_nested())) return false;
8839                         { type = 1; return true;}
8840                         return false;
8841
8842                 }
8843                 template<typename V> bool encode(V& v) const
8844                 {
8845                         return v(ref_nested());
8846
8847                 }
8848                 protected:
8849                 template<typename V>  bool decode(size_t index, V& v)
8850                 {
8851                         clear();
8852                         switch(index)
8853                         {
8854                         case 1: type = 1; return v(ref_nested());
8855                         ref_nested().clear();
8856                         }
8857                         return false;
8858
8859                 }
8860                 template<typename V> bool encode(size_t index, V& v) const
8861                 {
8862                         if(index != type) {return false;} return v(ref_nested());
8863
8864                 }
8865                 private:
8866                 size_t type {0};
8867
8868         };
8869
8870 };
8871 /*
8872 CellReplacingInfo ::= SEQUENCE {
8873         replacingCellsList                              ReplacingCellsList,
8874         iE-Extensions                                   ProtocolExtensionContainer { {CellReplacingInfo-ExtIEs}}        OPTIONAL,
8875         ...
8876 }
8877 */
8878
8879 struct CellReplacingInfo : asn::sequence<2, 0, true, 1>
8880 {
8881         static constexpr const char* name() {return "CellReplacingInfo";}
8882         using parent_t = asn::sequence<2, 0, true, 1>;
8883         struct replacingCellsList_t : ReplacingCellsList
8884         {
8885                 static constexpr const char* name() {return "replacingCellsList_t";}
8886                 using parent_t = ReplacingCellsList;
8887
8888         };
8889         replacingCellsList_t& ref_replacingCellsList() {return replacingCellsList;}
8890         replacingCellsList_t const& ref_replacingCellsList() const {return replacingCellsList;}
8891         struct iE_Extensions_t : ProtocolExtensionContainer<CellReplacingInfo_ExtIEs>
8892         {
8893                 static constexpr const char* name() {return "iE_Extensions_t";}
8894                 using parent_t = ProtocolExtensionContainer<CellReplacingInfo_ExtIEs>;
8895                 static constexpr bool optional = true;
8896
8897         };
8898         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
8899         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
8900         template<typename V> void decode(V& v)
8901         {
8902                 v(replacingCellsList);
8903                 v(iE_Extensions);
8904
8905         };
8906         template<typename V> void encode(V& v) const
8907         {
8908                 v(replacingCellsList);
8909                 v(iE_Extensions);
8910
8911         };
8912         void clear()
8913         {
8914                 replacingCellsList.clear();
8915                 iE_Extensions.clear();
8916
8917         };
8918         private:
8919         replacingCellsList_t    replacingCellsList;
8920         iE_Extensions_t iE_Extensions;
8921
8922 };
8923 /*
8924 CellReportingIndicator ::= ENUMERATED {stop-request, ... }
8925 */
8926
8927 struct CellReportingIndicator : asn::enumerated<1, 0, true>
8928 {
8929         static constexpr const char* name() {return "CellReportingIndicator";}
8930         using parent_t = asn::enumerated<1, 0, true>;
8931         typedef enum {
8932                 stop_request
8933         } index_t;
8934
8935 };
8936
8937 /*
8938 CellType-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
8939         ...
8940 }
8941 */
8942
8943 struct CellType_ExtIEs
8944 {
8945         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
8946         {
8947                 size_t get_index() const {return type;}
8948                 bool is_unknown() const { return type == 1; }
8949                 void clear() {type = 0;}
8950                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
8951                 template<typename V>  bool decode(V& v)
8952                 {
8953                         clear();
8954                         if(!v(ref_nested())) return false;
8955                         { type = 1; return true;}
8956                         return false;
8957
8958                 }
8959                 template<typename V> bool encode(V& v) const
8960                 {
8961                         return v(ref_nested());
8962
8963                 }
8964                 protected:
8965                 template<typename V>  bool decode(size_t index, V& v)
8966                 {
8967                         clear();
8968                         switch(index)
8969                         {
8970                         case 1: type = 1; return v(ref_nested());
8971                         ref_nested().clear();
8972                         }
8973                         return false;
8974
8975                 }
8976                 template<typename V> bool encode(size_t index, V& v) const
8977                 {
8978                         if(index != type) {return false;} return v(ref_nested());
8979
8980                 }
8981                 private:
8982                 size_t type {0};
8983
8984         };
8985         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
8986         {
8987                 size_t get_index() const {return type;}
8988                 bool is_unknown() const { return type == 1; }
8989                 void clear() {type = 0;}
8990                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
8991                 template<typename V>  bool decode(V& v)
8992                 {
8993                         clear();
8994                         if(!v(ref_nested())) return false;
8995                         { type = 1; return true;}
8996                         return false;
8997
8998                 }
8999                 template<typename V> bool encode(V& v) const
9000                 {
9001                         return v(ref_nested());
9002
9003                 }
9004                 protected:
9005                 template<typename V>  bool decode(size_t index, V& v)
9006                 {
9007                         clear();
9008                         switch(index)
9009                         {
9010                         case 1: type = 1; return v(ref_nested());
9011                         ref_nested().clear();
9012                         }
9013                         return false;
9014
9015                 }
9016                 template<typename V> bool encode(size_t index, V& v) const
9017                 {
9018                         if(index != type) {return false;} return v(ref_nested());
9019
9020                 }
9021                 private:
9022                 size_t type {0};
9023
9024         };
9025         struct Extension_t : asn::typefield<true>
9026         {
9027                 ~Extension_t()  {clear();}
9028                 size_t get_index() const {return type;}
9029                 bool is_unknown() const { return type == 1; }
9030                 void clear()
9031                 {
9032                         type = 0; ref_nested().clear();
9033                 }
9034                 template<typename V> static inline void enumerate(V& v)
9035                 {
9036
9037                 }
9038                 protected:
9039                 template<typename V> bool decode(size_t index, V& v)
9040                 {
9041                         clear();
9042                         switch(index)
9043                         {
9044                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
9045                         }
9046                         return false;
9047
9048                 }
9049                 template<typename V> bool encode(size_t index, V& v) const
9050                 {
9051                         if(index != type) return false;
9052                         return false;
9053
9054                 }
9055                 private:
9056                 size_t type {0};
9057
9058         };
9059         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
9060         {
9061                 size_t get_index() const {return type;}
9062                 bool is_unknown() const { return type == 1; }
9063                 void clear() {type = 0;}
9064                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
9065                 template<typename V>  bool decode(V& v)
9066                 {
9067                         clear();
9068                         if(!v(ref_nested())) return false;
9069                         { type = 1; return true;}
9070                         return false;
9071
9072                 }
9073                 template<typename V> bool encode(V& v) const
9074                 {
9075                         return v(ref_nested());
9076
9077                 }
9078                 protected:
9079                 template<typename V>  bool decode(size_t index, V& v)
9080                 {
9081                         clear();
9082                         switch(index)
9083                         {
9084                         case 1: type = 1; return v(ref_nested());
9085                         ref_nested().clear();
9086                         }
9087                         return false;
9088
9089                 }
9090                 template<typename V> bool encode(size_t index, V& v) const
9091                 {
9092                         if(index != type) {return false;} return v(ref_nested());
9093
9094                 }
9095                 private:
9096                 size_t type {0};
9097
9098         };
9099
9100 };
9101 /*
9102 CellType ::= SEQUENCE {
9103         cell-Size                                               Cell-Size,
9104         iE-Extensions                                   ProtocolExtensionContainer { {CellType-ExtIEs}} OPTIONAL,
9105         ...
9106 }
9107 */
9108
9109 struct CellType : asn::sequence<2, 0, true, 1>
9110 {
9111         static constexpr const char* name() {return "CellType";}
9112         using parent_t = asn::sequence<2, 0, true, 1>;
9113         struct cell_Size_t : Cell_Size
9114         {
9115                 static constexpr const char* name() {return "cell_Size_t";}
9116                 using parent_t = Cell_Size;
9117
9118         };
9119         cell_Size_t& ref_cell_Size() {return cell_Size;}
9120         cell_Size_t const& ref_cell_Size() const {return cell_Size;}
9121         struct iE_Extensions_t : ProtocolExtensionContainer<CellType_ExtIEs>
9122         {
9123                 static constexpr const char* name() {return "iE_Extensions_t";}
9124                 using parent_t = ProtocolExtensionContainer<CellType_ExtIEs>;
9125                 static constexpr bool optional = true;
9126
9127         };
9128         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
9129         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
9130         template<typename V> void decode(V& v)
9131         {
9132                 v(cell_Size);
9133                 v(iE_Extensions);
9134
9135         };
9136         template<typename V> void encode(V& v) const
9137         {
9138                 v(cell_Size);
9139                 v(iE_Extensions);
9140
9141         };
9142         void clear()
9143         {
9144                 cell_Size.clear();
9145                 iE_Extensions.clear();
9146
9147         };
9148         private:
9149         cell_Size_t     cell_Size;
9150         iE_Extensions_t iE_Extensions;
9151
9152 };
9153 /*
9154 CoMPHypothesisSetItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
9155         ...
9156 }
9157 */
9158
9159 struct CoMPHypothesisSetItem_ExtIEs
9160 {
9161         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
9162         {
9163                 size_t get_index() const {return type;}
9164                 bool is_unknown() const { return type == 1; }
9165                 void clear() {type = 0;}
9166                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
9167                 template<typename V>  bool decode(V& v)
9168                 {
9169                         clear();
9170                         if(!v(ref_nested())) return false;
9171                         { type = 1; return true;}
9172                         return false;
9173
9174                 }
9175                 template<typename V> bool encode(V& v) const
9176                 {
9177                         return v(ref_nested());
9178
9179                 }
9180                 protected:
9181                 template<typename V>  bool decode(size_t index, V& v)
9182                 {
9183                         clear();
9184                         switch(index)
9185                         {
9186                         case 1: type = 1; return v(ref_nested());
9187                         ref_nested().clear();
9188                         }
9189                         return false;
9190
9191                 }
9192                 template<typename V> bool encode(size_t index, V& v) const
9193                 {
9194                         if(index != type) {return false;} return v(ref_nested());
9195
9196                 }
9197                 private:
9198                 size_t type {0};
9199
9200         };
9201         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
9202         {
9203                 size_t get_index() const {return type;}
9204                 bool is_unknown() const { return type == 1; }
9205                 void clear() {type = 0;}
9206                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
9207                 template<typename V>  bool decode(V& v)
9208                 {
9209                         clear();
9210                         if(!v(ref_nested())) return false;
9211                         { type = 1; return true;}
9212                         return false;
9213
9214                 }
9215                 template<typename V> bool encode(V& v) const
9216                 {
9217                         return v(ref_nested());
9218
9219                 }
9220                 protected:
9221                 template<typename V>  bool decode(size_t index, V& v)
9222                 {
9223                         clear();
9224                         switch(index)
9225                         {
9226                         case 1: type = 1; return v(ref_nested());
9227                         ref_nested().clear();
9228                         }
9229                         return false;
9230
9231                 }
9232                 template<typename V> bool encode(size_t index, V& v) const
9233                 {
9234                         if(index != type) {return false;} return v(ref_nested());
9235
9236                 }
9237                 private:
9238                 size_t type {0};
9239
9240         };
9241         struct Extension_t : asn::typefield<true>
9242         {
9243                 ~Extension_t()  {clear();}
9244                 size_t get_index() const {return type;}
9245                 bool is_unknown() const { return type == 1; }
9246                 void clear()
9247                 {
9248                         type = 0; ref_nested().clear();
9249                 }
9250                 template<typename V> static inline void enumerate(V& v)
9251                 {
9252
9253                 }
9254                 protected:
9255                 template<typename V> bool decode(size_t index, V& v)
9256                 {
9257                         clear();
9258                         switch(index)
9259                         {
9260                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
9261                         }
9262                         return false;
9263
9264                 }
9265                 template<typename V> bool encode(size_t index, V& v) const
9266                 {
9267                         if(index != type) return false;
9268                         return false;
9269
9270                 }
9271                 private:
9272                 size_t type {0};
9273
9274         };
9275         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
9276         {
9277                 size_t get_index() const {return type;}
9278                 bool is_unknown() const { return type == 1; }
9279                 void clear() {type = 0;}
9280                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
9281                 template<typename V>  bool decode(V& v)
9282                 {
9283                         clear();
9284                         if(!v(ref_nested())) return false;
9285                         { type = 1; return true;}
9286                         return false;
9287
9288                 }
9289                 template<typename V> bool encode(V& v) const
9290                 {
9291                         return v(ref_nested());
9292
9293                 }
9294                 protected:
9295                 template<typename V>  bool decode(size_t index, V& v)
9296                 {
9297                         clear();
9298                         switch(index)
9299                         {
9300                         case 1: type = 1; return v(ref_nested());
9301                         ref_nested().clear();
9302                         }
9303                         return false;
9304
9305                 }
9306                 template<typename V> bool encode(size_t index, V& v) const
9307                 {
9308                         if(index != type) {return false;} return v(ref_nested());
9309
9310                 }
9311                 private:
9312                 size_t type {0};
9313
9314         };
9315
9316 };
9317 /*
9318 CoMPHypothesisSetItem ::= SEQUENCE {
9319         coMPCellID                                              ECGI,
9320         coMPHypothesis                                  BIT STRING (SIZE(6..4400, ...)),
9321         iE-Extensions                                   ProtocolExtensionContainer { {CoMPHypothesisSetItem-ExtIEs} } OPTIONAL,
9322         ...
9323 }
9324 */
9325
9326 struct CoMPHypothesisSetItem : asn::sequence<3, 0, true, 1>
9327 {
9328         static constexpr const char* name() {return "CoMPHypothesisSetItem";}
9329         using parent_t = asn::sequence<3, 0, true, 1>;
9330         struct coMPCellID_t : ECGI
9331         {
9332                 static constexpr const char* name() {return "coMPCellID_t";}
9333                 using parent_t = ECGI;
9334
9335         };
9336         coMPCellID_t& ref_coMPCellID() {return coMPCellID;}
9337         coMPCellID_t const& ref_coMPCellID() const {return coMPCellID;}
9338         struct coMPHypothesis_t : asn::bstring<>
9339         {
9340                 using constraint_t = asn::constraints<true,asn::span<6, 4400>>;
9341                 static constexpr const char* name() {return "coMPHypothesis_t";}
9342                 using parent_t = asn::bstring<>;
9343
9344         };
9345
9346         coMPHypothesis_t& ref_coMPHypothesis() {return coMPHypothesis;}
9347         coMPHypothesis_t const& ref_coMPHypothesis() const {return coMPHypothesis;}
9348         struct iE_Extensions_t : ProtocolExtensionContainer<CoMPHypothesisSetItem_ExtIEs>
9349         {
9350                 static constexpr const char* name() {return "iE_Extensions_t";}
9351                 using parent_t = ProtocolExtensionContainer<CoMPHypothesisSetItem_ExtIEs>;
9352                 static constexpr bool optional = true;
9353
9354         };
9355         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
9356         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
9357         template<typename V> void decode(V& v)
9358         {
9359                 v(coMPCellID);
9360                 v(coMPHypothesis);
9361                 v(iE_Extensions);
9362
9363         };
9364         template<typename V> void encode(V& v) const
9365         {
9366                 v(coMPCellID);
9367                 v(coMPHypothesis);
9368                 v(iE_Extensions);
9369
9370         };
9371         void clear()
9372         {
9373                 coMPCellID.clear();
9374                 coMPHypothesis.clear();
9375                 iE_Extensions.clear();
9376
9377         };
9378         private:
9379         coMPCellID_t    coMPCellID;
9380         coMPHypothesis_t        coMPHypothesis;
9381         iE_Extensions_t iE_Extensions;
9382
9383 };
9384 /*
9385 CoMPHypothesisSet ::= SEQUENCE (SIZE(1..maxnoofCoMPCells)) OF CoMPHypothesisSetItem
9386 */
9387
9388 struct CoMPHypothesisSet_elm : CoMPHypothesisSetItem
9389 {
9390         static constexpr const char* name() {return "CoMPHypothesisSet_elm";}
9391         using parent_t = CoMPHypothesisSetItem;
9392
9393 };
9394 struct CoMPHypothesisSet : asn::sequenceof<CoMPHypothesisSet_elm>
9395 {
9396         static constexpr const char* name() {return "CoMPHypothesisSet";}
9397         using parent_t = asn::sequenceof<CoMPHypothesisSet_elm>;
9398         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofCoMPCells >>;
9399
9400 };
9401 /*
9402 CoMPInformationItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
9403         ...
9404 }
9405 */
9406
9407 struct CoMPInformationItem_ExtIEs
9408 {
9409         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
9410         {
9411                 size_t get_index() const {return type;}
9412                 bool is_unknown() const { return type == 1; }
9413                 void clear() {type = 0;}
9414                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
9415                 template<typename V>  bool decode(V& v)
9416                 {
9417                         clear();
9418                         if(!v(ref_nested())) return false;
9419                         { type = 1; return true;}
9420                         return false;
9421
9422                 }
9423                 template<typename V> bool encode(V& v) const
9424                 {
9425                         return v(ref_nested());
9426
9427                 }
9428                 protected:
9429                 template<typename V>  bool decode(size_t index, V& v)
9430                 {
9431                         clear();
9432                         switch(index)
9433                         {
9434                         case 1: type = 1; return v(ref_nested());
9435                         ref_nested().clear();
9436                         }
9437                         return false;
9438
9439                 }
9440                 template<typename V> bool encode(size_t index, V& v) const
9441                 {
9442                         if(index != type) {return false;} return v(ref_nested());
9443
9444                 }
9445                 private:
9446                 size_t type {0};
9447
9448         };
9449         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
9450         {
9451                 size_t get_index() const {return type;}
9452                 bool is_unknown() const { return type == 1; }
9453                 void clear() {type = 0;}
9454                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
9455                 template<typename V>  bool decode(V& v)
9456                 {
9457                         clear();
9458                         if(!v(ref_nested())) return false;
9459                         { type = 1; return true;}
9460                         return false;
9461
9462                 }
9463                 template<typename V> bool encode(V& v) const
9464                 {
9465                         return v(ref_nested());
9466
9467                 }
9468                 protected:
9469                 template<typename V>  bool decode(size_t index, V& v)
9470                 {
9471                         clear();
9472                         switch(index)
9473                         {
9474                         case 1: type = 1; return v(ref_nested());
9475                         ref_nested().clear();
9476                         }
9477                         return false;
9478
9479                 }
9480                 template<typename V> bool encode(size_t index, V& v) const
9481                 {
9482                         if(index != type) {return false;} return v(ref_nested());
9483
9484                 }
9485                 private:
9486                 size_t type {0};
9487
9488         };
9489         struct Extension_t : asn::typefield<true>
9490         {
9491                 ~Extension_t()  {clear();}
9492                 size_t get_index() const {return type;}
9493                 bool is_unknown() const { return type == 1; }
9494                 void clear()
9495                 {
9496                         type = 0; ref_nested().clear();
9497                 }
9498                 template<typename V> static inline void enumerate(V& v)
9499                 {
9500
9501                 }
9502                 protected:
9503                 template<typename V> bool decode(size_t index, V& v)
9504                 {
9505                         clear();
9506                         switch(index)
9507                         {
9508                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
9509                         }
9510                         return false;
9511
9512                 }
9513                 template<typename V> bool encode(size_t index, V& v) const
9514                 {
9515                         if(index != type) return false;
9516                         return false;
9517
9518                 }
9519                 private:
9520                 size_t type {0};
9521
9522         };
9523         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
9524         {
9525                 size_t get_index() const {return type;}
9526                 bool is_unknown() const { return type == 1; }
9527                 void clear() {type = 0;}
9528                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
9529                 template<typename V>  bool decode(V& v)
9530                 {
9531                         clear();
9532                         if(!v(ref_nested())) return false;
9533                         { type = 1; return true;}
9534                         return false;
9535
9536                 }
9537                 template<typename V> bool encode(V& v) const
9538                 {
9539                         return v(ref_nested());
9540
9541                 }
9542                 protected:
9543                 template<typename V>  bool decode(size_t index, V& v)
9544                 {
9545                         clear();
9546                         switch(index)
9547                         {
9548                         case 1: type = 1; return v(ref_nested());
9549                         ref_nested().clear();
9550                         }
9551                         return false;
9552
9553                 }
9554                 template<typename V> bool encode(size_t index, V& v) const
9555                 {
9556                         if(index != type) {return false;} return v(ref_nested());
9557
9558                 }
9559                 private:
9560                 size_t type {0};
9561
9562         };
9563
9564 };
9565 /*
9566 CoMPInformationItem ::= SEQUENCE (SIZE(1..maxnoofCoMPHypothesisSet)) OF
9567         SEQUENCE {
9568                 coMPHypothesisSet                                       CoMPHypothesisSet,
9569                 benefitMetric                                           BenefitMetric,
9570                 iE-Extensions                                           ProtocolExtensionContainer { {CoMPInformationItem-ExtIEs} } OPTIONAL,
9571                 ...
9572         }
9573 */
9574
9575 struct CoMPInformationItem_elm : asn::sequence<3, 0, true, 1>
9576 {
9577         static constexpr const char* name() {return "CoMPInformationItem_elm";}
9578         using parent_t = asn::sequence<3, 0, true, 1>;
9579         struct coMPHypothesisSet_t : CoMPHypothesisSet
9580         {
9581                 static constexpr const char* name() {return "coMPHypothesisSet_t";}
9582                 using parent_t = CoMPHypothesisSet;
9583
9584         };
9585         coMPHypothesisSet_t& ref_coMPHypothesisSet() {return coMPHypothesisSet;}
9586         coMPHypothesisSet_t const& ref_coMPHypothesisSet() const {return coMPHypothesisSet;}
9587         struct benefitMetric_t : BenefitMetric
9588         {
9589                 static constexpr const char* name() {return "benefitMetric_t";}
9590                 using parent_t = BenefitMetric;
9591
9592         };
9593         benefitMetric_t& ref_benefitMetric() {return benefitMetric;}
9594         benefitMetric_t const& ref_benefitMetric() const {return benefitMetric;}
9595         struct iE_Extensions_t : ProtocolExtensionContainer<CoMPInformationItem_ExtIEs>
9596         {
9597                 static constexpr const char* name() {return "iE_Extensions_t";}
9598                 using parent_t = ProtocolExtensionContainer<CoMPInformationItem_ExtIEs>;
9599                 static constexpr bool optional = true;
9600
9601         };
9602         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
9603         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
9604         template<typename V> void decode(V& v)
9605         {
9606                 v(coMPHypothesisSet);
9607                 v(benefitMetric);
9608                 v(iE_Extensions);
9609
9610         };
9611         template<typename V> void encode(V& v) const
9612         {
9613                 v(coMPHypothesisSet);
9614                 v(benefitMetric);
9615                 v(iE_Extensions);
9616
9617         };
9618         void clear()
9619         {
9620                 coMPHypothesisSet.clear();
9621                 benefitMetric.clear();
9622                 iE_Extensions.clear();
9623
9624         };
9625         private:
9626         coMPHypothesisSet_t     coMPHypothesisSet;
9627         benefitMetric_t benefitMetric;
9628         iE_Extensions_t iE_Extensions;
9629
9630 };
9631 struct CoMPInformationItem : asn::sequenceof<CoMPInformationItem_elm>
9632 {
9633         static constexpr const char* name() {return "CoMPInformationItem";}
9634         using parent_t = asn::sequenceof<CoMPInformationItem_elm>;
9635         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofCoMPHypothesisSet >>;
9636
9637 };
9638 /*
9639 CoMPInformationStartTime-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
9640         ...
9641 }
9642 */
9643
9644 struct CoMPInformationStartTime_ExtIEs
9645 {
9646         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
9647         {
9648                 size_t get_index() const {return type;}
9649                 bool is_unknown() const { return type == 1; }
9650                 void clear() {type = 0;}
9651                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
9652                 template<typename V>  bool decode(V& v)
9653                 {
9654                         clear();
9655                         if(!v(ref_nested())) return false;
9656                         { type = 1; return true;}
9657                         return false;
9658
9659                 }
9660                 template<typename V> bool encode(V& v) const
9661                 {
9662                         return v(ref_nested());
9663
9664                 }
9665                 protected:
9666                 template<typename V>  bool decode(size_t index, V& v)
9667                 {
9668                         clear();
9669                         switch(index)
9670                         {
9671                         case 1: type = 1; return v(ref_nested());
9672                         ref_nested().clear();
9673                         }
9674                         return false;
9675
9676                 }
9677                 template<typename V> bool encode(size_t index, V& v) const
9678                 {
9679                         if(index != type) {return false;} return v(ref_nested());
9680
9681                 }
9682                 private:
9683                 size_t type {0};
9684
9685         };
9686         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
9687         {
9688                 size_t get_index() const {return type;}
9689                 bool is_unknown() const { return type == 1; }
9690                 void clear() {type = 0;}
9691                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
9692                 template<typename V>  bool decode(V& v)
9693                 {
9694                         clear();
9695                         if(!v(ref_nested())) return false;
9696                         { type = 1; return true;}
9697                         return false;
9698
9699                 }
9700                 template<typename V> bool encode(V& v) const
9701                 {
9702                         return v(ref_nested());
9703
9704                 }
9705                 protected:
9706                 template<typename V>  bool decode(size_t index, V& v)
9707                 {
9708                         clear();
9709                         switch(index)
9710                         {
9711                         case 1: type = 1; return v(ref_nested());
9712                         ref_nested().clear();
9713                         }
9714                         return false;
9715
9716                 }
9717                 template<typename V> bool encode(size_t index, V& v) const
9718                 {
9719                         if(index != type) {return false;} return v(ref_nested());
9720
9721                 }
9722                 private:
9723                 size_t type {0};
9724
9725         };
9726         struct Extension_t : asn::typefield<true>
9727         {
9728                 ~Extension_t()  {clear();}
9729                 size_t get_index() const {return type;}
9730                 bool is_unknown() const { return type == 1; }
9731                 void clear()
9732                 {
9733                         type = 0; ref_nested().clear();
9734                 }
9735                 template<typename V> static inline void enumerate(V& v)
9736                 {
9737
9738                 }
9739                 protected:
9740                 template<typename V> bool decode(size_t index, V& v)
9741                 {
9742                         clear();
9743                         switch(index)
9744                         {
9745                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
9746                         }
9747                         return false;
9748
9749                 }
9750                 template<typename V> bool encode(size_t index, V& v) const
9751                 {
9752                         if(index != type) return false;
9753                         return false;
9754
9755                 }
9756                 private:
9757                 size_t type {0};
9758
9759         };
9760         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
9761         {
9762                 size_t get_index() const {return type;}
9763                 bool is_unknown() const { return type == 1; }
9764                 void clear() {type = 0;}
9765                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
9766                 template<typename V>  bool decode(V& v)
9767                 {
9768                         clear();
9769                         if(!v(ref_nested())) return false;
9770                         { type = 1; return true;}
9771                         return false;
9772
9773                 }
9774                 template<typename V> bool encode(V& v) const
9775                 {
9776                         return v(ref_nested());
9777
9778                 }
9779                 protected:
9780                 template<typename V>  bool decode(size_t index, V& v)
9781                 {
9782                         clear();
9783                         switch(index)
9784                         {
9785                         case 1: type = 1; return v(ref_nested());
9786                         ref_nested().clear();
9787                         }
9788                         return false;
9789
9790                 }
9791                 template<typename V> bool encode(size_t index, V& v) const
9792                 {
9793                         if(index != type) {return false;} return v(ref_nested());
9794
9795                 }
9796                 private:
9797                 size_t type {0};
9798
9799         };
9800
9801 };
9802 /*
9803 CoMPInformationStartTime ::= SEQUENCE (SIZE(0..1)) OF
9804         SEQUENCE {
9805                 startSFN                                                        INTEGER (0..1023, ...),
9806                 startSubframeNumber                                     INTEGER (0..9, ...),
9807                 iE-Extensions                                           ProtocolExtensionContainer { {CoMPInformationStartTime-ExtIEs} } OPTIONAL,
9808                 ...
9809         }
9810 */
9811
9812 struct CoMPInformationStartTime_elm : asn::sequence<3, 0, true, 1>
9813 {
9814         static constexpr const char* name() {return "CoMPInformationStartTime_elm";}
9815         using parent_t = asn::sequence<3, 0, true, 1>;
9816         struct startSFN_t : asn::integer<>
9817         {
9818                 using constraint_t = asn::constraints<true,asn::span<0, 1023>>;
9819                 static constexpr const char* name() {return "startSFN_t";}
9820                 using parent_t = asn::integer<>;
9821
9822         };
9823
9824         startSFN_t& ref_startSFN() {return startSFN;}
9825         startSFN_t const& ref_startSFN() const {return startSFN;}
9826         struct startSubframeNumber_t : asn::integer<>
9827         {
9828                 using constraint_t = asn::constraints<true,asn::span<0, 9>>;
9829                 static constexpr const char* name() {return "startSubframeNumber_t";}
9830                 using parent_t = asn::integer<>;
9831
9832         };
9833
9834         startSubframeNumber_t& ref_startSubframeNumber() {return startSubframeNumber;}
9835         startSubframeNumber_t const& ref_startSubframeNumber() const {return startSubframeNumber;}
9836         struct iE_Extensions_t : ProtocolExtensionContainer<CoMPInformationStartTime_ExtIEs>
9837         {
9838                 static constexpr const char* name() {return "iE_Extensions_t";}
9839                 using parent_t = ProtocolExtensionContainer<CoMPInformationStartTime_ExtIEs>;
9840                 static constexpr bool optional = true;
9841
9842         };
9843         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
9844         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
9845         template<typename V> void decode(V& v)
9846         {
9847                 v(startSFN);
9848                 v(startSubframeNumber);
9849                 v(iE_Extensions);
9850
9851         };
9852         template<typename V> void encode(V& v) const
9853         {
9854                 v(startSFN);
9855                 v(startSubframeNumber);
9856                 v(iE_Extensions);
9857
9858         };
9859         void clear()
9860         {
9861                 startSFN.clear();
9862                 startSubframeNumber.clear();
9863                 iE_Extensions.clear();
9864
9865         };
9866         private:
9867         startSFN_t      startSFN;
9868         startSubframeNumber_t   startSubframeNumber;
9869         iE_Extensions_t iE_Extensions;
9870
9871 };
9872 struct CoMPInformationStartTime : asn::sequenceof<CoMPInformationStartTime_elm>
9873 {
9874         static constexpr const char* name() {return "CoMPInformationStartTime";}
9875         using parent_t = asn::sequenceof<CoMPInformationStartTime_elm>;
9876         using constraint_t = asn::constraints<false,asn::span<0, 1>>;
9877
9878 };
9879 /*
9880 CoMPInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
9881         ...
9882 }
9883 */
9884
9885 struct CoMPInformation_ExtIEs
9886 {
9887         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
9888         {
9889                 size_t get_index() const {return type;}
9890                 bool is_unknown() const { return type == 1; }
9891                 void clear() {type = 0;}
9892                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
9893                 template<typename V>  bool decode(V& v)
9894                 {
9895                         clear();
9896                         if(!v(ref_nested())) return false;
9897                         { type = 1; return true;}
9898                         return false;
9899
9900                 }
9901                 template<typename V> bool encode(V& v) const
9902                 {
9903                         return v(ref_nested());
9904
9905                 }
9906                 protected:
9907                 template<typename V>  bool decode(size_t index, V& v)
9908                 {
9909                         clear();
9910                         switch(index)
9911                         {
9912                         case 1: type = 1; return v(ref_nested());
9913                         ref_nested().clear();
9914                         }
9915                         return false;
9916
9917                 }
9918                 template<typename V> bool encode(size_t index, V& v) const
9919                 {
9920                         if(index != type) {return false;} return v(ref_nested());
9921
9922                 }
9923                 private:
9924                 size_t type {0};
9925
9926         };
9927         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
9928         {
9929                 size_t get_index() const {return type;}
9930                 bool is_unknown() const { return type == 1; }
9931                 void clear() {type = 0;}
9932                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
9933                 template<typename V>  bool decode(V& v)
9934                 {
9935                         clear();
9936                         if(!v(ref_nested())) return false;
9937                         { type = 1; return true;}
9938                         return false;
9939
9940                 }
9941                 template<typename V> bool encode(V& v) const
9942                 {
9943                         return v(ref_nested());
9944
9945                 }
9946                 protected:
9947                 template<typename V>  bool decode(size_t index, V& v)
9948                 {
9949                         clear();
9950                         switch(index)
9951                         {
9952                         case 1: type = 1; return v(ref_nested());
9953                         ref_nested().clear();
9954                         }
9955                         return false;
9956
9957                 }
9958                 template<typename V> bool encode(size_t index, V& v) const
9959                 {
9960                         if(index != type) {return false;} return v(ref_nested());
9961
9962                 }
9963                 private:
9964                 size_t type {0};
9965
9966         };
9967         struct Extension_t : asn::typefield<true>
9968         {
9969                 ~Extension_t()  {clear();}
9970                 size_t get_index() const {return type;}
9971                 bool is_unknown() const { return type == 1; }
9972                 void clear()
9973                 {
9974                         type = 0; ref_nested().clear();
9975                 }
9976                 template<typename V> static inline void enumerate(V& v)
9977                 {
9978
9979                 }
9980                 protected:
9981                 template<typename V> bool decode(size_t index, V& v)
9982                 {
9983                         clear();
9984                         switch(index)
9985                         {
9986                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
9987                         }
9988                         return false;
9989
9990                 }
9991                 template<typename V> bool encode(size_t index, V& v) const
9992                 {
9993                         if(index != type) return false;
9994                         return false;
9995
9996                 }
9997                 private:
9998                 size_t type {0};
9999
10000         };
10001         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
10002         {
10003                 size_t get_index() const {return type;}
10004                 bool is_unknown() const { return type == 1; }
10005                 void clear() {type = 0;}
10006                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
10007                 template<typename V>  bool decode(V& v)
10008                 {
10009                         clear();
10010                         if(!v(ref_nested())) return false;
10011                         { type = 1; return true;}
10012                         return false;
10013
10014                 }
10015                 template<typename V> bool encode(V& v) const
10016                 {
10017                         return v(ref_nested());
10018
10019                 }
10020                 protected:
10021                 template<typename V>  bool decode(size_t index, V& v)
10022                 {
10023                         clear();
10024                         switch(index)
10025                         {
10026                         case 1: type = 1; return v(ref_nested());
10027                         ref_nested().clear();
10028                         }
10029                         return false;
10030
10031                 }
10032                 template<typename V> bool encode(size_t index, V& v) const
10033                 {
10034                         if(index != type) {return false;} return v(ref_nested());
10035
10036                 }
10037                 private:
10038                 size_t type {0};
10039
10040         };
10041
10042 };
10043 /*
10044 CoMPInformation ::= SEQUENCE {
10045         coMPInformationItem                                             CoMPInformationItem,
10046         coMPInformationStartTime                                CoMPInformationStartTime,
10047         iE-Extensions                                                   ProtocolExtensionContainer { {CoMPInformation-ExtIEs} } OPTIONAL,
10048         ...
10049 }
10050 */
10051
10052 struct CoMPInformation : asn::sequence<3, 0, true, 1>
10053 {
10054         static constexpr const char* name() {return "CoMPInformation";}
10055         using parent_t = asn::sequence<3, 0, true, 1>;
10056         struct coMPInformationItem_t : CoMPInformationItem
10057         {
10058                 static constexpr const char* name() {return "coMPInformationItem_t";}
10059                 using parent_t = CoMPInformationItem;
10060
10061         };
10062         coMPInformationItem_t& ref_coMPInformationItem() {return coMPInformationItem;}
10063         coMPInformationItem_t const& ref_coMPInformationItem() const {return coMPInformationItem;}
10064         struct coMPInformationStartTime_t : CoMPInformationStartTime
10065         {
10066                 static constexpr const char* name() {return "coMPInformationStartTime_t";}
10067                 using parent_t = CoMPInformationStartTime;
10068
10069         };
10070         coMPInformationStartTime_t& ref_coMPInformationStartTime() {return coMPInformationStartTime;}
10071         coMPInformationStartTime_t const& ref_coMPInformationStartTime() const {return coMPInformationStartTime;}
10072         struct iE_Extensions_t : ProtocolExtensionContainer<CoMPInformation_ExtIEs>
10073         {
10074                 static constexpr const char* name() {return "iE_Extensions_t";}
10075                 using parent_t = ProtocolExtensionContainer<CoMPInformation_ExtIEs>;
10076                 static constexpr bool optional = true;
10077
10078         };
10079         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
10080         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
10081         template<typename V> void decode(V& v)
10082         {
10083                 v(coMPInformationItem);
10084                 v(coMPInformationStartTime);
10085                 v(iE_Extensions);
10086
10087         };
10088         template<typename V> void encode(V& v) const
10089         {
10090                 v(coMPInformationItem);
10091                 v(coMPInformationStartTime);
10092                 v(iE_Extensions);
10093
10094         };
10095         void clear()
10096         {
10097                 coMPInformationItem.clear();
10098                 coMPInformationStartTime.clear();
10099                 iE_Extensions.clear();
10100
10101         };
10102         private:
10103         coMPInformationItem_t   coMPInformationItem;
10104         coMPInformationStartTime_t      coMPInformationStartTime;
10105         iE_Extensions_t iE_Extensions;
10106
10107 };
10108 /*
10109 CompositeAvailableCapacity-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
10110         ...
10111 }
10112 */
10113
10114 struct CompositeAvailableCapacity_ExtIEs
10115 {
10116         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
10117         {
10118                 size_t get_index() const {return type;}
10119                 bool is_unknown() const { return type == 1; }
10120                 void clear() {type = 0;}
10121                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
10122                 template<typename V>  bool decode(V& v)
10123                 {
10124                         clear();
10125                         if(!v(ref_nested())) return false;
10126                         { type = 1; return true;}
10127                         return false;
10128
10129                 }
10130                 template<typename V> bool encode(V& v) const
10131                 {
10132                         return v(ref_nested());
10133
10134                 }
10135                 protected:
10136                 template<typename V>  bool decode(size_t index, V& v)
10137                 {
10138                         clear();
10139                         switch(index)
10140                         {
10141                         case 1: type = 1; return v(ref_nested());
10142                         ref_nested().clear();
10143                         }
10144                         return false;
10145
10146                 }
10147                 template<typename V> bool encode(size_t index, V& v) const
10148                 {
10149                         if(index != type) {return false;} return v(ref_nested());
10150
10151                 }
10152                 private:
10153                 size_t type {0};
10154
10155         };
10156         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
10157         {
10158                 size_t get_index() const {return type;}
10159                 bool is_unknown() const { return type == 1; }
10160                 void clear() {type = 0;}
10161                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
10162                 template<typename V>  bool decode(V& v)
10163                 {
10164                         clear();
10165                         if(!v(ref_nested())) return false;
10166                         { type = 1; return true;}
10167                         return false;
10168
10169                 }
10170                 template<typename V> bool encode(V& v) const
10171                 {
10172                         return v(ref_nested());
10173
10174                 }
10175                 protected:
10176                 template<typename V>  bool decode(size_t index, V& v)
10177                 {
10178                         clear();
10179                         switch(index)
10180                         {
10181                         case 1: type = 1; return v(ref_nested());
10182                         ref_nested().clear();
10183                         }
10184                         return false;
10185
10186                 }
10187                 template<typename V> bool encode(size_t index, V& v) const
10188                 {
10189                         if(index != type) {return false;} return v(ref_nested());
10190
10191                 }
10192                 private:
10193                 size_t type {0};
10194
10195         };
10196         struct Extension_t : asn::typefield<true>
10197         {
10198                 ~Extension_t()  {clear();}
10199                 size_t get_index() const {return type;}
10200                 bool is_unknown() const { return type == 1; }
10201                 void clear()
10202                 {
10203                         type = 0; ref_nested().clear();
10204                 }
10205                 template<typename V> static inline void enumerate(V& v)
10206                 {
10207
10208                 }
10209                 protected:
10210                 template<typename V> bool decode(size_t index, V& v)
10211                 {
10212                         clear();
10213                         switch(index)
10214                         {
10215                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
10216                         }
10217                         return false;
10218
10219                 }
10220                 template<typename V> bool encode(size_t index, V& v) const
10221                 {
10222                         if(index != type) return false;
10223                         return false;
10224
10225                 }
10226                 private:
10227                 size_t type {0};
10228
10229         };
10230         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
10231         {
10232                 size_t get_index() const {return type;}
10233                 bool is_unknown() const { return type == 1; }
10234                 void clear() {type = 0;}
10235                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
10236                 template<typename V>  bool decode(V& v)
10237                 {
10238                         clear();
10239                         if(!v(ref_nested())) return false;
10240                         { type = 1; return true;}
10241                         return false;
10242
10243                 }
10244                 template<typename V> bool encode(V& v) const
10245                 {
10246                         return v(ref_nested());
10247
10248                 }
10249                 protected:
10250                 template<typename V>  bool decode(size_t index, V& v)
10251                 {
10252                         clear();
10253                         switch(index)
10254                         {
10255                         case 1: type = 1; return v(ref_nested());
10256                         ref_nested().clear();
10257                         }
10258                         return false;
10259
10260                 }
10261                 template<typename V> bool encode(size_t index, V& v) const
10262                 {
10263                         if(index != type) {return false;} return v(ref_nested());
10264
10265                 }
10266                 private:
10267                 size_t type {0};
10268
10269         };
10270
10271 };
10272 /*
10273 CompositeAvailableCapacity ::= SEQUENCE {
10274         cellCapacityClassValue                                                  CellCapacityClassValue                          OPTIONAL,
10275         capacityValue                                                                   CapacityValue,
10276         iE-Extensions                                                                   ProtocolExtensionContainer { {CompositeAvailableCapacity-ExtIEs} } OPTIONAL,
10277         ...
10278 }
10279 */
10280
10281 struct CompositeAvailableCapacity : asn::sequence<3, 0, true, 2>
10282 {
10283         static constexpr const char* name() {return "CompositeAvailableCapacity";}
10284         using parent_t = asn::sequence<3, 0, true, 2>;
10285         struct cellCapacityClassValue_t : CellCapacityClassValue
10286         {
10287                 static constexpr const char* name() {return "cellCapacityClassValue_t";}
10288                 using parent_t = CellCapacityClassValue;
10289                 static constexpr bool optional = true;
10290
10291         };
10292         cellCapacityClassValue_t& set_cellCapacityClassValue() { cellCapacityClassValue.setpresent(true); return cellCapacityClassValue;}
10293         cellCapacityClassValue_t const* get_cellCapacityClassValue() const {return cellCapacityClassValue.is_valid() ? &cellCapacityClassValue : nullptr;}
10294         struct capacityValue_t : CapacityValue
10295         {
10296                 static constexpr const char* name() {return "capacityValue_t";}
10297                 using parent_t = CapacityValue;
10298
10299         };
10300         capacityValue_t& ref_capacityValue() {return capacityValue;}
10301         capacityValue_t const& ref_capacityValue() const {return capacityValue;}
10302         struct iE_Extensions_t : ProtocolExtensionContainer<CompositeAvailableCapacity_ExtIEs>
10303         {
10304                 static constexpr const char* name() {return "iE_Extensions_t";}
10305                 using parent_t = ProtocolExtensionContainer<CompositeAvailableCapacity_ExtIEs>;
10306                 static constexpr bool optional = true;
10307
10308         };
10309         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
10310         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
10311         template<typename V> void decode(V& v)
10312         {
10313                 v(cellCapacityClassValue);
10314                 v(capacityValue);
10315                 v(iE_Extensions);
10316
10317         };
10318         template<typename V> void encode(V& v) const
10319         {
10320                 v(cellCapacityClassValue);
10321                 v(capacityValue);
10322                 v(iE_Extensions);
10323
10324         };
10325         void clear()
10326         {
10327                 cellCapacityClassValue.clear();
10328                 capacityValue.clear();
10329                 iE_Extensions.clear();
10330
10331         };
10332         private:
10333         cellCapacityClassValue_t        cellCapacityClassValue;
10334         capacityValue_t capacityValue;
10335         iE_Extensions_t iE_Extensions;
10336
10337 };
10338 /*
10339 CompositeAvailableCapacityGroup-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
10340         ...
10341 }
10342 */
10343
10344 struct CompositeAvailableCapacityGroup_ExtIEs
10345 {
10346         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
10347         {
10348                 size_t get_index() const {return type;}
10349                 bool is_unknown() const { return type == 1; }
10350                 void clear() {type = 0;}
10351                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
10352                 template<typename V>  bool decode(V& v)
10353                 {
10354                         clear();
10355                         if(!v(ref_nested())) return false;
10356                         { type = 1; return true;}
10357                         return false;
10358
10359                 }
10360                 template<typename V> bool encode(V& v) const
10361                 {
10362                         return v(ref_nested());
10363
10364                 }
10365                 protected:
10366                 template<typename V>  bool decode(size_t index, V& v)
10367                 {
10368                         clear();
10369                         switch(index)
10370                         {
10371                         case 1: type = 1; return v(ref_nested());
10372                         ref_nested().clear();
10373                         }
10374                         return false;
10375
10376                 }
10377                 template<typename V> bool encode(size_t index, V& v) const
10378                 {
10379                         if(index != type) {return false;} return v(ref_nested());
10380
10381                 }
10382                 private:
10383                 size_t type {0};
10384
10385         };
10386         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
10387         {
10388                 size_t get_index() const {return type;}
10389                 bool is_unknown() const { return type == 1; }
10390                 void clear() {type = 0;}
10391                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
10392                 template<typename V>  bool decode(V& v)
10393                 {
10394                         clear();
10395                         if(!v(ref_nested())) return false;
10396                         { type = 1; return true;}
10397                         return false;
10398
10399                 }
10400                 template<typename V> bool encode(V& v) const
10401                 {
10402                         return v(ref_nested());
10403
10404                 }
10405                 protected:
10406                 template<typename V>  bool decode(size_t index, V& v)
10407                 {
10408                         clear();
10409                         switch(index)
10410                         {
10411                         case 1: type = 1; return v(ref_nested());
10412                         ref_nested().clear();
10413                         }
10414                         return false;
10415
10416                 }
10417                 template<typename V> bool encode(size_t index, V& v) const
10418                 {
10419                         if(index != type) {return false;} return v(ref_nested());
10420
10421                 }
10422                 private:
10423                 size_t type {0};
10424
10425         };
10426         struct Extension_t : asn::typefield<true>
10427         {
10428                 ~Extension_t()  {clear();}
10429                 size_t get_index() const {return type;}
10430                 bool is_unknown() const { return type == 1; }
10431                 void clear()
10432                 {
10433                         type = 0; ref_nested().clear();
10434                 }
10435                 template<typename V> static inline void enumerate(V& v)
10436                 {
10437
10438                 }
10439                 protected:
10440                 template<typename V> bool decode(size_t index, V& v)
10441                 {
10442                         clear();
10443                         switch(index)
10444                         {
10445                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
10446                         }
10447                         return false;
10448
10449                 }
10450                 template<typename V> bool encode(size_t index, V& v) const
10451                 {
10452                         if(index != type) return false;
10453                         return false;
10454
10455                 }
10456                 private:
10457                 size_t type {0};
10458
10459         };
10460         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
10461         {
10462                 size_t get_index() const {return type;}
10463                 bool is_unknown() const { return type == 1; }
10464                 void clear() {type = 0;}
10465                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
10466                 template<typename V>  bool decode(V& v)
10467                 {
10468                         clear();
10469                         if(!v(ref_nested())) return false;
10470                         { type = 1; return true;}
10471                         return false;
10472
10473                 }
10474                 template<typename V> bool encode(V& v) const
10475                 {
10476                         return v(ref_nested());
10477
10478                 }
10479                 protected:
10480                 template<typename V>  bool decode(size_t index, V& v)
10481                 {
10482                         clear();
10483                         switch(index)
10484                         {
10485                         case 1: type = 1; return v(ref_nested());
10486                         ref_nested().clear();
10487                         }
10488                         return false;
10489
10490                 }
10491                 template<typename V> bool encode(size_t index, V& v) const
10492                 {
10493                         if(index != type) {return false;} return v(ref_nested());
10494
10495                 }
10496                 private:
10497                 size_t type {0};
10498
10499         };
10500
10501 };
10502 /*
10503 CompositeAvailableCapacityGroup ::= SEQUENCE {
10504         dL-CompositeAvailableCapacity                                   CompositeAvailableCapacity,
10505         uL-CompositeAvailableCapacity                                   CompositeAvailableCapacity,
10506         iE-Extensions                                                                   ProtocolExtensionContainer { {CompositeAvailableCapacityGroup-ExtIEs} } OPTIONAL,
10507         ...
10508 }
10509 */
10510
10511 struct CompositeAvailableCapacityGroup : asn::sequence<3, 0, true, 1>
10512 {
10513         static constexpr const char* name() {return "CompositeAvailableCapacityGroup";}
10514         using parent_t = asn::sequence<3, 0, true, 1>;
10515         struct dL_CompositeAvailableCapacity_t : CompositeAvailableCapacity
10516         {
10517                 static constexpr const char* name() {return "dL_CompositeAvailableCapacity_t";}
10518                 using parent_t = CompositeAvailableCapacity;
10519
10520         };
10521         dL_CompositeAvailableCapacity_t& ref_dL_CompositeAvailableCapacity() {return dL_CompositeAvailableCapacity;}
10522         dL_CompositeAvailableCapacity_t const& ref_dL_CompositeAvailableCapacity() const {return dL_CompositeAvailableCapacity;}
10523         struct uL_CompositeAvailableCapacity_t : CompositeAvailableCapacity
10524         {
10525                 static constexpr const char* name() {return "uL_CompositeAvailableCapacity_t";}
10526                 using parent_t = CompositeAvailableCapacity;
10527
10528         };
10529         uL_CompositeAvailableCapacity_t& ref_uL_CompositeAvailableCapacity() {return uL_CompositeAvailableCapacity;}
10530         uL_CompositeAvailableCapacity_t const& ref_uL_CompositeAvailableCapacity() const {return uL_CompositeAvailableCapacity;}
10531         struct iE_Extensions_t : ProtocolExtensionContainer<CompositeAvailableCapacityGroup_ExtIEs>
10532         {
10533                 static constexpr const char* name() {return "iE_Extensions_t";}
10534                 using parent_t = ProtocolExtensionContainer<CompositeAvailableCapacityGroup_ExtIEs>;
10535                 static constexpr bool optional = true;
10536
10537         };
10538         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
10539         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
10540         template<typename V> void decode(V& v)
10541         {
10542                 v(dL_CompositeAvailableCapacity);
10543                 v(uL_CompositeAvailableCapacity);
10544                 v(iE_Extensions);
10545
10546         };
10547         template<typename V> void encode(V& v) const
10548         {
10549                 v(dL_CompositeAvailableCapacity);
10550                 v(uL_CompositeAvailableCapacity);
10551                 v(iE_Extensions);
10552
10553         };
10554         void clear()
10555         {
10556                 dL_CompositeAvailableCapacity.clear();
10557                 uL_CompositeAvailableCapacity.clear();
10558                 iE_Extensions.clear();
10559
10560         };
10561         private:
10562         dL_CompositeAvailableCapacity_t dL_CompositeAvailableCapacity;
10563         uL_CompositeAvailableCapacity_t uL_CompositeAvailableCapacity;
10564         iE_Extensions_t iE_Extensions;
10565
10566 };
10567 /*
10568 Correlation-ID ::= OCTET STRING (SIZE (4))
10569 */
10570
10571 struct Correlation_ID : asn::ostring<>
10572 {
10573         using constraint_t = asn::constraints<false,asn::one<4>>;
10574         static constexpr const char* name() {return "Correlation-ID";}
10575         using parent_t = asn::ostring<>;
10576
10577 };
10578
10579 /*
10580 CoverageModification-Item ::= SEQUENCE {
10581         eCGI                                                    ECGI,
10582         coverageState                                   INTEGER (0..15, ...),
10583         cellDeploymentStatusIndicator   CellDeploymentStatusIndicator                   OPTIONAL,
10584         cellReplacingInfo                               CellReplacingInfo                                               OPTIONAL,
10585 -- Included in case the Cell Deployment Status Indicator IE is present
10586         ...
10587 }
10588 */
10589
10590 struct CoverageModification_Item : asn::sequence<4, 0, true, 2>
10591 {
10592         static constexpr const char* name() {return "CoverageModification-Item";}
10593         using parent_t = asn::sequence<4, 0, true, 2>;
10594         struct eCGI_t : ECGI
10595         {
10596                 static constexpr const char* name() {return "eCGI_t";}
10597                 using parent_t = ECGI;
10598
10599         };
10600         eCGI_t& ref_eCGI() {return eCGI;}
10601         eCGI_t const& ref_eCGI() const {return eCGI;}
10602         struct coverageState_t : asn::integer<>
10603         {
10604                 using constraint_t = asn::constraints<true,asn::span<0, 15>>;
10605                 static constexpr const char* name() {return "coverageState_t";}
10606                 using parent_t = asn::integer<>;
10607
10608         };
10609
10610         coverageState_t& ref_coverageState() {return coverageState;}
10611         coverageState_t const& ref_coverageState() const {return coverageState;}
10612         struct cellDeploymentStatusIndicator_t : CellDeploymentStatusIndicator
10613         {
10614                 static constexpr const char* name() {return "cellDeploymentStatusIndicator_t";}
10615                 using parent_t = CellDeploymentStatusIndicator;
10616                 static constexpr bool optional = true;
10617
10618         };
10619         cellDeploymentStatusIndicator_t& set_cellDeploymentStatusIndicator() { cellDeploymentStatusIndicator.setpresent(true); return cellDeploymentStatusIndicator;}
10620         cellDeploymentStatusIndicator_t const* get_cellDeploymentStatusIndicator() const {return cellDeploymentStatusIndicator.is_valid() ? &cellDeploymentStatusIndicator : nullptr;}
10621         struct cellReplacingInfo_t : CellReplacingInfo
10622         {
10623                 static constexpr const char* name() {return "cellReplacingInfo_t";}
10624                 using parent_t = CellReplacingInfo;
10625                 static constexpr bool optional = true;
10626
10627         };
10628         cellReplacingInfo_t& set_cellReplacingInfo() { cellReplacingInfo.setpresent(true); return cellReplacingInfo;}
10629         cellReplacingInfo_t const* get_cellReplacingInfo() const {return cellReplacingInfo.is_valid() ? &cellReplacingInfo : nullptr;}
10630         template<typename V> void decode(V& v)
10631         {
10632                 v(eCGI);
10633                 v(coverageState);
10634                 v(cellDeploymentStatusIndicator);
10635                 v(cellReplacingInfo);
10636
10637         };
10638         template<typename V> void encode(V& v) const
10639         {
10640                 v(eCGI);
10641                 v(coverageState);
10642                 v(cellDeploymentStatusIndicator);
10643                 v(cellReplacingInfo);
10644
10645         };
10646         void clear()
10647         {
10648                 eCGI.clear();
10649                 coverageState.clear();
10650                 cellDeploymentStatusIndicator.clear();
10651                 cellReplacingInfo.clear();
10652
10653         };
10654         private:
10655         eCGI_t  eCGI;
10656         coverageState_t coverageState;
10657         cellDeploymentStatusIndicator_t cellDeploymentStatusIndicator;
10658         cellReplacingInfo_t     cellReplacingInfo;
10659
10660 };
10661 /*
10662 CoverageModificationList ::= SEQUENCE (SIZE (1..maxCellineNB)) OF CoverageModification-Item
10663 */
10664
10665 struct CoverageModificationList_elm : CoverageModification_Item
10666 {
10667         static constexpr const char* name() {return "CoverageModificationList_elm";}
10668         using parent_t = CoverageModification_Item;
10669
10670 };
10671 struct CoverageModificationList : asn::sequenceof<CoverageModificationList_elm>
10672 {
10673         static constexpr const char* name() {return "CoverageModificationList";}
10674         using parent_t = asn::sequenceof<CoverageModificationList_elm>;
10675         using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
10676
10677 };
10678 /*
10679 TypeOfError ::= ENUMERATED {
10680         not-understood,
10681         missing,
10682         ...
10683 }
10684 */
10685
10686 struct TypeOfError : asn::enumerated<2, 0, true>
10687 {
10688         static constexpr const char* name() {return "TypeOfError";}
10689         using parent_t = asn::enumerated<2, 0, true>;
10690         typedef enum {
10691                 not_understood
10692                 ,missing
10693         } index_t;
10694
10695 };
10696
10697 /*
10698 CriticalityDiagnostics-IE-List-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
10699         ...
10700 }
10701 */
10702
10703 struct CriticalityDiagnostics_IE_List_ExtIEs
10704 {
10705         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
10706         {
10707                 size_t get_index() const {return type;}
10708                 bool is_unknown() const { return type == 1; }
10709                 void clear() {type = 0;}
10710                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
10711                 template<typename V>  bool decode(V& v)
10712                 {
10713                         clear();
10714                         if(!v(ref_nested())) return false;
10715                         { type = 1; return true;}
10716                         return false;
10717
10718                 }
10719                 template<typename V> bool encode(V& v) const
10720                 {
10721                         return v(ref_nested());
10722
10723                 }
10724                 protected:
10725                 template<typename V>  bool decode(size_t index, V& v)
10726                 {
10727                         clear();
10728                         switch(index)
10729                         {
10730                         case 1: type = 1; return v(ref_nested());
10731                         ref_nested().clear();
10732                         }
10733                         return false;
10734
10735                 }
10736                 template<typename V> bool encode(size_t index, V& v) const
10737                 {
10738                         if(index != type) {return false;} return v(ref_nested());
10739
10740                 }
10741                 private:
10742                 size_t type {0};
10743
10744         };
10745         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
10746         {
10747                 size_t get_index() const {return type;}
10748                 bool is_unknown() const { return type == 1; }
10749                 void clear() {type = 0;}
10750                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
10751                 template<typename V>  bool decode(V& v)
10752                 {
10753                         clear();
10754                         if(!v(ref_nested())) return false;
10755                         { type = 1; return true;}
10756                         return false;
10757
10758                 }
10759                 template<typename V> bool encode(V& v) const
10760                 {
10761                         return v(ref_nested());
10762
10763                 }
10764                 protected:
10765                 template<typename V>  bool decode(size_t index, V& v)
10766                 {
10767                         clear();
10768                         switch(index)
10769                         {
10770                         case 1: type = 1; return v(ref_nested());
10771                         ref_nested().clear();
10772                         }
10773                         return false;
10774
10775                 }
10776                 template<typename V> bool encode(size_t index, V& v) const
10777                 {
10778                         if(index != type) {return false;} return v(ref_nested());
10779
10780                 }
10781                 private:
10782                 size_t type {0};
10783
10784         };
10785         struct Extension_t : asn::typefield<true>
10786         {
10787                 ~Extension_t()  {clear();}
10788                 size_t get_index() const {return type;}
10789                 bool is_unknown() const { return type == 1; }
10790                 void clear()
10791                 {
10792                         type = 0; ref_nested().clear();
10793                 }
10794                 template<typename V> static inline void enumerate(V& v)
10795                 {
10796
10797                 }
10798                 protected:
10799                 template<typename V> bool decode(size_t index, V& v)
10800                 {
10801                         clear();
10802                         switch(index)
10803                         {
10804                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
10805                         }
10806                         return false;
10807
10808                 }
10809                 template<typename V> bool encode(size_t index, V& v) const
10810                 {
10811                         if(index != type) return false;
10812                         return false;
10813
10814                 }
10815                 private:
10816                 size_t type {0};
10817
10818         };
10819         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
10820         {
10821                 size_t get_index() const {return type;}
10822                 bool is_unknown() const { return type == 1; }
10823                 void clear() {type = 0;}
10824                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
10825                 template<typename V>  bool decode(V& v)
10826                 {
10827                         clear();
10828                         if(!v(ref_nested())) return false;
10829                         { type = 1; return true;}
10830                         return false;
10831
10832                 }
10833                 template<typename V> bool encode(V& v) const
10834                 {
10835                         return v(ref_nested());
10836
10837                 }
10838                 protected:
10839                 template<typename V>  bool decode(size_t index, V& v)
10840                 {
10841                         clear();
10842                         switch(index)
10843                         {
10844                         case 1: type = 1; return v(ref_nested());
10845                         ref_nested().clear();
10846                         }
10847                         return false;
10848
10849                 }
10850                 template<typename V> bool encode(size_t index, V& v) const
10851                 {
10852                         if(index != type) {return false;} return v(ref_nested());
10853
10854                 }
10855                 private:
10856                 size_t type {0};
10857
10858         };
10859
10860 };
10861 /*
10862 CriticalityDiagnostics-IE-List ::= SEQUENCE (SIZE (1..maxNrOfErrors)) OF
10863         SEQUENCE {
10864                 iECriticality                   Criticality,
10865                 iE-ID                                   ProtocolIE-ID,
10866                 typeOfError                             TypeOfError,
10867                 iE-Extensions                   ProtocolExtensionContainer { {CriticalityDiagnostics-IE-List-ExtIEs} } OPTIONAL,
10868                 ...
10869 }
10870 */
10871
10872 struct CriticalityDiagnostics_IE_List_elm : asn::sequence<4, 0, true, 1>
10873 {
10874         static constexpr const char* name() {return "CriticalityDiagnostics_IE_List_elm";}
10875         using parent_t = asn::sequence<4, 0, true, 1>;
10876         struct iECriticality_t : Criticality
10877         {
10878                 static constexpr const char* name() {return "iECriticality_t";}
10879                 using parent_t = Criticality;
10880
10881         };
10882         iECriticality_t& ref_iECriticality() {return iECriticality;}
10883         iECriticality_t const& ref_iECriticality() const {return iECriticality;}
10884         struct iE_ID_t : ProtocolIE_ID
10885         {
10886                 static constexpr const char* name() {return "iE_ID_t";}
10887                 using parent_t = ProtocolIE_ID;
10888
10889         };
10890         iE_ID_t& ref_iE_ID() {return iE_ID;}
10891         iE_ID_t const& ref_iE_ID() const {return iE_ID;}
10892         struct typeOfError_t : TypeOfError
10893         {
10894                 static constexpr const char* name() {return "typeOfError_t";}
10895                 using parent_t = TypeOfError;
10896
10897         };
10898         typeOfError_t& ref_typeOfError() {return typeOfError;}
10899         typeOfError_t const& ref_typeOfError() const {return typeOfError;}
10900         struct iE_Extensions_t : ProtocolExtensionContainer<CriticalityDiagnostics_IE_List_ExtIEs>
10901         {
10902                 static constexpr const char* name() {return "iE_Extensions_t";}
10903                 using parent_t = ProtocolExtensionContainer<CriticalityDiagnostics_IE_List_ExtIEs>;
10904                 static constexpr bool optional = true;
10905
10906         };
10907         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
10908         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
10909         template<typename V> void decode(V& v)
10910         {
10911                 v(iECriticality);
10912                 v(iE_ID);
10913                 v(typeOfError);
10914                 v(iE_Extensions);
10915
10916         };
10917         template<typename V> void encode(V& v) const
10918         {
10919                 v(iECriticality);
10920                 v(iE_ID);
10921                 v(typeOfError);
10922                 v(iE_Extensions);
10923
10924         };
10925         void clear()
10926         {
10927                 iECriticality.clear();
10928                 iE_ID.clear();
10929                 typeOfError.clear();
10930                 iE_Extensions.clear();
10931
10932         };
10933         private:
10934         iECriticality_t iECriticality;
10935         iE_ID_t iE_ID;
10936         typeOfError_t   typeOfError;
10937         iE_Extensions_t iE_Extensions;
10938
10939 };
10940 struct CriticalityDiagnostics_IE_List : asn::sequenceof<CriticalityDiagnostics_IE_List_elm>
10941 {
10942         static constexpr const char* name() {return "CriticalityDiagnostics-IE-List";}
10943         using parent_t = asn::sequenceof<CriticalityDiagnostics_IE_List_elm>;
10944         using constraint_t = asn::constraints<false,asn::span<1,  maxNrOfErrors >>;
10945
10946 };
10947 /*
10948 CriticalityDiagnostics-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
10949         ...
10950 }
10951 */
10952
10953 struct CriticalityDiagnostics_ExtIEs
10954 {
10955         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
10956         {
10957                 size_t get_index() const {return type;}
10958                 bool is_unknown() const { return type == 1; }
10959                 void clear() {type = 0;}
10960                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
10961                 template<typename V>  bool decode(V& v)
10962                 {
10963                         clear();
10964                         if(!v(ref_nested())) return false;
10965                         { type = 1; return true;}
10966                         return false;
10967
10968                 }
10969                 template<typename V> bool encode(V& v) const
10970                 {
10971                         return v(ref_nested());
10972
10973                 }
10974                 protected:
10975                 template<typename V>  bool decode(size_t index, V& v)
10976                 {
10977                         clear();
10978                         switch(index)
10979                         {
10980                         case 1: type = 1; return v(ref_nested());
10981                         ref_nested().clear();
10982                         }
10983                         return false;
10984
10985                 }
10986                 template<typename V> bool encode(size_t index, V& v) const
10987                 {
10988                         if(index != type) {return false;} return v(ref_nested());
10989
10990                 }
10991                 private:
10992                 size_t type {0};
10993
10994         };
10995         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
10996         {
10997                 size_t get_index() const {return type;}
10998                 bool is_unknown() const { return type == 1; }
10999                 void clear() {type = 0;}
11000                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
11001                 template<typename V>  bool decode(V& v)
11002                 {
11003                         clear();
11004                         if(!v(ref_nested())) return false;
11005                         { type = 1; return true;}
11006                         return false;
11007
11008                 }
11009                 template<typename V> bool encode(V& v) const
11010                 {
11011                         return v(ref_nested());
11012
11013                 }
11014                 protected:
11015                 template<typename V>  bool decode(size_t index, V& v)
11016                 {
11017                         clear();
11018                         switch(index)
11019                         {
11020                         case 1: type = 1; return v(ref_nested());
11021                         ref_nested().clear();
11022                         }
11023                         return false;
11024
11025                 }
11026                 template<typename V> bool encode(size_t index, V& v) const
11027                 {
11028                         if(index != type) {return false;} return v(ref_nested());
11029
11030                 }
11031                 private:
11032                 size_t type {0};
11033
11034         };
11035         struct Extension_t : asn::typefield<true>
11036         {
11037                 ~Extension_t()  {clear();}
11038                 size_t get_index() const {return type;}
11039                 bool is_unknown() const { return type == 1; }
11040                 void clear()
11041                 {
11042                         type = 0; ref_nested().clear();
11043                 }
11044                 template<typename V> static inline void enumerate(V& v)
11045                 {
11046
11047                 }
11048                 protected:
11049                 template<typename V> bool decode(size_t index, V& v)
11050                 {
11051                         clear();
11052                         switch(index)
11053                         {
11054                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
11055                         }
11056                         return false;
11057
11058                 }
11059                 template<typename V> bool encode(size_t index, V& v) const
11060                 {
11061                         if(index != type) return false;
11062                         return false;
11063
11064                 }
11065                 private:
11066                 size_t type {0};
11067
11068         };
11069         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
11070         {
11071                 size_t get_index() const {return type;}
11072                 bool is_unknown() const { return type == 1; }
11073                 void clear() {type = 0;}
11074                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
11075                 template<typename V>  bool decode(V& v)
11076                 {
11077                         clear();
11078                         if(!v(ref_nested())) return false;
11079                         { type = 1; return true;}
11080                         return false;
11081
11082                 }
11083                 template<typename V> bool encode(V& v) const
11084                 {
11085                         return v(ref_nested());
11086
11087                 }
11088                 protected:
11089                 template<typename V>  bool decode(size_t index, V& v)
11090                 {
11091                         clear();
11092                         switch(index)
11093                         {
11094                         case 1: type = 1; return v(ref_nested());
11095                         ref_nested().clear();
11096                         }
11097                         return false;
11098
11099                 }
11100                 template<typename V> bool encode(size_t index, V& v) const
11101                 {
11102                         if(index != type) {return false;} return v(ref_nested());
11103
11104                 }
11105                 private:
11106                 size_t type {0};
11107
11108         };
11109
11110 };
11111 /*
11112 CriticalityDiagnostics ::= SEQUENCE {
11113         procedureCode                                   ProcedureCode                                   OPTIONAL,
11114         triggeringMessage                               TriggeringMessage                               OPTIONAL,
11115         procedureCriticality                    Criticality                                             OPTIONAL,
11116         iEsCriticalityDiagnostics               CriticalityDiagnostics-IE-List  OPTIONAL,
11117         iE-Extensions                                   ProtocolExtensionContainer { {CriticalityDiagnostics-ExtIEs} }  OPTIONAL,
11118         ...
11119 }
11120 */
11121
11122 struct CriticalityDiagnostics : asn::sequence<5, 0, true, 5>
11123 {
11124         static constexpr const char* name() {return "CriticalityDiagnostics";}
11125         using parent_t = asn::sequence<5, 0, true, 5>;
11126         struct procedureCode_t : ProcedureCode
11127         {
11128                 static constexpr const char* name() {return "procedureCode_t";}
11129                 using parent_t = ProcedureCode;
11130                 static constexpr bool optional = true;
11131
11132         };
11133         procedureCode_t& set_procedureCode() { procedureCode.setpresent(true); return procedureCode;}
11134         procedureCode_t const* get_procedureCode() const {return procedureCode.is_valid() ? &procedureCode : nullptr;}
11135         struct triggeringMessage_t : TriggeringMessage
11136         {
11137                 static constexpr const char* name() {return "triggeringMessage_t";}
11138                 using parent_t = TriggeringMessage;
11139                 static constexpr bool optional = true;
11140
11141         };
11142         triggeringMessage_t& set_triggeringMessage() { triggeringMessage.setpresent(true); return triggeringMessage;}
11143         triggeringMessage_t const* get_triggeringMessage() const {return triggeringMessage.is_valid() ? &triggeringMessage : nullptr;}
11144         struct procedureCriticality_t : Criticality
11145         {
11146                 static constexpr const char* name() {return "procedureCriticality_t";}
11147                 using parent_t = Criticality;
11148                 static constexpr bool optional = true;
11149
11150         };
11151         procedureCriticality_t& set_procedureCriticality() { procedureCriticality.setpresent(true); return procedureCriticality;}
11152         procedureCriticality_t const* get_procedureCriticality() const {return procedureCriticality.is_valid() ? &procedureCriticality : nullptr;}
11153         struct iEsCriticalityDiagnostics_t : CriticalityDiagnostics_IE_List
11154         {
11155                 static constexpr const char* name() {return "iEsCriticalityDiagnostics_t";}
11156                 using parent_t = CriticalityDiagnostics_IE_List;
11157                 static constexpr bool optional = true;
11158
11159         };
11160         iEsCriticalityDiagnostics_t& set_iEsCriticalityDiagnostics() { iEsCriticalityDiagnostics.setpresent(true); return iEsCriticalityDiagnostics;}
11161         iEsCriticalityDiagnostics_t const* get_iEsCriticalityDiagnostics() const {return iEsCriticalityDiagnostics.is_valid() ? &iEsCriticalityDiagnostics : nullptr;}
11162         struct iE_Extensions_t : ProtocolExtensionContainer<CriticalityDiagnostics_ExtIEs>
11163         {
11164                 static constexpr const char* name() {return "iE_Extensions_t";}
11165                 using parent_t = ProtocolExtensionContainer<CriticalityDiagnostics_ExtIEs>;
11166                 static constexpr bool optional = true;
11167
11168         };
11169         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
11170         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
11171         template<typename V> void decode(V& v)
11172         {
11173                 v(procedureCode);
11174                 v(triggeringMessage);
11175                 v(procedureCriticality);
11176                 v(iEsCriticalityDiagnostics);
11177                 v(iE_Extensions);
11178
11179         };
11180         template<typename V> void encode(V& v) const
11181         {
11182                 v(procedureCode);
11183                 v(triggeringMessage);
11184                 v(procedureCriticality);
11185                 v(iEsCriticalityDiagnostics);
11186                 v(iE_Extensions);
11187
11188         };
11189         void clear()
11190         {
11191                 procedureCode.clear();
11192                 triggeringMessage.clear();
11193                 procedureCriticality.clear();
11194                 iEsCriticalityDiagnostics.clear();
11195                 iE_Extensions.clear();
11196
11197         };
11198         private:
11199         procedureCode_t procedureCode;
11200         triggeringMessage_t     triggeringMessage;
11201         procedureCriticality_t  procedureCriticality;
11202         iEsCriticalityDiagnostics_t     iEsCriticalityDiagnostics;
11203         iE_Extensions_t iE_Extensions;
11204
11205 };
11206 /*
11207 DL-Forwarding ::= ENUMERATED {
11208         dL-forwardingProposed,
11209         ...
11210 }
11211 */
11212
11213 struct DL_Forwarding : asn::enumerated<1, 0, true>
11214 {
11215         static constexpr const char* name() {return "DL-Forwarding";}
11216         using parent_t = asn::enumerated<1, 0, true>;
11217         typedef enum {
11218                 dL_forwardingProposed
11219         } index_t;
11220
11221 };
11222
11223 /*
11224 DL-GBR-PRB-usage::= INTEGER (0..100)
11225 */
11226
11227 struct DL_GBR_PRB_usage : asn::integer<>
11228 {
11229         using constraint_t = asn::constraints<false,asn::span<0, 100>>;
11230         static constexpr const char* name() {return "DL-GBR-PRB-usage";}
11231         using parent_t = asn::integer<>;
11232
11233 };
11234
11235 /*
11236 DL-Total-PRB-usage::= INTEGER (0..100)
11237 */
11238
11239 struct DL_Total_PRB_usage : asn::integer<>
11240 {
11241         using constraint_t = asn::constraints<false,asn::span<0, 100>>;
11242         static constexpr const char* name() {return "DL-Total-PRB-usage";}
11243         using parent_t = asn::integer<>;
11244
11245 };
11246
11247 /*
11248 DL-non-GBR-PRB-usage::= INTEGER (0..100)
11249 */
11250
11251 struct DL_non_GBR_PRB_usage : asn::integer<>
11252 {
11253         using constraint_t = asn::constraints<false,asn::span<0, 100>>;
11254         static constexpr const char* name() {return "DL-non-GBR-PRB-usage";}
11255         using parent_t = asn::integer<>;
11256
11257 };
11258
11259 /*
11260 DL-scheduling-PDCCH-CCE-usage::= INTEGER (0..100)
11261 */
11262
11263 struct DL_scheduling_PDCCH_CCE_usage : asn::integer<>
11264 {
11265         using constraint_t = asn::constraints<false,asn::span<0, 100>>;
11266         static constexpr const char* name() {return "DL-scheduling-PDCCH-CCE-usage";}
11267         using parent_t = asn::integer<>;
11268
11269 };
11270
11271 /*
11272 DataTrafficResources ::= BIT STRING (SIZE(6..17600))
11273 */
11274
11275 struct DataTrafficResources : asn::bstring<>
11276 {
11277         using constraint_t = asn::constraints<false,asn::span<6, 17600>>;
11278         static constexpr const char* name() {return "DataTrafficResources";}
11279         using parent_t = asn::bstring<>;
11280
11281 };
11282
11283 /*
11284 DLResourceBitmapULandDLSharing ::= DataTrafficResources
11285 */
11286
11287 struct DLResourceBitmapULandDLSharing : DataTrafficResources
11288 {
11289         static constexpr const char* name() {return "DLResourceBitmapULandDLSharing";}
11290         using parent_t = DataTrafficResources;
11291
11292 };
11293 /*
11294 DLResourcesULandDLSharing ::= CHOICE {
11295 unchanged                       NULL,
11296         changed                         DLResourceBitmapULandDLSharing,
11297         ...
11298 }
11299 */
11300
11301 struct DLResourcesULandDLSharing : asn::choice<2, 0, true>
11302 {
11303         static constexpr const char* name() {return "DLResourcesULandDLSharing";}
11304         using parent_t = asn::choice<2, 0, true>;
11305         index_type get_index() const {return index;}
11306         bool is_unknown() const {return index == 3;}
11307         void set_unknown() { set_index(3);  }
11308         ~DLResourcesULandDLSharing() {clear();}
11309         struct unchanged_t : asn::nulltype
11310         {
11311                 static constexpr const char* name() {return "unchanged_t";}
11312                 using parent_t = asn::nulltype;
11313
11314         };
11315         struct changed_t : DLResourceBitmapULandDLSharing
11316         {
11317                 static constexpr const char* name() {return "changed_t";}
11318                 using parent_t = DLResourceBitmapULandDLSharing;
11319
11320         };
11321         void clear()
11322         {
11323                 switch(get_index())
11324                 {
11325                 case 1: var.destroy<unchanged_t>(); break;
11326                 case 2: var.destroy<changed_t>(); break;
11327                 }
11328                 index = 0;
11329                 base::clear();
11330         }
11331         template<typename V> bool decode(size_t idx, V& v)
11332         {
11333                 clear();
11334                 switch(idx)
11335                 {
11336                 case 1: set_index(1); return v(var.build<unchanged_t>());
11337                 case 2: set_index(2); return v(var.build<changed_t>());
11338                 }
11339                 return false;
11340
11341         }
11342         template<typename V> bool encode(V& v) const
11343         {
11344                 switch(get_index())
11345                 {
11346                 case 1: return v(var.as<unchanged_t>());
11347                 case 2: return v(var.as<changed_t>());
11348                 }
11349                 return false;
11350         }
11351         template<typename V> static inline void enumerate(V& v)
11352         {
11353                 v.template operator()<unchanged_t>(1);
11354                 v.template operator()<changed_t>(2);
11355
11356         }
11357         unchanged_t& select_unchanged() { if(get_index() != 1) { clear(); set_index(1); return var.build<unchanged_t>();} return var.as<unchanged_t>();}
11358         unchanged_t const* get_unchanged() const { if(get_index() == 1) { return &var.as<unchanged_t>();} return nullptr; }
11359         changed_t& select_changed() { if(get_index() != 2) { clear(); set_index(2); return var.build<changed_t>();} return var.as<changed_t>();}
11360         changed_t const* get_changed() const { if(get_index() == 2) { return &var.as<changed_t>();} return nullptr; }
11361         private:
11362         void set_index(index_type i) {index = i; base::set();}
11363         union union_type
11364         {
11365                 char dummy1[sizeof(unchanged_t)];
11366                 char dummy2[sizeof(changed_t)];
11367
11368         };
11369         asn::variant<sizeof(union_type)>        var;
11370         index_type      index {0};
11371 };
11372 /*
11373 DRB-ID ::= INTEGER (1..32)
11374 */
11375
11376 struct DRB_ID : asn::integer<>
11377 {
11378         using constraint_t = asn::constraints<false,asn::span<1, 32>>;
11379         static constexpr const char* name() {return "DRB-ID";}
11380         using parent_t = asn::integer<>;
11381
11382 };
11383
11384 /*
11385 ULOnlySharing-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
11386         ...
11387 }
11388 */
11389
11390 struct ULOnlySharing_ExtIEs
11391 {
11392         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
11393         {
11394                 size_t get_index() const {return type;}
11395                 bool is_unknown() const { return type == 1; }
11396                 void clear() {type = 0;}
11397                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
11398                 template<typename V>  bool decode(V& v)
11399                 {
11400                         clear();
11401                         if(!v(ref_nested())) return false;
11402                         { type = 1; return true;}
11403                         return false;
11404
11405                 }
11406                 template<typename V> bool encode(V& v) const
11407                 {
11408                         return v(ref_nested());
11409
11410                 }
11411                 protected:
11412                 template<typename V>  bool decode(size_t index, V& v)
11413                 {
11414                         clear();
11415                         switch(index)
11416                         {
11417                         case 1: type = 1; return v(ref_nested());
11418                         ref_nested().clear();
11419                         }
11420                         return false;
11421
11422                 }
11423                 template<typename V> bool encode(size_t index, V& v) const
11424                 {
11425                         if(index != type) {return false;} return v(ref_nested());
11426
11427                 }
11428                 private:
11429                 size_t type {0};
11430
11431         };
11432         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
11433         {
11434                 size_t get_index() const {return type;}
11435                 bool is_unknown() const { return type == 1; }
11436                 void clear() {type = 0;}
11437                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
11438                 template<typename V>  bool decode(V& v)
11439                 {
11440                         clear();
11441                         if(!v(ref_nested())) return false;
11442                         { type = 1; return true;}
11443                         return false;
11444
11445                 }
11446                 template<typename V> bool encode(V& v) const
11447                 {
11448                         return v(ref_nested());
11449
11450                 }
11451                 protected:
11452                 template<typename V>  bool decode(size_t index, V& v)
11453                 {
11454                         clear();
11455                         switch(index)
11456                         {
11457                         case 1: type = 1; return v(ref_nested());
11458                         ref_nested().clear();
11459                         }
11460                         return false;
11461
11462                 }
11463                 template<typename V> bool encode(size_t index, V& v) const
11464                 {
11465                         if(index != type) {return false;} return v(ref_nested());
11466
11467                 }
11468                 private:
11469                 size_t type {0};
11470
11471         };
11472         struct Extension_t : asn::typefield<true>
11473         {
11474                 ~Extension_t()  {clear();}
11475                 size_t get_index() const {return type;}
11476                 bool is_unknown() const { return type == 1; }
11477                 void clear()
11478                 {
11479                         type = 0; ref_nested().clear();
11480                 }
11481                 template<typename V> static inline void enumerate(V& v)
11482                 {
11483
11484                 }
11485                 protected:
11486                 template<typename V> bool decode(size_t index, V& v)
11487                 {
11488                         clear();
11489                         switch(index)
11490                         {
11491                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
11492                         }
11493                         return false;
11494
11495                 }
11496                 template<typename V> bool encode(size_t index, V& v) const
11497                 {
11498                         if(index != type) return false;
11499                         return false;
11500
11501                 }
11502                 private:
11503                 size_t type {0};
11504
11505         };
11506         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
11507         {
11508                 size_t get_index() const {return type;}
11509                 bool is_unknown() const { return type == 1; }
11510                 void clear() {type = 0;}
11511                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
11512                 template<typename V>  bool decode(V& v)
11513                 {
11514                         clear();
11515                         if(!v(ref_nested())) return false;
11516                         { type = 1; return true;}
11517                         return false;
11518
11519                 }
11520                 template<typename V> bool encode(V& v) const
11521                 {
11522                         return v(ref_nested());
11523
11524                 }
11525                 protected:
11526                 template<typename V>  bool decode(size_t index, V& v)
11527                 {
11528                         clear();
11529                         switch(index)
11530                         {
11531                         case 1: type = 1; return v(ref_nested());
11532                         ref_nested().clear();
11533                         }
11534                         return false;
11535
11536                 }
11537                 template<typename V> bool encode(size_t index, V& v) const
11538                 {
11539                         if(index != type) {return false;} return v(ref_nested());
11540
11541                 }
11542                 private:
11543                 size_t type {0};
11544
11545         };
11546
11547 };
11548 /*
11549 ULOnlySharing ::= SEQUENCE{
11550         uLResourceBitmapULOnlySharing   DataTrafficResources,
11551         iE-Extensions                                   ProtocolExtensionContainer { {ULOnlySharing-ExtIEs} }                           OPTIONAL,
11552         ...
11553 }
11554 */
11555
11556 struct ULOnlySharing : asn::sequence<2, 0, true, 1>
11557 {
11558         static constexpr const char* name() {return "ULOnlySharing";}
11559         using parent_t = asn::sequence<2, 0, true, 1>;
11560         struct uLResourceBitmapULOnlySharing_t : DataTrafficResources
11561         {
11562                 static constexpr const char* name() {return "uLResourceBitmapULOnlySharing_t";}
11563                 using parent_t = DataTrafficResources;
11564
11565         };
11566         uLResourceBitmapULOnlySharing_t& ref_uLResourceBitmapULOnlySharing() {return uLResourceBitmapULOnlySharing;}
11567         uLResourceBitmapULOnlySharing_t const& ref_uLResourceBitmapULOnlySharing() const {return uLResourceBitmapULOnlySharing;}
11568         struct iE_Extensions_t : ProtocolExtensionContainer<ULOnlySharing_ExtIEs>
11569         {
11570                 static constexpr const char* name() {return "iE_Extensions_t";}
11571                 using parent_t = ProtocolExtensionContainer<ULOnlySharing_ExtIEs>;
11572                 static constexpr bool optional = true;
11573
11574         };
11575         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
11576         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
11577         template<typename V> void decode(V& v)
11578         {
11579                 v(uLResourceBitmapULOnlySharing);
11580                 v(iE_Extensions);
11581
11582         };
11583         template<typename V> void encode(V& v) const
11584         {
11585                 v(uLResourceBitmapULOnlySharing);
11586                 v(iE_Extensions);
11587
11588         };
11589         void clear()
11590         {
11591                 uLResourceBitmapULOnlySharing.clear();
11592                 iE_Extensions.clear();
11593
11594         };
11595         private:
11596         uLResourceBitmapULOnlySharing_t uLResourceBitmapULOnlySharing;
11597         iE_Extensions_t iE_Extensions;
11598
11599 };
11600 /*
11601 ULResourceBitmapULandDLSharing ::= DataTrafficResources
11602 */
11603
11604 struct ULResourceBitmapULandDLSharing : DataTrafficResources
11605 {
11606         static constexpr const char* name() {return "ULResourceBitmapULandDLSharing";}
11607         using parent_t = DataTrafficResources;
11608
11609 };
11610 /*
11611 ULResourcesULandDLSharing ::= CHOICE {
11612         unchanged                       NULL,
11613         changed                         ULResourceBitmapULandDLSharing,
11614         ...
11615 }
11616 */
11617
11618 struct ULResourcesULandDLSharing : asn::choice<2, 0, true>
11619 {
11620         static constexpr const char* name() {return "ULResourcesULandDLSharing";}
11621         using parent_t = asn::choice<2, 0, true>;
11622         index_type get_index() const {return index;}
11623         bool is_unknown() const {return index == 3;}
11624         void set_unknown() { set_index(3);  }
11625         ~ULResourcesULandDLSharing() {clear();}
11626         struct unchanged_t : asn::nulltype
11627         {
11628                 static constexpr const char* name() {return "unchanged_t";}
11629                 using parent_t = asn::nulltype;
11630
11631         };
11632         struct changed_t : ULResourceBitmapULandDLSharing
11633         {
11634                 static constexpr const char* name() {return "changed_t";}
11635                 using parent_t = ULResourceBitmapULandDLSharing;
11636
11637         };
11638         void clear()
11639         {
11640                 switch(get_index())
11641                 {
11642                 case 1: var.destroy<unchanged_t>(); break;
11643                 case 2: var.destroy<changed_t>(); break;
11644                 }
11645                 index = 0;
11646                 base::clear();
11647         }
11648         template<typename V> bool decode(size_t idx, V& v)
11649         {
11650                 clear();
11651                 switch(idx)
11652                 {
11653                 case 1: set_index(1); return v(var.build<unchanged_t>());
11654                 case 2: set_index(2); return v(var.build<changed_t>());
11655                 }
11656                 return false;
11657
11658         }
11659         template<typename V> bool encode(V& v) const
11660         {
11661                 switch(get_index())
11662                 {
11663                 case 1: return v(var.as<unchanged_t>());
11664                 case 2: return v(var.as<changed_t>());
11665                 }
11666                 return false;
11667         }
11668         template<typename V> static inline void enumerate(V& v)
11669         {
11670                 v.template operator()<unchanged_t>(1);
11671                 v.template operator()<changed_t>(2);
11672
11673         }
11674         unchanged_t& select_unchanged() { if(get_index() != 1) { clear(); set_index(1); return var.build<unchanged_t>();} return var.as<unchanged_t>();}
11675         unchanged_t const* get_unchanged() const { if(get_index() == 1) { return &var.as<unchanged_t>();} return nullptr; }
11676         changed_t& select_changed() { if(get_index() != 2) { clear(); set_index(2); return var.build<changed_t>();} return var.as<changed_t>();}
11677         changed_t const* get_changed() const { if(get_index() == 2) { return &var.as<changed_t>();} return nullptr; }
11678         private:
11679         void set_index(index_type i) {index = i; base::set();}
11680         union union_type
11681         {
11682                 char dummy1[sizeof(unchanged_t)];
11683                 char dummy2[sizeof(changed_t)];
11684
11685         };
11686         asn::variant<sizeof(union_type)>        var;
11687         index_type      index {0};
11688 };
11689 /*
11690 ULandDLSharing-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
11691         ...
11692 }
11693 */
11694
11695 struct ULandDLSharing_ExtIEs
11696 {
11697         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
11698         {
11699                 size_t get_index() const {return type;}
11700                 bool is_unknown() const { return type == 1; }
11701                 void clear() {type = 0;}
11702                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
11703                 template<typename V>  bool decode(V& v)
11704                 {
11705                         clear();
11706                         if(!v(ref_nested())) return false;
11707                         { type = 1; return true;}
11708                         return false;
11709
11710                 }
11711                 template<typename V> bool encode(V& v) const
11712                 {
11713                         return v(ref_nested());
11714
11715                 }
11716                 protected:
11717                 template<typename V>  bool decode(size_t index, V& v)
11718                 {
11719                         clear();
11720                         switch(index)
11721                         {
11722                         case 1: type = 1; return v(ref_nested());
11723                         ref_nested().clear();
11724                         }
11725                         return false;
11726
11727                 }
11728                 template<typename V> bool encode(size_t index, V& v) const
11729                 {
11730                         if(index != type) {return false;} return v(ref_nested());
11731
11732                 }
11733                 private:
11734                 size_t type {0};
11735
11736         };
11737         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
11738         {
11739                 size_t get_index() const {return type;}
11740                 bool is_unknown() const { return type == 1; }
11741                 void clear() {type = 0;}
11742                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
11743                 template<typename V>  bool decode(V& v)
11744                 {
11745                         clear();
11746                         if(!v(ref_nested())) return false;
11747                         { type = 1; return true;}
11748                         return false;
11749
11750                 }
11751                 template<typename V> bool encode(V& v) const
11752                 {
11753                         return v(ref_nested());
11754
11755                 }
11756                 protected:
11757                 template<typename V>  bool decode(size_t index, V& v)
11758                 {
11759                         clear();
11760                         switch(index)
11761                         {
11762                         case 1: type = 1; return v(ref_nested());
11763                         ref_nested().clear();
11764                         }
11765                         return false;
11766
11767                 }
11768                 template<typename V> bool encode(size_t index, V& v) const
11769                 {
11770                         if(index != type) {return false;} return v(ref_nested());
11771
11772                 }
11773                 private:
11774                 size_t type {0};
11775
11776         };
11777         struct Extension_t : asn::typefield<true>
11778         {
11779                 ~Extension_t()  {clear();}
11780                 size_t get_index() const {return type;}
11781                 bool is_unknown() const { return type == 1; }
11782                 void clear()
11783                 {
11784                         type = 0; ref_nested().clear();
11785                 }
11786                 template<typename V> static inline void enumerate(V& v)
11787                 {
11788
11789                 }
11790                 protected:
11791                 template<typename V> bool decode(size_t index, V& v)
11792                 {
11793                         clear();
11794                         switch(index)
11795                         {
11796                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
11797                         }
11798                         return false;
11799
11800                 }
11801                 template<typename V> bool encode(size_t index, V& v) const
11802                 {
11803                         if(index != type) return false;
11804                         return false;
11805
11806                 }
11807                 private:
11808                 size_t type {0};
11809
11810         };
11811         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
11812         {
11813                 size_t get_index() const {return type;}
11814                 bool is_unknown() const { return type == 1; }
11815                 void clear() {type = 0;}
11816                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
11817                 template<typename V>  bool decode(V& v)
11818                 {
11819                         clear();
11820                         if(!v(ref_nested())) return false;
11821                         { type = 1; return true;}
11822                         return false;
11823
11824                 }
11825                 template<typename V> bool encode(V& v) const
11826                 {
11827                         return v(ref_nested());
11828
11829                 }
11830                 protected:
11831                 template<typename V>  bool decode(size_t index, V& v)
11832                 {
11833                         clear();
11834                         switch(index)
11835                         {
11836                         case 1: type = 1; return v(ref_nested());
11837                         ref_nested().clear();
11838                         }
11839                         return false;
11840
11841                 }
11842                 template<typename V> bool encode(size_t index, V& v) const
11843                 {
11844                         if(index != type) {return false;} return v(ref_nested());
11845
11846                 }
11847                 private:
11848                 size_t type {0};
11849
11850         };
11851
11852 };
11853 /*
11854 ULandDLSharing ::= SEQUENCE{
11855         uLResourcesULandDLSharing                               ULResourcesULandDLSharing,
11856         dLResourcesULandDLSharing                               DLResourcesULandDLSharing,
11857         iE-Extensions                   ProtocolExtensionContainer { {ULandDLSharing-ExtIEs} }                          OPTIONAL,
11858         ...
11859 }
11860 */
11861
11862 struct ULandDLSharing : asn::sequence<3, 0, true, 1>
11863 {
11864         static constexpr const char* name() {return "ULandDLSharing";}
11865         using parent_t = asn::sequence<3, 0, true, 1>;
11866         struct uLResourcesULandDLSharing_t : ULResourcesULandDLSharing
11867         {
11868                 static constexpr const char* name() {return "uLResourcesULandDLSharing_t";}
11869                 using parent_t = ULResourcesULandDLSharing;
11870
11871         };
11872         uLResourcesULandDLSharing_t& ref_uLResourcesULandDLSharing() {return uLResourcesULandDLSharing;}
11873         uLResourcesULandDLSharing_t const& ref_uLResourcesULandDLSharing() const {return uLResourcesULandDLSharing;}
11874         struct dLResourcesULandDLSharing_t : DLResourcesULandDLSharing
11875         {
11876                 static constexpr const char* name() {return "dLResourcesULandDLSharing_t";}
11877                 using parent_t = DLResourcesULandDLSharing;
11878
11879         };
11880         dLResourcesULandDLSharing_t& ref_dLResourcesULandDLSharing() {return dLResourcesULandDLSharing;}
11881         dLResourcesULandDLSharing_t const& ref_dLResourcesULandDLSharing() const {return dLResourcesULandDLSharing;}
11882         struct iE_Extensions_t : ProtocolExtensionContainer<ULandDLSharing_ExtIEs>
11883         {
11884                 static constexpr const char* name() {return "iE_Extensions_t";}
11885                 using parent_t = ProtocolExtensionContainer<ULandDLSharing_ExtIEs>;
11886                 static constexpr bool optional = true;
11887
11888         };
11889         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
11890         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
11891         template<typename V> void decode(V& v)
11892         {
11893                 v(uLResourcesULandDLSharing);
11894                 v(dLResourcesULandDLSharing);
11895                 v(iE_Extensions);
11896
11897         };
11898         template<typename V> void encode(V& v) const
11899         {
11900                 v(uLResourcesULandDLSharing);
11901                 v(dLResourcesULandDLSharing);
11902                 v(iE_Extensions);
11903
11904         };
11905         void clear()
11906         {
11907                 uLResourcesULandDLSharing.clear();
11908                 dLResourcesULandDLSharing.clear();
11909                 iE_Extensions.clear();
11910
11911         };
11912         private:
11913         uLResourcesULandDLSharing_t     uLResourcesULandDLSharing;
11914         dLResourcesULandDLSharing_t     dLResourcesULandDLSharing;
11915         iE_Extensions_t iE_Extensions;
11916
11917 };
11918 /*
11919 SharedResourceType ::= CHOICE{
11920         uLOnlySharing           ULOnlySharing,
11921         uLandDLSharing          ULandDLSharing,
11922         ...
11923 }
11924 */
11925
11926 struct SharedResourceType : asn::choice<2, 0, true>
11927 {
11928         static constexpr const char* name() {return "SharedResourceType";}
11929         using parent_t = asn::choice<2, 0, true>;
11930         index_type get_index() const {return index;}
11931         bool is_unknown() const {return index == 3;}
11932         void set_unknown() { set_index(3);  }
11933         ~SharedResourceType() {clear();}
11934         struct uLOnlySharing_t : ULOnlySharing
11935         {
11936                 static constexpr const char* name() {return "uLOnlySharing_t";}
11937                 using parent_t = ULOnlySharing;
11938
11939         };
11940         struct uLandDLSharing_t : ULandDLSharing
11941         {
11942                 static constexpr const char* name() {return "uLandDLSharing_t";}
11943                 using parent_t = ULandDLSharing;
11944
11945         };
11946         void clear()
11947         {
11948                 switch(get_index())
11949                 {
11950                 case 1: var.destroy<uLOnlySharing_t>(); break;
11951                 case 2: var.destroy<uLandDLSharing_t>(); break;
11952                 }
11953                 index = 0;
11954                 base::clear();
11955         }
11956         template<typename V> bool decode(size_t idx, V& v)
11957         {
11958                 clear();
11959                 switch(idx)
11960                 {
11961                 case 1: set_index(1); return v(var.build<uLOnlySharing_t>());
11962                 case 2: set_index(2); return v(var.build<uLandDLSharing_t>());
11963                 }
11964                 return false;
11965
11966         }
11967         template<typename V> bool encode(V& v) const
11968         {
11969                 switch(get_index())
11970                 {
11971                 case 1: return v(var.as<uLOnlySharing_t>());
11972                 case 2: return v(var.as<uLandDLSharing_t>());
11973                 }
11974                 return false;
11975         }
11976         template<typename V> static inline void enumerate(V& v)
11977         {
11978                 v.template operator()<uLOnlySharing_t>(1);
11979                 v.template operator()<uLandDLSharing_t>(2);
11980
11981         }
11982         uLOnlySharing_t& select_uLOnlySharing() { if(get_index() != 1) { clear(); set_index(1); return var.build<uLOnlySharing_t>();} return var.as<uLOnlySharing_t>();}
11983         uLOnlySharing_t const* get_uLOnlySharing() const { if(get_index() == 1) { return &var.as<uLOnlySharing_t>();} return nullptr; }
11984         uLandDLSharing_t& select_uLandDLSharing() { if(get_index() != 2) { clear(); set_index(2); return var.build<uLandDLSharing_t>();} return var.as<uLandDLSharing_t>();}
11985         uLandDLSharing_t const* get_uLandDLSharing() const { if(get_index() == 2) { return &var.as<uLandDLSharing_t>();} return nullptr; }
11986         private:
11987         void set_index(index_type i) {index = i; base::set();}
11988         union union_type
11989         {
11990                 char dummy1[sizeof(uLOnlySharing_t)];
11991                 char dummy2[sizeof(uLandDLSharing_t)];
11992
11993         };
11994         asn::variant<sizeof(union_type)>        var;
11995         index_type      index {0};
11996 };
11997 /*
11998 SubframeType ::= ENUMERATED{mbsfn,nonmbsfn,...}
11999 */
12000
12001 struct SubframeType : asn::enumerated<2, 0, true>
12002 {
12003         static constexpr const char* name() {return "SubframeType";}
12004         using parent_t = asn::enumerated<2, 0, true>;
12005         typedef enum {
12006                 mbsfn
12007                 ,nonmbsfn
12008         } index_t;
12009
12010 };
12011
12012 /*
12013 ReservedSubframePattern-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
12014         ...
12015 }
12016 */
12017
12018 struct ReservedSubframePattern_ExtIEs
12019 {
12020         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
12021         {
12022                 size_t get_index() const {return type;}
12023                 bool is_unknown() const { return type == 1; }
12024                 void clear() {type = 0;}
12025                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
12026                 template<typename V>  bool decode(V& v)
12027                 {
12028                         clear();
12029                         if(!v(ref_nested())) return false;
12030                         { type = 1; return true;}
12031                         return false;
12032
12033                 }
12034                 template<typename V> bool encode(V& v) const
12035                 {
12036                         return v(ref_nested());
12037
12038                 }
12039                 protected:
12040                 template<typename V>  bool decode(size_t index, V& v)
12041                 {
12042                         clear();
12043                         switch(index)
12044                         {
12045                         case 1: type = 1; return v(ref_nested());
12046                         ref_nested().clear();
12047                         }
12048                         return false;
12049
12050                 }
12051                 template<typename V> bool encode(size_t index, V& v) const
12052                 {
12053                         if(index != type) {return false;} return v(ref_nested());
12054
12055                 }
12056                 private:
12057                 size_t type {0};
12058
12059         };
12060         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
12061         {
12062                 size_t get_index() const {return type;}
12063                 bool is_unknown() const { return type == 1; }
12064                 void clear() {type = 0;}
12065                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
12066                 template<typename V>  bool decode(V& v)
12067                 {
12068                         clear();
12069                         if(!v(ref_nested())) return false;
12070                         { type = 1; return true;}
12071                         return false;
12072
12073                 }
12074                 template<typename V> bool encode(V& v) const
12075                 {
12076                         return v(ref_nested());
12077
12078                 }
12079                 protected:
12080                 template<typename V>  bool decode(size_t index, V& v)
12081                 {
12082                         clear();
12083                         switch(index)
12084                         {
12085                         case 1: type = 1; return v(ref_nested());
12086                         ref_nested().clear();
12087                         }
12088                         return false;
12089
12090                 }
12091                 template<typename V> bool encode(size_t index, V& v) const
12092                 {
12093                         if(index != type) {return false;} return v(ref_nested());
12094
12095                 }
12096                 private:
12097                 size_t type {0};
12098
12099         };
12100         struct Extension_t : asn::typefield<true>
12101         {
12102                 ~Extension_t()  {clear();}
12103                 size_t get_index() const {return type;}
12104                 bool is_unknown() const { return type == 1; }
12105                 void clear()
12106                 {
12107                         type = 0; ref_nested().clear();
12108                 }
12109                 template<typename V> static inline void enumerate(V& v)
12110                 {
12111
12112                 }
12113                 protected:
12114                 template<typename V> bool decode(size_t index, V& v)
12115                 {
12116                         clear();
12117                         switch(index)
12118                         {
12119                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
12120                         }
12121                         return false;
12122
12123                 }
12124                 template<typename V> bool encode(size_t index, V& v) const
12125                 {
12126                         if(index != type) return false;
12127                         return false;
12128
12129                 }
12130                 private:
12131                 size_t type {0};
12132
12133         };
12134         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
12135         {
12136                 size_t get_index() const {return type;}
12137                 bool is_unknown() const { return type == 1; }
12138                 void clear() {type = 0;}
12139                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
12140                 template<typename V>  bool decode(V& v)
12141                 {
12142                         clear();
12143                         if(!v(ref_nested())) return false;
12144                         { type = 1; return true;}
12145                         return false;
12146
12147                 }
12148                 template<typename V> bool encode(V& v) const
12149                 {
12150                         return v(ref_nested());
12151
12152                 }
12153                 protected:
12154                 template<typename V>  bool decode(size_t index, V& v)
12155                 {
12156                         clear();
12157                         switch(index)
12158                         {
12159                         case 1: type = 1; return v(ref_nested());
12160                         ref_nested().clear();
12161                         }
12162                         return false;
12163
12164                 }
12165                 template<typename V> bool encode(size_t index, V& v) const
12166                 {
12167                         if(index != type) {return false;} return v(ref_nested());
12168
12169                 }
12170                 private:
12171                 size_t type {0};
12172
12173         };
12174
12175 };
12176 /*
12177 ReservedSubframePattern ::= SEQUENCE{
12178         subframeType                                    SubframeType,
12179         reservedSubframePattern                 BIT STRING (SIZE(10..160)),
12180         mBSFNControlRegionLength                INTEGER (0..3),
12181         iE-Extensions                                   ProtocolExtensionContainer { {ReservedSubframePattern-ExtIEs} } OPTIONAL,
12182         ...
12183 }
12184 */
12185
12186 struct ReservedSubframePattern : asn::sequence<4, 0, true, 1>
12187 {
12188         static constexpr const char* name() {return "ReservedSubframePattern";}
12189         using parent_t = asn::sequence<4, 0, true, 1>;
12190         struct subframeType_t : SubframeType
12191         {
12192                 static constexpr const char* name() {return "subframeType_t";}
12193                 using parent_t = SubframeType;
12194
12195         };
12196         subframeType_t& ref_subframeType() {return subframeType;}
12197         subframeType_t const& ref_subframeType() const {return subframeType;}
12198         struct reservedSubframePattern_t : asn::bstring<>
12199         {
12200                 using constraint_t = asn::constraints<false,asn::span<10, 160>>;
12201                 static constexpr const char* name() {return "reservedSubframePattern_t";}
12202                 using parent_t = asn::bstring<>;
12203
12204         };
12205
12206         reservedSubframePattern_t& ref_reservedSubframePattern() {return reservedSubframePattern;}
12207         reservedSubframePattern_t const& ref_reservedSubframePattern() const {return reservedSubframePattern;}
12208         struct mBSFNControlRegionLength_t : asn::integer<>
12209         {
12210                 using constraint_t = asn::constraints<false,asn::span<0, 3>>;
12211                 static constexpr const char* name() {return "mBSFNControlRegionLength_t";}
12212                 using parent_t = asn::integer<>;
12213
12214         };
12215
12216         mBSFNControlRegionLength_t& ref_mBSFNControlRegionLength() {return mBSFNControlRegionLength;}
12217         mBSFNControlRegionLength_t const& ref_mBSFNControlRegionLength() const {return mBSFNControlRegionLength;}
12218         struct iE_Extensions_t : ProtocolExtensionContainer<ReservedSubframePattern_ExtIEs>
12219         {
12220                 static constexpr const char* name() {return "iE_Extensions_t";}
12221                 using parent_t = ProtocolExtensionContainer<ReservedSubframePattern_ExtIEs>;
12222                 static constexpr bool optional = true;
12223
12224         };
12225         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
12226         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
12227         template<typename V> void decode(V& v)
12228         {
12229                 v(subframeType);
12230                 v(reservedSubframePattern);
12231                 v(mBSFNControlRegionLength);
12232                 v(iE_Extensions);
12233
12234         };
12235         template<typename V> void encode(V& v) const
12236         {
12237                 v(subframeType);
12238                 v(reservedSubframePattern);
12239                 v(mBSFNControlRegionLength);
12240                 v(iE_Extensions);
12241
12242         };
12243         void clear()
12244         {
12245                 subframeType.clear();
12246                 reservedSubframePattern.clear();
12247                 mBSFNControlRegionLength.clear();
12248                 iE_Extensions.clear();
12249
12250         };
12251         private:
12252         subframeType_t  subframeType;
12253         reservedSubframePattern_t       reservedSubframePattern;
12254         mBSFNControlRegionLength_t      mBSFNControlRegionLength;
12255         iE_Extensions_t iE_Extensions;
12256
12257 };
12258 /*
12259 DataTrafficResourceIndication-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
12260         ...
12261 }
12262 */
12263
12264 struct DataTrafficResourceIndication_ExtIEs
12265 {
12266         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
12267         {
12268                 size_t get_index() const {return type;}
12269                 bool is_unknown() const { return type == 1; }
12270                 void clear() {type = 0;}
12271                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
12272                 template<typename V>  bool decode(V& v)
12273                 {
12274                         clear();
12275                         if(!v(ref_nested())) return false;
12276                         { type = 1; return true;}
12277                         return false;
12278
12279                 }
12280                 template<typename V> bool encode(V& v) const
12281                 {
12282                         return v(ref_nested());
12283
12284                 }
12285                 protected:
12286                 template<typename V>  bool decode(size_t index, V& v)
12287                 {
12288                         clear();
12289                         switch(index)
12290                         {
12291                         case 1: type = 1; return v(ref_nested());
12292                         ref_nested().clear();
12293                         }
12294                         return false;
12295
12296                 }
12297                 template<typename V> bool encode(size_t index, V& v) const
12298                 {
12299                         if(index != type) {return false;} return v(ref_nested());
12300
12301                 }
12302                 private:
12303                 size_t type {0};
12304
12305         };
12306         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
12307         {
12308                 size_t get_index() const {return type;}
12309                 bool is_unknown() const { return type == 1; }
12310                 void clear() {type = 0;}
12311                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
12312                 template<typename V>  bool decode(V& v)
12313                 {
12314                         clear();
12315                         if(!v(ref_nested())) return false;
12316                         { type = 1; return true;}
12317                         return false;
12318
12319                 }
12320                 template<typename V> bool encode(V& v) const
12321                 {
12322                         return v(ref_nested());
12323
12324                 }
12325                 protected:
12326                 template<typename V>  bool decode(size_t index, V& v)
12327                 {
12328                         clear();
12329                         switch(index)
12330                         {
12331                         case 1: type = 1; return v(ref_nested());
12332                         ref_nested().clear();
12333                         }
12334                         return false;
12335
12336                 }
12337                 template<typename V> bool encode(size_t index, V& v) const
12338                 {
12339                         if(index != type) {return false;} return v(ref_nested());
12340
12341                 }
12342                 private:
12343                 size_t type {0};
12344
12345         };
12346         struct Extension_t : asn::typefield<true>
12347         {
12348                 ~Extension_t()  {clear();}
12349                 size_t get_index() const {return type;}
12350                 bool is_unknown() const { return type == 1; }
12351                 void clear()
12352                 {
12353                         type = 0; ref_nested().clear();
12354                 }
12355                 template<typename V> static inline void enumerate(V& v)
12356                 {
12357
12358                 }
12359                 protected:
12360                 template<typename V> bool decode(size_t index, V& v)
12361                 {
12362                         clear();
12363                         switch(index)
12364                         {
12365                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
12366                         }
12367                         return false;
12368
12369                 }
12370                 template<typename V> bool encode(size_t index, V& v) const
12371                 {
12372                         if(index != type) return false;
12373                         return false;
12374
12375                 }
12376                 private:
12377                 size_t type {0};
12378
12379         };
12380         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
12381         {
12382                 size_t get_index() const {return type;}
12383                 bool is_unknown() const { return type == 1; }
12384                 void clear() {type = 0;}
12385                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
12386                 template<typename V>  bool decode(V& v)
12387                 {
12388                         clear();
12389                         if(!v(ref_nested())) return false;
12390                         { type = 1; return true;}
12391                         return false;
12392
12393                 }
12394                 template<typename V> bool encode(V& v) const
12395                 {
12396                         return v(ref_nested());
12397
12398                 }
12399                 protected:
12400                 template<typename V>  bool decode(size_t index, V& v)
12401                 {
12402                         clear();
12403                         switch(index)
12404                         {
12405                         case 1: type = 1; return v(ref_nested());
12406                         ref_nested().clear();
12407                         }
12408                         return false;
12409
12410                 }
12411                 template<typename V> bool encode(size_t index, V& v) const
12412                 {
12413                         if(index != type) {return false;} return v(ref_nested());
12414
12415                 }
12416                 private:
12417                 size_t type {0};
12418
12419         };
12420
12421 };
12422 /*
12423 DataTrafficResourceIndication ::= SEQUENCE {
12424         activationSFN                                   INTEGER (0..1023),
12425         sharedResourceType                              SharedResourceType,
12426         reservedSubframePattern                 ReservedSubframePattern OPTIONAL,
12427         iE-Extensions                                   ProtocolExtensionContainer { {DataTrafficResourceIndication-ExtIEs} } OPTIONAL,
12428 ...
12429 }
12430 */
12431
12432 struct DataTrafficResourceIndication : asn::sequence<4, 0, true, 2>
12433 {
12434         static constexpr const char* name() {return "DataTrafficResourceIndication";}
12435         using parent_t = asn::sequence<4, 0, true, 2>;
12436         struct activationSFN_t : asn::integer<>
12437         {
12438                 using constraint_t = asn::constraints<false,asn::span<0, 1023>>;
12439                 static constexpr const char* name() {return "activationSFN_t";}
12440                 using parent_t = asn::integer<>;
12441
12442         };
12443
12444         activationSFN_t& ref_activationSFN() {return activationSFN;}
12445         activationSFN_t const& ref_activationSFN() const {return activationSFN;}
12446         struct sharedResourceType_t : SharedResourceType
12447         {
12448                 static constexpr const char* name() {return "sharedResourceType_t";}
12449                 using parent_t = SharedResourceType;
12450
12451         };
12452         sharedResourceType_t& ref_sharedResourceType() {return sharedResourceType;}
12453         sharedResourceType_t const& ref_sharedResourceType() const {return sharedResourceType;}
12454         struct reservedSubframePattern_t : ReservedSubframePattern
12455         {
12456                 static constexpr const char* name() {return "reservedSubframePattern_t";}
12457                 using parent_t = ReservedSubframePattern;
12458                 static constexpr bool optional = true;
12459
12460         };
12461         reservedSubframePattern_t& set_reservedSubframePattern() { reservedSubframePattern.setpresent(true); return reservedSubframePattern;}
12462         reservedSubframePattern_t const* get_reservedSubframePattern() const {return reservedSubframePattern.is_valid() ? &reservedSubframePattern : nullptr;}
12463         struct iE_Extensions_t : ProtocolExtensionContainer<DataTrafficResourceIndication_ExtIEs>
12464         {
12465                 static constexpr const char* name() {return "iE_Extensions_t";}
12466                 using parent_t = ProtocolExtensionContainer<DataTrafficResourceIndication_ExtIEs>;
12467                 static constexpr bool optional = true;
12468
12469         };
12470         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
12471         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
12472         template<typename V> void decode(V& v)
12473         {
12474                 v(activationSFN);
12475                 v(sharedResourceType);
12476                 v(reservedSubframePattern);
12477                 v(iE_Extensions);
12478
12479         };
12480         template<typename V> void encode(V& v) const
12481         {
12482                 v(activationSFN);
12483                 v(sharedResourceType);
12484                 v(reservedSubframePattern);
12485                 v(iE_Extensions);
12486
12487         };
12488         void clear()
12489         {
12490                 activationSFN.clear();
12491                 sharedResourceType.clear();
12492                 reservedSubframePattern.clear();
12493                 iE_Extensions.clear();
12494
12495         };
12496         private:
12497         activationSFN_t activationSFN;
12498         sharedResourceType_t    sharedResourceType;
12499         reservedSubframePattern_t       reservedSubframePattern;
12500         iE_Extensions_t iE_Extensions;
12501
12502 };
12503 /*
12504 DeactivationIndication::= ENUMERATED {
12505         deactivated,
12506         ...
12507 }
12508 */
12509
12510 struct DeactivationIndication : asn::enumerated<1, 0, true>
12511 {
12512         static constexpr const char* name() {return "DeactivationIndication";}
12513         using parent_t = asn::enumerated<1, 0, true>;
12514         typedef enum {
12515                 deactivated
12516         } index_t;
12517
12518 };
12519
12520 /*
12521 DeliveryStatus-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
12522         ...
12523 }
12524 */
12525
12526 struct DeliveryStatus_ExtIEs
12527 {
12528         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
12529         {
12530                 size_t get_index() const {return type;}
12531                 bool is_unknown() const { return type == 1; }
12532                 void clear() {type = 0;}
12533                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
12534                 template<typename V>  bool decode(V& v)
12535                 {
12536                         clear();
12537                         if(!v(ref_nested())) return false;
12538                         { type = 1; return true;}
12539                         return false;
12540
12541                 }
12542                 template<typename V> bool encode(V& v) const
12543                 {
12544                         return v(ref_nested());
12545
12546                 }
12547                 protected:
12548                 template<typename V>  bool decode(size_t index, V& v)
12549                 {
12550                         clear();
12551                         switch(index)
12552                         {
12553                         case 1: type = 1; return v(ref_nested());
12554                         ref_nested().clear();
12555                         }
12556                         return false;
12557
12558                 }
12559                 template<typename V> bool encode(size_t index, V& v) const
12560                 {
12561                         if(index != type) {return false;} return v(ref_nested());
12562
12563                 }
12564                 private:
12565                 size_t type {0};
12566
12567         };
12568         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
12569         {
12570                 size_t get_index() const {return type;}
12571                 bool is_unknown() const { return type == 1; }
12572                 void clear() {type = 0;}
12573                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
12574                 template<typename V>  bool decode(V& v)
12575                 {
12576                         clear();
12577                         if(!v(ref_nested())) return false;
12578                         { type = 1; return true;}
12579                         return false;
12580
12581                 }
12582                 template<typename V> bool encode(V& v) const
12583                 {
12584                         return v(ref_nested());
12585
12586                 }
12587                 protected:
12588                 template<typename V>  bool decode(size_t index, V& v)
12589                 {
12590                         clear();
12591                         switch(index)
12592                         {
12593                         case 1: type = 1; return v(ref_nested());
12594                         ref_nested().clear();
12595                         }
12596                         return false;
12597
12598                 }
12599                 template<typename V> bool encode(size_t index, V& v) const
12600                 {
12601                         if(index != type) {return false;} return v(ref_nested());
12602
12603                 }
12604                 private:
12605                 size_t type {0};
12606
12607         };
12608         struct Extension_t : asn::typefield<true>
12609         {
12610                 ~Extension_t()  {clear();}
12611                 size_t get_index() const {return type;}
12612                 bool is_unknown() const { return type == 1; }
12613                 void clear()
12614                 {
12615                         type = 0; ref_nested().clear();
12616                 }
12617                 template<typename V> static inline void enumerate(V& v)
12618                 {
12619
12620                 }
12621                 protected:
12622                 template<typename V> bool decode(size_t index, V& v)
12623                 {
12624                         clear();
12625                         switch(index)
12626                         {
12627                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
12628                         }
12629                         return false;
12630
12631                 }
12632                 template<typename V> bool encode(size_t index, V& v) const
12633                 {
12634                         if(index != type) return false;
12635                         return false;
12636
12637                 }
12638                 private:
12639                 size_t type {0};
12640
12641         };
12642         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
12643         {
12644                 size_t get_index() const {return type;}
12645                 bool is_unknown() const { return type == 1; }
12646                 void clear() {type = 0;}
12647                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
12648                 template<typename V>  bool decode(V& v)
12649                 {
12650                         clear();
12651                         if(!v(ref_nested())) return false;
12652                         { type = 1; return true;}
12653                         return false;
12654
12655                 }
12656                 template<typename V> bool encode(V& v) const
12657                 {
12658                         return v(ref_nested());
12659
12660                 }
12661                 protected:
12662                 template<typename V>  bool decode(size_t index, V& v)
12663                 {
12664                         clear();
12665                         switch(index)
12666                         {
12667                         case 1: type = 1; return v(ref_nested());
12668                         ref_nested().clear();
12669                         }
12670                         return false;
12671
12672                 }
12673                 template<typename V> bool encode(size_t index, V& v) const
12674                 {
12675                         if(index != type) {return false;} return v(ref_nested());
12676
12677                 }
12678                 private:
12679                 size_t type {0};
12680
12681         };
12682
12683 };
12684 /*
12685 DeliveryStatus ::= SEQUENCE {
12686         highestSuccessDeliveredPDCPSN           INTEGER (0..4095),
12687         iE-Extensions           ProtocolExtensionContainer { {DeliveryStatus-ExtIEs} } OPTIONAL,
12688         ...
12689 }
12690 */
12691
12692 struct DeliveryStatus : asn::sequence<2, 0, true, 1>
12693 {
12694         static constexpr const char* name() {return "DeliveryStatus";}
12695         using parent_t = asn::sequence<2, 0, true, 1>;
12696         struct highestSuccessDeliveredPDCPSN_t : asn::integer<>
12697         {
12698                 using constraint_t = asn::constraints<false,asn::span<0, 4095>>;
12699                 static constexpr const char* name() {return "highestSuccessDeliveredPDCPSN_t";}
12700                 using parent_t = asn::integer<>;
12701
12702         };
12703
12704         highestSuccessDeliveredPDCPSN_t& ref_highestSuccessDeliveredPDCPSN() {return highestSuccessDeliveredPDCPSN;}
12705         highestSuccessDeliveredPDCPSN_t const& ref_highestSuccessDeliveredPDCPSN() const {return highestSuccessDeliveredPDCPSN;}
12706         struct iE_Extensions_t : ProtocolExtensionContainer<DeliveryStatus_ExtIEs>
12707         {
12708                 static constexpr const char* name() {return "iE_Extensions_t";}
12709                 using parent_t = ProtocolExtensionContainer<DeliveryStatus_ExtIEs>;
12710                 static constexpr bool optional = true;
12711
12712         };
12713         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
12714         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
12715         template<typename V> void decode(V& v)
12716         {
12717                 v(highestSuccessDeliveredPDCPSN);
12718                 v(iE_Extensions);
12719
12720         };
12721         template<typename V> void encode(V& v) const
12722         {
12723                 v(highestSuccessDeliveredPDCPSN);
12724                 v(iE_Extensions);
12725
12726         };
12727         void clear()
12728         {
12729                 highestSuccessDeliveredPDCPSN.clear();
12730                 iE_Extensions.clear();
12731
12732         };
12733         private:
12734         highestSuccessDeliveredPDCPSN_t highestSuccessDeliveredPDCPSN;
12735         iE_Extensions_t iE_Extensions;
12736
12737 };
12738 /*
12739 DuplicationActivation::= ENUMERATED {active, inactive, ...}
12740 */
12741
12742 struct DuplicationActivation : asn::enumerated<2, 0, true>
12743 {
12744         static constexpr const char* name() {return "DuplicationActivation";}
12745         using parent_t = asn::enumerated<2, 0, true>;
12746         typedef enum {
12747                 active
12748                 ,inactive
12749         } index_t;
12750
12751 };
12752
12753 /*
12754 PA-Values ::= ENUMERATED {
12755         dB-6,
12756         dB-4dot77,
12757         dB-3,
12758         dB-1dot77,
12759         dB0,
12760         dB1,
12761         dB2,
12762         dB3,
12763         ...
12764 }
12765 */
12766
12767 struct PA_Values : asn::enumerated<8, 0, true>
12768 {
12769         static constexpr const char* name() {return "PA-Values";}
12770         using parent_t = asn::enumerated<8, 0, true>;
12771         typedef enum {
12772                 dB_6
12773                 ,dB_4dot77
12774                 ,dB_3
12775                 ,dB_1dot77
12776                 ,dB0
12777                 ,dB1
12778                 ,dB2
12779                 ,dB3
12780         } index_t;
12781
12782 };
12783
12784 /*
12785 DynamicNAICSInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
12786         ...
12787 }
12788 */
12789
12790 struct DynamicNAICSInformation_ExtIEs
12791 {
12792         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
12793         {
12794                 size_t get_index() const {return type;}
12795                 bool is_unknown() const { return type == 1; }
12796                 void clear() {type = 0;}
12797                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
12798                 template<typename V>  bool decode(V& v)
12799                 {
12800                         clear();
12801                         if(!v(ref_nested())) return false;
12802                         { type = 1; return true;}
12803                         return false;
12804
12805                 }
12806                 template<typename V> bool encode(V& v) const
12807                 {
12808                         return v(ref_nested());
12809
12810                 }
12811                 protected:
12812                 template<typename V>  bool decode(size_t index, V& v)
12813                 {
12814                         clear();
12815                         switch(index)
12816                         {
12817                         case 1: type = 1; return v(ref_nested());
12818                         ref_nested().clear();
12819                         }
12820                         return false;
12821
12822                 }
12823                 template<typename V> bool encode(size_t index, V& v) const
12824                 {
12825                         if(index != type) {return false;} return v(ref_nested());
12826
12827                 }
12828                 private:
12829                 size_t type {0};
12830
12831         };
12832         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
12833         {
12834                 size_t get_index() const {return type;}
12835                 bool is_unknown() const { return type == 1; }
12836                 void clear() {type = 0;}
12837                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
12838                 template<typename V>  bool decode(V& v)
12839                 {
12840                         clear();
12841                         if(!v(ref_nested())) return false;
12842                         { type = 1; return true;}
12843                         return false;
12844
12845                 }
12846                 template<typename V> bool encode(V& v) const
12847                 {
12848                         return v(ref_nested());
12849
12850                 }
12851                 protected:
12852                 template<typename V>  bool decode(size_t index, V& v)
12853                 {
12854                         clear();
12855                         switch(index)
12856                         {
12857                         case 1: type = 1; return v(ref_nested());
12858                         ref_nested().clear();
12859                         }
12860                         return false;
12861
12862                 }
12863                 template<typename V> bool encode(size_t index, V& v) const
12864                 {
12865                         if(index != type) {return false;} return v(ref_nested());
12866
12867                 }
12868                 private:
12869                 size_t type {0};
12870
12871         };
12872         struct Extension_t : asn::typefield<true>
12873         {
12874                 ~Extension_t()  {clear();}
12875                 size_t get_index() const {return type;}
12876                 bool is_unknown() const { return type == 1; }
12877                 void clear()
12878                 {
12879                         type = 0; ref_nested().clear();
12880                 }
12881                 template<typename V> static inline void enumerate(V& v)
12882                 {
12883
12884                 }
12885                 protected:
12886                 template<typename V> bool decode(size_t index, V& v)
12887                 {
12888                         clear();
12889                         switch(index)
12890                         {
12891                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
12892                         }
12893                         return false;
12894
12895                 }
12896                 template<typename V> bool encode(size_t index, V& v) const
12897                 {
12898                         if(index != type) return false;
12899                         return false;
12900
12901                 }
12902                 private:
12903                 size_t type {0};
12904
12905         };
12906         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
12907         {
12908                 size_t get_index() const {return type;}
12909                 bool is_unknown() const { return type == 1; }
12910                 void clear() {type = 0;}
12911                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
12912                 template<typename V>  bool decode(V& v)
12913                 {
12914                         clear();
12915                         if(!v(ref_nested())) return false;
12916                         { type = 1; return true;}
12917                         return false;
12918
12919                 }
12920                 template<typename V> bool encode(V& v) const
12921                 {
12922                         return v(ref_nested());
12923
12924                 }
12925                 protected:
12926                 template<typename V>  bool decode(size_t index, V& v)
12927                 {
12928                         clear();
12929                         switch(index)
12930                         {
12931                         case 1: type = 1; return v(ref_nested());
12932                         ref_nested().clear();
12933                         }
12934                         return false;
12935
12936                 }
12937                 template<typename V> bool encode(size_t index, V& v) const
12938                 {
12939                         if(index != type) {return false;} return v(ref_nested());
12940
12941                 }
12942                 private:
12943                 size_t type {0};
12944
12945         };
12946
12947 };
12948 /*
12949 DynamicNAICSInformation ::= SEQUENCE {
12950         transmissionModes                                       BIT STRING (SIZE(8))                                                                                            OPTIONAL,
12951         pB-information                                          INTEGER(0..3)                                                                                                           OPTIONAL,
12952         pA-list                                                         SEQUENCE (SIZE(0..maxnoofPA)) OF PA-Values,
12953         iE-Extensions                                           ProtocolExtensionContainer { {DynamicNAICSInformation-ExtIEs} } OPTIONAL,
12954         ...
12955 }
12956 */
12957
12958 struct DynamicNAICSInformation : asn::sequence<4, 0, true, 3>
12959 {
12960         static constexpr const char* name() {return "DynamicNAICSInformation";}
12961         using parent_t = asn::sequence<4, 0, true, 3>;
12962         struct transmissionModes_t : asn::bstring<>
12963         {
12964                 using constraint_t = asn::constraints<false,asn::one<8>>;
12965                 static constexpr const char* name() {return "transmissionModes_t";}
12966                 using parent_t = asn::bstring<>;
12967                 static constexpr bool optional = true;
12968
12969         };
12970
12971         transmissionModes_t& set_transmissionModes() { transmissionModes.setpresent(true); return transmissionModes;}
12972         transmissionModes_t const* get_transmissionModes() const {return transmissionModes.is_valid() ? &transmissionModes : nullptr;}
12973         struct pB_information_t : asn::integer<>
12974         {
12975                 using constraint_t = asn::constraints<false,asn::span<0, 3>>;
12976                 static constexpr const char* name() {return "pB_information_t";}
12977                 using parent_t = asn::integer<>;
12978                 static constexpr bool optional = true;
12979
12980         };
12981
12982         pB_information_t& set_pB_information() { pB_information.setpresent(true); return pB_information;}
12983         pB_information_t const* get_pB_information() const {return pB_information.is_valid() ? &pB_information : nullptr;}
12984         struct pA_list_t_elm : PA_Values
12985         {
12986                 static constexpr const char* name() {return "pA_list_t_elm";}
12987                 using parent_t = PA_Values;
12988
12989         };
12990         struct pA_list_t : asn::sequenceof<pA_list_t_elm>
12991         {
12992                 static constexpr const char* name() {return "pA_list_t";}
12993                 using parent_t = asn::sequenceof<pA_list_t_elm>;
12994                 using constraint_t = asn::constraints<false,asn::span<0,  maxnoofPA >>;
12995
12996         };
12997         pA_list_t& ref_pA_list() {return pA_list;}
12998         pA_list_t const& ref_pA_list() const {return pA_list;}
12999         struct iE_Extensions_t : ProtocolExtensionContainer<DynamicNAICSInformation_ExtIEs>
13000         {
13001                 static constexpr const char* name() {return "iE_Extensions_t";}
13002                 using parent_t = ProtocolExtensionContainer<DynamicNAICSInformation_ExtIEs>;
13003                 static constexpr bool optional = true;
13004
13005         };
13006         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
13007         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
13008         template<typename V> void decode(V& v)
13009         {
13010                 v(transmissionModes);
13011                 v(pB_information);
13012                 v(pA_list);
13013                 v(iE_Extensions);
13014
13015         };
13016         template<typename V> void encode(V& v) const
13017         {
13018                 v(transmissionModes);
13019                 v(pB_information);
13020                 v(pA_list);
13021                 v(iE_Extensions);
13022
13023         };
13024         void clear()
13025         {
13026                 transmissionModes.clear();
13027                 pB_information.clear();
13028                 pA_list.clear();
13029                 iE_Extensions.clear();
13030
13031         };
13032         private:
13033         transmissionModes_t     transmissionModes;
13034         pB_information_t        pB_information;
13035         pA_list_t       pA_list;
13036         iE_Extensions_t iE_Extensions;
13037
13038 };
13039 /*
13040 DynamicDLTransmissionInformation ::= CHOICE {
13041         naics-active                    DynamicNAICSInformation,
13042         naics-inactive                  NULL,
13043         ...
13044 }
13045 */
13046
13047 struct DynamicDLTransmissionInformation : asn::choice<2, 0, true>
13048 {
13049         static constexpr const char* name() {return "DynamicDLTransmissionInformation";}
13050         using parent_t = asn::choice<2, 0, true>;
13051         index_type get_index() const {return index;}
13052         bool is_unknown() const {return index == 3;}
13053         void set_unknown() { set_index(3);  }
13054         ~DynamicDLTransmissionInformation() {clear();}
13055         struct naics_active_t : DynamicNAICSInformation
13056         {
13057                 static constexpr const char* name() {return "naics_active_t";}
13058                 using parent_t = DynamicNAICSInformation;
13059
13060         };
13061         struct naics_inactive_t : asn::nulltype
13062         {
13063                 static constexpr const char* name() {return "naics_inactive_t";}
13064                 using parent_t = asn::nulltype;
13065
13066         };
13067         void clear()
13068         {
13069                 switch(get_index())
13070                 {
13071                 case 1: var.destroy<naics_active_t>(); break;
13072                 case 2: var.destroy<naics_inactive_t>(); break;
13073                 }
13074                 index = 0;
13075                 base::clear();
13076         }
13077         template<typename V> bool decode(size_t idx, V& v)
13078         {
13079                 clear();
13080                 switch(idx)
13081                 {
13082                 case 1: set_index(1); return v(var.build<naics_active_t>());
13083                 case 2: set_index(2); return v(var.build<naics_inactive_t>());
13084                 }
13085                 return false;
13086
13087         }
13088         template<typename V> bool encode(V& v) const
13089         {
13090                 switch(get_index())
13091                 {
13092                 case 1: return v(var.as<naics_active_t>());
13093                 case 2: return v(var.as<naics_inactive_t>());
13094                 }
13095                 return false;
13096         }
13097         template<typename V> static inline void enumerate(V& v)
13098         {
13099                 v.template operator()<naics_active_t>(1);
13100                 v.template operator()<naics_inactive_t>(2);
13101
13102         }
13103         naics_active_t& select_naics_active() { if(get_index() != 1) { clear(); set_index(1); return var.build<naics_active_t>();} return var.as<naics_active_t>();}
13104         naics_active_t const* get_naics_active() const { if(get_index() == 1) { return &var.as<naics_active_t>();} return nullptr; }
13105         naics_inactive_t& select_naics_inactive() { if(get_index() != 2) { clear(); set_index(2); return var.build<naics_inactive_t>();} return var.as<naics_inactive_t>();}
13106         naics_inactive_t const* get_naics_inactive() const { if(get_index() == 2) { return &var.as<naics_inactive_t>();} return nullptr; }
13107         private:
13108         void set_index(index_type i) {index = i; base::set();}
13109         union union_type
13110         {
13111                 char dummy1[sizeof(naics_active_t)];
13112                 char dummy2[sizeof(naics_inactive_t)];
13113
13114         };
13115         asn::variant<sizeof(union_type)>        var;
13116         index_type      index {0};
13117 };
13118 /*
13119 E-RAB-ID ::= INTEGER (0..15, ...)
13120 */
13121
13122 struct E_RAB_ID : asn::integer<>
13123 {
13124         using constraint_t = asn::constraints<true,asn::span<0, 15>>;
13125         static constexpr const char* name() {return "E-RAB-ID";}
13126         using parent_t = asn::integer<>;
13127
13128 };
13129
13130 /*
13131 E-RAB-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
13132         ...
13133 }
13134 */
13135
13136 struct E_RAB_Item_ExtIEs
13137 {
13138         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
13139         {
13140                 size_t get_index() const {return type;}
13141                 bool is_unknown() const { return type == 1; }
13142                 void clear() {type = 0;}
13143                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
13144                 template<typename V>  bool decode(V& v)
13145                 {
13146                         clear();
13147                         if(!v(ref_nested())) return false;
13148                         { type = 1; return true;}
13149                         return false;
13150
13151                 }
13152                 template<typename V> bool encode(V& v) const
13153                 {
13154                         return v(ref_nested());
13155
13156                 }
13157                 protected:
13158                 template<typename V>  bool decode(size_t index, V& v)
13159                 {
13160                         clear();
13161                         switch(index)
13162                         {
13163                         case 1: type = 1; return v(ref_nested());
13164                         ref_nested().clear();
13165                         }
13166                         return false;
13167
13168                 }
13169                 template<typename V> bool encode(size_t index, V& v) const
13170                 {
13171                         if(index != type) {return false;} return v(ref_nested());
13172
13173                 }
13174                 private:
13175                 size_t type {0};
13176
13177         };
13178         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
13179         {
13180                 size_t get_index() const {return type;}
13181                 bool is_unknown() const { return type == 1; }
13182                 void clear() {type = 0;}
13183                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
13184                 template<typename V>  bool decode(V& v)
13185                 {
13186                         clear();
13187                         if(!v(ref_nested())) return false;
13188                         { type = 1; return true;}
13189                         return false;
13190
13191                 }
13192                 template<typename V> bool encode(V& v) const
13193                 {
13194                         return v(ref_nested());
13195
13196                 }
13197                 protected:
13198                 template<typename V>  bool decode(size_t index, V& v)
13199                 {
13200                         clear();
13201                         switch(index)
13202                         {
13203                         case 1: type = 1; return v(ref_nested());
13204                         ref_nested().clear();
13205                         }
13206                         return false;
13207
13208                 }
13209                 template<typename V> bool encode(size_t index, V& v) const
13210                 {
13211                         if(index != type) {return false;} return v(ref_nested());
13212
13213                 }
13214                 private:
13215                 size_t type {0};
13216
13217         };
13218         struct Extension_t : asn::typefield<true>
13219         {
13220                 ~Extension_t()  {clear();}
13221                 size_t get_index() const {return type;}
13222                 bool is_unknown() const { return type == 1; }
13223                 void clear()
13224                 {
13225                         type = 0; ref_nested().clear();
13226                 }
13227                 template<typename V> static inline void enumerate(V& v)
13228                 {
13229
13230                 }
13231                 protected:
13232                 template<typename V> bool decode(size_t index, V& v)
13233                 {
13234                         clear();
13235                         switch(index)
13236                         {
13237                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
13238                         }
13239                         return false;
13240
13241                 }
13242                 template<typename V> bool encode(size_t index, V& v) const
13243                 {
13244                         if(index != type) return false;
13245                         return false;
13246
13247                 }
13248                 private:
13249                 size_t type {0};
13250
13251         };
13252         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
13253         {
13254                 size_t get_index() const {return type;}
13255                 bool is_unknown() const { return type == 1; }
13256                 void clear() {type = 0;}
13257                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
13258                 template<typename V>  bool decode(V& v)
13259                 {
13260                         clear();
13261                         if(!v(ref_nested())) return false;
13262                         { type = 1; return true;}
13263                         return false;
13264
13265                 }
13266                 template<typename V> bool encode(V& v) const
13267                 {
13268                         return v(ref_nested());
13269
13270                 }
13271                 protected:
13272                 template<typename V>  bool decode(size_t index, V& v)
13273                 {
13274                         clear();
13275                         switch(index)
13276                         {
13277                         case 1: type = 1; return v(ref_nested());
13278                         ref_nested().clear();
13279                         }
13280                         return false;
13281
13282                 }
13283                 template<typename V> bool encode(size_t index, V& v) const
13284                 {
13285                         if(index != type) {return false;} return v(ref_nested());
13286
13287                 }
13288                 private:
13289                 size_t type {0};
13290
13291         };
13292
13293 };
13294 /*
13295 E-RAB-Item ::= SEQUENCE {
13296         e-RAB-ID                                E-RAB-ID,
13297         cause                                           Cause,
13298         iE-Extensions                           ProtocolExtensionContainer { {E-RAB-Item-ExtIEs} } OPTIONAL,
13299         ...
13300 }
13301 */
13302
13303 struct E_RAB_Item : asn::sequence<3, 0, true, 1>
13304 {
13305         static constexpr const char* name() {return "E-RAB-Item";}
13306         using parent_t = asn::sequence<3, 0, true, 1>;
13307         struct e_RAB_ID_t : E_RAB_ID
13308         {
13309                 static constexpr const char* name() {return "e_RAB_ID_t";}
13310                 using parent_t = E_RAB_ID;
13311
13312         };
13313         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
13314         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
13315         struct cause_t : Cause
13316         {
13317                 static constexpr const char* name() {return "cause_t";}
13318                 using parent_t = Cause;
13319
13320         };
13321         cause_t& ref_cause() {return cause;}
13322         cause_t const& ref_cause() const {return cause;}
13323         struct iE_Extensions_t : ProtocolExtensionContainer<E_RAB_Item_ExtIEs>
13324         {
13325                 static constexpr const char* name() {return "iE_Extensions_t";}
13326                 using parent_t = ProtocolExtensionContainer<E_RAB_Item_ExtIEs>;
13327                 static constexpr bool optional = true;
13328
13329         };
13330         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
13331         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
13332         template<typename V> void decode(V& v)
13333         {
13334                 v(e_RAB_ID);
13335                 v(cause);
13336                 v(iE_Extensions);
13337
13338         };
13339         template<typename V> void encode(V& v) const
13340         {
13341                 v(e_RAB_ID);
13342                 v(cause);
13343                 v(iE_Extensions);
13344
13345         };
13346         void clear()
13347         {
13348                 e_RAB_ID.clear();
13349                 cause.clear();
13350                 iE_Extensions.clear();
13351
13352         };
13353         private:
13354         e_RAB_ID_t      e_RAB_ID;
13355         cause_t cause;
13356         iE_Extensions_t iE_Extensions;
13357
13358 };
13359 /*
13360 E-RAB-ItemIEs   X2AP-PROTOCOL-IES ::= {
13361         { ID id-E-RAB-Item       CRITICALITY ignore     TYPE E-RAB-Item         PRESENCE mandatory },
13362         ...
13363 }
13364 */
13365
13366 struct E_RAB_ItemIEs
13367 {
13368         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
13369         {
13370                 size_t get_index() const {return type;}
13371                 bool is_unknown() const { return type == 2; }
13372                 void clear() {type = 0;}
13373                 void select_id_E_RAB_Item() { set(id_E_RAB_Item); type=1;}
13374                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
13375                 template<typename V>  bool decode(V& v)
13376                 {
13377                         clear();
13378                         if(!v(ref_nested())) return false;
13379                         if(equal(id_E_RAB_Item)) { type = 1; return true; }
13380                         else { type = 2; return true;}
13381                         return false;
13382
13383                 }
13384                 template<typename V> bool encode(V& v) const
13385                 {
13386                         return v(ref_nested());
13387
13388                 }
13389                 protected:
13390                 template<typename V>  bool decode(size_t index, V& v)
13391                 {
13392                         clear();
13393                         switch(index)
13394                         {
13395                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RAB_Item);} return false;
13396                         case 2: type = 2; return v(ref_nested());
13397                         ref_nested().clear();
13398                         }
13399                         return false;
13400
13401                 }
13402                 template<typename V> bool encode(size_t index, V& v) const
13403                 {
13404                         if(index != type) {return false;} return v(ref_nested());
13405
13406                 }
13407                 private:
13408                 size_t type {0};
13409
13410         };
13411         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
13412         {
13413                 size_t get_index() const {return type;}
13414                 bool is_unknown() const { return type == 2; }
13415                 void clear() {type = 0;}
13416                 void select_id_E_RAB_Item() { set(ignore); type=1;}
13417                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
13418                 template<typename V>  bool decode(V& v)
13419                 {
13420                         clear();
13421                         if(!v(ref_nested())) return false;
13422                         if(equal(ignore)) { type = 1; return true; }
13423                         else { type = 2; return true;}
13424                         return false;
13425
13426                 }
13427                 template<typename V> bool encode(V& v) const
13428                 {
13429                         return v(ref_nested());
13430
13431                 }
13432                 protected:
13433                 template<typename V>  bool decode(size_t index, V& v)
13434                 {
13435                         clear();
13436                         switch(index)
13437                         {
13438                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
13439                         case 2: type = 2; return v(ref_nested());
13440                         ref_nested().clear();
13441                         }
13442                         return false;
13443
13444                 }
13445                 template<typename V> bool encode(size_t index, V& v) const
13446                 {
13447                         if(index != type) {return false;} return v(ref_nested());
13448
13449                 }
13450                 private:
13451                 size_t type {0};
13452
13453         };
13454         struct Value_t : asn::typefield<true>
13455         {
13456                 ~Value_t()      {clear();}
13457                 size_t get_index() const {return type;}
13458                 E_RAB_Item& select_id_E_RAB_Item() { return set<E_RAB_Item>(1); }
13459                 E_RAB_Item const* get_id_E_RAB_Item() const { return get<E_RAB_Item>(1); }
13460                 bool is_unknown() const { return type == 2; }
13461                 void clear()
13462                 {
13463                         switch(type)
13464                         {
13465                         case 1: var.destroy<E_RAB_Item>(); break;
13466                         }
13467                         type = 0; ref_nested().clear();
13468                 }
13469                 template<typename V> static inline void enumerate(V& v)
13470                 {
13471                         v.template operator()<E_RAB_Item>(1);
13472
13473                 }
13474                 protected:
13475                 template<typename V> bool decode(size_t index, V& v)
13476                 {
13477                         clear();
13478                         switch(index)
13479                         {
13480                         case 1: v(select_id_E_RAB_Item()); return true;
13481                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
13482                         }
13483                         return false;
13484
13485                 }
13486                 template<typename V> bool encode(size_t index, V& v) const
13487                 {
13488                         if(index != type) return false;
13489                         switch(type)
13490                         {
13491                         case 1: v(var.as<E_RAB_Item>()); return true;
13492                         }
13493                         return false;
13494
13495                 }
13496                 private:
13497                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
13498                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
13499                 union union_type
13500                 {
13501                         char dummy1[sizeof(E_RAB_Item)];
13502
13503                 };
13504                 asn::variant<sizeof(union_type)> var;
13505                 size_t type {0};
13506
13507         };
13508         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
13509         {
13510                 size_t get_index() const {return type;}
13511                 bool is_unknown() const { return type == 2; }
13512                 void clear() {type = 0;}
13513                 void select_id_E_RAB_Item() { set(mandatory); type=1;}
13514                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
13515                 template<typename V>  bool decode(V& v)
13516                 {
13517                         clear();
13518                         if(!v(ref_nested())) return false;
13519                         if(equal(mandatory)) { type = 1; return true; }
13520                         else { type = 2; return true;}
13521                         return false;
13522
13523                 }
13524                 template<typename V> bool encode(V& v) const
13525                 {
13526                         return v(ref_nested());
13527
13528                 }
13529                 protected:
13530                 template<typename V>  bool decode(size_t index, V& v)
13531                 {
13532                         clear();
13533                         switch(index)
13534                         {
13535                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
13536                         case 2: type = 2; return v(ref_nested());
13537                         ref_nested().clear();
13538                         }
13539                         return false;
13540
13541                 }
13542                 template<typename V> bool encode(size_t index, V& v) const
13543                 {
13544                         if(index != type) {return false;} return v(ref_nested());
13545
13546                 }
13547                 private:
13548                 size_t type {0};
13549
13550         };
13551
13552 };
13553 /*
13554 QCI ::= INTEGER (0..255)
13555 */
13556
13557 struct QCI : asn::integer<>
13558 {
13559         using constraint_t = asn::constraints<false,asn::span<0, 255>>;
13560         static constexpr const char* name() {return "QCI";}
13561         using parent_t = asn::integer<>;
13562
13563 };
13564
13565 /*
13566 ExtendedBitRate ::= INTEGER (10000000001..4000000000000,...)
13567 */
13568
13569 struct ExtendedBitRate : asn::integer<>
13570 {
13571         using constraint_t = asn::constraints<true,asn::span<10000000001, 4000000000000>>;
13572         static constexpr const char* name() {return "ExtendedBitRate";}
13573         using parent_t = asn::integer<>;
13574
13575 };
13576
13577 /*
13578 GBR-QosInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
13579 -- Extension for maximum bitrate > 10Gbps --
13580         { ID id-extended-e-RAB-MaximumBitrateDL         CRITICALITY ignore      EXTENSION ExtendedBitRate       PRESENCE optional}|
13581         { ID id-extended-e-RAB-MaximumBitrateUL         CRITICALITY ignore      EXTENSION ExtendedBitRate       PRESENCE optional}|
13582         { ID id-extended-e-RAB-GuaranteedBitrateDL      CRITICALITY ignore      EXTENSION ExtendedBitRate       PRESENCE optional}|
13583         { ID id-extended-e-RAB-GuaranteedBitrateUL      CRITICALITY ignore      EXTENSION ExtendedBitRate       PRESENCE optional},
13584         ...
13585 }
13586 */
13587
13588 struct GBR_QosInformation_ExtIEs
13589 {
13590         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
13591         {
13592                 size_t get_index() const {return type;}
13593                 bool is_unknown() const { return type == 5; }
13594                 void clear() {type = 0;}
13595                 void select_id_extended_e_RAB_MaximumBitrateDL() { set(id_extended_e_RAB_MaximumBitrateDL); type=1;}
13596                 void select_id_extended_e_RAB_MaximumBitrateUL() { set(id_extended_e_RAB_MaximumBitrateUL); type=2;}
13597                 void select_id_extended_e_RAB_GuaranteedBitrateDL() { set(id_extended_e_RAB_GuaranteedBitrateDL); type=3;}
13598                 void select_id_extended_e_RAB_GuaranteedBitrateUL() { set(id_extended_e_RAB_GuaranteedBitrateUL); type=4;}
13599                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
13600                 template<typename V>  bool decode(V& v)
13601                 {
13602                         clear();
13603                         if(!v(ref_nested())) return false;
13604                         if(equal(id_extended_e_RAB_MaximumBitrateDL)) { type = 1; return true; }
13605                         else if(equal(id_extended_e_RAB_MaximumBitrateUL)) { type = 2; return true; }
13606                         else if(equal(id_extended_e_RAB_GuaranteedBitrateDL)) { type = 3; return true; }
13607                         else if(equal(id_extended_e_RAB_GuaranteedBitrateUL)) { type = 4; return true; }
13608                         else { type = 5; return true;}
13609                         return false;
13610
13611                 }
13612                 template<typename V> bool encode(V& v) const
13613                 {
13614                         return v(ref_nested());
13615
13616                 }
13617                 protected:
13618                 template<typename V>  bool decode(size_t index, V& v)
13619                 {
13620                         clear();
13621                         switch(index)
13622                         {
13623                         case 1: type = 1; if(v(ref_nested())) { return equal(id_extended_e_RAB_MaximumBitrateDL);} return false;
13624                         case 2: type = 2; if(v(ref_nested())) { return equal(id_extended_e_RAB_MaximumBitrateUL);} return false;
13625                         case 3: type = 3; if(v(ref_nested())) { return equal(id_extended_e_RAB_GuaranteedBitrateDL);} return false;
13626                         case 4: type = 4; if(v(ref_nested())) { return equal(id_extended_e_RAB_GuaranteedBitrateUL);} return false;
13627                         case 5: type = 5; return v(ref_nested());
13628                         ref_nested().clear();
13629                         }
13630                         return false;
13631
13632                 }
13633                 template<typename V> bool encode(size_t index, V& v) const
13634                 {
13635                         if(index != type) {return false;} return v(ref_nested());
13636
13637                 }
13638                 private:
13639                 size_t type {0};
13640
13641         };
13642         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
13643         {
13644                 size_t get_index() const {return type;}
13645                 bool is_unknown() const { return type == 5; }
13646                 void clear() {type = 0;}
13647                 void select_id_extended_e_RAB_MaximumBitrateDL() { set(ignore); type=1;}
13648                 void select_id_extended_e_RAB_MaximumBitrateUL() { set(ignore); type=2;}
13649                 void select_id_extended_e_RAB_GuaranteedBitrateDL() { set(ignore); type=3;}
13650                 void select_id_extended_e_RAB_GuaranteedBitrateUL() { set(ignore); type=4;}
13651                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
13652                 template<typename V>  bool decode(V& v)
13653                 {
13654                         clear();
13655                         if(!v(ref_nested())) return false;
13656                         if(equal(ignore)) { type = 1; return true; }
13657                         else if(equal(ignore)) { type = 2; return true; }
13658                         else if(equal(ignore)) { type = 3; return true; }
13659                         else if(equal(ignore)) { type = 4; return true; }
13660                         else { type = 5; return true;}
13661                         return false;
13662
13663                 }
13664                 template<typename V> bool encode(V& v) const
13665                 {
13666                         return v(ref_nested());
13667
13668                 }
13669                 protected:
13670                 template<typename V>  bool decode(size_t index, V& v)
13671                 {
13672                         clear();
13673                         switch(index)
13674                         {
13675                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
13676                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
13677                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
13678                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
13679                         case 5: type = 5; return v(ref_nested());
13680                         ref_nested().clear();
13681                         }
13682                         return false;
13683
13684                 }
13685                 template<typename V> bool encode(size_t index, V& v) const
13686                 {
13687                         if(index != type) {return false;} return v(ref_nested());
13688
13689                 }
13690                 private:
13691                 size_t type {0};
13692
13693         };
13694         struct Extension_t : asn::typefield<true>
13695         {
13696                 ~Extension_t()  {clear();}
13697                 size_t get_index() const {return type;}
13698                 ExtendedBitRate& select_id_extended_e_RAB_MaximumBitrateDL() { return set<ExtendedBitRate>(1); }
13699                 ExtendedBitRate const* get_id_extended_e_RAB_MaximumBitrateDL() const { return get<ExtendedBitRate>(1); }
13700                 ExtendedBitRate& select_id_extended_e_RAB_MaximumBitrateUL() { return set<ExtendedBitRate>(2); }
13701                 ExtendedBitRate const* get_id_extended_e_RAB_MaximumBitrateUL() const { return get<ExtendedBitRate>(2); }
13702                 ExtendedBitRate& select_id_extended_e_RAB_GuaranteedBitrateDL() { return set<ExtendedBitRate>(3); }
13703                 ExtendedBitRate const* get_id_extended_e_RAB_GuaranteedBitrateDL() const { return get<ExtendedBitRate>(3); }
13704                 ExtendedBitRate& select_id_extended_e_RAB_GuaranteedBitrateUL() { return set<ExtendedBitRate>(4); }
13705                 ExtendedBitRate const* get_id_extended_e_RAB_GuaranteedBitrateUL() const { return get<ExtendedBitRate>(4); }
13706                 bool is_unknown() const { return type == 5; }
13707                 void clear()
13708                 {
13709                         switch(type)
13710                         {
13711                         case 1: var.destroy<ExtendedBitRate>(); break;
13712                         case 2: var.destroy<ExtendedBitRate>(); break;
13713                         case 3: var.destroy<ExtendedBitRate>(); break;
13714                         case 4: var.destroy<ExtendedBitRate>(); break;
13715                         }
13716                         type = 0; ref_nested().clear();
13717                 }
13718                 template<typename V> static inline void enumerate(V& v)
13719                 {
13720                         v.template operator()<ExtendedBitRate>(1);
13721                         v.template operator()<ExtendedBitRate>(2);
13722                         v.template operator()<ExtendedBitRate>(3);
13723                         v.template operator()<ExtendedBitRate>(4);
13724
13725                 }
13726                 protected:
13727                 template<typename V> bool decode(size_t index, V& v)
13728                 {
13729                         clear();
13730                         switch(index)
13731                         {
13732                         case 1: v(select_id_extended_e_RAB_MaximumBitrateDL()); return true;
13733                         case 2: v(select_id_extended_e_RAB_MaximumBitrateUL()); return true;
13734                         case 3: v(select_id_extended_e_RAB_GuaranteedBitrateDL()); return true;
13735                         case 4: v(select_id_extended_e_RAB_GuaranteedBitrateUL()); return true;
13736                         case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
13737                         }
13738                         return false;
13739
13740                 }
13741                 template<typename V> bool encode(size_t index, V& v) const
13742                 {
13743                         if(index != type) return false;
13744                         switch(type)
13745                         {
13746                         case 1: v(var.as<ExtendedBitRate>()); return true;
13747                         case 2: v(var.as<ExtendedBitRate>()); return true;
13748                         case 3: v(var.as<ExtendedBitRate>()); return true;
13749                         case 4: v(var.as<ExtendedBitRate>()); return true;
13750                         }
13751                         return false;
13752
13753                 }
13754                 private:
13755                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
13756                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
13757                 union union_type
13758                 {
13759                         char dummy1[sizeof(ExtendedBitRate)];
13760
13761                 };
13762                 asn::variant<sizeof(union_type)> var;
13763                 size_t type {0};
13764
13765         };
13766         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
13767         {
13768                 size_t get_index() const {return type;}
13769                 bool is_unknown() const { return type == 5; }
13770                 void clear() {type = 0;}
13771                 void select_id_extended_e_RAB_MaximumBitrateDL() { set(optional); type=1;}
13772                 void select_id_extended_e_RAB_MaximumBitrateUL() { set(optional); type=2;}
13773                 void select_id_extended_e_RAB_GuaranteedBitrateDL() { set(optional); type=3;}
13774                 void select_id_extended_e_RAB_GuaranteedBitrateUL() { set(optional); type=4;}
13775                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
13776                 template<typename V>  bool decode(V& v)
13777                 {
13778                         clear();
13779                         if(!v(ref_nested())) return false;
13780                         if(equal(optional)) { type = 1; return true; }
13781                         else if(equal(optional)) { type = 2; return true; }
13782                         else if(equal(optional)) { type = 3; return true; }
13783                         else if(equal(optional)) { type = 4; return true; }
13784                         else { type = 5; return true;}
13785                         return false;
13786
13787                 }
13788                 template<typename V> bool encode(V& v) const
13789                 {
13790                         return v(ref_nested());
13791
13792                 }
13793                 protected:
13794                 template<typename V>  bool decode(size_t index, V& v)
13795                 {
13796                         clear();
13797                         switch(index)
13798                         {
13799                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
13800                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
13801                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
13802                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
13803                         case 5: type = 5; return v(ref_nested());
13804                         ref_nested().clear();
13805                         }
13806                         return false;
13807
13808                 }
13809                 template<typename V> bool encode(size_t index, V& v) const
13810                 {
13811                         if(index != type) {return false;} return v(ref_nested());
13812
13813                 }
13814                 private:
13815                 size_t type {0};
13816
13817         };
13818
13819 };
13820 /*
13821 GBR-QosInformation ::= SEQUENCE {
13822         e-RAB-MaximumBitrateDL                  BitRate,
13823         e-RAB-MaximumBitrateUL                  BitRate,
13824         e-RAB-GuaranteedBitrateDL               BitRate,
13825         e-RAB-GuaranteedBitrateUL               BitRate,
13826         iE-Extensions                                   ProtocolExtensionContainer { {GBR-QosInformation-ExtIEs} } OPTIONAL,
13827         ...
13828 }
13829 */
13830
13831 struct GBR_QosInformation : asn::sequence<5, 0, true, 1>
13832 {
13833         static constexpr const char* name() {return "GBR-QosInformation";}
13834         using parent_t = asn::sequence<5, 0, true, 1>;
13835         struct e_RAB_MaximumBitrateDL_t : BitRate
13836         {
13837                 static constexpr const char* name() {return "e_RAB_MaximumBitrateDL_t";}
13838                 using parent_t = BitRate;
13839
13840         };
13841         e_RAB_MaximumBitrateDL_t& ref_e_RAB_MaximumBitrateDL() {return e_RAB_MaximumBitrateDL;}
13842         e_RAB_MaximumBitrateDL_t const& ref_e_RAB_MaximumBitrateDL() const {return e_RAB_MaximumBitrateDL;}
13843         struct e_RAB_MaximumBitrateUL_t : BitRate
13844         {
13845                 static constexpr const char* name() {return "e_RAB_MaximumBitrateUL_t";}
13846                 using parent_t = BitRate;
13847
13848         };
13849         e_RAB_MaximumBitrateUL_t& ref_e_RAB_MaximumBitrateUL() {return e_RAB_MaximumBitrateUL;}
13850         e_RAB_MaximumBitrateUL_t const& ref_e_RAB_MaximumBitrateUL() const {return e_RAB_MaximumBitrateUL;}
13851         struct e_RAB_GuaranteedBitrateDL_t : BitRate
13852         {
13853                 static constexpr const char* name() {return "e_RAB_GuaranteedBitrateDL_t";}
13854                 using parent_t = BitRate;
13855
13856         };
13857         e_RAB_GuaranteedBitrateDL_t& ref_e_RAB_GuaranteedBitrateDL() {return e_RAB_GuaranteedBitrateDL;}
13858         e_RAB_GuaranteedBitrateDL_t const& ref_e_RAB_GuaranteedBitrateDL() const {return e_RAB_GuaranteedBitrateDL;}
13859         struct e_RAB_GuaranteedBitrateUL_t : BitRate
13860         {
13861                 static constexpr const char* name() {return "e_RAB_GuaranteedBitrateUL_t";}
13862                 using parent_t = BitRate;
13863
13864         };
13865         e_RAB_GuaranteedBitrateUL_t& ref_e_RAB_GuaranteedBitrateUL() {return e_RAB_GuaranteedBitrateUL;}
13866         e_RAB_GuaranteedBitrateUL_t const& ref_e_RAB_GuaranteedBitrateUL() const {return e_RAB_GuaranteedBitrateUL;}
13867         struct iE_Extensions_t : ProtocolExtensionContainer<GBR_QosInformation_ExtIEs>
13868         {
13869                 static constexpr const char* name() {return "iE_Extensions_t";}
13870                 using parent_t = ProtocolExtensionContainer<GBR_QosInformation_ExtIEs>;
13871                 static constexpr bool optional = true;
13872
13873         };
13874         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
13875         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
13876         template<typename V> void decode(V& v)
13877         {
13878                 v(e_RAB_MaximumBitrateDL);
13879                 v(e_RAB_MaximumBitrateUL);
13880                 v(e_RAB_GuaranteedBitrateDL);
13881                 v(e_RAB_GuaranteedBitrateUL);
13882                 v(iE_Extensions);
13883
13884         };
13885         template<typename V> void encode(V& v) const
13886         {
13887                 v(e_RAB_MaximumBitrateDL);
13888                 v(e_RAB_MaximumBitrateUL);
13889                 v(e_RAB_GuaranteedBitrateDL);
13890                 v(e_RAB_GuaranteedBitrateUL);
13891                 v(iE_Extensions);
13892
13893         };
13894         void clear()
13895         {
13896                 e_RAB_MaximumBitrateDL.clear();
13897                 e_RAB_MaximumBitrateUL.clear();
13898                 e_RAB_GuaranteedBitrateDL.clear();
13899                 e_RAB_GuaranteedBitrateUL.clear();
13900                 iE_Extensions.clear();
13901
13902         };
13903         private:
13904         e_RAB_MaximumBitrateDL_t        e_RAB_MaximumBitrateDL;
13905         e_RAB_MaximumBitrateUL_t        e_RAB_MaximumBitrateUL;
13906         e_RAB_GuaranteedBitrateDL_t     e_RAB_GuaranteedBitrateDL;
13907         e_RAB_GuaranteedBitrateUL_t     e_RAB_GuaranteedBitrateUL;
13908         iE_Extensions_t iE_Extensions;
13909
13910 };
13911 /*
13912 Packet-LossRate ::= INTEGER(0..1000)
13913 */
13914
13915 struct Packet_LossRate : asn::integer<>
13916 {
13917         using constraint_t = asn::constraints<false,asn::span<0, 1000>>;
13918         static constexpr const char* name() {return "Packet-LossRate";}
13919         using parent_t = asn::integer<>;
13920
13921 };
13922
13923 /*
13924 E-RAB-Level-QoS-Parameters-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
13925 -- Extended for introduction of downlink and uplink packet loss rate for enhanced Voice performance –
13926         { ID id-DownlinkPacketLossRate                  CRITICALITY ignore      EXTENSION Packet-LossRate               PRESENCE optional}|
13927         { ID id-UplinkPacketLossRate                    CRITICALITY ignore      EXTENSION Packet-LossRate               PRESENCE optional},
13928         ...
13929 }
13930 */
13931
13932 struct E_RAB_Level_QoS_Parameters_ExtIEs
13933 {
13934         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
13935         {
13936                 size_t get_index() const {return type;}
13937                 bool is_unknown() const { return type == 3; }
13938                 void clear() {type = 0;}
13939                 void select_id_DownlinkPacketLossRate() { set(id_DownlinkPacketLossRate); type=1;}
13940                 void select_id_UplinkPacketLossRate() { set(id_UplinkPacketLossRate); type=2;}
13941                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
13942                 template<typename V>  bool decode(V& v)
13943                 {
13944                         clear();
13945                         if(!v(ref_nested())) return false;
13946                         if(equal(id_DownlinkPacketLossRate)) { type = 1; return true; }
13947                         else if(equal(id_UplinkPacketLossRate)) { type = 2; return true; }
13948                         else { type = 3; return true;}
13949                         return false;
13950
13951                 }
13952                 template<typename V> bool encode(V& v) const
13953                 {
13954                         return v(ref_nested());
13955
13956                 }
13957                 protected:
13958                 template<typename V>  bool decode(size_t index, V& v)
13959                 {
13960                         clear();
13961                         switch(index)
13962                         {
13963                         case 1: type = 1; if(v(ref_nested())) { return equal(id_DownlinkPacketLossRate);} return false;
13964                         case 2: type = 2; if(v(ref_nested())) { return equal(id_UplinkPacketLossRate);} return false;
13965                         case 3: type = 3; return v(ref_nested());
13966                         ref_nested().clear();
13967                         }
13968                         return false;
13969
13970                 }
13971                 template<typename V> bool encode(size_t index, V& v) const
13972                 {
13973                         if(index != type) {return false;} return v(ref_nested());
13974
13975                 }
13976                 private:
13977                 size_t type {0};
13978
13979         };
13980         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
13981         {
13982                 size_t get_index() const {return type;}
13983                 bool is_unknown() const { return type == 3; }
13984                 void clear() {type = 0;}
13985                 void select_id_DownlinkPacketLossRate() { set(ignore); type=1;}
13986                 void select_id_UplinkPacketLossRate() { set(ignore); type=2;}
13987                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
13988                 template<typename V>  bool decode(V& v)
13989                 {
13990                         clear();
13991                         if(!v(ref_nested())) return false;
13992                         if(equal(ignore)) { type = 1; return true; }
13993                         else if(equal(ignore)) { type = 2; return true; }
13994                         else { type = 3; return true;}
13995                         return false;
13996
13997                 }
13998                 template<typename V> bool encode(V& v) const
13999                 {
14000                         return v(ref_nested());
14001
14002                 }
14003                 protected:
14004                 template<typename V>  bool decode(size_t index, V& v)
14005                 {
14006                         clear();
14007                         switch(index)
14008                         {
14009                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
14010                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
14011                         case 3: type = 3; return v(ref_nested());
14012                         ref_nested().clear();
14013                         }
14014                         return false;
14015
14016                 }
14017                 template<typename V> bool encode(size_t index, V& v) const
14018                 {
14019                         if(index != type) {return false;} return v(ref_nested());
14020
14021                 }
14022                 private:
14023                 size_t type {0};
14024
14025         };
14026         struct Extension_t : asn::typefield<true>
14027         {
14028                 ~Extension_t()  {clear();}
14029                 size_t get_index() const {return type;}
14030                 Packet_LossRate& select_id_DownlinkPacketLossRate() { return set<Packet_LossRate>(1); }
14031                 Packet_LossRate const* get_id_DownlinkPacketLossRate() const { return get<Packet_LossRate>(1); }
14032                 Packet_LossRate& select_id_UplinkPacketLossRate() { return set<Packet_LossRate>(2); }
14033                 Packet_LossRate const* get_id_UplinkPacketLossRate() const { return get<Packet_LossRate>(2); }
14034                 bool is_unknown() const { return type == 3; }
14035                 void clear()
14036                 {
14037                         switch(type)
14038                         {
14039                         case 1: var.destroy<Packet_LossRate>(); break;
14040                         case 2: var.destroy<Packet_LossRate>(); break;
14041                         }
14042                         type = 0; ref_nested().clear();
14043                 }
14044                 template<typename V> static inline void enumerate(V& v)
14045                 {
14046                         v.template operator()<Packet_LossRate>(1);
14047                         v.template operator()<Packet_LossRate>(2);
14048
14049                 }
14050                 protected:
14051                 template<typename V> bool decode(size_t index, V& v)
14052                 {
14053                         clear();
14054                         switch(index)
14055                         {
14056                         case 1: v(select_id_DownlinkPacketLossRate()); return true;
14057                         case 2: v(select_id_UplinkPacketLossRate()); return true;
14058                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
14059                         }
14060                         return false;
14061
14062                 }
14063                 template<typename V> bool encode(size_t index, V& v) const
14064                 {
14065                         if(index != type) return false;
14066                         switch(type)
14067                         {
14068                         case 1: v(var.as<Packet_LossRate>()); return true;
14069                         case 2: v(var.as<Packet_LossRate>()); return true;
14070                         }
14071                         return false;
14072
14073                 }
14074                 private:
14075                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
14076                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
14077                 union union_type
14078                 {
14079                         char dummy1[sizeof(Packet_LossRate)];
14080
14081                 };
14082                 asn::variant<sizeof(union_type)> var;
14083                 size_t type {0};
14084
14085         };
14086         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
14087         {
14088                 size_t get_index() const {return type;}
14089                 bool is_unknown() const { return type == 3; }
14090                 void clear() {type = 0;}
14091                 void select_id_DownlinkPacketLossRate() { set(optional); type=1;}
14092                 void select_id_UplinkPacketLossRate() { set(optional); type=2;}
14093                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
14094                 template<typename V>  bool decode(V& v)
14095                 {
14096                         clear();
14097                         if(!v(ref_nested())) return false;
14098                         if(equal(optional)) { type = 1; return true; }
14099                         else if(equal(optional)) { type = 2; return true; }
14100                         else { type = 3; return true;}
14101                         return false;
14102
14103                 }
14104                 template<typename V> bool encode(V& v) const
14105                 {
14106                         return v(ref_nested());
14107
14108                 }
14109                 protected:
14110                 template<typename V>  bool decode(size_t index, V& v)
14111                 {
14112                         clear();
14113                         switch(index)
14114                         {
14115                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
14116                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
14117                         case 3: type = 3; return v(ref_nested());
14118                         ref_nested().clear();
14119                         }
14120                         return false;
14121
14122                 }
14123                 template<typename V> bool encode(size_t index, V& v) const
14124                 {
14125                         if(index != type) {return false;} return v(ref_nested());
14126
14127                 }
14128                 private:
14129                 size_t type {0};
14130
14131         };
14132
14133 };
14134 /*
14135 E-RAB-Level-QoS-Parameters ::= SEQUENCE {
14136         qCI                                                             QCI,
14137         allocationAndRetentionPriority  AllocationAndRetentionPriority,
14138         gbrQosInformation                               GBR-QosInformation                                                                                                      OPTIONAL,
14139         iE-Extensions                                   ProtocolExtensionContainer { {E-RAB-Level-QoS-Parameters-ExtIEs} }      OPTIONAL,
14140         ...
14141 }
14142 */
14143
14144 struct E_RAB_Level_QoS_Parameters : asn::sequence<4, 0, true, 2>
14145 {
14146         static constexpr const char* name() {return "E-RAB-Level-QoS-Parameters";}
14147         using parent_t = asn::sequence<4, 0, true, 2>;
14148         struct qCI_t : QCI
14149         {
14150                 static constexpr const char* name() {return "qCI_t";}
14151                 using parent_t = QCI;
14152
14153         };
14154         qCI_t& ref_qCI() {return qCI;}
14155         qCI_t const& ref_qCI() const {return qCI;}
14156         struct allocationAndRetentionPriority_t : AllocationAndRetentionPriority
14157         {
14158                 static constexpr const char* name() {return "allocationAndRetentionPriority_t";}
14159                 using parent_t = AllocationAndRetentionPriority;
14160
14161         };
14162         allocationAndRetentionPriority_t& ref_allocationAndRetentionPriority() {return allocationAndRetentionPriority;}
14163         allocationAndRetentionPriority_t const& ref_allocationAndRetentionPriority() const {return allocationAndRetentionPriority;}
14164         struct gbrQosInformation_t : GBR_QosInformation
14165         {
14166                 static constexpr const char* name() {return "gbrQosInformation_t";}
14167                 using parent_t = GBR_QosInformation;
14168                 static constexpr bool optional = true;
14169
14170         };
14171         gbrQosInformation_t& set_gbrQosInformation() { gbrQosInformation.setpresent(true); return gbrQosInformation;}
14172         gbrQosInformation_t const* get_gbrQosInformation() const {return gbrQosInformation.is_valid() ? &gbrQosInformation : nullptr;}
14173         struct iE_Extensions_t : ProtocolExtensionContainer<E_RAB_Level_QoS_Parameters_ExtIEs>
14174         {
14175                 static constexpr const char* name() {return "iE_Extensions_t";}
14176                 using parent_t = ProtocolExtensionContainer<E_RAB_Level_QoS_Parameters_ExtIEs>;
14177                 static constexpr bool optional = true;
14178
14179         };
14180         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
14181         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
14182         template<typename V> void decode(V& v)
14183         {
14184                 v(qCI);
14185                 v(allocationAndRetentionPriority);
14186                 v(gbrQosInformation);
14187                 v(iE_Extensions);
14188
14189         };
14190         template<typename V> void encode(V& v) const
14191         {
14192                 v(qCI);
14193                 v(allocationAndRetentionPriority);
14194                 v(gbrQosInformation);
14195                 v(iE_Extensions);
14196
14197         };
14198         void clear()
14199         {
14200                 qCI.clear();
14201                 allocationAndRetentionPriority.clear();
14202                 gbrQosInformation.clear();
14203                 iE_Extensions.clear();
14204
14205         };
14206         private:
14207         qCI_t   qCI;
14208         allocationAndRetentionPriority_t        allocationAndRetentionPriority;
14209         gbrQosInformation_t     gbrQosInformation;
14210         iE_Extensions_t iE_Extensions;
14211
14212 };
14213 /*
14214 E-RAB-List ::= SEQUENCE (SIZE(1.. maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RAB-ItemIEs} }
14215 */
14216
14217 struct E_RAB_List_elm : ProtocolIE_Single_Container<E_RAB_ItemIEs>
14218 {
14219         static constexpr const char* name() {return "E_RAB_List_elm";}
14220         using parent_t = ProtocolIE_Single_Container<E_RAB_ItemIEs>;
14221
14222 };
14223 struct E_RAB_List : asn::sequenceof<E_RAB_List_elm>
14224 {
14225         static constexpr const char* name() {return "E-RAB-List";}
14226         using parent_t = asn::sequenceof<E_RAB_List_elm>;
14227         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
14228
14229 };
14230 /*
14231 E-RABUsageReport-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
14232         ...
14233 }
14234 */
14235
14236 struct E_RABUsageReport_Item_ExtIEs
14237 {
14238         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
14239         {
14240                 size_t get_index() const {return type;}
14241                 bool is_unknown() const { return type == 1; }
14242                 void clear() {type = 0;}
14243                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
14244                 template<typename V>  bool decode(V& v)
14245                 {
14246                         clear();
14247                         if(!v(ref_nested())) return false;
14248                         { type = 1; return true;}
14249                         return false;
14250
14251                 }
14252                 template<typename V> bool encode(V& v) const
14253                 {
14254                         return v(ref_nested());
14255
14256                 }
14257                 protected:
14258                 template<typename V>  bool decode(size_t index, V& v)
14259                 {
14260                         clear();
14261                         switch(index)
14262                         {
14263                         case 1: type = 1; return v(ref_nested());
14264                         ref_nested().clear();
14265                         }
14266                         return false;
14267
14268                 }
14269                 template<typename V> bool encode(size_t index, V& v) const
14270                 {
14271                         if(index != type) {return false;} return v(ref_nested());
14272
14273                 }
14274                 private:
14275                 size_t type {0};
14276
14277         };
14278         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
14279         {
14280                 size_t get_index() const {return type;}
14281                 bool is_unknown() const { return type == 1; }
14282                 void clear() {type = 0;}
14283                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
14284                 template<typename V>  bool decode(V& v)
14285                 {
14286                         clear();
14287                         if(!v(ref_nested())) return false;
14288                         { type = 1; return true;}
14289                         return false;
14290
14291                 }
14292                 template<typename V> bool encode(V& v) const
14293                 {
14294                         return v(ref_nested());
14295
14296                 }
14297                 protected:
14298                 template<typename V>  bool decode(size_t index, V& v)
14299                 {
14300                         clear();
14301                         switch(index)
14302                         {
14303                         case 1: type = 1; return v(ref_nested());
14304                         ref_nested().clear();
14305                         }
14306                         return false;
14307
14308                 }
14309                 template<typename V> bool encode(size_t index, V& v) const
14310                 {
14311                         if(index != type) {return false;} return v(ref_nested());
14312
14313                 }
14314                 private:
14315                 size_t type {0};
14316
14317         };
14318         struct Extension_t : asn::typefield<true>
14319         {
14320                 ~Extension_t()  {clear();}
14321                 size_t get_index() const {return type;}
14322                 bool is_unknown() const { return type == 1; }
14323                 void clear()
14324                 {
14325                         type = 0; ref_nested().clear();
14326                 }
14327                 template<typename V> static inline void enumerate(V& v)
14328                 {
14329
14330                 }
14331                 protected:
14332                 template<typename V> bool decode(size_t index, V& v)
14333                 {
14334                         clear();
14335                         switch(index)
14336                         {
14337                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
14338                         }
14339                         return false;
14340
14341                 }
14342                 template<typename V> bool encode(size_t index, V& v) const
14343                 {
14344                         if(index != type) return false;
14345                         return false;
14346
14347                 }
14348                 private:
14349                 size_t type {0};
14350
14351         };
14352         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
14353         {
14354                 size_t get_index() const {return type;}
14355                 bool is_unknown() const { return type == 1; }
14356                 void clear() {type = 0;}
14357                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
14358                 template<typename V>  bool decode(V& v)
14359                 {
14360                         clear();
14361                         if(!v(ref_nested())) return false;
14362                         { type = 1; return true;}
14363                         return false;
14364
14365                 }
14366                 template<typename V> bool encode(V& v) const
14367                 {
14368                         return v(ref_nested());
14369
14370                 }
14371                 protected:
14372                 template<typename V>  bool decode(size_t index, V& v)
14373                 {
14374                         clear();
14375                         switch(index)
14376                         {
14377                         case 1: type = 1; return v(ref_nested());
14378                         ref_nested().clear();
14379                         }
14380                         return false;
14381
14382                 }
14383                 template<typename V> bool encode(size_t index, V& v) const
14384                 {
14385                         if(index != type) {return false;} return v(ref_nested());
14386
14387                 }
14388                 private:
14389                 size_t type {0};
14390
14391         };
14392
14393 };
14394 /*
14395 E-RABUsageReport-Item ::= SEQUENCE {
14396         startTimeStamp                          OCTET STRING (SIZE(4)),
14397         endTimeStamp                                    OCTET STRING (SIZE(4)),
14398         usageCountUL                                    INTEGER (0..4294967295),
14399         usageCountDL                                    INTEGER (0..4294967295),
14400         iE-Extensions                           ProtocolExtensionContainer { {E-RABUsageReport-Item-ExtIEs} } OPTIONAL,
14401 ...
14402 }
14403 */
14404
14405 struct E_RABUsageReport_Item : asn::sequence<5, 0, true, 1>
14406 {
14407         static constexpr const char* name() {return "E-RABUsageReport-Item";}
14408         using parent_t = asn::sequence<5, 0, true, 1>;
14409         struct startTimeStamp_t : asn::ostring<>
14410         {
14411                 using constraint_t = asn::constraints<false,asn::one<4>>;
14412                 static constexpr const char* name() {return "startTimeStamp_t";}
14413                 using parent_t = asn::ostring<>;
14414
14415         };
14416
14417         startTimeStamp_t& ref_startTimeStamp() {return startTimeStamp;}
14418         startTimeStamp_t const& ref_startTimeStamp() const {return startTimeStamp;}
14419         struct endTimeStamp_t : asn::ostring<>
14420         {
14421                 using constraint_t = asn::constraints<false,asn::one<4>>;
14422                 static constexpr const char* name() {return "endTimeStamp_t";}
14423                 using parent_t = asn::ostring<>;
14424
14425         };
14426
14427         endTimeStamp_t& ref_endTimeStamp() {return endTimeStamp;}
14428         endTimeStamp_t const& ref_endTimeStamp() const {return endTimeStamp;}
14429         struct usageCountUL_t : asn::integer<>
14430         {
14431                 using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
14432                 static constexpr const char* name() {return "usageCountUL_t";}
14433                 using parent_t = asn::integer<>;
14434
14435         };
14436
14437         usageCountUL_t& ref_usageCountUL() {return usageCountUL;}
14438         usageCountUL_t const& ref_usageCountUL() const {return usageCountUL;}
14439         struct usageCountDL_t : asn::integer<>
14440         {
14441                 using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
14442                 static constexpr const char* name() {return "usageCountDL_t";}
14443                 using parent_t = asn::integer<>;
14444
14445         };
14446
14447         usageCountDL_t& ref_usageCountDL() {return usageCountDL;}
14448         usageCountDL_t const& ref_usageCountDL() const {return usageCountDL;}
14449         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABUsageReport_Item_ExtIEs>
14450         {
14451                 static constexpr const char* name() {return "iE_Extensions_t";}
14452                 using parent_t = ProtocolExtensionContainer<E_RABUsageReport_Item_ExtIEs>;
14453                 static constexpr bool optional = true;
14454
14455         };
14456         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
14457         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
14458         template<typename V> void decode(V& v)
14459         {
14460                 v(startTimeStamp);
14461                 v(endTimeStamp);
14462                 v(usageCountUL);
14463                 v(usageCountDL);
14464                 v(iE_Extensions);
14465
14466         };
14467         template<typename V> void encode(V& v) const
14468         {
14469                 v(startTimeStamp);
14470                 v(endTimeStamp);
14471                 v(usageCountUL);
14472                 v(usageCountDL);
14473                 v(iE_Extensions);
14474
14475         };
14476         void clear()
14477         {
14478                 startTimeStamp.clear();
14479                 endTimeStamp.clear();
14480                 usageCountUL.clear();
14481                 usageCountDL.clear();
14482                 iE_Extensions.clear();
14483
14484         };
14485         private:
14486         startTimeStamp_t        startTimeStamp;
14487         endTimeStamp_t  endTimeStamp;
14488         usageCountUL_t  usageCountUL;
14489         usageCountDL_t  usageCountDL;
14490         iE_Extensions_t iE_Extensions;
14491
14492 };
14493 /*
14494 E-RABUsageReport-ItemIEs X2AP-PROTOCOL-IES ::= {
14495         { ID id-E-RABUsageReport-Item    CRITICALITY ignore     TYPE E-RABUsageReport-Item      PRESENCE mandatory },
14496         ...
14497 }
14498 */
14499
14500 struct E_RABUsageReport_ItemIEs
14501 {
14502         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
14503         {
14504                 size_t get_index() const {return type;}
14505                 bool is_unknown() const { return type == 2; }
14506                 void clear() {type = 0;}
14507                 void select_id_E_RABUsageReport_Item() { set(id_E_RABUsageReport_Item); type=1;}
14508                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
14509                 template<typename V>  bool decode(V& v)
14510                 {
14511                         clear();
14512                         if(!v(ref_nested())) return false;
14513                         if(equal(id_E_RABUsageReport_Item)) { type = 1; return true; }
14514                         else { type = 2; return true;}
14515                         return false;
14516
14517                 }
14518                 template<typename V> bool encode(V& v) const
14519                 {
14520                         return v(ref_nested());
14521
14522                 }
14523                 protected:
14524                 template<typename V>  bool decode(size_t index, V& v)
14525                 {
14526                         clear();
14527                         switch(index)
14528                         {
14529                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABUsageReport_Item);} return false;
14530                         case 2: type = 2; return v(ref_nested());
14531                         ref_nested().clear();
14532                         }
14533                         return false;
14534
14535                 }
14536                 template<typename V> bool encode(size_t index, V& v) const
14537                 {
14538                         if(index != type) {return false;} return v(ref_nested());
14539
14540                 }
14541                 private:
14542                 size_t type {0};
14543
14544         };
14545         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
14546         {
14547                 size_t get_index() const {return type;}
14548                 bool is_unknown() const { return type == 2; }
14549                 void clear() {type = 0;}
14550                 void select_id_E_RABUsageReport_Item() { set(ignore); type=1;}
14551                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
14552                 template<typename V>  bool decode(V& v)
14553                 {
14554                         clear();
14555                         if(!v(ref_nested())) return false;
14556                         if(equal(ignore)) { type = 1; return true; }
14557                         else { type = 2; return true;}
14558                         return false;
14559
14560                 }
14561                 template<typename V> bool encode(V& v) const
14562                 {
14563                         return v(ref_nested());
14564
14565                 }
14566                 protected:
14567                 template<typename V>  bool decode(size_t index, V& v)
14568                 {
14569                         clear();
14570                         switch(index)
14571                         {
14572                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
14573                         case 2: type = 2; return v(ref_nested());
14574                         ref_nested().clear();
14575                         }
14576                         return false;
14577
14578                 }
14579                 template<typename V> bool encode(size_t index, V& v) const
14580                 {
14581                         if(index != type) {return false;} return v(ref_nested());
14582
14583                 }
14584                 private:
14585                 size_t type {0};
14586
14587         };
14588         struct Value_t : asn::typefield<true>
14589         {
14590                 ~Value_t()      {clear();}
14591                 size_t get_index() const {return type;}
14592                 E_RABUsageReport_Item& select_id_E_RABUsageReport_Item() { return set<E_RABUsageReport_Item>(1); }
14593                 E_RABUsageReport_Item const* get_id_E_RABUsageReport_Item() const { return get<E_RABUsageReport_Item>(1); }
14594                 bool is_unknown() const { return type == 2; }
14595                 void clear()
14596                 {
14597                         switch(type)
14598                         {
14599                         case 1: var.destroy<E_RABUsageReport_Item>(); break;
14600                         }
14601                         type = 0; ref_nested().clear();
14602                 }
14603                 template<typename V> static inline void enumerate(V& v)
14604                 {
14605                         v.template operator()<E_RABUsageReport_Item>(1);
14606
14607                 }
14608                 protected:
14609                 template<typename V> bool decode(size_t index, V& v)
14610                 {
14611                         clear();
14612                         switch(index)
14613                         {
14614                         case 1: v(select_id_E_RABUsageReport_Item()); return true;
14615                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
14616                         }
14617                         return false;
14618
14619                 }
14620                 template<typename V> bool encode(size_t index, V& v) const
14621                 {
14622                         if(index != type) return false;
14623                         switch(type)
14624                         {
14625                         case 1: v(var.as<E_RABUsageReport_Item>()); return true;
14626                         }
14627                         return false;
14628
14629                 }
14630                 private:
14631                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
14632                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
14633                 union union_type
14634                 {
14635                         char dummy1[sizeof(E_RABUsageReport_Item)];
14636
14637                 };
14638                 asn::variant<sizeof(union_type)> var;
14639                 size_t type {0};
14640
14641         };
14642         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
14643         {
14644                 size_t get_index() const {return type;}
14645                 bool is_unknown() const { return type == 2; }
14646                 void clear() {type = 0;}
14647                 void select_id_E_RABUsageReport_Item() { set(mandatory); type=1;}
14648                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
14649                 template<typename V>  bool decode(V& v)
14650                 {
14651                         clear();
14652                         if(!v(ref_nested())) return false;
14653                         if(equal(mandatory)) { type = 1; return true; }
14654                         else { type = 2; return true;}
14655                         return false;
14656
14657                 }
14658                 template<typename V> bool encode(V& v) const
14659                 {
14660                         return v(ref_nested());
14661
14662                 }
14663                 protected:
14664                 template<typename V>  bool decode(size_t index, V& v)
14665                 {
14666                         clear();
14667                         switch(index)
14668                         {
14669                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
14670                         case 2: type = 2; return v(ref_nested());
14671                         ref_nested().clear();
14672                         }
14673                         return false;
14674
14675                 }
14676                 template<typename V> bool encode(size_t index, V& v) const
14677                 {
14678                         if(index != type) {return false;} return v(ref_nested());
14679
14680                 }
14681                 private:
14682                 size_t type {0};
14683
14684         };
14685
14686 };
14687 /*
14688 E-RABUsageReportList ::= SEQUENCE (SIZE(1..maxnooftimeperiods)) OF ProtocolIE-Single-Container { {E-RABUsageReport-ItemIEs} }
14689 */
14690
14691 struct E_RABUsageReportList_elm : ProtocolIE_Single_Container<E_RABUsageReport_ItemIEs>
14692 {
14693         static constexpr const char* name() {return "E_RABUsageReportList_elm";}
14694         using parent_t = ProtocolIE_Single_Container<E_RABUsageReport_ItemIEs>;
14695
14696 };
14697 struct E_RABUsageReportList : asn::sequenceof<E_RABUsageReportList_elm>
14698 {
14699         static constexpr const char* name() {return "E-RABUsageReportList";}
14700         using parent_t = asn::sequenceof<E_RABUsageReportList_elm>;
14701         using constraint_t = asn::constraints<false,asn::span<1,  maxnooftimeperiods >>;
14702
14703 };
14704 /*
14705 EARFCN ::= INTEGER (0..maxEARFCN)
14706 */
14707
14708 struct EARFCN : asn::integer<>
14709 {
14710         using constraint_t = asn::constraints<false,asn::span<0,  maxEARFCN >>;
14711         static constexpr const char* name() {return "EARFCN";}
14712         using parent_t = asn::integer<>;
14713
14714 };
14715
14716 /*
14717 EARFCNExtension ::= INTEGER(maxEARFCNPlusOne..newmaxEARFCN, ...)
14718 */
14719
14720 struct EARFCNExtension : asn::integer<>
14721 {
14722         using constraint_t = asn::constraints<true,asn::span< maxEARFCNPlusOne ,  newmaxEARFCN >>;
14723         static constexpr const char* name() {return "EARFCNExtension";}
14724         using parent_t = asn::integer<>;
14725
14726 };
14727
14728 /*
14729 EN-DC-ResourceConfigurationExtIEs X2AP-PROTOCOL-EXTENSION ::= {
14730         ...
14731 }
14732 */
14733
14734 struct EN_DC_ResourceConfigurationExtIEs
14735 {
14736         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
14737         {
14738                 size_t get_index() const {return type;}
14739                 bool is_unknown() const { return type == 1; }
14740                 void clear() {type = 0;}
14741                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
14742                 template<typename V>  bool decode(V& v)
14743                 {
14744                         clear();
14745                         if(!v(ref_nested())) return false;
14746                         { type = 1; return true;}
14747                         return false;
14748
14749                 }
14750                 template<typename V> bool encode(V& v) const
14751                 {
14752                         return v(ref_nested());
14753
14754                 }
14755                 protected:
14756                 template<typename V>  bool decode(size_t index, V& v)
14757                 {
14758                         clear();
14759                         switch(index)
14760                         {
14761                         case 1: type = 1; return v(ref_nested());
14762                         ref_nested().clear();
14763                         }
14764                         return false;
14765
14766                 }
14767                 template<typename V> bool encode(size_t index, V& v) const
14768                 {
14769                         if(index != type) {return false;} return v(ref_nested());
14770
14771                 }
14772                 private:
14773                 size_t type {0};
14774
14775         };
14776         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
14777         {
14778                 size_t get_index() const {return type;}
14779                 bool is_unknown() const { return type == 1; }
14780                 void clear() {type = 0;}
14781                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
14782                 template<typename V>  bool decode(V& v)
14783                 {
14784                         clear();
14785                         if(!v(ref_nested())) return false;
14786                         { type = 1; return true;}
14787                         return false;
14788
14789                 }
14790                 template<typename V> bool encode(V& v) const
14791                 {
14792                         return v(ref_nested());
14793
14794                 }
14795                 protected:
14796                 template<typename V>  bool decode(size_t index, V& v)
14797                 {
14798                         clear();
14799                         switch(index)
14800                         {
14801                         case 1: type = 1; return v(ref_nested());
14802                         ref_nested().clear();
14803                         }
14804                         return false;
14805
14806                 }
14807                 template<typename V> bool encode(size_t index, V& v) const
14808                 {
14809                         if(index != type) {return false;} return v(ref_nested());
14810
14811                 }
14812                 private:
14813                 size_t type {0};
14814
14815         };
14816         struct Extension_t : asn::typefield<true>
14817         {
14818                 ~Extension_t()  {clear();}
14819                 size_t get_index() const {return type;}
14820                 bool is_unknown() const { return type == 1; }
14821                 void clear()
14822                 {
14823                         type = 0; ref_nested().clear();
14824                 }
14825                 template<typename V> static inline void enumerate(V& v)
14826                 {
14827
14828                 }
14829                 protected:
14830                 template<typename V> bool decode(size_t index, V& v)
14831                 {
14832                         clear();
14833                         switch(index)
14834                         {
14835                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
14836                         }
14837                         return false;
14838
14839                 }
14840                 template<typename V> bool encode(size_t index, V& v) const
14841                 {
14842                         if(index != type) return false;
14843                         return false;
14844
14845                 }
14846                 private:
14847                 size_t type {0};
14848
14849         };
14850         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
14851         {
14852                 size_t get_index() const {return type;}
14853                 bool is_unknown() const { return type == 1; }
14854                 void clear() {type = 0;}
14855                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
14856                 template<typename V>  bool decode(V& v)
14857                 {
14858                         clear();
14859                         if(!v(ref_nested())) return false;
14860                         { type = 1; return true;}
14861                         return false;
14862
14863                 }
14864                 template<typename V> bool encode(V& v) const
14865                 {
14866                         return v(ref_nested());
14867
14868                 }
14869                 protected:
14870                 template<typename V>  bool decode(size_t index, V& v)
14871                 {
14872                         clear();
14873                         switch(index)
14874                         {
14875                         case 1: type = 1; return v(ref_nested());
14876                         ref_nested().clear();
14877                         }
14878                         return false;
14879
14880                 }
14881                 template<typename V> bool encode(size_t index, V& v) const
14882                 {
14883                         if(index != type) {return false;} return v(ref_nested());
14884
14885                 }
14886                 private:
14887                 size_t type {0};
14888
14889         };
14890
14891 };
14892 /*
14893 EN-DC-ResourceConfiguration ::= SEQUENCE {
14894         pDCPatSgNB              ENUMERATED {present, not-present, ...},
14895         mCGresources    ENUMERATED {present, not-present, ...},
14896         sCGresources    ENUMERATED {present, not-present, ...},
14897         iE-Extensions                                   ProtocolExtensionContainer { {EN-DC-ResourceConfigurationExtIEs} }      OPTIONAL,
14898         ...
14899 }
14900 */
14901
14902 struct EN_DC_ResourceConfiguration : asn::sequence<4, 0, true, 1>
14903 {
14904         static constexpr const char* name() {return "EN-DC-ResourceConfiguration";}
14905         using parent_t = asn::sequence<4, 0, true, 1>;
14906         struct pDCPatSgNB_t : asn::enumerated<2, 0, true>
14907         {
14908                 static constexpr const char* name() {return "pDCPatSgNB_t";}
14909                 using parent_t = asn::enumerated<2, 0, true>;
14910                 typedef enum {
14911                         present
14912                         ,not_present
14913                 } index_t;
14914
14915         };
14916
14917         pDCPatSgNB_t& ref_pDCPatSgNB() {return pDCPatSgNB;}
14918         pDCPatSgNB_t const& ref_pDCPatSgNB() const {return pDCPatSgNB;}
14919         struct mCGresources_t : asn::enumerated<2, 0, true>
14920         {
14921                 static constexpr const char* name() {return "mCGresources_t";}
14922                 using parent_t = asn::enumerated<2, 0, true>;
14923                 typedef enum {
14924                         present
14925                         ,not_present
14926                 } index_t;
14927
14928         };
14929
14930         mCGresources_t& ref_mCGresources() {return mCGresources;}
14931         mCGresources_t const& ref_mCGresources() const {return mCGresources;}
14932         struct sCGresources_t : asn::enumerated<2, 0, true>
14933         {
14934                 static constexpr const char* name() {return "sCGresources_t";}
14935                 using parent_t = asn::enumerated<2, 0, true>;
14936                 typedef enum {
14937                         present
14938                         ,not_present
14939                 } index_t;
14940
14941         };
14942
14943         sCGresources_t& ref_sCGresources() {return sCGresources;}
14944         sCGresources_t const& ref_sCGresources() const {return sCGresources;}
14945         struct iE_Extensions_t : ProtocolExtensionContainer<EN_DC_ResourceConfigurationExtIEs>
14946         {
14947                 static constexpr const char* name() {return "iE_Extensions_t";}
14948                 using parent_t = ProtocolExtensionContainer<EN_DC_ResourceConfigurationExtIEs>;
14949                 static constexpr bool optional = true;
14950
14951         };
14952         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
14953         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
14954         template<typename V> void decode(V& v)
14955         {
14956                 v(pDCPatSgNB);
14957                 v(mCGresources);
14958                 v(sCGresources);
14959                 v(iE_Extensions);
14960
14961         };
14962         template<typename V> void encode(V& v) const
14963         {
14964                 v(pDCPatSgNB);
14965                 v(mCGresources);
14966                 v(sCGresources);
14967                 v(iE_Extensions);
14968
14969         };
14970         void clear()
14971         {
14972                 pDCPatSgNB.clear();
14973                 mCGresources.clear();
14974                 sCGresources.clear();
14975                 iE_Extensions.clear();
14976
14977         };
14978         private:
14979         pDCPatSgNB_t    pDCPatSgNB;
14980         mCGresources_t  mCGresources;
14981         sCGresources_t  sCGresources;
14982         iE_Extensions_t iE_Extensions;
14983
14984 };
14985 /*
14986 ENB-ID ::= CHOICE {
14987         macro-eNB-ID    BIT STRING (SIZE (20)),
14988         home-eNB-ID             BIT STRING (SIZE (28)),
14989         ... ,
14990         short-Macro-eNB-ID              BIT STRING (SIZE(18)),
14991         long-Macro-eNB-ID               BIT STRING (SIZE(21))
14992 }
14993 */
14994
14995 struct ENB_ID : asn::choice<4, 2, true>
14996 {
14997         static constexpr const char* name() {return "ENB-ID";}
14998         using parent_t = asn::choice<4, 2, true>;
14999         index_type get_index() const {return index;}
15000         bool is_unknown() const {return index == 5;}
15001         void set_unknown() { set_index(5);  }
15002         ~ENB_ID() {clear();}
15003         struct macro_eNB_ID_t : asn::bstring<>
15004         {
15005                 using constraint_t = asn::constraints<false,asn::one<20>>;
15006                 static constexpr const char* name() {return "macro_eNB_ID_t";}
15007                 using parent_t = asn::bstring<>;
15008
15009         };
15010
15011         struct home_eNB_ID_t : asn::bstring<>
15012         {
15013                 using constraint_t = asn::constraints<false,asn::one<28>>;
15014                 static constexpr const char* name() {return "home_eNB_ID_t";}
15015                 using parent_t = asn::bstring<>;
15016
15017         };
15018
15019         struct short_Macro_eNB_ID_t : asn::bstring<>
15020         {
15021                 using constraint_t = asn::constraints<false,asn::one<18>>;
15022                 static constexpr const char* name() {return "short_Macro_eNB_ID_t";}
15023                 using parent_t = asn::bstring<>;
15024
15025         };
15026
15027         struct long_Macro_eNB_ID_t : asn::bstring<>
15028         {
15029                 using constraint_t = asn::constraints<false,asn::one<21>>;
15030                 static constexpr const char* name() {return "long_Macro_eNB_ID_t";}
15031                 using parent_t = asn::bstring<>;
15032
15033         };
15034
15035         void clear()
15036         {
15037                 switch(get_index())
15038                 {
15039                 case 1: var.destroy<macro_eNB_ID_t>(); break;
15040                 case 2: var.destroy<home_eNB_ID_t>(); break;
15041                 case 3: var.destroy<short_Macro_eNB_ID_t>(); break;
15042                 case 4: var.destroy<long_Macro_eNB_ID_t>(); break;
15043                 }
15044                 index = 0;
15045                 base::clear();
15046         }
15047         template<typename V> bool decode(size_t idx, V& v)
15048         {
15049                 clear();
15050                 switch(idx)
15051                 {
15052                 case 1: set_index(1); return v(var.build<macro_eNB_ID_t>());
15053                 case 2: set_index(2); return v(var.build<home_eNB_ID_t>());
15054                 case 3: set_index(3); return v(var.build<short_Macro_eNB_ID_t>());
15055                 case 4: set_index(4); return v(var.build<long_Macro_eNB_ID_t>());
15056                 }
15057                 return false;
15058
15059         }
15060         template<typename V> bool encode(V& v) const
15061         {
15062                 switch(get_index())
15063                 {
15064                 case 1: return v(var.as<macro_eNB_ID_t>());
15065                 case 2: return v(var.as<home_eNB_ID_t>());
15066                 case 3: return v(var.as<short_Macro_eNB_ID_t>());
15067                 case 4: return v(var.as<long_Macro_eNB_ID_t>());
15068                 }
15069                 return false;
15070         }
15071         template<typename V> static inline void enumerate(V& v)
15072         {
15073                 v.template operator()<macro_eNB_ID_t>(1);
15074                 v.template operator()<home_eNB_ID_t>(2);
15075                 v.template operator()<short_Macro_eNB_ID_t>(3);
15076                 v.template operator()<long_Macro_eNB_ID_t>(4);
15077
15078         }
15079         macro_eNB_ID_t& select_macro_eNB_ID() { if(get_index() != 1) { clear(); set_index(1); return var.build<macro_eNB_ID_t>();} return var.as<macro_eNB_ID_t>();}
15080         macro_eNB_ID_t const* get_macro_eNB_ID() const { if(get_index() == 1) { return &var.as<macro_eNB_ID_t>();} return nullptr; }
15081         home_eNB_ID_t& select_home_eNB_ID() { if(get_index() != 2) { clear(); set_index(2); return var.build<home_eNB_ID_t>();} return var.as<home_eNB_ID_t>();}
15082         home_eNB_ID_t const* get_home_eNB_ID() const { if(get_index() == 2) { return &var.as<home_eNB_ID_t>();} return nullptr; }
15083         short_Macro_eNB_ID_t& select_short_Macro_eNB_ID() { if(get_index() != 3) { clear(); set_index(3); return var.build<short_Macro_eNB_ID_t>();} return var.as<short_Macro_eNB_ID_t>();}
15084         short_Macro_eNB_ID_t const* get_short_Macro_eNB_ID() const { if(get_index() == 3) { return &var.as<short_Macro_eNB_ID_t>();} return nullptr; }
15085         long_Macro_eNB_ID_t& select_long_Macro_eNB_ID() { if(get_index() != 4) { clear(); set_index(4); return var.build<long_Macro_eNB_ID_t>();} return var.as<long_Macro_eNB_ID_t>();}
15086         long_Macro_eNB_ID_t const* get_long_Macro_eNB_ID() const { if(get_index() == 4) { return &var.as<long_Macro_eNB_ID_t>();} return nullptr; }
15087         private:
15088         void set_index(index_type i) {index = i; base::set();}
15089         union union_type
15090         {
15091                 char dummy1[sizeof(macro_eNB_ID_t)];
15092                 char dummy2[sizeof(home_eNB_ID_t)];
15093                 char dummy3[sizeof(short_Macro_eNB_ID_t)];
15094                 char dummy4[sizeof(long_Macro_eNB_ID_t)];
15095
15096         };
15097         asn::variant<sizeof(union_type)>        var;
15098         index_type      index {0};
15099 };
15100 /*
15101 EPLMNs ::= SEQUENCE (SIZE(1..maxnoofEPLMNs)) OF PLMN-Identity
15102 */
15103
15104 struct EPLMNs_elm : PLMN_Identity
15105 {
15106         static constexpr const char* name() {return "EPLMNs_elm";}
15107         using parent_t = PLMN_Identity;
15108
15109 };
15110 struct EPLMNs : asn::sequenceof<EPLMNs_elm>
15111 {
15112         static constexpr const char* name() {return "EPLMNs";}
15113         using parent_t = asn::sequenceof<EPLMNs_elm>;
15114         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofEPLMNs >>;
15115
15116 };
15117 /*
15118 UserPlaneTrafficActivityReport ::= ENUMERATED {inactive, re-activated, ...}
15119 */
15120
15121 struct UserPlaneTrafficActivityReport : asn::enumerated<2, 0, true>
15122 {
15123         static constexpr const char* name() {return "UserPlaneTrafficActivityReport";}
15124         using parent_t = asn::enumerated<2, 0, true>;
15125         typedef enum {
15126                 inactive
15127                 ,re_activated
15128         } index_t;
15129
15130 };
15131
15132 /*
15133 ERABActivityNotifyItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
15134         ...
15135 }
15136 */
15137
15138 struct ERABActivityNotifyItem_ExtIEs
15139 {
15140         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
15141         {
15142                 size_t get_index() const {return type;}
15143                 bool is_unknown() const { return type == 1; }
15144                 void clear() {type = 0;}
15145                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
15146                 template<typename V>  bool decode(V& v)
15147                 {
15148                         clear();
15149                         if(!v(ref_nested())) return false;
15150                         { type = 1; return true;}
15151                         return false;
15152
15153                 }
15154                 template<typename V> bool encode(V& v) const
15155                 {
15156                         return v(ref_nested());
15157
15158                 }
15159                 protected:
15160                 template<typename V>  bool decode(size_t index, V& v)
15161                 {
15162                         clear();
15163                         switch(index)
15164                         {
15165                         case 1: type = 1; return v(ref_nested());
15166                         ref_nested().clear();
15167                         }
15168                         return false;
15169
15170                 }
15171                 template<typename V> bool encode(size_t index, V& v) const
15172                 {
15173                         if(index != type) {return false;} return v(ref_nested());
15174
15175                 }
15176                 private:
15177                 size_t type {0};
15178
15179         };
15180         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
15181         {
15182                 size_t get_index() const {return type;}
15183                 bool is_unknown() const { return type == 1; }
15184                 void clear() {type = 0;}
15185                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
15186                 template<typename V>  bool decode(V& v)
15187                 {
15188                         clear();
15189                         if(!v(ref_nested())) return false;
15190                         { type = 1; return true;}
15191                         return false;
15192
15193                 }
15194                 template<typename V> bool encode(V& v) const
15195                 {
15196                         return v(ref_nested());
15197
15198                 }
15199                 protected:
15200                 template<typename V>  bool decode(size_t index, V& v)
15201                 {
15202                         clear();
15203                         switch(index)
15204                         {
15205                         case 1: type = 1; return v(ref_nested());
15206                         ref_nested().clear();
15207                         }
15208                         return false;
15209
15210                 }
15211                 template<typename V> bool encode(size_t index, V& v) const
15212                 {
15213                         if(index != type) {return false;} return v(ref_nested());
15214
15215                 }
15216                 private:
15217                 size_t type {0};
15218
15219         };
15220         struct Extension_t : asn::typefield<true>
15221         {
15222                 ~Extension_t()  {clear();}
15223                 size_t get_index() const {return type;}
15224                 bool is_unknown() const { return type == 1; }
15225                 void clear()
15226                 {
15227                         type = 0; ref_nested().clear();
15228                 }
15229                 template<typename V> static inline void enumerate(V& v)
15230                 {
15231
15232                 }
15233                 protected:
15234                 template<typename V> bool decode(size_t index, V& v)
15235                 {
15236                         clear();
15237                         switch(index)
15238                         {
15239                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
15240                         }
15241                         return false;
15242
15243                 }
15244                 template<typename V> bool encode(size_t index, V& v) const
15245                 {
15246                         if(index != type) return false;
15247                         return false;
15248
15249                 }
15250                 private:
15251                 size_t type {0};
15252
15253         };
15254         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
15255         {
15256                 size_t get_index() const {return type;}
15257                 bool is_unknown() const { return type == 1; }
15258                 void clear() {type = 0;}
15259                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
15260                 template<typename V>  bool decode(V& v)
15261                 {
15262                         clear();
15263                         if(!v(ref_nested())) return false;
15264                         { type = 1; return true;}
15265                         return false;
15266
15267                 }
15268                 template<typename V> bool encode(V& v) const
15269                 {
15270                         return v(ref_nested());
15271
15272                 }
15273                 protected:
15274                 template<typename V>  bool decode(size_t index, V& v)
15275                 {
15276                         clear();
15277                         switch(index)
15278                         {
15279                         case 1: type = 1; return v(ref_nested());
15280                         ref_nested().clear();
15281                         }
15282                         return false;
15283
15284                 }
15285                 template<typename V> bool encode(size_t index, V& v) const
15286                 {
15287                         if(index != type) {return false;} return v(ref_nested());
15288
15289                 }
15290                 private:
15291                 size_t type {0};
15292
15293         };
15294
15295 };
15296 /*
15297 ERABActivityNotifyItem ::= SEQUENCE {
15298         e-RAB-ID                                                E-RAB-ID,
15299         activityReport                                  UserPlaneTrafficActivityReport,
15300         iE-Extensions                                   ProtocolExtensionContainer { {ERABActivityNotifyItem-ExtIEs} }  OPTIONAL,
15301         ...
15302 }
15303 */
15304
15305 struct ERABActivityNotifyItem : asn::sequence<3, 0, true, 1>
15306 {
15307         static constexpr const char* name() {return "ERABActivityNotifyItem";}
15308         using parent_t = asn::sequence<3, 0, true, 1>;
15309         struct e_RAB_ID_t : E_RAB_ID
15310         {
15311                 static constexpr const char* name() {return "e_RAB_ID_t";}
15312                 using parent_t = E_RAB_ID;
15313
15314         };
15315         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
15316         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
15317         struct activityReport_t : UserPlaneTrafficActivityReport
15318         {
15319                 static constexpr const char* name() {return "activityReport_t";}
15320                 using parent_t = UserPlaneTrafficActivityReport;
15321
15322         };
15323         activityReport_t& ref_activityReport() {return activityReport;}
15324         activityReport_t const& ref_activityReport() const {return activityReport;}
15325         struct iE_Extensions_t : ProtocolExtensionContainer<ERABActivityNotifyItem_ExtIEs>
15326         {
15327                 static constexpr const char* name() {return "iE_Extensions_t";}
15328                 using parent_t = ProtocolExtensionContainer<ERABActivityNotifyItem_ExtIEs>;
15329                 static constexpr bool optional = true;
15330
15331         };
15332         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
15333         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
15334         template<typename V> void decode(V& v)
15335         {
15336                 v(e_RAB_ID);
15337                 v(activityReport);
15338                 v(iE_Extensions);
15339
15340         };
15341         template<typename V> void encode(V& v) const
15342         {
15343                 v(e_RAB_ID);
15344                 v(activityReport);
15345                 v(iE_Extensions);
15346
15347         };
15348         void clear()
15349         {
15350                 e_RAB_ID.clear();
15351                 activityReport.clear();
15352                 iE_Extensions.clear();
15353
15354         };
15355         private:
15356         e_RAB_ID_t      e_RAB_ID;
15357         activityReport_t        activityReport;
15358         iE_Extensions_t iE_Extensions;
15359
15360 };
15361 /*
15362 ERABActivityNotifyItemList ::= SEQUENCE (SIZE (0..maxnoofBearers)) OF ERABActivityNotifyItem
15363 */
15364
15365 struct ERABActivityNotifyItemList_elm : ERABActivityNotifyItem
15366 {
15367         static constexpr const char* name() {return "ERABActivityNotifyItemList_elm";}
15368         using parent_t = ERABActivityNotifyItem;
15369
15370 };
15371 struct ERABActivityNotifyItemList : asn::sequenceof<ERABActivityNotifyItemList_elm>
15372 {
15373         static constexpr const char* name() {return "ERABActivityNotifyItemList";}
15374         using parent_t = asn::sequenceof<ERABActivityNotifyItemList_elm>;
15375         using constraint_t = asn::constraints<false,asn::span<0,  maxnoofBearers >>;
15376
15377 };
15378 /*
15379 Transmission-Bandwidth ::= ENUMERATED {
15380                 bw6,
15381                 bw15,
15382                 bw25,
15383                 bw50,
15384                 bw75,
15385                 bw100,
15386                 ...,
15387                 bw1
15388 }
15389 */
15390
15391 struct Transmission_Bandwidth : asn::enumerated<7, 1, true>
15392 {
15393         static constexpr const char* name() {return "Transmission-Bandwidth";}
15394         using parent_t = asn::enumerated<7, 1, true>;
15395         typedef enum {
15396                 bw6
15397                 ,bw15
15398                 ,bw25
15399                 ,bw50
15400                 ,bw75
15401                 ,bw100
15402                 ,bw1
15403         } index_t;
15404
15405 };
15406
15407 /*
15408 OffsetOfNbiotChannelNumberToEARFCN ::= ENUMERATED {
15409                 minusTen,
15410                 minusNine,
15411                 minusEight,
15412                 minusSeven,
15413                 minusSix,
15414                 minusFive,
15415                 minusFour,
15416                 minusThree,
15417                 minusTwo,
15418                 minusOne,
15419                 minusZeroDotFive,
15420                 zero,
15421                 one,
15422                 two,
15423                 three,
15424                 four,
15425                 five,
15426                 six,
15427                 seven,
15428                 eight,
15429                 nine,
15430                 ...
15431 }
15432 */
15433
15434 struct OffsetOfNbiotChannelNumberToEARFCN : asn::enumerated<21, 0, true>
15435 {
15436         static constexpr const char* name() {return "OffsetOfNbiotChannelNumberToEARFCN";}
15437         using parent_t = asn::enumerated<21, 0, true>;
15438         typedef enum {
15439                 minusTen
15440                 ,minusNine
15441                 ,minusEight
15442                 ,minusSeven
15443                 ,minusSix
15444                 ,minusFive
15445                 ,minusFour
15446                 ,minusThree
15447                 ,minusTwo
15448                 ,minusOne
15449                 ,minusZeroDotFive
15450                 ,zero
15451                 ,one
15452                 ,two
15453                 ,three
15454                 ,four
15455                 ,five
15456                 ,six
15457                 ,seven
15458                 ,eight
15459                 ,nine
15460         } index_t;
15461
15462 };
15463
15464 /*
15465 NRS-NSSS-PowerOffset ::= ENUMERATED { minusThree, zero, three, ...}
15466 */
15467
15468 struct NRS_NSSS_PowerOffset : asn::enumerated<3, 0, true>
15469 {
15470         static constexpr const char* name() {return "NRS-NSSS-PowerOffset";}
15471         using parent_t = asn::enumerated<3, 0, true>;
15472         typedef enum {
15473                 minusThree
15474                 ,zero
15475                 ,three
15476         } index_t;
15477
15478 };
15479
15480 /*
15481 NSSS-NumOccasionDifferentPrecoder ::= ENUMERATED { two, four, eight, ...}
15482 */
15483
15484 struct NSSS_NumOccasionDifferentPrecoder : asn::enumerated<3, 0, true>
15485 {
15486         static constexpr const char* name() {return "NSSS-NumOccasionDifferentPrecoder";}
15487         using parent_t = asn::enumerated<3, 0, true>;
15488         typedef enum {
15489                 two
15490                 ,four
15491                 ,eight
15492         } index_t;
15493
15494 };
15495
15496 /*
15497 FDD-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
15498         { ID id-UL-EARFCNExtension                                              CRITICALITY reject      EXTENSION EARFCNExtension                                                                       PRESENCE optional}|
15499         { ID id-DL-EARFCNExtension                                              CRITICALITY reject      EXTENSION EARFCNExtension                                                                       PRESENCE optional}|
15500         { ID id-OffsetOfNbiotChannelNumberToDL-EARFCN   CRITICALITY reject      EXTENSION OffsetOfNbiotChannelNumberToEARFCN            PRESENCE optional}|
15501         { ID id-OffsetOfNbiotChannelNumberToUL-EARFCN   CRITICALITY reject      EXTENSION OffsetOfNbiotChannelNumberToEARFCN            PRESENCE optional}|
15502         { ID id-NRS-NSSS-PowerOffset                                    CRITICALITY ignore      EXTENSION NRS-NSSS-PowerOffset                                                  PRESENCE optional}|
15503         { ID id-NSSS-NumOccasionDifferentPrecoder               CRITICALITY ignore      EXTENSION NSSS-NumOccasionDifferentPrecoder                     PRESENCE optional},
15504         ...
15505 }
15506 */
15507
15508 struct FDD_Info_ExtIEs
15509 {
15510         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
15511         {
15512                 size_t get_index() const {return type;}
15513                 bool is_unknown() const { return type == 7; }
15514                 void clear() {type = 0;}
15515                 void select_id_UL_EARFCNExtension() { set(id_UL_EARFCNExtension); type=1;}
15516                 void select_id_DL_EARFCNExtension() { set(id_DL_EARFCNExtension); type=2;}
15517                 void select_id_OffsetOfNbiotChannelNumberToDL_EARFCN() { set(id_OffsetOfNbiotChannelNumberToDL_EARFCN); type=3;}
15518                 void select_id_OffsetOfNbiotChannelNumberToUL_EARFCN() { set(id_OffsetOfNbiotChannelNumberToUL_EARFCN); type=4;}
15519                 void select_id_NRS_NSSS_PowerOffset() { set(id_NRS_NSSS_PowerOffset); type=5;}
15520                 void select_id_NSSS_NumOccasionDifferentPrecoder() { set(id_NSSS_NumOccasionDifferentPrecoder); type=6;}
15521                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
15522                 template<typename V>  bool decode(V& v)
15523                 {
15524                         clear();
15525                         if(!v(ref_nested())) return false;
15526                         if(equal(id_UL_EARFCNExtension)) { type = 1; return true; }
15527                         else if(equal(id_DL_EARFCNExtension)) { type = 2; return true; }
15528                         else if(equal(id_OffsetOfNbiotChannelNumberToDL_EARFCN)) { type = 3; return true; }
15529                         else if(equal(id_OffsetOfNbiotChannelNumberToUL_EARFCN)) { type = 4; return true; }
15530                         else if(equal(id_NRS_NSSS_PowerOffset)) { type = 5; return true; }
15531                         else if(equal(id_NSSS_NumOccasionDifferentPrecoder)) { type = 6; return true; }
15532                         else { type = 7; return true;}
15533                         return false;
15534
15535                 }
15536                 template<typename V> bool encode(V& v) const
15537                 {
15538                         return v(ref_nested());
15539
15540                 }
15541                 protected:
15542                 template<typename V>  bool decode(size_t index, V& v)
15543                 {
15544                         clear();
15545                         switch(index)
15546                         {
15547                         case 1: type = 1; if(v(ref_nested())) { return equal(id_UL_EARFCNExtension);} return false;
15548                         case 2: type = 2; if(v(ref_nested())) { return equal(id_DL_EARFCNExtension);} return false;
15549                         case 3: type = 3; if(v(ref_nested())) { return equal(id_OffsetOfNbiotChannelNumberToDL_EARFCN);} return false;
15550                         case 4: type = 4; if(v(ref_nested())) { return equal(id_OffsetOfNbiotChannelNumberToUL_EARFCN);} return false;
15551                         case 5: type = 5; if(v(ref_nested())) { return equal(id_NRS_NSSS_PowerOffset);} return false;
15552                         case 6: type = 6; if(v(ref_nested())) { return equal(id_NSSS_NumOccasionDifferentPrecoder);} return false;
15553                         case 7: type = 7; return v(ref_nested());
15554                         ref_nested().clear();
15555                         }
15556                         return false;
15557
15558                 }
15559                 template<typename V> bool encode(size_t index, V& v) const
15560                 {
15561                         if(index != type) {return false;} return v(ref_nested());
15562
15563                 }
15564                 private:
15565                 size_t type {0};
15566
15567         };
15568         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
15569         {
15570                 size_t get_index() const {return type;}
15571                 bool is_unknown() const { return type == 7; }
15572                 void clear() {type = 0;}
15573                 void select_id_UL_EARFCNExtension() { set(reject); type=1;}
15574                 void select_id_DL_EARFCNExtension() { set(reject); type=2;}
15575                 void select_id_OffsetOfNbiotChannelNumberToDL_EARFCN() { set(reject); type=3;}
15576                 void select_id_OffsetOfNbiotChannelNumberToUL_EARFCN() { set(reject); type=4;}
15577                 void select_id_NRS_NSSS_PowerOffset() { set(ignore); type=5;}
15578                 void select_id_NSSS_NumOccasionDifferentPrecoder() { set(ignore); type=6;}
15579                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
15580                 template<typename V>  bool decode(V& v)
15581                 {
15582                         clear();
15583                         if(!v(ref_nested())) return false;
15584                         if(equal(reject)) { type = 1; return true; }
15585                         else if(equal(reject)) { type = 2; return true; }
15586                         else if(equal(reject)) { type = 3; return true; }
15587                         else if(equal(reject)) { type = 4; return true; }
15588                         else if(equal(ignore)) { type = 5; return true; }
15589                         else if(equal(ignore)) { type = 6; return true; }
15590                         else { type = 7; return true;}
15591                         return false;
15592
15593                 }
15594                 template<typename V> bool encode(V& v) const
15595                 {
15596                         return v(ref_nested());
15597
15598                 }
15599                 protected:
15600                 template<typename V>  bool decode(size_t index, V& v)
15601                 {
15602                         clear();
15603                         switch(index)
15604                         {
15605                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
15606                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
15607                         case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
15608                         case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
15609                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
15610                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
15611                         case 7: type = 7; return v(ref_nested());
15612                         ref_nested().clear();
15613                         }
15614                         return false;
15615
15616                 }
15617                 template<typename V> bool encode(size_t index, V& v) const
15618                 {
15619                         if(index != type) {return false;} return v(ref_nested());
15620
15621                 }
15622                 private:
15623                 size_t type {0};
15624
15625         };
15626         struct Extension_t : asn::typefield<true>
15627         {
15628                 ~Extension_t()  {clear();}
15629                 size_t get_index() const {return type;}
15630                 EARFCNExtension& select_id_UL_EARFCNExtension() { return set<EARFCNExtension>(1); }
15631                 EARFCNExtension const* get_id_UL_EARFCNExtension() const { return get<EARFCNExtension>(1); }
15632                 EARFCNExtension& select_id_DL_EARFCNExtension() { return set<EARFCNExtension>(2); }
15633                 EARFCNExtension const* get_id_DL_EARFCNExtension() const { return get<EARFCNExtension>(2); }
15634                 OffsetOfNbiotChannelNumberToEARFCN& select_id_OffsetOfNbiotChannelNumberToDL_EARFCN() { return set<OffsetOfNbiotChannelNumberToEARFCN>(3); }
15635                 OffsetOfNbiotChannelNumberToEARFCN const* get_id_OffsetOfNbiotChannelNumberToDL_EARFCN() const { return get<OffsetOfNbiotChannelNumberToEARFCN>(3); }
15636                 OffsetOfNbiotChannelNumberToEARFCN& select_id_OffsetOfNbiotChannelNumberToUL_EARFCN() { return set<OffsetOfNbiotChannelNumberToEARFCN>(4); }
15637                 OffsetOfNbiotChannelNumberToEARFCN const* get_id_OffsetOfNbiotChannelNumberToUL_EARFCN() const { return get<OffsetOfNbiotChannelNumberToEARFCN>(4); }
15638                 NRS_NSSS_PowerOffset& select_id_NRS_NSSS_PowerOffset() { return set<NRS_NSSS_PowerOffset>(5); }
15639                 NRS_NSSS_PowerOffset const* get_id_NRS_NSSS_PowerOffset() const { return get<NRS_NSSS_PowerOffset>(5); }
15640                 NSSS_NumOccasionDifferentPrecoder& select_id_NSSS_NumOccasionDifferentPrecoder() { return set<NSSS_NumOccasionDifferentPrecoder>(6); }
15641                 NSSS_NumOccasionDifferentPrecoder const* get_id_NSSS_NumOccasionDifferentPrecoder() const { return get<NSSS_NumOccasionDifferentPrecoder>(6); }
15642                 bool is_unknown() const { return type == 7; }
15643                 void clear()
15644                 {
15645                         switch(type)
15646                         {
15647                         case 1: var.destroy<EARFCNExtension>(); break;
15648                         case 2: var.destroy<EARFCNExtension>(); break;
15649                         case 3: var.destroy<OffsetOfNbiotChannelNumberToEARFCN>(); break;
15650                         case 4: var.destroy<OffsetOfNbiotChannelNumberToEARFCN>(); break;
15651                         case 5: var.destroy<NRS_NSSS_PowerOffset>(); break;
15652                         case 6: var.destroy<NSSS_NumOccasionDifferentPrecoder>(); break;
15653                         }
15654                         type = 0; ref_nested().clear();
15655                 }
15656                 template<typename V> static inline void enumerate(V& v)
15657                 {
15658                         v.template operator()<EARFCNExtension>(1);
15659                         v.template operator()<EARFCNExtension>(2);
15660                         v.template operator()<OffsetOfNbiotChannelNumberToEARFCN>(3);
15661                         v.template operator()<OffsetOfNbiotChannelNumberToEARFCN>(4);
15662                         v.template operator()<NRS_NSSS_PowerOffset>(5);
15663                         v.template operator()<NSSS_NumOccasionDifferentPrecoder>(6);
15664
15665                 }
15666                 protected:
15667                 template<typename V> bool decode(size_t index, V& v)
15668                 {
15669                         clear();
15670                         switch(index)
15671                         {
15672                         case 1: v(select_id_UL_EARFCNExtension()); return true;
15673                         case 2: v(select_id_DL_EARFCNExtension()); return true;
15674                         case 3: v(select_id_OffsetOfNbiotChannelNumberToDL_EARFCN()); return true;
15675                         case 4: v(select_id_OffsetOfNbiotChannelNumberToUL_EARFCN()); return true;
15676                         case 5: v(select_id_NRS_NSSS_PowerOffset()); return true;
15677                         case 6: v(select_id_NSSS_NumOccasionDifferentPrecoder()); return true;
15678                         case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
15679                         }
15680                         return false;
15681
15682                 }
15683                 template<typename V> bool encode(size_t index, V& v) const
15684                 {
15685                         if(index != type) return false;
15686                         switch(type)
15687                         {
15688                         case 1: v(var.as<EARFCNExtension>()); return true;
15689                         case 2: v(var.as<EARFCNExtension>()); return true;
15690                         case 3: v(var.as<OffsetOfNbiotChannelNumberToEARFCN>()); return true;
15691                         case 4: v(var.as<OffsetOfNbiotChannelNumberToEARFCN>()); return true;
15692                         case 5: v(var.as<NRS_NSSS_PowerOffset>()); return true;
15693                         case 6: v(var.as<NSSS_NumOccasionDifferentPrecoder>()); return true;
15694                         }
15695                         return false;
15696
15697                 }
15698                 private:
15699                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
15700                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
15701                 union union_type
15702                 {
15703                         char dummy1[sizeof(EARFCNExtension)];
15704                         char dummy2[sizeof(NRS_NSSS_PowerOffset)];
15705                         char dummy3[sizeof(NSSS_NumOccasionDifferentPrecoder)];
15706                         char dummy4[sizeof(OffsetOfNbiotChannelNumberToEARFCN)];
15707
15708                 };
15709                 asn::variant<sizeof(union_type)> var;
15710                 size_t type {0};
15711
15712         };
15713         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
15714         {
15715                 size_t get_index() const {return type;}
15716                 bool is_unknown() const { return type == 7; }
15717                 void clear() {type = 0;}
15718                 void select_id_UL_EARFCNExtension() { set(optional); type=1;}
15719                 void select_id_DL_EARFCNExtension() { set(optional); type=2;}
15720                 void select_id_OffsetOfNbiotChannelNumberToDL_EARFCN() { set(optional); type=3;}
15721                 void select_id_OffsetOfNbiotChannelNumberToUL_EARFCN() { set(optional); type=4;}
15722                 void select_id_NRS_NSSS_PowerOffset() { set(optional); type=5;}
15723                 void select_id_NSSS_NumOccasionDifferentPrecoder() { set(optional); type=6;}
15724                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
15725                 template<typename V>  bool decode(V& v)
15726                 {
15727                         clear();
15728                         if(!v(ref_nested())) return false;
15729                         if(equal(optional)) { type = 1; return true; }
15730                         else if(equal(optional)) { type = 2; return true; }
15731                         else if(equal(optional)) { type = 3; return true; }
15732                         else if(equal(optional)) { type = 4; return true; }
15733                         else if(equal(optional)) { type = 5; return true; }
15734                         else if(equal(optional)) { type = 6; return true; }
15735                         else { type = 7; return true;}
15736                         return false;
15737
15738                 }
15739                 template<typename V> bool encode(V& v) const
15740                 {
15741                         return v(ref_nested());
15742
15743                 }
15744                 protected:
15745                 template<typename V>  bool decode(size_t index, V& v)
15746                 {
15747                         clear();
15748                         switch(index)
15749                         {
15750                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
15751                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
15752                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
15753                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
15754                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
15755                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
15756                         case 7: type = 7; return v(ref_nested());
15757                         ref_nested().clear();
15758                         }
15759                         return false;
15760
15761                 }
15762                 template<typename V> bool encode(size_t index, V& v) const
15763                 {
15764                         if(index != type) {return false;} return v(ref_nested());
15765
15766                 }
15767                 private:
15768                 size_t type {0};
15769
15770         };
15771
15772 };
15773 /*
15774 FDD-Info ::= SEQUENCE {
15775         uL-EARFCN                                               EARFCN,
15776         dL-EARFCN                                               EARFCN,
15777         uL-Transmission-Bandwidth               Transmission-Bandwidth,
15778         dL-Transmission-Bandwidth               Transmission-Bandwidth,
15779         iE-Extensions                           ProtocolExtensionContainer { {FDD-Info-ExtIEs} } OPTIONAL,
15780         ...
15781 }
15782 */
15783
15784 struct FDD_Info : asn::sequence<5, 0, true, 1>
15785 {
15786         static constexpr const char* name() {return "FDD-Info";}
15787         using parent_t = asn::sequence<5, 0, true, 1>;
15788         struct uL_EARFCN_t : EARFCN
15789         {
15790                 static constexpr const char* name() {return "uL_EARFCN_t";}
15791                 using parent_t = EARFCN;
15792
15793         };
15794         uL_EARFCN_t& ref_uL_EARFCN() {return uL_EARFCN;}
15795         uL_EARFCN_t const& ref_uL_EARFCN() const {return uL_EARFCN;}
15796         struct dL_EARFCN_t : EARFCN
15797         {
15798                 static constexpr const char* name() {return "dL_EARFCN_t";}
15799                 using parent_t = EARFCN;
15800
15801         };
15802         dL_EARFCN_t& ref_dL_EARFCN() {return dL_EARFCN;}
15803         dL_EARFCN_t const& ref_dL_EARFCN() const {return dL_EARFCN;}
15804         struct uL_Transmission_Bandwidth_t : Transmission_Bandwidth
15805         {
15806                 static constexpr const char* name() {return "uL_Transmission_Bandwidth_t";}
15807                 using parent_t = Transmission_Bandwidth;
15808
15809         };
15810         uL_Transmission_Bandwidth_t& ref_uL_Transmission_Bandwidth() {return uL_Transmission_Bandwidth;}
15811         uL_Transmission_Bandwidth_t const& ref_uL_Transmission_Bandwidth() const {return uL_Transmission_Bandwidth;}
15812         struct dL_Transmission_Bandwidth_t : Transmission_Bandwidth
15813         {
15814                 static constexpr const char* name() {return "dL_Transmission_Bandwidth_t";}
15815                 using parent_t = Transmission_Bandwidth;
15816
15817         };
15818         dL_Transmission_Bandwidth_t& ref_dL_Transmission_Bandwidth() {return dL_Transmission_Bandwidth;}
15819         dL_Transmission_Bandwidth_t const& ref_dL_Transmission_Bandwidth() const {return dL_Transmission_Bandwidth;}
15820         struct iE_Extensions_t : ProtocolExtensionContainer<FDD_Info_ExtIEs>
15821         {
15822                 static constexpr const char* name() {return "iE_Extensions_t";}
15823                 using parent_t = ProtocolExtensionContainer<FDD_Info_ExtIEs>;
15824                 static constexpr bool optional = true;
15825
15826         };
15827         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
15828         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
15829         template<typename V> void decode(V& v)
15830         {
15831                 v(uL_EARFCN);
15832                 v(dL_EARFCN);
15833                 v(uL_Transmission_Bandwidth);
15834                 v(dL_Transmission_Bandwidth);
15835                 v(iE_Extensions);
15836
15837         };
15838         template<typename V> void encode(V& v) const
15839         {
15840                 v(uL_EARFCN);
15841                 v(dL_EARFCN);
15842                 v(uL_Transmission_Bandwidth);
15843                 v(dL_Transmission_Bandwidth);
15844                 v(iE_Extensions);
15845
15846         };
15847         void clear()
15848         {
15849                 uL_EARFCN.clear();
15850                 dL_EARFCN.clear();
15851                 uL_Transmission_Bandwidth.clear();
15852                 dL_Transmission_Bandwidth.clear();
15853                 iE_Extensions.clear();
15854
15855         };
15856         private:
15857         uL_EARFCN_t     uL_EARFCN;
15858         dL_EARFCN_t     dL_EARFCN;
15859         uL_Transmission_Bandwidth_t     uL_Transmission_Bandwidth;
15860         dL_Transmission_Bandwidth_t     dL_Transmission_Bandwidth;
15861         iE_Extensions_t iE_Extensions;
15862
15863 };
15864 /*
15865 SubframeAssignment ::= ENUMERATED {
15866         sa0,
15867         sa1,
15868         sa2,
15869         sa3,
15870         sa4,
15871         sa5,
15872         sa6,
15873         ...
15874 }
15875 */
15876
15877 struct SubframeAssignment : asn::enumerated<7, 0, true>
15878 {
15879         static constexpr const char* name() {return "SubframeAssignment";}
15880         using parent_t = asn::enumerated<7, 0, true>;
15881         typedef enum {
15882                 sa0
15883                 ,sa1
15884                 ,sa2
15885                 ,sa3
15886                 ,sa4
15887                 ,sa5
15888                 ,sa6
15889         } index_t;
15890
15891 };
15892
15893 /*
15894 SpecialSubframePatterns ::= ENUMERATED {
15895         ssp0,
15896         ssp1,
15897         ssp2,
15898         ssp3,
15899         ssp4,
15900         ssp5,
15901         ssp6,
15902         ssp7,
15903         ssp8,
15904         ...
15905 }
15906 */
15907
15908 struct SpecialSubframePatterns : asn::enumerated<9, 0, true>
15909 {
15910         static constexpr const char* name() {return "SpecialSubframePatterns";}
15911         using parent_t = asn::enumerated<9, 0, true>;
15912         typedef enum {
15913                 ssp0
15914                 ,ssp1
15915                 ,ssp2
15916                 ,ssp3
15917                 ,ssp4
15918                 ,ssp5
15919                 ,ssp6
15920                 ,ssp7
15921                 ,ssp8
15922         } index_t;
15923
15924 };
15925
15926 /*
15927 SpecialSubframe-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
15928         ...
15929 }
15930 */
15931
15932 struct SpecialSubframe_Info_ExtIEs
15933 {
15934         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
15935         {
15936                 size_t get_index() const {return type;}
15937                 bool is_unknown() const { return type == 1; }
15938                 void clear() {type = 0;}
15939                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
15940                 template<typename V>  bool decode(V& v)
15941                 {
15942                         clear();
15943                         if(!v(ref_nested())) return false;
15944                         { type = 1; return true;}
15945                         return false;
15946
15947                 }
15948                 template<typename V> bool encode(V& v) const
15949                 {
15950                         return v(ref_nested());
15951
15952                 }
15953                 protected:
15954                 template<typename V>  bool decode(size_t index, V& v)
15955                 {
15956                         clear();
15957                         switch(index)
15958                         {
15959                         case 1: type = 1; return v(ref_nested());
15960                         ref_nested().clear();
15961                         }
15962                         return false;
15963
15964                 }
15965                 template<typename V> bool encode(size_t index, V& v) const
15966                 {
15967                         if(index != type) {return false;} return v(ref_nested());
15968
15969                 }
15970                 private:
15971                 size_t type {0};
15972
15973         };
15974         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
15975         {
15976                 size_t get_index() const {return type;}
15977                 bool is_unknown() const { return type == 1; }
15978                 void clear() {type = 0;}
15979                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
15980                 template<typename V>  bool decode(V& v)
15981                 {
15982                         clear();
15983                         if(!v(ref_nested())) return false;
15984                         { type = 1; return true;}
15985                         return false;
15986
15987                 }
15988                 template<typename V> bool encode(V& v) const
15989                 {
15990                         return v(ref_nested());
15991
15992                 }
15993                 protected:
15994                 template<typename V>  bool decode(size_t index, V& v)
15995                 {
15996                         clear();
15997                         switch(index)
15998                         {
15999                         case 1: type = 1; return v(ref_nested());
16000                         ref_nested().clear();
16001                         }
16002                         return false;
16003
16004                 }
16005                 template<typename V> bool encode(size_t index, V& v) const
16006                 {
16007                         if(index != type) {return false;} return v(ref_nested());
16008
16009                 }
16010                 private:
16011                 size_t type {0};
16012
16013         };
16014         struct Extension_t : asn::typefield<true>
16015         {
16016                 ~Extension_t()  {clear();}
16017                 size_t get_index() const {return type;}
16018                 bool is_unknown() const { return type == 1; }
16019                 void clear()
16020                 {
16021                         type = 0; ref_nested().clear();
16022                 }
16023                 template<typename V> static inline void enumerate(V& v)
16024                 {
16025
16026                 }
16027                 protected:
16028                 template<typename V> bool decode(size_t index, V& v)
16029                 {
16030                         clear();
16031                         switch(index)
16032                         {
16033                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
16034                         }
16035                         return false;
16036
16037                 }
16038                 template<typename V> bool encode(size_t index, V& v) const
16039                 {
16040                         if(index != type) return false;
16041                         return false;
16042
16043                 }
16044                 private:
16045                 size_t type {0};
16046
16047         };
16048         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
16049         {
16050                 size_t get_index() const {return type;}
16051                 bool is_unknown() const { return type == 1; }
16052                 void clear() {type = 0;}
16053                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
16054                 template<typename V>  bool decode(V& v)
16055                 {
16056                         clear();
16057                         if(!v(ref_nested())) return false;
16058                         { type = 1; return true;}
16059                         return false;
16060
16061                 }
16062                 template<typename V> bool encode(V& v) const
16063                 {
16064                         return v(ref_nested());
16065
16066                 }
16067                 protected:
16068                 template<typename V>  bool decode(size_t index, V& v)
16069                 {
16070                         clear();
16071                         switch(index)
16072                         {
16073                         case 1: type = 1; return v(ref_nested());
16074                         ref_nested().clear();
16075                         }
16076                         return false;
16077
16078                 }
16079                 template<typename V> bool encode(size_t index, V& v) const
16080                 {
16081                         if(index != type) {return false;} return v(ref_nested());
16082
16083                 }
16084                 private:
16085                 size_t type {0};
16086
16087         };
16088
16089 };
16090 /*
16091 SpecialSubframe-Info ::= SEQUENCE {
16092         specialSubframePatterns         SpecialSubframePatterns,
16093         cyclicPrefixDL                          CyclicPrefixDL,
16094         cyclicPrefixUL                          CyclicPrefixUL,
16095         iE-Extensions                           ProtocolExtensionContainer { {SpecialSubframe-Info-ExtIEs} } OPTIONAL,
16096         ...
16097 }
16098 */
16099
16100 struct SpecialSubframe_Info : asn::sequence<4, 0, true, 1>
16101 {
16102         static constexpr const char* name() {return "SpecialSubframe-Info";}
16103         using parent_t = asn::sequence<4, 0, true, 1>;
16104         struct specialSubframePatterns_t : SpecialSubframePatterns
16105         {
16106                 static constexpr const char* name() {return "specialSubframePatterns_t";}
16107                 using parent_t = SpecialSubframePatterns;
16108
16109         };
16110         specialSubframePatterns_t& ref_specialSubframePatterns() {return specialSubframePatterns;}
16111         specialSubframePatterns_t const& ref_specialSubframePatterns() const {return specialSubframePatterns;}
16112         struct cyclicPrefixDL_t : CyclicPrefixDL
16113         {
16114                 static constexpr const char* name() {return "cyclicPrefixDL_t";}
16115                 using parent_t = CyclicPrefixDL;
16116
16117         };
16118         cyclicPrefixDL_t& ref_cyclicPrefixDL() {return cyclicPrefixDL;}
16119         cyclicPrefixDL_t const& ref_cyclicPrefixDL() const {return cyclicPrefixDL;}
16120         struct cyclicPrefixUL_t : CyclicPrefixUL
16121         {
16122                 static constexpr const char* name() {return "cyclicPrefixUL_t";}
16123                 using parent_t = CyclicPrefixUL;
16124
16125         };
16126         cyclicPrefixUL_t& ref_cyclicPrefixUL() {return cyclicPrefixUL;}
16127         cyclicPrefixUL_t const& ref_cyclicPrefixUL() const {return cyclicPrefixUL;}
16128         struct iE_Extensions_t : ProtocolExtensionContainer<SpecialSubframe_Info_ExtIEs>
16129         {
16130                 static constexpr const char* name() {return "iE_Extensions_t";}
16131                 using parent_t = ProtocolExtensionContainer<SpecialSubframe_Info_ExtIEs>;
16132                 static constexpr bool optional = true;
16133
16134         };
16135         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
16136         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
16137         template<typename V> void decode(V& v)
16138         {
16139                 v(specialSubframePatterns);
16140                 v(cyclicPrefixDL);
16141                 v(cyclicPrefixUL);
16142                 v(iE_Extensions);
16143
16144         };
16145         template<typename V> void encode(V& v) const
16146         {
16147                 v(specialSubframePatterns);
16148                 v(cyclicPrefixDL);
16149                 v(cyclicPrefixUL);
16150                 v(iE_Extensions);
16151
16152         };
16153         void clear()
16154         {
16155                 specialSubframePatterns.clear();
16156                 cyclicPrefixDL.clear();
16157                 cyclicPrefixUL.clear();
16158                 iE_Extensions.clear();
16159
16160         };
16161         private:
16162         specialSubframePatterns_t       specialSubframePatterns;
16163         cyclicPrefixDL_t        cyclicPrefixDL;
16164         cyclicPrefixUL_t        cyclicPrefixUL;
16165         iE_Extensions_t iE_Extensions;
16166
16167 };
16168 /*
16169 TDD-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
16170         { ID id-AdditionalSpecialSubframe-Info  CRITICALITY ignore      EXTENSION AdditionalSpecialSubframe-Info        PRESENCE optional}|
16171         { ID id-eARFCNExtension                                 CRITICALITY reject      EXTENSION EARFCNExtension                                               PRESENCE optional}|
16172         { ID id-AdditionalSpecialSubframeExtension-Info CRITICALITY ignore      EXTENSION AdditionalSpecialSubframeExtension-Info       PRESENCE optional},
16173         ...
16174 }
16175 */
16176
16177 struct TDD_Info_ExtIEs
16178 {
16179         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
16180         {
16181                 size_t get_index() const {return type;}
16182                 bool is_unknown() const { return type == 4; }
16183                 void clear() {type = 0;}
16184                 void select_id_AdditionalSpecialSubframe_Info() { set(id_AdditionalSpecialSubframe_Info); type=1;}
16185                 void select_id_eARFCNExtension() { set(id_eARFCNExtension); type=2;}
16186                 void select_id_AdditionalSpecialSubframeExtension_Info() { set(id_AdditionalSpecialSubframeExtension_Info); type=3;}
16187                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
16188                 template<typename V>  bool decode(V& v)
16189                 {
16190                         clear();
16191                         if(!v(ref_nested())) return false;
16192                         if(equal(id_AdditionalSpecialSubframe_Info)) { type = 1; return true; }
16193                         else if(equal(id_eARFCNExtension)) { type = 2; return true; }
16194                         else if(equal(id_AdditionalSpecialSubframeExtension_Info)) { type = 3; return true; }
16195                         else { type = 4; return true;}
16196                         return false;
16197
16198                 }
16199                 template<typename V> bool encode(V& v) const
16200                 {
16201                         return v(ref_nested());
16202
16203                 }
16204                 protected:
16205                 template<typename V>  bool decode(size_t index, V& v)
16206                 {
16207                         clear();
16208                         switch(index)
16209                         {
16210                         case 1: type = 1; if(v(ref_nested())) { return equal(id_AdditionalSpecialSubframe_Info);} return false;
16211                         case 2: type = 2; if(v(ref_nested())) { return equal(id_eARFCNExtension);} return false;
16212                         case 3: type = 3; if(v(ref_nested())) { return equal(id_AdditionalSpecialSubframeExtension_Info);} return false;
16213                         case 4: type = 4; return v(ref_nested());
16214                         ref_nested().clear();
16215                         }
16216                         return false;
16217
16218                 }
16219                 template<typename V> bool encode(size_t index, V& v) const
16220                 {
16221                         if(index != type) {return false;} return v(ref_nested());
16222
16223                 }
16224                 private:
16225                 size_t type {0};
16226
16227         };
16228         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
16229         {
16230                 size_t get_index() const {return type;}
16231                 bool is_unknown() const { return type == 4; }
16232                 void clear() {type = 0;}
16233                 void select_id_AdditionalSpecialSubframe_Info() { set(ignore); type=1;}
16234                 void select_id_eARFCNExtension() { set(reject); type=2;}
16235                 void select_id_AdditionalSpecialSubframeExtension_Info() { set(ignore); type=3;}
16236                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
16237                 template<typename V>  bool decode(V& v)
16238                 {
16239                         clear();
16240                         if(!v(ref_nested())) return false;
16241                         if(equal(ignore)) { type = 1; return true; }
16242                         else if(equal(reject)) { type = 2; return true; }
16243                         else if(equal(ignore)) { type = 3; return true; }
16244                         else { type = 4; return true;}
16245                         return false;
16246
16247                 }
16248                 template<typename V> bool encode(V& v) const
16249                 {
16250                         return v(ref_nested());
16251
16252                 }
16253                 protected:
16254                 template<typename V>  bool decode(size_t index, V& v)
16255                 {
16256                         clear();
16257                         switch(index)
16258                         {
16259                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
16260                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
16261                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
16262                         case 4: type = 4; return v(ref_nested());
16263                         ref_nested().clear();
16264                         }
16265                         return false;
16266
16267                 }
16268                 template<typename V> bool encode(size_t index, V& v) const
16269                 {
16270                         if(index != type) {return false;} return v(ref_nested());
16271
16272                 }
16273                 private:
16274                 size_t type {0};
16275
16276         };
16277         struct Extension_t : asn::typefield<true>
16278         {
16279                 ~Extension_t()  {clear();}
16280                 size_t get_index() const {return type;}
16281                 AdditionalSpecialSubframe_Info& select_id_AdditionalSpecialSubframe_Info() { return set<AdditionalSpecialSubframe_Info>(1); }
16282                 AdditionalSpecialSubframe_Info const* get_id_AdditionalSpecialSubframe_Info() const { return get<AdditionalSpecialSubframe_Info>(1); }
16283                 EARFCNExtension& select_id_eARFCNExtension() { return set<EARFCNExtension>(2); }
16284                 EARFCNExtension const* get_id_eARFCNExtension() const { return get<EARFCNExtension>(2); }
16285                 AdditionalSpecialSubframeExtension_Info& select_id_AdditionalSpecialSubframeExtension_Info() { return set<AdditionalSpecialSubframeExtension_Info>(3); }
16286                 AdditionalSpecialSubframeExtension_Info const* get_id_AdditionalSpecialSubframeExtension_Info() const { return get<AdditionalSpecialSubframeExtension_Info>(3); }
16287                 bool is_unknown() const { return type == 4; }
16288                 void clear()
16289                 {
16290                         switch(type)
16291                         {
16292                         case 1: var.destroy<AdditionalSpecialSubframe_Info>(); break;
16293                         case 2: var.destroy<EARFCNExtension>(); break;
16294                         case 3: var.destroy<AdditionalSpecialSubframeExtension_Info>(); break;
16295                         }
16296                         type = 0; ref_nested().clear();
16297                 }
16298                 template<typename V> static inline void enumerate(V& v)
16299                 {
16300                         v.template operator()<AdditionalSpecialSubframe_Info>(1);
16301                         v.template operator()<EARFCNExtension>(2);
16302                         v.template operator()<AdditionalSpecialSubframeExtension_Info>(3);
16303
16304                 }
16305                 protected:
16306                 template<typename V> bool decode(size_t index, V& v)
16307                 {
16308                         clear();
16309                         switch(index)
16310                         {
16311                         case 1: v(select_id_AdditionalSpecialSubframe_Info()); return true;
16312                         case 2: v(select_id_eARFCNExtension()); return true;
16313                         case 3: v(select_id_AdditionalSpecialSubframeExtension_Info()); return true;
16314                         case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
16315                         }
16316                         return false;
16317
16318                 }
16319                 template<typename V> bool encode(size_t index, V& v) const
16320                 {
16321                         if(index != type) return false;
16322                         switch(type)
16323                         {
16324                         case 1: v(var.as<AdditionalSpecialSubframe_Info>()); return true;
16325                         case 2: v(var.as<EARFCNExtension>()); return true;
16326                         case 3: v(var.as<AdditionalSpecialSubframeExtension_Info>()); return true;
16327                         }
16328                         return false;
16329
16330                 }
16331                 private:
16332                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
16333                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
16334                 union union_type
16335                 {
16336                         char dummy1[sizeof(AdditionalSpecialSubframeExtension_Info)];
16337                         char dummy2[sizeof(AdditionalSpecialSubframe_Info)];
16338                         char dummy3[sizeof(EARFCNExtension)];
16339
16340                 };
16341                 asn::variant<sizeof(union_type)> var;
16342                 size_t type {0};
16343
16344         };
16345         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
16346         {
16347                 size_t get_index() const {return type;}
16348                 bool is_unknown() const { return type == 4; }
16349                 void clear() {type = 0;}
16350                 void select_id_AdditionalSpecialSubframe_Info() { set(optional); type=1;}
16351                 void select_id_eARFCNExtension() { set(optional); type=2;}
16352                 void select_id_AdditionalSpecialSubframeExtension_Info() { set(optional); type=3;}
16353                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
16354                 template<typename V>  bool decode(V& v)
16355                 {
16356                         clear();
16357                         if(!v(ref_nested())) return false;
16358                         if(equal(optional)) { type = 1; return true; }
16359                         else if(equal(optional)) { type = 2; return true; }
16360                         else if(equal(optional)) { type = 3; return true; }
16361                         else { type = 4; return true;}
16362                         return false;
16363
16364                 }
16365                 template<typename V> bool encode(V& v) const
16366                 {
16367                         return v(ref_nested());
16368
16369                 }
16370                 protected:
16371                 template<typename V>  bool decode(size_t index, V& v)
16372                 {
16373                         clear();
16374                         switch(index)
16375                         {
16376                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
16377                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
16378                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
16379                         case 4: type = 4; return v(ref_nested());
16380                         ref_nested().clear();
16381                         }
16382                         return false;
16383
16384                 }
16385                 template<typename V> bool encode(size_t index, V& v) const
16386                 {
16387                         if(index != type) {return false;} return v(ref_nested());
16388
16389                 }
16390                 private:
16391                 size_t type {0};
16392
16393         };
16394
16395 };
16396 /*
16397 TDD-Info ::= SEQUENCE {
16398         eARFCN                                                  EARFCN,
16399         transmission-Bandwidth                  Transmission-Bandwidth,
16400         subframeAssignment                              SubframeAssignment,
16401         specialSubframe-Info                    SpecialSubframe-Info,
16402         iE-Extensions                                   ProtocolExtensionContainer { {TDD-Info-ExtIEs} } OPTIONAL,
16403         ...
16404 }
16405 */
16406
16407 struct TDD_Info : asn::sequence<5, 0, true, 1>
16408 {
16409         static constexpr const char* name() {return "TDD-Info";}
16410         using parent_t = asn::sequence<5, 0, true, 1>;
16411         struct eARFCN_t : EARFCN
16412         {
16413                 static constexpr const char* name() {return "eARFCN_t";}
16414                 using parent_t = EARFCN;
16415
16416         };
16417         eARFCN_t& ref_eARFCN() {return eARFCN;}
16418         eARFCN_t const& ref_eARFCN() const {return eARFCN;}
16419         struct transmission_Bandwidth_t : Transmission_Bandwidth
16420         {
16421                 static constexpr const char* name() {return "transmission_Bandwidth_t";}
16422                 using parent_t = Transmission_Bandwidth;
16423
16424         };
16425         transmission_Bandwidth_t& ref_transmission_Bandwidth() {return transmission_Bandwidth;}
16426         transmission_Bandwidth_t const& ref_transmission_Bandwidth() const {return transmission_Bandwidth;}
16427         struct subframeAssignment_t : SubframeAssignment
16428         {
16429                 static constexpr const char* name() {return "subframeAssignment_t";}
16430                 using parent_t = SubframeAssignment;
16431
16432         };
16433         subframeAssignment_t& ref_subframeAssignment() {return subframeAssignment;}
16434         subframeAssignment_t const& ref_subframeAssignment() const {return subframeAssignment;}
16435         struct specialSubframe_Info_t : SpecialSubframe_Info
16436         {
16437                 static constexpr const char* name() {return "specialSubframe_Info_t";}
16438                 using parent_t = SpecialSubframe_Info;
16439
16440         };
16441         specialSubframe_Info_t& ref_specialSubframe_Info() {return specialSubframe_Info;}
16442         specialSubframe_Info_t const& ref_specialSubframe_Info() const {return specialSubframe_Info;}
16443         struct iE_Extensions_t : ProtocolExtensionContainer<TDD_Info_ExtIEs>
16444         {
16445                 static constexpr const char* name() {return "iE_Extensions_t";}
16446                 using parent_t = ProtocolExtensionContainer<TDD_Info_ExtIEs>;
16447                 static constexpr bool optional = true;
16448
16449         };
16450         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
16451         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
16452         template<typename V> void decode(V& v)
16453         {
16454                 v(eARFCN);
16455                 v(transmission_Bandwidth);
16456                 v(subframeAssignment);
16457                 v(specialSubframe_Info);
16458                 v(iE_Extensions);
16459
16460         };
16461         template<typename V> void encode(V& v) const
16462         {
16463                 v(eARFCN);
16464                 v(transmission_Bandwidth);
16465                 v(subframeAssignment);
16466                 v(specialSubframe_Info);
16467                 v(iE_Extensions);
16468
16469         };
16470         void clear()
16471         {
16472                 eARFCN.clear();
16473                 transmission_Bandwidth.clear();
16474                 subframeAssignment.clear();
16475                 specialSubframe_Info.clear();
16476                 iE_Extensions.clear();
16477
16478         };
16479         private:
16480         eARFCN_t        eARFCN;
16481         transmission_Bandwidth_t        transmission_Bandwidth;
16482         subframeAssignment_t    subframeAssignment;
16483         specialSubframe_Info_t  specialSubframe_Info;
16484         iE_Extensions_t iE_Extensions;
16485
16486 };
16487 /*
16488 EUTRA-Mode-Info ::= CHOICE {
16489         fDD             FDD-Info,
16490         tDD             TDD-Info,
16491         ...
16492 }
16493 */
16494
16495 struct EUTRA_Mode_Info : asn::choice<2, 0, true>
16496 {
16497         static constexpr const char* name() {return "EUTRA-Mode-Info";}
16498         using parent_t = asn::choice<2, 0, true>;
16499         index_type get_index() const {return index;}
16500         bool is_unknown() const {return index == 3;}
16501         void set_unknown() { set_index(3);  }
16502         ~EUTRA_Mode_Info() {clear();}
16503         struct fDD_t : FDD_Info
16504         {
16505                 static constexpr const char* name() {return "fDD_t";}
16506                 using parent_t = FDD_Info;
16507
16508         };
16509         struct tDD_t : TDD_Info
16510         {
16511                 static constexpr const char* name() {return "tDD_t";}
16512                 using parent_t = TDD_Info;
16513
16514         };
16515         void clear()
16516         {
16517                 switch(get_index())
16518                 {
16519                 case 1: var.destroy<fDD_t>(); break;
16520                 case 2: var.destroy<tDD_t>(); break;
16521                 }
16522                 index = 0;
16523                 base::clear();
16524         }
16525         template<typename V> bool decode(size_t idx, V& v)
16526         {
16527                 clear();
16528                 switch(idx)
16529                 {
16530                 case 1: set_index(1); return v(var.build<fDD_t>());
16531                 case 2: set_index(2); return v(var.build<tDD_t>());
16532                 }
16533                 return false;
16534
16535         }
16536         template<typename V> bool encode(V& v) const
16537         {
16538                 switch(get_index())
16539                 {
16540                 case 1: return v(var.as<fDD_t>());
16541                 case 2: return v(var.as<tDD_t>());
16542                 }
16543                 return false;
16544         }
16545         template<typename V> static inline void enumerate(V& v)
16546         {
16547                 v.template operator()<fDD_t>(1);
16548                 v.template operator()<tDD_t>(2);
16549
16550         }
16551         fDD_t& select_fDD() { if(get_index() != 1) { clear(); set_index(1); return var.build<fDD_t>();} return var.as<fDD_t>();}
16552         fDD_t const* get_fDD() const { if(get_index() == 1) { return &var.as<fDD_t>();} return nullptr; }
16553         tDD_t& select_tDD() { if(get_index() != 2) { clear(); set_index(2); return var.build<tDD_t>();} return var.as<tDD_t>();}
16554         tDD_t const* get_tDD() const { if(get_index() == 2) { return &var.as<tDD_t>();} return nullptr; }
16555         private:
16556         void set_index(index_type i) {index = i; base::set();}
16557         union union_type
16558         {
16559                 char dummy1[sizeof(fDD_t)];
16560                 char dummy2[sizeof(tDD_t)];
16561
16562         };
16563         asn::variant<sizeof(union_type)>        var;
16564         index_type      index {0};
16565 };
16566 /*
16567 EUTRANTraceID           ::= OCTET STRING (SIZE (8))
16568 */
16569
16570 struct EUTRANTraceID : asn::ostring<>
16571 {
16572         using constraint_t = asn::constraints<false,asn::one<8>>;
16573         static constexpr const char* name() {return "EUTRANTraceID";}
16574         using parent_t = asn::ostring<>;
16575
16576 };
16577
16578 /*
16579 EncryptionAlgorithms ::= BIT STRING (SIZE (16, ...))
16580 */
16581
16582 struct EncryptionAlgorithms : asn::bstring<>
16583 {
16584         using constraint_t = asn::constraints<true,asn::one<16>>;
16585         static constexpr const char* name() {return "EncryptionAlgorithms";}
16586         using parent_t = asn::bstring<>;
16587
16588 };
16589
16590 /*
16591 RNTP-Threshold ::= ENUMERATED {
16592         minusInfinity,
16593         minusEleven,
16594         minusTen,
16595         minusNine,
16596         minusEight,
16597         minusSeven,
16598         minusSix,
16599         minusFive,
16600         minusFour,
16601         minusThree,
16602         minusTwo,
16603         minusOne,
16604         zero,
16605         one,
16606         two,
16607         three,
16608         ...
16609 }
16610 */
16611
16612 struct RNTP_Threshold : asn::enumerated<16, 0, true>
16613 {
16614         static constexpr const char* name() {return "RNTP-Threshold";}
16615         using parent_t = asn::enumerated<16, 0, true>;
16616         typedef enum {
16617                 minusInfinity
16618                 ,minusEleven
16619                 ,minusTen
16620                 ,minusNine
16621                 ,minusEight
16622                 ,minusSeven
16623                 ,minusSix
16624                 ,minusFive
16625                 ,minusFour
16626                 ,minusThree
16627                 ,minusTwo
16628                 ,minusOne
16629                 ,zero
16630                 ,one
16631                 ,two
16632                 ,three
16633         } index_t;
16634
16635 };
16636
16637 /*
16638 EnhancedRNTPStartTime-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
16639         ...
16640 }
16641 */
16642
16643 struct EnhancedRNTPStartTime_ExtIEs
16644 {
16645         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
16646         {
16647                 size_t get_index() const {return type;}
16648                 bool is_unknown() const { return type == 1; }
16649                 void clear() {type = 0;}
16650                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
16651                 template<typename V>  bool decode(V& v)
16652                 {
16653                         clear();
16654                         if(!v(ref_nested())) return false;
16655                         { type = 1; return true;}
16656                         return false;
16657
16658                 }
16659                 template<typename V> bool encode(V& v) const
16660                 {
16661                         return v(ref_nested());
16662
16663                 }
16664                 protected:
16665                 template<typename V>  bool decode(size_t index, V& v)
16666                 {
16667                         clear();
16668                         switch(index)
16669                         {
16670                         case 1: type = 1; return v(ref_nested());
16671                         ref_nested().clear();
16672                         }
16673                         return false;
16674
16675                 }
16676                 template<typename V> bool encode(size_t index, V& v) const
16677                 {
16678                         if(index != type) {return false;} return v(ref_nested());
16679
16680                 }
16681                 private:
16682                 size_t type {0};
16683
16684         };
16685         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
16686         {
16687                 size_t get_index() const {return type;}
16688                 bool is_unknown() const { return type == 1; }
16689                 void clear() {type = 0;}
16690                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
16691                 template<typename V>  bool decode(V& v)
16692                 {
16693                         clear();
16694                         if(!v(ref_nested())) return false;
16695                         { type = 1; return true;}
16696                         return false;
16697
16698                 }
16699                 template<typename V> bool encode(V& v) const
16700                 {
16701                         return v(ref_nested());
16702
16703                 }
16704                 protected:
16705                 template<typename V>  bool decode(size_t index, V& v)
16706                 {
16707                         clear();
16708                         switch(index)
16709                         {
16710                         case 1: type = 1; return v(ref_nested());
16711                         ref_nested().clear();
16712                         }
16713                         return false;
16714
16715                 }
16716                 template<typename V> bool encode(size_t index, V& v) const
16717                 {
16718                         if(index != type) {return false;} return v(ref_nested());
16719
16720                 }
16721                 private:
16722                 size_t type {0};
16723
16724         };
16725         struct Extension_t : asn::typefield<true>
16726         {
16727                 ~Extension_t()  {clear();}
16728                 size_t get_index() const {return type;}
16729                 bool is_unknown() const { return type == 1; }
16730                 void clear()
16731                 {
16732                         type = 0; ref_nested().clear();
16733                 }
16734                 template<typename V> static inline void enumerate(V& v)
16735                 {
16736
16737                 }
16738                 protected:
16739                 template<typename V> bool decode(size_t index, V& v)
16740                 {
16741                         clear();
16742                         switch(index)
16743                         {
16744                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
16745                         }
16746                         return false;
16747
16748                 }
16749                 template<typename V> bool encode(size_t index, V& v) const
16750                 {
16751                         if(index != type) return false;
16752                         return false;
16753
16754                 }
16755                 private:
16756                 size_t type {0};
16757
16758         };
16759         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
16760         {
16761                 size_t get_index() const {return type;}
16762                 bool is_unknown() const { return type == 1; }
16763                 void clear() {type = 0;}
16764                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
16765                 template<typename V>  bool decode(V& v)
16766                 {
16767                         clear();
16768                         if(!v(ref_nested())) return false;
16769                         { type = 1; return true;}
16770                         return false;
16771
16772                 }
16773                 template<typename V> bool encode(V& v) const
16774                 {
16775                         return v(ref_nested());
16776
16777                 }
16778                 protected:
16779                 template<typename V>  bool decode(size_t index, V& v)
16780                 {
16781                         clear();
16782                         switch(index)
16783                         {
16784                         case 1: type = 1; return v(ref_nested());
16785                         ref_nested().clear();
16786                         }
16787                         return false;
16788
16789                 }
16790                 template<typename V> bool encode(size_t index, V& v) const
16791                 {
16792                         if(index != type) {return false;} return v(ref_nested());
16793
16794                 }
16795                 private:
16796                 size_t type {0};
16797
16798         };
16799
16800 };
16801 /*
16802 EnhancedRNTPStartTime ::= SEQUENCE {
16803                 startSFN                                INTEGER (0..1023, ...),
16804                 startSubframeNumber             INTEGER (0..9, ...),
16805                 iE-Extensions                   ProtocolExtensionContainer { {EnhancedRNTPStartTime-ExtIEs} } OPTIONAL,
16806                 ...
16807         }
16808 */
16809
16810 struct EnhancedRNTPStartTime : asn::sequence<3, 0, true, 1>
16811 {
16812         static constexpr const char* name() {return "EnhancedRNTPStartTime";}
16813         using parent_t = asn::sequence<3, 0, true, 1>;
16814         struct startSFN_t : asn::integer<>
16815         {
16816                 using constraint_t = asn::constraints<true,asn::span<0, 1023>>;
16817                 static constexpr const char* name() {return "startSFN_t";}
16818                 using parent_t = asn::integer<>;
16819
16820         };
16821
16822         startSFN_t& ref_startSFN() {return startSFN;}
16823         startSFN_t const& ref_startSFN() const {return startSFN;}
16824         struct startSubframeNumber_t : asn::integer<>
16825         {
16826                 using constraint_t = asn::constraints<true,asn::span<0, 9>>;
16827                 static constexpr const char* name() {return "startSubframeNumber_t";}
16828                 using parent_t = asn::integer<>;
16829
16830         };
16831
16832         startSubframeNumber_t& ref_startSubframeNumber() {return startSubframeNumber;}
16833         startSubframeNumber_t const& ref_startSubframeNumber() const {return startSubframeNumber;}
16834         struct iE_Extensions_t : ProtocolExtensionContainer<EnhancedRNTPStartTime_ExtIEs>
16835         {
16836                 static constexpr const char* name() {return "iE_Extensions_t";}
16837                 using parent_t = ProtocolExtensionContainer<EnhancedRNTPStartTime_ExtIEs>;
16838                 static constexpr bool optional = true;
16839
16840         };
16841         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
16842         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
16843         template<typename V> void decode(V& v)
16844         {
16845                 v(startSFN);
16846                 v(startSubframeNumber);
16847                 v(iE_Extensions);
16848
16849         };
16850         template<typename V> void encode(V& v) const
16851         {
16852                 v(startSFN);
16853                 v(startSubframeNumber);
16854                 v(iE_Extensions);
16855
16856         };
16857         void clear()
16858         {
16859                 startSFN.clear();
16860                 startSubframeNumber.clear();
16861                 iE_Extensions.clear();
16862
16863         };
16864         private:
16865         startSFN_t      startSFN;
16866         startSubframeNumber_t   startSubframeNumber;
16867         iE_Extensions_t iE_Extensions;
16868
16869 };
16870 /*
16871 EnhancedRNTP-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
16872         ...
16873 }
16874 */
16875
16876 struct EnhancedRNTP_ExtIEs
16877 {
16878         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
16879         {
16880                 size_t get_index() const {return type;}
16881                 bool is_unknown() const { return type == 1; }
16882                 void clear() {type = 0;}
16883                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
16884                 template<typename V>  bool decode(V& v)
16885                 {
16886                         clear();
16887                         if(!v(ref_nested())) return false;
16888                         { type = 1; return true;}
16889                         return false;
16890
16891                 }
16892                 template<typename V> bool encode(V& v) const
16893                 {
16894                         return v(ref_nested());
16895
16896                 }
16897                 protected:
16898                 template<typename V>  bool decode(size_t index, V& v)
16899                 {
16900                         clear();
16901                         switch(index)
16902                         {
16903                         case 1: type = 1; return v(ref_nested());
16904                         ref_nested().clear();
16905                         }
16906                         return false;
16907
16908                 }
16909                 template<typename V> bool encode(size_t index, V& v) const
16910                 {
16911                         if(index != type) {return false;} return v(ref_nested());
16912
16913                 }
16914                 private:
16915                 size_t type {0};
16916
16917         };
16918         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
16919         {
16920                 size_t get_index() const {return type;}
16921                 bool is_unknown() const { return type == 1; }
16922                 void clear() {type = 0;}
16923                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
16924                 template<typename V>  bool decode(V& v)
16925                 {
16926                         clear();
16927                         if(!v(ref_nested())) return false;
16928                         { type = 1; return true;}
16929                         return false;
16930
16931                 }
16932                 template<typename V> bool encode(V& v) const
16933                 {
16934                         return v(ref_nested());
16935
16936                 }
16937                 protected:
16938                 template<typename V>  bool decode(size_t index, V& v)
16939                 {
16940                         clear();
16941                         switch(index)
16942                         {
16943                         case 1: type = 1; return v(ref_nested());
16944                         ref_nested().clear();
16945                         }
16946                         return false;
16947
16948                 }
16949                 template<typename V> bool encode(size_t index, V& v) const
16950                 {
16951                         if(index != type) {return false;} return v(ref_nested());
16952
16953                 }
16954                 private:
16955                 size_t type {0};
16956
16957         };
16958         struct Extension_t : asn::typefield<true>
16959         {
16960                 ~Extension_t()  {clear();}
16961                 size_t get_index() const {return type;}
16962                 bool is_unknown() const { return type == 1; }
16963                 void clear()
16964                 {
16965                         type = 0; ref_nested().clear();
16966                 }
16967                 template<typename V> static inline void enumerate(V& v)
16968                 {
16969
16970                 }
16971                 protected:
16972                 template<typename V> bool decode(size_t index, V& v)
16973                 {
16974                         clear();
16975                         switch(index)
16976                         {
16977                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
16978                         }
16979                         return false;
16980
16981                 }
16982                 template<typename V> bool encode(size_t index, V& v) const
16983                 {
16984                         if(index != type) return false;
16985                         return false;
16986
16987                 }
16988                 private:
16989                 size_t type {0};
16990
16991         };
16992         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
16993         {
16994                 size_t get_index() const {return type;}
16995                 bool is_unknown() const { return type == 1; }
16996                 void clear() {type = 0;}
16997                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
16998                 template<typename V>  bool decode(V& v)
16999                 {
17000                         clear();
17001                         if(!v(ref_nested())) return false;
17002                         { type = 1; return true;}
17003                         return false;
17004
17005                 }
17006                 template<typename V> bool encode(V& v) const
17007                 {
17008                         return v(ref_nested());
17009
17010                 }
17011                 protected:
17012                 template<typename V>  bool decode(size_t index, V& v)
17013                 {
17014                         clear();
17015                         switch(index)
17016                         {
17017                         case 1: type = 1; return v(ref_nested());
17018                         ref_nested().clear();
17019                         }
17020                         return false;
17021
17022                 }
17023                 template<typename V> bool encode(size_t index, V& v) const
17024                 {
17025                         if(index != type) {return false;} return v(ref_nested());
17026
17027                 }
17028                 private:
17029                 size_t type {0};
17030
17031         };
17032
17033 };
17034 /*
17035 EnhancedRNTP ::= SEQUENCE {
17036         enhancedRNTPBitmap                      BIT STRING (SIZE(12..8800, ...)),
17037         rNTP-High-Power-Threshold       RNTP-Threshold,
17038         enhancedRNTPStartTime           EnhancedRNTPStartTime OPTIONAL,
17039         iE-Extensions                           ProtocolExtensionContainer { {EnhancedRNTP-ExtIEs} } OPTIONAL,
17040         ...
17041 }
17042 */
17043
17044 struct EnhancedRNTP : asn::sequence<4, 0, true, 2>
17045 {
17046         static constexpr const char* name() {return "EnhancedRNTP";}
17047         using parent_t = asn::sequence<4, 0, true, 2>;
17048         struct enhancedRNTPBitmap_t : asn::bstring<>
17049         {
17050                 using constraint_t = asn::constraints<true,asn::span<12, 8800>>;
17051                 static constexpr const char* name() {return "enhancedRNTPBitmap_t";}
17052                 using parent_t = asn::bstring<>;
17053
17054         };
17055
17056         enhancedRNTPBitmap_t& ref_enhancedRNTPBitmap() {return enhancedRNTPBitmap;}
17057         enhancedRNTPBitmap_t const& ref_enhancedRNTPBitmap() const {return enhancedRNTPBitmap;}
17058         struct rNTP_High_Power_Threshold_t : RNTP_Threshold
17059         {
17060                 static constexpr const char* name() {return "rNTP_High_Power_Threshold_t";}
17061                 using parent_t = RNTP_Threshold;
17062
17063         };
17064         rNTP_High_Power_Threshold_t& ref_rNTP_High_Power_Threshold() {return rNTP_High_Power_Threshold;}
17065         rNTP_High_Power_Threshold_t const& ref_rNTP_High_Power_Threshold() const {return rNTP_High_Power_Threshold;}
17066         struct enhancedRNTPStartTime_t : EnhancedRNTPStartTime
17067         {
17068                 static constexpr const char* name() {return "enhancedRNTPStartTime_t";}
17069                 using parent_t = EnhancedRNTPStartTime;
17070                 static constexpr bool optional = true;
17071
17072         };
17073         enhancedRNTPStartTime_t& set_enhancedRNTPStartTime() { enhancedRNTPStartTime.setpresent(true); return enhancedRNTPStartTime;}
17074         enhancedRNTPStartTime_t const* get_enhancedRNTPStartTime() const {return enhancedRNTPStartTime.is_valid() ? &enhancedRNTPStartTime : nullptr;}
17075         struct iE_Extensions_t : ProtocolExtensionContainer<EnhancedRNTP_ExtIEs>
17076         {
17077                 static constexpr const char* name() {return "iE_Extensions_t";}
17078                 using parent_t = ProtocolExtensionContainer<EnhancedRNTP_ExtIEs>;
17079                 static constexpr bool optional = true;
17080
17081         };
17082         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
17083         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
17084         template<typename V> void decode(V& v)
17085         {
17086                 v(enhancedRNTPBitmap);
17087                 v(rNTP_High_Power_Threshold);
17088                 v(enhancedRNTPStartTime);
17089                 v(iE_Extensions);
17090
17091         };
17092         template<typename V> void encode(V& v) const
17093         {
17094                 v(enhancedRNTPBitmap);
17095                 v(rNTP_High_Power_Threshold);
17096                 v(enhancedRNTPStartTime);
17097                 v(iE_Extensions);
17098
17099         };
17100         void clear()
17101         {
17102                 enhancedRNTPBitmap.clear();
17103                 rNTP_High_Power_Threshold.clear();
17104                 enhancedRNTPStartTime.clear();
17105                 iE_Extensions.clear();
17106
17107         };
17108         private:
17109         enhancedRNTPBitmap_t    enhancedRNTPBitmap;
17110         rNTP_High_Power_Threshold_t     rNTP_High_Power_Threshold;
17111         enhancedRNTPStartTime_t enhancedRNTPStartTime;
17112         iE_Extensions_t iE_Extensions;
17113
17114 };
17115 /*
17116 EventType ::= ENUMERATED{
17117         change-of-serving-cell,
17118         ...
17119 }
17120 */
17121
17122 struct EventType : asn::enumerated<1, 0, true>
17123 {
17124         static constexpr const char* name() {return "EventType";}
17125         using parent_t = asn::enumerated<1, 0, true>;
17126         typedef enum {
17127                 change_of_serving_cell
17128         } index_t;
17129
17130 };
17131
17132 /*
17133 ExpectedActivityPeriod ::= INTEGER (1..30|40|50|60|80|100|120|150|180|181,...)
17134 */
17135
17136 struct ExpectedActivityPeriod : asn::integer<>
17137 {
17138         using constraint_t = asn::constraints<true,asn::span<1, 30>,asn::one<40>,asn::one<50>,asn::one<60>,asn::one<80>,asn::one<100>,asn::one<120>,asn::one<150>,asn::one<180>,asn::one<181>>;
17139         static constexpr const char* name() {return "ExpectedActivityPeriod";}
17140         using parent_t = asn::integer<>;
17141
17142 };
17143
17144 /*
17145 ExpectedHOInterval ::= ENUMERATED {
17146         sec15, sec30, sec60, sec90, sec120, sec180, long-time,
17147         ...
17148 }
17149 */
17150
17151 struct ExpectedHOInterval : asn::enumerated<7, 0, true>
17152 {
17153         static constexpr const char* name() {return "ExpectedHOInterval";}
17154         using parent_t = asn::enumerated<7, 0, true>;
17155         typedef enum {
17156                 sec15
17157                 ,sec30
17158                 ,sec60
17159                 ,sec90
17160                 ,sec120
17161                 ,sec180
17162                 ,long_time
17163         } index_t;
17164
17165 };
17166
17167 /*
17168 ExpectedIdlePeriod ::= INTEGER (1..30|40|50|60|80|100|120|150|180|181,...)
17169 */
17170
17171 struct ExpectedIdlePeriod : asn::integer<>
17172 {
17173         using constraint_t = asn::constraints<true,asn::span<1, 30>,asn::one<40>,asn::one<50>,asn::one<60>,asn::one<80>,asn::one<100>,asn::one<120>,asn::one<150>,asn::one<180>,asn::one<181>>;
17174         static constexpr const char* name() {return "ExpectedIdlePeriod";}
17175         using parent_t = asn::integer<>;
17176
17177 };
17178
17179 /*
17180 SourceOfUEActivityBehaviourInformation ::= ENUMERATED {
17181         subscription-information,
17182         statistics,
17183         ...
17184 }
17185 */
17186
17187 struct SourceOfUEActivityBehaviourInformation : asn::enumerated<2, 0, true>
17188 {
17189         static constexpr const char* name() {return "SourceOfUEActivityBehaviourInformation";}
17190         using parent_t = asn::enumerated<2, 0, true>;
17191         typedef enum {
17192                 subscription_information
17193                 ,statistics
17194         } index_t;
17195
17196 };
17197
17198 /*
17199 ExpectedUEActivityBehaviour-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
17200         ...
17201 }
17202 */
17203
17204 struct ExpectedUEActivityBehaviour_ExtIEs
17205 {
17206         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
17207         {
17208                 size_t get_index() const {return type;}
17209                 bool is_unknown() const { return type == 1; }
17210                 void clear() {type = 0;}
17211                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
17212                 template<typename V>  bool decode(V& v)
17213                 {
17214                         clear();
17215                         if(!v(ref_nested())) return false;
17216                         { type = 1; return true;}
17217                         return false;
17218
17219                 }
17220                 template<typename V> bool encode(V& v) const
17221                 {
17222                         return v(ref_nested());
17223
17224                 }
17225                 protected:
17226                 template<typename V>  bool decode(size_t index, V& v)
17227                 {
17228                         clear();
17229                         switch(index)
17230                         {
17231                         case 1: type = 1; return v(ref_nested());
17232                         ref_nested().clear();
17233                         }
17234                         return false;
17235
17236                 }
17237                 template<typename V> bool encode(size_t index, V& v) const
17238                 {
17239                         if(index != type) {return false;} return v(ref_nested());
17240
17241                 }
17242                 private:
17243                 size_t type {0};
17244
17245         };
17246         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
17247         {
17248                 size_t get_index() const {return type;}
17249                 bool is_unknown() const { return type == 1; }
17250                 void clear() {type = 0;}
17251                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
17252                 template<typename V>  bool decode(V& v)
17253                 {
17254                         clear();
17255                         if(!v(ref_nested())) return false;
17256                         { type = 1; return true;}
17257                         return false;
17258
17259                 }
17260                 template<typename V> bool encode(V& v) const
17261                 {
17262                         return v(ref_nested());
17263
17264                 }
17265                 protected:
17266                 template<typename V>  bool decode(size_t index, V& v)
17267                 {
17268                         clear();
17269                         switch(index)
17270                         {
17271                         case 1: type = 1; return v(ref_nested());
17272                         ref_nested().clear();
17273                         }
17274                         return false;
17275
17276                 }
17277                 template<typename V> bool encode(size_t index, V& v) const
17278                 {
17279                         if(index != type) {return false;} return v(ref_nested());
17280
17281                 }
17282                 private:
17283                 size_t type {0};
17284
17285         };
17286         struct Extension_t : asn::typefield<true>
17287         {
17288                 ~Extension_t()  {clear();}
17289                 size_t get_index() const {return type;}
17290                 bool is_unknown() const { return type == 1; }
17291                 void clear()
17292                 {
17293                         type = 0; ref_nested().clear();
17294                 }
17295                 template<typename V> static inline void enumerate(V& v)
17296                 {
17297
17298                 }
17299                 protected:
17300                 template<typename V> bool decode(size_t index, V& v)
17301                 {
17302                         clear();
17303                         switch(index)
17304                         {
17305                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
17306                         }
17307                         return false;
17308
17309                 }
17310                 template<typename V> bool encode(size_t index, V& v) const
17311                 {
17312                         if(index != type) return false;
17313                         return false;
17314
17315                 }
17316                 private:
17317                 size_t type {0};
17318
17319         };
17320         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
17321         {
17322                 size_t get_index() const {return type;}
17323                 bool is_unknown() const { return type == 1; }
17324                 void clear() {type = 0;}
17325                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
17326                 template<typename V>  bool decode(V& v)
17327                 {
17328                         clear();
17329                         if(!v(ref_nested())) return false;
17330                         { type = 1; return true;}
17331                         return false;
17332
17333                 }
17334                 template<typename V> bool encode(V& v) const
17335                 {
17336                         return v(ref_nested());
17337
17338                 }
17339                 protected:
17340                 template<typename V>  bool decode(size_t index, V& v)
17341                 {
17342                         clear();
17343                         switch(index)
17344                         {
17345                         case 1: type = 1; return v(ref_nested());
17346                         ref_nested().clear();
17347                         }
17348                         return false;
17349
17350                 }
17351                 template<typename V> bool encode(size_t index, V& v) const
17352                 {
17353                         if(index != type) {return false;} return v(ref_nested());
17354
17355                 }
17356                 private:
17357                 size_t type {0};
17358
17359         };
17360
17361 };
17362 /*
17363 ExpectedUEActivityBehaviour ::= SEQUENCE {
17364         expectedActivityPeriod                                  ExpectedActivityPeriod                                  OPTIONAL,
17365         expectedIdlePeriod                                              ExpectedIdlePeriod                                              OPTIONAL,
17366         sourceofUEActivityBehaviourInformation  SourceOfUEActivityBehaviourInformation  OPTIONAL,
17367         iE-Extensions           ProtocolExtensionContainer { {ExpectedUEActivityBehaviour-ExtIEs} } OPTIONAL,
17368         ...
17369 }
17370 */
17371
17372 struct ExpectedUEActivityBehaviour : asn::sequence<4, 0, true, 4>
17373 {
17374         static constexpr const char* name() {return "ExpectedUEActivityBehaviour";}
17375         using parent_t = asn::sequence<4, 0, true, 4>;
17376         struct expectedActivityPeriod_t : ExpectedActivityPeriod
17377         {
17378                 static constexpr const char* name() {return "expectedActivityPeriod_t";}
17379                 using parent_t = ExpectedActivityPeriod;
17380                 static constexpr bool optional = true;
17381
17382         };
17383         expectedActivityPeriod_t& set_expectedActivityPeriod() { expectedActivityPeriod.setpresent(true); return expectedActivityPeriod;}
17384         expectedActivityPeriod_t const* get_expectedActivityPeriod() const {return expectedActivityPeriod.is_valid() ? &expectedActivityPeriod : nullptr;}
17385         struct expectedIdlePeriod_t : ExpectedIdlePeriod
17386         {
17387                 static constexpr const char* name() {return "expectedIdlePeriod_t";}
17388                 using parent_t = ExpectedIdlePeriod;
17389                 static constexpr bool optional = true;
17390
17391         };
17392         expectedIdlePeriod_t& set_expectedIdlePeriod() { expectedIdlePeriod.setpresent(true); return expectedIdlePeriod;}
17393         expectedIdlePeriod_t const* get_expectedIdlePeriod() const {return expectedIdlePeriod.is_valid() ? &expectedIdlePeriod : nullptr;}
17394         struct sourceofUEActivityBehaviourInformation_t : SourceOfUEActivityBehaviourInformation
17395         {
17396                 static constexpr const char* name() {return "sourceofUEActivityBehaviourInformation_t";}
17397                 using parent_t = SourceOfUEActivityBehaviourInformation;
17398                 static constexpr bool optional = true;
17399
17400         };
17401         sourceofUEActivityBehaviourInformation_t& set_sourceofUEActivityBehaviourInformation() { sourceofUEActivityBehaviourInformation.setpresent(true); return sourceofUEActivityBehaviourInformation;}
17402         sourceofUEActivityBehaviourInformation_t const* get_sourceofUEActivityBehaviourInformation() const {return sourceofUEActivityBehaviourInformation.is_valid() ? &sourceofUEActivityBehaviourInformation : nullptr;}
17403         struct iE_Extensions_t : ProtocolExtensionContainer<ExpectedUEActivityBehaviour_ExtIEs>
17404         {
17405                 static constexpr const char* name() {return "iE_Extensions_t";}
17406                 using parent_t = ProtocolExtensionContainer<ExpectedUEActivityBehaviour_ExtIEs>;
17407                 static constexpr bool optional = true;
17408
17409         };
17410         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
17411         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
17412         template<typename V> void decode(V& v)
17413         {
17414                 v(expectedActivityPeriod);
17415                 v(expectedIdlePeriod);
17416                 v(sourceofUEActivityBehaviourInformation);
17417                 v(iE_Extensions);
17418
17419         };
17420         template<typename V> void encode(V& v) const
17421         {
17422                 v(expectedActivityPeriod);
17423                 v(expectedIdlePeriod);
17424                 v(sourceofUEActivityBehaviourInformation);
17425                 v(iE_Extensions);
17426
17427         };
17428         void clear()
17429         {
17430                 expectedActivityPeriod.clear();
17431                 expectedIdlePeriod.clear();
17432                 sourceofUEActivityBehaviourInformation.clear();
17433                 iE_Extensions.clear();
17434
17435         };
17436         private:
17437         expectedActivityPeriod_t        expectedActivityPeriod;
17438         expectedIdlePeriod_t    expectedIdlePeriod;
17439         sourceofUEActivityBehaviourInformation_t        sourceofUEActivityBehaviourInformation;
17440         iE_Extensions_t iE_Extensions;
17441
17442 };
17443 /*
17444 ExpectedUEBehaviour-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
17445         ...
17446 }
17447 */
17448
17449 struct ExpectedUEBehaviour_ExtIEs
17450 {
17451         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
17452         {
17453                 size_t get_index() const {return type;}
17454                 bool is_unknown() const { return type == 1; }
17455                 void clear() {type = 0;}
17456                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
17457                 template<typename V>  bool decode(V& v)
17458                 {
17459                         clear();
17460                         if(!v(ref_nested())) return false;
17461                         { type = 1; return true;}
17462                         return false;
17463
17464                 }
17465                 template<typename V> bool encode(V& v) const
17466                 {
17467                         return v(ref_nested());
17468
17469                 }
17470                 protected:
17471                 template<typename V>  bool decode(size_t index, V& v)
17472                 {
17473                         clear();
17474                         switch(index)
17475                         {
17476                         case 1: type = 1; return v(ref_nested());
17477                         ref_nested().clear();
17478                         }
17479                         return false;
17480
17481                 }
17482                 template<typename V> bool encode(size_t index, V& v) const
17483                 {
17484                         if(index != type) {return false;} return v(ref_nested());
17485
17486                 }
17487                 private:
17488                 size_t type {0};
17489
17490         };
17491         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
17492         {
17493                 size_t get_index() const {return type;}
17494                 bool is_unknown() const { return type == 1; }
17495                 void clear() {type = 0;}
17496                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
17497                 template<typename V>  bool decode(V& v)
17498                 {
17499                         clear();
17500                         if(!v(ref_nested())) return false;
17501                         { type = 1; return true;}
17502                         return false;
17503
17504                 }
17505                 template<typename V> bool encode(V& v) const
17506                 {
17507                         return v(ref_nested());
17508
17509                 }
17510                 protected:
17511                 template<typename V>  bool decode(size_t index, V& v)
17512                 {
17513                         clear();
17514                         switch(index)
17515                         {
17516                         case 1: type = 1; return v(ref_nested());
17517                         ref_nested().clear();
17518                         }
17519                         return false;
17520
17521                 }
17522                 template<typename V> bool encode(size_t index, V& v) const
17523                 {
17524                         if(index != type) {return false;} return v(ref_nested());
17525
17526                 }
17527                 private:
17528                 size_t type {0};
17529
17530         };
17531         struct Extension_t : asn::typefield<true>
17532         {
17533                 ~Extension_t()  {clear();}
17534                 size_t get_index() const {return type;}
17535                 bool is_unknown() const { return type == 1; }
17536                 void clear()
17537                 {
17538                         type = 0; ref_nested().clear();
17539                 }
17540                 template<typename V> static inline void enumerate(V& v)
17541                 {
17542
17543                 }
17544                 protected:
17545                 template<typename V> bool decode(size_t index, V& v)
17546                 {
17547                         clear();
17548                         switch(index)
17549                         {
17550                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
17551                         }
17552                         return false;
17553
17554                 }
17555                 template<typename V> bool encode(size_t index, V& v) const
17556                 {
17557                         if(index != type) return false;
17558                         return false;
17559
17560                 }
17561                 private:
17562                 size_t type {0};
17563
17564         };
17565         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
17566         {
17567                 size_t get_index() const {return type;}
17568                 bool is_unknown() const { return type == 1; }
17569                 void clear() {type = 0;}
17570                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
17571                 template<typename V>  bool decode(V& v)
17572                 {
17573                         clear();
17574                         if(!v(ref_nested())) return false;
17575                         { type = 1; return true;}
17576                         return false;
17577
17578                 }
17579                 template<typename V> bool encode(V& v) const
17580                 {
17581                         return v(ref_nested());
17582
17583                 }
17584                 protected:
17585                 template<typename V>  bool decode(size_t index, V& v)
17586                 {
17587                         clear();
17588                         switch(index)
17589                         {
17590                         case 1: type = 1; return v(ref_nested());
17591                         ref_nested().clear();
17592                         }
17593                         return false;
17594
17595                 }
17596                 template<typename V> bool encode(size_t index, V& v) const
17597                 {
17598                         if(index != type) {return false;} return v(ref_nested());
17599
17600                 }
17601                 private:
17602                 size_t type {0};
17603
17604         };
17605
17606 };
17607 /*
17608 ExpectedUEBehaviour ::= SEQUENCE {
17609         expectedActivity                ExpectedUEActivityBehaviour OPTIONAL,
17610         expectedHOInterval              ExpectedHOInterval                      OPTIONAL,
17611         iE-Extensions                   ProtocolExtensionContainer { {ExpectedUEBehaviour-ExtIEs} } OPTIONAL,
17612         ...
17613 }
17614 */
17615
17616 struct ExpectedUEBehaviour : asn::sequence<3, 0, true, 3>
17617 {
17618         static constexpr const char* name() {return "ExpectedUEBehaviour";}
17619         using parent_t = asn::sequence<3, 0, true, 3>;
17620         struct expectedActivity_t : ExpectedUEActivityBehaviour
17621         {
17622                 static constexpr const char* name() {return "expectedActivity_t";}
17623                 using parent_t = ExpectedUEActivityBehaviour;
17624                 static constexpr bool optional = true;
17625
17626         };
17627         expectedActivity_t& set_expectedActivity() { expectedActivity.setpresent(true); return expectedActivity;}
17628         expectedActivity_t const* get_expectedActivity() const {return expectedActivity.is_valid() ? &expectedActivity : nullptr;}
17629         struct expectedHOInterval_t : ExpectedHOInterval
17630         {
17631                 static constexpr const char* name() {return "expectedHOInterval_t";}
17632                 using parent_t = ExpectedHOInterval;
17633                 static constexpr bool optional = true;
17634
17635         };
17636         expectedHOInterval_t& set_expectedHOInterval() { expectedHOInterval.setpresent(true); return expectedHOInterval;}
17637         expectedHOInterval_t const* get_expectedHOInterval() const {return expectedHOInterval.is_valid() ? &expectedHOInterval : nullptr;}
17638         struct iE_Extensions_t : ProtocolExtensionContainer<ExpectedUEBehaviour_ExtIEs>
17639         {
17640                 static constexpr const char* name() {return "iE_Extensions_t";}
17641                 using parent_t = ProtocolExtensionContainer<ExpectedUEBehaviour_ExtIEs>;
17642                 static constexpr bool optional = true;
17643
17644         };
17645         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
17646         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
17647         template<typename V> void decode(V& v)
17648         {
17649                 v(expectedActivity);
17650                 v(expectedHOInterval);
17651                 v(iE_Extensions);
17652
17653         };
17654         template<typename V> void encode(V& v) const
17655         {
17656                 v(expectedActivity);
17657                 v(expectedHOInterval);
17658                 v(iE_Extensions);
17659
17660         };
17661         void clear()
17662         {
17663                 expectedActivity.clear();
17664                 expectedHOInterval.clear();
17665                 iE_Extensions.clear();
17666
17667         };
17668         private:
17669         expectedActivity_t      expectedActivity;
17670         expectedHOInterval_t    expectedHOInterval;
17671         iE_Extensions_t iE_Extensions;
17672
17673 };
17674 /*
17675 UL-InterferenceOverloadIndication-Item ::= ENUMERATED {
17676         high-interference,
17677         medium-interference,
17678         low-interference,
17679         ...
17680 }
17681 */
17682
17683 struct UL_InterferenceOverloadIndication_Item : asn::enumerated<3, 0, true>
17684 {
17685         static constexpr const char* name() {return "UL-InterferenceOverloadIndication-Item";}
17686         using parent_t = asn::enumerated<3, 0, true>;
17687         typedef enum {
17688                 high_interference
17689                 ,medium_interference
17690                 ,low_interference
17691         } index_t;
17692
17693 };
17694
17695 /*
17696 UL-InterferenceOverloadIndication ::= SEQUENCE (SIZE(1..maxnoofPRBs)) OF UL-InterferenceOverloadIndication-Item
17697 */
17698
17699 struct UL_InterferenceOverloadIndication_elm : UL_InterferenceOverloadIndication_Item
17700 {
17701         static constexpr const char* name() {return "UL_InterferenceOverloadIndication_elm";}
17702         using parent_t = UL_InterferenceOverloadIndication_Item;
17703
17704 };
17705 struct UL_InterferenceOverloadIndication : asn::sequenceof<UL_InterferenceOverloadIndication_elm>
17706 {
17707         static constexpr const char* name() {return "UL-InterferenceOverloadIndication";}
17708         using parent_t = asn::sequenceof<UL_InterferenceOverloadIndication_elm>;
17709         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofPRBs >>;
17710
17711 };
17712 /*
17713 ExtendedULInterferenceOverloadInfo-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
17714         ...
17715 }
17716 */
17717
17718 struct ExtendedULInterferenceOverloadInfo_ExtIEs
17719 {
17720         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
17721         {
17722                 size_t get_index() const {return type;}
17723                 bool is_unknown() const { return type == 1; }
17724                 void clear() {type = 0;}
17725                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
17726                 template<typename V>  bool decode(V& v)
17727                 {
17728                         clear();
17729                         if(!v(ref_nested())) return false;
17730                         { type = 1; return true;}
17731                         return false;
17732
17733                 }
17734                 template<typename V> bool encode(V& v) const
17735                 {
17736                         return v(ref_nested());
17737
17738                 }
17739                 protected:
17740                 template<typename V>  bool decode(size_t index, V& v)
17741                 {
17742                         clear();
17743                         switch(index)
17744                         {
17745                         case 1: type = 1; return v(ref_nested());
17746                         ref_nested().clear();
17747                         }
17748                         return false;
17749
17750                 }
17751                 template<typename V> bool encode(size_t index, V& v) const
17752                 {
17753                         if(index != type) {return false;} return v(ref_nested());
17754
17755                 }
17756                 private:
17757                 size_t type {0};
17758
17759         };
17760         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
17761         {
17762                 size_t get_index() const {return type;}
17763                 bool is_unknown() const { return type == 1; }
17764                 void clear() {type = 0;}
17765                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
17766                 template<typename V>  bool decode(V& v)
17767                 {
17768                         clear();
17769                         if(!v(ref_nested())) return false;
17770                         { type = 1; return true;}
17771                         return false;
17772
17773                 }
17774                 template<typename V> bool encode(V& v) const
17775                 {
17776                         return v(ref_nested());
17777
17778                 }
17779                 protected:
17780                 template<typename V>  bool decode(size_t index, V& v)
17781                 {
17782                         clear();
17783                         switch(index)
17784                         {
17785                         case 1: type = 1; return v(ref_nested());
17786                         ref_nested().clear();
17787                         }
17788                         return false;
17789
17790                 }
17791                 template<typename V> bool encode(size_t index, V& v) const
17792                 {
17793                         if(index != type) {return false;} return v(ref_nested());
17794
17795                 }
17796                 private:
17797                 size_t type {0};
17798
17799         };
17800         struct Extension_t : asn::typefield<true>
17801         {
17802                 ~Extension_t()  {clear();}
17803                 size_t get_index() const {return type;}
17804                 bool is_unknown() const { return type == 1; }
17805                 void clear()
17806                 {
17807                         type = 0; ref_nested().clear();
17808                 }
17809                 template<typename V> static inline void enumerate(V& v)
17810                 {
17811
17812                 }
17813                 protected:
17814                 template<typename V> bool decode(size_t index, V& v)
17815                 {
17816                         clear();
17817                         switch(index)
17818                         {
17819                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
17820                         }
17821                         return false;
17822
17823                 }
17824                 template<typename V> bool encode(size_t index, V& v) const
17825                 {
17826                         if(index != type) return false;
17827                         return false;
17828
17829                 }
17830                 private:
17831                 size_t type {0};
17832
17833         };
17834         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
17835         {
17836                 size_t get_index() const {return type;}
17837                 bool is_unknown() const { return type == 1; }
17838                 void clear() {type = 0;}
17839                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
17840                 template<typename V>  bool decode(V& v)
17841                 {
17842                         clear();
17843                         if(!v(ref_nested())) return false;
17844                         { type = 1; return true;}
17845                         return false;
17846
17847                 }
17848                 template<typename V> bool encode(V& v) const
17849                 {
17850                         return v(ref_nested());
17851
17852                 }
17853                 protected:
17854                 template<typename V>  bool decode(size_t index, V& v)
17855                 {
17856                         clear();
17857                         switch(index)
17858                         {
17859                         case 1: type = 1; return v(ref_nested());
17860                         ref_nested().clear();
17861                         }
17862                         return false;
17863
17864                 }
17865                 template<typename V> bool encode(size_t index, V& v) const
17866                 {
17867                         if(index != type) {return false;} return v(ref_nested());
17868
17869                 }
17870                 private:
17871                 size_t type {0};
17872
17873         };
17874
17875 };
17876 /*
17877 ExtendedULInterferenceOverloadInfo ::= SEQUENCE {
17878         associatedSubframes                                                     BIT STRING (SIZE (5)),
17879         extended-ul-InterferenceOverloadIndication      UL-InterferenceOverloadIndication,
17880         iE-Extensions                                                           ProtocolExtensionContainer { {ExtendedULInterferenceOverloadInfo-ExtIEs} } OPTIONAL,
17881         ...
17882 }
17883 */
17884
17885 struct ExtendedULInterferenceOverloadInfo : asn::sequence<3, 0, true, 1>
17886 {
17887         static constexpr const char* name() {return "ExtendedULInterferenceOverloadInfo";}
17888         using parent_t = asn::sequence<3, 0, true, 1>;
17889         struct associatedSubframes_t : asn::bstring<>
17890         {
17891                 using constraint_t = asn::constraints<false,asn::one<5>>;
17892                 static constexpr const char* name() {return "associatedSubframes_t";}
17893                 using parent_t = asn::bstring<>;
17894
17895         };
17896
17897         associatedSubframes_t& ref_associatedSubframes() {return associatedSubframes;}
17898         associatedSubframes_t const& ref_associatedSubframes() const {return associatedSubframes;}
17899         struct extended_ul_InterferenceOverloadIndication_t : UL_InterferenceOverloadIndication
17900         {
17901                 static constexpr const char* name() {return "extended_ul_InterferenceOverloadIndication_t";}
17902                 using parent_t = UL_InterferenceOverloadIndication;
17903
17904         };
17905         extended_ul_InterferenceOverloadIndication_t& ref_extended_ul_InterferenceOverloadIndication() {return extended_ul_InterferenceOverloadIndication;}
17906         extended_ul_InterferenceOverloadIndication_t const& ref_extended_ul_InterferenceOverloadIndication() const {return extended_ul_InterferenceOverloadIndication;}
17907         struct iE_Extensions_t : ProtocolExtensionContainer<ExtendedULInterferenceOverloadInfo_ExtIEs>
17908         {
17909                 static constexpr const char* name() {return "iE_Extensions_t";}
17910                 using parent_t = ProtocolExtensionContainer<ExtendedULInterferenceOverloadInfo_ExtIEs>;
17911                 static constexpr bool optional = true;
17912
17913         };
17914         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
17915         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
17916         template<typename V> void decode(V& v)
17917         {
17918                 v(associatedSubframes);
17919                 v(extended_ul_InterferenceOverloadIndication);
17920                 v(iE_Extensions);
17921
17922         };
17923         template<typename V> void encode(V& v) const
17924         {
17925                 v(associatedSubframes);
17926                 v(extended_ul_InterferenceOverloadIndication);
17927                 v(iE_Extensions);
17928
17929         };
17930         void clear()
17931         {
17932                 associatedSubframes.clear();
17933                 extended_ul_InterferenceOverloadIndication.clear();
17934                 iE_Extensions.clear();
17935
17936         };
17937         private:
17938         associatedSubframes_t   associatedSubframes;
17939         extended_ul_InterferenceOverloadIndication_t    extended_ul_InterferenceOverloadIndication;
17940         iE_Extensions_t iE_Extensions;
17941
17942 };
17943 /*
17944 FiveGS-TAC ::= OCTET STRING (SIZE (3))
17945 */
17946
17947 struct FiveGS_TAC : asn::ostring<>
17948 {
17949         using constraint_t = asn::constraints<false,asn::one<3>>;
17950         static constexpr const char* name() {return "FiveGS-TAC";}
17951         using parent_t = asn::ostring<>;
17952
17953 };
17954
17955 /*
17956 ForbiddenInterRATs ::= ENUMERATED {
17957         all,
17958         geran,
17959         utran,
17960         cdma2000,
17961         ...,
17962         geranandutran,
17963         cdma2000andutran
17964
17965 }
17966 */
17967
17968 struct ForbiddenInterRATs : asn::enumerated<6, 2, true>
17969 {
17970         static constexpr const char* name() {return "ForbiddenInterRATs";}
17971         using parent_t = asn::enumerated<6, 2, true>;
17972         typedef enum {
17973                 all
17974                 ,geran
17975                 ,utran
17976                 ,cdma2000
17977                 ,geranandutran
17978                 ,cdma2000andutran
17979         } index_t;
17980
17981 };
17982
17983 /*
17984 LAC                                     ::= OCTET STRING (SIZE (2)) --(EXCEPT ('0000'H|'FFFE'H))
17985 */
17986
17987 struct LAC : asn::ostring<>
17988 {
17989         using constraint_t = asn::constraints<false,asn::one<2>>;
17990         static constexpr const char* name() {return "LAC";}
17991         using parent_t = asn::ostring<>;
17992
17993 };
17994
17995 /*
17996 ForbiddenLACs ::= SEQUENCE (SIZE(1..maxnoofForbLACs)) OF LAC
17997 */
17998
17999 struct ForbiddenLACs_elm : LAC
18000 {
18001         static constexpr const char* name() {return "ForbiddenLACs_elm";}
18002         using parent_t = LAC;
18003
18004 };
18005 struct ForbiddenLACs : asn::sequenceof<ForbiddenLACs_elm>
18006 {
18007         static constexpr const char* name() {return "ForbiddenLACs";}
18008         using parent_t = asn::sequenceof<ForbiddenLACs_elm>;
18009         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofForbLACs >>;
18010
18011 };
18012 /*
18013 ForbiddenLAs-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
18014         ...
18015 }
18016 */
18017
18018 struct ForbiddenLAs_Item_ExtIEs
18019 {
18020         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
18021         {
18022                 size_t get_index() const {return type;}
18023                 bool is_unknown() const { return type == 1; }
18024                 void clear() {type = 0;}
18025                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
18026                 template<typename V>  bool decode(V& v)
18027                 {
18028                         clear();
18029                         if(!v(ref_nested())) return false;
18030                         { type = 1; return true;}
18031                         return false;
18032
18033                 }
18034                 template<typename V> bool encode(V& v) const
18035                 {
18036                         return v(ref_nested());
18037
18038                 }
18039                 protected:
18040                 template<typename V>  bool decode(size_t index, V& v)
18041                 {
18042                         clear();
18043                         switch(index)
18044                         {
18045                         case 1: type = 1; return v(ref_nested());
18046                         ref_nested().clear();
18047                         }
18048                         return false;
18049
18050                 }
18051                 template<typename V> bool encode(size_t index, V& v) const
18052                 {
18053                         if(index != type) {return false;} return v(ref_nested());
18054
18055                 }
18056                 private:
18057                 size_t type {0};
18058
18059         };
18060         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
18061         {
18062                 size_t get_index() const {return type;}
18063                 bool is_unknown() const { return type == 1; }
18064                 void clear() {type = 0;}
18065                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
18066                 template<typename V>  bool decode(V& v)
18067                 {
18068                         clear();
18069                         if(!v(ref_nested())) return false;
18070                         { type = 1; return true;}
18071                         return false;
18072
18073                 }
18074                 template<typename V> bool encode(V& v) const
18075                 {
18076                         return v(ref_nested());
18077
18078                 }
18079                 protected:
18080                 template<typename V>  bool decode(size_t index, V& v)
18081                 {
18082                         clear();
18083                         switch(index)
18084                         {
18085                         case 1: type = 1; return v(ref_nested());
18086                         ref_nested().clear();
18087                         }
18088                         return false;
18089
18090                 }
18091                 template<typename V> bool encode(size_t index, V& v) const
18092                 {
18093                         if(index != type) {return false;} return v(ref_nested());
18094
18095                 }
18096                 private:
18097                 size_t type {0};
18098
18099         };
18100         struct Extension_t : asn::typefield<true>
18101         {
18102                 ~Extension_t()  {clear();}
18103                 size_t get_index() const {return type;}
18104                 bool is_unknown() const { return type == 1; }
18105                 void clear()
18106                 {
18107                         type = 0; ref_nested().clear();
18108                 }
18109                 template<typename V> static inline void enumerate(V& v)
18110                 {
18111
18112                 }
18113                 protected:
18114                 template<typename V> bool decode(size_t index, V& v)
18115                 {
18116                         clear();
18117                         switch(index)
18118                         {
18119                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
18120                         }
18121                         return false;
18122
18123                 }
18124                 template<typename V> bool encode(size_t index, V& v) const
18125                 {
18126                         if(index != type) return false;
18127                         return false;
18128
18129                 }
18130                 private:
18131                 size_t type {0};
18132
18133         };
18134         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
18135         {
18136                 size_t get_index() const {return type;}
18137                 bool is_unknown() const { return type == 1; }
18138                 void clear() {type = 0;}
18139                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
18140                 template<typename V>  bool decode(V& v)
18141                 {
18142                         clear();
18143                         if(!v(ref_nested())) return false;
18144                         { type = 1; return true;}
18145                         return false;
18146
18147                 }
18148                 template<typename V> bool encode(V& v) const
18149                 {
18150                         return v(ref_nested());
18151
18152                 }
18153                 protected:
18154                 template<typename V>  bool decode(size_t index, V& v)
18155                 {
18156                         clear();
18157                         switch(index)
18158                         {
18159                         case 1: type = 1; return v(ref_nested());
18160                         ref_nested().clear();
18161                         }
18162                         return false;
18163
18164                 }
18165                 template<typename V> bool encode(size_t index, V& v) const
18166                 {
18167                         if(index != type) {return false;} return v(ref_nested());
18168
18169                 }
18170                 private:
18171                 size_t type {0};
18172
18173         };
18174
18175 };
18176 /*
18177 ForbiddenLAs-Item ::= SEQUENCE {
18178         pLMN-Identity           PLMN-Identity,
18179         forbiddenLACs           ForbiddenLACs,
18180         iE-Extensions           ProtocolExtensionContainer { {ForbiddenLAs-Item-ExtIEs} } OPTIONAL,
18181         ...
18182 }
18183 */
18184
18185 struct ForbiddenLAs_Item : asn::sequence<3, 0, true, 1>
18186 {
18187         static constexpr const char* name() {return "ForbiddenLAs-Item";}
18188         using parent_t = asn::sequence<3, 0, true, 1>;
18189         struct pLMN_Identity_t : PLMN_Identity
18190         {
18191                 static constexpr const char* name() {return "pLMN_Identity_t";}
18192                 using parent_t = PLMN_Identity;
18193
18194         };
18195         pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
18196         pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
18197         struct forbiddenLACs_t : ForbiddenLACs
18198         {
18199                 static constexpr const char* name() {return "forbiddenLACs_t";}
18200                 using parent_t = ForbiddenLACs;
18201
18202         };
18203         forbiddenLACs_t& ref_forbiddenLACs() {return forbiddenLACs;}
18204         forbiddenLACs_t const& ref_forbiddenLACs() const {return forbiddenLACs;}
18205         struct iE_Extensions_t : ProtocolExtensionContainer<ForbiddenLAs_Item_ExtIEs>
18206         {
18207                 static constexpr const char* name() {return "iE_Extensions_t";}
18208                 using parent_t = ProtocolExtensionContainer<ForbiddenLAs_Item_ExtIEs>;
18209                 static constexpr bool optional = true;
18210
18211         };
18212         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
18213         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
18214         template<typename V> void decode(V& v)
18215         {
18216                 v(pLMN_Identity);
18217                 v(forbiddenLACs);
18218                 v(iE_Extensions);
18219
18220         };
18221         template<typename V> void encode(V& v) const
18222         {
18223                 v(pLMN_Identity);
18224                 v(forbiddenLACs);
18225                 v(iE_Extensions);
18226
18227         };
18228         void clear()
18229         {
18230                 pLMN_Identity.clear();
18231                 forbiddenLACs.clear();
18232                 iE_Extensions.clear();
18233
18234         };
18235         private:
18236         pLMN_Identity_t pLMN_Identity;
18237         forbiddenLACs_t forbiddenLACs;
18238         iE_Extensions_t iE_Extensions;
18239
18240 };
18241 /*
18242 ForbiddenLAs ::= SEQUENCE (SIZE(1..maxnoofEPLMNsPlusOne)) OF ForbiddenLAs-Item
18243 */
18244
18245 struct ForbiddenLAs_elm : ForbiddenLAs_Item
18246 {
18247         static constexpr const char* name() {return "ForbiddenLAs_elm";}
18248         using parent_t = ForbiddenLAs_Item;
18249
18250 };
18251 struct ForbiddenLAs : asn::sequenceof<ForbiddenLAs_elm>
18252 {
18253         static constexpr const char* name() {return "ForbiddenLAs";}
18254         using parent_t = asn::sequenceof<ForbiddenLAs_elm>;
18255         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofEPLMNsPlusOne >>;
18256
18257 };
18258 /*
18259 ForbiddenTACs ::= SEQUENCE (SIZE(1..maxnoofForbTACs)) OF TAC
18260 */
18261
18262 struct ForbiddenTACs_elm : TAC
18263 {
18264         static constexpr const char* name() {return "ForbiddenTACs_elm";}
18265         using parent_t = TAC;
18266
18267 };
18268 struct ForbiddenTACs : asn::sequenceof<ForbiddenTACs_elm>
18269 {
18270         static constexpr const char* name() {return "ForbiddenTACs";}
18271         using parent_t = asn::sequenceof<ForbiddenTACs_elm>;
18272         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofForbTACs >>;
18273
18274 };
18275 /*
18276 ForbiddenTAs-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
18277         ...
18278 }
18279 */
18280
18281 struct ForbiddenTAs_Item_ExtIEs
18282 {
18283         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
18284         {
18285                 size_t get_index() const {return type;}
18286                 bool is_unknown() const { return type == 1; }
18287                 void clear() {type = 0;}
18288                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
18289                 template<typename V>  bool decode(V& v)
18290                 {
18291                         clear();
18292                         if(!v(ref_nested())) return false;
18293                         { type = 1; return true;}
18294                         return false;
18295
18296                 }
18297                 template<typename V> bool encode(V& v) const
18298                 {
18299                         return v(ref_nested());
18300
18301                 }
18302                 protected:
18303                 template<typename V>  bool decode(size_t index, V& v)
18304                 {
18305                         clear();
18306                         switch(index)
18307                         {
18308                         case 1: type = 1; return v(ref_nested());
18309                         ref_nested().clear();
18310                         }
18311                         return false;
18312
18313                 }
18314                 template<typename V> bool encode(size_t index, V& v) const
18315                 {
18316                         if(index != type) {return false;} return v(ref_nested());
18317
18318                 }
18319                 private:
18320                 size_t type {0};
18321
18322         };
18323         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
18324         {
18325                 size_t get_index() const {return type;}
18326                 bool is_unknown() const { return type == 1; }
18327                 void clear() {type = 0;}
18328                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
18329                 template<typename V>  bool decode(V& v)
18330                 {
18331                         clear();
18332                         if(!v(ref_nested())) return false;
18333                         { type = 1; return true;}
18334                         return false;
18335
18336                 }
18337                 template<typename V> bool encode(V& v) const
18338                 {
18339                         return v(ref_nested());
18340
18341                 }
18342                 protected:
18343                 template<typename V>  bool decode(size_t index, V& v)
18344                 {
18345                         clear();
18346                         switch(index)
18347                         {
18348                         case 1: type = 1; return v(ref_nested());
18349                         ref_nested().clear();
18350                         }
18351                         return false;
18352
18353                 }
18354                 template<typename V> bool encode(size_t index, V& v) const
18355                 {
18356                         if(index != type) {return false;} return v(ref_nested());
18357
18358                 }
18359                 private:
18360                 size_t type {0};
18361
18362         };
18363         struct Extension_t : asn::typefield<true>
18364         {
18365                 ~Extension_t()  {clear();}
18366                 size_t get_index() const {return type;}
18367                 bool is_unknown() const { return type == 1; }
18368                 void clear()
18369                 {
18370                         type = 0; ref_nested().clear();
18371                 }
18372                 template<typename V> static inline void enumerate(V& v)
18373                 {
18374
18375                 }
18376                 protected:
18377                 template<typename V> bool decode(size_t index, V& v)
18378                 {
18379                         clear();
18380                         switch(index)
18381                         {
18382                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
18383                         }
18384                         return false;
18385
18386                 }
18387                 template<typename V> bool encode(size_t index, V& v) const
18388                 {
18389                         if(index != type) return false;
18390                         return false;
18391
18392                 }
18393                 private:
18394                 size_t type {0};
18395
18396         };
18397         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
18398         {
18399                 size_t get_index() const {return type;}
18400                 bool is_unknown() const { return type == 1; }
18401                 void clear() {type = 0;}
18402                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
18403                 template<typename V>  bool decode(V& v)
18404                 {
18405                         clear();
18406                         if(!v(ref_nested())) return false;
18407                         { type = 1; return true;}
18408                         return false;
18409
18410                 }
18411                 template<typename V> bool encode(V& v) const
18412                 {
18413                         return v(ref_nested());
18414
18415                 }
18416                 protected:
18417                 template<typename V>  bool decode(size_t index, V& v)
18418                 {
18419                         clear();
18420                         switch(index)
18421                         {
18422                         case 1: type = 1; return v(ref_nested());
18423                         ref_nested().clear();
18424                         }
18425                         return false;
18426
18427                 }
18428                 template<typename V> bool encode(size_t index, V& v) const
18429                 {
18430                         if(index != type) {return false;} return v(ref_nested());
18431
18432                 }
18433                 private:
18434                 size_t type {0};
18435
18436         };
18437
18438 };
18439 /*
18440 ForbiddenTAs-Item ::= SEQUENCE {
18441         pLMN-Identity           PLMN-Identity,
18442         forbiddenTACs           ForbiddenTACs,
18443         iE-Extensions           ProtocolExtensionContainer { {ForbiddenTAs-Item-ExtIEs} } OPTIONAL,
18444         ...
18445 }
18446 */
18447
18448 struct ForbiddenTAs_Item : asn::sequence<3, 0, true, 1>
18449 {
18450         static constexpr const char* name() {return "ForbiddenTAs-Item";}
18451         using parent_t = asn::sequence<3, 0, true, 1>;
18452         struct pLMN_Identity_t : PLMN_Identity
18453         {
18454                 static constexpr const char* name() {return "pLMN_Identity_t";}
18455                 using parent_t = PLMN_Identity;
18456
18457         };
18458         pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
18459         pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
18460         struct forbiddenTACs_t : ForbiddenTACs
18461         {
18462                 static constexpr const char* name() {return "forbiddenTACs_t";}
18463                 using parent_t = ForbiddenTACs;
18464
18465         };
18466         forbiddenTACs_t& ref_forbiddenTACs() {return forbiddenTACs;}
18467         forbiddenTACs_t const& ref_forbiddenTACs() const {return forbiddenTACs;}
18468         struct iE_Extensions_t : ProtocolExtensionContainer<ForbiddenTAs_Item_ExtIEs>
18469         {
18470                 static constexpr const char* name() {return "iE_Extensions_t";}
18471                 using parent_t = ProtocolExtensionContainer<ForbiddenTAs_Item_ExtIEs>;
18472                 static constexpr bool optional = true;
18473
18474         };
18475         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
18476         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
18477         template<typename V> void decode(V& v)
18478         {
18479                 v(pLMN_Identity);
18480                 v(forbiddenTACs);
18481                 v(iE_Extensions);
18482
18483         };
18484         template<typename V> void encode(V& v) const
18485         {
18486                 v(pLMN_Identity);
18487                 v(forbiddenTACs);
18488                 v(iE_Extensions);
18489
18490         };
18491         void clear()
18492         {
18493                 pLMN_Identity.clear();
18494                 forbiddenTACs.clear();
18495                 iE_Extensions.clear();
18496
18497         };
18498         private:
18499         pLMN_Identity_t pLMN_Identity;
18500         forbiddenTACs_t forbiddenTACs;
18501         iE_Extensions_t iE_Extensions;
18502
18503 };
18504 /*
18505 ForbiddenTAs ::= SEQUENCE (SIZE(1.. maxnoofEPLMNsPlusOne)) OF ForbiddenTAs-Item
18506 */
18507
18508 struct ForbiddenTAs_elm : ForbiddenTAs_Item
18509 {
18510         static constexpr const char* name() {return "ForbiddenTAs_elm";}
18511         using parent_t = ForbiddenTAs_Item;
18512
18513 };
18514 struct ForbiddenTAs : asn::sequenceof<ForbiddenTAs_elm>
18515 {
18516         static constexpr const char* name() {return "ForbiddenTAs";}
18517         using parent_t = asn::sequenceof<ForbiddenTAs_elm>;
18518         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofEPLMNsPlusOne >>;
18519
18520 };
18521 /*
18522 Fourframes ::= BIT STRING (SIZE (24))
18523 */
18524
18525 struct Fourframes : asn::bstring<>
18526 {
18527         using constraint_t = asn::constraints<false,asn::one<24>>;
18528         static constexpr const char* name() {return "Fourframes";}
18529         using parent_t = asn::bstring<>;
18530
18531 };
18532
18533 /*
18534 FreqBandIndicatorPriority ::= ENUMERATED {
18535         not-broadcasted,
18536         broadcasted,
18537         ...
18538 }
18539 */
18540
18541 struct FreqBandIndicatorPriority : asn::enumerated<2, 0, true>
18542 {
18543         static constexpr const char* name() {return "FreqBandIndicatorPriority";}
18544         using parent_t = asn::enumerated<2, 0, true>;
18545         typedef enum {
18546                 not_broadcasted
18547                 ,broadcasted
18548         } index_t;
18549
18550 };
18551
18552 /*
18553 SupportedSULFreqBandItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
18554         ...
18555 }
18556 */
18557
18558 struct SupportedSULFreqBandItem_ExtIEs
18559 {
18560         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
18561         {
18562                 size_t get_index() const {return type;}
18563                 bool is_unknown() const { return type == 1; }
18564                 void clear() {type = 0;}
18565                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
18566                 template<typename V>  bool decode(V& v)
18567                 {
18568                         clear();
18569                         if(!v(ref_nested())) return false;
18570                         { type = 1; return true;}
18571                         return false;
18572
18573                 }
18574                 template<typename V> bool encode(V& v) const
18575                 {
18576                         return v(ref_nested());
18577
18578                 }
18579                 protected:
18580                 template<typename V>  bool decode(size_t index, V& v)
18581                 {
18582                         clear();
18583                         switch(index)
18584                         {
18585                         case 1: type = 1; return v(ref_nested());
18586                         ref_nested().clear();
18587                         }
18588                         return false;
18589
18590                 }
18591                 template<typename V> bool encode(size_t index, V& v) const
18592                 {
18593                         if(index != type) {return false;} return v(ref_nested());
18594
18595                 }
18596                 private:
18597                 size_t type {0};
18598
18599         };
18600         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
18601         {
18602                 size_t get_index() const {return type;}
18603                 bool is_unknown() const { return type == 1; }
18604                 void clear() {type = 0;}
18605                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
18606                 template<typename V>  bool decode(V& v)
18607                 {
18608                         clear();
18609                         if(!v(ref_nested())) return false;
18610                         { type = 1; return true;}
18611                         return false;
18612
18613                 }
18614                 template<typename V> bool encode(V& v) const
18615                 {
18616                         return v(ref_nested());
18617
18618                 }
18619                 protected:
18620                 template<typename V>  bool decode(size_t index, V& v)
18621                 {
18622                         clear();
18623                         switch(index)
18624                         {
18625                         case 1: type = 1; return v(ref_nested());
18626                         ref_nested().clear();
18627                         }
18628                         return false;
18629
18630                 }
18631                 template<typename V> bool encode(size_t index, V& v) const
18632                 {
18633                         if(index != type) {return false;} return v(ref_nested());
18634
18635                 }
18636                 private:
18637                 size_t type {0};
18638
18639         };
18640         struct Extension_t : asn::typefield<true>
18641         {
18642                 ~Extension_t()  {clear();}
18643                 size_t get_index() const {return type;}
18644                 bool is_unknown() const { return type == 1; }
18645                 void clear()
18646                 {
18647                         type = 0; ref_nested().clear();
18648                 }
18649                 template<typename V> static inline void enumerate(V& v)
18650                 {
18651
18652                 }
18653                 protected:
18654                 template<typename V> bool decode(size_t index, V& v)
18655                 {
18656                         clear();
18657                         switch(index)
18658                         {
18659                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
18660                         }
18661                         return false;
18662
18663                 }
18664                 template<typename V> bool encode(size_t index, V& v) const
18665                 {
18666                         if(index != type) return false;
18667                         return false;
18668
18669                 }
18670                 private:
18671                 size_t type {0};
18672
18673         };
18674         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
18675         {
18676                 size_t get_index() const {return type;}
18677                 bool is_unknown() const { return type == 1; }
18678                 void clear() {type = 0;}
18679                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
18680                 template<typename V>  bool decode(V& v)
18681                 {
18682                         clear();
18683                         if(!v(ref_nested())) return false;
18684                         { type = 1; return true;}
18685                         return false;
18686
18687                 }
18688                 template<typename V> bool encode(V& v) const
18689                 {
18690                         return v(ref_nested());
18691
18692                 }
18693                 protected:
18694                 template<typename V>  bool decode(size_t index, V& v)
18695                 {
18696                         clear();
18697                         switch(index)
18698                         {
18699                         case 1: type = 1; return v(ref_nested());
18700                         ref_nested().clear();
18701                         }
18702                         return false;
18703
18704                 }
18705                 template<typename V> bool encode(size_t index, V& v) const
18706                 {
18707                         if(index != type) {return false;} return v(ref_nested());
18708
18709                 }
18710                 private:
18711                 size_t type {0};
18712
18713         };
18714
18715 };
18716 /*
18717 SupportedSULFreqBandItem ::= SEQUENCE {
18718         freqBandIndicatorNr                     INTEGER (1..1024,...),
18719         iE-Extensions                   ProtocolExtensionContainer { {SupportedSULFreqBandItem-ExtIEs} }                OPTIONAL,
18720         ...
18721 }
18722 */
18723
18724 struct SupportedSULFreqBandItem : asn::sequence<2, 0, true, 1>
18725 {
18726         static constexpr const char* name() {return "SupportedSULFreqBandItem";}
18727         using parent_t = asn::sequence<2, 0, true, 1>;
18728         struct freqBandIndicatorNr_t : asn::integer<>
18729         {
18730                 using constraint_t = asn::constraints<true,asn::span<1, 1024>>;
18731                 static constexpr const char* name() {return "freqBandIndicatorNr_t";}
18732                 using parent_t = asn::integer<>;
18733
18734         };
18735
18736         freqBandIndicatorNr_t& ref_freqBandIndicatorNr() {return freqBandIndicatorNr;}
18737         freqBandIndicatorNr_t const& ref_freqBandIndicatorNr() const {return freqBandIndicatorNr;}
18738         struct iE_Extensions_t : ProtocolExtensionContainer<SupportedSULFreqBandItem_ExtIEs>
18739         {
18740                 static constexpr const char* name() {return "iE_Extensions_t";}
18741                 using parent_t = ProtocolExtensionContainer<SupportedSULFreqBandItem_ExtIEs>;
18742                 static constexpr bool optional = true;
18743
18744         };
18745         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
18746         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
18747         template<typename V> void decode(V& v)
18748         {
18749                 v(freqBandIndicatorNr);
18750                 v(iE_Extensions);
18751
18752         };
18753         template<typename V> void encode(V& v) const
18754         {
18755                 v(freqBandIndicatorNr);
18756                 v(iE_Extensions);
18757
18758         };
18759         void clear()
18760         {
18761                 freqBandIndicatorNr.clear();
18762                 iE_Extensions.clear();
18763
18764         };
18765         private:
18766         freqBandIndicatorNr_t   freqBandIndicatorNr;
18767         iE_Extensions_t iE_Extensions;
18768
18769 };
18770 /*
18771 FreqBandNrItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
18772         ...
18773 }
18774 */
18775
18776 struct FreqBandNrItem_ExtIEs
18777 {
18778         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
18779         {
18780                 size_t get_index() const {return type;}
18781                 bool is_unknown() const { return type == 1; }
18782                 void clear() {type = 0;}
18783                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
18784                 template<typename V>  bool decode(V& v)
18785                 {
18786                         clear();
18787                         if(!v(ref_nested())) return false;
18788                         { type = 1; return true;}
18789                         return false;
18790
18791                 }
18792                 template<typename V> bool encode(V& v) const
18793                 {
18794                         return v(ref_nested());
18795
18796                 }
18797                 protected:
18798                 template<typename V>  bool decode(size_t index, V& v)
18799                 {
18800                         clear();
18801                         switch(index)
18802                         {
18803                         case 1: type = 1; return v(ref_nested());
18804                         ref_nested().clear();
18805                         }
18806                         return false;
18807
18808                 }
18809                 template<typename V> bool encode(size_t index, V& v) const
18810                 {
18811                         if(index != type) {return false;} return v(ref_nested());
18812
18813                 }
18814                 private:
18815                 size_t type {0};
18816
18817         };
18818         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
18819         {
18820                 size_t get_index() const {return type;}
18821                 bool is_unknown() const { return type == 1; }
18822                 void clear() {type = 0;}
18823                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
18824                 template<typename V>  bool decode(V& v)
18825                 {
18826                         clear();
18827                         if(!v(ref_nested())) return false;
18828                         { type = 1; return true;}
18829                         return false;
18830
18831                 }
18832                 template<typename V> bool encode(V& v) const
18833                 {
18834                         return v(ref_nested());
18835
18836                 }
18837                 protected:
18838                 template<typename V>  bool decode(size_t index, V& v)
18839                 {
18840                         clear();
18841                         switch(index)
18842                         {
18843                         case 1: type = 1; return v(ref_nested());
18844                         ref_nested().clear();
18845                         }
18846                         return false;
18847
18848                 }
18849                 template<typename V> bool encode(size_t index, V& v) const
18850                 {
18851                         if(index != type) {return false;} return v(ref_nested());
18852
18853                 }
18854                 private:
18855                 size_t type {0};
18856
18857         };
18858         struct Extension_t : asn::typefield<true>
18859         {
18860                 ~Extension_t()  {clear();}
18861                 size_t get_index() const {return type;}
18862                 bool is_unknown() const { return type == 1; }
18863                 void clear()
18864                 {
18865                         type = 0; ref_nested().clear();
18866                 }
18867                 template<typename V> static inline void enumerate(V& v)
18868                 {
18869
18870                 }
18871                 protected:
18872                 template<typename V> bool decode(size_t index, V& v)
18873                 {
18874                         clear();
18875                         switch(index)
18876                         {
18877                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
18878                         }
18879                         return false;
18880
18881                 }
18882                 template<typename V> bool encode(size_t index, V& v) const
18883                 {
18884                         if(index != type) return false;
18885                         return false;
18886
18887                 }
18888                 private:
18889                 size_t type {0};
18890
18891         };
18892         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
18893         {
18894                 size_t get_index() const {return type;}
18895                 bool is_unknown() const { return type == 1; }
18896                 void clear() {type = 0;}
18897                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
18898                 template<typename V>  bool decode(V& v)
18899                 {
18900                         clear();
18901                         if(!v(ref_nested())) return false;
18902                         { type = 1; return true;}
18903                         return false;
18904
18905                 }
18906                 template<typename V> bool encode(V& v) const
18907                 {
18908                         return v(ref_nested());
18909
18910                 }
18911                 protected:
18912                 template<typename V>  bool decode(size_t index, V& v)
18913                 {
18914                         clear();
18915                         switch(index)
18916                         {
18917                         case 1: type = 1; return v(ref_nested());
18918                         ref_nested().clear();
18919                         }
18920                         return false;
18921
18922                 }
18923                 template<typename V> bool encode(size_t index, V& v) const
18924                 {
18925                         if(index != type) {return false;} return v(ref_nested());
18926
18927                 }
18928                 private:
18929                 size_t type {0};
18930
18931         };
18932
18933 };
18934 /*
18935 FreqBandNrItem ::= SEQUENCE {
18936         freqBandIndicatorNr                     INTEGER (1..1024,...),
18937         supportedSULBandList    SEQUENCE (SIZE(0..maxnoofNrCellBands)) OF SupportedSULFreqBandItem,
18938         iE-Extensions                           ProtocolExtensionContainer { {FreqBandNrItem-ExtIEs} } OPTIONAL,
18939         ...
18940 }
18941 */
18942
18943 struct FreqBandNrItem : asn::sequence<3, 0, true, 1>
18944 {
18945         static constexpr const char* name() {return "FreqBandNrItem";}
18946         using parent_t = asn::sequence<3, 0, true, 1>;
18947         struct freqBandIndicatorNr_t : asn::integer<>
18948         {
18949                 using constraint_t = asn::constraints<true,asn::span<1, 1024>>;
18950                 static constexpr const char* name() {return "freqBandIndicatorNr_t";}
18951                 using parent_t = asn::integer<>;
18952
18953         };
18954
18955         freqBandIndicatorNr_t& ref_freqBandIndicatorNr() {return freqBandIndicatorNr;}
18956         freqBandIndicatorNr_t const& ref_freqBandIndicatorNr() const {return freqBandIndicatorNr;}
18957         struct supportedSULBandList_t_elm : SupportedSULFreqBandItem
18958         {
18959                 static constexpr const char* name() {return "supportedSULBandList_t_elm";}
18960                 using parent_t = SupportedSULFreqBandItem;
18961
18962         };
18963         struct supportedSULBandList_t : asn::sequenceof<supportedSULBandList_t_elm>
18964         {
18965                 static constexpr const char* name() {return "supportedSULBandList_t";}
18966                 using parent_t = asn::sequenceof<supportedSULBandList_t_elm>;
18967                 using constraint_t = asn::constraints<false,asn::span<0,  maxnoofNrCellBands >>;
18968
18969         };
18970         supportedSULBandList_t& ref_supportedSULBandList() {return supportedSULBandList;}
18971         supportedSULBandList_t const& ref_supportedSULBandList() const {return supportedSULBandList;}
18972         struct iE_Extensions_t : ProtocolExtensionContainer<FreqBandNrItem_ExtIEs>
18973         {
18974                 static constexpr const char* name() {return "iE_Extensions_t";}
18975                 using parent_t = ProtocolExtensionContainer<FreqBandNrItem_ExtIEs>;
18976                 static constexpr bool optional = true;
18977
18978         };
18979         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
18980         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
18981         template<typename V> void decode(V& v)
18982         {
18983                 v(freqBandIndicatorNr);
18984                 v(supportedSULBandList);
18985                 v(iE_Extensions);
18986
18987         };
18988         template<typename V> void encode(V& v) const
18989         {
18990                 v(freqBandIndicatorNr);
18991                 v(supportedSULBandList);
18992                 v(iE_Extensions);
18993
18994         };
18995         void clear()
18996         {
18997                 freqBandIndicatorNr.clear();
18998                 supportedSULBandList.clear();
18999                 iE_Extensions.clear();
19000
19001         };
19002         private:
19003         freqBandIndicatorNr_t   freqBandIndicatorNr;
19004         supportedSULBandList_t  supportedSULBandList;
19005         iE_Extensions_t iE_Extensions;
19006
19007 };
19008 /*
19009 GNB-ID ::= CHOICE {
19010         gNB-ID  BIT STRING (SIZE (22..32)),
19011         ...
19012 }
19013 */
19014
19015 struct GNB_ID : asn::choice<1, 0, true>
19016 {
19017         static constexpr const char* name() {return "GNB-ID";}
19018         using parent_t = asn::choice<1, 0, true>;
19019         index_type get_index() const {return index;}
19020         bool is_unknown() const {return index == 2;}
19021         void set_unknown() { set_index(2);  }
19022         ~GNB_ID() {clear();}
19023         struct gNB_ID_t : asn::bstring<>
19024         {
19025                 using constraint_t = asn::constraints<false,asn::span<22, 32>>;
19026                 static constexpr const char* name() {return "gNB_ID_t";}
19027                 using parent_t = asn::bstring<>;
19028
19029         };
19030
19031         void clear()
19032         {
19033                 switch(get_index())
19034                 {
19035                 case 1: var.destroy<gNB_ID_t>(); break;
19036                 }
19037                 index = 0;
19038                 base::clear();
19039         }
19040         template<typename V> bool decode(size_t idx, V& v)
19041         {
19042                 clear();
19043                 switch(idx)
19044                 {
19045                 case 1: set_index(1); return v(var.build<gNB_ID_t>());
19046                 }
19047                 return false;
19048
19049         }
19050         template<typename V> bool encode(V& v) const
19051         {
19052                 switch(get_index())
19053                 {
19054                 case 1: return v(var.as<gNB_ID_t>());
19055                 }
19056                 return false;
19057         }
19058         template<typename V> static inline void enumerate(V& v)
19059         {
19060                 v.template operator()<gNB_ID_t>(1);
19061
19062         }
19063         gNB_ID_t& select_gNB_ID() { if(get_index() != 1) { clear(); set_index(1); return var.build<gNB_ID_t>();} return var.as<gNB_ID_t>();}
19064         gNB_ID_t const* get_gNB_ID() const { if(get_index() == 1) { return &var.as<gNB_ID_t>();} return nullptr; }
19065         private:
19066         void set_index(index_type i) {index = i; base::set();}
19067         union union_type
19068         {
19069                 char dummy1[sizeof(gNB_ID_t)];
19070
19071         };
19072         asn::variant<sizeof(union_type)>        var;
19073         index_type      index {0};
19074 };
19075 /*
19076 GNBOverloadInformation ::= ENUMERATED {overloaded, not-overloaded, ...}
19077 */
19078
19079 struct GNBOverloadInformation : asn::enumerated<2, 0, true>
19080 {
19081         static constexpr const char* name() {return "GNBOverloadInformation";}
19082         using parent_t = asn::enumerated<2, 0, true>;
19083         typedef enum {
19084                 overloaded
19085                 ,not_overloaded
19086         } index_t;
19087
19088 };
19089
19090 /*
19091 GTP-TEI                                 ::= OCTET STRING (SIZE (4))
19092 */
19093
19094 struct GTP_TEI : asn::ostring<>
19095 {
19096         using constraint_t = asn::constraints<false,asn::one<4>>;
19097         static constexpr const char* name() {return "GTP-TEI";}
19098         using parent_t = asn::ostring<>;
19099
19100 };
19101
19102 /*
19103 TransportLayerAddress                   ::= BIT STRING (SIZE(1..160, ...))
19104 */
19105
19106 struct TransportLayerAddress : asn::bstring<>
19107 {
19108         using constraint_t = asn::constraints<true,asn::span<1, 160>>;
19109         static constexpr const char* name() {return "TransportLayerAddress";}
19110         using parent_t = asn::bstring<>;
19111
19112 };
19113
19114 /*
19115 GTPtunnelEndpoint-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
19116         ...
19117 }
19118 */
19119
19120 struct GTPtunnelEndpoint_ExtIEs
19121 {
19122         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
19123         {
19124                 size_t get_index() const {return type;}
19125                 bool is_unknown() const { return type == 1; }
19126                 void clear() {type = 0;}
19127                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
19128                 template<typename V>  bool decode(V& v)
19129                 {
19130                         clear();
19131                         if(!v(ref_nested())) return false;
19132                         { type = 1; return true;}
19133                         return false;
19134
19135                 }
19136                 template<typename V> bool encode(V& v) const
19137                 {
19138                         return v(ref_nested());
19139
19140                 }
19141                 protected:
19142                 template<typename V>  bool decode(size_t index, V& v)
19143                 {
19144                         clear();
19145                         switch(index)
19146                         {
19147                         case 1: type = 1; return v(ref_nested());
19148                         ref_nested().clear();
19149                         }
19150                         return false;
19151
19152                 }
19153                 template<typename V> bool encode(size_t index, V& v) const
19154                 {
19155                         if(index != type) {return false;} return v(ref_nested());
19156
19157                 }
19158                 private:
19159                 size_t type {0};
19160
19161         };
19162         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
19163         {
19164                 size_t get_index() const {return type;}
19165                 bool is_unknown() const { return type == 1; }
19166                 void clear() {type = 0;}
19167                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
19168                 template<typename V>  bool decode(V& v)
19169                 {
19170                         clear();
19171                         if(!v(ref_nested())) return false;
19172                         { type = 1; return true;}
19173                         return false;
19174
19175                 }
19176                 template<typename V> bool encode(V& v) const
19177                 {
19178                         return v(ref_nested());
19179
19180                 }
19181                 protected:
19182                 template<typename V>  bool decode(size_t index, V& v)
19183                 {
19184                         clear();
19185                         switch(index)
19186                         {
19187                         case 1: type = 1; return v(ref_nested());
19188                         ref_nested().clear();
19189                         }
19190                         return false;
19191
19192                 }
19193                 template<typename V> bool encode(size_t index, V& v) const
19194                 {
19195                         if(index != type) {return false;} return v(ref_nested());
19196
19197                 }
19198                 private:
19199                 size_t type {0};
19200
19201         };
19202         struct Extension_t : asn::typefield<true>
19203         {
19204                 ~Extension_t()  {clear();}
19205                 size_t get_index() const {return type;}
19206                 bool is_unknown() const { return type == 1; }
19207                 void clear()
19208                 {
19209                         type = 0; ref_nested().clear();
19210                 }
19211                 template<typename V> static inline void enumerate(V& v)
19212                 {
19213
19214                 }
19215                 protected:
19216                 template<typename V> bool decode(size_t index, V& v)
19217                 {
19218                         clear();
19219                         switch(index)
19220                         {
19221                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
19222                         }
19223                         return false;
19224
19225                 }
19226                 template<typename V> bool encode(size_t index, V& v) const
19227                 {
19228                         if(index != type) return false;
19229                         return false;
19230
19231                 }
19232                 private:
19233                 size_t type {0};
19234
19235         };
19236         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
19237         {
19238                 size_t get_index() const {return type;}
19239                 bool is_unknown() const { return type == 1; }
19240                 void clear() {type = 0;}
19241                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
19242                 template<typename V>  bool decode(V& v)
19243                 {
19244                         clear();
19245                         if(!v(ref_nested())) return false;
19246                         { type = 1; return true;}
19247                         return false;
19248
19249                 }
19250                 template<typename V> bool encode(V& v) const
19251                 {
19252                         return v(ref_nested());
19253
19254                 }
19255                 protected:
19256                 template<typename V>  bool decode(size_t index, V& v)
19257                 {
19258                         clear();
19259                         switch(index)
19260                         {
19261                         case 1: type = 1; return v(ref_nested());
19262                         ref_nested().clear();
19263                         }
19264                         return false;
19265
19266                 }
19267                 template<typename V> bool encode(size_t index, V& v) const
19268                 {
19269                         if(index != type) {return false;} return v(ref_nested());
19270
19271                 }
19272                 private:
19273                 size_t type {0};
19274
19275         };
19276
19277 };
19278 /*
19279 GTPtunnelEndpoint ::= SEQUENCE {
19280         transportLayerAddress                   TransportLayerAddress,
19281         gTP-TEID                                                GTP-TEI,
19282         iE-Extensions                                   ProtocolExtensionContainer { {GTPtunnelEndpoint-ExtIEs} } OPTIONAL,
19283         ...
19284 }
19285 */
19286
19287 struct GTPtunnelEndpoint : asn::sequence<3, 0, true, 1>
19288 {
19289         static constexpr const char* name() {return "GTPtunnelEndpoint";}
19290         using parent_t = asn::sequence<3, 0, true, 1>;
19291         struct transportLayerAddress_t : TransportLayerAddress
19292         {
19293                 static constexpr const char* name() {return "transportLayerAddress_t";}
19294                 using parent_t = TransportLayerAddress;
19295
19296         };
19297         transportLayerAddress_t& ref_transportLayerAddress() {return transportLayerAddress;}
19298         transportLayerAddress_t const& ref_transportLayerAddress() const {return transportLayerAddress;}
19299         struct gTP_TEID_t : GTP_TEI
19300         {
19301                 static constexpr const char* name() {return "gTP_TEID_t";}
19302                 using parent_t = GTP_TEI;
19303
19304         };
19305         gTP_TEID_t& ref_gTP_TEID() {return gTP_TEID;}
19306         gTP_TEID_t const& ref_gTP_TEID() const {return gTP_TEID;}
19307         struct iE_Extensions_t : ProtocolExtensionContainer<GTPtunnelEndpoint_ExtIEs>
19308         {
19309                 static constexpr const char* name() {return "iE_Extensions_t";}
19310                 using parent_t = ProtocolExtensionContainer<GTPtunnelEndpoint_ExtIEs>;
19311                 static constexpr bool optional = true;
19312
19313         };
19314         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
19315         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
19316         template<typename V> void decode(V& v)
19317         {
19318                 v(transportLayerAddress);
19319                 v(gTP_TEID);
19320                 v(iE_Extensions);
19321
19322         };
19323         template<typename V> void encode(V& v) const
19324         {
19325                 v(transportLayerAddress);
19326                 v(gTP_TEID);
19327                 v(iE_Extensions);
19328
19329         };
19330         void clear()
19331         {
19332                 transportLayerAddress.clear();
19333                 gTP_TEID.clear();
19334                 iE_Extensions.clear();
19335
19336         };
19337         private:
19338         transportLayerAddress_t transportLayerAddress;
19339         gTP_TEID_t      gTP_TEID;
19340         iE_Extensions_t iE_Extensions;
19341
19342 };
19343 /*
19344 MME-Group-ID    ::= OCTET STRING (SIZE (2))
19345 */
19346
19347 struct MME_Group_ID : asn::ostring<>
19348 {
19349         using constraint_t = asn::constraints<false,asn::one<2>>;
19350         static constexpr const char* name() {return "MME-Group-ID";}
19351         using parent_t = asn::ostring<>;
19352
19353 };
19354
19355 /*
19356 GU-Group-ID-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
19357         ...
19358 }
19359 */
19360
19361 struct GU_Group_ID_ExtIEs
19362 {
19363         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
19364         {
19365                 size_t get_index() const {return type;}
19366                 bool is_unknown() const { return type == 1; }
19367                 void clear() {type = 0;}
19368                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
19369                 template<typename V>  bool decode(V& v)
19370                 {
19371                         clear();
19372                         if(!v(ref_nested())) return false;
19373                         { type = 1; return true;}
19374                         return false;
19375
19376                 }
19377                 template<typename V> bool encode(V& v) const
19378                 {
19379                         return v(ref_nested());
19380
19381                 }
19382                 protected:
19383                 template<typename V>  bool decode(size_t index, V& v)
19384                 {
19385                         clear();
19386                         switch(index)
19387                         {
19388                         case 1: type = 1; return v(ref_nested());
19389                         ref_nested().clear();
19390                         }
19391                         return false;
19392
19393                 }
19394                 template<typename V> bool encode(size_t index, V& v) const
19395                 {
19396                         if(index != type) {return false;} return v(ref_nested());
19397
19398                 }
19399                 private:
19400                 size_t type {0};
19401
19402         };
19403         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
19404         {
19405                 size_t get_index() const {return type;}
19406                 bool is_unknown() const { return type == 1; }
19407                 void clear() {type = 0;}
19408                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
19409                 template<typename V>  bool decode(V& v)
19410                 {
19411                         clear();
19412                         if(!v(ref_nested())) return false;
19413                         { type = 1; return true;}
19414                         return false;
19415
19416                 }
19417                 template<typename V> bool encode(V& v) const
19418                 {
19419                         return v(ref_nested());
19420
19421                 }
19422                 protected:
19423                 template<typename V>  bool decode(size_t index, V& v)
19424                 {
19425                         clear();
19426                         switch(index)
19427                         {
19428                         case 1: type = 1; return v(ref_nested());
19429                         ref_nested().clear();
19430                         }
19431                         return false;
19432
19433                 }
19434                 template<typename V> bool encode(size_t index, V& v) const
19435                 {
19436                         if(index != type) {return false;} return v(ref_nested());
19437
19438                 }
19439                 private:
19440                 size_t type {0};
19441
19442         };
19443         struct Extension_t : asn::typefield<true>
19444         {
19445                 ~Extension_t()  {clear();}
19446                 size_t get_index() const {return type;}
19447                 bool is_unknown() const { return type == 1; }
19448                 void clear()
19449                 {
19450                         type = 0; ref_nested().clear();
19451                 }
19452                 template<typename V> static inline void enumerate(V& v)
19453                 {
19454
19455                 }
19456                 protected:
19457                 template<typename V> bool decode(size_t index, V& v)
19458                 {
19459                         clear();
19460                         switch(index)
19461                         {
19462                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
19463                         }
19464                         return false;
19465
19466                 }
19467                 template<typename V> bool encode(size_t index, V& v) const
19468                 {
19469                         if(index != type) return false;
19470                         return false;
19471
19472                 }
19473                 private:
19474                 size_t type {0};
19475
19476         };
19477         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
19478         {
19479                 size_t get_index() const {return type;}
19480                 bool is_unknown() const { return type == 1; }
19481                 void clear() {type = 0;}
19482                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
19483                 template<typename V>  bool decode(V& v)
19484                 {
19485                         clear();
19486                         if(!v(ref_nested())) return false;
19487                         { type = 1; return true;}
19488                         return false;
19489
19490                 }
19491                 template<typename V> bool encode(V& v) const
19492                 {
19493                         return v(ref_nested());
19494
19495                 }
19496                 protected:
19497                 template<typename V>  bool decode(size_t index, V& v)
19498                 {
19499                         clear();
19500                         switch(index)
19501                         {
19502                         case 1: type = 1; return v(ref_nested());
19503                         ref_nested().clear();
19504                         }
19505                         return false;
19506
19507                 }
19508                 template<typename V> bool encode(size_t index, V& v) const
19509                 {
19510                         if(index != type) {return false;} return v(ref_nested());
19511
19512                 }
19513                 private:
19514                 size_t type {0};
19515
19516         };
19517
19518 };
19519 /*
19520 GU-Group-ID                     ::= SEQUENCE {
19521         pLMN-Identity           PLMN-Identity,
19522         mME-Group-ID            MME-Group-ID,
19523         iE-Extensions           ProtocolExtensionContainer { {GU-Group-ID-ExtIEs} } OPTIONAL,
19524         ...
19525 }
19526 */
19527
19528 struct GU_Group_ID : asn::sequence<3, 0, true, 1>
19529 {
19530         static constexpr const char* name() {return "GU-Group-ID";}
19531         using parent_t = asn::sequence<3, 0, true, 1>;
19532         struct pLMN_Identity_t : PLMN_Identity
19533         {
19534                 static constexpr const char* name() {return "pLMN_Identity_t";}
19535                 using parent_t = PLMN_Identity;
19536
19537         };
19538         pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
19539         pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
19540         struct mME_Group_ID_t : MME_Group_ID
19541         {
19542                 static constexpr const char* name() {return "mME_Group_ID_t";}
19543                 using parent_t = MME_Group_ID;
19544
19545         };
19546         mME_Group_ID_t& ref_mME_Group_ID() {return mME_Group_ID;}
19547         mME_Group_ID_t const& ref_mME_Group_ID() const {return mME_Group_ID;}
19548         struct iE_Extensions_t : ProtocolExtensionContainer<GU_Group_ID_ExtIEs>
19549         {
19550                 static constexpr const char* name() {return "iE_Extensions_t";}
19551                 using parent_t = ProtocolExtensionContainer<GU_Group_ID_ExtIEs>;
19552                 static constexpr bool optional = true;
19553
19554         };
19555         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
19556         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
19557         template<typename V> void decode(V& v)
19558         {
19559                 v(pLMN_Identity);
19560                 v(mME_Group_ID);
19561                 v(iE_Extensions);
19562
19563         };
19564         template<typename V> void encode(V& v) const
19565         {
19566                 v(pLMN_Identity);
19567                 v(mME_Group_ID);
19568                 v(iE_Extensions);
19569
19570         };
19571         void clear()
19572         {
19573                 pLMN_Identity.clear();
19574                 mME_Group_ID.clear();
19575                 iE_Extensions.clear();
19576
19577         };
19578         private:
19579         pLMN_Identity_t pLMN_Identity;
19580         mME_Group_ID_t  mME_Group_ID;
19581         iE_Extensions_t iE_Extensions;
19582
19583 };
19584 /*
19585 GUGroupIDList           ::= SEQUENCE (SIZE (1..maxPools)) OF GU-Group-ID
19586 */
19587
19588 struct GUGroupIDList_elm : GU_Group_ID
19589 {
19590         static constexpr const char* name() {return "GUGroupIDList_elm";}
19591         using parent_t = GU_Group_ID;
19592
19593 };
19594 struct GUGroupIDList : asn::sequenceof<GUGroupIDList_elm>
19595 {
19596         static constexpr const char* name() {return "GUGroupIDList";}
19597         using parent_t = asn::sequenceof<GUGroupIDList_elm>;
19598         using constraint_t = asn::constraints<false,asn::span<1,  maxPools >>;
19599
19600 };
19601 /*
19602 MME-Code                ::= OCTET STRING (SIZE (1))
19603 */
19604
19605 struct MME_Code : asn::ostring<>
19606 {
19607         using constraint_t = asn::constraints<false,asn::one<1>>;
19608         static constexpr const char* name() {return "MME-Code";}
19609         using parent_t = asn::ostring<>;
19610
19611 };
19612
19613 /*
19614 GUMMEI-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
19615         ...
19616 }
19617 */
19618
19619 struct GUMMEI_ExtIEs
19620 {
19621         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
19622         {
19623                 size_t get_index() const {return type;}
19624                 bool is_unknown() const { return type == 1; }
19625                 void clear() {type = 0;}
19626                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
19627                 template<typename V>  bool decode(V& v)
19628                 {
19629                         clear();
19630                         if(!v(ref_nested())) return false;
19631                         { type = 1; return true;}
19632                         return false;
19633
19634                 }
19635                 template<typename V> bool encode(V& v) const
19636                 {
19637                         return v(ref_nested());
19638
19639                 }
19640                 protected:
19641                 template<typename V>  bool decode(size_t index, V& v)
19642                 {
19643                         clear();
19644                         switch(index)
19645                         {
19646                         case 1: type = 1; return v(ref_nested());
19647                         ref_nested().clear();
19648                         }
19649                         return false;
19650
19651                 }
19652                 template<typename V> bool encode(size_t index, V& v) const
19653                 {
19654                         if(index != type) {return false;} return v(ref_nested());
19655
19656                 }
19657                 private:
19658                 size_t type {0};
19659
19660         };
19661         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
19662         {
19663                 size_t get_index() const {return type;}
19664                 bool is_unknown() const { return type == 1; }
19665                 void clear() {type = 0;}
19666                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
19667                 template<typename V>  bool decode(V& v)
19668                 {
19669                         clear();
19670                         if(!v(ref_nested())) return false;
19671                         { type = 1; return true;}
19672                         return false;
19673
19674                 }
19675                 template<typename V> bool encode(V& v) const
19676                 {
19677                         return v(ref_nested());
19678
19679                 }
19680                 protected:
19681                 template<typename V>  bool decode(size_t index, V& v)
19682                 {
19683                         clear();
19684                         switch(index)
19685                         {
19686                         case 1: type = 1; return v(ref_nested());
19687                         ref_nested().clear();
19688                         }
19689                         return false;
19690
19691                 }
19692                 template<typename V> bool encode(size_t index, V& v) const
19693                 {
19694                         if(index != type) {return false;} return v(ref_nested());
19695
19696                 }
19697                 private:
19698                 size_t type {0};
19699
19700         };
19701         struct Extension_t : asn::typefield<true>
19702         {
19703                 ~Extension_t()  {clear();}
19704                 size_t get_index() const {return type;}
19705                 bool is_unknown() const { return type == 1; }
19706                 void clear()
19707                 {
19708                         type = 0; ref_nested().clear();
19709                 }
19710                 template<typename V> static inline void enumerate(V& v)
19711                 {
19712
19713                 }
19714                 protected:
19715                 template<typename V> bool decode(size_t index, V& v)
19716                 {
19717                         clear();
19718                         switch(index)
19719                         {
19720                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
19721                         }
19722                         return false;
19723
19724                 }
19725                 template<typename V> bool encode(size_t index, V& v) const
19726                 {
19727                         if(index != type) return false;
19728                         return false;
19729
19730                 }
19731                 private:
19732                 size_t type {0};
19733
19734         };
19735         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
19736         {
19737                 size_t get_index() const {return type;}
19738                 bool is_unknown() const { return type == 1; }
19739                 void clear() {type = 0;}
19740                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
19741                 template<typename V>  bool decode(V& v)
19742                 {
19743                         clear();
19744                         if(!v(ref_nested())) return false;
19745                         { type = 1; return true;}
19746                         return false;
19747
19748                 }
19749                 template<typename V> bool encode(V& v) const
19750                 {
19751                         return v(ref_nested());
19752
19753                 }
19754                 protected:
19755                 template<typename V>  bool decode(size_t index, V& v)
19756                 {
19757                         clear();
19758                         switch(index)
19759                         {
19760                         case 1: type = 1; return v(ref_nested());
19761                         ref_nested().clear();
19762                         }
19763                         return false;
19764
19765                 }
19766                 template<typename V> bool encode(size_t index, V& v) const
19767                 {
19768                         if(index != type) {return false;} return v(ref_nested());
19769
19770                 }
19771                 private:
19772                 size_t type {0};
19773
19774         };
19775
19776 };
19777 /*
19778 GUMMEI                  ::= SEQUENCE {
19779
19780         gU-Group-ID             GU-Group-ID,
19781         mME-Code                        MME-Code,
19782         iE-Extensions                                   ProtocolExtensionContainer { {GUMMEI-ExtIEs} } OPTIONAL,
19783         ...
19784 }
19785 */
19786
19787 struct GUMMEI : asn::sequence<3, 0, true, 1>
19788 {
19789         static constexpr const char* name() {return "GUMMEI";}
19790         using parent_t = asn::sequence<3, 0, true, 1>;
19791         struct gU_Group_ID_t : GU_Group_ID
19792         {
19793                 static constexpr const char* name() {return "gU_Group_ID_t";}
19794                 using parent_t = GU_Group_ID;
19795
19796         };
19797         gU_Group_ID_t& ref_gU_Group_ID() {return gU_Group_ID;}
19798         gU_Group_ID_t const& ref_gU_Group_ID() const {return gU_Group_ID;}
19799         struct mME_Code_t : MME_Code
19800         {
19801                 static constexpr const char* name() {return "mME_Code_t";}
19802                 using parent_t = MME_Code;
19803
19804         };
19805         mME_Code_t& ref_mME_Code() {return mME_Code;}
19806         mME_Code_t const& ref_mME_Code() const {return mME_Code;}
19807         struct iE_Extensions_t : ProtocolExtensionContainer<GUMMEI_ExtIEs>
19808         {
19809                 static constexpr const char* name() {return "iE_Extensions_t";}
19810                 using parent_t = ProtocolExtensionContainer<GUMMEI_ExtIEs>;
19811                 static constexpr bool optional = true;
19812
19813         };
19814         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
19815         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
19816         template<typename V> void decode(V& v)
19817         {
19818                 v(gU_Group_ID);
19819                 v(mME_Code);
19820                 v(iE_Extensions);
19821
19822         };
19823         template<typename V> void encode(V& v) const
19824         {
19825                 v(gU_Group_ID);
19826                 v(mME_Code);
19827                 v(iE_Extensions);
19828
19829         };
19830         void clear()
19831         {
19832                 gU_Group_ID.clear();
19833                 mME_Code.clear();
19834                 iE_Extensions.clear();
19835
19836         };
19837         private:
19838         gU_Group_ID_t   gU_Group_ID;
19839         mME_Code_t      mME_Code;
19840         iE_Extensions_t iE_Extensions;
19841
19842 };
19843 /*
19844 GlobalENB-ID-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
19845         ...
19846 }
19847 */
19848
19849 struct GlobalENB_ID_ExtIEs
19850 {
19851         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
19852         {
19853                 size_t get_index() const {return type;}
19854                 bool is_unknown() const { return type == 1; }
19855                 void clear() {type = 0;}
19856                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
19857                 template<typename V>  bool decode(V& v)
19858                 {
19859                         clear();
19860                         if(!v(ref_nested())) return false;
19861                         { type = 1; return true;}
19862                         return false;
19863
19864                 }
19865                 template<typename V> bool encode(V& v) const
19866                 {
19867                         return v(ref_nested());
19868
19869                 }
19870                 protected:
19871                 template<typename V>  bool decode(size_t index, V& v)
19872                 {
19873                         clear();
19874                         switch(index)
19875                         {
19876                         case 1: type = 1; return v(ref_nested());
19877                         ref_nested().clear();
19878                         }
19879                         return false;
19880
19881                 }
19882                 template<typename V> bool encode(size_t index, V& v) const
19883                 {
19884                         if(index != type) {return false;} return v(ref_nested());
19885
19886                 }
19887                 private:
19888                 size_t type {0};
19889
19890         };
19891         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
19892         {
19893                 size_t get_index() const {return type;}
19894                 bool is_unknown() const { return type == 1; }
19895                 void clear() {type = 0;}
19896                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
19897                 template<typename V>  bool decode(V& v)
19898                 {
19899                         clear();
19900                         if(!v(ref_nested())) return false;
19901                         { type = 1; return true;}
19902                         return false;
19903
19904                 }
19905                 template<typename V> bool encode(V& v) const
19906                 {
19907                         return v(ref_nested());
19908
19909                 }
19910                 protected:
19911                 template<typename V>  bool decode(size_t index, V& v)
19912                 {
19913                         clear();
19914                         switch(index)
19915                         {
19916                         case 1: type = 1; return v(ref_nested());
19917                         ref_nested().clear();
19918                         }
19919                         return false;
19920
19921                 }
19922                 template<typename V> bool encode(size_t index, V& v) const
19923                 {
19924                         if(index != type) {return false;} return v(ref_nested());
19925
19926                 }
19927                 private:
19928                 size_t type {0};
19929
19930         };
19931         struct Extension_t : asn::typefield<true>
19932         {
19933                 ~Extension_t()  {clear();}
19934                 size_t get_index() const {return type;}
19935                 bool is_unknown() const { return type == 1; }
19936                 void clear()
19937                 {
19938                         type = 0; ref_nested().clear();
19939                 }
19940                 template<typename V> static inline void enumerate(V& v)
19941                 {
19942
19943                 }
19944                 protected:
19945                 template<typename V> bool decode(size_t index, V& v)
19946                 {
19947                         clear();
19948                         switch(index)
19949                         {
19950                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
19951                         }
19952                         return false;
19953
19954                 }
19955                 template<typename V> bool encode(size_t index, V& v) const
19956                 {
19957                         if(index != type) return false;
19958                         return false;
19959
19960                 }
19961                 private:
19962                 size_t type {0};
19963
19964         };
19965         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
19966         {
19967                 size_t get_index() const {return type;}
19968                 bool is_unknown() const { return type == 1; }
19969                 void clear() {type = 0;}
19970                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
19971                 template<typename V>  bool decode(V& v)
19972                 {
19973                         clear();
19974                         if(!v(ref_nested())) return false;
19975                         { type = 1; return true;}
19976                         return false;
19977
19978                 }
19979                 template<typename V> bool encode(V& v) const
19980                 {
19981                         return v(ref_nested());
19982
19983                 }
19984                 protected:
19985                 template<typename V>  bool decode(size_t index, V& v)
19986                 {
19987                         clear();
19988                         switch(index)
19989                         {
19990                         case 1: type = 1; return v(ref_nested());
19991                         ref_nested().clear();
19992                         }
19993                         return false;
19994
19995                 }
19996                 template<typename V> bool encode(size_t index, V& v) const
19997                 {
19998                         if(index != type) {return false;} return v(ref_nested());
19999
20000                 }
20001                 private:
20002                 size_t type {0};
20003
20004         };
20005
20006 };
20007 /*
20008 GlobalENB-ID ::= SEQUENCE {
20009         pLMN-Identity                   PLMN-Identity,
20010         eNB-ID                                  ENB-ID,
20011         iE-Extensions                   ProtocolExtensionContainer { {GlobalENB-ID-ExtIEs} } OPTIONAL,
20012         ...
20013 }
20014 */
20015
20016 struct GlobalENB_ID : asn::sequence<3, 0, true, 1>
20017 {
20018         static constexpr const char* name() {return "GlobalENB-ID";}
20019         using parent_t = asn::sequence<3, 0, true, 1>;
20020         struct pLMN_Identity_t : PLMN_Identity
20021         {
20022                 static constexpr const char* name() {return "pLMN_Identity_t";}
20023                 using parent_t = PLMN_Identity;
20024
20025         };
20026         pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
20027         pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
20028         struct eNB_ID_t : ENB_ID
20029         {
20030                 static constexpr const char* name() {return "eNB_ID_t";}
20031                 using parent_t = ENB_ID;
20032
20033         };
20034         eNB_ID_t& ref_eNB_ID() {return eNB_ID;}
20035         eNB_ID_t const& ref_eNB_ID() const {return eNB_ID;}
20036         struct iE_Extensions_t : ProtocolExtensionContainer<GlobalENB_ID_ExtIEs>
20037         {
20038                 static constexpr const char* name() {return "iE_Extensions_t";}
20039                 using parent_t = ProtocolExtensionContainer<GlobalENB_ID_ExtIEs>;
20040                 static constexpr bool optional = true;
20041
20042         };
20043         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
20044         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
20045         template<typename V> void decode(V& v)
20046         {
20047                 v(pLMN_Identity);
20048                 v(eNB_ID);
20049                 v(iE_Extensions);
20050
20051         };
20052         template<typename V> void encode(V& v) const
20053         {
20054                 v(pLMN_Identity);
20055                 v(eNB_ID);
20056                 v(iE_Extensions);
20057
20058         };
20059         void clear()
20060         {
20061                 pLMN_Identity.clear();
20062                 eNB_ID.clear();
20063                 iE_Extensions.clear();
20064
20065         };
20066         private:
20067         pLMN_Identity_t pLMN_Identity;
20068         eNB_ID_t        eNB_ID;
20069         iE_Extensions_t iE_Extensions;
20070
20071 };
20072 /*
20073 GlobalGNB-ID-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
20074         ...
20075 }
20076 */
20077
20078 struct GlobalGNB_ID_ExtIEs
20079 {
20080         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
20081         {
20082                 size_t get_index() const {return type;}
20083                 bool is_unknown() const { return type == 1; }
20084                 void clear() {type = 0;}
20085                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
20086                 template<typename V>  bool decode(V& v)
20087                 {
20088                         clear();
20089                         if(!v(ref_nested())) return false;
20090                         { type = 1; return true;}
20091                         return false;
20092
20093                 }
20094                 template<typename V> bool encode(V& v) const
20095                 {
20096                         return v(ref_nested());
20097
20098                 }
20099                 protected:
20100                 template<typename V>  bool decode(size_t index, V& v)
20101                 {
20102                         clear();
20103                         switch(index)
20104                         {
20105                         case 1: type = 1; return v(ref_nested());
20106                         ref_nested().clear();
20107                         }
20108                         return false;
20109
20110                 }
20111                 template<typename V> bool encode(size_t index, V& v) const
20112                 {
20113                         if(index != type) {return false;} return v(ref_nested());
20114
20115                 }
20116                 private:
20117                 size_t type {0};
20118
20119         };
20120         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
20121         {
20122                 size_t get_index() const {return type;}
20123                 bool is_unknown() const { return type == 1; }
20124                 void clear() {type = 0;}
20125                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
20126                 template<typename V>  bool decode(V& v)
20127                 {
20128                         clear();
20129                         if(!v(ref_nested())) return false;
20130                         { type = 1; return true;}
20131                         return false;
20132
20133                 }
20134                 template<typename V> bool encode(V& v) const
20135                 {
20136                         return v(ref_nested());
20137
20138                 }
20139                 protected:
20140                 template<typename V>  bool decode(size_t index, V& v)
20141                 {
20142                         clear();
20143                         switch(index)
20144                         {
20145                         case 1: type = 1; return v(ref_nested());
20146                         ref_nested().clear();
20147                         }
20148                         return false;
20149
20150                 }
20151                 template<typename V> bool encode(size_t index, V& v) const
20152                 {
20153                         if(index != type) {return false;} return v(ref_nested());
20154
20155                 }
20156                 private:
20157                 size_t type {0};
20158
20159         };
20160         struct Extension_t : asn::typefield<true>
20161         {
20162                 ~Extension_t()  {clear();}
20163                 size_t get_index() const {return type;}
20164                 bool is_unknown() const { return type == 1; }
20165                 void clear()
20166                 {
20167                         type = 0; ref_nested().clear();
20168                 }
20169                 template<typename V> static inline void enumerate(V& v)
20170                 {
20171
20172                 }
20173                 protected:
20174                 template<typename V> bool decode(size_t index, V& v)
20175                 {
20176                         clear();
20177                         switch(index)
20178                         {
20179                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
20180                         }
20181                         return false;
20182
20183                 }
20184                 template<typename V> bool encode(size_t index, V& v) const
20185                 {
20186                         if(index != type) return false;
20187                         return false;
20188
20189                 }
20190                 private:
20191                 size_t type {0};
20192
20193         };
20194         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
20195         {
20196                 size_t get_index() const {return type;}
20197                 bool is_unknown() const { return type == 1; }
20198                 void clear() {type = 0;}
20199                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
20200                 template<typename V>  bool decode(V& v)
20201                 {
20202                         clear();
20203                         if(!v(ref_nested())) return false;
20204                         { type = 1; return true;}
20205                         return false;
20206
20207                 }
20208                 template<typename V> bool encode(V& v) const
20209                 {
20210                         return v(ref_nested());
20211
20212                 }
20213                 protected:
20214                 template<typename V>  bool decode(size_t index, V& v)
20215                 {
20216                         clear();
20217                         switch(index)
20218                         {
20219                         case 1: type = 1; return v(ref_nested());
20220                         ref_nested().clear();
20221                         }
20222                         return false;
20223
20224                 }
20225                 template<typename V> bool encode(size_t index, V& v) const
20226                 {
20227                         if(index != type) {return false;} return v(ref_nested());
20228
20229                 }
20230                 private:
20231                 size_t type {0};
20232
20233         };
20234
20235 };
20236 /*
20237 GlobalGNB-ID ::= SEQUENCE {
20238         pLMN-Identity                   PLMN-Identity,
20239         gNB-ID                                  GNB-ID,
20240         iE-Extensions                   ProtocolExtensionContainer { {GlobalGNB-ID-ExtIEs} } OPTIONAL,
20241         ...
20242 }
20243 */
20244
20245 struct GlobalGNB_ID : asn::sequence<3, 0, true, 1>
20246 {
20247         static constexpr const char* name() {return "GlobalGNB-ID";}
20248         using parent_t = asn::sequence<3, 0, true, 1>;
20249         struct pLMN_Identity_t : PLMN_Identity
20250         {
20251                 static constexpr const char* name() {return "pLMN_Identity_t";}
20252                 using parent_t = PLMN_Identity;
20253
20254         };
20255         pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
20256         pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
20257         struct gNB_ID_t : GNB_ID
20258         {
20259                 static constexpr const char* name() {return "gNB_ID_t";}
20260                 using parent_t = GNB_ID;
20261
20262         };
20263         gNB_ID_t& ref_gNB_ID() {return gNB_ID;}
20264         gNB_ID_t const& ref_gNB_ID() const {return gNB_ID;}
20265         struct iE_Extensions_t : ProtocolExtensionContainer<GlobalGNB_ID_ExtIEs>
20266         {
20267                 static constexpr const char* name() {return "iE_Extensions_t";}
20268                 using parent_t = ProtocolExtensionContainer<GlobalGNB_ID_ExtIEs>;
20269                 static constexpr bool optional = true;
20270
20271         };
20272         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
20273         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
20274         template<typename V> void decode(V& v)
20275         {
20276                 v(pLMN_Identity);
20277                 v(gNB_ID);
20278                 v(iE_Extensions);
20279
20280         };
20281         template<typename V> void encode(V& v) const
20282         {
20283                 v(pLMN_Identity);
20284                 v(gNB_ID);
20285                 v(iE_Extensions);
20286
20287         };
20288         void clear()
20289         {
20290                 pLMN_Identity.clear();
20291                 gNB_ID.clear();
20292                 iE_Extensions.clear();
20293
20294         };
20295         private:
20296         pLMN_Identity_t pLMN_Identity;
20297         gNB_ID_t        gNB_ID;
20298         iE_Extensions_t iE_Extensions;
20299
20300 };
20301 /*
20302 LoadIndicator ::= ENUMERATED {
20303         lowLoad,
20304         mediumLoad,
20305         highLoad,
20306         overLoad,
20307         ...
20308 }
20309 */
20310
20311 struct LoadIndicator : asn::enumerated<4, 0, true>
20312 {
20313         static constexpr const char* name() {return "LoadIndicator";}
20314         using parent_t = asn::enumerated<4, 0, true>;
20315         typedef enum {
20316                 lowLoad
20317                 ,mediumLoad
20318                 ,highLoad
20319                 ,overLoad
20320         } index_t;
20321
20322 };
20323
20324 /*
20325 HWLoadIndicator-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
20326         ...
20327 }
20328 */
20329
20330 struct HWLoadIndicator_ExtIEs
20331 {
20332         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
20333         {
20334                 size_t get_index() const {return type;}
20335                 bool is_unknown() const { return type == 1; }
20336                 void clear() {type = 0;}
20337                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
20338                 template<typename V>  bool decode(V& v)
20339                 {
20340                         clear();
20341                         if(!v(ref_nested())) return false;
20342                         { type = 1; return true;}
20343                         return false;
20344
20345                 }
20346                 template<typename V> bool encode(V& v) const
20347                 {
20348                         return v(ref_nested());
20349
20350                 }
20351                 protected:
20352                 template<typename V>  bool decode(size_t index, V& v)
20353                 {
20354                         clear();
20355                         switch(index)
20356                         {
20357                         case 1: type = 1; return v(ref_nested());
20358                         ref_nested().clear();
20359                         }
20360                         return false;
20361
20362                 }
20363                 template<typename V> bool encode(size_t index, V& v) const
20364                 {
20365                         if(index != type) {return false;} return v(ref_nested());
20366
20367                 }
20368                 private:
20369                 size_t type {0};
20370
20371         };
20372         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
20373         {
20374                 size_t get_index() const {return type;}
20375                 bool is_unknown() const { return type == 1; }
20376                 void clear() {type = 0;}
20377                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
20378                 template<typename V>  bool decode(V& v)
20379                 {
20380                         clear();
20381                         if(!v(ref_nested())) return false;
20382                         { type = 1; return true;}
20383                         return false;
20384
20385                 }
20386                 template<typename V> bool encode(V& v) const
20387                 {
20388                         return v(ref_nested());
20389
20390                 }
20391                 protected:
20392                 template<typename V>  bool decode(size_t index, V& v)
20393                 {
20394                         clear();
20395                         switch(index)
20396                         {
20397                         case 1: type = 1; return v(ref_nested());
20398                         ref_nested().clear();
20399                         }
20400                         return false;
20401
20402                 }
20403                 template<typename V> bool encode(size_t index, V& v) const
20404                 {
20405                         if(index != type) {return false;} return v(ref_nested());
20406
20407                 }
20408                 private:
20409                 size_t type {0};
20410
20411         };
20412         struct Extension_t : asn::typefield<true>
20413         {
20414                 ~Extension_t()  {clear();}
20415                 size_t get_index() const {return type;}
20416                 bool is_unknown() const { return type == 1; }
20417                 void clear()
20418                 {
20419                         type = 0; ref_nested().clear();
20420                 }
20421                 template<typename V> static inline void enumerate(V& v)
20422                 {
20423
20424                 }
20425                 protected:
20426                 template<typename V> bool decode(size_t index, V& v)
20427                 {
20428                         clear();
20429                         switch(index)
20430                         {
20431                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
20432                         }
20433                         return false;
20434
20435                 }
20436                 template<typename V> bool encode(size_t index, V& v) const
20437                 {
20438                         if(index != type) return false;
20439                         return false;
20440
20441                 }
20442                 private:
20443                 size_t type {0};
20444
20445         };
20446         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
20447         {
20448                 size_t get_index() const {return type;}
20449                 bool is_unknown() const { return type == 1; }
20450                 void clear() {type = 0;}
20451                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
20452                 template<typename V>  bool decode(V& v)
20453                 {
20454                         clear();
20455                         if(!v(ref_nested())) return false;
20456                         { type = 1; return true;}
20457                         return false;
20458
20459                 }
20460                 template<typename V> bool encode(V& v) const
20461                 {
20462                         return v(ref_nested());
20463
20464                 }
20465                 protected:
20466                 template<typename V>  bool decode(size_t index, V& v)
20467                 {
20468                         clear();
20469                         switch(index)
20470                         {
20471                         case 1: type = 1; return v(ref_nested());
20472                         ref_nested().clear();
20473                         }
20474                         return false;
20475
20476                 }
20477                 template<typename V> bool encode(size_t index, V& v) const
20478                 {
20479                         if(index != type) {return false;} return v(ref_nested());
20480
20481                 }
20482                 private:
20483                 size_t type {0};
20484
20485         };
20486
20487 };
20488 /*
20489 HWLoadIndicator ::= SEQUENCE {
20490         dLHWLoadIndicator                       LoadIndicator,
20491         uLHWLoadIndicator                       LoadIndicator,
20492         iE-Extensions                           ProtocolExtensionContainer { {HWLoadIndicator-ExtIEs} } OPTIONAL,
20493         ...
20494 }
20495 */
20496
20497 struct HWLoadIndicator : asn::sequence<3, 0, true, 1>
20498 {
20499         static constexpr const char* name() {return "HWLoadIndicator";}
20500         using parent_t = asn::sequence<3, 0, true, 1>;
20501         struct dLHWLoadIndicator_t : LoadIndicator
20502         {
20503                 static constexpr const char* name() {return "dLHWLoadIndicator_t";}
20504                 using parent_t = LoadIndicator;
20505
20506         };
20507         dLHWLoadIndicator_t& ref_dLHWLoadIndicator() {return dLHWLoadIndicator;}
20508         dLHWLoadIndicator_t const& ref_dLHWLoadIndicator() const {return dLHWLoadIndicator;}
20509         struct uLHWLoadIndicator_t : LoadIndicator
20510         {
20511                 static constexpr const char* name() {return "uLHWLoadIndicator_t";}
20512                 using parent_t = LoadIndicator;
20513
20514         };
20515         uLHWLoadIndicator_t& ref_uLHWLoadIndicator() {return uLHWLoadIndicator;}
20516         uLHWLoadIndicator_t const& ref_uLHWLoadIndicator() const {return uLHWLoadIndicator;}
20517         struct iE_Extensions_t : ProtocolExtensionContainer<HWLoadIndicator_ExtIEs>
20518         {
20519                 static constexpr const char* name() {return "iE_Extensions_t";}
20520                 using parent_t = ProtocolExtensionContainer<HWLoadIndicator_ExtIEs>;
20521                 static constexpr bool optional = true;
20522
20523         };
20524         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
20525         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
20526         template<typename V> void decode(V& v)
20527         {
20528                 v(dLHWLoadIndicator);
20529                 v(uLHWLoadIndicator);
20530                 v(iE_Extensions);
20531
20532         };
20533         template<typename V> void encode(V& v) const
20534         {
20535                 v(dLHWLoadIndicator);
20536                 v(uLHWLoadIndicator);
20537                 v(iE_Extensions);
20538
20539         };
20540         void clear()
20541         {
20542                 dLHWLoadIndicator.clear();
20543                 uLHWLoadIndicator.clear();
20544                 iE_Extensions.clear();
20545
20546         };
20547         private:
20548         dLHWLoadIndicator_t     dLHWLoadIndicator;
20549         uLHWLoadIndicator_t     uLHWLoadIndicator;
20550         iE_Extensions_t iE_Extensions;
20551
20552 };
20553 /*
20554 HandoverReportType ::= ENUMERATED {
20555         hoTooEarly,
20556         hoToWrongCell,
20557         ...,
20558         interRATpingpong
20559 }
20560 */
20561
20562 struct HandoverReportType : asn::enumerated<3, 1, true>
20563 {
20564         static constexpr const char* name() {return "HandoverReportType";}
20565         using parent_t = asn::enumerated<3, 1, true>;
20566         typedef enum {
20567                 hoTooEarly
20568                 ,hoToWrongCell
20569                 ,interRATpingpong
20570         } index_t;
20571
20572 };
20573
20574 /*
20575 NRrestrictioninEPSasSecondaryRAT ::= ENUMERATED {
20576         nRrestrictedinEPSasSecondaryRAT,
20577         ...
20578 }
20579 */
20580
20581 struct NRrestrictioninEPSasSecondaryRAT : asn::enumerated<1, 0, true>
20582 {
20583         static constexpr const char* name() {return "NRrestrictioninEPSasSecondaryRAT";}
20584         using parent_t = asn::enumerated<1, 0, true>;
20585         typedef enum {
20586                 nRrestrictedinEPSasSecondaryRAT
20587         } index_t;
20588
20589 };
20590
20591 /*
20592 NRrestrictionin5GS ::= ENUMERATED {
20593         nRrestrictedin5GS,
20594         ...
20595 }
20596 */
20597
20598 struct NRrestrictionin5GS : asn::enumerated<1, 0, true>
20599 {
20600         static constexpr const char* name() {return "NRrestrictionin5GS";}
20601         using parent_t = asn::enumerated<1, 0, true>;
20602         typedef enum {
20603                 nRrestrictedin5GS
20604         } index_t;
20605
20606 };
20607
20608 /*
20609 HandoverRestrictionList-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
20610         { ID id-NRrestrictioninEPSasSecondaryRAT                        CRITICALITY ignore      EXTENSION NRrestrictioninEPSasSecondaryRAT                      PRESENCE optional}|
20611         { ID id-CNTypeRestrictions                                              CRITICALITY ignore      EXTENSION CNTypeRestrictions                                                            PRESENCE optional}|
20612         { ID id-NRrestrictionin5GS                                              CRITICALITY ignore      EXTENSION NRrestrictionin5GS                                                            PRESENCE optional},
20613         ...
20614 }
20615 */
20616
20617 struct HandoverRestrictionList_ExtIEs
20618 {
20619         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
20620         {
20621                 size_t get_index() const {return type;}
20622                 bool is_unknown() const { return type == 4; }
20623                 void clear() {type = 0;}
20624                 void select_id_NRrestrictioninEPSasSecondaryRAT() { set(id_NRrestrictioninEPSasSecondaryRAT); type=1;}
20625                 void select_id_CNTypeRestrictions() { set(id_CNTypeRestrictions); type=2;}
20626                 void select_id_NRrestrictionin5GS() { set(id_NRrestrictionin5GS); type=3;}
20627                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
20628                 template<typename V>  bool decode(V& v)
20629                 {
20630                         clear();
20631                         if(!v(ref_nested())) return false;
20632                         if(equal(id_NRrestrictioninEPSasSecondaryRAT)) { type = 1; return true; }
20633                         else if(equal(id_CNTypeRestrictions)) { type = 2; return true; }
20634                         else if(equal(id_NRrestrictionin5GS)) { type = 3; return true; }
20635                         else { type = 4; return true;}
20636                         return false;
20637
20638                 }
20639                 template<typename V> bool encode(V& v) const
20640                 {
20641                         return v(ref_nested());
20642
20643                 }
20644                 protected:
20645                 template<typename V>  bool decode(size_t index, V& v)
20646                 {
20647                         clear();
20648                         switch(index)
20649                         {
20650                         case 1: type = 1; if(v(ref_nested())) { return equal(id_NRrestrictioninEPSasSecondaryRAT);} return false;
20651                         case 2: type = 2; if(v(ref_nested())) { return equal(id_CNTypeRestrictions);} return false;
20652                         case 3: type = 3; if(v(ref_nested())) { return equal(id_NRrestrictionin5GS);} return false;
20653                         case 4: type = 4; return v(ref_nested());
20654                         ref_nested().clear();
20655                         }
20656                         return false;
20657
20658                 }
20659                 template<typename V> bool encode(size_t index, V& v) const
20660                 {
20661                         if(index != type) {return false;} return v(ref_nested());
20662
20663                 }
20664                 private:
20665                 size_t type {0};
20666
20667         };
20668         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
20669         {
20670                 size_t get_index() const {return type;}
20671                 bool is_unknown() const { return type == 4; }
20672                 void clear() {type = 0;}
20673                 void select_id_NRrestrictioninEPSasSecondaryRAT() { set(ignore); type=1;}
20674                 void select_id_CNTypeRestrictions() { set(ignore); type=2;}
20675                 void select_id_NRrestrictionin5GS() { set(ignore); type=3;}
20676                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
20677                 template<typename V>  bool decode(V& v)
20678                 {
20679                         clear();
20680                         if(!v(ref_nested())) return false;
20681                         if(equal(ignore)) { type = 1; return true; }
20682                         else if(equal(ignore)) { type = 2; return true; }
20683                         else if(equal(ignore)) { type = 3; return true; }
20684                         else { type = 4; return true;}
20685                         return false;
20686
20687                 }
20688                 template<typename V> bool encode(V& v) const
20689                 {
20690                         return v(ref_nested());
20691
20692                 }
20693                 protected:
20694                 template<typename V>  bool decode(size_t index, V& v)
20695                 {
20696                         clear();
20697                         switch(index)
20698                         {
20699                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
20700                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
20701                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
20702                         case 4: type = 4; return v(ref_nested());
20703                         ref_nested().clear();
20704                         }
20705                         return false;
20706
20707                 }
20708                 template<typename V> bool encode(size_t index, V& v) const
20709                 {
20710                         if(index != type) {return false;} return v(ref_nested());
20711
20712                 }
20713                 private:
20714                 size_t type {0};
20715
20716         };
20717         struct Extension_t : asn::typefield<true>
20718         {
20719                 ~Extension_t()  {clear();}
20720                 size_t get_index() const {return type;}
20721                 NRrestrictioninEPSasSecondaryRAT& select_id_NRrestrictioninEPSasSecondaryRAT() { return set<NRrestrictioninEPSasSecondaryRAT>(1); }
20722                 NRrestrictioninEPSasSecondaryRAT const* get_id_NRrestrictioninEPSasSecondaryRAT() const { return get<NRrestrictioninEPSasSecondaryRAT>(1); }
20723                 CNTypeRestrictions& select_id_CNTypeRestrictions() { return set<CNTypeRestrictions>(2); }
20724                 CNTypeRestrictions const* get_id_CNTypeRestrictions() const { return get<CNTypeRestrictions>(2); }
20725                 NRrestrictionin5GS& select_id_NRrestrictionin5GS() { return set<NRrestrictionin5GS>(3); }
20726                 NRrestrictionin5GS const* get_id_NRrestrictionin5GS() const { return get<NRrestrictionin5GS>(3); }
20727                 bool is_unknown() const { return type == 4; }
20728                 void clear()
20729                 {
20730                         switch(type)
20731                         {
20732                         case 1: var.destroy<NRrestrictioninEPSasSecondaryRAT>(); break;
20733                         case 2: var.destroy<CNTypeRestrictions>(); break;
20734                         case 3: var.destroy<NRrestrictionin5GS>(); break;
20735                         }
20736                         type = 0; ref_nested().clear();
20737                 }
20738                 template<typename V> static inline void enumerate(V& v)
20739                 {
20740                         v.template operator()<NRrestrictioninEPSasSecondaryRAT>(1);
20741                         v.template operator()<CNTypeRestrictions>(2);
20742                         v.template operator()<NRrestrictionin5GS>(3);
20743
20744                 }
20745                 protected:
20746                 template<typename V> bool decode(size_t index, V& v)
20747                 {
20748                         clear();
20749                         switch(index)
20750                         {
20751                         case 1: v(select_id_NRrestrictioninEPSasSecondaryRAT()); return true;
20752                         case 2: v(select_id_CNTypeRestrictions()); return true;
20753                         case 3: v(select_id_NRrestrictionin5GS()); return true;
20754                         case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
20755                         }
20756                         return false;
20757
20758                 }
20759                 template<typename V> bool encode(size_t index, V& v) const
20760                 {
20761                         if(index != type) return false;
20762                         switch(type)
20763                         {
20764                         case 1: v(var.as<NRrestrictioninEPSasSecondaryRAT>()); return true;
20765                         case 2: v(var.as<CNTypeRestrictions>()); return true;
20766                         case 3: v(var.as<NRrestrictionin5GS>()); return true;
20767                         }
20768                         return false;
20769
20770                 }
20771                 private:
20772                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
20773                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
20774                 union union_type
20775                 {
20776                         char dummy1[sizeof(CNTypeRestrictions)];
20777                         char dummy2[sizeof(NRrestrictionin5GS)];
20778                         char dummy3[sizeof(NRrestrictioninEPSasSecondaryRAT)];
20779
20780                 };
20781                 asn::variant<sizeof(union_type)> var;
20782                 size_t type {0};
20783
20784         };
20785         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
20786         {
20787                 size_t get_index() const {return type;}
20788                 bool is_unknown() const { return type == 4; }
20789                 void clear() {type = 0;}
20790                 void select_id_NRrestrictioninEPSasSecondaryRAT() { set(optional); type=1;}
20791                 void select_id_CNTypeRestrictions() { set(optional); type=2;}
20792                 void select_id_NRrestrictionin5GS() { set(optional); type=3;}
20793                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
20794                 template<typename V>  bool decode(V& v)
20795                 {
20796                         clear();
20797                         if(!v(ref_nested())) return false;
20798                         if(equal(optional)) { type = 1; return true; }
20799                         else if(equal(optional)) { type = 2; return true; }
20800                         else if(equal(optional)) { type = 3; return true; }
20801                         else { type = 4; return true;}
20802                         return false;
20803
20804                 }
20805                 template<typename V> bool encode(V& v) const
20806                 {
20807                         return v(ref_nested());
20808
20809                 }
20810                 protected:
20811                 template<typename V>  bool decode(size_t index, V& v)
20812                 {
20813                         clear();
20814                         switch(index)
20815                         {
20816                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
20817                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
20818                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
20819                         case 4: type = 4; return v(ref_nested());
20820                         ref_nested().clear();
20821                         }
20822                         return false;
20823
20824                 }
20825                 template<typename V> bool encode(size_t index, V& v) const
20826                 {
20827                         if(index != type) {return false;} return v(ref_nested());
20828
20829                 }
20830                 private:
20831                 size_t type {0};
20832
20833         };
20834
20835 };
20836 /*
20837 HandoverRestrictionList ::= SEQUENCE {
20838         servingPLMN                                     PLMN-Identity,
20839         equivalentPLMNs                         EPLMNs                                  OPTIONAL,
20840         forbiddenTAs                            ForbiddenTAs                    OPTIONAL,
20841         forbiddenLAs                            ForbiddenLAs                    OPTIONAL,
20842         forbiddenInterRATs                      ForbiddenInterRATs              OPTIONAL,
20843         iE-Extensions                           ProtocolExtensionContainer { {HandoverRestrictionList-ExtIEs} } OPTIONAL,
20844         ...
20845 }
20846 */
20847
20848 struct HandoverRestrictionList : asn::sequence<6, 0, true, 5>
20849 {
20850         static constexpr const char* name() {return "HandoverRestrictionList";}
20851         using parent_t = asn::sequence<6, 0, true, 5>;
20852         struct servingPLMN_t : PLMN_Identity
20853         {
20854                 static constexpr const char* name() {return "servingPLMN_t";}
20855                 using parent_t = PLMN_Identity;
20856
20857         };
20858         servingPLMN_t& ref_servingPLMN() {return servingPLMN;}
20859         servingPLMN_t const& ref_servingPLMN() const {return servingPLMN;}
20860         struct equivalentPLMNs_t : EPLMNs
20861         {
20862                 static constexpr const char* name() {return "equivalentPLMNs_t";}
20863                 using parent_t = EPLMNs;
20864                 static constexpr bool optional = true;
20865
20866         };
20867         equivalentPLMNs_t& set_equivalentPLMNs() { equivalentPLMNs.setpresent(true); return equivalentPLMNs;}
20868         equivalentPLMNs_t const* get_equivalentPLMNs() const {return equivalentPLMNs.is_valid() ? &equivalentPLMNs : nullptr;}
20869         struct forbiddenTAs_t : ForbiddenTAs
20870         {
20871                 static constexpr const char* name() {return "forbiddenTAs_t";}
20872                 using parent_t = ForbiddenTAs;
20873                 static constexpr bool optional = true;
20874
20875         };
20876         forbiddenTAs_t& set_forbiddenTAs() { forbiddenTAs.setpresent(true); return forbiddenTAs;}
20877         forbiddenTAs_t const* get_forbiddenTAs() const {return forbiddenTAs.is_valid() ? &forbiddenTAs : nullptr;}
20878         struct forbiddenLAs_t : ForbiddenLAs
20879         {
20880                 static constexpr const char* name() {return "forbiddenLAs_t";}
20881                 using parent_t = ForbiddenLAs;
20882                 static constexpr bool optional = true;
20883
20884         };
20885         forbiddenLAs_t& set_forbiddenLAs() { forbiddenLAs.setpresent(true); return forbiddenLAs;}
20886         forbiddenLAs_t const* get_forbiddenLAs() const {return forbiddenLAs.is_valid() ? &forbiddenLAs : nullptr;}
20887         struct forbiddenInterRATs_t : ForbiddenInterRATs
20888         {
20889                 static constexpr const char* name() {return "forbiddenInterRATs_t";}
20890                 using parent_t = ForbiddenInterRATs;
20891                 static constexpr bool optional = true;
20892
20893         };
20894         forbiddenInterRATs_t& set_forbiddenInterRATs() { forbiddenInterRATs.setpresent(true); return forbiddenInterRATs;}
20895         forbiddenInterRATs_t const* get_forbiddenInterRATs() const {return forbiddenInterRATs.is_valid() ? &forbiddenInterRATs : nullptr;}
20896         struct iE_Extensions_t : ProtocolExtensionContainer<HandoverRestrictionList_ExtIEs>
20897         {
20898                 static constexpr const char* name() {return "iE_Extensions_t";}
20899                 using parent_t = ProtocolExtensionContainer<HandoverRestrictionList_ExtIEs>;
20900                 static constexpr bool optional = true;
20901
20902         };
20903         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
20904         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
20905         template<typename V> void decode(V& v)
20906         {
20907                 v(servingPLMN);
20908                 v(equivalentPLMNs);
20909                 v(forbiddenTAs);
20910                 v(forbiddenLAs);
20911                 v(forbiddenInterRATs);
20912                 v(iE_Extensions);
20913
20914         };
20915         template<typename V> void encode(V& v) const
20916         {
20917                 v(servingPLMN);
20918                 v(equivalentPLMNs);
20919                 v(forbiddenTAs);
20920                 v(forbiddenLAs);
20921                 v(forbiddenInterRATs);
20922                 v(iE_Extensions);
20923
20924         };
20925         void clear()
20926         {
20927                 servingPLMN.clear();
20928                 equivalentPLMNs.clear();
20929                 forbiddenTAs.clear();
20930                 forbiddenLAs.clear();
20931                 forbiddenInterRATs.clear();
20932                 iE_Extensions.clear();
20933
20934         };
20935         private:
20936         servingPLMN_t   servingPLMN;
20937         equivalentPLMNs_t       equivalentPLMNs;
20938         forbiddenTAs_t  forbiddenTAs;
20939         forbiddenLAs_t  forbiddenLAs;
20940         forbiddenInterRATs_t    forbiddenInterRATs;
20941         iE_Extensions_t iE_Extensions;
20942
20943 };
20944 /*
20945 IntegrityProtectionAlgorithms ::= BIT STRING (SIZE (16, ...))
20946 */
20947
20948 struct IntegrityProtectionAlgorithms : asn::bstring<>
20949 {
20950         using constraint_t = asn::constraints<true,asn::one<16>>;
20951         static constexpr const char* name() {return "IntegrityProtectionAlgorithms";}
20952         using parent_t = asn::bstring<>;
20953
20954 };
20955
20956 /*
20957 InterfacesToTrace ::= BIT STRING (SIZE (8))
20958 */
20959
20960 struct InterfacesToTrace : asn::bstring<>
20961 {
20962         using constraint_t = asn::constraints<false,asn::one<8>>;
20963         static constexpr const char* name() {return "InterfacesToTrace";}
20964         using parent_t = asn::bstring<>;
20965
20966 };
20967
20968 /*
20969 InvokeIndication ::= ENUMERATED{
20970         abs-information,
20971         ...,
20972         naics-information-start,
20973         naics-information-stop
20974 }
20975 */
20976
20977 struct InvokeIndication : asn::enumerated<3, 2, true>
20978 {
20979         static constexpr const char* name() {return "InvokeIndication";}
20980         using parent_t = asn::enumerated<3, 2, true>;
20981         typedef enum {
20982                 abs_information
20983                 ,naics_information_start
20984                 ,naics_information_stop
20985         } index_t;
20986
20987 };
20988
20989 /*
20990 LCID ::= INTEGER(1..32, ...)
20991 */
20992
20993 struct LCID : asn::integer<>
20994 {
20995         using constraint_t = asn::constraints<true,asn::span<1, 32>>;
20996         static constexpr const char* name() {return "LCID";}
20997         using parent_t = asn::integer<>;
20998
20999 };
21000
21001 /*
21002 LHN-ID ::= OCTET STRING(SIZE (32..256))
21003 */
21004
21005 struct LHN_ID : asn::ostring<>
21006 {
21007         using constraint_t = asn::constraints<false,asn::span<32, 256>>;
21008         static constexpr const char* name() {return "LHN-ID";}
21009         using parent_t = asn::ostring<>;
21010
21011 };
21012
21013 /*
21014 Time-UE-StayedInCell ::= INTEGER (0..4095)
21015 */
21016
21017 struct Time_UE_StayedInCell : asn::integer<>
21018 {
21019         using constraint_t = asn::constraints<false,asn::span<0, 4095>>;
21020         static constexpr const char* name() {return "Time-UE-StayedInCell";}
21021         using parent_t = asn::integer<>;
21022
21023 };
21024
21025 /*
21026 Time-UE-StayedInCell-EnhancedGranularity ::= INTEGER (0..40950)
21027 */
21028
21029 struct Time_UE_StayedInCell_EnhancedGranularity : asn::integer<>
21030 {
21031         using constraint_t = asn::constraints<false,asn::span<0, 40950>>;
21032         static constexpr const char* name() {return "Time-UE-StayedInCell-EnhancedGranularity";}
21033         using parent_t = asn::integer<>;
21034
21035 };
21036
21037 /*
21038 LastVisitedEUTRANCellInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
21039 -- Extension for Rel-11 to support enhanced granularity for time UE stayed in cell --
21040         { ID id-Time-UE-StayedInCell-EnhancedGranularity        CRITICALITY ignore      EXTENSION Time-UE-StayedInCell-EnhancedGranularity      PRESENCE optional}|
21041         { ID id-HO-cause                                                                        CRITICALITY ignore      EXTENSION Cause                                                                                                 PRESENCE optional},
21042         ...
21043 }
21044 */
21045
21046 struct LastVisitedEUTRANCellInformation_ExtIEs
21047 {
21048         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
21049         {
21050                 size_t get_index() const {return type;}
21051                 bool is_unknown() const { return type == 3; }
21052                 void clear() {type = 0;}
21053                 void select_id_Time_UE_StayedInCell_EnhancedGranularity() { set(id_Time_UE_StayedInCell_EnhancedGranularity); type=1;}
21054                 void select_id_HO_cause() { set(id_HO_cause); type=2;}
21055                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
21056                 template<typename V>  bool decode(V& v)
21057                 {
21058                         clear();
21059                         if(!v(ref_nested())) return false;
21060                         if(equal(id_Time_UE_StayedInCell_EnhancedGranularity)) { type = 1; return true; }
21061                         else if(equal(id_HO_cause)) { type = 2; return true; }
21062                         else { type = 3; return true;}
21063                         return false;
21064
21065                 }
21066                 template<typename V> bool encode(V& v) const
21067                 {
21068                         return v(ref_nested());
21069
21070                 }
21071                 protected:
21072                 template<typename V>  bool decode(size_t index, V& v)
21073                 {
21074                         clear();
21075                         switch(index)
21076                         {
21077                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Time_UE_StayedInCell_EnhancedGranularity);} return false;
21078                         case 2: type = 2; if(v(ref_nested())) { return equal(id_HO_cause);} return false;
21079                         case 3: type = 3; return v(ref_nested());
21080                         ref_nested().clear();
21081                         }
21082                         return false;
21083
21084                 }
21085                 template<typename V> bool encode(size_t index, V& v) const
21086                 {
21087                         if(index != type) {return false;} return v(ref_nested());
21088
21089                 }
21090                 private:
21091                 size_t type {0};
21092
21093         };
21094         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
21095         {
21096                 size_t get_index() const {return type;}
21097                 bool is_unknown() const { return type == 3; }
21098                 void clear() {type = 0;}
21099                 void select_id_Time_UE_StayedInCell_EnhancedGranularity() { set(ignore); type=1;}
21100                 void select_id_HO_cause() { set(ignore); type=2;}
21101                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
21102                 template<typename V>  bool decode(V& v)
21103                 {
21104                         clear();
21105                         if(!v(ref_nested())) return false;
21106                         if(equal(ignore)) { type = 1; return true; }
21107                         else if(equal(ignore)) { type = 2; return true; }
21108                         else { type = 3; return true;}
21109                         return false;
21110
21111                 }
21112                 template<typename V> bool encode(V& v) const
21113                 {
21114                         return v(ref_nested());
21115
21116                 }
21117                 protected:
21118                 template<typename V>  bool decode(size_t index, V& v)
21119                 {
21120                         clear();
21121                         switch(index)
21122                         {
21123                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
21124                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
21125                         case 3: type = 3; return v(ref_nested());
21126                         ref_nested().clear();
21127                         }
21128                         return false;
21129
21130                 }
21131                 template<typename V> bool encode(size_t index, V& v) const
21132                 {
21133                         if(index != type) {return false;} return v(ref_nested());
21134
21135                 }
21136                 private:
21137                 size_t type {0};
21138
21139         };
21140         struct Extension_t : asn::typefield<true>
21141         {
21142                 ~Extension_t()  {clear();}
21143                 size_t get_index() const {return type;}
21144                 Time_UE_StayedInCell_EnhancedGranularity& select_id_Time_UE_StayedInCell_EnhancedGranularity() { return set<Time_UE_StayedInCell_EnhancedGranularity>(1); }
21145                 Time_UE_StayedInCell_EnhancedGranularity const* get_id_Time_UE_StayedInCell_EnhancedGranularity() const { return get<Time_UE_StayedInCell_EnhancedGranularity>(1); }
21146                 Cause& select_id_HO_cause() { return set<Cause>(2); }
21147                 Cause const* get_id_HO_cause() const { return get<Cause>(2); }
21148                 bool is_unknown() const { return type == 3; }
21149                 void clear()
21150                 {
21151                         switch(type)
21152                         {
21153                         case 1: var.destroy<Time_UE_StayedInCell_EnhancedGranularity>(); break;
21154                         case 2: var.destroy<Cause>(); break;
21155                         }
21156                         type = 0; ref_nested().clear();
21157                 }
21158                 template<typename V> static inline void enumerate(V& v)
21159                 {
21160                         v.template operator()<Time_UE_StayedInCell_EnhancedGranularity>(1);
21161                         v.template operator()<Cause>(2);
21162
21163                 }
21164                 protected:
21165                 template<typename V> bool decode(size_t index, V& v)
21166                 {
21167                         clear();
21168                         switch(index)
21169                         {
21170                         case 1: v(select_id_Time_UE_StayedInCell_EnhancedGranularity()); return true;
21171                         case 2: v(select_id_HO_cause()); return true;
21172                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
21173                         }
21174                         return false;
21175
21176                 }
21177                 template<typename V> bool encode(size_t index, V& v) const
21178                 {
21179                         if(index != type) return false;
21180                         switch(type)
21181                         {
21182                         case 1: v(var.as<Time_UE_StayedInCell_EnhancedGranularity>()); return true;
21183                         case 2: v(var.as<Cause>()); return true;
21184                         }
21185                         return false;
21186
21187                 }
21188                 private:
21189                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
21190                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
21191                 union union_type
21192                 {
21193                         char dummy1[sizeof(Cause)];
21194                         char dummy2[sizeof(Time_UE_StayedInCell_EnhancedGranularity)];
21195
21196                 };
21197                 asn::variant<sizeof(union_type)> var;
21198                 size_t type {0};
21199
21200         };
21201         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
21202         {
21203                 size_t get_index() const {return type;}
21204                 bool is_unknown() const { return type == 3; }
21205                 void clear() {type = 0;}
21206                 void select_id_Time_UE_StayedInCell_EnhancedGranularity() { set(optional); type=1;}
21207                 void select_id_HO_cause() { set(optional); type=2;}
21208                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
21209                 template<typename V>  bool decode(V& v)
21210                 {
21211                         clear();
21212                         if(!v(ref_nested())) return false;
21213                         if(equal(optional)) { type = 1; return true; }
21214                         else if(equal(optional)) { type = 2; return true; }
21215                         else { type = 3; return true;}
21216                         return false;
21217
21218                 }
21219                 template<typename V> bool encode(V& v) const
21220                 {
21221                         return v(ref_nested());
21222
21223                 }
21224                 protected:
21225                 template<typename V>  bool decode(size_t index, V& v)
21226                 {
21227                         clear();
21228                         switch(index)
21229                         {
21230                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
21231                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
21232                         case 3: type = 3; return v(ref_nested());
21233                         ref_nested().clear();
21234                         }
21235                         return false;
21236
21237                 }
21238                 template<typename V> bool encode(size_t index, V& v) const
21239                 {
21240                         if(index != type) {return false;} return v(ref_nested());
21241
21242                 }
21243                 private:
21244                 size_t type {0};
21245
21246         };
21247
21248 };
21249 /*
21250 LastVisitedEUTRANCellInformation ::= SEQUENCE {
21251         global-Cell-ID                                  ECGI,
21252         cellType                                                CellType,
21253         time-UE-StayedInCell                    Time-UE-StayedInCell,
21254         iE-Extensions                                   ProtocolExtensionContainer { {LastVisitedEUTRANCellInformation-ExtIEs} } OPTIONAL,
21255         ...
21256 }
21257 */
21258
21259 struct LastVisitedEUTRANCellInformation : asn::sequence<4, 0, true, 1>
21260 {
21261         static constexpr const char* name() {return "LastVisitedEUTRANCellInformation";}
21262         using parent_t = asn::sequence<4, 0, true, 1>;
21263         struct global_Cell_ID_t : ECGI
21264         {
21265                 static constexpr const char* name() {return "global_Cell_ID_t";}
21266                 using parent_t = ECGI;
21267
21268         };
21269         global_Cell_ID_t& ref_global_Cell_ID() {return global_Cell_ID;}
21270         global_Cell_ID_t const& ref_global_Cell_ID() const {return global_Cell_ID;}
21271         struct cellType_t : CellType
21272         {
21273                 static constexpr const char* name() {return "cellType_t";}
21274                 using parent_t = CellType;
21275
21276         };
21277         cellType_t& ref_cellType() {return cellType;}
21278         cellType_t const& ref_cellType() const {return cellType;}
21279         struct time_UE_StayedInCell_t : Time_UE_StayedInCell
21280         {
21281                 static constexpr const char* name() {return "time_UE_StayedInCell_t";}
21282                 using parent_t = Time_UE_StayedInCell;
21283
21284         };
21285         time_UE_StayedInCell_t& ref_time_UE_StayedInCell() {return time_UE_StayedInCell;}
21286         time_UE_StayedInCell_t const& ref_time_UE_StayedInCell() const {return time_UE_StayedInCell;}
21287         struct iE_Extensions_t : ProtocolExtensionContainer<LastVisitedEUTRANCellInformation_ExtIEs>
21288         {
21289                 static constexpr const char* name() {return "iE_Extensions_t";}
21290                 using parent_t = ProtocolExtensionContainer<LastVisitedEUTRANCellInformation_ExtIEs>;
21291                 static constexpr bool optional = true;
21292
21293         };
21294         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
21295         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
21296         template<typename V> void decode(V& v)
21297         {
21298                 v(global_Cell_ID);
21299                 v(cellType);
21300                 v(time_UE_StayedInCell);
21301                 v(iE_Extensions);
21302
21303         };
21304         template<typename V> void encode(V& v) const
21305         {
21306                 v(global_Cell_ID);
21307                 v(cellType);
21308                 v(time_UE_StayedInCell);
21309                 v(iE_Extensions);
21310
21311         };
21312         void clear()
21313         {
21314                 global_Cell_ID.clear();
21315                 cellType.clear();
21316                 time_UE_StayedInCell.clear();
21317                 iE_Extensions.clear();
21318
21319         };
21320         private:
21321         global_Cell_ID_t        global_Cell_ID;
21322         cellType_t      cellType;
21323         time_UE_StayedInCell_t  time_UE_StayedInCell;
21324         iE_Extensions_t iE_Extensions;
21325
21326 };
21327 /*
21328 LastVisitedUTRANCellInformation ::= OCTET STRING
21329 */
21330
21331 struct LastVisitedUTRANCellInformation : asn::ostring<>
21332 {
21333         static constexpr const char* name() {return "LastVisitedUTRANCellInformation";}
21334         using parent_t = asn::ostring<>;
21335
21336 };
21337
21338 /*
21339 LastVisitedGERANCellInformation ::= CHOICE {
21340         undefined                                               NULL,
21341         ...
21342 }
21343 */
21344
21345 struct LastVisitedGERANCellInformation : asn::choice<1, 0, true>
21346 {
21347         static constexpr const char* name() {return "LastVisitedGERANCellInformation";}
21348         using parent_t = asn::choice<1, 0, true>;
21349         index_type get_index() const {return index;}
21350         bool is_unknown() const {return index == 2;}
21351         void set_unknown() { set_index(2);  }
21352         ~LastVisitedGERANCellInformation() {clear();}
21353         struct undefined_t : asn::nulltype
21354         {
21355                 static constexpr const char* name() {return "undefined_t";}
21356                 using parent_t = asn::nulltype;
21357
21358         };
21359         void clear()
21360         {
21361                 switch(get_index())
21362                 {
21363                 case 1: var.destroy<undefined_t>(); break;
21364                 }
21365                 index = 0;
21366                 base::clear();
21367         }
21368         template<typename V> bool decode(size_t idx, V& v)
21369         {
21370                 clear();
21371                 switch(idx)
21372                 {
21373                 case 1: set_index(1); return v(var.build<undefined_t>());
21374                 }
21375                 return false;
21376
21377         }
21378         template<typename V> bool encode(V& v) const
21379         {
21380                 switch(get_index())
21381                 {
21382                 case 1: return v(var.as<undefined_t>());
21383                 }
21384                 return false;
21385         }
21386         template<typename V> static inline void enumerate(V& v)
21387         {
21388                 v.template operator()<undefined_t>(1);
21389
21390         }
21391         undefined_t& select_undefined() { if(get_index() != 1) { clear(); set_index(1); return var.build<undefined_t>();} return var.as<undefined_t>();}
21392         undefined_t const* get_undefined() const { if(get_index() == 1) { return &var.as<undefined_t>();} return nullptr; }
21393         private:
21394         void set_index(index_type i) {index = i; base::set();}
21395         union union_type
21396         {
21397                 char dummy1[sizeof(undefined_t)];
21398
21399         };
21400         asn::variant<sizeof(union_type)>        var;
21401         index_type      index {0};
21402 };
21403 /*
21404 LastVisitedNGRANCellInformation ::= OCTET STRING
21405 */
21406
21407 struct LastVisitedNGRANCellInformation : asn::ostring<>
21408 {
21409         static constexpr const char* name() {return "LastVisitedNGRANCellInformation";}
21410         using parent_t = asn::ostring<>;
21411
21412 };
21413
21414 /*
21415 LastVisitedCell-Item ::= CHOICE {
21416         e-UTRAN-Cell                                    LastVisitedEUTRANCellInformation,
21417         uTRAN-Cell                                              LastVisitedUTRANCellInformation,
21418         gERAN-Cell                                              LastVisitedGERANCellInformation,
21419         ...,
21420         nG-RAN-Cell                                             LastVisitedNGRANCellInformation
21421 }
21422 */
21423
21424 struct LastVisitedCell_Item : asn::choice<4, 1, true>
21425 {
21426         static constexpr const char* name() {return "LastVisitedCell-Item";}
21427         using parent_t = asn::choice<4, 1, true>;
21428         index_type get_index() const {return index;}
21429         bool is_unknown() const {return index == 5;}
21430         void set_unknown() { set_index(5);  }
21431         ~LastVisitedCell_Item() {clear();}
21432         struct e_UTRAN_Cell_t : LastVisitedEUTRANCellInformation
21433         {
21434                 static constexpr const char* name() {return "e_UTRAN_Cell_t";}
21435                 using parent_t = LastVisitedEUTRANCellInformation;
21436
21437         };
21438         struct uTRAN_Cell_t : LastVisitedUTRANCellInformation
21439         {
21440                 static constexpr const char* name() {return "uTRAN_Cell_t";}
21441                 using parent_t = LastVisitedUTRANCellInformation;
21442
21443         };
21444         struct gERAN_Cell_t : LastVisitedGERANCellInformation
21445         {
21446                 static constexpr const char* name() {return "gERAN_Cell_t";}
21447                 using parent_t = LastVisitedGERANCellInformation;
21448
21449         };
21450         struct nG_RAN_Cell_t : LastVisitedNGRANCellInformation
21451         {
21452                 static constexpr const char* name() {return "nG_RAN_Cell_t";}
21453                 using parent_t = LastVisitedNGRANCellInformation;
21454
21455         };
21456         void clear()
21457         {
21458                 switch(get_index())
21459                 {
21460                 case 1: var.destroy<e_UTRAN_Cell_t>(); break;
21461                 case 2: var.destroy<uTRAN_Cell_t>(); break;
21462                 case 3: var.destroy<gERAN_Cell_t>(); break;
21463                 case 4: var.destroy<nG_RAN_Cell_t>(); break;
21464                 }
21465                 index = 0;
21466                 base::clear();
21467         }
21468         template<typename V> bool decode(size_t idx, V& v)
21469         {
21470                 clear();
21471                 switch(idx)
21472                 {
21473                 case 1: set_index(1); return v(var.build<e_UTRAN_Cell_t>());
21474                 case 2: set_index(2); return v(var.build<uTRAN_Cell_t>());
21475                 case 3: set_index(3); return v(var.build<gERAN_Cell_t>());
21476                 case 4: set_index(4); return v(var.build<nG_RAN_Cell_t>());
21477                 }
21478                 return false;
21479
21480         }
21481         template<typename V> bool encode(V& v) const
21482         {
21483                 switch(get_index())
21484                 {
21485                 case 1: return v(var.as<e_UTRAN_Cell_t>());
21486                 case 2: return v(var.as<uTRAN_Cell_t>());
21487                 case 3: return v(var.as<gERAN_Cell_t>());
21488                 case 4: return v(var.as<nG_RAN_Cell_t>());
21489                 }
21490                 return false;
21491         }
21492         template<typename V> static inline void enumerate(V& v)
21493         {
21494                 v.template operator()<e_UTRAN_Cell_t>(1);
21495                 v.template operator()<uTRAN_Cell_t>(2);
21496                 v.template operator()<gERAN_Cell_t>(3);
21497                 v.template operator()<nG_RAN_Cell_t>(4);
21498
21499         }
21500         e_UTRAN_Cell_t& select_e_UTRAN_Cell() { if(get_index() != 1) { clear(); set_index(1); return var.build<e_UTRAN_Cell_t>();} return var.as<e_UTRAN_Cell_t>();}
21501         e_UTRAN_Cell_t const* get_e_UTRAN_Cell() const { if(get_index() == 1) { return &var.as<e_UTRAN_Cell_t>();} return nullptr; }
21502         uTRAN_Cell_t& select_uTRAN_Cell() { if(get_index() != 2) { clear(); set_index(2); return var.build<uTRAN_Cell_t>();} return var.as<uTRAN_Cell_t>();}
21503         uTRAN_Cell_t const* get_uTRAN_Cell() const { if(get_index() == 2) { return &var.as<uTRAN_Cell_t>();} return nullptr; }
21504         gERAN_Cell_t& select_gERAN_Cell() { if(get_index() != 3) { clear(); set_index(3); return var.build<gERAN_Cell_t>();} return var.as<gERAN_Cell_t>();}
21505         gERAN_Cell_t const* get_gERAN_Cell() const { if(get_index() == 3) { return &var.as<gERAN_Cell_t>();} return nullptr; }
21506         nG_RAN_Cell_t& select_nG_RAN_Cell() { if(get_index() != 4) { clear(); set_index(4); return var.build<nG_RAN_Cell_t>();} return var.as<nG_RAN_Cell_t>();}
21507         nG_RAN_Cell_t const* get_nG_RAN_Cell() const { if(get_index() == 4) { return &var.as<nG_RAN_Cell_t>();} return nullptr; }
21508         private:
21509         void set_index(index_type i) {index = i; base::set();}
21510         union union_type
21511         {
21512                 char dummy1[sizeof(e_UTRAN_Cell_t)];
21513                 char dummy2[sizeof(uTRAN_Cell_t)];
21514                 char dummy3[sizeof(gERAN_Cell_t)];
21515                 char dummy4[sizeof(nG_RAN_Cell_t)];
21516
21517         };
21518         asn::variant<sizeof(union_type)>        var;
21519         index_type      index {0};
21520 };
21521 /*
21522 Links-to-log ::= ENUMERATED {uplink, downlink, both-uplink-and-downlink, ...}
21523 */
21524
21525 struct Links_to_log : asn::enumerated<3, 0, true>
21526 {
21527         static constexpr const char* name() {return "Links-to-log";}
21528         using parent_t = asn::enumerated<3, 0, true>;
21529         typedef enum {
21530                 uplink
21531                 ,downlink
21532                 ,both_uplink_and_downlink
21533         } index_t;
21534
21535 };
21536
21537 /*
21538 ReportArea ::= ENUMERATED{
21539         ecgi,
21540         ...
21541 }
21542 */
21543
21544 struct ReportArea : asn::enumerated<1, 0, true>
21545 {
21546         static constexpr const char* name() {return "ReportArea";}
21547         using parent_t = asn::enumerated<1, 0, true>;
21548         typedef enum {
21549                 ecgi
21550         } index_t;
21551
21552 };
21553
21554 /*
21555 LocationReportingInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::={
21556         ...
21557 }
21558 */
21559
21560 struct LocationReportingInformation_ExtIEs
21561 {
21562         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
21563         {
21564                 size_t get_index() const {return type;}
21565                 bool is_unknown() const { return type == 1; }
21566                 void clear() {type = 0;}
21567                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
21568                 template<typename V>  bool decode(V& v)
21569                 {
21570                         clear();
21571                         if(!v(ref_nested())) return false;
21572                         { type = 1; return true;}
21573                         return false;
21574
21575                 }
21576                 template<typename V> bool encode(V& v) const
21577                 {
21578                         return v(ref_nested());
21579
21580                 }
21581                 protected:
21582                 template<typename V>  bool decode(size_t index, V& v)
21583                 {
21584                         clear();
21585                         switch(index)
21586                         {
21587                         case 1: type = 1; return v(ref_nested());
21588                         ref_nested().clear();
21589                         }
21590                         return false;
21591
21592                 }
21593                 template<typename V> bool encode(size_t index, V& v) const
21594                 {
21595                         if(index != type) {return false;} return v(ref_nested());
21596
21597                 }
21598                 private:
21599                 size_t type {0};
21600
21601         };
21602         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
21603         {
21604                 size_t get_index() const {return type;}
21605                 bool is_unknown() const { return type == 1; }
21606                 void clear() {type = 0;}
21607                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
21608                 template<typename V>  bool decode(V& v)
21609                 {
21610                         clear();
21611                         if(!v(ref_nested())) return false;
21612                         { type = 1; return true;}
21613                         return false;
21614
21615                 }
21616                 template<typename V> bool encode(V& v) const
21617                 {
21618                         return v(ref_nested());
21619
21620                 }
21621                 protected:
21622                 template<typename V>  bool decode(size_t index, V& v)
21623                 {
21624                         clear();
21625                         switch(index)
21626                         {
21627                         case 1: type = 1; return v(ref_nested());
21628                         ref_nested().clear();
21629                         }
21630                         return false;
21631
21632                 }
21633                 template<typename V> bool encode(size_t index, V& v) const
21634                 {
21635                         if(index != type) {return false;} return v(ref_nested());
21636
21637                 }
21638                 private:
21639                 size_t type {0};
21640
21641         };
21642         struct Extension_t : asn::typefield<true>
21643         {
21644                 ~Extension_t()  {clear();}
21645                 size_t get_index() const {return type;}
21646                 bool is_unknown() const { return type == 1; }
21647                 void clear()
21648                 {
21649                         type = 0; ref_nested().clear();
21650                 }
21651                 template<typename V> static inline void enumerate(V& v)
21652                 {
21653
21654                 }
21655                 protected:
21656                 template<typename V> bool decode(size_t index, V& v)
21657                 {
21658                         clear();
21659                         switch(index)
21660                         {
21661                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
21662                         }
21663                         return false;
21664
21665                 }
21666                 template<typename V> bool encode(size_t index, V& v) const
21667                 {
21668                         if(index != type) return false;
21669                         return false;
21670
21671                 }
21672                 private:
21673                 size_t type {0};
21674
21675         };
21676         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
21677         {
21678                 size_t get_index() const {return type;}
21679                 bool is_unknown() const { return type == 1; }
21680                 void clear() {type = 0;}
21681                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
21682                 template<typename V>  bool decode(V& v)
21683                 {
21684                         clear();
21685                         if(!v(ref_nested())) return false;
21686                         { type = 1; return true;}
21687                         return false;
21688
21689                 }
21690                 template<typename V> bool encode(V& v) const
21691                 {
21692                         return v(ref_nested());
21693
21694                 }
21695                 protected:
21696                 template<typename V>  bool decode(size_t index, V& v)
21697                 {
21698                         clear();
21699                         switch(index)
21700                         {
21701                         case 1: type = 1; return v(ref_nested());
21702                         ref_nested().clear();
21703                         }
21704                         return false;
21705
21706                 }
21707                 template<typename V> bool encode(size_t index, V& v) const
21708                 {
21709                         if(index != type) {return false;} return v(ref_nested());
21710
21711                 }
21712                 private:
21713                 size_t type {0};
21714
21715         };
21716
21717 };
21718 /*
21719 LocationReportingInformation ::= SEQUENCE {
21720         eventType               EventType,
21721         reportArea              ReportArea,
21722         iE-Extensions           ProtocolExtensionContainer { {LocationReportingInformation-ExtIEs} } OPTIONAL,
21723         ...
21724 }
21725 */
21726
21727 struct LocationReportingInformation : asn::sequence<3, 0, true, 1>
21728 {
21729         static constexpr const char* name() {return "LocationReportingInformation";}
21730         using parent_t = asn::sequence<3, 0, true, 1>;
21731         struct eventType_t : EventType
21732         {
21733                 static constexpr const char* name() {return "eventType_t";}
21734                 using parent_t = EventType;
21735
21736         };
21737         eventType_t& ref_eventType() {return eventType;}
21738         eventType_t const& ref_eventType() const {return eventType;}
21739         struct reportArea_t : ReportArea
21740         {
21741                 static constexpr const char* name() {return "reportArea_t";}
21742                 using parent_t = ReportArea;
21743
21744         };
21745         reportArea_t& ref_reportArea() {return reportArea;}
21746         reportArea_t const& ref_reportArea() const {return reportArea;}
21747         struct iE_Extensions_t : ProtocolExtensionContainer<LocationReportingInformation_ExtIEs>
21748         {
21749                 static constexpr const char* name() {return "iE_Extensions_t";}
21750                 using parent_t = ProtocolExtensionContainer<LocationReportingInformation_ExtIEs>;
21751                 static constexpr bool optional = true;
21752
21753         };
21754         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
21755         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
21756         template<typename V> void decode(V& v)
21757         {
21758                 v(eventType);
21759                 v(reportArea);
21760                 v(iE_Extensions);
21761
21762         };
21763         template<typename V> void encode(V& v) const
21764         {
21765                 v(eventType);
21766                 v(reportArea);
21767                 v(iE_Extensions);
21768
21769         };
21770         void clear()
21771         {
21772                 eventType.clear();
21773                 reportArea.clear();
21774                 iE_Extensions.clear();
21775
21776         };
21777         private:
21778         eventType_t     eventType;
21779         reportArea_t    reportArea;
21780         iE_Extensions_t iE_Extensions;
21781
21782 };
21783 /*
21784 ReportIntervalMDT ::= ENUMERATED {ms120, ms240, ms480, ms640, ms1024, ms2048, ms5120, ms10240, min1, min6, min12, min30, min60}
21785 */
21786
21787 struct ReportIntervalMDT : asn::enumerated<13, 0, false>
21788 {
21789         static constexpr const char* name() {return "ReportIntervalMDT";}
21790         using parent_t = asn::enumerated<13, 0, false>;
21791         typedef enum {
21792                 ms120
21793                 ,ms240
21794                 ,ms480
21795                 ,ms640
21796                 ,ms1024
21797                 ,ms2048
21798                 ,ms5120
21799                 ,ms10240
21800                 ,min1
21801                 ,min6
21802                 ,min12
21803                 ,min30
21804                 ,min60
21805         } index_t;
21806
21807 };
21808
21809 /*
21810 ReportAmountMDT ::= ENUMERATED{r1, r2, r4, r8, r16, r32, r64, rinfinity}
21811 */
21812
21813 struct ReportAmountMDT : asn::enumerated<8, 0, false>
21814 {
21815         static constexpr const char* name() {return "ReportAmountMDT";}
21816         using parent_t = asn::enumerated<8, 0, false>;
21817         typedef enum {
21818                 r1
21819                 ,r2
21820                 ,r4
21821                 ,r8
21822                 ,r16
21823                 ,r32
21824                 ,r64
21825                 ,rinfinity
21826         } index_t;
21827
21828 };
21829
21830 /*
21831 M1PeriodicReporting-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
21832         ...
21833 }
21834 */
21835
21836 struct M1PeriodicReporting_ExtIEs
21837 {
21838         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
21839         {
21840                 size_t get_index() const {return type;}
21841                 bool is_unknown() const { return type == 1; }
21842                 void clear() {type = 0;}
21843                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
21844                 template<typename V>  bool decode(V& v)
21845                 {
21846                         clear();
21847                         if(!v(ref_nested())) return false;
21848                         { type = 1; return true;}
21849                         return false;
21850
21851                 }
21852                 template<typename V> bool encode(V& v) const
21853                 {
21854                         return v(ref_nested());
21855
21856                 }
21857                 protected:
21858                 template<typename V>  bool decode(size_t index, V& v)
21859                 {
21860                         clear();
21861                         switch(index)
21862                         {
21863                         case 1: type = 1; return v(ref_nested());
21864                         ref_nested().clear();
21865                         }
21866                         return false;
21867
21868                 }
21869                 template<typename V> bool encode(size_t index, V& v) const
21870                 {
21871                         if(index != type) {return false;} return v(ref_nested());
21872
21873                 }
21874                 private:
21875                 size_t type {0};
21876
21877         };
21878         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
21879         {
21880                 size_t get_index() const {return type;}
21881                 bool is_unknown() const { return type == 1; }
21882                 void clear() {type = 0;}
21883                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
21884                 template<typename V>  bool decode(V& v)
21885                 {
21886                         clear();
21887                         if(!v(ref_nested())) return false;
21888                         { type = 1; return true;}
21889                         return false;
21890
21891                 }
21892                 template<typename V> bool encode(V& v) const
21893                 {
21894                         return v(ref_nested());
21895
21896                 }
21897                 protected:
21898                 template<typename V>  bool decode(size_t index, V& v)
21899                 {
21900                         clear();
21901                         switch(index)
21902                         {
21903                         case 1: type = 1; return v(ref_nested());
21904                         ref_nested().clear();
21905                         }
21906                         return false;
21907
21908                 }
21909                 template<typename V> bool encode(size_t index, V& v) const
21910                 {
21911                         if(index != type) {return false;} return v(ref_nested());
21912
21913                 }
21914                 private:
21915                 size_t type {0};
21916
21917         };
21918         struct Extension_t : asn::typefield<true>
21919         {
21920                 ~Extension_t()  {clear();}
21921                 size_t get_index() const {return type;}
21922                 bool is_unknown() const { return type == 1; }
21923                 void clear()
21924                 {
21925                         type = 0; ref_nested().clear();
21926                 }
21927                 template<typename V> static inline void enumerate(V& v)
21928                 {
21929
21930                 }
21931                 protected:
21932                 template<typename V> bool decode(size_t index, V& v)
21933                 {
21934                         clear();
21935                         switch(index)
21936                         {
21937                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
21938                         }
21939                         return false;
21940
21941                 }
21942                 template<typename V> bool encode(size_t index, V& v) const
21943                 {
21944                         if(index != type) return false;
21945                         return false;
21946
21947                 }
21948                 private:
21949                 size_t type {0};
21950
21951         };
21952         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
21953         {
21954                 size_t get_index() const {return type;}
21955                 bool is_unknown() const { return type == 1; }
21956                 void clear() {type = 0;}
21957                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
21958                 template<typename V>  bool decode(V& v)
21959                 {
21960                         clear();
21961                         if(!v(ref_nested())) return false;
21962                         { type = 1; return true;}
21963                         return false;
21964
21965                 }
21966                 template<typename V> bool encode(V& v) const
21967                 {
21968                         return v(ref_nested());
21969
21970                 }
21971                 protected:
21972                 template<typename V>  bool decode(size_t index, V& v)
21973                 {
21974                         clear();
21975                         switch(index)
21976                         {
21977                         case 1: type = 1; return v(ref_nested());
21978                         ref_nested().clear();
21979                         }
21980                         return false;
21981
21982                 }
21983                 template<typename V> bool encode(size_t index, V& v) const
21984                 {
21985                         if(index != type) {return false;} return v(ref_nested());
21986
21987                 }
21988                 private:
21989                 size_t type {0};
21990
21991         };
21992
21993 };
21994 /*
21995 M1PeriodicReporting ::= SEQUENCE {
21996         reportInterval                          ReportIntervalMDT,
21997         reportAmount                            ReportAmountMDT,
21998         iE-Extensions                           ProtocolExtensionContainer { {M1PeriodicReporting-ExtIEs} } OPTIONAL,
21999         ...
22000 }
22001 */
22002
22003 struct M1PeriodicReporting : asn::sequence<3, 0, true, 1>
22004 {
22005         static constexpr const char* name() {return "M1PeriodicReporting";}
22006         using parent_t = asn::sequence<3, 0, true, 1>;
22007         struct reportInterval_t : ReportIntervalMDT
22008         {
22009                 static constexpr const char* name() {return "reportInterval_t";}
22010                 using parent_t = ReportIntervalMDT;
22011
22012         };
22013         reportInterval_t& ref_reportInterval() {return reportInterval;}
22014         reportInterval_t const& ref_reportInterval() const {return reportInterval;}
22015         struct reportAmount_t : ReportAmountMDT
22016         {
22017                 static constexpr const char* name() {return "reportAmount_t";}
22018                 using parent_t = ReportAmountMDT;
22019
22020         };
22021         reportAmount_t& ref_reportAmount() {return reportAmount;}
22022         reportAmount_t const& ref_reportAmount() const {return reportAmount;}
22023         struct iE_Extensions_t : ProtocolExtensionContainer<M1PeriodicReporting_ExtIEs>
22024         {
22025                 static constexpr const char* name() {return "iE_Extensions_t";}
22026                 using parent_t = ProtocolExtensionContainer<M1PeriodicReporting_ExtIEs>;
22027                 static constexpr bool optional = true;
22028
22029         };
22030         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
22031         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
22032         template<typename V> void decode(V& v)
22033         {
22034                 v(reportInterval);
22035                 v(reportAmount);
22036                 v(iE_Extensions);
22037
22038         };
22039         template<typename V> void encode(V& v) const
22040         {
22041                 v(reportInterval);
22042                 v(reportAmount);
22043                 v(iE_Extensions);
22044
22045         };
22046         void clear()
22047         {
22048                 reportInterval.clear();
22049                 reportAmount.clear();
22050                 iE_Extensions.clear();
22051
22052         };
22053         private:
22054         reportInterval_t        reportInterval;
22055         reportAmount_t  reportAmount;
22056         iE_Extensions_t iE_Extensions;
22057
22058 };
22059 /*
22060 M1ReportingTrigger::= ENUMERATED{
22061         periodic,
22062         a2eventtriggered,
22063         ...,
22064         a2eventtriggered-periodic
22065 }
22066 */
22067
22068 struct M1ReportingTrigger : asn::enumerated<3, 1, true>
22069 {
22070         static constexpr const char* name() {return "M1ReportingTrigger";}
22071         using parent_t = asn::enumerated<3, 1, true>;
22072         typedef enum {
22073                 periodic
22074                 ,a2eventtriggered
22075                 ,a2eventtriggered_periodic
22076         } index_t;
22077
22078 };
22079
22080 /*
22081 Threshold-RSRP ::= INTEGER(0..97)
22082 */
22083
22084 struct Threshold_RSRP : asn::integer<>
22085 {
22086         using constraint_t = asn::constraints<false,asn::span<0, 97>>;
22087         static constexpr const char* name() {return "Threshold-RSRP";}
22088         using parent_t = asn::integer<>;
22089
22090 };
22091
22092 /*
22093 Threshold-RSRQ ::= INTEGER(0..34)
22094 */
22095
22096 struct Threshold_RSRQ : asn::integer<>
22097 {
22098         using constraint_t = asn::constraints<false,asn::span<0, 34>>;
22099         static constexpr const char* name() {return "Threshold-RSRQ";}
22100         using parent_t = asn::integer<>;
22101
22102 };
22103
22104 /*
22105 MeasurementThresholdA2 ::= CHOICE {
22106         threshold-RSRP                          Threshold-RSRP,
22107         threshold-RSRQ                          Threshold-RSRQ,
22108         ...
22109 }
22110 */
22111
22112 struct MeasurementThresholdA2 : asn::choice<2, 0, true>
22113 {
22114         static constexpr const char* name() {return "MeasurementThresholdA2";}
22115         using parent_t = asn::choice<2, 0, true>;
22116         index_type get_index() const {return index;}
22117         bool is_unknown() const {return index == 3;}
22118         void set_unknown() { set_index(3);  }
22119         ~MeasurementThresholdA2() {clear();}
22120         struct threshold_RSRP_t : Threshold_RSRP
22121         {
22122                 static constexpr const char* name() {return "threshold_RSRP_t";}
22123                 using parent_t = Threshold_RSRP;
22124
22125         };
22126         struct threshold_RSRQ_t : Threshold_RSRQ
22127         {
22128                 static constexpr const char* name() {return "threshold_RSRQ_t";}
22129                 using parent_t = Threshold_RSRQ;
22130
22131         };
22132         void clear()
22133         {
22134                 switch(get_index())
22135                 {
22136                 case 1: var.destroy<threshold_RSRP_t>(); break;
22137                 case 2: var.destroy<threshold_RSRQ_t>(); break;
22138                 }
22139                 index = 0;
22140                 base::clear();
22141         }
22142         template<typename V> bool decode(size_t idx, V& v)
22143         {
22144                 clear();
22145                 switch(idx)
22146                 {
22147                 case 1: set_index(1); return v(var.build<threshold_RSRP_t>());
22148                 case 2: set_index(2); return v(var.build<threshold_RSRQ_t>());
22149                 }
22150                 return false;
22151
22152         }
22153         template<typename V> bool encode(V& v) const
22154         {
22155                 switch(get_index())
22156                 {
22157                 case 1: return v(var.as<threshold_RSRP_t>());
22158                 case 2: return v(var.as<threshold_RSRQ_t>());
22159                 }
22160                 return false;
22161         }
22162         template<typename V> static inline void enumerate(V& v)
22163         {
22164                 v.template operator()<threshold_RSRP_t>(1);
22165                 v.template operator()<threshold_RSRQ_t>(2);
22166
22167         }
22168         threshold_RSRP_t& select_threshold_RSRP() { if(get_index() != 1) { clear(); set_index(1); return var.build<threshold_RSRP_t>();} return var.as<threshold_RSRP_t>();}
22169         threshold_RSRP_t const* get_threshold_RSRP() const { if(get_index() == 1) { return &var.as<threshold_RSRP_t>();} return nullptr; }
22170         threshold_RSRQ_t& select_threshold_RSRQ() { if(get_index() != 2) { clear(); set_index(2); return var.build<threshold_RSRQ_t>();} return var.as<threshold_RSRQ_t>();}
22171         threshold_RSRQ_t const* get_threshold_RSRQ() const { if(get_index() == 2) { return &var.as<threshold_RSRQ_t>();} return nullptr; }
22172         private:
22173         void set_index(index_type i) {index = i; base::set();}
22174         union union_type
22175         {
22176                 char dummy1[sizeof(threshold_RSRP_t)];
22177                 char dummy2[sizeof(threshold_RSRQ_t)];
22178
22179         };
22180         asn::variant<sizeof(union_type)>        var;
22181         index_type      index {0};
22182 };
22183 /*
22184 M1ThresholdEventA2-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
22185         ...
22186 }
22187 */
22188
22189 struct M1ThresholdEventA2_ExtIEs
22190 {
22191         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
22192         {
22193                 size_t get_index() const {return type;}
22194                 bool is_unknown() const { return type == 1; }
22195                 void clear() {type = 0;}
22196                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
22197                 template<typename V>  bool decode(V& v)
22198                 {
22199                         clear();
22200                         if(!v(ref_nested())) return false;
22201                         { type = 1; return true;}
22202                         return false;
22203
22204                 }
22205                 template<typename V> bool encode(V& v) const
22206                 {
22207                         return v(ref_nested());
22208
22209                 }
22210                 protected:
22211                 template<typename V>  bool decode(size_t index, V& v)
22212                 {
22213                         clear();
22214                         switch(index)
22215                         {
22216                         case 1: type = 1; return v(ref_nested());
22217                         ref_nested().clear();
22218                         }
22219                         return false;
22220
22221                 }
22222                 template<typename V> bool encode(size_t index, V& v) const
22223                 {
22224                         if(index != type) {return false;} return v(ref_nested());
22225
22226                 }
22227                 private:
22228                 size_t type {0};
22229
22230         };
22231         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
22232         {
22233                 size_t get_index() const {return type;}
22234                 bool is_unknown() const { return type == 1; }
22235                 void clear() {type = 0;}
22236                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
22237                 template<typename V>  bool decode(V& v)
22238                 {
22239                         clear();
22240                         if(!v(ref_nested())) return false;
22241                         { type = 1; return true;}
22242                         return false;
22243
22244                 }
22245                 template<typename V> bool encode(V& v) const
22246                 {
22247                         return v(ref_nested());
22248
22249                 }
22250                 protected:
22251                 template<typename V>  bool decode(size_t index, V& v)
22252                 {
22253                         clear();
22254                         switch(index)
22255                         {
22256                         case 1: type = 1; return v(ref_nested());
22257                         ref_nested().clear();
22258                         }
22259                         return false;
22260
22261                 }
22262                 template<typename V> bool encode(size_t index, V& v) const
22263                 {
22264                         if(index != type) {return false;} return v(ref_nested());
22265
22266                 }
22267                 private:
22268                 size_t type {0};
22269
22270         };
22271         struct Extension_t : asn::typefield<true>
22272         {
22273                 ~Extension_t()  {clear();}
22274                 size_t get_index() const {return type;}
22275                 bool is_unknown() const { return type == 1; }
22276                 void clear()
22277                 {
22278                         type = 0; ref_nested().clear();
22279                 }
22280                 template<typename V> static inline void enumerate(V& v)
22281                 {
22282
22283                 }
22284                 protected:
22285                 template<typename V> bool decode(size_t index, V& v)
22286                 {
22287                         clear();
22288                         switch(index)
22289                         {
22290                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
22291                         }
22292                         return false;
22293
22294                 }
22295                 template<typename V> bool encode(size_t index, V& v) const
22296                 {
22297                         if(index != type) return false;
22298                         return false;
22299
22300                 }
22301                 private:
22302                 size_t type {0};
22303
22304         };
22305         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
22306         {
22307                 size_t get_index() const {return type;}
22308                 bool is_unknown() const { return type == 1; }
22309                 void clear() {type = 0;}
22310                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
22311                 template<typename V>  bool decode(V& v)
22312                 {
22313                         clear();
22314                         if(!v(ref_nested())) return false;
22315                         { type = 1; return true;}
22316                         return false;
22317
22318                 }
22319                 template<typename V> bool encode(V& v) const
22320                 {
22321                         return v(ref_nested());
22322
22323                 }
22324                 protected:
22325                 template<typename V>  bool decode(size_t index, V& v)
22326                 {
22327                         clear();
22328                         switch(index)
22329                         {
22330                         case 1: type = 1; return v(ref_nested());
22331                         ref_nested().clear();
22332                         }
22333                         return false;
22334
22335                 }
22336                 template<typename V> bool encode(size_t index, V& v) const
22337                 {
22338                         if(index != type) {return false;} return v(ref_nested());
22339
22340                 }
22341                 private:
22342                 size_t type {0};
22343
22344         };
22345
22346 };
22347 /*
22348 M1ThresholdEventA2 ::= SEQUENCE {
22349         measurementThreshold            MeasurementThresholdA2,
22350         iE-Extensions                           ProtocolExtensionContainer { {M1ThresholdEventA2-ExtIEs} } OPTIONAL,
22351         ...
22352 }
22353 */
22354
22355 struct M1ThresholdEventA2 : asn::sequence<2, 0, true, 1>
22356 {
22357         static constexpr const char* name() {return "M1ThresholdEventA2";}
22358         using parent_t = asn::sequence<2, 0, true, 1>;
22359         struct measurementThreshold_t : MeasurementThresholdA2
22360         {
22361                 static constexpr const char* name() {return "measurementThreshold_t";}
22362                 using parent_t = MeasurementThresholdA2;
22363
22364         };
22365         measurementThreshold_t& ref_measurementThreshold() {return measurementThreshold;}
22366         measurementThreshold_t const& ref_measurementThreshold() const {return measurementThreshold;}
22367         struct iE_Extensions_t : ProtocolExtensionContainer<M1ThresholdEventA2_ExtIEs>
22368         {
22369                 static constexpr const char* name() {return "iE_Extensions_t";}
22370                 using parent_t = ProtocolExtensionContainer<M1ThresholdEventA2_ExtIEs>;
22371                 static constexpr bool optional = true;
22372
22373         };
22374         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
22375         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
22376         template<typename V> void decode(V& v)
22377         {
22378                 v(measurementThreshold);
22379                 v(iE_Extensions);
22380
22381         };
22382         template<typename V> void encode(V& v) const
22383         {
22384                 v(measurementThreshold);
22385                 v(iE_Extensions);
22386
22387         };
22388         void clear()
22389         {
22390                 measurementThreshold.clear();
22391                 iE_Extensions.clear();
22392
22393         };
22394         private:
22395         measurementThreshold_t  measurementThreshold;
22396         iE_Extensions_t iE_Extensions;
22397
22398 };
22399 /*
22400 M3period ::= ENUMERATED {ms100, ms1000, ms10000, ... }
22401 */
22402
22403 struct M3period : asn::enumerated<3, 0, true>
22404 {
22405         static constexpr const char* name() {return "M3period";}
22406         using parent_t = asn::enumerated<3, 0, true>;
22407         typedef enum {
22408                 ms100
22409                 ,ms1000
22410                 ,ms10000
22411         } index_t;
22412
22413 };
22414
22415 /*
22416 M3Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
22417         ...
22418 }
22419 */
22420
22421 struct M3Configuration_ExtIEs
22422 {
22423         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
22424         {
22425                 size_t get_index() const {return type;}
22426                 bool is_unknown() const { return type == 1; }
22427                 void clear() {type = 0;}
22428                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
22429                 template<typename V>  bool decode(V& v)
22430                 {
22431                         clear();
22432                         if(!v(ref_nested())) return false;
22433                         { type = 1; return true;}
22434                         return false;
22435
22436                 }
22437                 template<typename V> bool encode(V& v) const
22438                 {
22439                         return v(ref_nested());
22440
22441                 }
22442                 protected:
22443                 template<typename V>  bool decode(size_t index, V& v)
22444                 {
22445                         clear();
22446                         switch(index)
22447                         {
22448                         case 1: type = 1; return v(ref_nested());
22449                         ref_nested().clear();
22450                         }
22451                         return false;
22452
22453                 }
22454                 template<typename V> bool encode(size_t index, V& v) const
22455                 {
22456                         if(index != type) {return false;} return v(ref_nested());
22457
22458                 }
22459                 private:
22460                 size_t type {0};
22461
22462         };
22463         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
22464         {
22465                 size_t get_index() const {return type;}
22466                 bool is_unknown() const { return type == 1; }
22467                 void clear() {type = 0;}
22468                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
22469                 template<typename V>  bool decode(V& v)
22470                 {
22471                         clear();
22472                         if(!v(ref_nested())) return false;
22473                         { type = 1; return true;}
22474                         return false;
22475
22476                 }
22477                 template<typename V> bool encode(V& v) const
22478                 {
22479                         return v(ref_nested());
22480
22481                 }
22482                 protected:
22483                 template<typename V>  bool decode(size_t index, V& v)
22484                 {
22485                         clear();
22486                         switch(index)
22487                         {
22488                         case 1: type = 1; return v(ref_nested());
22489                         ref_nested().clear();
22490                         }
22491                         return false;
22492
22493                 }
22494                 template<typename V> bool encode(size_t index, V& v) const
22495                 {
22496                         if(index != type) {return false;} return v(ref_nested());
22497
22498                 }
22499                 private:
22500                 size_t type {0};
22501
22502         };
22503         struct Extension_t : asn::typefield<true>
22504         {
22505                 ~Extension_t()  {clear();}
22506                 size_t get_index() const {return type;}
22507                 bool is_unknown() const { return type == 1; }
22508                 void clear()
22509                 {
22510                         type = 0; ref_nested().clear();
22511                 }
22512                 template<typename V> static inline void enumerate(V& v)
22513                 {
22514
22515                 }
22516                 protected:
22517                 template<typename V> bool decode(size_t index, V& v)
22518                 {
22519                         clear();
22520                         switch(index)
22521                         {
22522                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
22523                         }
22524                         return false;
22525
22526                 }
22527                 template<typename V> bool encode(size_t index, V& v) const
22528                 {
22529                         if(index != type) return false;
22530                         return false;
22531
22532                 }
22533                 private:
22534                 size_t type {0};
22535
22536         };
22537         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
22538         {
22539                 size_t get_index() const {return type;}
22540                 bool is_unknown() const { return type == 1; }
22541                 void clear() {type = 0;}
22542                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
22543                 template<typename V>  bool decode(V& v)
22544                 {
22545                         clear();
22546                         if(!v(ref_nested())) return false;
22547                         { type = 1; return true;}
22548                         return false;
22549
22550                 }
22551                 template<typename V> bool encode(V& v) const
22552                 {
22553                         return v(ref_nested());
22554
22555                 }
22556                 protected:
22557                 template<typename V>  bool decode(size_t index, V& v)
22558                 {
22559                         clear();
22560                         switch(index)
22561                         {
22562                         case 1: type = 1; return v(ref_nested());
22563                         ref_nested().clear();
22564                         }
22565                         return false;
22566
22567                 }
22568                 template<typename V> bool encode(size_t index, V& v) const
22569                 {
22570                         if(index != type) {return false;} return v(ref_nested());
22571
22572                 }
22573                 private:
22574                 size_t type {0};
22575
22576         };
22577
22578 };
22579 /*
22580 M3Configuration ::= SEQUENCE {
22581         m3period                        M3period,
22582         iE-Extensions           ProtocolExtensionContainer { {M3Configuration-ExtIEs} } OPTIONAL,
22583         ...
22584 }
22585 */
22586
22587 struct M3Configuration : asn::sequence<2, 0, true, 1>
22588 {
22589         static constexpr const char* name() {return "M3Configuration";}
22590         using parent_t = asn::sequence<2, 0, true, 1>;
22591         struct m3period_t : M3period
22592         {
22593                 static constexpr const char* name() {return "m3period_t";}
22594                 using parent_t = M3period;
22595
22596         };
22597         m3period_t& ref_m3period() {return m3period;}
22598         m3period_t const& ref_m3period() const {return m3period;}
22599         struct iE_Extensions_t : ProtocolExtensionContainer<M3Configuration_ExtIEs>
22600         {
22601                 static constexpr const char* name() {return "iE_Extensions_t";}
22602                 using parent_t = ProtocolExtensionContainer<M3Configuration_ExtIEs>;
22603                 static constexpr bool optional = true;
22604
22605         };
22606         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
22607         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
22608         template<typename V> void decode(V& v)
22609         {
22610                 v(m3period);
22611                 v(iE_Extensions);
22612
22613         };
22614         template<typename V> void encode(V& v) const
22615         {
22616                 v(m3period);
22617                 v(iE_Extensions);
22618
22619         };
22620         void clear()
22621         {
22622                 m3period.clear();
22623                 iE_Extensions.clear();
22624
22625         };
22626         private:
22627         m3period_t      m3period;
22628         iE_Extensions_t iE_Extensions;
22629
22630 };
22631 /*
22632 M4period ::= ENUMERATED {ms1024, ms2048, ms5120, ms10240, min1, ... }
22633 */
22634
22635 struct M4period : asn::enumerated<5, 0, true>
22636 {
22637         static constexpr const char* name() {return "M4period";}
22638         using parent_t = asn::enumerated<5, 0, true>;
22639         typedef enum {
22640                 ms1024
22641                 ,ms2048
22642                 ,ms5120
22643                 ,ms10240
22644                 ,min1
22645         } index_t;
22646
22647 };
22648
22649 /*
22650 M4Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
22651         ...
22652 }
22653 */
22654
22655 struct M4Configuration_ExtIEs
22656 {
22657         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
22658         {
22659                 size_t get_index() const {return type;}
22660                 bool is_unknown() const { return type == 1; }
22661                 void clear() {type = 0;}
22662                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
22663                 template<typename V>  bool decode(V& v)
22664                 {
22665                         clear();
22666                         if(!v(ref_nested())) return false;
22667                         { type = 1; return true;}
22668                         return false;
22669
22670                 }
22671                 template<typename V> bool encode(V& v) const
22672                 {
22673                         return v(ref_nested());
22674
22675                 }
22676                 protected:
22677                 template<typename V>  bool decode(size_t index, V& v)
22678                 {
22679                         clear();
22680                         switch(index)
22681                         {
22682                         case 1: type = 1; return v(ref_nested());
22683                         ref_nested().clear();
22684                         }
22685                         return false;
22686
22687                 }
22688                 template<typename V> bool encode(size_t index, V& v) const
22689                 {
22690                         if(index != type) {return false;} return v(ref_nested());
22691
22692                 }
22693                 private:
22694                 size_t type {0};
22695
22696         };
22697         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
22698         {
22699                 size_t get_index() const {return type;}
22700                 bool is_unknown() const { return type == 1; }
22701                 void clear() {type = 0;}
22702                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
22703                 template<typename V>  bool decode(V& v)
22704                 {
22705                         clear();
22706                         if(!v(ref_nested())) return false;
22707                         { type = 1; return true;}
22708                         return false;
22709
22710                 }
22711                 template<typename V> bool encode(V& v) const
22712                 {
22713                         return v(ref_nested());
22714
22715                 }
22716                 protected:
22717                 template<typename V>  bool decode(size_t index, V& v)
22718                 {
22719                         clear();
22720                         switch(index)
22721                         {
22722                         case 1: type = 1; return v(ref_nested());
22723                         ref_nested().clear();
22724                         }
22725                         return false;
22726
22727                 }
22728                 template<typename V> bool encode(size_t index, V& v) const
22729                 {
22730                         if(index != type) {return false;} return v(ref_nested());
22731
22732                 }
22733                 private:
22734                 size_t type {0};
22735
22736         };
22737         struct Extension_t : asn::typefield<true>
22738         {
22739                 ~Extension_t()  {clear();}
22740                 size_t get_index() const {return type;}
22741                 bool is_unknown() const { return type == 1; }
22742                 void clear()
22743                 {
22744                         type = 0; ref_nested().clear();
22745                 }
22746                 template<typename V> static inline void enumerate(V& v)
22747                 {
22748
22749                 }
22750                 protected:
22751                 template<typename V> bool decode(size_t index, V& v)
22752                 {
22753                         clear();
22754                         switch(index)
22755                         {
22756                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
22757                         }
22758                         return false;
22759
22760                 }
22761                 template<typename V> bool encode(size_t index, V& v) const
22762                 {
22763                         if(index != type) return false;
22764                         return false;
22765
22766                 }
22767                 private:
22768                 size_t type {0};
22769
22770         };
22771         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
22772         {
22773                 size_t get_index() const {return type;}
22774                 bool is_unknown() const { return type == 1; }
22775                 void clear() {type = 0;}
22776                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
22777                 template<typename V>  bool decode(V& v)
22778                 {
22779                         clear();
22780                         if(!v(ref_nested())) return false;
22781                         { type = 1; return true;}
22782                         return false;
22783
22784                 }
22785                 template<typename V> bool encode(V& v) const
22786                 {
22787                         return v(ref_nested());
22788
22789                 }
22790                 protected:
22791                 template<typename V>  bool decode(size_t index, V& v)
22792                 {
22793                         clear();
22794                         switch(index)
22795                         {
22796                         case 1: type = 1; return v(ref_nested());
22797                         ref_nested().clear();
22798                         }
22799                         return false;
22800
22801                 }
22802                 template<typename V> bool encode(size_t index, V& v) const
22803                 {
22804                         if(index != type) {return false;} return v(ref_nested());
22805
22806                 }
22807                 private:
22808                 size_t type {0};
22809
22810         };
22811
22812 };
22813 /*
22814 M4Configuration ::= SEQUENCE {
22815         m4period                        M4period,
22816         m4-links-to-log         Links-to-log,
22817         iE-Extensions           ProtocolExtensionContainer { {M4Configuration-ExtIEs} } OPTIONAL,
22818         ...
22819 }
22820 */
22821
22822 struct M4Configuration : asn::sequence<3, 0, true, 1>
22823 {
22824         static constexpr const char* name() {return "M4Configuration";}
22825         using parent_t = asn::sequence<3, 0, true, 1>;
22826         struct m4period_t : M4period
22827         {
22828                 static constexpr const char* name() {return "m4period_t";}
22829                 using parent_t = M4period;
22830
22831         };
22832         m4period_t& ref_m4period() {return m4period;}
22833         m4period_t const& ref_m4period() const {return m4period;}
22834         struct m4_links_to_log_t : Links_to_log
22835         {
22836                 static constexpr const char* name() {return "m4_links_to_log_t";}
22837                 using parent_t = Links_to_log;
22838
22839         };
22840         m4_links_to_log_t& ref_m4_links_to_log() {return m4_links_to_log;}
22841         m4_links_to_log_t const& ref_m4_links_to_log() const {return m4_links_to_log;}
22842         struct iE_Extensions_t : ProtocolExtensionContainer<M4Configuration_ExtIEs>
22843         {
22844                 static constexpr const char* name() {return "iE_Extensions_t";}
22845                 using parent_t = ProtocolExtensionContainer<M4Configuration_ExtIEs>;
22846                 static constexpr bool optional = true;
22847
22848         };
22849         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
22850         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
22851         template<typename V> void decode(V& v)
22852         {
22853                 v(m4period);
22854                 v(m4_links_to_log);
22855                 v(iE_Extensions);
22856
22857         };
22858         template<typename V> void encode(V& v) const
22859         {
22860                 v(m4period);
22861                 v(m4_links_to_log);
22862                 v(iE_Extensions);
22863
22864         };
22865         void clear()
22866         {
22867                 m4period.clear();
22868                 m4_links_to_log.clear();
22869                 iE_Extensions.clear();
22870
22871         };
22872         private:
22873         m4period_t      m4period;
22874         m4_links_to_log_t       m4_links_to_log;
22875         iE_Extensions_t iE_Extensions;
22876
22877 };
22878 /*
22879 M5period ::= ENUMERATED {ms1024, ms2048, ms5120, ms10240, min1, ... }
22880 */
22881
22882 struct M5period : asn::enumerated<5, 0, true>
22883 {
22884         static constexpr const char* name() {return "M5period";}
22885         using parent_t = asn::enumerated<5, 0, true>;
22886         typedef enum {
22887                 ms1024
22888                 ,ms2048
22889                 ,ms5120
22890                 ,ms10240
22891                 ,min1
22892         } index_t;
22893
22894 };
22895
22896 /*
22897 M5Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
22898         ...
22899 }
22900 */
22901
22902 struct M5Configuration_ExtIEs
22903 {
22904         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
22905         {
22906                 size_t get_index() const {return type;}
22907                 bool is_unknown() const { return type == 1; }
22908                 void clear() {type = 0;}
22909                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
22910                 template<typename V>  bool decode(V& v)
22911                 {
22912                         clear();
22913                         if(!v(ref_nested())) return false;
22914                         { type = 1; return true;}
22915                         return false;
22916
22917                 }
22918                 template<typename V> bool encode(V& v) const
22919                 {
22920                         return v(ref_nested());
22921
22922                 }
22923                 protected:
22924                 template<typename V>  bool decode(size_t index, V& v)
22925                 {
22926                         clear();
22927                         switch(index)
22928                         {
22929                         case 1: type = 1; return v(ref_nested());
22930                         ref_nested().clear();
22931                         }
22932                         return false;
22933
22934                 }
22935                 template<typename V> bool encode(size_t index, V& v) const
22936                 {
22937                         if(index != type) {return false;} return v(ref_nested());
22938
22939                 }
22940                 private:
22941                 size_t type {0};
22942
22943         };
22944         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
22945         {
22946                 size_t get_index() const {return type;}
22947                 bool is_unknown() const { return type == 1; }
22948                 void clear() {type = 0;}
22949                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
22950                 template<typename V>  bool decode(V& v)
22951                 {
22952                         clear();
22953                         if(!v(ref_nested())) return false;
22954                         { type = 1; return true;}
22955                         return false;
22956
22957                 }
22958                 template<typename V> bool encode(V& v) const
22959                 {
22960                         return v(ref_nested());
22961
22962                 }
22963                 protected:
22964                 template<typename V>  bool decode(size_t index, V& v)
22965                 {
22966                         clear();
22967                         switch(index)
22968                         {
22969                         case 1: type = 1; return v(ref_nested());
22970                         ref_nested().clear();
22971                         }
22972                         return false;
22973
22974                 }
22975                 template<typename V> bool encode(size_t index, V& v) const
22976                 {
22977                         if(index != type) {return false;} return v(ref_nested());
22978
22979                 }
22980                 private:
22981                 size_t type {0};
22982
22983         };
22984         struct Extension_t : asn::typefield<true>
22985         {
22986                 ~Extension_t()  {clear();}
22987                 size_t get_index() const {return type;}
22988                 bool is_unknown() const { return type == 1; }
22989                 void clear()
22990                 {
22991                         type = 0; ref_nested().clear();
22992                 }
22993                 template<typename V> static inline void enumerate(V& v)
22994                 {
22995
22996                 }
22997                 protected:
22998                 template<typename V> bool decode(size_t index, V& v)
22999                 {
23000                         clear();
23001                         switch(index)
23002                         {
23003                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
23004                         }
23005                         return false;
23006
23007                 }
23008                 template<typename V> bool encode(size_t index, V& v) const
23009                 {
23010                         if(index != type) return false;
23011                         return false;
23012
23013                 }
23014                 private:
23015                 size_t type {0};
23016
23017         };
23018         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
23019         {
23020                 size_t get_index() const {return type;}
23021                 bool is_unknown() const { return type == 1; }
23022                 void clear() {type = 0;}
23023                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
23024                 template<typename V>  bool decode(V& v)
23025                 {
23026                         clear();
23027                         if(!v(ref_nested())) return false;
23028                         { type = 1; return true;}
23029                         return false;
23030
23031                 }
23032                 template<typename V> bool encode(V& v) const
23033                 {
23034                         return v(ref_nested());
23035
23036                 }
23037                 protected:
23038                 template<typename V>  bool decode(size_t index, V& v)
23039                 {
23040                         clear();
23041                         switch(index)
23042                         {
23043                         case 1: type = 1; return v(ref_nested());
23044                         ref_nested().clear();
23045                         }
23046                         return false;
23047
23048                 }
23049                 template<typename V> bool encode(size_t index, V& v) const
23050                 {
23051                         if(index != type) {return false;} return v(ref_nested());
23052
23053                 }
23054                 private:
23055                 size_t type {0};
23056
23057         };
23058
23059 };
23060 /*
23061 M5Configuration ::= SEQUENCE {
23062         m5period                        M5period,
23063         m5-links-to-log         Links-to-log,
23064         iE-Extensions           ProtocolExtensionContainer { {M5Configuration-ExtIEs} } OPTIONAL,
23065         ...
23066 }
23067 */
23068
23069 struct M5Configuration : asn::sequence<3, 0, true, 1>
23070 {
23071         static constexpr const char* name() {return "M5Configuration";}
23072         using parent_t = asn::sequence<3, 0, true, 1>;
23073         struct m5period_t : M5period
23074         {
23075                 static constexpr const char* name() {return "m5period_t";}
23076                 using parent_t = M5period;
23077
23078         };
23079         m5period_t& ref_m5period() {return m5period;}
23080         m5period_t const& ref_m5period() const {return m5period;}
23081         struct m5_links_to_log_t : Links_to_log
23082         {
23083                 static constexpr const char* name() {return "m5_links_to_log_t";}
23084                 using parent_t = Links_to_log;
23085
23086         };
23087         m5_links_to_log_t& ref_m5_links_to_log() {return m5_links_to_log;}
23088         m5_links_to_log_t const& ref_m5_links_to_log() const {return m5_links_to_log;}
23089         struct iE_Extensions_t : ProtocolExtensionContainer<M5Configuration_ExtIEs>
23090         {
23091                 static constexpr const char* name() {return "iE_Extensions_t";}
23092                 using parent_t = ProtocolExtensionContainer<M5Configuration_ExtIEs>;
23093                 static constexpr bool optional = true;
23094
23095         };
23096         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
23097         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
23098         template<typename V> void decode(V& v)
23099         {
23100                 v(m5period);
23101                 v(m5_links_to_log);
23102                 v(iE_Extensions);
23103
23104         };
23105         template<typename V> void encode(V& v) const
23106         {
23107                 v(m5period);
23108                 v(m5_links_to_log);
23109                 v(iE_Extensions);
23110
23111         };
23112         void clear()
23113         {
23114                 m5period.clear();
23115                 m5_links_to_log.clear();
23116                 iE_Extensions.clear();
23117
23118         };
23119         private:
23120         m5period_t      m5period;
23121         m5_links_to_log_t       m5_links_to_log;
23122         iE_Extensions_t iE_Extensions;
23123
23124 };
23125 /*
23126 M6report-interval ::= ENUMERATED { ms1024, ms2048, ms5120, ms10240, ... }
23127 */
23128
23129 struct M6report_interval : asn::enumerated<4, 0, true>
23130 {
23131         static constexpr const char* name() {return "M6report-interval";}
23132         using parent_t = asn::enumerated<4, 0, true>;
23133         typedef enum {
23134                 ms1024
23135                 ,ms2048
23136                 ,ms5120
23137                 ,ms10240
23138         } index_t;
23139
23140 };
23141
23142 /*
23143 M6delay-threshold ::= ENUMERATED { ms30, ms40, ms50, ms60, ms70, ms80, ms90, ms100, ms150, ms300, ms500, ms750, ... }
23144 */
23145
23146 struct M6delay_threshold : asn::enumerated<12, 0, true>
23147 {
23148         static constexpr const char* name() {return "M6delay-threshold";}
23149         using parent_t = asn::enumerated<12, 0, true>;
23150         typedef enum {
23151                 ms30
23152                 ,ms40
23153                 ,ms50
23154                 ,ms60
23155                 ,ms70
23156                 ,ms80
23157                 ,ms90
23158                 ,ms100
23159                 ,ms150
23160                 ,ms300
23161                 ,ms500
23162                 ,ms750
23163         } index_t;
23164
23165 };
23166
23167 /*
23168 M6Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
23169         ...
23170 }
23171 */
23172
23173 struct M6Configuration_ExtIEs
23174 {
23175         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
23176         {
23177                 size_t get_index() const {return type;}
23178                 bool is_unknown() const { return type == 1; }
23179                 void clear() {type = 0;}
23180                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
23181                 template<typename V>  bool decode(V& v)
23182                 {
23183                         clear();
23184                         if(!v(ref_nested())) return false;
23185                         { type = 1; return true;}
23186                         return false;
23187
23188                 }
23189                 template<typename V> bool encode(V& v) const
23190                 {
23191                         return v(ref_nested());
23192
23193                 }
23194                 protected:
23195                 template<typename V>  bool decode(size_t index, V& v)
23196                 {
23197                         clear();
23198                         switch(index)
23199                         {
23200                         case 1: type = 1; return v(ref_nested());
23201                         ref_nested().clear();
23202                         }
23203                         return false;
23204
23205                 }
23206                 template<typename V> bool encode(size_t index, V& v) const
23207                 {
23208                         if(index != type) {return false;} return v(ref_nested());
23209
23210                 }
23211                 private:
23212                 size_t type {0};
23213
23214         };
23215         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
23216         {
23217                 size_t get_index() const {return type;}
23218                 bool is_unknown() const { return type == 1; }
23219                 void clear() {type = 0;}
23220                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
23221                 template<typename V>  bool decode(V& v)
23222                 {
23223                         clear();
23224                         if(!v(ref_nested())) return false;
23225                         { type = 1; return true;}
23226                         return false;
23227
23228                 }
23229                 template<typename V> bool encode(V& v) const
23230                 {
23231                         return v(ref_nested());
23232
23233                 }
23234                 protected:
23235                 template<typename V>  bool decode(size_t index, V& v)
23236                 {
23237                         clear();
23238                         switch(index)
23239                         {
23240                         case 1: type = 1; return v(ref_nested());
23241                         ref_nested().clear();
23242                         }
23243                         return false;
23244
23245                 }
23246                 template<typename V> bool encode(size_t index, V& v) const
23247                 {
23248                         if(index != type) {return false;} return v(ref_nested());
23249
23250                 }
23251                 private:
23252                 size_t type {0};
23253
23254         };
23255         struct Extension_t : asn::typefield<true>
23256         {
23257                 ~Extension_t()  {clear();}
23258                 size_t get_index() const {return type;}
23259                 bool is_unknown() const { return type == 1; }
23260                 void clear()
23261                 {
23262                         type = 0; ref_nested().clear();
23263                 }
23264                 template<typename V> static inline void enumerate(V& v)
23265                 {
23266
23267                 }
23268                 protected:
23269                 template<typename V> bool decode(size_t index, V& v)
23270                 {
23271                         clear();
23272                         switch(index)
23273                         {
23274                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
23275                         }
23276                         return false;
23277
23278                 }
23279                 template<typename V> bool encode(size_t index, V& v) const
23280                 {
23281                         if(index != type) return false;
23282                         return false;
23283
23284                 }
23285                 private:
23286                 size_t type {0};
23287
23288         };
23289         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
23290         {
23291                 size_t get_index() const {return type;}
23292                 bool is_unknown() const { return type == 1; }
23293                 void clear() {type = 0;}
23294                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
23295                 template<typename V>  bool decode(V& v)
23296                 {
23297                         clear();
23298                         if(!v(ref_nested())) return false;
23299                         { type = 1; return true;}
23300                         return false;
23301
23302                 }
23303                 template<typename V> bool encode(V& v) const
23304                 {
23305                         return v(ref_nested());
23306
23307                 }
23308                 protected:
23309                 template<typename V>  bool decode(size_t index, V& v)
23310                 {
23311                         clear();
23312                         switch(index)
23313                         {
23314                         case 1: type = 1; return v(ref_nested());
23315                         ref_nested().clear();
23316                         }
23317                         return false;
23318
23319                 }
23320                 template<typename V> bool encode(size_t index, V& v) const
23321                 {
23322                         if(index != type) {return false;} return v(ref_nested());
23323
23324                 }
23325                 private:
23326                 size_t type {0};
23327
23328         };
23329
23330 };
23331 /*
23332 M6Configuration ::= SEQUENCE {
23333         m6report-interval       M6report-interval,
23334         m6delay-threshold       M6delay-threshold       OPTIONAL,
23335 -- This IE shall be present if the M6 Links to log IE is set to “uplink” or to “both-uplink-and-downlink” --
23336         m6-links-to-log         Links-to-log,
23337         iE-Extensions           ProtocolExtensionContainer { {M6Configuration-ExtIEs} } OPTIONAL,
23338         ...
23339 }
23340 */
23341
23342 struct M6Configuration : asn::sequence<4, 0, true, 2>
23343 {
23344         static constexpr const char* name() {return "M6Configuration";}
23345         using parent_t = asn::sequence<4, 0, true, 2>;
23346         struct m6report_interval_t : M6report_interval
23347         {
23348                 static constexpr const char* name() {return "m6report_interval_t";}
23349                 using parent_t = M6report_interval;
23350
23351         };
23352         m6report_interval_t& ref_m6report_interval() {return m6report_interval;}
23353         m6report_interval_t const& ref_m6report_interval() const {return m6report_interval;}
23354         struct m6delay_threshold_t : M6delay_threshold
23355         {
23356                 static constexpr const char* name() {return "m6delay_threshold_t";}
23357                 using parent_t = M6delay_threshold;
23358                 static constexpr bool optional = true;
23359
23360         };
23361         m6delay_threshold_t& set_m6delay_threshold() { m6delay_threshold.setpresent(true); return m6delay_threshold;}
23362         m6delay_threshold_t const* get_m6delay_threshold() const {return m6delay_threshold.is_valid() ? &m6delay_threshold : nullptr;}
23363         struct m6_links_to_log_t : Links_to_log
23364         {
23365                 static constexpr const char* name() {return "m6_links_to_log_t";}
23366                 using parent_t = Links_to_log;
23367
23368         };
23369         m6_links_to_log_t& ref_m6_links_to_log() {return m6_links_to_log;}
23370         m6_links_to_log_t const& ref_m6_links_to_log() const {return m6_links_to_log;}
23371         struct iE_Extensions_t : ProtocolExtensionContainer<M6Configuration_ExtIEs>
23372         {
23373                 static constexpr const char* name() {return "iE_Extensions_t";}
23374                 using parent_t = ProtocolExtensionContainer<M6Configuration_ExtIEs>;
23375                 static constexpr bool optional = true;
23376
23377         };
23378         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
23379         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
23380         template<typename V> void decode(V& v)
23381         {
23382                 v(m6report_interval);
23383                 v(m6delay_threshold);
23384                 v(m6_links_to_log);
23385                 v(iE_Extensions);
23386
23387         };
23388         template<typename V> void encode(V& v) const
23389         {
23390                 v(m6report_interval);
23391                 v(m6delay_threshold);
23392                 v(m6_links_to_log);
23393                 v(iE_Extensions);
23394
23395         };
23396         void clear()
23397         {
23398                 m6report_interval.clear();
23399                 m6delay_threshold.clear();
23400                 m6_links_to_log.clear();
23401                 iE_Extensions.clear();
23402
23403         };
23404         private:
23405         m6report_interval_t     m6report_interval;
23406         m6delay_threshold_t     m6delay_threshold;
23407         m6_links_to_log_t       m6_links_to_log;
23408         iE_Extensions_t iE_Extensions;
23409
23410 };
23411 /*
23412 M7period ::= INTEGER(1..60, ...)
23413 */
23414
23415 struct M7period : asn::integer<>
23416 {
23417         using constraint_t = asn::constraints<true,asn::span<1, 60>>;
23418         static constexpr const char* name() {return "M7period";}
23419         using parent_t = asn::integer<>;
23420
23421 };
23422
23423 /*
23424 M7Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
23425         ...
23426 }
23427 */
23428
23429 struct M7Configuration_ExtIEs
23430 {
23431         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
23432         {
23433                 size_t get_index() const {return type;}
23434                 bool is_unknown() const { return type == 1; }
23435                 void clear() {type = 0;}
23436                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
23437                 template<typename V>  bool decode(V& v)
23438                 {
23439                         clear();
23440                         if(!v(ref_nested())) return false;
23441                         { type = 1; return true;}
23442                         return false;
23443
23444                 }
23445                 template<typename V> bool encode(V& v) const
23446                 {
23447                         return v(ref_nested());
23448
23449                 }
23450                 protected:
23451                 template<typename V>  bool decode(size_t index, V& v)
23452                 {
23453                         clear();
23454                         switch(index)
23455                         {
23456                         case 1: type = 1; return v(ref_nested());
23457                         ref_nested().clear();
23458                         }
23459                         return false;
23460
23461                 }
23462                 template<typename V> bool encode(size_t index, V& v) const
23463                 {
23464                         if(index != type) {return false;} return v(ref_nested());
23465
23466                 }
23467                 private:
23468                 size_t type {0};
23469
23470         };
23471         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
23472         {
23473                 size_t get_index() const {return type;}
23474                 bool is_unknown() const { return type == 1; }
23475                 void clear() {type = 0;}
23476                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
23477                 template<typename V>  bool decode(V& v)
23478                 {
23479                         clear();
23480                         if(!v(ref_nested())) return false;
23481                         { type = 1; return true;}
23482                         return false;
23483
23484                 }
23485                 template<typename V> bool encode(V& v) const
23486                 {
23487                         return v(ref_nested());
23488
23489                 }
23490                 protected:
23491                 template<typename V>  bool decode(size_t index, V& v)
23492                 {
23493                         clear();
23494                         switch(index)
23495                         {
23496                         case 1: type = 1; return v(ref_nested());
23497                         ref_nested().clear();
23498                         }
23499                         return false;
23500
23501                 }
23502                 template<typename V> bool encode(size_t index, V& v) const
23503                 {
23504                         if(index != type) {return false;} return v(ref_nested());
23505
23506                 }
23507                 private:
23508                 size_t type {0};
23509
23510         };
23511         struct Extension_t : asn::typefield<true>
23512         {
23513                 ~Extension_t()  {clear();}
23514                 size_t get_index() const {return type;}
23515                 bool is_unknown() const { return type == 1; }
23516                 void clear()
23517                 {
23518                         type = 0; ref_nested().clear();
23519                 }
23520                 template<typename V> static inline void enumerate(V& v)
23521                 {
23522
23523                 }
23524                 protected:
23525                 template<typename V> bool decode(size_t index, V& v)
23526                 {
23527                         clear();
23528                         switch(index)
23529                         {
23530                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
23531                         }
23532                         return false;
23533
23534                 }
23535                 template<typename V> bool encode(size_t index, V& v) const
23536                 {
23537                         if(index != type) return false;
23538                         return false;
23539
23540                 }
23541                 private:
23542                 size_t type {0};
23543
23544         };
23545         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
23546         {
23547                 size_t get_index() const {return type;}
23548                 bool is_unknown() const { return type == 1; }
23549                 void clear() {type = 0;}
23550                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
23551                 template<typename V>  bool decode(V& v)
23552                 {
23553                         clear();
23554                         if(!v(ref_nested())) return false;
23555                         { type = 1; return true;}
23556                         return false;
23557
23558                 }
23559                 template<typename V> bool encode(V& v) const
23560                 {
23561                         return v(ref_nested());
23562
23563                 }
23564                 protected:
23565                 template<typename V>  bool decode(size_t index, V& v)
23566                 {
23567                         clear();
23568                         switch(index)
23569                         {
23570                         case 1: type = 1; return v(ref_nested());
23571                         ref_nested().clear();
23572                         }
23573                         return false;
23574
23575                 }
23576                 template<typename V> bool encode(size_t index, V& v) const
23577                 {
23578                         if(index != type) {return false;} return v(ref_nested());
23579
23580                 }
23581                 private:
23582                 size_t type {0};
23583
23584         };
23585
23586 };
23587 /*
23588 M7Configuration ::= SEQUENCE {
23589         m7period                        M7period,
23590         m7-links-to-log         Links-to-log,
23591         iE-Extensions           ProtocolExtensionContainer { {M7Configuration-ExtIEs} } OPTIONAL,
23592         ...
23593 }
23594 */
23595
23596 struct M7Configuration : asn::sequence<3, 0, true, 1>
23597 {
23598         static constexpr const char* name() {return "M7Configuration";}
23599         using parent_t = asn::sequence<3, 0, true, 1>;
23600         struct m7period_t : M7period
23601         {
23602                 static constexpr const char* name() {return "m7period_t";}
23603                 using parent_t = M7period;
23604
23605         };
23606         m7period_t& ref_m7period() {return m7period;}
23607         m7period_t const& ref_m7period() const {return m7period;}
23608         struct m7_links_to_log_t : Links_to_log
23609         {
23610                 static constexpr const char* name() {return "m7_links_to_log_t";}
23611                 using parent_t = Links_to_log;
23612
23613         };
23614         m7_links_to_log_t& ref_m7_links_to_log() {return m7_links_to_log;}
23615         m7_links_to_log_t const& ref_m7_links_to_log() const {return m7_links_to_log;}
23616         struct iE_Extensions_t : ProtocolExtensionContainer<M7Configuration_ExtIEs>
23617         {
23618                 static constexpr const char* name() {return "iE_Extensions_t";}
23619                 using parent_t = ProtocolExtensionContainer<M7Configuration_ExtIEs>;
23620                 static constexpr bool optional = true;
23621
23622         };
23623         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
23624         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
23625         template<typename V> void decode(V& v)
23626         {
23627                 v(m7period);
23628                 v(m7_links_to_log);
23629                 v(iE_Extensions);
23630
23631         };
23632         template<typename V> void encode(V& v) const
23633         {
23634                 v(m7period);
23635                 v(m7_links_to_log);
23636                 v(iE_Extensions);
23637
23638         };
23639         void clear()
23640         {
23641                 m7period.clear();
23642                 m7_links_to_log.clear();
23643                 iE_Extensions.clear();
23644
23645         };
23646         private:
23647         m7period_t      m7period;
23648         m7_links_to_log_t       m7_links_to_log;
23649         iE_Extensions_t iE_Extensions;
23650
23651 };
23652 /*
23653 MBMS-Service-Area-Identity ::= OCTET STRING (SIZE (2))
23654 */
23655
23656 struct MBMS_Service_Area_Identity : asn::ostring<>
23657 {
23658         using constraint_t = asn::constraints<false,asn::one<2>>;
23659         static constexpr const char* name() {return "MBMS-Service-Area-Identity";}
23660         using parent_t = asn::ostring<>;
23661
23662 };
23663
23664 /*
23665 MBMS-Service-Area-Identity-List ::= SEQUENCE (SIZE(1.. maxnoofMBMSServiceAreaIdentities)) OF MBMS-Service-Area-Identity
23666 */
23667
23668 struct MBMS_Service_Area_Identity_List_elm : MBMS_Service_Area_Identity
23669 {
23670         static constexpr const char* name() {return "MBMS_Service_Area_Identity_List_elm";}
23671         using parent_t = MBMS_Service_Area_Identity;
23672
23673 };
23674 struct MBMS_Service_Area_Identity_List : asn::sequenceof<MBMS_Service_Area_Identity_List_elm>
23675 {
23676         static constexpr const char* name() {return "MBMS-Service-Area-Identity-List";}
23677         using parent_t = asn::sequenceof<MBMS_Service_Area_Identity_List_elm>;
23678         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofMBMSServiceAreaIdentities >>;
23679
23680 };
23681 /*
23682 RadioframeAllocationPeriod ::= ENUMERATED{
23683         n1,
23684         n2,
23685         n4,
23686         n8,
23687         n16,
23688         n32,
23689         ...
23690 }
23691 */
23692
23693 struct RadioframeAllocationPeriod : asn::enumerated<6, 0, true>
23694 {
23695         static constexpr const char* name() {return "RadioframeAllocationPeriod";}
23696         using parent_t = asn::enumerated<6, 0, true>;
23697         typedef enum {
23698                 n1
23699                 ,n2
23700                 ,n4
23701                 ,n8
23702                 ,n16
23703                 ,n32
23704         } index_t;
23705
23706 };
23707
23708 /*
23709 RadioframeAllocationOffset ::= INTEGER (0..7, ...)
23710 */
23711
23712 struct RadioframeAllocationOffset : asn::integer<>
23713 {
23714         using constraint_t = asn::constraints<true,asn::span<0, 7>>;
23715         static constexpr const char* name() {return "RadioframeAllocationOffset";}
23716         using parent_t = asn::integer<>;
23717
23718 };
23719
23720 /*
23721 Oneframe ::= BIT STRING (SIZE (6))
23722 */
23723
23724 struct Oneframe : asn::bstring<>
23725 {
23726         using constraint_t = asn::constraints<false,asn::one<6>>;
23727         static constexpr const char* name() {return "Oneframe";}
23728         using parent_t = asn::bstring<>;
23729
23730 };
23731
23732 /*
23733 SubframeAllocation ::= CHOICE {
23734         oneframe                                                Oneframe,
23735         fourframes                                              Fourframes,
23736         ...
23737 }
23738 */
23739
23740 struct SubframeAllocation : asn::choice<2, 0, true>
23741 {
23742         static constexpr const char* name() {return "SubframeAllocation";}
23743         using parent_t = asn::choice<2, 0, true>;
23744         index_type get_index() const {return index;}
23745         bool is_unknown() const {return index == 3;}
23746         void set_unknown() { set_index(3);  }
23747         ~SubframeAllocation() {clear();}
23748         struct oneframe_t : Oneframe
23749         {
23750                 static constexpr const char* name() {return "oneframe_t";}
23751                 using parent_t = Oneframe;
23752
23753         };
23754         struct fourframes_t : Fourframes
23755         {
23756                 static constexpr const char* name() {return "fourframes_t";}
23757                 using parent_t = Fourframes;
23758
23759         };
23760         void clear()
23761         {
23762                 switch(get_index())
23763                 {
23764                 case 1: var.destroy<oneframe_t>(); break;
23765                 case 2: var.destroy<fourframes_t>(); break;
23766                 }
23767                 index = 0;
23768                 base::clear();
23769         }
23770         template<typename V> bool decode(size_t idx, V& v)
23771         {
23772                 clear();
23773                 switch(idx)
23774                 {
23775                 case 1: set_index(1); return v(var.build<oneframe_t>());
23776                 case 2: set_index(2); return v(var.build<fourframes_t>());
23777                 }
23778                 return false;
23779
23780         }
23781         template<typename V> bool encode(V& v) const
23782         {
23783                 switch(get_index())
23784                 {
23785                 case 1: return v(var.as<oneframe_t>());
23786                 case 2: return v(var.as<fourframes_t>());
23787                 }
23788                 return false;
23789         }
23790         template<typename V> static inline void enumerate(V& v)
23791         {
23792                 v.template operator()<oneframe_t>(1);
23793                 v.template operator()<fourframes_t>(2);
23794
23795         }
23796         oneframe_t& select_oneframe() { if(get_index() != 1) { clear(); set_index(1); return var.build<oneframe_t>();} return var.as<oneframe_t>();}
23797         oneframe_t const* get_oneframe() const { if(get_index() == 1) { return &var.as<oneframe_t>();} return nullptr; }
23798         fourframes_t& select_fourframes() { if(get_index() != 2) { clear(); set_index(2); return var.build<fourframes_t>();} return var.as<fourframes_t>();}
23799         fourframes_t const* get_fourframes() const { if(get_index() == 2) { return &var.as<fourframes_t>();} return nullptr; }
23800         private:
23801         void set_index(index_type i) {index = i; base::set();}
23802         union union_type
23803         {
23804                 char dummy1[sizeof(oneframe_t)];
23805                 char dummy2[sizeof(fourframes_t)];
23806
23807         };
23808         asn::variant<sizeof(union_type)>        var;
23809         index_type      index {0};
23810 };
23811 /*
23812 MBSFN-Subframe-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
23813         ...
23814 }
23815 */
23816
23817 struct MBSFN_Subframe_Info_ExtIEs
23818 {
23819         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
23820         {
23821                 size_t get_index() const {return type;}
23822                 bool is_unknown() const { return type == 1; }
23823                 void clear() {type = 0;}
23824                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
23825                 template<typename V>  bool decode(V& v)
23826                 {
23827                         clear();
23828                         if(!v(ref_nested())) return false;
23829                         { type = 1; return true;}
23830                         return false;
23831
23832                 }
23833                 template<typename V> bool encode(V& v) const
23834                 {
23835                         return v(ref_nested());
23836
23837                 }
23838                 protected:
23839                 template<typename V>  bool decode(size_t index, V& v)
23840                 {
23841                         clear();
23842                         switch(index)
23843                         {
23844                         case 1: type = 1; return v(ref_nested());
23845                         ref_nested().clear();
23846                         }
23847                         return false;
23848
23849                 }
23850                 template<typename V> bool encode(size_t index, V& v) const
23851                 {
23852                         if(index != type) {return false;} return v(ref_nested());
23853
23854                 }
23855                 private:
23856                 size_t type {0};
23857
23858         };
23859         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
23860         {
23861                 size_t get_index() const {return type;}
23862                 bool is_unknown() const { return type == 1; }
23863                 void clear() {type = 0;}
23864                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
23865                 template<typename V>  bool decode(V& v)
23866                 {
23867                         clear();
23868                         if(!v(ref_nested())) return false;
23869                         { type = 1; return true;}
23870                         return false;
23871
23872                 }
23873                 template<typename V> bool encode(V& v) const
23874                 {
23875                         return v(ref_nested());
23876
23877                 }
23878                 protected:
23879                 template<typename V>  bool decode(size_t index, V& v)
23880                 {
23881                         clear();
23882                         switch(index)
23883                         {
23884                         case 1: type = 1; return v(ref_nested());
23885                         ref_nested().clear();
23886                         }
23887                         return false;
23888
23889                 }
23890                 template<typename V> bool encode(size_t index, V& v) const
23891                 {
23892                         if(index != type) {return false;} return v(ref_nested());
23893
23894                 }
23895                 private:
23896                 size_t type {0};
23897
23898         };
23899         struct Extension_t : asn::typefield<true>
23900         {
23901                 ~Extension_t()  {clear();}
23902                 size_t get_index() const {return type;}
23903                 bool is_unknown() const { return type == 1; }
23904                 void clear()
23905                 {
23906                         type = 0; ref_nested().clear();
23907                 }
23908                 template<typename V> static inline void enumerate(V& v)
23909                 {
23910
23911                 }
23912                 protected:
23913                 template<typename V> bool decode(size_t index, V& v)
23914                 {
23915                         clear();
23916                         switch(index)
23917                         {
23918                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
23919                         }
23920                         return false;
23921
23922                 }
23923                 template<typename V> bool encode(size_t index, V& v) const
23924                 {
23925                         if(index != type) return false;
23926                         return false;
23927
23928                 }
23929                 private:
23930                 size_t type {0};
23931
23932         };
23933         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
23934         {
23935                 size_t get_index() const {return type;}
23936                 bool is_unknown() const { return type == 1; }
23937                 void clear() {type = 0;}
23938                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
23939                 template<typename V>  bool decode(V& v)
23940                 {
23941                         clear();
23942                         if(!v(ref_nested())) return false;
23943                         { type = 1; return true;}
23944                         return false;
23945
23946                 }
23947                 template<typename V> bool encode(V& v) const
23948                 {
23949                         return v(ref_nested());
23950
23951                 }
23952                 protected:
23953                 template<typename V>  bool decode(size_t index, V& v)
23954                 {
23955                         clear();
23956                         switch(index)
23957                         {
23958                         case 1: type = 1; return v(ref_nested());
23959                         ref_nested().clear();
23960                         }
23961                         return false;
23962
23963                 }
23964                 template<typename V> bool encode(size_t index, V& v) const
23965                 {
23966                         if(index != type) {return false;} return v(ref_nested());
23967
23968                 }
23969                 private:
23970                 size_t type {0};
23971
23972         };
23973
23974 };
23975 /*
23976 MBSFN-Subframe-Info     ::= SEQUENCE {
23977         radioframeAllocationPeriod              RadioframeAllocationPeriod,
23978         radioframeAllocationOffset              RadioframeAllocationOffset,
23979         subframeAllocation                              SubframeAllocation,
23980         iE-Extensions                                   ProtocolExtensionContainer { {MBSFN-Subframe-Info-ExtIEs} }     OPTIONAL,
23981         ...
23982 }
23983 */
23984
23985 struct MBSFN_Subframe_Info : asn::sequence<4, 0, true, 1>
23986 {
23987         static constexpr const char* name() {return "MBSFN-Subframe-Info";}
23988         using parent_t = asn::sequence<4, 0, true, 1>;
23989         struct radioframeAllocationPeriod_t : RadioframeAllocationPeriod
23990         {
23991                 static constexpr const char* name() {return "radioframeAllocationPeriod_t";}
23992                 using parent_t = RadioframeAllocationPeriod;
23993
23994         };
23995         radioframeAllocationPeriod_t& ref_radioframeAllocationPeriod() {return radioframeAllocationPeriod;}
23996         radioframeAllocationPeriod_t const& ref_radioframeAllocationPeriod() const {return radioframeAllocationPeriod;}
23997         struct radioframeAllocationOffset_t : RadioframeAllocationOffset
23998         {
23999                 static constexpr const char* name() {return "radioframeAllocationOffset_t";}
24000                 using parent_t = RadioframeAllocationOffset;
24001
24002         };
24003         radioframeAllocationOffset_t& ref_radioframeAllocationOffset() {return radioframeAllocationOffset;}
24004         radioframeAllocationOffset_t const& ref_radioframeAllocationOffset() const {return radioframeAllocationOffset;}
24005         struct subframeAllocation_t : SubframeAllocation
24006         {
24007                 static constexpr const char* name() {return "subframeAllocation_t";}
24008                 using parent_t = SubframeAllocation;
24009
24010         };
24011         subframeAllocation_t& ref_subframeAllocation() {return subframeAllocation;}
24012         subframeAllocation_t const& ref_subframeAllocation() const {return subframeAllocation;}
24013         struct iE_Extensions_t : ProtocolExtensionContainer<MBSFN_Subframe_Info_ExtIEs>
24014         {
24015                 static constexpr const char* name() {return "iE_Extensions_t";}
24016                 using parent_t = ProtocolExtensionContainer<MBSFN_Subframe_Info_ExtIEs>;
24017                 static constexpr bool optional = true;
24018
24019         };
24020         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
24021         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
24022         template<typename V> void decode(V& v)
24023         {
24024                 v(radioframeAllocationPeriod);
24025                 v(radioframeAllocationOffset);
24026                 v(subframeAllocation);
24027                 v(iE_Extensions);
24028
24029         };
24030         template<typename V> void encode(V& v) const
24031         {
24032                 v(radioframeAllocationPeriod);
24033                 v(radioframeAllocationOffset);
24034                 v(subframeAllocation);
24035                 v(iE_Extensions);
24036
24037         };
24038         void clear()
24039         {
24040                 radioframeAllocationPeriod.clear();
24041                 radioframeAllocationOffset.clear();
24042                 subframeAllocation.clear();
24043                 iE_Extensions.clear();
24044
24045         };
24046         private:
24047         radioframeAllocationPeriod_t    radioframeAllocationPeriod;
24048         radioframeAllocationOffset_t    radioframeAllocationOffset;
24049         subframeAllocation_t    subframeAllocation;
24050         iE_Extensions_t iE_Extensions;
24051
24052 };
24053 /*
24054 MBSFN-Subframe-Infolist::= SEQUENCE (SIZE(1.. maxnoofMBSFN)) OF MBSFN-Subframe-Info
24055 */
24056
24057 struct MBSFN_Subframe_Infolist_elm : MBSFN_Subframe_Info
24058 {
24059         static constexpr const char* name() {return "MBSFN_Subframe_Infolist_elm";}
24060         using parent_t = MBSFN_Subframe_Info;
24061
24062 };
24063 struct MBSFN_Subframe_Infolist : asn::sequenceof<MBSFN_Subframe_Infolist_elm>
24064 {
24065         static constexpr const char* name() {return "MBSFN-Subframe-Infolist";}
24066         using parent_t = asn::sequenceof<MBSFN_Subframe_Infolist_elm>;
24067         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofMBSFN >>;
24068
24069 };
24070 /*
24071 MDT-Activation          ::= ENUMERATED {
24072         immediate-MDT-only,
24073         immediate-MDT-and-Trace,
24074         ...
24075 }
24076 */
24077
24078 struct MDT_Activation : asn::enumerated<2, 0, true>
24079 {
24080         static constexpr const char* name() {return "MDT-Activation";}
24081         using parent_t = asn::enumerated<2, 0, true>;
24082         typedef enum {
24083                 immediate_MDT_only
24084                 ,immediate_MDT_and_Trace
24085         } index_t;
24086
24087 };
24088
24089 /*
24090 MeasurementsToActivate::= BIT STRING (SIZE (8))
24091 */
24092
24093 struct MeasurementsToActivate : asn::bstring<>
24094 {
24095         using constraint_t = asn::constraints<false,asn::one<8>>;
24096         static constexpr const char* name() {return "MeasurementsToActivate";}
24097         using parent_t = asn::bstring<>;
24098
24099 };
24100
24101 /*
24102 MDT-Location-Info ::= BIT STRING (SIZE (8))
24103 */
24104
24105 struct MDT_Location_Info : asn::bstring<>
24106 {
24107         using constraint_t = asn::constraints<false,asn::one<8>>;
24108         static constexpr const char* name() {return "MDT-Location-Info";}
24109         using parent_t = asn::bstring<>;
24110
24111 };
24112
24113 /*
24114 MDTPLMNList ::= SEQUENCE (SIZE(1..maxnoofMDTPLMNs)) OF PLMN-Identity
24115 */
24116
24117 struct MDTPLMNList_elm : PLMN_Identity
24118 {
24119         static constexpr const char* name() {return "MDTPLMNList_elm";}
24120         using parent_t = PLMN_Identity;
24121
24122 };
24123 struct MDTPLMNList : asn::sequenceof<MDTPLMNList_elm>
24124 {
24125         static constexpr const char* name() {return "MDTPLMNList";}
24126         using parent_t = asn::sequenceof<MDTPLMNList_elm>;
24127         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofMDTPLMNs >>;
24128
24129 };
24130 /*
24131 WLANMeasConfig::= ENUMERATED {setup,...}
24132 */
24133
24134 struct WLANMeasConfig : asn::enumerated<1, 0, true>
24135 {
24136         static constexpr const char* name() {return "WLANMeasConfig";}
24137         using parent_t = asn::enumerated<1, 0, true>;
24138         typedef enum {
24139                 setup
24140         } index_t;
24141
24142 };
24143
24144 /*
24145 WLANName ::= OCTET STRING (SIZE (1..32))
24146 */
24147
24148 struct WLANName : asn::ostring<>
24149 {
24150         using constraint_t = asn::constraints<false,asn::span<1, 32>>;
24151         static constexpr const char* name() {return "WLANName";}
24152         using parent_t = asn::ostring<>;
24153
24154 };
24155
24156 /*
24157 WLANMeasConfigNameList ::= SEQUENCE (SIZE(1..maxnoofWLANName)) OF WLANName
24158 */
24159
24160 struct WLANMeasConfigNameList_elm : WLANName
24161 {
24162         static constexpr const char* name() {return "WLANMeasConfigNameList_elm";}
24163         using parent_t = WLANName;
24164
24165 };
24166 struct WLANMeasConfigNameList : asn::sequenceof<WLANMeasConfigNameList_elm>
24167 {
24168         static constexpr const char* name() {return "WLANMeasConfigNameList";}
24169         using parent_t = asn::sequenceof<WLANMeasConfigNameList_elm>;
24170         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofWLANName >>;
24171
24172 };
24173 /*
24174 WLANMeasurementConfiguration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
24175         ...
24176 }
24177 */
24178
24179 struct WLANMeasurementConfiguration_ExtIEs
24180 {
24181         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
24182         {
24183                 size_t get_index() const {return type;}
24184                 bool is_unknown() const { return type == 1; }
24185                 void clear() {type = 0;}
24186                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
24187                 template<typename V>  bool decode(V& v)
24188                 {
24189                         clear();
24190                         if(!v(ref_nested())) return false;
24191                         { type = 1; return true;}
24192                         return false;
24193
24194                 }
24195                 template<typename V> bool encode(V& v) const
24196                 {
24197                         return v(ref_nested());
24198
24199                 }
24200                 protected:
24201                 template<typename V>  bool decode(size_t index, V& v)
24202                 {
24203                         clear();
24204                         switch(index)
24205                         {
24206                         case 1: type = 1; return v(ref_nested());
24207                         ref_nested().clear();
24208                         }
24209                         return false;
24210
24211                 }
24212                 template<typename V> bool encode(size_t index, V& v) const
24213                 {
24214                         if(index != type) {return false;} return v(ref_nested());
24215
24216                 }
24217                 private:
24218                 size_t type {0};
24219
24220         };
24221         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
24222         {
24223                 size_t get_index() const {return type;}
24224                 bool is_unknown() const { return type == 1; }
24225                 void clear() {type = 0;}
24226                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
24227                 template<typename V>  bool decode(V& v)
24228                 {
24229                         clear();
24230                         if(!v(ref_nested())) return false;
24231                         { type = 1; return true;}
24232                         return false;
24233
24234                 }
24235                 template<typename V> bool encode(V& v) const
24236                 {
24237                         return v(ref_nested());
24238
24239                 }
24240                 protected:
24241                 template<typename V>  bool decode(size_t index, V& v)
24242                 {
24243                         clear();
24244                         switch(index)
24245                         {
24246                         case 1: type = 1; return v(ref_nested());
24247                         ref_nested().clear();
24248                         }
24249                         return false;
24250
24251                 }
24252                 template<typename V> bool encode(size_t index, V& v) const
24253                 {
24254                         if(index != type) {return false;} return v(ref_nested());
24255
24256                 }
24257                 private:
24258                 size_t type {0};
24259
24260         };
24261         struct Extension_t : asn::typefield<true>
24262         {
24263                 ~Extension_t()  {clear();}
24264                 size_t get_index() const {return type;}
24265                 bool is_unknown() const { return type == 1; }
24266                 void clear()
24267                 {
24268                         type = 0; ref_nested().clear();
24269                 }
24270                 template<typename V> static inline void enumerate(V& v)
24271                 {
24272
24273                 }
24274                 protected:
24275                 template<typename V> bool decode(size_t index, V& v)
24276                 {
24277                         clear();
24278                         switch(index)
24279                         {
24280                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
24281                         }
24282                         return false;
24283
24284                 }
24285                 template<typename V> bool encode(size_t index, V& v) const
24286                 {
24287                         if(index != type) return false;
24288                         return false;
24289
24290                 }
24291                 private:
24292                 size_t type {0};
24293
24294         };
24295         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
24296         {
24297                 size_t get_index() const {return type;}
24298                 bool is_unknown() const { return type == 1; }
24299                 void clear() {type = 0;}
24300                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
24301                 template<typename V>  bool decode(V& v)
24302                 {
24303                         clear();
24304                         if(!v(ref_nested())) return false;
24305                         { type = 1; return true;}
24306                         return false;
24307
24308                 }
24309                 template<typename V> bool encode(V& v) const
24310                 {
24311                         return v(ref_nested());
24312
24313                 }
24314                 protected:
24315                 template<typename V>  bool decode(size_t index, V& v)
24316                 {
24317                         clear();
24318                         switch(index)
24319                         {
24320                         case 1: type = 1; return v(ref_nested());
24321                         ref_nested().clear();
24322                         }
24323                         return false;
24324
24325                 }
24326                 template<typename V> bool encode(size_t index, V& v) const
24327                 {
24328                         if(index != type) {return false;} return v(ref_nested());
24329
24330                 }
24331                 private:
24332                 size_t type {0};
24333
24334         };
24335
24336 };
24337 /*
24338 WLANMeasurementConfiguration ::= SEQUENCE {
24339         wlanMeasConfig                          WLANMeasConfig,
24340         wlanMeasConfigNameList          WLANMeasConfigNameList                          OPTIONAL,
24341         wlan-rssi                                       ENUMERATED {true, ...}                          OPTIONAL,
24342         wlan-rtt                                        ENUMERATED {true, ...}                          OPTIONAL,
24343         iE-Extensions           ProtocolExtensionContainer { {WLANMeasurementConfiguration-ExtIEs} } OPTIONAL,
24344         ...
24345 }
24346 */
24347
24348 struct WLANMeasurementConfiguration : asn::sequence<5, 0, true, 4>
24349 {
24350         static constexpr const char* name() {return "WLANMeasurementConfiguration";}
24351         using parent_t = asn::sequence<5, 0, true, 4>;
24352         struct wlanMeasConfig_t : WLANMeasConfig
24353         {
24354                 static constexpr const char* name() {return "wlanMeasConfig_t";}
24355                 using parent_t = WLANMeasConfig;
24356
24357         };
24358         wlanMeasConfig_t& ref_wlanMeasConfig() {return wlanMeasConfig;}
24359         wlanMeasConfig_t const& ref_wlanMeasConfig() const {return wlanMeasConfig;}
24360         struct wlanMeasConfigNameList_t : WLANMeasConfigNameList
24361         {
24362                 static constexpr const char* name() {return "wlanMeasConfigNameList_t";}
24363                 using parent_t = WLANMeasConfigNameList;
24364                 static constexpr bool optional = true;
24365
24366         };
24367         wlanMeasConfigNameList_t& set_wlanMeasConfigNameList() { wlanMeasConfigNameList.setpresent(true); return wlanMeasConfigNameList;}
24368         wlanMeasConfigNameList_t const* get_wlanMeasConfigNameList() const {return wlanMeasConfigNameList.is_valid() ? &wlanMeasConfigNameList : nullptr;}
24369         struct wlan_rssi_t : asn::enumerated<1, 0, true>
24370         {
24371                 static constexpr const char* name() {return "wlan_rssi_t";}
24372                 using parent_t = asn::enumerated<1, 0, true>;
24373                 static constexpr bool optional = true;
24374                 typedef enum {
24375                         True
24376                 } index_t;
24377
24378         };
24379
24380         wlan_rssi_t& set_wlan_rssi() { wlan_rssi.setpresent(true); return wlan_rssi;}
24381         wlan_rssi_t const* get_wlan_rssi() const {return wlan_rssi.is_valid() ? &wlan_rssi : nullptr;}
24382         struct wlan_rtt_t : asn::enumerated<1, 0, true>
24383         {
24384                 static constexpr const char* name() {return "wlan_rtt_t";}
24385                 using parent_t = asn::enumerated<1, 0, true>;
24386                 static constexpr bool optional = true;
24387                 typedef enum {
24388                         True
24389                 } index_t;
24390
24391         };
24392
24393         wlan_rtt_t& set_wlan_rtt() { wlan_rtt.setpresent(true); return wlan_rtt;}
24394         wlan_rtt_t const* get_wlan_rtt() const {return wlan_rtt.is_valid() ? &wlan_rtt : nullptr;}
24395         struct iE_Extensions_t : ProtocolExtensionContainer<WLANMeasurementConfiguration_ExtIEs>
24396         {
24397                 static constexpr const char* name() {return "iE_Extensions_t";}
24398                 using parent_t = ProtocolExtensionContainer<WLANMeasurementConfiguration_ExtIEs>;
24399                 static constexpr bool optional = true;
24400
24401         };
24402         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
24403         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
24404         template<typename V> void decode(V& v)
24405         {
24406                 v(wlanMeasConfig);
24407                 v(wlanMeasConfigNameList);
24408                 v(wlan_rssi);
24409                 v(wlan_rtt);
24410                 v(iE_Extensions);
24411
24412         };
24413         template<typename V> void encode(V& v) const
24414         {
24415                 v(wlanMeasConfig);
24416                 v(wlanMeasConfigNameList);
24417                 v(wlan_rssi);
24418                 v(wlan_rtt);
24419                 v(iE_Extensions);
24420
24421         };
24422         void clear()
24423         {
24424                 wlanMeasConfig.clear();
24425                 wlanMeasConfigNameList.clear();
24426                 wlan_rssi.clear();
24427                 wlan_rtt.clear();
24428                 iE_Extensions.clear();
24429
24430         };
24431         private:
24432         wlanMeasConfig_t        wlanMeasConfig;
24433         wlanMeasConfigNameList_t        wlanMeasConfigNameList;
24434         wlan_rssi_t     wlan_rssi;
24435         wlan_rtt_t      wlan_rtt;
24436         iE_Extensions_t iE_Extensions;
24437
24438 };
24439 /*
24440 MDT-Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
24441         {ID id-M3Configuration                                                  CRITICALITY ignore      EXTENSION M3Configuration                                                               PRESENCE conditional}|
24442         {ID id-M4Configuration                                                  CRITICALITY ignore      EXTENSION M4Configuration                                                               PRESENCE conditional}|
24443         {ID id-M5Configuration                                                  CRITICALITY ignore      EXTENSION M5Configuration                                                               PRESENCE conditional}|
24444         {ID id-MDT-Location-Info                                                CRITICALITY ignore      EXTENSION MDT-Location-Info                                                     PRESENCE optional}|
24445         {ID id-SignallingBasedMDTPLMNList                               CRITICALITY ignore      EXTENSION MDTPLMNList                                                                   PRESENCE optional}|
24446         {ID id-M6Configuration                                                  CRITICALITY ignore      EXTENSION M6Configuration                                                               PRESENCE conditional}|
24447         {ID id-M7Configuration                                                  CRITICALITY ignore      EXTENSION M7Configuration                                                               PRESENCE conditional}|
24448         { ID id-BluetoothMeasurementConfiguration               CRITICALITY ignore      EXTENSION BluetoothMeasurementConfiguration             PRESENCE optional}|
24449         { ID id-WLANMeasurementConfiguration                    CRITICALITY ignore      EXTENSION WLANMeasurementConfiguration                  PRESENCE optional},
24450         ...
24451 }
24452 */
24453
24454 struct MDT_Configuration_ExtIEs
24455 {
24456         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
24457         {
24458                 size_t get_index() const {return type;}
24459                 bool is_unknown() const { return type == 10; }
24460                 void clear() {type = 0;}
24461                 void select_id_M3Configuration() { set(id_M3Configuration); type=1;}
24462                 void select_id_M4Configuration() { set(id_M4Configuration); type=2;}
24463                 void select_id_M5Configuration() { set(id_M5Configuration); type=3;}
24464                 void select_id_MDT_Location_Info() { set(id_MDT_Location_Info); type=4;}
24465                 void select_id_SignallingBasedMDTPLMNList() { set(id_SignallingBasedMDTPLMNList); type=5;}
24466                 void select_id_M6Configuration() { set(id_M6Configuration); type=6;}
24467                 void select_id_M7Configuration() { set(id_M7Configuration); type=7;}
24468                 void select_id_BluetoothMeasurementConfiguration() { set(id_BluetoothMeasurementConfiguration); type=8;}
24469                 void select_id_WLANMeasurementConfiguration() { set(id_WLANMeasurementConfiguration); type=9;}
24470                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
24471                 template<typename V>  bool decode(V& v)
24472                 {
24473                         clear();
24474                         if(!v(ref_nested())) return false;
24475                         if(equal(id_M3Configuration)) { type = 1; return true; }
24476                         else if(equal(id_M4Configuration)) { type = 2; return true; }
24477                         else if(equal(id_M5Configuration)) { type = 3; return true; }
24478                         else if(equal(id_MDT_Location_Info)) { type = 4; return true; }
24479                         else if(equal(id_SignallingBasedMDTPLMNList)) { type = 5; return true; }
24480                         else if(equal(id_M6Configuration)) { type = 6; return true; }
24481                         else if(equal(id_M7Configuration)) { type = 7; return true; }
24482                         else if(equal(id_BluetoothMeasurementConfiguration)) { type = 8; return true; }
24483                         else if(equal(id_WLANMeasurementConfiguration)) { type = 9; return true; }
24484                         else { type = 10; return true;}
24485                         return false;
24486
24487                 }
24488                 template<typename V> bool encode(V& v) const
24489                 {
24490                         return v(ref_nested());
24491
24492                 }
24493                 protected:
24494                 template<typename V>  bool decode(size_t index, V& v)
24495                 {
24496                         clear();
24497                         switch(index)
24498                         {
24499                         case 1: type = 1; if(v(ref_nested())) { return equal(id_M3Configuration);} return false;
24500                         case 2: type = 2; if(v(ref_nested())) { return equal(id_M4Configuration);} return false;
24501                         case 3: type = 3; if(v(ref_nested())) { return equal(id_M5Configuration);} return false;
24502                         case 4: type = 4; if(v(ref_nested())) { return equal(id_MDT_Location_Info);} return false;
24503                         case 5: type = 5; if(v(ref_nested())) { return equal(id_SignallingBasedMDTPLMNList);} return false;
24504                         case 6: type = 6; if(v(ref_nested())) { return equal(id_M6Configuration);} return false;
24505                         case 7: type = 7; if(v(ref_nested())) { return equal(id_M7Configuration);} return false;
24506                         case 8: type = 8; if(v(ref_nested())) { return equal(id_BluetoothMeasurementConfiguration);} return false;
24507                         case 9: type = 9; if(v(ref_nested())) { return equal(id_WLANMeasurementConfiguration);} return false;
24508                         case 10: type = 10; return v(ref_nested());
24509                         ref_nested().clear();
24510                         }
24511                         return false;
24512
24513                 }
24514                 template<typename V> bool encode(size_t index, V& v) const
24515                 {
24516                         if(index != type) {return false;} return v(ref_nested());
24517
24518                 }
24519                 private:
24520                 size_t type {0};
24521
24522         };
24523         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
24524         {
24525                 size_t get_index() const {return type;}
24526                 bool is_unknown() const { return type == 10; }
24527                 void clear() {type = 0;}
24528                 void select_id_M3Configuration() { set(ignore); type=1;}
24529                 void select_id_M4Configuration() { set(ignore); type=2;}
24530                 void select_id_M5Configuration() { set(ignore); type=3;}
24531                 void select_id_MDT_Location_Info() { set(ignore); type=4;}
24532                 void select_id_SignallingBasedMDTPLMNList() { set(ignore); type=5;}
24533                 void select_id_M6Configuration() { set(ignore); type=6;}
24534                 void select_id_M7Configuration() { set(ignore); type=7;}
24535                 void select_id_BluetoothMeasurementConfiguration() { set(ignore); type=8;}
24536                 void select_id_WLANMeasurementConfiguration() { set(ignore); type=9;}
24537                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
24538                 template<typename V>  bool decode(V& v)
24539                 {
24540                         clear();
24541                         if(!v(ref_nested())) return false;
24542                         if(equal(ignore)) { type = 1; return true; }
24543                         else if(equal(ignore)) { type = 2; return true; }
24544                         else if(equal(ignore)) { type = 3; return true; }
24545                         else if(equal(ignore)) { type = 4; return true; }
24546                         else if(equal(ignore)) { type = 5; return true; }
24547                         else if(equal(ignore)) { type = 6; return true; }
24548                         else if(equal(ignore)) { type = 7; return true; }
24549                         else if(equal(ignore)) { type = 8; return true; }
24550                         else if(equal(ignore)) { type = 9; return true; }
24551                         else { type = 10; return true;}
24552                         return false;
24553
24554                 }
24555                 template<typename V> bool encode(V& v) const
24556                 {
24557                         return v(ref_nested());
24558
24559                 }
24560                 protected:
24561                 template<typename V>  bool decode(size_t index, V& v)
24562                 {
24563                         clear();
24564                         switch(index)
24565                         {
24566                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
24567                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
24568                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
24569                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
24570                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
24571                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
24572                         case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
24573                         case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
24574                         case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
24575                         case 10: type = 10; return v(ref_nested());
24576                         ref_nested().clear();
24577                         }
24578                         return false;
24579
24580                 }
24581                 template<typename V> bool encode(size_t index, V& v) const
24582                 {
24583                         if(index != type) {return false;} return v(ref_nested());
24584
24585                 }
24586                 private:
24587                 size_t type {0};
24588
24589         };
24590         struct Extension_t : asn::typefield<true>
24591         {
24592                 ~Extension_t()  {clear();}
24593                 size_t get_index() const {return type;}
24594                 M3Configuration& select_id_M3Configuration() { return set<M3Configuration>(1); }
24595                 M3Configuration const* get_id_M3Configuration() const { return get<M3Configuration>(1); }
24596                 M4Configuration& select_id_M4Configuration() { return set<M4Configuration>(2); }
24597                 M4Configuration const* get_id_M4Configuration() const { return get<M4Configuration>(2); }
24598                 M5Configuration& select_id_M5Configuration() { return set<M5Configuration>(3); }
24599                 M5Configuration const* get_id_M5Configuration() const { return get<M5Configuration>(3); }
24600                 MDT_Location_Info& select_id_MDT_Location_Info() { return set<MDT_Location_Info>(4); }
24601                 MDT_Location_Info const* get_id_MDT_Location_Info() const { return get<MDT_Location_Info>(4); }
24602                 MDTPLMNList& select_id_SignallingBasedMDTPLMNList() { return set<MDTPLMNList>(5); }
24603                 MDTPLMNList const* get_id_SignallingBasedMDTPLMNList() const { return get<MDTPLMNList>(5); }
24604                 M6Configuration& select_id_M6Configuration() { return set<M6Configuration>(6); }
24605                 M6Configuration const* get_id_M6Configuration() const { return get<M6Configuration>(6); }
24606                 M7Configuration& select_id_M7Configuration() { return set<M7Configuration>(7); }
24607                 M7Configuration const* get_id_M7Configuration() const { return get<M7Configuration>(7); }
24608                 BluetoothMeasurementConfiguration& select_id_BluetoothMeasurementConfiguration() { return set<BluetoothMeasurementConfiguration>(8); }
24609                 BluetoothMeasurementConfiguration const* get_id_BluetoothMeasurementConfiguration() const { return get<BluetoothMeasurementConfiguration>(8); }
24610                 WLANMeasurementConfiguration& select_id_WLANMeasurementConfiguration() { return set<WLANMeasurementConfiguration>(9); }
24611                 WLANMeasurementConfiguration const* get_id_WLANMeasurementConfiguration() const { return get<WLANMeasurementConfiguration>(9); }
24612                 bool is_unknown() const { return type == 10; }
24613                 void clear()
24614                 {
24615                         switch(type)
24616                         {
24617                         case 1: var.destroy<M3Configuration>(); break;
24618                         case 2: var.destroy<M4Configuration>(); break;
24619                         case 3: var.destroy<M5Configuration>(); break;
24620                         case 4: var.destroy<MDT_Location_Info>(); break;
24621                         case 5: var.destroy<MDTPLMNList>(); break;
24622                         case 6: var.destroy<M6Configuration>(); break;
24623                         case 7: var.destroy<M7Configuration>(); break;
24624                         case 8: var.destroy<BluetoothMeasurementConfiguration>(); break;
24625                         case 9: var.destroy<WLANMeasurementConfiguration>(); break;
24626                         }
24627                         type = 0; ref_nested().clear();
24628                 }
24629                 template<typename V> static inline void enumerate(V& v)
24630                 {
24631                         v.template operator()<M3Configuration>(1);
24632                         v.template operator()<M4Configuration>(2);
24633                         v.template operator()<M5Configuration>(3);
24634                         v.template operator()<MDT_Location_Info>(4);
24635                         v.template operator()<MDTPLMNList>(5);
24636                         v.template operator()<M6Configuration>(6);
24637                         v.template operator()<M7Configuration>(7);
24638                         v.template operator()<BluetoothMeasurementConfiguration>(8);
24639                         v.template operator()<WLANMeasurementConfiguration>(9);
24640
24641                 }
24642                 protected:
24643                 template<typename V> bool decode(size_t index, V& v)
24644                 {
24645                         clear();
24646                         switch(index)
24647                         {
24648                         case 1: v(select_id_M3Configuration()); return true;
24649                         case 2: v(select_id_M4Configuration()); return true;
24650                         case 3: v(select_id_M5Configuration()); return true;
24651                         case 4: v(select_id_MDT_Location_Info()); return true;
24652                         case 5: v(select_id_SignallingBasedMDTPLMNList()); return true;
24653                         case 6: v(select_id_M6Configuration()); return true;
24654                         case 7: v(select_id_M7Configuration()); return true;
24655                         case 8: v(select_id_BluetoothMeasurementConfiguration()); return true;
24656                         case 9: v(select_id_WLANMeasurementConfiguration()); return true;
24657                         case 10: if(type != 10) {clear(); asn::base::set();} type = 10; return true;
24658                         }
24659                         return false;
24660
24661                 }
24662                 template<typename V> bool encode(size_t index, V& v) const
24663                 {
24664                         if(index != type) return false;
24665                         switch(type)
24666                         {
24667                         case 1: v(var.as<M3Configuration>()); return true;
24668                         case 2: v(var.as<M4Configuration>()); return true;
24669                         case 3: v(var.as<M5Configuration>()); return true;
24670                         case 4: v(var.as<MDT_Location_Info>()); return true;
24671                         case 5: v(var.as<MDTPLMNList>()); return true;
24672                         case 6: v(var.as<M6Configuration>()); return true;
24673                         case 7: v(var.as<M7Configuration>()); return true;
24674                         case 8: v(var.as<BluetoothMeasurementConfiguration>()); return true;
24675                         case 9: v(var.as<WLANMeasurementConfiguration>()); return true;
24676                         }
24677                         return false;
24678
24679                 }
24680                 private:
24681                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
24682                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
24683                 union union_type
24684                 {
24685                         char dummy1[sizeof(BluetoothMeasurementConfiguration)];
24686                         char dummy2[sizeof(M3Configuration)];
24687                         char dummy3[sizeof(M4Configuration)];
24688                         char dummy4[sizeof(M5Configuration)];
24689                         char dummy5[sizeof(M6Configuration)];
24690                         char dummy6[sizeof(M7Configuration)];
24691                         char dummy7[sizeof(MDTPLMNList)];
24692                         char dummy8[sizeof(MDT_Location_Info)];
24693                         char dummy9[sizeof(WLANMeasurementConfiguration)];
24694
24695                 };
24696                 asn::variant<sizeof(union_type)> var;
24697                 size_t type {0};
24698
24699         };
24700         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
24701         {
24702                 size_t get_index() const {return type;}
24703                 bool is_unknown() const { return type == 10; }
24704                 void clear() {type = 0;}
24705                 void select_id_M3Configuration() { set(conditional); type=1;}
24706                 void select_id_M4Configuration() { set(conditional); type=2;}
24707                 void select_id_M5Configuration() { set(conditional); type=3;}
24708                 void select_id_MDT_Location_Info() { set(optional); type=4;}
24709                 void select_id_SignallingBasedMDTPLMNList() { set(optional); type=5;}
24710                 void select_id_M6Configuration() { set(conditional); type=6;}
24711                 void select_id_M7Configuration() { set(conditional); type=7;}
24712                 void select_id_BluetoothMeasurementConfiguration() { set(optional); type=8;}
24713                 void select_id_WLANMeasurementConfiguration() { set(optional); type=9;}
24714                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
24715                 template<typename V>  bool decode(V& v)
24716                 {
24717                         clear();
24718                         if(!v(ref_nested())) return false;
24719                         if(equal(conditional)) { type = 1; return true; }
24720                         else if(equal(conditional)) { type = 2; return true; }
24721                         else if(equal(conditional)) { type = 3; return true; }
24722                         else if(equal(optional)) { type = 4; return true; }
24723                         else if(equal(optional)) { type = 5; return true; }
24724                         else if(equal(conditional)) { type = 6; return true; }
24725                         else if(equal(conditional)) { type = 7; return true; }
24726                         else if(equal(optional)) { type = 8; return true; }
24727                         else if(equal(optional)) { type = 9; return true; }
24728                         else { type = 10; return true;}
24729                         return false;
24730
24731                 }
24732                 template<typename V> bool encode(V& v) const
24733                 {
24734                         return v(ref_nested());
24735
24736                 }
24737                 protected:
24738                 template<typename V>  bool decode(size_t index, V& v)
24739                 {
24740                         clear();
24741                         switch(index)
24742                         {
24743                         case 1: type = 1; if(v(ref_nested())) { return equal(conditional);} return false;
24744                         case 2: type = 2; if(v(ref_nested())) { return equal(conditional);} return false;
24745                         case 3: type = 3; if(v(ref_nested())) { return equal(conditional);} return false;
24746                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
24747                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
24748                         case 6: type = 6; if(v(ref_nested())) { return equal(conditional);} return false;
24749                         case 7: type = 7; if(v(ref_nested())) { return equal(conditional);} return false;
24750                         case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
24751                         case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
24752                         case 10: type = 10; return v(ref_nested());
24753                         ref_nested().clear();
24754                         }
24755                         return false;
24756
24757                 }
24758                 template<typename V> bool encode(size_t index, V& v) const
24759                 {
24760                         if(index != type) {return false;} return v(ref_nested());
24761
24762                 }
24763                 private:
24764                 size_t type {0};
24765
24766         };
24767
24768 };
24769 /*
24770 MDT-Configuration ::= SEQUENCE {
24771         mdt-Activation                          MDT-Activation,
24772         areaScopeOfMDT                          AreaScopeOfMDT,
24773         measurementsToActivate          MeasurementsToActivate,
24774         m1reportingTrigger                      M1ReportingTrigger,
24775         m1thresholdeventA2                      M1ThresholdEventA2                      OPTIONAL,
24776 -- Included in case of event-triggered, or event-triggered periodic reporting for measurement M1
24777         m1periodicReporting                     M1PeriodicReporting                     OPTIONAL,
24778 -- Included in case of periodic, or event-triggered periodic reporting for measurement M1
24779         iE-Extensions                           ProtocolExtensionContainer { {MDT-Configuration-ExtIEs} } OPTIONAL,
24780         ...
24781 }
24782 */
24783
24784 struct MDT_Configuration : asn::sequence<7, 0, true, 3>
24785 {
24786         static constexpr const char* name() {return "MDT-Configuration";}
24787         using parent_t = asn::sequence<7, 0, true, 3>;
24788         struct mdt_Activation_t : MDT_Activation
24789         {
24790                 static constexpr const char* name() {return "mdt_Activation_t";}
24791                 using parent_t = MDT_Activation;
24792
24793         };
24794         mdt_Activation_t& ref_mdt_Activation() {return mdt_Activation;}
24795         mdt_Activation_t const& ref_mdt_Activation() const {return mdt_Activation;}
24796         struct areaScopeOfMDT_t : AreaScopeOfMDT
24797         {
24798                 static constexpr const char* name() {return "areaScopeOfMDT_t";}
24799                 using parent_t = AreaScopeOfMDT;
24800
24801         };
24802         areaScopeOfMDT_t& ref_areaScopeOfMDT() {return areaScopeOfMDT;}
24803         areaScopeOfMDT_t const& ref_areaScopeOfMDT() const {return areaScopeOfMDT;}
24804         struct measurementsToActivate_t : MeasurementsToActivate
24805         {
24806                 static constexpr const char* name() {return "measurementsToActivate_t";}
24807                 using parent_t = MeasurementsToActivate;
24808
24809         };
24810         measurementsToActivate_t& ref_measurementsToActivate() {return measurementsToActivate;}
24811         measurementsToActivate_t const& ref_measurementsToActivate() const {return measurementsToActivate;}
24812         struct m1reportingTrigger_t : M1ReportingTrigger
24813         {
24814                 static constexpr const char* name() {return "m1reportingTrigger_t";}
24815                 using parent_t = M1ReportingTrigger;
24816
24817         };
24818         m1reportingTrigger_t& ref_m1reportingTrigger() {return m1reportingTrigger;}
24819         m1reportingTrigger_t const& ref_m1reportingTrigger() const {return m1reportingTrigger;}
24820         struct m1thresholdeventA2_t : M1ThresholdEventA2
24821         {
24822                 static constexpr const char* name() {return "m1thresholdeventA2_t";}
24823                 using parent_t = M1ThresholdEventA2;
24824                 static constexpr bool optional = true;
24825
24826         };
24827         m1thresholdeventA2_t& set_m1thresholdeventA2() { m1thresholdeventA2.setpresent(true); return m1thresholdeventA2;}
24828         m1thresholdeventA2_t const* get_m1thresholdeventA2() const {return m1thresholdeventA2.is_valid() ? &m1thresholdeventA2 : nullptr;}
24829         struct m1periodicReporting_t : M1PeriodicReporting
24830         {
24831                 static constexpr const char* name() {return "m1periodicReporting_t";}
24832                 using parent_t = M1PeriodicReporting;
24833                 static constexpr bool optional = true;
24834
24835         };
24836         m1periodicReporting_t& set_m1periodicReporting() { m1periodicReporting.setpresent(true); return m1periodicReporting;}
24837         m1periodicReporting_t const* get_m1periodicReporting() const {return m1periodicReporting.is_valid() ? &m1periodicReporting : nullptr;}
24838         struct iE_Extensions_t : ProtocolExtensionContainer<MDT_Configuration_ExtIEs>
24839         {
24840                 static constexpr const char* name() {return "iE_Extensions_t";}
24841                 using parent_t = ProtocolExtensionContainer<MDT_Configuration_ExtIEs>;
24842                 static constexpr bool optional = true;
24843
24844         };
24845         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
24846         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
24847         template<typename V> void decode(V& v)
24848         {
24849                 v(mdt_Activation);
24850                 v(areaScopeOfMDT);
24851                 v(measurementsToActivate);
24852                 v(m1reportingTrigger);
24853                 v(m1thresholdeventA2);
24854                 v(m1periodicReporting);
24855                 v(iE_Extensions);
24856
24857         };
24858         template<typename V> void encode(V& v) const
24859         {
24860                 v(mdt_Activation);
24861                 v(areaScopeOfMDT);
24862                 v(measurementsToActivate);
24863                 v(m1reportingTrigger);
24864                 v(m1thresholdeventA2);
24865                 v(m1periodicReporting);
24866                 v(iE_Extensions);
24867
24868         };
24869         void clear()
24870         {
24871                 mdt_Activation.clear();
24872                 areaScopeOfMDT.clear();
24873                 measurementsToActivate.clear();
24874                 m1reportingTrigger.clear();
24875                 m1thresholdeventA2.clear();
24876                 m1periodicReporting.clear();
24877                 iE_Extensions.clear();
24878
24879         };
24880         private:
24881         mdt_Activation_t        mdt_Activation;
24882         areaScopeOfMDT_t        areaScopeOfMDT;
24883         measurementsToActivate_t        measurementsToActivate;
24884         m1reportingTrigger_t    m1reportingTrigger;
24885         m1thresholdeventA2_t    m1thresholdeventA2;
24886         m1periodicReporting_t   m1periodicReporting;
24887         iE_Extensions_t iE_Extensions;
24888
24889 };
24890 /*
24891 MakeBeforeBreakIndicator::= ENUMERATED {true, ...}
24892 */
24893
24894 struct MakeBeforeBreakIndicator : asn::enumerated<1, 0, true>
24895 {
24896         static constexpr const char* name() {return "MakeBeforeBreakIndicator";}
24897         using parent_t = asn::enumerated<1, 0, true>;
24898         typedef enum {
24899                 True
24900         } index_t;
24901
24902 };
24903
24904 /*
24905 ManagementBasedMDTallowed ::= ENUMERATED {allowed, ...}
24906 */
24907
24908 struct ManagementBasedMDTallowed : asn::enumerated<1, 0, true>
24909 {
24910         static constexpr const char* name() {return "ManagementBasedMDTallowed";}
24911         using parent_t = asn::enumerated<1, 0, true>;
24912         typedef enum {
24913                 allowed
24914         } index_t;
24915
24916 };
24917
24918 /*
24919 Masked-IMEISV ::= BIT STRING (SIZE (64))
24920 */
24921
24922 struct Masked_IMEISV : asn::bstring<>
24923 {
24924         using constraint_t = asn::constraints<false,asn::one<64>>;
24925         static constexpr const char* name() {return "Masked-IMEISV";}
24926         using parent_t = asn::bstring<>;
24927
24928 };
24929
24930 /*
24931 MeNBCoordinationAssistanceInformation ::= ENUMERATED{
24932         coordination-not-required,
24933         ...
24934 }
24935 */
24936
24937 struct MeNBCoordinationAssistanceInformation : asn::enumerated<1, 0, true>
24938 {
24939         static constexpr const char* name() {return "MeNBCoordinationAssistanceInformation";}
24940         using parent_t = asn::enumerated<1, 0, true>;
24941         typedef enum {
24942                 coordination_not_required
24943         } index_t;
24944
24945 };
24946
24947 /*
24948 NRCellIdentifier ::= BIT STRING (SIZE (36))
24949 */
24950
24951 struct NRCellIdentifier : asn::bstring<>
24952 {
24953         using constraint_t = asn::constraints<false,asn::one<36>>;
24954         static constexpr const char* name() {return "NRCellIdentifier";}
24955         using parent_t = asn::bstring<>;
24956
24957 };
24958
24959 /*
24960 NRCGI-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
24961         ...
24962 }
24963 */
24964
24965 struct NRCGI_ExtIEs
24966 {
24967         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
24968         {
24969                 size_t get_index() const {return type;}
24970                 bool is_unknown() const { return type == 1; }
24971                 void clear() {type = 0;}
24972                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
24973                 template<typename V>  bool decode(V& v)
24974                 {
24975                         clear();
24976                         if(!v(ref_nested())) return false;
24977                         { type = 1; return true;}
24978                         return false;
24979
24980                 }
24981                 template<typename V> bool encode(V& v) const
24982                 {
24983                         return v(ref_nested());
24984
24985                 }
24986                 protected:
24987                 template<typename V>  bool decode(size_t index, V& v)
24988                 {
24989                         clear();
24990                         switch(index)
24991                         {
24992                         case 1: type = 1; return v(ref_nested());
24993                         ref_nested().clear();
24994                         }
24995                         return false;
24996
24997                 }
24998                 template<typename V> bool encode(size_t index, V& v) const
24999                 {
25000                         if(index != type) {return false;} return v(ref_nested());
25001
25002                 }
25003                 private:
25004                 size_t type {0};
25005
25006         };
25007         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
25008         {
25009                 size_t get_index() const {return type;}
25010                 bool is_unknown() const { return type == 1; }
25011                 void clear() {type = 0;}
25012                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
25013                 template<typename V>  bool decode(V& v)
25014                 {
25015                         clear();
25016                         if(!v(ref_nested())) return false;
25017                         { type = 1; return true;}
25018                         return false;
25019
25020                 }
25021                 template<typename V> bool encode(V& v) const
25022                 {
25023                         return v(ref_nested());
25024
25025                 }
25026                 protected:
25027                 template<typename V>  bool decode(size_t index, V& v)
25028                 {
25029                         clear();
25030                         switch(index)
25031                         {
25032                         case 1: type = 1; return v(ref_nested());
25033                         ref_nested().clear();
25034                         }
25035                         return false;
25036
25037                 }
25038                 template<typename V> bool encode(size_t index, V& v) const
25039                 {
25040                         if(index != type) {return false;} return v(ref_nested());
25041
25042                 }
25043                 private:
25044                 size_t type {0};
25045
25046         };
25047         struct Extension_t : asn::typefield<true>
25048         {
25049                 ~Extension_t()  {clear();}
25050                 size_t get_index() const {return type;}
25051                 bool is_unknown() const { return type == 1; }
25052                 void clear()
25053                 {
25054                         type = 0; ref_nested().clear();
25055                 }
25056                 template<typename V> static inline void enumerate(V& v)
25057                 {
25058
25059                 }
25060                 protected:
25061                 template<typename V> bool decode(size_t index, V& v)
25062                 {
25063                         clear();
25064                         switch(index)
25065                         {
25066                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
25067                         }
25068                         return false;
25069
25070                 }
25071                 template<typename V> bool encode(size_t index, V& v) const
25072                 {
25073                         if(index != type) return false;
25074                         return false;
25075
25076                 }
25077                 private:
25078                 size_t type {0};
25079
25080         };
25081         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
25082         {
25083                 size_t get_index() const {return type;}
25084                 bool is_unknown() const { return type == 1; }
25085                 void clear() {type = 0;}
25086                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
25087                 template<typename V>  bool decode(V& v)
25088                 {
25089                         clear();
25090                         if(!v(ref_nested())) return false;
25091                         { type = 1; return true;}
25092                         return false;
25093
25094                 }
25095                 template<typename V> bool encode(V& v) const
25096                 {
25097                         return v(ref_nested());
25098
25099                 }
25100                 protected:
25101                 template<typename V>  bool decode(size_t index, V& v)
25102                 {
25103                         clear();
25104                         switch(index)
25105                         {
25106                         case 1: type = 1; return v(ref_nested());
25107                         ref_nested().clear();
25108                         }
25109                         return false;
25110
25111                 }
25112                 template<typename V> bool encode(size_t index, V& v) const
25113                 {
25114                         if(index != type) {return false;} return v(ref_nested());
25115
25116                 }
25117                 private:
25118                 size_t type {0};
25119
25120         };
25121
25122 };
25123 /*
25124 NRCGI ::= SEQUENCE {
25125         pLMN-Identity                           PLMN-Identity,
25126         nRcellIdentifier                                NRCellIdentifier,
25127         iE-Extensions                           ProtocolExtensionContainer { {NRCGI-ExtIEs} } OPTIONAL,
25128         ...
25129 }
25130 */
25131
25132 struct NRCGI : asn::sequence<3, 0, true, 1>
25133 {
25134         static constexpr const char* name() {return "NRCGI";}
25135         using parent_t = asn::sequence<3, 0, true, 1>;
25136         struct pLMN_Identity_t : PLMN_Identity
25137         {
25138                 static constexpr const char* name() {return "pLMN_Identity_t";}
25139                 using parent_t = PLMN_Identity;
25140
25141         };
25142         pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
25143         pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
25144         struct nRcellIdentifier_t : NRCellIdentifier
25145         {
25146                 static constexpr const char* name() {return "nRcellIdentifier_t";}
25147                 using parent_t = NRCellIdentifier;
25148
25149         };
25150         nRcellIdentifier_t& ref_nRcellIdentifier() {return nRcellIdentifier;}
25151         nRcellIdentifier_t const& ref_nRcellIdentifier() const {return nRcellIdentifier;}
25152         struct iE_Extensions_t : ProtocolExtensionContainer<NRCGI_ExtIEs>
25153         {
25154                 static constexpr const char* name() {return "iE_Extensions_t";}
25155                 using parent_t = ProtocolExtensionContainer<NRCGI_ExtIEs>;
25156                 static constexpr bool optional = true;
25157
25158         };
25159         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
25160         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
25161         template<typename V> void decode(V& v)
25162         {
25163                 v(pLMN_Identity);
25164                 v(nRcellIdentifier);
25165                 v(iE_Extensions);
25166
25167         };
25168         template<typename V> void encode(V& v) const
25169         {
25170                 v(pLMN_Identity);
25171                 v(nRcellIdentifier);
25172                 v(iE_Extensions);
25173
25174         };
25175         void clear()
25176         {
25177                 pLMN_Identity.clear();
25178                 nRcellIdentifier.clear();
25179                 iE_Extensions.clear();
25180
25181         };
25182         private:
25183         pLMN_Identity_t pLMN_Identity;
25184         nRcellIdentifier_t      nRcellIdentifier;
25185         iE_Extensions_t iE_Extensions;
25186
25187 };
25188 /*
25189 MeNBResourceCoordinationInformationExtIEs X2AP-PROTOCOL-EXTENSION ::= {
25190         { ID id-NRCGI                                                                   CRITICALITY ignore      EXTENSION NRCGI                                                                                         PRESENCE optional}|
25191         { ID id-MeNBCoordinationAssistanceInformation           CRITICALITY reject      EXTENSION MeNBCoordinationAssistanceInformation PRESENCE optional},
25192         ...
25193 }
25194 */
25195
25196 struct MeNBResourceCoordinationInformationExtIEs
25197 {
25198         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
25199         {
25200                 size_t get_index() const {return type;}
25201                 bool is_unknown() const { return type == 3; }
25202                 void clear() {type = 0;}
25203                 void select_id_NRCGI() { set(id_NRCGI); type=1;}
25204                 void select_id_MeNBCoordinationAssistanceInformation() { set(id_MeNBCoordinationAssistanceInformation); type=2;}
25205                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
25206                 template<typename V>  bool decode(V& v)
25207                 {
25208                         clear();
25209                         if(!v(ref_nested())) return false;
25210                         if(equal(id_NRCGI)) { type = 1; return true; }
25211                         else if(equal(id_MeNBCoordinationAssistanceInformation)) { type = 2; return true; }
25212                         else { type = 3; return true;}
25213                         return false;
25214
25215                 }
25216                 template<typename V> bool encode(V& v) const
25217                 {
25218                         return v(ref_nested());
25219
25220                 }
25221                 protected:
25222                 template<typename V>  bool decode(size_t index, V& v)
25223                 {
25224                         clear();
25225                         switch(index)
25226                         {
25227                         case 1: type = 1; if(v(ref_nested())) { return equal(id_NRCGI);} return false;
25228                         case 2: type = 2; if(v(ref_nested())) { return equal(id_MeNBCoordinationAssistanceInformation);} return false;
25229                         case 3: type = 3; return v(ref_nested());
25230                         ref_nested().clear();
25231                         }
25232                         return false;
25233
25234                 }
25235                 template<typename V> bool encode(size_t index, V& v) const
25236                 {
25237                         if(index != type) {return false;} return v(ref_nested());
25238
25239                 }
25240                 private:
25241                 size_t type {0};
25242
25243         };
25244         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
25245         {
25246                 size_t get_index() const {return type;}
25247                 bool is_unknown() const { return type == 3; }
25248                 void clear() {type = 0;}
25249                 void select_id_NRCGI() { set(ignore); type=1;}
25250                 void select_id_MeNBCoordinationAssistanceInformation() { set(reject); type=2;}
25251                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
25252                 template<typename V>  bool decode(V& v)
25253                 {
25254                         clear();
25255                         if(!v(ref_nested())) return false;
25256                         if(equal(ignore)) { type = 1; return true; }
25257                         else if(equal(reject)) { type = 2; return true; }
25258                         else { type = 3; return true;}
25259                         return false;
25260
25261                 }
25262                 template<typename V> bool encode(V& v) const
25263                 {
25264                         return v(ref_nested());
25265
25266                 }
25267                 protected:
25268                 template<typename V>  bool decode(size_t index, V& v)
25269                 {
25270                         clear();
25271                         switch(index)
25272                         {
25273                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
25274                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
25275                         case 3: type = 3; return v(ref_nested());
25276                         ref_nested().clear();
25277                         }
25278                         return false;
25279
25280                 }
25281                 template<typename V> bool encode(size_t index, V& v) const
25282                 {
25283                         if(index != type) {return false;} return v(ref_nested());
25284
25285                 }
25286                 private:
25287                 size_t type {0};
25288
25289         };
25290         struct Extension_t : asn::typefield<true>
25291         {
25292                 ~Extension_t()  {clear();}
25293                 size_t get_index() const {return type;}
25294                 NRCGI& select_id_NRCGI() { return set<NRCGI>(1); }
25295                 NRCGI const* get_id_NRCGI() const { return get<NRCGI>(1); }
25296                 MeNBCoordinationAssistanceInformation& select_id_MeNBCoordinationAssistanceInformation() { return set<MeNBCoordinationAssistanceInformation>(2); }
25297                 MeNBCoordinationAssistanceInformation const* get_id_MeNBCoordinationAssistanceInformation() const { return get<MeNBCoordinationAssistanceInformation>(2); }
25298                 bool is_unknown() const { return type == 3; }
25299                 void clear()
25300                 {
25301                         switch(type)
25302                         {
25303                         case 1: var.destroy<NRCGI>(); break;
25304                         case 2: var.destroy<MeNBCoordinationAssistanceInformation>(); break;
25305                         }
25306                         type = 0; ref_nested().clear();
25307                 }
25308                 template<typename V> static inline void enumerate(V& v)
25309                 {
25310                         v.template operator()<NRCGI>(1);
25311                         v.template operator()<MeNBCoordinationAssistanceInformation>(2);
25312
25313                 }
25314                 protected:
25315                 template<typename V> bool decode(size_t index, V& v)
25316                 {
25317                         clear();
25318                         switch(index)
25319                         {
25320                         case 1: v(select_id_NRCGI()); return true;
25321                         case 2: v(select_id_MeNBCoordinationAssistanceInformation()); return true;
25322                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
25323                         }
25324                         return false;
25325
25326                 }
25327                 template<typename V> bool encode(size_t index, V& v) const
25328                 {
25329                         if(index != type) return false;
25330                         switch(type)
25331                         {
25332                         case 1: v(var.as<NRCGI>()); return true;
25333                         case 2: v(var.as<MeNBCoordinationAssistanceInformation>()); return true;
25334                         }
25335                         return false;
25336
25337                 }
25338                 private:
25339                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
25340                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
25341                 union union_type
25342                 {
25343                         char dummy1[sizeof(MeNBCoordinationAssistanceInformation)];
25344                         char dummy2[sizeof(NRCGI)];
25345
25346                 };
25347                 asn::variant<sizeof(union_type)> var;
25348                 size_t type {0};
25349
25350         };
25351         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
25352         {
25353                 size_t get_index() const {return type;}
25354                 bool is_unknown() const { return type == 3; }
25355                 void clear() {type = 0;}
25356                 void select_id_NRCGI() { set(optional); type=1;}
25357                 void select_id_MeNBCoordinationAssistanceInformation() { set(optional); type=2;}
25358                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
25359                 template<typename V>  bool decode(V& v)
25360                 {
25361                         clear();
25362                         if(!v(ref_nested())) return false;
25363                         if(equal(optional)) { type = 1; return true; }
25364                         else if(equal(optional)) { type = 2; return true; }
25365                         else { type = 3; return true;}
25366                         return false;
25367
25368                 }
25369                 template<typename V> bool encode(V& v) const
25370                 {
25371                         return v(ref_nested());
25372
25373                 }
25374                 protected:
25375                 template<typename V>  bool decode(size_t index, V& v)
25376                 {
25377                         clear();
25378                         switch(index)
25379                         {
25380                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
25381                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
25382                         case 3: type = 3; return v(ref_nested());
25383                         ref_nested().clear();
25384                         }
25385                         return false;
25386
25387                 }
25388                 template<typename V> bool encode(size_t index, V& v) const
25389                 {
25390                         if(index != type) {return false;} return v(ref_nested());
25391
25392                 }
25393                 private:
25394                 size_t type {0};
25395
25396         };
25397
25398 };
25399 /*
25400 MeNBResourceCoordinationInformation ::= SEQUENCE {
25401         eUTRA-Cell-ID                                   ECGI,
25402         uLCoordinationInformation               BIT STRING (SIZE(6..4400, ...)),
25403         dLCoordinationInformation               BIT STRING (SIZE(6..4400, ...))         OPTIONAL,
25404         iE-Extensions                                   ProtocolExtensionContainer { {MeNBResourceCoordinationInformationExtIEs} }               OPTIONAL,
25405         ...
25406 }
25407 */
25408
25409 struct MeNBResourceCoordinationInformation : asn::sequence<4, 0, true, 2>
25410 {
25411         static constexpr const char* name() {return "MeNBResourceCoordinationInformation";}
25412         using parent_t = asn::sequence<4, 0, true, 2>;
25413         struct eUTRA_Cell_ID_t : ECGI
25414         {
25415                 static constexpr const char* name() {return "eUTRA_Cell_ID_t";}
25416                 using parent_t = ECGI;
25417
25418         };
25419         eUTRA_Cell_ID_t& ref_eUTRA_Cell_ID() {return eUTRA_Cell_ID;}
25420         eUTRA_Cell_ID_t const& ref_eUTRA_Cell_ID() const {return eUTRA_Cell_ID;}
25421         struct uLCoordinationInformation_t : asn::bstring<>
25422         {
25423                 using constraint_t = asn::constraints<true,asn::span<6, 4400>>;
25424                 static constexpr const char* name() {return "uLCoordinationInformation_t";}
25425                 using parent_t = asn::bstring<>;
25426
25427         };
25428
25429         uLCoordinationInformation_t& ref_uLCoordinationInformation() {return uLCoordinationInformation;}
25430         uLCoordinationInformation_t const& ref_uLCoordinationInformation() const {return uLCoordinationInformation;}
25431         struct dLCoordinationInformation_t : asn::bstring<>
25432         {
25433                 using constraint_t = asn::constraints<true,asn::span<6, 4400>>;
25434                 static constexpr const char* name() {return "dLCoordinationInformation_t";}
25435                 using parent_t = asn::bstring<>;
25436                 static constexpr bool optional = true;
25437
25438         };
25439
25440         dLCoordinationInformation_t& set_dLCoordinationInformation() { dLCoordinationInformation.setpresent(true); return dLCoordinationInformation;}
25441         dLCoordinationInformation_t const* get_dLCoordinationInformation() const {return dLCoordinationInformation.is_valid() ? &dLCoordinationInformation : nullptr;}
25442         struct iE_Extensions_t : ProtocolExtensionContainer<MeNBResourceCoordinationInformationExtIEs>
25443         {
25444                 static constexpr const char* name() {return "iE_Extensions_t";}
25445                 using parent_t = ProtocolExtensionContainer<MeNBResourceCoordinationInformationExtIEs>;
25446                 static constexpr bool optional = true;
25447
25448         };
25449         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
25450         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
25451         template<typename V> void decode(V& v)
25452         {
25453                 v(eUTRA_Cell_ID);
25454                 v(uLCoordinationInformation);
25455                 v(dLCoordinationInformation);
25456                 v(iE_Extensions);
25457
25458         };
25459         template<typename V> void encode(V& v) const
25460         {
25461                 v(eUTRA_Cell_ID);
25462                 v(uLCoordinationInformation);
25463                 v(dLCoordinationInformation);
25464                 v(iE_Extensions);
25465
25466         };
25467         void clear()
25468         {
25469                 eUTRA_Cell_ID.clear();
25470                 uLCoordinationInformation.clear();
25471                 dLCoordinationInformation.clear();
25472                 iE_Extensions.clear();
25473
25474         };
25475         private:
25476         eUTRA_Cell_ID_t eUTRA_Cell_ID;
25477         uLCoordinationInformation_t     uLCoordinationInformation;
25478         dLCoordinationInformation_t     dLCoordinationInformation;
25479         iE_Extensions_t iE_Extensions;
25480
25481 };
25482 /*
25483 MeNBtoSeNBContainer ::= OCTET STRING
25484 */
25485
25486 struct MeNBtoSeNBContainer : asn::ostring<>
25487 {
25488         static constexpr const char* name() {return "MeNBtoSeNBContainer";}
25489         using parent_t = asn::ostring<>;
25490
25491 };
25492
25493 /*
25494 MeNBtoSgNBContainer ::= OCTET STRING
25495 */
25496
25497 struct MeNBtoSgNBContainer : asn::ostring<>
25498 {
25499         static constexpr const char* name() {return "MeNBtoSgNBContainer";}
25500         using parent_t = asn::ostring<>;
25501
25502 };
25503
25504 /*
25505 Measurement-ID  ::= INTEGER (1..4095, ...)
25506 */
25507
25508 struct Measurement_ID : asn::integer<>
25509 {
25510         using constraint_t = asn::constraints<true,asn::span<1, 4095>>;
25511         static constexpr const char* name() {return "Measurement-ID";}
25512         using parent_t = asn::integer<>;
25513
25514 };
25515
25516 /*
25517 MobilityParametersInformation ::= SEQUENCE {
25518         handoverTriggerChange                   INTEGER (-20..20),
25519         ...
25520 }
25521 */
25522
25523 struct MobilityParametersInformation : asn::sequence<1, 0, true, 0>
25524 {
25525         static constexpr const char* name() {return "MobilityParametersInformation";}
25526         using parent_t = asn::sequence<1, 0, true, 0>;
25527         struct handoverTriggerChange_t : asn::integer<>
25528         {
25529                 using constraint_t = asn::constraints<false,asn::span<-20, 20>>;
25530                 static constexpr const char* name() {return "handoverTriggerChange_t";}
25531                 using parent_t = asn::integer<>;
25532
25533         };
25534
25535         handoverTriggerChange_t& ref_handoverTriggerChange() {return handoverTriggerChange;}
25536         handoverTriggerChange_t const& ref_handoverTriggerChange() const {return handoverTriggerChange;}
25537         template<typename V> void decode(V& v)
25538         {
25539                 v(handoverTriggerChange);
25540
25541         };
25542         template<typename V> void encode(V& v) const
25543         {
25544                 v(handoverTriggerChange);
25545
25546         };
25547         void clear()
25548         {
25549                 handoverTriggerChange.clear();
25550
25551         };
25552         private:
25553         handoverTriggerChange_t handoverTriggerChange;
25554
25555 };
25556 /*
25557 MobilityParametersModificationRange ::= SEQUENCE {
25558         handoverTriggerChangeLowerLimit         INTEGER (-20..20),
25559         handoverTriggerChangeUpperLimit         INTEGER (-20..20),
25560         ...
25561 }
25562 */
25563
25564 struct MobilityParametersModificationRange : asn::sequence<2, 0, true, 0>
25565 {
25566         static constexpr const char* name() {return "MobilityParametersModificationRange";}
25567         using parent_t = asn::sequence<2, 0, true, 0>;
25568         struct handoverTriggerChangeLowerLimit_t : asn::integer<>
25569         {
25570                 using constraint_t = asn::constraints<false,asn::span<-20, 20>>;
25571                 static constexpr const char* name() {return "handoverTriggerChangeLowerLimit_t";}
25572                 using parent_t = asn::integer<>;
25573
25574         };
25575
25576         handoverTriggerChangeLowerLimit_t& ref_handoverTriggerChangeLowerLimit() {return handoverTriggerChangeLowerLimit;}
25577         handoverTriggerChangeLowerLimit_t const& ref_handoverTriggerChangeLowerLimit() const {return handoverTriggerChangeLowerLimit;}
25578         struct handoverTriggerChangeUpperLimit_t : asn::integer<>
25579         {
25580                 using constraint_t = asn::constraints<false,asn::span<-20, 20>>;
25581                 static constexpr const char* name() {return "handoverTriggerChangeUpperLimit_t";}
25582                 using parent_t = asn::integer<>;
25583
25584         };
25585
25586         handoverTriggerChangeUpperLimit_t& ref_handoverTriggerChangeUpperLimit() {return handoverTriggerChangeUpperLimit;}
25587         handoverTriggerChangeUpperLimit_t const& ref_handoverTriggerChangeUpperLimit() const {return handoverTriggerChangeUpperLimit;}
25588         template<typename V> void decode(V& v)
25589         {
25590                 v(handoverTriggerChangeLowerLimit);
25591                 v(handoverTriggerChangeUpperLimit);
25592
25593         };
25594         template<typename V> void encode(V& v) const
25595         {
25596                 v(handoverTriggerChangeLowerLimit);
25597                 v(handoverTriggerChangeUpperLimit);
25598
25599         };
25600         void clear()
25601         {
25602                 handoverTriggerChangeLowerLimit.clear();
25603                 handoverTriggerChangeUpperLimit.clear();
25604
25605         };
25606         private:
25607         handoverTriggerChangeLowerLimit_t       handoverTriggerChangeLowerLimit;
25608         handoverTriggerChangeUpperLimit_t       handoverTriggerChangeUpperLimit;
25609
25610 };
25611 /*
25612 MultibandInfoList ::= SEQUENCE (SIZE(1..maxnoofBands)) OF BandInfo
25613 */
25614
25615 struct MultibandInfoList_elm : BandInfo
25616 {
25617         static constexpr const char* name() {return "MultibandInfoList_elm";}
25618         using parent_t = BandInfo;
25619
25620 };
25621 struct MultibandInfoList : asn::sequenceof<MultibandInfoList_elm>
25622 {
25623         static constexpr const char* name() {return "MultibandInfoList";}
25624         using parent_t = asn::sequenceof<MultibandInfoList_elm>;
25625         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBands >>;
25626
25627 };
25628 /*
25629 NRSCS ::= ENUMERATED { scs15, scs30, scs60, scs120, ...}
25630 */
25631
25632 struct NRSCS : asn::enumerated<4, 0, true>
25633 {
25634         static constexpr const char* name() {return "NRSCS";}
25635         using parent_t = asn::enumerated<4, 0, true>;
25636         typedef enum {
25637                 scs15
25638                 ,scs30
25639                 ,scs60
25640                 ,scs120
25641         } index_t;
25642
25643 };
25644
25645 /*
25646 NRNRB ::= ENUMERATED { nrb11, nrb18, nrb24, nrb25, nrb31, nrb32, nrb38, nrb51, nrb52, nrb65, nrb66, nrb78, nrb79, nrb93, nrb106, nrb107, nrb121, nrb132, nrb133, nrb135, nrb160, nrb162, nrb189, nrb216, nrb217, nrb245, nrb264, nrb270, nrb273, ...}
25647 */
25648
25649 struct NRNRB : asn::enumerated<29, 0, true>
25650 {
25651         static constexpr const char* name() {return "NRNRB";}
25652         using parent_t = asn::enumerated<29, 0, true>;
25653         typedef enum {
25654                 nrb11
25655                 ,nrb18
25656                 ,nrb24
25657                 ,nrb25
25658                 ,nrb31
25659                 ,nrb32
25660                 ,nrb38
25661                 ,nrb51
25662                 ,nrb52
25663                 ,nrb65
25664                 ,nrb66
25665                 ,nrb78
25666                 ,nrb79
25667                 ,nrb93
25668                 ,nrb106
25669                 ,nrb107
25670                 ,nrb121
25671                 ,nrb132
25672                 ,nrb133
25673                 ,nrb135
25674                 ,nrb160
25675                 ,nrb162
25676                 ,nrb189
25677                 ,nrb216
25678                 ,nrb217
25679                 ,nrb245
25680                 ,nrb264
25681                 ,nrb270
25682                 ,nrb273
25683         } index_t;
25684
25685 };
25686
25687 /*
25688 NR-TxBW-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
25689         ...
25690 }
25691 */
25692
25693 struct NR_TxBW_ExtIEs
25694 {
25695         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
25696         {
25697                 size_t get_index() const {return type;}
25698                 bool is_unknown() const { return type == 1; }
25699                 void clear() {type = 0;}
25700                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
25701                 template<typename V>  bool decode(V& v)
25702                 {
25703                         clear();
25704                         if(!v(ref_nested())) return false;
25705                         { type = 1; return true;}
25706                         return false;
25707
25708                 }
25709                 template<typename V> bool encode(V& v) const
25710                 {
25711                         return v(ref_nested());
25712
25713                 }
25714                 protected:
25715                 template<typename V>  bool decode(size_t index, V& v)
25716                 {
25717                         clear();
25718                         switch(index)
25719                         {
25720                         case 1: type = 1; return v(ref_nested());
25721                         ref_nested().clear();
25722                         }
25723                         return false;
25724
25725                 }
25726                 template<typename V> bool encode(size_t index, V& v) const
25727                 {
25728                         if(index != type) {return false;} return v(ref_nested());
25729
25730                 }
25731                 private:
25732                 size_t type {0};
25733
25734         };
25735         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
25736         {
25737                 size_t get_index() const {return type;}
25738                 bool is_unknown() const { return type == 1; }
25739                 void clear() {type = 0;}
25740                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
25741                 template<typename V>  bool decode(V& v)
25742                 {
25743                         clear();
25744                         if(!v(ref_nested())) return false;
25745                         { type = 1; return true;}
25746                         return false;
25747
25748                 }
25749                 template<typename V> bool encode(V& v) const
25750                 {
25751                         return v(ref_nested());
25752
25753                 }
25754                 protected:
25755                 template<typename V>  bool decode(size_t index, V& v)
25756                 {
25757                         clear();
25758                         switch(index)
25759                         {
25760                         case 1: type = 1; return v(ref_nested());
25761                         ref_nested().clear();
25762                         }
25763                         return false;
25764
25765                 }
25766                 template<typename V> bool encode(size_t index, V& v) const
25767                 {
25768                         if(index != type) {return false;} return v(ref_nested());
25769
25770                 }
25771                 private:
25772                 size_t type {0};
25773
25774         };
25775         struct Extension_t : asn::typefield<true>
25776         {
25777                 ~Extension_t()  {clear();}
25778                 size_t get_index() const {return type;}
25779                 bool is_unknown() const { return type == 1; }
25780                 void clear()
25781                 {
25782                         type = 0; ref_nested().clear();
25783                 }
25784                 template<typename V> static inline void enumerate(V& v)
25785                 {
25786
25787                 }
25788                 protected:
25789                 template<typename V> bool decode(size_t index, V& v)
25790                 {
25791                         clear();
25792                         switch(index)
25793                         {
25794                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
25795                         }
25796                         return false;
25797
25798                 }
25799                 template<typename V> bool encode(size_t index, V& v) const
25800                 {
25801                         if(index != type) return false;
25802                         return false;
25803
25804                 }
25805                 private:
25806                 size_t type {0};
25807
25808         };
25809         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
25810         {
25811                 size_t get_index() const {return type;}
25812                 bool is_unknown() const { return type == 1; }
25813                 void clear() {type = 0;}
25814                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
25815                 template<typename V>  bool decode(V& v)
25816                 {
25817                         clear();
25818                         if(!v(ref_nested())) return false;
25819                         { type = 1; return true;}
25820                         return false;
25821
25822                 }
25823                 template<typename V> bool encode(V& v) const
25824                 {
25825                         return v(ref_nested());
25826
25827                 }
25828                 protected:
25829                 template<typename V>  bool decode(size_t index, V& v)
25830                 {
25831                         clear();
25832                         switch(index)
25833                         {
25834                         case 1: type = 1; return v(ref_nested());
25835                         ref_nested().clear();
25836                         }
25837                         return false;
25838
25839                 }
25840                 template<typename V> bool encode(size_t index, V& v) const
25841                 {
25842                         if(index != type) {return false;} return v(ref_nested());
25843
25844                 }
25845                 private:
25846                 size_t type {0};
25847
25848         };
25849
25850 };
25851 /*
25852 NR-TxBW ::= SEQUENCE {
25853         nRSCS   NRSCS,
25854         nRNRB   NRNRB,
25855         iE-Extensions                           ProtocolExtensionContainer { {NR-TxBW-ExtIEs} } OPTIONAL,
25856         ...
25857 }
25858 */
25859
25860 struct NR_TxBW : asn::sequence<3, 0, true, 1>
25861 {
25862         static constexpr const char* name() {return "NR-TxBW";}
25863         using parent_t = asn::sequence<3, 0, true, 1>;
25864         struct nRSCS_t : NRSCS
25865         {
25866                 static constexpr const char* name() {return "nRSCS_t";}
25867                 using parent_t = NRSCS;
25868
25869         };
25870         nRSCS_t& ref_nRSCS() {return nRSCS;}
25871         nRSCS_t const& ref_nRSCS() const {return nRSCS;}
25872         struct nRNRB_t : NRNRB
25873         {
25874                 static constexpr const char* name() {return "nRNRB_t";}
25875                 using parent_t = NRNRB;
25876
25877         };
25878         nRNRB_t& ref_nRNRB() {return nRNRB;}
25879         nRNRB_t const& ref_nRNRB() const {return nRNRB;}
25880         struct iE_Extensions_t : ProtocolExtensionContainer<NR_TxBW_ExtIEs>
25881         {
25882                 static constexpr const char* name() {return "iE_Extensions_t";}
25883                 using parent_t = ProtocolExtensionContainer<NR_TxBW_ExtIEs>;
25884                 static constexpr bool optional = true;
25885
25886         };
25887         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
25888         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
25889         template<typename V> void decode(V& v)
25890         {
25891                 v(nRSCS);
25892                 v(nRNRB);
25893                 v(iE_Extensions);
25894
25895         };
25896         template<typename V> void encode(V& v) const
25897         {
25898                 v(nRSCS);
25899                 v(nRNRB);
25900                 v(iE_Extensions);
25901
25902         };
25903         void clear()
25904         {
25905                 nRSCS.clear();
25906                 nRNRB.clear();
25907                 iE_Extensions.clear();
25908
25909         };
25910         private:
25911         nRSCS_t nRSCS;
25912         nRNRB_t nRNRB;
25913         iE_Extensions_t iE_Extensions;
25914
25915 };
25916 /*
25917 SULInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
25918         ...
25919 }
25920 */
25921
25922 struct SULInformation_ExtIEs
25923 {
25924         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
25925         {
25926                 size_t get_index() const {return type;}
25927                 bool is_unknown() const { return type == 1; }
25928                 void clear() {type = 0;}
25929                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
25930                 template<typename V>  bool decode(V& v)
25931                 {
25932                         clear();
25933                         if(!v(ref_nested())) return false;
25934                         { type = 1; return true;}
25935                         return false;
25936
25937                 }
25938                 template<typename V> bool encode(V& v) const
25939                 {
25940                         return v(ref_nested());
25941
25942                 }
25943                 protected:
25944                 template<typename V>  bool decode(size_t index, V& v)
25945                 {
25946                         clear();
25947                         switch(index)
25948                         {
25949                         case 1: type = 1; return v(ref_nested());
25950                         ref_nested().clear();
25951                         }
25952                         return false;
25953
25954                 }
25955                 template<typename V> bool encode(size_t index, V& v) const
25956                 {
25957                         if(index != type) {return false;} return v(ref_nested());
25958
25959                 }
25960                 private:
25961                 size_t type {0};
25962
25963         };
25964         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
25965         {
25966                 size_t get_index() const {return type;}
25967                 bool is_unknown() const { return type == 1; }
25968                 void clear() {type = 0;}
25969                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
25970                 template<typename V>  bool decode(V& v)
25971                 {
25972                         clear();
25973                         if(!v(ref_nested())) return false;
25974                         { type = 1; return true;}
25975                         return false;
25976
25977                 }
25978                 template<typename V> bool encode(V& v) const
25979                 {
25980                         return v(ref_nested());
25981
25982                 }
25983                 protected:
25984                 template<typename V>  bool decode(size_t index, V& v)
25985                 {
25986                         clear();
25987                         switch(index)
25988                         {
25989                         case 1: type = 1; return v(ref_nested());
25990                         ref_nested().clear();
25991                         }
25992                         return false;
25993
25994                 }
25995                 template<typename V> bool encode(size_t index, V& v) const
25996                 {
25997                         if(index != type) {return false;} return v(ref_nested());
25998
25999                 }
26000                 private:
26001                 size_t type {0};
26002
26003         };
26004         struct Extension_t : asn::typefield<true>
26005         {
26006                 ~Extension_t()  {clear();}
26007                 size_t get_index() const {return type;}
26008                 bool is_unknown() const { return type == 1; }
26009                 void clear()
26010                 {
26011                         type = 0; ref_nested().clear();
26012                 }
26013                 template<typename V> static inline void enumerate(V& v)
26014                 {
26015
26016                 }
26017                 protected:
26018                 template<typename V> bool decode(size_t index, V& v)
26019                 {
26020                         clear();
26021                         switch(index)
26022                         {
26023                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
26024                         }
26025                         return false;
26026
26027                 }
26028                 template<typename V> bool encode(size_t index, V& v) const
26029                 {
26030                         if(index != type) return false;
26031                         return false;
26032
26033                 }
26034                 private:
26035                 size_t type {0};
26036
26037         };
26038         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
26039         {
26040                 size_t get_index() const {return type;}
26041                 bool is_unknown() const { return type == 1; }
26042                 void clear() {type = 0;}
26043                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
26044                 template<typename V>  bool decode(V& v)
26045                 {
26046                         clear();
26047                         if(!v(ref_nested())) return false;
26048                         { type = 1; return true;}
26049                         return false;
26050
26051                 }
26052                 template<typename V> bool encode(V& v) const
26053                 {
26054                         return v(ref_nested());
26055
26056                 }
26057                 protected:
26058                 template<typename V>  bool decode(size_t index, V& v)
26059                 {
26060                         clear();
26061                         switch(index)
26062                         {
26063                         case 1: type = 1; return v(ref_nested());
26064                         ref_nested().clear();
26065                         }
26066                         return false;
26067
26068                 }
26069                 template<typename V> bool encode(size_t index, V& v) const
26070                 {
26071                         if(index != type) {return false;} return v(ref_nested());
26072
26073                 }
26074                 private:
26075                 size_t type {0};
26076
26077         };
26078
26079 };
26080 /*
26081 SULInformation ::= SEQUENCE {
26082         sUL-ARFCN                               INTEGER (0.. 3279165),
26083         sUL-TxBW                                NR-TxBW,
26084         iE-Extensions                   ProtocolExtensionContainer { {SULInformation-ExtIEs} }          OPTIONAL,
26085         ...
26086 }
26087 */
26088
26089 struct SULInformation : asn::sequence<3, 0, true, 1>
26090 {
26091         static constexpr const char* name() {return "SULInformation";}
26092         using parent_t = asn::sequence<3, 0, true, 1>;
26093         struct sUL_ARFCN_t : asn::integer<>
26094         {
26095                 using constraint_t = asn::constraints<false,asn::span<0, 3279165>>;
26096                 static constexpr const char* name() {return "sUL_ARFCN_t";}
26097                 using parent_t = asn::integer<>;
26098
26099         };
26100
26101         sUL_ARFCN_t& ref_sUL_ARFCN() {return sUL_ARFCN;}
26102         sUL_ARFCN_t const& ref_sUL_ARFCN() const {return sUL_ARFCN;}
26103         struct sUL_TxBW_t : NR_TxBW
26104         {
26105                 static constexpr const char* name() {return "sUL_TxBW_t";}
26106                 using parent_t = NR_TxBW;
26107
26108         };
26109         sUL_TxBW_t& ref_sUL_TxBW() {return sUL_TxBW;}
26110         sUL_TxBW_t const& ref_sUL_TxBW() const {return sUL_TxBW;}
26111         struct iE_Extensions_t : ProtocolExtensionContainer<SULInformation_ExtIEs>
26112         {
26113                 static constexpr const char* name() {return "iE_Extensions_t";}
26114                 using parent_t = ProtocolExtensionContainer<SULInformation_ExtIEs>;
26115                 static constexpr bool optional = true;
26116
26117         };
26118         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
26119         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
26120         template<typename V> void decode(V& v)
26121         {
26122                 v(sUL_ARFCN);
26123                 v(sUL_TxBW);
26124                 v(iE_Extensions);
26125
26126         };
26127         template<typename V> void encode(V& v) const
26128         {
26129                 v(sUL_ARFCN);
26130                 v(sUL_TxBW);
26131                 v(iE_Extensions);
26132
26133         };
26134         void clear()
26135         {
26136                 sUL_ARFCN.clear();
26137                 sUL_TxBW.clear();
26138                 iE_Extensions.clear();
26139
26140         };
26141         private:
26142         sUL_ARFCN_t     sUL_ARFCN;
26143         sUL_TxBW_t      sUL_TxBW;
26144         iE_Extensions_t iE_Extensions;
26145
26146 };
26147 /*
26148 NRFreqInfo-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
26149         ...
26150 }
26151 */
26152
26153 struct NRFreqInfo_ExtIEs
26154 {
26155         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
26156         {
26157                 size_t get_index() const {return type;}
26158                 bool is_unknown() const { return type == 1; }
26159                 void clear() {type = 0;}
26160                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
26161                 template<typename V>  bool decode(V& v)
26162                 {
26163                         clear();
26164                         if(!v(ref_nested())) return false;
26165                         { type = 1; return true;}
26166                         return false;
26167
26168                 }
26169                 template<typename V> bool encode(V& v) const
26170                 {
26171                         return v(ref_nested());
26172
26173                 }
26174                 protected:
26175                 template<typename V>  bool decode(size_t index, V& v)
26176                 {
26177                         clear();
26178                         switch(index)
26179                         {
26180                         case 1: type = 1; return v(ref_nested());
26181                         ref_nested().clear();
26182                         }
26183                         return false;
26184
26185                 }
26186                 template<typename V> bool encode(size_t index, V& v) const
26187                 {
26188                         if(index != type) {return false;} return v(ref_nested());
26189
26190                 }
26191                 private:
26192                 size_t type {0};
26193
26194         };
26195         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
26196         {
26197                 size_t get_index() const {return type;}
26198                 bool is_unknown() const { return type == 1; }
26199                 void clear() {type = 0;}
26200                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
26201                 template<typename V>  bool decode(V& v)
26202                 {
26203                         clear();
26204                         if(!v(ref_nested())) return false;
26205                         { type = 1; return true;}
26206                         return false;
26207
26208                 }
26209                 template<typename V> bool encode(V& v) const
26210                 {
26211                         return v(ref_nested());
26212
26213                 }
26214                 protected:
26215                 template<typename V>  bool decode(size_t index, V& v)
26216                 {
26217                         clear();
26218                         switch(index)
26219                         {
26220                         case 1: type = 1; return v(ref_nested());
26221                         ref_nested().clear();
26222                         }
26223                         return false;
26224
26225                 }
26226                 template<typename V> bool encode(size_t index, V& v) const
26227                 {
26228                         if(index != type) {return false;} return v(ref_nested());
26229
26230                 }
26231                 private:
26232                 size_t type {0};
26233
26234         };
26235         struct Extension_t : asn::typefield<true>
26236         {
26237                 ~Extension_t()  {clear();}
26238                 size_t get_index() const {return type;}
26239                 bool is_unknown() const { return type == 1; }
26240                 void clear()
26241                 {
26242                         type = 0; ref_nested().clear();
26243                 }
26244                 template<typename V> static inline void enumerate(V& v)
26245                 {
26246
26247                 }
26248                 protected:
26249                 template<typename V> bool decode(size_t index, V& v)
26250                 {
26251                         clear();
26252                         switch(index)
26253                         {
26254                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
26255                         }
26256                         return false;
26257
26258                 }
26259                 template<typename V> bool encode(size_t index, V& v) const
26260                 {
26261                         if(index != type) return false;
26262                         return false;
26263
26264                 }
26265                 private:
26266                 size_t type {0};
26267
26268         };
26269         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
26270         {
26271                 size_t get_index() const {return type;}
26272                 bool is_unknown() const { return type == 1; }
26273                 void clear() {type = 0;}
26274                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
26275                 template<typename V>  bool decode(V& v)
26276                 {
26277                         clear();
26278                         if(!v(ref_nested())) return false;
26279                         { type = 1; return true;}
26280                         return false;
26281
26282                 }
26283                 template<typename V> bool encode(V& v) const
26284                 {
26285                         return v(ref_nested());
26286
26287                 }
26288                 protected:
26289                 template<typename V>  bool decode(size_t index, V& v)
26290                 {
26291                         clear();
26292                         switch(index)
26293                         {
26294                         case 1: type = 1; return v(ref_nested());
26295                         ref_nested().clear();
26296                         }
26297                         return false;
26298
26299                 }
26300                 template<typename V> bool encode(size_t index, V& v) const
26301                 {
26302                         if(index != type) {return false;} return v(ref_nested());
26303
26304                 }
26305                 private:
26306                 size_t type {0};
26307
26308         };
26309
26310 };
26311 /*
26312 NRFreqInfo ::= SEQUENCE{
26313         nRARFCN                 INTEGER (0.. 3279165),
26314         freqBandListNr  SEQUENCE (SIZE(1..maxnoofNrCellBands)) OF FreqBandNrItem,
26315         sULInformation  SULInformation          OPTIONAL,
26316         iE-Extensions   ProtocolExtensionContainer { {NRFreqInfo-ExtIEs} } OPTIONAL,
26317
26318         ...
26319 }
26320 */
26321
26322 struct NRFreqInfo : asn::sequence<4, 0, true, 2>
26323 {
26324         static constexpr const char* name() {return "NRFreqInfo";}
26325         using parent_t = asn::sequence<4, 0, true, 2>;
26326         struct nRARFCN_t : asn::integer<>
26327         {
26328                 using constraint_t = asn::constraints<false,asn::span<0, 3279165>>;
26329                 static constexpr const char* name() {return "nRARFCN_t";}
26330                 using parent_t = asn::integer<>;
26331
26332         };
26333
26334         nRARFCN_t& ref_nRARFCN() {return nRARFCN;}
26335         nRARFCN_t const& ref_nRARFCN() const {return nRARFCN;}
26336         struct freqBandListNr_t_elm : FreqBandNrItem
26337         {
26338                 static constexpr const char* name() {return "freqBandListNr_t_elm";}
26339                 using parent_t = FreqBandNrItem;
26340
26341         };
26342         struct freqBandListNr_t : asn::sequenceof<freqBandListNr_t_elm>
26343         {
26344                 static constexpr const char* name() {return "freqBandListNr_t";}
26345                 using parent_t = asn::sequenceof<freqBandListNr_t_elm>;
26346                 using constraint_t = asn::constraints<false,asn::span<1,  maxnoofNrCellBands >>;
26347
26348         };
26349         freqBandListNr_t& ref_freqBandListNr() {return freqBandListNr;}
26350         freqBandListNr_t const& ref_freqBandListNr() const {return freqBandListNr;}
26351         struct sULInformation_t : SULInformation
26352         {
26353                 static constexpr const char* name() {return "sULInformation_t";}
26354                 using parent_t = SULInformation;
26355                 static constexpr bool optional = true;
26356
26357         };
26358         sULInformation_t& set_sULInformation() { sULInformation.setpresent(true); return sULInformation;}
26359         sULInformation_t const* get_sULInformation() const {return sULInformation.is_valid() ? &sULInformation : nullptr;}
26360         struct iE_Extensions_t : ProtocolExtensionContainer<NRFreqInfo_ExtIEs>
26361         {
26362                 static constexpr const char* name() {return "iE_Extensions_t";}
26363                 using parent_t = ProtocolExtensionContainer<NRFreqInfo_ExtIEs>;
26364                 static constexpr bool optional = true;
26365
26366         };
26367         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
26368         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
26369         template<typename V> void decode(V& v)
26370         {
26371                 v(nRARFCN);
26372                 v(freqBandListNr);
26373                 v(sULInformation);
26374                 v(iE_Extensions);
26375
26376         };
26377         template<typename V> void encode(V& v) const
26378         {
26379                 v(nRARFCN);
26380                 v(freqBandListNr);
26381                 v(sULInformation);
26382                 v(iE_Extensions);
26383
26384         };
26385         void clear()
26386         {
26387                 nRARFCN.clear();
26388                 freqBandListNr.clear();
26389                 sULInformation.clear();
26390                 iE_Extensions.clear();
26391
26392         };
26393         private:
26394         nRARFCN_t       nRARFCN;
26395         freqBandListNr_t        freqBandListNr;
26396         sULInformation_t        sULInformation;
26397         iE_Extensions_t iE_Extensions;
26398
26399 };
26400 /*
26401 NRPCI ::= INTEGER (0..1007)
26402 */
26403
26404 struct NRPCI : asn::integer<>
26405 {
26406         using constraint_t = asn::constraints<false,asn::span<0, 1007>>;
26407         static constexpr const char* name() {return "NRPCI";}
26408         using parent_t = asn::integer<>;
26409
26410 };
26411
26412 /*
26413 NRencryptionAlgorithms ::= BIT STRING (SIZE (16,...))
26414 */
26415
26416 struct NRencryptionAlgorithms : asn::bstring<>
26417 {
26418         using constraint_t = asn::constraints<true,asn::one<16>>;
26419         static constexpr const char* name() {return "NRencryptionAlgorithms";}
26420         using parent_t = asn::bstring<>;
26421
26422 };
26423
26424 /*
26425 NRintegrityProtectionAlgorithms ::= BIT STRING (SIZE (16,...))
26426 */
26427
26428 struct NRintegrityProtectionAlgorithms : asn::bstring<>
26429 {
26430         using constraint_t = asn::constraints<true,asn::one<16>>;
26431         static constexpr const char* name() {return "NRintegrityProtectionAlgorithms";}
26432         using parent_t = asn::bstring<>;
26433
26434 };
26435
26436 /*
26437 NRUESecurityCapabilities-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
26438         ...
26439 }
26440 */
26441
26442 struct NRUESecurityCapabilities_ExtIEs
26443 {
26444         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
26445         {
26446                 size_t get_index() const {return type;}
26447                 bool is_unknown() const { return type == 1; }
26448                 void clear() {type = 0;}
26449                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
26450                 template<typename V>  bool decode(V& v)
26451                 {
26452                         clear();
26453                         if(!v(ref_nested())) return false;
26454                         { type = 1; return true;}
26455                         return false;
26456
26457                 }
26458                 template<typename V> bool encode(V& v) const
26459                 {
26460                         return v(ref_nested());
26461
26462                 }
26463                 protected:
26464                 template<typename V>  bool decode(size_t index, V& v)
26465                 {
26466                         clear();
26467                         switch(index)
26468                         {
26469                         case 1: type = 1; return v(ref_nested());
26470                         ref_nested().clear();
26471                         }
26472                         return false;
26473
26474                 }
26475                 template<typename V> bool encode(size_t index, V& v) const
26476                 {
26477                         if(index != type) {return false;} return v(ref_nested());
26478
26479                 }
26480                 private:
26481                 size_t type {0};
26482
26483         };
26484         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
26485         {
26486                 size_t get_index() const {return type;}
26487                 bool is_unknown() const { return type == 1; }
26488                 void clear() {type = 0;}
26489                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
26490                 template<typename V>  bool decode(V& v)
26491                 {
26492                         clear();
26493                         if(!v(ref_nested())) return false;
26494                         { type = 1; return true;}
26495                         return false;
26496
26497                 }
26498                 template<typename V> bool encode(V& v) const
26499                 {
26500                         return v(ref_nested());
26501
26502                 }
26503                 protected:
26504                 template<typename V>  bool decode(size_t index, V& v)
26505                 {
26506                         clear();
26507                         switch(index)
26508                         {
26509                         case 1: type = 1; return v(ref_nested());
26510                         ref_nested().clear();
26511                         }
26512                         return false;
26513
26514                 }
26515                 template<typename V> bool encode(size_t index, V& v) const
26516                 {
26517                         if(index != type) {return false;} return v(ref_nested());
26518
26519                 }
26520                 private:
26521                 size_t type {0};
26522
26523         };
26524         struct Extension_t : asn::typefield<true>
26525         {
26526                 ~Extension_t()  {clear();}
26527                 size_t get_index() const {return type;}
26528                 bool is_unknown() const { return type == 1; }
26529                 void clear()
26530                 {
26531                         type = 0; ref_nested().clear();
26532                 }
26533                 template<typename V> static inline void enumerate(V& v)
26534                 {
26535
26536                 }
26537                 protected:
26538                 template<typename V> bool decode(size_t index, V& v)
26539                 {
26540                         clear();
26541                         switch(index)
26542                         {
26543                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
26544                         }
26545                         return false;
26546
26547                 }
26548                 template<typename V> bool encode(size_t index, V& v) const
26549                 {
26550                         if(index != type) return false;
26551                         return false;
26552
26553                 }
26554                 private:
26555                 size_t type {0};
26556
26557         };
26558         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
26559         {
26560                 size_t get_index() const {return type;}
26561                 bool is_unknown() const { return type == 1; }
26562                 void clear() {type = 0;}
26563                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
26564                 template<typename V>  bool decode(V& v)
26565                 {
26566                         clear();
26567                         if(!v(ref_nested())) return false;
26568                         { type = 1; return true;}
26569                         return false;
26570
26571                 }
26572                 template<typename V> bool encode(V& v) const
26573                 {
26574                         return v(ref_nested());
26575
26576                 }
26577                 protected:
26578                 template<typename V>  bool decode(size_t index, V& v)
26579                 {
26580                         clear();
26581                         switch(index)
26582                         {
26583                         case 1: type = 1; return v(ref_nested());
26584                         ref_nested().clear();
26585                         }
26586                         return false;
26587
26588                 }
26589                 template<typename V> bool encode(size_t index, V& v) const
26590                 {
26591                         if(index != type) {return false;} return v(ref_nested());
26592
26593                 }
26594                 private:
26595                 size_t type {0};
26596
26597         };
26598
26599 };
26600 /*
26601 NRUESecurityCapabilities ::= SEQUENCE {
26602         nRencryptionAlgorithms                          NRencryptionAlgorithms,
26603         nRintegrityProtectionAlgorithms         NRintegrityProtectionAlgorithms,
26604         iE-Extensions                                           ProtocolExtensionContainer { {NRUESecurityCapabilities-ExtIEs} }        OPTIONAL,
26605 ...
26606 }
26607 */
26608
26609 struct NRUESecurityCapabilities : asn::sequence<3, 0, true, 1>
26610 {
26611         static constexpr const char* name() {return "NRUESecurityCapabilities";}
26612         using parent_t = asn::sequence<3, 0, true, 1>;
26613         struct nRencryptionAlgorithms_t : NRencryptionAlgorithms
26614         {
26615                 static constexpr const char* name() {return "nRencryptionAlgorithms_t";}
26616                 using parent_t = NRencryptionAlgorithms;
26617
26618         };
26619         nRencryptionAlgorithms_t& ref_nRencryptionAlgorithms() {return nRencryptionAlgorithms;}
26620         nRencryptionAlgorithms_t const& ref_nRencryptionAlgorithms() const {return nRencryptionAlgorithms;}
26621         struct nRintegrityProtectionAlgorithms_t : NRintegrityProtectionAlgorithms
26622         {
26623                 static constexpr const char* name() {return "nRintegrityProtectionAlgorithms_t";}
26624                 using parent_t = NRintegrityProtectionAlgorithms;
26625
26626         };
26627         nRintegrityProtectionAlgorithms_t& ref_nRintegrityProtectionAlgorithms() {return nRintegrityProtectionAlgorithms;}
26628         nRintegrityProtectionAlgorithms_t const& ref_nRintegrityProtectionAlgorithms() const {return nRintegrityProtectionAlgorithms;}
26629         struct iE_Extensions_t : ProtocolExtensionContainer<NRUESecurityCapabilities_ExtIEs>
26630         {
26631                 static constexpr const char* name() {return "iE_Extensions_t";}
26632                 using parent_t = ProtocolExtensionContainer<NRUESecurityCapabilities_ExtIEs>;
26633                 static constexpr bool optional = true;
26634
26635         };
26636         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
26637         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
26638         template<typename V> void decode(V& v)
26639         {
26640                 v(nRencryptionAlgorithms);
26641                 v(nRintegrityProtectionAlgorithms);
26642                 v(iE_Extensions);
26643
26644         };
26645         template<typename V> void encode(V& v) const
26646         {
26647                 v(nRencryptionAlgorithms);
26648                 v(nRintegrityProtectionAlgorithms);
26649                 v(iE_Extensions);
26650
26651         };
26652         void clear()
26653         {
26654                 nRencryptionAlgorithms.clear();
26655                 nRintegrityProtectionAlgorithms.clear();
26656                 iE_Extensions.clear();
26657
26658         };
26659         private:
26660         nRencryptionAlgorithms_t        nRencryptionAlgorithms;
26661         nRintegrityProtectionAlgorithms_t       nRintegrityProtectionAlgorithms;
26662         iE_Extensions_t iE_Extensions;
26663
26664 };
26665 /*
26666 PCI ::= INTEGER (0..503, ...)
26667 */
26668
26669 struct PCI : asn::integer<>
26670 {
26671         using constraint_t = asn::constraints<true,asn::span<0, 503>>;
26672         static constexpr const char* name() {return "PCI";}
26673         using parent_t = asn::integer<>;
26674
26675 };
26676
26677 /*
26678 Neighbour-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
26679         { ID id-NeighbourTAC            CRITICALITY ignore      EXTENSION TAC                           PRESENCE optional}|
26680         { ID id-eARFCNExtension         CRITICALITY reject      EXTENSION EARFCNExtension       PRESENCE optional},
26681         ...
26682 }
26683 */
26684
26685 struct Neighbour_Information_ExtIEs
26686 {
26687         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
26688         {
26689                 size_t get_index() const {return type;}
26690                 bool is_unknown() const { return type == 3; }
26691                 void clear() {type = 0;}
26692                 void select_id_NeighbourTAC() { set(id_NeighbourTAC); type=1;}
26693                 void select_id_eARFCNExtension() { set(id_eARFCNExtension); type=2;}
26694                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
26695                 template<typename V>  bool decode(V& v)
26696                 {
26697                         clear();
26698                         if(!v(ref_nested())) return false;
26699                         if(equal(id_NeighbourTAC)) { type = 1; return true; }
26700                         else if(equal(id_eARFCNExtension)) { type = 2; return true; }
26701                         else { type = 3; return true;}
26702                         return false;
26703
26704                 }
26705                 template<typename V> bool encode(V& v) const
26706                 {
26707                         return v(ref_nested());
26708
26709                 }
26710                 protected:
26711                 template<typename V>  bool decode(size_t index, V& v)
26712                 {
26713                         clear();
26714                         switch(index)
26715                         {
26716                         case 1: type = 1; if(v(ref_nested())) { return equal(id_NeighbourTAC);} return false;
26717                         case 2: type = 2; if(v(ref_nested())) { return equal(id_eARFCNExtension);} return false;
26718                         case 3: type = 3; return v(ref_nested());
26719                         ref_nested().clear();
26720                         }
26721                         return false;
26722
26723                 }
26724                 template<typename V> bool encode(size_t index, V& v) const
26725                 {
26726                         if(index != type) {return false;} return v(ref_nested());
26727
26728                 }
26729                 private:
26730                 size_t type {0};
26731
26732         };
26733         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
26734         {
26735                 size_t get_index() const {return type;}
26736                 bool is_unknown() const { return type == 3; }
26737                 void clear() {type = 0;}
26738                 void select_id_NeighbourTAC() { set(ignore); type=1;}
26739                 void select_id_eARFCNExtension() { set(reject); type=2;}
26740                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
26741                 template<typename V>  bool decode(V& v)
26742                 {
26743                         clear();
26744                         if(!v(ref_nested())) return false;
26745                         if(equal(ignore)) { type = 1; return true; }
26746                         else if(equal(reject)) { type = 2; return true; }
26747                         else { type = 3; return true;}
26748                         return false;
26749
26750                 }
26751                 template<typename V> bool encode(V& v) const
26752                 {
26753                         return v(ref_nested());
26754
26755                 }
26756                 protected:
26757                 template<typename V>  bool decode(size_t index, V& v)
26758                 {
26759                         clear();
26760                         switch(index)
26761                         {
26762                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
26763                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
26764                         case 3: type = 3; return v(ref_nested());
26765                         ref_nested().clear();
26766                         }
26767                         return false;
26768
26769                 }
26770                 template<typename V> bool encode(size_t index, V& v) const
26771                 {
26772                         if(index != type) {return false;} return v(ref_nested());
26773
26774                 }
26775                 private:
26776                 size_t type {0};
26777
26778         };
26779         struct Extension_t : asn::typefield<true>
26780         {
26781                 ~Extension_t()  {clear();}
26782                 size_t get_index() const {return type;}
26783                 TAC& select_id_NeighbourTAC() { return set<TAC>(1); }
26784                 TAC const* get_id_NeighbourTAC() const { return get<TAC>(1); }
26785                 EARFCNExtension& select_id_eARFCNExtension() { return set<EARFCNExtension>(2); }
26786                 EARFCNExtension const* get_id_eARFCNExtension() const { return get<EARFCNExtension>(2); }
26787                 bool is_unknown() const { return type == 3; }
26788                 void clear()
26789                 {
26790                         switch(type)
26791                         {
26792                         case 1: var.destroy<TAC>(); break;
26793                         case 2: var.destroy<EARFCNExtension>(); break;
26794                         }
26795                         type = 0; ref_nested().clear();
26796                 }
26797                 template<typename V> static inline void enumerate(V& v)
26798                 {
26799                         v.template operator()<TAC>(1);
26800                         v.template operator()<EARFCNExtension>(2);
26801
26802                 }
26803                 protected:
26804                 template<typename V> bool decode(size_t index, V& v)
26805                 {
26806                         clear();
26807                         switch(index)
26808                         {
26809                         case 1: v(select_id_NeighbourTAC()); return true;
26810                         case 2: v(select_id_eARFCNExtension()); return true;
26811                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
26812                         }
26813                         return false;
26814
26815                 }
26816                 template<typename V> bool encode(size_t index, V& v) const
26817                 {
26818                         if(index != type) return false;
26819                         switch(type)
26820                         {
26821                         case 1: v(var.as<TAC>()); return true;
26822                         case 2: v(var.as<EARFCNExtension>()); return true;
26823                         }
26824                         return false;
26825
26826                 }
26827                 private:
26828                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
26829                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
26830                 union union_type
26831                 {
26832                         char dummy1[sizeof(EARFCNExtension)];
26833                         char dummy2[sizeof(TAC)];
26834
26835                 };
26836                 asn::variant<sizeof(union_type)> var;
26837                 size_t type {0};
26838
26839         };
26840         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
26841         {
26842                 size_t get_index() const {return type;}
26843                 bool is_unknown() const { return type == 3; }
26844                 void clear() {type = 0;}
26845                 void select_id_NeighbourTAC() { set(optional); type=1;}
26846                 void select_id_eARFCNExtension() { set(optional); type=2;}
26847                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
26848                 template<typename V>  bool decode(V& v)
26849                 {
26850                         clear();
26851                         if(!v(ref_nested())) return false;
26852                         if(equal(optional)) { type = 1; return true; }
26853                         else if(equal(optional)) { type = 2; return true; }
26854                         else { type = 3; return true;}
26855                         return false;
26856
26857                 }
26858                 template<typename V> bool encode(V& v) const
26859                 {
26860                         return v(ref_nested());
26861
26862                 }
26863                 protected:
26864                 template<typename V>  bool decode(size_t index, V& v)
26865                 {
26866                         clear();
26867                         switch(index)
26868                         {
26869                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
26870                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
26871                         case 3: type = 3; return v(ref_nested());
26872                         ref_nested().clear();
26873                         }
26874                         return false;
26875
26876                 }
26877                 template<typename V> bool encode(size_t index, V& v) const
26878                 {
26879                         if(index != type) {return false;} return v(ref_nested());
26880
26881                 }
26882                 private:
26883                 size_t type {0};
26884
26885         };
26886
26887 };
26888 /*
26889 Neighbour-Information ::= SEQUENCE (SIZE (0..maxnoofNeighbours)) OF SEQUENCE {
26890         eCGI                                            ECGI,
26891         pCI                                                     PCI,
26892         eARFCN                                          EARFCN,
26893         iE-Extensions                           ProtocolExtensionContainer { {Neighbour-Information-ExtIEs} } OPTIONAL,
26894         ...
26895 }
26896 */
26897
26898 struct Neighbour_Information_elm : asn::sequence<4, 0, true, 1>
26899 {
26900         static constexpr const char* name() {return "Neighbour_Information_elm";}
26901         using parent_t = asn::sequence<4, 0, true, 1>;
26902         struct eCGI_t : ECGI
26903         {
26904                 static constexpr const char* name() {return "eCGI_t";}
26905                 using parent_t = ECGI;
26906
26907         };
26908         eCGI_t& ref_eCGI() {return eCGI;}
26909         eCGI_t const& ref_eCGI() const {return eCGI;}
26910         struct pCI_t : PCI
26911         {
26912                 static constexpr const char* name() {return "pCI_t";}
26913                 using parent_t = PCI;
26914
26915         };
26916         pCI_t& ref_pCI() {return pCI;}
26917         pCI_t const& ref_pCI() const {return pCI;}
26918         struct eARFCN_t : EARFCN
26919         {
26920                 static constexpr const char* name() {return "eARFCN_t";}
26921                 using parent_t = EARFCN;
26922
26923         };
26924         eARFCN_t& ref_eARFCN() {return eARFCN;}
26925         eARFCN_t const& ref_eARFCN() const {return eARFCN;}
26926         struct iE_Extensions_t : ProtocolExtensionContainer<Neighbour_Information_ExtIEs>
26927         {
26928                 static constexpr const char* name() {return "iE_Extensions_t";}
26929                 using parent_t = ProtocolExtensionContainer<Neighbour_Information_ExtIEs>;
26930                 static constexpr bool optional = true;
26931
26932         };
26933         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
26934         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
26935         template<typename V> void decode(V& v)
26936         {
26937                 v(eCGI);
26938                 v(pCI);
26939                 v(eARFCN);
26940                 v(iE_Extensions);
26941
26942         };
26943         template<typename V> void encode(V& v) const
26944         {
26945                 v(eCGI);
26946                 v(pCI);
26947                 v(eARFCN);
26948                 v(iE_Extensions);
26949
26950         };
26951         void clear()
26952         {
26953                 eCGI.clear();
26954                 pCI.clear();
26955                 eARFCN.clear();
26956                 iE_Extensions.clear();
26957
26958         };
26959         private:
26960         eCGI_t  eCGI;
26961         pCI_t   pCI;
26962         eARFCN_t        eARFCN;
26963         iE_Extensions_t iE_Extensions;
26964
26965 };
26966 struct Neighbour_Information : asn::sequenceof<Neighbour_Information_elm>
26967 {
26968         static constexpr const char* name() {return "Neighbour-Information";}
26969         using parent_t = asn::sequenceof<Neighbour_Information_elm>;
26970         using constraint_t = asn::constraints<false,asn::span<0,  maxnoofNeighbours >>;
26971
26972 };
26973 /*
26974 NewDRBIDrequest::= ENUMERATED {true, ...}
26975 */
26976
26977 struct NewDRBIDrequest : asn::enumerated<1, 0, true>
26978 {
26979         static constexpr const char* name() {return "NewDRBIDrequest";}
26980         using parent_t = asn::enumerated<1, 0, true>;
26981         typedef enum {
26982                 True
26983         } index_t;
26984
26985 };
26986
26987 /*
26988 Number-of-Antennaports ::= ENUMERATED {
26989                 an1,
26990                 an2,
26991                 an4,
26992                 ...
26993 }
26994 */
26995
26996 struct Number_of_Antennaports : asn::enumerated<3, 0, true>
26997 {
26998         static constexpr const char* name() {return "Number-of-Antennaports";}
26999         using parent_t = asn::enumerated<3, 0, true>;
27000         typedef enum {
27001                 an1
27002                 ,an2
27003                 ,an4
27004         } index_t;
27005
27006 };
27007
27008 /*
27009 PDCPChangeIndication ::= ENUMERATED {s-KgNB-update-required, pDCP-data-recovery-required,...}
27010 */
27011
27012 struct PDCPChangeIndication : asn::enumerated<2, 0, true>
27013 {
27014         static constexpr const char* name() {return "PDCPChangeIndication";}
27015         using parent_t = asn::enumerated<2, 0, true>;
27016         typedef enum {
27017                 s_KgNB_update_required
27018                 ,pDCP_data_recovery_required
27019         } index_t;
27020
27021 };
27022
27023 /*
27024 PDCPSnLength    ::=     ENUMERATED {twelve-bits,eighteen-bits,...}
27025 */
27026
27027 struct PDCPSnLength : asn::enumerated<2, 0, true>
27028 {
27029         static constexpr const char* name() {return "PDCPSnLength";}
27030         using parent_t = asn::enumerated<2, 0, true>;
27031         typedef enum {
27032                 twelve_bits
27033                 ,eighteen_bits
27034         } index_t;
27035
27036 };
27037
27038 /*
27039 PRACH-Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
27040         ...
27041 }
27042 */
27043
27044 struct PRACH_Configuration_ExtIEs
27045 {
27046         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
27047         {
27048                 size_t get_index() const {return type;}
27049                 bool is_unknown() const { return type == 1; }
27050                 void clear() {type = 0;}
27051                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
27052                 template<typename V>  bool decode(V& v)
27053                 {
27054                         clear();
27055                         if(!v(ref_nested())) return false;
27056                         { type = 1; return true;}
27057                         return false;
27058
27059                 }
27060                 template<typename V> bool encode(V& v) const
27061                 {
27062                         return v(ref_nested());
27063
27064                 }
27065                 protected:
27066                 template<typename V>  bool decode(size_t index, V& v)
27067                 {
27068                         clear();
27069                         switch(index)
27070                         {
27071                         case 1: type = 1; return v(ref_nested());
27072                         ref_nested().clear();
27073                         }
27074                         return false;
27075
27076                 }
27077                 template<typename V> bool encode(size_t index, V& v) const
27078                 {
27079                         if(index != type) {return false;} return v(ref_nested());
27080
27081                 }
27082                 private:
27083                 size_t type {0};
27084
27085         };
27086         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
27087         {
27088                 size_t get_index() const {return type;}
27089                 bool is_unknown() const { return type == 1; }
27090                 void clear() {type = 0;}
27091                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
27092                 template<typename V>  bool decode(V& v)
27093                 {
27094                         clear();
27095                         if(!v(ref_nested())) return false;
27096                         { type = 1; return true;}
27097                         return false;
27098
27099                 }
27100                 template<typename V> bool encode(V& v) const
27101                 {
27102                         return v(ref_nested());
27103
27104                 }
27105                 protected:
27106                 template<typename V>  bool decode(size_t index, V& v)
27107                 {
27108                         clear();
27109                         switch(index)
27110                         {
27111                         case 1: type = 1; return v(ref_nested());
27112                         ref_nested().clear();
27113                         }
27114                         return false;
27115
27116                 }
27117                 template<typename V> bool encode(size_t index, V& v) const
27118                 {
27119                         if(index != type) {return false;} return v(ref_nested());
27120
27121                 }
27122                 private:
27123                 size_t type {0};
27124
27125         };
27126         struct Extension_t : asn::typefield<true>
27127         {
27128                 ~Extension_t()  {clear();}
27129                 size_t get_index() const {return type;}
27130                 bool is_unknown() const { return type == 1; }
27131                 void clear()
27132                 {
27133                         type = 0; ref_nested().clear();
27134                 }
27135                 template<typename V> static inline void enumerate(V& v)
27136                 {
27137
27138                 }
27139                 protected:
27140                 template<typename V> bool decode(size_t index, V& v)
27141                 {
27142                         clear();
27143                         switch(index)
27144                         {
27145                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
27146                         }
27147                         return false;
27148
27149                 }
27150                 template<typename V> bool encode(size_t index, V& v) const
27151                 {
27152                         if(index != type) return false;
27153                         return false;
27154
27155                 }
27156                 private:
27157                 size_t type {0};
27158
27159         };
27160         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
27161         {
27162                 size_t get_index() const {return type;}
27163                 bool is_unknown() const { return type == 1; }
27164                 void clear() {type = 0;}
27165                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
27166                 template<typename V>  bool decode(V& v)
27167                 {
27168                         clear();
27169                         if(!v(ref_nested())) return false;
27170                         { type = 1; return true;}
27171                         return false;
27172
27173                 }
27174                 template<typename V> bool encode(V& v) const
27175                 {
27176                         return v(ref_nested());
27177
27178                 }
27179                 protected:
27180                 template<typename V>  bool decode(size_t index, V& v)
27181                 {
27182                         clear();
27183                         switch(index)
27184                         {
27185                         case 1: type = 1; return v(ref_nested());
27186                         ref_nested().clear();
27187                         }
27188                         return false;
27189
27190                 }
27191                 template<typename V> bool encode(size_t index, V& v) const
27192                 {
27193                         if(index != type) {return false;} return v(ref_nested());
27194
27195                 }
27196                 private:
27197                 size_t type {0};
27198
27199         };
27200
27201 };
27202 /*
27203 PRACH-Configuration ::= SEQUENCE {
27204         rootSequenceIndex                                               INTEGER (0..837),
27205         zeroCorrelationIndex                                    INTEGER (0..15),
27206         highSpeedFlag                                                   BOOLEAN,
27207         prach-FreqOffset                                                INTEGER (0..94),
27208         prach-ConfigIndex                                               INTEGER (0..63)         OPTIONAL, -- present for TDD --
27209         iE-Extensions                                                   ProtocolExtensionContainer { {PRACH-Configuration-ExtIEs} }     OPTIONAL,
27210         ...
27211 }
27212 */
27213
27214 struct PRACH_Configuration : asn::sequence<6, 0, true, 2>
27215 {
27216         static constexpr const char* name() {return "PRACH-Configuration";}
27217         using parent_t = asn::sequence<6, 0, true, 2>;
27218         struct rootSequenceIndex_t : asn::integer<>
27219         {
27220                 using constraint_t = asn::constraints<false,asn::span<0, 837>>;
27221                 static constexpr const char* name() {return "rootSequenceIndex_t";}
27222                 using parent_t = asn::integer<>;
27223
27224         };
27225
27226         rootSequenceIndex_t& ref_rootSequenceIndex() {return rootSequenceIndex;}
27227         rootSequenceIndex_t const& ref_rootSequenceIndex() const {return rootSequenceIndex;}
27228         struct zeroCorrelationIndex_t : asn::integer<>
27229         {
27230                 using constraint_t = asn::constraints<false,asn::span<0, 15>>;
27231                 static constexpr const char* name() {return "zeroCorrelationIndex_t";}
27232                 using parent_t = asn::integer<>;
27233
27234         };
27235
27236         zeroCorrelationIndex_t& ref_zeroCorrelationIndex() {return zeroCorrelationIndex;}
27237         zeroCorrelationIndex_t const& ref_zeroCorrelationIndex() const {return zeroCorrelationIndex;}
27238         struct highSpeedFlag_t : asn::boolean
27239         {
27240                 static constexpr const char* name() {return "highSpeedFlag_t";}
27241                 using parent_t = asn::boolean;
27242
27243         };
27244         highSpeedFlag_t& ref_highSpeedFlag() {return highSpeedFlag;}
27245         highSpeedFlag_t const& ref_highSpeedFlag() const {return highSpeedFlag;}
27246         struct prach_FreqOffset_t : asn::integer<>
27247         {
27248                 using constraint_t = asn::constraints<false,asn::span<0, 94>>;
27249                 static constexpr const char* name() {return "prach_FreqOffset_t";}
27250                 using parent_t = asn::integer<>;
27251
27252         };
27253
27254         prach_FreqOffset_t& ref_prach_FreqOffset() {return prach_FreqOffset;}
27255         prach_FreqOffset_t const& ref_prach_FreqOffset() const {return prach_FreqOffset;}
27256         struct prach_ConfigIndex_t : asn::integer<>
27257         {
27258                 using constraint_t = asn::constraints<false,asn::span<0, 63>>;
27259                 static constexpr const char* name() {return "prach_ConfigIndex_t";}
27260                 using parent_t = asn::integer<>;
27261                 static constexpr bool optional = true;
27262
27263         };
27264
27265         prach_ConfigIndex_t& set_prach_ConfigIndex() { prach_ConfigIndex.setpresent(true); return prach_ConfigIndex;}
27266         prach_ConfigIndex_t const* get_prach_ConfigIndex() const {return prach_ConfigIndex.is_valid() ? &prach_ConfigIndex : nullptr;}
27267         struct iE_Extensions_t : ProtocolExtensionContainer<PRACH_Configuration_ExtIEs>
27268         {
27269                 static constexpr const char* name() {return "iE_Extensions_t";}
27270                 using parent_t = ProtocolExtensionContainer<PRACH_Configuration_ExtIEs>;
27271                 static constexpr bool optional = true;
27272
27273         };
27274         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
27275         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
27276         template<typename V> void decode(V& v)
27277         {
27278                 v(rootSequenceIndex);
27279                 v(zeroCorrelationIndex);
27280                 v(highSpeedFlag);
27281                 v(prach_FreqOffset);
27282                 v(prach_ConfigIndex);
27283                 v(iE_Extensions);
27284
27285         };
27286         template<typename V> void encode(V& v) const
27287         {
27288                 v(rootSequenceIndex);
27289                 v(zeroCorrelationIndex);
27290                 v(highSpeedFlag);
27291                 v(prach_FreqOffset);
27292                 v(prach_ConfigIndex);
27293                 v(iE_Extensions);
27294
27295         };
27296         void clear()
27297         {
27298                 rootSequenceIndex.clear();
27299                 zeroCorrelationIndex.clear();
27300                 highSpeedFlag.clear();
27301                 prach_FreqOffset.clear();
27302                 prach_ConfigIndex.clear();
27303                 iE_Extensions.clear();
27304
27305         };
27306         private:
27307         rootSequenceIndex_t     rootSequenceIndex;
27308         zeroCorrelationIndex_t  zeroCorrelationIndex;
27309         highSpeedFlag_t highSpeedFlag;
27310         prach_FreqOffset_t      prach_FreqOffset;
27311         prach_ConfigIndex_t     prach_ConfigIndex;
27312         iE_Extensions_t iE_Extensions;
27313
27314 };
27315 /*
27316 PedestrianUE ::= ENUMERATED {
27317         authorized,
27318         not-authorized,
27319         ...
27320 }
27321 */
27322
27323 struct PedestrianUE : asn::enumerated<2, 0, true>
27324 {
27325         static constexpr const char* name() {return "PedestrianUE";}
27326         using parent_t = asn::enumerated<2, 0, true>;
27327         typedef enum {
27328                 authorized
27329                 ,not_authorized
27330         } index_t;
27331
27332 };
27333
27334 /*
27335 Port-Number ::= OCTET STRING (SIZE (2))
27336 */
27337
27338 struct Port_Number : asn::ostring<>
27339 {
27340         using constraint_t = asn::constraints<false,asn::one<2>>;
27341         static constexpr const char* name() {return "Port-Number";}
27342         using parent_t = asn::ostring<>;
27343
27344 };
27345
27346 /*
27347 ProSeDirectDiscovery ::= ENUMERATED {
27348         authorized,
27349         not-authorized,
27350         ...
27351 }
27352 */
27353
27354 struct ProSeDirectDiscovery : asn::enumerated<2, 0, true>
27355 {
27356         static constexpr const char* name() {return "ProSeDirectDiscovery";}
27357         using parent_t = asn::enumerated<2, 0, true>;
27358         typedef enum {
27359                 authorized
27360                 ,not_authorized
27361         } index_t;
27362
27363 };
27364
27365 /*
27366 ProSeDirectCommunication ::= ENUMERATED {
27367         authorized,
27368         not-authorized,
27369         ...
27370 }
27371 */
27372
27373 struct ProSeDirectCommunication : asn::enumerated<2, 0, true>
27374 {
27375         static constexpr const char* name() {return "ProSeDirectCommunication";}
27376         using parent_t = asn::enumerated<2, 0, true>;
27377         typedef enum {
27378                 authorized
27379                 ,not_authorized
27380         } index_t;
27381
27382 };
27383
27384 /*
27385 ProSeUEtoNetworkRelaying ::= ENUMERATED {
27386         authorized,
27387         not-authorized,
27388         ...
27389 }
27390 */
27391
27392 struct ProSeUEtoNetworkRelaying : asn::enumerated<2, 0, true>
27393 {
27394         static constexpr const char* name() {return "ProSeUEtoNetworkRelaying";}
27395         using parent_t = asn::enumerated<2, 0, true>;
27396         typedef enum {
27397                 authorized
27398                 ,not_authorized
27399         } index_t;
27400
27401 };
27402
27403 /*
27404 ProSeAuthorized-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
27405         { ID id-ProSeUEtoNetworkRelaying        CRITICALITY ignore      EXTENSION ProSeUEtoNetworkRelaying              PRESENCE optional},
27406         ...
27407 }
27408 */
27409
27410 struct ProSeAuthorized_ExtIEs
27411 {
27412         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
27413         {
27414                 size_t get_index() const {return type;}
27415                 bool is_unknown() const { return type == 2; }
27416                 void clear() {type = 0;}
27417                 void select_id_ProSeUEtoNetworkRelaying() { set(id_ProSeUEtoNetworkRelaying); type=1;}
27418                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
27419                 template<typename V>  bool decode(V& v)
27420                 {
27421                         clear();
27422                         if(!v(ref_nested())) return false;
27423                         if(equal(id_ProSeUEtoNetworkRelaying)) { type = 1; return true; }
27424                         else { type = 2; return true;}
27425                         return false;
27426
27427                 }
27428                 template<typename V> bool encode(V& v) const
27429                 {
27430                         return v(ref_nested());
27431
27432                 }
27433                 protected:
27434                 template<typename V>  bool decode(size_t index, V& v)
27435                 {
27436                         clear();
27437                         switch(index)
27438                         {
27439                         case 1: type = 1; if(v(ref_nested())) { return equal(id_ProSeUEtoNetworkRelaying);} return false;
27440                         case 2: type = 2; return v(ref_nested());
27441                         ref_nested().clear();
27442                         }
27443                         return false;
27444
27445                 }
27446                 template<typename V> bool encode(size_t index, V& v) const
27447                 {
27448                         if(index != type) {return false;} return v(ref_nested());
27449
27450                 }
27451                 private:
27452                 size_t type {0};
27453
27454         };
27455         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
27456         {
27457                 size_t get_index() const {return type;}
27458                 bool is_unknown() const { return type == 2; }
27459                 void clear() {type = 0;}
27460                 void select_id_ProSeUEtoNetworkRelaying() { set(ignore); type=1;}
27461                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
27462                 template<typename V>  bool decode(V& v)
27463                 {
27464                         clear();
27465                         if(!v(ref_nested())) return false;
27466                         if(equal(ignore)) { type = 1; return true; }
27467                         else { type = 2; return true;}
27468                         return false;
27469
27470                 }
27471                 template<typename V> bool encode(V& v) const
27472                 {
27473                         return v(ref_nested());
27474
27475                 }
27476                 protected:
27477                 template<typename V>  bool decode(size_t index, V& v)
27478                 {
27479                         clear();
27480                         switch(index)
27481                         {
27482                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
27483                         case 2: type = 2; return v(ref_nested());
27484                         ref_nested().clear();
27485                         }
27486                         return false;
27487
27488                 }
27489                 template<typename V> bool encode(size_t index, V& v) const
27490                 {
27491                         if(index != type) {return false;} return v(ref_nested());
27492
27493                 }
27494                 private:
27495                 size_t type {0};
27496
27497         };
27498         struct Extension_t : asn::typefield<true>
27499         {
27500                 ~Extension_t()  {clear();}
27501                 size_t get_index() const {return type;}
27502                 ProSeUEtoNetworkRelaying& select_id_ProSeUEtoNetworkRelaying() { return set<ProSeUEtoNetworkRelaying>(1); }
27503                 ProSeUEtoNetworkRelaying const* get_id_ProSeUEtoNetworkRelaying() const { return get<ProSeUEtoNetworkRelaying>(1); }
27504                 bool is_unknown() const { return type == 2; }
27505                 void clear()
27506                 {
27507                         switch(type)
27508                         {
27509                         case 1: var.destroy<ProSeUEtoNetworkRelaying>(); break;
27510                         }
27511                         type = 0; ref_nested().clear();
27512                 }
27513                 template<typename V> static inline void enumerate(V& v)
27514                 {
27515                         v.template operator()<ProSeUEtoNetworkRelaying>(1);
27516
27517                 }
27518                 protected:
27519                 template<typename V> bool decode(size_t index, V& v)
27520                 {
27521                         clear();
27522                         switch(index)
27523                         {
27524                         case 1: v(select_id_ProSeUEtoNetworkRelaying()); return true;
27525                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
27526                         }
27527                         return false;
27528
27529                 }
27530                 template<typename V> bool encode(size_t index, V& v) const
27531                 {
27532                         if(index != type) return false;
27533                         switch(type)
27534                         {
27535                         case 1: v(var.as<ProSeUEtoNetworkRelaying>()); return true;
27536                         }
27537                         return false;
27538
27539                 }
27540                 private:
27541                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
27542                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
27543                 union union_type
27544                 {
27545                         char dummy1[sizeof(ProSeUEtoNetworkRelaying)];
27546
27547                 };
27548                 asn::variant<sizeof(union_type)> var;
27549                 size_t type {0};
27550
27551         };
27552         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
27553         {
27554                 size_t get_index() const {return type;}
27555                 bool is_unknown() const { return type == 2; }
27556                 void clear() {type = 0;}
27557                 void select_id_ProSeUEtoNetworkRelaying() { set(optional); type=1;}
27558                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
27559                 template<typename V>  bool decode(V& v)
27560                 {
27561                         clear();
27562                         if(!v(ref_nested())) return false;
27563                         if(equal(optional)) { type = 1; return true; }
27564                         else { type = 2; return true;}
27565                         return false;
27566
27567                 }
27568                 template<typename V> bool encode(V& v) const
27569                 {
27570                         return v(ref_nested());
27571
27572                 }
27573                 protected:
27574                 template<typename V>  bool decode(size_t index, V& v)
27575                 {
27576                         clear();
27577                         switch(index)
27578                         {
27579                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
27580                         case 2: type = 2; return v(ref_nested());
27581                         ref_nested().clear();
27582                         }
27583                         return false;
27584
27585                 }
27586                 template<typename V> bool encode(size_t index, V& v) const
27587                 {
27588                         if(index != type) {return false;} return v(ref_nested());
27589
27590                 }
27591                 private:
27592                 size_t type {0};
27593
27594         };
27595
27596 };
27597 /*
27598 ProSeAuthorized ::= SEQUENCE {
27599         proSeDirectDiscovery            ProSeDirectDiscovery                    OPTIONAL,
27600         proSeDirectCommunication        ProSeDirectCommunication                OPTIONAL,
27601         iE-Extensions                           ProtocolExtensionContainer { {ProSeAuthorized-ExtIEs} } OPTIONAL,
27602         ...
27603 }
27604 */
27605
27606 struct ProSeAuthorized : asn::sequence<3, 0, true, 3>
27607 {
27608         static constexpr const char* name() {return "ProSeAuthorized";}
27609         using parent_t = asn::sequence<3, 0, true, 3>;
27610         struct proSeDirectDiscovery_t : ProSeDirectDiscovery
27611         {
27612                 static constexpr const char* name() {return "proSeDirectDiscovery_t";}
27613                 using parent_t = ProSeDirectDiscovery;
27614                 static constexpr bool optional = true;
27615
27616         };
27617         proSeDirectDiscovery_t& set_proSeDirectDiscovery() { proSeDirectDiscovery.setpresent(true); return proSeDirectDiscovery;}
27618         proSeDirectDiscovery_t const* get_proSeDirectDiscovery() const {return proSeDirectDiscovery.is_valid() ? &proSeDirectDiscovery : nullptr;}
27619         struct proSeDirectCommunication_t : ProSeDirectCommunication
27620         {
27621                 static constexpr const char* name() {return "proSeDirectCommunication_t";}
27622                 using parent_t = ProSeDirectCommunication;
27623                 static constexpr bool optional = true;
27624
27625         };
27626         proSeDirectCommunication_t& set_proSeDirectCommunication() { proSeDirectCommunication.setpresent(true); return proSeDirectCommunication;}
27627         proSeDirectCommunication_t const* get_proSeDirectCommunication() const {return proSeDirectCommunication.is_valid() ? &proSeDirectCommunication : nullptr;}
27628         struct iE_Extensions_t : ProtocolExtensionContainer<ProSeAuthorized_ExtIEs>
27629         {
27630                 static constexpr const char* name() {return "iE_Extensions_t";}
27631                 using parent_t = ProtocolExtensionContainer<ProSeAuthorized_ExtIEs>;
27632                 static constexpr bool optional = true;
27633
27634         };
27635         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
27636         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
27637         template<typename V> void decode(V& v)
27638         {
27639                 v(proSeDirectDiscovery);
27640                 v(proSeDirectCommunication);
27641                 v(iE_Extensions);
27642
27643         };
27644         template<typename V> void encode(V& v) const
27645         {
27646                 v(proSeDirectDiscovery);
27647                 v(proSeDirectCommunication);
27648                 v(iE_Extensions);
27649
27650         };
27651         void clear()
27652         {
27653                 proSeDirectDiscovery.clear();
27654                 proSeDirectCommunication.clear();
27655                 iE_Extensions.clear();
27656
27657         };
27658         private:
27659         proSeDirectDiscovery_t  proSeDirectDiscovery;
27660         proSeDirectCommunication_t      proSeDirectCommunication;
27661         iE_Extensions_t iE_Extensions;
27662
27663 };
27664 /*
27665 ResourceType ::= ENUMERATED {
27666         downlinknonCRS,
27667         cRS,
27668         uplink,
27669         ...
27670 }
27671 */
27672
27673 struct ResourceType : asn::enumerated<3, 0, true>
27674 {
27675         static constexpr const char* name() {return "ResourceType";}
27676         using parent_t = asn::enumerated<3, 0, true>;
27677         typedef enum {
27678                 downlinknonCRS
27679                 ,cRS
27680                 ,uplink
27681         } index_t;
27682
27683 };
27684
27685 /*
27686 ProtectedFootprintTimePattern-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
27687         ...
27688 }
27689 */
27690
27691 struct ProtectedFootprintTimePattern_ExtIEs
27692 {
27693         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
27694         {
27695                 size_t get_index() const {return type;}
27696                 bool is_unknown() const { return type == 1; }
27697                 void clear() {type = 0;}
27698                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
27699                 template<typename V>  bool decode(V& v)
27700                 {
27701                         clear();
27702                         if(!v(ref_nested())) return false;
27703                         { type = 1; return true;}
27704                         return false;
27705
27706                 }
27707                 template<typename V> bool encode(V& v) const
27708                 {
27709                         return v(ref_nested());
27710
27711                 }
27712                 protected:
27713                 template<typename V>  bool decode(size_t index, V& v)
27714                 {
27715                         clear();
27716                         switch(index)
27717                         {
27718                         case 1: type = 1; return v(ref_nested());
27719                         ref_nested().clear();
27720                         }
27721                         return false;
27722
27723                 }
27724                 template<typename V> bool encode(size_t index, V& v) const
27725                 {
27726                         if(index != type) {return false;} return v(ref_nested());
27727
27728                 }
27729                 private:
27730                 size_t type {0};
27731
27732         };
27733         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
27734         {
27735                 size_t get_index() const {return type;}
27736                 bool is_unknown() const { return type == 1; }
27737                 void clear() {type = 0;}
27738                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
27739                 template<typename V>  bool decode(V& v)
27740                 {
27741                         clear();
27742                         if(!v(ref_nested())) return false;
27743                         { type = 1; return true;}
27744                         return false;
27745
27746                 }
27747                 template<typename V> bool encode(V& v) const
27748                 {
27749                         return v(ref_nested());
27750
27751                 }
27752                 protected:
27753                 template<typename V>  bool decode(size_t index, V& v)
27754                 {
27755                         clear();
27756                         switch(index)
27757                         {
27758                         case 1: type = 1; return v(ref_nested());
27759                         ref_nested().clear();
27760                         }
27761                         return false;
27762
27763                 }
27764                 template<typename V> bool encode(size_t index, V& v) const
27765                 {
27766                         if(index != type) {return false;} return v(ref_nested());
27767
27768                 }
27769                 private:
27770                 size_t type {0};
27771
27772         };
27773         struct Extension_t : asn::typefield<true>
27774         {
27775                 ~Extension_t()  {clear();}
27776                 size_t get_index() const {return type;}
27777                 bool is_unknown() const { return type == 1; }
27778                 void clear()
27779                 {
27780                         type = 0; ref_nested().clear();
27781                 }
27782                 template<typename V> static inline void enumerate(V& v)
27783                 {
27784
27785                 }
27786                 protected:
27787                 template<typename V> bool decode(size_t index, V& v)
27788                 {
27789                         clear();
27790                         switch(index)
27791                         {
27792                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
27793                         }
27794                         return false;
27795
27796                 }
27797                 template<typename V> bool encode(size_t index, V& v) const
27798                 {
27799                         if(index != type) return false;
27800                         return false;
27801
27802                 }
27803                 private:
27804                 size_t type {0};
27805
27806         };
27807         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
27808         {
27809                 size_t get_index() const {return type;}
27810                 bool is_unknown() const { return type == 1; }
27811                 void clear() {type = 0;}
27812                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
27813                 template<typename V>  bool decode(V& v)
27814                 {
27815                         clear();
27816                         if(!v(ref_nested())) return false;
27817                         { type = 1; return true;}
27818                         return false;
27819
27820                 }
27821                 template<typename V> bool encode(V& v) const
27822                 {
27823                         return v(ref_nested());
27824
27825                 }
27826                 protected:
27827                 template<typename V>  bool decode(size_t index, V& v)
27828                 {
27829                         clear();
27830                         switch(index)
27831                         {
27832                         case 1: type = 1; return v(ref_nested());
27833                         ref_nested().clear();
27834                         }
27835                         return false;
27836
27837                 }
27838                 template<typename V> bool encode(size_t index, V& v) const
27839                 {
27840                         if(index != type) {return false;} return v(ref_nested());
27841
27842                 }
27843                 private:
27844                 size_t type {0};
27845
27846         };
27847
27848 };
27849 /*
27850 ProtectedFootprintTimePattern ::= SEQUENCE {
27851         protectedFootprintTimePeriodicity                               INTEGER (1..320, ...),
27852         protectedFootprintStartTime                                             INTEGER (1..20, ...),
27853         iE-Extensions                                                                   ProtocolExtensionContainer { {ProtectedFootprintTimePattern-ExtIEs} }   OPTIONAL,
27854         ...
27855 }
27856 */
27857
27858 struct ProtectedFootprintTimePattern : asn::sequence<3, 0, true, 1>
27859 {
27860         static constexpr const char* name() {return "ProtectedFootprintTimePattern";}
27861         using parent_t = asn::sequence<3, 0, true, 1>;
27862         struct protectedFootprintTimePeriodicity_t : asn::integer<>
27863         {
27864                 using constraint_t = asn::constraints<true,asn::span<1, 320>>;
27865                 static constexpr const char* name() {return "protectedFootprintTimePeriodicity_t";}
27866                 using parent_t = asn::integer<>;
27867
27868         };
27869
27870         protectedFootprintTimePeriodicity_t& ref_protectedFootprintTimePeriodicity() {return protectedFootprintTimePeriodicity;}
27871         protectedFootprintTimePeriodicity_t const& ref_protectedFootprintTimePeriodicity() const {return protectedFootprintTimePeriodicity;}
27872         struct protectedFootprintStartTime_t : asn::integer<>
27873         {
27874                 using constraint_t = asn::constraints<true,asn::span<1, 20>>;
27875                 static constexpr const char* name() {return "protectedFootprintStartTime_t";}
27876                 using parent_t = asn::integer<>;
27877
27878         };
27879
27880         protectedFootprintStartTime_t& ref_protectedFootprintStartTime() {return protectedFootprintStartTime;}
27881         protectedFootprintStartTime_t const& ref_protectedFootprintStartTime() const {return protectedFootprintStartTime;}
27882         struct iE_Extensions_t : ProtocolExtensionContainer<ProtectedFootprintTimePattern_ExtIEs>
27883         {
27884                 static constexpr const char* name() {return "iE_Extensions_t";}
27885                 using parent_t = ProtocolExtensionContainer<ProtectedFootprintTimePattern_ExtIEs>;
27886                 static constexpr bool optional = true;
27887
27888         };
27889         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
27890         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
27891         template<typename V> void decode(V& v)
27892         {
27893                 v(protectedFootprintTimePeriodicity);
27894                 v(protectedFootprintStartTime);
27895                 v(iE_Extensions);
27896
27897         };
27898         template<typename V> void encode(V& v) const
27899         {
27900                 v(protectedFootprintTimePeriodicity);
27901                 v(protectedFootprintStartTime);
27902                 v(iE_Extensions);
27903
27904         };
27905         void clear()
27906         {
27907                 protectedFootprintTimePeriodicity.clear();
27908                 protectedFootprintStartTime.clear();
27909                 iE_Extensions.clear();
27910
27911         };
27912         private:
27913         protectedFootprintTimePeriodicity_t     protectedFootprintTimePeriodicity;
27914         protectedFootprintStartTime_t   protectedFootprintStartTime;
27915         iE_Extensions_t iE_Extensions;
27916
27917 };
27918 /*
27919 ProtectedResourceList-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
27920         ...
27921 }
27922 */
27923
27924 struct ProtectedResourceList_Item_ExtIEs
27925 {
27926         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
27927         {
27928                 size_t get_index() const {return type;}
27929                 bool is_unknown() const { return type == 1; }
27930                 void clear() {type = 0;}
27931                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
27932                 template<typename V>  bool decode(V& v)
27933                 {
27934                         clear();
27935                         if(!v(ref_nested())) return false;
27936                         { type = 1; return true;}
27937                         return false;
27938
27939                 }
27940                 template<typename V> bool encode(V& v) const
27941                 {
27942                         return v(ref_nested());
27943
27944                 }
27945                 protected:
27946                 template<typename V>  bool decode(size_t index, V& v)
27947                 {
27948                         clear();
27949                         switch(index)
27950                         {
27951                         case 1: type = 1; return v(ref_nested());
27952                         ref_nested().clear();
27953                         }
27954                         return false;
27955
27956                 }
27957                 template<typename V> bool encode(size_t index, V& v) const
27958                 {
27959                         if(index != type) {return false;} return v(ref_nested());
27960
27961                 }
27962                 private:
27963                 size_t type {0};
27964
27965         };
27966         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
27967         {
27968                 size_t get_index() const {return type;}
27969                 bool is_unknown() const { return type == 1; }
27970                 void clear() {type = 0;}
27971                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
27972                 template<typename V>  bool decode(V& v)
27973                 {
27974                         clear();
27975                         if(!v(ref_nested())) return false;
27976                         { type = 1; return true;}
27977                         return false;
27978
27979                 }
27980                 template<typename V> bool encode(V& v) const
27981                 {
27982                         return v(ref_nested());
27983
27984                 }
27985                 protected:
27986                 template<typename V>  bool decode(size_t index, V& v)
27987                 {
27988                         clear();
27989                         switch(index)
27990                         {
27991                         case 1: type = 1; return v(ref_nested());
27992                         ref_nested().clear();
27993                         }
27994                         return false;
27995
27996                 }
27997                 template<typename V> bool encode(size_t index, V& v) const
27998                 {
27999                         if(index != type) {return false;} return v(ref_nested());
28000
28001                 }
28002                 private:
28003                 size_t type {0};
28004
28005         };
28006         struct Extension_t : asn::typefield<true>
28007         {
28008                 ~Extension_t()  {clear();}
28009                 size_t get_index() const {return type;}
28010                 bool is_unknown() const { return type == 1; }
28011                 void clear()
28012                 {
28013                         type = 0; ref_nested().clear();
28014                 }
28015                 template<typename V> static inline void enumerate(V& v)
28016                 {
28017
28018                 }
28019                 protected:
28020                 template<typename V> bool decode(size_t index, V& v)
28021                 {
28022                         clear();
28023                         switch(index)
28024                         {
28025                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
28026                         }
28027                         return false;
28028
28029                 }
28030                 template<typename V> bool encode(size_t index, V& v) const
28031                 {
28032                         if(index != type) return false;
28033                         return false;
28034
28035                 }
28036                 private:
28037                 size_t type {0};
28038
28039         };
28040         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
28041         {
28042                 size_t get_index() const {return type;}
28043                 bool is_unknown() const { return type == 1; }
28044                 void clear() {type = 0;}
28045                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
28046                 template<typename V>  bool decode(V& v)
28047                 {
28048                         clear();
28049                         if(!v(ref_nested())) return false;
28050                         { type = 1; return true;}
28051                         return false;
28052
28053                 }
28054                 template<typename V> bool encode(V& v) const
28055                 {
28056                         return v(ref_nested());
28057
28058                 }
28059                 protected:
28060                 template<typename V>  bool decode(size_t index, V& v)
28061                 {
28062                         clear();
28063                         switch(index)
28064                         {
28065                         case 1: type = 1; return v(ref_nested());
28066                         ref_nested().clear();
28067                         }
28068                         return false;
28069
28070                 }
28071                 template<typename V> bool encode(size_t index, V& v) const
28072                 {
28073                         if(index != type) {return false;} return v(ref_nested());
28074
28075                 }
28076                 private:
28077                 size_t type {0};
28078
28079         };
28080
28081 };
28082 /*
28083 ProtectedResourceList-Item ::= SEQUENCE {
28084         resourceType                                    ResourceType,
28085         intraPRBProtectedResourceFootprint              BIT STRING (SIZE(84, ...)),
28086         protectedFootprintFrequencyPattern              BIT STRING (SIZE(6..110, ...)),
28087         protectedFootprintTimePattern                   ProtectedFootprintTimePattern,
28088         iE-Extensions                                                   ProtocolExtensionContainer { {ProtectedResourceList-Item-ExtIEs} }      OPTIONAL,
28089         ...
28090 }
28091 */
28092
28093 struct ProtectedResourceList_Item : asn::sequence<5, 0, true, 1>
28094 {
28095         static constexpr const char* name() {return "ProtectedResourceList-Item";}
28096         using parent_t = asn::sequence<5, 0, true, 1>;
28097         struct resourceType_t : ResourceType
28098         {
28099                 static constexpr const char* name() {return "resourceType_t";}
28100                 using parent_t = ResourceType;
28101
28102         };
28103         resourceType_t& ref_resourceType() {return resourceType;}
28104         resourceType_t const& ref_resourceType() const {return resourceType;}
28105         struct intraPRBProtectedResourceFootprint_t : asn::bstring<>
28106         {
28107                 using constraint_t = asn::constraints<true,asn::one<84>>;
28108                 static constexpr const char* name() {return "intraPRBProtectedResourceFootprint_t";}
28109                 using parent_t = asn::bstring<>;
28110
28111         };
28112
28113         intraPRBProtectedResourceFootprint_t& ref_intraPRBProtectedResourceFootprint() {return intraPRBProtectedResourceFootprint;}
28114         intraPRBProtectedResourceFootprint_t const& ref_intraPRBProtectedResourceFootprint() const {return intraPRBProtectedResourceFootprint;}
28115         struct protectedFootprintFrequencyPattern_t : asn::bstring<>
28116         {
28117                 using constraint_t = asn::constraints<true,asn::span<6, 110>>;
28118                 static constexpr const char* name() {return "protectedFootprintFrequencyPattern_t";}
28119                 using parent_t = asn::bstring<>;
28120
28121         };
28122
28123         protectedFootprintFrequencyPattern_t& ref_protectedFootprintFrequencyPattern() {return protectedFootprintFrequencyPattern;}
28124         protectedFootprintFrequencyPattern_t const& ref_protectedFootprintFrequencyPattern() const {return protectedFootprintFrequencyPattern;}
28125         struct protectedFootprintTimePattern_t : ProtectedFootprintTimePattern
28126         {
28127                 static constexpr const char* name() {return "protectedFootprintTimePattern_t";}
28128                 using parent_t = ProtectedFootprintTimePattern;
28129
28130         };
28131         protectedFootprintTimePattern_t& ref_protectedFootprintTimePattern() {return protectedFootprintTimePattern;}
28132         protectedFootprintTimePattern_t const& ref_protectedFootprintTimePattern() const {return protectedFootprintTimePattern;}
28133         struct iE_Extensions_t : ProtocolExtensionContainer<ProtectedResourceList_Item_ExtIEs>
28134         {
28135                 static constexpr const char* name() {return "iE_Extensions_t";}
28136                 using parent_t = ProtocolExtensionContainer<ProtectedResourceList_Item_ExtIEs>;
28137                 static constexpr bool optional = true;
28138
28139         };
28140         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
28141         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
28142         template<typename V> void decode(V& v)
28143         {
28144                 v(resourceType);
28145                 v(intraPRBProtectedResourceFootprint);
28146                 v(protectedFootprintFrequencyPattern);
28147                 v(protectedFootprintTimePattern);
28148                 v(iE_Extensions);
28149
28150         };
28151         template<typename V> void encode(V& v) const
28152         {
28153                 v(resourceType);
28154                 v(intraPRBProtectedResourceFootprint);
28155                 v(protectedFootprintFrequencyPattern);
28156                 v(protectedFootprintTimePattern);
28157                 v(iE_Extensions);
28158
28159         };
28160         void clear()
28161         {
28162                 resourceType.clear();
28163                 intraPRBProtectedResourceFootprint.clear();
28164                 protectedFootprintFrequencyPattern.clear();
28165                 protectedFootprintTimePattern.clear();
28166                 iE_Extensions.clear();
28167
28168         };
28169         private:
28170         resourceType_t  resourceType;
28171         intraPRBProtectedResourceFootprint_t    intraPRBProtectedResourceFootprint;
28172         protectedFootprintFrequencyPattern_t    protectedFootprintFrequencyPattern;
28173         protectedFootprintTimePattern_t protectedFootprintTimePattern;
28174         iE_Extensions_t iE_Extensions;
28175
28176 };
28177 /*
28178 ProtectedResourceList ::= SEQUENCE (SIZE(1.. maxnoofProtectedResourcePatterns)) OF ProtectedResourceList-Item
28179 */
28180
28181 struct ProtectedResourceList_elm : ProtectedResourceList_Item
28182 {
28183         static constexpr const char* name() {return "ProtectedResourceList_elm";}
28184         using parent_t = ProtectedResourceList_Item;
28185
28186 };
28187 struct ProtectedResourceList : asn::sequenceof<ProtectedResourceList_elm>
28188 {
28189         static constexpr const char* name() {return "ProtectedResourceList";}
28190         using parent_t = asn::sequenceof<ProtectedResourceList_elm>;
28191         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofProtectedResourcePatterns >>;
28192
28193 };
28194 /*
28195 ProtectedEUTRAResourceIndication-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
28196         ...
28197 } -- Rapporteur: missing extension --
28198 */
28199
28200 struct ProtectedEUTRAResourceIndication_ExtIEs
28201 {
28202         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
28203         {
28204                 size_t get_index() const {return type;}
28205                 bool is_unknown() const { return type == 1; }
28206                 void clear() {type = 0;}
28207                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
28208                 template<typename V>  bool decode(V& v)
28209                 {
28210                         clear();
28211                         if(!v(ref_nested())) return false;
28212                         { type = 1; return true;}
28213                         return false;
28214
28215                 }
28216                 template<typename V> bool encode(V& v) const
28217                 {
28218                         return v(ref_nested());
28219
28220                 }
28221                 protected:
28222                 template<typename V>  bool decode(size_t index, V& v)
28223                 {
28224                         clear();
28225                         switch(index)
28226                         {
28227                         case 1: type = 1; return v(ref_nested());
28228                         ref_nested().clear();
28229                         }
28230                         return false;
28231
28232                 }
28233                 template<typename V> bool encode(size_t index, V& v) const
28234                 {
28235                         if(index != type) {return false;} return v(ref_nested());
28236
28237                 }
28238                 private:
28239                 size_t type {0};
28240
28241         };
28242         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
28243         {
28244                 size_t get_index() const {return type;}
28245                 bool is_unknown() const { return type == 1; }
28246                 void clear() {type = 0;}
28247                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
28248                 template<typename V>  bool decode(V& v)
28249                 {
28250                         clear();
28251                         if(!v(ref_nested())) return false;
28252                         { type = 1; return true;}
28253                         return false;
28254
28255                 }
28256                 template<typename V> bool encode(V& v) const
28257                 {
28258                         return v(ref_nested());
28259
28260                 }
28261                 protected:
28262                 template<typename V>  bool decode(size_t index, V& v)
28263                 {
28264                         clear();
28265                         switch(index)
28266                         {
28267                         case 1: type = 1; return v(ref_nested());
28268                         ref_nested().clear();
28269                         }
28270                         return false;
28271
28272                 }
28273                 template<typename V> bool encode(size_t index, V& v) const
28274                 {
28275                         if(index != type) {return false;} return v(ref_nested());
28276
28277                 }
28278                 private:
28279                 size_t type {0};
28280
28281         };
28282         struct Extension_t : asn::typefield<true>
28283         {
28284                 ~Extension_t()  {clear();}
28285                 size_t get_index() const {return type;}
28286                 bool is_unknown() const { return type == 1; }
28287                 void clear()
28288                 {
28289                         type = 0; ref_nested().clear();
28290                 }
28291                 template<typename V> static inline void enumerate(V& v)
28292                 {
28293
28294                 }
28295                 protected:
28296                 template<typename V> bool decode(size_t index, V& v)
28297                 {
28298                         clear();
28299                         switch(index)
28300                         {
28301                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
28302                         }
28303                         return false;
28304
28305                 }
28306                 template<typename V> bool encode(size_t index, V& v) const
28307                 {
28308                         if(index != type) return false;
28309                         return false;
28310
28311                 }
28312                 private:
28313                 size_t type {0};
28314
28315         };
28316         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
28317         {
28318                 size_t get_index() const {return type;}
28319                 bool is_unknown() const { return type == 1; }
28320                 void clear() {type = 0;}
28321                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
28322                 template<typename V>  bool decode(V& v)
28323                 {
28324                         clear();
28325                         if(!v(ref_nested())) return false;
28326                         { type = 1; return true;}
28327                         return false;
28328
28329                 }
28330                 template<typename V> bool encode(V& v) const
28331                 {
28332                         return v(ref_nested());
28333
28334                 }
28335                 protected:
28336                 template<typename V>  bool decode(size_t index, V& v)
28337                 {
28338                         clear();
28339                         switch(index)
28340                         {
28341                         case 1: type = 1; return v(ref_nested());
28342                         ref_nested().clear();
28343                         }
28344                         return false;
28345
28346                 }
28347                 template<typename V> bool encode(size_t index, V& v) const
28348                 {
28349                         if(index != type) {return false;} return v(ref_nested());
28350
28351                 }
28352                 private:
28353                 size_t type {0};
28354
28355         };
28356
28357 };
28358 /*
28359 ProtectedEUTRAResourceIndication::= SEQUENCE {
28360         activationSFN                                                   INTEGER (0..1023),
28361         protectedResourceList                                   ProtectedResourceList,
28362         mBSFNControlRegionLength                                INTEGER (0..3) OPTIONAL,
28363         pDCCHRegionLength                                               INTEGER (1..3) OPTIONAL,
28364         iE-Extensions                                                   ProtocolExtensionContainer { {ProtectedEUTRAResourceIndication-ExtIEs} }        OPTIONAL,
28365         ...
28366 }
28367 */
28368
28369 struct ProtectedEUTRAResourceIndication : asn::sequence<5, 0, true, 3>
28370 {
28371         static constexpr const char* name() {return "ProtectedEUTRAResourceIndication";}
28372         using parent_t = asn::sequence<5, 0, true, 3>;
28373         struct activationSFN_t : asn::integer<>
28374         {
28375                 using constraint_t = asn::constraints<false,asn::span<0, 1023>>;
28376                 static constexpr const char* name() {return "activationSFN_t";}
28377                 using parent_t = asn::integer<>;
28378
28379         };
28380
28381         activationSFN_t& ref_activationSFN() {return activationSFN;}
28382         activationSFN_t const& ref_activationSFN() const {return activationSFN;}
28383         struct protectedResourceList_t : ProtectedResourceList
28384         {
28385                 static constexpr const char* name() {return "protectedResourceList_t";}
28386                 using parent_t = ProtectedResourceList;
28387
28388         };
28389         protectedResourceList_t& ref_protectedResourceList() {return protectedResourceList;}
28390         protectedResourceList_t const& ref_protectedResourceList() const {return protectedResourceList;}
28391         struct mBSFNControlRegionLength_t : asn::integer<>
28392         {
28393                 using constraint_t = asn::constraints<false,asn::span<0, 3>>;
28394                 static constexpr const char* name() {return "mBSFNControlRegionLength_t";}
28395                 using parent_t = asn::integer<>;
28396                 static constexpr bool optional = true;
28397
28398         };
28399
28400         mBSFNControlRegionLength_t& set_mBSFNControlRegionLength() { mBSFNControlRegionLength.setpresent(true); return mBSFNControlRegionLength;}
28401         mBSFNControlRegionLength_t const* get_mBSFNControlRegionLength() const {return mBSFNControlRegionLength.is_valid() ? &mBSFNControlRegionLength : nullptr;}
28402         struct pDCCHRegionLength_t : asn::integer<>
28403         {
28404                 using constraint_t = asn::constraints<false,asn::span<1, 3>>;
28405                 static constexpr const char* name() {return "pDCCHRegionLength_t";}
28406                 using parent_t = asn::integer<>;
28407                 static constexpr bool optional = true;
28408
28409         };
28410
28411         pDCCHRegionLength_t& set_pDCCHRegionLength() { pDCCHRegionLength.setpresent(true); return pDCCHRegionLength;}
28412         pDCCHRegionLength_t const* get_pDCCHRegionLength() const {return pDCCHRegionLength.is_valid() ? &pDCCHRegionLength : nullptr;}
28413         struct iE_Extensions_t : ProtocolExtensionContainer<ProtectedEUTRAResourceIndication_ExtIEs>
28414         {
28415                 static constexpr const char* name() {return "iE_Extensions_t";}
28416                 using parent_t = ProtocolExtensionContainer<ProtectedEUTRAResourceIndication_ExtIEs>;
28417                 static constexpr bool optional = true;
28418
28419         };
28420         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
28421         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
28422         template<typename V> void decode(V& v)
28423         {
28424                 v(activationSFN);
28425                 v(protectedResourceList);
28426                 v(mBSFNControlRegionLength);
28427                 v(pDCCHRegionLength);
28428                 v(iE_Extensions);
28429
28430         };
28431         template<typename V> void encode(V& v) const
28432         {
28433                 v(activationSFN);
28434                 v(protectedResourceList);
28435                 v(mBSFNControlRegionLength);
28436                 v(pDCCHRegionLength);
28437                 v(iE_Extensions);
28438
28439         };
28440         void clear()
28441         {
28442                 activationSFN.clear();
28443                 protectedResourceList.clear();
28444                 mBSFNControlRegionLength.clear();
28445                 pDCCHRegionLength.clear();
28446                 iE_Extensions.clear();
28447
28448         };
28449         private:
28450         activationSFN_t activationSFN;
28451         protectedResourceList_t protectedResourceList;
28452         mBSFNControlRegionLength_t      mBSFNControlRegionLength;
28453         pDCCHRegionLength_t     pDCCHRegionLength;
28454         iE_Extensions_t iE_Extensions;
28455
28456 };
28457 /*
28458 Reestablishment-Indication ::= ENUMERATED {
28459         reestablished,
28460         ...
28461 }
28462 */
28463
28464 struct Reestablishment_Indication : asn::enumerated<1, 0, true>
28465 {
28466         static constexpr const char* name() {return "Reestablishment-Indication";}
28467         using parent_t = asn::enumerated<1, 0, true>;
28468         typedef enum {
28469                 reestablished
28470         } index_t;
28471
28472 };
28473
28474 /*
28475 RLC-Status-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
28476         ...
28477 }
28478 */
28479
28480 struct RLC_Status_ExtIEs
28481 {
28482         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
28483         {
28484                 size_t get_index() const {return type;}
28485                 bool is_unknown() const { return type == 1; }
28486                 void clear() {type = 0;}
28487                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
28488                 template<typename V>  bool decode(V& v)
28489                 {
28490                         clear();
28491                         if(!v(ref_nested())) return false;
28492                         { type = 1; return true;}
28493                         return false;
28494
28495                 }
28496                 template<typename V> bool encode(V& v) const
28497                 {
28498                         return v(ref_nested());
28499
28500                 }
28501                 protected:
28502                 template<typename V>  bool decode(size_t index, V& v)
28503                 {
28504                         clear();
28505                         switch(index)
28506                         {
28507                         case 1: type = 1; return v(ref_nested());
28508                         ref_nested().clear();
28509                         }
28510                         return false;
28511
28512                 }
28513                 template<typename V> bool encode(size_t index, V& v) const
28514                 {
28515                         if(index != type) {return false;} return v(ref_nested());
28516
28517                 }
28518                 private:
28519                 size_t type {0};
28520
28521         };
28522         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
28523         {
28524                 size_t get_index() const {return type;}
28525                 bool is_unknown() const { return type == 1; }
28526                 void clear() {type = 0;}
28527                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
28528                 template<typename V>  bool decode(V& v)
28529                 {
28530                         clear();
28531                         if(!v(ref_nested())) return false;
28532                         { type = 1; return true;}
28533                         return false;
28534
28535                 }
28536                 template<typename V> bool encode(V& v) const
28537                 {
28538                         return v(ref_nested());
28539
28540                 }
28541                 protected:
28542                 template<typename V>  bool decode(size_t index, V& v)
28543                 {
28544                         clear();
28545                         switch(index)
28546                         {
28547                         case 1: type = 1; return v(ref_nested());
28548                         ref_nested().clear();
28549                         }
28550                         return false;
28551
28552                 }
28553                 template<typename V> bool encode(size_t index, V& v) const
28554                 {
28555                         if(index != type) {return false;} return v(ref_nested());
28556
28557                 }
28558                 private:
28559                 size_t type {0};
28560
28561         };
28562         struct Extension_t : asn::typefield<true>
28563         {
28564                 ~Extension_t()  {clear();}
28565                 size_t get_index() const {return type;}
28566                 bool is_unknown() const { return type == 1; }
28567                 void clear()
28568                 {
28569                         type = 0; ref_nested().clear();
28570                 }
28571                 template<typename V> static inline void enumerate(V& v)
28572                 {
28573
28574                 }
28575                 protected:
28576                 template<typename V> bool decode(size_t index, V& v)
28577                 {
28578                         clear();
28579                         switch(index)
28580                         {
28581                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
28582                         }
28583                         return false;
28584
28585                 }
28586                 template<typename V> bool encode(size_t index, V& v) const
28587                 {
28588                         if(index != type) return false;
28589                         return false;
28590
28591                 }
28592                 private:
28593                 size_t type {0};
28594
28595         };
28596         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
28597         {
28598                 size_t get_index() const {return type;}
28599                 bool is_unknown() const { return type == 1; }
28600                 void clear() {type = 0;}
28601                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
28602                 template<typename V>  bool decode(V& v)
28603                 {
28604                         clear();
28605                         if(!v(ref_nested())) return false;
28606                         { type = 1; return true;}
28607                         return false;
28608
28609                 }
28610                 template<typename V> bool encode(V& v) const
28611                 {
28612                         return v(ref_nested());
28613
28614                 }
28615                 protected:
28616                 template<typename V>  bool decode(size_t index, V& v)
28617                 {
28618                         clear();
28619                         switch(index)
28620                         {
28621                         case 1: type = 1; return v(ref_nested());
28622                         ref_nested().clear();
28623                         }
28624                         return false;
28625
28626                 }
28627                 template<typename V> bool encode(size_t index, V& v) const
28628                 {
28629                         if(index != type) {return false;} return v(ref_nested());
28630
28631                 }
28632                 private:
28633                 size_t type {0};
28634
28635         };
28636
28637 };
28638 /*
28639 RLC-Status ::= SEQUENCE {
28640         reestablishment-Indication      Reestablishment-Indication,
28641         iE-Extensions                           ProtocolExtensionContainer { {RLC-Status-ExtIEs} } OPTIONAL,
28642         ...
28643 }
28644 */
28645
28646 struct RLC_Status : asn::sequence<2, 0, true, 1>
28647 {
28648         static constexpr const char* name() {return "RLC-Status";}
28649         using parent_t = asn::sequence<2, 0, true, 1>;
28650         struct reestablishment_Indication_t : Reestablishment_Indication
28651         {
28652                 static constexpr const char* name() {return "reestablishment_Indication_t";}
28653                 using parent_t = Reestablishment_Indication;
28654
28655         };
28656         reestablishment_Indication_t& ref_reestablishment_Indication() {return reestablishment_Indication;}
28657         reestablishment_Indication_t const& ref_reestablishment_Indication() const {return reestablishment_Indication;}
28658         struct iE_Extensions_t : ProtocolExtensionContainer<RLC_Status_ExtIEs>
28659         {
28660                 static constexpr const char* name() {return "iE_Extensions_t";}
28661                 using parent_t = ProtocolExtensionContainer<RLC_Status_ExtIEs>;
28662                 static constexpr bool optional = true;
28663
28664         };
28665         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
28666         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
28667         template<typename V> void decode(V& v)
28668         {
28669                 v(reestablishment_Indication);
28670                 v(iE_Extensions);
28671
28672         };
28673         template<typename V> void encode(V& v) const
28674         {
28675                 v(reestablishment_Indication);
28676                 v(iE_Extensions);
28677
28678         };
28679         void clear()
28680         {
28681                 reestablishment_Indication.clear();
28682                 iE_Extensions.clear();
28683
28684         };
28685         private:
28686         reestablishment_Indication_t    reestablishment_Indication;
28687         iE_Extensions_t iE_Extensions;
28688
28689 };
28690 /*
28691 RLCMode ::= ENUMERATED {
28692         rlc-am,
28693         rlc-um-bidirectional,
28694         rlc-um-unidirectional-ul,
28695         rlc-um-unidirectional-dl,
28696         ...
28697 }
28698 */
28699
28700 struct RLCMode : asn::enumerated<4, 0, true>
28701 {
28702         static constexpr const char* name() {return "RLCMode";}
28703         using parent_t = asn::enumerated<4, 0, true>;
28704         typedef enum {
28705                 rlc_am
28706                 ,rlc_um_bidirectional
28707                 ,rlc_um_unidirectional_ul
28708                 ,rlc_um_unidirectional_dl
28709         } index_t;
28710
28711 };
28712
28713 /*
28714 RRC-Config-Ind ::= ENUMERATED {
28715         full-config,
28716         delta-config,
28717         ...
28718 }
28719 */
28720
28721 struct RRC_Config_Ind : asn::enumerated<2, 0, true>
28722 {
28723         static constexpr const char* name() {return "RRC-Config-Ind";}
28724         using parent_t = asn::enumerated<2, 0, true>;
28725         typedef enum {
28726                 full_config
28727                 ,delta_config
28728         } index_t;
28729
28730 };
28731
28732 /*
28733 RRC-Context ::= OCTET STRING
28734 */
28735
28736 struct RRC_Context : asn::ostring<>
28737 {
28738         static constexpr const char* name() {return "RRC-Context";}
28739         using parent_t = asn::ostring<>;
28740
28741 };
28742
28743 /*
28744 RRCConnReestabIndicator ::= ENUMERATED {
28745         reconfigurationFailure, handoverFailure, otherFailure, ...
28746 }
28747 */
28748
28749 struct RRCConnReestabIndicator : asn::enumerated<3, 0, true>
28750 {
28751         static constexpr const char* name() {return "RRCConnReestabIndicator";}
28752         using parent_t = asn::enumerated<3, 0, true>;
28753         typedef enum {
28754                 reconfigurationFailure
28755                 ,handoverFailure
28756                 ,otherFailure
28757         } index_t;
28758
28759 };
28760
28761 /*
28762 RRCConnSetupIndicator::= ENUMERATED {
28763         rrcConnSetup,
28764         ...
28765 }
28766 */
28767
28768 struct RRCConnSetupIndicator : asn::enumerated<1, 0, true>
28769 {
28770         static constexpr const char* name() {return "RRCConnSetupIndicator";}
28771         using parent_t = asn::enumerated<1, 0, true>;
28772         typedef enum {
28773                 rrcConnSetup
28774         } index_t;
28775
28776 };
28777
28778 /*
28779 RRCContainer ::= OCTET STRING
28780 */
28781
28782 struct RRCContainer : asn::ostring<>
28783 {
28784         static constexpr const char* name() {return "RRCContainer";}
28785         using parent_t = asn::ostring<>;
28786
28787 };
28788
28789 /*
28790 RSRPMeasurementResult-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
28791         ...
28792 }
28793 */
28794
28795 struct RSRPMeasurementResult_ExtIEs
28796 {
28797         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
28798         {
28799                 size_t get_index() const {return type;}
28800                 bool is_unknown() const { return type == 1; }
28801                 void clear() {type = 0;}
28802                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
28803                 template<typename V>  bool decode(V& v)
28804                 {
28805                         clear();
28806                         if(!v(ref_nested())) return false;
28807                         { type = 1; return true;}
28808                         return false;
28809
28810                 }
28811                 template<typename V> bool encode(V& v) const
28812                 {
28813                         return v(ref_nested());
28814
28815                 }
28816                 protected:
28817                 template<typename V>  bool decode(size_t index, V& v)
28818                 {
28819                         clear();
28820                         switch(index)
28821                         {
28822                         case 1: type = 1; return v(ref_nested());
28823                         ref_nested().clear();
28824                         }
28825                         return false;
28826
28827                 }
28828                 template<typename V> bool encode(size_t index, V& v) const
28829                 {
28830                         if(index != type) {return false;} return v(ref_nested());
28831
28832                 }
28833                 private:
28834                 size_t type {0};
28835
28836         };
28837         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
28838         {
28839                 size_t get_index() const {return type;}
28840                 bool is_unknown() const { return type == 1; }
28841                 void clear() {type = 0;}
28842                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
28843                 template<typename V>  bool decode(V& v)
28844                 {
28845                         clear();
28846                         if(!v(ref_nested())) return false;
28847                         { type = 1; return true;}
28848                         return false;
28849
28850                 }
28851                 template<typename V> bool encode(V& v) const
28852                 {
28853                         return v(ref_nested());
28854
28855                 }
28856                 protected:
28857                 template<typename V>  bool decode(size_t index, V& v)
28858                 {
28859                         clear();
28860                         switch(index)
28861                         {
28862                         case 1: type = 1; return v(ref_nested());
28863                         ref_nested().clear();
28864                         }
28865                         return false;
28866
28867                 }
28868                 template<typename V> bool encode(size_t index, V& v) const
28869                 {
28870                         if(index != type) {return false;} return v(ref_nested());
28871
28872                 }
28873                 private:
28874                 size_t type {0};
28875
28876         };
28877         struct Extension_t : asn::typefield<true>
28878         {
28879                 ~Extension_t()  {clear();}
28880                 size_t get_index() const {return type;}
28881                 bool is_unknown() const { return type == 1; }
28882                 void clear()
28883                 {
28884                         type = 0; ref_nested().clear();
28885                 }
28886                 template<typename V> static inline void enumerate(V& v)
28887                 {
28888
28889                 }
28890                 protected:
28891                 template<typename V> bool decode(size_t index, V& v)
28892                 {
28893                         clear();
28894                         switch(index)
28895                         {
28896                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
28897                         }
28898                         return false;
28899
28900                 }
28901                 template<typename V> bool encode(size_t index, V& v) const
28902                 {
28903                         if(index != type) return false;
28904                         return false;
28905
28906                 }
28907                 private:
28908                 size_t type {0};
28909
28910         };
28911         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
28912         {
28913                 size_t get_index() const {return type;}
28914                 bool is_unknown() const { return type == 1; }
28915                 void clear() {type = 0;}
28916                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
28917                 template<typename V>  bool decode(V& v)
28918                 {
28919                         clear();
28920                         if(!v(ref_nested())) return false;
28921                         { type = 1; return true;}
28922                         return false;
28923
28924                 }
28925                 template<typename V> bool encode(V& v) const
28926                 {
28927                         return v(ref_nested());
28928
28929                 }
28930                 protected:
28931                 template<typename V>  bool decode(size_t index, V& v)
28932                 {
28933                         clear();
28934                         switch(index)
28935                         {
28936                         case 1: type = 1; return v(ref_nested());
28937                         ref_nested().clear();
28938                         }
28939                         return false;
28940
28941                 }
28942                 template<typename V> bool encode(size_t index, V& v) const
28943                 {
28944                         if(index != type) {return false;} return v(ref_nested());
28945
28946                 }
28947                 private:
28948                 size_t type {0};
28949
28950         };
28951
28952 };
28953 /*
28954 RSRPMeasurementResult ::= SEQUENCE (SIZE(1..maxCellReport)) OF
28955         SEQUENCE {
28956                 rSRPCellID                                              ECGI,
28957                 rSRPMeasured                                    INTEGER (0..97, ...),
28958                 iE-Extensions                                   ProtocolExtensionContainer { {RSRPMeasurementResult-ExtIEs} } OPTIONAL,
28959                 ...
28960         }
28961 */
28962
28963 struct RSRPMeasurementResult_elm : asn::sequence<3, 0, true, 1>
28964 {
28965         static constexpr const char* name() {return "RSRPMeasurementResult_elm";}
28966         using parent_t = asn::sequence<3, 0, true, 1>;
28967         struct rSRPCellID_t : ECGI
28968         {
28969                 static constexpr const char* name() {return "rSRPCellID_t";}
28970                 using parent_t = ECGI;
28971
28972         };
28973         rSRPCellID_t& ref_rSRPCellID() {return rSRPCellID;}
28974         rSRPCellID_t const& ref_rSRPCellID() const {return rSRPCellID;}
28975         struct rSRPMeasured_t : asn::integer<>
28976         {
28977                 using constraint_t = asn::constraints<true,asn::span<0, 97>>;
28978                 static constexpr const char* name() {return "rSRPMeasured_t";}
28979                 using parent_t = asn::integer<>;
28980
28981         };
28982
28983         rSRPMeasured_t& ref_rSRPMeasured() {return rSRPMeasured;}
28984         rSRPMeasured_t const& ref_rSRPMeasured() const {return rSRPMeasured;}
28985         struct iE_Extensions_t : ProtocolExtensionContainer<RSRPMeasurementResult_ExtIEs>
28986         {
28987                 static constexpr const char* name() {return "iE_Extensions_t";}
28988                 using parent_t = ProtocolExtensionContainer<RSRPMeasurementResult_ExtIEs>;
28989                 static constexpr bool optional = true;
28990
28991         };
28992         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
28993         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
28994         template<typename V> void decode(V& v)
28995         {
28996                 v(rSRPCellID);
28997                 v(rSRPMeasured);
28998                 v(iE_Extensions);
28999
29000         };
29001         template<typename V> void encode(V& v) const
29002         {
29003                 v(rSRPCellID);
29004                 v(rSRPMeasured);
29005                 v(iE_Extensions);
29006
29007         };
29008         void clear()
29009         {
29010                 rSRPCellID.clear();
29011                 rSRPMeasured.clear();
29012                 iE_Extensions.clear();
29013
29014         };
29015         private:
29016         rSRPCellID_t    rSRPCellID;
29017         rSRPMeasured_t  rSRPMeasured;
29018         iE_Extensions_t iE_Extensions;
29019
29020 };
29021 struct RSRPMeasurementResult : asn::sequenceof<RSRPMeasurementResult_elm>
29022 {
29023         static constexpr const char* name() {return "RSRPMeasurementResult";}
29024         using parent_t = asn::sequenceof<RSRPMeasurementResult_elm>;
29025         using constraint_t = asn::constraints<false,asn::span<1,  maxCellReport >>;
29026
29027 };
29028 /*
29029 RSRPMRList-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
29030         { ID id-UEID    CRITICALITY ignore      EXTENSION UEID          PRESENCE optional},
29031         ...
29032 }
29033 */
29034
29035 struct RSRPMRList_ExtIEs
29036 {
29037         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
29038         {
29039                 size_t get_index() const {return type;}
29040                 bool is_unknown() const { return type == 2; }
29041                 void clear() {type = 0;}
29042                 void select_id_UEID() { set(id_UEID); type=1;}
29043                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
29044                 template<typename V>  bool decode(V& v)
29045                 {
29046                         clear();
29047                         if(!v(ref_nested())) return false;
29048                         if(equal(id_UEID)) { type = 1; return true; }
29049                         else { type = 2; return true;}
29050                         return false;
29051
29052                 }
29053                 template<typename V> bool encode(V& v) const
29054                 {
29055                         return v(ref_nested());
29056
29057                 }
29058                 protected:
29059                 template<typename V>  bool decode(size_t index, V& v)
29060                 {
29061                         clear();
29062                         switch(index)
29063                         {
29064                         case 1: type = 1; if(v(ref_nested())) { return equal(id_UEID);} return false;
29065                         case 2: type = 2; return v(ref_nested());
29066                         ref_nested().clear();
29067                         }
29068                         return false;
29069
29070                 }
29071                 template<typename V> bool encode(size_t index, V& v) const
29072                 {
29073                         if(index != type) {return false;} return v(ref_nested());
29074
29075                 }
29076                 private:
29077                 size_t type {0};
29078
29079         };
29080         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
29081         {
29082                 size_t get_index() const {return type;}
29083                 bool is_unknown() const { return type == 2; }
29084                 void clear() {type = 0;}
29085                 void select_id_UEID() { set(ignore); type=1;}
29086                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
29087                 template<typename V>  bool decode(V& v)
29088                 {
29089                         clear();
29090                         if(!v(ref_nested())) return false;
29091                         if(equal(ignore)) { type = 1; return true; }
29092                         else { type = 2; return true;}
29093                         return false;
29094
29095                 }
29096                 template<typename V> bool encode(V& v) const
29097                 {
29098                         return v(ref_nested());
29099
29100                 }
29101                 protected:
29102                 template<typename V>  bool decode(size_t index, V& v)
29103                 {
29104                         clear();
29105                         switch(index)
29106                         {
29107                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
29108                         case 2: type = 2; return v(ref_nested());
29109                         ref_nested().clear();
29110                         }
29111                         return false;
29112
29113                 }
29114                 template<typename V> bool encode(size_t index, V& v) const
29115                 {
29116                         if(index != type) {return false;} return v(ref_nested());
29117
29118                 }
29119                 private:
29120                 size_t type {0};
29121
29122         };
29123         struct Extension_t : asn::typefield<true>
29124         {
29125                 ~Extension_t()  {clear();}
29126                 size_t get_index() const {return type;}
29127                 UEID& select_id_UEID() { return set<UEID>(1); }
29128                 UEID const* get_id_UEID() const { return get<UEID>(1); }
29129                 bool is_unknown() const { return type == 2; }
29130                 void clear()
29131                 {
29132                         switch(type)
29133                         {
29134                         case 1: var.destroy<UEID>(); break;
29135                         }
29136                         type = 0; ref_nested().clear();
29137                 }
29138                 template<typename V> static inline void enumerate(V& v)
29139                 {
29140                         v.template operator()<UEID>(1);
29141
29142                 }
29143                 protected:
29144                 template<typename V> bool decode(size_t index, V& v)
29145                 {
29146                         clear();
29147                         switch(index)
29148                         {
29149                         case 1: v(select_id_UEID()); return true;
29150                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
29151                         }
29152                         return false;
29153
29154                 }
29155                 template<typename V> bool encode(size_t index, V& v) const
29156                 {
29157                         if(index != type) return false;
29158                         switch(type)
29159                         {
29160                         case 1: v(var.as<UEID>()); return true;
29161                         }
29162                         return false;
29163
29164                 }
29165                 private:
29166                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
29167                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
29168                 union union_type
29169                 {
29170                         char dummy1[sizeof(UEID)];
29171
29172                 };
29173                 asn::variant<sizeof(union_type)> var;
29174                 size_t type {0};
29175
29176         };
29177         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
29178         {
29179                 size_t get_index() const {return type;}
29180                 bool is_unknown() const { return type == 2; }
29181                 void clear() {type = 0;}
29182                 void select_id_UEID() { set(optional); type=1;}
29183                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
29184                 template<typename V>  bool decode(V& v)
29185                 {
29186                         clear();
29187                         if(!v(ref_nested())) return false;
29188                         if(equal(optional)) { type = 1; return true; }
29189                         else { type = 2; return true;}
29190                         return false;
29191
29192                 }
29193                 template<typename V> bool encode(V& v) const
29194                 {
29195                         return v(ref_nested());
29196
29197                 }
29198                 protected:
29199                 template<typename V>  bool decode(size_t index, V& v)
29200                 {
29201                         clear();
29202                         switch(index)
29203                         {
29204                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
29205                         case 2: type = 2; return v(ref_nested());
29206                         ref_nested().clear();
29207                         }
29208                         return false;
29209
29210                 }
29211                 template<typename V> bool encode(size_t index, V& v) const
29212                 {
29213                         if(index != type) {return false;} return v(ref_nested());
29214
29215                 }
29216                 private:
29217                 size_t type {0};
29218
29219         };
29220
29221 };
29222 /*
29223 RSRPMRList ::= SEQUENCE (SIZE(1..maxUEReport)) OF
29224         SEQUENCE {
29225                 rSRPMeasurementResult                   RSRPMeasurementResult,
29226                 iE-Extensions                                   ProtocolExtensionContainer { {RSRPMRList-ExtIEs} } OPTIONAL,
29227                 ...
29228         }
29229 */
29230
29231 struct RSRPMRList_elm : asn::sequence<2, 0, true, 1>
29232 {
29233         static constexpr const char* name() {return "RSRPMRList_elm";}
29234         using parent_t = asn::sequence<2, 0, true, 1>;
29235         struct rSRPMeasurementResult_t : RSRPMeasurementResult
29236         {
29237                 static constexpr const char* name() {return "rSRPMeasurementResult_t";}
29238                 using parent_t = RSRPMeasurementResult;
29239
29240         };
29241         rSRPMeasurementResult_t& ref_rSRPMeasurementResult() {return rSRPMeasurementResult;}
29242         rSRPMeasurementResult_t const& ref_rSRPMeasurementResult() const {return rSRPMeasurementResult;}
29243         struct iE_Extensions_t : ProtocolExtensionContainer<RSRPMRList_ExtIEs>
29244         {
29245                 static constexpr const char* name() {return "iE_Extensions_t";}
29246                 using parent_t = ProtocolExtensionContainer<RSRPMRList_ExtIEs>;
29247                 static constexpr bool optional = true;
29248
29249         };
29250         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
29251         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
29252         template<typename V> void decode(V& v)
29253         {
29254                 v(rSRPMeasurementResult);
29255                 v(iE_Extensions);
29256
29257         };
29258         template<typename V> void encode(V& v) const
29259         {
29260                 v(rSRPMeasurementResult);
29261                 v(iE_Extensions);
29262
29263         };
29264         void clear()
29265         {
29266                 rSRPMeasurementResult.clear();
29267                 iE_Extensions.clear();
29268
29269         };
29270         private:
29271         rSRPMeasurementResult_t rSRPMeasurementResult;
29272         iE_Extensions_t iE_Extensions;
29273
29274 };
29275 struct RSRPMRList : asn::sequenceof<RSRPMRList_elm>
29276 {
29277         static constexpr const char* name() {return "RSRPMRList";}
29278         using parent_t = asn::sequenceof<RSRPMRList_elm>;
29279         using constraint_t = asn::constraints<false,asn::span<1,  maxUEReport >>;
29280
29281 };
29282 /*
29283 UL-GBR-PRB-usage::= INTEGER (0..100)
29284 */
29285
29286 struct UL_GBR_PRB_usage : asn::integer<>
29287 {
29288         using constraint_t = asn::constraints<false,asn::span<0, 100>>;
29289         static constexpr const char* name() {return "UL-GBR-PRB-usage";}
29290         using parent_t = asn::integer<>;
29291
29292 };
29293
29294 /*
29295 UL-non-GBR-PRB-usage::= INTEGER (0..100)
29296 */
29297
29298 struct UL_non_GBR_PRB_usage : asn::integer<>
29299 {
29300         using constraint_t = asn::constraints<false,asn::span<0, 100>>;
29301         static constexpr const char* name() {return "UL-non-GBR-PRB-usage";}
29302         using parent_t = asn::integer<>;
29303
29304 };
29305
29306 /*
29307 UL-Total-PRB-usage::= INTEGER (0..100)
29308 */
29309
29310 struct UL_Total_PRB_usage : asn::integer<>
29311 {
29312         using constraint_t = asn::constraints<false,asn::span<0, 100>>;
29313         static constexpr const char* name() {return "UL-Total-PRB-usage";}
29314         using parent_t = asn::integer<>;
29315
29316 };
29317
29318 /*
29319 UL-scheduling-PDCCH-CCE-usage::= INTEGER (0..100)
29320 */
29321
29322 struct UL_scheduling_PDCCH_CCE_usage : asn::integer<>
29323 {
29324         using constraint_t = asn::constraints<false,asn::span<0, 100>>;
29325         static constexpr const char* name() {return "UL-scheduling-PDCCH-CCE-usage";}
29326         using parent_t = asn::integer<>;
29327
29328 };
29329
29330 /*
29331 RadioResourceStatus-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
29332         {ID id-DL-scheduling-PDCCH-CCE-usage            CRITICALITY ignore      EXTENSION DL-scheduling-PDCCH-CCE-usage         PRESENCE optional}|
29333
29334         {ID id-UL-scheduling-PDCCH-CCE-usage            CRITICALITY ignore      EXTENSION UL-scheduling-PDCCH-CCE-usage         PRESENCE optional},
29335         ...
29336 }
29337 */
29338
29339 struct RadioResourceStatus_ExtIEs
29340 {
29341         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
29342         {
29343                 size_t get_index() const {return type;}
29344                 bool is_unknown() const { return type == 3; }
29345                 void clear() {type = 0;}
29346                 void select_id_DL_scheduling_PDCCH_CCE_usage() { set(id_DL_scheduling_PDCCH_CCE_usage); type=1;}
29347                 void select_id_UL_scheduling_PDCCH_CCE_usage() { set(id_UL_scheduling_PDCCH_CCE_usage); type=2;}
29348                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
29349                 template<typename V>  bool decode(V& v)
29350                 {
29351                         clear();
29352                         if(!v(ref_nested())) return false;
29353                         if(equal(id_DL_scheduling_PDCCH_CCE_usage)) { type = 1; return true; }
29354                         else if(equal(id_UL_scheduling_PDCCH_CCE_usage)) { type = 2; return true; }
29355                         else { type = 3; return true;}
29356                         return false;
29357
29358                 }
29359                 template<typename V> bool encode(V& v) const
29360                 {
29361                         return v(ref_nested());
29362
29363                 }
29364                 protected:
29365                 template<typename V>  bool decode(size_t index, V& v)
29366                 {
29367                         clear();
29368                         switch(index)
29369                         {
29370                         case 1: type = 1; if(v(ref_nested())) { return equal(id_DL_scheduling_PDCCH_CCE_usage);} return false;
29371                         case 2: type = 2; if(v(ref_nested())) { return equal(id_UL_scheduling_PDCCH_CCE_usage);} return false;
29372                         case 3: type = 3; return v(ref_nested());
29373                         ref_nested().clear();
29374                         }
29375                         return false;
29376
29377                 }
29378                 template<typename V> bool encode(size_t index, V& v) const
29379                 {
29380                         if(index != type) {return false;} return v(ref_nested());
29381
29382                 }
29383                 private:
29384                 size_t type {0};
29385
29386         };
29387         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
29388         {
29389                 size_t get_index() const {return type;}
29390                 bool is_unknown() const { return type == 3; }
29391                 void clear() {type = 0;}
29392                 void select_id_DL_scheduling_PDCCH_CCE_usage() { set(ignore); type=1;}
29393                 void select_id_UL_scheduling_PDCCH_CCE_usage() { set(ignore); type=2;}
29394                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
29395                 template<typename V>  bool decode(V& v)
29396                 {
29397                         clear();
29398                         if(!v(ref_nested())) return false;
29399                         if(equal(ignore)) { type = 1; return true; }
29400                         else if(equal(ignore)) { type = 2; return true; }
29401                         else { type = 3; return true;}
29402                         return false;
29403
29404                 }
29405                 template<typename V> bool encode(V& v) const
29406                 {
29407                         return v(ref_nested());
29408
29409                 }
29410                 protected:
29411                 template<typename V>  bool decode(size_t index, V& v)
29412                 {
29413                         clear();
29414                         switch(index)
29415                         {
29416                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
29417                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
29418                         case 3: type = 3; return v(ref_nested());
29419                         ref_nested().clear();
29420                         }
29421                         return false;
29422
29423                 }
29424                 template<typename V> bool encode(size_t index, V& v) const
29425                 {
29426                         if(index != type) {return false;} return v(ref_nested());
29427
29428                 }
29429                 private:
29430                 size_t type {0};
29431
29432         };
29433         struct Extension_t : asn::typefield<true>
29434         {
29435                 ~Extension_t()  {clear();}
29436                 size_t get_index() const {return type;}
29437                 DL_scheduling_PDCCH_CCE_usage& select_id_DL_scheduling_PDCCH_CCE_usage() { return set<DL_scheduling_PDCCH_CCE_usage>(1); }
29438                 DL_scheduling_PDCCH_CCE_usage const* get_id_DL_scheduling_PDCCH_CCE_usage() const { return get<DL_scheduling_PDCCH_CCE_usage>(1); }
29439                 UL_scheduling_PDCCH_CCE_usage& select_id_UL_scheduling_PDCCH_CCE_usage() { return set<UL_scheduling_PDCCH_CCE_usage>(2); }
29440                 UL_scheduling_PDCCH_CCE_usage const* get_id_UL_scheduling_PDCCH_CCE_usage() const { return get<UL_scheduling_PDCCH_CCE_usage>(2); }
29441                 bool is_unknown() const { return type == 3; }
29442                 void clear()
29443                 {
29444                         switch(type)
29445                         {
29446                         case 1: var.destroy<DL_scheduling_PDCCH_CCE_usage>(); break;
29447                         case 2: var.destroy<UL_scheduling_PDCCH_CCE_usage>(); break;
29448                         }
29449                         type = 0; ref_nested().clear();
29450                 }
29451                 template<typename V> static inline void enumerate(V& v)
29452                 {
29453                         v.template operator()<DL_scheduling_PDCCH_CCE_usage>(1);
29454                         v.template operator()<UL_scheduling_PDCCH_CCE_usage>(2);
29455
29456                 }
29457                 protected:
29458                 template<typename V> bool decode(size_t index, V& v)
29459                 {
29460                         clear();
29461                         switch(index)
29462                         {
29463                         case 1: v(select_id_DL_scheduling_PDCCH_CCE_usage()); return true;
29464                         case 2: v(select_id_UL_scheduling_PDCCH_CCE_usage()); return true;
29465                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
29466                         }
29467                         return false;
29468
29469                 }
29470                 template<typename V> bool encode(size_t index, V& v) const
29471                 {
29472                         if(index != type) return false;
29473                         switch(type)
29474                         {
29475                         case 1: v(var.as<DL_scheduling_PDCCH_CCE_usage>()); return true;
29476                         case 2: v(var.as<UL_scheduling_PDCCH_CCE_usage>()); return true;
29477                         }
29478                         return false;
29479
29480                 }
29481                 private:
29482                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
29483                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
29484                 union union_type
29485                 {
29486                         char dummy1[sizeof(DL_scheduling_PDCCH_CCE_usage)];
29487                         char dummy2[sizeof(UL_scheduling_PDCCH_CCE_usage)];
29488
29489                 };
29490                 asn::variant<sizeof(union_type)> var;
29491                 size_t type {0};
29492
29493         };
29494         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
29495         {
29496                 size_t get_index() const {return type;}
29497                 bool is_unknown() const { return type == 3; }
29498                 void clear() {type = 0;}
29499                 void select_id_DL_scheduling_PDCCH_CCE_usage() { set(optional); type=1;}
29500                 void select_id_UL_scheduling_PDCCH_CCE_usage() { set(optional); type=2;}
29501                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
29502                 template<typename V>  bool decode(V& v)
29503                 {
29504                         clear();
29505                         if(!v(ref_nested())) return false;
29506                         if(equal(optional)) { type = 1; return true; }
29507                         else if(equal(optional)) { type = 2; return true; }
29508                         else { type = 3; return true;}
29509                         return false;
29510
29511                 }
29512                 template<typename V> bool encode(V& v) const
29513                 {
29514                         return v(ref_nested());
29515
29516                 }
29517                 protected:
29518                 template<typename V>  bool decode(size_t index, V& v)
29519                 {
29520                         clear();
29521                         switch(index)
29522                         {
29523                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
29524                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
29525                         case 3: type = 3; return v(ref_nested());
29526                         ref_nested().clear();
29527                         }
29528                         return false;
29529
29530                 }
29531                 template<typename V> bool encode(size_t index, V& v) const
29532                 {
29533                         if(index != type) {return false;} return v(ref_nested());
29534
29535                 }
29536                 private:
29537                 size_t type {0};
29538
29539         };
29540
29541 };
29542 /*
29543 RadioResourceStatus     ::= SEQUENCE {
29544         dL-GBR-PRB-usage                                                        DL-GBR-PRB-usage,
29545         uL-GBR-PRB-usage                                                        UL-GBR-PRB-usage,
29546         dL-non-GBR-PRB-usage                                            DL-non-GBR-PRB-usage,
29547         uL-non-GBR-PRB-usage                                            UL-non-GBR-PRB-usage,
29548         dL-Total-PRB-usage                                                      DL-Total-PRB-usage,
29549         uL-Total-PRB-usage                                                      UL-Total-PRB-usage,
29550         iE-Extensions                                                           ProtocolExtensionContainer { {RadioResourceStatus-ExtIEs} } OPTIONAL,
29551         ...
29552 }
29553 */
29554
29555 struct RadioResourceStatus : asn::sequence<7, 0, true, 1>
29556 {
29557         static constexpr const char* name() {return "RadioResourceStatus";}
29558         using parent_t = asn::sequence<7, 0, true, 1>;
29559         struct dL_GBR_PRB_usage_t : DL_GBR_PRB_usage
29560         {
29561                 static constexpr const char* name() {return "dL_GBR_PRB_usage_t";}
29562                 using parent_t = DL_GBR_PRB_usage;
29563
29564         };
29565         dL_GBR_PRB_usage_t& ref_dL_GBR_PRB_usage() {return dL_GBR_PRB_usage;}
29566         dL_GBR_PRB_usage_t const& ref_dL_GBR_PRB_usage() const {return dL_GBR_PRB_usage;}
29567         struct uL_GBR_PRB_usage_t : UL_GBR_PRB_usage
29568         {
29569                 static constexpr const char* name() {return "uL_GBR_PRB_usage_t";}
29570                 using parent_t = UL_GBR_PRB_usage;
29571
29572         };
29573         uL_GBR_PRB_usage_t& ref_uL_GBR_PRB_usage() {return uL_GBR_PRB_usage;}
29574         uL_GBR_PRB_usage_t const& ref_uL_GBR_PRB_usage() const {return uL_GBR_PRB_usage;}
29575         struct dL_non_GBR_PRB_usage_t : DL_non_GBR_PRB_usage
29576         {
29577                 static constexpr const char* name() {return "dL_non_GBR_PRB_usage_t";}
29578                 using parent_t = DL_non_GBR_PRB_usage;
29579
29580         };
29581         dL_non_GBR_PRB_usage_t& ref_dL_non_GBR_PRB_usage() {return dL_non_GBR_PRB_usage;}
29582         dL_non_GBR_PRB_usage_t const& ref_dL_non_GBR_PRB_usage() const {return dL_non_GBR_PRB_usage;}
29583         struct uL_non_GBR_PRB_usage_t : UL_non_GBR_PRB_usage
29584         {
29585                 static constexpr const char* name() {return "uL_non_GBR_PRB_usage_t";}
29586                 using parent_t = UL_non_GBR_PRB_usage;
29587
29588         };
29589         uL_non_GBR_PRB_usage_t& ref_uL_non_GBR_PRB_usage() {return uL_non_GBR_PRB_usage;}
29590         uL_non_GBR_PRB_usage_t const& ref_uL_non_GBR_PRB_usage() const {return uL_non_GBR_PRB_usage;}
29591         struct dL_Total_PRB_usage_t : DL_Total_PRB_usage
29592         {
29593                 static constexpr const char* name() {return "dL_Total_PRB_usage_t";}
29594                 using parent_t = DL_Total_PRB_usage;
29595
29596         };
29597         dL_Total_PRB_usage_t& ref_dL_Total_PRB_usage() {return dL_Total_PRB_usage;}
29598         dL_Total_PRB_usage_t const& ref_dL_Total_PRB_usage() const {return dL_Total_PRB_usage;}
29599         struct uL_Total_PRB_usage_t : UL_Total_PRB_usage
29600         {
29601                 static constexpr const char* name() {return "uL_Total_PRB_usage_t";}
29602                 using parent_t = UL_Total_PRB_usage;
29603
29604         };
29605         uL_Total_PRB_usage_t& ref_uL_Total_PRB_usage() {return uL_Total_PRB_usage;}
29606         uL_Total_PRB_usage_t const& ref_uL_Total_PRB_usage() const {return uL_Total_PRB_usage;}
29607         struct iE_Extensions_t : ProtocolExtensionContainer<RadioResourceStatus_ExtIEs>
29608         {
29609                 static constexpr const char* name() {return "iE_Extensions_t";}
29610                 using parent_t = ProtocolExtensionContainer<RadioResourceStatus_ExtIEs>;
29611                 static constexpr bool optional = true;
29612
29613         };
29614         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
29615         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
29616         template<typename V> void decode(V& v)
29617         {
29618                 v(dL_GBR_PRB_usage);
29619                 v(uL_GBR_PRB_usage);
29620                 v(dL_non_GBR_PRB_usage);
29621                 v(uL_non_GBR_PRB_usage);
29622                 v(dL_Total_PRB_usage);
29623                 v(uL_Total_PRB_usage);
29624                 v(iE_Extensions);
29625
29626         };
29627         template<typename V> void encode(V& v) const
29628         {
29629                 v(dL_GBR_PRB_usage);
29630                 v(uL_GBR_PRB_usage);
29631                 v(dL_non_GBR_PRB_usage);
29632                 v(uL_non_GBR_PRB_usage);
29633                 v(dL_Total_PRB_usage);
29634                 v(uL_Total_PRB_usage);
29635                 v(iE_Extensions);
29636
29637         };
29638         void clear()
29639         {
29640                 dL_GBR_PRB_usage.clear();
29641                 uL_GBR_PRB_usage.clear();
29642                 dL_non_GBR_PRB_usage.clear();
29643                 uL_non_GBR_PRB_usage.clear();
29644                 dL_Total_PRB_usage.clear();
29645                 uL_Total_PRB_usage.clear();
29646                 iE_Extensions.clear();
29647
29648         };
29649         private:
29650         dL_GBR_PRB_usage_t      dL_GBR_PRB_usage;
29651         uL_GBR_PRB_usage_t      uL_GBR_PRB_usage;
29652         dL_non_GBR_PRB_usage_t  dL_non_GBR_PRB_usage;
29653         uL_non_GBR_PRB_usage_t  uL_non_GBR_PRB_usage;
29654         dL_Total_PRB_usage_t    dL_Total_PRB_usage;
29655         uL_Total_PRB_usage_t    uL_Total_PRB_usage;
29656         iE_Extensions_t iE_Extensions;
29657
29658 };
29659 /*
29660 ReceiveStatusOfULPDCPSDUsExtended ::= BIT STRING (SIZE(1..16384))
29661 */
29662
29663 struct ReceiveStatusOfULPDCPSDUsExtended : asn::bstring<>
29664 {
29665         using constraint_t = asn::constraints<false,asn::span<1, 16384>>;
29666         static constexpr const char* name() {return "ReceiveStatusOfULPDCPSDUsExtended";}
29667         using parent_t = asn::bstring<>;
29668
29669 };
29670
29671 /*
29672 ReceiveStatusOfULPDCPSDUsPDCP-SNlength18 ::= BIT STRING (SIZE(1..131072))
29673 */
29674
29675 struct ReceiveStatusOfULPDCPSDUsPDCP_SNlength18 : asn::bstring<>
29676 {
29677         using constraint_t = asn::constraints<false,asn::span<1, 131072>>;
29678         static constexpr const char* name() {return "ReceiveStatusOfULPDCPSDUsPDCP-SNlength18";}
29679         using parent_t = asn::bstring<>;
29680
29681 };
29682
29683 /*
29684 ReceiveStatusofULPDCPSDUs ::= BIT STRING (SIZE(4096))
29685 */
29686
29687 struct ReceiveStatusofULPDCPSDUs : asn::bstring<>
29688 {
29689         using constraint_t = asn::constraints<false,asn::one<4096>>;
29690         static constexpr const char* name() {return "ReceiveStatusofULPDCPSDUs";}
29691         using parent_t = asn::bstring<>;
29692
29693 };
29694
29695 /*
29696 Registration-Request    ::= ENUMERATED {
29697         start,
29698         stop,
29699         ...,
29700         partial-stop,
29701         add
29702 }
29703 */
29704
29705 struct Registration_Request : asn::enumerated<4, 2, true>
29706 {
29707         static constexpr const char* name() {return "Registration-Request";}
29708         using parent_t = asn::enumerated<4, 2, true>;
29709         typedef enum {
29710                 start
29711                 ,stop
29712                 ,partial_stop
29713                 ,add
29714         } index_t;
29715
29716 };
29717
29718 /*
29719 RelativeNarrowbandTxPower-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
29720         { ID id-enhancedRNTP    CRITICALITY ignore      EXTENSION EnhancedRNTP          PRESENCE optional },
29721         ...
29722 }
29723 */
29724
29725 struct RelativeNarrowbandTxPower_ExtIEs
29726 {
29727         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
29728         {
29729                 size_t get_index() const {return type;}
29730                 bool is_unknown() const { return type == 2; }
29731                 void clear() {type = 0;}
29732                 void select_id_enhancedRNTP() { set(id_enhancedRNTP); type=1;}
29733                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
29734                 template<typename V>  bool decode(V& v)
29735                 {
29736                         clear();
29737                         if(!v(ref_nested())) return false;
29738                         if(equal(id_enhancedRNTP)) { type = 1; return true; }
29739                         else { type = 2; return true;}
29740                         return false;
29741
29742                 }
29743                 template<typename V> bool encode(V& v) const
29744                 {
29745                         return v(ref_nested());
29746
29747                 }
29748                 protected:
29749                 template<typename V>  bool decode(size_t index, V& v)
29750                 {
29751                         clear();
29752                         switch(index)
29753                         {
29754                         case 1: type = 1; if(v(ref_nested())) { return equal(id_enhancedRNTP);} return false;
29755                         case 2: type = 2; return v(ref_nested());
29756                         ref_nested().clear();
29757                         }
29758                         return false;
29759
29760                 }
29761                 template<typename V> bool encode(size_t index, V& v) const
29762                 {
29763                         if(index != type) {return false;} return v(ref_nested());
29764
29765                 }
29766                 private:
29767                 size_t type {0};
29768
29769         };
29770         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
29771         {
29772                 size_t get_index() const {return type;}
29773                 bool is_unknown() const { return type == 2; }
29774                 void clear() {type = 0;}
29775                 void select_id_enhancedRNTP() { set(ignore); type=1;}
29776                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
29777                 template<typename V>  bool decode(V& v)
29778                 {
29779                         clear();
29780                         if(!v(ref_nested())) return false;
29781                         if(equal(ignore)) { type = 1; return true; }
29782                         else { type = 2; return true;}
29783                         return false;
29784
29785                 }
29786                 template<typename V> bool encode(V& v) const
29787                 {
29788                         return v(ref_nested());
29789
29790                 }
29791                 protected:
29792                 template<typename V>  bool decode(size_t index, V& v)
29793                 {
29794                         clear();
29795                         switch(index)
29796                         {
29797                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
29798                         case 2: type = 2; return v(ref_nested());
29799                         ref_nested().clear();
29800                         }
29801                         return false;
29802
29803                 }
29804                 template<typename V> bool encode(size_t index, V& v) const
29805                 {
29806                         if(index != type) {return false;} return v(ref_nested());
29807
29808                 }
29809                 private:
29810                 size_t type {0};
29811
29812         };
29813         struct Extension_t : asn::typefield<true>
29814         {
29815                 ~Extension_t()  {clear();}
29816                 size_t get_index() const {return type;}
29817                 EnhancedRNTP& select_id_enhancedRNTP() { return set<EnhancedRNTP>(1); }
29818                 EnhancedRNTP const* get_id_enhancedRNTP() const { return get<EnhancedRNTP>(1); }
29819                 bool is_unknown() const { return type == 2; }
29820                 void clear()
29821                 {
29822                         switch(type)
29823                         {
29824                         case 1: var.destroy<EnhancedRNTP>(); break;
29825                         }
29826                         type = 0; ref_nested().clear();
29827                 }
29828                 template<typename V> static inline void enumerate(V& v)
29829                 {
29830                         v.template operator()<EnhancedRNTP>(1);
29831
29832                 }
29833                 protected:
29834                 template<typename V> bool decode(size_t index, V& v)
29835                 {
29836                         clear();
29837                         switch(index)
29838                         {
29839                         case 1: v(select_id_enhancedRNTP()); return true;
29840                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
29841                         }
29842                         return false;
29843
29844                 }
29845                 template<typename V> bool encode(size_t index, V& v) const
29846                 {
29847                         if(index != type) return false;
29848                         switch(type)
29849                         {
29850                         case 1: v(var.as<EnhancedRNTP>()); return true;
29851                         }
29852                         return false;
29853
29854                 }
29855                 private:
29856                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
29857                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
29858                 union union_type
29859                 {
29860                         char dummy1[sizeof(EnhancedRNTP)];
29861
29862                 };
29863                 asn::variant<sizeof(union_type)> var;
29864                 size_t type {0};
29865
29866         };
29867         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
29868         {
29869                 size_t get_index() const {return type;}
29870                 bool is_unknown() const { return type == 2; }
29871                 void clear() {type = 0;}
29872                 void select_id_enhancedRNTP() { set(optional); type=1;}
29873                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
29874                 template<typename V>  bool decode(V& v)
29875                 {
29876                         clear();
29877                         if(!v(ref_nested())) return false;
29878                         if(equal(optional)) { type = 1; return true; }
29879                         else { type = 2; return true;}
29880                         return false;
29881
29882                 }
29883                 template<typename V> bool encode(V& v) const
29884                 {
29885                         return v(ref_nested());
29886
29887                 }
29888                 protected:
29889                 template<typename V>  bool decode(size_t index, V& v)
29890                 {
29891                         clear();
29892                         switch(index)
29893                         {
29894                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
29895                         case 2: type = 2; return v(ref_nested());
29896                         ref_nested().clear();
29897                         }
29898                         return false;
29899
29900                 }
29901                 template<typename V> bool encode(size_t index, V& v) const
29902                 {
29903                         if(index != type) {return false;} return v(ref_nested());
29904
29905                 }
29906                 private:
29907                 size_t type {0};
29908
29909         };
29910
29911 };
29912 /*
29913 RelativeNarrowbandTxPower ::= SEQUENCE {
29914
29915         rNTP-PerPRB                                                     BIT STRING (SIZE(6..110, ...)),
29916         rNTP-Threshold                                          RNTP-Threshold,
29917         numberOfCellSpecificAntennaPorts        ENUMERATED {one, two, four, ...},
29918         p-B                                                                     INTEGER (0..3,...),
29919         pDCCH-InterferenceImpact                        INTEGER (0..4,...),
29920         iE-Extensions                                           ProtocolExtensionContainer { {RelativeNarrowbandTxPower-ExtIEs} } OPTIONAL,
29921         ...
29922 }
29923 */
29924
29925 struct RelativeNarrowbandTxPower : asn::sequence<6, 0, true, 1>
29926 {
29927         static constexpr const char* name() {return "RelativeNarrowbandTxPower";}
29928         using parent_t = asn::sequence<6, 0, true, 1>;
29929         struct rNTP_PerPRB_t : asn::bstring<>
29930         {
29931                 using constraint_t = asn::constraints<true,asn::span<6, 110>>;
29932                 static constexpr const char* name() {return "rNTP_PerPRB_t";}
29933                 using parent_t = asn::bstring<>;
29934
29935         };
29936
29937         rNTP_PerPRB_t& ref_rNTP_PerPRB() {return rNTP_PerPRB;}
29938         rNTP_PerPRB_t const& ref_rNTP_PerPRB() const {return rNTP_PerPRB;}
29939         struct rNTP_Threshold_t : RNTP_Threshold
29940         {
29941                 static constexpr const char* name() {return "rNTP_Threshold_t";}
29942                 using parent_t = RNTP_Threshold;
29943
29944         };
29945         rNTP_Threshold_t& ref_rNTP_Threshold() {return rNTP_Threshold;}
29946         rNTP_Threshold_t const& ref_rNTP_Threshold() const {return rNTP_Threshold;}
29947         struct numberOfCellSpecificAntennaPorts_t : asn::enumerated<3, 0, true>
29948         {
29949                 static constexpr const char* name() {return "numberOfCellSpecificAntennaPorts_t";}
29950                 using parent_t = asn::enumerated<3, 0, true>;
29951                 typedef enum {
29952                         one
29953                         ,two
29954                         ,four
29955                 } index_t;
29956
29957         };
29958
29959         numberOfCellSpecificAntennaPorts_t& ref_numberOfCellSpecificAntennaPorts() {return numberOfCellSpecificAntennaPorts;}
29960         numberOfCellSpecificAntennaPorts_t const& ref_numberOfCellSpecificAntennaPorts() const {return numberOfCellSpecificAntennaPorts;}
29961         struct p_B_t : asn::integer<>
29962         {
29963                 using constraint_t = asn::constraints<true,asn::span<0, 3>>;
29964                 static constexpr const char* name() {return "p_B_t";}
29965                 using parent_t = asn::integer<>;
29966
29967         };
29968
29969         p_B_t& ref_p_B() {return p_B;}
29970         p_B_t const& ref_p_B() const {return p_B;}
29971         struct pDCCH_InterferenceImpact_t : asn::integer<>
29972         {
29973                 using constraint_t = asn::constraints<true,asn::span<0, 4>>;
29974                 static constexpr const char* name() {return "pDCCH_InterferenceImpact_t";}
29975                 using parent_t = asn::integer<>;
29976
29977         };
29978
29979         pDCCH_InterferenceImpact_t& ref_pDCCH_InterferenceImpact() {return pDCCH_InterferenceImpact;}
29980         pDCCH_InterferenceImpact_t const& ref_pDCCH_InterferenceImpact() const {return pDCCH_InterferenceImpact;}
29981         struct iE_Extensions_t : ProtocolExtensionContainer<RelativeNarrowbandTxPower_ExtIEs>
29982         {
29983                 static constexpr const char* name() {return "iE_Extensions_t";}
29984                 using parent_t = ProtocolExtensionContainer<RelativeNarrowbandTxPower_ExtIEs>;
29985                 static constexpr bool optional = true;
29986
29987         };
29988         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
29989         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
29990         template<typename V> void decode(V& v)
29991         {
29992                 v(rNTP_PerPRB);
29993                 v(rNTP_Threshold);
29994                 v(numberOfCellSpecificAntennaPorts);
29995                 v(p_B);
29996                 v(pDCCH_InterferenceImpact);
29997                 v(iE_Extensions);
29998
29999         };
30000         template<typename V> void encode(V& v) const
30001         {
30002                 v(rNTP_PerPRB);
30003                 v(rNTP_Threshold);
30004                 v(numberOfCellSpecificAntennaPorts);
30005                 v(p_B);
30006                 v(pDCCH_InterferenceImpact);
30007                 v(iE_Extensions);
30008
30009         };
30010         void clear()
30011         {
30012                 rNTP_PerPRB.clear();
30013                 rNTP_Threshold.clear();
30014                 numberOfCellSpecificAntennaPorts.clear();
30015                 p_B.clear();
30016                 pDCCH_InterferenceImpact.clear();
30017                 iE_Extensions.clear();
30018
30019         };
30020         private:
30021         rNTP_PerPRB_t   rNTP_PerPRB;
30022         rNTP_Threshold_t        rNTP_Threshold;
30023         numberOfCellSpecificAntennaPorts_t      numberOfCellSpecificAntennaPorts;
30024         p_B_t   p_B;
30025         pDCCH_InterferenceImpact_t      pDCCH_InterferenceImpact;
30026         iE_Extensions_t iE_Extensions;
30027
30028 };
30029 /*
30030 ReportCharacteristics   ::= BIT STRING (SIZE (32))
30031 */
30032
30033 struct ReportCharacteristics : asn::bstring<>
30034 {
30035         using constraint_t = asn::constraints<false,asn::one<32>>;
30036         static constexpr const char* name() {return "ReportCharacteristics";}
30037         using parent_t = asn::bstring<>;
30038
30039 };
30040
30041 /*
30042 ReportingPeriodicityCSIR ::= ENUMERATED {
30043         ms5,
30044         ms10,
30045         ms20,
30046         ms40,
30047         ms80,
30048 ...
30049 }
30050 */
30051
30052 struct ReportingPeriodicityCSIR : asn::enumerated<5, 0, true>
30053 {
30054         static constexpr const char* name() {return "ReportingPeriodicityCSIR";}
30055         using parent_t = asn::enumerated<5, 0, true>;
30056         typedef enum {
30057                 ms5
30058                 ,ms10
30059                 ,ms20
30060                 ,ms40
30061                 ,ms80
30062         } index_t;
30063
30064 };
30065
30066 /*
30067 ReportingPeriodicityRSRPMR ::= ENUMERATED {
30068         one-hundred-20-ms,
30069         two-hundred-40-ms,
30070         four-hundred-80-ms,
30071         six-hundred-40-ms,
30072 ...
30073 }
30074 */
30075
30076 struct ReportingPeriodicityRSRPMR : asn::enumerated<4, 0, true>
30077 {
30078         static constexpr const char* name() {return "ReportingPeriodicityRSRPMR";}
30079         using parent_t = asn::enumerated<4, 0, true>;
30080         typedef enum {
30081                 one_hundred_20_ms
30082                 ,two_hundred_40_ms
30083                 ,four_hundred_80_ms
30084                 ,six_hundred_40_ms
30085         } index_t;
30086
30087 };
30088
30089 /*
30090 ResumeID        ::= CHOICE {
30091         non-truncated   BIT STRING(SIZE(40)),
30092         truncated               BIT STRING(SIZE(24)),
30093         ...
30094 }
30095 */
30096
30097 struct ResumeID : asn::choice<2, 0, true>
30098 {
30099         static constexpr const char* name() {return "ResumeID";}
30100         using parent_t = asn::choice<2, 0, true>;
30101         index_type get_index() const {return index;}
30102         bool is_unknown() const {return index == 3;}
30103         void set_unknown() { set_index(3);  }
30104         ~ResumeID() {clear();}
30105         struct non_truncated_t : asn::bstring<>
30106         {
30107                 using constraint_t = asn::constraints<false,asn::one<40>>;
30108                 static constexpr const char* name() {return "non_truncated_t";}
30109                 using parent_t = asn::bstring<>;
30110
30111         };
30112
30113         struct truncated_t : asn::bstring<>
30114         {
30115                 using constraint_t = asn::constraints<false,asn::one<24>>;
30116                 static constexpr const char* name() {return "truncated_t";}
30117                 using parent_t = asn::bstring<>;
30118
30119         };
30120
30121         void clear()
30122         {
30123                 switch(get_index())
30124                 {
30125                 case 1: var.destroy<non_truncated_t>(); break;
30126                 case 2: var.destroy<truncated_t>(); break;
30127                 }
30128                 index = 0;
30129                 base::clear();
30130         }
30131         template<typename V> bool decode(size_t idx, V& v)
30132         {
30133                 clear();
30134                 switch(idx)
30135                 {
30136                 case 1: set_index(1); return v(var.build<non_truncated_t>());
30137                 case 2: set_index(2); return v(var.build<truncated_t>());
30138                 }
30139                 return false;
30140
30141         }
30142         template<typename V> bool encode(V& v) const
30143         {
30144                 switch(get_index())
30145                 {
30146                 case 1: return v(var.as<non_truncated_t>());
30147                 case 2: return v(var.as<truncated_t>());
30148                 }
30149                 return false;
30150         }
30151         template<typename V> static inline void enumerate(V& v)
30152         {
30153                 v.template operator()<non_truncated_t>(1);
30154                 v.template operator()<truncated_t>(2);
30155
30156         }
30157         non_truncated_t& select_non_truncated() { if(get_index() != 1) { clear(); set_index(1); return var.build<non_truncated_t>();} return var.as<non_truncated_t>();}
30158         non_truncated_t const* get_non_truncated() const { if(get_index() == 1) { return &var.as<non_truncated_t>();} return nullptr; }
30159         truncated_t& select_truncated() { if(get_index() != 2) { clear(); set_index(2); return var.build<truncated_t>();} return var.as<truncated_t>();}
30160         truncated_t const* get_truncated() const { if(get_index() == 2) { return &var.as<truncated_t>();} return nullptr; }
30161         private:
30162         void set_index(index_type i) {index = i; base::set();}
30163         union union_type
30164         {
30165                 char dummy1[sizeof(non_truncated_t)];
30166                 char dummy2[sizeof(truncated_t)];
30167
30168         };
30169         asn::variant<sizeof(union_type)>        var;
30170         index_type      index {0};
30171 };
30172 /*
30173 S1TNLLoadIndicator-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
30174         ...
30175 }
30176 */
30177
30178 struct S1TNLLoadIndicator_ExtIEs
30179 {
30180         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
30181         {
30182                 size_t get_index() const {return type;}
30183                 bool is_unknown() const { return type == 1; }
30184                 void clear() {type = 0;}
30185                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
30186                 template<typename V>  bool decode(V& v)
30187                 {
30188                         clear();
30189                         if(!v(ref_nested())) return false;
30190                         { type = 1; return true;}
30191                         return false;
30192
30193                 }
30194                 template<typename V> bool encode(V& v) const
30195                 {
30196                         return v(ref_nested());
30197
30198                 }
30199                 protected:
30200                 template<typename V>  bool decode(size_t index, V& v)
30201                 {
30202                         clear();
30203                         switch(index)
30204                         {
30205                         case 1: type = 1; return v(ref_nested());
30206                         ref_nested().clear();
30207                         }
30208                         return false;
30209
30210                 }
30211                 template<typename V> bool encode(size_t index, V& v) const
30212                 {
30213                         if(index != type) {return false;} return v(ref_nested());
30214
30215                 }
30216                 private:
30217                 size_t type {0};
30218
30219         };
30220         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
30221         {
30222                 size_t get_index() const {return type;}
30223                 bool is_unknown() const { return type == 1; }
30224                 void clear() {type = 0;}
30225                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
30226                 template<typename V>  bool decode(V& v)
30227                 {
30228                         clear();
30229                         if(!v(ref_nested())) return false;
30230                         { type = 1; return true;}
30231                         return false;
30232
30233                 }
30234                 template<typename V> bool encode(V& v) const
30235                 {
30236                         return v(ref_nested());
30237
30238                 }
30239                 protected:
30240                 template<typename V>  bool decode(size_t index, V& v)
30241                 {
30242                         clear();
30243                         switch(index)
30244                         {
30245                         case 1: type = 1; return v(ref_nested());
30246                         ref_nested().clear();
30247                         }
30248                         return false;
30249
30250                 }
30251                 template<typename V> bool encode(size_t index, V& v) const
30252                 {
30253                         if(index != type) {return false;} return v(ref_nested());
30254
30255                 }
30256                 private:
30257                 size_t type {0};
30258
30259         };
30260         struct Extension_t : asn::typefield<true>
30261         {
30262                 ~Extension_t()  {clear();}
30263                 size_t get_index() const {return type;}
30264                 bool is_unknown() const { return type == 1; }
30265                 void clear()
30266                 {
30267                         type = 0; ref_nested().clear();
30268                 }
30269                 template<typename V> static inline void enumerate(V& v)
30270                 {
30271
30272                 }
30273                 protected:
30274                 template<typename V> bool decode(size_t index, V& v)
30275                 {
30276                         clear();
30277                         switch(index)
30278                         {
30279                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
30280                         }
30281                         return false;
30282
30283                 }
30284                 template<typename V> bool encode(size_t index, V& v) const
30285                 {
30286                         if(index != type) return false;
30287                         return false;
30288
30289                 }
30290                 private:
30291                 size_t type {0};
30292
30293         };
30294         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
30295         {
30296                 size_t get_index() const {return type;}
30297                 bool is_unknown() const { return type == 1; }
30298                 void clear() {type = 0;}
30299                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
30300                 template<typename V>  bool decode(V& v)
30301                 {
30302                         clear();
30303                         if(!v(ref_nested())) return false;
30304                         { type = 1; return true;}
30305                         return false;
30306
30307                 }
30308                 template<typename V> bool encode(V& v) const
30309                 {
30310                         return v(ref_nested());
30311
30312                 }
30313                 protected:
30314                 template<typename V>  bool decode(size_t index, V& v)
30315                 {
30316                         clear();
30317                         switch(index)
30318                         {
30319                         case 1: type = 1; return v(ref_nested());
30320                         ref_nested().clear();
30321                         }
30322                         return false;
30323
30324                 }
30325                 template<typename V> bool encode(size_t index, V& v) const
30326                 {
30327                         if(index != type) {return false;} return v(ref_nested());
30328
30329                 }
30330                 private:
30331                 size_t type {0};
30332
30333         };
30334
30335 };
30336 /*
30337 S1TNLLoadIndicator ::= SEQUENCE {
30338         dLS1TNLLoadIndicator                    LoadIndicator,
30339         uLS1TNLLoadIndicator                    LoadIndicator,
30340         iE-Extensions                                   ProtocolExtensionContainer { {S1TNLLoadIndicator-ExtIEs} } OPTIONAL,
30341         ...
30342 }
30343 */
30344
30345 struct S1TNLLoadIndicator : asn::sequence<3, 0, true, 1>
30346 {
30347         static constexpr const char* name() {return "S1TNLLoadIndicator";}
30348         using parent_t = asn::sequence<3, 0, true, 1>;
30349         struct dLS1TNLLoadIndicator_t : LoadIndicator
30350         {
30351                 static constexpr const char* name() {return "dLS1TNLLoadIndicator_t";}
30352                 using parent_t = LoadIndicator;
30353
30354         };
30355         dLS1TNLLoadIndicator_t& ref_dLS1TNLLoadIndicator() {return dLS1TNLLoadIndicator;}
30356         dLS1TNLLoadIndicator_t const& ref_dLS1TNLLoadIndicator() const {return dLS1TNLLoadIndicator;}
30357         struct uLS1TNLLoadIndicator_t : LoadIndicator
30358         {
30359                 static constexpr const char* name() {return "uLS1TNLLoadIndicator_t";}
30360                 using parent_t = LoadIndicator;
30361
30362         };
30363         uLS1TNLLoadIndicator_t& ref_uLS1TNLLoadIndicator() {return uLS1TNLLoadIndicator;}
30364         uLS1TNLLoadIndicator_t const& ref_uLS1TNLLoadIndicator() const {return uLS1TNLLoadIndicator;}
30365         struct iE_Extensions_t : ProtocolExtensionContainer<S1TNLLoadIndicator_ExtIEs>
30366         {
30367                 static constexpr const char* name() {return "iE_Extensions_t";}
30368                 using parent_t = ProtocolExtensionContainer<S1TNLLoadIndicator_ExtIEs>;
30369                 static constexpr bool optional = true;
30370
30371         };
30372         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
30373         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
30374         template<typename V> void decode(V& v)
30375         {
30376                 v(dLS1TNLLoadIndicator);
30377                 v(uLS1TNLLoadIndicator);
30378                 v(iE_Extensions);
30379
30380         };
30381         template<typename V> void encode(V& v) const
30382         {
30383                 v(dLS1TNLLoadIndicator);
30384                 v(uLS1TNLLoadIndicator);
30385                 v(iE_Extensions);
30386
30387         };
30388         void clear()
30389         {
30390                 dLS1TNLLoadIndicator.clear();
30391                 uLS1TNLLoadIndicator.clear();
30392                 iE_Extensions.clear();
30393
30394         };
30395         private:
30396         dLS1TNLLoadIndicator_t  dLS1TNLLoadIndicator;
30397         uLS1TNLLoadIndicator_t  uLS1TNLLoadIndicator;
30398         iE_Extensions_t iE_Extensions;
30399
30400 };
30401 /*
30402 SCGChangeIndication ::= ENUMERATED {pDCPCountWrapAround, pSCellChange, other, ...}
30403 */
30404
30405 struct SCGChangeIndication : asn::enumerated<3, 0, true>
30406 {
30407         static constexpr const char* name() {return "SCGChangeIndication";}
30408         using parent_t = asn::enumerated<3, 0, true>;
30409         typedef enum {
30410                 pDCPCountWrapAround
30411                 ,pSCellChange
30412                 ,other
30413         } index_t;
30414
30415 };
30416
30417 /*
30418 SCGConfigurationQuery ::= ENUMERATED {true,...}
30419 */
30420
30421 struct SCGConfigurationQuery : asn::enumerated<1, 0, true>
30422 {
30423         static constexpr const char* name() {return "SCGConfigurationQuery";}
30424         using parent_t = asn::enumerated<1, 0, true>;
30425         typedef enum {
30426                 True
30427         } index_t;
30428
30429 };
30430
30431 /*
30432 SGNB-Addition-Trigger-Ind        ::= ENUMERATED {
30433         sn-change,
30434         inter-eNB-HO,
30435         intra-eNB-HO,
30436         ...
30437 }
30438 */
30439
30440 struct SGNB_Addition_Trigger_Ind : asn::enumerated<3, 0, true>
30441 {
30442         static constexpr const char* name() {return "SGNB-Addition-Trigger-Ind";}
30443         using parent_t = asn::enumerated<3, 0, true>;
30444         typedef enum {
30445                 sn_change
30446                 ,inter_eNB_HO
30447                 ,intra_eNB_HO
30448         } index_t;
30449
30450 };
30451
30452 /*
30453 SIPTOBearerDeactivationIndication ::= ENUMERATED {
30454         true,
30455         ...
30456 }
30457 */
30458
30459 struct SIPTOBearerDeactivationIndication : asn::enumerated<1, 0, true>
30460 {
30461         static constexpr const char* name() {return "SIPTOBearerDeactivationIndication";}
30462         using parent_t = asn::enumerated<1, 0, true>;
30463         typedef enum {
30464                 True
30465         } index_t;
30466
30467 };
30468
30469 /*
30470 SRBType ::= ENUMERATED {srb1, srb2, ...}
30471 */
30472
30473 struct SRBType : asn::enumerated<2, 0, true>
30474 {
30475         static constexpr const char* name() {return "SRBType";}
30476         using parent_t = asn::enumerated<2, 0, true>;
30477         typedef enum {
30478                 srb1
30479                 ,srb2
30480         } index_t;
30481
30482 };
30483
30484 /*
30485 SRVCCOperationPossible ::= ENUMERATED {
30486         possible,
30487         ...
30488 }
30489 */
30490
30491 struct SRVCCOperationPossible : asn::enumerated<1, 0, true>
30492 {
30493         static constexpr const char* name() {return "SRVCCOperationPossible";}
30494         using parent_t = asn::enumerated<1, 0, true>;
30495         typedef enum {
30496                 possible
30497         } index_t;
30498
30499 };
30500
30501 /*
30502 ScheduledCommunicationTime-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
30503         ...
30504 }
30505 */
30506
30507 struct ScheduledCommunicationTime_ExtIEs
30508 {
30509         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
30510         {
30511                 size_t get_index() const {return type;}
30512                 bool is_unknown() const { return type == 1; }
30513                 void clear() {type = 0;}
30514                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
30515                 template<typename V>  bool decode(V& v)
30516                 {
30517                         clear();
30518                         if(!v(ref_nested())) return false;
30519                         { type = 1; return true;}
30520                         return false;
30521
30522                 }
30523                 template<typename V> bool encode(V& v) const
30524                 {
30525                         return v(ref_nested());
30526
30527                 }
30528                 protected:
30529                 template<typename V>  bool decode(size_t index, V& v)
30530                 {
30531                         clear();
30532                         switch(index)
30533                         {
30534                         case 1: type = 1; return v(ref_nested());
30535                         ref_nested().clear();
30536                         }
30537                         return false;
30538
30539                 }
30540                 template<typename V> bool encode(size_t index, V& v) const
30541                 {
30542                         if(index != type) {return false;} return v(ref_nested());
30543
30544                 }
30545                 private:
30546                 size_t type {0};
30547
30548         };
30549         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
30550         {
30551                 size_t get_index() const {return type;}
30552                 bool is_unknown() const { return type == 1; }
30553                 void clear() {type = 0;}
30554                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
30555                 template<typename V>  bool decode(V& v)
30556                 {
30557                         clear();
30558                         if(!v(ref_nested())) return false;
30559                         { type = 1; return true;}
30560                         return false;
30561
30562                 }
30563                 template<typename V> bool encode(V& v) const
30564                 {
30565                         return v(ref_nested());
30566
30567                 }
30568                 protected:
30569                 template<typename V>  bool decode(size_t index, V& v)
30570                 {
30571                         clear();
30572                         switch(index)
30573                         {
30574                         case 1: type = 1; return v(ref_nested());
30575                         ref_nested().clear();
30576                         }
30577                         return false;
30578
30579                 }
30580                 template<typename V> bool encode(size_t index, V& v) const
30581                 {
30582                         if(index != type) {return false;} return v(ref_nested());
30583
30584                 }
30585                 private:
30586                 size_t type {0};
30587
30588         };
30589         struct Extension_t : asn::typefield<true>
30590         {
30591                 ~Extension_t()  {clear();}
30592                 size_t get_index() const {return type;}
30593                 bool is_unknown() const { return type == 1; }
30594                 void clear()
30595                 {
30596                         type = 0; ref_nested().clear();
30597                 }
30598                 template<typename V> static inline void enumerate(V& v)
30599                 {
30600
30601                 }
30602                 protected:
30603                 template<typename V> bool decode(size_t index, V& v)
30604                 {
30605                         clear();
30606                         switch(index)
30607                         {
30608                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
30609                         }
30610                         return false;
30611
30612                 }
30613                 template<typename V> bool encode(size_t index, V& v) const
30614                 {
30615                         if(index != type) return false;
30616                         return false;
30617
30618                 }
30619                 private:
30620                 size_t type {0};
30621
30622         };
30623         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
30624         {
30625                 size_t get_index() const {return type;}
30626                 bool is_unknown() const { return type == 1; }
30627                 void clear() {type = 0;}
30628                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
30629                 template<typename V>  bool decode(V& v)
30630                 {
30631                         clear();
30632                         if(!v(ref_nested())) return false;
30633                         { type = 1; return true;}
30634                         return false;
30635
30636                 }
30637                 template<typename V> bool encode(V& v) const
30638                 {
30639                         return v(ref_nested());
30640
30641                 }
30642                 protected:
30643                 template<typename V>  bool decode(size_t index, V& v)
30644                 {
30645                         clear();
30646                         switch(index)
30647                         {
30648                         case 1: type = 1; return v(ref_nested());
30649                         ref_nested().clear();
30650                         }
30651                         return false;
30652
30653                 }
30654                 template<typename V> bool encode(size_t index, V& v) const
30655                 {
30656                         if(index != type) {return false;} return v(ref_nested());
30657
30658                 }
30659                 private:
30660                 size_t type {0};
30661
30662         };
30663
30664 };
30665 /*
30666 ScheduledCommunicationTime ::= SEQUENCE {
30667         dayofWeek                               BIT STRING (SIZE(7))                                                                    OPTIONAL,
30668         timeofDayStart                  INTEGER (0..86399, ...)                                                                 OPTIONAL,
30669         timeofDayEnd                            INTEGER (0..86399, ...)                                                                 OPTIONAL,
30670         iE-Extensions                   ProtocolExtensionContainer { { ScheduledCommunicationTime-ExtIEs}}      OPTIONAL,
30671         ...
30672 }
30673 */
30674
30675 struct ScheduledCommunicationTime : asn::sequence<4, 0, true, 4>
30676 {
30677         static constexpr const char* name() {return "ScheduledCommunicationTime";}
30678         using parent_t = asn::sequence<4, 0, true, 4>;
30679         struct dayofWeek_t : asn::bstring<>
30680         {
30681                 using constraint_t = asn::constraints<false,asn::one<7>>;
30682                 static constexpr const char* name() {return "dayofWeek_t";}
30683                 using parent_t = asn::bstring<>;
30684                 static constexpr bool optional = true;
30685
30686         };
30687
30688         dayofWeek_t& set_dayofWeek() { dayofWeek.setpresent(true); return dayofWeek;}
30689         dayofWeek_t const* get_dayofWeek() const {return dayofWeek.is_valid() ? &dayofWeek : nullptr;}
30690         struct timeofDayStart_t : asn::integer<>
30691         {
30692                 using constraint_t = asn::constraints<true,asn::span<0, 86399>>;
30693                 static constexpr const char* name() {return "timeofDayStart_t";}
30694                 using parent_t = asn::integer<>;
30695                 static constexpr bool optional = true;
30696
30697         };
30698
30699         timeofDayStart_t& set_timeofDayStart() { timeofDayStart.setpresent(true); return timeofDayStart;}
30700         timeofDayStart_t const* get_timeofDayStart() const {return timeofDayStart.is_valid() ? &timeofDayStart : nullptr;}
30701         struct timeofDayEnd_t : asn::integer<>
30702         {
30703                 using constraint_t = asn::constraints<true,asn::span<0, 86399>>;
30704                 static constexpr const char* name() {return "timeofDayEnd_t";}
30705                 using parent_t = asn::integer<>;
30706                 static constexpr bool optional = true;
30707
30708         };
30709
30710         timeofDayEnd_t& set_timeofDayEnd() { timeofDayEnd.setpresent(true); return timeofDayEnd;}
30711         timeofDayEnd_t const* get_timeofDayEnd() const {return timeofDayEnd.is_valid() ? &timeofDayEnd : nullptr;}
30712         struct iE_Extensions_t : ProtocolExtensionContainer<ScheduledCommunicationTime_ExtIEs>
30713         {
30714                 static constexpr const char* name() {return "iE_Extensions_t";}
30715                 using parent_t = ProtocolExtensionContainer<ScheduledCommunicationTime_ExtIEs>;
30716                 static constexpr bool optional = true;
30717
30718         };
30719         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
30720         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
30721         template<typename V> void decode(V& v)
30722         {
30723                 v(dayofWeek);
30724                 v(timeofDayStart);
30725                 v(timeofDayEnd);
30726                 v(iE_Extensions);
30727
30728         };
30729         template<typename V> void encode(V& v) const
30730         {
30731                 v(dayofWeek);
30732                 v(timeofDayStart);
30733                 v(timeofDayEnd);
30734                 v(iE_Extensions);
30735
30736         };
30737         void clear()
30738         {
30739                 dayofWeek.clear();
30740                 timeofDayStart.clear();
30741                 timeofDayEnd.clear();
30742                 iE_Extensions.clear();
30743
30744         };
30745         private:
30746         dayofWeek_t     dayofWeek;
30747         timeofDayStart_t        timeofDayStart;
30748         timeofDayEnd_t  timeofDayEnd;
30749         iE_Extensions_t iE_Extensions;
30750
30751 };
30752 /*
30753 SeNBSecurityKey ::= BIT STRING (SIZE(256))
30754 */
30755
30756 struct SeNBSecurityKey : asn::bstring<>
30757 {
30758         using constraint_t = asn::constraints<false,asn::one<256>>;
30759         static constexpr const char* name() {return "SeNBSecurityKey";}
30760         using parent_t = asn::bstring<>;
30761
30762 };
30763
30764 /*
30765 SeNBtoMeNBContainer ::= OCTET STRING
30766 */
30767
30768 struct SeNBtoMeNBContainer : asn::ostring<>
30769 {
30770         static constexpr const char* name() {return "SeNBtoMeNBContainer";}
30771         using parent_t = asn::ostring<>;
30772
30773 };
30774
30775 /*
30776 SecondaryRATUsageReport-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
30777         ...
30778 }
30779 */
30780
30781 struct SecondaryRATUsageReport_Item_ExtIEs
30782 {
30783         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
30784         {
30785                 size_t get_index() const {return type;}
30786                 bool is_unknown() const { return type == 1; }
30787                 void clear() {type = 0;}
30788                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
30789                 template<typename V>  bool decode(V& v)
30790                 {
30791                         clear();
30792                         if(!v(ref_nested())) return false;
30793                         { type = 1; return true;}
30794                         return false;
30795
30796                 }
30797                 template<typename V> bool encode(V& v) const
30798                 {
30799                         return v(ref_nested());
30800
30801                 }
30802                 protected:
30803                 template<typename V>  bool decode(size_t index, V& v)
30804                 {
30805                         clear();
30806                         switch(index)
30807                         {
30808                         case 1: type = 1; return v(ref_nested());
30809                         ref_nested().clear();
30810                         }
30811                         return false;
30812
30813                 }
30814                 template<typename V> bool encode(size_t index, V& v) const
30815                 {
30816                         if(index != type) {return false;} return v(ref_nested());
30817
30818                 }
30819                 private:
30820                 size_t type {0};
30821
30822         };
30823         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
30824         {
30825                 size_t get_index() const {return type;}
30826                 bool is_unknown() const { return type == 1; }
30827                 void clear() {type = 0;}
30828                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
30829                 template<typename V>  bool decode(V& v)
30830                 {
30831                         clear();
30832                         if(!v(ref_nested())) return false;
30833                         { type = 1; return true;}
30834                         return false;
30835
30836                 }
30837                 template<typename V> bool encode(V& v) const
30838                 {
30839                         return v(ref_nested());
30840
30841                 }
30842                 protected:
30843                 template<typename V>  bool decode(size_t index, V& v)
30844                 {
30845                         clear();
30846                         switch(index)
30847                         {
30848                         case 1: type = 1; return v(ref_nested());
30849                         ref_nested().clear();
30850                         }
30851                         return false;
30852
30853                 }
30854                 template<typename V> bool encode(size_t index, V& v) const
30855                 {
30856                         if(index != type) {return false;} return v(ref_nested());
30857
30858                 }
30859                 private:
30860                 size_t type {0};
30861
30862         };
30863         struct Extension_t : asn::typefield<true>
30864         {
30865                 ~Extension_t()  {clear();}
30866                 size_t get_index() const {return type;}
30867                 bool is_unknown() const { return type == 1; }
30868                 void clear()
30869                 {
30870                         type = 0; ref_nested().clear();
30871                 }
30872                 template<typename V> static inline void enumerate(V& v)
30873                 {
30874
30875                 }
30876                 protected:
30877                 template<typename V> bool decode(size_t index, V& v)
30878                 {
30879                         clear();
30880                         switch(index)
30881                         {
30882                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
30883                         }
30884                         return false;
30885
30886                 }
30887                 template<typename V> bool encode(size_t index, V& v) const
30888                 {
30889                         if(index != type) return false;
30890                         return false;
30891
30892                 }
30893                 private:
30894                 size_t type {0};
30895
30896         };
30897         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
30898         {
30899                 size_t get_index() const {return type;}
30900                 bool is_unknown() const { return type == 1; }
30901                 void clear() {type = 0;}
30902                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
30903                 template<typename V>  bool decode(V& v)
30904                 {
30905                         clear();
30906                         if(!v(ref_nested())) return false;
30907                         { type = 1; return true;}
30908                         return false;
30909
30910                 }
30911                 template<typename V> bool encode(V& v) const
30912                 {
30913                         return v(ref_nested());
30914
30915                 }
30916                 protected:
30917                 template<typename V>  bool decode(size_t index, V& v)
30918                 {
30919                         clear();
30920                         switch(index)
30921                         {
30922                         case 1: type = 1; return v(ref_nested());
30923                         ref_nested().clear();
30924                         }
30925                         return false;
30926
30927                 }
30928                 template<typename V> bool encode(size_t index, V& v) const
30929                 {
30930                         if(index != type) {return false;} return v(ref_nested());
30931
30932                 }
30933                 private:
30934                 size_t type {0};
30935
30936         };
30937
30938 };
30939 /*
30940 SecondaryRATUsageReport-Item ::= SEQUENCE {
30941         e-RAB-ID                                                E-RAB-ID,
30942         secondaryRATType                                ENUMERATED {nr, ...},
30943         e-RABUsageReportList                    E-RABUsageReportList,
30944         iE-Extensions                           ProtocolExtensionContainer { {SecondaryRATUsageReport-Item-ExtIEs} } OPTIONAL,
30945 ...
30946 }
30947 */
30948
30949 struct SecondaryRATUsageReport_Item : asn::sequence<4, 0, true, 1>
30950 {
30951         static constexpr const char* name() {return "SecondaryRATUsageReport-Item";}
30952         using parent_t = asn::sequence<4, 0, true, 1>;
30953         struct e_RAB_ID_t : E_RAB_ID
30954         {
30955                 static constexpr const char* name() {return "e_RAB_ID_t";}
30956                 using parent_t = E_RAB_ID;
30957
30958         };
30959         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
30960         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
30961         struct secondaryRATType_t : asn::enumerated<1, 0, true>
30962         {
30963                 static constexpr const char* name() {return "secondaryRATType_t";}
30964                 using parent_t = asn::enumerated<1, 0, true>;
30965                 typedef enum {
30966                         nr
30967                 } index_t;
30968
30969         };
30970
30971         secondaryRATType_t& ref_secondaryRATType() {return secondaryRATType;}
30972         secondaryRATType_t const& ref_secondaryRATType() const {return secondaryRATType;}
30973         struct e_RABUsageReportList_t : E_RABUsageReportList
30974         {
30975                 static constexpr const char* name() {return "e_RABUsageReportList_t";}
30976                 using parent_t = E_RABUsageReportList;
30977
30978         };
30979         e_RABUsageReportList_t& ref_e_RABUsageReportList() {return e_RABUsageReportList;}
30980         e_RABUsageReportList_t const& ref_e_RABUsageReportList() const {return e_RABUsageReportList;}
30981         struct iE_Extensions_t : ProtocolExtensionContainer<SecondaryRATUsageReport_Item_ExtIEs>
30982         {
30983                 static constexpr const char* name() {return "iE_Extensions_t";}
30984                 using parent_t = ProtocolExtensionContainer<SecondaryRATUsageReport_Item_ExtIEs>;
30985                 static constexpr bool optional = true;
30986
30987         };
30988         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
30989         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
30990         template<typename V> void decode(V& v)
30991         {
30992                 v(e_RAB_ID);
30993                 v(secondaryRATType);
30994                 v(e_RABUsageReportList);
30995                 v(iE_Extensions);
30996
30997         };
30998         template<typename V> void encode(V& v) const
30999         {
31000                 v(e_RAB_ID);
31001                 v(secondaryRATType);
31002                 v(e_RABUsageReportList);
31003                 v(iE_Extensions);
31004
31005         };
31006         void clear()
31007         {
31008                 e_RAB_ID.clear();
31009                 secondaryRATType.clear();
31010                 e_RABUsageReportList.clear();
31011                 iE_Extensions.clear();
31012
31013         };
31014         private:
31015         e_RAB_ID_t      e_RAB_ID;
31016         secondaryRATType_t      secondaryRATType;
31017         e_RABUsageReportList_t  e_RABUsageReportList;
31018         iE_Extensions_t iE_Extensions;
31019
31020 };
31021 /*
31022 SecondaryRATUsageReport-ItemIEs X2AP-PROTOCOL-IES ::= {
31023         { ID id-SecondaryRATUsageReport-Item            CRITICALITY reject      TYPE SecondaryRATUsageReport-Item               PRESENCE mandatory},
31024         ...
31025 }
31026 */
31027
31028 struct SecondaryRATUsageReport_ItemIEs
31029 {
31030         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
31031         {
31032                 size_t get_index() const {return type;}
31033                 bool is_unknown() const { return type == 2; }
31034                 void clear() {type = 0;}
31035                 void select_id_SecondaryRATUsageReport_Item() { set(id_SecondaryRATUsageReport_Item); type=1;}
31036                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
31037                 template<typename V>  bool decode(V& v)
31038                 {
31039                         clear();
31040                         if(!v(ref_nested())) return false;
31041                         if(equal(id_SecondaryRATUsageReport_Item)) { type = 1; return true; }
31042                         else { type = 2; return true;}
31043                         return false;
31044
31045                 }
31046                 template<typename V> bool encode(V& v) const
31047                 {
31048                         return v(ref_nested());
31049
31050                 }
31051                 protected:
31052                 template<typename V>  bool decode(size_t index, V& v)
31053                 {
31054                         clear();
31055                         switch(index)
31056                         {
31057                         case 1: type = 1; if(v(ref_nested())) { return equal(id_SecondaryRATUsageReport_Item);} return false;
31058                         case 2: type = 2; return v(ref_nested());
31059                         ref_nested().clear();
31060                         }
31061                         return false;
31062
31063                 }
31064                 template<typename V> bool encode(size_t index, V& v) const
31065                 {
31066                         if(index != type) {return false;} return v(ref_nested());
31067
31068                 }
31069                 private:
31070                 size_t type {0};
31071
31072         };
31073         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
31074         {
31075                 size_t get_index() const {return type;}
31076                 bool is_unknown() const { return type == 2; }
31077                 void clear() {type = 0;}
31078                 void select_id_SecondaryRATUsageReport_Item() { set(reject); type=1;}
31079                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
31080                 template<typename V>  bool decode(V& v)
31081                 {
31082                         clear();
31083                         if(!v(ref_nested())) return false;
31084                         if(equal(reject)) { type = 1; return true; }
31085                         else { type = 2; return true;}
31086                         return false;
31087
31088                 }
31089                 template<typename V> bool encode(V& v) const
31090                 {
31091                         return v(ref_nested());
31092
31093                 }
31094                 protected:
31095                 template<typename V>  bool decode(size_t index, V& v)
31096                 {
31097                         clear();
31098                         switch(index)
31099                         {
31100                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
31101                         case 2: type = 2; return v(ref_nested());
31102                         ref_nested().clear();
31103                         }
31104                         return false;
31105
31106                 }
31107                 template<typename V> bool encode(size_t index, V& v) const
31108                 {
31109                         if(index != type) {return false;} return v(ref_nested());
31110
31111                 }
31112                 private:
31113                 size_t type {0};
31114
31115         };
31116         struct Value_t : asn::typefield<true>
31117         {
31118                 ~Value_t()      {clear();}
31119                 size_t get_index() const {return type;}
31120                 SecondaryRATUsageReport_Item& select_id_SecondaryRATUsageReport_Item() { return set<SecondaryRATUsageReport_Item>(1); }
31121                 SecondaryRATUsageReport_Item const* get_id_SecondaryRATUsageReport_Item() const { return get<SecondaryRATUsageReport_Item>(1); }
31122                 bool is_unknown() const { return type == 2; }
31123                 void clear()
31124                 {
31125                         switch(type)
31126                         {
31127                         case 1: var.destroy<SecondaryRATUsageReport_Item>(); break;
31128                         }
31129                         type = 0; ref_nested().clear();
31130                 }
31131                 template<typename V> static inline void enumerate(V& v)
31132                 {
31133                         v.template operator()<SecondaryRATUsageReport_Item>(1);
31134
31135                 }
31136                 protected:
31137                 template<typename V> bool decode(size_t index, V& v)
31138                 {
31139                         clear();
31140                         switch(index)
31141                         {
31142                         case 1: v(select_id_SecondaryRATUsageReport_Item()); return true;
31143                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
31144                         }
31145                         return false;
31146
31147                 }
31148                 template<typename V> bool encode(size_t index, V& v) const
31149                 {
31150                         if(index != type) return false;
31151                         switch(type)
31152                         {
31153                         case 1: v(var.as<SecondaryRATUsageReport_Item>()); return true;
31154                         }
31155                         return false;
31156
31157                 }
31158                 private:
31159                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
31160                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
31161                 union union_type
31162                 {
31163                         char dummy1[sizeof(SecondaryRATUsageReport_Item)];
31164
31165                 };
31166                 asn::variant<sizeof(union_type)> var;
31167                 size_t type {0};
31168
31169         };
31170         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
31171         {
31172                 size_t get_index() const {return type;}
31173                 bool is_unknown() const { return type == 2; }
31174                 void clear() {type = 0;}
31175                 void select_id_SecondaryRATUsageReport_Item() { set(mandatory); type=1;}
31176                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
31177                 template<typename V>  bool decode(V& v)
31178                 {
31179                         clear();
31180                         if(!v(ref_nested())) return false;
31181                         if(equal(mandatory)) { type = 1; return true; }
31182                         else { type = 2; return true;}
31183                         return false;
31184
31185                 }
31186                 template<typename V> bool encode(V& v) const
31187                 {
31188                         return v(ref_nested());
31189
31190                 }
31191                 protected:
31192                 template<typename V>  bool decode(size_t index, V& v)
31193                 {
31194                         clear();
31195                         switch(index)
31196                         {
31197                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
31198                         case 2: type = 2; return v(ref_nested());
31199                         ref_nested().clear();
31200                         }
31201                         return false;
31202
31203                 }
31204                 template<typename V> bool encode(size_t index, V& v) const
31205                 {
31206                         if(index != type) {return false;} return v(ref_nested());
31207
31208                 }
31209                 private:
31210                 size_t type {0};
31211
31212         };
31213
31214 };
31215 /*
31216 SecondaryRATUsageReportList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container {{SecondaryRATUsageReport-ItemIEs}}
31217 */
31218
31219 struct SecondaryRATUsageReportList_elm : ProtocolIE_Single_Container<SecondaryRATUsageReport_ItemIEs>
31220 {
31221         static constexpr const char* name() {return "SecondaryRATUsageReportList_elm";}
31222         using parent_t = ProtocolIE_Single_Container<SecondaryRATUsageReport_ItemIEs>;
31223
31224 };
31225 struct SecondaryRATUsageReportList : asn::sequenceof<SecondaryRATUsageReportList_elm>
31226 {
31227         static constexpr const char* name() {return "SecondaryRATUsageReportList";}
31228         using parent_t = asn::sequenceof<SecondaryRATUsageReportList_elm>;
31229         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
31230
31231 };
31232 /*
31233 ServedCell-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
31234         ...
31235 }
31236 */
31237
31238 struct ServedCell_ExtIEs
31239 {
31240         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
31241         {
31242                 size_t get_index() const {return type;}
31243                 bool is_unknown() const { return type == 1; }
31244                 void clear() {type = 0;}
31245                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
31246                 template<typename V>  bool decode(V& v)
31247                 {
31248                         clear();
31249                         if(!v(ref_nested())) return false;
31250                         { type = 1; return true;}
31251                         return false;
31252
31253                 }
31254                 template<typename V> bool encode(V& v) const
31255                 {
31256                         return v(ref_nested());
31257
31258                 }
31259                 protected:
31260                 template<typename V>  bool decode(size_t index, V& v)
31261                 {
31262                         clear();
31263                         switch(index)
31264                         {
31265                         case 1: type = 1; return v(ref_nested());
31266                         ref_nested().clear();
31267                         }
31268                         return false;
31269
31270                 }
31271                 template<typename V> bool encode(size_t index, V& v) const
31272                 {
31273                         if(index != type) {return false;} return v(ref_nested());
31274
31275                 }
31276                 private:
31277                 size_t type {0};
31278
31279         };
31280         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
31281         {
31282                 size_t get_index() const {return type;}
31283                 bool is_unknown() const { return type == 1; }
31284                 void clear() {type = 0;}
31285                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
31286                 template<typename V>  bool decode(V& v)
31287                 {
31288                         clear();
31289                         if(!v(ref_nested())) return false;
31290                         { type = 1; return true;}
31291                         return false;
31292
31293                 }
31294                 template<typename V> bool encode(V& v) const
31295                 {
31296                         return v(ref_nested());
31297
31298                 }
31299                 protected:
31300                 template<typename V>  bool decode(size_t index, V& v)
31301                 {
31302                         clear();
31303                         switch(index)
31304                         {
31305                         case 1: type = 1; return v(ref_nested());
31306                         ref_nested().clear();
31307                         }
31308                         return false;
31309
31310                 }
31311                 template<typename V> bool encode(size_t index, V& v) const
31312                 {
31313                         if(index != type) {return false;} return v(ref_nested());
31314
31315                 }
31316                 private:
31317                 size_t type {0};
31318
31319         };
31320         struct Extension_t : asn::typefield<true>
31321         {
31322                 ~Extension_t()  {clear();}
31323                 size_t get_index() const {return type;}
31324                 bool is_unknown() const { return type == 1; }
31325                 void clear()
31326                 {
31327                         type = 0; ref_nested().clear();
31328                 }
31329                 template<typename V> static inline void enumerate(V& v)
31330                 {
31331
31332                 }
31333                 protected:
31334                 template<typename V> bool decode(size_t index, V& v)
31335                 {
31336                         clear();
31337                         switch(index)
31338                         {
31339                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
31340                         }
31341                         return false;
31342
31343                 }
31344                 template<typename V> bool encode(size_t index, V& v) const
31345                 {
31346                         if(index != type) return false;
31347                         return false;
31348
31349                 }
31350                 private:
31351                 size_t type {0};
31352
31353         };
31354         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
31355         {
31356                 size_t get_index() const {return type;}
31357                 bool is_unknown() const { return type == 1; }
31358                 void clear() {type = 0;}
31359                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
31360                 template<typename V>  bool decode(V& v)
31361                 {
31362                         clear();
31363                         if(!v(ref_nested())) return false;
31364                         { type = 1; return true;}
31365                         return false;
31366
31367                 }
31368                 template<typename V> bool encode(V& v) const
31369                 {
31370                         return v(ref_nested());
31371
31372                 }
31373                 protected:
31374                 template<typename V>  bool decode(size_t index, V& v)
31375                 {
31376                         clear();
31377                         switch(index)
31378                         {
31379                         case 1: type = 1; return v(ref_nested());
31380                         ref_nested().clear();
31381                         }
31382                         return false;
31383
31384                 }
31385                 template<typename V> bool encode(size_t index, V& v) const
31386                 {
31387                         if(index != type) {return false;} return v(ref_nested());
31388
31389                 }
31390                 private:
31391                 size_t type {0};
31392
31393         };
31394
31395 };
31396 /*
31397 ServedCell-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
31398         { ID id-Number-of-Antennaports                          CRITICALITY ignore      EXTENSION Number-of-Antennaports                                        PRESENCE optional}|
31399         { ID id-PRACH-Configuration                                     CRITICALITY ignore      EXTENSION PRACH-Configuration                                           PRESENCE optional}|
31400         { ID id-MBSFN-Subframe-Info                                     CRITICALITY ignore      EXTENSION MBSFN-Subframe-Infolist                               PRESENCE optional}|
31401         { ID id-CSG-Id                                                          CRITICALITY ignore      EXTENSION CSG-Id                                                                        PRESENCE optional}|
31402         { ID id-MBMS-Service-Area-List                          CRITICALITY ignore      EXTENSION MBMS-Service-Area-Identity-List               PRESENCE optional}|
31403         { ID id-MultibandInfoList                                       CRITICALITY ignore      EXTENSION MultibandInfoList                                                     PRESENCE optional}|
31404         { ID id-FreqBandIndicatorPriority                       CRITICALITY ignore      EXTENSION FreqBandIndicatorPriority                             PRESENCE optional}|
31405         { ID id-BandwidthReducedSI                                      CRITICALITY ignore      EXTENSION BandwidthReducedSI                                            PRESENCE optional}|
31406         { ID id-ProtectedEUTRAResourceIndication        CRITICALITY ignore      EXTENSION ProtectedEUTRAResourceIndication      PRESENCE optional},
31407         ...
31408 }
31409 */
31410
31411 struct ServedCell_Information_ExtIEs
31412 {
31413         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
31414         {
31415                 size_t get_index() const {return type;}
31416                 bool is_unknown() const { return type == 10; }
31417                 void clear() {type = 0;}
31418                 void select_id_Number_of_Antennaports() { set(id_Number_of_Antennaports); type=1;}
31419                 void select_id_PRACH_Configuration() { set(id_PRACH_Configuration); type=2;}
31420                 void select_id_MBSFN_Subframe_Info() { set(id_MBSFN_Subframe_Info); type=3;}
31421                 void select_id_CSG_Id() { set(id_CSG_Id); type=4;}
31422                 void select_id_MBMS_Service_Area_List() { set(id_MBMS_Service_Area_List); type=5;}
31423                 void select_id_MultibandInfoList() { set(id_MultibandInfoList); type=6;}
31424                 void select_id_FreqBandIndicatorPriority() { set(id_FreqBandIndicatorPriority); type=7;}
31425                 void select_id_BandwidthReducedSI() { set(id_BandwidthReducedSI); type=8;}
31426                 void select_id_ProtectedEUTRAResourceIndication() { set(id_ProtectedEUTRAResourceIndication); type=9;}
31427                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
31428                 template<typename V>  bool decode(V& v)
31429                 {
31430                         clear();
31431                         if(!v(ref_nested())) return false;
31432                         if(equal(id_Number_of_Antennaports)) { type = 1; return true; }
31433                         else if(equal(id_PRACH_Configuration)) { type = 2; return true; }
31434                         else if(equal(id_MBSFN_Subframe_Info)) { type = 3; return true; }
31435                         else if(equal(id_CSG_Id)) { type = 4; return true; }
31436                         else if(equal(id_MBMS_Service_Area_List)) { type = 5; return true; }
31437                         else if(equal(id_MultibandInfoList)) { type = 6; return true; }
31438                         else if(equal(id_FreqBandIndicatorPriority)) { type = 7; return true; }
31439                         else if(equal(id_BandwidthReducedSI)) { type = 8; return true; }
31440                         else if(equal(id_ProtectedEUTRAResourceIndication)) { type = 9; return true; }
31441                         else { type = 10; return true;}
31442                         return false;
31443
31444                 }
31445                 template<typename V> bool encode(V& v) const
31446                 {
31447                         return v(ref_nested());
31448
31449                 }
31450                 protected:
31451                 template<typename V>  bool decode(size_t index, V& v)
31452                 {
31453                         clear();
31454                         switch(index)
31455                         {
31456                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Number_of_Antennaports);} return false;
31457                         case 2: type = 2; if(v(ref_nested())) { return equal(id_PRACH_Configuration);} return false;
31458                         case 3: type = 3; if(v(ref_nested())) { return equal(id_MBSFN_Subframe_Info);} return false;
31459                         case 4: type = 4; if(v(ref_nested())) { return equal(id_CSG_Id);} return false;
31460                         case 5: type = 5; if(v(ref_nested())) { return equal(id_MBMS_Service_Area_List);} return false;
31461                         case 6: type = 6; if(v(ref_nested())) { return equal(id_MultibandInfoList);} return false;
31462                         case 7: type = 7; if(v(ref_nested())) { return equal(id_FreqBandIndicatorPriority);} return false;
31463                         case 8: type = 8; if(v(ref_nested())) { return equal(id_BandwidthReducedSI);} return false;
31464                         case 9: type = 9; if(v(ref_nested())) { return equal(id_ProtectedEUTRAResourceIndication);} return false;
31465                         case 10: type = 10; return v(ref_nested());
31466                         ref_nested().clear();
31467                         }
31468                         return false;
31469
31470                 }
31471                 template<typename V> bool encode(size_t index, V& v) const
31472                 {
31473                         if(index != type) {return false;} return v(ref_nested());
31474
31475                 }
31476                 private:
31477                 size_t type {0};
31478
31479         };
31480         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
31481         {
31482                 size_t get_index() const {return type;}
31483                 bool is_unknown() const { return type == 10; }
31484                 void clear() {type = 0;}
31485                 void select_id_Number_of_Antennaports() { set(ignore); type=1;}
31486                 void select_id_PRACH_Configuration() { set(ignore); type=2;}
31487                 void select_id_MBSFN_Subframe_Info() { set(ignore); type=3;}
31488                 void select_id_CSG_Id() { set(ignore); type=4;}
31489                 void select_id_MBMS_Service_Area_List() { set(ignore); type=5;}
31490                 void select_id_MultibandInfoList() { set(ignore); type=6;}
31491                 void select_id_FreqBandIndicatorPriority() { set(ignore); type=7;}
31492                 void select_id_BandwidthReducedSI() { set(ignore); type=8;}
31493                 void select_id_ProtectedEUTRAResourceIndication() { set(ignore); type=9;}
31494                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
31495                 template<typename V>  bool decode(V& v)
31496                 {
31497                         clear();
31498                         if(!v(ref_nested())) return false;
31499                         if(equal(ignore)) { type = 1; return true; }
31500                         else if(equal(ignore)) { type = 2; return true; }
31501                         else if(equal(ignore)) { type = 3; return true; }
31502                         else if(equal(ignore)) { type = 4; return true; }
31503                         else if(equal(ignore)) { type = 5; return true; }
31504                         else if(equal(ignore)) { type = 6; return true; }
31505                         else if(equal(ignore)) { type = 7; return true; }
31506                         else if(equal(ignore)) { type = 8; return true; }
31507                         else if(equal(ignore)) { type = 9; return true; }
31508                         else { type = 10; return true;}
31509                         return false;
31510
31511                 }
31512                 template<typename V> bool encode(V& v) const
31513                 {
31514                         return v(ref_nested());
31515
31516                 }
31517                 protected:
31518                 template<typename V>  bool decode(size_t index, V& v)
31519                 {
31520                         clear();
31521                         switch(index)
31522                         {
31523                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
31524                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
31525                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
31526                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
31527                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
31528                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
31529                         case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
31530                         case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
31531                         case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
31532                         case 10: type = 10; return v(ref_nested());
31533                         ref_nested().clear();
31534                         }
31535                         return false;
31536
31537                 }
31538                 template<typename V> bool encode(size_t index, V& v) const
31539                 {
31540                         if(index != type) {return false;} return v(ref_nested());
31541
31542                 }
31543                 private:
31544                 size_t type {0};
31545
31546         };
31547         struct Extension_t : asn::typefield<true>
31548         {
31549                 ~Extension_t()  {clear();}
31550                 size_t get_index() const {return type;}
31551                 Number_of_Antennaports& select_id_Number_of_Antennaports() { return set<Number_of_Antennaports>(1); }
31552                 Number_of_Antennaports const* get_id_Number_of_Antennaports() const { return get<Number_of_Antennaports>(1); }
31553                 PRACH_Configuration& select_id_PRACH_Configuration() { return set<PRACH_Configuration>(2); }
31554                 PRACH_Configuration const* get_id_PRACH_Configuration() const { return get<PRACH_Configuration>(2); }
31555                 MBSFN_Subframe_Infolist& select_id_MBSFN_Subframe_Info() { return set<MBSFN_Subframe_Infolist>(3); }
31556                 MBSFN_Subframe_Infolist const* get_id_MBSFN_Subframe_Info() const { return get<MBSFN_Subframe_Infolist>(3); }
31557                 CSG_Id& select_id_CSG_Id() { return set<CSG_Id>(4); }
31558                 CSG_Id const* get_id_CSG_Id() const { return get<CSG_Id>(4); }
31559                 MBMS_Service_Area_Identity_List& select_id_MBMS_Service_Area_List() { return set<MBMS_Service_Area_Identity_List>(5); }
31560                 MBMS_Service_Area_Identity_List const* get_id_MBMS_Service_Area_List() const { return get<MBMS_Service_Area_Identity_List>(5); }
31561                 MultibandInfoList& select_id_MultibandInfoList() { return set<MultibandInfoList>(6); }
31562                 MultibandInfoList const* get_id_MultibandInfoList() const { return get<MultibandInfoList>(6); }
31563                 FreqBandIndicatorPriority& select_id_FreqBandIndicatorPriority() { return set<FreqBandIndicatorPriority>(7); }
31564                 FreqBandIndicatorPriority const* get_id_FreqBandIndicatorPriority() const { return get<FreqBandIndicatorPriority>(7); }
31565                 BandwidthReducedSI& select_id_BandwidthReducedSI() { return set<BandwidthReducedSI>(8); }
31566                 BandwidthReducedSI const* get_id_BandwidthReducedSI() const { return get<BandwidthReducedSI>(8); }
31567                 ProtectedEUTRAResourceIndication& select_id_ProtectedEUTRAResourceIndication() { return set<ProtectedEUTRAResourceIndication>(9); }
31568                 ProtectedEUTRAResourceIndication const* get_id_ProtectedEUTRAResourceIndication() const { return get<ProtectedEUTRAResourceIndication>(9); }
31569                 bool is_unknown() const { return type == 10; }
31570                 void clear()
31571                 {
31572                         switch(type)
31573                         {
31574                         case 1: var.destroy<Number_of_Antennaports>(); break;
31575                         case 2: var.destroy<PRACH_Configuration>(); break;
31576                         case 3: var.destroy<MBSFN_Subframe_Infolist>(); break;
31577                         case 4: var.destroy<CSG_Id>(); break;
31578                         case 5: var.destroy<MBMS_Service_Area_Identity_List>(); break;
31579                         case 6: var.destroy<MultibandInfoList>(); break;
31580                         case 7: var.destroy<FreqBandIndicatorPriority>(); break;
31581                         case 8: var.destroy<BandwidthReducedSI>(); break;
31582                         case 9: var.destroy<ProtectedEUTRAResourceIndication>(); break;
31583                         }
31584                         type = 0; ref_nested().clear();
31585                 }
31586                 template<typename V> static inline void enumerate(V& v)
31587                 {
31588                         v.template operator()<Number_of_Antennaports>(1);
31589                         v.template operator()<PRACH_Configuration>(2);
31590                         v.template operator()<MBSFN_Subframe_Infolist>(3);
31591                         v.template operator()<CSG_Id>(4);
31592                         v.template operator()<MBMS_Service_Area_Identity_List>(5);
31593                         v.template operator()<MultibandInfoList>(6);
31594                         v.template operator()<FreqBandIndicatorPriority>(7);
31595                         v.template operator()<BandwidthReducedSI>(8);
31596                         v.template operator()<ProtectedEUTRAResourceIndication>(9);
31597
31598                 }
31599                 protected:
31600                 template<typename V> bool decode(size_t index, V& v)
31601                 {
31602                         clear();
31603                         switch(index)
31604                         {
31605                         case 1: v(select_id_Number_of_Antennaports()); return true;
31606                         case 2: v(select_id_PRACH_Configuration()); return true;
31607                         case 3: v(select_id_MBSFN_Subframe_Info()); return true;
31608                         case 4: v(select_id_CSG_Id()); return true;
31609                         case 5: v(select_id_MBMS_Service_Area_List()); return true;
31610                         case 6: v(select_id_MultibandInfoList()); return true;
31611                         case 7: v(select_id_FreqBandIndicatorPriority()); return true;
31612                         case 8: v(select_id_BandwidthReducedSI()); return true;
31613                         case 9: v(select_id_ProtectedEUTRAResourceIndication()); return true;
31614                         case 10: if(type != 10) {clear(); asn::base::set();} type = 10; return true;
31615                         }
31616                         return false;
31617
31618                 }
31619                 template<typename V> bool encode(size_t index, V& v) const
31620                 {
31621                         if(index != type) return false;
31622                         switch(type)
31623                         {
31624                         case 1: v(var.as<Number_of_Antennaports>()); return true;
31625                         case 2: v(var.as<PRACH_Configuration>()); return true;
31626                         case 3: v(var.as<MBSFN_Subframe_Infolist>()); return true;
31627                         case 4: v(var.as<CSG_Id>()); return true;
31628                         case 5: v(var.as<MBMS_Service_Area_Identity_List>()); return true;
31629                         case 6: v(var.as<MultibandInfoList>()); return true;
31630                         case 7: v(var.as<FreqBandIndicatorPriority>()); return true;
31631                         case 8: v(var.as<BandwidthReducedSI>()); return true;
31632                         case 9: v(var.as<ProtectedEUTRAResourceIndication>()); return true;
31633                         }
31634                         return false;
31635
31636                 }
31637                 private:
31638                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
31639                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
31640                 union union_type
31641                 {
31642                         char dummy1[sizeof(BandwidthReducedSI)];
31643                         char dummy2[sizeof(CSG_Id)];
31644                         char dummy3[sizeof(FreqBandIndicatorPriority)];
31645                         char dummy4[sizeof(MBMS_Service_Area_Identity_List)];
31646                         char dummy5[sizeof(MBSFN_Subframe_Infolist)];
31647                         char dummy6[sizeof(MultibandInfoList)];
31648                         char dummy7[sizeof(Number_of_Antennaports)];
31649                         char dummy8[sizeof(PRACH_Configuration)];
31650                         char dummy9[sizeof(ProtectedEUTRAResourceIndication)];
31651
31652                 };
31653                 asn::variant<sizeof(union_type)> var;
31654                 size_t type {0};
31655
31656         };
31657         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
31658         {
31659                 size_t get_index() const {return type;}
31660                 bool is_unknown() const { return type == 10; }
31661                 void clear() {type = 0;}
31662                 void select_id_Number_of_Antennaports() { set(optional); type=1;}
31663                 void select_id_PRACH_Configuration() { set(optional); type=2;}
31664                 void select_id_MBSFN_Subframe_Info() { set(optional); type=3;}
31665                 void select_id_CSG_Id() { set(optional); type=4;}
31666                 void select_id_MBMS_Service_Area_List() { set(optional); type=5;}
31667                 void select_id_MultibandInfoList() { set(optional); type=6;}
31668                 void select_id_FreqBandIndicatorPriority() { set(optional); type=7;}
31669                 void select_id_BandwidthReducedSI() { set(optional); type=8;}
31670                 void select_id_ProtectedEUTRAResourceIndication() { set(optional); type=9;}
31671                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
31672                 template<typename V>  bool decode(V& v)
31673                 {
31674                         clear();
31675                         if(!v(ref_nested())) return false;
31676                         if(equal(optional)) { type = 1; return true; }
31677                         else if(equal(optional)) { type = 2; return true; }
31678                         else if(equal(optional)) { type = 3; return true; }
31679                         else if(equal(optional)) { type = 4; return true; }
31680                         else if(equal(optional)) { type = 5; return true; }
31681                         else if(equal(optional)) { type = 6; return true; }
31682                         else if(equal(optional)) { type = 7; return true; }
31683                         else if(equal(optional)) { type = 8; return true; }
31684                         else if(equal(optional)) { type = 9; return true; }
31685                         else { type = 10; return true;}
31686                         return false;
31687
31688                 }
31689                 template<typename V> bool encode(V& v) const
31690                 {
31691                         return v(ref_nested());
31692
31693                 }
31694                 protected:
31695                 template<typename V>  bool decode(size_t index, V& v)
31696                 {
31697                         clear();
31698                         switch(index)
31699                         {
31700                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
31701                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
31702                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
31703                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
31704                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
31705                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
31706                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
31707                         case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
31708                         case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
31709                         case 10: type = 10; return v(ref_nested());
31710                         ref_nested().clear();
31711                         }
31712                         return false;
31713
31714                 }
31715                 template<typename V> bool encode(size_t index, V& v) const
31716                 {
31717                         if(index != type) {return false;} return v(ref_nested());
31718
31719                 }
31720                 private:
31721                 size_t type {0};
31722
31723         };
31724
31725 };
31726 /*
31727 ServedCell-Information ::= SEQUENCE {
31728         pCI                                     PCI,
31729         cellId                          ECGI,
31730         tAC                                     TAC,
31731         broadcastPLMNs          BroadcastPLMNs-Item,
31732         eUTRA-Mode-Info         EUTRA-Mode-Info,
31733         iE-Extensions           ProtocolExtensionContainer { {ServedCell-Information-ExtIEs} } OPTIONAL,
31734         ...
31735 }
31736 */
31737
31738 struct ServedCell_Information : asn::sequence<6, 0, true, 1>
31739 {
31740         static constexpr const char* name() {return "ServedCell-Information";}
31741         using parent_t = asn::sequence<6, 0, true, 1>;
31742         struct pCI_t : PCI
31743         {
31744                 static constexpr const char* name() {return "pCI_t";}
31745                 using parent_t = PCI;
31746
31747         };
31748         pCI_t& ref_pCI() {return pCI;}
31749         pCI_t const& ref_pCI() const {return pCI;}
31750         struct cellId_t : ECGI
31751         {
31752                 static constexpr const char* name() {return "cellId_t";}
31753                 using parent_t = ECGI;
31754
31755         };
31756         cellId_t& ref_cellId() {return cellId;}
31757         cellId_t const& ref_cellId() const {return cellId;}
31758         struct tAC_t : TAC
31759         {
31760                 static constexpr const char* name() {return "tAC_t";}
31761                 using parent_t = TAC;
31762
31763         };
31764         tAC_t& ref_tAC() {return tAC;}
31765         tAC_t const& ref_tAC() const {return tAC;}
31766         struct broadcastPLMNs_t : BroadcastPLMNs_Item
31767         {
31768                 static constexpr const char* name() {return "broadcastPLMNs_t";}
31769                 using parent_t = BroadcastPLMNs_Item;
31770
31771         };
31772         broadcastPLMNs_t& ref_broadcastPLMNs() {return broadcastPLMNs;}
31773         broadcastPLMNs_t const& ref_broadcastPLMNs() const {return broadcastPLMNs;}
31774         struct eUTRA_Mode_Info_t : EUTRA_Mode_Info
31775         {
31776                 static constexpr const char* name() {return "eUTRA_Mode_Info_t";}
31777                 using parent_t = EUTRA_Mode_Info;
31778
31779         };
31780         eUTRA_Mode_Info_t& ref_eUTRA_Mode_Info() {return eUTRA_Mode_Info;}
31781         eUTRA_Mode_Info_t const& ref_eUTRA_Mode_Info() const {return eUTRA_Mode_Info;}
31782         struct iE_Extensions_t : ProtocolExtensionContainer<ServedCell_Information_ExtIEs>
31783         {
31784                 static constexpr const char* name() {return "iE_Extensions_t";}
31785                 using parent_t = ProtocolExtensionContainer<ServedCell_Information_ExtIEs>;
31786                 static constexpr bool optional = true;
31787
31788         };
31789         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
31790         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
31791         template<typename V> void decode(V& v)
31792         {
31793                 v(pCI);
31794                 v(cellId);
31795                 v(tAC);
31796                 v(broadcastPLMNs);
31797                 v(eUTRA_Mode_Info);
31798                 v(iE_Extensions);
31799
31800         };
31801         template<typename V> void encode(V& v) const
31802         {
31803                 v(pCI);
31804                 v(cellId);
31805                 v(tAC);
31806                 v(broadcastPLMNs);
31807                 v(eUTRA_Mode_Info);
31808                 v(iE_Extensions);
31809
31810         };
31811         void clear()
31812         {
31813                 pCI.clear();
31814                 cellId.clear();
31815                 tAC.clear();
31816                 broadcastPLMNs.clear();
31817                 eUTRA_Mode_Info.clear();
31818                 iE_Extensions.clear();
31819
31820         };
31821         private:
31822         pCI_t   pCI;
31823         cellId_t        cellId;
31824         tAC_t   tAC;
31825         broadcastPLMNs_t        broadcastPLMNs;
31826         eUTRA_Mode_Info_t       eUTRA_Mode_Info;
31827         iE_Extensions_t iE_Extensions;
31828
31829 };
31830 /*
31831 ServedCells ::= SEQUENCE (SIZE (1.. maxCellineNB)) OF SEQUENCE {
31832         servedCellInfo                                  ServedCell-Information,
31833         neighbour-Info                                  Neighbour-Information                   OPTIONAL,
31834         iE-Extensions                                   ProtocolExtensionContainer { {ServedCell-ExtIEs} } OPTIONAL,
31835         ...
31836 }
31837 */
31838
31839 struct ServedCells_elm : asn::sequence<3, 0, true, 2>
31840 {
31841         static constexpr const char* name() {return "ServedCells_elm";}
31842         using parent_t = asn::sequence<3, 0, true, 2>;
31843         struct servedCellInfo_t : ServedCell_Information
31844         {
31845                 static constexpr const char* name() {return "servedCellInfo_t";}
31846                 using parent_t = ServedCell_Information;
31847
31848         };
31849         servedCellInfo_t& ref_servedCellInfo() {return servedCellInfo;}
31850         servedCellInfo_t const& ref_servedCellInfo() const {return servedCellInfo;}
31851         struct neighbour_Info_t : Neighbour_Information
31852         {
31853                 static constexpr const char* name() {return "neighbour_Info_t";}
31854                 using parent_t = Neighbour_Information;
31855                 static constexpr bool optional = true;
31856
31857         };
31858         neighbour_Info_t& set_neighbour_Info() { neighbour_Info.setpresent(true); return neighbour_Info;}
31859         neighbour_Info_t const* get_neighbour_Info() const {return neighbour_Info.is_valid() ? &neighbour_Info : nullptr;}
31860         struct iE_Extensions_t : ProtocolExtensionContainer<ServedCell_ExtIEs>
31861         {
31862                 static constexpr const char* name() {return "iE_Extensions_t";}
31863                 using parent_t = ProtocolExtensionContainer<ServedCell_ExtIEs>;
31864                 static constexpr bool optional = true;
31865
31866         };
31867         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
31868         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
31869         template<typename V> void decode(V& v)
31870         {
31871                 v(servedCellInfo);
31872                 v(neighbour_Info);
31873                 v(iE_Extensions);
31874
31875         };
31876         template<typename V> void encode(V& v) const
31877         {
31878                 v(servedCellInfo);
31879                 v(neighbour_Info);
31880                 v(iE_Extensions);
31881
31882         };
31883         void clear()
31884         {
31885                 servedCellInfo.clear();
31886                 neighbour_Info.clear();
31887                 iE_Extensions.clear();
31888
31889         };
31890         private:
31891         servedCellInfo_t        servedCellInfo;
31892         neighbour_Info_t        neighbour_Info;
31893         iE_Extensions_t iE_Extensions;
31894
31895 };
31896 struct ServedCells : asn::sequenceof<ServedCells_elm>
31897 {
31898         static constexpr const char* name() {return "ServedCells";}
31899         using parent_t = asn::sequenceof<ServedCells_elm>;
31900         using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
31901
31902 };
31903 /*
31904 ServiceType ::= ENUMERATED{
31905         qMC-for-streaming-service,
31906         qMC-for-MTSI-service,
31907         ...
31908 }
31909 */
31910
31911 struct ServiceType : asn::enumerated<2, 0, true>
31912 {
31913         static constexpr const char* name() {return "ServiceType";}
31914         using parent_t = asn::enumerated<2, 0, true>;
31915         typedef enum {
31916                 qMC_for_streaming_service
31917                 ,qMC_for_MTSI_service
31918         } index_t;
31919
31920 };
31921
31922 /*
31923 SgNB-UE-X2AP-ID ::= INTEGER (0..4294967295)
31924 */
31925
31926 struct SgNB_UE_X2AP_ID : asn::integer<>
31927 {
31928         using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
31929         static constexpr const char* name() {return "SgNB-UE-X2AP-ID";}
31930         using parent_t = asn::integer<>;
31931
31932 };
31933
31934 /*
31935 SgNBCoordinationAssistanceInformation ::= ENUMERATED{
31936         coordination-not-required,
31937         ...
31938 }
31939 */
31940
31941 struct SgNBCoordinationAssistanceInformation : asn::enumerated<1, 0, true>
31942 {
31943         static constexpr const char* name() {return "SgNBCoordinationAssistanceInformation";}
31944         using parent_t = asn::enumerated<1, 0, true>;
31945         typedef enum {
31946                 coordination_not_required
31947         } index_t;
31948
31949 };
31950
31951 /*
31952 SgNBResourceCoordinationInformationExtIEs X2AP-PROTOCOL-EXTENSION ::= {
31953         { ID id-ECGI                                                                            CRITICALITY ignore      EXTENSION ECGI                                                                                          PRESENCE optional}|
31954         { ID id-SgNBCoordinationAssistanceInformation           CRITICALITY reject      EXTENSION SgNBCoordinationAssistanceInformation PRESENCE optional},
31955         ...
31956 }
31957 */
31958
31959 struct SgNBResourceCoordinationInformationExtIEs
31960 {
31961         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
31962         {
31963                 size_t get_index() const {return type;}
31964                 bool is_unknown() const { return type == 3; }
31965                 void clear() {type = 0;}
31966                 void select_id_ECGI() { set(id_ECGI); type=1;}
31967                 void select_id_SgNBCoordinationAssistanceInformation() { set(id_SgNBCoordinationAssistanceInformation); type=2;}
31968                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
31969                 template<typename V>  bool decode(V& v)
31970                 {
31971                         clear();
31972                         if(!v(ref_nested())) return false;
31973                         if(equal(id_ECGI)) { type = 1; return true; }
31974                         else if(equal(id_SgNBCoordinationAssistanceInformation)) { type = 2; return true; }
31975                         else { type = 3; return true;}
31976                         return false;
31977
31978                 }
31979                 template<typename V> bool encode(V& v) const
31980                 {
31981                         return v(ref_nested());
31982
31983                 }
31984                 protected:
31985                 template<typename V>  bool decode(size_t index, V& v)
31986                 {
31987                         clear();
31988                         switch(index)
31989                         {
31990                         case 1: type = 1; if(v(ref_nested())) { return equal(id_ECGI);} return false;
31991                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNBCoordinationAssistanceInformation);} return false;
31992                         case 3: type = 3; return v(ref_nested());
31993                         ref_nested().clear();
31994                         }
31995                         return false;
31996
31997                 }
31998                 template<typename V> bool encode(size_t index, V& v) const
31999                 {
32000                         if(index != type) {return false;} return v(ref_nested());
32001
32002                 }
32003                 private:
32004                 size_t type {0};
32005
32006         };
32007         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
32008         {
32009                 size_t get_index() const {return type;}
32010                 bool is_unknown() const { return type == 3; }
32011                 void clear() {type = 0;}
32012                 void select_id_ECGI() { set(ignore); type=1;}
32013                 void select_id_SgNBCoordinationAssistanceInformation() { set(reject); type=2;}
32014                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
32015                 template<typename V>  bool decode(V& v)
32016                 {
32017                         clear();
32018                         if(!v(ref_nested())) return false;
32019                         if(equal(ignore)) { type = 1; return true; }
32020                         else if(equal(reject)) { type = 2; return true; }
32021                         else { type = 3; return true;}
32022                         return false;
32023
32024                 }
32025                 template<typename V> bool encode(V& v) const
32026                 {
32027                         return v(ref_nested());
32028
32029                 }
32030                 protected:
32031                 template<typename V>  bool decode(size_t index, V& v)
32032                 {
32033                         clear();
32034                         switch(index)
32035                         {
32036                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
32037                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
32038                         case 3: type = 3; return v(ref_nested());
32039                         ref_nested().clear();
32040                         }
32041                         return false;
32042
32043                 }
32044                 template<typename V> bool encode(size_t index, V& v) const
32045                 {
32046                         if(index != type) {return false;} return v(ref_nested());
32047
32048                 }
32049                 private:
32050                 size_t type {0};
32051
32052         };
32053         struct Extension_t : asn::typefield<true>
32054         {
32055                 ~Extension_t()  {clear();}
32056                 size_t get_index() const {return type;}
32057                 ECGI& select_id_ECGI() { return set<ECGI>(1); }
32058                 ECGI const* get_id_ECGI() const { return get<ECGI>(1); }
32059                 SgNBCoordinationAssistanceInformation& select_id_SgNBCoordinationAssistanceInformation() { return set<SgNBCoordinationAssistanceInformation>(2); }
32060                 SgNBCoordinationAssistanceInformation const* get_id_SgNBCoordinationAssistanceInformation() const { return get<SgNBCoordinationAssistanceInformation>(2); }
32061                 bool is_unknown() const { return type == 3; }
32062                 void clear()
32063                 {
32064                         switch(type)
32065                         {
32066                         case 1: var.destroy<ECGI>(); break;
32067                         case 2: var.destroy<SgNBCoordinationAssistanceInformation>(); break;
32068                         }
32069                         type = 0; ref_nested().clear();
32070                 }
32071                 template<typename V> static inline void enumerate(V& v)
32072                 {
32073                         v.template operator()<ECGI>(1);
32074                         v.template operator()<SgNBCoordinationAssistanceInformation>(2);
32075
32076                 }
32077                 protected:
32078                 template<typename V> bool decode(size_t index, V& v)
32079                 {
32080                         clear();
32081                         switch(index)
32082                         {
32083                         case 1: v(select_id_ECGI()); return true;
32084                         case 2: v(select_id_SgNBCoordinationAssistanceInformation()); return true;
32085                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
32086                         }
32087                         return false;
32088
32089                 }
32090                 template<typename V> bool encode(size_t index, V& v) const
32091                 {
32092                         if(index != type) return false;
32093                         switch(type)
32094                         {
32095                         case 1: v(var.as<ECGI>()); return true;
32096                         case 2: v(var.as<SgNBCoordinationAssistanceInformation>()); return true;
32097                         }
32098                         return false;
32099
32100                 }
32101                 private:
32102                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
32103                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
32104                 union union_type
32105                 {
32106                         char dummy1[sizeof(ECGI)];
32107                         char dummy2[sizeof(SgNBCoordinationAssistanceInformation)];
32108
32109                 };
32110                 asn::variant<sizeof(union_type)> var;
32111                 size_t type {0};
32112
32113         };
32114         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
32115         {
32116                 size_t get_index() const {return type;}
32117                 bool is_unknown() const { return type == 3; }
32118                 void clear() {type = 0;}
32119                 void select_id_ECGI() { set(optional); type=1;}
32120                 void select_id_SgNBCoordinationAssistanceInformation() { set(optional); type=2;}
32121                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
32122                 template<typename V>  bool decode(V& v)
32123                 {
32124                         clear();
32125                         if(!v(ref_nested())) return false;
32126                         if(equal(optional)) { type = 1; return true; }
32127                         else if(equal(optional)) { type = 2; return true; }
32128                         else { type = 3; return true;}
32129                         return false;
32130
32131                 }
32132                 template<typename V> bool encode(V& v) const
32133                 {
32134                         return v(ref_nested());
32135
32136                 }
32137                 protected:
32138                 template<typename V>  bool decode(size_t index, V& v)
32139                 {
32140                         clear();
32141                         switch(index)
32142                         {
32143                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
32144                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
32145                         case 3: type = 3; return v(ref_nested());
32146                         ref_nested().clear();
32147                         }
32148                         return false;
32149
32150                 }
32151                 template<typename V> bool encode(size_t index, V& v) const
32152                 {
32153                         if(index != type) {return false;} return v(ref_nested());
32154
32155                 }
32156                 private:
32157                 size_t type {0};
32158
32159         };
32160
32161 };
32162 /*
32163 SgNBResourceCoordinationInformation ::= SEQUENCE {
32164         nR-CGI                                                  NRCGI,
32165         uLCoordinationInformation               BIT STRING (SIZE(6..4400, ...)),
32166         dLCoordinationInformation               BIT STRING (SIZE(6..4400, ...)) OPTIONAL,
32167         iE-Extensions                                   ProtocolExtensionContainer { {SgNBResourceCoordinationInformationExtIEs} }               OPTIONAL,
32168         ...
32169 }
32170 */
32171
32172 struct SgNBResourceCoordinationInformation : asn::sequence<4, 0, true, 2>
32173 {
32174         static constexpr const char* name() {return "SgNBResourceCoordinationInformation";}
32175         using parent_t = asn::sequence<4, 0, true, 2>;
32176         struct nR_CGI_t : NRCGI
32177         {
32178                 static constexpr const char* name() {return "nR_CGI_t";}
32179                 using parent_t = NRCGI;
32180
32181         };
32182         nR_CGI_t& ref_nR_CGI() {return nR_CGI;}
32183         nR_CGI_t const& ref_nR_CGI() const {return nR_CGI;}
32184         struct uLCoordinationInformation_t : asn::bstring<>
32185         {
32186                 using constraint_t = asn::constraints<true,asn::span<6, 4400>>;
32187                 static constexpr const char* name() {return "uLCoordinationInformation_t";}
32188                 using parent_t = asn::bstring<>;
32189
32190         };
32191
32192         uLCoordinationInformation_t& ref_uLCoordinationInformation() {return uLCoordinationInformation;}
32193         uLCoordinationInformation_t const& ref_uLCoordinationInformation() const {return uLCoordinationInformation;}
32194         struct dLCoordinationInformation_t : asn::bstring<>
32195         {
32196                 using constraint_t = asn::constraints<true,asn::span<6, 4400>>;
32197                 static constexpr const char* name() {return "dLCoordinationInformation_t";}
32198                 using parent_t = asn::bstring<>;
32199                 static constexpr bool optional = true;
32200
32201         };
32202
32203         dLCoordinationInformation_t& set_dLCoordinationInformation() { dLCoordinationInformation.setpresent(true); return dLCoordinationInformation;}
32204         dLCoordinationInformation_t const* get_dLCoordinationInformation() const {return dLCoordinationInformation.is_valid() ? &dLCoordinationInformation : nullptr;}
32205         struct iE_Extensions_t : ProtocolExtensionContainer<SgNBResourceCoordinationInformationExtIEs>
32206         {
32207                 static constexpr const char* name() {return "iE_Extensions_t";}
32208                 using parent_t = ProtocolExtensionContainer<SgNBResourceCoordinationInformationExtIEs>;
32209                 static constexpr bool optional = true;
32210
32211         };
32212         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
32213         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
32214         template<typename V> void decode(V& v)
32215         {
32216                 v(nR_CGI);
32217                 v(uLCoordinationInformation);
32218                 v(dLCoordinationInformation);
32219                 v(iE_Extensions);
32220
32221         };
32222         template<typename V> void encode(V& v) const
32223         {
32224                 v(nR_CGI);
32225                 v(uLCoordinationInformation);
32226                 v(dLCoordinationInformation);
32227                 v(iE_Extensions);
32228
32229         };
32230         void clear()
32231         {
32232                 nR_CGI.clear();
32233                 uLCoordinationInformation.clear();
32234                 dLCoordinationInformation.clear();
32235                 iE_Extensions.clear();
32236
32237         };
32238         private:
32239         nR_CGI_t        nR_CGI;
32240         uLCoordinationInformation_t     uLCoordinationInformation;
32241         dLCoordinationInformation_t     dLCoordinationInformation;
32242         iE_Extensions_t iE_Extensions;
32243
32244 };
32245 /*
32246 SgNBSecurityKey ::= BIT STRING (SIZE(256))
32247 */
32248
32249 struct SgNBSecurityKey : asn::bstring<>
32250 {
32251         using constraint_t = asn::constraints<false,asn::one<256>>;
32252         static constexpr const char* name() {return "SgNBSecurityKey";}
32253         using parent_t = asn::bstring<>;
32254
32255 };
32256
32257 /*
32258 SgNBtoMeNBContainer ::= OCTET STRING
32259 */
32260
32261 struct SgNBtoMeNBContainer : asn::ostring<>
32262 {
32263         static constexpr const char* name() {return "SgNBtoMeNBContainer";}
32264         using parent_t = asn::ostring<>;
32265
32266 };
32267
32268 /*
32269 ShortMAC-I ::= BIT STRING (SIZE(16))
32270 */
32271
32272 struct ShortMAC_I : asn::bstring<>
32273 {
32274         using constraint_t = asn::constraints<false,asn::one<16>>;
32275         static constexpr const char* name() {return "ShortMAC-I";}
32276         using parent_t = asn::bstring<>;
32277
32278 };
32279
32280 /*
32281 SpectrumSharingGroupID ::= INTEGER (1..maxCellineNB)
32282 */
32283
32284 struct SpectrumSharingGroupID : asn::integer<>
32285 {
32286         using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
32287         static constexpr const char* name() {return "SpectrumSharingGroupID";}
32288         using parent_t = asn::integer<>;
32289
32290 };
32291
32292 /*
32293 SplitSRB-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
32294         ...
32295 }
32296 */
32297
32298 struct SplitSRB_ExtIEs
32299 {
32300         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
32301         {
32302                 size_t get_index() const {return type;}
32303                 bool is_unknown() const { return type == 1; }
32304                 void clear() {type = 0;}
32305                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
32306                 template<typename V>  bool decode(V& v)
32307                 {
32308                         clear();
32309                         if(!v(ref_nested())) return false;
32310                         { type = 1; return true;}
32311                         return false;
32312
32313                 }
32314                 template<typename V> bool encode(V& v) const
32315                 {
32316                         return v(ref_nested());
32317
32318                 }
32319                 protected:
32320                 template<typename V>  bool decode(size_t index, V& v)
32321                 {
32322                         clear();
32323                         switch(index)
32324                         {
32325                         case 1: type = 1; return v(ref_nested());
32326                         ref_nested().clear();
32327                         }
32328                         return false;
32329
32330                 }
32331                 template<typename V> bool encode(size_t index, V& v) const
32332                 {
32333                         if(index != type) {return false;} return v(ref_nested());
32334
32335                 }
32336                 private:
32337                 size_t type {0};
32338
32339         };
32340         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
32341         {
32342                 size_t get_index() const {return type;}
32343                 bool is_unknown() const { return type == 1; }
32344                 void clear() {type = 0;}
32345                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
32346                 template<typename V>  bool decode(V& v)
32347                 {
32348                         clear();
32349                         if(!v(ref_nested())) return false;
32350                         { type = 1; return true;}
32351                         return false;
32352
32353                 }
32354                 template<typename V> bool encode(V& v) const
32355                 {
32356                         return v(ref_nested());
32357
32358                 }
32359                 protected:
32360                 template<typename V>  bool decode(size_t index, V& v)
32361                 {
32362                         clear();
32363                         switch(index)
32364                         {
32365                         case 1: type = 1; return v(ref_nested());
32366                         ref_nested().clear();
32367                         }
32368                         return false;
32369
32370                 }
32371                 template<typename V> bool encode(size_t index, V& v) const
32372                 {
32373                         if(index != type) {return false;} return v(ref_nested());
32374
32375                 }
32376                 private:
32377                 size_t type {0};
32378
32379         };
32380         struct Extension_t : asn::typefield<true>
32381         {
32382                 ~Extension_t()  {clear();}
32383                 size_t get_index() const {return type;}
32384                 bool is_unknown() const { return type == 1; }
32385                 void clear()
32386                 {
32387                         type = 0; ref_nested().clear();
32388                 }
32389                 template<typename V> static inline void enumerate(V& v)
32390                 {
32391
32392                 }
32393                 protected:
32394                 template<typename V> bool decode(size_t index, V& v)
32395                 {
32396                         clear();
32397                         switch(index)
32398                         {
32399                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
32400                         }
32401                         return false;
32402
32403                 }
32404                 template<typename V> bool encode(size_t index, V& v) const
32405                 {
32406                         if(index != type) return false;
32407                         return false;
32408
32409                 }
32410                 private:
32411                 size_t type {0};
32412
32413         };
32414         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
32415         {
32416                 size_t get_index() const {return type;}
32417                 bool is_unknown() const { return type == 1; }
32418                 void clear() {type = 0;}
32419                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
32420                 template<typename V>  bool decode(V& v)
32421                 {
32422                         clear();
32423                         if(!v(ref_nested())) return false;
32424                         { type = 1; return true;}
32425                         return false;
32426
32427                 }
32428                 template<typename V> bool encode(V& v) const
32429                 {
32430                         return v(ref_nested());
32431
32432                 }
32433                 protected:
32434                 template<typename V>  bool decode(size_t index, V& v)
32435                 {
32436                         clear();
32437                         switch(index)
32438                         {
32439                         case 1: type = 1; return v(ref_nested());
32440                         ref_nested().clear();
32441                         }
32442                         return false;
32443
32444                 }
32445                 template<typename V> bool encode(size_t index, V& v) const
32446                 {
32447                         if(index != type) {return false;} return v(ref_nested());
32448
32449                 }
32450                 private:
32451                 size_t type {0};
32452
32453         };
32454
32455 };
32456 /*
32457 SplitSRB ::= SEQUENCE {
32458         rrcContainer                            RRCContainer                    OPTIONAL,
32459         srbType                                         SRBType,
32460         deliveryStatus                          DeliveryStatus                  OPTIONAL,
32461         iE-Extensions                           ProtocolExtensionContainer { {SplitSRB-ExtIEs} } OPTIONAL,
32462         ...
32463 }
32464 */
32465
32466 struct SplitSRB : asn::sequence<4, 0, true, 3>
32467 {
32468         static constexpr const char* name() {return "SplitSRB";}
32469         using parent_t = asn::sequence<4, 0, true, 3>;
32470         struct rrcContainer_t : RRCContainer
32471         {
32472                 static constexpr const char* name() {return "rrcContainer_t";}
32473                 using parent_t = RRCContainer;
32474                 static constexpr bool optional = true;
32475
32476         };
32477         rrcContainer_t& set_rrcContainer() { rrcContainer.setpresent(true); return rrcContainer;}
32478         rrcContainer_t const* get_rrcContainer() const {return rrcContainer.is_valid() ? &rrcContainer : nullptr;}
32479         struct srbType_t : SRBType
32480         {
32481                 static constexpr const char* name() {return "srbType_t";}
32482                 using parent_t = SRBType;
32483
32484         };
32485         srbType_t& ref_srbType() {return srbType;}
32486         srbType_t const& ref_srbType() const {return srbType;}
32487         struct deliveryStatus_t : DeliveryStatus
32488         {
32489                 static constexpr const char* name() {return "deliveryStatus_t";}
32490                 using parent_t = DeliveryStatus;
32491                 static constexpr bool optional = true;
32492
32493         };
32494         deliveryStatus_t& set_deliveryStatus() { deliveryStatus.setpresent(true); return deliveryStatus;}
32495         deliveryStatus_t const* get_deliveryStatus() const {return deliveryStatus.is_valid() ? &deliveryStatus : nullptr;}
32496         struct iE_Extensions_t : ProtocolExtensionContainer<SplitSRB_ExtIEs>
32497         {
32498                 static constexpr const char* name() {return "iE_Extensions_t";}
32499                 using parent_t = ProtocolExtensionContainer<SplitSRB_ExtIEs>;
32500                 static constexpr bool optional = true;
32501
32502         };
32503         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
32504         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
32505         template<typename V> void decode(V& v)
32506         {
32507                 v(rrcContainer);
32508                 v(srbType);
32509                 v(deliveryStatus);
32510                 v(iE_Extensions);
32511
32512         };
32513         template<typename V> void encode(V& v) const
32514         {
32515                 v(rrcContainer);
32516                 v(srbType);
32517                 v(deliveryStatus);
32518                 v(iE_Extensions);
32519
32520         };
32521         void clear()
32522         {
32523                 rrcContainer.clear();
32524                 srbType.clear();
32525                 deliveryStatus.clear();
32526                 iE_Extensions.clear();
32527
32528         };
32529         private:
32530         rrcContainer_t  rrcContainer;
32531         srbType_t       srbType;
32532         deliveryStatus_t        deliveryStatus;
32533         iE_Extensions_t iE_Extensions;
32534
32535 };
32536 /*
32537 SplitSRBs ::= ENUMERATED {srb1, srb2, srb1and2, ...}
32538 */
32539
32540 struct SplitSRBs : asn::enumerated<3, 0, true>
32541 {
32542         static constexpr const char* name() {return "SplitSRBs";}
32543         using parent_t = asn::enumerated<3, 0, true>;
32544         typedef enum {
32545                 srb1
32546                 ,srb2
32547                 ,srb1and2
32548         } index_t;
32549
32550 };
32551
32552 /*
32553 SubscriberProfileIDforRFP ::= INTEGER (1..256)
32554 */
32555
32556 struct SubscriberProfileIDforRFP : asn::integer<>
32557 {
32558         using constraint_t = asn::constraints<false,asn::span<1, 256>>;
32559         static constexpr const char* name() {return "SubscriberProfileIDforRFP";}
32560         using parent_t = asn::integer<>;
32561
32562 };
32563
32564 /*
32565 Subscription-Based-UE-DifferentiationInfo-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
32566         ...
32567 }
32568 */
32569
32570 struct Subscription_Based_UE_DifferentiationInfo_ExtIEs
32571 {
32572         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
32573         {
32574                 size_t get_index() const {return type;}
32575                 bool is_unknown() const { return type == 1; }
32576                 void clear() {type = 0;}
32577                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
32578                 template<typename V>  bool decode(V& v)
32579                 {
32580                         clear();
32581                         if(!v(ref_nested())) return false;
32582                         { type = 1; return true;}
32583                         return false;
32584
32585                 }
32586                 template<typename V> bool encode(V& v) const
32587                 {
32588                         return v(ref_nested());
32589
32590                 }
32591                 protected:
32592                 template<typename V>  bool decode(size_t index, V& v)
32593                 {
32594                         clear();
32595                         switch(index)
32596                         {
32597                         case 1: type = 1; return v(ref_nested());
32598                         ref_nested().clear();
32599                         }
32600                         return false;
32601
32602                 }
32603                 template<typename V> bool encode(size_t index, V& v) const
32604                 {
32605                         if(index != type) {return false;} return v(ref_nested());
32606
32607                 }
32608                 private:
32609                 size_t type {0};
32610
32611         };
32612         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
32613         {
32614                 size_t get_index() const {return type;}
32615                 bool is_unknown() const { return type == 1; }
32616                 void clear() {type = 0;}
32617                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
32618                 template<typename V>  bool decode(V& v)
32619                 {
32620                         clear();
32621                         if(!v(ref_nested())) return false;
32622                         { type = 1; return true;}
32623                         return false;
32624
32625                 }
32626                 template<typename V> bool encode(V& v) const
32627                 {
32628                         return v(ref_nested());
32629
32630                 }
32631                 protected:
32632                 template<typename V>  bool decode(size_t index, V& v)
32633                 {
32634                         clear();
32635                         switch(index)
32636                         {
32637                         case 1: type = 1; return v(ref_nested());
32638                         ref_nested().clear();
32639                         }
32640                         return false;
32641
32642                 }
32643                 template<typename V> bool encode(size_t index, V& v) const
32644                 {
32645                         if(index != type) {return false;} return v(ref_nested());
32646
32647                 }
32648                 private:
32649                 size_t type {0};
32650
32651         };
32652         struct Extension_t : asn::typefield<true>
32653         {
32654                 ~Extension_t()  {clear();}
32655                 size_t get_index() const {return type;}
32656                 bool is_unknown() const { return type == 1; }
32657                 void clear()
32658                 {
32659                         type = 0; ref_nested().clear();
32660                 }
32661                 template<typename V> static inline void enumerate(V& v)
32662                 {
32663
32664                 }
32665                 protected:
32666                 template<typename V> bool decode(size_t index, V& v)
32667                 {
32668                         clear();
32669                         switch(index)
32670                         {
32671                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
32672                         }
32673                         return false;
32674
32675                 }
32676                 template<typename V> bool encode(size_t index, V& v) const
32677                 {
32678                         if(index != type) return false;
32679                         return false;
32680
32681                 }
32682                 private:
32683                 size_t type {0};
32684
32685         };
32686         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
32687         {
32688                 size_t get_index() const {return type;}
32689                 bool is_unknown() const { return type == 1; }
32690                 void clear() {type = 0;}
32691                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
32692                 template<typename V>  bool decode(V& v)
32693                 {
32694                         clear();
32695                         if(!v(ref_nested())) return false;
32696                         { type = 1; return true;}
32697                         return false;
32698
32699                 }
32700                 template<typename V> bool encode(V& v) const
32701                 {
32702                         return v(ref_nested());
32703
32704                 }
32705                 protected:
32706                 template<typename V>  bool decode(size_t index, V& v)
32707                 {
32708                         clear();
32709                         switch(index)
32710                         {
32711                         case 1: type = 1; return v(ref_nested());
32712                         ref_nested().clear();
32713                         }
32714                         return false;
32715
32716                 }
32717                 template<typename V> bool encode(size_t index, V& v) const
32718                 {
32719                         if(index != type) {return false;} return v(ref_nested());
32720
32721                 }
32722                 private:
32723                 size_t type {0};
32724
32725         };
32726
32727 };
32728 /*
32729 Subscription-Based-UE-DifferentiationInfo ::= SEQUENCE {
32730         periodicCommunicationIndicator  ENUMERATED {periodically, ondemand, ...}                OPTIONAL,
32731         periodicTime                                    INTEGER (1..3600, ...)                                                  OPTIONAL,
32732         scheduledCommunicationTime              ScheduledCommunicationTime                                              OPTIONAL,
32733         stationaryIndication                    ENUMERATED {stationary, mobile, ...}                    OPTIONAL,
32734         trafficProfile                                  ENUMERATED {single-packet, dual-packets, multiple-packets, ...}                         OPTIONAL,
32735         batteryIndication                               ENUMERATED {battery-powered, battery-powered-not-rechargeable-or-replaceable, not-battery-powered, ...}         OPTIONAL,
32736         iE-Extensions                                   ProtocolExtensionContainer { { Subscription-Based-UE-DifferentiationInfo-ExtIEs} } OPTIONAL,
32737         ...
32738 }
32739 */
32740
32741 struct Subscription_Based_UE_DifferentiationInfo : asn::sequence<7, 0, true, 7>
32742 {
32743         static constexpr const char* name() {return "Subscription-Based-UE-DifferentiationInfo";}
32744         using parent_t = asn::sequence<7, 0, true, 7>;
32745         struct periodicCommunicationIndicator_t : asn::enumerated<2, 0, true>
32746         {
32747                 static constexpr const char* name() {return "periodicCommunicationIndicator_t";}
32748                 using parent_t = asn::enumerated<2, 0, true>;
32749                 static constexpr bool optional = true;
32750                 typedef enum {
32751                         periodically
32752                         ,ondemand
32753                 } index_t;
32754
32755         };
32756
32757         periodicCommunicationIndicator_t& set_periodicCommunicationIndicator() { periodicCommunicationIndicator.setpresent(true); return periodicCommunicationIndicator;}
32758         periodicCommunicationIndicator_t const* get_periodicCommunicationIndicator() const {return periodicCommunicationIndicator.is_valid() ? &periodicCommunicationIndicator : nullptr;}
32759         struct periodicTime_t : asn::integer<>
32760         {
32761                 using constraint_t = asn::constraints<true,asn::span<1, 3600>>;
32762                 static constexpr const char* name() {return "periodicTime_t";}
32763                 using parent_t = asn::integer<>;
32764                 static constexpr bool optional = true;
32765
32766         };
32767
32768         periodicTime_t& set_periodicTime() { periodicTime.setpresent(true); return periodicTime;}
32769         periodicTime_t const* get_periodicTime() const {return periodicTime.is_valid() ? &periodicTime : nullptr;}
32770         struct scheduledCommunicationTime_t : ScheduledCommunicationTime
32771         {
32772                 static constexpr const char* name() {return "scheduledCommunicationTime_t";}
32773                 using parent_t = ScheduledCommunicationTime;
32774                 static constexpr bool optional = true;
32775
32776         };
32777         scheduledCommunicationTime_t& set_scheduledCommunicationTime() { scheduledCommunicationTime.setpresent(true); return scheduledCommunicationTime;}
32778         scheduledCommunicationTime_t const* get_scheduledCommunicationTime() const {return scheduledCommunicationTime.is_valid() ? &scheduledCommunicationTime : nullptr;}
32779         struct stationaryIndication_t : asn::enumerated<2, 0, true>
32780         {
32781                 static constexpr const char* name() {return "stationaryIndication_t";}
32782                 using parent_t = asn::enumerated<2, 0, true>;
32783                 static constexpr bool optional = true;
32784                 typedef enum {
32785                         stationary
32786                         ,mobile
32787                 } index_t;
32788
32789         };
32790
32791         stationaryIndication_t& set_stationaryIndication() { stationaryIndication.setpresent(true); return stationaryIndication;}
32792         stationaryIndication_t const* get_stationaryIndication() const {return stationaryIndication.is_valid() ? &stationaryIndication : nullptr;}
32793         struct trafficProfile_t : asn::enumerated<3, 0, true>
32794         {
32795                 static constexpr const char* name() {return "trafficProfile_t";}
32796                 using parent_t = asn::enumerated<3, 0, true>;
32797                 static constexpr bool optional = true;
32798                 typedef enum {
32799                         single_packet
32800                         ,dual_packets
32801                         ,multiple_packets
32802                 } index_t;
32803
32804         };
32805
32806         trafficProfile_t& set_trafficProfile() { trafficProfile.setpresent(true); return trafficProfile;}
32807         trafficProfile_t const* get_trafficProfile() const {return trafficProfile.is_valid() ? &trafficProfile : nullptr;}
32808         struct batteryIndication_t : asn::enumerated<3, 0, true>
32809         {
32810                 static constexpr const char* name() {return "batteryIndication_t";}
32811                 using parent_t = asn::enumerated<3, 0, true>;
32812                 static constexpr bool optional = true;
32813                 typedef enum {
32814                         battery_powered
32815                         ,battery_powered_not_rechargeable_or_replaceable
32816                         ,not_battery_powered
32817                 } index_t;
32818
32819         };
32820
32821         batteryIndication_t& set_batteryIndication() { batteryIndication.setpresent(true); return batteryIndication;}
32822         batteryIndication_t const* get_batteryIndication() const {return batteryIndication.is_valid() ? &batteryIndication : nullptr;}
32823         struct iE_Extensions_t : ProtocolExtensionContainer<Subscription_Based_UE_DifferentiationInfo_ExtIEs>
32824         {
32825                 static constexpr const char* name() {return "iE_Extensions_t";}
32826                 using parent_t = ProtocolExtensionContainer<Subscription_Based_UE_DifferentiationInfo_ExtIEs>;
32827                 static constexpr bool optional = true;
32828
32829         };
32830         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
32831         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
32832         template<typename V> void decode(V& v)
32833         {
32834                 v(periodicCommunicationIndicator);
32835                 v(periodicTime);
32836                 v(scheduledCommunicationTime);
32837                 v(stationaryIndication);
32838                 v(trafficProfile);
32839                 v(batteryIndication);
32840                 v(iE_Extensions);
32841
32842         };
32843         template<typename V> void encode(V& v) const
32844         {
32845                 v(periodicCommunicationIndicator);
32846                 v(periodicTime);
32847                 v(scheduledCommunicationTime);
32848                 v(stationaryIndication);
32849                 v(trafficProfile);
32850                 v(batteryIndication);
32851                 v(iE_Extensions);
32852
32853         };
32854         void clear()
32855         {
32856                 periodicCommunicationIndicator.clear();
32857                 periodicTime.clear();
32858                 scheduledCommunicationTime.clear();
32859                 stationaryIndication.clear();
32860                 trafficProfile.clear();
32861                 batteryIndication.clear();
32862                 iE_Extensions.clear();
32863
32864         };
32865         private:
32866         periodicCommunicationIndicator_t        periodicCommunicationIndicator;
32867         periodicTime_t  periodicTime;
32868         scheduledCommunicationTime_t    scheduledCommunicationTime;
32869         stationaryIndication_t  stationaryIndication;
32870         trafficProfile_t        trafficProfile;
32871         batteryIndication_t     batteryIndication;
32872         iE_Extensions_t iE_Extensions;
32873
32874 };
32875 /*
32876 TargetCellInUTRAN ::= OCTET STRING -- This IE is to be encoded according to the UTRAN Cell ID in the Last Visited UTRAN Cell Information IE in TS 25.413 [24]
32877 */
32878
32879 struct TargetCellInUTRAN : asn::ostring<>
32880 {
32881         static constexpr const char* name() {return "TargetCellInUTRAN";}
32882         using parent_t = asn::ostring<>;
32883
32884 };
32885
32886 /*
32887 TargeteNBtoSource-eNBTransparentContainer       ::= OCTET STRING
32888 */
32889
32890 struct TargeteNBtoSource_eNBTransparentContainer : asn::ostring<>
32891 {
32892         static constexpr const char* name() {return "TargeteNBtoSource-eNBTransparentContainer";}
32893         using parent_t = asn::ostring<>;
32894
32895 };
32896
32897 /*
32898 TimeToWait ::= ENUMERATED {
32899         v1s,
32900         v2s,
32901         v5s,
32902         v10s,
32903         v20s,
32904         v60s,
32905         ...
32906 }
32907 */
32908
32909 struct TimeToWait : asn::enumerated<6, 0, true>
32910 {
32911         static constexpr const char* name() {return "TimeToWait";}
32912         using parent_t = asn::enumerated<6, 0, true>;
32913         typedef enum {
32914                 v1s
32915                 ,v2s
32916                 ,v5s
32917                 ,v10s
32918                 ,v20s
32919                 ,v60s
32920         } index_t;
32921
32922 };
32923
32924 /*
32925 TraceDepth              ::= ENUMERATED {
32926         minimum,
32927         medium,
32928         maximum,
32929         minimumWithoutVendorSpecificExtension,
32930         mediumWithoutVendorSpecificExtension,
32931         maximumWithoutVendorSpecificExtension,
32932         ...
32933 }
32934 */
32935
32936 struct TraceDepth : asn::enumerated<6, 0, true>
32937 {
32938         static constexpr const char* name() {return "TraceDepth";}
32939         using parent_t = asn::enumerated<6, 0, true>;
32940         typedef enum {
32941                 minimum
32942                 ,medium
32943                 ,maximum
32944                 ,minimumWithoutVendorSpecificExtension
32945                 ,mediumWithoutVendorSpecificExtension
32946                 ,maximumWithoutVendorSpecificExtension
32947         } index_t;
32948
32949 };
32950
32951 /*
32952 TraceCollectionEntityIPAddress ::= BIT STRING (SIZE(1..160, ...))
32953 */
32954
32955 struct TraceCollectionEntityIPAddress : asn::bstring<>
32956 {
32957         using constraint_t = asn::constraints<true,asn::span<1, 160>>;
32958         static constexpr const char* name() {return "TraceCollectionEntityIPAddress";}
32959         using parent_t = asn::bstring<>;
32960
32961 };
32962
32963 /*
32964 UEAppLayerMeasConfig-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
32965         {ID id-serviceType      CRITICALITY ignore      EXTENSION ServiceType   PRESENCE optional},
32966         ...
32967 }
32968 */
32969
32970 struct UEAppLayerMeasConfig_ExtIEs
32971 {
32972         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
32973         {
32974                 size_t get_index() const {return type;}
32975                 bool is_unknown() const { return type == 2; }
32976                 void clear() {type = 0;}
32977                 void select_id_serviceType() { set(id_serviceType); type=1;}
32978                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
32979                 template<typename V>  bool decode(V& v)
32980                 {
32981                         clear();
32982                         if(!v(ref_nested())) return false;
32983                         if(equal(id_serviceType)) { type = 1; return true; }
32984                         else { type = 2; return true;}
32985                         return false;
32986
32987                 }
32988                 template<typename V> bool encode(V& v) const
32989                 {
32990                         return v(ref_nested());
32991
32992                 }
32993                 protected:
32994                 template<typename V>  bool decode(size_t index, V& v)
32995                 {
32996                         clear();
32997                         switch(index)
32998                         {
32999                         case 1: type = 1; if(v(ref_nested())) { return equal(id_serviceType);} return false;
33000                         case 2: type = 2; return v(ref_nested());
33001                         ref_nested().clear();
33002                         }
33003                         return false;
33004
33005                 }
33006                 template<typename V> bool encode(size_t index, V& v) const
33007                 {
33008                         if(index != type) {return false;} return v(ref_nested());
33009
33010                 }
33011                 private:
33012                 size_t type {0};
33013
33014         };
33015         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
33016         {
33017                 size_t get_index() const {return type;}
33018                 bool is_unknown() const { return type == 2; }
33019                 void clear() {type = 0;}
33020                 void select_id_serviceType() { set(ignore); type=1;}
33021                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
33022                 template<typename V>  bool decode(V& v)
33023                 {
33024                         clear();
33025                         if(!v(ref_nested())) return false;
33026                         if(equal(ignore)) { type = 1; return true; }
33027                         else { type = 2; return true;}
33028                         return false;
33029
33030                 }
33031                 template<typename V> bool encode(V& v) const
33032                 {
33033                         return v(ref_nested());
33034
33035                 }
33036                 protected:
33037                 template<typename V>  bool decode(size_t index, V& v)
33038                 {
33039                         clear();
33040                         switch(index)
33041                         {
33042                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
33043                         case 2: type = 2; return v(ref_nested());
33044                         ref_nested().clear();
33045                         }
33046                         return false;
33047
33048                 }
33049                 template<typename V> bool encode(size_t index, V& v) const
33050                 {
33051                         if(index != type) {return false;} return v(ref_nested());
33052
33053                 }
33054                 private:
33055                 size_t type {0};
33056
33057         };
33058         struct Extension_t : asn::typefield<true>
33059         {
33060                 ~Extension_t()  {clear();}
33061                 size_t get_index() const {return type;}
33062                 ServiceType& select_id_serviceType() { return set<ServiceType>(1); }
33063                 ServiceType const* get_id_serviceType() const { return get<ServiceType>(1); }
33064                 bool is_unknown() const { return type == 2; }
33065                 void clear()
33066                 {
33067                         switch(type)
33068                         {
33069                         case 1: var.destroy<ServiceType>(); break;
33070                         }
33071                         type = 0; ref_nested().clear();
33072                 }
33073                 template<typename V> static inline void enumerate(V& v)
33074                 {
33075                         v.template operator()<ServiceType>(1);
33076
33077                 }
33078                 protected:
33079                 template<typename V> bool decode(size_t index, V& v)
33080                 {
33081                         clear();
33082                         switch(index)
33083                         {
33084                         case 1: v(select_id_serviceType()); return true;
33085                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
33086                         }
33087                         return false;
33088
33089                 }
33090                 template<typename V> bool encode(size_t index, V& v) const
33091                 {
33092                         if(index != type) return false;
33093                         switch(type)
33094                         {
33095                         case 1: v(var.as<ServiceType>()); return true;
33096                         }
33097                         return false;
33098
33099                 }
33100                 private:
33101                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
33102                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
33103                 union union_type
33104                 {
33105                         char dummy1[sizeof(ServiceType)];
33106
33107                 };
33108                 asn::variant<sizeof(union_type)> var;
33109                 size_t type {0};
33110
33111         };
33112         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
33113         {
33114                 size_t get_index() const {return type;}
33115                 bool is_unknown() const { return type == 2; }
33116                 void clear() {type = 0;}
33117                 void select_id_serviceType() { set(optional); type=1;}
33118                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
33119                 template<typename V>  bool decode(V& v)
33120                 {
33121                         clear();
33122                         if(!v(ref_nested())) return false;
33123                         if(equal(optional)) { type = 1; return true; }
33124                         else { type = 2; return true;}
33125                         return false;
33126
33127                 }
33128                 template<typename V> bool encode(V& v) const
33129                 {
33130                         return v(ref_nested());
33131
33132                 }
33133                 protected:
33134                 template<typename V>  bool decode(size_t index, V& v)
33135                 {
33136                         clear();
33137                         switch(index)
33138                         {
33139                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
33140                         case 2: type = 2; return v(ref_nested());
33141                         ref_nested().clear();
33142                         }
33143                         return false;
33144
33145                 }
33146                 template<typename V> bool encode(size_t index, V& v) const
33147                 {
33148                         if(index != type) {return false;} return v(ref_nested());
33149
33150                 }
33151                 private:
33152                 size_t type {0};
33153
33154         };
33155
33156 };
33157 /*
33158 UEAppLayerMeasConfig ::= SEQUENCE {
33159         containerForAppLayerMeasConfig                  OCTET STRING (SIZE(1..1000)),
33160         areaScopeOfQMC          AreaScopeOfQMC,
33161         iE-Extensions           ProtocolExtensionContainer { {UEAppLayerMeasConfig-ExtIEs} } OPTIONAL,
33162         ...
33163 }
33164 */
33165
33166 struct UEAppLayerMeasConfig : asn::sequence<3, 0, true, 1>
33167 {
33168         static constexpr const char* name() {return "UEAppLayerMeasConfig";}
33169         using parent_t = asn::sequence<3, 0, true, 1>;
33170         struct containerForAppLayerMeasConfig_t : asn::ostring<>
33171         {
33172                 using constraint_t = asn::constraints<false,asn::span<1, 1000>>;
33173                 static constexpr const char* name() {return "containerForAppLayerMeasConfig_t";}
33174                 using parent_t = asn::ostring<>;
33175
33176         };
33177
33178         containerForAppLayerMeasConfig_t& ref_containerForAppLayerMeasConfig() {return containerForAppLayerMeasConfig;}
33179         containerForAppLayerMeasConfig_t const& ref_containerForAppLayerMeasConfig() const {return containerForAppLayerMeasConfig;}
33180         struct areaScopeOfQMC_t : AreaScopeOfQMC
33181         {
33182                 static constexpr const char* name() {return "areaScopeOfQMC_t";}
33183                 using parent_t = AreaScopeOfQMC;
33184
33185         };
33186         areaScopeOfQMC_t& ref_areaScopeOfQMC() {return areaScopeOfQMC;}
33187         areaScopeOfQMC_t const& ref_areaScopeOfQMC() const {return areaScopeOfQMC;}
33188         struct iE_Extensions_t : ProtocolExtensionContainer<UEAppLayerMeasConfig_ExtIEs>
33189         {
33190                 static constexpr const char* name() {return "iE_Extensions_t";}
33191                 using parent_t = ProtocolExtensionContainer<UEAppLayerMeasConfig_ExtIEs>;
33192                 static constexpr bool optional = true;
33193
33194         };
33195         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
33196         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
33197         template<typename V> void decode(V& v)
33198         {
33199                 v(containerForAppLayerMeasConfig);
33200                 v(areaScopeOfQMC);
33201                 v(iE_Extensions);
33202
33203         };
33204         template<typename V> void encode(V& v) const
33205         {
33206                 v(containerForAppLayerMeasConfig);
33207                 v(areaScopeOfQMC);
33208                 v(iE_Extensions);
33209
33210         };
33211         void clear()
33212         {
33213                 containerForAppLayerMeasConfig.clear();
33214                 areaScopeOfQMC.clear();
33215                 iE_Extensions.clear();
33216
33217         };
33218         private:
33219         containerForAppLayerMeasConfig_t        containerForAppLayerMeasConfig;
33220         areaScopeOfQMC_t        areaScopeOfQMC;
33221         iE_Extensions_t iE_Extensions;
33222
33223 };
33224 /*
33225 TraceActivation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
33226         { ID id-MDTConfiguration                        CRITICALITY ignore      EXTENSION MDT-Configuration                     PRESENCE optional}|
33227         { ID id-UEAppLayerMeasConfig            CRITICALITY ignore      EXTENSION UEAppLayerMeasConfig          PRESENCE optional},
33228         ...
33229 }
33230 */
33231
33232 struct TraceActivation_ExtIEs
33233 {
33234         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
33235         {
33236                 size_t get_index() const {return type;}
33237                 bool is_unknown() const { return type == 3; }
33238                 void clear() {type = 0;}
33239                 void select_id_MDTConfiguration() { set(id_MDTConfiguration); type=1;}
33240                 void select_id_UEAppLayerMeasConfig() { set(id_UEAppLayerMeasConfig); type=2;}
33241                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
33242                 template<typename V>  bool decode(V& v)
33243                 {
33244                         clear();
33245                         if(!v(ref_nested())) return false;
33246                         if(equal(id_MDTConfiguration)) { type = 1; return true; }
33247                         else if(equal(id_UEAppLayerMeasConfig)) { type = 2; return true; }
33248                         else { type = 3; return true;}
33249                         return false;
33250
33251                 }
33252                 template<typename V> bool encode(V& v) const
33253                 {
33254                         return v(ref_nested());
33255
33256                 }
33257                 protected:
33258                 template<typename V>  bool decode(size_t index, V& v)
33259                 {
33260                         clear();
33261                         switch(index)
33262                         {
33263                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MDTConfiguration);} return false;
33264                         case 2: type = 2; if(v(ref_nested())) { return equal(id_UEAppLayerMeasConfig);} return false;
33265                         case 3: type = 3; return v(ref_nested());
33266                         ref_nested().clear();
33267                         }
33268                         return false;
33269
33270                 }
33271                 template<typename V> bool encode(size_t index, V& v) const
33272                 {
33273                         if(index != type) {return false;} return v(ref_nested());
33274
33275                 }
33276                 private:
33277                 size_t type {0};
33278
33279         };
33280         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
33281         {
33282                 size_t get_index() const {return type;}
33283                 bool is_unknown() const { return type == 3; }
33284                 void clear() {type = 0;}
33285                 void select_id_MDTConfiguration() { set(ignore); type=1;}
33286                 void select_id_UEAppLayerMeasConfig() { set(ignore); type=2;}
33287                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
33288                 template<typename V>  bool decode(V& v)
33289                 {
33290                         clear();
33291                         if(!v(ref_nested())) return false;
33292                         if(equal(ignore)) { type = 1; return true; }
33293                         else if(equal(ignore)) { type = 2; return true; }
33294                         else { type = 3; return true;}
33295                         return false;
33296
33297                 }
33298                 template<typename V> bool encode(V& v) const
33299                 {
33300                         return v(ref_nested());
33301
33302                 }
33303                 protected:
33304                 template<typename V>  bool decode(size_t index, V& v)
33305                 {
33306                         clear();
33307                         switch(index)
33308                         {
33309                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
33310                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
33311                         case 3: type = 3; return v(ref_nested());
33312                         ref_nested().clear();
33313                         }
33314                         return false;
33315
33316                 }
33317                 template<typename V> bool encode(size_t index, V& v) const
33318                 {
33319                         if(index != type) {return false;} return v(ref_nested());
33320
33321                 }
33322                 private:
33323                 size_t type {0};
33324
33325         };
33326         struct Extension_t : asn::typefield<true>
33327         {
33328                 ~Extension_t()  {clear();}
33329                 size_t get_index() const {return type;}
33330                 MDT_Configuration& select_id_MDTConfiguration() { return set<MDT_Configuration>(1); }
33331                 MDT_Configuration const* get_id_MDTConfiguration() const { return get<MDT_Configuration>(1); }
33332                 UEAppLayerMeasConfig& select_id_UEAppLayerMeasConfig() { return set<UEAppLayerMeasConfig>(2); }
33333                 UEAppLayerMeasConfig const* get_id_UEAppLayerMeasConfig() const { return get<UEAppLayerMeasConfig>(2); }
33334                 bool is_unknown() const { return type == 3; }
33335                 void clear()
33336                 {
33337                         switch(type)
33338                         {
33339                         case 1: var.destroy<MDT_Configuration>(); break;
33340                         case 2: var.destroy<UEAppLayerMeasConfig>(); break;
33341                         }
33342                         type = 0; ref_nested().clear();
33343                 }
33344                 template<typename V> static inline void enumerate(V& v)
33345                 {
33346                         v.template operator()<MDT_Configuration>(1);
33347                         v.template operator()<UEAppLayerMeasConfig>(2);
33348
33349                 }
33350                 protected:
33351                 template<typename V> bool decode(size_t index, V& v)
33352                 {
33353                         clear();
33354                         switch(index)
33355                         {
33356                         case 1: v(select_id_MDTConfiguration()); return true;
33357                         case 2: v(select_id_UEAppLayerMeasConfig()); return true;
33358                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
33359                         }
33360                         return false;
33361
33362                 }
33363                 template<typename V> bool encode(size_t index, V& v) const
33364                 {
33365                         if(index != type) return false;
33366                         switch(type)
33367                         {
33368                         case 1: v(var.as<MDT_Configuration>()); return true;
33369                         case 2: v(var.as<UEAppLayerMeasConfig>()); return true;
33370                         }
33371                         return false;
33372
33373                 }
33374                 private:
33375                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
33376                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
33377                 union union_type
33378                 {
33379                         char dummy1[sizeof(MDT_Configuration)];
33380                         char dummy2[sizeof(UEAppLayerMeasConfig)];
33381
33382                 };
33383                 asn::variant<sizeof(union_type)> var;
33384                 size_t type {0};
33385
33386         };
33387         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
33388         {
33389                 size_t get_index() const {return type;}
33390                 bool is_unknown() const { return type == 3; }
33391                 void clear() {type = 0;}
33392                 void select_id_MDTConfiguration() { set(optional); type=1;}
33393                 void select_id_UEAppLayerMeasConfig() { set(optional); type=2;}
33394                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
33395                 template<typename V>  bool decode(V& v)
33396                 {
33397                         clear();
33398                         if(!v(ref_nested())) return false;
33399                         if(equal(optional)) { type = 1; return true; }
33400                         else if(equal(optional)) { type = 2; return true; }
33401                         else { type = 3; return true;}
33402                         return false;
33403
33404                 }
33405                 template<typename V> bool encode(V& v) const
33406                 {
33407                         return v(ref_nested());
33408
33409                 }
33410                 protected:
33411                 template<typename V>  bool decode(size_t index, V& v)
33412                 {
33413                         clear();
33414                         switch(index)
33415                         {
33416                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
33417                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
33418                         case 3: type = 3; return v(ref_nested());
33419                         ref_nested().clear();
33420                         }
33421                         return false;
33422
33423                 }
33424                 template<typename V> bool encode(size_t index, V& v) const
33425                 {
33426                         if(index != type) {return false;} return v(ref_nested());
33427
33428                 }
33429                 private:
33430                 size_t type {0};
33431
33432         };
33433
33434 };
33435 /*
33436 TraceActivation ::= SEQUENCE {
33437         eUTRANTraceID                                   EUTRANTraceID,
33438         interfacesToTrace                               InterfacesToTrace,
33439 traceDepth                                                      TraceDepth,
33440 traceCollectionEntityIPAddress          TraceCollectionEntityIPAddress,
33441         iE-Extensions                                   ProtocolExtensionContainer { {TraceActivation-ExtIEs} } OPTIONAL,
33442         ...
33443 }
33444 */
33445
33446 struct TraceActivation : asn::sequence<5, 0, true, 1>
33447 {
33448         static constexpr const char* name() {return "TraceActivation";}
33449         using parent_t = asn::sequence<5, 0, true, 1>;
33450         struct eUTRANTraceID_t : EUTRANTraceID
33451         {
33452                 static constexpr const char* name() {return "eUTRANTraceID_t";}
33453                 using parent_t = EUTRANTraceID;
33454
33455         };
33456         eUTRANTraceID_t& ref_eUTRANTraceID() {return eUTRANTraceID;}
33457         eUTRANTraceID_t const& ref_eUTRANTraceID() const {return eUTRANTraceID;}
33458         struct interfacesToTrace_t : InterfacesToTrace
33459         {
33460                 static constexpr const char* name() {return "interfacesToTrace_t";}
33461                 using parent_t = InterfacesToTrace;
33462
33463         };
33464         interfacesToTrace_t& ref_interfacesToTrace() {return interfacesToTrace;}
33465         interfacesToTrace_t const& ref_interfacesToTrace() const {return interfacesToTrace;}
33466         struct traceDepth_t : TraceDepth
33467         {
33468                 static constexpr const char* name() {return "traceDepth_t";}
33469                 using parent_t = TraceDepth;
33470
33471         };
33472         traceDepth_t& ref_traceDepth() {return traceDepth;}
33473         traceDepth_t const& ref_traceDepth() const {return traceDepth;}
33474         struct traceCollectionEntityIPAddress_t : TraceCollectionEntityIPAddress
33475         {
33476                 static constexpr const char* name() {return "traceCollectionEntityIPAddress_t";}
33477                 using parent_t = TraceCollectionEntityIPAddress;
33478
33479         };
33480         traceCollectionEntityIPAddress_t& ref_traceCollectionEntityIPAddress() {return traceCollectionEntityIPAddress;}
33481         traceCollectionEntityIPAddress_t const& ref_traceCollectionEntityIPAddress() const {return traceCollectionEntityIPAddress;}
33482         struct iE_Extensions_t : ProtocolExtensionContainer<TraceActivation_ExtIEs>
33483         {
33484                 static constexpr const char* name() {return "iE_Extensions_t";}
33485                 using parent_t = ProtocolExtensionContainer<TraceActivation_ExtIEs>;
33486                 static constexpr bool optional = true;
33487
33488         };
33489         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
33490         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
33491         template<typename V> void decode(V& v)
33492         {
33493                 v(eUTRANTraceID);
33494                 v(interfacesToTrace);
33495                 v(traceDepth);
33496                 v(traceCollectionEntityIPAddress);
33497                 v(iE_Extensions);
33498
33499         };
33500         template<typename V> void encode(V& v) const
33501         {
33502                 v(eUTRANTraceID);
33503                 v(interfacesToTrace);
33504                 v(traceDepth);
33505                 v(traceCollectionEntityIPAddress);
33506                 v(iE_Extensions);
33507
33508         };
33509         void clear()
33510         {
33511                 eUTRANTraceID.clear();
33512                 interfacesToTrace.clear();
33513                 traceDepth.clear();
33514                 traceCollectionEntityIPAddress.clear();
33515                 iE_Extensions.clear();
33516
33517         };
33518         private:
33519         eUTRANTraceID_t eUTRANTraceID;
33520         interfacesToTrace_t     interfacesToTrace;
33521         traceDepth_t    traceDepth;
33522         traceCollectionEntityIPAddress_t        traceCollectionEntityIPAddress;
33523         iE_Extensions_t iE_Extensions;
33524
33525 };
33526 /*
33527 Tunnel-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
33528         ...
33529 }
33530 */
33531
33532 struct Tunnel_Information_ExtIEs
33533 {
33534         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
33535         {
33536                 size_t get_index() const {return type;}
33537                 bool is_unknown() const { return type == 1; }
33538                 void clear() {type = 0;}
33539                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
33540                 template<typename V>  bool decode(V& v)
33541                 {
33542                         clear();
33543                         if(!v(ref_nested())) return false;
33544                         { type = 1; return true;}
33545                         return false;
33546
33547                 }
33548                 template<typename V> bool encode(V& v) const
33549                 {
33550                         return v(ref_nested());
33551
33552                 }
33553                 protected:
33554                 template<typename V>  bool decode(size_t index, V& v)
33555                 {
33556                         clear();
33557                         switch(index)
33558                         {
33559                         case 1: type = 1; return v(ref_nested());
33560                         ref_nested().clear();
33561                         }
33562                         return false;
33563
33564                 }
33565                 template<typename V> bool encode(size_t index, V& v) const
33566                 {
33567                         if(index != type) {return false;} return v(ref_nested());
33568
33569                 }
33570                 private:
33571                 size_t type {0};
33572
33573         };
33574         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
33575         {
33576                 size_t get_index() const {return type;}
33577                 bool is_unknown() const { return type == 1; }
33578                 void clear() {type = 0;}
33579                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
33580                 template<typename V>  bool decode(V& v)
33581                 {
33582                         clear();
33583                         if(!v(ref_nested())) return false;
33584                         { type = 1; return true;}
33585                         return false;
33586
33587                 }
33588                 template<typename V> bool encode(V& v) const
33589                 {
33590                         return v(ref_nested());
33591
33592                 }
33593                 protected:
33594                 template<typename V>  bool decode(size_t index, V& v)
33595                 {
33596                         clear();
33597                         switch(index)
33598                         {
33599                         case 1: type = 1; return v(ref_nested());
33600                         ref_nested().clear();
33601                         }
33602                         return false;
33603
33604                 }
33605                 template<typename V> bool encode(size_t index, V& v) const
33606                 {
33607                         if(index != type) {return false;} return v(ref_nested());
33608
33609                 }
33610                 private:
33611                 size_t type {0};
33612
33613         };
33614         struct Extension_t : asn::typefield<true>
33615         {
33616                 ~Extension_t()  {clear();}
33617                 size_t get_index() const {return type;}
33618                 bool is_unknown() const { return type == 1; }
33619                 void clear()
33620                 {
33621                         type = 0; ref_nested().clear();
33622                 }
33623                 template<typename V> static inline void enumerate(V& v)
33624                 {
33625
33626                 }
33627                 protected:
33628                 template<typename V> bool decode(size_t index, V& v)
33629                 {
33630                         clear();
33631                         switch(index)
33632                         {
33633                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
33634                         }
33635                         return false;
33636
33637                 }
33638                 template<typename V> bool encode(size_t index, V& v) const
33639                 {
33640                         if(index != type) return false;
33641                         return false;
33642
33643                 }
33644                 private:
33645                 size_t type {0};
33646
33647         };
33648         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
33649         {
33650                 size_t get_index() const {return type;}
33651                 bool is_unknown() const { return type == 1; }
33652                 void clear() {type = 0;}
33653                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
33654                 template<typename V>  bool decode(V& v)
33655                 {
33656                         clear();
33657                         if(!v(ref_nested())) return false;
33658                         { type = 1; return true;}
33659                         return false;
33660
33661                 }
33662                 template<typename V> bool encode(V& v) const
33663                 {
33664                         return v(ref_nested());
33665
33666                 }
33667                 protected:
33668                 template<typename V>  bool decode(size_t index, V& v)
33669                 {
33670                         clear();
33671                         switch(index)
33672                         {
33673                         case 1: type = 1; return v(ref_nested());
33674                         ref_nested().clear();
33675                         }
33676                         return false;
33677
33678                 }
33679                 template<typename V> bool encode(size_t index, V& v) const
33680                 {
33681                         if(index != type) {return false;} return v(ref_nested());
33682
33683                 }
33684                 private:
33685                 size_t type {0};
33686
33687         };
33688
33689 };
33690 /*
33691 TunnelInformation ::= SEQUENCE {
33692         transportLayerAddress   TransportLayerAddress,
33693         uDP-Port-Number                 Port-Number                     OPTIONAL,
33694         iE-Extensions                   ProtocolExtensionContainer { {Tunnel-Information-ExtIEs} } OPTIONAL,
33695         ...
33696 }
33697 */
33698
33699 struct TunnelInformation : asn::sequence<3, 0, true, 2>
33700 {
33701         static constexpr const char* name() {return "TunnelInformation";}
33702         using parent_t = asn::sequence<3, 0, true, 2>;
33703         struct transportLayerAddress_t : TransportLayerAddress
33704         {
33705                 static constexpr const char* name() {return "transportLayerAddress_t";}
33706                 using parent_t = TransportLayerAddress;
33707
33708         };
33709         transportLayerAddress_t& ref_transportLayerAddress() {return transportLayerAddress;}
33710         transportLayerAddress_t const& ref_transportLayerAddress() const {return transportLayerAddress;}
33711         struct uDP_Port_Number_t : Port_Number
33712         {
33713                 static constexpr const char* name() {return "uDP_Port_Number_t";}
33714                 using parent_t = Port_Number;
33715                 static constexpr bool optional = true;
33716
33717         };
33718         uDP_Port_Number_t& set_uDP_Port_Number() { uDP_Port_Number.setpresent(true); return uDP_Port_Number;}
33719         uDP_Port_Number_t const* get_uDP_Port_Number() const {return uDP_Port_Number.is_valid() ? &uDP_Port_Number : nullptr;}
33720         struct iE_Extensions_t : ProtocolExtensionContainer<Tunnel_Information_ExtIEs>
33721         {
33722                 static constexpr const char* name() {return "iE_Extensions_t";}
33723                 using parent_t = ProtocolExtensionContainer<Tunnel_Information_ExtIEs>;
33724                 static constexpr bool optional = true;
33725
33726         };
33727         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
33728         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
33729         template<typename V> void decode(V& v)
33730         {
33731                 v(transportLayerAddress);
33732                 v(uDP_Port_Number);
33733                 v(iE_Extensions);
33734
33735         };
33736         template<typename V> void encode(V& v) const
33737         {
33738                 v(transportLayerAddress);
33739                 v(uDP_Port_Number);
33740                 v(iE_Extensions);
33741
33742         };
33743         void clear()
33744         {
33745                 transportLayerAddress.clear();
33746                 uDP_Port_Number.clear();
33747                 iE_Extensions.clear();
33748
33749         };
33750         private:
33751         transportLayerAddress_t transportLayerAddress;
33752         uDP_Port_Number_t       uDP_Port_Number;
33753         iE_Extensions_t iE_Extensions;
33754
33755 };
33756 /*
33757 UE-ContextKeptIndicator ::= ENUMERATED {
33758         true,
33759         ...
33760 }
33761 */
33762
33763 struct UE_ContextKeptIndicator : asn::enumerated<1, 0, true>
33764 {
33765         static constexpr const char* name() {return "UE-ContextKeptIndicator";}
33766         using parent_t = asn::enumerated<1, 0, true>;
33767         typedef enum {
33768                 True
33769         } index_t;
33770
33771 };
33772
33773 /*
33774 UE-HistoryInformation ::= SEQUENCE (SIZE(1..maxnoofCells)) OF LastVisitedCell-Item
33775 */
33776
33777 struct UE_HistoryInformation_elm : LastVisitedCell_Item
33778 {
33779         static constexpr const char* name() {return "UE_HistoryInformation_elm";}
33780         using parent_t = LastVisitedCell_Item;
33781
33782 };
33783 struct UE_HistoryInformation : asn::sequenceof<UE_HistoryInformation_elm>
33784 {
33785         static constexpr const char* name() {return "UE-HistoryInformation";}
33786         using parent_t = asn::sequenceof<UE_HistoryInformation_elm>;
33787         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofCells >>;
33788
33789 };
33790 /*
33791 UE-HistoryInformationFromTheUE ::= OCTET STRING
33792 */
33793
33794 struct UE_HistoryInformationFromTheUE : asn::ostring<>
33795 {
33796         static constexpr const char* name() {return "UE-HistoryInformationFromTheUE";}
33797         using parent_t = asn::ostring<>;
33798
33799 };
33800
33801 /*
33802 UE-RLF-Report-Container::= OCTET STRING
33803 */
33804
33805 struct UE_RLF_Report_Container : asn::ostring<>
33806 {
33807         static constexpr const char* name() {return "UE-RLF-Report-Container";}
33808         using parent_t = asn::ostring<>;
33809
33810 };
33811
33812 /*
33813 UE-RLF-Report-Container-for-extended-bands ::= OCTET STRING
33814 */
33815
33816 struct UE_RLF_Report_Container_for_extended_bands : asn::ostring<>
33817 {
33818         static constexpr const char* name() {return "UE-RLF-Report-Container-for-extended-bands";}
33819         using parent_t = asn::ostring<>;
33820
33821 };
33822
33823 /*
33824 UE-S1AP-ID ::= INTEGER (0.. 4294967295)
33825 */
33826
33827 struct UE_S1AP_ID : asn::integer<>
33828 {
33829         using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
33830         static constexpr const char* name() {return "UE-S1AP-ID";}
33831         using parent_t = asn::integer<>;
33832
33833 };
33834
33835 /*
33836 UE-Sidelink-Aggregate-MaximumBitRate-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
33837         ...
33838 }
33839 */
33840
33841 struct UE_Sidelink_Aggregate_MaximumBitRate_ExtIEs
33842 {
33843         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
33844         {
33845                 size_t get_index() const {return type;}
33846                 bool is_unknown() const { return type == 1; }
33847                 void clear() {type = 0;}
33848                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
33849                 template<typename V>  bool decode(V& v)
33850                 {
33851                         clear();
33852                         if(!v(ref_nested())) return false;
33853                         { type = 1; return true;}
33854                         return false;
33855
33856                 }
33857                 template<typename V> bool encode(V& v) const
33858                 {
33859                         return v(ref_nested());
33860
33861                 }
33862                 protected:
33863                 template<typename V>  bool decode(size_t index, V& v)
33864                 {
33865                         clear();
33866                         switch(index)
33867                         {
33868                         case 1: type = 1; return v(ref_nested());
33869                         ref_nested().clear();
33870                         }
33871                         return false;
33872
33873                 }
33874                 template<typename V> bool encode(size_t index, V& v) const
33875                 {
33876                         if(index != type) {return false;} return v(ref_nested());
33877
33878                 }
33879                 private:
33880                 size_t type {0};
33881
33882         };
33883         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
33884         {
33885                 size_t get_index() const {return type;}
33886                 bool is_unknown() const { return type == 1; }
33887                 void clear() {type = 0;}
33888                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
33889                 template<typename V>  bool decode(V& v)
33890                 {
33891                         clear();
33892                         if(!v(ref_nested())) return false;
33893                         { type = 1; return true;}
33894                         return false;
33895
33896                 }
33897                 template<typename V> bool encode(V& v) const
33898                 {
33899                         return v(ref_nested());
33900
33901                 }
33902                 protected:
33903                 template<typename V>  bool decode(size_t index, V& v)
33904                 {
33905                         clear();
33906                         switch(index)
33907                         {
33908                         case 1: type = 1; return v(ref_nested());
33909                         ref_nested().clear();
33910                         }
33911                         return false;
33912
33913                 }
33914                 template<typename V> bool encode(size_t index, V& v) const
33915                 {
33916                         if(index != type) {return false;} return v(ref_nested());
33917
33918                 }
33919                 private:
33920                 size_t type {0};
33921
33922         };
33923         struct Extension_t : asn::typefield<true>
33924         {
33925                 ~Extension_t()  {clear();}
33926                 size_t get_index() const {return type;}
33927                 bool is_unknown() const { return type == 1; }
33928                 void clear()
33929                 {
33930                         type = 0; ref_nested().clear();
33931                 }
33932                 template<typename V> static inline void enumerate(V& v)
33933                 {
33934
33935                 }
33936                 protected:
33937                 template<typename V> bool decode(size_t index, V& v)
33938                 {
33939                         clear();
33940                         switch(index)
33941                         {
33942                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
33943                         }
33944                         return false;
33945
33946                 }
33947                 template<typename V> bool encode(size_t index, V& v) const
33948                 {
33949                         if(index != type) return false;
33950                         return false;
33951
33952                 }
33953                 private:
33954                 size_t type {0};
33955
33956         };
33957         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
33958         {
33959                 size_t get_index() const {return type;}
33960                 bool is_unknown() const { return type == 1; }
33961                 void clear() {type = 0;}
33962                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
33963                 template<typename V>  bool decode(V& v)
33964                 {
33965                         clear();
33966                         if(!v(ref_nested())) return false;
33967                         { type = 1; return true;}
33968                         return false;
33969
33970                 }
33971                 template<typename V> bool encode(V& v) const
33972                 {
33973                         return v(ref_nested());
33974
33975                 }
33976                 protected:
33977                 template<typename V>  bool decode(size_t index, V& v)
33978                 {
33979                         clear();
33980                         switch(index)
33981                         {
33982                         case 1: type = 1; return v(ref_nested());
33983                         ref_nested().clear();
33984                         }
33985                         return false;
33986
33987                 }
33988                 template<typename V> bool encode(size_t index, V& v) const
33989                 {
33990                         if(index != type) {return false;} return v(ref_nested());
33991
33992                 }
33993                 private:
33994                 size_t type {0};
33995
33996         };
33997
33998 };
33999 /*
34000 UE-X2AP-ID ::= INTEGER (0..4095)
34001 */
34002
34003 struct UE_X2AP_ID : asn::integer<>
34004 {
34005         using constraint_t = asn::constraints<false,asn::span<0, 4095>>;
34006         static constexpr const char* name() {return "UE-X2AP-ID";}
34007         using parent_t = asn::integer<>;
34008
34009 };
34010
34011 /*
34012 UE-X2AP-ID-Extension ::= INTEGER (0..4095, ...)
34013 */
34014
34015 struct UE_X2AP_ID_Extension : asn::integer<>
34016 {
34017         using constraint_t = asn::constraints<true,asn::span<0, 4095>>;
34018         static constexpr const char* name() {return "UE-X2AP-ID-Extension";}
34019         using parent_t = asn::integer<>;
34020
34021 };
34022
34023 /*
34024 UEAggregate-MaximumBitrate-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
34025         { ID id-extended-uEaggregateMaximumBitRateDownlink      CRITICALITY ignore      EXTENSION ExtendedBitRate       PRESENCE optional}|
34026         { ID id-extended-uEaggregateMaximumBitRateUplink        CRITICALITY ignore      EXTENSION ExtendedBitRate       PRESENCE optional},
34027         ...
34028 }
34029 */
34030
34031 struct UEAggregate_MaximumBitrate_ExtIEs
34032 {
34033         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
34034         {
34035                 size_t get_index() const {return type;}
34036                 bool is_unknown() const { return type == 3; }
34037                 void clear() {type = 0;}
34038                 void select_id_extended_uEaggregateMaximumBitRateDownlink() { set(id_extended_uEaggregateMaximumBitRateDownlink); type=1;}
34039                 void select_id_extended_uEaggregateMaximumBitRateUplink() { set(id_extended_uEaggregateMaximumBitRateUplink); type=2;}
34040                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
34041                 template<typename V>  bool decode(V& v)
34042                 {
34043                         clear();
34044                         if(!v(ref_nested())) return false;
34045                         if(equal(id_extended_uEaggregateMaximumBitRateDownlink)) { type = 1; return true; }
34046                         else if(equal(id_extended_uEaggregateMaximumBitRateUplink)) { type = 2; return true; }
34047                         else { type = 3; return true;}
34048                         return false;
34049
34050                 }
34051                 template<typename V> bool encode(V& v) const
34052                 {
34053                         return v(ref_nested());
34054
34055                 }
34056                 protected:
34057                 template<typename V>  bool decode(size_t index, V& v)
34058                 {
34059                         clear();
34060                         switch(index)
34061                         {
34062                         case 1: type = 1; if(v(ref_nested())) { return equal(id_extended_uEaggregateMaximumBitRateDownlink);} return false;
34063                         case 2: type = 2; if(v(ref_nested())) { return equal(id_extended_uEaggregateMaximumBitRateUplink);} return false;
34064                         case 3: type = 3; return v(ref_nested());
34065                         ref_nested().clear();
34066                         }
34067                         return false;
34068
34069                 }
34070                 template<typename V> bool encode(size_t index, V& v) const
34071                 {
34072                         if(index != type) {return false;} return v(ref_nested());
34073
34074                 }
34075                 private:
34076                 size_t type {0};
34077
34078         };
34079         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
34080         {
34081                 size_t get_index() const {return type;}
34082                 bool is_unknown() const { return type == 3; }
34083                 void clear() {type = 0;}
34084                 void select_id_extended_uEaggregateMaximumBitRateDownlink() { set(ignore); type=1;}
34085                 void select_id_extended_uEaggregateMaximumBitRateUplink() { set(ignore); type=2;}
34086                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
34087                 template<typename V>  bool decode(V& v)
34088                 {
34089                         clear();
34090                         if(!v(ref_nested())) return false;
34091                         if(equal(ignore)) { type = 1; return true; }
34092                         else if(equal(ignore)) { type = 2; return true; }
34093                         else { type = 3; return true;}
34094                         return false;
34095
34096                 }
34097                 template<typename V> bool encode(V& v) const
34098                 {
34099                         return v(ref_nested());
34100
34101                 }
34102                 protected:
34103                 template<typename V>  bool decode(size_t index, V& v)
34104                 {
34105                         clear();
34106                         switch(index)
34107                         {
34108                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
34109                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
34110                         case 3: type = 3; return v(ref_nested());
34111                         ref_nested().clear();
34112                         }
34113                         return false;
34114
34115                 }
34116                 template<typename V> bool encode(size_t index, V& v) const
34117                 {
34118                         if(index != type) {return false;} return v(ref_nested());
34119
34120                 }
34121                 private:
34122                 size_t type {0};
34123
34124         };
34125         struct Extension_t : asn::typefield<true>
34126         {
34127                 ~Extension_t()  {clear();}
34128                 size_t get_index() const {return type;}
34129                 ExtendedBitRate& select_id_extended_uEaggregateMaximumBitRateDownlink() { return set<ExtendedBitRate>(1); }
34130                 ExtendedBitRate const* get_id_extended_uEaggregateMaximumBitRateDownlink() const { return get<ExtendedBitRate>(1); }
34131                 ExtendedBitRate& select_id_extended_uEaggregateMaximumBitRateUplink() { return set<ExtendedBitRate>(2); }
34132                 ExtendedBitRate const* get_id_extended_uEaggregateMaximumBitRateUplink() const { return get<ExtendedBitRate>(2); }
34133                 bool is_unknown() const { return type == 3; }
34134                 void clear()
34135                 {
34136                         switch(type)
34137                         {
34138                         case 1: var.destroy<ExtendedBitRate>(); break;
34139                         case 2: var.destroy<ExtendedBitRate>(); break;
34140                         }
34141                         type = 0; ref_nested().clear();
34142                 }
34143                 template<typename V> static inline void enumerate(V& v)
34144                 {
34145                         v.template operator()<ExtendedBitRate>(1);
34146                         v.template operator()<ExtendedBitRate>(2);
34147
34148                 }
34149                 protected:
34150                 template<typename V> bool decode(size_t index, V& v)
34151                 {
34152                         clear();
34153                         switch(index)
34154                         {
34155                         case 1: v(select_id_extended_uEaggregateMaximumBitRateDownlink()); return true;
34156                         case 2: v(select_id_extended_uEaggregateMaximumBitRateUplink()); return true;
34157                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
34158                         }
34159                         return false;
34160
34161                 }
34162                 template<typename V> bool encode(size_t index, V& v) const
34163                 {
34164                         if(index != type) return false;
34165                         switch(type)
34166                         {
34167                         case 1: v(var.as<ExtendedBitRate>()); return true;
34168                         case 2: v(var.as<ExtendedBitRate>()); return true;
34169                         }
34170                         return false;
34171
34172                 }
34173                 private:
34174                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
34175                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
34176                 union union_type
34177                 {
34178                         char dummy1[sizeof(ExtendedBitRate)];
34179
34180                 };
34181                 asn::variant<sizeof(union_type)> var;
34182                 size_t type {0};
34183
34184         };
34185         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
34186         {
34187                 size_t get_index() const {return type;}
34188                 bool is_unknown() const { return type == 3; }
34189                 void clear() {type = 0;}
34190                 void select_id_extended_uEaggregateMaximumBitRateDownlink() { set(optional); type=1;}
34191                 void select_id_extended_uEaggregateMaximumBitRateUplink() { set(optional); type=2;}
34192                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
34193                 template<typename V>  bool decode(V& v)
34194                 {
34195                         clear();
34196                         if(!v(ref_nested())) return false;
34197                         if(equal(optional)) { type = 1; return true; }
34198                         else if(equal(optional)) { type = 2; return true; }
34199                         else { type = 3; return true;}
34200                         return false;
34201
34202                 }
34203                 template<typename V> bool encode(V& v) const
34204                 {
34205                         return v(ref_nested());
34206
34207                 }
34208                 protected:
34209                 template<typename V>  bool decode(size_t index, V& v)
34210                 {
34211                         clear();
34212                         switch(index)
34213                         {
34214                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
34215                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
34216                         case 3: type = 3; return v(ref_nested());
34217                         ref_nested().clear();
34218                         }
34219                         return false;
34220
34221                 }
34222                 template<typename V> bool encode(size_t index, V& v) const
34223                 {
34224                         if(index != type) {return false;} return v(ref_nested());
34225
34226                 }
34227                 private:
34228                 size_t type {0};
34229
34230         };
34231
34232 };
34233 /*
34234 UEAggregateMaximumBitRate ::= SEQUENCE {
34235         uEaggregateMaximumBitRateDownlink       BitRate,
34236         uEaggregateMaximumBitRateUplink         BitRate,
34237         iE-Extensions                                           ProtocolExtensionContainer { {UEAggregate-MaximumBitrate-ExtIEs} } OPTIONAL,
34238         ...
34239 }
34240 */
34241
34242 struct UEAggregateMaximumBitRate : asn::sequence<3, 0, true, 1>
34243 {
34244         static constexpr const char* name() {return "UEAggregateMaximumBitRate";}
34245         using parent_t = asn::sequence<3, 0, true, 1>;
34246         struct uEaggregateMaximumBitRateDownlink_t : BitRate
34247         {
34248                 static constexpr const char* name() {return "uEaggregateMaximumBitRateDownlink_t";}
34249                 using parent_t = BitRate;
34250
34251         };
34252         uEaggregateMaximumBitRateDownlink_t& ref_uEaggregateMaximumBitRateDownlink() {return uEaggregateMaximumBitRateDownlink;}
34253         uEaggregateMaximumBitRateDownlink_t const& ref_uEaggregateMaximumBitRateDownlink() const {return uEaggregateMaximumBitRateDownlink;}
34254         struct uEaggregateMaximumBitRateUplink_t : BitRate
34255         {
34256                 static constexpr const char* name() {return "uEaggregateMaximumBitRateUplink_t";}
34257                 using parent_t = BitRate;
34258
34259         };
34260         uEaggregateMaximumBitRateUplink_t& ref_uEaggregateMaximumBitRateUplink() {return uEaggregateMaximumBitRateUplink;}
34261         uEaggregateMaximumBitRateUplink_t const& ref_uEaggregateMaximumBitRateUplink() const {return uEaggregateMaximumBitRateUplink;}
34262         struct iE_Extensions_t : ProtocolExtensionContainer<UEAggregate_MaximumBitrate_ExtIEs>
34263         {
34264                 static constexpr const char* name() {return "iE_Extensions_t";}
34265                 using parent_t = ProtocolExtensionContainer<UEAggregate_MaximumBitrate_ExtIEs>;
34266                 static constexpr bool optional = true;
34267
34268         };
34269         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
34270         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
34271         template<typename V> void decode(V& v)
34272         {
34273                 v(uEaggregateMaximumBitRateDownlink);
34274                 v(uEaggregateMaximumBitRateUplink);
34275                 v(iE_Extensions);
34276
34277         };
34278         template<typename V> void encode(V& v) const
34279         {
34280                 v(uEaggregateMaximumBitRateDownlink);
34281                 v(uEaggregateMaximumBitRateUplink);
34282                 v(iE_Extensions);
34283
34284         };
34285         void clear()
34286         {
34287                 uEaggregateMaximumBitRateDownlink.clear();
34288                 uEaggregateMaximumBitRateUplink.clear();
34289                 iE_Extensions.clear();
34290
34291         };
34292         private:
34293         uEaggregateMaximumBitRateDownlink_t     uEaggregateMaximumBitRateDownlink;
34294         uEaggregateMaximumBitRateUplink_t       uEaggregateMaximumBitRateUplink;
34295         iE_Extensions_t iE_Extensions;
34296
34297 };
34298 /*
34299 UENRMeasurement-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
34300         ...
34301 }
34302 */
34303
34304 struct UENRMeasurement_ExtIEs
34305 {
34306         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
34307         {
34308                 size_t get_index() const {return type;}
34309                 bool is_unknown() const { return type == 1; }
34310                 void clear() {type = 0;}
34311                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
34312                 template<typename V>  bool decode(V& v)
34313                 {
34314                         clear();
34315                         if(!v(ref_nested())) return false;
34316                         { type = 1; return true;}
34317                         return false;
34318
34319                 }
34320                 template<typename V> bool encode(V& v) const
34321                 {
34322                         return v(ref_nested());
34323
34324                 }
34325                 protected:
34326                 template<typename V>  bool decode(size_t index, V& v)
34327                 {
34328                         clear();
34329                         switch(index)
34330                         {
34331                         case 1: type = 1; return v(ref_nested());
34332                         ref_nested().clear();
34333                         }
34334                         return false;
34335
34336                 }
34337                 template<typename V> bool encode(size_t index, V& v) const
34338                 {
34339                         if(index != type) {return false;} return v(ref_nested());
34340
34341                 }
34342                 private:
34343                 size_t type {0};
34344
34345         };
34346         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
34347         {
34348                 size_t get_index() const {return type;}
34349                 bool is_unknown() const { return type == 1; }
34350                 void clear() {type = 0;}
34351                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
34352                 template<typename V>  bool decode(V& v)
34353                 {
34354                         clear();
34355                         if(!v(ref_nested())) return false;
34356                         { type = 1; return true;}
34357                         return false;
34358
34359                 }
34360                 template<typename V> bool encode(V& v) const
34361                 {
34362                         return v(ref_nested());
34363
34364                 }
34365                 protected:
34366                 template<typename V>  bool decode(size_t index, V& v)
34367                 {
34368                         clear();
34369                         switch(index)
34370                         {
34371                         case 1: type = 1; return v(ref_nested());
34372                         ref_nested().clear();
34373                         }
34374                         return false;
34375
34376                 }
34377                 template<typename V> bool encode(size_t index, V& v) const
34378                 {
34379                         if(index != type) {return false;} return v(ref_nested());
34380
34381                 }
34382                 private:
34383                 size_t type {0};
34384
34385         };
34386         struct Extension_t : asn::typefield<true>
34387         {
34388                 ~Extension_t()  {clear();}
34389                 size_t get_index() const {return type;}
34390                 bool is_unknown() const { return type == 1; }
34391                 void clear()
34392                 {
34393                         type = 0; ref_nested().clear();
34394                 }
34395                 template<typename V> static inline void enumerate(V& v)
34396                 {
34397
34398                 }
34399                 protected:
34400                 template<typename V> bool decode(size_t index, V& v)
34401                 {
34402                         clear();
34403                         switch(index)
34404                         {
34405                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
34406                         }
34407                         return false;
34408
34409                 }
34410                 template<typename V> bool encode(size_t index, V& v) const
34411                 {
34412                         if(index != type) return false;
34413                         return false;
34414
34415                 }
34416                 private:
34417                 size_t type {0};
34418
34419         };
34420         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
34421         {
34422                 size_t get_index() const {return type;}
34423                 bool is_unknown() const { return type == 1; }
34424                 void clear() {type = 0;}
34425                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
34426                 template<typename V>  bool decode(V& v)
34427                 {
34428                         clear();
34429                         if(!v(ref_nested())) return false;
34430                         { type = 1; return true;}
34431                         return false;
34432
34433                 }
34434                 template<typename V> bool encode(V& v) const
34435                 {
34436                         return v(ref_nested());
34437
34438                 }
34439                 protected:
34440                 template<typename V>  bool decode(size_t index, V& v)
34441                 {
34442                         clear();
34443                         switch(index)
34444                         {
34445                         case 1: type = 1; return v(ref_nested());
34446                         ref_nested().clear();
34447                         }
34448                         return false;
34449
34450                 }
34451                 template<typename V> bool encode(size_t index, V& v) const
34452                 {
34453                         if(index != type) {return false;} return v(ref_nested());
34454
34455                 }
34456                 private:
34457                 size_t type {0};
34458
34459         };
34460
34461 };
34462 /*
34463 UENRMeasurement ::= SEQUENCE {
34464         uENRMeasurements                        RRCContainer,
34465         iE-Extensions                   ProtocolExtensionContainer { {UENRMeasurement-ExtIEs} } OPTIONAL,
34466         ...
34467 }
34468 */
34469
34470 struct UENRMeasurement : asn::sequence<2, 0, true, 1>
34471 {
34472         static constexpr const char* name() {return "UENRMeasurement";}
34473         using parent_t = asn::sequence<2, 0, true, 1>;
34474         struct uENRMeasurements_t : RRCContainer
34475         {
34476                 static constexpr const char* name() {return "uENRMeasurements_t";}
34477                 using parent_t = RRCContainer;
34478
34479         };
34480         uENRMeasurements_t& ref_uENRMeasurements() {return uENRMeasurements;}
34481         uENRMeasurements_t const& ref_uENRMeasurements() const {return uENRMeasurements;}
34482         struct iE_Extensions_t : ProtocolExtensionContainer<UENRMeasurement_ExtIEs>
34483         {
34484                 static constexpr const char* name() {return "iE_Extensions_t";}
34485                 using parent_t = ProtocolExtensionContainer<UENRMeasurement_ExtIEs>;
34486                 static constexpr bool optional = true;
34487
34488         };
34489         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
34490         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
34491         template<typename V> void decode(V& v)
34492         {
34493                 v(uENRMeasurements);
34494                 v(iE_Extensions);
34495
34496         };
34497         template<typename V> void encode(V& v) const
34498         {
34499                 v(uENRMeasurements);
34500                 v(iE_Extensions);
34501
34502         };
34503         void clear()
34504         {
34505                 uENRMeasurements.clear();
34506                 iE_Extensions.clear();
34507
34508         };
34509         private:
34510         uENRMeasurements_t      uENRMeasurements;
34511         iE_Extensions_t iE_Extensions;
34512
34513 };
34514 /*
34515 UESecurityCapabilities-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
34516         ...
34517 }
34518 */
34519
34520 struct UESecurityCapabilities_ExtIEs
34521 {
34522         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
34523         {
34524                 size_t get_index() const {return type;}
34525                 bool is_unknown() const { return type == 1; }
34526                 void clear() {type = 0;}
34527                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
34528                 template<typename V>  bool decode(V& v)
34529                 {
34530                         clear();
34531                         if(!v(ref_nested())) return false;
34532                         { type = 1; return true;}
34533                         return false;
34534
34535                 }
34536                 template<typename V> bool encode(V& v) const
34537                 {
34538                         return v(ref_nested());
34539
34540                 }
34541                 protected:
34542                 template<typename V>  bool decode(size_t index, V& v)
34543                 {
34544                         clear();
34545                         switch(index)
34546                         {
34547                         case 1: type = 1; return v(ref_nested());
34548                         ref_nested().clear();
34549                         }
34550                         return false;
34551
34552                 }
34553                 template<typename V> bool encode(size_t index, V& v) const
34554                 {
34555                         if(index != type) {return false;} return v(ref_nested());
34556
34557                 }
34558                 private:
34559                 size_t type {0};
34560
34561         };
34562         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
34563         {
34564                 size_t get_index() const {return type;}
34565                 bool is_unknown() const { return type == 1; }
34566                 void clear() {type = 0;}
34567                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
34568                 template<typename V>  bool decode(V& v)
34569                 {
34570                         clear();
34571                         if(!v(ref_nested())) return false;
34572                         { type = 1; return true;}
34573                         return false;
34574
34575                 }
34576                 template<typename V> bool encode(V& v) const
34577                 {
34578                         return v(ref_nested());
34579
34580                 }
34581                 protected:
34582                 template<typename V>  bool decode(size_t index, V& v)
34583                 {
34584                         clear();
34585                         switch(index)
34586                         {
34587                         case 1: type = 1; return v(ref_nested());
34588                         ref_nested().clear();
34589                         }
34590                         return false;
34591
34592                 }
34593                 template<typename V> bool encode(size_t index, V& v) const
34594                 {
34595                         if(index != type) {return false;} return v(ref_nested());
34596
34597                 }
34598                 private:
34599                 size_t type {0};
34600
34601         };
34602         struct Extension_t : asn::typefield<true>
34603         {
34604                 ~Extension_t()  {clear();}
34605                 size_t get_index() const {return type;}
34606                 bool is_unknown() const { return type == 1; }
34607                 void clear()
34608                 {
34609                         type = 0; ref_nested().clear();
34610                 }
34611                 template<typename V> static inline void enumerate(V& v)
34612                 {
34613
34614                 }
34615                 protected:
34616                 template<typename V> bool decode(size_t index, V& v)
34617                 {
34618                         clear();
34619                         switch(index)
34620                         {
34621                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
34622                         }
34623                         return false;
34624
34625                 }
34626                 template<typename V> bool encode(size_t index, V& v) const
34627                 {
34628                         if(index != type) return false;
34629                         return false;
34630
34631                 }
34632                 private:
34633                 size_t type {0};
34634
34635         };
34636         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
34637         {
34638                 size_t get_index() const {return type;}
34639                 bool is_unknown() const { return type == 1; }
34640                 void clear() {type = 0;}
34641                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
34642                 template<typename V>  bool decode(V& v)
34643                 {
34644                         clear();
34645                         if(!v(ref_nested())) return false;
34646                         { type = 1; return true;}
34647                         return false;
34648
34649                 }
34650                 template<typename V> bool encode(V& v) const
34651                 {
34652                         return v(ref_nested());
34653
34654                 }
34655                 protected:
34656                 template<typename V>  bool decode(size_t index, V& v)
34657                 {
34658                         clear();
34659                         switch(index)
34660                         {
34661                         case 1: type = 1; return v(ref_nested());
34662                         ref_nested().clear();
34663                         }
34664                         return false;
34665
34666                 }
34667                 template<typename V> bool encode(size_t index, V& v) const
34668                 {
34669                         if(index != type) {return false;} return v(ref_nested());
34670
34671                 }
34672                 private:
34673                 size_t type {0};
34674
34675         };
34676
34677 };
34678 /*
34679 UESecurityCapabilities ::= SEQUENCE {
34680         encryptionAlgorithms                            EncryptionAlgorithms,
34681         integrityProtectionAlgorithms           IntegrityProtectionAlgorithms,
34682         iE-Extensions                                           ProtocolExtensionContainer { {UESecurityCapabilities-ExtIEs} }          OPTIONAL,
34683 ...
34684 }
34685 */
34686
34687 struct UESecurityCapabilities : asn::sequence<3, 0, true, 1>
34688 {
34689         static constexpr const char* name() {return "UESecurityCapabilities";}
34690         using parent_t = asn::sequence<3, 0, true, 1>;
34691         struct encryptionAlgorithms_t : EncryptionAlgorithms
34692         {
34693                 static constexpr const char* name() {return "encryptionAlgorithms_t";}
34694                 using parent_t = EncryptionAlgorithms;
34695
34696         };
34697         encryptionAlgorithms_t& ref_encryptionAlgorithms() {return encryptionAlgorithms;}
34698         encryptionAlgorithms_t const& ref_encryptionAlgorithms() const {return encryptionAlgorithms;}
34699         struct integrityProtectionAlgorithms_t : IntegrityProtectionAlgorithms
34700         {
34701                 static constexpr const char* name() {return "integrityProtectionAlgorithms_t";}
34702                 using parent_t = IntegrityProtectionAlgorithms;
34703
34704         };
34705         integrityProtectionAlgorithms_t& ref_integrityProtectionAlgorithms() {return integrityProtectionAlgorithms;}
34706         integrityProtectionAlgorithms_t const& ref_integrityProtectionAlgorithms() const {return integrityProtectionAlgorithms;}
34707         struct iE_Extensions_t : ProtocolExtensionContainer<UESecurityCapabilities_ExtIEs>
34708         {
34709                 static constexpr const char* name() {return "iE_Extensions_t";}
34710                 using parent_t = ProtocolExtensionContainer<UESecurityCapabilities_ExtIEs>;
34711                 static constexpr bool optional = true;
34712
34713         };
34714         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
34715         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
34716         template<typename V> void decode(V& v)
34717         {
34718                 v(encryptionAlgorithms);
34719                 v(integrityProtectionAlgorithms);
34720                 v(iE_Extensions);
34721
34722         };
34723         template<typename V> void encode(V& v) const
34724         {
34725                 v(encryptionAlgorithms);
34726                 v(integrityProtectionAlgorithms);
34727                 v(iE_Extensions);
34728
34729         };
34730         void clear()
34731         {
34732                 encryptionAlgorithms.clear();
34733                 integrityProtectionAlgorithms.clear();
34734                 iE_Extensions.clear();
34735
34736         };
34737         private:
34738         encryptionAlgorithms_t  encryptionAlgorithms;
34739         integrityProtectionAlgorithms_t integrityProtectionAlgorithms;
34740         iE_Extensions_t iE_Extensions;
34741
34742 };
34743 /*
34744 UESidelinkAggregateMaximumBitRate ::= SEQUENCE {
34745         uESidelinkAggregateMaximumBitRate               BitRate,
34746         iE-Extensions                                   ProtocolExtensionContainer { {UE-Sidelink-Aggregate-MaximumBitRate-ExtIEs} } OPTIONAL,
34747         ...
34748 }
34749 */
34750
34751 struct UESidelinkAggregateMaximumBitRate : asn::sequence<2, 0, true, 1>
34752 {
34753         static constexpr const char* name() {return "UESidelinkAggregateMaximumBitRate";}
34754         using parent_t = asn::sequence<2, 0, true, 1>;
34755         struct uESidelinkAggregateMaximumBitRate_t : BitRate
34756         {
34757                 static constexpr const char* name() {return "uESidelinkAggregateMaximumBitRate_t";}
34758                 using parent_t = BitRate;
34759
34760         };
34761         uESidelinkAggregateMaximumBitRate_t& ref_uESidelinkAggregateMaximumBitRate() {return uESidelinkAggregateMaximumBitRate;}
34762         uESidelinkAggregateMaximumBitRate_t const& ref_uESidelinkAggregateMaximumBitRate() const {return uESidelinkAggregateMaximumBitRate;}
34763         struct iE_Extensions_t : ProtocolExtensionContainer<UE_Sidelink_Aggregate_MaximumBitRate_ExtIEs>
34764         {
34765                 static constexpr const char* name() {return "iE_Extensions_t";}
34766                 using parent_t = ProtocolExtensionContainer<UE_Sidelink_Aggregate_MaximumBitRate_ExtIEs>;
34767                 static constexpr bool optional = true;
34768
34769         };
34770         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
34771         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
34772         template<typename V> void decode(V& v)
34773         {
34774                 v(uESidelinkAggregateMaximumBitRate);
34775                 v(iE_Extensions);
34776
34777         };
34778         template<typename V> void encode(V& v) const
34779         {
34780                 v(uESidelinkAggregateMaximumBitRate);
34781                 v(iE_Extensions);
34782
34783         };
34784         void clear()
34785         {
34786                 uESidelinkAggregateMaximumBitRate.clear();
34787                 iE_Extensions.clear();
34788
34789         };
34790         private:
34791         uESidelinkAggregateMaximumBitRate_t     uESidelinkAggregateMaximumBitRate;
34792         iE_Extensions_t iE_Extensions;
34793
34794 };
34795 /*
34796 UEsToBeResetList-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
34797         ...
34798 }
34799 */
34800
34801 struct UEsToBeResetList_Item_ExtIEs
34802 {
34803         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
34804         {
34805                 size_t get_index() const {return type;}
34806                 bool is_unknown() const { return type == 1; }
34807                 void clear() {type = 0;}
34808                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
34809                 template<typename V>  bool decode(V& v)
34810                 {
34811                         clear();
34812                         if(!v(ref_nested())) return false;
34813                         { type = 1; return true;}
34814                         return false;
34815
34816                 }
34817                 template<typename V> bool encode(V& v) const
34818                 {
34819                         return v(ref_nested());
34820
34821                 }
34822                 protected:
34823                 template<typename V>  bool decode(size_t index, V& v)
34824                 {
34825                         clear();
34826                         switch(index)
34827                         {
34828                         case 1: type = 1; return v(ref_nested());
34829                         ref_nested().clear();
34830                         }
34831                         return false;
34832
34833                 }
34834                 template<typename V> bool encode(size_t index, V& v) const
34835                 {
34836                         if(index != type) {return false;} return v(ref_nested());
34837
34838                 }
34839                 private:
34840                 size_t type {0};
34841
34842         };
34843         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
34844         {
34845                 size_t get_index() const {return type;}
34846                 bool is_unknown() const { return type == 1; }
34847                 void clear() {type = 0;}
34848                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
34849                 template<typename V>  bool decode(V& v)
34850                 {
34851                         clear();
34852                         if(!v(ref_nested())) return false;
34853                         { type = 1; return true;}
34854                         return false;
34855
34856                 }
34857                 template<typename V> bool encode(V& v) const
34858                 {
34859                         return v(ref_nested());
34860
34861                 }
34862                 protected:
34863                 template<typename V>  bool decode(size_t index, V& v)
34864                 {
34865                         clear();
34866                         switch(index)
34867                         {
34868                         case 1: type = 1; return v(ref_nested());
34869                         ref_nested().clear();
34870                         }
34871                         return false;
34872
34873                 }
34874                 template<typename V> bool encode(size_t index, V& v) const
34875                 {
34876                         if(index != type) {return false;} return v(ref_nested());
34877
34878                 }
34879                 private:
34880                 size_t type {0};
34881
34882         };
34883         struct Extension_t : asn::typefield<true>
34884         {
34885                 ~Extension_t()  {clear();}
34886                 size_t get_index() const {return type;}
34887                 bool is_unknown() const { return type == 1; }
34888                 void clear()
34889                 {
34890                         type = 0; ref_nested().clear();
34891                 }
34892                 template<typename V> static inline void enumerate(V& v)
34893                 {
34894
34895                 }
34896                 protected:
34897                 template<typename V> bool decode(size_t index, V& v)
34898                 {
34899                         clear();
34900                         switch(index)
34901                         {
34902                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
34903                         }
34904                         return false;
34905
34906                 }
34907                 template<typename V> bool encode(size_t index, V& v) const
34908                 {
34909                         if(index != type) return false;
34910                         return false;
34911
34912                 }
34913                 private:
34914                 size_t type {0};
34915
34916         };
34917         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
34918         {
34919                 size_t get_index() const {return type;}
34920                 bool is_unknown() const { return type == 1; }
34921                 void clear() {type = 0;}
34922                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
34923                 template<typename V>  bool decode(V& v)
34924                 {
34925                         clear();
34926                         if(!v(ref_nested())) return false;
34927                         { type = 1; return true;}
34928                         return false;
34929
34930                 }
34931                 template<typename V> bool encode(V& v) const
34932                 {
34933                         return v(ref_nested());
34934
34935                 }
34936                 protected:
34937                 template<typename V>  bool decode(size_t index, V& v)
34938                 {
34939                         clear();
34940                         switch(index)
34941                         {
34942                         case 1: type = 1; return v(ref_nested());
34943                         ref_nested().clear();
34944                         }
34945                         return false;
34946
34947                 }
34948                 template<typename V> bool encode(size_t index, V& v) const
34949                 {
34950                         if(index != type) {return false;} return v(ref_nested());
34951
34952                 }
34953                 private:
34954                 size_t type {0};
34955
34956         };
34957
34958 };
34959 /*
34960 UEsToBeResetList-Item::= SEQUENCE {
34961         meNB-ID                                 UE-X2AP-ID,
34962         meNB-ID-ext                             UE-X2AP-ID-Extension                                                                                                            OPTIONAL,
34963         sgNB-ID                                 SgNB-UE-X2AP-ID                                                                                                                         OPTIONAL,
34964         iE-Extensions                   ProtocolExtensionContainer { {UEsToBeResetList-Item-ExtIEs} }                           OPTIONAL,
34965         ...
34966 }
34967 */
34968
34969 struct UEsToBeResetList_Item : asn::sequence<4, 0, true, 3>
34970 {
34971         static constexpr const char* name() {return "UEsToBeResetList-Item";}
34972         using parent_t = asn::sequence<4, 0, true, 3>;
34973         struct meNB_ID_t : UE_X2AP_ID
34974         {
34975                 static constexpr const char* name() {return "meNB_ID_t";}
34976                 using parent_t = UE_X2AP_ID;
34977
34978         };
34979         meNB_ID_t& ref_meNB_ID() {return meNB_ID;}
34980         meNB_ID_t const& ref_meNB_ID() const {return meNB_ID;}
34981         struct meNB_ID_ext_t : UE_X2AP_ID_Extension
34982         {
34983                 static constexpr const char* name() {return "meNB_ID_ext_t";}
34984                 using parent_t = UE_X2AP_ID_Extension;
34985                 static constexpr bool optional = true;
34986
34987         };
34988         meNB_ID_ext_t& set_meNB_ID_ext() { meNB_ID_ext.setpresent(true); return meNB_ID_ext;}
34989         meNB_ID_ext_t const* get_meNB_ID_ext() const {return meNB_ID_ext.is_valid() ? &meNB_ID_ext : nullptr;}
34990         struct sgNB_ID_t : SgNB_UE_X2AP_ID
34991         {
34992                 static constexpr const char* name() {return "sgNB_ID_t";}
34993                 using parent_t = SgNB_UE_X2AP_ID;
34994                 static constexpr bool optional = true;
34995
34996         };
34997         sgNB_ID_t& set_sgNB_ID() { sgNB_ID.setpresent(true); return sgNB_ID;}
34998         sgNB_ID_t const* get_sgNB_ID() const {return sgNB_ID.is_valid() ? &sgNB_ID : nullptr;}
34999         struct iE_Extensions_t : ProtocolExtensionContainer<UEsToBeResetList_Item_ExtIEs>
35000         {
35001                 static constexpr const char* name() {return "iE_Extensions_t";}
35002                 using parent_t = ProtocolExtensionContainer<UEsToBeResetList_Item_ExtIEs>;
35003                 static constexpr bool optional = true;
35004
35005         };
35006         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
35007         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
35008         template<typename V> void decode(V& v)
35009         {
35010                 v(meNB_ID);
35011                 v(meNB_ID_ext);
35012                 v(sgNB_ID);
35013                 v(iE_Extensions);
35014
35015         };
35016         template<typename V> void encode(V& v) const
35017         {
35018                 v(meNB_ID);
35019                 v(meNB_ID_ext);
35020                 v(sgNB_ID);
35021                 v(iE_Extensions);
35022
35023         };
35024         void clear()
35025         {
35026                 meNB_ID.clear();
35027                 meNB_ID_ext.clear();
35028                 sgNB_ID.clear();
35029                 iE_Extensions.clear();
35030
35031         };
35032         private:
35033         meNB_ID_t       meNB_ID;
35034         meNB_ID_ext_t   meNB_ID_ext;
35035         sgNB_ID_t       sgNB_ID;
35036         iE_Extensions_t iE_Extensions;
35037
35038 };
35039 /*
35040 UEsToBeResetList ::= SEQUENCE (SIZE (1.. maxUEsinengNBDU)) OF UEsToBeResetList-Item
35041 */
35042
35043 struct UEsToBeResetList_elm : UEsToBeResetList_Item
35044 {
35045         static constexpr const char* name() {return "UEsToBeResetList_elm";}
35046         using parent_t = UEsToBeResetList_Item;
35047
35048 };
35049 struct UEsToBeResetList : asn::sequenceof<UEsToBeResetList_elm>
35050 {
35051         static constexpr const char* name() {return "UEsToBeResetList";}
35052         using parent_t = asn::sequenceof<UEsToBeResetList_elm>;
35053         using constraint_t = asn::constraints<false,asn::span<1,  maxUEsinengNBDU >>;
35054
35055 };
35056 /*
35057 UL-HighInterferenceIndication ::= BIT STRING (SIZE(1..110, ...))
35058 */
35059
35060 struct UL_HighInterferenceIndication : asn::bstring<>
35061 {
35062         using constraint_t = asn::constraints<true,asn::span<1, 110>>;
35063         static constexpr const char* name() {return "UL-HighInterferenceIndication";}
35064         using parent_t = asn::bstring<>;
35065
35066 };
35067
35068 /*
35069 UL-HighInterferenceIndicationInfo-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
35070         ...
35071 }
35072 */
35073
35074 struct UL_HighInterferenceIndicationInfo_Item_ExtIEs
35075 {
35076         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
35077         {
35078                 size_t get_index() const {return type;}
35079                 bool is_unknown() const { return type == 1; }
35080                 void clear() {type = 0;}
35081                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
35082                 template<typename V>  bool decode(V& v)
35083                 {
35084                         clear();
35085                         if(!v(ref_nested())) return false;
35086                         { type = 1; return true;}
35087                         return false;
35088
35089                 }
35090                 template<typename V> bool encode(V& v) const
35091                 {
35092                         return v(ref_nested());
35093
35094                 }
35095                 protected:
35096                 template<typename V>  bool decode(size_t index, V& v)
35097                 {
35098                         clear();
35099                         switch(index)
35100                         {
35101                         case 1: type = 1; return v(ref_nested());
35102                         ref_nested().clear();
35103                         }
35104                         return false;
35105
35106                 }
35107                 template<typename V> bool encode(size_t index, V& v) const
35108                 {
35109                         if(index != type) {return false;} return v(ref_nested());
35110
35111                 }
35112                 private:
35113                 size_t type {0};
35114
35115         };
35116         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
35117         {
35118                 size_t get_index() const {return type;}
35119                 bool is_unknown() const { return type == 1; }
35120                 void clear() {type = 0;}
35121                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
35122                 template<typename V>  bool decode(V& v)
35123                 {
35124                         clear();
35125                         if(!v(ref_nested())) return false;
35126                         { type = 1; return true;}
35127                         return false;
35128
35129                 }
35130                 template<typename V> bool encode(V& v) const
35131                 {
35132                         return v(ref_nested());
35133
35134                 }
35135                 protected:
35136                 template<typename V>  bool decode(size_t index, V& v)
35137                 {
35138                         clear();
35139                         switch(index)
35140                         {
35141                         case 1: type = 1; return v(ref_nested());
35142                         ref_nested().clear();
35143                         }
35144                         return false;
35145
35146                 }
35147                 template<typename V> bool encode(size_t index, V& v) const
35148                 {
35149                         if(index != type) {return false;} return v(ref_nested());
35150
35151                 }
35152                 private:
35153                 size_t type {0};
35154
35155         };
35156         struct Extension_t : asn::typefield<true>
35157         {
35158                 ~Extension_t()  {clear();}
35159                 size_t get_index() const {return type;}
35160                 bool is_unknown() const { return type == 1; }
35161                 void clear()
35162                 {
35163                         type = 0; ref_nested().clear();
35164                 }
35165                 template<typename V> static inline void enumerate(V& v)
35166                 {
35167
35168                 }
35169                 protected:
35170                 template<typename V> bool decode(size_t index, V& v)
35171                 {
35172                         clear();
35173                         switch(index)
35174                         {
35175                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
35176                         }
35177                         return false;
35178
35179                 }
35180                 template<typename V> bool encode(size_t index, V& v) const
35181                 {
35182                         if(index != type) return false;
35183                         return false;
35184
35185                 }
35186                 private:
35187                 size_t type {0};
35188
35189         };
35190         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
35191         {
35192                 size_t get_index() const {return type;}
35193                 bool is_unknown() const { return type == 1; }
35194                 void clear() {type = 0;}
35195                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
35196                 template<typename V>  bool decode(V& v)
35197                 {
35198                         clear();
35199                         if(!v(ref_nested())) return false;
35200                         { type = 1; return true;}
35201                         return false;
35202
35203                 }
35204                 template<typename V> bool encode(V& v) const
35205                 {
35206                         return v(ref_nested());
35207
35208                 }
35209                 protected:
35210                 template<typename V>  bool decode(size_t index, V& v)
35211                 {
35212                         clear();
35213                         switch(index)
35214                         {
35215                         case 1: type = 1; return v(ref_nested());
35216                         ref_nested().clear();
35217                         }
35218                         return false;
35219
35220                 }
35221                 template<typename V> bool encode(size_t index, V& v) const
35222                 {
35223                         if(index != type) {return false;} return v(ref_nested());
35224
35225                 }
35226                 private:
35227                 size_t type {0};
35228
35229         };
35230
35231 };
35232 /*
35233 UL-HighInterferenceIndicationInfo-Item ::= SEQUENCE {
35234         target-Cell-ID                                  ECGI,
35235         ul-interferenceindication               UL-HighInterferenceIndication,
35236         iE-Extensions                                   ProtocolExtensionContainer { {UL-HighInterferenceIndicationInfo-Item-ExtIEs} } OPTIONAL,
35237         ...
35238 }
35239 */
35240
35241 struct UL_HighInterferenceIndicationInfo_Item : asn::sequence<3, 0, true, 1>
35242 {
35243         static constexpr const char* name() {return "UL-HighInterferenceIndicationInfo-Item";}
35244         using parent_t = asn::sequence<3, 0, true, 1>;
35245         struct target_Cell_ID_t : ECGI
35246         {
35247                 static constexpr const char* name() {return "target_Cell_ID_t";}
35248                 using parent_t = ECGI;
35249
35250         };
35251         target_Cell_ID_t& ref_target_Cell_ID() {return target_Cell_ID;}
35252         target_Cell_ID_t const& ref_target_Cell_ID() const {return target_Cell_ID;}
35253         struct ul_interferenceindication_t : UL_HighInterferenceIndication
35254         {
35255                 static constexpr const char* name() {return "ul_interferenceindication_t";}
35256                 using parent_t = UL_HighInterferenceIndication;
35257
35258         };
35259         ul_interferenceindication_t& ref_ul_interferenceindication() {return ul_interferenceindication;}
35260         ul_interferenceindication_t const& ref_ul_interferenceindication() const {return ul_interferenceindication;}
35261         struct iE_Extensions_t : ProtocolExtensionContainer<UL_HighInterferenceIndicationInfo_Item_ExtIEs>
35262         {
35263                 static constexpr const char* name() {return "iE_Extensions_t";}
35264                 using parent_t = ProtocolExtensionContainer<UL_HighInterferenceIndicationInfo_Item_ExtIEs>;
35265                 static constexpr bool optional = true;
35266
35267         };
35268         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
35269         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
35270         template<typename V> void decode(V& v)
35271         {
35272                 v(target_Cell_ID);
35273                 v(ul_interferenceindication);
35274                 v(iE_Extensions);
35275
35276         };
35277         template<typename V> void encode(V& v) const
35278         {
35279                 v(target_Cell_ID);
35280                 v(ul_interferenceindication);
35281                 v(iE_Extensions);
35282
35283         };
35284         void clear()
35285         {
35286                 target_Cell_ID.clear();
35287                 ul_interferenceindication.clear();
35288                 iE_Extensions.clear();
35289
35290         };
35291         private:
35292         target_Cell_ID_t        target_Cell_ID;
35293         ul_interferenceindication_t     ul_interferenceindication;
35294         iE_Extensions_t iE_Extensions;
35295
35296 };
35297 /*
35298 UL-HighInterferenceIndicationInfo ::= SEQUENCE (SIZE(1..maxCellineNB)) OF UL-HighInterferenceIndicationInfo-Item
35299 */
35300
35301 struct UL_HighInterferenceIndicationInfo_elm : UL_HighInterferenceIndicationInfo_Item
35302 {
35303         static constexpr const char* name() {return "UL_HighInterferenceIndicationInfo_elm";}
35304         using parent_t = UL_HighInterferenceIndicationInfo_Item;
35305
35306 };
35307 struct UL_HighInterferenceIndicationInfo : asn::sequenceof<UL_HighInterferenceIndicationInfo_elm>
35308 {
35309         static constexpr const char* name() {return "UL-HighInterferenceIndicationInfo";}
35310         using parent_t = asn::sequenceof<UL_HighInterferenceIndicationInfo_elm>;
35311         using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
35312
35313 };
35314 /*
35315 UL-UE-Configuration::= ENUMERATED { no-data, shared, only, ... }
35316 */
35317
35318 struct UL_UE_Configuration : asn::enumerated<3, 0, true>
35319 {
35320         static constexpr const char* name() {return "UL-UE-Configuration";}
35321         using parent_t = asn::enumerated<3, 0, true>;
35322         typedef enum {
35323                 no_data
35324                 ,shared
35325                 ,only
35326         } index_t;
35327
35328 };
35329
35330 /*
35331 ULConfiguration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
35332         ...
35333 }
35334 */
35335
35336 struct ULConfiguration_ExtIEs
35337 {
35338         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
35339         {
35340                 size_t get_index() const {return type;}
35341                 bool is_unknown() const { return type == 1; }
35342                 void clear() {type = 0;}
35343                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
35344                 template<typename V>  bool decode(V& v)
35345                 {
35346                         clear();
35347                         if(!v(ref_nested())) return false;
35348                         { type = 1; return true;}
35349                         return false;
35350
35351                 }
35352                 template<typename V> bool encode(V& v) const
35353                 {
35354                         return v(ref_nested());
35355
35356                 }
35357                 protected:
35358                 template<typename V>  bool decode(size_t index, V& v)
35359                 {
35360                         clear();
35361                         switch(index)
35362                         {
35363                         case 1: type = 1; return v(ref_nested());
35364                         ref_nested().clear();
35365                         }
35366                         return false;
35367
35368                 }
35369                 template<typename V> bool encode(size_t index, V& v) const
35370                 {
35371                         if(index != type) {return false;} return v(ref_nested());
35372
35373                 }
35374                 private:
35375                 size_t type {0};
35376
35377         };
35378         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
35379         {
35380                 size_t get_index() const {return type;}
35381                 bool is_unknown() const { return type == 1; }
35382                 void clear() {type = 0;}
35383                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
35384                 template<typename V>  bool decode(V& v)
35385                 {
35386                         clear();
35387                         if(!v(ref_nested())) return false;
35388                         { type = 1; return true;}
35389                         return false;
35390
35391                 }
35392                 template<typename V> bool encode(V& v) const
35393                 {
35394                         return v(ref_nested());
35395
35396                 }
35397                 protected:
35398                 template<typename V>  bool decode(size_t index, V& v)
35399                 {
35400                         clear();
35401                         switch(index)
35402                         {
35403                         case 1: type = 1; return v(ref_nested());
35404                         ref_nested().clear();
35405                         }
35406                         return false;
35407
35408                 }
35409                 template<typename V> bool encode(size_t index, V& v) const
35410                 {
35411                         if(index != type) {return false;} return v(ref_nested());
35412
35413                 }
35414                 private:
35415                 size_t type {0};
35416
35417         };
35418         struct Extension_t : asn::typefield<true>
35419         {
35420                 ~Extension_t()  {clear();}
35421                 size_t get_index() const {return type;}
35422                 bool is_unknown() const { return type == 1; }
35423                 void clear()
35424                 {
35425                         type = 0; ref_nested().clear();
35426                 }
35427                 template<typename V> static inline void enumerate(V& v)
35428                 {
35429
35430                 }
35431                 protected:
35432                 template<typename V> bool decode(size_t index, V& v)
35433                 {
35434                         clear();
35435                         switch(index)
35436                         {
35437                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
35438                         }
35439                         return false;
35440
35441                 }
35442                 template<typename V> bool encode(size_t index, V& v) const
35443                 {
35444                         if(index != type) return false;
35445                         return false;
35446
35447                 }
35448                 private:
35449                 size_t type {0};
35450
35451         };
35452         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
35453         {
35454                 size_t get_index() const {return type;}
35455                 bool is_unknown() const { return type == 1; }
35456                 void clear() {type = 0;}
35457                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
35458                 template<typename V>  bool decode(V& v)
35459                 {
35460                         clear();
35461                         if(!v(ref_nested())) return false;
35462                         { type = 1; return true;}
35463                         return false;
35464
35465                 }
35466                 template<typename V> bool encode(V& v) const
35467                 {
35468                         return v(ref_nested());
35469
35470                 }
35471                 protected:
35472                 template<typename V>  bool decode(size_t index, V& v)
35473                 {
35474                         clear();
35475                         switch(index)
35476                         {
35477                         case 1: type = 1; return v(ref_nested());
35478                         ref_nested().clear();
35479                         }
35480                         return false;
35481
35482                 }
35483                 template<typename V> bool encode(size_t index, V& v) const
35484                 {
35485                         if(index != type) {return false;} return v(ref_nested());
35486
35487                 }
35488                 private:
35489                 size_t type {0};
35490
35491         };
35492
35493 };
35494 /*
35495 ULConfiguration::= SEQUENCE {
35496         uL-PDCP                 UL-UE-Configuration,
35497         iE-Extensions                                   ProtocolExtensionContainer { {ULConfiguration-ExtIEs} } OPTIONAL,
35498         ...
35499 }
35500 */
35501
35502 struct ULConfiguration : asn::sequence<2, 0, true, 1>
35503 {
35504         static constexpr const char* name() {return "ULConfiguration";}
35505         using parent_t = asn::sequence<2, 0, true, 1>;
35506         struct uL_PDCP_t : UL_UE_Configuration
35507         {
35508                 static constexpr const char* name() {return "uL_PDCP_t";}
35509                 using parent_t = UL_UE_Configuration;
35510
35511         };
35512         uL_PDCP_t& ref_uL_PDCP() {return uL_PDCP;}
35513         uL_PDCP_t const& ref_uL_PDCP() const {return uL_PDCP;}
35514         struct iE_Extensions_t : ProtocolExtensionContainer<ULConfiguration_ExtIEs>
35515         {
35516                 static constexpr const char* name() {return "iE_Extensions_t";}
35517                 using parent_t = ProtocolExtensionContainer<ULConfiguration_ExtIEs>;
35518                 static constexpr bool optional = true;
35519
35520         };
35521         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
35522         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
35523         template<typename V> void decode(V& v)
35524         {
35525                 v(uL_PDCP);
35526                 v(iE_Extensions);
35527
35528         };
35529         template<typename V> void encode(V& v) const
35530         {
35531                 v(uL_PDCP);
35532                 v(iE_Extensions);
35533
35534         };
35535         void clear()
35536         {
35537                 uL_PDCP.clear();
35538                 iE_Extensions.clear();
35539
35540         };
35541         private:
35542         uL_PDCP_t       uL_PDCP;
35543         iE_Extensions_t iE_Extensions;
35544
35545 };
35546 /*
35547 VehicleUE ::= ENUMERATED {
35548         authorized,
35549         not-authorized,
35550         ...
35551 }
35552 */
35553
35554 struct VehicleUE : asn::enumerated<2, 0, true>
35555 {
35556         static constexpr const char* name() {return "VehicleUE";}
35557         using parent_t = asn::enumerated<2, 0, true>;
35558         typedef enum {
35559                 authorized
35560                 ,not_authorized
35561         } index_t;
35562
35563 };
35564
35565 /*
35566 V2XServicesAuthorized-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
35567         ...
35568 }
35569 */
35570
35571 struct V2XServicesAuthorized_ExtIEs
35572 {
35573         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
35574         {
35575                 size_t get_index() const {return type;}
35576                 bool is_unknown() const { return type == 1; }
35577                 void clear() {type = 0;}
35578                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
35579                 template<typename V>  bool decode(V& v)
35580                 {
35581                         clear();
35582                         if(!v(ref_nested())) return false;
35583                         { type = 1; return true;}
35584                         return false;
35585
35586                 }
35587                 template<typename V> bool encode(V& v) const
35588                 {
35589                         return v(ref_nested());
35590
35591                 }
35592                 protected:
35593                 template<typename V>  bool decode(size_t index, V& v)
35594                 {
35595                         clear();
35596                         switch(index)
35597                         {
35598                         case 1: type = 1; return v(ref_nested());
35599                         ref_nested().clear();
35600                         }
35601                         return false;
35602
35603                 }
35604                 template<typename V> bool encode(size_t index, V& v) const
35605                 {
35606                         if(index != type) {return false;} return v(ref_nested());
35607
35608                 }
35609                 private:
35610                 size_t type {0};
35611
35612         };
35613         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
35614         {
35615                 size_t get_index() const {return type;}
35616                 bool is_unknown() const { return type == 1; }
35617                 void clear() {type = 0;}
35618                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
35619                 template<typename V>  bool decode(V& v)
35620                 {
35621                         clear();
35622                         if(!v(ref_nested())) return false;
35623                         { type = 1; return true;}
35624                         return false;
35625
35626                 }
35627                 template<typename V> bool encode(V& v) const
35628                 {
35629                         return v(ref_nested());
35630
35631                 }
35632                 protected:
35633                 template<typename V>  bool decode(size_t index, V& v)
35634                 {
35635                         clear();
35636                         switch(index)
35637                         {
35638                         case 1: type = 1; return v(ref_nested());
35639                         ref_nested().clear();
35640                         }
35641                         return false;
35642
35643                 }
35644                 template<typename V> bool encode(size_t index, V& v) const
35645                 {
35646                         if(index != type) {return false;} return v(ref_nested());
35647
35648                 }
35649                 private:
35650                 size_t type {0};
35651
35652         };
35653         struct Extension_t : asn::typefield<true>
35654         {
35655                 ~Extension_t()  {clear();}
35656                 size_t get_index() const {return type;}
35657                 bool is_unknown() const { return type == 1; }
35658                 void clear()
35659                 {
35660                         type = 0; ref_nested().clear();
35661                 }
35662                 template<typename V> static inline void enumerate(V& v)
35663                 {
35664
35665                 }
35666                 protected:
35667                 template<typename V> bool decode(size_t index, V& v)
35668                 {
35669                         clear();
35670                         switch(index)
35671                         {
35672                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
35673                         }
35674                         return false;
35675
35676                 }
35677                 template<typename V> bool encode(size_t index, V& v) const
35678                 {
35679                         if(index != type) return false;
35680                         return false;
35681
35682                 }
35683                 private:
35684                 size_t type {0};
35685
35686         };
35687         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
35688         {
35689                 size_t get_index() const {return type;}
35690                 bool is_unknown() const { return type == 1; }
35691                 void clear() {type = 0;}
35692                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
35693                 template<typename V>  bool decode(V& v)
35694                 {
35695                         clear();
35696                         if(!v(ref_nested())) return false;
35697                         { type = 1; return true;}
35698                         return false;
35699
35700                 }
35701                 template<typename V> bool encode(V& v) const
35702                 {
35703                         return v(ref_nested());
35704
35705                 }
35706                 protected:
35707                 template<typename V>  bool decode(size_t index, V& v)
35708                 {
35709                         clear();
35710                         switch(index)
35711                         {
35712                         case 1: type = 1; return v(ref_nested());
35713                         ref_nested().clear();
35714                         }
35715                         return false;
35716
35717                 }
35718                 template<typename V> bool encode(size_t index, V& v) const
35719                 {
35720                         if(index != type) {return false;} return v(ref_nested());
35721
35722                 }
35723                 private:
35724                 size_t type {0};
35725
35726         };
35727
35728 };
35729 /*
35730 V2XServicesAuthorized ::= SEQUENCE {
35731         vehicleUE                       VehicleUE                                                                                                               OPTIONAL,
35732 pedestrianUE                    PedestrianUE                                                                                                    OPTIONAL,
35733         iE-Extensions           ProtocolExtensionContainer { {V2XServicesAuthorized-ExtIEs} }   OPTIONAL,
35734         ...
35735 }
35736 */
35737
35738 struct V2XServicesAuthorized : asn::sequence<3, 0, true, 3>
35739 {
35740         static constexpr const char* name() {return "V2XServicesAuthorized";}
35741         using parent_t = asn::sequence<3, 0, true, 3>;
35742         struct vehicleUE_t : VehicleUE
35743         {
35744                 static constexpr const char* name() {return "vehicleUE_t";}
35745                 using parent_t = VehicleUE;
35746                 static constexpr bool optional = true;
35747
35748         };
35749         vehicleUE_t& set_vehicleUE() { vehicleUE.setpresent(true); return vehicleUE;}
35750         vehicleUE_t const* get_vehicleUE() const {return vehicleUE.is_valid() ? &vehicleUE : nullptr;}
35751         struct pedestrianUE_t : PedestrianUE
35752         {
35753                 static constexpr const char* name() {return "pedestrianUE_t";}
35754                 using parent_t = PedestrianUE;
35755                 static constexpr bool optional = true;
35756
35757         };
35758         pedestrianUE_t& set_pedestrianUE() { pedestrianUE.setpresent(true); return pedestrianUE;}
35759         pedestrianUE_t const* get_pedestrianUE() const {return pedestrianUE.is_valid() ? &pedestrianUE : nullptr;}
35760         struct iE_Extensions_t : ProtocolExtensionContainer<V2XServicesAuthorized_ExtIEs>
35761         {
35762                 static constexpr const char* name() {return "iE_Extensions_t";}
35763                 using parent_t = ProtocolExtensionContainer<V2XServicesAuthorized_ExtIEs>;
35764                 static constexpr bool optional = true;
35765
35766         };
35767         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
35768         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
35769         template<typename V> void decode(V& v)
35770         {
35771                 v(vehicleUE);
35772                 v(pedestrianUE);
35773                 v(iE_Extensions);
35774
35775         };
35776         template<typename V> void encode(V& v) const
35777         {
35778                 v(vehicleUE);
35779                 v(pedestrianUE);
35780                 v(iE_Extensions);
35781
35782         };
35783         void clear()
35784         {
35785                 vehicleUE.clear();
35786                 pedestrianUE.clear();
35787                 iE_Extensions.clear();
35788
35789         };
35790         private:
35791         vehicleUE_t     vehicleUE;
35792         pedestrianUE_t  pedestrianUE;
35793         iE_Extensions_t iE_Extensions;
35794
35795 };
35796 /*
35797 WT-UE-XwAP-ID ::= OCTET STRING (SIZE (3))
35798 */
35799
35800 struct WT_UE_XwAP_ID : asn::ostring<>
35801 {
35802         using constraint_t = asn::constraints<false,asn::one<3>>;
35803         static constexpr const char* name() {return "WT-UE-XwAP-ID";}
35804         using parent_t = asn::ostring<>;
35805
35806 };
35807
35808 /*
35809 WTID-Type1 ::= SEQUENCE {
35810         pLMN-Identity                                   PLMN-Identity,
35811         shortWTID                                               BIT STRING (SIZE(24)),
35812         ...
35813 }
35814 */
35815
35816 struct WTID_Type1 : asn::sequence<2, 0, true, 0>
35817 {
35818         static constexpr const char* name() {return "WTID-Type1";}
35819         using parent_t = asn::sequence<2, 0, true, 0>;
35820         struct pLMN_Identity_t : PLMN_Identity
35821         {
35822                 static constexpr const char* name() {return "pLMN_Identity_t";}
35823                 using parent_t = PLMN_Identity;
35824
35825         };
35826         pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
35827         pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
35828         struct shortWTID_t : asn::bstring<>
35829         {
35830                 using constraint_t = asn::constraints<false,asn::one<24>>;
35831                 static constexpr const char* name() {return "shortWTID_t";}
35832                 using parent_t = asn::bstring<>;
35833
35834         };
35835
35836         shortWTID_t& ref_shortWTID() {return shortWTID;}
35837         shortWTID_t const& ref_shortWTID() const {return shortWTID;}
35838         template<typename V> void decode(V& v)
35839         {
35840                 v(pLMN_Identity);
35841                 v(shortWTID);
35842
35843         };
35844         template<typename V> void encode(V& v) const
35845         {
35846                 v(pLMN_Identity);
35847                 v(shortWTID);
35848
35849         };
35850         void clear()
35851         {
35852                 pLMN_Identity.clear();
35853                 shortWTID.clear();
35854
35855         };
35856         private:
35857         pLMN_Identity_t pLMN_Identity;
35858         shortWTID_t     shortWTID;
35859
35860 };
35861 /*
35862 WTID-Long-Type2 ::= BIT STRING (SIZE(48))
35863 */
35864
35865 struct WTID_Long_Type2 : asn::bstring<>
35866 {
35867         using constraint_t = asn::constraints<false,asn::one<48>>;
35868         static constexpr const char* name() {return "WTID-Long-Type2";}
35869         using parent_t = asn::bstring<>;
35870
35871 };
35872
35873 /*
35874 WTID ::= CHOICE {
35875         wTID-Type1                      WTID-Type1,
35876         wTID-Type2                      WTID-Long-Type2,
35877         ...
35878 }
35879 */
35880
35881 struct WTID : asn::choice<2, 0, true>
35882 {
35883         static constexpr const char* name() {return "WTID";}
35884         using parent_t = asn::choice<2, 0, true>;
35885         index_type get_index() const {return index;}
35886         bool is_unknown() const {return index == 3;}
35887         void set_unknown() { set_index(3);  }
35888         ~WTID() {clear();}
35889         struct wTID_Type1_t : WTID_Type1
35890         {
35891                 static constexpr const char* name() {return "wTID_Type1_t";}
35892                 using parent_t = WTID_Type1;
35893
35894         };
35895         struct wTID_Type2_t : WTID_Long_Type2
35896         {
35897                 static constexpr const char* name() {return "wTID_Type2_t";}
35898                 using parent_t = WTID_Long_Type2;
35899
35900         };
35901         void clear()
35902         {
35903                 switch(get_index())
35904                 {
35905                 case 1: var.destroy<wTID_Type1_t>(); break;
35906                 case 2: var.destroy<wTID_Type2_t>(); break;
35907                 }
35908                 index = 0;
35909                 base::clear();
35910         }
35911         template<typename V> bool decode(size_t idx, V& v)
35912         {
35913                 clear();
35914                 switch(idx)
35915                 {
35916                 case 1: set_index(1); return v(var.build<wTID_Type1_t>());
35917                 case 2: set_index(2); return v(var.build<wTID_Type2_t>());
35918                 }
35919                 return false;
35920
35921         }
35922         template<typename V> bool encode(V& v) const
35923         {
35924                 switch(get_index())
35925                 {
35926                 case 1: return v(var.as<wTID_Type1_t>());
35927                 case 2: return v(var.as<wTID_Type2_t>());
35928                 }
35929                 return false;
35930         }
35931         template<typename V> static inline void enumerate(V& v)
35932         {
35933                 v.template operator()<wTID_Type1_t>(1);
35934                 v.template operator()<wTID_Type2_t>(2);
35935
35936         }
35937         wTID_Type1_t& select_wTID_Type1() { if(get_index() != 1) { clear(); set_index(1); return var.build<wTID_Type1_t>();} return var.as<wTID_Type1_t>();}
35938         wTID_Type1_t const* get_wTID_Type1() const { if(get_index() == 1) { return &var.as<wTID_Type1_t>();} return nullptr; }
35939         wTID_Type2_t& select_wTID_Type2() { if(get_index() != 2) { clear(); set_index(2); return var.build<wTID_Type2_t>();} return var.as<wTID_Type2_t>();}
35940         wTID_Type2_t const* get_wTID_Type2() const { if(get_index() == 2) { return &var.as<wTID_Type2_t>();} return nullptr; }
35941         private:
35942         void set_index(index_type i) {index = i; base::set();}
35943         union union_type
35944         {
35945                 char dummy1[sizeof(wTID_Type1_t)];
35946                 char dummy2[sizeof(wTID_Type2_t)];
35947
35948         };
35949         asn::variant<sizeof(union_type)>        var;
35950         index_type      index {0};
35951 };
35952 /*
35953 X2BenefitValue ::= INTEGER (1..8, ...)
35954 */
35955
35956 struct X2BenefitValue : asn::integer<>
35957 {
35958         using constraint_t = asn::constraints<true,asn::span<1, 8>>;
35959         static constexpr const char* name() {return "X2BenefitValue";}
35960         using parent_t = asn::integer<>;
35961
35962 };