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

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

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

#ifndef RLCMAC__Types_HH
#define RLCMAC__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 "RLCMAC_CSN1_Types.hh"

#if TTCN3_VERSION != 110100
#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 RLCMAC__Types_HH
#endif

namespace RLCMAC__Types {

/* Forward declarations of classes */

class MacPayloadType;
class MacPayloadType_template;
class MacRrbp;
class MacRrbp_template;
class EgprsHeaderType;
class EgprsHeaderType_template;
class CodingScheme;
class CodingScheme_template;
class CodingSchemeArray;
class CodingSchemeArray_template;
class DlMacHeader;
class DlMacHeader_template;
class PowerReduction;
class PowerReduction_template;
class DirectionBit;
class DirectionBit_template;
class TfiOctet;
class TfiOctet_template;
class RbsnExtOctet;
class RbsnExtOctet_template;
class DlCtrlOptOctets;
class DlCtrlOptOctets_template;
class RlcmacDlCtrlBlock;
class RlcmacDlCtrlBlock_template;
class UlMacCtrlHeader;
class UlMacCtrlHeader_template;
class RlcmacUlCtrlBlock;
class RlcmacUlCtrlBlock_template;
class LlcBlockHdr;
class LlcBlockHdr_template;
class LlcBlock;
class LlcBlock_template;
class LlcBlocks;
class LlcBlocks_template;
class DlMacHdrDataExt;
class DlMacHdrDataExt_template;
class DlMacDataHeader;
class DlMacDataHeader_template;
class RlcmacDlDataBlock;
class RlcmacDlDataBlock_template;
class EgprsLlcBlockHdr;
class EgprsLlcBlockHdr_template;
class EgprsLlcBlock;
class EgprsLlcBlock_template;
class EgprsLlcBlocks;
class EgprsLlcBlocks_template;
class EgprsDlMacDataHeader;
class EgprsDlMacDataHeader_template;
class RlcmacDlEgprsDataBlock;
class RlcmacDlEgprsDataBlock_template;
class UlMacDataHeader;
class UlMacDataHeader_template;
class RlcMacUlPfi;
class RlcMacUlPfi_template;
class EgprsUlMacDataHeader;
class EgprsUlMacDataHeader_template;
class RlcmacUlEgprsDataBlock;
class RlcmacUlEgprsDataBlock_template;
class RlcmacUlDataBlock;
class RlcmacUlDataBlock_template;
class RlcmacUlBlock;
class RlcmacUlBlock_template;
class RlcmacDlBlock;
class RlcmacDlBlock_template;
class PTCCHTimingAdvanceIE;
class PTCCHTimingAdvanceIE_template;
class PTCCHTimingAdvanceIEs;
class PTCCHTimingAdvanceIEs_template;
class PTCCHDownlinkMsg;
class PTCCHDownlinkMsg_template;

} /* end of namespace */

#ifndef RLCMAC__Types_HH
#define RLCMAC__Types_HH

namespace RLCMAC__Types {

/* Class definitions */

class MacPayloadType : public Base_Type { // enum
friend class MacPayloadType_template;
public:
enum enum_type { MAC__PT__RLC__DATA = 0, MAC__PT__RLCMAC__NO__OPT = 1, MAC__PT__RLCMAC__OPT = 2, MAC__PT__RESERVED = 3, UNKNOWN_VALUE = 4, UNBOUND_VALUE = 5 };
private:
enum_type enum_value;

public:
MacPayloadType();
MacPayloadType(int other_value);
MacPayloadType(enum_type other_value);
MacPayloadType(const MacPayloadType& other_value);

MacPayloadType& operator=(int other_value);
MacPayloadType& operator=(enum_type other_value);
MacPayloadType& operator=(const MacPayloadType& other_value);

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const MacPayloadType& other_value) const;
inline boolean operator!=(int other_value) const { return !(*this == other_value); }
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const MacPayloadType& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const MacPayloadType& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const MacPayloadType& other_value) const;
inline boolean operator<=(int other_value) const { return !(*this > other_value); }
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const MacPayloadType& other_value) const { return !(*this > other_value); }
inline boolean operator>=(int other_value) const { return !(*this < other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const MacPayloadType& other_value) const { return !(*this < other_value); }

static const char *enum_to_str(enum_type enum_par);
static enum_type str_to_enum(const char *str_par, const int* int_par = NULL, const int* int_par2 = NULL);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const MacPayloadType& enum_par);
int as_int() const { return enum2int(enum_value); }
void from_int(int p_val) { *this = p_val; }
void int2enum(int int_val);
operator enum_type() const;
inline boolean is_bound() const { return enum_value != UNBOUND_VALUE; }
inline boolean is_value() const { return enum_value != UNBOUND_VALUE; }
inline void clean_up(){ enum_value = UNBOUND_VALUE; }
inline boolean is_present() const { return is_bound(); }
void log() const;
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 MacPayloadType_template : public Base_Template {
union {
MacPayloadType::enum_type single_value;
struct {
unsigned int n_values;
MacPayloadType_template *list_value;
} value_list;
struct {
MacPayloadType_template* precondition;
MacPayloadType_template* implied_template;
} implication_;
dynmatch_struct<MacPayloadType>* dyn_match;
};

void copy_template(const MacPayloadType_template& other_value);

public:
MacPayloadType_template();
MacPayloadType_template(template_sel other_value);
MacPayloadType_template(int other_value);
MacPayloadType_template(MacPayloadType::enum_type other_value);
MacPayloadType_template(const MacPayloadType& other_value);
MacPayloadType_template(const OPTIONAL<MacPayloadType>& other_value);
MacPayloadType_template(MacPayloadType_template* p_precondition, MacPayloadType_template* p_implied_template);
MacPayloadType_template(Dynamic_Match_Interface<MacPayloadType>* p_dyn_match);
MacPayloadType_template(const MacPayloadType_template& other_value);
~MacPayloadType_template();

boolean is_bound() const;
boolean is_value() const;
void clean_up();
MacPayloadType_template& operator=(template_sel other_value);
MacPayloadType_template& operator=(int other_value);
MacPayloadType_template& operator=(MacPayloadType::enum_type other_value);
MacPayloadType_template& operator=(const MacPayloadType& other_value);
MacPayloadType_template& operator=(const OPTIONAL<MacPayloadType>& other_value);
MacPayloadType_template& operator=(const MacPayloadType_template& other_value);

boolean match(MacPayloadType::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const MacPayloadType& other_value, boolean legacy = FALSE) const;
MacPayloadType::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
MacPayloadType_template& list_item(unsigned int list_index);
void log() const;
void log_match(const MacPayloadType& 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 MacRrbp : public Base_Type { // enum
friend class MacRrbp_template;
public:
enum enum_type { RRBP__Nplus13__mod__2715648 = 0, RRBP__Nplus17__or__18__mod__2715648 = 1, RRBP__Nplus21__or__22__mod__2715648 = 2, RRBP__Nplus26__mod__2715648 = 3, UNKNOWN_VALUE = 4, UNBOUND_VALUE = 5 };
private:
enum_type enum_value;

public:
MacRrbp();
MacRrbp(int other_value);
MacRrbp(enum_type other_value);
MacRrbp(const MacRrbp& other_value);

MacRrbp& operator=(int other_value);
MacRrbp& operator=(enum_type other_value);
MacRrbp& operator=(const MacRrbp& other_value);

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const MacRrbp& other_value) const;
inline boolean operator!=(int other_value) const { return !(*this == other_value); }
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const MacRrbp& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const MacRrbp& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const MacRrbp& other_value) const;
inline boolean operator<=(int other_value) const { return !(*this > other_value); }
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const MacRrbp& other_value) const { return !(*this > other_value); }
inline boolean operator>=(int other_value) const { return !(*this < other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const MacRrbp& other_value) const { return !(*this < other_value); }

static const char *enum_to_str(enum_type enum_par);
static enum_type str_to_enum(const char *str_par, const int* int_par = NULL, const int* int_par2 = NULL);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const MacRrbp& enum_par);
int as_int() const { return enum2int(enum_value); }
void from_int(int p_val) { *this = p_val; }
void int2enum(int int_val);
operator enum_type() const;
inline boolean is_bound() const { return enum_value != UNBOUND_VALUE; }
inline boolean is_value() const { return enum_value != UNBOUND_VALUE; }
inline void clean_up(){ enum_value = UNBOUND_VALUE; }
inline boolean is_present() const { return is_bound(); }
void log() const;
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 MacRrbp_template : public Base_Template {
union {
MacRrbp::enum_type single_value;
struct {
unsigned int n_values;
MacRrbp_template *list_value;
} value_list;
struct {
MacRrbp_template* precondition;
MacRrbp_template* implied_template;
} implication_;
dynmatch_struct<MacRrbp>* dyn_match;
};

void copy_template(const MacRrbp_template& other_value);

public:
MacRrbp_template();
MacRrbp_template(template_sel other_value);
MacRrbp_template(int other_value);
MacRrbp_template(MacRrbp::enum_type other_value);
MacRrbp_template(const MacRrbp& other_value);
MacRrbp_template(const OPTIONAL<MacRrbp>& other_value);
MacRrbp_template(MacRrbp_template* p_precondition, MacRrbp_template* p_implied_template);
MacRrbp_template(Dynamic_Match_Interface<MacRrbp>* p_dyn_match);
MacRrbp_template(const MacRrbp_template& other_value);
~MacRrbp_template();

boolean is_bound() const;
boolean is_value() const;
void clean_up();
MacRrbp_template& operator=(template_sel other_value);
MacRrbp_template& operator=(int other_value);
MacRrbp_template& operator=(MacRrbp::enum_type other_value);
MacRrbp_template& operator=(const MacRrbp& other_value);
MacRrbp_template& operator=(const OPTIONAL<MacRrbp>& other_value);
MacRrbp_template& operator=(const MacRrbp_template& other_value);

boolean match(MacRrbp::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const MacRrbp& other_value, boolean legacy = FALSE) const;
MacRrbp::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
MacRrbp_template& list_item(unsigned int list_index);
void log() const;
void log_match(const MacRrbp& 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 EgprsHeaderType : public Base_Type { // enum
friend class EgprsHeaderType_template;
public:
enum enum_type { RLCMAC__HDR__TYPE__1 = 0, RLCMAC__HDR__TYPE__2 = 1, RLCMAC__HDR__TYPE__3 = 2, UNKNOWN_VALUE = 3, UNBOUND_VALUE = 4 };
private:
enum_type enum_value;

public:
EgprsHeaderType();
EgprsHeaderType(int other_value);
EgprsHeaderType(enum_type other_value);
EgprsHeaderType(const EgprsHeaderType& other_value);

EgprsHeaderType& operator=(int other_value);
EgprsHeaderType& operator=(enum_type other_value);
EgprsHeaderType& operator=(const EgprsHeaderType& other_value);

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const EgprsHeaderType& other_value) const;
inline boolean operator!=(int other_value) const { return !(*this == other_value); }
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const EgprsHeaderType& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const EgprsHeaderType& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const EgprsHeaderType& other_value) const;
inline boolean operator<=(int other_value) const { return !(*this > other_value); }
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const EgprsHeaderType& other_value) const { return !(*this > other_value); }
inline boolean operator>=(int other_value) const { return !(*this < other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const EgprsHeaderType& other_value) const { return !(*this < other_value); }

static const char *enum_to_str(enum_type enum_par);
static enum_type str_to_enum(const char *str_par, const int* int_par = NULL, const int* int_par2 = NULL);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const EgprsHeaderType& enum_par);
int as_int() const { return enum2int(enum_value); }
void from_int(int p_val) { *this = p_val; }
void int2enum(int int_val);
operator enum_type() const;
inline boolean is_bound() const { return enum_value != UNBOUND_VALUE; }
inline boolean is_value() const { return enum_value != UNBOUND_VALUE; }
inline void clean_up(){ enum_value = UNBOUND_VALUE; }
inline boolean is_present() const { return is_bound(); }
void log() const;
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 EgprsHeaderType_template : public Base_Template {
union {
EgprsHeaderType::enum_type single_value;
struct {
unsigned int n_values;
EgprsHeaderType_template *list_value;
} value_list;
struct {
EgprsHeaderType_template* precondition;
EgprsHeaderType_template* implied_template;
} implication_;
dynmatch_struct<EgprsHeaderType>* dyn_match;
};

void copy_template(const EgprsHeaderType_template& other_value);

public:
EgprsHeaderType_template();
EgprsHeaderType_template(template_sel other_value);
EgprsHeaderType_template(int other_value);
EgprsHeaderType_template(EgprsHeaderType::enum_type other_value);
EgprsHeaderType_template(const EgprsHeaderType& other_value);
EgprsHeaderType_template(const OPTIONAL<EgprsHeaderType>& other_value);
EgprsHeaderType_template(EgprsHeaderType_template* p_precondition, EgprsHeaderType_template* p_implied_template);
EgprsHeaderType_template(Dynamic_Match_Interface<EgprsHeaderType>* p_dyn_match);
EgprsHeaderType_template(const EgprsHeaderType_template& other_value);
~EgprsHeaderType_template();

boolean is_bound() const;
boolean is_value() const;
void clean_up();
EgprsHeaderType_template& operator=(template_sel other_value);
EgprsHeaderType_template& operator=(int other_value);
EgprsHeaderType_template& operator=(EgprsHeaderType::enum_type other_value);
EgprsHeaderType_template& operator=(const EgprsHeaderType& other_value);
EgprsHeaderType_template& operator=(const OPTIONAL<EgprsHeaderType>& other_value);
EgprsHeaderType_template& operator=(const EgprsHeaderType_template& other_value);

boolean match(EgprsHeaderType::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const EgprsHeaderType& other_value, boolean legacy = FALSE) const;
EgprsHeaderType::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
EgprsHeaderType_template& list_item(unsigned int list_index);
void log() const;
void log_match(const EgprsHeaderType& 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 CodingScheme : public Base_Type { // enum
friend class CodingScheme_template;
public:
enum enum_type { CS__1 = 0, CS__2 = 1, CS__3 = 2, CS__4 = 3, MCS__0 = 4, MCS__1 = 5, MCS__2 = 6, MCS__3 = 7, MCS__4 = 8, MCS__5 = 9, MCS__6 = 10, MCS__7 = 11, MCS__8 = 12, MCS__9 = 13, UNKNOWN_VALUE = 14, UNBOUND_VALUE = 15 };
private:
enum_type enum_value;

public:
CodingScheme();
CodingScheme(int other_value);
CodingScheme(enum_type other_value);
CodingScheme(const CodingScheme& other_value);

CodingScheme& operator=(int other_value);
CodingScheme& operator=(enum_type other_value);
CodingScheme& operator=(const CodingScheme& other_value);

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const CodingScheme& other_value) const;
inline boolean operator!=(int other_value) const { return !(*this == other_value); }
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const CodingScheme& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const CodingScheme& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const CodingScheme& other_value) const;
inline boolean operator<=(int other_value) const { return !(*this > other_value); }
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const CodingScheme& other_value) const { return !(*this > other_value); }
inline boolean operator>=(int other_value) const { return !(*this < other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const CodingScheme& other_value) const { return !(*this < other_value); }

static const char *enum_to_str(enum_type enum_par);
static enum_type str_to_enum(const char *str_par, const int* int_par = NULL, const int* int_par2 = NULL);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const CodingScheme& enum_par);
int as_int() const { return enum2int(enum_value); }
void from_int(int p_val) { *this = p_val; }
void int2enum(int int_val);
operator enum_type() const;
inline boolean is_bound() const { return enum_value != UNBOUND_VALUE; }
inline boolean is_value() const { return enum_value != UNBOUND_VALUE; }
inline void clean_up(){ enum_value = UNBOUND_VALUE; }
inline boolean is_present() const { return is_bound(); }
void log() const;
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 CodingScheme_template : public Base_Template {
union {
CodingScheme::enum_type single_value;
struct {
unsigned int n_values;
CodingScheme_template *list_value;
} value_list;
struct {
CodingScheme_template* precondition;
CodingScheme_template* implied_template;
} implication_;
dynmatch_struct<CodingScheme>* dyn_match;
};

void copy_template(const CodingScheme_template& other_value);

public:
CodingScheme_template();
CodingScheme_template(template_sel other_value);
CodingScheme_template(int other_value);
CodingScheme_template(CodingScheme::enum_type other_value);
CodingScheme_template(const CodingScheme& other_value);
CodingScheme_template(const OPTIONAL<CodingScheme>& other_value);
CodingScheme_template(CodingScheme_template* p_precondition, CodingScheme_template* p_implied_template);
CodingScheme_template(Dynamic_Match_Interface<CodingScheme>* p_dyn_match);
CodingScheme_template(const CodingScheme_template& other_value);
~CodingScheme_template();

boolean is_bound() const;
boolean is_value() const;
void clean_up();
CodingScheme_template& operator=(template_sel other_value);
CodingScheme_template& operator=(int other_value);
CodingScheme_template& operator=(CodingScheme::enum_type other_value);
CodingScheme_template& operator=(const CodingScheme& other_value);
CodingScheme_template& operator=(const OPTIONAL<CodingScheme>& other_value);
CodingScheme_template& operator=(const CodingScheme_template& other_value);

boolean match(CodingScheme::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const CodingScheme& other_value, boolean legacy = FALSE) const;
CodingScheme::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
CodingScheme_template& list_item(unsigned int list_index);
void log() const;
void log_match(const CodingScheme& 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 CodingSchemeArray : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
CodingScheme **value_elements;
} *val_ptr;

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

public:
  typedef CodingScheme of_type;
CodingSchemeArray();
CodingSchemeArray(null_type other_value);
CodingSchemeArray(const CodingSchemeArray& other_value);
~CodingSchemeArray();

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

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

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

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

CodingSchemeArray operator+(const CodingSchemeArray& other_value) const;

CodingSchemeArray substr(int index, int returncount) const;

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

CodingSchemeArray replace(int index, int len, const CodingSchemeArray_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 CodingSchemeArray_template : public Base_Record_Of_Template {
union {
struct {
int n_elements;
CodingScheme_template **value_elements;
} single_value;
struct {
unsigned int n_values;
CodingSchemeArray_template *list_value;
} value_list;
struct {
CodingSchemeArray_template* precondition;
CodingSchemeArray_template* implied_template;
} implication_;
dynmatch_struct<CodingSchemeArray>* dyn_match;
};
void copy_value(const CodingSchemeArray& other_value);
void copy_template(const CodingSchemeArray_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:
CodingSchemeArray_template();
CodingSchemeArray_template(template_sel other_value);
CodingSchemeArray_template(null_type other_value);
CodingSchemeArray_template(const CodingSchemeArray& other_value);
CodingSchemeArray_template(const OPTIONAL<CodingSchemeArray>& other_value);
CodingSchemeArray_template(CodingSchemeArray_template* p_precondition, CodingSchemeArray_template* p_implied_template);
CodingSchemeArray_template(Dynamic_Match_Interface<CodingSchemeArray>* p_dyn_match);
CodingSchemeArray_template(const CodingSchemeArray_template& other_value);
~CodingSchemeArray_template();

void clean_up();
CodingSchemeArray_template& operator=(template_sel other_value);
CodingSchemeArray_template& operator=(null_type other_value);
CodingSchemeArray_template& operator=(const CodingSchemeArray& other_value);
CodingSchemeArray_template& operator=(const OPTIONAL<CodingSchemeArray>& other_value);
CodingSchemeArray_template& operator=(const CodingSchemeArray_template& other_value);

CodingScheme_template& operator[](int index_value);
CodingScheme_template& operator[](const INTEGER& index_value);
const CodingScheme_template& operator[](int index_value) const;
const CodingScheme_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 CodingSchemeArray& other_value, boolean legacy = FALSE) const;
inline boolean is_bound() const 
  {return template_selection != UNINITIALIZED_TEMPLATE; }
boolean is_value() const;
CodingSchemeArray valueof() const;
CodingSchemeArray substr(int index, int returncount) const;

CodingSchemeArray replace(int index, int len, const CodingSchemeArray_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
CodingSchemeArray_template& list_item(unsigned int list_index);
void log() const;
void log_match(const CodingSchemeArray& 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_implicit_omit();
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 DlMacHeader : public Base_Type {
  MacPayloadType field_payload__type;
  MacRrbp field_rrbp;
  BOOLEAN field_rrbp__valid;
  INTEGER field_usf;
public:
  DlMacHeader();
  DlMacHeader(const MacPayloadType& par_payload__type,
    const MacRrbp& par_rrbp,
    const BOOLEAN& par_rrbp__valid,
    const INTEGER& par_usf);
  DlMacHeader(const DlMacHeader& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  DlMacHeader& operator=(const DlMacHeader& other_value);
  boolean operator==(const DlMacHeader& other_value) const;
  inline boolean operator!=(const DlMacHeader& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline MacPayloadType& payload__type()
    {return field_payload__type;}
  inline const MacPayloadType& payload__type() const
    {return field_payload__type;}
  inline MacRrbp& rrbp()
    {return field_rrbp;}
  inline const MacRrbp& rrbp() const
    {return field_rrbp;}
  inline BOOLEAN& rrbp__valid()
    {return field_rrbp__valid;}
  inline const BOOLEAN& rrbp__valid() const
    {return field_rrbp__valid;}
  inline INTEGER& usf()
    {return field_usf;}
  inline const INTEGER& usf() const
    {return field_usf;}
  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 DlMacHeader_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
DlMacHeader_template *list_value;
} value_list;
struct {
DlMacHeader_template* precondition;
DlMacHeader_template* implied_template;
} implication_;
dynmatch_struct<DlMacHeader>* dyn_match;
};

void set_specific();
void copy_value(const DlMacHeader& other_value);
void copy_template(const DlMacHeader_template& other_value);

public:
DlMacHeader_template();
DlMacHeader_template(template_sel other_value);
DlMacHeader_template(const DlMacHeader& other_value);
DlMacHeader_template(const OPTIONAL<DlMacHeader>& other_value);
DlMacHeader_template(DlMacHeader_template* p_precondition, DlMacHeader_template* p_implied_template);
DlMacHeader_template(Dynamic_Match_Interface<DlMacHeader>* p_dyn_match);
DlMacHeader_template(const DlMacHeader_template& other_value);
~DlMacHeader_template();
DlMacHeader_template& operator=(template_sel other_value);
DlMacHeader_template& operator=(const DlMacHeader& other_value);
DlMacHeader_template& operator=(const OPTIONAL<DlMacHeader>& other_value);
DlMacHeader_template& operator=(const DlMacHeader_template& other_value);
boolean match(const DlMacHeader& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
DlMacHeader valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
DlMacHeader_template& list_item(unsigned int list_index) const;
MacPayloadType_template& payload__type();
const MacPayloadType_template& payload__type() const;
MacRrbp_template& rrbp();
const MacRrbp_template& rrbp() const;
BOOLEAN_template& rrbp__valid();
const BOOLEAN_template& rrbp__valid() const;
INTEGER_template& usf();
const INTEGER_template& usf() const;
int size_of() const;
void log() const;
void log_match(const DlMacHeader& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 PowerReduction : public Base_Type { // enum
friend class PowerReduction_template;
public:
enum enum_type { PWR__RED__0__to__3dB = 0, PWR__RED__3__to__7dB = 1, PWR__RED__7__to__10dB = 2, PWR__RED__RESERVED = 3, UNKNOWN_VALUE = 4, UNBOUND_VALUE = 5 };
private:
enum_type enum_value;

public:
PowerReduction();
PowerReduction(int other_value);
PowerReduction(enum_type other_value);
PowerReduction(const PowerReduction& other_value);

PowerReduction& operator=(int other_value);
PowerReduction& operator=(enum_type other_value);
PowerReduction& operator=(const PowerReduction& other_value);

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const PowerReduction& other_value) const;
inline boolean operator!=(int other_value) const { return !(*this == other_value); }
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const PowerReduction& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const PowerReduction& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const PowerReduction& other_value) const;
inline boolean operator<=(int other_value) const { return !(*this > other_value); }
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const PowerReduction& other_value) const { return !(*this > other_value); }
inline boolean operator>=(int other_value) const { return !(*this < other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const PowerReduction& other_value) const { return !(*this < other_value); }

static const char *enum_to_str(enum_type enum_par);
static enum_type str_to_enum(const char *str_par, const int* int_par = NULL, const int* int_par2 = NULL);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const PowerReduction& enum_par);
int as_int() const { return enum2int(enum_value); }
void from_int(int p_val) { *this = p_val; }
void int2enum(int int_val);
operator enum_type() const;
inline boolean is_bound() const { return enum_value != UNBOUND_VALUE; }
inline boolean is_value() const { return enum_value != UNBOUND_VALUE; }
inline void clean_up(){ enum_value = UNBOUND_VALUE; }
inline boolean is_present() const { return is_bound(); }
void log() const;
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 PowerReduction_template : public Base_Template {
union {
PowerReduction::enum_type single_value;
struct {
unsigned int n_values;
PowerReduction_template *list_value;
} value_list;
struct {
PowerReduction_template* precondition;
PowerReduction_template* implied_template;
} implication_;
dynmatch_struct<PowerReduction>* dyn_match;
};

void copy_template(const PowerReduction_template& other_value);

public:
PowerReduction_template();
PowerReduction_template(template_sel other_value);
PowerReduction_template(int other_value);
PowerReduction_template(PowerReduction::enum_type other_value);
PowerReduction_template(const PowerReduction& other_value);
PowerReduction_template(const OPTIONAL<PowerReduction>& other_value);
PowerReduction_template(PowerReduction_template* p_precondition, PowerReduction_template* p_implied_template);
PowerReduction_template(Dynamic_Match_Interface<PowerReduction>* p_dyn_match);
PowerReduction_template(const PowerReduction_template& other_value);
~PowerReduction_template();

boolean is_bound() const;
boolean is_value() const;
void clean_up();
PowerReduction_template& operator=(template_sel other_value);
PowerReduction_template& operator=(int other_value);
PowerReduction_template& operator=(PowerReduction::enum_type other_value);
PowerReduction_template& operator=(const PowerReduction& other_value);
PowerReduction_template& operator=(const OPTIONAL<PowerReduction>& other_value);
PowerReduction_template& operator=(const PowerReduction_template& other_value);

boolean match(PowerReduction::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const PowerReduction& other_value, boolean legacy = FALSE) const;
PowerReduction::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
PowerReduction_template& list_item(unsigned int list_index);
void log() const;
void log_match(const PowerReduction& 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 DirectionBit : public Base_Type { // enum
friend class DirectionBit_template;
public:
enum enum_type { DIR__UPLINK__TBF = 0, DIR__DOWNLINK__TBF = 1, UNKNOWN_VALUE = 2, UNBOUND_VALUE = 3 };
private:
enum_type enum_value;

public:
DirectionBit();
DirectionBit(int other_value);
DirectionBit(enum_type other_value);
DirectionBit(const DirectionBit& other_value);

DirectionBit& operator=(int other_value);
DirectionBit& operator=(enum_type other_value);
DirectionBit& operator=(const DirectionBit& other_value);

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const DirectionBit& other_value) const;
inline boolean operator!=(int other_value) const { return !(*this == other_value); }
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const DirectionBit& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const DirectionBit& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const DirectionBit& other_value) const;
inline boolean operator<=(int other_value) const { return !(*this > other_value); }
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const DirectionBit& other_value) const { return !(*this > other_value); }
inline boolean operator>=(int other_value) const { return !(*this < other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const DirectionBit& other_value) const { return !(*this < other_value); }

static const char *enum_to_str(enum_type enum_par);
static enum_type str_to_enum(const char *str_par, const int* int_par = NULL, const int* int_par2 = NULL);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const DirectionBit& enum_par);
int as_int() const { return enum2int(enum_value); }
void from_int(int p_val) { *this = p_val; }
void int2enum(int int_val);
operator enum_type() const;
inline boolean is_bound() const { return enum_value != UNBOUND_VALUE; }
inline boolean is_value() const { return enum_value != UNBOUND_VALUE; }
inline void clean_up(){ enum_value = UNBOUND_VALUE; }
inline boolean is_present() const { return is_bound(); }
void log() const;
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 DirectionBit_template : public Base_Template {
union {
DirectionBit::enum_type single_value;
struct {
unsigned int n_values;
DirectionBit_template *list_value;
} value_list;
struct {
DirectionBit_template* precondition;
DirectionBit_template* implied_template;
} implication_;
dynmatch_struct<DirectionBit>* dyn_match;
};

void copy_template(const DirectionBit_template& other_value);

public:
DirectionBit_template();
DirectionBit_template(template_sel other_value);
DirectionBit_template(int other_value);
DirectionBit_template(DirectionBit::enum_type other_value);
DirectionBit_template(const DirectionBit& other_value);
DirectionBit_template(const OPTIONAL<DirectionBit>& other_value);
DirectionBit_template(DirectionBit_template* p_precondition, DirectionBit_template* p_implied_template);
DirectionBit_template(Dynamic_Match_Interface<DirectionBit>* p_dyn_match);
DirectionBit_template(const DirectionBit_template& other_value);
~DirectionBit_template();

boolean is_bound() const;
boolean is_value() const;
void clean_up();
DirectionBit_template& operator=(template_sel other_value);
DirectionBit_template& operator=(int other_value);
DirectionBit_template& operator=(DirectionBit::enum_type other_value);
DirectionBit_template& operator=(const DirectionBit& other_value);
DirectionBit_template& operator=(const OPTIONAL<DirectionBit>& other_value);
DirectionBit_template& operator=(const DirectionBit_template& other_value);

boolean match(DirectionBit::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const DirectionBit& other_value, boolean legacy = FALSE) const;
DirectionBit::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
DirectionBit_template& list_item(unsigned int list_index);
void log() const;
void log_match(const DirectionBit& 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 TfiOctet : public Base_Type {
  PowerReduction field_pr;
  INTEGER field_tfi;
  DirectionBit field_d;
public:
  TfiOctet();
  TfiOctet(const PowerReduction& par_pr,
    const INTEGER& par_tfi,
    const DirectionBit& par_d);
  TfiOctet(const TfiOctet& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  TfiOctet& operator=(const TfiOctet& other_value);
  boolean operator==(const TfiOctet& other_value) const;
  inline boolean operator!=(const TfiOctet& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline PowerReduction& pr()
    {return field_pr;}
  inline const PowerReduction& pr() const
    {return field_pr;}
  inline INTEGER& tfi()
    {return field_tfi;}
  inline const INTEGER& tfi() const
    {return field_tfi;}
  inline DirectionBit& d()
    {return field_d;}
  inline const DirectionBit& d() const
    {return field_d;}
  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 TfiOctet_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
TfiOctet_template *list_value;
} value_list;
struct {
TfiOctet_template* precondition;
TfiOctet_template* implied_template;
} implication_;
dynmatch_struct<TfiOctet>* dyn_match;
};

void set_specific();
void copy_value(const TfiOctet& other_value);
void copy_template(const TfiOctet_template& other_value);

public:
TfiOctet_template();
TfiOctet_template(template_sel other_value);
TfiOctet_template(const TfiOctet& other_value);
TfiOctet_template(const OPTIONAL<TfiOctet>& other_value);
TfiOctet_template(TfiOctet_template* p_precondition, TfiOctet_template* p_implied_template);
TfiOctet_template(Dynamic_Match_Interface<TfiOctet>* p_dyn_match);
TfiOctet_template(const TfiOctet_template& other_value);
~TfiOctet_template();
TfiOctet_template& operator=(template_sel other_value);
TfiOctet_template& operator=(const TfiOctet& other_value);
TfiOctet_template& operator=(const OPTIONAL<TfiOctet>& other_value);
TfiOctet_template& operator=(const TfiOctet_template& other_value);
boolean match(const TfiOctet& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
TfiOctet valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
TfiOctet_template& list_item(unsigned int list_index) const;
PowerReduction_template& pr();
const PowerReduction_template& pr() const;
INTEGER_template& tfi();
const INTEGER_template& tfi() const;
DirectionBit_template& d();
const DirectionBit_template& d() const;
int size_of() const;
void log() const;
void log_match(const TfiOctet& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 RbsnExtOctet : public Base_Type {
  INTEGER field_rbsn__e;
  BITSTRING field_fs__e;
  BITSTRING field_spare;
public:
  RbsnExtOctet();
  RbsnExtOctet(const INTEGER& par_rbsn__e,
    const BITSTRING& par_fs__e,
    const BITSTRING& par_spare);
  RbsnExtOctet(const RbsnExtOctet& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RbsnExtOctet& operator=(const RbsnExtOctet& other_value);
  boolean operator==(const RbsnExtOctet& other_value) const;
  inline boolean operator!=(const RbsnExtOctet& 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& rbsn__e()
    {return field_rbsn__e;}
  inline const INTEGER& rbsn__e() const
    {return field_rbsn__e;}
  inline BITSTRING& fs__e()
    {return field_fs__e;}
  inline const BITSTRING& fs__e() const
    {return field_fs__e;}
  inline BITSTRING& spare()
    {return field_spare;}
  inline const BITSTRING& spare() const
    {return field_spare;}
  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 RbsnExtOctet_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RbsnExtOctet_template *list_value;
} value_list;
struct {
RbsnExtOctet_template* precondition;
RbsnExtOctet_template* implied_template;
} implication_;
dynmatch_struct<RbsnExtOctet>* dyn_match;
};

void set_specific();
void copy_value(const RbsnExtOctet& other_value);
void copy_template(const RbsnExtOctet_template& other_value);

public:
RbsnExtOctet_template();
RbsnExtOctet_template(template_sel other_value);
RbsnExtOctet_template(const RbsnExtOctet& other_value);
RbsnExtOctet_template(const OPTIONAL<RbsnExtOctet>& other_value);
RbsnExtOctet_template(RbsnExtOctet_template* p_precondition, RbsnExtOctet_template* p_implied_template);
RbsnExtOctet_template(Dynamic_Match_Interface<RbsnExtOctet>* p_dyn_match);
RbsnExtOctet_template(const RbsnExtOctet_template& other_value);
~RbsnExtOctet_template();
RbsnExtOctet_template& operator=(template_sel other_value);
RbsnExtOctet_template& operator=(const RbsnExtOctet& other_value);
RbsnExtOctet_template& operator=(const OPTIONAL<RbsnExtOctet>& other_value);
RbsnExtOctet_template& operator=(const RbsnExtOctet_template& other_value);
boolean match(const RbsnExtOctet& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
RbsnExtOctet valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RbsnExtOctet_template& list_item(unsigned int list_index) const;
INTEGER_template& rbsn__e();
const INTEGER_template& rbsn__e() const;
BITSTRING_template& fs__e();
const BITSTRING_template& fs__e() const;
BITSTRING_template& spare();
const BITSTRING_template& spare() const;
int size_of() const;
void log() const;
void log_match(const RbsnExtOctet& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 DlCtrlOptOctets : public Base_Type {
  BITSTRING field_rbsn;
  INTEGER field_rti;
  BOOLEAN field_fs;
  BOOLEAN field_tfi__octet__present;
  OPTIONAL< TfiOctet > field_tfi;
  OPTIONAL< RbsnExtOctet > field_rbsn__ext;
public:
  DlCtrlOptOctets();
  DlCtrlOptOctets(const BITSTRING& par_rbsn,
    const INTEGER& par_rti,
    const BOOLEAN& par_fs,
    const BOOLEAN& par_tfi__octet__present,
    const OPTIONAL< TfiOctet >& par_tfi,
    const OPTIONAL< RbsnExtOctet >& par_rbsn__ext);
  DlCtrlOptOctets(const DlCtrlOptOctets& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  DlCtrlOptOctets& operator=(const DlCtrlOptOctets& other_value);
  boolean operator==(const DlCtrlOptOctets& other_value) const;
  inline boolean operator!=(const DlCtrlOptOctets& 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& rbsn()
    {return field_rbsn;}
  inline const BITSTRING& rbsn() const
    {return field_rbsn;}
  inline INTEGER& rti()
    {return field_rti;}
  inline const INTEGER& rti() const
    {return field_rti;}
  inline BOOLEAN& fs()
    {return field_fs;}
  inline const BOOLEAN& fs() const
    {return field_fs;}
  inline BOOLEAN& tfi__octet__present()
    {return field_tfi__octet__present;}
  inline const BOOLEAN& tfi__octet__present() const
    {return field_tfi__octet__present;}
  inline OPTIONAL< TfiOctet >& tfi()
    {return field_tfi;}
  inline const OPTIONAL< TfiOctet >& tfi() const
    {return field_tfi;}
  inline OPTIONAL< RbsnExtOctet >& rbsn__ext()
    {return field_rbsn__ext;}
  inline const OPTIONAL< RbsnExtOctet >& rbsn__ext() const
    {return field_rbsn__ext;}
  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 DlCtrlOptOctets_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
DlCtrlOptOctets_template *list_value;
} value_list;
struct {
DlCtrlOptOctets_template* precondition;
DlCtrlOptOctets_template* implied_template;
} implication_;
dynmatch_struct<DlCtrlOptOctets>* dyn_match;
};

void set_specific();
void copy_value(const DlCtrlOptOctets& other_value);
void copy_template(const DlCtrlOptOctets_template& other_value);

public:
DlCtrlOptOctets_template();
DlCtrlOptOctets_template(template_sel other_value);
DlCtrlOptOctets_template(const DlCtrlOptOctets& other_value);
DlCtrlOptOctets_template(const OPTIONAL<DlCtrlOptOctets>& other_value);
DlCtrlOptOctets_template(DlCtrlOptOctets_template* p_precondition, DlCtrlOptOctets_template* p_implied_template);
DlCtrlOptOctets_template(Dynamic_Match_Interface<DlCtrlOptOctets>* p_dyn_match);
DlCtrlOptOctets_template(const DlCtrlOptOctets_template& other_value);
~DlCtrlOptOctets_template();
DlCtrlOptOctets_template& operator=(template_sel other_value);
DlCtrlOptOctets_template& operator=(const DlCtrlOptOctets& other_value);
DlCtrlOptOctets_template& operator=(const OPTIONAL<DlCtrlOptOctets>& other_value);
DlCtrlOptOctets_template& operator=(const DlCtrlOptOctets_template& other_value);
boolean match(const DlCtrlOptOctets& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
DlCtrlOptOctets valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
DlCtrlOptOctets_template& list_item(unsigned int list_index) const;
BITSTRING_template& rbsn();
const BITSTRING_template& rbsn() const;
INTEGER_template& rti();
const INTEGER_template& rti() const;
BOOLEAN_template& fs();
const BOOLEAN_template& fs() const;
BOOLEAN_template& tfi__octet__present();
const BOOLEAN_template& tfi__octet__present() const;
TfiOctet_template& tfi();
const TfiOctet_template& tfi() const;
RbsnExtOctet_template& rbsn__ext();
const RbsnExtOctet_template& rbsn__ext() const;
int size_of() const;
void log() const;
void log_match(const DlCtrlOptOctets& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 RlcmacDlCtrlBlock : public Base_Type {
  DlMacHeader field_mac__hdr;
  OPTIONAL< DlCtrlOptOctets > field_opt;
  RLCMAC__CSN1__Types::RlcmacDlCtrlMsg field_payload;
public:
  RlcmacDlCtrlBlock();
  RlcmacDlCtrlBlock(const DlMacHeader& par_mac__hdr,
    const OPTIONAL< DlCtrlOptOctets >& par_opt,
    const RLCMAC__CSN1__Types::RlcmacDlCtrlMsg& par_payload);
  RlcmacDlCtrlBlock(const RlcmacDlCtrlBlock& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RlcmacDlCtrlBlock& operator=(const RlcmacDlCtrlBlock& other_value);
  boolean operator==(const RlcmacDlCtrlBlock& other_value) const;
  inline boolean operator!=(const RlcmacDlCtrlBlock& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline DlMacHeader& mac__hdr()
    {return field_mac__hdr;}
  inline const DlMacHeader& mac__hdr() const
    {return field_mac__hdr;}
  inline OPTIONAL< DlCtrlOptOctets >& opt()
    {return field_opt;}
  inline const OPTIONAL< DlCtrlOptOctets >& opt() const
    {return field_opt;}
  inline RLCMAC__CSN1__Types::RlcmacDlCtrlMsg& payload()
    {return field_payload;}
  inline const RLCMAC__CSN1__Types::RlcmacDlCtrlMsg& payload() const
    {return field_payload;}
  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 RlcmacDlCtrlBlock_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RlcmacDlCtrlBlock_template *list_value;
} value_list;
struct {
RlcmacDlCtrlBlock_template* precondition;
RlcmacDlCtrlBlock_template* implied_template;
} implication_;
dynmatch_struct<RlcmacDlCtrlBlock>* dyn_match;
};

void set_specific();
void copy_value(const RlcmacDlCtrlBlock& other_value);
void copy_template(const RlcmacDlCtrlBlock_template& other_value);

public:
RlcmacDlCtrlBlock_template();
RlcmacDlCtrlBlock_template(template_sel other_value);
RlcmacDlCtrlBlock_template(const RlcmacDlCtrlBlock& other_value);
RlcmacDlCtrlBlock_template(const OPTIONAL<RlcmacDlCtrlBlock>& other_value);
RlcmacDlCtrlBlock_template(RlcmacDlCtrlBlock_template* p_precondition, RlcmacDlCtrlBlock_template* p_implied_template);
RlcmacDlCtrlBlock_template(Dynamic_Match_Interface<RlcmacDlCtrlBlock>* p_dyn_match);
RlcmacDlCtrlBlock_template(const RlcmacDlCtrlBlock_template& other_value);
~RlcmacDlCtrlBlock_template();
RlcmacDlCtrlBlock_template& operator=(template_sel other_value);
RlcmacDlCtrlBlock_template& operator=(const RlcmacDlCtrlBlock& other_value);
RlcmacDlCtrlBlock_template& operator=(const OPTIONAL<RlcmacDlCtrlBlock>& other_value);
RlcmacDlCtrlBlock_template& operator=(const RlcmacDlCtrlBlock_template& other_value);
boolean match(const RlcmacDlCtrlBlock& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
RlcmacDlCtrlBlock valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RlcmacDlCtrlBlock_template& list_item(unsigned int list_index) const;
DlMacHeader_template& mac__hdr();
const DlMacHeader_template& mac__hdr() const;
DlCtrlOptOctets_template& opt();
const DlCtrlOptOctets_template& opt() const;
RLCMAC__CSN1__Types::RlcmacDlCtrlMsg_template& payload();
const RLCMAC__CSN1__Types::RlcmacDlCtrlMsg_template& payload() const;
int size_of() const;
void log() const;
void log_match(const RlcmacDlCtrlBlock& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 UlMacCtrlHeader : public Base_Type {
  MacPayloadType field_payload__type;
  BITSTRING field_spare;
  BOOLEAN field_retry;
public:
  UlMacCtrlHeader();
  UlMacCtrlHeader(const MacPayloadType& par_payload__type,
    const BITSTRING& par_spare,
    const BOOLEAN& par_retry);
  UlMacCtrlHeader(const UlMacCtrlHeader& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  UlMacCtrlHeader& operator=(const UlMacCtrlHeader& other_value);
  boolean operator==(const UlMacCtrlHeader& other_value) const;
  inline boolean operator!=(const UlMacCtrlHeader& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline MacPayloadType& payload__type()
    {return field_payload__type;}
  inline const MacPayloadType& payload__type() const
    {return field_payload__type;}
  inline BITSTRING& spare()
    {return field_spare;}
  inline const BITSTRING& spare() const
    {return field_spare;}
  inline BOOLEAN& retry()
    {return field_retry;}
  inline const BOOLEAN& retry() const
    {return field_retry;}
  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 UlMacCtrlHeader_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
UlMacCtrlHeader_template *list_value;
} value_list;
struct {
UlMacCtrlHeader_template* precondition;
UlMacCtrlHeader_template* implied_template;
} implication_;
dynmatch_struct<UlMacCtrlHeader>* dyn_match;
};

void set_specific();
void copy_value(const UlMacCtrlHeader& other_value);
void copy_template(const UlMacCtrlHeader_template& other_value);

public:
UlMacCtrlHeader_template();
UlMacCtrlHeader_template(template_sel other_value);
UlMacCtrlHeader_template(const UlMacCtrlHeader& other_value);
UlMacCtrlHeader_template(const OPTIONAL<UlMacCtrlHeader>& other_value);
UlMacCtrlHeader_template(UlMacCtrlHeader_template* p_precondition, UlMacCtrlHeader_template* p_implied_template);
UlMacCtrlHeader_template(Dynamic_Match_Interface<UlMacCtrlHeader>* p_dyn_match);
UlMacCtrlHeader_template(const UlMacCtrlHeader_template& other_value);
~UlMacCtrlHeader_template();
UlMacCtrlHeader_template& operator=(template_sel other_value);
UlMacCtrlHeader_template& operator=(const UlMacCtrlHeader& other_value);
UlMacCtrlHeader_template& operator=(const OPTIONAL<UlMacCtrlHeader>& other_value);
UlMacCtrlHeader_template& operator=(const UlMacCtrlHeader_template& other_value);
boolean match(const UlMacCtrlHeader& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
UlMacCtrlHeader valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
UlMacCtrlHeader_template& list_item(unsigned int list_index) const;
MacPayloadType_template& payload__type();
const MacPayloadType_template& payload__type() const;
BITSTRING_template& spare();
const BITSTRING_template& spare() const;
BOOLEAN_template& retry();
const BOOLEAN_template& retry() const;
int size_of() const;
void log() const;
void log_match(const UlMacCtrlHeader& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 RlcmacUlCtrlBlock : public Base_Type {
  UlMacCtrlHeader field_mac__hdr;
  RLCMAC__CSN1__Types::RlcmacUlCtrlMsg field_payload;
public:
  RlcmacUlCtrlBlock();
  RlcmacUlCtrlBlock(const UlMacCtrlHeader& par_mac__hdr,
    const RLCMAC__CSN1__Types::RlcmacUlCtrlMsg& par_payload);
  RlcmacUlCtrlBlock(const RlcmacUlCtrlBlock& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RlcmacUlCtrlBlock& operator=(const RlcmacUlCtrlBlock& other_value);
  boolean operator==(const RlcmacUlCtrlBlock& other_value) const;
  inline boolean operator!=(const RlcmacUlCtrlBlock& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline UlMacCtrlHeader& mac__hdr()
    {return field_mac__hdr;}
  inline const UlMacCtrlHeader& mac__hdr() const
    {return field_mac__hdr;}
  inline RLCMAC__CSN1__Types::RlcmacUlCtrlMsg& payload()
    {return field_payload;}
  inline const RLCMAC__CSN1__Types::RlcmacUlCtrlMsg& payload() const
    {return field_payload;}
  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 RlcmacUlCtrlBlock_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RlcmacUlCtrlBlock_template *list_value;
} value_list;
struct {
RlcmacUlCtrlBlock_template* precondition;
RlcmacUlCtrlBlock_template* implied_template;
} implication_;
dynmatch_struct<RlcmacUlCtrlBlock>* dyn_match;
};

void set_specific();
void copy_value(const RlcmacUlCtrlBlock& other_value);
void copy_template(const RlcmacUlCtrlBlock_template& other_value);

public:
RlcmacUlCtrlBlock_template();
RlcmacUlCtrlBlock_template(template_sel other_value);
RlcmacUlCtrlBlock_template(const RlcmacUlCtrlBlock& other_value);
RlcmacUlCtrlBlock_template(const OPTIONAL<RlcmacUlCtrlBlock>& other_value);
RlcmacUlCtrlBlock_template(RlcmacUlCtrlBlock_template* p_precondition, RlcmacUlCtrlBlock_template* p_implied_template);
RlcmacUlCtrlBlock_template(Dynamic_Match_Interface<RlcmacUlCtrlBlock>* p_dyn_match);
RlcmacUlCtrlBlock_template(const RlcmacUlCtrlBlock_template& other_value);
~RlcmacUlCtrlBlock_template();
RlcmacUlCtrlBlock_template& operator=(template_sel other_value);
RlcmacUlCtrlBlock_template& operator=(const RlcmacUlCtrlBlock& other_value);
RlcmacUlCtrlBlock_template& operator=(const OPTIONAL<RlcmacUlCtrlBlock>& other_value);
RlcmacUlCtrlBlock_template& operator=(const RlcmacUlCtrlBlock_template& other_value);
boolean match(const RlcmacUlCtrlBlock& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
RlcmacUlCtrlBlock valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RlcmacUlCtrlBlock_template& list_item(unsigned int list_index) const;
UlMacCtrlHeader_template& mac__hdr();
const UlMacCtrlHeader_template& mac__hdr() const;
RLCMAC__CSN1__Types::RlcmacUlCtrlMsg_template& payload();
const RLCMAC__CSN1__Types::RlcmacUlCtrlMsg_template& payload() const;
int size_of() const;
void log() const;
void log_match(const RlcmacUlCtrlBlock& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 LlcBlockHdr : public Base_Type {
  INTEGER field_length__ind;
  BOOLEAN field_more;
  BOOLEAN field_e;
public:
  LlcBlockHdr();
  LlcBlockHdr(const INTEGER& par_length__ind,
    const BOOLEAN& par_more,
    const BOOLEAN& par_e);
  LlcBlockHdr(const LlcBlockHdr& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  LlcBlockHdr& operator=(const LlcBlockHdr& other_value);
  boolean operator==(const LlcBlockHdr& other_value) const;
  inline boolean operator!=(const LlcBlockHdr& 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& length__ind()
    {return field_length__ind;}
  inline const INTEGER& length__ind() const
    {return field_length__ind;}
  inline BOOLEAN& more()
    {return field_more;}
  inline const BOOLEAN& more() const
    {return field_more;}
  inline BOOLEAN& e()
    {return field_e;}
  inline const BOOLEAN& e() const
    {return field_e;}
  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 LlcBlockHdr_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
LlcBlockHdr_template *list_value;
} value_list;
struct {
LlcBlockHdr_template* precondition;
LlcBlockHdr_template* implied_template;
} implication_;
dynmatch_struct<LlcBlockHdr>* dyn_match;
};

void set_specific();
void copy_value(const LlcBlockHdr& other_value);
void copy_template(const LlcBlockHdr_template& other_value);

public:
LlcBlockHdr_template();
LlcBlockHdr_template(template_sel other_value);
LlcBlockHdr_template(const LlcBlockHdr& other_value);
LlcBlockHdr_template(const OPTIONAL<LlcBlockHdr>& other_value);
LlcBlockHdr_template(LlcBlockHdr_template* p_precondition, LlcBlockHdr_template* p_implied_template);
LlcBlockHdr_template(Dynamic_Match_Interface<LlcBlockHdr>* p_dyn_match);
LlcBlockHdr_template(const LlcBlockHdr_template& other_value);
~LlcBlockHdr_template();
LlcBlockHdr_template& operator=(template_sel other_value);
LlcBlockHdr_template& operator=(const LlcBlockHdr& other_value);
LlcBlockHdr_template& operator=(const OPTIONAL<LlcBlockHdr>& other_value);
LlcBlockHdr_template& operator=(const LlcBlockHdr_template& other_value);
boolean match(const LlcBlockHdr& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
LlcBlockHdr valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
LlcBlockHdr_template& list_item(unsigned int list_index) const;
INTEGER_template& length__ind();
const INTEGER_template& length__ind() const;
BOOLEAN_template& more();
const BOOLEAN_template& more() const;
BOOLEAN_template& e();
const BOOLEAN_template& e() const;
int size_of() const;
void log() const;
void log_match(const LlcBlockHdr& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 LlcBlock : public Base_Type {
  OPTIONAL< LlcBlockHdr > field_hdr;
  OCTETSTRING field_payload;
public:
  LlcBlock();
  LlcBlock(const OPTIONAL< LlcBlockHdr >& par_hdr,
    const OCTETSTRING& par_payload);
  LlcBlock(const LlcBlock& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  LlcBlock& operator=(const LlcBlock& other_value);
  boolean operator==(const LlcBlock& other_value) const;
  inline boolean operator!=(const LlcBlock& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline OPTIONAL< LlcBlockHdr >& hdr()
    {return field_hdr;}
  inline const OPTIONAL< LlcBlockHdr >& hdr() const
    {return field_hdr;}
  inline OCTETSTRING& payload()
    {return field_payload;}
  inline const OCTETSTRING& payload() const
    {return field_payload;}
  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 LlcBlock_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
LlcBlock_template *list_value;
} value_list;
struct {
LlcBlock_template* precondition;
LlcBlock_template* implied_template;
} implication_;
dynmatch_struct<LlcBlock>* dyn_match;
};

void set_specific();
void copy_value(const LlcBlock& other_value);
void copy_template(const LlcBlock_template& other_value);

public:
LlcBlock_template();
LlcBlock_template(template_sel other_value);
LlcBlock_template(const LlcBlock& other_value);
LlcBlock_template(const OPTIONAL<LlcBlock>& other_value);
LlcBlock_template(LlcBlock_template* p_precondition, LlcBlock_template* p_implied_template);
LlcBlock_template(Dynamic_Match_Interface<LlcBlock>* p_dyn_match);
LlcBlock_template(const LlcBlock_template& other_value);
~LlcBlock_template();
LlcBlock_template& operator=(template_sel other_value);
LlcBlock_template& operator=(const LlcBlock& other_value);
LlcBlock_template& operator=(const OPTIONAL<LlcBlock>& other_value);
LlcBlock_template& operator=(const LlcBlock_template& other_value);
boolean match(const LlcBlock& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
LlcBlock valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
LlcBlock_template& list_item(unsigned int list_index) const;
LlcBlockHdr_template& hdr();
const LlcBlockHdr_template& hdr() const;
OCTETSTRING_template& payload();
const OCTETSTRING_template& payload() const;
int size_of() const;
void log() const;
void log_match(const LlcBlock& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 LlcBlocks : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
LlcBlock **value_elements;
} *val_ptr;

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

public:
  typedef LlcBlock of_type;
LlcBlocks();
LlcBlocks(null_type other_value);
LlcBlocks(const LlcBlocks& other_value);
~LlcBlocks();

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

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

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

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

LlcBlocks operator+(const LlcBlocks& other_value) const;

LlcBlocks substr(int index, int returncount) const;

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

LlcBlocks replace(int index, int len, const LlcBlocks_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 LlcBlocks_template : public Base_Record_Of_Template {
union {
struct {
int n_elements;
LlcBlock_template **value_elements;
} single_value;
struct {
unsigned int n_values;
LlcBlocks_template *list_value;
} value_list;
struct {
LlcBlocks_template* precondition;
LlcBlocks_template* implied_template;
} implication_;
dynmatch_struct<LlcBlocks>* dyn_match;
};
void copy_value(const LlcBlocks& other_value);
void copy_template(const LlcBlocks_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:
LlcBlocks_template();
LlcBlocks_template(template_sel other_value);
LlcBlocks_template(null_type other_value);
LlcBlocks_template(const LlcBlocks& other_value);
LlcBlocks_template(const OPTIONAL<LlcBlocks>& other_value);
LlcBlocks_template(LlcBlocks_template* p_precondition, LlcBlocks_template* p_implied_template);
LlcBlocks_template(Dynamic_Match_Interface<LlcBlocks>* p_dyn_match);
LlcBlocks_template(const LlcBlocks_template& other_value);
~LlcBlocks_template();

void clean_up();
LlcBlocks_template& operator=(template_sel other_value);
LlcBlocks_template& operator=(null_type other_value);
LlcBlocks_template& operator=(const LlcBlocks& other_value);
LlcBlocks_template& operator=(const OPTIONAL<LlcBlocks>& other_value);
LlcBlocks_template& operator=(const LlcBlocks_template& other_value);

LlcBlock_template& operator[](int index_value);
LlcBlock_template& operator[](const INTEGER& index_value);
const LlcBlock_template& operator[](int index_value) const;
const LlcBlock_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 LlcBlocks& other_value, boolean legacy = FALSE) const;
inline boolean is_bound() const 
  {return template_selection != UNINITIALIZED_TEMPLATE; }
boolean is_value() const;
LlcBlocks valueof() const;
LlcBlocks substr(int index, int returncount) const;

LlcBlocks replace(int index, int len, const LlcBlocks_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
LlcBlocks_template& list_item(unsigned int list_index);
void log() const;
void log_match(const LlcBlocks& 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_implicit_omit();
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 DlMacHdrDataExt : public Base_Type {
  PowerReduction field_pr;
  BITSTRING field_spare;
  INTEGER field_tfi;
  BOOLEAN field_fbi;
  INTEGER field_bsn;
  BOOLEAN field_e;
public:
  DlMacHdrDataExt();
  DlMacHdrDataExt(const PowerReduction& par_pr,
    const BITSTRING& par_spare,
    const INTEGER& par_tfi,
    const BOOLEAN& par_fbi,
    const INTEGER& par_bsn,
    const BOOLEAN& par_e);
  DlMacHdrDataExt(const DlMacHdrDataExt& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  DlMacHdrDataExt& operator=(const DlMacHdrDataExt& other_value);
  boolean operator==(const DlMacHdrDataExt& other_value) const;
  inline boolean operator!=(const DlMacHdrDataExt& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline PowerReduction& pr()
    {return field_pr;}
  inline const PowerReduction& pr() const
    {return field_pr;}
  inline BITSTRING& spare()
    {return field_spare;}
  inline const BITSTRING& spare() const
    {return field_spare;}
  inline INTEGER& tfi()
    {return field_tfi;}
  inline const INTEGER& tfi() const
    {return field_tfi;}
  inline BOOLEAN& fbi()
    {return field_fbi;}
  inline const BOOLEAN& fbi() const
    {return field_fbi;}
  inline INTEGER& bsn()
    {return field_bsn;}
  inline const INTEGER& bsn() const
    {return field_bsn;}
  inline BOOLEAN& e()
    {return field_e;}
  inline const BOOLEAN& e() const
    {return field_e;}
  inline int size_of() const
    {return 6;}
  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 DlMacHdrDataExt_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
DlMacHdrDataExt_template *list_value;
} value_list;
struct {
DlMacHdrDataExt_template* precondition;
DlMacHdrDataExt_template* implied_template;
} implication_;
dynmatch_struct<DlMacHdrDataExt>* dyn_match;
};

void set_specific();
void copy_value(const DlMacHdrDataExt& other_value);
void copy_template(const DlMacHdrDataExt_template& other_value);

public:
DlMacHdrDataExt_template();
DlMacHdrDataExt_template(template_sel other_value);
DlMacHdrDataExt_template(const DlMacHdrDataExt& other_value);
DlMacHdrDataExt_template(const OPTIONAL<DlMacHdrDataExt>& other_value);
DlMacHdrDataExt_template(DlMacHdrDataExt_template* p_precondition, DlMacHdrDataExt_template* p_implied_template);
DlMacHdrDataExt_template(Dynamic_Match_Interface<DlMacHdrDataExt>* p_dyn_match);
DlMacHdrDataExt_template(const DlMacHdrDataExt_template& other_value);
~DlMacHdrDataExt_template();
DlMacHdrDataExt_template& operator=(template_sel other_value);
DlMacHdrDataExt_template& operator=(const DlMacHdrDataExt& other_value);
DlMacHdrDataExt_template& operator=(const OPTIONAL<DlMacHdrDataExt>& other_value);
DlMacHdrDataExt_template& operator=(const DlMacHdrDataExt_template& other_value);
boolean match(const DlMacHdrDataExt& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
DlMacHdrDataExt valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
DlMacHdrDataExt_template& list_item(unsigned int list_index) const;
PowerReduction_template& pr();
const PowerReduction_template& pr() const;
BITSTRING_template& spare();
const BITSTRING_template& spare() const;
INTEGER_template& tfi();
const INTEGER_template& tfi() const;
BOOLEAN_template& fbi();
const BOOLEAN_template& fbi() const;
INTEGER_template& bsn();
const INTEGER_template& bsn() const;
BOOLEAN_template& e();
const BOOLEAN_template& e() const;
int size_of() const;
void log() const;
void log_match(const DlMacHdrDataExt& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 DlMacDataHeader : public Base_Type {
  DlMacHeader field_mac__hdr;
  DlMacHdrDataExt field_hdr__ext;
public:
  DlMacDataHeader();
  DlMacDataHeader(const DlMacHeader& par_mac__hdr,
    const DlMacHdrDataExt& par_hdr__ext);
  DlMacDataHeader(const DlMacDataHeader& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  DlMacDataHeader& operator=(const DlMacDataHeader& other_value);
  boolean operator==(const DlMacDataHeader& other_value) const;
  inline boolean operator!=(const DlMacDataHeader& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline DlMacHeader& mac__hdr()
    {return field_mac__hdr;}
  inline const DlMacHeader& mac__hdr() const
    {return field_mac__hdr;}
  inline DlMacHdrDataExt& hdr__ext()
    {return field_hdr__ext;}
  inline const DlMacHdrDataExt& hdr__ext() const
    {return field_hdr__ext;}
  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 DlMacDataHeader_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
DlMacDataHeader_template *list_value;
} value_list;
struct {
DlMacDataHeader_template* precondition;
DlMacDataHeader_template* implied_template;
} implication_;
dynmatch_struct<DlMacDataHeader>* dyn_match;
};

void set_specific();
void copy_value(const DlMacDataHeader& other_value);
void copy_template(const DlMacDataHeader_template& other_value);

public:
DlMacDataHeader_template();
DlMacDataHeader_template(template_sel other_value);
DlMacDataHeader_template(const DlMacDataHeader& other_value);
DlMacDataHeader_template(const OPTIONAL<DlMacDataHeader>& other_value);
DlMacDataHeader_template(DlMacDataHeader_template* p_precondition, DlMacDataHeader_template* p_implied_template);
DlMacDataHeader_template(Dynamic_Match_Interface<DlMacDataHeader>* p_dyn_match);
DlMacDataHeader_template(const DlMacDataHeader_template& other_value);
~DlMacDataHeader_template();
DlMacDataHeader_template& operator=(template_sel other_value);
DlMacDataHeader_template& operator=(const DlMacDataHeader& other_value);
DlMacDataHeader_template& operator=(const OPTIONAL<DlMacDataHeader>& other_value);
DlMacDataHeader_template& operator=(const DlMacDataHeader_template& other_value);
boolean match(const DlMacDataHeader& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
DlMacDataHeader valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
DlMacDataHeader_template& list_item(unsigned int list_index) const;
DlMacHeader_template& mac__hdr();
const DlMacHeader_template& mac__hdr() const;
DlMacHdrDataExt_template& hdr__ext();
const DlMacHdrDataExt_template& hdr__ext() const;
int size_of() const;
void log() const;
void log_match(const DlMacDataHeader& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 RlcmacDlDataBlock : public Base_Type {
  CodingScheme field_cs;
  DlMacDataHeader field_mac__hdr;
  LlcBlocks field_blocks;
public:
  RlcmacDlDataBlock();
  RlcmacDlDataBlock(const CodingScheme& par_cs,
    const DlMacDataHeader& par_mac__hdr,
    const LlcBlocks& par_blocks);
  RlcmacDlDataBlock(const RlcmacDlDataBlock& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RlcmacDlDataBlock& operator=(const RlcmacDlDataBlock& other_value);
  boolean operator==(const RlcmacDlDataBlock& other_value) const;
  inline boolean operator!=(const RlcmacDlDataBlock& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline CodingScheme& cs()
    {return field_cs;}
  inline const CodingScheme& cs() const
    {return field_cs;}
  inline DlMacDataHeader& mac__hdr()
    {return field_mac__hdr;}
  inline const DlMacDataHeader& mac__hdr() const
    {return field_mac__hdr;}
  inline LlcBlocks& blocks()
    {return field_blocks;}
  inline const LlcBlocks& blocks() const
    {return field_blocks;}
  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 RlcmacDlDataBlock_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RlcmacDlDataBlock_template *list_value;
} value_list;
struct {
RlcmacDlDataBlock_template* precondition;
RlcmacDlDataBlock_template* implied_template;
} implication_;
dynmatch_struct<RlcmacDlDataBlock>* dyn_match;
};

void set_specific();
void copy_value(const RlcmacDlDataBlock& other_value);
void copy_template(const RlcmacDlDataBlock_template& other_value);

public:
RlcmacDlDataBlock_template();
RlcmacDlDataBlock_template(template_sel other_value);
RlcmacDlDataBlock_template(const RlcmacDlDataBlock& other_value);
RlcmacDlDataBlock_template(const OPTIONAL<RlcmacDlDataBlock>& other_value);
RlcmacDlDataBlock_template(RlcmacDlDataBlock_template* p_precondition, RlcmacDlDataBlock_template* p_implied_template);
RlcmacDlDataBlock_template(Dynamic_Match_Interface<RlcmacDlDataBlock>* p_dyn_match);
RlcmacDlDataBlock_template(const RlcmacDlDataBlock_template& other_value);
~RlcmacDlDataBlock_template();
RlcmacDlDataBlock_template& operator=(template_sel other_value);
RlcmacDlDataBlock_template& operator=(const RlcmacDlDataBlock& other_value);
RlcmacDlDataBlock_template& operator=(const OPTIONAL<RlcmacDlDataBlock>& other_value);
RlcmacDlDataBlock_template& operator=(const RlcmacDlDataBlock_template& other_value);
boolean match(const RlcmacDlDataBlock& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
RlcmacDlDataBlock valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RlcmacDlDataBlock_template& list_item(unsigned int list_index) const;
CodingScheme_template& cs();
const CodingScheme_template& cs() const;
DlMacDataHeader_template& mac__hdr();
const DlMacDataHeader_template& mac__hdr() const;
LlcBlocks_template& blocks();
const LlcBlocks_template& blocks() const;
int size_of() const;
void log() const;
void log_match(const RlcmacDlDataBlock& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 EgprsLlcBlockHdr : public Base_Type {
  INTEGER field_length__ind;
  BOOLEAN field_e;
public:
  EgprsLlcBlockHdr();
  EgprsLlcBlockHdr(const INTEGER& par_length__ind,
    const BOOLEAN& par_e);
  EgprsLlcBlockHdr(const EgprsLlcBlockHdr& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  EgprsLlcBlockHdr& operator=(const EgprsLlcBlockHdr& other_value);
  boolean operator==(const EgprsLlcBlockHdr& other_value) const;
  inline boolean operator!=(const EgprsLlcBlockHdr& 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& length__ind()
    {return field_length__ind;}
  inline const INTEGER& length__ind() const
    {return field_length__ind;}
  inline BOOLEAN& e()
    {return field_e;}
  inline const BOOLEAN& e() const
    {return field_e;}
  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 EgprsLlcBlockHdr_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
EgprsLlcBlockHdr_template *list_value;
} value_list;
struct {
EgprsLlcBlockHdr_template* precondition;
EgprsLlcBlockHdr_template* implied_template;
} implication_;
dynmatch_struct<EgprsLlcBlockHdr>* dyn_match;
};

void set_specific();
void copy_value(const EgprsLlcBlockHdr& other_value);
void copy_template(const EgprsLlcBlockHdr_template& other_value);

public:
EgprsLlcBlockHdr_template();
EgprsLlcBlockHdr_template(template_sel other_value);
EgprsLlcBlockHdr_template(const EgprsLlcBlockHdr& other_value);
EgprsLlcBlockHdr_template(const OPTIONAL<EgprsLlcBlockHdr>& other_value);
EgprsLlcBlockHdr_template(EgprsLlcBlockHdr_template* p_precondition, EgprsLlcBlockHdr_template* p_implied_template);
EgprsLlcBlockHdr_template(Dynamic_Match_Interface<EgprsLlcBlockHdr>* p_dyn_match);
EgprsLlcBlockHdr_template(const EgprsLlcBlockHdr_template& other_value);
~EgprsLlcBlockHdr_template();
EgprsLlcBlockHdr_template& operator=(template_sel other_value);
EgprsLlcBlockHdr_template& operator=(const EgprsLlcBlockHdr& other_value);
EgprsLlcBlockHdr_template& operator=(const OPTIONAL<EgprsLlcBlockHdr>& other_value);
EgprsLlcBlockHdr_template& operator=(const EgprsLlcBlockHdr_template& other_value);
boolean match(const EgprsLlcBlockHdr& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
EgprsLlcBlockHdr valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
EgprsLlcBlockHdr_template& list_item(unsigned int list_index) const;
INTEGER_template& length__ind();
const INTEGER_template& length__ind() const;
BOOLEAN_template& e();
const BOOLEAN_template& e() const;
int size_of() const;
void log() const;
void log_match(const EgprsLlcBlockHdr& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 EgprsLlcBlock : public Base_Type {
  OPTIONAL< EgprsLlcBlockHdr > field_hdr;
  OCTETSTRING field_payload;
public:
  EgprsLlcBlock();
  EgprsLlcBlock(const OPTIONAL< EgprsLlcBlockHdr >& par_hdr,
    const OCTETSTRING& par_payload);
  EgprsLlcBlock(const EgprsLlcBlock& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  EgprsLlcBlock& operator=(const EgprsLlcBlock& other_value);
  boolean operator==(const EgprsLlcBlock& other_value) const;
  inline boolean operator!=(const EgprsLlcBlock& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline OPTIONAL< EgprsLlcBlockHdr >& hdr()
    {return field_hdr;}
  inline const OPTIONAL< EgprsLlcBlockHdr >& hdr() const
    {return field_hdr;}
  inline OCTETSTRING& payload()
    {return field_payload;}
  inline const OCTETSTRING& payload() const
    {return field_payload;}
  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 EgprsLlcBlock_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
EgprsLlcBlock_template *list_value;
} value_list;
struct {
EgprsLlcBlock_template* precondition;
EgprsLlcBlock_template* implied_template;
} implication_;
dynmatch_struct<EgprsLlcBlock>* dyn_match;
};

void set_specific();
void copy_value(const EgprsLlcBlock& other_value);
void copy_template(const EgprsLlcBlock_template& other_value);

public:
EgprsLlcBlock_template();
EgprsLlcBlock_template(template_sel other_value);
EgprsLlcBlock_template(const EgprsLlcBlock& other_value);
EgprsLlcBlock_template(const OPTIONAL<EgprsLlcBlock>& other_value);
EgprsLlcBlock_template(EgprsLlcBlock_template* p_precondition, EgprsLlcBlock_template* p_implied_template);
EgprsLlcBlock_template(Dynamic_Match_Interface<EgprsLlcBlock>* p_dyn_match);
EgprsLlcBlock_template(const EgprsLlcBlock_template& other_value);
~EgprsLlcBlock_template();
EgprsLlcBlock_template& operator=(template_sel other_value);
EgprsLlcBlock_template& operator=(const EgprsLlcBlock& other_value);
EgprsLlcBlock_template& operator=(const OPTIONAL<EgprsLlcBlock>& other_value);
EgprsLlcBlock_template& operator=(const EgprsLlcBlock_template& other_value);
boolean match(const EgprsLlcBlock& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
EgprsLlcBlock valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
EgprsLlcBlock_template& list_item(unsigned int list_index) const;
EgprsLlcBlockHdr_template& hdr();
const EgprsLlcBlockHdr_template& hdr() const;
OCTETSTRING_template& payload();
const OCTETSTRING_template& payload() const;
int size_of() const;
void log() const;
void log_match(const EgprsLlcBlock& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 EgprsLlcBlocks : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
EgprsLlcBlock **value_elements;
} *val_ptr;

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

public:
  typedef EgprsLlcBlock of_type;
EgprsLlcBlocks();
EgprsLlcBlocks(null_type other_value);
EgprsLlcBlocks(const EgprsLlcBlocks& other_value);
~EgprsLlcBlocks();

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

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

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

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

EgprsLlcBlocks operator+(const EgprsLlcBlocks& other_value) const;

EgprsLlcBlocks substr(int index, int returncount) const;

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

EgprsLlcBlocks replace(int index, int len, const EgprsLlcBlocks_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 EgprsLlcBlocks_template : public Base_Record_Of_Template {
union {
struct {
int n_elements;
EgprsLlcBlock_template **value_elements;
} single_value;
struct {
unsigned int n_values;
EgprsLlcBlocks_template *list_value;
} value_list;
struct {
EgprsLlcBlocks_template* precondition;
EgprsLlcBlocks_template* implied_template;
} implication_;
dynmatch_struct<EgprsLlcBlocks>* dyn_match;
};
void copy_value(const EgprsLlcBlocks& other_value);
void copy_template(const EgprsLlcBlocks_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:
EgprsLlcBlocks_template();
EgprsLlcBlocks_template(template_sel other_value);
EgprsLlcBlocks_template(null_type other_value);
EgprsLlcBlocks_template(const EgprsLlcBlocks& other_value);
EgprsLlcBlocks_template(const OPTIONAL<EgprsLlcBlocks>& other_value);
EgprsLlcBlocks_template(EgprsLlcBlocks_template* p_precondition, EgprsLlcBlocks_template* p_implied_template);
EgprsLlcBlocks_template(Dynamic_Match_Interface<EgprsLlcBlocks>* p_dyn_match);
EgprsLlcBlocks_template(const EgprsLlcBlocks_template& other_value);
~EgprsLlcBlocks_template();

void clean_up();
EgprsLlcBlocks_template& operator=(template_sel other_value);
EgprsLlcBlocks_template& operator=(null_type other_value);
EgprsLlcBlocks_template& operator=(const EgprsLlcBlocks& other_value);
EgprsLlcBlocks_template& operator=(const OPTIONAL<EgprsLlcBlocks>& other_value);
EgprsLlcBlocks_template& operator=(const EgprsLlcBlocks_template& other_value);

EgprsLlcBlock_template& operator[](int index_value);
EgprsLlcBlock_template& operator[](const INTEGER& index_value);
const EgprsLlcBlock_template& operator[](int index_value) const;
const EgprsLlcBlock_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 EgprsLlcBlocks& other_value, boolean legacy = FALSE) const;
inline boolean is_bound() const 
  {return template_selection != UNINITIALIZED_TEMPLATE; }
boolean is_value() const;
EgprsLlcBlocks valueof() const;
EgprsLlcBlocks substr(int index, int returncount) const;

EgprsLlcBlocks replace(int index, int len, const EgprsLlcBlocks_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
EgprsLlcBlocks_template& list_item(unsigned int list_index);
void log() const;
void log_match(const EgprsLlcBlocks& 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_implicit_omit();
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 EgprsDlMacDataHeader : public Base_Type {
  EgprsHeaderType field_header__type;
  INTEGER field_tfi;
  MacRrbp field_rrbp;
  BITSTRING field_esp;
  INTEGER field_usf;
  INTEGER field_bsn1;
  INTEGER field_bsn2__offset;
  INTEGER field_pr;
  OPTIONAL< INTEGER > field_spb;
  INTEGER field_cps;
public:
  EgprsDlMacDataHeader();
  EgprsDlMacDataHeader(const EgprsHeaderType& par_header__type,
    const INTEGER& par_tfi,
    const MacRrbp& par_rrbp,
    const BITSTRING& par_esp,
    const INTEGER& par_usf,
    const INTEGER& par_bsn1,
    const INTEGER& par_bsn2__offset,
    const INTEGER& par_pr,
    const OPTIONAL< INTEGER >& par_spb,
    const INTEGER& par_cps);
  EgprsDlMacDataHeader(const EgprsDlMacDataHeader& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  EgprsDlMacDataHeader& operator=(const EgprsDlMacDataHeader& other_value);
  boolean operator==(const EgprsDlMacDataHeader& other_value) const;
  inline boolean operator!=(const EgprsDlMacDataHeader& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline EgprsHeaderType& header__type()
    {return field_header__type;}
  inline const EgprsHeaderType& header__type() const
    {return field_header__type;}
  inline INTEGER& tfi()
    {return field_tfi;}
  inline const INTEGER& tfi() const
    {return field_tfi;}
  inline MacRrbp& rrbp()
    {return field_rrbp;}
  inline const MacRrbp& rrbp() const
    {return field_rrbp;}
  inline BITSTRING& esp()
    {return field_esp;}
  inline const BITSTRING& esp() const
    {return field_esp;}
  inline INTEGER& usf()
    {return field_usf;}
  inline const INTEGER& usf() const
    {return field_usf;}
  inline INTEGER& bsn1()
    {return field_bsn1;}
  inline const INTEGER& bsn1() const
    {return field_bsn1;}
  inline INTEGER& bsn2__offset()
    {return field_bsn2__offset;}
  inline const INTEGER& bsn2__offset() const
    {return field_bsn2__offset;}
  inline INTEGER& pr()
    {return field_pr;}
  inline const INTEGER& pr() const
    {return field_pr;}
  inline OPTIONAL< INTEGER >& spb()
    {return field_spb;}
  inline const OPTIONAL< INTEGER >& spb() const
    {return field_spb;}
  inline INTEGER& cps()
    {return field_cps;}
  inline const INTEGER& cps() const
    {return field_cps;}
  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 EgprsDlMacDataHeader_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
EgprsDlMacDataHeader_template *list_value;
} value_list;
struct {
EgprsDlMacDataHeader_template* precondition;
EgprsDlMacDataHeader_template* implied_template;
} implication_;
dynmatch_struct<EgprsDlMacDataHeader>* dyn_match;
};

void set_specific();
void copy_value(const EgprsDlMacDataHeader& other_value);
void copy_template(const EgprsDlMacDataHeader_template& other_value);

public:
EgprsDlMacDataHeader_template();
EgprsDlMacDataHeader_template(template_sel other_value);
EgprsDlMacDataHeader_template(const EgprsDlMacDataHeader& other_value);
EgprsDlMacDataHeader_template(const OPTIONAL<EgprsDlMacDataHeader>& other_value);
EgprsDlMacDataHeader_template(EgprsDlMacDataHeader_template* p_precondition, EgprsDlMacDataHeader_template* p_implied_template);
EgprsDlMacDataHeader_template(Dynamic_Match_Interface<EgprsDlMacDataHeader>* p_dyn_match);
EgprsDlMacDataHeader_template(const EgprsDlMacDataHeader_template& other_value);
~EgprsDlMacDataHeader_template();
EgprsDlMacDataHeader_template& operator=(template_sel other_value);
EgprsDlMacDataHeader_template& operator=(const EgprsDlMacDataHeader& other_value);
EgprsDlMacDataHeader_template& operator=(const OPTIONAL<EgprsDlMacDataHeader>& other_value);
EgprsDlMacDataHeader_template& operator=(const EgprsDlMacDataHeader_template& other_value);
boolean match(const EgprsDlMacDataHeader& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
EgprsDlMacDataHeader valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
EgprsDlMacDataHeader_template& list_item(unsigned int list_index) const;
EgprsHeaderType_template& header__type();
const EgprsHeaderType_template& header__type() const;
INTEGER_template& tfi();
const INTEGER_template& tfi() const;
MacRrbp_template& rrbp();
const MacRrbp_template& rrbp() const;
BITSTRING_template& esp();
const BITSTRING_template& esp() const;
INTEGER_template& usf();
const INTEGER_template& usf() const;
INTEGER_template& bsn1();
const INTEGER_template& bsn1() const;
INTEGER_template& bsn2__offset();
const INTEGER_template& bsn2__offset() const;
INTEGER_template& pr();
const INTEGER_template& pr() const;
INTEGER_template& spb();
const INTEGER_template& spb() const;
INTEGER_template& cps();
const INTEGER_template& cps() const;
int size_of() const;
void log() const;
void log_match(const EgprsDlMacDataHeader& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 RlcmacDlEgprsDataBlock : public Base_Type {
  CodingScheme field_mcs;
  EgprsDlMacDataHeader field_mac__hdr;
  BOOLEAN field_fbi;
  BOOLEAN field_e;
  EgprsLlcBlocks field_blocks;
public:
  RlcmacDlEgprsDataBlock();
  RlcmacDlEgprsDataBlock(const CodingScheme& par_mcs,
    const EgprsDlMacDataHeader& par_mac__hdr,
    const BOOLEAN& par_fbi,
    const BOOLEAN& par_e,
    const EgprsLlcBlocks& par_blocks);
  RlcmacDlEgprsDataBlock(const RlcmacDlEgprsDataBlock& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RlcmacDlEgprsDataBlock& operator=(const RlcmacDlEgprsDataBlock& other_value);
  boolean operator==(const RlcmacDlEgprsDataBlock& other_value) const;
  inline boolean operator!=(const RlcmacDlEgprsDataBlock& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline CodingScheme& mcs()
    {return field_mcs;}
  inline const CodingScheme& mcs() const
    {return field_mcs;}
  inline EgprsDlMacDataHeader& mac__hdr()
    {return field_mac__hdr;}
  inline const EgprsDlMacDataHeader& mac__hdr() const
    {return field_mac__hdr;}
  inline BOOLEAN& fbi()
    {return field_fbi;}
  inline const BOOLEAN& fbi() const
    {return field_fbi;}
  inline BOOLEAN& e()
    {return field_e;}
  inline const BOOLEAN& e() const
    {return field_e;}
  inline EgprsLlcBlocks& blocks()
    {return field_blocks;}
  inline const EgprsLlcBlocks& blocks() const
    {return field_blocks;}
  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 RlcmacDlEgprsDataBlock_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RlcmacDlEgprsDataBlock_template *list_value;
} value_list;
struct {
RlcmacDlEgprsDataBlock_template* precondition;
RlcmacDlEgprsDataBlock_template* implied_template;
} implication_;
dynmatch_struct<RlcmacDlEgprsDataBlock>* dyn_match;
};

void set_specific();
void copy_value(const RlcmacDlEgprsDataBlock& other_value);
void copy_template(const RlcmacDlEgprsDataBlock_template& other_value);

public:
RlcmacDlEgprsDataBlock_template();
RlcmacDlEgprsDataBlock_template(template_sel other_value);
RlcmacDlEgprsDataBlock_template(const RlcmacDlEgprsDataBlock& other_value);
RlcmacDlEgprsDataBlock_template(const OPTIONAL<RlcmacDlEgprsDataBlock>& other_value);
RlcmacDlEgprsDataBlock_template(RlcmacDlEgprsDataBlock_template* p_precondition, RlcmacDlEgprsDataBlock_template* p_implied_template);
RlcmacDlEgprsDataBlock_template(Dynamic_Match_Interface<RlcmacDlEgprsDataBlock>* p_dyn_match);
RlcmacDlEgprsDataBlock_template(const RlcmacDlEgprsDataBlock_template& other_value);
~RlcmacDlEgprsDataBlock_template();
RlcmacDlEgprsDataBlock_template& operator=(template_sel other_value);
RlcmacDlEgprsDataBlock_template& operator=(const RlcmacDlEgprsDataBlock& other_value);
RlcmacDlEgprsDataBlock_template& operator=(const OPTIONAL<RlcmacDlEgprsDataBlock>& other_value);
RlcmacDlEgprsDataBlock_template& operator=(const RlcmacDlEgprsDataBlock_template& other_value);
boolean match(const RlcmacDlEgprsDataBlock& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
RlcmacDlEgprsDataBlock valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RlcmacDlEgprsDataBlock_template& list_item(unsigned int list_index) const;
CodingScheme_template& mcs();
const CodingScheme_template& mcs() const;
EgprsDlMacDataHeader_template& mac__hdr();
const EgprsDlMacDataHeader_template& mac__hdr() const;
BOOLEAN_template& fbi();
const BOOLEAN_template& fbi() const;
BOOLEAN_template& e();
const BOOLEAN_template& e() const;
EgprsLlcBlocks_template& blocks();
const EgprsLlcBlocks_template& blocks() const;
int size_of() const;
void log() const;
void log_match(const RlcmacDlEgprsDataBlock& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 UlMacDataHeader : public Base_Type {
  MacPayloadType field_payload__type;
  INTEGER field_countdown;
  BOOLEAN field_stall__ind;
  BOOLEAN field_retry;
  BITSTRING field_spare;
  BOOLEAN field_pfi__ind;
  INTEGER field_tfi;
  BOOLEAN field_tlli__ind;
  INTEGER field_bsn;
  BOOLEAN field_e;
public:
  UlMacDataHeader();
  UlMacDataHeader(const MacPayloadType& par_payload__type,
    const INTEGER& par_countdown,
    const BOOLEAN& par_stall__ind,
    const BOOLEAN& par_retry,
    const BITSTRING& par_spare,
    const BOOLEAN& par_pfi__ind,
    const INTEGER& par_tfi,
    const BOOLEAN& par_tlli__ind,
    const INTEGER& par_bsn,
    const BOOLEAN& par_e);
  UlMacDataHeader(const UlMacDataHeader& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  UlMacDataHeader& operator=(const UlMacDataHeader& other_value);
  boolean operator==(const UlMacDataHeader& other_value) const;
  inline boolean operator!=(const UlMacDataHeader& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline MacPayloadType& payload__type()
    {return field_payload__type;}
  inline const MacPayloadType& payload__type() const
    {return field_payload__type;}
  inline INTEGER& countdown()
    {return field_countdown;}
  inline const INTEGER& countdown() const
    {return field_countdown;}
  inline BOOLEAN& stall__ind()
    {return field_stall__ind;}
  inline const BOOLEAN& stall__ind() const
    {return field_stall__ind;}
  inline BOOLEAN& retry()
    {return field_retry;}
  inline const BOOLEAN& retry() const
    {return field_retry;}
  inline BITSTRING& spare()
    {return field_spare;}
  inline const BITSTRING& spare() const
    {return field_spare;}
  inline BOOLEAN& pfi__ind()
    {return field_pfi__ind;}
  inline const BOOLEAN& pfi__ind() const
    {return field_pfi__ind;}
  inline INTEGER& tfi()
    {return field_tfi;}
  inline const INTEGER& tfi() const
    {return field_tfi;}
  inline BOOLEAN& tlli__ind()
    {return field_tlli__ind;}
  inline const BOOLEAN& tlli__ind() const
    {return field_tlli__ind;}
  inline INTEGER& bsn()
    {return field_bsn;}
  inline const INTEGER& bsn() const
    {return field_bsn;}
  inline BOOLEAN& e()
    {return field_e;}
  inline const BOOLEAN& e() const
    {return field_e;}
  inline int size_of() const
    {return 10;}
  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 UlMacDataHeader_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
UlMacDataHeader_template *list_value;
} value_list;
struct {
UlMacDataHeader_template* precondition;
UlMacDataHeader_template* implied_template;
} implication_;
dynmatch_struct<UlMacDataHeader>* dyn_match;
};

void set_specific();
void copy_value(const UlMacDataHeader& other_value);
void copy_template(const UlMacDataHeader_template& other_value);

public:
UlMacDataHeader_template();
UlMacDataHeader_template(template_sel other_value);
UlMacDataHeader_template(const UlMacDataHeader& other_value);
UlMacDataHeader_template(const OPTIONAL<UlMacDataHeader>& other_value);
UlMacDataHeader_template(UlMacDataHeader_template* p_precondition, UlMacDataHeader_template* p_implied_template);
UlMacDataHeader_template(Dynamic_Match_Interface<UlMacDataHeader>* p_dyn_match);
UlMacDataHeader_template(const UlMacDataHeader_template& other_value);
~UlMacDataHeader_template();
UlMacDataHeader_template& operator=(template_sel other_value);
UlMacDataHeader_template& operator=(const UlMacDataHeader& other_value);
UlMacDataHeader_template& operator=(const OPTIONAL<UlMacDataHeader>& other_value);
UlMacDataHeader_template& operator=(const UlMacDataHeader_template& other_value);
boolean match(const UlMacDataHeader& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
UlMacDataHeader valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
UlMacDataHeader_template& list_item(unsigned int list_index) const;
MacPayloadType_template& payload__type();
const MacPayloadType_template& payload__type() const;
INTEGER_template& countdown();
const INTEGER_template& countdown() const;
BOOLEAN_template& stall__ind();
const BOOLEAN_template& stall__ind() const;
BOOLEAN_template& retry();
const BOOLEAN_template& retry() const;
BITSTRING_template& spare();
const BITSTRING_template& spare() const;
BOOLEAN_template& pfi__ind();
const BOOLEAN_template& pfi__ind() const;
INTEGER_template& tfi();
const INTEGER_template& tfi() const;
BOOLEAN_template& tlli__ind();
const BOOLEAN_template& tlli__ind() const;
INTEGER_template& bsn();
const INTEGER_template& bsn() const;
BOOLEAN_template& e();
const BOOLEAN_template& e() const;
int size_of() const;
void log() const;
void log_match(const UlMacDataHeader& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 RlcMacUlPfi : public Base_Type {
  INTEGER field_pfi;
  BOOLEAN field_m;
public:
  RlcMacUlPfi();
  RlcMacUlPfi(const INTEGER& par_pfi,
    const BOOLEAN& par_m);
  RlcMacUlPfi(const RlcMacUlPfi& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RlcMacUlPfi& operator=(const RlcMacUlPfi& other_value);
  boolean operator==(const RlcMacUlPfi& other_value) const;
  inline boolean operator!=(const RlcMacUlPfi& 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& pfi()
    {return field_pfi;}
  inline const INTEGER& pfi() const
    {return field_pfi;}
  inline BOOLEAN& m()
    {return field_m;}
  inline const BOOLEAN& m() const
    {return field_m;}
  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 RlcMacUlPfi_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RlcMacUlPfi_template *list_value;
} value_list;
struct {
RlcMacUlPfi_template* precondition;
RlcMacUlPfi_template* implied_template;
} implication_;
dynmatch_struct<RlcMacUlPfi>* dyn_match;
};

void set_specific();
void copy_value(const RlcMacUlPfi& other_value);
void copy_template(const RlcMacUlPfi_template& other_value);

public:
RlcMacUlPfi_template();
RlcMacUlPfi_template(template_sel other_value);
RlcMacUlPfi_template(const RlcMacUlPfi& other_value);
RlcMacUlPfi_template(const OPTIONAL<RlcMacUlPfi>& other_value);
RlcMacUlPfi_template(RlcMacUlPfi_template* p_precondition, RlcMacUlPfi_template* p_implied_template);
RlcMacUlPfi_template(Dynamic_Match_Interface<RlcMacUlPfi>* p_dyn_match);
RlcMacUlPfi_template(const RlcMacUlPfi_template& other_value);
~RlcMacUlPfi_template();
RlcMacUlPfi_template& operator=(template_sel other_value);
RlcMacUlPfi_template& operator=(const RlcMacUlPfi& other_value);
RlcMacUlPfi_template& operator=(const OPTIONAL<RlcMacUlPfi>& other_value);
RlcMacUlPfi_template& operator=(const RlcMacUlPfi_template& other_value);
boolean match(const RlcMacUlPfi& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
RlcMacUlPfi valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RlcMacUlPfi_template& list_item(unsigned int list_index) const;
INTEGER_template& pfi();
const INTEGER_template& pfi() const;
BOOLEAN_template& m();
const BOOLEAN_template& m() const;
int size_of() const;
void log() const;
void log_match(const RlcMacUlPfi& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 EgprsUlMacDataHeader : public Base_Type {
  EgprsHeaderType field_header__type;
  INTEGER field_tfi;
  INTEGER field_countdown;
  BITSTRING field_foi__si;
  BITSTRING field_r__ri;
  INTEGER field_bsn1;
  INTEGER field_bsn2__offset;
  INTEGER field_cps;
  BOOLEAN field_pfi__ind;
  BITSTRING field_rsb;
  OPTIONAL< BITSTRING > field_spb;
public:
  EgprsUlMacDataHeader();
  EgprsUlMacDataHeader(const EgprsHeaderType& par_header__type,
    const INTEGER& par_tfi,
    const INTEGER& par_countdown,
    const BITSTRING& par_foi__si,
    const BITSTRING& par_r__ri,
    const INTEGER& par_bsn1,
    const INTEGER& par_bsn2__offset,
    const INTEGER& par_cps,
    const BOOLEAN& par_pfi__ind,
    const BITSTRING& par_rsb,
    const OPTIONAL< BITSTRING >& par_spb);
  EgprsUlMacDataHeader(const EgprsUlMacDataHeader& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  EgprsUlMacDataHeader& operator=(const EgprsUlMacDataHeader& other_value);
  boolean operator==(const EgprsUlMacDataHeader& other_value) const;
  inline boolean operator!=(const EgprsUlMacDataHeader& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline EgprsHeaderType& header__type()
    {return field_header__type;}
  inline const EgprsHeaderType& header__type() const
    {return field_header__type;}
  inline INTEGER& tfi()
    {return field_tfi;}
  inline const INTEGER& tfi() const
    {return field_tfi;}
  inline INTEGER& countdown()
    {return field_countdown;}
  inline const INTEGER& countdown() const
    {return field_countdown;}
  inline BITSTRING& foi__si()
    {return field_foi__si;}
  inline const BITSTRING& foi__si() const
    {return field_foi__si;}
  inline BITSTRING& r__ri()
    {return field_r__ri;}
  inline const BITSTRING& r__ri() const
    {return field_r__ri;}
  inline INTEGER& bsn1()
    {return field_bsn1;}
  inline const INTEGER& bsn1() const
    {return field_bsn1;}
  inline INTEGER& bsn2__offset()
    {return field_bsn2__offset;}
  inline const INTEGER& bsn2__offset() const
    {return field_bsn2__offset;}
  inline INTEGER& cps()
    {return field_cps;}
  inline const INTEGER& cps() const
    {return field_cps;}
  inline BOOLEAN& pfi__ind()
    {return field_pfi__ind;}
  inline const BOOLEAN& pfi__ind() const
    {return field_pfi__ind;}
  inline BITSTRING& rsb()
    {return field_rsb;}
  inline const BITSTRING& rsb() const
    {return field_rsb;}
  inline OPTIONAL< BITSTRING >& spb()
    {return field_spb;}
  inline const OPTIONAL< BITSTRING >& spb() const
    {return field_spb;}
  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 EgprsUlMacDataHeader_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
EgprsUlMacDataHeader_template *list_value;
} value_list;
struct {
EgprsUlMacDataHeader_template* precondition;
EgprsUlMacDataHeader_template* implied_template;
} implication_;
dynmatch_struct<EgprsUlMacDataHeader>* dyn_match;
};

void set_specific();
void copy_value(const EgprsUlMacDataHeader& other_value);
void copy_template(const EgprsUlMacDataHeader_template& other_value);

public:
EgprsUlMacDataHeader_template();
EgprsUlMacDataHeader_template(template_sel other_value);
EgprsUlMacDataHeader_template(const EgprsUlMacDataHeader& other_value);
EgprsUlMacDataHeader_template(const OPTIONAL<EgprsUlMacDataHeader>& other_value);
EgprsUlMacDataHeader_template(EgprsUlMacDataHeader_template* p_precondition, EgprsUlMacDataHeader_template* p_implied_template);
EgprsUlMacDataHeader_template(Dynamic_Match_Interface<EgprsUlMacDataHeader>* p_dyn_match);
EgprsUlMacDataHeader_template(const EgprsUlMacDataHeader_template& other_value);
~EgprsUlMacDataHeader_template();
EgprsUlMacDataHeader_template& operator=(template_sel other_value);
EgprsUlMacDataHeader_template& operator=(const EgprsUlMacDataHeader& other_value);
EgprsUlMacDataHeader_template& operator=(const OPTIONAL<EgprsUlMacDataHeader>& other_value);
EgprsUlMacDataHeader_template& operator=(const EgprsUlMacDataHeader_template& other_value);
boolean match(const EgprsUlMacDataHeader& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
EgprsUlMacDataHeader valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
EgprsUlMacDataHeader_template& list_item(unsigned int list_index) const;
EgprsHeaderType_template& header__type();
const EgprsHeaderType_template& header__type() const;
INTEGER_template& tfi();
const INTEGER_template& tfi() const;
INTEGER_template& countdown();
const INTEGER_template& countdown() const;
BITSTRING_template& foi__si();
const BITSTRING_template& foi__si() const;
BITSTRING_template& r__ri();
const BITSTRING_template& r__ri() const;
INTEGER_template& bsn1();
const INTEGER_template& bsn1() const;
INTEGER_template& bsn2__offset();
const INTEGER_template& bsn2__offset() const;
INTEGER_template& cps();
const INTEGER_template& cps() const;
BOOLEAN_template& pfi__ind();
const BOOLEAN_template& pfi__ind() const;
BITSTRING_template& rsb();
const BITSTRING_template& rsb() const;
BITSTRING_template& spb();
const BITSTRING_template& spb() const;
int size_of() const;
void log() const;
void log_match(const EgprsUlMacDataHeader& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 RlcmacUlEgprsDataBlock : public Base_Type {
  CodingScheme field_mcs;
  EgprsUlMacDataHeader field_mac__hdr;
  BOOLEAN field_tlli__ind;
  BOOLEAN field_e;
  OPTIONAL< OCTETSTRING > field_tlli;
  OPTIONAL< RlcMacUlPfi > field_pfi;
  EgprsLlcBlocks field_blocks;
public:
  RlcmacUlEgprsDataBlock();
  RlcmacUlEgprsDataBlock(const CodingScheme& par_mcs,
    const EgprsUlMacDataHeader& par_mac__hdr,
    const BOOLEAN& par_tlli__ind,
    const BOOLEAN& par_e,
    const OPTIONAL< OCTETSTRING >& par_tlli,
    const OPTIONAL< RlcMacUlPfi >& par_pfi,
    const EgprsLlcBlocks& par_blocks);
  RlcmacUlEgprsDataBlock(const RlcmacUlEgprsDataBlock& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RlcmacUlEgprsDataBlock& operator=(const RlcmacUlEgprsDataBlock& other_value);
  boolean operator==(const RlcmacUlEgprsDataBlock& other_value) const;
  inline boolean operator!=(const RlcmacUlEgprsDataBlock& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline CodingScheme& mcs()
    {return field_mcs;}
  inline const CodingScheme& mcs() const
    {return field_mcs;}
  inline EgprsUlMacDataHeader& mac__hdr()
    {return field_mac__hdr;}
  inline const EgprsUlMacDataHeader& mac__hdr() const
    {return field_mac__hdr;}
  inline BOOLEAN& tlli__ind()
    {return field_tlli__ind;}
  inline const BOOLEAN& tlli__ind() const
    {return field_tlli__ind;}
  inline BOOLEAN& e()
    {return field_e;}
  inline const BOOLEAN& e() const
    {return field_e;}
  inline OPTIONAL< OCTETSTRING >& tlli()
    {return field_tlli;}
  inline const OPTIONAL< OCTETSTRING >& tlli() const
    {return field_tlli;}
  inline OPTIONAL< RlcMacUlPfi >& pfi()
    {return field_pfi;}
  inline const OPTIONAL< RlcMacUlPfi >& pfi() const
    {return field_pfi;}
  inline EgprsLlcBlocks& blocks()
    {return field_blocks;}
  inline const EgprsLlcBlocks& blocks() const
    {return field_blocks;}
  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 RlcmacUlEgprsDataBlock_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RlcmacUlEgprsDataBlock_template *list_value;
} value_list;
struct {
RlcmacUlEgprsDataBlock_template* precondition;
RlcmacUlEgprsDataBlock_template* implied_template;
} implication_;
dynmatch_struct<RlcmacUlEgprsDataBlock>* dyn_match;
};

void set_specific();
void copy_value(const RlcmacUlEgprsDataBlock& other_value);
void copy_template(const RlcmacUlEgprsDataBlock_template& other_value);

public:
RlcmacUlEgprsDataBlock_template();
RlcmacUlEgprsDataBlock_template(template_sel other_value);
RlcmacUlEgprsDataBlock_template(const RlcmacUlEgprsDataBlock& other_value);
RlcmacUlEgprsDataBlock_template(const OPTIONAL<RlcmacUlEgprsDataBlock>& other_value);
RlcmacUlEgprsDataBlock_template(RlcmacUlEgprsDataBlock_template* p_precondition, RlcmacUlEgprsDataBlock_template* p_implied_template);
RlcmacUlEgprsDataBlock_template(Dynamic_Match_Interface<RlcmacUlEgprsDataBlock>* p_dyn_match);
RlcmacUlEgprsDataBlock_template(const RlcmacUlEgprsDataBlock_template& other_value);
~RlcmacUlEgprsDataBlock_template();
RlcmacUlEgprsDataBlock_template& operator=(template_sel other_value);
RlcmacUlEgprsDataBlock_template& operator=(const RlcmacUlEgprsDataBlock& other_value);
RlcmacUlEgprsDataBlock_template& operator=(const OPTIONAL<RlcmacUlEgprsDataBlock>& other_value);
RlcmacUlEgprsDataBlock_template& operator=(const RlcmacUlEgprsDataBlock_template& other_value);
boolean match(const RlcmacUlEgprsDataBlock& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
RlcmacUlEgprsDataBlock valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RlcmacUlEgprsDataBlock_template& list_item(unsigned int list_index) const;
CodingScheme_template& mcs();
const CodingScheme_template& mcs() const;
EgprsUlMacDataHeader_template& mac__hdr();
const EgprsUlMacDataHeader_template& mac__hdr() const;
BOOLEAN_template& tlli__ind();
const BOOLEAN_template& tlli__ind() const;
BOOLEAN_template& e();
const BOOLEAN_template& e() const;
OCTETSTRING_template& tlli();
const OCTETSTRING_template& tlli() const;
RlcMacUlPfi_template& pfi();
const RlcMacUlPfi_template& pfi() const;
EgprsLlcBlocks_template& blocks();
const EgprsLlcBlocks_template& blocks() const;
int size_of() const;
void log() const;
void log_match(const RlcmacUlEgprsDataBlock& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 RlcmacUlDataBlock : public Base_Type {
  CodingScheme field_cs;
  UlMacDataHeader field_mac__hdr;
  OPTIONAL< OCTETSTRING > field_tlli;
  OPTIONAL< RlcMacUlPfi > field_pfi;
  LlcBlocks field_blocks;
public:
  RlcmacUlDataBlock();
  RlcmacUlDataBlock(const CodingScheme& par_cs,
    const UlMacDataHeader& par_mac__hdr,
    const OPTIONAL< OCTETSTRING >& par_tlli,
    const OPTIONAL< RlcMacUlPfi >& par_pfi,
    const LlcBlocks& par_blocks);
  RlcmacUlDataBlock(const RlcmacUlDataBlock& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RlcmacUlDataBlock& operator=(const RlcmacUlDataBlock& other_value);
  boolean operator==(const RlcmacUlDataBlock& other_value) const;
  inline boolean operator!=(const RlcmacUlDataBlock& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline CodingScheme& cs()
    {return field_cs;}
  inline const CodingScheme& cs() const
    {return field_cs;}
  inline UlMacDataHeader& mac__hdr()
    {return field_mac__hdr;}
  inline const UlMacDataHeader& mac__hdr() const
    {return field_mac__hdr;}
  inline OPTIONAL< OCTETSTRING >& tlli()
    {return field_tlli;}
  inline const OPTIONAL< OCTETSTRING >& tlli() const
    {return field_tlli;}
  inline OPTIONAL< RlcMacUlPfi >& pfi()
    {return field_pfi;}
  inline const OPTIONAL< RlcMacUlPfi >& pfi() const
    {return field_pfi;}
  inline LlcBlocks& blocks()
    {return field_blocks;}
  inline const LlcBlocks& blocks() const
    {return field_blocks;}
  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 RlcmacUlDataBlock_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RlcmacUlDataBlock_template *list_value;
} value_list;
struct {
RlcmacUlDataBlock_template* precondition;
RlcmacUlDataBlock_template* implied_template;
} implication_;
dynmatch_struct<RlcmacUlDataBlock>* dyn_match;
};

void set_specific();
void copy_value(const RlcmacUlDataBlock& other_value);
void copy_template(const RlcmacUlDataBlock_template& other_value);

public:
RlcmacUlDataBlock_template();
RlcmacUlDataBlock_template(template_sel other_value);
RlcmacUlDataBlock_template(const RlcmacUlDataBlock& other_value);
RlcmacUlDataBlock_template(const OPTIONAL<RlcmacUlDataBlock>& other_value);
RlcmacUlDataBlock_template(RlcmacUlDataBlock_template* p_precondition, RlcmacUlDataBlock_template* p_implied_template);
RlcmacUlDataBlock_template(Dynamic_Match_Interface<RlcmacUlDataBlock>* p_dyn_match);
RlcmacUlDataBlock_template(const RlcmacUlDataBlock_template& other_value);
~RlcmacUlDataBlock_template();
RlcmacUlDataBlock_template& operator=(template_sel other_value);
RlcmacUlDataBlock_template& operator=(const RlcmacUlDataBlock& other_value);
RlcmacUlDataBlock_template& operator=(const OPTIONAL<RlcmacUlDataBlock>& other_value);
RlcmacUlDataBlock_template& operator=(const RlcmacUlDataBlock_template& other_value);
boolean match(const RlcmacUlDataBlock& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
RlcmacUlDataBlock valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RlcmacUlDataBlock_template& list_item(unsigned int list_index) const;
CodingScheme_template& cs();
const CodingScheme_template& cs() const;
UlMacDataHeader_template& mac__hdr();
const UlMacDataHeader_template& mac__hdr() const;
OCTETSTRING_template& tlli();
const OCTETSTRING_template& tlli() const;
RlcMacUlPfi_template& pfi();
const RlcMacUlPfi_template& pfi() const;
LlcBlocks_template& blocks();
const LlcBlocks_template& blocks() const;
int size_of() const;
void log() const;
void log_match(const RlcmacUlDataBlock& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 RlcmacUlBlock : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_data = 1, ALT_data__egprs = 2, ALT_ctrl = 3 };
private:
union_selection_type union_selection;
union {
RlcmacUlDataBlock *field_data;
RlcmacUlEgprsDataBlock *field_data__egprs;
RlcmacUlCtrlBlock *field_ctrl;
};
void copy_value(const RlcmacUlBlock& other_value);

public:
RlcmacUlBlock();
RlcmacUlBlock(const RlcmacUlBlock& other_value);
~RlcmacUlBlock();
RlcmacUlBlock& operator=(const RlcmacUlBlock& other_value);
boolean operator==(const RlcmacUlBlock& other_value) const;
inline boolean operator!=(const RlcmacUlBlock& other_value) const { return !(*this == other_value); }
RlcmacUlDataBlock& data();
const RlcmacUlDataBlock& data() const;
RlcmacUlEgprsDataBlock& data__egprs();
const RlcmacUlEgprsDataBlock& data__egprs() const;
RlcmacUlCtrlBlock& ctrl();
const RlcmacUlCtrlBlock& ctrl() 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 RlcmacUlBlock_template : public Base_Template {
union {
struct {
RlcmacUlBlock::union_selection_type union_selection;
union {
RlcmacUlDataBlock_template *field_data;
RlcmacUlEgprsDataBlock_template *field_data__egprs;
RlcmacUlCtrlBlock_template *field_ctrl;
};
} single_value;
struct {
unsigned int n_values;
RlcmacUlBlock_template *list_value;
} value_list;
struct {
RlcmacUlBlock_template* precondition;
RlcmacUlBlock_template* implied_template;
} implication_;
dynmatch_struct<RlcmacUlBlock>* dyn_match;
};
void copy_value(const RlcmacUlBlock& other_value);

void copy_template(const RlcmacUlBlock_template& other_value);

public:
RlcmacUlBlock_template();
RlcmacUlBlock_template(template_sel other_value);
RlcmacUlBlock_template(const RlcmacUlBlock& other_value);
RlcmacUlBlock_template(const OPTIONAL<RlcmacUlBlock>& other_value);
RlcmacUlBlock_template(RlcmacUlBlock_template* p_precondition, RlcmacUlBlock_template* p_implied_template);
RlcmacUlBlock_template(Dynamic_Match_Interface<RlcmacUlBlock>* p_dyn_match);
RlcmacUlBlock_template(const RlcmacUlBlock_template& other_value);
~RlcmacUlBlock_template();
void clean_up();
RlcmacUlBlock_template& operator=(template_sel other_value);
RlcmacUlBlock_template& operator=(const RlcmacUlBlock& other_value);
RlcmacUlBlock_template& operator=(const OPTIONAL<RlcmacUlBlock>& other_value);
RlcmacUlBlock_template& operator=(const RlcmacUlBlock_template& other_value);
boolean match(const RlcmacUlBlock& other_value, boolean legacy = FALSE) const;
boolean is_value() const;RlcmacUlBlock valueof() const;
RlcmacUlBlock_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
RlcmacUlDataBlock_template& data();
const RlcmacUlDataBlock_template& data() const;
RlcmacUlEgprsDataBlock_template& data__egprs();
const RlcmacUlEgprsDataBlock_template& data__egprs() const;
RlcmacUlCtrlBlock_template& ctrl();
const RlcmacUlCtrlBlock_template& ctrl() const;
boolean ischosen(RlcmacUlBlock::union_selection_type checked_selection) const;
void log() const;
void log_match(const RlcmacUlBlock& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 RlcmacDlBlock : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_data = 1, ALT_data__egprs = 2, ALT_ctrl = 3 };
private:
union_selection_type union_selection;
union {
RlcmacDlDataBlock *field_data;
RlcmacDlEgprsDataBlock *field_data__egprs;
RlcmacDlCtrlBlock *field_ctrl;
};
void copy_value(const RlcmacDlBlock& other_value);

public:
RlcmacDlBlock();
RlcmacDlBlock(const RlcmacDlBlock& other_value);
~RlcmacDlBlock();
RlcmacDlBlock& operator=(const RlcmacDlBlock& other_value);
boolean operator==(const RlcmacDlBlock& other_value) const;
inline boolean operator!=(const RlcmacDlBlock& other_value) const { return !(*this == other_value); }
RlcmacDlDataBlock& data();
const RlcmacDlDataBlock& data() const;
RlcmacDlEgprsDataBlock& data__egprs();
const RlcmacDlEgprsDataBlock& data__egprs() const;
RlcmacDlCtrlBlock& ctrl();
const RlcmacDlCtrlBlock& ctrl() 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 RlcmacDlBlock_template : public Base_Template {
union {
struct {
RlcmacDlBlock::union_selection_type union_selection;
union {
RlcmacDlDataBlock_template *field_data;
RlcmacDlEgprsDataBlock_template *field_data__egprs;
RlcmacDlCtrlBlock_template *field_ctrl;
};
} single_value;
struct {
unsigned int n_values;
RlcmacDlBlock_template *list_value;
} value_list;
struct {
RlcmacDlBlock_template* precondition;
RlcmacDlBlock_template* implied_template;
} implication_;
dynmatch_struct<RlcmacDlBlock>* dyn_match;
};
void copy_value(const RlcmacDlBlock& other_value);

void copy_template(const RlcmacDlBlock_template& other_value);

public:
RlcmacDlBlock_template();
RlcmacDlBlock_template(template_sel other_value);
RlcmacDlBlock_template(const RlcmacDlBlock& other_value);
RlcmacDlBlock_template(const OPTIONAL<RlcmacDlBlock>& other_value);
RlcmacDlBlock_template(RlcmacDlBlock_template* p_precondition, RlcmacDlBlock_template* p_implied_template);
RlcmacDlBlock_template(Dynamic_Match_Interface<RlcmacDlBlock>* p_dyn_match);
RlcmacDlBlock_template(const RlcmacDlBlock_template& other_value);
~RlcmacDlBlock_template();
void clean_up();
RlcmacDlBlock_template& operator=(template_sel other_value);
RlcmacDlBlock_template& operator=(const RlcmacDlBlock& other_value);
RlcmacDlBlock_template& operator=(const OPTIONAL<RlcmacDlBlock>& other_value);
RlcmacDlBlock_template& operator=(const RlcmacDlBlock_template& other_value);
boolean match(const RlcmacDlBlock& other_value, boolean legacy = FALSE) const;
boolean is_value() const;RlcmacDlBlock valueof() const;
RlcmacDlBlock_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
RlcmacDlDataBlock_template& data();
const RlcmacDlDataBlock_template& data() const;
RlcmacDlEgprsDataBlock_template& data__egprs();
const RlcmacDlEgprsDataBlock_template& data__egprs() const;
RlcmacDlCtrlBlock_template& ctrl();
const RlcmacDlCtrlBlock_template& ctrl() const;
boolean ischosen(RlcmacDlBlock::union_selection_type checked_selection) const;
void log() const;
void log_match(const RlcmacDlBlock& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 PTCCHTimingAdvanceIE : public Base_Type {
  BITSTRING field_spare;
  INTEGER field_ta__val;
public:
  PTCCHTimingAdvanceIE();
  PTCCHTimingAdvanceIE(const BITSTRING& par_spare,
    const INTEGER& par_ta__val);
  PTCCHTimingAdvanceIE(const PTCCHTimingAdvanceIE& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  PTCCHTimingAdvanceIE& operator=(const PTCCHTimingAdvanceIE& other_value);
  boolean operator==(const PTCCHTimingAdvanceIE& other_value) const;
  inline boolean operator!=(const PTCCHTimingAdvanceIE& 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& ta__val()
    {return field_ta__val;}
  inline const INTEGER& ta__val() const
    {return field_ta__val;}
  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 PTCCHTimingAdvanceIE_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
PTCCHTimingAdvanceIE_template *list_value;
} value_list;
struct {
PTCCHTimingAdvanceIE_template* precondition;
PTCCHTimingAdvanceIE_template* implied_template;
} implication_;
dynmatch_struct<PTCCHTimingAdvanceIE>* dyn_match;
};

void set_specific();
void copy_value(const PTCCHTimingAdvanceIE& other_value);
void copy_template(const PTCCHTimingAdvanceIE_template& other_value);

public:
PTCCHTimingAdvanceIE_template();
PTCCHTimingAdvanceIE_template(template_sel other_value);
PTCCHTimingAdvanceIE_template(const PTCCHTimingAdvanceIE& other_value);
PTCCHTimingAdvanceIE_template(const OPTIONAL<PTCCHTimingAdvanceIE>& other_value);
PTCCHTimingAdvanceIE_template(PTCCHTimingAdvanceIE_template* p_precondition, PTCCHTimingAdvanceIE_template* p_implied_template);
PTCCHTimingAdvanceIE_template(Dynamic_Match_Interface<PTCCHTimingAdvanceIE>* p_dyn_match);
PTCCHTimingAdvanceIE_template(const PTCCHTimingAdvanceIE_template& other_value);
~PTCCHTimingAdvanceIE_template();
PTCCHTimingAdvanceIE_template& operator=(template_sel other_value);
PTCCHTimingAdvanceIE_template& operator=(const PTCCHTimingAdvanceIE& other_value);
PTCCHTimingAdvanceIE_template& operator=(const OPTIONAL<PTCCHTimingAdvanceIE>& other_value);
PTCCHTimingAdvanceIE_template& operator=(const PTCCHTimingAdvanceIE_template& other_value);
boolean match(const PTCCHTimingAdvanceIE& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
PTCCHTimingAdvanceIE valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
PTCCHTimingAdvanceIE_template& list_item(unsigned int list_index) const;
BITSTRING_template& spare();
const BITSTRING_template& spare() const;
INTEGER_template& ta__val();
const INTEGER_template& ta__val() const;
int size_of() const;
void log() const;
void log_match(const PTCCHTimingAdvanceIE& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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 PTCCHTimingAdvanceIEs : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
PTCCHTimingAdvanceIE **value_elements;
} *val_ptr;

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

public:
  typedef PTCCHTimingAdvanceIE of_type;
PTCCHTimingAdvanceIEs();
PTCCHTimingAdvanceIEs(null_type other_value);
PTCCHTimingAdvanceIEs(const PTCCHTimingAdvanceIEs& other_value);
~PTCCHTimingAdvanceIEs();

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

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

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

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

PTCCHTimingAdvanceIEs operator+(const PTCCHTimingAdvanceIEs& other_value) const;

PTCCHTimingAdvanceIEs substr(int index, int returncount) const;

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

PTCCHTimingAdvanceIEs replace(int index, int len, const PTCCHTimingAdvanceIEs_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 PTCCHTimingAdvanceIEs_template : public Base_Record_Of_Template {
union {
struct {
int n_elements;
PTCCHTimingAdvanceIE_template **value_elements;
} single_value;
struct {
unsigned int n_values;
PTCCHTimingAdvanceIEs_template *list_value;
} value_list;
struct {
PTCCHTimingAdvanceIEs_template* precondition;
PTCCHTimingAdvanceIEs_template* implied_template;
} implication_;
dynmatch_struct<PTCCHTimingAdvanceIEs>* dyn_match;
};
void copy_value(const PTCCHTimingAdvanceIEs& other_value);
void copy_template(const PTCCHTimingAdvanceIEs_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:
PTCCHTimingAdvanceIEs_template();
PTCCHTimingAdvanceIEs_template(template_sel other_value);
PTCCHTimingAdvanceIEs_template(null_type other_value);
PTCCHTimingAdvanceIEs_template(const PTCCHTimingAdvanceIEs& other_value);
PTCCHTimingAdvanceIEs_template(const OPTIONAL<PTCCHTimingAdvanceIEs>& other_value);
PTCCHTimingAdvanceIEs_template(PTCCHTimingAdvanceIEs_template* p_precondition, PTCCHTimingAdvanceIEs_template* p_implied_template);
PTCCHTimingAdvanceIEs_template(Dynamic_Match_Interface<PTCCHTimingAdvanceIEs>* p_dyn_match);
PTCCHTimingAdvanceIEs_template(const PTCCHTimingAdvanceIEs_template& other_value);
~PTCCHTimingAdvanceIEs_template();

void clean_up();
PTCCHTimingAdvanceIEs_template& operator=(template_sel other_value);
PTCCHTimingAdvanceIEs_template& operator=(null_type other_value);
PTCCHTimingAdvanceIEs_template& operator=(const PTCCHTimingAdvanceIEs& other_value);
PTCCHTimingAdvanceIEs_template& operator=(const OPTIONAL<PTCCHTimingAdvanceIEs>& other_value);
PTCCHTimingAdvanceIEs_template& operator=(const PTCCHTimingAdvanceIEs_template& other_value);

PTCCHTimingAdvanceIE_template& operator[](int index_value);
PTCCHTimingAdvanceIE_template& operator[](const INTEGER& index_value);
const PTCCHTimingAdvanceIE_template& operator[](int index_value) const;
const PTCCHTimingAdvanceIE_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 PTCCHTimingAdvanceIEs& other_value, boolean legacy = FALSE) const;
inline boolean is_bound() const 
  {return template_selection != UNINITIALIZED_TEMPLATE; }
boolean is_value() const;
PTCCHTimingAdvanceIEs valueof() const;
PTCCHTimingAdvanceIEs substr(int index, int returncount) const;

PTCCHTimingAdvanceIEs replace(int index, int len, const PTCCHTimingAdvanceIEs_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
PTCCHTimingAdvanceIEs_template& list_item(unsigned int list_index);
void log() const;
void log_match(const PTCCHTimingAdvanceIEs& 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_implicit_omit();
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 PTCCHDownlinkMsg : public Base_Type {
  PTCCHTimingAdvanceIEs field_ta__idx;
  OCTETSTRING field_padding;
public:
  PTCCHDownlinkMsg();
  PTCCHDownlinkMsg(const PTCCHTimingAdvanceIEs& par_ta__idx,
    const OCTETSTRING& par_padding);
  PTCCHDownlinkMsg(const PTCCHDownlinkMsg& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  PTCCHDownlinkMsg& operator=(const PTCCHDownlinkMsg& other_value);
  boolean operator==(const PTCCHDownlinkMsg& other_value) const;
  inline boolean operator!=(const PTCCHDownlinkMsg& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline PTCCHTimingAdvanceIEs& ta__idx()
    {return field_ta__idx;}
  inline const PTCCHTimingAdvanceIEs& ta__idx() const
    {return field_ta__idx;}
  inline OCTETSTRING& padding()
    {return field_padding;}
  inline const OCTETSTRING& padding() const
    {return field_padding;}
  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 PTCCHDownlinkMsg_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
PTCCHDownlinkMsg_template *list_value;
} value_list;
struct {
PTCCHDownlinkMsg_template* precondition;
PTCCHDownlinkMsg_template* implied_template;
} implication_;
dynmatch_struct<PTCCHDownlinkMsg>* dyn_match;
};

void set_specific();
void copy_value(const PTCCHDownlinkMsg& other_value);
void copy_template(const PTCCHDownlinkMsg_template& other_value);

public:
PTCCHDownlinkMsg_template();
PTCCHDownlinkMsg_template(template_sel other_value);
PTCCHDownlinkMsg_template(const PTCCHDownlinkMsg& other_value);
PTCCHDownlinkMsg_template(const OPTIONAL<PTCCHDownlinkMsg>& other_value);
PTCCHDownlinkMsg_template(PTCCHDownlinkMsg_template* p_precondition, PTCCHDownlinkMsg_template* p_implied_template);
PTCCHDownlinkMsg_template(Dynamic_Match_Interface<PTCCHDownlinkMsg>* p_dyn_match);
PTCCHDownlinkMsg_template(const PTCCHDownlinkMsg_template& other_value);
~PTCCHDownlinkMsg_template();
PTCCHDownlinkMsg_template& operator=(template_sel other_value);
PTCCHDownlinkMsg_template& operator=(const PTCCHDownlinkMsg& other_value);
PTCCHDownlinkMsg_template& operator=(const OPTIONAL<PTCCHDownlinkMsg>& other_value);
PTCCHDownlinkMsg_template& operator=(const PTCCHDownlinkMsg_template& other_value);
boolean match(const PTCCHDownlinkMsg& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
PTCCHDownlinkMsg valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
PTCCHDownlinkMsg_template& list_item(unsigned int list_index) const;
PTCCHTimingAdvanceIEs_template& ta__idx();
const PTCCHTimingAdvanceIEs_template& ta__idx() const;
OCTETSTRING_template& padding();
const OCTETSTRING_template& padding() const;
int size_of() const;
void log() const;
void log_match(const PTCCHDownlinkMsg& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
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;
};


/* Function prototypes */

extern void MacPayloadType_encoder(const MacPayloadType& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER MacPayloadType_decoder(OCTETSTRING& input_stream, MacPayloadType& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void MacRrbp_encoder(const MacRrbp& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER MacRrbp_decoder(OCTETSTRING& input_stream, MacRrbp& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsHeaderType_encoder(const EgprsHeaderType& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsHeaderType_decoder(OCTETSTRING& input_stream, EgprsHeaderType& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void CodingScheme_encoder(const CodingScheme& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER CodingScheme_decoder(OCTETSTRING& input_stream, CodingScheme& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern boolean operator==(null_type null_value, const CodingSchemeArray& other_value);
inline boolean operator!=(null_type null_value, const CodingSchemeArray& other_value) { return !(null_value == other_value); }
extern void CodingSchemeArray_0_encoder(const CodingScheme& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER CodingSchemeArray_0_decoder(OCTETSTRING& input_stream, CodingScheme& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void CodingSchemeArray_encoder(const CodingSchemeArray& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER CodingSchemeArray_decoder(OCTETSTRING& input_stream, CodingSchemeArray& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlMacHeader_payload__type_encoder(const MacPayloadType& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlMacHeader_payload__type_decoder(OCTETSTRING& input_stream, MacPayloadType& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlMacHeader_rrbp_encoder(const MacRrbp& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlMacHeader_rrbp_decoder(OCTETSTRING& input_stream, MacRrbp& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlMacHeader_rrbp__valid_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlMacHeader_rrbp__valid_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlMacHeader_usf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlMacHeader_usf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlMacHeader_encoder(const DlMacHeader& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlMacHeader_decoder(OCTETSTRING& input_stream, DlMacHeader& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void PowerReduction_encoder(const PowerReduction& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PowerReduction_decoder(OCTETSTRING& input_stream, PowerReduction& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DirectionBit_encoder(const DirectionBit& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DirectionBit_decoder(OCTETSTRING& input_stream, DirectionBit& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void TfiOctet_pr_encoder(const PowerReduction& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER TfiOctet_pr_decoder(OCTETSTRING& input_stream, PowerReduction& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void TfiOctet_tfi_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER TfiOctet_tfi_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void TfiOctet_d_encoder(const DirectionBit& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER TfiOctet_d_decoder(OCTETSTRING& input_stream, DirectionBit& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void TfiOctet_encoder(const TfiOctet& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER TfiOctet_decoder(OCTETSTRING& input_stream, TfiOctet& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RbsnExtOctet_rbsn__e_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RbsnExtOctet_rbsn__e_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RbsnExtOctet_fs__e_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RbsnExtOctet_fs__e_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RbsnExtOctet_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RbsnExtOctet_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RbsnExtOctet_encoder(const RbsnExtOctet& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RbsnExtOctet_decoder(OCTETSTRING& input_stream, RbsnExtOctet& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlCtrlOptOctets_rbsn_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlCtrlOptOctets_rbsn_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlCtrlOptOctets_rti_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlCtrlOptOctets_rti_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlCtrlOptOctets_fs_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlCtrlOptOctets_fs_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlCtrlOptOctets_tfi__octet__present_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlCtrlOptOctets_tfi__octet__present_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlCtrlOptOctets_tfi_encoder(const TfiOctet& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlCtrlOptOctets_tfi_decoder(OCTETSTRING& input_stream, TfiOctet& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlCtrlOptOctets_rbsn__ext_encoder(const RbsnExtOctet& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlCtrlOptOctets_rbsn__ext_decoder(OCTETSTRING& input_stream, RbsnExtOctet& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlCtrlOptOctets_encoder(const DlCtrlOptOctets& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlCtrlOptOctets_decoder(OCTETSTRING& input_stream, DlCtrlOptOctets& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacDlCtrlBlock_mac__hdr_encoder(const DlMacHeader& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacDlCtrlBlock_mac__hdr_decoder(OCTETSTRING& input_stream, DlMacHeader& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacDlCtrlBlock_payload_encoder(const RLCMAC__CSN1__Types::RlcmacDlCtrlMsg& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacDlCtrlBlock_payload_decoder(OCTETSTRING& input_stream, RLCMAC__CSN1__Types::RlcmacDlCtrlMsg& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacDlCtrlBlock_opt_encoder(const DlCtrlOptOctets& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacDlCtrlBlock_opt_decoder(OCTETSTRING& input_stream, DlCtrlOptOctets& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacDlCtrlBlock_encoder(const RlcmacDlCtrlBlock& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacDlCtrlBlock_decoder(OCTETSTRING& input_stream, RlcmacDlCtrlBlock& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern OCTETSTRING enc__RlcmacDlCtrlBlock(const RlcmacDlCtrlBlock& si);
extern RlcmacDlCtrlBlock dec__RlcmacDlCtrlBlock(const OCTETSTRING& stream);
extern void UlMacCtrlHeader_payload__type_encoder(const MacPayloadType& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER UlMacCtrlHeader_payload__type_decoder(OCTETSTRING& input_stream, MacPayloadType& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void UlMacCtrlHeader_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER UlMacCtrlHeader_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void UlMacCtrlHeader_retry_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER UlMacCtrlHeader_retry_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void UlMacCtrlHeader_encoder(const UlMacCtrlHeader& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER UlMacCtrlHeader_decoder(OCTETSTRING& input_stream, UlMacCtrlHeader& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacUlCtrlBlock_mac__hdr_encoder(const UlMacCtrlHeader& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlCtrlBlock_mac__hdr_decoder(OCTETSTRING& input_stream, UlMacCtrlHeader& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacUlCtrlBlock_payload_encoder(const RLCMAC__CSN1__Types::RlcmacUlCtrlMsg& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlCtrlBlock_payload_decoder(OCTETSTRING& input_stream, RLCMAC__CSN1__Types::RlcmacUlCtrlMsg& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacUlCtrlBlock_encoder(const RlcmacUlCtrlBlock& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlCtrlBlock_decoder(OCTETSTRING& input_stream, RlcmacUlCtrlBlock& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern OCTETSTRING enc__RlcmacUlCtrlBlock(const RlcmacUlCtrlBlock& si);
extern RlcmacUlCtrlBlock dec__RlcmacUlCtrlBlock(const OCTETSTRING& stream);
extern void LlcBlockHdr_length__ind_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER LlcBlockHdr_length__ind_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void LlcBlockHdr_more_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER LlcBlockHdr_more_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void LlcBlockHdr_e_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER LlcBlockHdr_e_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void LlcBlockHdr_encoder(const LlcBlockHdr& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER LlcBlockHdr_decoder(OCTETSTRING& input_stream, LlcBlockHdr& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern OCTETSTRING enc__LlcBlockHdr(const LlcBlockHdr& si);
extern LlcBlockHdr dec__LlcBlockHdr(const OCTETSTRING& stream);
extern void LlcBlock_payload_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER LlcBlock_payload_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void LlcBlock_hdr_encoder(const LlcBlockHdr& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER LlcBlock_hdr_decoder(OCTETSTRING& input_stream, LlcBlockHdr& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void LlcBlock_encoder(const LlcBlock& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER LlcBlock_decoder(OCTETSTRING& input_stream, LlcBlock& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern boolean operator==(null_type null_value, const LlcBlocks& other_value);
inline boolean operator!=(null_type null_value, const LlcBlocks& other_value) { return !(null_value == other_value); }
extern void LlcBlocks_0_encoder(const LlcBlock& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER LlcBlocks_0_decoder(OCTETSTRING& input_stream, LlcBlock& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void LlcBlocks_encoder(const LlcBlocks& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER LlcBlocks_decoder(OCTETSTRING& input_stream, LlcBlocks& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlMacHdrDataExt_pr_encoder(const PowerReduction& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlMacHdrDataExt_pr_decoder(OCTETSTRING& input_stream, PowerReduction& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlMacHdrDataExt_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlMacHdrDataExt_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlMacHdrDataExt_tfi_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlMacHdrDataExt_tfi_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlMacHdrDataExt_fbi_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlMacHdrDataExt_fbi_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlMacHdrDataExt_bsn_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlMacHdrDataExt_bsn_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlMacHdrDataExt_e_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlMacHdrDataExt_e_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlMacHdrDataExt_encoder(const DlMacHdrDataExt& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlMacHdrDataExt_decoder(OCTETSTRING& input_stream, DlMacHdrDataExt& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlMacDataHeader_mac__hdr_encoder(const DlMacHeader& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlMacDataHeader_mac__hdr_decoder(OCTETSTRING& input_stream, DlMacHeader& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlMacDataHeader_hdr__ext_encoder(const DlMacHdrDataExt& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlMacDataHeader_hdr__ext_decoder(OCTETSTRING& input_stream, DlMacHdrDataExt& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void DlMacDataHeader_encoder(const DlMacDataHeader& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER DlMacDataHeader_decoder(OCTETSTRING& input_stream, DlMacDataHeader& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacDlDataBlock_cs_encoder(const CodingScheme& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacDlDataBlock_cs_decoder(OCTETSTRING& input_stream, CodingScheme& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacDlDataBlock_mac__hdr_encoder(const DlMacDataHeader& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacDlDataBlock_mac__hdr_decoder(OCTETSTRING& input_stream, DlMacDataHeader& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacDlDataBlock_blocks_encoder(const LlcBlocks& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacDlDataBlock_blocks_decoder(OCTETSTRING& input_stream, LlcBlocks& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacDlDataBlock_encoder(const RlcmacDlDataBlock& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacDlDataBlock_decoder(OCTETSTRING& input_stream, RlcmacDlDataBlock& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern OCTETSTRING enc__RlcmacDlDataBlock(const RlcmacDlDataBlock& si);
extern RlcmacDlDataBlock dec__RlcmacDlDataBlock(const OCTETSTRING& stream);
extern void EgprsLlcBlockHdr_length__ind_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsLlcBlockHdr_length__ind_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsLlcBlockHdr_e_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsLlcBlockHdr_e_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsLlcBlockHdr_encoder(const EgprsLlcBlockHdr& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsLlcBlockHdr_decoder(OCTETSTRING& input_stream, EgprsLlcBlockHdr& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern OCTETSTRING enc__EgprsLlcBlockHdr(const EgprsLlcBlockHdr& si);
extern EgprsLlcBlockHdr dec__EgprsLlcBlockHdr(const OCTETSTRING& stream);
extern void EgprsLlcBlock_payload_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsLlcBlock_payload_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsLlcBlock_hdr_encoder(const EgprsLlcBlockHdr& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsLlcBlock_hdr_decoder(OCTETSTRING& input_stream, EgprsLlcBlockHdr& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsLlcBlock_encoder(const EgprsLlcBlock& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsLlcBlock_decoder(OCTETSTRING& input_stream, EgprsLlcBlock& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern boolean operator==(null_type null_value, const EgprsLlcBlocks& other_value);
inline boolean operator!=(null_type null_value, const EgprsLlcBlocks& other_value) { return !(null_value == other_value); }
extern void EgprsLlcBlocks_0_encoder(const EgprsLlcBlock& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsLlcBlocks_0_decoder(OCTETSTRING& input_stream, EgprsLlcBlock& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsLlcBlocks_encoder(const EgprsLlcBlocks& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsLlcBlocks_decoder(OCTETSTRING& input_stream, EgprsLlcBlocks& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsDlMacDataHeader_header__type_encoder(const EgprsHeaderType& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsDlMacDataHeader_header__type_decoder(OCTETSTRING& input_stream, EgprsHeaderType& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsDlMacDataHeader_tfi_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsDlMacDataHeader_tfi_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsDlMacDataHeader_rrbp_encoder(const MacRrbp& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsDlMacDataHeader_rrbp_decoder(OCTETSTRING& input_stream, MacRrbp& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsDlMacDataHeader_esp_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsDlMacDataHeader_esp_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsDlMacDataHeader_usf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsDlMacDataHeader_usf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsDlMacDataHeader_bsn1_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsDlMacDataHeader_bsn1_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsDlMacDataHeader_bsn2__offset_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsDlMacDataHeader_bsn2__offset_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsDlMacDataHeader_pr_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsDlMacDataHeader_pr_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsDlMacDataHeader_cps_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsDlMacDataHeader_cps_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsDlMacDataHeader_spb_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsDlMacDataHeader_spb_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsDlMacDataHeader_encoder(const EgprsDlMacDataHeader& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsDlMacDataHeader_decoder(OCTETSTRING& input_stream, EgprsDlMacDataHeader& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacDlEgprsDataBlock_mcs_encoder(const CodingScheme& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacDlEgprsDataBlock_mcs_decoder(OCTETSTRING& input_stream, CodingScheme& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacDlEgprsDataBlock_mac__hdr_encoder(const EgprsDlMacDataHeader& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacDlEgprsDataBlock_mac__hdr_decoder(OCTETSTRING& input_stream, EgprsDlMacDataHeader& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacDlEgprsDataBlock_fbi_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacDlEgprsDataBlock_fbi_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacDlEgprsDataBlock_e_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacDlEgprsDataBlock_e_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacDlEgprsDataBlock_blocks_encoder(const EgprsLlcBlocks& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacDlEgprsDataBlock_blocks_decoder(OCTETSTRING& input_stream, EgprsLlcBlocks& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacDlEgprsDataBlock_encoder(const RlcmacDlEgprsDataBlock& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacDlEgprsDataBlock_decoder(OCTETSTRING& input_stream, RlcmacDlEgprsDataBlock& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void UlMacDataHeader_payload__type_encoder(const MacPayloadType& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER UlMacDataHeader_payload__type_decoder(OCTETSTRING& input_stream, MacPayloadType& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void UlMacDataHeader_countdown_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER UlMacDataHeader_countdown_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void UlMacDataHeader_stall__ind_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER UlMacDataHeader_stall__ind_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void UlMacDataHeader_retry_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER UlMacDataHeader_retry_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void UlMacDataHeader_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER UlMacDataHeader_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void UlMacDataHeader_pfi__ind_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER UlMacDataHeader_pfi__ind_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void UlMacDataHeader_tfi_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER UlMacDataHeader_tfi_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void UlMacDataHeader_tlli__ind_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER UlMacDataHeader_tlli__ind_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void UlMacDataHeader_bsn_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER UlMacDataHeader_bsn_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void UlMacDataHeader_e_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER UlMacDataHeader_e_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void UlMacDataHeader_encoder(const UlMacDataHeader& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER UlMacDataHeader_decoder(OCTETSTRING& input_stream, UlMacDataHeader& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcMacUlPfi_pfi_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcMacUlPfi_pfi_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcMacUlPfi_m_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcMacUlPfi_m_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcMacUlPfi_encoder(const RlcMacUlPfi& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcMacUlPfi_decoder(OCTETSTRING& input_stream, RlcMacUlPfi& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsUlMacDataHeader_header__type_encoder(const EgprsHeaderType& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsUlMacDataHeader_header__type_decoder(OCTETSTRING& input_stream, EgprsHeaderType& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsUlMacDataHeader_tfi_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsUlMacDataHeader_tfi_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsUlMacDataHeader_countdown_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsUlMacDataHeader_countdown_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsUlMacDataHeader_foi__si_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsUlMacDataHeader_foi__si_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsUlMacDataHeader_r__ri_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsUlMacDataHeader_r__ri_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsUlMacDataHeader_bsn1_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsUlMacDataHeader_bsn1_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsUlMacDataHeader_bsn2__offset_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsUlMacDataHeader_bsn2__offset_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsUlMacDataHeader_cps_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsUlMacDataHeader_cps_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsUlMacDataHeader_pfi__ind_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsUlMacDataHeader_pfi__ind_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsUlMacDataHeader_rsb_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsUlMacDataHeader_rsb_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsUlMacDataHeader_spb_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsUlMacDataHeader_spb_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void EgprsUlMacDataHeader_encoder(const EgprsUlMacDataHeader& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER EgprsUlMacDataHeader_decoder(OCTETSTRING& input_stream, EgprsUlMacDataHeader& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacUlEgprsDataBlock_mcs_encoder(const CodingScheme& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlEgprsDataBlock_mcs_decoder(OCTETSTRING& input_stream, CodingScheme& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacUlEgprsDataBlock_mac__hdr_encoder(const EgprsUlMacDataHeader& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlEgprsDataBlock_mac__hdr_decoder(OCTETSTRING& input_stream, EgprsUlMacDataHeader& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacUlEgprsDataBlock_tlli__ind_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlEgprsDataBlock_tlli__ind_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacUlEgprsDataBlock_e_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlEgprsDataBlock_e_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacUlEgprsDataBlock_blocks_encoder(const EgprsLlcBlocks& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlEgprsDataBlock_blocks_decoder(OCTETSTRING& input_stream, EgprsLlcBlocks& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacUlEgprsDataBlock_tlli_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlEgprsDataBlock_tlli_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacUlEgprsDataBlock_pfi_encoder(const RlcMacUlPfi& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlEgprsDataBlock_pfi_decoder(OCTETSTRING& input_stream, RlcMacUlPfi& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacUlEgprsDataBlock_encoder(const RlcmacUlEgprsDataBlock& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlEgprsDataBlock_decoder(OCTETSTRING& input_stream, RlcmacUlEgprsDataBlock& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacUlDataBlock_cs_encoder(const CodingScheme& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlDataBlock_cs_decoder(OCTETSTRING& input_stream, CodingScheme& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacUlDataBlock_mac__hdr_encoder(const UlMacDataHeader& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlDataBlock_mac__hdr_decoder(OCTETSTRING& input_stream, UlMacDataHeader& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacUlDataBlock_blocks_encoder(const LlcBlocks& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlDataBlock_blocks_decoder(OCTETSTRING& input_stream, LlcBlocks& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacUlDataBlock_tlli_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlDataBlock_tlli_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacUlDataBlock_pfi_encoder(const RlcMacUlPfi& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlDataBlock_pfi_decoder(OCTETSTRING& input_stream, RlcMacUlPfi& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacUlDataBlock_encoder(const RlcmacUlDataBlock& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlDataBlock_decoder(OCTETSTRING& input_stream, RlcmacUlDataBlock& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern OCTETSTRING enc__RlcmacUlDataBlock(const RlcmacUlDataBlock& si);
extern RlcmacUlDataBlock dec__RlcmacUlDataBlock(const OCTETSTRING& stream);
extern void RlcmacUlBlock_data_encoder(const RlcmacUlDataBlock& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlBlock_data_decoder(OCTETSTRING& input_stream, RlcmacUlDataBlock& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacUlBlock_data__egprs_encoder(const RlcmacUlEgprsDataBlock& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlBlock_data__egprs_decoder(OCTETSTRING& input_stream, RlcmacUlEgprsDataBlock& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacUlBlock_ctrl_encoder(const RlcmacUlCtrlBlock& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlBlock_ctrl_decoder(OCTETSTRING& input_stream, RlcmacUlCtrlBlock& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacUlBlock_encoder(const RlcmacUlBlock& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacUlBlock_decoder(OCTETSTRING& input_stream, RlcmacUlBlock& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern OCTETSTRING enc__RlcmacUlBlock(const RlcmacUlBlock& si);
extern RlcmacUlBlock dec__RlcmacUlBlock(const OCTETSTRING& stream);
extern void RlcmacDlBlock_data_encoder(const RlcmacDlDataBlock& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacDlBlock_data_decoder(OCTETSTRING& input_stream, RlcmacDlDataBlock& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacDlBlock_data__egprs_encoder(const RlcmacDlEgprsDataBlock& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacDlBlock_data__egprs_decoder(OCTETSTRING& input_stream, RlcmacDlEgprsDataBlock& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacDlBlock_ctrl_encoder(const RlcmacDlCtrlBlock& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacDlBlock_ctrl_decoder(OCTETSTRING& input_stream, RlcmacDlCtrlBlock& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RlcmacDlBlock_encoder(const RlcmacDlBlock& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RlcmacDlBlock_decoder(OCTETSTRING& input_stream, RlcmacDlBlock& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern OCTETSTRING enc__RlcmacDlBlock(const RlcmacDlBlock& si);
extern RlcmacDlBlock dec__RlcmacDlBlock(const OCTETSTRING& stream);
extern void PTCCHTimingAdvanceIE_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PTCCHTimingAdvanceIE_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void PTCCHTimingAdvanceIE_ta__val_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PTCCHTimingAdvanceIE_ta__val_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void PTCCHTimingAdvanceIE_encoder(const PTCCHTimingAdvanceIE& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PTCCHTimingAdvanceIE_decoder(OCTETSTRING& input_stream, PTCCHTimingAdvanceIE& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern boolean operator==(null_type null_value, const PTCCHTimingAdvanceIEs& other_value);
inline boolean operator!=(null_type null_value, const PTCCHTimingAdvanceIEs& other_value) { return !(null_value == other_value); }
extern void PTCCHTimingAdvanceIEs_0_encoder(const PTCCHTimingAdvanceIE& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PTCCHTimingAdvanceIEs_0_decoder(OCTETSTRING& input_stream, PTCCHTimingAdvanceIE& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void PTCCHTimingAdvanceIEs_encoder(const PTCCHTimingAdvanceIEs& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PTCCHTimingAdvanceIEs_decoder(OCTETSTRING& input_stream, PTCCHTimingAdvanceIEs& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void PTCCHDownlinkMsg_ta__idx_encoder(const PTCCHTimingAdvanceIEs& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PTCCHDownlinkMsg_ta__idx_decoder(OCTETSTRING& input_stream, PTCCHTimingAdvanceIEs& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void PTCCHDownlinkMsg_padding_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PTCCHDownlinkMsg_padding_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void PTCCHDownlinkMsg_encoder(const PTCCHDownlinkMsg& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PTCCHDownlinkMsg_decoder(OCTETSTRING& input_stream, PTCCHDownlinkMsg& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern OCTETSTRING enc__PTCCHDownlinkMsg(const PTCCHDownlinkMsg& si);
extern PTCCHDownlinkMsg dec__PTCCHDownlinkMsg(const OCTETSTRING& stream);
extern void pre_init_module();
extern void post_init_module();

/* Global variable declarations */

extern const TTCN_RAWdescriptor_t MacPayloadType_raw_;
extern const TTCN_Typedescriptor_t MacPayloadType_descr_;
extern UNIVERSAL_CHARSTRING MacPayloadType_default_coding;
extern const TTCN_RAWdescriptor_t MacRrbp_raw_;
extern const TTCN_Typedescriptor_t MacRrbp_descr_;
extern UNIVERSAL_CHARSTRING MacRrbp_default_coding;
extern const TTCN_RAWdescriptor_t EgprsHeaderType_raw_;
extern const TTCN_Typedescriptor_t EgprsHeaderType_descr_;
extern UNIVERSAL_CHARSTRING EgprsHeaderType_default_coding;
extern const TTCN_RAWdescriptor_t CodingScheme_raw_;
extern const TTCN_Typedescriptor_t CodingScheme_descr_;
extern UNIVERSAL_CHARSTRING CodingScheme_default_coding;
extern const TTCN_RAWdescriptor_t CodingSchemeArray_raw_;
extern const TTCN_Typedescriptor_t CodingSchemeArray_descr_;
extern const TTCN_RAWdescriptor_t CodingSchemeArray_0_raw_;
extern const TTCN_Typedescriptor_t CodingSchemeArray_0_descr_;
extern UNIVERSAL_CHARSTRING CodingSchemeArray_0_default_coding;
extern UNIVERSAL_CHARSTRING CodingSchemeArray_default_coding;
extern const TTCN_RAWdescriptor_t DlMacHeader_payload__type_raw_;
extern const TTCN_Typedescriptor_t DlMacHeader_payload__type_descr_;
extern UNIVERSAL_CHARSTRING DlMacHeader_payload__type_default_coding;
extern const TTCN_RAWdescriptor_t DlMacHeader_rrbp_raw_;
extern const TTCN_Typedescriptor_t DlMacHeader_rrbp_descr_;
extern UNIVERSAL_CHARSTRING DlMacHeader_rrbp_default_coding;
extern const TTCN_RAWdescriptor_t DlMacHeader_rrbp__valid_raw_;
extern const XERdescriptor_t DlMacHeader_rrbp__valid_xer_;
extern const TTCN_OERdescriptor_t DlMacHeader_rrbp__valid_oer_;
extern const TTCN_Typedescriptor_t DlMacHeader_rrbp__valid_descr_;
extern UNIVERSAL_CHARSTRING DlMacHeader_rrbp__valid_default_coding;
extern const TTCN_RAWdescriptor_t DlMacHeader_usf_raw_;
extern const XERdescriptor_t DlMacHeader_usf_xer_;
extern const TTCN_OERdescriptor_t DlMacHeader_usf_oer_;
extern const TTCN_Typedescriptor_t DlMacHeader_usf_descr_;
extern UNIVERSAL_CHARSTRING DlMacHeader_usf_default_coding;
extern const TTCN_RAWdescriptor_t DlMacHeader_raw_;
extern const TTCN_Typedescriptor_t DlMacHeader_descr_;
extern UNIVERSAL_CHARSTRING DlMacHeader_default_coding;
extern const TTCN_RAWdescriptor_t PowerReduction_raw_;
extern const TTCN_Typedescriptor_t PowerReduction_descr_;
extern UNIVERSAL_CHARSTRING PowerReduction_default_coding;
extern const TTCN_RAWdescriptor_t DirectionBit_raw_;
extern const TTCN_Typedescriptor_t DirectionBit_descr_;
extern UNIVERSAL_CHARSTRING DirectionBit_default_coding;
extern const TTCN_RAWdescriptor_t TfiOctet_pr_raw_;
extern const TTCN_Typedescriptor_t TfiOctet_pr_descr_;
extern UNIVERSAL_CHARSTRING TfiOctet_pr_default_coding;
extern const TTCN_RAWdescriptor_t TfiOctet_tfi_raw_;
extern const XERdescriptor_t TfiOctet_tfi_xer_;
extern const TTCN_OERdescriptor_t TfiOctet_tfi_oer_;
extern const TTCN_Typedescriptor_t TfiOctet_tfi_descr_;
extern UNIVERSAL_CHARSTRING TfiOctet_tfi_default_coding;
extern const TTCN_RAWdescriptor_t TfiOctet_d_raw_;
extern const TTCN_Typedescriptor_t TfiOctet_d_descr_;
extern UNIVERSAL_CHARSTRING TfiOctet_d_default_coding;
extern const TTCN_RAWdescriptor_t TfiOctet_raw_;
extern const TTCN_Typedescriptor_t TfiOctet_descr_;
extern UNIVERSAL_CHARSTRING TfiOctet_default_coding;
extern const TTCN_RAWdescriptor_t RbsnExtOctet_rbsn__e_raw_;
extern const XERdescriptor_t RbsnExtOctet_rbsn__e_xer_;
extern const TTCN_OERdescriptor_t RbsnExtOctet_rbsn__e_oer_;
extern const TTCN_Typedescriptor_t RbsnExtOctet_rbsn__e_descr_;
extern UNIVERSAL_CHARSTRING RbsnExtOctet_rbsn__e_default_coding;
extern const TTCN_RAWdescriptor_t RbsnExtOctet_fs__e_raw_;
extern const XERdescriptor_t RbsnExtOctet_fs__e_xer_;
extern const TTCN_OERdescriptor_t RbsnExtOctet_fs__e_oer_;
extern const TTCN_Typedescriptor_t RbsnExtOctet_fs__e_descr_;
extern UNIVERSAL_CHARSTRING RbsnExtOctet_fs__e_default_coding;
extern const TTCN_RAWdescriptor_t RbsnExtOctet_spare_raw_;
extern const XERdescriptor_t RbsnExtOctet_spare_xer_;
extern const TTCN_OERdescriptor_t RbsnExtOctet_spare_oer_;
extern const TTCN_Typedescriptor_t RbsnExtOctet_spare_descr_;
extern UNIVERSAL_CHARSTRING RbsnExtOctet_spare_default_coding;
extern const TTCN_RAWdescriptor_t RbsnExtOctet_raw_;
extern const TTCN_Typedescriptor_t RbsnExtOctet_descr_;
extern UNIVERSAL_CHARSTRING RbsnExtOctet_default_coding;
extern const TTCN_RAWdescriptor_t DlCtrlOptOctets_rbsn_raw_;
extern const XERdescriptor_t DlCtrlOptOctets_rbsn_xer_;
extern const TTCN_OERdescriptor_t DlCtrlOptOctets_rbsn_oer_;
extern const TTCN_Typedescriptor_t DlCtrlOptOctets_rbsn_descr_;
extern UNIVERSAL_CHARSTRING DlCtrlOptOctets_rbsn_default_coding;
extern const TTCN_RAWdescriptor_t DlCtrlOptOctets_rti_raw_;
extern const XERdescriptor_t DlCtrlOptOctets_rti_xer_;
extern const TTCN_OERdescriptor_t DlCtrlOptOctets_rti_oer_;
extern const TTCN_Typedescriptor_t DlCtrlOptOctets_rti_descr_;
extern UNIVERSAL_CHARSTRING DlCtrlOptOctets_rti_default_coding;
extern const TTCN_RAWdescriptor_t DlCtrlOptOctets_fs_raw_;
extern const XERdescriptor_t DlCtrlOptOctets_fs_xer_;
extern const TTCN_OERdescriptor_t DlCtrlOptOctets_fs_oer_;
extern const TTCN_Typedescriptor_t DlCtrlOptOctets_fs_descr_;
extern UNIVERSAL_CHARSTRING DlCtrlOptOctets_fs_default_coding;
extern const TTCN_RAWdescriptor_t DlCtrlOptOctets_tfi__octet__present_raw_;
extern const XERdescriptor_t DlCtrlOptOctets_tfi__octet__present_xer_;
extern const TTCN_OERdescriptor_t DlCtrlOptOctets_tfi__octet__present_oer_;
extern const TTCN_Typedescriptor_t DlCtrlOptOctets_tfi__octet__present_descr_;
extern UNIVERSAL_CHARSTRING DlCtrlOptOctets_tfi__octet__present_default_coding;
extern const TTCN_RAWdescriptor_t DlCtrlOptOctets_raw_;
extern const TTCN_Typedescriptor_t DlCtrlOptOctets_descr_;
extern const TTCN_RAWdescriptor_t DlCtrlOptOctets_tfi_raw_;
extern const TTCN_Typedescriptor_t DlCtrlOptOctets_tfi_descr_;
extern UNIVERSAL_CHARSTRING DlCtrlOptOctets_tfi_default_coding;
extern const TTCN_RAWdescriptor_t DlCtrlOptOctets_rbsn__ext_raw_;
extern const TTCN_Typedescriptor_t DlCtrlOptOctets_rbsn__ext_descr_;
extern UNIVERSAL_CHARSTRING DlCtrlOptOctets_rbsn__ext_default_coding;
extern UNIVERSAL_CHARSTRING DlCtrlOptOctets_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacDlCtrlBlock_mac__hdr_raw_;
extern const TTCN_Typedescriptor_t RlcmacDlCtrlBlock_mac__hdr_descr_;
extern UNIVERSAL_CHARSTRING RlcmacDlCtrlBlock_mac__hdr_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacDlCtrlBlock_payload_raw_;
extern const TTCN_Typedescriptor_t RlcmacDlCtrlBlock_payload_descr_;
extern UNIVERSAL_CHARSTRING RlcmacDlCtrlBlock_payload_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacDlCtrlBlock_raw_;
extern const TTCN_Typedescriptor_t RlcmacDlCtrlBlock_descr_;
extern const TTCN_RAWdescriptor_t RlcmacDlCtrlBlock_opt_raw_;
extern const TTCN_Typedescriptor_t RlcmacDlCtrlBlock_opt_descr_;
extern UNIVERSAL_CHARSTRING RlcmacDlCtrlBlock_opt_default_coding;
extern UNIVERSAL_CHARSTRING RlcmacDlCtrlBlock_default_coding;
extern const TTCN_RAWdescriptor_t UlMacCtrlHeader_payload__type_raw_;
extern const TTCN_Typedescriptor_t UlMacCtrlHeader_payload__type_descr_;
extern UNIVERSAL_CHARSTRING UlMacCtrlHeader_payload__type_default_coding;
extern const TTCN_RAWdescriptor_t UlMacCtrlHeader_spare_raw_;
extern const XERdescriptor_t UlMacCtrlHeader_spare_xer_;
extern const TTCN_OERdescriptor_t UlMacCtrlHeader_spare_oer_;
extern const TTCN_Typedescriptor_t UlMacCtrlHeader_spare_descr_;
extern UNIVERSAL_CHARSTRING UlMacCtrlHeader_spare_default_coding;
extern const TTCN_RAWdescriptor_t UlMacCtrlHeader_retry_raw_;
extern const XERdescriptor_t UlMacCtrlHeader_retry_xer_;
extern const TTCN_OERdescriptor_t UlMacCtrlHeader_retry_oer_;
extern const TTCN_Typedescriptor_t UlMacCtrlHeader_retry_descr_;
extern UNIVERSAL_CHARSTRING UlMacCtrlHeader_retry_default_coding;
extern const TTCN_RAWdescriptor_t UlMacCtrlHeader_raw_;
extern const TTCN_Typedescriptor_t UlMacCtrlHeader_descr_;
extern UNIVERSAL_CHARSTRING UlMacCtrlHeader_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacUlCtrlBlock_mac__hdr_raw_;
extern const TTCN_Typedescriptor_t RlcmacUlCtrlBlock_mac__hdr_descr_;
extern UNIVERSAL_CHARSTRING RlcmacUlCtrlBlock_mac__hdr_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacUlCtrlBlock_payload_raw_;
extern const TTCN_Typedescriptor_t RlcmacUlCtrlBlock_payload_descr_;
extern UNIVERSAL_CHARSTRING RlcmacUlCtrlBlock_payload_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacUlCtrlBlock_raw_;
extern const TTCN_Typedescriptor_t RlcmacUlCtrlBlock_descr_;
extern UNIVERSAL_CHARSTRING RlcmacUlCtrlBlock_default_coding;
extern const TTCN_RAWdescriptor_t LlcBlockHdr_length__ind_raw_;
extern const XERdescriptor_t LlcBlockHdr_length__ind_xer_;
extern const TTCN_OERdescriptor_t LlcBlockHdr_length__ind_oer_;
extern const TTCN_Typedescriptor_t LlcBlockHdr_length__ind_descr_;
extern UNIVERSAL_CHARSTRING LlcBlockHdr_length__ind_default_coding;
extern const TTCN_RAWdescriptor_t LlcBlockHdr_more_raw_;
extern const XERdescriptor_t LlcBlockHdr_more_xer_;
extern const TTCN_OERdescriptor_t LlcBlockHdr_more_oer_;
extern const TTCN_Typedescriptor_t LlcBlockHdr_more_descr_;
extern UNIVERSAL_CHARSTRING LlcBlockHdr_more_default_coding;
extern const TTCN_RAWdescriptor_t LlcBlockHdr_e_raw_;
extern const XERdescriptor_t LlcBlockHdr_e_xer_;
extern const TTCN_OERdescriptor_t LlcBlockHdr_e_oer_;
extern const TTCN_Typedescriptor_t LlcBlockHdr_e_descr_;
extern UNIVERSAL_CHARSTRING LlcBlockHdr_e_default_coding;
extern const TTCN_RAWdescriptor_t LlcBlockHdr_raw_;
extern const TTCN_Typedescriptor_t LlcBlockHdr_descr_;
extern UNIVERSAL_CHARSTRING LlcBlockHdr_default_coding;
extern const TTCN_RAWdescriptor_t LlcBlock_payload_raw_;
extern const XERdescriptor_t LlcBlock_payload_xer_;
extern const TTCN_OERdescriptor_t LlcBlock_payload_oer_;
extern const TTCN_Typedescriptor_t LlcBlock_payload_descr_;
extern UNIVERSAL_CHARSTRING LlcBlock_payload_default_coding;
extern const TTCN_RAWdescriptor_t LlcBlock_raw_;
extern const TTCN_Typedescriptor_t LlcBlock_descr_;
extern const TTCN_RAWdescriptor_t LlcBlock_hdr_raw_;
extern const TTCN_Typedescriptor_t LlcBlock_hdr_descr_;
extern UNIVERSAL_CHARSTRING LlcBlock_hdr_default_coding;
extern UNIVERSAL_CHARSTRING LlcBlock_default_coding;
extern const TTCN_RAWdescriptor_t LlcBlocks_raw_;
extern const TTCN_Typedescriptor_t LlcBlocks_descr_;
extern const TTCN_RAWdescriptor_t LlcBlocks_0_raw_;
extern const TTCN_Typedescriptor_t LlcBlocks_0_descr_;
extern UNIVERSAL_CHARSTRING LlcBlocks_0_default_coding;
extern UNIVERSAL_CHARSTRING LlcBlocks_default_coding;
extern const TTCN_RAWdescriptor_t DlMacHdrDataExt_pr_raw_;
extern const TTCN_Typedescriptor_t DlMacHdrDataExt_pr_descr_;
extern UNIVERSAL_CHARSTRING DlMacHdrDataExt_pr_default_coding;
extern const TTCN_RAWdescriptor_t DlMacHdrDataExt_spare_raw_;
extern const XERdescriptor_t DlMacHdrDataExt_spare_xer_;
extern const TTCN_OERdescriptor_t DlMacHdrDataExt_spare_oer_;
extern const TTCN_Typedescriptor_t DlMacHdrDataExt_spare_descr_;
extern UNIVERSAL_CHARSTRING DlMacHdrDataExt_spare_default_coding;
extern const TTCN_RAWdescriptor_t DlMacHdrDataExt_tfi_raw_;
extern const XERdescriptor_t DlMacHdrDataExt_tfi_xer_;
extern const TTCN_OERdescriptor_t DlMacHdrDataExt_tfi_oer_;
extern const TTCN_Typedescriptor_t DlMacHdrDataExt_tfi_descr_;
extern UNIVERSAL_CHARSTRING DlMacHdrDataExt_tfi_default_coding;
extern const TTCN_RAWdescriptor_t DlMacHdrDataExt_fbi_raw_;
extern const XERdescriptor_t DlMacHdrDataExt_fbi_xer_;
extern const TTCN_OERdescriptor_t DlMacHdrDataExt_fbi_oer_;
extern const TTCN_Typedescriptor_t DlMacHdrDataExt_fbi_descr_;
extern UNIVERSAL_CHARSTRING DlMacHdrDataExt_fbi_default_coding;
extern const TTCN_RAWdescriptor_t DlMacHdrDataExt_bsn_raw_;
extern const XERdescriptor_t DlMacHdrDataExt_bsn_xer_;
extern const TTCN_OERdescriptor_t DlMacHdrDataExt_bsn_oer_;
extern const TTCN_Typedescriptor_t DlMacHdrDataExt_bsn_descr_;
extern UNIVERSAL_CHARSTRING DlMacHdrDataExt_bsn_default_coding;
extern const TTCN_RAWdescriptor_t DlMacHdrDataExt_e_raw_;
extern const XERdescriptor_t DlMacHdrDataExt_e_xer_;
extern const TTCN_OERdescriptor_t DlMacHdrDataExt_e_oer_;
extern const TTCN_Typedescriptor_t DlMacHdrDataExt_e_descr_;
extern UNIVERSAL_CHARSTRING DlMacHdrDataExt_e_default_coding;
extern const TTCN_RAWdescriptor_t DlMacHdrDataExt_raw_;
extern const TTCN_Typedescriptor_t DlMacHdrDataExt_descr_;
extern UNIVERSAL_CHARSTRING DlMacHdrDataExt_default_coding;
extern const TTCN_RAWdescriptor_t DlMacDataHeader_mac__hdr_raw_;
extern const TTCN_Typedescriptor_t DlMacDataHeader_mac__hdr_descr_;
extern UNIVERSAL_CHARSTRING DlMacDataHeader_mac__hdr_default_coding;
extern const TTCN_RAWdescriptor_t DlMacDataHeader_hdr__ext_raw_;
extern const TTCN_Typedescriptor_t DlMacDataHeader_hdr__ext_descr_;
extern UNIVERSAL_CHARSTRING DlMacDataHeader_hdr__ext_default_coding;
extern const TTCN_RAWdescriptor_t DlMacDataHeader_raw_;
extern const TTCN_Typedescriptor_t DlMacDataHeader_descr_;
extern UNIVERSAL_CHARSTRING DlMacDataHeader_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacDlDataBlock_cs_raw_;
extern const TTCN_Typedescriptor_t RlcmacDlDataBlock_cs_descr_;
extern UNIVERSAL_CHARSTRING RlcmacDlDataBlock_cs_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacDlDataBlock_mac__hdr_raw_;
extern const TTCN_Typedescriptor_t RlcmacDlDataBlock_mac__hdr_descr_;
extern UNIVERSAL_CHARSTRING RlcmacDlDataBlock_mac__hdr_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacDlDataBlock_blocks_raw_;
extern const TTCN_Typedescriptor_t RlcmacDlDataBlock_blocks_descr_;
extern UNIVERSAL_CHARSTRING RlcmacDlDataBlock_blocks_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacDlDataBlock_raw_;
extern const TTCN_Typedescriptor_t RlcmacDlDataBlock_descr_;
extern UNIVERSAL_CHARSTRING RlcmacDlDataBlock_default_coding;
extern const TTCN_RAWdescriptor_t EgprsLlcBlockHdr_length__ind_raw_;
extern const XERdescriptor_t EgprsLlcBlockHdr_length__ind_xer_;
extern const TTCN_OERdescriptor_t EgprsLlcBlockHdr_length__ind_oer_;
extern const TTCN_Typedescriptor_t EgprsLlcBlockHdr_length__ind_descr_;
extern UNIVERSAL_CHARSTRING EgprsLlcBlockHdr_length__ind_default_coding;
extern const TTCN_RAWdescriptor_t EgprsLlcBlockHdr_e_raw_;
extern const XERdescriptor_t EgprsLlcBlockHdr_e_xer_;
extern const TTCN_OERdescriptor_t EgprsLlcBlockHdr_e_oer_;
extern const TTCN_Typedescriptor_t EgprsLlcBlockHdr_e_descr_;
extern UNIVERSAL_CHARSTRING EgprsLlcBlockHdr_e_default_coding;
extern const TTCN_RAWdescriptor_t EgprsLlcBlockHdr_raw_;
extern const TTCN_Typedescriptor_t EgprsLlcBlockHdr_descr_;
extern UNIVERSAL_CHARSTRING EgprsLlcBlockHdr_default_coding;
extern const TTCN_RAWdescriptor_t EgprsLlcBlock_payload_raw_;
extern const XERdescriptor_t EgprsLlcBlock_payload_xer_;
extern const TTCN_OERdescriptor_t EgprsLlcBlock_payload_oer_;
extern const TTCN_Typedescriptor_t EgprsLlcBlock_payload_descr_;
extern UNIVERSAL_CHARSTRING EgprsLlcBlock_payload_default_coding;
extern const TTCN_RAWdescriptor_t EgprsLlcBlock_raw_;
extern const TTCN_Typedescriptor_t EgprsLlcBlock_descr_;
extern const TTCN_RAWdescriptor_t EgprsLlcBlock_hdr_raw_;
extern const TTCN_Typedescriptor_t EgprsLlcBlock_hdr_descr_;
extern UNIVERSAL_CHARSTRING EgprsLlcBlock_hdr_default_coding;
extern UNIVERSAL_CHARSTRING EgprsLlcBlock_default_coding;
extern const TTCN_RAWdescriptor_t EgprsLlcBlocks_raw_;
extern const TTCN_Typedescriptor_t EgprsLlcBlocks_descr_;
extern const TTCN_RAWdescriptor_t EgprsLlcBlocks_0_raw_;
extern const TTCN_Typedescriptor_t EgprsLlcBlocks_0_descr_;
extern UNIVERSAL_CHARSTRING EgprsLlcBlocks_0_default_coding;
extern UNIVERSAL_CHARSTRING EgprsLlcBlocks_default_coding;
extern const TTCN_RAWdescriptor_t EgprsDlMacDataHeader_header__type_raw_;
extern const TTCN_Typedescriptor_t EgprsDlMacDataHeader_header__type_descr_;
extern UNIVERSAL_CHARSTRING EgprsDlMacDataHeader_header__type_default_coding;
extern const TTCN_RAWdescriptor_t EgprsDlMacDataHeader_tfi_raw_;
extern const XERdescriptor_t EgprsDlMacDataHeader_tfi_xer_;
extern const TTCN_OERdescriptor_t EgprsDlMacDataHeader_tfi_oer_;
extern const TTCN_Typedescriptor_t EgprsDlMacDataHeader_tfi_descr_;
extern UNIVERSAL_CHARSTRING EgprsDlMacDataHeader_tfi_default_coding;
extern const TTCN_RAWdescriptor_t EgprsDlMacDataHeader_rrbp_raw_;
extern const TTCN_Typedescriptor_t EgprsDlMacDataHeader_rrbp_descr_;
extern UNIVERSAL_CHARSTRING EgprsDlMacDataHeader_rrbp_default_coding;
extern const TTCN_RAWdescriptor_t EgprsDlMacDataHeader_esp_raw_;
extern const XERdescriptor_t EgprsDlMacDataHeader_esp_xer_;
extern const TTCN_OERdescriptor_t EgprsDlMacDataHeader_esp_oer_;
extern const TTCN_Typedescriptor_t EgprsDlMacDataHeader_esp_descr_;
extern UNIVERSAL_CHARSTRING EgprsDlMacDataHeader_esp_default_coding;
extern const TTCN_RAWdescriptor_t EgprsDlMacDataHeader_usf_raw_;
extern const XERdescriptor_t EgprsDlMacDataHeader_usf_xer_;
extern const TTCN_OERdescriptor_t EgprsDlMacDataHeader_usf_oer_;
extern const TTCN_Typedescriptor_t EgprsDlMacDataHeader_usf_descr_;
extern UNIVERSAL_CHARSTRING EgprsDlMacDataHeader_usf_default_coding;
extern const TTCN_RAWdescriptor_t EgprsDlMacDataHeader_bsn1_raw_;
extern const XERdescriptor_t EgprsDlMacDataHeader_bsn1_xer_;
extern const TTCN_OERdescriptor_t EgprsDlMacDataHeader_bsn1_oer_;
extern const TTCN_Typedescriptor_t EgprsDlMacDataHeader_bsn1_descr_;
extern UNIVERSAL_CHARSTRING EgprsDlMacDataHeader_bsn1_default_coding;
extern const TTCN_RAWdescriptor_t EgprsDlMacDataHeader_bsn2__offset_raw_;
extern const XERdescriptor_t EgprsDlMacDataHeader_bsn2__offset_xer_;
extern const TTCN_OERdescriptor_t EgprsDlMacDataHeader_bsn2__offset_oer_;
extern const TTCN_Typedescriptor_t EgprsDlMacDataHeader_bsn2__offset_descr_;
extern UNIVERSAL_CHARSTRING EgprsDlMacDataHeader_bsn2__offset_default_coding;
extern const TTCN_RAWdescriptor_t EgprsDlMacDataHeader_pr_raw_;
extern const XERdescriptor_t EgprsDlMacDataHeader_pr_xer_;
extern const TTCN_OERdescriptor_t EgprsDlMacDataHeader_pr_oer_;
extern const TTCN_Typedescriptor_t EgprsDlMacDataHeader_pr_descr_;
extern UNIVERSAL_CHARSTRING EgprsDlMacDataHeader_pr_default_coding;
extern const TTCN_RAWdescriptor_t EgprsDlMacDataHeader_cps_raw_;
extern const XERdescriptor_t EgprsDlMacDataHeader_cps_xer_;
extern const TTCN_OERdescriptor_t EgprsDlMacDataHeader_cps_oer_;
extern const TTCN_Typedescriptor_t EgprsDlMacDataHeader_cps_descr_;
extern UNIVERSAL_CHARSTRING EgprsDlMacDataHeader_cps_default_coding;
extern const TTCN_RAWdescriptor_t EgprsDlMacDataHeader_raw_;
extern const TTCN_Typedescriptor_t EgprsDlMacDataHeader_descr_;
extern const TTCN_RAWdescriptor_t EgprsDlMacDataHeader_spb_raw_;
extern const XERdescriptor_t EgprsDlMacDataHeader_spb_xer_;
extern const TTCN_OERdescriptor_t EgprsDlMacDataHeader_spb_oer_;
extern const TTCN_Typedescriptor_t EgprsDlMacDataHeader_spb_descr_;
extern UNIVERSAL_CHARSTRING EgprsDlMacDataHeader_spb_default_coding;
extern UNIVERSAL_CHARSTRING EgprsDlMacDataHeader_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacDlEgprsDataBlock_mcs_raw_;
extern const TTCN_Typedescriptor_t RlcmacDlEgprsDataBlock_mcs_descr_;
extern UNIVERSAL_CHARSTRING RlcmacDlEgprsDataBlock_mcs_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacDlEgprsDataBlock_mac__hdr_raw_;
extern const TTCN_Typedescriptor_t RlcmacDlEgprsDataBlock_mac__hdr_descr_;
extern UNIVERSAL_CHARSTRING RlcmacDlEgprsDataBlock_mac__hdr_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacDlEgprsDataBlock_fbi_raw_;
extern const XERdescriptor_t RlcmacDlEgprsDataBlock_fbi_xer_;
extern const TTCN_OERdescriptor_t RlcmacDlEgprsDataBlock_fbi_oer_;
extern const TTCN_Typedescriptor_t RlcmacDlEgprsDataBlock_fbi_descr_;
extern UNIVERSAL_CHARSTRING RlcmacDlEgprsDataBlock_fbi_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacDlEgprsDataBlock_e_raw_;
extern const XERdescriptor_t RlcmacDlEgprsDataBlock_e_xer_;
extern const TTCN_OERdescriptor_t RlcmacDlEgprsDataBlock_e_oer_;
extern const TTCN_Typedescriptor_t RlcmacDlEgprsDataBlock_e_descr_;
extern UNIVERSAL_CHARSTRING RlcmacDlEgprsDataBlock_e_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacDlEgprsDataBlock_blocks_raw_;
extern const TTCN_Typedescriptor_t RlcmacDlEgprsDataBlock_blocks_descr_;
extern UNIVERSAL_CHARSTRING RlcmacDlEgprsDataBlock_blocks_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacDlEgprsDataBlock_raw_;
extern const TTCN_Typedescriptor_t RlcmacDlEgprsDataBlock_descr_;
extern UNIVERSAL_CHARSTRING RlcmacDlEgprsDataBlock_default_coding;
extern const TTCN_RAWdescriptor_t UlMacDataHeader_payload__type_raw_;
extern const TTCN_Typedescriptor_t UlMacDataHeader_payload__type_descr_;
extern UNIVERSAL_CHARSTRING UlMacDataHeader_payload__type_default_coding;
extern const TTCN_RAWdescriptor_t UlMacDataHeader_countdown_raw_;
extern const XERdescriptor_t UlMacDataHeader_countdown_xer_;
extern const TTCN_OERdescriptor_t UlMacDataHeader_countdown_oer_;
extern const TTCN_Typedescriptor_t UlMacDataHeader_countdown_descr_;
extern UNIVERSAL_CHARSTRING UlMacDataHeader_countdown_default_coding;
extern const TTCN_RAWdescriptor_t UlMacDataHeader_stall__ind_raw_;
extern const XERdescriptor_t UlMacDataHeader_stall__ind_xer_;
extern const TTCN_OERdescriptor_t UlMacDataHeader_stall__ind_oer_;
extern const TTCN_Typedescriptor_t UlMacDataHeader_stall__ind_descr_;
extern UNIVERSAL_CHARSTRING UlMacDataHeader_stall__ind_default_coding;
extern const TTCN_RAWdescriptor_t UlMacDataHeader_retry_raw_;
extern const XERdescriptor_t UlMacDataHeader_retry_xer_;
extern const TTCN_OERdescriptor_t UlMacDataHeader_retry_oer_;
extern const TTCN_Typedescriptor_t UlMacDataHeader_retry_descr_;
extern UNIVERSAL_CHARSTRING UlMacDataHeader_retry_default_coding;
extern const TTCN_RAWdescriptor_t UlMacDataHeader_spare_raw_;
extern const XERdescriptor_t UlMacDataHeader_spare_xer_;
extern const TTCN_OERdescriptor_t UlMacDataHeader_spare_oer_;
extern const TTCN_Typedescriptor_t UlMacDataHeader_spare_descr_;
extern UNIVERSAL_CHARSTRING UlMacDataHeader_spare_default_coding;
extern const TTCN_RAWdescriptor_t UlMacDataHeader_pfi__ind_raw_;
extern const XERdescriptor_t UlMacDataHeader_pfi__ind_xer_;
extern const TTCN_OERdescriptor_t UlMacDataHeader_pfi__ind_oer_;
extern const TTCN_Typedescriptor_t UlMacDataHeader_pfi__ind_descr_;
extern UNIVERSAL_CHARSTRING UlMacDataHeader_pfi__ind_default_coding;
extern const TTCN_RAWdescriptor_t UlMacDataHeader_tfi_raw_;
extern const XERdescriptor_t UlMacDataHeader_tfi_xer_;
extern const TTCN_OERdescriptor_t UlMacDataHeader_tfi_oer_;
extern const TTCN_Typedescriptor_t UlMacDataHeader_tfi_descr_;
extern UNIVERSAL_CHARSTRING UlMacDataHeader_tfi_default_coding;
extern const TTCN_RAWdescriptor_t UlMacDataHeader_tlli__ind_raw_;
extern const XERdescriptor_t UlMacDataHeader_tlli__ind_xer_;
extern const TTCN_OERdescriptor_t UlMacDataHeader_tlli__ind_oer_;
extern const TTCN_Typedescriptor_t UlMacDataHeader_tlli__ind_descr_;
extern UNIVERSAL_CHARSTRING UlMacDataHeader_tlli__ind_default_coding;
extern const TTCN_RAWdescriptor_t UlMacDataHeader_bsn_raw_;
extern const XERdescriptor_t UlMacDataHeader_bsn_xer_;
extern const TTCN_OERdescriptor_t UlMacDataHeader_bsn_oer_;
extern const TTCN_Typedescriptor_t UlMacDataHeader_bsn_descr_;
extern UNIVERSAL_CHARSTRING UlMacDataHeader_bsn_default_coding;
extern const TTCN_RAWdescriptor_t UlMacDataHeader_e_raw_;
extern const XERdescriptor_t UlMacDataHeader_e_xer_;
extern const TTCN_OERdescriptor_t UlMacDataHeader_e_oer_;
extern const TTCN_Typedescriptor_t UlMacDataHeader_e_descr_;
extern UNIVERSAL_CHARSTRING UlMacDataHeader_e_default_coding;
extern const TTCN_RAWdescriptor_t UlMacDataHeader_raw_;
extern const TTCN_Typedescriptor_t UlMacDataHeader_descr_;
extern UNIVERSAL_CHARSTRING UlMacDataHeader_default_coding;
extern const TTCN_RAWdescriptor_t RlcMacUlPfi_pfi_raw_;
extern const XERdescriptor_t RlcMacUlPfi_pfi_xer_;
extern const TTCN_OERdescriptor_t RlcMacUlPfi_pfi_oer_;
extern const TTCN_Typedescriptor_t RlcMacUlPfi_pfi_descr_;
extern UNIVERSAL_CHARSTRING RlcMacUlPfi_pfi_default_coding;
extern const TTCN_RAWdescriptor_t RlcMacUlPfi_m_raw_;
extern const XERdescriptor_t RlcMacUlPfi_m_xer_;
extern const TTCN_OERdescriptor_t RlcMacUlPfi_m_oer_;
extern const TTCN_Typedescriptor_t RlcMacUlPfi_m_descr_;
extern UNIVERSAL_CHARSTRING RlcMacUlPfi_m_default_coding;
extern const TTCN_RAWdescriptor_t RlcMacUlPfi_raw_;
extern const TTCN_Typedescriptor_t RlcMacUlPfi_descr_;
extern UNIVERSAL_CHARSTRING RlcMacUlPfi_default_coding;
extern const TTCN_RAWdescriptor_t EgprsUlMacDataHeader_header__type_raw_;
extern const TTCN_Typedescriptor_t EgprsUlMacDataHeader_header__type_descr_;
extern UNIVERSAL_CHARSTRING EgprsUlMacDataHeader_header__type_default_coding;
extern const TTCN_RAWdescriptor_t EgprsUlMacDataHeader_tfi_raw_;
extern const XERdescriptor_t EgprsUlMacDataHeader_tfi_xer_;
extern const TTCN_OERdescriptor_t EgprsUlMacDataHeader_tfi_oer_;
extern const TTCN_Typedescriptor_t EgprsUlMacDataHeader_tfi_descr_;
extern UNIVERSAL_CHARSTRING EgprsUlMacDataHeader_tfi_default_coding;
extern const TTCN_RAWdescriptor_t EgprsUlMacDataHeader_countdown_raw_;
extern const XERdescriptor_t EgprsUlMacDataHeader_countdown_xer_;
extern const TTCN_OERdescriptor_t EgprsUlMacDataHeader_countdown_oer_;
extern const TTCN_Typedescriptor_t EgprsUlMacDataHeader_countdown_descr_;
extern UNIVERSAL_CHARSTRING EgprsUlMacDataHeader_countdown_default_coding;
extern const TTCN_RAWdescriptor_t EgprsUlMacDataHeader_foi__si_raw_;
extern const XERdescriptor_t EgprsUlMacDataHeader_foi__si_xer_;
extern const TTCN_OERdescriptor_t EgprsUlMacDataHeader_foi__si_oer_;
extern const TTCN_Typedescriptor_t EgprsUlMacDataHeader_foi__si_descr_;
extern UNIVERSAL_CHARSTRING EgprsUlMacDataHeader_foi__si_default_coding;
extern const TTCN_RAWdescriptor_t EgprsUlMacDataHeader_r__ri_raw_;
extern const XERdescriptor_t EgprsUlMacDataHeader_r__ri_xer_;
extern const TTCN_OERdescriptor_t EgprsUlMacDataHeader_r__ri_oer_;
extern const TTCN_Typedescriptor_t EgprsUlMacDataHeader_r__ri_descr_;
extern UNIVERSAL_CHARSTRING EgprsUlMacDataHeader_r__ri_default_coding;
extern const TTCN_RAWdescriptor_t EgprsUlMacDataHeader_bsn1_raw_;
extern const XERdescriptor_t EgprsUlMacDataHeader_bsn1_xer_;
extern const TTCN_OERdescriptor_t EgprsUlMacDataHeader_bsn1_oer_;
extern const TTCN_Typedescriptor_t EgprsUlMacDataHeader_bsn1_descr_;
extern UNIVERSAL_CHARSTRING EgprsUlMacDataHeader_bsn1_default_coding;
extern const TTCN_RAWdescriptor_t EgprsUlMacDataHeader_bsn2__offset_raw_;
extern const XERdescriptor_t EgprsUlMacDataHeader_bsn2__offset_xer_;
extern const TTCN_OERdescriptor_t EgprsUlMacDataHeader_bsn2__offset_oer_;
extern const TTCN_Typedescriptor_t EgprsUlMacDataHeader_bsn2__offset_descr_;
extern UNIVERSAL_CHARSTRING EgprsUlMacDataHeader_bsn2__offset_default_coding;
extern const TTCN_RAWdescriptor_t EgprsUlMacDataHeader_cps_raw_;
extern const XERdescriptor_t EgprsUlMacDataHeader_cps_xer_;
extern const TTCN_OERdescriptor_t EgprsUlMacDataHeader_cps_oer_;
extern const TTCN_Typedescriptor_t EgprsUlMacDataHeader_cps_descr_;
extern UNIVERSAL_CHARSTRING EgprsUlMacDataHeader_cps_default_coding;
extern const TTCN_RAWdescriptor_t EgprsUlMacDataHeader_pfi__ind_raw_;
extern const XERdescriptor_t EgprsUlMacDataHeader_pfi__ind_xer_;
extern const TTCN_OERdescriptor_t EgprsUlMacDataHeader_pfi__ind_oer_;
extern const TTCN_Typedescriptor_t EgprsUlMacDataHeader_pfi__ind_descr_;
extern UNIVERSAL_CHARSTRING EgprsUlMacDataHeader_pfi__ind_default_coding;
extern const TTCN_RAWdescriptor_t EgprsUlMacDataHeader_rsb_raw_;
extern const XERdescriptor_t EgprsUlMacDataHeader_rsb_xer_;
extern const TTCN_OERdescriptor_t EgprsUlMacDataHeader_rsb_oer_;
extern const TTCN_Typedescriptor_t EgprsUlMacDataHeader_rsb_descr_;
extern UNIVERSAL_CHARSTRING EgprsUlMacDataHeader_rsb_default_coding;
extern const TTCN_RAWdescriptor_t EgprsUlMacDataHeader_raw_;
extern const TTCN_Typedescriptor_t EgprsUlMacDataHeader_descr_;
extern const TTCN_RAWdescriptor_t EgprsUlMacDataHeader_spb_raw_;
extern const XERdescriptor_t EgprsUlMacDataHeader_spb_xer_;
extern const TTCN_OERdescriptor_t EgprsUlMacDataHeader_spb_oer_;
extern const TTCN_Typedescriptor_t EgprsUlMacDataHeader_spb_descr_;
extern UNIVERSAL_CHARSTRING EgprsUlMacDataHeader_spb_default_coding;
extern UNIVERSAL_CHARSTRING EgprsUlMacDataHeader_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacUlEgprsDataBlock_mcs_raw_;
extern const TTCN_Typedescriptor_t RlcmacUlEgprsDataBlock_mcs_descr_;
extern UNIVERSAL_CHARSTRING RlcmacUlEgprsDataBlock_mcs_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacUlEgprsDataBlock_mac__hdr_raw_;
extern const TTCN_Typedescriptor_t RlcmacUlEgprsDataBlock_mac__hdr_descr_;
extern UNIVERSAL_CHARSTRING RlcmacUlEgprsDataBlock_mac__hdr_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacUlEgprsDataBlock_tlli__ind_raw_;
extern const XERdescriptor_t RlcmacUlEgprsDataBlock_tlli__ind_xer_;
extern const TTCN_OERdescriptor_t RlcmacUlEgprsDataBlock_tlli__ind_oer_;
extern const TTCN_Typedescriptor_t RlcmacUlEgprsDataBlock_tlli__ind_descr_;
extern UNIVERSAL_CHARSTRING RlcmacUlEgprsDataBlock_tlli__ind_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacUlEgprsDataBlock_e_raw_;
extern const XERdescriptor_t RlcmacUlEgprsDataBlock_e_xer_;
extern const TTCN_OERdescriptor_t RlcmacUlEgprsDataBlock_e_oer_;
extern const TTCN_Typedescriptor_t RlcmacUlEgprsDataBlock_e_descr_;
extern UNIVERSAL_CHARSTRING RlcmacUlEgprsDataBlock_e_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacUlEgprsDataBlock_blocks_raw_;
extern const TTCN_Typedescriptor_t RlcmacUlEgprsDataBlock_blocks_descr_;
extern UNIVERSAL_CHARSTRING RlcmacUlEgprsDataBlock_blocks_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacUlEgprsDataBlock_raw_;
extern const TTCN_Typedescriptor_t RlcmacUlEgprsDataBlock_descr_;
extern const TTCN_RAWdescriptor_t RlcmacUlEgprsDataBlock_tlli_raw_;
extern const XERdescriptor_t RlcmacUlEgprsDataBlock_tlli_xer_;
extern const TTCN_OERdescriptor_t RlcmacUlEgprsDataBlock_tlli_oer_;
extern const TTCN_Typedescriptor_t RlcmacUlEgprsDataBlock_tlli_descr_;
extern UNIVERSAL_CHARSTRING RlcmacUlEgprsDataBlock_tlli_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacUlEgprsDataBlock_pfi_raw_;
extern const TTCN_Typedescriptor_t RlcmacUlEgprsDataBlock_pfi_descr_;
extern UNIVERSAL_CHARSTRING RlcmacUlEgprsDataBlock_pfi_default_coding;
extern UNIVERSAL_CHARSTRING RlcmacUlEgprsDataBlock_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacUlDataBlock_cs_raw_;
extern const TTCN_Typedescriptor_t RlcmacUlDataBlock_cs_descr_;
extern UNIVERSAL_CHARSTRING RlcmacUlDataBlock_cs_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacUlDataBlock_mac__hdr_raw_;
extern const TTCN_Typedescriptor_t RlcmacUlDataBlock_mac__hdr_descr_;
extern UNIVERSAL_CHARSTRING RlcmacUlDataBlock_mac__hdr_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacUlDataBlock_blocks_raw_;
extern const TTCN_Typedescriptor_t RlcmacUlDataBlock_blocks_descr_;
extern UNIVERSAL_CHARSTRING RlcmacUlDataBlock_blocks_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacUlDataBlock_raw_;
extern const TTCN_Typedescriptor_t RlcmacUlDataBlock_descr_;
extern const TTCN_RAWdescriptor_t RlcmacUlDataBlock_tlli_raw_;
extern const XERdescriptor_t RlcmacUlDataBlock_tlli_xer_;
extern const TTCN_OERdescriptor_t RlcmacUlDataBlock_tlli_oer_;
extern const TTCN_Typedescriptor_t RlcmacUlDataBlock_tlli_descr_;
extern UNIVERSAL_CHARSTRING RlcmacUlDataBlock_tlli_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacUlDataBlock_pfi_raw_;
extern const TTCN_Typedescriptor_t RlcmacUlDataBlock_pfi_descr_;
extern UNIVERSAL_CHARSTRING RlcmacUlDataBlock_pfi_default_coding;
extern UNIVERSAL_CHARSTRING RlcmacUlDataBlock_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacUlBlock_raw_;
extern const TTCN_Typedescriptor_t RlcmacUlBlock_descr_;
extern const TTCN_RAWdescriptor_t RlcmacUlBlock_data_raw_;
extern const TTCN_Typedescriptor_t RlcmacUlBlock_data_descr_;
extern UNIVERSAL_CHARSTRING RlcmacUlBlock_data_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacUlBlock_data__egprs_raw_;
extern const TTCN_Typedescriptor_t RlcmacUlBlock_data__egprs_descr_;
extern UNIVERSAL_CHARSTRING RlcmacUlBlock_data__egprs_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacUlBlock_ctrl_raw_;
extern const TTCN_Typedescriptor_t RlcmacUlBlock_ctrl_descr_;
extern UNIVERSAL_CHARSTRING RlcmacUlBlock_ctrl_default_coding;
extern UNIVERSAL_CHARSTRING RlcmacUlBlock_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacDlBlock_raw_;
extern const TTCN_Typedescriptor_t RlcmacDlBlock_descr_;
extern const TTCN_RAWdescriptor_t RlcmacDlBlock_data_raw_;
extern const TTCN_Typedescriptor_t RlcmacDlBlock_data_descr_;
extern UNIVERSAL_CHARSTRING RlcmacDlBlock_data_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacDlBlock_data__egprs_raw_;
extern const TTCN_Typedescriptor_t RlcmacDlBlock_data__egprs_descr_;
extern UNIVERSAL_CHARSTRING RlcmacDlBlock_data__egprs_default_coding;
extern const TTCN_RAWdescriptor_t RlcmacDlBlock_ctrl_raw_;
extern const TTCN_Typedescriptor_t RlcmacDlBlock_ctrl_descr_;
extern UNIVERSAL_CHARSTRING RlcmacDlBlock_ctrl_default_coding;
extern UNIVERSAL_CHARSTRING RlcmacDlBlock_default_coding;
extern const TTCN_RAWdescriptor_t PTCCHTimingAdvanceIE_spare_raw_;
extern const XERdescriptor_t PTCCHTimingAdvanceIE_spare_xer_;
extern const TTCN_OERdescriptor_t PTCCHTimingAdvanceIE_spare_oer_;
extern const TTCN_Typedescriptor_t PTCCHTimingAdvanceIE_spare_descr_;
extern UNIVERSAL_CHARSTRING PTCCHTimingAdvanceIE_spare_default_coding;
extern const TTCN_RAWdescriptor_t PTCCHTimingAdvanceIE_ta__val_raw_;
extern const XERdescriptor_t PTCCHTimingAdvanceIE_ta__val_xer_;
extern const TTCN_OERdescriptor_t PTCCHTimingAdvanceIE_ta__val_oer_;
extern const TTCN_Typedescriptor_t PTCCHTimingAdvanceIE_ta__val_descr_;
extern UNIVERSAL_CHARSTRING PTCCHTimingAdvanceIE_ta__val_default_coding;
extern const TTCN_RAWdescriptor_t PTCCHTimingAdvanceIE_raw_;
extern const TTCN_Typedescriptor_t PTCCHTimingAdvanceIE_descr_;
extern UNIVERSAL_CHARSTRING PTCCHTimingAdvanceIE_default_coding;
extern const TTCN_RAWdescriptor_t PTCCHTimingAdvanceIEs_raw_;
extern const TTCN_Typedescriptor_t PTCCHTimingAdvanceIEs_descr_;
extern const TTCN_RAWdescriptor_t PTCCHTimingAdvanceIEs_0_raw_;
extern const TTCN_Typedescriptor_t PTCCHTimingAdvanceIEs_0_descr_;
extern UNIVERSAL_CHARSTRING PTCCHTimingAdvanceIEs_0_default_coding;
extern UNIVERSAL_CHARSTRING PTCCHTimingAdvanceIEs_default_coding;
extern const TTCN_RAWdescriptor_t PTCCHDownlinkMsg_ta__idx_raw_;
extern const TTCN_Typedescriptor_t PTCCHDownlinkMsg_ta__idx_descr_;
extern UNIVERSAL_CHARSTRING PTCCHDownlinkMsg_ta__idx_default_coding;
extern const TTCN_RAWdescriptor_t PTCCHDownlinkMsg_padding_raw_;
extern const XERdescriptor_t PTCCHDownlinkMsg_padding_xer_;
extern const TTCN_OERdescriptor_t PTCCHDownlinkMsg_padding_oer_;
extern const TTCN_Typedescriptor_t PTCCHDownlinkMsg_padding_descr_;
extern UNIVERSAL_CHARSTRING PTCCHDownlinkMsg_padding_default_coding;
extern const TTCN_RAWdescriptor_t PTCCHDownlinkMsg_raw_;
extern const TTCN_Typedescriptor_t PTCCHDownlinkMsg_descr_;
extern UNIVERSAL_CHARSTRING PTCCHDownlinkMsg_default_coding;
extern const BITSTRING bs_0;
extern const unsigned char module_checksum[];
extern TTCN_Module module_object;
extern const RuntimeVersionChecker ver_checker;

} /* end of namespace */

#endif
