Created with colorer-take5 library. Type 'asn1'

--
-- @(#) IvmaiAsn-ECN-CLASS.asn - ECN built-in core definitions.
-- (c) 2002 Ivan Maidanski <ivmai@mail.ru>
-- Free specification (GNU GPL). No warranties. All rights reserved.
-- -
-- Project: IvmaiAsn ASN1/ECN/XDR Tools
-- Language: ASN.1:2002
-- Tested with: OSS ASN.1 and ECN Syntax Checker Version 8.2
-- --

--
-- This ASN.1 module defines the primary (core) encoding classes of
-- ECN:2002 (Encoding Control Notation) with their "defined syntax"
-- precisely as specified by ITU-T X.692 document (but expressed in
-- a valid ASN.1:2002 language).
-- This file could be a user formal reference on the syntax of ECN
-- encoding classes.
-- This file could be used as an integral part of an ECN compiler.
-- --

--
-- Normative references:
-- - ITU-T Recommendation X.680 (2002) | ISO/IEC 8824-1:2002,
-- Information technology - Abstract Syntax Notation One (ASN.1):
-- Specification of basic notation.
-- - ITU-T Recommendation X.681 (2002) | ISO/IEC 8824-2:2002,
-- Information technology - Abstract Syntax Notation One (ASN.1):
-- Information object specification.
-- - ITU-T Recommendation X.683 (2002) | ISO/IEC 8824-4:2002,
-- Information technology - Abstract Syntax Notation One (ASN.1):
-- Parameterization of ASN.1 specifications.
-- - ITU-T Draft Recommendation X.692 (2002) | ISO/IEC 8825-3:2002,
-- Information technology - ASN.1 encoding rules: Specification
-- of Encoding Control Notation (ECN).
-- --

IvmaiAsn-ECN-CLASS
 --< ASN1.Version 1994 IvmaiAsn-ECN-CLASS >--
DEFINITIONS AUTOMATIC TAGS EXTENSIBILITY IMPLIED ::= BEGIN

--
-- Note 1: A trailing '0' char for names (if present) shall be
-- ignored.
-- Note 2: 'OPTIONS' literal after an optional group starting with
-- a literal shall be ignored.
-- Note 3: A optional field of type OPTIONS shall be ignored in the
-- defined syntax.
-- Note 4: '&index' component of ORDERED {} class shall be hidden in
-- the defined syntax.
-- --

EXPORTS
        ALTERNATIVES0,
        BITS0,
        BOOL0,
        CHARS0,
        CONCATENATION0,
        CONDITIONAL-INT0,
        CONDITIONAL-REPETITION0,
        INT0,
        NUL0,
        OBJECT-IDENTIFIER0,
        OCTETS0,
        OPEN-TYPE0,
        OPTIONAL0,
        OUTER0,
        PAD0,
        REAL0,
        REPETITION0,
        TAG0,
        TRANSFORM0;

IMPORTS;

UnsignedInteger ::= INTEGER (0 .. MAX)

PositiveInteger ::= UnsignedInteger (1 .. MAX)

TwoOrMoreInteger ::= UnsignedInteger (2 .. MAX)

OPTIONS ::= NULL -- Type for a hidden value field --

ENCODINGS ::= NULL -- Type for a set of any encoding classes --

REFERENCE ::= UnsignedInteger -- Type for a component index --

ORDERED { TYPE-OR-CLASS } ::= CLASS {
        &index UnsignedInteger UNIQUE,
        &valobj TYPE-OR-CLASS }
 WITH SYNTAX {
        &index
        &valobj }

HandlePosition ::= UnsignedInteger

HandleName ::= PrintableString (SIZE (1 .. MAX))

UniversalStrChar ::= UniversalString (SIZE (1))

UniversalStrChar-ORDERED ::= ORDERED { UniversalStrChar }

BIT-STRING-ORDERED ::= ORDERED { BIT STRING }

Unit ::= INTEGER {
        repetitions(0),
        bit(1),
        nibble(4),
        octet(8),
        word16(16),
        dword32(32) } (0 .. 256)

FixedUnit ::= Unit (ALL EXCEPT repetitions)

EncodingSpaceSize ::= INTEGER {
        encoder-option-with-determinant(-3),
        variable-with-determinant(-2),
        self-delimiting-values(-1),
        fixed-to-max(0) } (-3 .. MAX)

ResultSize ::= INTEGER {
        variable(-1),
        fixed-to-max(0) } (-1 .. MAX)

Determinator ::= ENUMERATED {
        field-to-be-set,
        field-to-be-used,
        container,
        handle,
        pointer,
        pattern,
        flag-to-be-set,
        flag-to-be-used,
        not-needed }

RepetitionSpaceDetermination ::= Determinator (ALL EXCEPT pointer)

UnusedBitsDetermination ::= RepetitionSpaceDetermination (ALL EXCEPT
 (container | handle | pattern | flag-to-be-set | flag-to-be-used))

OptionalityDetermination ::= Determinator (ALL EXCEPT
 (pattern | flag-to-be-set | flag-to-be-used | not-needed))

EncodingSpaceDetermination ::= OptionalityDetermination (ALL EXCEPT
 (handle | pointer))

AlternativeDetermination ::= OptionalityDetermination (ALL EXCEPT
 (container | pointer))

Padding ::= ENUMERATED {
        zero,
        one,
        pattern,
        encoder-option }

RangeCondition ::= ENUMERATED {
        unbounded-or-no-lower-bound,
        semi-bounded-with-negatives,
        bounded-with-negatives,
        semi-bounded-without-negatives,
        bounded-without-negatives }

SizeRangeCondition ::= ENUMERATED {
        no-ub-with-zero-lb,
        ub-with-zero-lb,
        no-ub-with-non-zero-lb,
        ub-with-non-zero-lb,
        fixed-size }

ReversalSpecification ::= ENUMERATED {
        no-reversal,
        reverse-bits-in-units,
        reverse-half-units,
        reverse-bits-in-half-units }

BoolToInt ::= ENUMERATED {
        true-zero,
        true-one }

IntToBool ::= ENUMERATED {
        zero-true,
        zero-false }

IntToCharsPad ::= ENUMERATED {
        spaces,
        zeros }

IntValueEncoding ::= ENUMERATED {
        positive-int,
        twos-complement,
        reverse-positive-int,
        reverse-twos-complement }

IntToBitsEncoded ::= IntValueEncoding (ALL EXCEPT
 (reverse-positive-int | reverse-twos-complement))

CharToBitsEncoded ::= ENUMERATED {
        iso10646,
        compact,
        mapped }

BitsToCharDecoded ::= CharToBitsEncoded (ALL EXCEPT compact)

RepeatConcatAlignment ::= ENUMERATED {
        none,
        aligned }

AlignmentPoint ::= ENUMERATED {
        unchanged,
        reset }

ConcatenationOrdering ::= ENUMERATED {
        textual,
        tag,
        random }

AlternativeOrdering ::= ConcatenationOrdering (ALL EXCEPT random)

AddedBits ::= ENUMERATED {
        hard-error,
        signal-application,
        silently-ignore,
        next-value }

ENUMERATED-any ::= ENUMERATED {
        any }

ENUMERATED-value ::= ENUMERATED {
        value }

ENUMERATED-lower-bound ::= ENUMERATED {
        lower-bound }

ENUMERATED-not ::= ENUMERATED {
        not }

Justification ::= CHOICE {
        left UnsignedInteger,
        right UnsignedInteger }

Pattern ::= CHOICE {
        bits BIT STRING,
        octets OCTET STRING,
        char8 IA5String,
        char16 BMPString,
        char32 UniversalString,
        any-of-length PositiveInteger,
        different ENUMERATED-any }

FixedPattern ::= Pattern (ALL EXCEPT different: any)

Non-Null-Pattern ::= Pattern (ALL EXCEPT
 (bits: ''B | octets: ''H | char8: "" | char16: "" | char32: ""))

FixedNonNullPattern ::= Non-Null-Pattern (ALL EXCEPT different: any)

HandleValue ::= CHOICE {
        bits BIT STRING,
        octets OCTET STRING,
        number UnsignedInteger,
        tag ENUMERATED-any }

IntToInt ::= CHOICE {
        increment PositiveInteger,
        decrement PositiveInteger,
        multiply TwoOrMoreInteger,
        divide TwoOrMoreInteger,
        negate ENUMERATED-value,
        modulo TwoOrMoreInteger,
        subtract ENUMERATED-lower-bound }

BoolToBool ::= CHOICE {
        logical ENUMERATED-not }

TRANSFORM0 ::= CLASS {
 -- int-to-int
        &int-to-int IntToInt OPTIONAL,
 -- bool-to-bool
        &bool-to-bool-X OPTIONS OPTIONAL,
        &bool-to-bool BoolToBool DEFAULT logical: not,
 -- bool-to-int
        &bool-to-int-X OPTIONS OPTIONAL,
        &bool-to-int BoolToInt DEFAULT true-one,
 -- int-to-bool
        &int-to-bool-X OPTIONS OPTIONAL,
        &int-to-bool IntToBool DEFAULT zero-false,
        &Int-to-bool-true-is INTEGER OPTIONAL,
        &Int-to-bool-false-is INTEGER OPTIONAL,
 -- int-to-chars
        &int-to-chars-X OPTIONS OPTIONAL,
        &int-to-chars-size ResultSize DEFAULT variable,
        &int-to-chars-plus BOOLEAN DEFAULT FALSE,
        &int-to-chars-pad IntToCharsPad DEFAULT zeros,
 -- int-to-bits
        &int-to-bits-X OPTIONS OPTIONAL,
        &int-to-bits-encoded-as IntToBitsEncoded
         DEFAULT twos-complement,
        &int-to-bits-unit FixedUnit DEFAULT bit,
        &int-to-bits-size ResultSize DEFAULT variable,
 -- bits-to-int
        &bits-to-int-X OPTIONS OPTIONAL,
        &bits-to-int-decoded-assuming IntToBitsEncoded
         DEFAULT twos-complement,
 -- char-to-bits
        &char-to-bits-X OPTIONS OPTIONAL,
        &char-to-bits-encoded-as CharToBitsEncoded DEFAULT compact,
        &Char-to-bits-chars UniversalStrChar-ORDERED OPTIONAL,
        &Char-to-bits-values BIT-STRING-ORDERED OPTIONAL,
        &char-to-bits-unit FixedUnit DEFAULT bit,
        &char-to-bits-size ResultSize DEFAULT variable,
 -- bits-to-char
        &bits-to-char-X OPTIONS OPTIONAL,
        &bits-to-char-decoded-assuming BitsToCharDecoded
         DEFAULT iso10646,
        &Bits-to-char-values BIT-STRING-ORDERED OPTIONAL,
        &Bits-to-char-chars UniversalStrChar-ORDERED OPTIONAL,
 -- bit-to-bits
        &bit-to-bits-X OPTIONS OPTIONAL,
        &bit-to-bits-one Non-Null-Pattern DEFAULT bits: '1'B,
        &bit-to-bits-zero Non-Null-Pattern DEFAULT bits: '0'B,
 -- bits-to-bits
        &Source-values BIT-STRING-ORDERED OPTIONAL,
        &Result-values BIT-STRING-ORDERED OPTIONAL,
 -- chars-to-composite-char
        &chars-to-composite-char-X OPTIONS OPTIONAL,
 -- bits-to-composite-bits
        &bits-to-composite-bits-X OPTIONS OPTIONAL,
        &bits-to-composite-bits-unit FixedUnit DEFAULT bit,
 -- octets-to-composite-bits
        &octets-to-composite-bits-X OPTIONS OPTIONAL,
 -- composite-char-to-chars
        &composite-char-to-chars-X OPTIONS OPTIONAL,
 -- composite-bits-to-bits
        &composite-bits-to-bits-X OPTIONS OPTIONAL,
 -- composite-bits-to-octets
        &composite-bits-to-octets-X OPTIONS OPTIONAL }
 WITH SYNTAX {
 -- Only one of the following clauses can be used --
        [ INT-TO-INT &int-to-int ]
        [ BOOL-TO-BOOL &bool-to-bool-X
                [ AS &bool-to-bool ] ]
        [ BOOL-TO-INT &bool-to-int-X
                [ AS &bool-to-int ] ]
        [ INT-TO-BOOL &int-to-bool-X
                [ AS &int-to-bool ]
                [ TRUE-IS &Int-to-bool-true-is ]
                [ FALSE-IS &Int-to-bool-false-is ] ]
        [ INT-TO-CHARS &int-to-chars-X
                [ SIZE &int-to-chars-size ]
                [ PLUS-SIGN &int-to-chars-plus ]
                [ PADDING &int-to-chars-pad ] ]
        [ INT-TO-BITS &int-to-bits-X
                [ AS &int-to-bits-encoded-as ]
                [ SIZE &int-to-bits-size ]
                [ MULTIPLE OF &int-to-bits-unit ] ]
        [ BITS-TO-INT &bits-to-int-X
                [ AS &bits-to-int-decoded-assuming ] ]
        [ CHAR-TO-BITS &char-to-bits-X
                [ AS &char-to-bits-encoded-as ]
                [ CHAR-LIST &Char-to-bits-chars ]
                [ BITS-LIST &Char-to-bits-values ]
                [ SIZE &char-to-bits-size ]
                [ MULTIPLE OF &char-to-bits-unit ] ]
        [ BITS-TO-CHAR &bits-to-char-X
                [ AS &bits-to-char-decoded-assuming ]
                [ BITS-LIST &Bits-to-char-values ]
                [ CHAR-LIST &Bits-to-char-chars ] ]
        [ BIT-TO-BITS &bit-to-bits-X
                [ ZERO-PATTERN &bit-to-bits-zero ]
                [ ONE-PATTERN &bit-to-bits-one ] ]
        [ BITS-TO-BITS SOURCE-LIST &Source-values
                RESULT-LIST &Result-values ]
        [ CHARS-TO-COMPOSITE-CHAR &chars-to-composite-char-X ]
        [ BITS-TO-COMPOSITE-BITS &bits-to-composite-bits-X
                [ UNIT &bits-to-composite-bits-unit ] ]
        [ OCTETS-TO-COMPOSITE-BITS &octets-to-composite-bits-X ]
        [ COMPOSITE-CHAR-TO-CHARS &composite-char-to-chars-X ]
        [ COMPOSITE-BITS-TO-BITS &composite-bits-to-bits-X ]
        [ COMPOSITE-BITS-TO-OCTETS &composite-bits-to-octets-X ] }

TRANSFORM-ORDERED ::= ORDERED { TRANSFORM0 }

CONDITIONAL-REPETITION0 ::= CLASS {
 -- Condition
        &size-range-condition SizeRangeCondition OPTIONAL,
        &condition-else-X OPTIONS OPTIONAL,
 -- Structure or component replacement specification
        &replace-structure-X OPTIONS OPTIONAL,
        &replace-component-X OPTIONS OPTIONAL,
        &replace-all-components-X OPTIONS OPTIONAL,
        &Replacement-structure OPTIONAL,
        &replacement-structure-encoding-object
         &Replacement-structure OPTIONAL,
        &Head-end-structure OPTIONAL,
 -- Pre-alignment and padding specification
        &aligned-to-next-X OPTIONS OPTIONAL,
        &aligned-to-any-X OPTIONS OPTIONAL,
        &encoding-space-pre-alignment-unit FixedUnit DEFAULT bit,
        &encoding-space-pre-padding Padding DEFAULT zero,
        &encoding-space-pre-pattern FixedNonNullPattern
         DEFAULT bits: '0'B,
 -- Start pointer specification
        &start-pointer REFERENCE OPTIONAL,
        &start-pointer-unit FixedUnit DEFAULT bit,
        &Start-pointer-encoder-transforms TRANSFORM-ORDERED
         OPTIONAL,
 -- Repetition space specification
        &repetition-space-size EncodingSpaceSize
         DEFAULT self-delimiting-values,
        &repetition-space-unit Unit DEFAULT bit,
        &repetition-space-determination RepetitionSpaceDetermination
         DEFAULT field-to-be-set,
        &main-reference REFERENCE OPTIONAL,
        &Encoder-transforms TRANSFORM-ORDERED OPTIONAL,
        &Decoder-transforms TRANSFORM-ORDERED OPTIONAL,
        &handle-id HandleName DEFAULT "default-handle",
        &termination-pattern FixedNonNullPattern DEFAULT bits: '0'B,
 -- Repetition alignment
        &repetition-alignment RepeatConcatAlignment DEFAULT none,
 -- Value padding and justification
        &value-padding-X OPTIONS OPTIONAL,
        &value-justification Justification DEFAULT right: 0,
        &value-pre-padding Padding DEFAULT zero,
        &value-pre-pattern Non-Null-Pattern DEFAULT bits: '0'B,
        &value-post-padding Padding DEFAULT zero,
        &value-post-pattern Non-Null-Pattern DEFAULT bits: '0'B,
        &unused-bits-determination UnusedBitsDetermination
         DEFAULT field-to-be-set,
        &unused-bits-reference REFERENCE OPTIONAL,
        &Unused-bits-encoder-transforms TRANSFORM-ORDERED OPTIONAL,
        &Unused-bits-decoder-transforms TRANSFORM-ORDERED OPTIONAL,
 -- Identification handle specification
        &exhibited-handle HandleName OPTIONAL,
        &Handle-positions HandlePosition OPTIONAL,
        &handle-value HandleValue DEFAULT tag: any,
 -- Bit reversal specification
        &bit-reversal ReversalSpecification DEFAULT no-reversal }
 WITH SYNTAX {
        [ IF &size-range-condition ]
        [ ELSE &condition-else-X ]
        [ REPLACE
                [ STRUCTURE &replace-structure-X ]
                [ COMPONENT &replace-component-X ]
                [ ALL COMPONENTS &replace-all-components-X ]
                WITH &Replacement-structure
                [ ENCODED BY &replacement-structure-encoding-object
                        [ INSERT AT HEAD &Head-end-structure ] ] ]
        [ ALIGNED TO
                [ NEXT &aligned-to-next-X ]
                [ ANY &aligned-to-any-X ]
                OPTIONS &encoding-space-pre-alignment-unit
                [ PADDING &encoding-space-pre-padding
                        [ PATTERN &encoding-space-pre-pattern ] ] ]
        [ START-POINTER &start-pointer
                [ MULTIPLE OF &start-pointer-unit ]
                [ ENCODER-TRANSFORMS
                 &Start-pointer-encoder-transforms ] ]
        REPETITION-SPACE
        [ SIZE &repetition-space-size
                [ MULTIPLE OF &repetition-space-unit ] ]
        [ DETERMINED BY &repetition-space-determination
                [ HANDLE &handle-id ] ]
        [ USING &main-reference
                [ ENCODER-TRANSFORMS &Encoder-transforms ]
                [ DECODER-TRANSFORMS &Decoder-transforms ] ]
        [ PATTERN &termination-pattern ]
        [ ALIGNMENT &repetition-alignment ]
        [ VALUE-PADDING &value-padding-X
                [ JUSTIFIED &value-justification ]
                [ PRE-PADDING &value-pre-padding
                        [ PATTERN &value-pre-pattern ] ]
                [ POST-PADDING &value-post-padding
                        [ PATTERN &value-post-pattern ] ]
                [ UNUSED BITS
                        [ DETERMINED BY &unused-bits-determination ]
                        [ USING &unused-bits-reference
                                [ ENCODER-TRANSFORMS
                                 &Unused-bits-encoder-transforms ]
                                [ DECODER-TRANSFORMS
                                 &Unused-bits-decoder-transforms ] ] ] ]
        [ EXHIBITS HANDLE &exhibited-handle
                AT &Handle-positions
                [ AS &handle-value ] ]
        [ BIT-REVERSAL &bit-reversal ] }

CONDITIONAL-REPETITION-ORDERED ::= ORDERED { CONDITIONAL-REPETITION0 }

REPETITION0 ::= CLASS {
 -- Repetition encoding
        &Repetition-encodings CONDITIONAL-REPETITION-ORDERED
         OPTIONAL,
        &repetition-encoding CONDITIONAL-REPETITION0 OPTIONAL }
 WITH SYNTAX {
        [ REPETITION-ENCODINGS &Repetition-encodings ]
        [ REPETITION-ENCODING &repetition-encoding ] }

CONDITIONAL-INT0 ::= CLASS {
 -- Condition
        &range-condition RangeCondition OPTIONAL,
        &condition-else-X OPTIONS OPTIONAL,
 -- Structure-only replacement specification
        &replace-structure-X OPTIONS OPTIONAL,
        &Replacement-structure OPTIONAL,
        &replacement-structure-encoding-object
         &Replacement-structure OPTIONAL,
 -- Pre-alignment and padding specification
        &aligned-to-next-X OPTIONS OPTIONAL,
        &aligned-to-any-X OPTIONS OPTIONAL,
        &encoding-space-pre-alignment-unit FixedUnit DEFAULT bit,
        &encoding-space-pre-padding Padding DEFAULT zero,
        &encoding-space-pre-pattern FixedNonNullPattern
         DEFAULT bits: '0'B,
 -- Start pointer specification
        &start-pointer REFERENCE OPTIONAL,
        &start-pointer-unit FixedUnit DEFAULT bit,
        &Start-pointer-encoder-transforms TRANSFORM-ORDERED
         OPTIONAL,
 -- Encoding space specification
        &encoding-space-size EncodingSpaceSize
         DEFAULT self-delimiting-values,
        &encoding-space-unit FixedUnit DEFAULT bit,
        &encoding-space-determination EncodingSpaceDetermination
         DEFAULT field-to-be-set,
        &encoding-space-reference REFERENCE OPTIONAL,
        &Encoder-transforms TRANSFORM-ORDERED OPTIONAL,
        &Decoder-transforms TRANSFORM-ORDERED OPTIONAL,
 -- Value encoding
        &Transforms TRANSFORM-ORDERED OPTIONAL,
        &encoding IntValueEncoding DEFAULT twos-complement,
 -- Value padding and justification
        &value-padding-X OPTIONS OPTIONAL,
        &value-justification Justification DEFAULT right: 0,
        &value-pre-padding Padding DEFAULT zero,
        &value-pre-pattern Non-Null-Pattern DEFAULT bits: '0'B,
        &value-post-padding Padding DEFAULT zero,
        &value-post-pattern Non-Null-Pattern DEFAULT bits: '0'B,
        &unused-bits-determination UnusedBitsDetermination
         DEFAULT field-to-be-set,
        &unused-bits-reference REFERENCE OPTIONAL,
        &Unused-bits-encoder-transforms TRANSFORM-ORDERED OPTIONAL,
        &Unused-bits-decoder-transforms TRANSFORM-ORDERED OPTIONAL,
 -- Identification handle specification
        &exhibited-handle HandleName OPTIONAL,
        &Handle-positions HandlePosition OPTIONAL,
        &handle-value HandleValue DEFAULT tag: any,
 -- Bit reversal specification
        &bit-reversal ReversalSpecification DEFAULT no-reversal }
 WITH SYNTAX {
        [ IF &range-condition ]
        [ ELSE &condition-else-X ]
        [ REPLACE
                [ STRUCTURE &replace-structure-X ]
                WITH &Replacement-structure
                [ ENCODED BY
                 &replacement-structure-encoding-object ] ]
        [ ALIGNED TO
                [ NEXT &aligned-to-next-X ]
                [ ANY &aligned-to-any-X ]
                OPTIONS &encoding-space-pre-alignment-unit
                [ PADDING &encoding-space-pre-padding
                        [ PATTERN &encoding-space-pre-pattern ] ] ]
        [ START-POINTER &start-pointer
                [ MULTIPLE OF &start-pointer-unit ]
                [ ENCODER-TRANSFORMS
                 &Start-pointer-encoder-transforms ] ]
        ENCODING-SPACE
        [ SIZE &encoding-space-size
                [ MULTIPLE OF &encoding-space-unit ] ]
        [ DETERMINED BY &encoding-space-determination ]
        [ USING &encoding-space-reference
                [ ENCODER-TRANSFORMS &Encoder-transforms ]
                [ DECODER-TRANSFORMS &Decoder-transforms ] ]
        [ TRANSFORMS &Transforms ]
        [ ENCODING &encoding ]
        [ VALUE-PADDING &value-padding-X
                [ JUSTIFIED &value-justification ]
                [ PRE-PADDING &value-pre-padding
                        [ PATTERN &value-pre-pattern ] ]
                [ POST-PADDING &value-post-padding
                        [ PATTERN &value-post-pattern ] ]
                [ UNUSED BITS
                        [ DETERMINED BY &unused-bits-determination ]
                        [ USING &unused-bits-reference
                                [ ENCODER-TRANSFORMS
                                 &Unused-bits-encoder-transforms ]
                                [ DECODER-TRANSFORMS
                                 &Unused-bits-decoder-transforms ] ] ] ]
        [ EXHIBITS HANDLE &exhibited-handle
                AT &Handle-positions
                [ AS &handle-value ] ]
        [ BIT-REVERSAL &bit-reversal ] }

CONDITIONAL-INT-ORDERED ::= ORDERED { CONDITIONAL-INT0 }

INT0 ::= CLASS {
 -- Integer encoding
        &Integer-encodings CONDITIONAL-INT-ORDERED OPTIONAL,
        &integer-encoding CONDITIONAL-INT0 OPTIONAL }
 WITH SYNTAX {
        [ ENCODINGS &Integer-encodings ]
        [ ENCODING &integer-encoding ] }

ALTERNATIVES0 ::= CLASS {
 -- Structure or component replacement specification
        &replace-structure-X OPTIONS OPTIONAL,
        &replace-component-X OPTIONS OPTIONAL,
        &replace-all-components-X OPTIONS OPTIONAL,
        &Replacement-structure OPTIONAL,
        &replacement-structure-encoding-object
         &Replacement-structure OPTIONAL,
        &Head-end-structure OPTIONAL,
 -- Pre-alignment and padding specification
        &aligned-to-next-X OPTIONS OPTIONAL,
        &aligned-to-any-X OPTIONS OPTIONAL,
        &encoding-space-pre-alignment-unit FixedUnit DEFAULT bit,
        &encoding-space-pre-padding Padding DEFAULT zero,
        &encoding-space-pre-pattern FixedNonNullPattern
         DEFAULT bits: '0'B,
 -- Start pointer specification
        &start-pointer REFERENCE OPTIONAL,
        &start-pointer-unit FixedUnit DEFAULT bit,
        &Start-pointer-encoder-transforms TRANSFORM-ORDERED
         OPTIONAL,
 -- Alternative determination
        &alternative-determination AlternativeDetermination
         DEFAULT field-to-be-set,
        &alternative-reference REFERENCE OPTIONAL,
        &Encoder-transforms TRANSFORM-ORDERED OPTIONAL,
        &Decoder-transforms TRANSFORM-ORDERED OPTIONAL,
        &handle-id HandleName DEFAULT "default-handle",
        &alternative-ordering AlternativeOrdering DEFAULT textual,
 -- Identification handle specification
        &exhibited-handle HandleName OPTIONAL,
        &Handle-positions HandlePosition OPTIONAL,
        &handle-value HandleValue DEFAULT tag: any }
 WITH SYNTAX {
        [ REPLACE
                [ STRUCTURE &replace-structure-X ]
                [ COMPONENT &replace-component-X ]
                [ ALL COMPONENTS &replace-all-components-X ]
                WITH &Replacement-structure
                [ ENCODED BY &replacement-structure-encoding-object
                        [ INSERT AT HEAD &Head-end-structure ] ] ]
        [ ALIGNED TO
                [ NEXT &aligned-to-next-X ]
                [ ANY &aligned-to-any-X ]
                OPTIONS &encoding-space-pre-alignment-unit
                [ PADDING &encoding-space-pre-padding
                        [ PATTERN &encoding-space-pre-pattern ] ] ]
        [ START-POINTER &start-pointer
                [ MULTIPLE OF &start-pointer-unit ]
                [ ENCODER-TRANSFORMS
                 &Start-pointer-encoder-transforms ] ]
        ALTERNATIVE
        [ DETERMINED BY &alternative-determination
                [ HANDLE &handle-id ] ]
        [ USING &alternative-reference
                [ ORDER &alternative-ordering ]
                [ ENCODER-TRANSFORMS &Encoder-transforms ]
                [ DECODER-TRANSFORMS &Decoder-transforms ] ]
        [ EXHIBITS HANDLE &exhibited-handle
                AT &Handle-positions
                [ AS &handle-value ] ] }

BITS0 ::= CLASS {
 -- Pre-alignment and padding specification
        &aligned-to-next-X OPTIONS OPTIONAL,
        &aligned-to-any-X OPTIONS OPTIONAL,
        &encoding-space-pre-alignment-unit FixedUnit DEFAULT bit,
        &encoding-space-pre-padding Padding DEFAULT zero,
        &encoding-space-pre-pattern FixedNonNullPattern
         DEFAULT bits: '0'B,
 -- Start pointer specification
        &start-pointer REFERENCE OPTIONAL,
        &start-pointer-unit FixedUnit DEFAULT bit,
        &Start-pointer-encoder-transforms TRANSFORM-ORDERED
         OPTIONAL,
 -- Bits value encoding
        &value-reversal BOOLEAN DEFAULT FALSE,
        &Transforms TRANSFORM-ORDERED OPTIONAL,
        &Bits-repetition-encodings CONDITIONAL-REPETITION-ORDERED
         OPTIONAL,
        &bits-repetition-encoding CONDITIONAL-REPETITION0 OPTIONAL,
 -- Identification handle specification
        &exhibited-handle HandleName OPTIONAL,
        &Handle-positions HandlePosition OPTIONAL,
        &handle-value HandleValue DEFAULT tag: any,
 -- Contained type encoding specification
        &Primary-encoding-object-set ENCODINGS OPTIONAL,
        &Secondary-encoding-object-set ENCODINGS OPTIONAL,
        &over-ride-encoded-by BOOLEAN DEFAULT FALSE }
 WITH SYNTAX {
        [ ALIGNED TO
                [ NEXT &aligned-to-next-X ]
                [ ANY &aligned-to-any-X ]
                OPTIONS &encoding-space-pre-alignment-unit
                [ PADDING &encoding-space-pre-padding
                        [ PATTERN &encoding-space-pre-pattern ] ] ]
        [ START-POINTER &start-pointer
                [ MULTIPLE OF &start-pointer-unit ]
                [ ENCODER-TRANSFORMS
                 &Start-pointer-encoder-transforms ] ]
        [ VALUE-REVERSAL &value-reversal ]
        [ TRANSFORMS &Transforms ]
        [ REPETITION-ENCODINGS &Bits-repetition-encodings ]
        [ REPETITION-ENCODING &bits-repetition-encoding ]
        [ EXHIBITS HANDLE &exhibited-handle
                AT &Handle-positions
                [ AS &handle-value ] ]
        [ CONTENTS-ENCODING &Primary-encoding-object-set
                [ COMPLETED BY &Secondary-encoding-object-set ]
                [ OVERRIDE &over-ride-encoded-by ] ] }

BOOL0 ::= CLASS {
 -- Structure-only replacement specification
        &replace-structure-X OPTIONS OPTIONAL,
        &Replacement-structure OPTIONAL,
        &replacement-structure-encoding-object
         &Replacement-structure OPTIONAL,
 -- Pre-alignment and padding specification
        &aligned-to-next-X OPTIONS OPTIONAL,
        &aligned-to-any-X OPTIONS OPTIONAL,
        &encoding-space-pre-alignment-unit FixedUnit DEFAULT bit,
        &encoding-space-pre-padding Padding DEFAULT zero,
        &encoding-space-pre-pattern FixedNonNullPattern
         DEFAULT bits: '0'B,
 -- Start pointer specification
        &start-pointer REFERENCE OPTIONAL,
        &start-pointer-unit FixedUnit DEFAULT bit,
        &Start-pointer-encoder-transforms TRANSFORM-ORDERED
         OPTIONAL,
 -- Encoding space specification
        &encoding-space-size EncodingSpaceSize
         DEFAULT self-delimiting-values,
        &encoding-space-unit FixedUnit DEFAULT bit,
        &encoding-space-determination EncodingSpaceDetermination
         DEFAULT field-to-be-set,
        &encoding-space-reference REFERENCE OPTIONAL,
        &Encoder-transforms TRANSFORM-ORDERED OPTIONAL,
        &Decoder-transforms TRANSFORM-ORDERED OPTIONAL,
 -- Boolean value encoding
        &value-true-pattern Pattern DEFAULT bits: '1'B,
        &value-false-pattern Pattern DEFAULT bits: '0'B,
 -- Value padding and justification
        &value-padding-X OPTIONS OPTIONAL,
        &value-justification Justification DEFAULT right: 0,
        &value-pre-padding Padding DEFAULT zero,
        &value-pre-pattern Non-Null-Pattern DEFAULT bits: '0'B,
        &value-post-padding Padding DEFAULT zero,
        &value-post-pattern Non-Null-Pattern DEFAULT bits: '0'B,
        &unused-bits-determination UnusedBitsDetermination
         DEFAULT field-to-be-set,
        &unused-bits-reference REFERENCE OPTIONAL,
        &Unused-bits-encoder-transforms TRANSFORM-ORDERED OPTIONAL,
        &Unused-bits-decoder-transforms TRANSFORM-ORDERED OPTIONAL,
 -- Identification handle specification
        &exhibited-handle HandleName OPTIONAL,
        &Handle-positions HandlePosition OPTIONAL,
        &handle-value HandleValue DEFAULT tag: any,
 -- Bit reversal specification
        &bit-reversal ReversalSpecification DEFAULT no-reversal }
 WITH SYNTAX {
        [ REPLACE
                [ STRUCTURE &replace-structure-X ]
                WITH &Replacement-structure
                [ ENCODED BY
                 &replacement-structure-encoding-object ] ]
        [ ALIGNED TO
                [ NEXT &aligned-to-next-X ]
                [ ANY &aligned-to-any-X ]
                OPTIONS &encoding-space-pre-alignment-unit
                [ PADDING &encoding-space-pre-padding
                        [ PATTERN &encoding-space-pre-pattern ] ] ]
        [ START-POINTER &start-pointer
                [ MULTIPLE OF &start-pointer-unit ]
                [ ENCODER-TRANSFORMS
                 &Start-pointer-encoder-transforms ] ]
        ENCODING-SPACE
        [ SIZE &encoding-space-size
                [ MULTIPLE OF &encoding-space-unit ] ]
        [ DETERMINED BY &encoding-space-determination ]
        [ USING &encoding-space-reference
                [ ENCODER-TRANSFORMS &Encoder-transforms ]
                [ DECODER-TRANSFORMS &Decoder-transforms ] ]
        [ TRUE-PATTERN &value-true-pattern ]
        [ FALSE-PATTERN &value-false-pattern ]
        [ VALUE-PADDING &value-padding-X
                [ JUSTIFIED &value-justification ]
                [ PRE-PADDING &value-pre-padding
                        [ PATTERN &value-pre-pattern ] ]
                [ POST-PADDING &value-post-padding
                        [ PATTERN &value-post-pattern ] ]
                [ UNUSED BITS
                        [ DETERMINED BY &unused-bits-determination ]
                        [ USING &unused-bits-reference
                                [ ENCODER-TRANSFORMS
                                 &Unused-bits-encoder-transforms ]
                                [ DECODER-TRANSFORMS
                                 &Unused-bits-decoder-transforms ] ] ] ]
        [ EXHIBITS HANDLE &exhibited-handle
                AT &Handle-positions
                [ AS &handle-value ] ]
        [ BIT-REVERSAL &bit-reversal ] }

CHARS0 ::= CLASS {
 -- Pre-alignment and padding specification
        &aligned-to-next-X OPTIONS OPTIONAL,
        &aligned-to-any-X OPTIONS OPTIONAL,
        &encoding-space-pre-alignment-unit FixedUnit DEFAULT bit,
        &encoding-space-pre-padding Padding DEFAULT zero,
        &encoding-space-pre-pattern FixedNonNullPattern
         DEFAULT bits: '0'B,
 -- Start pointer specification
        &start-pointer REFERENCE OPTIONAL,
        &start-pointer-unit FixedUnit DEFAULT bit,
        &Start-pointer-encoder-transforms TRANSFORM-ORDERED
         OPTIONAL,
 -- Chars value encoding
        &value-reversal BOOLEAN DEFAULT FALSE,
        &Transforms TRANSFORM-ORDERED OPTIONAL,
        &Chars-repetition-encodings CONDITIONAL-REPETITION-ORDERED
         OPTIONAL,
        &chars-repetition-encoding CONDITIONAL-REPETITION0 OPTIONAL,
 -- Identification handle specification
        &exhibited-handle HandleName OPTIONAL,
        &Handle-positions HandlePosition OPTIONAL,
        &handle-value HandleValue DEFAULT tag: any }
 WITH SYNTAX {
        [ ALIGNED TO
                [ NEXT &aligned-to-next-X ]
                [ ANY &aligned-to-any-X ]
                OPTIONS &encoding-space-pre-alignment-unit
                [ PADDING &encoding-space-pre-padding
                        [ PATTERN &encoding-space-pre-pattern ] ] ]
        [ START-POINTER &start-pointer
                [ MULTIPLE OF &start-pointer-unit ]
                [ ENCODER-TRANSFORMS
                 &Start-pointer-encoder-transforms ] ]
        [ VALUE-REVERSAL &value-reversal ]
        [ TRANSFORMS &Transforms ]
        [ REPETITION-ENCODINGS &Chars-repetition-encodings ]
        [ REPETITION-ENCODING &chars-repetition-encoding ]
        [ EXHIBITS HANDLE &exhibited-handle
                AT &Handle-positions
                [ AS &handle-value ] ] }

CONCATENATION0 ::= CLASS {
 -- Full replacement specification
        &replace-structure-X OPTIONS OPTIONAL,
        &replace-component-X OPTIONS OPTIONAL,
        &replace-all-components-X OPTIONS OPTIONAL,
        &replace-optionals-X OPTIONS OPTIONAL,
        &replace-non-optionals-X OPTIONS OPTIONAL,
        &Replacement-structure OPTIONAL,
        &Replacement-structure2 OPTIONAL,
        &replacement-structure-encoding-object
         &Replacement-structure OPTIONAL,
        &replacement-structure-encoding-object2
         &Replacement-structure2 OPTIONAL,
        &Head-end-structure OPTIONAL,
        &Head-end-structure2 OPTIONAL,
 -- Pre-alignment and padding specification
        &aligned-to-next-X OPTIONS OPTIONAL,
        &aligned-to-any-X OPTIONS OPTIONAL,
        &encoding-space-pre-alignment-unit FixedUnit DEFAULT bit,
        &encoding-space-pre-padding Padding DEFAULT zero,
        &encoding-space-pre-pattern FixedNonNullPattern
         DEFAULT bits: '0'B,
 -- Start pointer specification
        &start-pointer REFERENCE OPTIONAL,
        &start-pointer-unit FixedUnit DEFAULT bit,
        &Start-pointer-encoder-transforms TRANSFORM-ORDERED
         OPTIONAL,
 -- Encoding space specification
        &encoding-space-size EncodingSpaceSize
         DEFAULT self-delimiting-values,
        &encoding-space-unit FixedUnit DEFAULT bit,
        &encoding-space-determination EncodingSpaceDetermination
         DEFAULT field-to-be-set,
        &encoding-space-reference REFERENCE OPTIONAL,
        &Encoder-transforms TRANSFORM-ORDERED OPTIONAL,
        &Decoder-transforms TRANSFORM-ORDERED OPTIONAL,
 -- Concatenation specification
        &concatenation-order ConcatenationOrdering DEFAULT textual,
        &concatenation-alignment RepeatConcatAlignment
         DEFAULT aligned,
        &concatenation-handle HandleName DEFAULT "default-handle",
 -- Value padding and justification
        &value-padding-X OPTIONS OPTIONAL,
        &value-justification Justification DEFAULT right: 0,
        &value-pre-padding Padding DEFAULT zero,
        &value-pre-pattern Non-Null-Pattern DEFAULT bits: '0'B,
        &value-post-padding Padding DEFAULT zero,
        &value-post-pattern Non-Null-Pattern DEFAULT bits: '0'B,
        &unused-bits-determination UnusedBitsDetermination
         DEFAULT field-to-be-set,
        &unused-bits-reference REFERENCE OPTIONAL,
        &Unused-bits-encoder-transforms TRANSFORM-ORDERED OPTIONAL,
        &Unused-bits-decoder-transforms TRANSFORM-ORDERED OPTIONAL,
 -- Identification handle specification
        &exhibited-handle HandleName OPTIONAL,
        &Handle-positions HandlePosition OPTIONAL,
        &handle-value HandleValue DEFAULT tag: any,
 -- Bit reversal specification
        &bit-reversal ReversalSpecification DEFAULT no-reversal }
 WITH SYNTAX {
        [ REPLACE
                [ STRUCTURE &replace-structure-X ]
                [ COMPONENT &replace-component-X ]
                [ ALL COMPONENTS &replace-all-components-X ]
                [ OPTIONALS &replace-optionals-X ]
                [ NON-OPTIONALS &replace-non-optionals-X ]
                WITH &Replacement-structure
                [ ENCODED BY &replacement-structure-encoding-object
                        [ INSERT AT HEAD &Head-end-structure ] ]
                [ AND OPTIONALS WITH &Replacement-structure2
                        [ ENCODED BY
                         &replacement-structure-encoding-object2
                                [ INSERT AT HEAD
                                 &Head-end-structure2 ] ] ] ]
        [ ALIGNED TO
                [ NEXT &aligned-to-next-X ]
                [ ANY &aligned-to-any-X ]
                OPTIONS &encoding-space-pre-alignment-unit
                [ PADDING &encoding-space-pre-padding
                        [ PATTERN &encoding-space-pre-pattern ] ] ]
        [ START-POINTER &start-pointer
                [ MULTIPLE OF &start-pointer-unit ]
                [ ENCODER-TRANSFORMS
                 &Start-pointer-encoder-transforms ] ]
        ENCODING-SPACE
        [ SIZE &encoding-space-size
                [ MULTIPLE OF &encoding-space-unit ] ]
        [ DETERMINED BY &encoding-space-determination ]
        [ USING &encoding-space-reference
                [ ENCODER-TRANSFORMS &Encoder-transforms ]
                [ DECODER-TRANSFORMS &Decoder-transforms ] ]
        [ CONCATENATION
                [ ORDER &concatenation-order ]
                [ ALIGNMENT &concatenation-alignment ]
                [ HANDLE &concatenation-handle ] ]
        [ VALUE-PADDING &value-padding-X
                [ JUSTIFIED &value-justification ]
                [ PRE-PADDING &value-pre-padding
                        [ PATTERN &value-pre-pattern ] ]
                [ POST-PADDING &value-post-padding
                        [ PATTERN &value-post-pattern ] ]
                [ UNUSED BITS
                        [ DETERMINED BY &unused-bits-determination ]
                        [ USING &unused-bits-reference
                                [ ENCODER-TRANSFORMS
                                 &Unused-bits-encoder-transforms ]
                                [ DECODER-TRANSFORMS
                                 &Unused-bits-decoder-transforms ] ] ] ]
        [ EXHIBITS HANDLE &exhibited-handle
                AT &Handle-positions
                [ AS &handle-value ] ]
        [ BIT-REVERSAL &bit-reversal ] }

NUL0 ::= CLASS {
 -- Structure-only replacement specification
        &replace-structure-X OPTIONS OPTIONAL,
        &Replacement-structure OPTIONAL,
        &replacement-structure-encoding-object
         &Replacement-structure OPTIONAL,
 -- Pre-alignment and padding specification
        &aligned-to-next-X OPTIONS OPTIONAL,
        &aligned-to-any-X OPTIONS OPTIONAL,
        &encoding-space-pre-alignment-unit FixedUnit DEFAULT bit,
        &encoding-space-pre-padding Padding DEFAULT zero,
        &encoding-space-pre-pattern FixedNonNullPattern
         DEFAULT bits: '0'B,
 -- Start pointer specification
        &start-pointer REFERENCE OPTIONAL,
        &start-pointer-unit FixedUnit DEFAULT bit,
        &Start-pointer-encoder-transforms TRANSFORM-ORDERED
         OPTIONAL,
 -- Encoding space specification
        &encoding-space-size EncodingSpaceSize
         DEFAULT self-delimiting-values,
        &encoding-space-unit FixedUnit DEFAULT bit,
        &encoding-space-determination EncodingSpaceDetermination
         DEFAULT field-to-be-set,
        &encoding-space-reference REFERENCE OPTIONAL,
        &Encoder-transforms TRANSFORM-ORDERED OPTIONAL,
        &Decoder-transforms TRANSFORM-ORDERED OPTIONAL,
 -- Value pattern
        &value-pattern FixedPattern DEFAULT bits: ''B,
 -- Value padding and justification
        &value-padding-X OPTIONS OPTIONAL,
        &value-justification Justification DEFAULT right: 0,
        &value-pre-padding Padding DEFAULT zero,
        &value-pre-pattern Non-Null-Pattern DEFAULT bits: '0'B,
        &value-post-padding Padding DEFAULT zero,
        &value-post-pattern Non-Null-Pattern DEFAULT bits: '0'B,
        &unused-bits-determination UnusedBitsDetermination
         DEFAULT field-to-be-set,
        &unused-bits-reference REFERENCE OPTIONAL,
        &Unused-bits-encoder-transforms TRANSFORM-ORDERED OPTIONAL,
        &Unused-bits-decoder-transforms TRANSFORM-ORDERED OPTIONAL,
 -- Identification handle specification
        &exhibited-handle HandleName OPTIONAL,
        &Handle-positions HandlePosition OPTIONAL,
        &handle-value HandleValue DEFAULT tag: any,
 -- Bit reversal specification
        &bit-reversal ReversalSpecification DEFAULT no-reversal }
 WITH SYNTAX {
        [ REPLACE
                [ STRUCTURE &replace-structure-X ]
                WITH &Replacement-structure
                [ ENCODED BY
                 &replacement-structure-encoding-object ] ]
        [ ALIGNED TO
                [ NEXT &aligned-to-next-X ]
                [ ANY &aligned-to-any-X ]
                OPTIONS &encoding-space-pre-alignment-unit
                [ PADDING &encoding-space-pre-padding
                        [ PATTERN &encoding-space-pre-pattern ] ] ]
        [ START-POINTER &start-pointer
                [ MULTIPLE OF &start-pointer-unit ]
                [ ENCODER-TRANSFORMS
                 &Start-pointer-encoder-transforms ] ]
        ENCODING-SPACE
        [ SIZE &encoding-space-size
                [ MULTIPLE OF &encoding-space-unit ] ]
        [ DETERMINED BY &encoding-space-determination ]
        [ USING &encoding-space-reference
                [ ENCODER-TRANSFORMS &Encoder-transforms ]
                [ DECODER-TRANSFORMS &Decoder-transforms ] ]
        [ NULL-PATTERN &value-pattern ]
        [ VALUE-PADDING &value-padding-X
                [ JUSTIFIED &value-justification ]
                [ PRE-PADDING &value-pre-padding
                        [ PATTERN &value-pre-pattern ] ]
                [ POST-PADDING &value-post-padding
                        [ PATTERN &value-post-pattern ] ]
                [ UNUSED BITS
                        [ DETERMINED BY &unused-bits-determination ]
                        [ USING &unused-bits-reference
                                [ ENCODER-TRANSFORMS
                                 &Unused-bits-encoder-transforms ]
                                [ DECODER-TRANSFORMS
                                 &Unused-bits-decoder-transforms ] ] ] ]
        [ EXHIBITS HANDLE &exhibited-handle
                AT &Handle-positions
                [ AS &handle-value ] ]
        [ BIT-REVERSAL &bit-reversal ] }

OCTETS0 ::= CLASS {
 -- Pre-alignment and padding specification
        &aligned-to-next-X OPTIONS OPTIONAL,
        &aligned-to-any-X OPTIONS OPTIONAL,
        &encoding-space-pre-alignment-unit FixedUnit DEFAULT bit,
        &encoding-space-pre-padding Padding DEFAULT zero,
        &encoding-space-pre-pattern FixedNonNullPattern
         DEFAULT bits: '0'B,
 -- Start pointer specification
        &start-pointer REFERENCE OPTIONAL,
        &start-pointer-unit FixedUnit DEFAULT bit,
        &Start-pointer-encoder-transforms TRANSFORM-ORDERED
         OPTIONAL,
 -- Octets value encoding
        &value-reversal BOOLEAN DEFAULT FALSE,
        &Transforms TRANSFORM-ORDERED OPTIONAL,
        &Octets-repetition-encodings CONDITIONAL-REPETITION-ORDERED
         OPTIONAL,
        &octets-repetition-encoding CONDITIONAL-REPETITION0 OPTIONAL,
 -- Identification handle specification
        &exhibited-handle HandleName OPTIONAL,
        &Handle-positions HandlePosition OPTIONAL,
        &handle-value HandleValue DEFAULT tag: any,
 -- Contained type encoding specification
        &Primary-encoding-object-set ENCODINGS OPTIONAL,
        &Secondary-encoding-object-set ENCODINGS OPTIONAL,
        &over-ride-encoded-by BOOLEAN DEFAULT FALSE }
 WITH SYNTAX {
        [ ALIGNED TO
                [ NEXT &aligned-to-next-X ]
                [ ANY &aligned-to-any-X ]
                OPTIONS &encoding-space-pre-alignment-unit
                [ PADDING &encoding-space-pre-padding
                        [ PATTERN &encoding-space-pre-pattern ] ] ]
        [ START-POINTER &start-pointer
                [ MULTIPLE OF &start-pointer-unit ]
                [ ENCODER-TRANSFORMS
                 &Start-pointer-encoder-transforms ] ]
        [ VALUE-REVERSAL &value-reversal ]
        [ TRANSFORMS &Transforms ]
        [ REPETITION-ENCODINGS &Octets-repetition-encodings ]
        [ REPETITION-ENCODING &octets-repetition-encoding ]
        [ EXHIBITS HANDLE &exhibited-handle
                AT &Handle-positions
                [ AS &handle-value ] ]
        [ CONTENTS-ENCODING &Primary-encoding-object-set
                [ COMPLETED BY &Secondary-encoding-object-set ]
                [ OVERRIDE &over-ride-encoded-by ] ] }

OPTIONAL0 ::= CLASS {
 -- Structure-only replacement specification
        &replace-structure-X OPTIONS OPTIONAL,
        &Replacement-structure OPTIONAL,
        &replacement-structure-encoding-object
         &Replacement-structure OPTIONAL,
 -- Pre-alignment and padding specification
        &aligned-to-next-X OPTIONS OPTIONAL,
        &aligned-to-any-X OPTIONS OPTIONAL,
        &encoding-space-pre-alignment-unit FixedUnit DEFAULT bit,
        &encoding-space-pre-padding Padding DEFAULT zero,
        &encoding-space-pre-pattern FixedNonNullPattern
         DEFAULT bits: '0'B,
 -- Start pointer specification
        &start-pointer REFERENCE OPTIONAL,
        &start-pointer-unit FixedUnit DEFAULT bit,
        &Start-pointer-encoder-transforms TRANSFORM-ORDERED
         OPTIONAL,
 -- Optionality determination
        &optionality-determination OptionalityDetermination
         DEFAULT field-to-be-set,
        &optionality-reference REFERENCE OPTIONAL,
        &Encoder-transforms TRANSFORM-ORDERED OPTIONAL,
        &Decoder-transforms TRANSFORM-ORDERED OPTIONAL,
        &handle-id HandleName DEFAULT "default-handle" }
 WITH SYNTAX {
        [ REPLACE
                [ STRUCTURE &replace-structure-X ]
                WITH &Replacement-structure
                [ ENCODED BY
                 &replacement-structure-encoding-object ] ]
        [ ALIGNED TO
                [ NEXT &aligned-to-next-X ]
                [ ANY &aligned-to-any-X ]
                OPTIONS &encoding-space-pre-alignment-unit
                [ PADDING &encoding-space-pre-padding
                        [ PATTERN &encoding-space-pre-pattern ] ] ]
        [ START-POINTER &start-pointer
                [ MULTIPLE OF &start-pointer-unit ]
                [ ENCODER-TRANSFORMS
                 &Start-pointer-encoder-transforms ] ]
        PRESENCE
        [ DETERMINED BY &optionality-determination
                [ HANDLE &handle-id ] ]
        [ USING &optionality-reference
                [ ENCODER-TRANSFORMS &Encoder-transforms ]
                [ DECODER-TRANSFORMS &Decoder-transforms ] ] }

PAD0 ::= CLASS {
 -- Structure-only replacement specification
        &replace-structure-X OPTIONS OPTIONAL,
        &Replacement-structure OPTIONAL,
        &replacement-structure-encoding-object
         &Replacement-structure OPTIONAL,
 -- Pre-alignment and padding specification
        &aligned-to-next-X OPTIONS OPTIONAL,
        &aligned-to-any-X OPTIONS OPTIONAL,
        &encoding-space-pre-alignment-unit FixedUnit DEFAULT bit,
        &encoding-space-pre-padding Padding DEFAULT zero,
        &encoding-space-pre-pattern FixedNonNullPattern
         DEFAULT bits: '0'B,
 -- Start pointer specification
        &start-pointer REFERENCE OPTIONAL,
        &start-pointer-unit FixedUnit DEFAULT bit,
        &Start-pointer-encoder-transforms TRANSFORM-ORDERED
         OPTIONAL,
 -- Encoding space specification
        &encoding-space-size EncodingSpaceSize
         DEFAULT self-delimiting-values,
        &encoding-space-unit FixedUnit DEFAULT bit,
        &encoding-space-determination EncodingSpaceDetermination
         DEFAULT field-to-be-set,
        &encoding-space-reference REFERENCE OPTIONAL,
        &Encoder-transforms TRANSFORM-ORDERED OPTIONAL,
        &Decoder-transforms TRANSFORM-ORDERED OPTIONAL,
 -- Value encoding
        &pad-pattern FixedPattern DEFAULT bits: ''B,
 -- Identification handle specification
        &exhibited-handle HandleName OPTIONAL,
        &Handle-positions HandlePosition OPTIONAL,
        &handle-value HandleValue DEFAULT tag: any,
 -- Bit reversal specification
        &bit-reversal ReversalSpecification DEFAULT no-reversal }
 WITH SYNTAX {
        [ REPLACE
                [ STRUCTURE &replace-structure-X ]
                WITH &Replacement-structure
                [ ENCODED BY
                 &replacement-structure-encoding-object ] ]
        [ ALIGNED TO
                [ NEXT &aligned-to-next-X ]
                [ ANY &aligned-to-any-X ]
                OPTIONS &encoding-space-pre-alignment-unit
                [ PADDING &encoding-space-pre-padding
                        [ PATTERN &encoding-space-pre-pattern ] ] ]
        [ START-POINTER &start-pointer
                [ MULTIPLE OF &start-pointer-unit ]
                [ ENCODER-TRANSFORMS
                 &Start-pointer-encoder-transforms ] ]
        ENCODING-SPACE
        [ SIZE &encoding-space-size
                [ MULTIPLE OF &encoding-space-unit ] ]
        [ DETERMINED BY &encoding-space-determination ]
        [ USING &encoding-space-reference
                [ ENCODER-TRANSFORMS &Encoder-transforms ]
                [ DECODER-TRANSFORMS &Decoder-transforms ] ]
        [ PAD-PATTERN &pad-pattern ]
        [ EXHIBITS HANDLE &exhibited-handle
                AT &Handle-positions
                [ AS &handle-value ] ]
        [ BIT-REVERSAL &bit-reversal ] }

TAG0 ::= CLASS {
 -- Structure-only replacement specification
        &replace-structure-X OPTIONS OPTIONAL,
        &Replacement-structure OPTIONAL,
        &replacement-structure-encoding-object
         &Replacement-structure OPTIONAL,
 -- Pre-alignment and padding specification
        &aligned-to-next-X OPTIONS OPTIONAL,
        &aligned-to-any-X OPTIONS OPTIONAL,
        &encoding-space-pre-alignment-unit FixedUnit DEFAULT bit,
        &encoding-space-pre-padding Padding DEFAULT zero,
        &encoding-space-pre-pattern FixedNonNullPattern
         DEFAULT bits: '0'B,
 -- Start pointer specification
        &start-pointer REFERENCE OPTIONAL,
        &start-pointer-unit FixedUnit DEFAULT bit,
        &Start-pointer-encoder-transforms TRANSFORM-ORDERED
         OPTIONAL,
 -- Encoding space specification
        &encoding-space-size EncodingSpaceSize
         DEFAULT self-delimiting-values,
        &encoding-space-unit FixedUnit DEFAULT bit,
        &encoding-space-determination EncodingSpaceDetermination
         DEFAULT field-to-be-set,
        &encoding-space-reference REFERENCE OPTIONAL,
        &Encoder-transforms TRANSFORM-ORDERED OPTIONAL,
        &Decoder-transforms TRANSFORM-ORDERED OPTIONAL,
 -- Value padding and justification
        &value-padding-X OPTIONS OPTIONAL,
        &value-justification Justification DEFAULT right: 0,
        &value-pre-padding Padding DEFAULT zero,
        &value-pre-pattern Non-Null-Pattern DEFAULT bits: '0'B,
        &value-post-padding Padding DEFAULT zero,
        &value-post-pattern Non-Null-Pattern DEFAULT bits: '0'B,
        &unused-bits-determination UnusedBitsDetermination
         DEFAULT field-to-be-set,
        &unused-bits-reference REFERENCE OPTIONAL,
        &Unused-bits-encoder-transforms TRANSFORM-ORDERED OPTIONAL,
        &Unused-bits-decoder-transforms TRANSFORM-ORDERED OPTIONAL,
 -- Identification handle specification
        &exhibited-handle HandleName OPTIONAL,
        &Handle-positions HandlePosition OPTIONAL,
        &handle-value HandleValue DEFAULT tag: any,
 -- Bit reversal specification
        &bit-reversal ReversalSpecification DEFAULT no-reversal }
 WITH SYNTAX {
        [ REPLACE
                [ STRUCTURE &replace-structure-X ]
                WITH &Replacement-structure
                [ ENCODED BY
                 &replacement-structure-encoding-object ] ]
        [ ALIGNED TO
                [ NEXT &aligned-to-next-X ]
                [ ANY &aligned-to-any-X ]
                OPTIONS &encoding-space-pre-alignment-unit
                [ PADDING &encoding-space-pre-padding
                        [ PATTERN &encoding-space-pre-pattern ] ] ]
        [ START-POINTER &start-pointer
                [ MULTIPLE OF &start-pointer-unit ]
                [ ENCODER-TRANSFORMS
                 &Start-pointer-encoder-transforms ] ]
        ENCODING-SPACE
        [ SIZE &encoding-space-size
                [ MULTIPLE OF &encoding-space-unit ] ]
        [ DETERMINED BY &encoding-space-determination ]
        [ USING &encoding-space-reference
                [ ENCODER-TRANSFORMS &Encoder-transforms ]
                [ DECODER-TRANSFORMS &Decoder-transforms ] ]
        [ VALUE-PADDING &value-padding-X
                [ JUSTIFIED &value-justification ]
                [ PRE-PADDING &value-pre-padding
                        [ PATTERN &value-pre-pattern ] ]
                [ POST-PADDING &value-post-padding
                        [ PATTERN &value-post-pattern ] ]
                [ UNUSED BITS
                        [ DETERMINED BY &unused-bits-determination ]
                        [ USING &unused-bits-reference
                                [ ENCODER-TRANSFORMS
                                 &Unused-bits-encoder-transforms ]
                                [ DECODER-TRANSFORMS
                                 &Unused-bits-decoder-transforms ] ] ] ]
        [ EXHIBITS HANDLE &exhibited-handle
                AT &Handle-positions
                [ AS &handle-value ] ]
        [ BIT-REVERSAL &bit-reversal ] }

OUTER0 ::= CLASS {
 -- Alignment point
        &alignment-point AlignmentPoint DEFAULT reset,
 -- Padding
        &post-padding-unit FixedUnit DEFAULT octet,
        &post-padding Padding DEFAULT zero,
        &post-padding-pattern FixedNonNullPattern
         DEFAULT bits: '0'B,
 -- Bit reversal specification
        &bit-reversal ReversalSpecification DEFAULT no-reversal,
 -- Added bits action
        &added-bits AddedBits DEFAULT hard-error }
 WITH SYNTAX {
        [ ALIGNMENT &alignment-point ]
        [ PADDING
                [ MULTIPLE OF &post-padding-unit ]
                [ POST-PADDING &post-padding
                        [ PATTERN &post-padding-pattern ] ] ]
        [ BIT-REVERSAL &bit-reversal ]
        [ ADDED BITS DECODING &added-bits ] }

OPEN-TYPE0 ::= OCTETS0 -- No special encoding class yet --

OBJECT-IDENTIFIER0 ::= OCTETS0 -- No special encoding class yet --

REAL0 ::= OCTETS0 -- No special encoding class yet --

-- EXTENSIONS ::= EXTENSIONS

-- VERSION-BRACKET ::= VERSION-BRACKET

END