tests/tests-asn1c-compiler/154-with-REAL-components-OK.asn1.-Pgen-OER

   1
   2 /*** <<< INCLUDES [UnconstrainedREAL] >>> ***/
   3
   4 #include <NativeReal.h>
   5
   6 /*** <<< TYPE-DECLS [UnconstrainedREAL] >>> ***/
   7
   8 typedef double   UnconstrainedREAL_t;
   9
  10 /*** <<< FUNC-DECLS [UnconstrainedREAL] >>> ***/
  11
  12 extern asn_TYPE_descriptor_t asn_DEF_UnconstrainedREAL;
  13 asn_struct_free_f UnconstrainedREAL_free;
  14 asn_struct_print_f UnconstrainedREAL_print;
  15 asn_constr_check_f UnconstrainedREAL_constraint;
  16 ber_type_decoder_f UnconstrainedREAL_decode_ber;
  17 der_type_encoder_f UnconstrainedREAL_encode_der;
  18 xer_type_decoder_f UnconstrainedREAL_decode_xer;
  19 xer_type_encoder_f UnconstrainedREAL_encode_xer;
  20 oer_type_decoder_f UnconstrainedREAL_decode_oer;
  21 oer_type_encoder_f UnconstrainedREAL_encode_oer;
  22
  23 /*** <<< CODE [UnconstrainedREAL] >>> ***/
  24
  25 /*
  26  * This type is implemented using NativeReal,
  27  * so here we adjust the DEF accordingly.
  28  */
  29
  30 /*** <<< STAT-DEFS [UnconstrainedREAL] >>> ***/
  31
  32 static const ber_tlv_tag_t asn_DEF_UnconstrainedREAL_tags_1[] = {
  33         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
  34 };
  35 asn_TYPE_descriptor_t asn_DEF_UnconstrainedREAL = {
  36         "UnconstrainedREAL",
  37         "UnconstrainedREAL",
  38         &asn_OP_NativeReal,
  39         asn_DEF_UnconstrainedREAL_tags_1,
  40         sizeof(asn_DEF_UnconstrainedREAL_tags_1)
  41                 /sizeof(asn_DEF_UnconstrainedREAL_tags_1[0]), /* 1 */
  42         asn_DEF_UnconstrainedREAL_tags_1,       /* Same as above */
  43         sizeof(asn_DEF_UnconstrainedREAL_tags_1)
  44                 /sizeof(asn_DEF_UnconstrainedREAL_tags_1[0]), /* 1 */
  45         { 0, 0, NativeReal_constraint },
  46         0, 0,   /* No members */
  47         0       /* No specifics */
  48 };
  49
  50
  51 /*** <<< INCLUDES [WeirdlyConstrainedREAL] >>> ***/
  52
  53 #include <NativeReal.h>
  54
  55 /*** <<< TYPE-DECLS [WeirdlyConstrainedREAL] >>> ***/
  56
  57 typedef double   WeirdlyConstrainedREAL_t;
  58
  59 /*** <<< FUNC-DECLS [WeirdlyConstrainedREAL] >>> ***/
  60
  61 extern asn_TYPE_descriptor_t asn_DEF_WeirdlyConstrainedREAL;
  62 asn_struct_free_f WeirdlyConstrainedREAL_free;
  63 asn_struct_print_f WeirdlyConstrainedREAL_print;
  64 asn_constr_check_f WeirdlyConstrainedREAL_constraint;
  65 ber_type_decoder_f WeirdlyConstrainedREAL_decode_ber;
  66 der_type_encoder_f WeirdlyConstrainedREAL_encode_der;
  67 xer_type_decoder_f WeirdlyConstrainedREAL_decode_xer;
  68 xer_type_encoder_f WeirdlyConstrainedREAL_encode_xer;
  69 oer_type_decoder_f WeirdlyConstrainedREAL_decode_oer;
  70 oer_type_encoder_f WeirdlyConstrainedREAL_encode_oer;
  71
  72 /*** <<< CODE [WeirdlyConstrainedREAL] >>> ***/
  73
  74 int
  75 WeirdlyConstrainedREAL_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
  76                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
  77         double value;
  78
  79         if(!sptr) {
  80                 ASN__CTFAIL(app_key, td, sptr,
  81                         "%s: value not given (%s:%d)",
  82                         td->name, __FILE__, __LINE__);
  83                 return -1;
  84         }
  85
  86         value = *(const double *)sptr;
  87
  88         if((value == 3)) {
  89                 /* Constraint check succeeded */
  90                 return 0;
  91         } else {
  92                 ASN__CTFAIL(app_key, td, sptr,
  93                         "%s: constraint failed (%s:%d)",
  94                         td->name, __FILE__, __LINE__);
  95                 return -1;
  96         }
  97 }
  98
  99 /*
 100  * This type is implemented using NativeReal,
 101  * so here we adjust the DEF accordingly.
 102  */
 103
 104 /*** <<< CTDEFS [WeirdlyConstrainedREAL] >>> ***/
 105
 106 static asn_oer_constraints_t asn_OER_type_WeirdlyConstrainedREAL_constr_1 CC_NOTUSED = {
 107         { 0, 0 },
 108         -1};
 109
 110 /*** <<< STAT-DEFS [WeirdlyConstrainedREAL] >>> ***/
 111
 112 static const ber_tlv_tag_t asn_DEF_WeirdlyConstrainedREAL_tags_1[] = {
 113         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 114 };
 115 asn_TYPE_descriptor_t asn_DEF_WeirdlyConstrainedREAL = {
 116         "WeirdlyConstrainedREAL",
 117         "WeirdlyConstrainedREAL",
 118         &asn_OP_NativeReal,
 119         asn_DEF_WeirdlyConstrainedREAL_tags_1,
 120         sizeof(asn_DEF_WeirdlyConstrainedREAL_tags_1)
 121                 /sizeof(asn_DEF_WeirdlyConstrainedREAL_tags_1[0]), /* 1 */
 122         asn_DEF_WeirdlyConstrainedREAL_tags_1,  /* Same as above */
 123         sizeof(asn_DEF_WeirdlyConstrainedREAL_tags_1)
 124                 /sizeof(asn_DEF_WeirdlyConstrainedREAL_tags_1[0]), /* 1 */
 125         { &asn_OER_type_WeirdlyConstrainedREAL_constr_1, 0, WeirdlyConstrainedREAL_constraint },
 126         0, 0,   /* No members */
 127         0       /* No specifics */
 128 };
 129
 130
 131 /*** <<< INCLUDES [Indirect-IEEE-binary32] >>> ***/
 132
 133 #include "UnconstrainedREAL.h"
 134
 135 /*** <<< TYPE-DECLS [Indirect-IEEE-binary32] >>> ***/
 136
 137 typedef UnconstrainedREAL_t      Indirect_IEEE_binary32_t;
 138
 139 /*** <<< FUNC-DECLS [Indirect-IEEE-binary32] >>> ***/
 140
 141 extern asn_TYPE_descriptor_t asn_DEF_Indirect_IEEE_binary32;
 142 extern const asn_NativeReal_specifics_t asn_SPC_Indirect_IEEE_binary32_specs_1;
 143 asn_struct_free_f Indirect_IEEE_binary32_free;
 144 asn_struct_print_f Indirect_IEEE_binary32_print;
 145 asn_constr_check_f Indirect_IEEE_binary32_constraint;
 146 ber_type_decoder_f Indirect_IEEE_binary32_decode_ber;
 147 der_type_encoder_f Indirect_IEEE_binary32_encode_der;
 148 xer_type_decoder_f Indirect_IEEE_binary32_decode_xer;
 149 xer_type_encoder_f Indirect_IEEE_binary32_encode_xer;
 150 oer_type_decoder_f Indirect_IEEE_binary32_decode_oer;
 151 oer_type_encoder_f Indirect_IEEE_binary32_encode_oer;
 152
 153 /*** <<< CODE [Indirect-IEEE-binary32] >>> ***/
 154
 155 int
 156 Indirect_IEEE_binary32_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 157                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 158
 159         if(!sptr) {
 160                 ASN__CTFAIL(app_key, td, sptr,
 161                         "%s: value not given (%s:%d)",
 162                         td->name, __FILE__, __LINE__);
 163                 return -1;
 164         }
 165
 166
 167         if(1 /* No applicable constraints whatsoever */) {
 168                 /* Nothing is here. See below */
 169         }
 170
 171         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 172 }
 173
 174 /*
 175  * This type is implemented using UnconstrainedREAL,
 176  * so here we adjust the DEF accordingly.
 177  */
 178
 179 /*** <<< CTDEFS [Indirect-IEEE-binary32] >>> ***/
 180
 181 static asn_oer_constraints_t asn_OER_type_Indirect_IEEE_binary32_constr_1 CC_NOTUSED = {
 182         { sizeof(float), 0 },
 183         -1};
 184
 185 /*** <<< STAT-DEFS [Indirect-IEEE-binary32] >>> ***/
 186
 187 const asn_NativeReal_specifics_t asn_SPC_Indirect_IEEE_binary32_specs_1 = {
 188         4       /* Use 'float' type. */
 189 };
 190 static const ber_tlv_tag_t asn_DEF_Indirect_IEEE_binary32_tags_1[] = {
 191         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 192 };
 193 asn_TYPE_descriptor_t asn_DEF_Indirect_IEEE_binary32 = {
 194         "Indirect-IEEE-binary32",
 195         "Indirect-IEEE-binary32",
 196         &asn_OP_NativeReal,
 197         asn_DEF_Indirect_IEEE_binary32_tags_1,
 198         sizeof(asn_DEF_Indirect_IEEE_binary32_tags_1)
 199                 /sizeof(asn_DEF_Indirect_IEEE_binary32_tags_1[0]), /* 1 */
 200         asn_DEF_Indirect_IEEE_binary32_tags_1,  /* Same as above */
 201         sizeof(asn_DEF_Indirect_IEEE_binary32_tags_1)
 202                 /sizeof(asn_DEF_Indirect_IEEE_binary32_tags_1[0]), /* 1 */
 203         { &asn_OER_type_Indirect_IEEE_binary32_constr_1, 0, Indirect_IEEE_binary32_constraint },
 204         0, 0,   /* No members */
 205         &asn_SPC_Indirect_IEEE_binary32_specs_1 /* Additional specs */
 206 };
 207
 208
 209 /*** <<< INCLUDES [IEEE-binary32-w] >>> ***/
 210
 211 #include <NativeReal.h>
 212
 213 /*** <<< TYPE-DECLS [IEEE-binary32-w] >>> ***/
 214
 215 typedef float    IEEE_binary32_w_t;
 216
 217 /*** <<< FUNC-DECLS [IEEE-binary32-w] >>> ***/
 218
 219 extern asn_TYPE_descriptor_t asn_DEF_IEEE_binary32_w;
 220 extern const asn_NativeReal_specifics_t asn_SPC_IEEE_binary32_w_specs_1;
 221 asn_struct_free_f IEEE_binary32_w_free;
 222 asn_struct_print_f IEEE_binary32_w_print;
 223 asn_constr_check_f IEEE_binary32_w_constraint;
 224 ber_type_decoder_f IEEE_binary32_w_decode_ber;
 225 der_type_encoder_f IEEE_binary32_w_encode_der;
 226 xer_type_decoder_f IEEE_binary32_w_decode_xer;
 227 xer_type_encoder_f IEEE_binary32_w_encode_xer;
 228 oer_type_decoder_f IEEE_binary32_w_decode_oer;
 229 oer_type_encoder_f IEEE_binary32_w_encode_oer;
 230
 231 /*** <<< CODE [IEEE-binary32-w] >>> ***/
 232
 233 int
 234 IEEE_binary32_w_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 235                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 236
 237         if(!sptr) {
 238                 ASN__CTFAIL(app_key, td, sptr,
 239                         "%s: value not given (%s:%d)",
 240                         td->name, __FILE__, __LINE__);
 241                 return -1;
 242         }
 243
 244
 245         if(1 /* No applicable constraints whatsoever */) {
 246                 /* Nothing is here. See below */
 247         }
 248
 249         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 250 }
 251
 252 /*
 253  * This type is implemented using NativeReal,
 254  * so here we adjust the DEF accordingly.
 255  */
 256
 257 /*** <<< CTDEFS [IEEE-binary32-w] >>> ***/
 258
 259 static asn_oer_constraints_t asn_OER_type_IEEE_binary32_w_constr_1 CC_NOTUSED = {
 260         { sizeof(float), 0 },
 261         -1};
 262
 263 /*** <<< STAT-DEFS [IEEE-binary32-w] >>> ***/
 264
 265 const asn_NativeReal_specifics_t asn_SPC_IEEE_binary32_w_specs_1 = {
 266         4       /* Use 'float' type. */
 267 };
 268 static const ber_tlv_tag_t asn_DEF_IEEE_binary32_w_tags_1[] = {
 269         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 270 };
 271 asn_TYPE_descriptor_t asn_DEF_IEEE_binary32_w = {
 272         "IEEE-binary32-w",
 273         "IEEE-binary32-w",
 274         &asn_OP_NativeReal,
 275         asn_DEF_IEEE_binary32_w_tags_1,
 276         sizeof(asn_DEF_IEEE_binary32_w_tags_1)
 277                 /sizeof(asn_DEF_IEEE_binary32_w_tags_1[0]), /* 1 */
 278         asn_DEF_IEEE_binary32_w_tags_1, /* Same as above */
 279         sizeof(asn_DEF_IEEE_binary32_w_tags_1)
 280                 /sizeof(asn_DEF_IEEE_binary32_w_tags_1[0]), /* 1 */
 281         { &asn_OER_type_IEEE_binary32_w_constr_1, 0, IEEE_binary32_w_constraint },
 282         0, 0,   /* No members */
 283         &asn_SPC_IEEE_binary32_w_specs_1        /* Additional specs */
 284 };
 285
 286
 287 /*** <<< INCLUDES [IEEE-binary32-0w] >>> ***/
 288
 289 #include <NativeReal.h>
 290
 291 /*** <<< TYPE-DECLS [IEEE-binary32-0w] >>> ***/
 292
 293 typedef float    IEEE_binary32_0w_t;
 294
 295 /*** <<< FUNC-DECLS [IEEE-binary32-0w] >>> ***/
 296
 297 extern asn_TYPE_descriptor_t asn_DEF_IEEE_binary32_0w;
 298 extern const asn_NativeReal_specifics_t asn_SPC_IEEE_binary32_0w_specs_1;
 299 asn_struct_free_f IEEE_binary32_0w_free;
 300 asn_struct_print_f IEEE_binary32_0w_print;
 301 asn_constr_check_f IEEE_binary32_0w_constraint;
 302 ber_type_decoder_f IEEE_binary32_0w_decode_ber;
 303 der_type_encoder_f IEEE_binary32_0w_encode_der;
 304 xer_type_decoder_f IEEE_binary32_0w_decode_xer;
 305 xer_type_encoder_f IEEE_binary32_0w_encode_xer;
 306 oer_type_decoder_f IEEE_binary32_0w_decode_oer;
 307 oer_type_encoder_f IEEE_binary32_0w_encode_oer;
 308
 309 /*** <<< CODE [IEEE-binary32-0w] >>> ***/
 310
 311 int
 312 IEEE_binary32_0w_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 313                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 314
 315         if(!sptr) {
 316                 ASN__CTFAIL(app_key, td, sptr,
 317                         "%s: value not given (%s:%d)",
 318                         td->name, __FILE__, __LINE__);
 319                 return -1;
 320         }
 321
 322
 323         if(1 /* No applicable constraints whatsoever */) {
 324                 /* Nothing is here. See below */
 325         }
 326
 327         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 328 }
 329
 330 /*
 331  * This type is implemented using NativeReal,
 332  * so here we adjust the DEF accordingly.
 333  */
 334
 335 /*** <<< CTDEFS [IEEE-binary32-0w] >>> ***/
 336
 337 static asn_oer_constraints_t asn_OER_type_IEEE_binary32_0w_constr_1 CC_NOTUSED = {
 338         { sizeof(float), 0 },
 339         -1};
 340
 341 /*** <<< STAT-DEFS [IEEE-binary32-0w] >>> ***/
 342
 343 const asn_NativeReal_specifics_t asn_SPC_IEEE_binary32_0w_specs_1 = {
 344         4       /* Use 'float' type. */
 345 };
 346 static const ber_tlv_tag_t asn_DEF_IEEE_binary32_0w_tags_1[] = {
 347         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 348 };
 349 asn_TYPE_descriptor_t asn_DEF_IEEE_binary32_0w = {
 350         "IEEE-binary32-0w",
 351         "IEEE-binary32-0w",
 352         &asn_OP_NativeReal,
 353         asn_DEF_IEEE_binary32_0w_tags_1,
 354         sizeof(asn_DEF_IEEE_binary32_0w_tags_1)
 355                 /sizeof(asn_DEF_IEEE_binary32_0w_tags_1[0]), /* 1 */
 356         asn_DEF_IEEE_binary32_0w_tags_1,        /* Same as above */
 357         sizeof(asn_DEF_IEEE_binary32_0w_tags_1)
 358                 /sizeof(asn_DEF_IEEE_binary32_0w_tags_1[0]), /* 1 */
 359         { &asn_OER_type_IEEE_binary32_0w_constr_1, 0, IEEE_binary32_0w_constraint },
 360         0, 0,   /* No members */
 361         &asn_SPC_IEEE_binary32_0w_specs_1       /* Additional specs */
 362 };
 363
 364
 365 /*** <<< INCLUDES [IEEE-binary32-w0] >>> ***/
 366
 367 #include <NativeReal.h>
 368
 369 /*** <<< TYPE-DECLS [IEEE-binary32-w0] >>> ***/
 370
 371 typedef float    IEEE_binary32_w0_t;
 372
 373 /*** <<< FUNC-DECLS [IEEE-binary32-w0] >>> ***/
 374
 375 extern asn_TYPE_descriptor_t asn_DEF_IEEE_binary32_w0;
 376 extern const asn_NativeReal_specifics_t asn_SPC_IEEE_binary32_w0_specs_1;
 377 asn_struct_free_f IEEE_binary32_w0_free;
 378 asn_struct_print_f IEEE_binary32_w0_print;
 379 asn_constr_check_f IEEE_binary32_w0_constraint;
 380 ber_type_decoder_f IEEE_binary32_w0_decode_ber;
 381 der_type_encoder_f IEEE_binary32_w0_encode_der;
 382 xer_type_decoder_f IEEE_binary32_w0_decode_xer;
 383 xer_type_encoder_f IEEE_binary32_w0_encode_xer;
 384 oer_type_decoder_f IEEE_binary32_w0_decode_oer;
 385 oer_type_encoder_f IEEE_binary32_w0_encode_oer;
 386
 387 /*** <<< CODE [IEEE-binary32-w0] >>> ***/
 388
 389 int
 390 IEEE_binary32_w0_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 391                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 392
 393         if(!sptr) {
 394                 ASN__CTFAIL(app_key, td, sptr,
 395                         "%s: value not given (%s:%d)",
 396                         td->name, __FILE__, __LINE__);
 397                 return -1;
 398         }
 399
 400
 401         if(1 /* No applicable constraints whatsoever */) {
 402                 /* Nothing is here. See below */
 403         }
 404
 405         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 406 }
 407
 408 /*
 409  * This type is implemented using NativeReal,
 410  * so here we adjust the DEF accordingly.
 411  */
 412
 413 /*** <<< CTDEFS [IEEE-binary32-w0] >>> ***/
 414
 415 static asn_oer_constraints_t asn_OER_type_IEEE_binary32_w0_constr_1 CC_NOTUSED = {
 416         { sizeof(float), 0 },
 417         -1};
 418
 419 /*** <<< STAT-DEFS [IEEE-binary32-w0] >>> ***/
 420
 421 const asn_NativeReal_specifics_t asn_SPC_IEEE_binary32_w0_specs_1 = {
 422         4       /* Use 'float' type. */
 423 };
 424 static const ber_tlv_tag_t asn_DEF_IEEE_binary32_w0_tags_1[] = {
 425         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 426 };
 427 asn_TYPE_descriptor_t asn_DEF_IEEE_binary32_w0 = {
 428         "IEEE-binary32-w0",
 429         "IEEE-binary32-w0",
 430         &asn_OP_NativeReal,
 431         asn_DEF_IEEE_binary32_w0_tags_1,
 432         sizeof(asn_DEF_IEEE_binary32_w0_tags_1)
 433                 /sizeof(asn_DEF_IEEE_binary32_w0_tags_1[0]), /* 1 */
 434         asn_DEF_IEEE_binary32_w0_tags_1,        /* Same as above */
 435         sizeof(asn_DEF_IEEE_binary32_w0_tags_1)
 436                 /sizeof(asn_DEF_IEEE_binary32_w0_tags_1[0]), /* 1 */
 437         { &asn_OER_type_IEEE_binary32_w0_constr_1, 0, IEEE_binary32_w0_constraint },
 438         0, 0,   /* No members */
 439         &asn_SPC_IEEE_binary32_w0_specs_1       /* Additional specs */
 440 };
 441
 442
 443 /*** <<< INCLUDES [IEEE-binary64-w] >>> ***/
 444
 445 #include <NativeReal.h>
 446
 447 /*** <<< TYPE-DECLS [IEEE-binary64-w] >>> ***/
 448
 449 typedef double   IEEE_binary64_w_t;
 450
 451 /*** <<< FUNC-DECLS [IEEE-binary64-w] >>> ***/
 452
 453 extern asn_TYPE_descriptor_t asn_DEF_IEEE_binary64_w;
 454 asn_struct_free_f IEEE_binary64_w_free;
 455 asn_struct_print_f IEEE_binary64_w_print;
 456 asn_constr_check_f IEEE_binary64_w_constraint;
 457 ber_type_decoder_f IEEE_binary64_w_decode_ber;
 458 der_type_encoder_f IEEE_binary64_w_encode_der;
 459 xer_type_decoder_f IEEE_binary64_w_decode_xer;
 460 xer_type_encoder_f IEEE_binary64_w_encode_xer;
 461 oer_type_decoder_f IEEE_binary64_w_decode_oer;
 462 oer_type_encoder_f IEEE_binary64_w_encode_oer;
 463
 464 /*** <<< CODE [IEEE-binary64-w] >>> ***/
 465
 466 int
 467 IEEE_binary64_w_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 468                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 469
 470         if(!sptr) {
 471                 ASN__CTFAIL(app_key, td, sptr,
 472                         "%s: value not given (%s:%d)",
 473                         td->name, __FILE__, __LINE__);
 474                 return -1;
 475         }
 476
 477
 478         if(1 /* No applicable constraints whatsoever */) {
 479                 /* Nothing is here. See below */
 480         }
 481
 482         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 483 }
 484
 485 /*
 486  * This type is implemented using NativeReal,
 487  * so here we adjust the DEF accordingly.
 488  */
 489
 490 /*** <<< CTDEFS [IEEE-binary64-w] >>> ***/
 491
 492 static asn_oer_constraints_t asn_OER_type_IEEE_binary64_w_constr_1 CC_NOTUSED = {
 493         { sizeof(double), 0 },
 494         -1};
 495
 496 /*** <<< STAT-DEFS [IEEE-binary64-w] >>> ***/
 497
 498 static const ber_tlv_tag_t asn_DEF_IEEE_binary64_w_tags_1[] = {
 499         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 500 };
 501 asn_TYPE_descriptor_t asn_DEF_IEEE_binary64_w = {
 502         "IEEE-binary64-w",
 503         "IEEE-binary64-w",
 504         &asn_OP_NativeReal,
 505         asn_DEF_IEEE_binary64_w_tags_1,
 506         sizeof(asn_DEF_IEEE_binary64_w_tags_1)
 507                 /sizeof(asn_DEF_IEEE_binary64_w_tags_1[0]), /* 1 */
 508         asn_DEF_IEEE_binary64_w_tags_1, /* Same as above */
 509         sizeof(asn_DEF_IEEE_binary64_w_tags_1)
 510                 /sizeof(asn_DEF_IEEE_binary64_w_tags_1[0]), /* 1 */
 511         { &asn_OER_type_IEEE_binary64_w_constr_1, 0, IEEE_binary64_w_constraint },
 512         0, 0,   /* No members */
 513         0       /* No specifics */
 514 };
 515
 516
 517 /*** <<< INCLUDES [IEEE-binary64-0w] >>> ***/
 518
 519 #include <NativeReal.h>
 520
 521 /*** <<< TYPE-DECLS [IEEE-binary64-0w] >>> ***/
 522
 523 typedef double   IEEE_binary64_0w_t;
 524
 525 /*** <<< FUNC-DECLS [IEEE-binary64-0w] >>> ***/
 526
 527 extern asn_TYPE_descriptor_t asn_DEF_IEEE_binary64_0w;
 528 asn_struct_free_f IEEE_binary64_0w_free;
 529 asn_struct_print_f IEEE_binary64_0w_print;
 530 asn_constr_check_f IEEE_binary64_0w_constraint;
 531 ber_type_decoder_f IEEE_binary64_0w_decode_ber;
 532 der_type_encoder_f IEEE_binary64_0w_encode_der;
 533 xer_type_decoder_f IEEE_binary64_0w_decode_xer;
 534 xer_type_encoder_f IEEE_binary64_0w_encode_xer;
 535 oer_type_decoder_f IEEE_binary64_0w_decode_oer;
 536 oer_type_encoder_f IEEE_binary64_0w_encode_oer;
 537
 538 /*** <<< CODE [IEEE-binary64-0w] >>> ***/
 539
 540 int
 541 IEEE_binary64_0w_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 542                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 543
 544         if(!sptr) {
 545                 ASN__CTFAIL(app_key, td, sptr,
 546                         "%s: value not given (%s:%d)",
 547                         td->name, __FILE__, __LINE__);
 548                 return -1;
 549         }
 550
 551
 552         if(1 /* No applicable constraints whatsoever */) {
 553                 /* Nothing is here. See below */
 554         }
 555
 556         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 557 }
 558
 559 /*
 560  * This type is implemented using NativeReal,
 561  * so here we adjust the DEF accordingly.
 562  */
 563
 564 /*** <<< CTDEFS [IEEE-binary64-0w] >>> ***/
 565
 566 static asn_oer_constraints_t asn_OER_type_IEEE_binary64_0w_constr_1 CC_NOTUSED = {
 567         { sizeof(double), 0 },
 568         -1};
 569
 570 /*** <<< STAT-DEFS [IEEE-binary64-0w] >>> ***/
 571
 572 static const ber_tlv_tag_t asn_DEF_IEEE_binary64_0w_tags_1[] = {
 573         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 574 };
 575 asn_TYPE_descriptor_t asn_DEF_IEEE_binary64_0w = {
 576         "IEEE-binary64-0w",
 577         "IEEE-binary64-0w",
 578         &asn_OP_NativeReal,
 579         asn_DEF_IEEE_binary64_0w_tags_1,
 580         sizeof(asn_DEF_IEEE_binary64_0w_tags_1)
 581                 /sizeof(asn_DEF_IEEE_binary64_0w_tags_1[0]), /* 1 */
 582         asn_DEF_IEEE_binary64_0w_tags_1,        /* Same as above */
 583         sizeof(asn_DEF_IEEE_binary64_0w_tags_1)
 584                 /sizeof(asn_DEF_IEEE_binary64_0w_tags_1[0]), /* 1 */
 585         { &asn_OER_type_IEEE_binary64_0w_constr_1, 0, IEEE_binary64_0w_constraint },
 586         0, 0,   /* No members */
 587         0       /* No specifics */
 588 };
 589
 590
 591 /*** <<< INCLUDES [IEEE-binary64-w0] >>> ***/
 592
 593 #include <NativeReal.h>
 594
 595 /*** <<< TYPE-DECLS [IEEE-binary64-w0] >>> ***/
 596
 597 typedef double   IEEE_binary64_w0_t;
 598
 599 /*** <<< FUNC-DECLS [IEEE-binary64-w0] >>> ***/
 600
 601 extern asn_TYPE_descriptor_t asn_DEF_IEEE_binary64_w0;
 602 asn_struct_free_f IEEE_binary64_w0_free;
 603 asn_struct_print_f IEEE_binary64_w0_print;
 604 asn_constr_check_f IEEE_binary64_w0_constraint;
 605 ber_type_decoder_f IEEE_binary64_w0_decode_ber;
 606 der_type_encoder_f IEEE_binary64_w0_encode_der;
 607 xer_type_decoder_f IEEE_binary64_w0_decode_xer;
 608 xer_type_encoder_f IEEE_binary64_w0_encode_xer;
 609 oer_type_decoder_f IEEE_binary64_w0_decode_oer;
 610 oer_type_encoder_f IEEE_binary64_w0_encode_oer;
 611
 612 /*** <<< CODE [IEEE-binary64-w0] >>> ***/
 613
 614 int
 615 IEEE_binary64_w0_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 616                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 617
 618         if(!sptr) {
 619                 ASN__CTFAIL(app_key, td, sptr,
 620                         "%s: value not given (%s:%d)",
 621                         td->name, __FILE__, __LINE__);
 622                 return -1;
 623         }
 624
 625
 626         if(1 /* No applicable constraints whatsoever */) {
 627                 /* Nothing is here. See below */
 628         }
 629
 630         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 631 }
 632
 633 /*
 634  * This type is implemented using NativeReal,
 635  * so here we adjust the DEF accordingly.
 636  */
 637
 638 /*** <<< CTDEFS [IEEE-binary64-w0] >>> ***/
 639
 640 static asn_oer_constraints_t asn_OER_type_IEEE_binary64_w0_constr_1 CC_NOTUSED = {
 641         { sizeof(double), 0 },
 642         -1};
 643
 644 /*** <<< STAT-DEFS [IEEE-binary64-w0] >>> ***/
 645
 646 static const ber_tlv_tag_t asn_DEF_IEEE_binary64_w0_tags_1[] = {
 647         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 648 };
 649 asn_TYPE_descriptor_t asn_DEF_IEEE_binary64_w0 = {
 650         "IEEE-binary64-w0",
 651         "IEEE-binary64-w0",
 652         &asn_OP_NativeReal,
 653         asn_DEF_IEEE_binary64_w0_tags_1,
 654         sizeof(asn_DEF_IEEE_binary64_w0_tags_1)
 655                 /sizeof(asn_DEF_IEEE_binary64_w0_tags_1[0]), /* 1 */
 656         asn_DEF_IEEE_binary64_w0_tags_1,        /* Same as above */
 657         sizeof(asn_DEF_IEEE_binary64_w0_tags_1)
 658                 /sizeof(asn_DEF_IEEE_binary64_w0_tags_1[0]), /* 1 */
 659         { &asn_OER_type_IEEE_binary64_w0_constr_1, 0, IEEE_binary64_w0_constraint },
 660         0, 0,   /* No members */
 661         0       /* No specifics */
 662 };
 663
 664
 665 /*** <<< INCLUDES [Test] >>> ***/
 666
 667 #include "Indirect-IEEE-binary32.h"
 668 #include "IEEE-binary32-w.h"
 669 #include "IEEE-binary32-0w.h"
 670 #include "IEEE-binary32-w0.h"
 671 #include "IEEE-binary64-w.h"
 672 #include "IEEE-binary64-0w.h"
 673 #include "IEEE-binary64-w0.h"
 674 #include <constr_SEQUENCE.h>
 675
 676 /*** <<< TYPE-DECLS [Test] >>> ***/
 677
 678 typedef struct Test {
 679         Indirect_IEEE_binary32_t         indirect_ieee_binary32;
 680         IEEE_binary32_w_t        ieee_binary32_w;
 681         IEEE_binary32_0w_t       ieee_binary32_0w;
 682         IEEE_binary32_w0_t       ieee_binary32_w0;
 683         IEEE_binary64_w_t        ieee_binary64_w;
 684         IEEE_binary64_0w_t       ieee_binary64_0w;
 685         IEEE_binary64_w0_t       ieee_binary64_w0;
 686
 687         /* Context for parsing across buffer boundaries */
 688         asn_struct_ctx_t _asn_ctx;
 689 } Test_t;
 690
 691 /*** <<< FUNC-DECLS [Test] >>> ***/
 692
 693 /* extern asn_TYPE_descriptor_t asn_DEF_indirect_ieee_binary32_2;       // (Use -fall-defs-global to expose) */
 694 /* extern asn_TYPE_descriptor_t asn_DEF_ieee_binary32_w_3;      // (Use -fall-defs-global to expose) */
 695 /* extern asn_TYPE_descriptor_t asn_DEF_ieee_binary32_0w_4;     // (Use -fall-defs-global to expose) */
 696 /* extern asn_TYPE_descriptor_t asn_DEF_ieee_binary32_w0_5;     // (Use -fall-defs-global to expose) */
 697 extern asn_TYPE_descriptor_t asn_DEF_Test;
 698
 699 /*** <<< CODE [Test] >>> ***/
 700
 701 static int
 702 indirect_ieee_binary32_2_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 703                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 704
 705         if(!sptr) {
 706                 ASN__CTFAIL(app_key, td, sptr,
 707                         "%s: value not given (%s:%d)",
 708                         td->name, __FILE__, __LINE__);
 709                 return -1;
 710         }
 711
 712
 713         if(1 /* No applicable constraints whatsoever */) {
 714                 /* Nothing is here. See below */
 715         }
 716
 717         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 718 }
 719
 720 /*
 721  * This type is implemented using Indirect_IEEE_binary32,
 722  * so here we adjust the DEF accordingly.
 723  */
 724 static int
 725 ieee_binary32_w_3_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 726                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 727
 728         if(!sptr) {
 729                 ASN__CTFAIL(app_key, td, sptr,
 730                         "%s: value not given (%s:%d)",
 731                         td->name, __FILE__, __LINE__);
 732                 return -1;
 733         }
 734
 735
 736         if(1 /* No applicable constraints whatsoever */) {
 737                 /* Nothing is here. See below */
 738         }
 739
 740         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 741 }
 742
 743 /*
 744  * This type is implemented using IEEE_binary32_w,
 745  * so here we adjust the DEF accordingly.
 746  */
 747 static int
 748 ieee_binary32_0w_4_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 749                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 750
 751         if(!sptr) {
 752                 ASN__CTFAIL(app_key, td, sptr,
 753                         "%s: value not given (%s:%d)",
 754                         td->name, __FILE__, __LINE__);
 755                 return -1;
 756         }
 757
 758
 759         if(1 /* No applicable constraints whatsoever */) {
 760                 /* Nothing is here. See below */
 761         }
 762
 763         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 764 }
 765
 766 /*
 767  * This type is implemented using IEEE_binary32_0w,
 768  * so here we adjust the DEF accordingly.
 769  */
 770 static int
 771 ieee_binary32_w0_5_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 772                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 773
 774         if(!sptr) {
 775                 ASN__CTFAIL(app_key, td, sptr,
 776                         "%s: value not given (%s:%d)",
 777                         td->name, __FILE__, __LINE__);
 778                 return -1;
 779         }
 780
 781
 782         if(1 /* No applicable constraints whatsoever */) {
 783                 /* Nothing is here. See below */
 784         }
 785
 786         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 787 }
 788
 789 /*
 790  * This type is implemented using IEEE_binary32_w0,
 791  * so here we adjust the DEF accordingly.
 792  */
 793
 794 /*** <<< CTDEFS [Test] >>> ***/
 795
 796 static asn_oer_constraints_t asn_OER_type_indirect_ieee_binary32_constr_2 CC_NOTUSED = {
 797         { sizeof(float), 0 },
 798         -1};
 799 static asn_oer_constraints_t asn_OER_type_ieee_binary32_w_constr_3 CC_NOTUSED = {
 800         { sizeof(float), 0 },
 801         -1};
 802 static asn_oer_constraints_t asn_OER_type_ieee_binary32_0w_constr_4 CC_NOTUSED = {
 803         { sizeof(float), 0 },
 804         -1};
 805 static asn_oer_constraints_t asn_OER_type_ieee_binary32_w0_constr_5 CC_NOTUSED = {
 806         { sizeof(float), 0 },
 807         -1};
 808
 809 /*** <<< STAT-DEFS [Test] >>> ***/
 810
 811 static const asn_NativeReal_specifics_t asn_SPC_indirect_ieee_binary32_specs_2 = {
 812         4       /* Use 'float' type. */
 813 };
 814 static const ber_tlv_tag_t asn_DEF_indirect_ieee_binary32_tags_2[] = {
 815         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 816 };
 817 static /* Use -fall-defs-global to expose */
 818 asn_TYPE_descriptor_t asn_DEF_indirect_ieee_binary32_2 = {
 819         "indirect-ieee-binary32",
 820         "indirect-ieee-binary32",
 821         &asn_OP_NativeReal,
 822         asn_DEF_indirect_ieee_binary32_tags_2,
 823         sizeof(asn_DEF_indirect_ieee_binary32_tags_2)
 824                 /sizeof(asn_DEF_indirect_ieee_binary32_tags_2[0]), /* 1 */
 825         asn_DEF_indirect_ieee_binary32_tags_2,  /* Same as above */
 826         sizeof(asn_DEF_indirect_ieee_binary32_tags_2)
 827                 /sizeof(asn_DEF_indirect_ieee_binary32_tags_2[0]), /* 1 */
 828         { &asn_OER_type_indirect_ieee_binary32_constr_2, 0, indirect_ieee_binary32_2_constraint },
 829         0, 0,   /* No members */
 830         &asn_SPC_indirect_ieee_binary32_specs_2 /* Additional specs */
 831 };
 832
 833 static const asn_NativeReal_specifics_t asn_SPC_ieee_binary32_w_specs_3 = {
 834         4       /* Use 'float' type. */
 835 };
 836 static const ber_tlv_tag_t asn_DEF_ieee_binary32_w_tags_3[] = {
 837         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 838 };
 839 static /* Use -fall-defs-global to expose */
 840 asn_TYPE_descriptor_t asn_DEF_ieee_binary32_w_3 = {
 841         "ieee-binary32-w",
 842         "ieee-binary32-w",
 843         &asn_OP_NativeReal,
 844         asn_DEF_ieee_binary32_w_tags_3,
 845         sizeof(asn_DEF_ieee_binary32_w_tags_3)
 846                 /sizeof(asn_DEF_ieee_binary32_w_tags_3[0]), /* 1 */
 847         asn_DEF_ieee_binary32_w_tags_3, /* Same as above */
 848         sizeof(asn_DEF_ieee_binary32_w_tags_3)
 849                 /sizeof(asn_DEF_ieee_binary32_w_tags_3[0]), /* 1 */
 850         { &asn_OER_type_ieee_binary32_w_constr_3, 0, ieee_binary32_w_3_constraint },
 851         0, 0,   /* No members */
 852         &asn_SPC_ieee_binary32_w_specs_3        /* Additional specs */
 853 };
 854
 855 static const asn_NativeReal_specifics_t asn_SPC_ieee_binary32_0w_specs_4 = {
 856         4       /* Use 'float' type. */
 857 };
 858 static const ber_tlv_tag_t asn_DEF_ieee_binary32_0w_tags_4[] = {
 859         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 860 };
 861 static /* Use -fall-defs-global to expose */
 862 asn_TYPE_descriptor_t asn_DEF_ieee_binary32_0w_4 = {
 863         "ieee-binary32-0w",
 864         "ieee-binary32-0w",
 865         &asn_OP_NativeReal,
 866         asn_DEF_ieee_binary32_0w_tags_4,
 867         sizeof(asn_DEF_ieee_binary32_0w_tags_4)
 868                 /sizeof(asn_DEF_ieee_binary32_0w_tags_4[0]), /* 1 */
 869         asn_DEF_ieee_binary32_0w_tags_4,        /* Same as above */
 870         sizeof(asn_DEF_ieee_binary32_0w_tags_4)
 871                 /sizeof(asn_DEF_ieee_binary32_0w_tags_4[0]), /* 1 */
 872         { &asn_OER_type_ieee_binary32_0w_constr_4, 0, ieee_binary32_0w_4_constraint },
 873         0, 0,   /* No members */
 874         &asn_SPC_ieee_binary32_0w_specs_4       /* Additional specs */
 875 };
 876
 877 static const asn_NativeReal_specifics_t asn_SPC_ieee_binary32_w0_specs_5 = {
 878         4       /* Use 'float' type. */
 879 };
 880 static const ber_tlv_tag_t asn_DEF_ieee_binary32_w0_tags_5[] = {
 881         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 882 };
 883 static /* Use -fall-defs-global to expose */
 884 asn_TYPE_descriptor_t asn_DEF_ieee_binary32_w0_5 = {
 885         "ieee-binary32-w0",
 886         "ieee-binary32-w0",
 887         &asn_OP_NativeReal,
 888         asn_DEF_ieee_binary32_w0_tags_5,
 889         sizeof(asn_DEF_ieee_binary32_w0_tags_5)
 890                 /sizeof(asn_DEF_ieee_binary32_w0_tags_5[0]), /* 1 */
 891         asn_DEF_ieee_binary32_w0_tags_5,        /* Same as above */
 892         sizeof(asn_DEF_ieee_binary32_w0_tags_5)
 893                 /sizeof(asn_DEF_ieee_binary32_w0_tags_5[0]), /* 1 */
 894         { &asn_OER_type_ieee_binary32_w0_constr_5, 0, ieee_binary32_w0_5_constraint },
 895         0, 0,   /* No members */
 896         &asn_SPC_ieee_binary32_w0_specs_5       /* Additional specs */
 897 };
 898
 899 static asn_TYPE_member_t asn_MBR_Test_1[] = {
 900         { ATF_NOFLAGS, 0, offsetof(struct Test, indirect_ieee_binary32),
 901                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
 902                 .tag_mode = 0,
 903                 .type = &asn_DEF_Indirect_IEEE_binary32,
 904                 .type_selector = 0,
 905                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 906                 0, 0, /* No default value */
 907                 .name = "indirect-ieee-binary32"
 908                 },
 909         { ATF_NOFLAGS, 0, offsetof(struct Test, ieee_binary32_w),
 910                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
 911                 .tag_mode = 0,
 912                 .type = &asn_DEF_IEEE_binary32_w,
 913                 .type_selector = 0,
 914                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 915                 0, 0, /* No default value */
 916                 .name = "ieee-binary32-w"
 917                 },
 918         { ATF_NOFLAGS, 0, offsetof(struct Test, ieee_binary32_0w),
 919                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
 920                 .tag_mode = 0,
 921                 .type = &asn_DEF_IEEE_binary32_0w,
 922                 .type_selector = 0,
 923                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 924                 0, 0, /* No default value */
 925                 .name = "ieee-binary32-0w"
 926                 },
 927         { ATF_NOFLAGS, 0, offsetof(struct Test, ieee_binary32_w0),
 928                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
 929                 .tag_mode = 0,
 930                 .type = &asn_DEF_IEEE_binary32_w0,
 931                 .type_selector = 0,
 932                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 933                 0, 0, /* No default value */
 934                 .name = "ieee-binary32-w0"
 935                 },
 936         { ATF_NOFLAGS, 0, offsetof(struct Test, ieee_binary64_w),
 937                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
 938                 .tag_mode = 0,
 939                 .type = &asn_DEF_IEEE_binary64_w,
 940                 .type_selector = 0,
 941                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 942                 0, 0, /* No default value */
 943                 .name = "ieee-binary64-w"
 944                 },
 945         { ATF_NOFLAGS, 0, offsetof(struct Test, ieee_binary64_0w),
 946                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
 947                 .tag_mode = 0,
 948                 .type = &asn_DEF_IEEE_binary64_0w,
 949                 .type_selector = 0,
 950                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 951                 0, 0, /* No default value */
 952                 .name = "ieee-binary64-0w"
 953                 },
 954         { ATF_NOFLAGS, 0, offsetof(struct Test, ieee_binary64_w0),
 955                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
 956                 .tag_mode = 0,
 957                 .type = &asn_DEF_IEEE_binary64_w0,
 958                 .type_selector = 0,
 959                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 960                 0, 0, /* No default value */
 961                 .name = "ieee-binary64-w0"
 962                 },
 963 };
 964 static const ber_tlv_tag_t asn_DEF_Test_tags_1[] = {
 965         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 966 };
 967 static const asn_TYPE_tag2member_t asn_MAP_Test_tag2el_1[] = {
 968     { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 0, 0, 6 }, /* indirect-ieee-binary32 */
 969     { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 1, -1, 5 }, /* ieee-binary32-w */
 970     { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 2, -2, 4 }, /* ieee-binary32-0w */
 971     { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 3, -3, 3 }, /* ieee-binary32-w0 */
 972     { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 4, -4, 2 }, /* ieee-binary64-w */
 973     { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 5, -5, 1 }, /* ieee-binary64-0w */
 974     { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 6, -6, 0 } /* ieee-binary64-w0 */
 975 };
 976 static asn_SEQUENCE_specifics_t asn_SPC_Test_specs_1 = {
 977         sizeof(struct Test),
 978         offsetof(struct Test, _asn_ctx),
 979         .tag2el = asn_MAP_Test_tag2el_1,
 980         .tag2el_count = 7,      /* Count of tags in the map */
 981         0, 0, 0,        /* Optional elements (not needed) */
 982         -1,     /* First extension addition */
 983 };
 984 asn_TYPE_descriptor_t asn_DEF_Test = {
 985         "Test",
 986         "Test",
 987         &asn_OP_SEQUENCE,
 988         asn_DEF_Test_tags_1,
 989         sizeof(asn_DEF_Test_tags_1)
 990                 /sizeof(asn_DEF_Test_tags_1[0]), /* 1 */
 991         asn_DEF_Test_tags_1,    /* Same as above */
 992         sizeof(asn_DEF_Test_tags_1)
 993                 /sizeof(asn_DEF_Test_tags_1[0]), /* 1 */
 994         { 0, 0, SEQUENCE_constraint },
 995         asn_MBR_Test_1,
 996         7,      /* Elements count */
 997         &asn_SPC_Test_specs_1   /* Additional specs */
 998 };
 999