// This C++ header file was generated by the TTCN-3 compiler
// of the TTCN-3 Test Executor version 9.0.0
// The generation of user and time information were disabled by the -D flag.

// Copyright (c) 2000-2023 Ericsson Telecom AB

// Do not edit this file unless you know what you are doing.

#ifndef LLC__Types_HH
#define LLC__Types_HH

#ifdef TITAN_RUNTIME_2
#error Generated code does not match with used runtime.\
 Code was generated without -R option but -DTITAN_RUNTIME_2 was used.
#endif

/* Header file includes */

#include <TTCN3.hh>
#include "General_Types.hh"

#if TTCN3_VERSION != 90000
#error Version mismatch detected.\
 Please check the version of the TTCN-3 compiler and the base library.\
 Run make clean and rebuild the project if the version of the compiler changed recently.
#endif

#ifndef LINUX
#error This file should be compiled on LINUX
#endif

#undef LLC__Types_HH
#endif

namespace LLC__Types {

/* Forward declarations of classes */

class Version;
class Version_template;
class T200;
class T200_template;
class N200;
class N200_template;
class N201__U;
class N201__U_template;
class N201__I;
class N201__I_template;
class MD;
class MD_template;
class MU;
class MU_template;
class XID__Data;
class XID__Data_template;
class XID__length;
class XID__length_template;
class XID;
class XID_template;
class Control__field__UI;
class Control__field__UI_template;
class RejectedFrameControlField__UI;
class RejectedFrameControlField__UI_template;
class Control__field__U;
class Control__field__U_template;
class RejectedFrameControlField__U;
class RejectedFrameControlField__U_template;
class RejectedFrameControlField;
class RejectedFrameControlField_template;
class UA__Information;
class UA__Information_template;
class SABM__Information;
class SABM__Information_template;
class XID__Information;
class XID__Information_template;
class FRMR__Information;
class FRMR__Information_template;
class Address__field;
class Address__field_template;
class Information__field__U;
class Information__field__U_template;
class PDU__LLC__UI;
class PDU__LLC__UI_template;
class PDU__LLC__U;
class PDU__LLC__U_template;
class PDU__LLC;
class PDU__LLC_template;

} /* end of namespace */

#ifndef LLC__Types_HH
#define LLC__Types_HH

namespace LLC__Types {

/* Type definitions */

typedef OCTETSTRING IOV__UI;
typedef OCTETSTRING_template IOV__UI_template;
typedef OCTETSTRING IOV__I;
typedef OCTETSTRING_template IOV__I_template;
typedef INTEGER KD;
typedef INTEGER_template KD_template;
typedef INTEGER KU;
typedef INTEGER_template KU_template;
typedef OCTETSTRING L3param;
typedef OCTETSTRING_template L3param_template;
typedef OCTETSTRING Reset__LLC;
typedef OCTETSTRING_template Reset__LLC_template;
typedef OCTETSTRING DM__Information;
typedef OCTETSTRING_template DM__Information_template;
typedef OCTETSTRING NULL__Information;
typedef OCTETSTRING_template NULL__Information_template;
typedef OCTETSTRING DISC__Information;
typedef OCTETSTRING_template DISC__Information_template;

/* Class definitions */

class Version : public Base_Type {
  INTEGER field_version__value;
  BITSTRING field_spare;
public:
  Version();
  Version(const INTEGER& par_version__value,
    const BITSTRING& par_spare);
  Version(const Version& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  Version& operator=(const Version& other_value);
  boolean operator==(const Version& other_value) const;
  inline boolean operator!=(const Version& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline INTEGER& version__value()
    {return field_version__value;}
  inline const INTEGER& version__value() const
    {return field_version__value;}
  inline BITSTRING& spare()
    {return field_spare;}
  inline const BITSTRING& spare() const
    {return field_spare;}
  inline int size_of() const
    {return 2;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class Version_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
Version_template *list_value;
} value_list;
struct {
Version_template* precondition;
Version_template* implied_template;
} implication_;
dynmatch_struct<Version>* dyn_match;
};

void set_specific();
void copy_value(const Version& other_value);
void copy_template(const Version_template& other_value);

public:
Version_template();
Version_template(template_sel other_value);
Version_template(const Version& other_value);
Version_template(const OPTIONAL<Version>& other_value);
Version_template(Version_template* p_precondition, Version_template* p_implied_template);
Version_template(Dynamic_Match_Interface<Version>* p_dyn_match);
Version_template(const Version_template& other_value);
~Version_template();
Version_template& operator=(template_sel other_value);
Version_template& operator=(const Version& other_value);
Version_template& operator=(const OPTIONAL<Version>& other_value);
Version_template& operator=(const Version_template& other_value);
boolean match(const Version& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
Version valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
Version_template& list_item(unsigned int list_index) const;
INTEGER_template& version__value();
const INTEGER_template& version__value() const;
BITSTRING_template& spare();
const BITSTRING_template& spare() const;
int size_of() const;
void log() const;
void log_match(const Version& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class T200 : public Base_Type {
  BITSTRING field_spare;
  INTEGER field_t200Value;
public:
  T200();
  T200(const BITSTRING& par_spare,
    const INTEGER& par_t200Value);
  T200(const T200& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  T200& operator=(const T200& other_value);
  boolean operator==(const T200& other_value) const;
  inline boolean operator!=(const T200& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline BITSTRING& spare()
    {return field_spare;}
  inline const BITSTRING& spare() const
    {return field_spare;}
  inline INTEGER& t200Value()
    {return field_t200Value;}
  inline const INTEGER& t200Value() const
    {return field_t200Value;}
  inline int size_of() const
    {return 2;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class T200_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
T200_template *list_value;
} value_list;
struct {
T200_template* precondition;
T200_template* implied_template;
} implication_;
dynmatch_struct<T200>* dyn_match;
};

void set_specific();
void copy_value(const T200& other_value);
void copy_template(const T200_template& other_value);

public:
T200_template();
T200_template(template_sel other_value);
T200_template(const T200& other_value);
T200_template(const OPTIONAL<T200>& other_value);
T200_template(T200_template* p_precondition, T200_template* p_implied_template);
T200_template(Dynamic_Match_Interface<T200>* p_dyn_match);
T200_template(const T200_template& other_value);
~T200_template();
T200_template& operator=(template_sel other_value);
T200_template& operator=(const T200& other_value);
T200_template& operator=(const OPTIONAL<T200>& other_value);
T200_template& operator=(const T200_template& other_value);
boolean match(const T200& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
T200 valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
T200_template& list_item(unsigned int list_index) const;
BITSTRING_template& spare();
const BITSTRING_template& spare() const;
INTEGER_template& t200Value();
const INTEGER_template& t200Value() const;
int size_of() const;
void log() const;
void log_match(const T200& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class N200 : public Base_Type {
  INTEGER field_retransmissions;
  BITSTRING field_spare;
public:
  N200();
  N200(const INTEGER& par_retransmissions,
    const BITSTRING& par_spare);
  N200(const N200& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  N200& operator=(const N200& other_value);
  boolean operator==(const N200& other_value) const;
  inline boolean operator!=(const N200& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline INTEGER& retransmissions()
    {return field_retransmissions;}
  inline const INTEGER& retransmissions() const
    {return field_retransmissions;}
  inline BITSTRING& spare()
    {return field_spare;}
  inline const BITSTRING& spare() const
    {return field_spare;}
  inline int size_of() const
    {return 2;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class N200_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
N200_template *list_value;
} value_list;
struct {
N200_template* precondition;
N200_template* implied_template;
} implication_;
dynmatch_struct<N200>* dyn_match;
};

void set_specific();
void copy_value(const N200& other_value);
void copy_template(const N200_template& other_value);

public:
N200_template();
N200_template(template_sel other_value);
N200_template(const N200& other_value);
N200_template(const OPTIONAL<N200>& other_value);
N200_template(N200_template* p_precondition, N200_template* p_implied_template);
N200_template(Dynamic_Match_Interface<N200>* p_dyn_match);
N200_template(const N200_template& other_value);
~N200_template();
N200_template& operator=(template_sel other_value);
N200_template& operator=(const N200& other_value);
N200_template& operator=(const OPTIONAL<N200>& other_value);
N200_template& operator=(const N200_template& other_value);
boolean match(const N200& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
N200 valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
N200_template& list_item(unsigned int list_index) const;
INTEGER_template& retransmissions();
const INTEGER_template& retransmissions() const;
BITSTRING_template& spare();
const BITSTRING_template& spare() const;
int size_of() const;
void log() const;
void log_match(const N200& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class N201__U : public Base_Type {
  BITSTRING field_spare;
  INTEGER field_n201UValue;
public:
  N201__U();
  N201__U(const BITSTRING& par_spare,
    const INTEGER& par_n201UValue);
  N201__U(const N201__U& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  N201__U& operator=(const N201__U& other_value);
  boolean operator==(const N201__U& other_value) const;
  inline boolean operator!=(const N201__U& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline BITSTRING& spare()
    {return field_spare;}
  inline const BITSTRING& spare() const
    {return field_spare;}
  inline INTEGER& n201UValue()
    {return field_n201UValue;}
  inline const INTEGER& n201UValue() const
    {return field_n201UValue;}
  inline int size_of() const
    {return 2;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class N201__U_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
N201__U_template *list_value;
} value_list;
struct {
N201__U_template* precondition;
N201__U_template* implied_template;
} implication_;
dynmatch_struct<N201__U>* dyn_match;
};

void set_specific();
void copy_value(const N201__U& other_value);
void copy_template(const N201__U_template& other_value);

public:
N201__U_template();
N201__U_template(template_sel other_value);
N201__U_template(const N201__U& other_value);
N201__U_template(const OPTIONAL<N201__U>& other_value);
N201__U_template(N201__U_template* p_precondition, N201__U_template* p_implied_template);
N201__U_template(Dynamic_Match_Interface<N201__U>* p_dyn_match);
N201__U_template(const N201__U_template& other_value);
~N201__U_template();
N201__U_template& operator=(template_sel other_value);
N201__U_template& operator=(const N201__U& other_value);
N201__U_template& operator=(const OPTIONAL<N201__U>& other_value);
N201__U_template& operator=(const N201__U_template& other_value);
boolean match(const N201__U& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
N201__U valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
N201__U_template& list_item(unsigned int list_index) const;
BITSTRING_template& spare();
const BITSTRING_template& spare() const;
INTEGER_template& n201UValue();
const INTEGER_template& n201UValue() const;
int size_of() const;
void log() const;
void log_match(const N201__U& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class N201__I : public Base_Type {
  BITSTRING field_spare;
  INTEGER field_n201IValue;
public:
  N201__I();
  N201__I(const BITSTRING& par_spare,
    const INTEGER& par_n201IValue);
  N201__I(const N201__I& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  N201__I& operator=(const N201__I& other_value);
  boolean operator==(const N201__I& other_value) const;
  inline boolean operator!=(const N201__I& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline BITSTRING& spare()
    {return field_spare;}
  inline const BITSTRING& spare() const
    {return field_spare;}
  inline INTEGER& n201IValue()
    {return field_n201IValue;}
  inline const INTEGER& n201IValue() const
    {return field_n201IValue;}
  inline int size_of() const
    {return 2;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class N201__I_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
N201__I_template *list_value;
} value_list;
struct {
N201__I_template* precondition;
N201__I_template* implied_template;
} implication_;
dynmatch_struct<N201__I>* dyn_match;
};

void set_specific();
void copy_value(const N201__I& other_value);
void copy_template(const N201__I_template& other_value);

public:
N201__I_template();
N201__I_template(template_sel other_value);
N201__I_template(const N201__I& other_value);
N201__I_template(const OPTIONAL<N201__I>& other_value);
N201__I_template(N201__I_template* p_precondition, N201__I_template* p_implied_template);
N201__I_template(Dynamic_Match_Interface<N201__I>* p_dyn_match);
N201__I_template(const N201__I_template& other_value);
~N201__I_template();
N201__I_template& operator=(template_sel other_value);
N201__I_template& operator=(const N201__I& other_value);
N201__I_template& operator=(const OPTIONAL<N201__I>& other_value);
N201__I_template& operator=(const N201__I_template& other_value);
boolean match(const N201__I& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
N201__I valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
N201__I_template& list_item(unsigned int list_index) const;
BITSTRING_template& spare();
const BITSTRING_template& spare() const;
INTEGER_template& n201IValue();
const INTEGER_template& n201IValue() const;
int size_of() const;
void log() const;
void log_match(const N201__I& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class MD : public Base_Type {
  BITSTRING field_spare;
  INTEGER field_mDValue;
public:
  MD();
  MD(const BITSTRING& par_spare,
    const INTEGER& par_mDValue);
  MD(const MD& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  MD& operator=(const MD& other_value);
  boolean operator==(const MD& other_value) const;
  inline boolean operator!=(const MD& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline BITSTRING& spare()
    {return field_spare;}
  inline const BITSTRING& spare() const
    {return field_spare;}
  inline INTEGER& mDValue()
    {return field_mDValue;}
  inline const INTEGER& mDValue() const
    {return field_mDValue;}
  inline int size_of() const
    {return 2;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class MD_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
MD_template *list_value;
} value_list;
struct {
MD_template* precondition;
MD_template* implied_template;
} implication_;
dynmatch_struct<MD>* dyn_match;
};

void set_specific();
void copy_value(const MD& other_value);
void copy_template(const MD_template& other_value);

public:
MD_template();
MD_template(template_sel other_value);
MD_template(const MD& other_value);
MD_template(const OPTIONAL<MD>& other_value);
MD_template(MD_template* p_precondition, MD_template* p_implied_template);
MD_template(Dynamic_Match_Interface<MD>* p_dyn_match);
MD_template(const MD_template& other_value);
~MD_template();
MD_template& operator=(template_sel other_value);
MD_template& operator=(const MD& other_value);
MD_template& operator=(const OPTIONAL<MD>& other_value);
MD_template& operator=(const MD_template& other_value);
boolean match(const MD& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
MD valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
MD_template& list_item(unsigned int list_index) const;
BITSTRING_template& spare();
const BITSTRING_template& spare() const;
INTEGER_template& mDValue();
const INTEGER_template& mDValue() const;
int size_of() const;
void log() const;
void log_match(const MD& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class MU : public Base_Type {
  BITSTRING field_spare;
  INTEGER field_mUValue;
public:
  MU();
  MU(const BITSTRING& par_spare,
    const INTEGER& par_mUValue);
  MU(const MU& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  MU& operator=(const MU& other_value);
  boolean operator==(const MU& other_value) const;
  inline boolean operator!=(const MU& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline BITSTRING& spare()
    {return field_spare;}
  inline const BITSTRING& spare() const
    {return field_spare;}
  inline INTEGER& mUValue()
    {return field_mUValue;}
  inline const INTEGER& mUValue() const
    {return field_mUValue;}
  inline int size_of() const
    {return 2;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class MU_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
MU_template *list_value;
} value_list;
struct {
MU_template* precondition;
MU_template* implied_template;
} implication_;
dynmatch_struct<MU>* dyn_match;
};

void set_specific();
void copy_value(const MU& other_value);
void copy_template(const MU_template& other_value);

public:
MU_template();
MU_template(template_sel other_value);
MU_template(const MU& other_value);
MU_template(const OPTIONAL<MU>& other_value);
MU_template(MU_template* p_precondition, MU_template* p_implied_template);
MU_template(Dynamic_Match_Interface<MU>* p_dyn_match);
MU_template(const MU_template& other_value);
~MU_template();
MU_template& operator=(template_sel other_value);
MU_template& operator=(const MU& other_value);
MU_template& operator=(const OPTIONAL<MU>& other_value);
MU_template& operator=(const MU_template& other_value);
boolean match(const MU& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
MU valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
MU_template& list_item(unsigned int list_index) const;
BITSTRING_template& spare();
const BITSTRING_template& spare() const;
INTEGER_template& mUValue();
const INTEGER_template& mUValue() const;
int size_of() const;
void log() const;
void log_match(const MU& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class XID__Data : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_version = 1, ALT_iOV__UI = 2, ALT_iOV__I = 3, ALT_t200 = 4, ALT_n200 = 5, ALT_n201__U = 6, ALT_n201__I = 7, ALT_mD = 8, ALT_mU = 9, ALT_kD = 10, ALT_kU = 11, ALT_l3param = 12, ALT_reset = 13 };
private:
union_selection_type union_selection;
union {
Version *field_version;
OCTETSTRING *field_iOV__UI;
OCTETSTRING *field_iOV__I;
T200 *field_t200;
N200 *field_n200;
N201__U *field_n201__U;
N201__I *field_n201__I;
MD *field_mD;
MU *field_mU;
INTEGER *field_kD;
INTEGER *field_kU;
OCTETSTRING *field_l3param;
OCTETSTRING *field_reset;
};
void copy_value(const XID__Data& other_value);

public:
XID__Data();
XID__Data(const XID__Data& other_value);
~XID__Data();
XID__Data& operator=(const XID__Data& other_value);
boolean operator==(const XID__Data& other_value) const;
inline boolean operator!=(const XID__Data& other_value) const { return !(*this == other_value); }
Version& version();
const Version& version() const;
OCTETSTRING& iOV__UI();
const OCTETSTRING& iOV__UI() const;
OCTETSTRING& iOV__I();
const OCTETSTRING& iOV__I() const;
T200& t200();
const T200& t200() const;
N200& n200();
const N200& n200() const;
N201__U& n201__U();
const N201__U& n201__U() const;
N201__I& n201__I();
const N201__I& n201__I() const;
MD& mD();
const MD& mD() const;
MU& mU();
const MU& mU() const;
INTEGER& kD();
const INTEGER& kD() const;
INTEGER& kU();
const INTEGER& kU() const;
OCTETSTRING& l3param();
const OCTETSTRING& l3param() const;
OCTETSTRING& reset();
const OCTETSTRING& reset() const;
inline union_selection_type get_selection() const { return union_selection; }
boolean ischosen(union_selection_type checked_selection) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
inline boolean is_present() const { return is_bound(); }
void log() const;
void set_param(Module_Param& param);
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class XID__Data_template : public Base_Template {
union {
struct {
XID__Data::union_selection_type union_selection;
union {
Version_template *field_version;
OCTETSTRING_template *field_iOV__UI;
OCTETSTRING_template *field_iOV__I;
T200_template *field_t200;
N200_template *field_n200;
N201__U_template *field_n201__U;
N201__I_template *field_n201__I;
MD_template *field_mD;
MU_template *field_mU;
INTEGER_template *field_kD;
INTEGER_template *field_kU;
OCTETSTRING_template *field_l3param;
OCTETSTRING_template *field_reset;
};
} single_value;
struct {
unsigned int n_values;
XID__Data_template *list_value;
} value_list;
struct {
XID__Data_template* precondition;
XID__Data_template* implied_template;
} implication_;
dynmatch_struct<XID__Data>* dyn_match;
};
void copy_value(const XID__Data& other_value);

void copy_template(const XID__Data_template& other_value);

public:
XID__Data_template();
XID__Data_template(template_sel other_value);
XID__Data_template(const XID__Data& other_value);
XID__Data_template(const OPTIONAL<XID__Data>& other_value);
XID__Data_template(XID__Data_template* p_precondition, XID__Data_template* p_implied_template);
XID__Data_template(Dynamic_Match_Interface<XID__Data>* p_dyn_match);
XID__Data_template(const XID__Data_template& other_value);
~XID__Data_template();
void clean_up();
XID__Data_template& operator=(template_sel other_value);
XID__Data_template& operator=(const XID__Data& other_value);
XID__Data_template& operator=(const OPTIONAL<XID__Data>& other_value);
XID__Data_template& operator=(const XID__Data_template& other_value);
boolean match(const XID__Data& other_value, boolean legacy = FALSE) const;
boolean is_value() const;XID__Data valueof() const;
XID__Data_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
Version_template& version();
const Version_template& version() const;
OCTETSTRING_template& iOV__UI();
const OCTETSTRING_template& iOV__UI() const;
OCTETSTRING_template& iOV__I();
const OCTETSTRING_template& iOV__I() const;
T200_template& t200();
const T200_template& t200() const;
N200_template& n200();
const N200_template& n200() const;
N201__U_template& n201__U();
const N201__U_template& n201__U() const;
N201__I_template& n201__I();
const N201__I_template& n201__I() const;
MD_template& mD();
const MD_template& mD() const;
MU_template& mU();
const MU_template& mU() const;
INTEGER_template& kD();
const INTEGER_template& kD() const;
INTEGER_template& kU();
const INTEGER_template& kU() const;
OCTETSTRING_template& l3param();
const OCTETSTRING_template& l3param() const;
OCTETSTRING_template& reset();
const OCTETSTRING_template& reset() const;
boolean ischosen(XID__Data::union_selection_type checked_selection) const;
void log() const;
void log_match(const XID__Data& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
};

class XID__length : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_short__len = 1, ALT_long__len = 2 };
private:
union_selection_type union_selection;
union {
INTEGER *field_short__len;
INTEGER *field_long__len;
};
void copy_value(const XID__length& other_value);

public:
XID__length();
XID__length(const XID__length& other_value);
~XID__length();
XID__length& operator=(const XID__length& other_value);
boolean operator==(const XID__length& other_value) const;
inline boolean operator!=(const XID__length& other_value) const { return !(*this == other_value); }
INTEGER& short__len();
const INTEGER& short__len() const;
INTEGER& long__len();
const INTEGER& long__len() const;
inline union_selection_type get_selection() const { return union_selection; }
boolean ischosen(union_selection_type checked_selection) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
inline boolean is_present() const { return is_bound(); }
void log() const;
void set_param(Module_Param& param);
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class XID__length_template : public Base_Template {
union {
struct {
XID__length::union_selection_type union_selection;
union {
INTEGER_template *field_short__len;
INTEGER_template *field_long__len;
};
} single_value;
struct {
unsigned int n_values;
XID__length_template *list_value;
} value_list;
struct {
XID__length_template* precondition;
XID__length_template* implied_template;
} implication_;
dynmatch_struct<XID__length>* dyn_match;
};
void copy_value(const XID__length& other_value);

void copy_template(const XID__length_template& other_value);

public:
XID__length_template();
XID__length_template(template_sel other_value);
XID__length_template(const XID__length& other_value);
XID__length_template(const OPTIONAL<XID__length>& other_value);
XID__length_template(XID__length_template* p_precondition, XID__length_template* p_implied_template);
XID__length_template(Dynamic_Match_Interface<XID__length>* p_dyn_match);
XID__length_template(const XID__length_template& other_value);
~XID__length_template();
void clean_up();
XID__length_template& operator=(template_sel other_value);
XID__length_template& operator=(const XID__length& other_value);
XID__length_template& operator=(const OPTIONAL<XID__length>& other_value);
XID__length_template& operator=(const XID__length_template& other_value);
boolean match(const XID__length& other_value, boolean legacy = FALSE) const;
boolean is_value() const;XID__length valueof() const;
XID__length_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
INTEGER_template& short__len();
const INTEGER_template& short__len() const;
INTEGER_template& long__len();
const INTEGER_template& long__len() const;
boolean ischosen(XID__length::union_selection_type checked_selection) const;
void log() const;
void log_match(const XID__length& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
};

class XID : public Base_Type {
  BITSTRING field_xl;
  BITSTRING field_typefield;
  XID__length field_xID__length;
  XID__Data field_xID__Data;
public:
  XID();
  XID(const BITSTRING& par_xl,
    const BITSTRING& par_typefield,
    const XID__length& par_xID__length,
    const XID__Data& par_xID__Data);
  XID(const XID& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  XID& operator=(const XID& other_value);
  boolean operator==(const XID& other_value) const;
  inline boolean operator!=(const XID& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline BITSTRING& xl()
    {return field_xl;}
  inline const BITSTRING& xl() const
    {return field_xl;}
  inline BITSTRING& typefield()
    {return field_typefield;}
  inline const BITSTRING& typefield() const
    {return field_typefield;}
  inline XID__length& xID__length()
    {return field_xID__length;}
  inline const XID__length& xID__length() const
    {return field_xID__length;}
  inline XID__Data& xID__Data()
    {return field_xID__Data;}
  inline const XID__Data& xID__Data() const
    {return field_xID__Data;}
  inline int size_of() const
    {return 4;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class XID_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
XID_template *list_value;
} value_list;
struct {
XID_template* precondition;
XID_template* implied_template;
} implication_;
dynmatch_struct<XID>* dyn_match;
};

void set_specific();
void copy_value(const XID& other_value);
void copy_template(const XID_template& other_value);

public:
XID_template();
XID_template(template_sel other_value);
XID_template(const XID& other_value);
XID_template(const OPTIONAL<XID>& other_value);
XID_template(XID_template* p_precondition, XID_template* p_implied_template);
XID_template(Dynamic_Match_Interface<XID>* p_dyn_match);
XID_template(const XID_template& other_value);
~XID_template();
XID_template& operator=(template_sel other_value);
XID_template& operator=(const XID& other_value);
XID_template& operator=(const OPTIONAL<XID>& other_value);
XID_template& operator=(const XID_template& other_value);
boolean match(const XID& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
XID valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
XID_template& list_item(unsigned int list_index) const;
BITSTRING_template& xl();
const BITSTRING_template& xl() const;
BITSTRING_template& typefield();
const BITSTRING_template& typefield() const;
XID__length_template& xID__length();
const XID__length_template& xID__length() const;
XID__Data_template& xID__Data();
const XID__Data_template& xID__Data() const;
int size_of() const;
void log() const;
void log_match(const XID& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class Control__field__UI : public Base_Type {
  BITSTRING field_format;
  BITSTRING field_spare;
  INTEGER field_nU;
  BITSTRING field_e;
  BITSTRING field_pM;
public:
  Control__field__UI();
  Control__field__UI(const BITSTRING& par_format,
    const BITSTRING& par_spare,
    const INTEGER& par_nU,
    const BITSTRING& par_e,
    const BITSTRING& par_pM);
  Control__field__UI(const Control__field__UI& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  Control__field__UI& operator=(const Control__field__UI& other_value);
  boolean operator==(const Control__field__UI& other_value) const;
  inline boolean operator!=(const Control__field__UI& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline BITSTRING& format()
    {return field_format;}
  inline const BITSTRING& format() const
    {return field_format;}
  inline BITSTRING& spare()
    {return field_spare;}
  inline const BITSTRING& spare() const
    {return field_spare;}
  inline INTEGER& nU()
    {return field_nU;}
  inline const INTEGER& nU() const
    {return field_nU;}
  inline BITSTRING& e()
    {return field_e;}
  inline const BITSTRING& e() const
    {return field_e;}
  inline BITSTRING& pM()
    {return field_pM;}
  inline const BITSTRING& pM() const
    {return field_pM;}
  inline int size_of() const
    {return 5;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class Control__field__UI_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
Control__field__UI_template *list_value;
} value_list;
struct {
Control__field__UI_template* precondition;
Control__field__UI_template* implied_template;
} implication_;
dynmatch_struct<Control__field__UI>* dyn_match;
};

void set_specific();
void copy_value(const Control__field__UI& other_value);
void copy_template(const Control__field__UI_template& other_value);

public:
Control__field__UI_template();
Control__field__UI_template(template_sel other_value);
Control__field__UI_template(const Control__field__UI& other_value);
Control__field__UI_template(const OPTIONAL<Control__field__UI>& other_value);
Control__field__UI_template(Control__field__UI_template* p_precondition, Control__field__UI_template* p_implied_template);
Control__field__UI_template(Dynamic_Match_Interface<Control__field__UI>* p_dyn_match);
Control__field__UI_template(const Control__field__UI_template& other_value);
~Control__field__UI_template();
Control__field__UI_template& operator=(template_sel other_value);
Control__field__UI_template& operator=(const Control__field__UI& other_value);
Control__field__UI_template& operator=(const OPTIONAL<Control__field__UI>& other_value);
Control__field__UI_template& operator=(const Control__field__UI_template& other_value);
boolean match(const Control__field__UI& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
Control__field__UI valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
Control__field__UI_template& list_item(unsigned int list_index) const;
BITSTRING_template& format();
const BITSTRING_template& format() const;
BITSTRING_template& spare();
const BITSTRING_template& spare() const;
INTEGER_template& nU();
const INTEGER_template& nU() const;
BITSTRING_template& e();
const BITSTRING_template& e() const;
BITSTRING_template& pM();
const BITSTRING_template& pM() const;
int size_of() const;
void log() const;
void log_match(const Control__field__UI& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class RejectedFrameControlField__UI : public Base_Type {
  Control__field__UI field_control__field;
  OCTETSTRING field_spare;
public:
  RejectedFrameControlField__UI();
  RejectedFrameControlField__UI(const Control__field__UI& par_control__field,
    const OCTETSTRING& par_spare);
  RejectedFrameControlField__UI(const RejectedFrameControlField__UI& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RejectedFrameControlField__UI& operator=(const RejectedFrameControlField__UI& other_value);
  boolean operator==(const RejectedFrameControlField__UI& other_value) const;
  inline boolean operator!=(const RejectedFrameControlField__UI& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline Control__field__UI& control__field()
    {return field_control__field;}
  inline const Control__field__UI& control__field() const
    {return field_control__field;}
  inline OCTETSTRING& spare()
    {return field_spare;}
  inline const OCTETSTRING& spare() const
    {return field_spare;}
  inline int size_of() const
    {return 2;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class RejectedFrameControlField__UI_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RejectedFrameControlField__UI_template *list_value;
} value_list;
struct {
RejectedFrameControlField__UI_template* precondition;
RejectedFrameControlField__UI_template* implied_template;
} implication_;
dynmatch_struct<RejectedFrameControlField__UI>* dyn_match;
};

void set_specific();
void copy_value(const RejectedFrameControlField__UI& other_value);
void copy_template(const RejectedFrameControlField__UI_template& other_value);

public:
RejectedFrameControlField__UI_template();
RejectedFrameControlField__UI_template(template_sel other_value);
RejectedFrameControlField__UI_template(const RejectedFrameControlField__UI& other_value);
RejectedFrameControlField__UI_template(const OPTIONAL<RejectedFrameControlField__UI>& other_value);
RejectedFrameControlField__UI_template(RejectedFrameControlField__UI_template* p_precondition, RejectedFrameControlField__UI_template* p_implied_template);
RejectedFrameControlField__UI_template(Dynamic_Match_Interface<RejectedFrameControlField__UI>* p_dyn_match);
RejectedFrameControlField__UI_template(const RejectedFrameControlField__UI_template& other_value);
~RejectedFrameControlField__UI_template();
RejectedFrameControlField__UI_template& operator=(template_sel other_value);
RejectedFrameControlField__UI_template& operator=(const RejectedFrameControlField__UI& other_value);
RejectedFrameControlField__UI_template& operator=(const OPTIONAL<RejectedFrameControlField__UI>& other_value);
RejectedFrameControlField__UI_template& operator=(const RejectedFrameControlField__UI_template& other_value);
boolean match(const RejectedFrameControlField__UI& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
RejectedFrameControlField__UI valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RejectedFrameControlField__UI_template& list_item(unsigned int list_index) const;
Control__field__UI_template& control__field();
const Control__field__UI_template& control__field() const;
OCTETSTRING_template& spare();
const OCTETSTRING_template& spare() const;
int size_of() const;
void log() const;
void log_match(const RejectedFrameControlField__UI& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class Control__field__U : public Base_Type {
  BITSTRING field_mBits;
  BITSTRING field_pF;
  BITSTRING field_format;
public:
  Control__field__U();
  Control__field__U(const BITSTRING& par_mBits,
    const BITSTRING& par_pF,
    const BITSTRING& par_format);
  Control__field__U(const Control__field__U& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  Control__field__U& operator=(const Control__field__U& other_value);
  boolean operator==(const Control__field__U& other_value) const;
  inline boolean operator!=(const Control__field__U& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline BITSTRING& mBits()
    {return field_mBits;}
  inline const BITSTRING& mBits() const
    {return field_mBits;}
  inline BITSTRING& pF()
    {return field_pF;}
  inline const BITSTRING& pF() const
    {return field_pF;}
  inline BITSTRING& format()
    {return field_format;}
  inline const BITSTRING& format() const
    {return field_format;}
  inline int size_of() const
    {return 3;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class Control__field__U_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
Control__field__U_template *list_value;
} value_list;
struct {
Control__field__U_template* precondition;
Control__field__U_template* implied_template;
} implication_;
dynmatch_struct<Control__field__U>* dyn_match;
};

void set_specific();
void copy_value(const Control__field__U& other_value);
void copy_template(const Control__field__U_template& other_value);

public:
Control__field__U_template();
Control__field__U_template(template_sel other_value);
Control__field__U_template(const Control__field__U& other_value);
Control__field__U_template(const OPTIONAL<Control__field__U>& other_value);
Control__field__U_template(Control__field__U_template* p_precondition, Control__field__U_template* p_implied_template);
Control__field__U_template(Dynamic_Match_Interface<Control__field__U>* p_dyn_match);
Control__field__U_template(const Control__field__U_template& other_value);
~Control__field__U_template();
Control__field__U_template& operator=(template_sel other_value);
Control__field__U_template& operator=(const Control__field__U& other_value);
Control__field__U_template& operator=(const OPTIONAL<Control__field__U>& other_value);
Control__field__U_template& operator=(const Control__field__U_template& other_value);
boolean match(const Control__field__U& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
Control__field__U valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
Control__field__U_template& list_item(unsigned int list_index) const;
BITSTRING_template& mBits();
const BITSTRING_template& mBits() const;
BITSTRING_template& pF();
const BITSTRING_template& pF() const;
BITSTRING_template& format();
const BITSTRING_template& format() const;
int size_of() const;
void log() const;
void log_match(const Control__field__U& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class RejectedFrameControlField__U : public Base_Type {
  Control__field__U field_control__field;
  OCTETSTRING field_spare;
public:
  RejectedFrameControlField__U();
  RejectedFrameControlField__U(const Control__field__U& par_control__field,
    const OCTETSTRING& par_spare);
  RejectedFrameControlField__U(const RejectedFrameControlField__U& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RejectedFrameControlField__U& operator=(const RejectedFrameControlField__U& other_value);
  boolean operator==(const RejectedFrameControlField__U& other_value) const;
  inline boolean operator!=(const RejectedFrameControlField__U& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline Control__field__U& control__field()
    {return field_control__field;}
  inline const Control__field__U& control__field() const
    {return field_control__field;}
  inline OCTETSTRING& spare()
    {return field_spare;}
  inline const OCTETSTRING& spare() const
    {return field_spare;}
  inline int size_of() const
    {return 2;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class RejectedFrameControlField__U_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RejectedFrameControlField__U_template *list_value;
} value_list;
struct {
RejectedFrameControlField__U_template* precondition;
RejectedFrameControlField__U_template* implied_template;
} implication_;
dynmatch_struct<RejectedFrameControlField__U>* dyn_match;
};

void set_specific();
void copy_value(const RejectedFrameControlField__U& other_value);
void copy_template(const RejectedFrameControlField__U_template& other_value);

public:
RejectedFrameControlField__U_template();
RejectedFrameControlField__U_template(template_sel other_value);
RejectedFrameControlField__U_template(const RejectedFrameControlField__U& other_value);
RejectedFrameControlField__U_template(const OPTIONAL<RejectedFrameControlField__U>& other_value);
RejectedFrameControlField__U_template(RejectedFrameControlField__U_template* p_precondition, RejectedFrameControlField__U_template* p_implied_template);
RejectedFrameControlField__U_template(Dynamic_Match_Interface<RejectedFrameControlField__U>* p_dyn_match);
RejectedFrameControlField__U_template(const RejectedFrameControlField__U_template& other_value);
~RejectedFrameControlField__U_template();
RejectedFrameControlField__U_template& operator=(template_sel other_value);
RejectedFrameControlField__U_template& operator=(const RejectedFrameControlField__U& other_value);
RejectedFrameControlField__U_template& operator=(const OPTIONAL<RejectedFrameControlField__U>& other_value);
RejectedFrameControlField__U_template& operator=(const RejectedFrameControlField__U_template& other_value);
boolean match(const RejectedFrameControlField__U& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
RejectedFrameControlField__U valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RejectedFrameControlField__U_template& list_item(unsigned int list_index) const;
Control__field__U_template& control__field();
const Control__field__U_template& control__field() const;
OCTETSTRING_template& spare();
const OCTETSTRING_template& spare() const;
int size_of() const;
void log() const;
void log_match(const RejectedFrameControlField__U& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class RejectedFrameControlField : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_rejectedFrameControlField__UI = 1, ALT_rejectedFrameControlField__U = 2 };
private:
union_selection_type union_selection;
union {
RejectedFrameControlField__UI *field_rejectedFrameControlField__UI;
RejectedFrameControlField__U *field_rejectedFrameControlField__U;
};
void copy_value(const RejectedFrameControlField& other_value);

public:
RejectedFrameControlField();
RejectedFrameControlField(const RejectedFrameControlField& other_value);
~RejectedFrameControlField();
RejectedFrameControlField& operator=(const RejectedFrameControlField& other_value);
boolean operator==(const RejectedFrameControlField& other_value) const;
inline boolean operator!=(const RejectedFrameControlField& other_value) const { return !(*this == other_value); }
RejectedFrameControlField__UI& rejectedFrameControlField__UI();
const RejectedFrameControlField__UI& rejectedFrameControlField__UI() const;
RejectedFrameControlField__U& rejectedFrameControlField__U();
const RejectedFrameControlField__U& rejectedFrameControlField__U() const;
inline union_selection_type get_selection() const { return union_selection; }
boolean ischosen(union_selection_type checked_selection) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
inline boolean is_present() const { return is_bound(); }
void log() const;
void set_param(Module_Param& param);
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class RejectedFrameControlField_template : public Base_Template {
union {
struct {
RejectedFrameControlField::union_selection_type union_selection;
union {
RejectedFrameControlField__UI_template *field_rejectedFrameControlField__UI;
RejectedFrameControlField__U_template *field_rejectedFrameControlField__U;
};
} single_value;
struct {
unsigned int n_values;
RejectedFrameControlField_template *list_value;
} value_list;
struct {
RejectedFrameControlField_template* precondition;
RejectedFrameControlField_template* implied_template;
} implication_;
dynmatch_struct<RejectedFrameControlField>* dyn_match;
};
void copy_value(const RejectedFrameControlField& other_value);

void copy_template(const RejectedFrameControlField_template& other_value);

public:
RejectedFrameControlField_template();
RejectedFrameControlField_template(template_sel other_value);
RejectedFrameControlField_template(const RejectedFrameControlField& other_value);
RejectedFrameControlField_template(const OPTIONAL<RejectedFrameControlField>& other_value);
RejectedFrameControlField_template(RejectedFrameControlField_template* p_precondition, RejectedFrameControlField_template* p_implied_template);
RejectedFrameControlField_template(Dynamic_Match_Interface<RejectedFrameControlField>* p_dyn_match);
RejectedFrameControlField_template(const RejectedFrameControlField_template& other_value);
~RejectedFrameControlField_template();
void clean_up();
RejectedFrameControlField_template& operator=(template_sel other_value);
RejectedFrameControlField_template& operator=(const RejectedFrameControlField& other_value);
RejectedFrameControlField_template& operator=(const OPTIONAL<RejectedFrameControlField>& other_value);
RejectedFrameControlField_template& operator=(const RejectedFrameControlField_template& other_value);
boolean match(const RejectedFrameControlField& other_value, boolean legacy = FALSE) const;
boolean is_value() const;RejectedFrameControlField valueof() const;
RejectedFrameControlField_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
RejectedFrameControlField__UI_template& rejectedFrameControlField__UI();
const RejectedFrameControlField__UI_template& rejectedFrameControlField__UI() const;
RejectedFrameControlField__U_template& rejectedFrameControlField__U();
const RejectedFrameControlField__U_template& rejectedFrameControlField__U() const;
boolean ischosen(RejectedFrameControlField::union_selection_type checked_selection) const;
void log() const;
void log_match(const RejectedFrameControlField& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
};

class UA__Information : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
XID **value_elements;
} *val_ptr;

static const XID UNBOUND_ELEM;
private:
friend boolean operator==(null_type null_value, const UA__Information& other_value);

public:
  typedef XID of_type;
UA__Information();
UA__Information(null_type other_value);
UA__Information(const UA__Information& other_value);
~UA__Information();

void clean_up();
UA__Information& operator=(null_type other_value);
UA__Information& operator=(const UA__Information& other_value);

boolean operator==(null_type other_value) const;
boolean operator==(const UA__Information& other_value) const;
inline boolean operator!=(null_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const UA__Information& other_value) const { return !(*this == other_value); }

XID& operator[](int index_value);
XID& operator[](const INTEGER& index_value);
const XID& operator[](int index_value) const;
const XID& operator[](const INTEGER& index_value) const;

UA__Information operator<<=(int rotate_count) const;
UA__Information operator<<=(const INTEGER& rotate_count) const;
UA__Information operator>>=(int rotate_count) const;
UA__Information operator>>=(const INTEGER& rotate_count) const;

UA__Information operator+(const UA__Information& other_value) const;

UA__Information substr(int index, int returncount) const;

UA__Information replace(int index, int len, const UA__Information& repl) const;

UA__Information replace(int index, int len, const UA__Information_template& repl) const;

void set_size(int new_size);
inline boolean is_bound() const {return val_ptr != NULL; }
inline boolean is_present() const { return is_bound(); }
boolean is_value() const;
int size_of() const;
int n_elem() const { return size_of(); }
int lengthof() const;
void log() const;
  void set_implicit_omit();
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class UA__Information_template : public Base_Record_Of_Template {
union {
struct {
int n_elements;
XID_template **value_elements;
} single_value;
struct {
unsigned int n_values;
UA__Information_template *list_value;
} value_list;
struct {
UA__Information_template* precondition;
UA__Information_template* implied_template;
} implication_;
dynmatch_struct<UA__Information>* dyn_match;
};
void copy_value(const UA__Information& other_value);
void copy_template(const UA__Information_template& other_value);
static boolean match_function_specific(const Base_Type *value_ptr, int value_index, const Restricted_Length_Template *template_ptr, int template_index, boolean legacy);

public:
UA__Information_template();
UA__Information_template(template_sel other_value);
UA__Information_template(null_type other_value);
UA__Information_template(const UA__Information& other_value);
UA__Information_template(const OPTIONAL<UA__Information>& other_value);
UA__Information_template(UA__Information_template* p_precondition, UA__Information_template* p_implied_template);
UA__Information_template(Dynamic_Match_Interface<UA__Information>* p_dyn_match);
UA__Information_template(const UA__Information_template& other_value);
~UA__Information_template();

void clean_up();
UA__Information_template& operator=(template_sel other_value);
UA__Information_template& operator=(null_type other_value);
UA__Information_template& operator=(const UA__Information& other_value);
UA__Information_template& operator=(const OPTIONAL<UA__Information>& other_value);
UA__Information_template& operator=(const UA__Information_template& other_value);

XID_template& operator[](int index_value);
XID_template& operator[](const INTEGER& index_value);
const XID_template& operator[](int index_value) const;
const XID_template& operator[](const INTEGER& index_value) const;

void set_size(int new_size);
int n_elem() const;
int size_of(boolean is_size) const;
inline int size_of() const { return size_of(TRUE); }
inline int lengthof() const { return size_of(FALSE); }
boolean match(const UA__Information& other_value, boolean legacy = FALSE) const;
inline boolean is_bound() const 
  {return template_selection != UNINITIALIZED_TEMPLATE; }
boolean is_value() const;
UA__Information valueof() const;
UA__Information substr(int index, int returncount) const;

UA__Information replace(int index, int len, const UA__Information_template& repl) const;

UA__Information replace(int index, int len, const UA__Information& repl) const;

void set_type(template_sel template_type, unsigned int list_length);
UA__Information_template& list_item(unsigned int list_index);
void log() const;
void log_match(const UA__Information& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean get_istemplate_kind(const char* type) const;
};

class SABM__Information : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
XID **value_elements;
} *val_ptr;

static const XID UNBOUND_ELEM;
private:
friend boolean operator==(null_type null_value, const SABM__Information& other_value);

public:
  typedef XID of_type;
SABM__Information();
SABM__Information(null_type other_value);
SABM__Information(const SABM__Information& other_value);
~SABM__Information();

void clean_up();
SABM__Information& operator=(null_type other_value);
SABM__Information& operator=(const SABM__Information& other_value);

boolean operator==(null_type other_value) const;
boolean operator==(const SABM__Information& other_value) const;
inline boolean operator!=(null_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const SABM__Information& other_value) const { return !(*this == other_value); }

XID& operator[](int index_value);
XID& operator[](const INTEGER& index_value);
const XID& operator[](int index_value) const;
const XID& operator[](const INTEGER& index_value) const;

SABM__Information operator<<=(int rotate_count) const;
SABM__Information operator<<=(const INTEGER& rotate_count) const;
SABM__Information operator>>=(int rotate_count) const;
SABM__Information operator>>=(const INTEGER& rotate_count) const;

SABM__Information operator+(const SABM__Information& other_value) const;

SABM__Information substr(int index, int returncount) const;

SABM__Information replace(int index, int len, const SABM__Information& repl) const;

SABM__Information replace(int index, int len, const SABM__Information_template& repl) const;

void set_size(int new_size);
inline boolean is_bound() const {return val_ptr != NULL; }
inline boolean is_present() const { return is_bound(); }
boolean is_value() const;
int size_of() const;
int n_elem() const { return size_of(); }
int lengthof() const;
void log() const;
  void set_implicit_omit();
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class SABM__Information_template : public Base_Record_Of_Template {
union {
struct {
int n_elements;
XID_template **value_elements;
} single_value;
struct {
unsigned int n_values;
SABM__Information_template *list_value;
} value_list;
struct {
SABM__Information_template* precondition;
SABM__Information_template* implied_template;
} implication_;
dynmatch_struct<SABM__Information>* dyn_match;
};
void copy_value(const SABM__Information& other_value);
void copy_template(const SABM__Information_template& other_value);
static boolean match_function_specific(const Base_Type *value_ptr, int value_index, const Restricted_Length_Template *template_ptr, int template_index, boolean legacy);

public:
SABM__Information_template();
SABM__Information_template(template_sel other_value);
SABM__Information_template(null_type other_value);
SABM__Information_template(const SABM__Information& other_value);
SABM__Information_template(const OPTIONAL<SABM__Information>& other_value);
SABM__Information_template(SABM__Information_template* p_precondition, SABM__Information_template* p_implied_template);
SABM__Information_template(Dynamic_Match_Interface<SABM__Information>* p_dyn_match);
SABM__Information_template(const SABM__Information_template& other_value);
~SABM__Information_template();

void clean_up();
SABM__Information_template& operator=(template_sel other_value);
SABM__Information_template& operator=(null_type other_value);
SABM__Information_template& operator=(const SABM__Information& other_value);
SABM__Information_template& operator=(const OPTIONAL<SABM__Information>& other_value);
SABM__Information_template& operator=(const SABM__Information_template& other_value);

XID_template& operator[](int index_value);
XID_template& operator[](const INTEGER& index_value);
const XID_template& operator[](int index_value) const;
const XID_template& operator[](const INTEGER& index_value) const;

void set_size(int new_size);
int n_elem() const;
int size_of(boolean is_size) const;
inline int size_of() const { return size_of(TRUE); }
inline int lengthof() const { return size_of(FALSE); }
boolean match(const SABM__Information& other_value, boolean legacy = FALSE) const;
inline boolean is_bound() const 
  {return template_selection != UNINITIALIZED_TEMPLATE; }
boolean is_value() const;
SABM__Information valueof() const;
SABM__Information substr(int index, int returncount) const;

SABM__Information replace(int index, int len, const SABM__Information_template& repl) const;

SABM__Information replace(int index, int len, const SABM__Information& repl) const;

void set_type(template_sel template_type, unsigned int list_length);
SABM__Information_template& list_item(unsigned int list_index);
void log() const;
void log_match(const SABM__Information& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean get_istemplate_kind(const char* type) const;
};

class XID__Information : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
XID **value_elements;
} *val_ptr;

static const XID UNBOUND_ELEM;
private:
friend boolean operator==(null_type null_value, const XID__Information& other_value);

public:
  typedef XID of_type;
XID__Information();
XID__Information(null_type other_value);
XID__Information(const XID__Information& other_value);
~XID__Information();

void clean_up();
XID__Information& operator=(null_type other_value);
XID__Information& operator=(const XID__Information& other_value);

boolean operator==(null_type other_value) const;
boolean operator==(const XID__Information& other_value) const;
inline boolean operator!=(null_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const XID__Information& other_value) const { return !(*this == other_value); }

XID& operator[](int index_value);
XID& operator[](const INTEGER& index_value);
const XID& operator[](int index_value) const;
const XID& operator[](const INTEGER& index_value) const;

XID__Information operator<<=(int rotate_count) const;
XID__Information operator<<=(const INTEGER& rotate_count) const;
XID__Information operator>>=(int rotate_count) const;
XID__Information operator>>=(const INTEGER& rotate_count) const;

XID__Information operator+(const XID__Information& other_value) const;

XID__Information substr(int index, int returncount) const;

XID__Information replace(int index, int len, const XID__Information& repl) const;

XID__Information replace(int index, int len, const XID__Information_template& repl) const;

void set_size(int new_size);
inline boolean is_bound() const {return val_ptr != NULL; }
inline boolean is_present() const { return is_bound(); }
boolean is_value() const;
int size_of() const;
int n_elem() const { return size_of(); }
int lengthof() const;
void log() const;
  void set_implicit_omit();
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class XID__Information_template : public Base_Record_Of_Template {
union {
struct {
int n_elements;
XID_template **value_elements;
} single_value;
struct {
unsigned int n_values;
XID__Information_template *list_value;
} value_list;
struct {
XID__Information_template* precondition;
XID__Information_template* implied_template;
} implication_;
dynmatch_struct<XID__Information>* dyn_match;
};
void copy_value(const XID__Information& other_value);
void copy_template(const XID__Information_template& other_value);
static boolean match_function_specific(const Base_Type *value_ptr, int value_index, const Restricted_Length_Template *template_ptr, int template_index, boolean legacy);

public:
XID__Information_template();
XID__Information_template(template_sel other_value);
XID__Information_template(null_type other_value);
XID__Information_template(const XID__Information& other_value);
XID__Information_template(const OPTIONAL<XID__Information>& other_value);
XID__Information_template(XID__Information_template* p_precondition, XID__Information_template* p_implied_template);
XID__Information_template(Dynamic_Match_Interface<XID__Information>* p_dyn_match);
XID__Information_template(const XID__Information_template& other_value);
~XID__Information_template();

void clean_up();
XID__Information_template& operator=(template_sel other_value);
XID__Information_template& operator=(null_type other_value);
XID__Information_template& operator=(const XID__Information& other_value);
XID__Information_template& operator=(const OPTIONAL<XID__Information>& other_value);
XID__Information_template& operator=(const XID__Information_template& other_value);

XID_template& operator[](int index_value);
XID_template& operator[](const INTEGER& index_value);
const XID_template& operator[](int index_value) const;
const XID_template& operator[](const INTEGER& index_value) const;

void set_size(int new_size);
int n_elem() const;
int size_of(boolean is_size) const;
inline int size_of() const { return size_of(TRUE); }
inline int lengthof() const { return size_of(FALSE); }
boolean match(const XID__Information& other_value, boolean legacy = FALSE) const;
inline boolean is_bound() const 
  {return template_selection != UNINITIALIZED_TEMPLATE; }
boolean is_value() const;
XID__Information valueof() const;
XID__Information substr(int index, int returncount) const;

XID__Information replace(int index, int len, const XID__Information_template& repl) const;

XID__Information replace(int index, int len, const XID__Information& repl) const;

void set_type(template_sel template_type, unsigned int list_length);
XID__Information_template& list_item(unsigned int list_index);
void log() const;
void log_match(const XID__Information& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean get_istemplate_kind(const char* type) const;
};

class FRMR__Information : public Base_Type {
  RejectedFrameControlField field_rejectedFrameControlField;
  BITSTRING field_spare1;
  BITSTRING field_vS;
  BITSTRING field_spare2;
  BITSTRING field_vR;
  BITSTRING field_cR;
  BITSTRING field_spare3;
  BITSTRING field_w4;
  BITSTRING field_w3;
  BITSTRING field_w2;
  BITSTRING field_w1;
public:
  FRMR__Information();
  FRMR__Information(const RejectedFrameControlField& par_rejectedFrameControlField,
    const BITSTRING& par_spare1,
    const BITSTRING& par_vS,
    const BITSTRING& par_spare2,
    const BITSTRING& par_vR,
    const BITSTRING& par_cR,
    const BITSTRING& par_spare3,
    const BITSTRING& par_w4,
    const BITSTRING& par_w3,
    const BITSTRING& par_w2,
    const BITSTRING& par_w1);
  FRMR__Information(const FRMR__Information& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  FRMR__Information& operator=(const FRMR__Information& other_value);
  boolean operator==(const FRMR__Information& other_value) const;
  inline boolean operator!=(const FRMR__Information& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline RejectedFrameControlField& rejectedFrameControlField()
    {return field_rejectedFrameControlField;}
  inline const RejectedFrameControlField& rejectedFrameControlField() const
    {return field_rejectedFrameControlField;}
  inline BITSTRING& spare1()
    {return field_spare1;}
  inline const BITSTRING& spare1() const
    {return field_spare1;}
  inline BITSTRING& vS()
    {return field_vS;}
  inline const BITSTRING& vS() const
    {return field_vS;}
  inline BITSTRING& spare2()
    {return field_spare2;}
  inline const BITSTRING& spare2() const
    {return field_spare2;}
  inline BITSTRING& vR()
    {return field_vR;}
  inline const BITSTRING& vR() const
    {return field_vR;}
  inline BITSTRING& cR()
    {return field_cR;}
  inline const BITSTRING& cR() const
    {return field_cR;}
  inline BITSTRING& spare3()
    {return field_spare3;}
  inline const BITSTRING& spare3() const
    {return field_spare3;}
  inline BITSTRING& w4()
    {return field_w4;}
  inline const BITSTRING& w4() const
    {return field_w4;}
  inline BITSTRING& w3()
    {return field_w3;}
  inline const BITSTRING& w3() const
    {return field_w3;}
  inline BITSTRING& w2()
    {return field_w2;}
  inline const BITSTRING& w2() const
    {return field_w2;}
  inline BITSTRING& w1()
    {return field_w1;}
  inline const BITSTRING& w1() const
    {return field_w1;}
  inline int size_of() const
    {return 11;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class FRMR__Information_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
FRMR__Information_template *list_value;
} value_list;
struct {
FRMR__Information_template* precondition;
FRMR__Information_template* implied_template;
} implication_;
dynmatch_struct<FRMR__Information>* dyn_match;
};

void set_specific();
void copy_value(const FRMR__Information& other_value);
void copy_template(const FRMR__Information_template& other_value);

public:
FRMR__Information_template();
FRMR__Information_template(template_sel other_value);
FRMR__Information_template(const FRMR__Information& other_value);
FRMR__Information_template(const OPTIONAL<FRMR__Information>& other_value);
FRMR__Information_template(FRMR__Information_template* p_precondition, FRMR__Information_template* p_implied_template);
FRMR__Information_template(Dynamic_Match_Interface<FRMR__Information>* p_dyn_match);
FRMR__Information_template(const FRMR__Information_template& other_value);
~FRMR__Information_template();
FRMR__Information_template& operator=(template_sel other_value);
FRMR__Information_template& operator=(const FRMR__Information& other_value);
FRMR__Information_template& operator=(const OPTIONAL<FRMR__Information>& other_value);
FRMR__Information_template& operator=(const FRMR__Information_template& other_value);
boolean match(const FRMR__Information& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
FRMR__Information valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
FRMR__Information_template& list_item(unsigned int list_index) const;
RejectedFrameControlField_template& rejectedFrameControlField();
const RejectedFrameControlField_template& rejectedFrameControlField() const;
BITSTRING_template& spare1();
const BITSTRING_template& spare1() const;
BITSTRING_template& vS();
const BITSTRING_template& vS() const;
BITSTRING_template& spare2();
const BITSTRING_template& spare2() const;
BITSTRING_template& vR();
const BITSTRING_template& vR() const;
BITSTRING_template& cR();
const BITSTRING_template& cR() const;
BITSTRING_template& spare3();
const BITSTRING_template& spare3() const;
BITSTRING_template& w4();
const BITSTRING_template& w4() const;
BITSTRING_template& w3();
const BITSTRING_template& w3() const;
BITSTRING_template& w2();
const BITSTRING_template& w2() const;
BITSTRING_template& w1();
const BITSTRING_template& w1() const;
int size_of() const;
void log() const;
void log_match(const FRMR__Information& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class Address__field : public Base_Type {
  BITSTRING field_sAPI;
  BITSTRING field_spare;
  BITSTRING field_cR;
  BITSTRING field_pD;
public:
  Address__field();
  Address__field(const BITSTRING& par_sAPI,
    const BITSTRING& par_spare,
    const BITSTRING& par_cR,
    const BITSTRING& par_pD);
  Address__field(const Address__field& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  Address__field& operator=(const Address__field& other_value);
  boolean operator==(const Address__field& other_value) const;
  inline boolean operator!=(const Address__field& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline BITSTRING& sAPI()
    {return field_sAPI;}
  inline const BITSTRING& sAPI() const
    {return field_sAPI;}
  inline BITSTRING& spare()
    {return field_spare;}
  inline const BITSTRING& spare() const
    {return field_spare;}
  inline BITSTRING& cR()
    {return field_cR;}
  inline const BITSTRING& cR() const
    {return field_cR;}
  inline BITSTRING& pD()
    {return field_pD;}
  inline const BITSTRING& pD() const
    {return field_pD;}
  inline int size_of() const
    {return 4;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class Address__field_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
Address__field_template *list_value;
} value_list;
struct {
Address__field_template* precondition;
Address__field_template* implied_template;
} implication_;
dynmatch_struct<Address__field>* dyn_match;
};

void set_specific();
void copy_value(const Address__field& other_value);
void copy_template(const Address__field_template& other_value);

public:
Address__field_template();
Address__field_template(template_sel other_value);
Address__field_template(const Address__field& other_value);
Address__field_template(const OPTIONAL<Address__field>& other_value);
Address__field_template(Address__field_template* p_precondition, Address__field_template* p_implied_template);
Address__field_template(Dynamic_Match_Interface<Address__field>* p_dyn_match);
Address__field_template(const Address__field_template& other_value);
~Address__field_template();
Address__field_template& operator=(template_sel other_value);
Address__field_template& operator=(const Address__field& other_value);
Address__field_template& operator=(const OPTIONAL<Address__field>& other_value);
Address__field_template& operator=(const Address__field_template& other_value);
boolean match(const Address__field& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
Address__field valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
Address__field_template& list_item(unsigned int list_index) const;
BITSTRING_template& sAPI();
const BITSTRING_template& sAPI() const;
BITSTRING_template& spare();
const BITSTRING_template& spare() const;
BITSTRING_template& cR();
const BITSTRING_template& cR() const;
BITSTRING_template& pD();
const BITSTRING_template& pD() const;
int size_of() const;
void log() const;
void log_match(const Address__field& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class Information__field__U : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_uA = 1, ALT_sABM = 2, ALT_fRMR = 3, ALT_dM = 4, ALT_xID = 5, ALT_nULL = 6, ALT_dISC = 7 };
private:
union_selection_type union_selection;
union {
UA__Information *field_uA;
SABM__Information *field_sABM;
FRMR__Information *field_fRMR;
OCTETSTRING *field_dM;
XID__Information *field_xID;
OCTETSTRING *field_nULL;
OCTETSTRING *field_dISC;
};
void copy_value(const Information__field__U& other_value);

public:
Information__field__U();
Information__field__U(const Information__field__U& other_value);
~Information__field__U();
Information__field__U& operator=(const Information__field__U& other_value);
boolean operator==(const Information__field__U& other_value) const;
inline boolean operator!=(const Information__field__U& other_value) const { return !(*this == other_value); }
UA__Information& uA();
const UA__Information& uA() const;
SABM__Information& sABM();
const SABM__Information& sABM() const;
FRMR__Information& fRMR();
const FRMR__Information& fRMR() const;
OCTETSTRING& dM();
const OCTETSTRING& dM() const;
XID__Information& xID();
const XID__Information& xID() const;
OCTETSTRING& nULL();
const OCTETSTRING& nULL() const;
OCTETSTRING& dISC();
const OCTETSTRING& dISC() const;
inline union_selection_type get_selection() const { return union_selection; }
boolean ischosen(union_selection_type checked_selection) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
inline boolean is_present() const { return is_bound(); }
void log() const;
void set_param(Module_Param& param);
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class Information__field__U_template : public Base_Template {
union {
struct {
Information__field__U::union_selection_type union_selection;
union {
UA__Information_template *field_uA;
SABM__Information_template *field_sABM;
FRMR__Information_template *field_fRMR;
OCTETSTRING_template *field_dM;
XID__Information_template *field_xID;
OCTETSTRING_template *field_nULL;
OCTETSTRING_template *field_dISC;
};
} single_value;
struct {
unsigned int n_values;
Information__field__U_template *list_value;
} value_list;
struct {
Information__field__U_template* precondition;
Information__field__U_template* implied_template;
} implication_;
dynmatch_struct<Information__field__U>* dyn_match;
};
void copy_value(const Information__field__U& other_value);

void copy_template(const Information__field__U_template& other_value);

public:
Information__field__U_template();
Information__field__U_template(template_sel other_value);
Information__field__U_template(const Information__field__U& other_value);
Information__field__U_template(const OPTIONAL<Information__field__U>& other_value);
Information__field__U_template(Information__field__U_template* p_precondition, Information__field__U_template* p_implied_template);
Information__field__U_template(Dynamic_Match_Interface<Information__field__U>* p_dyn_match);
Information__field__U_template(const Information__field__U_template& other_value);
~Information__field__U_template();
void clean_up();
Information__field__U_template& operator=(template_sel other_value);
Information__field__U_template& operator=(const Information__field__U& other_value);
Information__field__U_template& operator=(const OPTIONAL<Information__field__U>& other_value);
Information__field__U_template& operator=(const Information__field__U_template& other_value);
boolean match(const Information__field__U& other_value, boolean legacy = FALSE) const;
boolean is_value() const;Information__field__U valueof() const;
Information__field__U_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
UA__Information_template& uA();
const UA__Information_template& uA() const;
SABM__Information_template& sABM();
const SABM__Information_template& sABM() const;
FRMR__Information_template& fRMR();
const FRMR__Information_template& fRMR() const;
OCTETSTRING_template& dM();
const OCTETSTRING_template& dM() const;
XID__Information_template& xID();
const XID__Information_template& xID() const;
OCTETSTRING_template& nULL();
const OCTETSTRING_template& nULL() const;
OCTETSTRING_template& dISC();
const OCTETSTRING_template& dISC() const;
boolean ischosen(Information__field__U::union_selection_type checked_selection) const;
void log() const;
void log_match(const Information__field__U& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
};

class PDU__LLC__UI : public Base_Type {
  Address__field field_address__field;
  Control__field__UI field_control__field;
  OCTETSTRING field_information__field__UI;
  OPTIONAL< OCTETSTRING > field_fCS;
public:
  PDU__LLC__UI();
  PDU__LLC__UI(const Address__field& par_address__field,
    const Control__field__UI& par_control__field,
    const OCTETSTRING& par_information__field__UI,
    const OPTIONAL< OCTETSTRING >& par_fCS);
  PDU__LLC__UI(const PDU__LLC__UI& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  PDU__LLC__UI& operator=(const PDU__LLC__UI& other_value);
  boolean operator==(const PDU__LLC__UI& other_value) const;
  inline boolean operator!=(const PDU__LLC__UI& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline Address__field& address__field()
    {return field_address__field;}
  inline const Address__field& address__field() const
    {return field_address__field;}
  inline Control__field__UI& control__field()
    {return field_control__field;}
  inline const Control__field__UI& control__field() const
    {return field_control__field;}
  inline OCTETSTRING& information__field__UI()
    {return field_information__field__UI;}
  inline const OCTETSTRING& information__field__UI() const
    {return field_information__field__UI;}
  inline OPTIONAL< OCTETSTRING >& fCS()
    {return field_fCS;}
  inline const OPTIONAL< OCTETSTRING >& fCS() const
    {return field_fCS;}
  int size_of() const;
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class PDU__LLC__UI_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
PDU__LLC__UI_template *list_value;
} value_list;
struct {
PDU__LLC__UI_template* precondition;
PDU__LLC__UI_template* implied_template;
} implication_;
dynmatch_struct<PDU__LLC__UI>* dyn_match;
};

void set_specific();
void copy_value(const PDU__LLC__UI& other_value);
void copy_template(const PDU__LLC__UI_template& other_value);

public:
PDU__LLC__UI_template();
PDU__LLC__UI_template(template_sel other_value);
PDU__LLC__UI_template(const PDU__LLC__UI& other_value);
PDU__LLC__UI_template(const OPTIONAL<PDU__LLC__UI>& other_value);
PDU__LLC__UI_template(PDU__LLC__UI_template* p_precondition, PDU__LLC__UI_template* p_implied_template);
PDU__LLC__UI_template(Dynamic_Match_Interface<PDU__LLC__UI>* p_dyn_match);
PDU__LLC__UI_template(const PDU__LLC__UI_template& other_value);
~PDU__LLC__UI_template();
PDU__LLC__UI_template& operator=(template_sel other_value);
PDU__LLC__UI_template& operator=(const PDU__LLC__UI& other_value);
PDU__LLC__UI_template& operator=(const OPTIONAL<PDU__LLC__UI>& other_value);
PDU__LLC__UI_template& operator=(const PDU__LLC__UI_template& other_value);
boolean match(const PDU__LLC__UI& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
PDU__LLC__UI valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
PDU__LLC__UI_template& list_item(unsigned int list_index) const;
Address__field_template& address__field();
const Address__field_template& address__field() const;
Control__field__UI_template& control__field();
const Control__field__UI_template& control__field() const;
OCTETSTRING_template& information__field__UI();
const OCTETSTRING_template& information__field__UI() const;
OCTETSTRING_template& fCS();
const OCTETSTRING_template& fCS() const;
int size_of() const;
void log() const;
void log_match(const PDU__LLC__UI& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class PDU__LLC__U : public Base_Type {
  Address__field field_address__field;
  Control__field__U field_control__field;
  Information__field__U field_information__field__U;
  OPTIONAL< OCTETSTRING > field_fCS;
public:
  PDU__LLC__U();
  PDU__LLC__U(const Address__field& par_address__field,
    const Control__field__U& par_control__field,
    const Information__field__U& par_information__field__U,
    const OPTIONAL< OCTETSTRING >& par_fCS);
  PDU__LLC__U(const PDU__LLC__U& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  PDU__LLC__U& operator=(const PDU__LLC__U& other_value);
  boolean operator==(const PDU__LLC__U& other_value) const;
  inline boolean operator!=(const PDU__LLC__U& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline Address__field& address__field()
    {return field_address__field;}
  inline const Address__field& address__field() const
    {return field_address__field;}
  inline Control__field__U& control__field()
    {return field_control__field;}
  inline const Control__field__U& control__field() const
    {return field_control__field;}
  inline Information__field__U& information__field__U()
    {return field_information__field__U;}
  inline const Information__field__U& information__field__U() const
    {return field_information__field__U;}
  inline OPTIONAL< OCTETSTRING >& fCS()
    {return field_fCS;}
  inline const OPTIONAL< OCTETSTRING >& fCS() const
    {return field_fCS;}
  int size_of() const;
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class PDU__LLC__U_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
PDU__LLC__U_template *list_value;
} value_list;
struct {
PDU__LLC__U_template* precondition;
PDU__LLC__U_template* implied_template;
} implication_;
dynmatch_struct<PDU__LLC__U>* dyn_match;
};

void set_specific();
void copy_value(const PDU__LLC__U& other_value);
void copy_template(const PDU__LLC__U_template& other_value);

public:
PDU__LLC__U_template();
PDU__LLC__U_template(template_sel other_value);
PDU__LLC__U_template(const PDU__LLC__U& other_value);
PDU__LLC__U_template(const OPTIONAL<PDU__LLC__U>& other_value);
PDU__LLC__U_template(PDU__LLC__U_template* p_precondition, PDU__LLC__U_template* p_implied_template);
PDU__LLC__U_template(Dynamic_Match_Interface<PDU__LLC__U>* p_dyn_match);
PDU__LLC__U_template(const PDU__LLC__U_template& other_value);
~PDU__LLC__U_template();
PDU__LLC__U_template& operator=(template_sel other_value);
PDU__LLC__U_template& operator=(const PDU__LLC__U& other_value);
PDU__LLC__U_template& operator=(const OPTIONAL<PDU__LLC__U>& other_value);
PDU__LLC__U_template& operator=(const PDU__LLC__U_template& other_value);
boolean match(const PDU__LLC__U& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
PDU__LLC__U valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
PDU__LLC__U_template& list_item(unsigned int list_index) const;
Address__field_template& address__field();
const Address__field_template& address__field() const;
Control__field__U_template& control__field();
const Control__field__U_template& control__field() const;
Information__field__U_template& information__field__U();
const Information__field__U_template& information__field__U() const;
OCTETSTRING_template& fCS();
const OCTETSTRING_template& fCS() const;
int size_of() const;
void log() const;
void log_match(const PDU__LLC__U& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class PDU__LLC : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_pDU__LLC__UI = 1, ALT_pDU__LLC__U = 2 };
private:
union_selection_type union_selection;
union {
PDU__LLC__UI *field_pDU__LLC__UI;
PDU__LLC__U *field_pDU__LLC__U;
};
void copy_value(const PDU__LLC& other_value);

public:
PDU__LLC();
PDU__LLC(const PDU__LLC& other_value);
~PDU__LLC();
PDU__LLC& operator=(const PDU__LLC& other_value);
boolean operator==(const PDU__LLC& other_value) const;
inline boolean operator!=(const PDU__LLC& other_value) const { return !(*this == other_value); }
PDU__LLC__UI& pDU__LLC__UI();
const PDU__LLC__UI& pDU__LLC__UI() const;
PDU__LLC__U& pDU__LLC__U();
const PDU__LLC__U& pDU__LLC__U() const;
inline union_selection_type get_selection() const { return union_selection; }
boolean ischosen(union_selection_type checked_selection) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
inline boolean is_present() const { return is_bound(); }
void log() const;
void set_param(Module_Param& param);
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class PDU__LLC_template : public Base_Template {
union {
struct {
PDU__LLC::union_selection_type union_selection;
union {
PDU__LLC__UI_template *field_pDU__LLC__UI;
PDU__LLC__U_template *field_pDU__LLC__U;
};
} single_value;
struct {
unsigned int n_values;
PDU__LLC_template *list_value;
} value_list;
struct {
PDU__LLC_template* precondition;
PDU__LLC_template* implied_template;
} implication_;
dynmatch_struct<PDU__LLC>* dyn_match;
};
void copy_value(const PDU__LLC& other_value);

void copy_template(const PDU__LLC_template& other_value);

public:
PDU__LLC_template();
PDU__LLC_template(template_sel other_value);
PDU__LLC_template(const PDU__LLC& other_value);
PDU__LLC_template(const OPTIONAL<PDU__LLC>& other_value);
PDU__LLC_template(PDU__LLC_template* p_precondition, PDU__LLC_template* p_implied_template);
PDU__LLC_template(Dynamic_Match_Interface<PDU__LLC>* p_dyn_match);
PDU__LLC_template(const PDU__LLC_template& other_value);
~PDU__LLC_template();
void clean_up();
PDU__LLC_template& operator=(template_sel other_value);
PDU__LLC_template& operator=(const PDU__LLC& other_value);
PDU__LLC_template& operator=(const OPTIONAL<PDU__LLC>& other_value);
PDU__LLC_template& operator=(const PDU__LLC_template& other_value);
boolean match(const PDU__LLC& other_value, boolean legacy = FALSE) const;
boolean is_value() const;PDU__LLC valueof() const;
PDU__LLC_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
PDU__LLC__UI_template& pDU__LLC__UI();
const PDU__LLC__UI_template& pDU__LLC__UI() const;
PDU__LLC__U_template& pDU__LLC__U();
const PDU__LLC__U_template& pDU__LLC__U() const;
boolean ischosen(PDU__LLC::union_selection_type checked_selection) const;
void log() const;
void log_match(const PDU__LLC& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
};


/* Function prototypes */

extern OCTETSTRING enc__PDU__LLC(const PDU__LLC& pdu);
extern PDU__LLC dec__PDU__LLC(const OCTETSTRING& stream, const BOOLEAN& checkFCS);
extern void Version_version__value_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER Version_version__value_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void Version_encoder(const Version& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER Version_decoder(OCTETSTRING& input_stream, Version& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void IOV__UI_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER IOV__UI_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void IOV__I_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER IOV__I_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void T200_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER T200_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void T200_t200Value_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER T200_t200Value_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void T200_encoder(const T200& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER T200_decoder(OCTETSTRING& input_stream, T200& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void N200_retransmissions_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER N200_retransmissions_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void N200_encoder(const N200& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER N200_decoder(OCTETSTRING& input_stream, N200& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void N201__U_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER N201__U_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void N201__U_n201UValue_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER N201__U_n201UValue_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void N201__U_encoder(const N201__U& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER N201__U_decoder(OCTETSTRING& input_stream, N201__U& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void N201__I_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER N201__I_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void N201__I_n201IValue_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER N201__I_n201IValue_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void N201__I_encoder(const N201__I& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER N201__I_decoder(OCTETSTRING& input_stream, N201__I& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void MD_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER MD_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void MD_mDValue_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER MD_mDValue_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void MD_encoder(const MD& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER MD_decoder(OCTETSTRING& input_stream, MD& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void MU_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER MU_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void MU_mUValue_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER MU_mUValue_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void MU_encoder(const MU& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER MU_decoder(OCTETSTRING& input_stream, MU& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void KD_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER KD_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void KU_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER KU_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L3param_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L3param_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void Reset__LLC_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER Reset__LLC_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void XID__Data_encoder(const XID__Data& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER XID__Data_decoder(OCTETSTRING& input_stream, XID__Data& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void XID__length_short__len_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER XID__length_short__len_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void XID__length_long__len_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER XID__length_long__len_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void XID__length_encoder(const XID__length& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER XID__length_decoder(OCTETSTRING& input_stream, XID__length& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void XID_xl_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER XID_xl_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void XID_typefield_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER XID_typefield_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void XID_xID__length_encoder(const XID__length& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER XID_xID__length_decoder(OCTETSTRING& input_stream, XID__length& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void XID_xID__Data_encoder(const XID__Data& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER XID_xID__Data_decoder(OCTETSTRING& input_stream, XID__Data& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void XID_encoder(const XID& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER XID_decoder(OCTETSTRING& input_stream, XID& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void Control__field__UI_format_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER Control__field__UI_format_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void Control__field__UI_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER Control__field__UI_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void Control__field__UI_nU_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER Control__field__UI_nU_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void Control__field__UI_e_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER Control__field__UI_e_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void Control__field__UI_pM_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER Control__field__UI_pM_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void Control__field__UI_encoder(const Control__field__UI& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER Control__field__UI_decoder(OCTETSTRING& input_stream, Control__field__UI& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RejectedFrameControlField__UI_encoder(const RejectedFrameControlField__UI& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RejectedFrameControlField__UI_decoder(OCTETSTRING& input_stream, RejectedFrameControlField__UI& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void Control__field__U_encoder(const Control__field__U& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER Control__field__U_decoder(OCTETSTRING& input_stream, Control__field__U& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RejectedFrameControlField__U_encoder(const RejectedFrameControlField__U& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RejectedFrameControlField__U_decoder(OCTETSTRING& input_stream, RejectedFrameControlField__U& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RejectedFrameControlField_encoder(const RejectedFrameControlField& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RejectedFrameControlField_decoder(OCTETSTRING& input_stream, RejectedFrameControlField& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern boolean operator==(null_type null_value, const UA__Information& other_value);
inline boolean operator!=(null_type null_value, const UA__Information& other_value) { return !(null_value == other_value); }
extern void UA__Information_encoder(const UA__Information& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER UA__Information_decoder(OCTETSTRING& input_stream, UA__Information& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern boolean operator==(null_type null_value, const SABM__Information& other_value);
inline boolean operator!=(null_type null_value, const SABM__Information& other_value) { return !(null_value == other_value); }
extern void SABM__Information_encoder(const SABM__Information& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER SABM__Information_decoder(OCTETSTRING& input_stream, SABM__Information& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern boolean operator==(null_type null_value, const XID__Information& other_value);
inline boolean operator!=(null_type null_value, const XID__Information& other_value) { return !(null_value == other_value); }
extern void XID__Information_encoder(const XID__Information& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER XID__Information_decoder(OCTETSTRING& input_stream, XID__Information& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DM__Information_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DM__Information_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void NULL__Information_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER NULL__Information_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DISC__Information_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DISC__Information_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void FRMR__Information_rejectedFrameControlField_encoder(const RejectedFrameControlField& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER FRMR__Information_rejectedFrameControlField_decoder(OCTETSTRING& input_stream, RejectedFrameControlField& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void FRMR__Information_spare1_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER FRMR__Information_spare1_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void FRMR__Information_vS_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER FRMR__Information_vS_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void FRMR__Information_spare2_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER FRMR__Information_spare2_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void FRMR__Information_vR_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER FRMR__Information_vR_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void FRMR__Information_cR_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER FRMR__Information_cR_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void FRMR__Information_spare3_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER FRMR__Information_spare3_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void FRMR__Information_w4_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER FRMR__Information_w4_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void FRMR__Information_w3_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER FRMR__Information_w3_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void FRMR__Information_w2_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER FRMR__Information_w2_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void FRMR__Information_w1_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER FRMR__Information_w1_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void FRMR__Information_encoder(const FRMR__Information& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER FRMR__Information_decoder(OCTETSTRING& input_stream, FRMR__Information& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void Address__field_encoder(const Address__field& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER Address__field_decoder(OCTETSTRING& input_stream, Address__field& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void Information__field__U_encoder(const Information__field__U& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER Information__field__U_decoder(OCTETSTRING& input_stream, Information__field__U& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void PDU__LLC__UI_information__field__UI_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PDU__LLC__UI_information__field__UI_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void PDU__LLC__UI_encoder(const PDU__LLC__UI& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PDU__LLC__UI_decoder(OCTETSTRING& input_stream, PDU__LLC__UI& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void PDU__LLC__U_information__field__U_encoder(const Information__field__U& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PDU__LLC__U_information__field__U_decoder(OCTETSTRING& input_stream, Information__field__U& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void PDU__LLC__U_encoder(const PDU__LLC__U& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PDU__LLC__U_decoder(OCTETSTRING& input_stream, PDU__LLC__U& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void PDU__LLC_encoder(const PDU__LLC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PDU__LLC_decoder(OCTETSTRING& input_stream, PDU__LLC& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void pre_init_module();
extern void post_init_module();

/* Global variable declarations */

extern const BOOLEAN& dec__PDU__LLC_checkFCS_defval;
extern BOOLEAN const_dec__PDU__LLC_checkFCS_defval;
extern const TTCN_RAWdescriptor_t Version_version__value_raw_;
extern const XERdescriptor_t Version_version__value_xer_;
extern const TTCN_Typedescriptor_t Version_version__value_descr_;
extern UNIVERSAL_CHARSTRING Version_version__value_default_coding;
extern const XERdescriptor_t Version_spare_xer_;
extern const TTCN_OERdescriptor_t Version_spare_oer_;
extern const TTCN_Typedescriptor_t Version_spare_descr_;
extern UNIVERSAL_CHARSTRING Version_spare_default_coding;
extern const TTCN_RAWdescriptor_t Version_raw_;
extern const TTCN_Typedescriptor_t Version_descr_;
extern UNIVERSAL_CHARSTRING Version_default_coding;
extern const TTCN_RAWdescriptor_t IOV__UI_raw_;
extern const XERdescriptor_t IOV__UI_xer_;
extern const TTCN_OERdescriptor_t IOV__UI_oer_;
extern const TTCN_Typedescriptor_t IOV__UI_descr_;
extern UNIVERSAL_CHARSTRING IOV__UI_default_coding;
extern const TTCN_RAWdescriptor_t IOV__I_raw_;
extern const XERdescriptor_t IOV__I_xer_;
extern const TTCN_OERdescriptor_t IOV__I_oer_;
extern const TTCN_Typedescriptor_t IOV__I_descr_;
extern UNIVERSAL_CHARSTRING IOV__I_default_coding;
extern const TTCN_RAWdescriptor_t T200_spare_raw_;
extern const XERdescriptor_t T200_spare_xer_;
extern const TTCN_OERdescriptor_t T200_spare_oer_;
extern const TTCN_Typedescriptor_t T200_spare_descr_;
extern UNIVERSAL_CHARSTRING T200_spare_default_coding;
extern const TTCN_RAWdescriptor_t T200_t200Value_raw_;
extern const XERdescriptor_t T200_t200Value_xer_;
extern const TTCN_Typedescriptor_t T200_t200Value_descr_;
extern UNIVERSAL_CHARSTRING T200_t200Value_default_coding;
extern const TTCN_RAWdescriptor_t T200_raw_;
extern const TTCN_Typedescriptor_t T200_descr_;
extern UNIVERSAL_CHARSTRING T200_default_coding;
extern const TTCN_RAWdescriptor_t N200_retransmissions_raw_;
extern const XERdescriptor_t N200_retransmissions_xer_;
extern const TTCN_Typedescriptor_t N200_retransmissions_descr_;
extern UNIVERSAL_CHARSTRING N200_retransmissions_default_coding;
extern const XERdescriptor_t N200_spare_xer_;
extern const TTCN_OERdescriptor_t N200_spare_oer_;
extern const TTCN_Typedescriptor_t N200_spare_descr_;
extern UNIVERSAL_CHARSTRING N200_spare_default_coding;
extern const TTCN_RAWdescriptor_t N200_raw_;
extern const TTCN_Typedescriptor_t N200_descr_;
extern UNIVERSAL_CHARSTRING N200_default_coding;
extern const TTCN_RAWdescriptor_t N201__U_spare_raw_;
extern const XERdescriptor_t N201__U_spare_xer_;
extern const TTCN_OERdescriptor_t N201__U_spare_oer_;
extern const TTCN_Typedescriptor_t N201__U_spare_descr_;
extern UNIVERSAL_CHARSTRING N201__U_spare_default_coding;
extern const TTCN_RAWdescriptor_t N201__U_n201UValue_raw_;
extern const XERdescriptor_t N201__U_n201UValue_xer_;
extern const TTCN_Typedescriptor_t N201__U_n201UValue_descr_;
extern UNIVERSAL_CHARSTRING N201__U_n201UValue_default_coding;
extern const TTCN_RAWdescriptor_t N201__U_raw_;
extern const TTCN_Typedescriptor_t N201__U_descr_;
extern UNIVERSAL_CHARSTRING N201__U_default_coding;
extern const TTCN_RAWdescriptor_t N201__I_spare_raw_;
extern const XERdescriptor_t N201__I_spare_xer_;
extern const TTCN_OERdescriptor_t N201__I_spare_oer_;
extern const TTCN_Typedescriptor_t N201__I_spare_descr_;
extern UNIVERSAL_CHARSTRING N201__I_spare_default_coding;
extern const TTCN_RAWdescriptor_t N201__I_n201IValue_raw_;
extern const XERdescriptor_t N201__I_n201IValue_xer_;
extern const TTCN_Typedescriptor_t N201__I_n201IValue_descr_;
extern UNIVERSAL_CHARSTRING N201__I_n201IValue_default_coding;
extern const TTCN_RAWdescriptor_t N201__I_raw_;
extern const TTCN_Typedescriptor_t N201__I_descr_;
extern UNIVERSAL_CHARSTRING N201__I_default_coding;
extern const TTCN_RAWdescriptor_t MD_spare_raw_;
extern const XERdescriptor_t MD_spare_xer_;
extern const TTCN_OERdescriptor_t MD_spare_oer_;
extern const TTCN_Typedescriptor_t MD_spare_descr_;
extern UNIVERSAL_CHARSTRING MD_spare_default_coding;
extern const TTCN_RAWdescriptor_t MD_mDValue_raw_;
extern const XERdescriptor_t MD_mDValue_xer_;
extern const TTCN_Typedescriptor_t MD_mDValue_descr_;
extern UNIVERSAL_CHARSTRING MD_mDValue_default_coding;
extern const TTCN_RAWdescriptor_t MD_raw_;
extern const TTCN_Typedescriptor_t MD_descr_;
extern UNIVERSAL_CHARSTRING MD_default_coding;
extern const TTCN_RAWdescriptor_t MU_spare_raw_;
extern const XERdescriptor_t MU_spare_xer_;
extern const TTCN_OERdescriptor_t MU_spare_oer_;
extern const TTCN_Typedescriptor_t MU_spare_descr_;
extern UNIVERSAL_CHARSTRING MU_spare_default_coding;
extern const TTCN_RAWdescriptor_t MU_mUValue_raw_;
extern const XERdescriptor_t MU_mUValue_xer_;
extern const TTCN_Typedescriptor_t MU_mUValue_descr_;
extern UNIVERSAL_CHARSTRING MU_mUValue_default_coding;
extern const TTCN_RAWdescriptor_t MU_raw_;
extern const TTCN_Typedescriptor_t MU_descr_;
extern UNIVERSAL_CHARSTRING MU_default_coding;
extern const TTCN_RAWdescriptor_t KD_raw_;
extern const XERdescriptor_t KD_xer_;
extern const TTCN_Typedescriptor_t KD_descr_;
extern UNIVERSAL_CHARSTRING KD_default_coding;
extern const TTCN_RAWdescriptor_t KU_raw_;
extern const XERdescriptor_t KU_xer_;
extern const TTCN_Typedescriptor_t KU_descr_;
extern UNIVERSAL_CHARSTRING KU_default_coding;
extern const XERdescriptor_t L3param_xer_;
extern const TTCN_OERdescriptor_t L3param_oer_;
extern const TTCN_Typedescriptor_t L3param_descr_;
extern UNIVERSAL_CHARSTRING L3param_default_coding;
extern const TTCN_RAWdescriptor_t Reset__LLC_raw_;
extern const XERdescriptor_t Reset__LLC_xer_;
extern const TTCN_OERdescriptor_t Reset__LLC_oer_;
extern const TTCN_Typedescriptor_t Reset__LLC_descr_;
extern UNIVERSAL_CHARSTRING Reset__LLC_default_coding;
extern const TTCN_RAWdescriptor_t XID__Data_raw_;
extern const TTCN_Typedescriptor_t XID__Data_descr_;
extern UNIVERSAL_CHARSTRING XID__Data_version_default_coding;
extern const XERdescriptor_t XID__Data_iOV__UI_xer_;
extern const TTCN_OERdescriptor_t XID__Data_iOV__UI_oer_;
extern const TTCN_Typedescriptor_t XID__Data_iOV__UI_descr_;
extern UNIVERSAL_CHARSTRING XID__Data_iOV__UI_default_coding;
extern const XERdescriptor_t XID__Data_iOV__I_xer_;
extern const TTCN_OERdescriptor_t XID__Data_iOV__I_oer_;
extern const TTCN_Typedescriptor_t XID__Data_iOV__I_descr_;
extern UNIVERSAL_CHARSTRING XID__Data_iOV__I_default_coding;
extern UNIVERSAL_CHARSTRING XID__Data_t200_default_coding;
extern UNIVERSAL_CHARSTRING XID__Data_n200_default_coding;
extern UNIVERSAL_CHARSTRING XID__Data_n201__U_default_coding;
extern UNIVERSAL_CHARSTRING XID__Data_n201__I_default_coding;
extern UNIVERSAL_CHARSTRING XID__Data_mD_default_coding;
extern UNIVERSAL_CHARSTRING XID__Data_mU_default_coding;
extern const XERdescriptor_t XID__Data_kD_xer_;
extern const TTCN_OERdescriptor_t XID__Data_kD_oer_;
extern const TTCN_Typedescriptor_t XID__Data_kD_descr_;
extern UNIVERSAL_CHARSTRING XID__Data_kD_default_coding;
extern const XERdescriptor_t XID__Data_kU_xer_;
extern const TTCN_OERdescriptor_t XID__Data_kU_oer_;
extern const TTCN_Typedescriptor_t XID__Data_kU_descr_;
extern UNIVERSAL_CHARSTRING XID__Data_kU_default_coding;
extern const XERdescriptor_t XID__Data_l3param_xer_;
extern const TTCN_OERdescriptor_t XID__Data_l3param_oer_;
extern const TTCN_Typedescriptor_t XID__Data_l3param_descr_;
extern UNIVERSAL_CHARSTRING XID__Data_l3param_default_coding;
extern const XERdescriptor_t XID__Data_reset_xer_;
extern const TTCN_OERdescriptor_t XID__Data_reset_oer_;
extern const TTCN_Typedescriptor_t XID__Data_reset_descr_;
extern UNIVERSAL_CHARSTRING XID__Data_reset_default_coding;
extern UNIVERSAL_CHARSTRING XID__Data_default_coding;
extern const TTCN_RAWdescriptor_t XID__length_raw_;
extern const TTCN_Typedescriptor_t XID__length_descr_;
extern const TTCN_RAWdescriptor_t XID__length_short__len_raw_;
extern const XERdescriptor_t XID__length_short__len_xer_;
extern const TTCN_Typedescriptor_t XID__length_short__len_descr_;
extern UNIVERSAL_CHARSTRING XID__length_short__len_default_coding;
extern const TTCN_RAWdescriptor_t XID__length_long__len_raw_;
extern const XERdescriptor_t XID__length_long__len_xer_;
extern const TTCN_Typedescriptor_t XID__length_long__len_descr_;
extern UNIVERSAL_CHARSTRING XID__length_long__len_default_coding;
extern UNIVERSAL_CHARSTRING XID__length_default_coding;
extern const TTCN_RAWdescriptor_t XID_xl_raw_;
extern const XERdescriptor_t XID_xl_xer_;
extern const TTCN_OERdescriptor_t XID_xl_oer_;
extern const TTCN_Typedescriptor_t XID_xl_descr_;
extern UNIVERSAL_CHARSTRING XID_xl_default_coding;
extern const TTCN_RAWdescriptor_t XID_typefield_raw_;
extern const XERdescriptor_t XID_typefield_xer_;
extern const TTCN_OERdescriptor_t XID_typefield_oer_;
extern const TTCN_Typedescriptor_t XID_typefield_descr_;
extern UNIVERSAL_CHARSTRING XID_typefield_default_coding;
extern const TTCN_RAWdescriptor_t XID_xID__length_raw_;
extern const TTCN_Typedescriptor_t XID_xID__length_descr_;
extern UNIVERSAL_CHARSTRING XID_xID__length_default_coding;
extern const TTCN_RAWdescriptor_t XID_xID__Data_raw_;
extern const TTCN_Typedescriptor_t XID_xID__Data_descr_;
extern UNIVERSAL_CHARSTRING XID_xID__Data_default_coding;
extern const TTCN_RAWdescriptor_t XID_raw_;
extern const TTCN_Typedescriptor_t XID_descr_;
extern UNIVERSAL_CHARSTRING XID_default_coding;
extern const TTCN_RAWdescriptor_t Control__field__UI_format_raw_;
extern const XERdescriptor_t Control__field__UI_format_xer_;
extern const TTCN_OERdescriptor_t Control__field__UI_format_oer_;
extern const TTCN_Typedescriptor_t Control__field__UI_format_descr_;
extern UNIVERSAL_CHARSTRING Control__field__UI_format_default_coding;
extern const TTCN_RAWdescriptor_t Control__field__UI_spare_raw_;
extern const XERdescriptor_t Control__field__UI_spare_xer_;
extern const TTCN_OERdescriptor_t Control__field__UI_spare_oer_;
extern const TTCN_Typedescriptor_t Control__field__UI_spare_descr_;
extern UNIVERSAL_CHARSTRING Control__field__UI_spare_default_coding;
extern const TTCN_RAWdescriptor_t Control__field__UI_nU_raw_;
extern const XERdescriptor_t Control__field__UI_nU_xer_;
extern const TTCN_Typedescriptor_t Control__field__UI_nU_descr_;
extern UNIVERSAL_CHARSTRING Control__field__UI_nU_default_coding;
extern const TTCN_RAWdescriptor_t Control__field__UI_e_raw_;
extern const XERdescriptor_t Control__field__UI_e_xer_;
extern const TTCN_OERdescriptor_t Control__field__UI_e_oer_;
extern const TTCN_Typedescriptor_t Control__field__UI_e_descr_;
extern UNIVERSAL_CHARSTRING Control__field__UI_e_default_coding;
extern const TTCN_RAWdescriptor_t Control__field__UI_pM_raw_;
extern const XERdescriptor_t Control__field__UI_pM_xer_;
extern const TTCN_OERdescriptor_t Control__field__UI_pM_oer_;
extern const TTCN_Typedescriptor_t Control__field__UI_pM_descr_;
extern UNIVERSAL_CHARSTRING Control__field__UI_pM_default_coding;
extern const TTCN_RAWdescriptor_t Control__field__UI_raw_;
extern const TTCN_Typedescriptor_t Control__field__UI_descr_;
extern UNIVERSAL_CHARSTRING Control__field__UI_default_coding;
extern UNIVERSAL_CHARSTRING RejectedFrameControlField__UI_control__field_default_coding;
extern const XERdescriptor_t RejectedFrameControlField__UI_spare_xer_;
extern const TTCN_OERdescriptor_t RejectedFrameControlField__UI_spare_oer_;
extern const TTCN_Typedescriptor_t RejectedFrameControlField__UI_spare_descr_;
extern UNIVERSAL_CHARSTRING RejectedFrameControlField__UI_spare_default_coding;
extern const TTCN_RAWdescriptor_t RejectedFrameControlField__UI_raw_;
extern const TTCN_Typedescriptor_t RejectedFrameControlField__UI_descr_;
extern UNIVERSAL_CHARSTRING RejectedFrameControlField__UI_default_coding;
extern const XERdescriptor_t Control__field__U_mBits_xer_;
extern const TTCN_OERdescriptor_t Control__field__U_mBits_oer_;
extern const TTCN_Typedescriptor_t Control__field__U_mBits_descr_;
extern UNIVERSAL_CHARSTRING Control__field__U_mBits_default_coding;
extern const XERdescriptor_t Control__field__U_pF_xer_;
extern const TTCN_OERdescriptor_t Control__field__U_pF_oer_;
extern const TTCN_Typedescriptor_t Control__field__U_pF_descr_;
extern UNIVERSAL_CHARSTRING Control__field__U_pF_default_coding;
extern const XERdescriptor_t Control__field__U_format_xer_;
extern const TTCN_OERdescriptor_t Control__field__U_format_oer_;
extern const TTCN_Typedescriptor_t Control__field__U_format_descr_;
extern UNIVERSAL_CHARSTRING Control__field__U_format_default_coding;
extern const TTCN_RAWdescriptor_t Control__field__U_raw_;
extern const TTCN_Typedescriptor_t Control__field__U_descr_;
extern UNIVERSAL_CHARSTRING Control__field__U_default_coding;
extern UNIVERSAL_CHARSTRING RejectedFrameControlField__U_control__field_default_coding;
extern const XERdescriptor_t RejectedFrameControlField__U_spare_xer_;
extern const TTCN_OERdescriptor_t RejectedFrameControlField__U_spare_oer_;
extern const TTCN_Typedescriptor_t RejectedFrameControlField__U_spare_descr_;
extern UNIVERSAL_CHARSTRING RejectedFrameControlField__U_spare_default_coding;
extern const TTCN_RAWdescriptor_t RejectedFrameControlField__U_raw_;
extern const TTCN_Typedescriptor_t RejectedFrameControlField__U_descr_;
extern UNIVERSAL_CHARSTRING RejectedFrameControlField__U_default_coding;
extern const TTCN_RAWdescriptor_t RejectedFrameControlField_raw_;
extern const TTCN_Typedescriptor_t RejectedFrameControlField_descr_;
extern UNIVERSAL_CHARSTRING RejectedFrameControlField_rejectedFrameControlField__UI_default_coding;
extern UNIVERSAL_CHARSTRING RejectedFrameControlField_rejectedFrameControlField__U_default_coding;
extern UNIVERSAL_CHARSTRING RejectedFrameControlField_default_coding;
extern const TTCN_RAWdescriptor_t UA__Information_raw_;
extern const TTCN_Typedescriptor_t UA__Information_descr_;
extern UNIVERSAL_CHARSTRING UA__Information_0_default_coding;
extern UNIVERSAL_CHARSTRING UA__Information_default_coding;
extern const TTCN_RAWdescriptor_t SABM__Information_raw_;
extern const TTCN_Typedescriptor_t SABM__Information_descr_;
extern UNIVERSAL_CHARSTRING SABM__Information_0_default_coding;
extern UNIVERSAL_CHARSTRING SABM__Information_default_coding;
extern const TTCN_RAWdescriptor_t XID__Information_raw_;
extern const TTCN_Typedescriptor_t XID__Information_descr_;
extern UNIVERSAL_CHARSTRING XID__Information_0_default_coding;
extern UNIVERSAL_CHARSTRING XID__Information_default_coding;
extern const TTCN_RAWdescriptor_t DM__Information_raw_;
extern const XERdescriptor_t DM__Information_xer_;
extern const TTCN_OERdescriptor_t DM__Information_oer_;
extern const TTCN_Typedescriptor_t DM__Information_descr_;
extern UNIVERSAL_CHARSTRING DM__Information_default_coding;
extern const TTCN_RAWdescriptor_t NULL__Information_raw_;
extern const XERdescriptor_t NULL__Information_xer_;
extern const TTCN_OERdescriptor_t NULL__Information_oer_;
extern const TTCN_Typedescriptor_t NULL__Information_descr_;
extern UNIVERSAL_CHARSTRING NULL__Information_default_coding;
extern const TTCN_RAWdescriptor_t DISC__Information_raw_;
extern const XERdescriptor_t DISC__Information_xer_;
extern const TTCN_OERdescriptor_t DISC__Information_oer_;
extern const TTCN_Typedescriptor_t DISC__Information_descr_;
extern UNIVERSAL_CHARSTRING DISC__Information_default_coding;
extern const TTCN_RAWdescriptor_t FRMR__Information_rejectedFrameControlField_raw_;
extern const TTCN_Typedescriptor_t FRMR__Information_rejectedFrameControlField_descr_;
extern UNIVERSAL_CHARSTRING FRMR__Information_rejectedFrameControlField_default_coding;
extern const TTCN_RAWdescriptor_t FRMR__Information_spare1_raw_;
extern const XERdescriptor_t FRMR__Information_spare1_xer_;
extern const TTCN_OERdescriptor_t FRMR__Information_spare1_oer_;
extern const TTCN_Typedescriptor_t FRMR__Information_spare1_descr_;
extern UNIVERSAL_CHARSTRING FRMR__Information_spare1_default_coding;
extern const TTCN_RAWdescriptor_t FRMR__Information_vS_raw_;
extern const XERdescriptor_t FRMR__Information_vS_xer_;
extern const TTCN_OERdescriptor_t FRMR__Information_vS_oer_;
extern const TTCN_Typedescriptor_t FRMR__Information_vS_descr_;
extern UNIVERSAL_CHARSTRING FRMR__Information_vS_default_coding;
extern const TTCN_RAWdescriptor_t FRMR__Information_spare2_raw_;
extern const XERdescriptor_t FRMR__Information_spare2_xer_;
extern const TTCN_OERdescriptor_t FRMR__Information_spare2_oer_;
extern const TTCN_Typedescriptor_t FRMR__Information_spare2_descr_;
extern UNIVERSAL_CHARSTRING FRMR__Information_spare2_default_coding;
extern const TTCN_RAWdescriptor_t FRMR__Information_vR_raw_;
extern const XERdescriptor_t FRMR__Information_vR_xer_;
extern const TTCN_OERdescriptor_t FRMR__Information_vR_oer_;
extern const TTCN_Typedescriptor_t FRMR__Information_vR_descr_;
extern UNIVERSAL_CHARSTRING FRMR__Information_vR_default_coding;
extern const TTCN_RAWdescriptor_t FRMR__Information_cR_raw_;
extern const XERdescriptor_t FRMR__Information_cR_xer_;
extern const TTCN_OERdescriptor_t FRMR__Information_cR_oer_;
extern const TTCN_Typedescriptor_t FRMR__Information_cR_descr_;
extern UNIVERSAL_CHARSTRING FRMR__Information_cR_default_coding;
extern const TTCN_RAWdescriptor_t FRMR__Information_spare3_raw_;
extern const XERdescriptor_t FRMR__Information_spare3_xer_;
extern const TTCN_OERdescriptor_t FRMR__Information_spare3_oer_;
extern const TTCN_Typedescriptor_t FRMR__Information_spare3_descr_;
extern UNIVERSAL_CHARSTRING FRMR__Information_spare3_default_coding;
extern const TTCN_RAWdescriptor_t FRMR__Information_w4_raw_;
extern const XERdescriptor_t FRMR__Information_w4_xer_;
extern const TTCN_OERdescriptor_t FRMR__Information_w4_oer_;
extern const TTCN_Typedescriptor_t FRMR__Information_w4_descr_;
extern UNIVERSAL_CHARSTRING FRMR__Information_w4_default_coding;
extern const TTCN_RAWdescriptor_t FRMR__Information_w3_raw_;
extern const XERdescriptor_t FRMR__Information_w3_xer_;
extern const TTCN_OERdescriptor_t FRMR__Information_w3_oer_;
extern const TTCN_Typedescriptor_t FRMR__Information_w3_descr_;
extern UNIVERSAL_CHARSTRING FRMR__Information_w3_default_coding;
extern const TTCN_RAWdescriptor_t FRMR__Information_w2_raw_;
extern const XERdescriptor_t FRMR__Information_w2_xer_;
extern const TTCN_OERdescriptor_t FRMR__Information_w2_oer_;
extern const TTCN_Typedescriptor_t FRMR__Information_w2_descr_;
extern UNIVERSAL_CHARSTRING FRMR__Information_w2_default_coding;
extern const TTCN_RAWdescriptor_t FRMR__Information_w1_raw_;
extern const XERdescriptor_t FRMR__Information_w1_xer_;
extern const TTCN_OERdescriptor_t FRMR__Information_w1_oer_;
extern const TTCN_Typedescriptor_t FRMR__Information_w1_descr_;
extern UNIVERSAL_CHARSTRING FRMR__Information_w1_default_coding;
extern const TTCN_RAWdescriptor_t FRMR__Information_raw_;
extern const TTCN_Typedescriptor_t FRMR__Information_descr_;
extern UNIVERSAL_CHARSTRING FRMR__Information_default_coding;
extern const XERdescriptor_t Address__field_sAPI_xer_;
extern const TTCN_OERdescriptor_t Address__field_sAPI_oer_;
extern const TTCN_Typedescriptor_t Address__field_sAPI_descr_;
extern UNIVERSAL_CHARSTRING Address__field_sAPI_default_coding;
extern const XERdescriptor_t Address__field_spare_xer_;
extern const TTCN_OERdescriptor_t Address__field_spare_oer_;
extern const TTCN_Typedescriptor_t Address__field_spare_descr_;
extern UNIVERSAL_CHARSTRING Address__field_spare_default_coding;
extern const XERdescriptor_t Address__field_cR_xer_;
extern const TTCN_OERdescriptor_t Address__field_cR_oer_;
extern const TTCN_Typedescriptor_t Address__field_cR_descr_;
extern UNIVERSAL_CHARSTRING Address__field_cR_default_coding;
extern const XERdescriptor_t Address__field_pD_xer_;
extern const TTCN_OERdescriptor_t Address__field_pD_oer_;
extern const TTCN_Typedescriptor_t Address__field_pD_descr_;
extern UNIVERSAL_CHARSTRING Address__field_pD_default_coding;
extern const TTCN_RAWdescriptor_t Address__field_raw_;
extern const TTCN_Typedescriptor_t Address__field_descr_;
extern UNIVERSAL_CHARSTRING Address__field_default_coding;
extern const TTCN_RAWdescriptor_t Information__field__U_raw_;
extern const TTCN_Typedescriptor_t Information__field__U_descr_;
extern UNIVERSAL_CHARSTRING Information__field__U_uA_default_coding;
extern UNIVERSAL_CHARSTRING Information__field__U_sABM_default_coding;
extern UNIVERSAL_CHARSTRING Information__field__U_fRMR_default_coding;
extern const XERdescriptor_t Information__field__U_dM_xer_;
extern const TTCN_OERdescriptor_t Information__field__U_dM_oer_;
extern const TTCN_Typedescriptor_t Information__field__U_dM_descr_;
extern UNIVERSAL_CHARSTRING Information__field__U_dM_default_coding;
extern UNIVERSAL_CHARSTRING Information__field__U_xID_default_coding;
extern const XERdescriptor_t Information__field__U_nULL_xer_;
extern const TTCN_OERdescriptor_t Information__field__U_nULL_oer_;
extern const TTCN_Typedescriptor_t Information__field__U_nULL_descr_;
extern UNIVERSAL_CHARSTRING Information__field__U_nULL_default_coding;
extern const XERdescriptor_t Information__field__U_dISC_xer_;
extern const TTCN_OERdescriptor_t Information__field__U_dISC_oer_;
extern const TTCN_Typedescriptor_t Information__field__U_dISC_descr_;
extern UNIVERSAL_CHARSTRING Information__field__U_dISC_default_coding;
extern UNIVERSAL_CHARSTRING Information__field__U_default_coding;
extern UNIVERSAL_CHARSTRING PDU__LLC__UI_address__field_default_coding;
extern UNIVERSAL_CHARSTRING PDU__LLC__UI_control__field_default_coding;
extern const XERdescriptor_t PDU__LLC__UI_information__field__UI_xer_;
extern const TTCN_OERdescriptor_t PDU__LLC__UI_information__field__UI_oer_;
extern const TTCN_Typedescriptor_t PDU__LLC__UI_information__field__UI_descr_;
extern UNIVERSAL_CHARSTRING PDU__LLC__UI_information__field__UI_default_coding;
extern const TTCN_RAWdescriptor_t PDU__LLC__UI_raw_;
extern const TTCN_Typedescriptor_t PDU__LLC__UI_descr_;
extern const XERdescriptor_t PDU__LLC__UI_fCS_xer_;
extern const TTCN_OERdescriptor_t PDU__LLC__UI_fCS_oer_;
extern const TTCN_Typedescriptor_t PDU__LLC__UI_fCS_descr_;
extern UNIVERSAL_CHARSTRING PDU__LLC__UI_fCS_default_coding;
extern UNIVERSAL_CHARSTRING PDU__LLC__UI_default_coding;
extern UNIVERSAL_CHARSTRING PDU__LLC__U_address__field_default_coding;
extern UNIVERSAL_CHARSTRING PDU__LLC__U_control__field_default_coding;
extern const TTCN_RAWdescriptor_t PDU__LLC__U_information__field__U_raw_;
extern const TTCN_Typedescriptor_t PDU__LLC__U_information__field__U_descr_;
extern UNIVERSAL_CHARSTRING PDU__LLC__U_information__field__U_default_coding;
extern const TTCN_RAWdescriptor_t PDU__LLC__U_raw_;
extern const TTCN_Typedescriptor_t PDU__LLC__U_descr_;
extern const XERdescriptor_t PDU__LLC__U_fCS_xer_;
extern const TTCN_OERdescriptor_t PDU__LLC__U_fCS_oer_;
extern const TTCN_Typedescriptor_t PDU__LLC__U_fCS_descr_;
extern UNIVERSAL_CHARSTRING PDU__LLC__U_fCS_default_coding;
extern UNIVERSAL_CHARSTRING PDU__LLC__U_default_coding;
extern const TTCN_RAWdescriptor_t PDU__LLC_raw_;
extern const TTCN_Typedescriptor_t PDU__LLC_descr_;
extern UNIVERSAL_CHARSTRING PDU__LLC_pDU__LLC__UI_default_coding;
extern UNIVERSAL_CHARSTRING PDU__LLC_pDU__LLC__U_default_coding;
extern UNIVERSAL_CHARSTRING PDU__LLC_default_coding;
extern const BITSTRING bs_13,
bs_22,
bs_0,
bs_1,
bs_20,
bs_2,
bs_3,
bs_4,
bs_5,
bs_6,
bs_7,
bs_23,
bs_8,
bs_9,
bs_10,
bs_11,
bs_17,
bs_12,
bs_18,
bs_14,
bs_19,
bs_21,
bs_15,
bs_16;
extern const unsigned char module_checksum[];
extern TTCN_Module module_object;
extern const RuntimeVersionChecker ver_checker;

} /* end of namespace */

#endif
