// 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 L1CTL__Types_HH
#define L1CTL__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 "GSM_RR_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 L1CTL__Types_HH
#endif

namespace L1CTL__Types {

/* Forward declarations of classes */

class L1ctlMsgType;
class L1ctlMsgType_template;
class L1ctlCcchMode;
class L1ctlCcchMode_template;
class L1ctlNeighMode;
class L1ctlNeighMode_template;
class L1ctlResetType;
class L1ctlResetType_template;
class L1ctlHdrFlags;
class L1ctlHdrFlags_template;
class L1ctlHeader;
class L1ctlHeader_template;
class L1ctlDlInfo;
class L1ctlDlInfo_template;
class L1ctlFbsbConf;
class L1ctlFbsbConf_template;
class L1ctlCcchModeConf;
class L1ctlCcchModeConf_template;
class L1ctlTchMode;
class L1ctlTchMode_template;
class L1ctlLoopMode;
class L1ctlLoopMode_template;
class L1ctlAudioMode;
class L1ctlAudioMode_template;
class L1ctlTchModeConf_amr;
class L1ctlTchModeConf_amr_template;
class L1ctlTchModeConf;
class L1ctlTchModeConf_template;
class L1ctlDataInd;
class L1ctlDataInd_template;
class L1ctlUlInfo;
class L1ctlUlInfo_template;
class L1ctlFbsbFlags;
class L1ctlFbsbFlags_template;
class L1ctlFbsbReq;
class L1ctlFbsbReq_template;
class L1ctlCcchModeReq;
class L1ctlCcchModeReq_template;
class L1ctlTchModeReq_amr;
class L1ctlTchModeReq_amr_template;
class L1ctlTchModeReq;
class L1ctlTchModeReq_template;
class L1ctlRachReq;
class L1ctlRachReq_template;
class L1ctlRachSynchSeq;
class L1ctlRachSynchSeq_template;
class L1ctlExtRachReq;
class L1ctlExtRachReq_template;
class L1ctlParReq;
class L1ctlParReq_template;
class L1ctlDataReq;
class L1ctlDataReq_template;
class L1ctlH0;
class L1ctlH0_template;
class L1ctlMA;
class L1ctlMA_template;
class L1ctlH1;
class L1ctlH1_template;
class L1ctlH0H1;
class L1ctlH0H1_template;
class L1ctlDmEstReq;
class L1ctlDmEstReq_template;
class L1ctlReset;
class L1ctlReset_template;
class L1CtlCryptoReq;
class L1CtlCryptoReq_template;
class L1ctlTrafficReq;
class L1ctlTrafficReq_template;
class L1ctlGprsUlTbfCfgReq;
class L1ctlGprsUlTbfCfgReq_template;
class L1ctlGprsDlTbfCfgReq;
class L1ctlGprsDlTbfCfgReq_template;
class L1ctlGprsBlockHdr;
class L1ctlGprsBlockHdr_template;
class L1ctlGprsUlBlockReq;
class L1ctlGprsUlBlockReq_template;
class L1ctlGprsUlBlockCnf;
class L1ctlGprsUlBlockCnf_template;
class L1ctlGprsDlBlockInd_meas;
class L1ctlGprsDlBlockInd_meas_template;
class L1ctlGprsDlBlockInd;
class L1ctlGprsDlBlockInd_template;
class L1ctlGprsRtsInd;
class L1ctlGprsRtsInd_template;
class L1ctlMsgPayload;
class L1ctlMsgPayload_template;
class L1ctlMessage;
class L1ctlMessage_template;
class L1ctlMessageLV;
class L1ctlMessageLV_template;

} /* end of namespace */

#ifndef L1CTL__Types_HH
#define L1CTL__Types_HH

namespace L1CTL__Types {

/* Class definitions */

class L1ctlMsgType : public Base_Type { // enum
friend class L1ctlMsgType_template;
public:
enum enum_type { L1CTL__NONE = 0, L1CTL__FBSB__REQ = 1, L1CTL__FBSB__CONF = 2, L1CTL__DATA__IND = 3, L1CTL__RACH__REQ = 4, L1CTL__DM__EST__REQ = 5, L1CTL__DATA__REQ = 6, L1CTL__RESET__IND = 7, L1CTL__PM__REQ = 8, L1CTL__PM__CONF = 9, L1CTL__ECHO__REQ = 10, L1CTL__ECHO__CONF = 11, L1CTL__RACH__CONF = 12, L1CTL__RESET__REQ = 13, L1CTL__RESET__CONF = 14, L1CTL__DATA__CONF = 15, L1CTL__CCCH__MODE__REQ = 16, L1CTL__CCCH__MODE__CONF = 17, L1CTL__DM__REL__REQ = 18, L1CTL__PARAM__REQ = 19, L1CTL__DM__FREQ__REQ = 20, L1CTL__CRYPTO__REQ = 21, L1CTL__SIM__REQ = 22, L1CTL__SIM__CONF = 23, L1CTL__TCH__MODE__REQ = 24, L1CTL__TCH__MODE__CONF = 25, L1CTL__NEIGH__PM__REQ = 26, L1CTL__NEIGH__PM__IND = 27, L1CTL__TRAFFIC__REQ = 28, L1CTL__TRAFFIC__CONF = 29, L1CTL__TRAFFIC__IND = 30, L1CTL__BURST__IND = 31, L1CTL__GPRS__UL__TBF__CFG__REQ = 32, L1CTL__GPRS__DL__TBF__CFG__REQ = 33, L1CTL__GPRS__UL__BLOCK__REQ = 34, L1CTL__GPRS__DL__BLOCK__IND = 35, L1CTL__EXT__RACH__REQ = 36, L1CTL__GPRS__RTS__IND = 37, L1CTL__GPRS__UL__BLOCK__CNF = 38, UNKNOWN_VALUE = 39, UNBOUND_VALUE = 40 };
private:
enum_type enum_value;

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

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

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const L1ctlMsgType& 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 L1ctlMsgType& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const L1ctlMsgType& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const L1ctlMsgType& 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 L1ctlMsgType& 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 L1ctlMsgType& 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 L1ctlMsgType& 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 L1ctlMsgType_template : public Base_Template {
union {
L1ctlMsgType::enum_type single_value;
struct {
unsigned int n_values;
L1ctlMsgType_template *list_value;
} value_list;
struct {
L1ctlMsgType_template* precondition;
L1ctlMsgType_template* implied_template;
} implication_;
dynmatch_struct<L1ctlMsgType>* dyn_match;
};

void copy_template(const L1ctlMsgType_template& other_value);

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

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

boolean match(L1ctlMsgType::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const L1ctlMsgType& other_value, boolean legacy = FALSE) const;
L1ctlMsgType::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
L1ctlMsgType_template& list_item(unsigned int list_index);
void log() const;
void log_match(const L1ctlMsgType& 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 L1ctlCcchMode : public Base_Type { // enum
friend class L1ctlCcchMode_template;
public:
enum enum_type { CCCH__MODE__NONE = 0, CCCH__MODE__NON__COMBINED = 1, CCCH__MODE__COMBINED = 2, CCCH__MODE__COMBINED__CBCH = 3, UNKNOWN_VALUE = 4, UNBOUND_VALUE = 5 };
private:
enum_type enum_value;

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

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

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const L1ctlCcchMode& 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 L1ctlCcchMode& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const L1ctlCcchMode& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const L1ctlCcchMode& 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 L1ctlCcchMode& 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 L1ctlCcchMode& 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 L1ctlCcchMode& 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 L1ctlCcchMode_template : public Base_Template {
union {
L1ctlCcchMode::enum_type single_value;
struct {
unsigned int n_values;
L1ctlCcchMode_template *list_value;
} value_list;
struct {
L1ctlCcchMode_template* precondition;
L1ctlCcchMode_template* implied_template;
} implication_;
dynmatch_struct<L1ctlCcchMode>* dyn_match;
};

void copy_template(const L1ctlCcchMode_template& other_value);

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

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

boolean match(L1ctlCcchMode::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const L1ctlCcchMode& other_value, boolean legacy = FALSE) const;
L1ctlCcchMode::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
L1ctlCcchMode_template& list_item(unsigned int list_index);
void log() const;
void log_match(const L1ctlCcchMode& 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 L1ctlNeighMode : public Base_Type { // enum
friend class L1ctlNeighMode_template;
public:
enum enum_type { NEIGH__MODE__NONE = 0, NEIGH__MODE__PM = 1, NEIGH__MODE__SB = 2, UNKNOWN_VALUE = 3, UNBOUND_VALUE = 4 };
private:
enum_type enum_value;

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

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

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const L1ctlNeighMode& 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 L1ctlNeighMode& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const L1ctlNeighMode& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const L1ctlNeighMode& 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 L1ctlNeighMode& 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 L1ctlNeighMode& 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 L1ctlNeighMode& 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 L1ctlNeighMode_template : public Base_Template {
union {
L1ctlNeighMode::enum_type single_value;
struct {
unsigned int n_values;
L1ctlNeighMode_template *list_value;
} value_list;
struct {
L1ctlNeighMode_template* precondition;
L1ctlNeighMode_template* implied_template;
} implication_;
dynmatch_struct<L1ctlNeighMode>* dyn_match;
};

void copy_template(const L1ctlNeighMode_template& other_value);

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

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

boolean match(L1ctlNeighMode::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const L1ctlNeighMode& other_value, boolean legacy = FALSE) const;
L1ctlNeighMode::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
L1ctlNeighMode_template& list_item(unsigned int list_index);
void log() const;
void log_match(const L1ctlNeighMode& 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 L1ctlResetType : public Base_Type { // enum
friend class L1ctlResetType_template;
public:
enum enum_type { L1CTL__RES__T__BOOT = 0, L1CTL__RES__T__FULL = 1, L1CTL__RES__T__SCHED = 2, UNKNOWN_VALUE = 3, UNBOUND_VALUE = 4 };
private:
enum_type enum_value;

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

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

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const L1ctlResetType& 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 L1ctlResetType& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const L1ctlResetType& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const L1ctlResetType& 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 L1ctlResetType& 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 L1ctlResetType& 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 L1ctlResetType& 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 L1ctlResetType_template : public Base_Template {
union {
L1ctlResetType::enum_type single_value;
struct {
unsigned int n_values;
L1ctlResetType_template *list_value;
} value_list;
struct {
L1ctlResetType_template* precondition;
L1ctlResetType_template* implied_template;
} implication_;
dynmatch_struct<L1ctlResetType>* dyn_match;
};

void copy_template(const L1ctlResetType_template& other_value);

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

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

boolean match(L1ctlResetType::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const L1ctlResetType& other_value, boolean legacy = FALSE) const;
L1ctlResetType::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
L1ctlResetType_template& list_item(unsigned int list_index);
void log() const;
void log_match(const L1ctlResetType& 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 L1ctlHdrFlags : public Base_Type {
  BITSTRING field_padding;
  BOOLEAN field_f__done;
public:
  L1ctlHdrFlags();
  L1ctlHdrFlags(const BITSTRING& par_padding,
    const BOOLEAN& par_f__done);
  L1ctlHdrFlags(const L1ctlHdrFlags& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlHdrFlags& operator=(const L1ctlHdrFlags& other_value);
  boolean operator==(const L1ctlHdrFlags& other_value) const;
  inline boolean operator!=(const L1ctlHdrFlags& 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& padding()
    {return field_padding;}
  inline const BITSTRING& padding() const
    {return field_padding;}
  inline BOOLEAN& f__done()
    {return field_f__done;}
  inline const BOOLEAN& f__done() const
    {return field_f__done;}
  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 L1ctlHdrFlags_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlHdrFlags_template *list_value;
} value_list;
struct {
L1ctlHdrFlags_template* precondition;
L1ctlHdrFlags_template* implied_template;
} implication_;
dynmatch_struct<L1ctlHdrFlags>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlHdrFlags& other_value);
void copy_template(const L1ctlHdrFlags_template& other_value);

public:
L1ctlHdrFlags_template();
L1ctlHdrFlags_template(template_sel other_value);
L1ctlHdrFlags_template(const L1ctlHdrFlags& other_value);
L1ctlHdrFlags_template(const OPTIONAL<L1ctlHdrFlags>& other_value);
L1ctlHdrFlags_template(L1ctlHdrFlags_template* p_precondition, L1ctlHdrFlags_template* p_implied_template);
L1ctlHdrFlags_template(Dynamic_Match_Interface<L1ctlHdrFlags>* p_dyn_match);
L1ctlHdrFlags_template(const L1ctlHdrFlags_template& other_value);
~L1ctlHdrFlags_template();
L1ctlHdrFlags_template& operator=(template_sel other_value);
L1ctlHdrFlags_template& operator=(const L1ctlHdrFlags& other_value);
L1ctlHdrFlags_template& operator=(const OPTIONAL<L1ctlHdrFlags>& other_value);
L1ctlHdrFlags_template& operator=(const L1ctlHdrFlags_template& other_value);
boolean match(const L1ctlHdrFlags& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlHdrFlags valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlHdrFlags_template& list_item(unsigned int list_index) const;
BITSTRING_template& padding();
const BITSTRING_template& padding() const;
BOOLEAN_template& f__done();
const BOOLEAN_template& f__done() const;
int size_of() const;
void log() const;
void log_match(const L1ctlHdrFlags& 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 L1ctlHeader : public Base_Type {
  L1ctlMsgType field_msg__type;
  L1ctlHdrFlags field_flags;
  OCTETSTRING field_padding;
public:
  L1ctlHeader();
  L1ctlHeader(const L1ctlMsgType& par_msg__type,
    const L1ctlHdrFlags& par_flags,
    const OCTETSTRING& par_padding);
  L1ctlHeader(const L1ctlHeader& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlHeader& operator=(const L1ctlHeader& other_value);
  boolean operator==(const L1ctlHeader& other_value) const;
  inline boolean operator!=(const L1ctlHeader& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline L1ctlMsgType& msg__type()
    {return field_msg__type;}
  inline const L1ctlMsgType& msg__type() const
    {return field_msg__type;}
  inline L1ctlHdrFlags& flags()
    {return field_flags;}
  inline const L1ctlHdrFlags& flags() const
    {return field_flags;}
  inline OCTETSTRING& padding()
    {return field_padding;}
  inline const OCTETSTRING& padding() const
    {return field_padding;}
  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 L1ctlHeader_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlHeader_template *list_value;
} value_list;
struct {
L1ctlHeader_template* precondition;
L1ctlHeader_template* implied_template;
} implication_;
dynmatch_struct<L1ctlHeader>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlHeader& other_value);
void copy_template(const L1ctlHeader_template& other_value);

public:
L1ctlHeader_template();
L1ctlHeader_template(template_sel other_value);
L1ctlHeader_template(const L1ctlHeader& other_value);
L1ctlHeader_template(const OPTIONAL<L1ctlHeader>& other_value);
L1ctlHeader_template(L1ctlHeader_template* p_precondition, L1ctlHeader_template* p_implied_template);
L1ctlHeader_template(Dynamic_Match_Interface<L1ctlHeader>* p_dyn_match);
L1ctlHeader_template(const L1ctlHeader_template& other_value);
~L1ctlHeader_template();
L1ctlHeader_template& operator=(template_sel other_value);
L1ctlHeader_template& operator=(const L1ctlHeader& other_value);
L1ctlHeader_template& operator=(const OPTIONAL<L1ctlHeader>& other_value);
L1ctlHeader_template& operator=(const L1ctlHeader_template& other_value);
boolean match(const L1ctlHeader& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlHeader valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlHeader_template& list_item(unsigned int list_index) const;
L1ctlMsgType_template& msg__type();
const L1ctlMsgType_template& msg__type() const;
L1ctlHdrFlags_template& flags();
const L1ctlHdrFlags_template& flags() const;
OCTETSTRING_template& padding();
const OCTETSTRING_template& padding() const;
int size_of() const;
void log() const;
void log_match(const L1ctlHeader& 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 L1ctlDlInfo : public Base_Type {
  GSM__Types::RslChannelNr field_chan__nr;
  GSM__Types::RslLinkId field_link__id;
  GSM__Types::GsmBandArfcn field_arfcn;
  INTEGER field_frame__nr;
  INTEGER field_rx__level;
  INTEGER field_snr;
  INTEGER field_num__biterr;
  INTEGER field_fire__crc;
public:
  L1ctlDlInfo();
  L1ctlDlInfo(const GSM__Types::RslChannelNr& par_chan__nr,
    const GSM__Types::RslLinkId& par_link__id,
    const GSM__Types::GsmBandArfcn& par_arfcn,
    const INTEGER& par_frame__nr,
    const INTEGER& par_rx__level,
    const INTEGER& par_snr,
    const INTEGER& par_num__biterr,
    const INTEGER& par_fire__crc);
  L1ctlDlInfo(const L1ctlDlInfo& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlDlInfo& operator=(const L1ctlDlInfo& other_value);
  boolean operator==(const L1ctlDlInfo& other_value) const;
  inline boolean operator!=(const L1ctlDlInfo& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline GSM__Types::RslChannelNr& chan__nr()
    {return field_chan__nr;}
  inline const GSM__Types::RslChannelNr& chan__nr() const
    {return field_chan__nr;}
  inline GSM__Types::RslLinkId& link__id()
    {return field_link__id;}
  inline const GSM__Types::RslLinkId& link__id() const
    {return field_link__id;}
  inline GSM__Types::GsmBandArfcn& arfcn()
    {return field_arfcn;}
  inline const GSM__Types::GsmBandArfcn& arfcn() const
    {return field_arfcn;}
  inline INTEGER& frame__nr()
    {return field_frame__nr;}
  inline const INTEGER& frame__nr() const
    {return field_frame__nr;}
  inline INTEGER& rx__level()
    {return field_rx__level;}
  inline const INTEGER& rx__level() const
    {return field_rx__level;}
  inline INTEGER& snr()
    {return field_snr;}
  inline const INTEGER& snr() const
    {return field_snr;}
  inline INTEGER& num__biterr()
    {return field_num__biterr;}
  inline const INTEGER& num__biterr() const
    {return field_num__biterr;}
  inline INTEGER& fire__crc()
    {return field_fire__crc;}
  inline const INTEGER& fire__crc() const
    {return field_fire__crc;}
  inline int size_of() const
    {return 8;}
  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 L1ctlDlInfo_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlDlInfo_template *list_value;
} value_list;
struct {
L1ctlDlInfo_template* precondition;
L1ctlDlInfo_template* implied_template;
} implication_;
dynmatch_struct<L1ctlDlInfo>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlDlInfo& other_value);
void copy_template(const L1ctlDlInfo_template& other_value);

public:
L1ctlDlInfo_template();
L1ctlDlInfo_template(template_sel other_value);
L1ctlDlInfo_template(const L1ctlDlInfo& other_value);
L1ctlDlInfo_template(const OPTIONAL<L1ctlDlInfo>& other_value);
L1ctlDlInfo_template(L1ctlDlInfo_template* p_precondition, L1ctlDlInfo_template* p_implied_template);
L1ctlDlInfo_template(Dynamic_Match_Interface<L1ctlDlInfo>* p_dyn_match);
L1ctlDlInfo_template(const L1ctlDlInfo_template& other_value);
~L1ctlDlInfo_template();
L1ctlDlInfo_template& operator=(template_sel other_value);
L1ctlDlInfo_template& operator=(const L1ctlDlInfo& other_value);
L1ctlDlInfo_template& operator=(const OPTIONAL<L1ctlDlInfo>& other_value);
L1ctlDlInfo_template& operator=(const L1ctlDlInfo_template& other_value);
boolean match(const L1ctlDlInfo& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlDlInfo valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlDlInfo_template& list_item(unsigned int list_index) const;
GSM__Types::RslChannelNr_template& chan__nr();
const GSM__Types::RslChannelNr_template& chan__nr() const;
GSM__Types::RslLinkId_template& link__id();
const GSM__Types::RslLinkId_template& link__id() const;
GSM__Types::GsmBandArfcn_template& arfcn();
const GSM__Types::GsmBandArfcn_template& arfcn() const;
INTEGER_template& frame__nr();
const INTEGER_template& frame__nr() const;
INTEGER_template& rx__level();
const INTEGER_template& rx__level() const;
INTEGER_template& snr();
const INTEGER_template& snr() const;
INTEGER_template& num__biterr();
const INTEGER_template& num__biterr() const;
INTEGER_template& fire__crc();
const INTEGER_template& fire__crc() const;
int size_of() const;
void log() const;
void log_match(const L1ctlDlInfo& 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 L1ctlFbsbConf : public Base_Type {
  INTEGER field_initial__freq__err;
  INTEGER field_result;
  INTEGER field_bsic;
public:
  L1ctlFbsbConf();
  L1ctlFbsbConf(const INTEGER& par_initial__freq__err,
    const INTEGER& par_result,
    const INTEGER& par_bsic);
  L1ctlFbsbConf(const L1ctlFbsbConf& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlFbsbConf& operator=(const L1ctlFbsbConf& other_value);
  boolean operator==(const L1ctlFbsbConf& other_value) const;
  inline boolean operator!=(const L1ctlFbsbConf& 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& initial__freq__err()
    {return field_initial__freq__err;}
  inline const INTEGER& initial__freq__err() const
    {return field_initial__freq__err;}
  inline INTEGER& result()
    {return field_result;}
  inline const INTEGER& result() const
    {return field_result;}
  inline INTEGER& bsic()
    {return field_bsic;}
  inline const INTEGER& bsic() const
    {return field_bsic;}
  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 L1ctlFbsbConf_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlFbsbConf_template *list_value;
} value_list;
struct {
L1ctlFbsbConf_template* precondition;
L1ctlFbsbConf_template* implied_template;
} implication_;
dynmatch_struct<L1ctlFbsbConf>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlFbsbConf& other_value);
void copy_template(const L1ctlFbsbConf_template& other_value);

public:
L1ctlFbsbConf_template();
L1ctlFbsbConf_template(template_sel other_value);
L1ctlFbsbConf_template(const L1ctlFbsbConf& other_value);
L1ctlFbsbConf_template(const OPTIONAL<L1ctlFbsbConf>& other_value);
L1ctlFbsbConf_template(L1ctlFbsbConf_template* p_precondition, L1ctlFbsbConf_template* p_implied_template);
L1ctlFbsbConf_template(Dynamic_Match_Interface<L1ctlFbsbConf>* p_dyn_match);
L1ctlFbsbConf_template(const L1ctlFbsbConf_template& other_value);
~L1ctlFbsbConf_template();
L1ctlFbsbConf_template& operator=(template_sel other_value);
L1ctlFbsbConf_template& operator=(const L1ctlFbsbConf& other_value);
L1ctlFbsbConf_template& operator=(const OPTIONAL<L1ctlFbsbConf>& other_value);
L1ctlFbsbConf_template& operator=(const L1ctlFbsbConf_template& other_value);
boolean match(const L1ctlFbsbConf& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlFbsbConf valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlFbsbConf_template& list_item(unsigned int list_index) const;
INTEGER_template& initial__freq__err();
const INTEGER_template& initial__freq__err() const;
INTEGER_template& result();
const INTEGER_template& result() const;
INTEGER_template& bsic();
const INTEGER_template& bsic() const;
int size_of() const;
void log() const;
void log_match(const L1ctlFbsbConf& 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 L1ctlCcchModeConf : public Base_Type {
  L1ctlCcchMode field_ccch__mode;
  OCTETSTRING field_padding;
public:
  L1ctlCcchModeConf();
  L1ctlCcchModeConf(const L1ctlCcchMode& par_ccch__mode,
    const OCTETSTRING& par_padding);
  L1ctlCcchModeConf(const L1ctlCcchModeConf& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlCcchModeConf& operator=(const L1ctlCcchModeConf& other_value);
  boolean operator==(const L1ctlCcchModeConf& other_value) const;
  inline boolean operator!=(const L1ctlCcchModeConf& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline L1ctlCcchMode& ccch__mode()
    {return field_ccch__mode;}
  inline const L1ctlCcchMode& ccch__mode() const
    {return field_ccch__mode;}
  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 L1ctlCcchModeConf_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlCcchModeConf_template *list_value;
} value_list;
struct {
L1ctlCcchModeConf_template* precondition;
L1ctlCcchModeConf_template* implied_template;
} implication_;
dynmatch_struct<L1ctlCcchModeConf>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlCcchModeConf& other_value);
void copy_template(const L1ctlCcchModeConf_template& other_value);

public:
L1ctlCcchModeConf_template();
L1ctlCcchModeConf_template(template_sel other_value);
L1ctlCcchModeConf_template(const L1ctlCcchModeConf& other_value);
L1ctlCcchModeConf_template(const OPTIONAL<L1ctlCcchModeConf>& other_value);
L1ctlCcchModeConf_template(L1ctlCcchModeConf_template* p_precondition, L1ctlCcchModeConf_template* p_implied_template);
L1ctlCcchModeConf_template(Dynamic_Match_Interface<L1ctlCcchModeConf>* p_dyn_match);
L1ctlCcchModeConf_template(const L1ctlCcchModeConf_template& other_value);
~L1ctlCcchModeConf_template();
L1ctlCcchModeConf_template& operator=(template_sel other_value);
L1ctlCcchModeConf_template& operator=(const L1ctlCcchModeConf& other_value);
L1ctlCcchModeConf_template& operator=(const OPTIONAL<L1ctlCcchModeConf>& other_value);
L1ctlCcchModeConf_template& operator=(const L1ctlCcchModeConf_template& other_value);
boolean match(const L1ctlCcchModeConf& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlCcchModeConf valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlCcchModeConf_template& list_item(unsigned int list_index) const;
L1ctlCcchMode_template& ccch__mode();
const L1ctlCcchMode_template& ccch__mode() const;
OCTETSTRING_template& padding();
const OCTETSTRING_template& padding() const;
int size_of() const;
void log() const;
void log_match(const L1ctlCcchModeConf& 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 L1ctlTchMode : public Base_Type { // enum
friend class L1ctlTchMode_template;
public:
enum enum_type { L1CTL__CHAN__MODE__SIGN = 0, L1CTL__CHAN__MODE__SPEECH__V1 = 1, L1CTL__CHAN__MODE__SPEECH__V2 = 33, L1CTL__CHAN__MODE__SPEECH__V3 = 65, L1CTL__CHAN__MODE__DATA__14k5 = 15, L1CTL__CHAN__MODE__DATA__12k0 = 3, L1CTL__CHAN__MODE__DATA__6k0 = 11, L1CTL__CHAN__MODE__DATA__3k6 = 19, UNKNOWN_VALUE = 2, UNBOUND_VALUE = 4 };
private:
enum_type enum_value;

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

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

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const L1ctlTchMode& 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 L1ctlTchMode& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const L1ctlTchMode& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const L1ctlTchMode& 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 L1ctlTchMode& 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 L1ctlTchMode& 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 L1ctlTchMode& 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 L1ctlTchMode_template : public Base_Template {
union {
L1ctlTchMode::enum_type single_value;
struct {
unsigned int n_values;
L1ctlTchMode_template *list_value;
} value_list;
struct {
L1ctlTchMode_template* precondition;
L1ctlTchMode_template* implied_template;
} implication_;
dynmatch_struct<L1ctlTchMode>* dyn_match;
};

void copy_template(const L1ctlTchMode_template& other_value);

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

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

boolean match(L1ctlTchMode::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const L1ctlTchMode& other_value, boolean legacy = FALSE) const;
L1ctlTchMode::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
L1ctlTchMode_template& list_item(unsigned int list_index);
void log() const;
void log_match(const L1ctlTchMode& 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 L1ctlLoopMode : public Base_Type { // enum
friend class L1ctlLoopMode_template;
public:
enum enum_type { L1CTL__LOOP__MODE__OPEN = 0, L1CTL__LOOP__MODE__A = 1, L1CTL__LOOP__MODE__B = 2, L1CTL__LOOP__MODE__C = 3, L1CTL__LOOP__MODE__D = 4, L1CTL__LOOP__MODE__E = 5, L1CTL__LOOP__MODE__F = 6, L1CTL__LOOP__MODE__I = 7, UNKNOWN_VALUE = 8, UNBOUND_VALUE = 9 };
private:
enum_type enum_value;

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

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

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const L1ctlLoopMode& 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 L1ctlLoopMode& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const L1ctlLoopMode& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const L1ctlLoopMode& 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 L1ctlLoopMode& 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 L1ctlLoopMode& 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 L1ctlLoopMode& 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 L1ctlLoopMode_template : public Base_Template {
union {
L1ctlLoopMode::enum_type single_value;
struct {
unsigned int n_values;
L1ctlLoopMode_template *list_value;
} value_list;
struct {
L1ctlLoopMode_template* precondition;
L1ctlLoopMode_template* implied_template;
} implication_;
dynmatch_struct<L1ctlLoopMode>* dyn_match;
};

void copy_template(const L1ctlLoopMode_template& other_value);

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

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

boolean match(L1ctlLoopMode::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const L1ctlLoopMode& other_value, boolean legacy = FALSE) const;
L1ctlLoopMode::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
L1ctlLoopMode_template& list_item(unsigned int list_index);
void log() const;
void log_match(const L1ctlLoopMode& 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 L1ctlAudioMode : public Base_Type {
  BITSTRING field_padding;
  BOOLEAN field_tx__microphone;
  BOOLEAN field_tx__traffic__req;
  BOOLEAN field_rx__speaker;
  BOOLEAN field_rx__traffic__ind;
public:
  L1ctlAudioMode();
  L1ctlAudioMode(const BITSTRING& par_padding,
    const BOOLEAN& par_tx__microphone,
    const BOOLEAN& par_tx__traffic__req,
    const BOOLEAN& par_rx__speaker,
    const BOOLEAN& par_rx__traffic__ind);
  L1ctlAudioMode(const L1ctlAudioMode& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlAudioMode& operator=(const L1ctlAudioMode& other_value);
  boolean operator==(const L1ctlAudioMode& other_value) const;
  inline boolean operator!=(const L1ctlAudioMode& 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& padding()
    {return field_padding;}
  inline const BITSTRING& padding() const
    {return field_padding;}
  inline BOOLEAN& tx__microphone()
    {return field_tx__microphone;}
  inline const BOOLEAN& tx__microphone() const
    {return field_tx__microphone;}
  inline BOOLEAN& tx__traffic__req()
    {return field_tx__traffic__req;}
  inline const BOOLEAN& tx__traffic__req() const
    {return field_tx__traffic__req;}
  inline BOOLEAN& rx__speaker()
    {return field_rx__speaker;}
  inline const BOOLEAN& rx__speaker() const
    {return field_rx__speaker;}
  inline BOOLEAN& rx__traffic__ind()
    {return field_rx__traffic__ind;}
  inline const BOOLEAN& rx__traffic__ind() const
    {return field_rx__traffic__ind;}
  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 L1ctlAudioMode_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlAudioMode_template *list_value;
} value_list;
struct {
L1ctlAudioMode_template* precondition;
L1ctlAudioMode_template* implied_template;
} implication_;
dynmatch_struct<L1ctlAudioMode>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlAudioMode& other_value);
void copy_template(const L1ctlAudioMode_template& other_value);

public:
L1ctlAudioMode_template();
L1ctlAudioMode_template(template_sel other_value);
L1ctlAudioMode_template(const L1ctlAudioMode& other_value);
L1ctlAudioMode_template(const OPTIONAL<L1ctlAudioMode>& other_value);
L1ctlAudioMode_template(L1ctlAudioMode_template* p_precondition, L1ctlAudioMode_template* p_implied_template);
L1ctlAudioMode_template(Dynamic_Match_Interface<L1ctlAudioMode>* p_dyn_match);
L1ctlAudioMode_template(const L1ctlAudioMode_template& other_value);
~L1ctlAudioMode_template();
L1ctlAudioMode_template& operator=(template_sel other_value);
L1ctlAudioMode_template& operator=(const L1ctlAudioMode& other_value);
L1ctlAudioMode_template& operator=(const OPTIONAL<L1ctlAudioMode>& other_value);
L1ctlAudioMode_template& operator=(const L1ctlAudioMode_template& other_value);
boolean match(const L1ctlAudioMode& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlAudioMode valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlAudioMode_template& list_item(unsigned int list_index) const;
BITSTRING_template& padding();
const BITSTRING_template& padding() const;
BOOLEAN_template& tx__microphone();
const BOOLEAN_template& tx__microphone() const;
BOOLEAN_template& tx__traffic__req();
const BOOLEAN_template& tx__traffic__req() const;
BOOLEAN_template& rx__speaker();
const BOOLEAN_template& rx__speaker() const;
BOOLEAN_template& rx__traffic__ind();
const BOOLEAN_template& rx__traffic__ind() const;
int size_of() const;
void log() const;
void log_match(const L1ctlAudioMode& 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 L1ctlTchModeConf_amr : public Base_Type {
  INTEGER field_start__codec;
  BITSTRING field_codecs__bitmask;
public:
  L1ctlTchModeConf_amr();
  L1ctlTchModeConf_amr(const INTEGER& par_start__codec,
    const BITSTRING& par_codecs__bitmask);
  L1ctlTchModeConf_amr(const L1ctlTchModeConf_amr& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlTchModeConf_amr& operator=(const L1ctlTchModeConf_amr& other_value);
  boolean operator==(const L1ctlTchModeConf_amr& other_value) const;
  inline boolean operator!=(const L1ctlTchModeConf_amr& 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& start__codec()
    {return field_start__codec;}
  inline const INTEGER& start__codec() const
    {return field_start__codec;}
  inline BITSTRING& codecs__bitmask()
    {return field_codecs__bitmask;}
  inline const BITSTRING& codecs__bitmask() const
    {return field_codecs__bitmask;}
  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 L1ctlTchModeConf_amr_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlTchModeConf_amr_template *list_value;
} value_list;
struct {
L1ctlTchModeConf_amr_template* precondition;
L1ctlTchModeConf_amr_template* implied_template;
} implication_;
dynmatch_struct<L1ctlTchModeConf_amr>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlTchModeConf_amr& other_value);
void copy_template(const L1ctlTchModeConf_amr_template& other_value);

public:
L1ctlTchModeConf_amr_template();
L1ctlTchModeConf_amr_template(template_sel other_value);
L1ctlTchModeConf_amr_template(const L1ctlTchModeConf_amr& other_value);
L1ctlTchModeConf_amr_template(const OPTIONAL<L1ctlTchModeConf_amr>& other_value);
L1ctlTchModeConf_amr_template(L1ctlTchModeConf_amr_template* p_precondition, L1ctlTchModeConf_amr_template* p_implied_template);
L1ctlTchModeConf_amr_template(Dynamic_Match_Interface<L1ctlTchModeConf_amr>* p_dyn_match);
L1ctlTchModeConf_amr_template(const L1ctlTchModeConf_amr_template& other_value);
~L1ctlTchModeConf_amr_template();
L1ctlTchModeConf_amr_template& operator=(template_sel other_value);
L1ctlTchModeConf_amr_template& operator=(const L1ctlTchModeConf_amr& other_value);
L1ctlTchModeConf_amr_template& operator=(const OPTIONAL<L1ctlTchModeConf_amr>& other_value);
L1ctlTchModeConf_amr_template& operator=(const L1ctlTchModeConf_amr_template& other_value);
boolean match(const L1ctlTchModeConf_amr& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlTchModeConf_amr valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlTchModeConf_amr_template& list_item(unsigned int list_index) const;
INTEGER_template& start__codec();
const INTEGER_template& start__codec() const;
BITSTRING_template& codecs__bitmask();
const BITSTRING_template& codecs__bitmask() const;
int size_of() const;
void log() const;
void log_match(const L1ctlTchModeConf_amr& 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 L1ctlTchModeConf : public Base_Type {
  L1ctlTchMode field_tch__mode;
  L1ctlAudioMode field_audio__mode;
  L1ctlTchModeConf_amr field_amr;
public:
  L1ctlTchModeConf();
  L1ctlTchModeConf(const L1ctlTchMode& par_tch__mode,
    const L1ctlAudioMode& par_audio__mode,
    const L1ctlTchModeConf_amr& par_amr);
  L1ctlTchModeConf(const L1ctlTchModeConf& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlTchModeConf& operator=(const L1ctlTchModeConf& other_value);
  boolean operator==(const L1ctlTchModeConf& other_value) const;
  inline boolean operator!=(const L1ctlTchModeConf& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline L1ctlTchMode& tch__mode()
    {return field_tch__mode;}
  inline const L1ctlTchMode& tch__mode() const
    {return field_tch__mode;}
  inline L1ctlAudioMode& audio__mode()
    {return field_audio__mode;}
  inline const L1ctlAudioMode& audio__mode() const
    {return field_audio__mode;}
  inline L1ctlTchModeConf_amr& amr()
    {return field_amr;}
  inline const L1ctlTchModeConf_amr& amr() const
    {return field_amr;}
  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 L1ctlTchModeConf_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlTchModeConf_template *list_value;
} value_list;
struct {
L1ctlTchModeConf_template* precondition;
L1ctlTchModeConf_template* implied_template;
} implication_;
dynmatch_struct<L1ctlTchModeConf>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlTchModeConf& other_value);
void copy_template(const L1ctlTchModeConf_template& other_value);

public:
L1ctlTchModeConf_template();
L1ctlTchModeConf_template(template_sel other_value);
L1ctlTchModeConf_template(const L1ctlTchModeConf& other_value);
L1ctlTchModeConf_template(const OPTIONAL<L1ctlTchModeConf>& other_value);
L1ctlTchModeConf_template(L1ctlTchModeConf_template* p_precondition, L1ctlTchModeConf_template* p_implied_template);
L1ctlTchModeConf_template(Dynamic_Match_Interface<L1ctlTchModeConf>* p_dyn_match);
L1ctlTchModeConf_template(const L1ctlTchModeConf_template& other_value);
~L1ctlTchModeConf_template();
L1ctlTchModeConf_template& operator=(template_sel other_value);
L1ctlTchModeConf_template& operator=(const L1ctlTchModeConf& other_value);
L1ctlTchModeConf_template& operator=(const OPTIONAL<L1ctlTchModeConf>& other_value);
L1ctlTchModeConf_template& operator=(const L1ctlTchModeConf_template& other_value);
boolean match(const L1ctlTchModeConf& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlTchModeConf valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlTchModeConf_template& list_item(unsigned int list_index) const;
L1ctlTchMode_template& tch__mode();
const L1ctlTchMode_template& tch__mode() const;
L1ctlAudioMode_template& audio__mode();
const L1ctlAudioMode_template& audio__mode() const;
L1ctlTchModeConf_amr_template& amr();
const L1ctlTchModeConf_amr_template& amr() const;
int size_of() const;
void log() const;
void log_match(const L1ctlTchModeConf& 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 L1ctlDataInd : public Base_Type {
  OCTETSTRING field_payload;
public:
  L1ctlDataInd();
  L1ctlDataInd(const OCTETSTRING& par_payload);
  L1ctlDataInd(const L1ctlDataInd& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlDataInd& operator=(const L1ctlDataInd& other_value);
  boolean operator==(const L1ctlDataInd& other_value) const;
  inline boolean operator!=(const L1ctlDataInd& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline OCTETSTRING& payload()
    {return field_payload;}
  inline const OCTETSTRING& payload() const
    {return field_payload;}
  inline int size_of() const
    {return 1;}
  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 L1ctlDataInd_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlDataInd_template *list_value;
} value_list;
struct {
L1ctlDataInd_template* precondition;
L1ctlDataInd_template* implied_template;
} implication_;
dynmatch_struct<L1ctlDataInd>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlDataInd& other_value);
void copy_template(const L1ctlDataInd_template& other_value);

public:
L1ctlDataInd_template();
L1ctlDataInd_template(template_sel other_value);
L1ctlDataInd_template(const L1ctlDataInd& other_value);
L1ctlDataInd_template(const OPTIONAL<L1ctlDataInd>& other_value);
L1ctlDataInd_template(L1ctlDataInd_template* p_precondition, L1ctlDataInd_template* p_implied_template);
L1ctlDataInd_template(Dynamic_Match_Interface<L1ctlDataInd>* p_dyn_match);
L1ctlDataInd_template(const L1ctlDataInd_template& other_value);
~L1ctlDataInd_template();
L1ctlDataInd_template& operator=(template_sel other_value);
L1ctlDataInd_template& operator=(const L1ctlDataInd& other_value);
L1ctlDataInd_template& operator=(const OPTIONAL<L1ctlDataInd>& other_value);
L1ctlDataInd_template& operator=(const L1ctlDataInd_template& other_value);
boolean match(const L1ctlDataInd& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlDataInd valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlDataInd_template& list_item(unsigned int list_index) const;
OCTETSTRING_template& payload();
const OCTETSTRING_template& payload() const;
int size_of() const;
void log() const;
void log_match(const L1ctlDataInd& 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 L1ctlUlInfo : public Base_Type {
  GSM__Types::RslChannelNr field_chan__nr;
  GSM__Types::RslLinkId field_link__id;
  OCTETSTRING field_padding;
public:
  L1ctlUlInfo();
  L1ctlUlInfo(const GSM__Types::RslChannelNr& par_chan__nr,
    const GSM__Types::RslLinkId& par_link__id,
    const OCTETSTRING& par_padding);
  L1ctlUlInfo(const L1ctlUlInfo& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlUlInfo& operator=(const L1ctlUlInfo& other_value);
  boolean operator==(const L1ctlUlInfo& other_value) const;
  inline boolean operator!=(const L1ctlUlInfo& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline GSM__Types::RslChannelNr& chan__nr()
    {return field_chan__nr;}
  inline const GSM__Types::RslChannelNr& chan__nr() const
    {return field_chan__nr;}
  inline GSM__Types::RslLinkId& link__id()
    {return field_link__id;}
  inline const GSM__Types::RslLinkId& link__id() const
    {return field_link__id;}
  inline OCTETSTRING& padding()
    {return field_padding;}
  inline const OCTETSTRING& padding() const
    {return field_padding;}
  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 L1ctlUlInfo_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlUlInfo_template *list_value;
} value_list;
struct {
L1ctlUlInfo_template* precondition;
L1ctlUlInfo_template* implied_template;
} implication_;
dynmatch_struct<L1ctlUlInfo>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlUlInfo& other_value);
void copy_template(const L1ctlUlInfo_template& other_value);

public:
L1ctlUlInfo_template();
L1ctlUlInfo_template(template_sel other_value);
L1ctlUlInfo_template(const L1ctlUlInfo& other_value);
L1ctlUlInfo_template(const OPTIONAL<L1ctlUlInfo>& other_value);
L1ctlUlInfo_template(L1ctlUlInfo_template* p_precondition, L1ctlUlInfo_template* p_implied_template);
L1ctlUlInfo_template(Dynamic_Match_Interface<L1ctlUlInfo>* p_dyn_match);
L1ctlUlInfo_template(const L1ctlUlInfo_template& other_value);
~L1ctlUlInfo_template();
L1ctlUlInfo_template& operator=(template_sel other_value);
L1ctlUlInfo_template& operator=(const L1ctlUlInfo& other_value);
L1ctlUlInfo_template& operator=(const OPTIONAL<L1ctlUlInfo>& other_value);
L1ctlUlInfo_template& operator=(const L1ctlUlInfo_template& other_value);
boolean match(const L1ctlUlInfo& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlUlInfo valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlUlInfo_template& list_item(unsigned int list_index) const;
GSM__Types::RslChannelNr_template& chan__nr();
const GSM__Types::RslChannelNr_template& chan__nr() const;
GSM__Types::RslLinkId_template& link__id();
const GSM__Types::RslLinkId_template& link__id() const;
OCTETSTRING_template& padding();
const OCTETSTRING_template& padding() const;
int size_of() const;
void log() const;
void log_match(const L1ctlUlInfo& 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 L1ctlFbsbFlags : public Base_Type {
  BITSTRING field_padding;
  BOOLEAN field_sb;
  BOOLEAN field_fb1;
  BOOLEAN field_fb0;
public:
  L1ctlFbsbFlags();
  L1ctlFbsbFlags(const BITSTRING& par_padding,
    const BOOLEAN& par_sb,
    const BOOLEAN& par_fb1,
    const BOOLEAN& par_fb0);
  L1ctlFbsbFlags(const L1ctlFbsbFlags& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlFbsbFlags& operator=(const L1ctlFbsbFlags& other_value);
  boolean operator==(const L1ctlFbsbFlags& other_value) const;
  inline boolean operator!=(const L1ctlFbsbFlags& 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& padding()
    {return field_padding;}
  inline const BITSTRING& padding() const
    {return field_padding;}
  inline BOOLEAN& sb()
    {return field_sb;}
  inline const BOOLEAN& sb() const
    {return field_sb;}
  inline BOOLEAN& fb1()
    {return field_fb1;}
  inline const BOOLEAN& fb1() const
    {return field_fb1;}
  inline BOOLEAN& fb0()
    {return field_fb0;}
  inline const BOOLEAN& fb0() const
    {return field_fb0;}
  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 L1ctlFbsbFlags_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlFbsbFlags_template *list_value;
} value_list;
struct {
L1ctlFbsbFlags_template* precondition;
L1ctlFbsbFlags_template* implied_template;
} implication_;
dynmatch_struct<L1ctlFbsbFlags>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlFbsbFlags& other_value);
void copy_template(const L1ctlFbsbFlags_template& other_value);

public:
L1ctlFbsbFlags_template();
L1ctlFbsbFlags_template(template_sel other_value);
L1ctlFbsbFlags_template(const L1ctlFbsbFlags& other_value);
L1ctlFbsbFlags_template(const OPTIONAL<L1ctlFbsbFlags>& other_value);
L1ctlFbsbFlags_template(L1ctlFbsbFlags_template* p_precondition, L1ctlFbsbFlags_template* p_implied_template);
L1ctlFbsbFlags_template(Dynamic_Match_Interface<L1ctlFbsbFlags>* p_dyn_match);
L1ctlFbsbFlags_template(const L1ctlFbsbFlags_template& other_value);
~L1ctlFbsbFlags_template();
L1ctlFbsbFlags_template& operator=(template_sel other_value);
L1ctlFbsbFlags_template& operator=(const L1ctlFbsbFlags& other_value);
L1ctlFbsbFlags_template& operator=(const OPTIONAL<L1ctlFbsbFlags>& other_value);
L1ctlFbsbFlags_template& operator=(const L1ctlFbsbFlags_template& other_value);
boolean match(const L1ctlFbsbFlags& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlFbsbFlags valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlFbsbFlags_template& list_item(unsigned int list_index) const;
BITSTRING_template& padding();
const BITSTRING_template& padding() const;
BOOLEAN_template& sb();
const BOOLEAN_template& sb() const;
BOOLEAN_template& fb1();
const BOOLEAN_template& fb1() const;
BOOLEAN_template& fb0();
const BOOLEAN_template& fb0() const;
int size_of() const;
void log() const;
void log_match(const L1ctlFbsbFlags& 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 L1ctlFbsbReq : public Base_Type {
  GSM__Types::GsmBandArfcn field_arfcn;
  INTEGER field_timeout__tdma__frames;
  INTEGER field_freq__err__thresh1;
  INTEGER field_freq__err__thresh2;
  INTEGER field_num__freqerr__avg;
  L1ctlFbsbFlags field_flags;
  INTEGER field_sync__info__idx;
  L1ctlCcchMode field_ccch__mode;
  INTEGER field_rxlev__exp;
public:
  L1ctlFbsbReq();
  L1ctlFbsbReq(const GSM__Types::GsmBandArfcn& par_arfcn,
    const INTEGER& par_timeout__tdma__frames,
    const INTEGER& par_freq__err__thresh1,
    const INTEGER& par_freq__err__thresh2,
    const INTEGER& par_num__freqerr__avg,
    const L1ctlFbsbFlags& par_flags,
    const INTEGER& par_sync__info__idx,
    const L1ctlCcchMode& par_ccch__mode,
    const INTEGER& par_rxlev__exp);
  L1ctlFbsbReq(const L1ctlFbsbReq& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlFbsbReq& operator=(const L1ctlFbsbReq& other_value);
  boolean operator==(const L1ctlFbsbReq& other_value) const;
  inline boolean operator!=(const L1ctlFbsbReq& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline GSM__Types::GsmBandArfcn& arfcn()
    {return field_arfcn;}
  inline const GSM__Types::GsmBandArfcn& arfcn() const
    {return field_arfcn;}
  inline INTEGER& timeout__tdma__frames()
    {return field_timeout__tdma__frames;}
  inline const INTEGER& timeout__tdma__frames() const
    {return field_timeout__tdma__frames;}
  inline INTEGER& freq__err__thresh1()
    {return field_freq__err__thresh1;}
  inline const INTEGER& freq__err__thresh1() const
    {return field_freq__err__thresh1;}
  inline INTEGER& freq__err__thresh2()
    {return field_freq__err__thresh2;}
  inline const INTEGER& freq__err__thresh2() const
    {return field_freq__err__thresh2;}
  inline INTEGER& num__freqerr__avg()
    {return field_num__freqerr__avg;}
  inline const INTEGER& num__freqerr__avg() const
    {return field_num__freqerr__avg;}
  inline L1ctlFbsbFlags& flags()
    {return field_flags;}
  inline const L1ctlFbsbFlags& flags() const
    {return field_flags;}
  inline INTEGER& sync__info__idx()
    {return field_sync__info__idx;}
  inline const INTEGER& sync__info__idx() const
    {return field_sync__info__idx;}
  inline L1ctlCcchMode& ccch__mode()
    {return field_ccch__mode;}
  inline const L1ctlCcchMode& ccch__mode() const
    {return field_ccch__mode;}
  inline INTEGER& rxlev__exp()
    {return field_rxlev__exp;}
  inline const INTEGER& rxlev__exp() const
    {return field_rxlev__exp;}
  inline int size_of() const
    {return 9;}
  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 L1ctlFbsbReq_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlFbsbReq_template *list_value;
} value_list;
struct {
L1ctlFbsbReq_template* precondition;
L1ctlFbsbReq_template* implied_template;
} implication_;
dynmatch_struct<L1ctlFbsbReq>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlFbsbReq& other_value);
void copy_template(const L1ctlFbsbReq_template& other_value);

public:
L1ctlFbsbReq_template();
L1ctlFbsbReq_template(template_sel other_value);
L1ctlFbsbReq_template(const L1ctlFbsbReq& other_value);
L1ctlFbsbReq_template(const OPTIONAL<L1ctlFbsbReq>& other_value);
L1ctlFbsbReq_template(L1ctlFbsbReq_template* p_precondition, L1ctlFbsbReq_template* p_implied_template);
L1ctlFbsbReq_template(Dynamic_Match_Interface<L1ctlFbsbReq>* p_dyn_match);
L1ctlFbsbReq_template(const L1ctlFbsbReq_template& other_value);
~L1ctlFbsbReq_template();
L1ctlFbsbReq_template& operator=(template_sel other_value);
L1ctlFbsbReq_template& operator=(const L1ctlFbsbReq& other_value);
L1ctlFbsbReq_template& operator=(const OPTIONAL<L1ctlFbsbReq>& other_value);
L1ctlFbsbReq_template& operator=(const L1ctlFbsbReq_template& other_value);
boolean match(const L1ctlFbsbReq& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlFbsbReq valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlFbsbReq_template& list_item(unsigned int list_index) const;
GSM__Types::GsmBandArfcn_template& arfcn();
const GSM__Types::GsmBandArfcn_template& arfcn() const;
INTEGER_template& timeout__tdma__frames();
const INTEGER_template& timeout__tdma__frames() const;
INTEGER_template& freq__err__thresh1();
const INTEGER_template& freq__err__thresh1() const;
INTEGER_template& freq__err__thresh2();
const INTEGER_template& freq__err__thresh2() const;
INTEGER_template& num__freqerr__avg();
const INTEGER_template& num__freqerr__avg() const;
L1ctlFbsbFlags_template& flags();
const L1ctlFbsbFlags_template& flags() const;
INTEGER_template& sync__info__idx();
const INTEGER_template& sync__info__idx() const;
L1ctlCcchMode_template& ccch__mode();
const L1ctlCcchMode_template& ccch__mode() const;
INTEGER_template& rxlev__exp();
const INTEGER_template& rxlev__exp() const;
int size_of() const;
void log() const;
void log_match(const L1ctlFbsbReq& 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 L1ctlCcchModeReq : public Base_Type {
  L1ctlCcchMode field_ccch__mode;
  OCTETSTRING field_padding;
public:
  L1ctlCcchModeReq();
  L1ctlCcchModeReq(const L1ctlCcchMode& par_ccch__mode,
    const OCTETSTRING& par_padding);
  L1ctlCcchModeReq(const L1ctlCcchModeReq& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlCcchModeReq& operator=(const L1ctlCcchModeReq& other_value);
  boolean operator==(const L1ctlCcchModeReq& other_value) const;
  inline boolean operator!=(const L1ctlCcchModeReq& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline L1ctlCcchMode& ccch__mode()
    {return field_ccch__mode;}
  inline const L1ctlCcchMode& ccch__mode() const
    {return field_ccch__mode;}
  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 L1ctlCcchModeReq_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlCcchModeReq_template *list_value;
} value_list;
struct {
L1ctlCcchModeReq_template* precondition;
L1ctlCcchModeReq_template* implied_template;
} implication_;
dynmatch_struct<L1ctlCcchModeReq>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlCcchModeReq& other_value);
void copy_template(const L1ctlCcchModeReq_template& other_value);

public:
L1ctlCcchModeReq_template();
L1ctlCcchModeReq_template(template_sel other_value);
L1ctlCcchModeReq_template(const L1ctlCcchModeReq& other_value);
L1ctlCcchModeReq_template(const OPTIONAL<L1ctlCcchModeReq>& other_value);
L1ctlCcchModeReq_template(L1ctlCcchModeReq_template* p_precondition, L1ctlCcchModeReq_template* p_implied_template);
L1ctlCcchModeReq_template(Dynamic_Match_Interface<L1ctlCcchModeReq>* p_dyn_match);
L1ctlCcchModeReq_template(const L1ctlCcchModeReq_template& other_value);
~L1ctlCcchModeReq_template();
L1ctlCcchModeReq_template& operator=(template_sel other_value);
L1ctlCcchModeReq_template& operator=(const L1ctlCcchModeReq& other_value);
L1ctlCcchModeReq_template& operator=(const OPTIONAL<L1ctlCcchModeReq>& other_value);
L1ctlCcchModeReq_template& operator=(const L1ctlCcchModeReq_template& other_value);
boolean match(const L1ctlCcchModeReq& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlCcchModeReq valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlCcchModeReq_template& list_item(unsigned int list_index) const;
L1ctlCcchMode_template& ccch__mode();
const L1ctlCcchMode_template& ccch__mode() const;
OCTETSTRING_template& padding();
const OCTETSTRING_template& padding() const;
int size_of() const;
void log() const;
void log_match(const L1ctlCcchModeReq& 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 L1ctlTchModeReq_amr : public Base_Type {
  INTEGER field_start__codec;
  BITSTRING field_codecs__bitmask;
public:
  L1ctlTchModeReq_amr();
  L1ctlTchModeReq_amr(const INTEGER& par_start__codec,
    const BITSTRING& par_codecs__bitmask);
  L1ctlTchModeReq_amr(const L1ctlTchModeReq_amr& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlTchModeReq_amr& operator=(const L1ctlTchModeReq_amr& other_value);
  boolean operator==(const L1ctlTchModeReq_amr& other_value) const;
  inline boolean operator!=(const L1ctlTchModeReq_amr& 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& start__codec()
    {return field_start__codec;}
  inline const INTEGER& start__codec() const
    {return field_start__codec;}
  inline BITSTRING& codecs__bitmask()
    {return field_codecs__bitmask;}
  inline const BITSTRING& codecs__bitmask() const
    {return field_codecs__bitmask;}
  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 L1ctlTchModeReq_amr_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlTchModeReq_amr_template *list_value;
} value_list;
struct {
L1ctlTchModeReq_amr_template* precondition;
L1ctlTchModeReq_amr_template* implied_template;
} implication_;
dynmatch_struct<L1ctlTchModeReq_amr>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlTchModeReq_amr& other_value);
void copy_template(const L1ctlTchModeReq_amr_template& other_value);

public:
L1ctlTchModeReq_amr_template();
L1ctlTchModeReq_amr_template(template_sel other_value);
L1ctlTchModeReq_amr_template(const L1ctlTchModeReq_amr& other_value);
L1ctlTchModeReq_amr_template(const OPTIONAL<L1ctlTchModeReq_amr>& other_value);
L1ctlTchModeReq_amr_template(L1ctlTchModeReq_amr_template* p_precondition, L1ctlTchModeReq_amr_template* p_implied_template);
L1ctlTchModeReq_amr_template(Dynamic_Match_Interface<L1ctlTchModeReq_amr>* p_dyn_match);
L1ctlTchModeReq_amr_template(const L1ctlTchModeReq_amr_template& other_value);
~L1ctlTchModeReq_amr_template();
L1ctlTchModeReq_amr_template& operator=(template_sel other_value);
L1ctlTchModeReq_amr_template& operator=(const L1ctlTchModeReq_amr& other_value);
L1ctlTchModeReq_amr_template& operator=(const OPTIONAL<L1ctlTchModeReq_amr>& other_value);
L1ctlTchModeReq_amr_template& operator=(const L1ctlTchModeReq_amr_template& other_value);
boolean match(const L1ctlTchModeReq_amr& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlTchModeReq_amr valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlTchModeReq_amr_template& list_item(unsigned int list_index) const;
INTEGER_template& start__codec();
const INTEGER_template& start__codec() const;
BITSTRING_template& codecs__bitmask();
const BITSTRING_template& codecs__bitmask() const;
int size_of() const;
void log() const;
void log_match(const L1ctlTchModeReq_amr& 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 L1ctlTchModeReq : public Base_Type {
  L1ctlTchMode field_tch__mode;
  L1ctlAudioMode field_audio__mode;
  L1ctlLoopMode field_loop__mode;
  L1ctlTchModeReq_amr field_amr;
public:
  L1ctlTchModeReq();
  L1ctlTchModeReq(const L1ctlTchMode& par_tch__mode,
    const L1ctlAudioMode& par_audio__mode,
    const L1ctlLoopMode& par_loop__mode,
    const L1ctlTchModeReq_amr& par_amr);
  L1ctlTchModeReq(const L1ctlTchModeReq& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlTchModeReq& operator=(const L1ctlTchModeReq& other_value);
  boolean operator==(const L1ctlTchModeReq& other_value) const;
  inline boolean operator!=(const L1ctlTchModeReq& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline L1ctlTchMode& tch__mode()
    {return field_tch__mode;}
  inline const L1ctlTchMode& tch__mode() const
    {return field_tch__mode;}
  inline L1ctlAudioMode& audio__mode()
    {return field_audio__mode;}
  inline const L1ctlAudioMode& audio__mode() const
    {return field_audio__mode;}
  inline L1ctlLoopMode& loop__mode()
    {return field_loop__mode;}
  inline const L1ctlLoopMode& loop__mode() const
    {return field_loop__mode;}
  inline L1ctlTchModeReq_amr& amr()
    {return field_amr;}
  inline const L1ctlTchModeReq_amr& amr() const
    {return field_amr;}
  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 L1ctlTchModeReq_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlTchModeReq_template *list_value;
} value_list;
struct {
L1ctlTchModeReq_template* precondition;
L1ctlTchModeReq_template* implied_template;
} implication_;
dynmatch_struct<L1ctlTchModeReq>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlTchModeReq& other_value);
void copy_template(const L1ctlTchModeReq_template& other_value);

public:
L1ctlTchModeReq_template();
L1ctlTchModeReq_template(template_sel other_value);
L1ctlTchModeReq_template(const L1ctlTchModeReq& other_value);
L1ctlTchModeReq_template(const OPTIONAL<L1ctlTchModeReq>& other_value);
L1ctlTchModeReq_template(L1ctlTchModeReq_template* p_precondition, L1ctlTchModeReq_template* p_implied_template);
L1ctlTchModeReq_template(Dynamic_Match_Interface<L1ctlTchModeReq>* p_dyn_match);
L1ctlTchModeReq_template(const L1ctlTchModeReq_template& other_value);
~L1ctlTchModeReq_template();
L1ctlTchModeReq_template& operator=(template_sel other_value);
L1ctlTchModeReq_template& operator=(const L1ctlTchModeReq& other_value);
L1ctlTchModeReq_template& operator=(const OPTIONAL<L1ctlTchModeReq>& other_value);
L1ctlTchModeReq_template& operator=(const L1ctlTchModeReq_template& other_value);
boolean match(const L1ctlTchModeReq& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlTchModeReq valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlTchModeReq_template& list_item(unsigned int list_index) const;
L1ctlTchMode_template& tch__mode();
const L1ctlTchMode_template& tch__mode() const;
L1ctlAudioMode_template& audio__mode();
const L1ctlAudioMode_template& audio__mode() const;
L1ctlLoopMode_template& loop__mode();
const L1ctlLoopMode_template& loop__mode() const;
L1ctlTchModeReq_amr_template& amr();
const L1ctlTchModeReq_amr_template& amr() const;
int size_of() const;
void log() const;
void log_match(const L1ctlTchModeReq& 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 L1ctlRachReq : public Base_Type {
  INTEGER field_ra;
  INTEGER field_combined;
  INTEGER field_offset;
public:
  L1ctlRachReq();
  L1ctlRachReq(const INTEGER& par_ra,
    const INTEGER& par_combined,
    const INTEGER& par_offset);
  L1ctlRachReq(const L1ctlRachReq& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlRachReq& operator=(const L1ctlRachReq& other_value);
  boolean operator==(const L1ctlRachReq& other_value) const;
  inline boolean operator!=(const L1ctlRachReq& 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& ra()
    {return field_ra;}
  inline const INTEGER& ra() const
    {return field_ra;}
  inline INTEGER& combined()
    {return field_combined;}
  inline const INTEGER& combined() const
    {return field_combined;}
  inline INTEGER& offset()
    {return field_offset;}
  inline const INTEGER& offset() const
    {return field_offset;}
  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 L1ctlRachReq_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlRachReq_template *list_value;
} value_list;
struct {
L1ctlRachReq_template* precondition;
L1ctlRachReq_template* implied_template;
} implication_;
dynmatch_struct<L1ctlRachReq>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlRachReq& other_value);
void copy_template(const L1ctlRachReq_template& other_value);

public:
L1ctlRachReq_template();
L1ctlRachReq_template(template_sel other_value);
L1ctlRachReq_template(const L1ctlRachReq& other_value);
L1ctlRachReq_template(const OPTIONAL<L1ctlRachReq>& other_value);
L1ctlRachReq_template(L1ctlRachReq_template* p_precondition, L1ctlRachReq_template* p_implied_template);
L1ctlRachReq_template(Dynamic_Match_Interface<L1ctlRachReq>* p_dyn_match);
L1ctlRachReq_template(const L1ctlRachReq_template& other_value);
~L1ctlRachReq_template();
L1ctlRachReq_template& operator=(template_sel other_value);
L1ctlRachReq_template& operator=(const L1ctlRachReq& other_value);
L1ctlRachReq_template& operator=(const OPTIONAL<L1ctlRachReq>& other_value);
L1ctlRachReq_template& operator=(const L1ctlRachReq_template& other_value);
boolean match(const L1ctlRachReq& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlRachReq valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlRachReq_template& list_item(unsigned int list_index) const;
INTEGER_template& ra();
const INTEGER_template& ra() const;
INTEGER_template& combined();
const INTEGER_template& combined() const;
INTEGER_template& offset();
const INTEGER_template& offset() const;
int size_of() const;
void log() const;
void log_match(const L1ctlRachReq& 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 L1ctlRachSynchSeq : public Base_Type { // enum
friend class L1ctlRachSynchSeq_template;
public:
enum enum_type { RACH__SYNCH__SEQ__TS0 = 0, RACH__SYNCH__SEQ__TS1 = 1, RACH__SYNCH__SEQ__TS2 = 2, UNKNOWN_VALUE = 3, UNBOUND_VALUE = 4 };
private:
enum_type enum_value;

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

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

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const L1ctlRachSynchSeq& 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 L1ctlRachSynchSeq& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const L1ctlRachSynchSeq& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const L1ctlRachSynchSeq& 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 L1ctlRachSynchSeq& 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 L1ctlRachSynchSeq& 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 L1ctlRachSynchSeq& 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 L1ctlRachSynchSeq_template : public Base_Template {
union {
L1ctlRachSynchSeq::enum_type single_value;
struct {
unsigned int n_values;
L1ctlRachSynchSeq_template *list_value;
} value_list;
struct {
L1ctlRachSynchSeq_template* precondition;
L1ctlRachSynchSeq_template* implied_template;
} implication_;
dynmatch_struct<L1ctlRachSynchSeq>* dyn_match;
};

void copy_template(const L1ctlRachSynchSeq_template& other_value);

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

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

boolean match(L1ctlRachSynchSeq::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const L1ctlRachSynchSeq& other_value, boolean legacy = FALSE) const;
L1ctlRachSynchSeq::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
L1ctlRachSynchSeq_template& list_item(unsigned int list_index);
void log() const;
void log_match(const L1ctlRachSynchSeq& 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 L1ctlExtRachReq : public Base_Type {
  INTEGER field_ra11;
  L1ctlRachSynchSeq field_synch__seq;
  INTEGER field_combined;
  INTEGER field_offset;
public:
  L1ctlExtRachReq();
  L1ctlExtRachReq(const INTEGER& par_ra11,
    const L1ctlRachSynchSeq& par_synch__seq,
    const INTEGER& par_combined,
    const INTEGER& par_offset);
  L1ctlExtRachReq(const L1ctlExtRachReq& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlExtRachReq& operator=(const L1ctlExtRachReq& other_value);
  boolean operator==(const L1ctlExtRachReq& other_value) const;
  inline boolean operator!=(const L1ctlExtRachReq& 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& ra11()
    {return field_ra11;}
  inline const INTEGER& ra11() const
    {return field_ra11;}
  inline L1ctlRachSynchSeq& synch__seq()
    {return field_synch__seq;}
  inline const L1ctlRachSynchSeq& synch__seq() const
    {return field_synch__seq;}
  inline INTEGER& combined()
    {return field_combined;}
  inline const INTEGER& combined() const
    {return field_combined;}
  inline INTEGER& offset()
    {return field_offset;}
  inline const INTEGER& offset() const
    {return field_offset;}
  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 L1ctlExtRachReq_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlExtRachReq_template *list_value;
} value_list;
struct {
L1ctlExtRachReq_template* precondition;
L1ctlExtRachReq_template* implied_template;
} implication_;
dynmatch_struct<L1ctlExtRachReq>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlExtRachReq& other_value);
void copy_template(const L1ctlExtRachReq_template& other_value);

public:
L1ctlExtRachReq_template();
L1ctlExtRachReq_template(template_sel other_value);
L1ctlExtRachReq_template(const L1ctlExtRachReq& other_value);
L1ctlExtRachReq_template(const OPTIONAL<L1ctlExtRachReq>& other_value);
L1ctlExtRachReq_template(L1ctlExtRachReq_template* p_precondition, L1ctlExtRachReq_template* p_implied_template);
L1ctlExtRachReq_template(Dynamic_Match_Interface<L1ctlExtRachReq>* p_dyn_match);
L1ctlExtRachReq_template(const L1ctlExtRachReq_template& other_value);
~L1ctlExtRachReq_template();
L1ctlExtRachReq_template& operator=(template_sel other_value);
L1ctlExtRachReq_template& operator=(const L1ctlExtRachReq& other_value);
L1ctlExtRachReq_template& operator=(const OPTIONAL<L1ctlExtRachReq>& other_value);
L1ctlExtRachReq_template& operator=(const L1ctlExtRachReq_template& other_value);
boolean match(const L1ctlExtRachReq& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlExtRachReq valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlExtRachReq_template& list_item(unsigned int list_index) const;
INTEGER_template& ra11();
const INTEGER_template& ra11() const;
L1ctlRachSynchSeq_template& synch__seq();
const L1ctlRachSynchSeq_template& synch__seq() const;
INTEGER_template& combined();
const INTEGER_template& combined() const;
INTEGER_template& offset();
const INTEGER_template& offset() const;
int size_of() const;
void log() const;
void log_match(const L1ctlExtRachReq& 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 L1ctlParReq : public Base_Type {
  INTEGER field_ta;
  INTEGER field_tx__power;
  OCTETSTRING field_padding;
public:
  L1ctlParReq();
  L1ctlParReq(const INTEGER& par_ta,
    const INTEGER& par_tx__power,
    const OCTETSTRING& par_padding);
  L1ctlParReq(const L1ctlParReq& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlParReq& operator=(const L1ctlParReq& other_value);
  boolean operator==(const L1ctlParReq& other_value) const;
  inline boolean operator!=(const L1ctlParReq& 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& ta()
    {return field_ta;}
  inline const INTEGER& ta() const
    {return field_ta;}
  inline INTEGER& tx__power()
    {return field_tx__power;}
  inline const INTEGER& tx__power() const
    {return field_tx__power;}
  inline OCTETSTRING& padding()
    {return field_padding;}
  inline const OCTETSTRING& padding() const
    {return field_padding;}
  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 L1ctlParReq_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlParReq_template *list_value;
} value_list;
struct {
L1ctlParReq_template* precondition;
L1ctlParReq_template* implied_template;
} implication_;
dynmatch_struct<L1ctlParReq>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlParReq& other_value);
void copy_template(const L1ctlParReq_template& other_value);

public:
L1ctlParReq_template();
L1ctlParReq_template(template_sel other_value);
L1ctlParReq_template(const L1ctlParReq& other_value);
L1ctlParReq_template(const OPTIONAL<L1ctlParReq>& other_value);
L1ctlParReq_template(L1ctlParReq_template* p_precondition, L1ctlParReq_template* p_implied_template);
L1ctlParReq_template(Dynamic_Match_Interface<L1ctlParReq>* p_dyn_match);
L1ctlParReq_template(const L1ctlParReq_template& other_value);
~L1ctlParReq_template();
L1ctlParReq_template& operator=(template_sel other_value);
L1ctlParReq_template& operator=(const L1ctlParReq& other_value);
L1ctlParReq_template& operator=(const OPTIONAL<L1ctlParReq>& other_value);
L1ctlParReq_template& operator=(const L1ctlParReq_template& other_value);
boolean match(const L1ctlParReq& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlParReq valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlParReq_template& list_item(unsigned int list_index) const;
INTEGER_template& ta();
const INTEGER_template& ta() const;
INTEGER_template& tx__power();
const INTEGER_template& tx__power() const;
OCTETSTRING_template& padding();
const OCTETSTRING_template& padding() const;
int size_of() const;
void log() const;
void log_match(const L1ctlParReq& 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 L1ctlDataReq : public Base_Type {
  OPTIONAL< GSM__RR__Types::SacchL1Header > field_l1header;
  OCTETSTRING field_l2__payload;
public:
  L1ctlDataReq();
  L1ctlDataReq(const OPTIONAL< GSM__RR__Types::SacchL1Header >& par_l1header,
    const OCTETSTRING& par_l2__payload);
  L1ctlDataReq(const L1ctlDataReq& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlDataReq& operator=(const L1ctlDataReq& other_value);
  boolean operator==(const L1ctlDataReq& other_value) const;
  inline boolean operator!=(const L1ctlDataReq& 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< GSM__RR__Types::SacchL1Header >& l1header()
    {return field_l1header;}
  inline const OPTIONAL< GSM__RR__Types::SacchL1Header >& l1header() const
    {return field_l1header;}
  inline OCTETSTRING& l2__payload()
    {return field_l2__payload;}
  inline const OCTETSTRING& l2__payload() const
    {return field_l2__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 L1ctlDataReq_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlDataReq_template *list_value;
} value_list;
struct {
L1ctlDataReq_template* precondition;
L1ctlDataReq_template* implied_template;
} implication_;
dynmatch_struct<L1ctlDataReq>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlDataReq& other_value);
void copy_template(const L1ctlDataReq_template& other_value);

public:
L1ctlDataReq_template();
L1ctlDataReq_template(template_sel other_value);
L1ctlDataReq_template(const L1ctlDataReq& other_value);
L1ctlDataReq_template(const OPTIONAL<L1ctlDataReq>& other_value);
L1ctlDataReq_template(L1ctlDataReq_template* p_precondition, L1ctlDataReq_template* p_implied_template);
L1ctlDataReq_template(Dynamic_Match_Interface<L1ctlDataReq>* p_dyn_match);
L1ctlDataReq_template(const L1ctlDataReq_template& other_value);
~L1ctlDataReq_template();
L1ctlDataReq_template& operator=(template_sel other_value);
L1ctlDataReq_template& operator=(const L1ctlDataReq& other_value);
L1ctlDataReq_template& operator=(const OPTIONAL<L1ctlDataReq>& other_value);
L1ctlDataReq_template& operator=(const L1ctlDataReq_template& other_value);
boolean match(const L1ctlDataReq& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlDataReq valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlDataReq_template& list_item(unsigned int list_index) const;
GSM__RR__Types::SacchL1Header_template& l1header();
const GSM__RR__Types::SacchL1Header_template& l1header() const;
OCTETSTRING_template& l2__payload();
const OCTETSTRING_template& l2__payload() const;
int size_of() const;
void log() const;
void log_match(const L1ctlDataReq& 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 L1ctlH0 : public Base_Type {
  INTEGER field_h;
  GSM__Types::GsmBandArfcn field_arfcn;
  OCTETSTRING field_padding;
public:
  L1ctlH0();
  L1ctlH0(const INTEGER& par_h,
    const GSM__Types::GsmBandArfcn& par_arfcn,
    const OCTETSTRING& par_padding);
  L1ctlH0(const L1ctlH0& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlH0& operator=(const L1ctlH0& other_value);
  boolean operator==(const L1ctlH0& other_value) const;
  inline boolean operator!=(const L1ctlH0& 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& h()
    {return field_h;}
  inline const INTEGER& h() const
    {return field_h;}
  inline GSM__Types::GsmBandArfcn& arfcn()
    {return field_arfcn;}
  inline const GSM__Types::GsmBandArfcn& arfcn() const
    {return field_arfcn;}
  inline OCTETSTRING& padding()
    {return field_padding;}
  inline const OCTETSTRING& padding() const
    {return field_padding;}
  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 L1ctlH0_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlH0_template *list_value;
} value_list;
struct {
L1ctlH0_template* precondition;
L1ctlH0_template* implied_template;
} implication_;
dynmatch_struct<L1ctlH0>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlH0& other_value);
void copy_template(const L1ctlH0_template& other_value);

public:
L1ctlH0_template();
L1ctlH0_template(template_sel other_value);
L1ctlH0_template(const L1ctlH0& other_value);
L1ctlH0_template(const OPTIONAL<L1ctlH0>& other_value);
L1ctlH0_template(L1ctlH0_template* p_precondition, L1ctlH0_template* p_implied_template);
L1ctlH0_template(Dynamic_Match_Interface<L1ctlH0>* p_dyn_match);
L1ctlH0_template(const L1ctlH0_template& other_value);
~L1ctlH0_template();
L1ctlH0_template& operator=(template_sel other_value);
L1ctlH0_template& operator=(const L1ctlH0& other_value);
L1ctlH0_template& operator=(const OPTIONAL<L1ctlH0>& other_value);
L1ctlH0_template& operator=(const L1ctlH0_template& other_value);
boolean match(const L1ctlH0& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlH0 valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlH0_template& list_item(unsigned int list_index) const;
INTEGER_template& h();
const INTEGER_template& h() const;
GSM__Types::GsmBandArfcn_template& arfcn();
const GSM__Types::GsmBandArfcn_template& arfcn() const;
OCTETSTRING_template& padding();
const OCTETSTRING_template& padding() const;
int size_of() const;
void log() const;
void log_match(const L1ctlH0& 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 L1ctlMA : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
GSM__Types::GsmBandArfcn **value_elements;
} *val_ptr;

static const GSM__Types::GsmBandArfcn UNBOUND_ELEM;
private:
friend boolean operator==(null_type null_value, const L1ctlMA& other_value);

public:
  typedef GSM__Types::GsmBandArfcn of_type;
L1ctlMA();
L1ctlMA(null_type other_value);
L1ctlMA(const L1ctlMA& other_value);
~L1ctlMA();

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

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

GSM__Types::GsmBandArfcn& operator[](int index_value);
GSM__Types::GsmBandArfcn& operator[](const INTEGER& index_value);
const GSM__Types::GsmBandArfcn& operator[](int index_value) const;
const GSM__Types::GsmBandArfcn& operator[](const INTEGER& index_value) const;

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

L1ctlMA operator+(const L1ctlMA& other_value) const;

L1ctlMA substr(int index, int returncount) const;

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

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

void clean_up();
L1ctlMA_template& operator=(template_sel other_value);
L1ctlMA_template& operator=(null_type other_value);
L1ctlMA_template& operator=(const L1ctlMA& other_value);
L1ctlMA_template& operator=(const OPTIONAL<L1ctlMA>& other_value);
L1ctlMA_template& operator=(const L1ctlMA_template& other_value);

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

L1ctlMA replace(int index, int len, const L1ctlMA_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
L1ctlMA_template& list_item(unsigned int list_index);
void log() const;
void log_match(const L1ctlMA& 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 L1ctlH1 : public Base_Type {
  INTEGER field_h;
  INTEGER field_hsn;
  INTEGER field_maio;
  INTEGER field_n;
  OCTETSTRING field_spare;
  L1ctlMA field_ma;
  OCTETSTRING field_padding;
public:
  L1ctlH1();
  L1ctlH1(const INTEGER& par_h,
    const INTEGER& par_hsn,
    const INTEGER& par_maio,
    const INTEGER& par_n,
    const OCTETSTRING& par_spare,
    const L1ctlMA& par_ma,
    const OCTETSTRING& par_padding);
  L1ctlH1(const L1ctlH1& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlH1& operator=(const L1ctlH1& other_value);
  boolean operator==(const L1ctlH1& other_value) const;
  inline boolean operator!=(const L1ctlH1& 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& h()
    {return field_h;}
  inline const INTEGER& h() const
    {return field_h;}
  inline INTEGER& hsn()
    {return field_hsn;}
  inline const INTEGER& hsn() const
    {return field_hsn;}
  inline INTEGER& maio()
    {return field_maio;}
  inline const INTEGER& maio() const
    {return field_maio;}
  inline INTEGER& n()
    {return field_n;}
  inline const INTEGER& n() const
    {return field_n;}
  inline OCTETSTRING& spare()
    {return field_spare;}
  inline const OCTETSTRING& spare() const
    {return field_spare;}
  inline L1ctlMA& ma()
    {return field_ma;}
  inline const L1ctlMA& ma() const
    {return field_ma;}
  inline OCTETSTRING& padding()
    {return field_padding;}
  inline const OCTETSTRING& padding() const
    {return field_padding;}
  inline int size_of() const
    {return 7;}
  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 L1ctlH1_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlH1_template *list_value;
} value_list;
struct {
L1ctlH1_template* precondition;
L1ctlH1_template* implied_template;
} implication_;
dynmatch_struct<L1ctlH1>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlH1& other_value);
void copy_template(const L1ctlH1_template& other_value);

public:
L1ctlH1_template();
L1ctlH1_template(template_sel other_value);
L1ctlH1_template(const L1ctlH1& other_value);
L1ctlH1_template(const OPTIONAL<L1ctlH1>& other_value);
L1ctlH1_template(L1ctlH1_template* p_precondition, L1ctlH1_template* p_implied_template);
L1ctlH1_template(Dynamic_Match_Interface<L1ctlH1>* p_dyn_match);
L1ctlH1_template(const L1ctlH1_template& other_value);
~L1ctlH1_template();
L1ctlH1_template& operator=(template_sel other_value);
L1ctlH1_template& operator=(const L1ctlH1& other_value);
L1ctlH1_template& operator=(const OPTIONAL<L1ctlH1>& other_value);
L1ctlH1_template& operator=(const L1ctlH1_template& other_value);
boolean match(const L1ctlH1& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlH1 valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlH1_template& list_item(unsigned int list_index) const;
INTEGER_template& h();
const INTEGER_template& h() const;
INTEGER_template& hsn();
const INTEGER_template& hsn() const;
INTEGER_template& maio();
const INTEGER_template& maio() const;
INTEGER_template& n();
const INTEGER_template& n() const;
OCTETSTRING_template& spare();
const OCTETSTRING_template& spare() const;
L1ctlMA_template& ma();
const L1ctlMA_template& ma() const;
OCTETSTRING_template& padding();
const OCTETSTRING_template& padding() const;
int size_of() const;
void log() const;
void log_match(const L1ctlH1& 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 L1ctlH0H1 : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_h0 = 1, ALT_h1 = 2 };
private:
union_selection_type union_selection;
union {
L1ctlH0 *field_h0;
L1ctlH1 *field_h1;
};
void copy_value(const L1ctlH0H1& other_value);

public:
L1ctlH0H1();
L1ctlH0H1(const L1ctlH0H1& other_value);
~L1ctlH0H1();
L1ctlH0H1& operator=(const L1ctlH0H1& other_value);
boolean operator==(const L1ctlH0H1& other_value) const;
inline boolean operator!=(const L1ctlH0H1& other_value) const { return !(*this == other_value); }
L1ctlH0& h0();
const L1ctlH0& h0() const;
L1ctlH1& h1();
const L1ctlH1& h1() 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 L1ctlH0H1_template : public Base_Template {
union {
struct {
L1ctlH0H1::union_selection_type union_selection;
union {
L1ctlH0_template *field_h0;
L1ctlH1_template *field_h1;
};
} single_value;
struct {
unsigned int n_values;
L1ctlH0H1_template *list_value;
} value_list;
struct {
L1ctlH0H1_template* precondition;
L1ctlH0H1_template* implied_template;
} implication_;
dynmatch_struct<L1ctlH0H1>* dyn_match;
};
void copy_value(const L1ctlH0H1& other_value);

void copy_template(const L1ctlH0H1_template& other_value);

public:
L1ctlH0H1_template();
L1ctlH0H1_template(template_sel other_value);
L1ctlH0H1_template(const L1ctlH0H1& other_value);
L1ctlH0H1_template(const OPTIONAL<L1ctlH0H1>& other_value);
L1ctlH0H1_template(L1ctlH0H1_template* p_precondition, L1ctlH0H1_template* p_implied_template);
L1ctlH0H1_template(Dynamic_Match_Interface<L1ctlH0H1>* p_dyn_match);
L1ctlH0H1_template(const L1ctlH0H1_template& other_value);
~L1ctlH0H1_template();
void clean_up();
L1ctlH0H1_template& operator=(template_sel other_value);
L1ctlH0H1_template& operator=(const L1ctlH0H1& other_value);
L1ctlH0H1_template& operator=(const OPTIONAL<L1ctlH0H1>& other_value);
L1ctlH0H1_template& operator=(const L1ctlH0H1_template& other_value);
boolean match(const L1ctlH0H1& other_value, boolean legacy = FALSE) const;
boolean is_value() const;L1ctlH0H1 valueof() const;
L1ctlH0H1_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlH0_template& h0();
const L1ctlH0_template& h0() const;
L1ctlH1_template& h1();
const L1ctlH1_template& h1() const;
boolean ischosen(L1ctlH0H1::union_selection_type checked_selection) const;
void log() const;
void log_match(const L1ctlH0H1& 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 L1ctlDmEstReq : public Base_Type {
  INTEGER field_tsc;
  L1ctlH0H1 field_h0h1;
  L1ctlTchMode field_tch__mode;
  L1ctlAudioMode field_audio__mode;
public:
  L1ctlDmEstReq();
  L1ctlDmEstReq(const INTEGER& par_tsc,
    const L1ctlH0H1& par_h0h1,
    const L1ctlTchMode& par_tch__mode,
    const L1ctlAudioMode& par_audio__mode);
  L1ctlDmEstReq(const L1ctlDmEstReq& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlDmEstReq& operator=(const L1ctlDmEstReq& other_value);
  boolean operator==(const L1ctlDmEstReq& other_value) const;
  inline boolean operator!=(const L1ctlDmEstReq& 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& tsc()
    {return field_tsc;}
  inline const INTEGER& tsc() const
    {return field_tsc;}
  inline L1ctlH0H1& h0h1()
    {return field_h0h1;}
  inline const L1ctlH0H1& h0h1() const
    {return field_h0h1;}
  inline L1ctlTchMode& tch__mode()
    {return field_tch__mode;}
  inline const L1ctlTchMode& tch__mode() const
    {return field_tch__mode;}
  inline L1ctlAudioMode& audio__mode()
    {return field_audio__mode;}
  inline const L1ctlAudioMode& audio__mode() const
    {return field_audio__mode;}
  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 L1ctlDmEstReq_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlDmEstReq_template *list_value;
} value_list;
struct {
L1ctlDmEstReq_template* precondition;
L1ctlDmEstReq_template* implied_template;
} implication_;
dynmatch_struct<L1ctlDmEstReq>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlDmEstReq& other_value);
void copy_template(const L1ctlDmEstReq_template& other_value);

public:
L1ctlDmEstReq_template();
L1ctlDmEstReq_template(template_sel other_value);
L1ctlDmEstReq_template(const L1ctlDmEstReq& other_value);
L1ctlDmEstReq_template(const OPTIONAL<L1ctlDmEstReq>& other_value);
L1ctlDmEstReq_template(L1ctlDmEstReq_template* p_precondition, L1ctlDmEstReq_template* p_implied_template);
L1ctlDmEstReq_template(Dynamic_Match_Interface<L1ctlDmEstReq>* p_dyn_match);
L1ctlDmEstReq_template(const L1ctlDmEstReq_template& other_value);
~L1ctlDmEstReq_template();
L1ctlDmEstReq_template& operator=(template_sel other_value);
L1ctlDmEstReq_template& operator=(const L1ctlDmEstReq& other_value);
L1ctlDmEstReq_template& operator=(const OPTIONAL<L1ctlDmEstReq>& other_value);
L1ctlDmEstReq_template& operator=(const L1ctlDmEstReq_template& other_value);
boolean match(const L1ctlDmEstReq& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlDmEstReq valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlDmEstReq_template& list_item(unsigned int list_index) const;
INTEGER_template& tsc();
const INTEGER_template& tsc() const;
L1ctlH0H1_template& h0h1();
const L1ctlH0H1_template& h0h1() const;
L1ctlTchMode_template& tch__mode();
const L1ctlTchMode_template& tch__mode() const;
L1ctlAudioMode_template& audio__mode();
const L1ctlAudioMode_template& audio__mode() const;
int size_of() const;
void log() const;
void log_match(const L1ctlDmEstReq& 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 L1ctlReset : public Base_Type {
  L1ctlResetType field_reset__type;
  OCTETSTRING field_padding;
public:
  L1ctlReset();
  L1ctlReset(const L1ctlResetType& par_reset__type,
    const OCTETSTRING& par_padding);
  L1ctlReset(const L1ctlReset& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlReset& operator=(const L1ctlReset& other_value);
  boolean operator==(const L1ctlReset& other_value) const;
  inline boolean operator!=(const L1ctlReset& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline L1ctlResetType& reset__type()
    {return field_reset__type;}
  inline const L1ctlResetType& reset__type() const
    {return field_reset__type;}
  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 L1ctlReset_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlReset_template *list_value;
} value_list;
struct {
L1ctlReset_template* precondition;
L1ctlReset_template* implied_template;
} implication_;
dynmatch_struct<L1ctlReset>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlReset& other_value);
void copy_template(const L1ctlReset_template& other_value);

public:
L1ctlReset_template();
L1ctlReset_template(template_sel other_value);
L1ctlReset_template(const L1ctlReset& other_value);
L1ctlReset_template(const OPTIONAL<L1ctlReset>& other_value);
L1ctlReset_template(L1ctlReset_template* p_precondition, L1ctlReset_template* p_implied_template);
L1ctlReset_template(Dynamic_Match_Interface<L1ctlReset>* p_dyn_match);
L1ctlReset_template(const L1ctlReset_template& other_value);
~L1ctlReset_template();
L1ctlReset_template& operator=(template_sel other_value);
L1ctlReset_template& operator=(const L1ctlReset& other_value);
L1ctlReset_template& operator=(const OPTIONAL<L1ctlReset>& other_value);
L1ctlReset_template& operator=(const L1ctlReset_template& other_value);
boolean match(const L1ctlReset& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlReset valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlReset_template& list_item(unsigned int list_index) const;
L1ctlResetType_template& reset__type();
const L1ctlResetType_template& reset__type() const;
OCTETSTRING_template& padding();
const OCTETSTRING_template& padding() const;
int size_of() const;
void log() const;
void log_match(const L1ctlReset& 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 L1CtlCryptoReq : public Base_Type {
  INTEGER field_algo;
  INTEGER field_key__len;
  OCTETSTRING field_key;
public:
  L1CtlCryptoReq();
  L1CtlCryptoReq(const INTEGER& par_algo,
    const INTEGER& par_key__len,
    const OCTETSTRING& par_key);
  L1CtlCryptoReq(const L1CtlCryptoReq& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1CtlCryptoReq& operator=(const L1CtlCryptoReq& other_value);
  boolean operator==(const L1CtlCryptoReq& other_value) const;
  inline boolean operator!=(const L1CtlCryptoReq& 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& algo()
    {return field_algo;}
  inline const INTEGER& algo() const
    {return field_algo;}
  inline INTEGER& key__len()
    {return field_key__len;}
  inline const INTEGER& key__len() const
    {return field_key__len;}
  inline OCTETSTRING& key()
    {return field_key;}
  inline const OCTETSTRING& key() const
    {return field_key;}
  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 L1CtlCryptoReq_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1CtlCryptoReq_template *list_value;
} value_list;
struct {
L1CtlCryptoReq_template* precondition;
L1CtlCryptoReq_template* implied_template;
} implication_;
dynmatch_struct<L1CtlCryptoReq>* dyn_match;
};

void set_specific();
void copy_value(const L1CtlCryptoReq& other_value);
void copy_template(const L1CtlCryptoReq_template& other_value);

public:
L1CtlCryptoReq_template();
L1CtlCryptoReq_template(template_sel other_value);
L1CtlCryptoReq_template(const L1CtlCryptoReq& other_value);
L1CtlCryptoReq_template(const OPTIONAL<L1CtlCryptoReq>& other_value);
L1CtlCryptoReq_template(L1CtlCryptoReq_template* p_precondition, L1CtlCryptoReq_template* p_implied_template);
L1CtlCryptoReq_template(Dynamic_Match_Interface<L1CtlCryptoReq>* p_dyn_match);
L1CtlCryptoReq_template(const L1CtlCryptoReq_template& other_value);
~L1CtlCryptoReq_template();
L1CtlCryptoReq_template& operator=(template_sel other_value);
L1CtlCryptoReq_template& operator=(const L1CtlCryptoReq& other_value);
L1CtlCryptoReq_template& operator=(const OPTIONAL<L1CtlCryptoReq>& other_value);
L1CtlCryptoReq_template& operator=(const L1CtlCryptoReq_template& other_value);
boolean match(const L1CtlCryptoReq& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1CtlCryptoReq valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1CtlCryptoReq_template& list_item(unsigned int list_index) const;
INTEGER_template& algo();
const INTEGER_template& algo() const;
INTEGER_template& key__len();
const INTEGER_template& key__len() const;
OCTETSTRING_template& key();
const OCTETSTRING_template& key() const;
int size_of() const;
void log() const;
void log_match(const L1CtlCryptoReq& 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 L1ctlTrafficReq : public Base_Type {
  OCTETSTRING field_data;
public:
  L1ctlTrafficReq();
  L1ctlTrafficReq(const OCTETSTRING& par_data);
  L1ctlTrafficReq(const L1ctlTrafficReq& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlTrafficReq& operator=(const L1ctlTrafficReq& other_value);
  boolean operator==(const L1ctlTrafficReq& other_value) const;
  inline boolean operator!=(const L1ctlTrafficReq& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline OCTETSTRING& data()
    {return field_data;}
  inline const OCTETSTRING& data() const
    {return field_data;}
  inline int size_of() const
    {return 1;}
  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 L1ctlTrafficReq_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlTrafficReq_template *list_value;
} value_list;
struct {
L1ctlTrafficReq_template* precondition;
L1ctlTrafficReq_template* implied_template;
} implication_;
dynmatch_struct<L1ctlTrafficReq>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlTrafficReq& other_value);
void copy_template(const L1ctlTrafficReq_template& other_value);

public:
L1ctlTrafficReq_template();
L1ctlTrafficReq_template(template_sel other_value);
L1ctlTrafficReq_template(const L1ctlTrafficReq& other_value);
L1ctlTrafficReq_template(const OPTIONAL<L1ctlTrafficReq>& other_value);
L1ctlTrafficReq_template(L1ctlTrafficReq_template* p_precondition, L1ctlTrafficReq_template* p_implied_template);
L1ctlTrafficReq_template(Dynamic_Match_Interface<L1ctlTrafficReq>* p_dyn_match);
L1ctlTrafficReq_template(const L1ctlTrafficReq_template& other_value);
~L1ctlTrafficReq_template();
L1ctlTrafficReq_template& operator=(template_sel other_value);
L1ctlTrafficReq_template& operator=(const L1ctlTrafficReq& other_value);
L1ctlTrafficReq_template& operator=(const OPTIONAL<L1ctlTrafficReq>& other_value);
L1ctlTrafficReq_template& operator=(const L1ctlTrafficReq_template& other_value);
boolean match(const L1ctlTrafficReq& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlTrafficReq valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlTrafficReq_template& list_item(unsigned int list_index) const;
OCTETSTRING_template& data();
const OCTETSTRING_template& data() const;
int size_of() const;
void log() const;
void log_match(const L1ctlTrafficReq& 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 L1ctlGprsUlTbfCfgReq : public Base_Type {
  INTEGER field_tbf__ref;
  BITSTRING field_slotmask;
  OCTETSTRING field_pad;
  INTEGER field_start__fn;
public:
  L1ctlGprsUlTbfCfgReq();
  L1ctlGprsUlTbfCfgReq(const INTEGER& par_tbf__ref,
    const BITSTRING& par_slotmask,
    const OCTETSTRING& par_pad,
    const INTEGER& par_start__fn);
  L1ctlGprsUlTbfCfgReq(const L1ctlGprsUlTbfCfgReq& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlGprsUlTbfCfgReq& operator=(const L1ctlGprsUlTbfCfgReq& other_value);
  boolean operator==(const L1ctlGprsUlTbfCfgReq& other_value) const;
  inline boolean operator!=(const L1ctlGprsUlTbfCfgReq& 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& tbf__ref()
    {return field_tbf__ref;}
  inline const INTEGER& tbf__ref() const
    {return field_tbf__ref;}
  inline BITSTRING& slotmask()
    {return field_slotmask;}
  inline const BITSTRING& slotmask() const
    {return field_slotmask;}
  inline OCTETSTRING& pad()
    {return field_pad;}
  inline const OCTETSTRING& pad() const
    {return field_pad;}
  inline INTEGER& start__fn()
    {return field_start__fn;}
  inline const INTEGER& start__fn() const
    {return field_start__fn;}
  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 L1ctlGprsUlTbfCfgReq_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlGprsUlTbfCfgReq_template *list_value;
} value_list;
struct {
L1ctlGprsUlTbfCfgReq_template* precondition;
L1ctlGprsUlTbfCfgReq_template* implied_template;
} implication_;
dynmatch_struct<L1ctlGprsUlTbfCfgReq>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlGprsUlTbfCfgReq& other_value);
void copy_template(const L1ctlGprsUlTbfCfgReq_template& other_value);

public:
L1ctlGprsUlTbfCfgReq_template();
L1ctlGprsUlTbfCfgReq_template(template_sel other_value);
L1ctlGprsUlTbfCfgReq_template(const L1ctlGprsUlTbfCfgReq& other_value);
L1ctlGprsUlTbfCfgReq_template(const OPTIONAL<L1ctlGprsUlTbfCfgReq>& other_value);
L1ctlGprsUlTbfCfgReq_template(L1ctlGprsUlTbfCfgReq_template* p_precondition, L1ctlGprsUlTbfCfgReq_template* p_implied_template);
L1ctlGprsUlTbfCfgReq_template(Dynamic_Match_Interface<L1ctlGprsUlTbfCfgReq>* p_dyn_match);
L1ctlGprsUlTbfCfgReq_template(const L1ctlGprsUlTbfCfgReq_template& other_value);
~L1ctlGprsUlTbfCfgReq_template();
L1ctlGprsUlTbfCfgReq_template& operator=(template_sel other_value);
L1ctlGprsUlTbfCfgReq_template& operator=(const L1ctlGprsUlTbfCfgReq& other_value);
L1ctlGprsUlTbfCfgReq_template& operator=(const OPTIONAL<L1ctlGprsUlTbfCfgReq>& other_value);
L1ctlGprsUlTbfCfgReq_template& operator=(const L1ctlGprsUlTbfCfgReq_template& other_value);
boolean match(const L1ctlGprsUlTbfCfgReq& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlGprsUlTbfCfgReq valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlGprsUlTbfCfgReq_template& list_item(unsigned int list_index) const;
INTEGER_template& tbf__ref();
const INTEGER_template& tbf__ref() const;
BITSTRING_template& slotmask();
const BITSTRING_template& slotmask() const;
OCTETSTRING_template& pad();
const OCTETSTRING_template& pad() const;
INTEGER_template& start__fn();
const INTEGER_template& start__fn() const;
int size_of() const;
void log() const;
void log_match(const L1ctlGprsUlTbfCfgReq& 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 L1ctlGprsDlTbfCfgReq : public Base_Type {
  INTEGER field_tbf__ref;
  BITSTRING field_slotmask;
  INTEGER field_dl__tfi;
  OCTETSTRING field_pad;
  INTEGER field_start__fn;
public:
  L1ctlGprsDlTbfCfgReq();
  L1ctlGprsDlTbfCfgReq(const INTEGER& par_tbf__ref,
    const BITSTRING& par_slotmask,
    const INTEGER& par_dl__tfi,
    const OCTETSTRING& par_pad,
    const INTEGER& par_start__fn);
  L1ctlGprsDlTbfCfgReq(const L1ctlGprsDlTbfCfgReq& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlGprsDlTbfCfgReq& operator=(const L1ctlGprsDlTbfCfgReq& other_value);
  boolean operator==(const L1ctlGprsDlTbfCfgReq& other_value) const;
  inline boolean operator!=(const L1ctlGprsDlTbfCfgReq& 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& tbf__ref()
    {return field_tbf__ref;}
  inline const INTEGER& tbf__ref() const
    {return field_tbf__ref;}
  inline BITSTRING& slotmask()
    {return field_slotmask;}
  inline const BITSTRING& slotmask() const
    {return field_slotmask;}
  inline INTEGER& dl__tfi()
    {return field_dl__tfi;}
  inline const INTEGER& dl__tfi() const
    {return field_dl__tfi;}
  inline OCTETSTRING& pad()
    {return field_pad;}
  inline const OCTETSTRING& pad() const
    {return field_pad;}
  inline INTEGER& start__fn()
    {return field_start__fn;}
  inline const INTEGER& start__fn() const
    {return field_start__fn;}
  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 L1ctlGprsDlTbfCfgReq_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlGprsDlTbfCfgReq_template *list_value;
} value_list;
struct {
L1ctlGprsDlTbfCfgReq_template* precondition;
L1ctlGprsDlTbfCfgReq_template* implied_template;
} implication_;
dynmatch_struct<L1ctlGprsDlTbfCfgReq>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlGprsDlTbfCfgReq& other_value);
void copy_template(const L1ctlGprsDlTbfCfgReq_template& other_value);

public:
L1ctlGprsDlTbfCfgReq_template();
L1ctlGprsDlTbfCfgReq_template(template_sel other_value);
L1ctlGprsDlTbfCfgReq_template(const L1ctlGprsDlTbfCfgReq& other_value);
L1ctlGprsDlTbfCfgReq_template(const OPTIONAL<L1ctlGprsDlTbfCfgReq>& other_value);
L1ctlGprsDlTbfCfgReq_template(L1ctlGprsDlTbfCfgReq_template* p_precondition, L1ctlGprsDlTbfCfgReq_template* p_implied_template);
L1ctlGprsDlTbfCfgReq_template(Dynamic_Match_Interface<L1ctlGprsDlTbfCfgReq>* p_dyn_match);
L1ctlGprsDlTbfCfgReq_template(const L1ctlGprsDlTbfCfgReq_template& other_value);
~L1ctlGprsDlTbfCfgReq_template();
L1ctlGprsDlTbfCfgReq_template& operator=(template_sel other_value);
L1ctlGprsDlTbfCfgReq_template& operator=(const L1ctlGprsDlTbfCfgReq& other_value);
L1ctlGprsDlTbfCfgReq_template& operator=(const OPTIONAL<L1ctlGprsDlTbfCfgReq>& other_value);
L1ctlGprsDlTbfCfgReq_template& operator=(const L1ctlGprsDlTbfCfgReq_template& other_value);
boolean match(const L1ctlGprsDlTbfCfgReq& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlGprsDlTbfCfgReq valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlGprsDlTbfCfgReq_template& list_item(unsigned int list_index) const;
INTEGER_template& tbf__ref();
const INTEGER_template& tbf__ref() const;
BITSTRING_template& slotmask();
const BITSTRING_template& slotmask() const;
INTEGER_template& dl__tfi();
const INTEGER_template& dl__tfi() const;
OCTETSTRING_template& pad();
const OCTETSTRING_template& pad() const;
INTEGER_template& start__fn();
const INTEGER_template& start__fn() const;
int size_of() const;
void log() const;
void log_match(const L1ctlGprsDlTbfCfgReq& 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 L1ctlGprsBlockHdr : public Base_Type {
  INTEGER field_fn;
  INTEGER field_tn;
  OCTETSTRING field_pad;
public:
  L1ctlGprsBlockHdr();
  L1ctlGprsBlockHdr(const INTEGER& par_fn,
    const INTEGER& par_tn,
    const OCTETSTRING& par_pad);
  L1ctlGprsBlockHdr(const L1ctlGprsBlockHdr& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlGprsBlockHdr& operator=(const L1ctlGprsBlockHdr& other_value);
  boolean operator==(const L1ctlGprsBlockHdr& other_value) const;
  inline boolean operator!=(const L1ctlGprsBlockHdr& 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& fn()
    {return field_fn;}
  inline const INTEGER& fn() const
    {return field_fn;}
  inline INTEGER& tn()
    {return field_tn;}
  inline const INTEGER& tn() const
    {return field_tn;}
  inline OCTETSTRING& pad()
    {return field_pad;}
  inline const OCTETSTRING& pad() const
    {return field_pad;}
  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 L1ctlGprsBlockHdr_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlGprsBlockHdr_template *list_value;
} value_list;
struct {
L1ctlGprsBlockHdr_template* precondition;
L1ctlGprsBlockHdr_template* implied_template;
} implication_;
dynmatch_struct<L1ctlGprsBlockHdr>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlGprsBlockHdr& other_value);
void copy_template(const L1ctlGprsBlockHdr_template& other_value);

public:
L1ctlGprsBlockHdr_template();
L1ctlGprsBlockHdr_template(template_sel other_value);
L1ctlGprsBlockHdr_template(const L1ctlGprsBlockHdr& other_value);
L1ctlGprsBlockHdr_template(const OPTIONAL<L1ctlGprsBlockHdr>& other_value);
L1ctlGprsBlockHdr_template(L1ctlGprsBlockHdr_template* p_precondition, L1ctlGprsBlockHdr_template* p_implied_template);
L1ctlGprsBlockHdr_template(Dynamic_Match_Interface<L1ctlGprsBlockHdr>* p_dyn_match);
L1ctlGprsBlockHdr_template(const L1ctlGprsBlockHdr_template& other_value);
~L1ctlGprsBlockHdr_template();
L1ctlGprsBlockHdr_template& operator=(template_sel other_value);
L1ctlGprsBlockHdr_template& operator=(const L1ctlGprsBlockHdr& other_value);
L1ctlGprsBlockHdr_template& operator=(const OPTIONAL<L1ctlGprsBlockHdr>& other_value);
L1ctlGprsBlockHdr_template& operator=(const L1ctlGprsBlockHdr_template& other_value);
boolean match(const L1ctlGprsBlockHdr& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlGprsBlockHdr valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlGprsBlockHdr_template& list_item(unsigned int list_index) const;
INTEGER_template& fn();
const INTEGER_template& fn() const;
INTEGER_template& tn();
const INTEGER_template& tn() const;
OCTETSTRING_template& pad();
const OCTETSTRING_template& pad() const;
int size_of() const;
void log() const;
void log_match(const L1ctlGprsBlockHdr& 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 L1ctlGprsUlBlockReq : public Base_Type {
  L1ctlGprsBlockHdr field_hdr;
  OCTETSTRING field_data;
public:
  L1ctlGprsUlBlockReq();
  L1ctlGprsUlBlockReq(const L1ctlGprsBlockHdr& par_hdr,
    const OCTETSTRING& par_data);
  L1ctlGprsUlBlockReq(const L1ctlGprsUlBlockReq& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlGprsUlBlockReq& operator=(const L1ctlGprsUlBlockReq& other_value);
  boolean operator==(const L1ctlGprsUlBlockReq& other_value) const;
  inline boolean operator!=(const L1ctlGprsUlBlockReq& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline L1ctlGprsBlockHdr& hdr()
    {return field_hdr;}
  inline const L1ctlGprsBlockHdr& hdr() const
    {return field_hdr;}
  inline OCTETSTRING& data()
    {return field_data;}
  inline const OCTETSTRING& data() const
    {return field_data;}
  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 L1ctlGprsUlBlockReq_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlGprsUlBlockReq_template *list_value;
} value_list;
struct {
L1ctlGprsUlBlockReq_template* precondition;
L1ctlGprsUlBlockReq_template* implied_template;
} implication_;
dynmatch_struct<L1ctlGprsUlBlockReq>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlGprsUlBlockReq& other_value);
void copy_template(const L1ctlGprsUlBlockReq_template& other_value);

public:
L1ctlGprsUlBlockReq_template();
L1ctlGprsUlBlockReq_template(template_sel other_value);
L1ctlGprsUlBlockReq_template(const L1ctlGprsUlBlockReq& other_value);
L1ctlGprsUlBlockReq_template(const OPTIONAL<L1ctlGprsUlBlockReq>& other_value);
L1ctlGprsUlBlockReq_template(L1ctlGprsUlBlockReq_template* p_precondition, L1ctlGprsUlBlockReq_template* p_implied_template);
L1ctlGprsUlBlockReq_template(Dynamic_Match_Interface<L1ctlGprsUlBlockReq>* p_dyn_match);
L1ctlGprsUlBlockReq_template(const L1ctlGprsUlBlockReq_template& other_value);
~L1ctlGprsUlBlockReq_template();
L1ctlGprsUlBlockReq_template& operator=(template_sel other_value);
L1ctlGprsUlBlockReq_template& operator=(const L1ctlGprsUlBlockReq& other_value);
L1ctlGprsUlBlockReq_template& operator=(const OPTIONAL<L1ctlGprsUlBlockReq>& other_value);
L1ctlGprsUlBlockReq_template& operator=(const L1ctlGprsUlBlockReq_template& other_value);
boolean match(const L1ctlGprsUlBlockReq& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlGprsUlBlockReq valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlGprsUlBlockReq_template& list_item(unsigned int list_index) const;
L1ctlGprsBlockHdr_template& hdr();
const L1ctlGprsBlockHdr_template& hdr() const;
OCTETSTRING_template& data();
const OCTETSTRING_template& data() const;
int size_of() const;
void log() const;
void log_match(const L1ctlGprsUlBlockReq& 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 L1ctlGprsUlBlockCnf : public Base_Type {
  INTEGER field_fn;
  INTEGER field_tn;
  OCTETSTRING field_data;
public:
  L1ctlGprsUlBlockCnf();
  L1ctlGprsUlBlockCnf(const INTEGER& par_fn,
    const INTEGER& par_tn,
    const OCTETSTRING& par_data);
  L1ctlGprsUlBlockCnf(const L1ctlGprsUlBlockCnf& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlGprsUlBlockCnf& operator=(const L1ctlGprsUlBlockCnf& other_value);
  boolean operator==(const L1ctlGprsUlBlockCnf& other_value) const;
  inline boolean operator!=(const L1ctlGprsUlBlockCnf& 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& fn()
    {return field_fn;}
  inline const INTEGER& fn() const
    {return field_fn;}
  inline INTEGER& tn()
    {return field_tn;}
  inline const INTEGER& tn() const
    {return field_tn;}
  inline OCTETSTRING& data()
    {return field_data;}
  inline const OCTETSTRING& data() const
    {return field_data;}
  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 L1ctlGprsUlBlockCnf_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlGprsUlBlockCnf_template *list_value;
} value_list;
struct {
L1ctlGprsUlBlockCnf_template* precondition;
L1ctlGprsUlBlockCnf_template* implied_template;
} implication_;
dynmatch_struct<L1ctlGprsUlBlockCnf>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlGprsUlBlockCnf& other_value);
void copy_template(const L1ctlGprsUlBlockCnf_template& other_value);

public:
L1ctlGprsUlBlockCnf_template();
L1ctlGprsUlBlockCnf_template(template_sel other_value);
L1ctlGprsUlBlockCnf_template(const L1ctlGprsUlBlockCnf& other_value);
L1ctlGprsUlBlockCnf_template(const OPTIONAL<L1ctlGprsUlBlockCnf>& other_value);
L1ctlGprsUlBlockCnf_template(L1ctlGprsUlBlockCnf_template* p_precondition, L1ctlGprsUlBlockCnf_template* p_implied_template);
L1ctlGprsUlBlockCnf_template(Dynamic_Match_Interface<L1ctlGprsUlBlockCnf>* p_dyn_match);
L1ctlGprsUlBlockCnf_template(const L1ctlGprsUlBlockCnf_template& other_value);
~L1ctlGprsUlBlockCnf_template();
L1ctlGprsUlBlockCnf_template& operator=(template_sel other_value);
L1ctlGprsUlBlockCnf_template& operator=(const L1ctlGprsUlBlockCnf& other_value);
L1ctlGprsUlBlockCnf_template& operator=(const OPTIONAL<L1ctlGprsUlBlockCnf>& other_value);
L1ctlGprsUlBlockCnf_template& operator=(const L1ctlGprsUlBlockCnf_template& other_value);
boolean match(const L1ctlGprsUlBlockCnf& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlGprsUlBlockCnf valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlGprsUlBlockCnf_template& list_item(unsigned int list_index) const;
INTEGER_template& fn();
const INTEGER_template& fn() const;
INTEGER_template& tn();
const INTEGER_template& tn() const;
OCTETSTRING_template& data();
const OCTETSTRING_template& data() const;
int size_of() const;
void log() const;
void log_match(const L1ctlGprsUlBlockCnf& 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 L1ctlGprsDlBlockInd_meas : public Base_Type {
  INTEGER field_ber10k;
  INTEGER field_ci__cb;
  INTEGER field_rx__level;
public:
  L1ctlGprsDlBlockInd_meas();
  L1ctlGprsDlBlockInd_meas(const INTEGER& par_ber10k,
    const INTEGER& par_ci__cb,
    const INTEGER& par_rx__level);
  L1ctlGprsDlBlockInd_meas(const L1ctlGprsDlBlockInd_meas& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlGprsDlBlockInd_meas& operator=(const L1ctlGprsDlBlockInd_meas& other_value);
  boolean operator==(const L1ctlGprsDlBlockInd_meas& other_value) const;
  inline boolean operator!=(const L1ctlGprsDlBlockInd_meas& 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& ber10k()
    {return field_ber10k;}
  inline const INTEGER& ber10k() const
    {return field_ber10k;}
  inline INTEGER& ci__cb()
    {return field_ci__cb;}
  inline const INTEGER& ci__cb() const
    {return field_ci__cb;}
  inline INTEGER& rx__level()
    {return field_rx__level;}
  inline const INTEGER& rx__level() const
    {return field_rx__level;}
  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 L1ctlGprsDlBlockInd_meas_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlGprsDlBlockInd_meas_template *list_value;
} value_list;
struct {
L1ctlGprsDlBlockInd_meas_template* precondition;
L1ctlGprsDlBlockInd_meas_template* implied_template;
} implication_;
dynmatch_struct<L1ctlGprsDlBlockInd_meas>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlGprsDlBlockInd_meas& other_value);
void copy_template(const L1ctlGprsDlBlockInd_meas_template& other_value);

public:
L1ctlGprsDlBlockInd_meas_template();
L1ctlGprsDlBlockInd_meas_template(template_sel other_value);
L1ctlGprsDlBlockInd_meas_template(const L1ctlGprsDlBlockInd_meas& other_value);
L1ctlGprsDlBlockInd_meas_template(const OPTIONAL<L1ctlGprsDlBlockInd_meas>& other_value);
L1ctlGprsDlBlockInd_meas_template(L1ctlGprsDlBlockInd_meas_template* p_precondition, L1ctlGprsDlBlockInd_meas_template* p_implied_template);
L1ctlGprsDlBlockInd_meas_template(Dynamic_Match_Interface<L1ctlGprsDlBlockInd_meas>* p_dyn_match);
L1ctlGprsDlBlockInd_meas_template(const L1ctlGprsDlBlockInd_meas_template& other_value);
~L1ctlGprsDlBlockInd_meas_template();
L1ctlGprsDlBlockInd_meas_template& operator=(template_sel other_value);
L1ctlGprsDlBlockInd_meas_template& operator=(const L1ctlGprsDlBlockInd_meas& other_value);
L1ctlGprsDlBlockInd_meas_template& operator=(const OPTIONAL<L1ctlGprsDlBlockInd_meas>& other_value);
L1ctlGprsDlBlockInd_meas_template& operator=(const L1ctlGprsDlBlockInd_meas_template& other_value);
boolean match(const L1ctlGprsDlBlockInd_meas& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlGprsDlBlockInd_meas valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlGprsDlBlockInd_meas_template& list_item(unsigned int list_index) const;
INTEGER_template& ber10k();
const INTEGER_template& ber10k() const;
INTEGER_template& ci__cb();
const INTEGER_template& ci__cb() const;
INTEGER_template& rx__level();
const INTEGER_template& rx__level() const;
int size_of() const;
void log() const;
void log_match(const L1ctlGprsDlBlockInd_meas& 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 L1ctlGprsDlBlockInd : public Base_Type {
  L1ctlGprsBlockHdr field_hdr;
  L1ctlGprsDlBlockInd_meas field_meas;
  INTEGER field_usf;
  OCTETSTRING field_data;
public:
  L1ctlGprsDlBlockInd();
  L1ctlGprsDlBlockInd(const L1ctlGprsBlockHdr& par_hdr,
    const L1ctlGprsDlBlockInd_meas& par_meas,
    const INTEGER& par_usf,
    const OCTETSTRING& par_data);
  L1ctlGprsDlBlockInd(const L1ctlGprsDlBlockInd& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlGprsDlBlockInd& operator=(const L1ctlGprsDlBlockInd& other_value);
  boolean operator==(const L1ctlGprsDlBlockInd& other_value) const;
  inline boolean operator!=(const L1ctlGprsDlBlockInd& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline L1ctlGprsBlockHdr& hdr()
    {return field_hdr;}
  inline const L1ctlGprsBlockHdr& hdr() const
    {return field_hdr;}
  inline L1ctlGprsDlBlockInd_meas& meas()
    {return field_meas;}
  inline const L1ctlGprsDlBlockInd_meas& meas() const
    {return field_meas;}
  inline INTEGER& usf()
    {return field_usf;}
  inline const INTEGER& usf() const
    {return field_usf;}
  inline OCTETSTRING& data()
    {return field_data;}
  inline const OCTETSTRING& data() const
    {return field_data;}
  inline int size_of() const
    {return 4;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

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

void set_specific();
void copy_value(const L1ctlGprsDlBlockInd& other_value);
void copy_template(const L1ctlGprsDlBlockInd_template& other_value);

public:
L1ctlGprsDlBlockInd_template();
L1ctlGprsDlBlockInd_template(template_sel other_value);
L1ctlGprsDlBlockInd_template(const L1ctlGprsDlBlockInd& other_value);
L1ctlGprsDlBlockInd_template(const OPTIONAL<L1ctlGprsDlBlockInd>& other_value);
L1ctlGprsDlBlockInd_template(L1ctlGprsDlBlockInd_template* p_precondition, L1ctlGprsDlBlockInd_template* p_implied_template);
L1ctlGprsDlBlockInd_template(Dynamic_Match_Interface<L1ctlGprsDlBlockInd>* p_dyn_match);
L1ctlGprsDlBlockInd_template(const L1ctlGprsDlBlockInd_template& other_value);
~L1ctlGprsDlBlockInd_template();
L1ctlGprsDlBlockInd_template& operator=(template_sel other_value);
L1ctlGprsDlBlockInd_template& operator=(const L1ctlGprsDlBlockInd& other_value);
L1ctlGprsDlBlockInd_template& operator=(const OPTIONAL<L1ctlGprsDlBlockInd>& other_value);
L1ctlGprsDlBlockInd_template& operator=(const L1ctlGprsDlBlockInd_template& other_value);
boolean match(const L1ctlGprsDlBlockInd& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlGprsDlBlockInd valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlGprsDlBlockInd_template& list_item(unsigned int list_index) const;
L1ctlGprsBlockHdr_template& hdr();
const L1ctlGprsBlockHdr_template& hdr() const;
L1ctlGprsDlBlockInd_meas_template& meas();
const L1ctlGprsDlBlockInd_meas_template& meas() const;
INTEGER_template& usf();
const INTEGER_template& usf() const;
OCTETSTRING_template& data();
const OCTETSTRING_template& data() const;
int size_of() const;
void log() const;
void log_match(const L1ctlGprsDlBlockInd& 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 L1ctlGprsRtsInd : public Base_Type {
  INTEGER field_fn;
  INTEGER field_tn;
  INTEGER field_usf;
public:
  L1ctlGprsRtsInd();
  L1ctlGprsRtsInd(const INTEGER& par_fn,
    const INTEGER& par_tn,
    const INTEGER& par_usf);
  L1ctlGprsRtsInd(const L1ctlGprsRtsInd& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlGprsRtsInd& operator=(const L1ctlGprsRtsInd& other_value);
  boolean operator==(const L1ctlGprsRtsInd& other_value) const;
  inline boolean operator!=(const L1ctlGprsRtsInd& 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& fn()
    {return field_fn;}
  inline const INTEGER& fn() const
    {return field_fn;}
  inline INTEGER& tn()
    {return field_tn;}
  inline const INTEGER& tn() const
    {return field_tn;}
  inline INTEGER& usf()
    {return field_usf;}
  inline const INTEGER& usf() const
    {return field_usf;}
  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 L1ctlGprsRtsInd_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlGprsRtsInd_template *list_value;
} value_list;
struct {
L1ctlGprsRtsInd_template* precondition;
L1ctlGprsRtsInd_template* implied_template;
} implication_;
dynmatch_struct<L1ctlGprsRtsInd>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlGprsRtsInd& other_value);
void copy_template(const L1ctlGprsRtsInd_template& other_value);

public:
L1ctlGprsRtsInd_template();
L1ctlGprsRtsInd_template(template_sel other_value);
L1ctlGprsRtsInd_template(const L1ctlGprsRtsInd& other_value);
L1ctlGprsRtsInd_template(const OPTIONAL<L1ctlGprsRtsInd>& other_value);
L1ctlGprsRtsInd_template(L1ctlGprsRtsInd_template* p_precondition, L1ctlGprsRtsInd_template* p_implied_template);
L1ctlGprsRtsInd_template(Dynamic_Match_Interface<L1ctlGprsRtsInd>* p_dyn_match);
L1ctlGprsRtsInd_template(const L1ctlGprsRtsInd_template& other_value);
~L1ctlGprsRtsInd_template();
L1ctlGprsRtsInd_template& operator=(template_sel other_value);
L1ctlGprsRtsInd_template& operator=(const L1ctlGprsRtsInd& other_value);
L1ctlGprsRtsInd_template& operator=(const OPTIONAL<L1ctlGprsRtsInd>& other_value);
L1ctlGprsRtsInd_template& operator=(const L1ctlGprsRtsInd_template& other_value);
boolean match(const L1ctlGprsRtsInd& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlGprsRtsInd valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlGprsRtsInd_template& list_item(unsigned int list_index) const;
INTEGER_template& fn();
const INTEGER_template& fn() const;
INTEGER_template& tn();
const INTEGER_template& tn() const;
INTEGER_template& usf();
const INTEGER_template& usf() const;
int size_of() const;
void log() const;
void log_match(const L1ctlGprsRtsInd& 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 L1ctlMsgPayload : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_fbsb__req = 1, ALT_fbsb__conf = 2, ALT_data__ind = 3, ALT_rach__req = 4, ALT_dm__est__req = 5, ALT_data__req = 6, ALT_reset__req = 7, ALT_ccch__mode__req = 8, ALT_ccch__mode__conf = 9, ALT_par__req = 10, ALT_crypto__req = 11, ALT_tch__mode__req = 12, ALT_tch__mode__conf = 13, ALT_traffic__req = 14, ALT_traffic__ind = 15, ALT_ul__tbf__cfg__req = 16, ALT_dl__tbf__cfg__req = 17, ALT_ul__block__req = 18, ALT_ul__block__cnf = 19, ALT_dl__block__ind = 20, ALT_ext__rach__req = 21, ALT_rts__ind = 22, ALT_other = 23 };
private:
union_selection_type union_selection;
union {
L1ctlFbsbReq *field_fbsb__req;
L1ctlFbsbConf *field_fbsb__conf;
L1ctlDataInd *field_data__ind;
L1ctlRachReq *field_rach__req;
L1ctlDmEstReq *field_dm__est__req;
L1ctlDataReq *field_data__req;
L1ctlReset *field_reset__req;
L1ctlCcchModeReq *field_ccch__mode__req;
L1ctlCcchModeConf *field_ccch__mode__conf;
L1ctlParReq *field_par__req;
L1CtlCryptoReq *field_crypto__req;
L1ctlTchModeReq *field_tch__mode__req;
L1ctlTchModeConf *field_tch__mode__conf;
L1ctlTrafficReq *field_traffic__req;
L1ctlTrafficReq *field_traffic__ind;
L1ctlGprsUlTbfCfgReq *field_ul__tbf__cfg__req;
L1ctlGprsDlTbfCfgReq *field_dl__tbf__cfg__req;
L1ctlGprsUlBlockReq *field_ul__block__req;
L1ctlGprsUlBlockCnf *field_ul__block__cnf;
L1ctlGprsDlBlockInd *field_dl__block__ind;
L1ctlExtRachReq *field_ext__rach__req;
L1ctlGprsRtsInd *field_rts__ind;
OCTETSTRING *field_other;
};
void copy_value(const L1ctlMsgPayload& other_value);

public:
L1ctlMsgPayload();
L1ctlMsgPayload(const L1ctlMsgPayload& other_value);
~L1ctlMsgPayload();
L1ctlMsgPayload& operator=(const L1ctlMsgPayload& other_value);
boolean operator==(const L1ctlMsgPayload& other_value) const;
inline boolean operator!=(const L1ctlMsgPayload& other_value) const { return !(*this == other_value); }
L1ctlFbsbReq& fbsb__req();
const L1ctlFbsbReq& fbsb__req() const;
L1ctlFbsbConf& fbsb__conf();
const L1ctlFbsbConf& fbsb__conf() const;
L1ctlDataInd& data__ind();
const L1ctlDataInd& data__ind() const;
L1ctlRachReq& rach__req();
const L1ctlRachReq& rach__req() const;
L1ctlDmEstReq& dm__est__req();
const L1ctlDmEstReq& dm__est__req() const;
L1ctlDataReq& data__req();
const L1ctlDataReq& data__req() const;
L1ctlReset& reset__req();
const L1ctlReset& reset__req() const;
L1ctlCcchModeReq& ccch__mode__req();
const L1ctlCcchModeReq& ccch__mode__req() const;
L1ctlCcchModeConf& ccch__mode__conf();
const L1ctlCcchModeConf& ccch__mode__conf() const;
L1ctlParReq& par__req();
const L1ctlParReq& par__req() const;
L1CtlCryptoReq& crypto__req();
const L1CtlCryptoReq& crypto__req() const;
L1ctlTchModeReq& tch__mode__req();
const L1ctlTchModeReq& tch__mode__req() const;
L1ctlTchModeConf& tch__mode__conf();
const L1ctlTchModeConf& tch__mode__conf() const;
L1ctlTrafficReq& traffic__req();
const L1ctlTrafficReq& traffic__req() const;
L1ctlTrafficReq& traffic__ind();
const L1ctlTrafficReq& traffic__ind() const;
L1ctlGprsUlTbfCfgReq& ul__tbf__cfg__req();
const L1ctlGprsUlTbfCfgReq& ul__tbf__cfg__req() const;
L1ctlGprsDlTbfCfgReq& dl__tbf__cfg__req();
const L1ctlGprsDlTbfCfgReq& dl__tbf__cfg__req() const;
L1ctlGprsUlBlockReq& ul__block__req();
const L1ctlGprsUlBlockReq& ul__block__req() const;
L1ctlGprsUlBlockCnf& ul__block__cnf();
const L1ctlGprsUlBlockCnf& ul__block__cnf() const;
L1ctlGprsDlBlockInd& dl__block__ind();
const L1ctlGprsDlBlockInd& dl__block__ind() const;
L1ctlExtRachReq& ext__rach__req();
const L1ctlExtRachReq& ext__rach__req() const;
L1ctlGprsRtsInd& rts__ind();
const L1ctlGprsRtsInd& rts__ind() const;
OCTETSTRING& other();
const OCTETSTRING& other() 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 L1ctlMsgPayload_template : public Base_Template {
union {
struct {
L1ctlMsgPayload::union_selection_type union_selection;
union {
L1ctlFbsbReq_template *field_fbsb__req;
L1ctlFbsbConf_template *field_fbsb__conf;
L1ctlDataInd_template *field_data__ind;
L1ctlRachReq_template *field_rach__req;
L1ctlDmEstReq_template *field_dm__est__req;
L1ctlDataReq_template *field_data__req;
L1ctlReset_template *field_reset__req;
L1ctlCcchModeReq_template *field_ccch__mode__req;
L1ctlCcchModeConf_template *field_ccch__mode__conf;
L1ctlParReq_template *field_par__req;
L1CtlCryptoReq_template *field_crypto__req;
L1ctlTchModeReq_template *field_tch__mode__req;
L1ctlTchModeConf_template *field_tch__mode__conf;
L1ctlTrafficReq_template *field_traffic__req;
L1ctlTrafficReq_template *field_traffic__ind;
L1ctlGprsUlTbfCfgReq_template *field_ul__tbf__cfg__req;
L1ctlGprsDlTbfCfgReq_template *field_dl__tbf__cfg__req;
L1ctlGprsUlBlockReq_template *field_ul__block__req;
L1ctlGprsUlBlockCnf_template *field_ul__block__cnf;
L1ctlGprsDlBlockInd_template *field_dl__block__ind;
L1ctlExtRachReq_template *field_ext__rach__req;
L1ctlGprsRtsInd_template *field_rts__ind;
OCTETSTRING_template *field_other;
};
} single_value;
struct {
unsigned int n_values;
L1ctlMsgPayload_template *list_value;
} value_list;
struct {
L1ctlMsgPayload_template* precondition;
L1ctlMsgPayload_template* implied_template;
} implication_;
dynmatch_struct<L1ctlMsgPayload>* dyn_match;
};
void copy_value(const L1ctlMsgPayload& other_value);

void copy_template(const L1ctlMsgPayload_template& other_value);

public:
L1ctlMsgPayload_template();
L1ctlMsgPayload_template(template_sel other_value);
L1ctlMsgPayload_template(const L1ctlMsgPayload& other_value);
L1ctlMsgPayload_template(const OPTIONAL<L1ctlMsgPayload>& other_value);
L1ctlMsgPayload_template(L1ctlMsgPayload_template* p_precondition, L1ctlMsgPayload_template* p_implied_template);
L1ctlMsgPayload_template(Dynamic_Match_Interface<L1ctlMsgPayload>* p_dyn_match);
L1ctlMsgPayload_template(const L1ctlMsgPayload_template& other_value);
~L1ctlMsgPayload_template();
void clean_up();
L1ctlMsgPayload_template& operator=(template_sel other_value);
L1ctlMsgPayload_template& operator=(const L1ctlMsgPayload& other_value);
L1ctlMsgPayload_template& operator=(const OPTIONAL<L1ctlMsgPayload>& other_value);
L1ctlMsgPayload_template& operator=(const L1ctlMsgPayload_template& other_value);
boolean match(const L1ctlMsgPayload& other_value, boolean legacy = FALSE) const;
boolean is_value() const;L1ctlMsgPayload valueof() const;
L1ctlMsgPayload_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlFbsbReq_template& fbsb__req();
const L1ctlFbsbReq_template& fbsb__req() const;
L1ctlFbsbConf_template& fbsb__conf();
const L1ctlFbsbConf_template& fbsb__conf() const;
L1ctlDataInd_template& data__ind();
const L1ctlDataInd_template& data__ind() const;
L1ctlRachReq_template& rach__req();
const L1ctlRachReq_template& rach__req() const;
L1ctlDmEstReq_template& dm__est__req();
const L1ctlDmEstReq_template& dm__est__req() const;
L1ctlDataReq_template& data__req();
const L1ctlDataReq_template& data__req() const;
L1ctlReset_template& reset__req();
const L1ctlReset_template& reset__req() const;
L1ctlCcchModeReq_template& ccch__mode__req();
const L1ctlCcchModeReq_template& ccch__mode__req() const;
L1ctlCcchModeConf_template& ccch__mode__conf();
const L1ctlCcchModeConf_template& ccch__mode__conf() const;
L1ctlParReq_template& par__req();
const L1ctlParReq_template& par__req() const;
L1CtlCryptoReq_template& crypto__req();
const L1CtlCryptoReq_template& crypto__req() const;
L1ctlTchModeReq_template& tch__mode__req();
const L1ctlTchModeReq_template& tch__mode__req() const;
L1ctlTchModeConf_template& tch__mode__conf();
const L1ctlTchModeConf_template& tch__mode__conf() const;
L1ctlTrafficReq_template& traffic__req();
const L1ctlTrafficReq_template& traffic__req() const;
L1ctlTrafficReq_template& traffic__ind();
const L1ctlTrafficReq_template& traffic__ind() const;
L1ctlGprsUlTbfCfgReq_template& ul__tbf__cfg__req();
const L1ctlGprsUlTbfCfgReq_template& ul__tbf__cfg__req() const;
L1ctlGprsDlTbfCfgReq_template& dl__tbf__cfg__req();
const L1ctlGprsDlTbfCfgReq_template& dl__tbf__cfg__req() const;
L1ctlGprsUlBlockReq_template& ul__block__req();
const L1ctlGprsUlBlockReq_template& ul__block__req() const;
L1ctlGprsUlBlockCnf_template& ul__block__cnf();
const L1ctlGprsUlBlockCnf_template& ul__block__cnf() const;
L1ctlGprsDlBlockInd_template& dl__block__ind();
const L1ctlGprsDlBlockInd_template& dl__block__ind() const;
L1ctlExtRachReq_template& ext__rach__req();
const L1ctlExtRachReq_template& ext__rach__req() const;
L1ctlGprsRtsInd_template& rts__ind();
const L1ctlGprsRtsInd_template& rts__ind() const;
OCTETSTRING_template& other();
const OCTETSTRING_template& other() const;
boolean ischosen(L1ctlMsgPayload::union_selection_type checked_selection) const;
void log() const;
void log_match(const L1ctlMsgPayload& 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 L1ctlMessage : public Base_Type {
  L1ctlHeader field_header;
  OPTIONAL< L1ctlUlInfo > field_ul__info;
  OPTIONAL< L1ctlDlInfo > field_dl__info;
  OPTIONAL< L1ctlMsgPayload > field_payload;
public:
  L1ctlMessage();
  L1ctlMessage(const L1ctlHeader& par_header,
    const OPTIONAL< L1ctlUlInfo >& par_ul__info,
    const OPTIONAL< L1ctlDlInfo >& par_dl__info,
    const OPTIONAL< L1ctlMsgPayload >& par_payload);
  L1ctlMessage(const L1ctlMessage& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlMessage& operator=(const L1ctlMessage& other_value);
  boolean operator==(const L1ctlMessage& other_value) const;
  inline boolean operator!=(const L1ctlMessage& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline L1ctlHeader& header()
    {return field_header;}
  inline const L1ctlHeader& header() const
    {return field_header;}
  inline OPTIONAL< L1ctlUlInfo >& ul__info()
    {return field_ul__info;}
  inline const OPTIONAL< L1ctlUlInfo >& ul__info() const
    {return field_ul__info;}
  inline OPTIONAL< L1ctlDlInfo >& dl__info()
    {return field_dl__info;}
  inline const OPTIONAL< L1ctlDlInfo >& dl__info() const
    {return field_dl__info;}
  inline OPTIONAL< L1ctlMsgPayload >& payload()
    {return field_payload;}
  inline const OPTIONAL< L1ctlMsgPayload >& 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 L1ctlMessage_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlMessage_template *list_value;
} value_list;
struct {
L1ctlMessage_template* precondition;
L1ctlMessage_template* implied_template;
} implication_;
dynmatch_struct<L1ctlMessage>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlMessage& other_value);
void copy_template(const L1ctlMessage_template& other_value);

public:
L1ctlMessage_template();
L1ctlMessage_template(template_sel other_value);
L1ctlMessage_template(const L1ctlMessage& other_value);
L1ctlMessage_template(const OPTIONAL<L1ctlMessage>& other_value);
L1ctlMessage_template(L1ctlMessage_template* p_precondition, L1ctlMessage_template* p_implied_template);
L1ctlMessage_template(Dynamic_Match_Interface<L1ctlMessage>* p_dyn_match);
L1ctlMessage_template(const L1ctlMessage_template& other_value);
~L1ctlMessage_template();
L1ctlMessage_template& operator=(template_sel other_value);
L1ctlMessage_template& operator=(const L1ctlMessage& other_value);
L1ctlMessage_template& operator=(const OPTIONAL<L1ctlMessage>& other_value);
L1ctlMessage_template& operator=(const L1ctlMessage_template& other_value);
boolean match(const L1ctlMessage& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlMessage valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlMessage_template& list_item(unsigned int list_index) const;
L1ctlHeader_template& header();
const L1ctlHeader_template& header() const;
L1ctlUlInfo_template& ul__info();
const L1ctlUlInfo_template& ul__info() const;
L1ctlDlInfo_template& dl__info();
const L1ctlDlInfo_template& dl__info() const;
L1ctlMsgPayload_template& payload();
const L1ctlMsgPayload_template& payload() const;
int size_of() const;
void log() const;
void log_match(const L1ctlMessage& 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 L1ctlMessageLV : public Base_Type {
  INTEGER field_len;
  L1ctlMessage field_msg;
public:
  L1ctlMessageLV();
  L1ctlMessageLV(const INTEGER& par_len,
    const L1ctlMessage& par_msg);
  L1ctlMessageLV(const L1ctlMessageLV& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  L1ctlMessageLV& operator=(const L1ctlMessageLV& other_value);
  boolean operator==(const L1ctlMessageLV& other_value) const;
  inline boolean operator!=(const L1ctlMessageLV& 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& len()
    {return field_len;}
  inline const INTEGER& len() const
    {return field_len;}
  inline L1ctlMessage& msg()
    {return field_msg;}
  inline const L1ctlMessage& msg() const
    {return field_msg;}
  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 L1ctlMessageLV_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
L1ctlMessageLV_template *list_value;
} value_list;
struct {
L1ctlMessageLV_template* precondition;
L1ctlMessageLV_template* implied_template;
} implication_;
dynmatch_struct<L1ctlMessageLV>* dyn_match;
};

void set_specific();
void copy_value(const L1ctlMessageLV& other_value);
void copy_template(const L1ctlMessageLV_template& other_value);

public:
L1ctlMessageLV_template();
L1ctlMessageLV_template(template_sel other_value);
L1ctlMessageLV_template(const L1ctlMessageLV& other_value);
L1ctlMessageLV_template(const OPTIONAL<L1ctlMessageLV>& other_value);
L1ctlMessageLV_template(L1ctlMessageLV_template* p_precondition, L1ctlMessageLV_template* p_implied_template);
L1ctlMessageLV_template(Dynamic_Match_Interface<L1ctlMessageLV>* p_dyn_match);
L1ctlMessageLV_template(const L1ctlMessageLV_template& other_value);
~L1ctlMessageLV_template();
L1ctlMessageLV_template& operator=(template_sel other_value);
L1ctlMessageLV_template& operator=(const L1ctlMessageLV& other_value);
L1ctlMessageLV_template& operator=(const OPTIONAL<L1ctlMessageLV>& other_value);
L1ctlMessageLV_template& operator=(const L1ctlMessageLV_template& other_value);
boolean match(const L1ctlMessageLV& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
L1ctlMessageLV valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
L1ctlMessageLV_template& list_item(unsigned int list_index) const;
INTEGER_template& len();
const INTEGER_template& len() const;
L1ctlMessage_template& msg();
const L1ctlMessage_template& msg() const;
int size_of() const;
void log() const;
void log_match(const L1ctlMessageLV& 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 L1ctlMsgType_encoder(const L1ctlMsgType& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlMsgType_decoder(OCTETSTRING& input_stream, L1ctlMsgType& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlCcchMode_encoder(const L1ctlCcchMode& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlCcchMode_decoder(OCTETSTRING& input_stream, L1ctlCcchMode& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlNeighMode_encoder(const L1ctlNeighMode& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlNeighMode_decoder(OCTETSTRING& input_stream, L1ctlNeighMode& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlResetType_encoder(const L1ctlResetType& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlResetType_decoder(OCTETSTRING& input_stream, L1ctlResetType& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlHdrFlags_f__done_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlHdrFlags_f__done_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlHdrFlags_encoder(const L1ctlHdrFlags& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlHdrFlags_decoder(OCTETSTRING& input_stream, L1ctlHdrFlags& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlHeader_encoder(const L1ctlHeader& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlHeader_decoder(OCTETSTRING& input_stream, L1ctlHeader& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern L1ctlHeader_template tr__L1ctlHeader(const L1ctlMsgType_template& msg__type);
extern L1ctlHeader_template ts__L1ctlHeader(const L1ctlMsgType_template& msg__type);
extern void L1ctlDlInfo_encoder(const L1ctlDlInfo& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlDlInfo_decoder(OCTETSTRING& input_stream, L1ctlDlInfo& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlFbsbConf_encoder(const L1ctlFbsbConf& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlFbsbConf_decoder(OCTETSTRING& input_stream, L1ctlFbsbConf& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlCcchModeConf_encoder(const L1ctlCcchModeConf& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlCcchModeConf_decoder(OCTETSTRING& input_stream, L1ctlCcchModeConf& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlTchMode_encoder(const L1ctlTchMode& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlTchMode_decoder(OCTETSTRING& input_stream, L1ctlTchMode& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlLoopMode_encoder(const L1ctlLoopMode& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlLoopMode_decoder(OCTETSTRING& input_stream, L1ctlLoopMode& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlAudioMode_tx__microphone_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlAudioMode_tx__microphone_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlAudioMode_tx__traffic__req_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlAudioMode_tx__traffic__req_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlAudioMode_rx__speaker_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlAudioMode_rx__speaker_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlAudioMode_rx__traffic__ind_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlAudioMode_rx__traffic__ind_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlAudioMode_encoder(const L1ctlAudioMode& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlAudioMode_decoder(OCTETSTRING& input_stream, L1ctlAudioMode& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlTchModeConf_amr_encoder(const L1ctlTchModeConf_amr& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlTchModeConf_amr_decoder(OCTETSTRING& input_stream, L1ctlTchModeConf_amr& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlTchModeConf_encoder(const L1ctlTchModeConf& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlTchModeConf_decoder(OCTETSTRING& input_stream, L1ctlTchModeConf& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlDataInd_payload_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlDataInd_payload_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlDataInd_encoder(const L1ctlDataInd& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlDataInd_decoder(OCTETSTRING& input_stream, L1ctlDataInd& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlUlInfo_encoder(const L1ctlUlInfo& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlUlInfo_decoder(OCTETSTRING& input_stream, L1ctlUlInfo& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlFbsbFlags_padding_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlFbsbFlags_padding_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlFbsbFlags_sb_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlFbsbFlags_sb_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlFbsbFlags_fb1_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlFbsbFlags_fb1_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlFbsbFlags_fb0_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlFbsbFlags_fb0_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlFbsbFlags_encoder(const L1ctlFbsbFlags& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlFbsbFlags_decoder(OCTETSTRING& input_stream, L1ctlFbsbFlags& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlFbsbReq_encoder(const L1ctlFbsbReq& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlFbsbReq_decoder(OCTETSTRING& input_stream, L1ctlFbsbReq& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlCcchModeReq_encoder(const L1ctlCcchModeReq& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlCcchModeReq_decoder(OCTETSTRING& input_stream, L1ctlCcchModeReq& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlTchModeReq_amr_encoder(const L1ctlTchModeReq_amr& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlTchModeReq_amr_decoder(OCTETSTRING& input_stream, L1ctlTchModeReq_amr& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlTchModeReq_encoder(const L1ctlTchModeReq& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlTchModeReq_decoder(OCTETSTRING& input_stream, L1ctlTchModeReq& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlRachReq_encoder(const L1ctlRachReq& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlRachReq_decoder(OCTETSTRING& input_stream, L1ctlRachReq& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlRachSynchSeq_encoder(const L1ctlRachSynchSeq& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlRachSynchSeq_decoder(OCTETSTRING& input_stream, L1ctlRachSynchSeq& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlExtRachReq_encoder(const L1ctlExtRachReq& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlExtRachReq_decoder(OCTETSTRING& input_stream, L1ctlExtRachReq& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlParReq_encoder(const L1ctlParReq& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlParReq_decoder(OCTETSTRING& input_stream, L1ctlParReq& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlDataReq_l2__payload_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlDataReq_l2__payload_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlDataReq_encoder(const L1ctlDataReq& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlDataReq_decoder(OCTETSTRING& input_stream, L1ctlDataReq& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlH0_padding_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlH0_padding_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlH0_encoder(const L1ctlH0& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlH0_decoder(OCTETSTRING& input_stream, L1ctlH0& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern boolean operator==(null_type null_value, const L1ctlMA& other_value);
inline boolean operator!=(null_type null_value, const L1ctlMA& other_value) { return !(null_value == other_value); }
extern void L1ctlMA_encoder(const L1ctlMA& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlMA_decoder(OCTETSTRING& input_stream, L1ctlMA& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlH1_n_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlH1_n_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlH1_padding_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlH1_padding_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlH1_encoder(const L1ctlH1& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlH1_decoder(OCTETSTRING& input_stream, L1ctlH1& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlH0H1_encoder(const L1ctlH0H1& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlH0H1_decoder(OCTETSTRING& input_stream, L1ctlH0H1& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlDmEstReq_encoder(const L1ctlDmEstReq& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlDmEstReq_decoder(OCTETSTRING& input_stream, L1ctlDmEstReq& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlReset_encoder(const L1ctlReset& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlReset_decoder(OCTETSTRING& input_stream, L1ctlReset& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1CtlCryptoReq_key__len_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1CtlCryptoReq_key__len_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1CtlCryptoReq_key_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1CtlCryptoReq_key_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1CtlCryptoReq_encoder(const L1CtlCryptoReq& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1CtlCryptoReq_decoder(OCTETSTRING& input_stream, L1CtlCryptoReq& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlTrafficReq_data_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlTrafficReq_data_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlTrafficReq_encoder(const L1ctlTrafficReq& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlTrafficReq_decoder(OCTETSTRING& input_stream, L1ctlTrafficReq& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlGprsUlTbfCfgReq_slotmask_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlGprsUlTbfCfgReq_slotmask_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlGprsUlTbfCfgReq_pad_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlGprsUlTbfCfgReq_pad_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlGprsUlTbfCfgReq_encoder(const L1ctlGprsUlTbfCfgReq& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlGprsUlTbfCfgReq_decoder(OCTETSTRING& input_stream, L1ctlGprsUlTbfCfgReq& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlGprsDlTbfCfgReq_slotmask_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlGprsDlTbfCfgReq_slotmask_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlGprsDlTbfCfgReq_pad_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlGprsDlTbfCfgReq_pad_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlGprsDlTbfCfgReq_encoder(const L1ctlGprsDlTbfCfgReq& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlGprsDlTbfCfgReq_decoder(OCTETSTRING& input_stream, L1ctlGprsDlTbfCfgReq& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlGprsBlockHdr_pad_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlGprsBlockHdr_pad_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlGprsBlockHdr_encoder(const L1ctlGprsBlockHdr& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlGprsBlockHdr_decoder(OCTETSTRING& input_stream, L1ctlGprsBlockHdr& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlGprsUlBlockReq_data_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlGprsUlBlockReq_data_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlGprsUlBlockReq_encoder(const L1ctlGprsUlBlockReq& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlGprsUlBlockReq_decoder(OCTETSTRING& input_stream, L1ctlGprsUlBlockReq& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlGprsUlBlockCnf_data_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlGprsUlBlockCnf_data_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlGprsUlBlockCnf_encoder(const L1ctlGprsUlBlockCnf& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlGprsUlBlockCnf_decoder(OCTETSTRING& input_stream, L1ctlGprsUlBlockCnf& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlGprsDlBlockInd_meas_encoder(const L1ctlGprsDlBlockInd_meas& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlGprsDlBlockInd_meas_decoder(OCTETSTRING& input_stream, L1ctlGprsDlBlockInd_meas& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlGprsDlBlockInd_data_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlGprsDlBlockInd_data_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlGprsDlBlockInd_encoder(const L1ctlGprsDlBlockInd& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlGprsDlBlockInd_decoder(OCTETSTRING& input_stream, L1ctlGprsDlBlockInd& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlGprsRtsInd_encoder(const L1ctlGprsRtsInd& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlGprsRtsInd_decoder(OCTETSTRING& input_stream, L1ctlGprsRtsInd& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlMsgPayload_other_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlMsgPayload_other_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlMsgPayload_encoder(const L1ctlMsgPayload& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlMsgPayload_decoder(OCTETSTRING& input_stream, L1ctlMsgPayload& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlMessage_ul__info_encoder(const L1ctlUlInfo& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlMessage_ul__info_decoder(OCTETSTRING& input_stream, L1ctlUlInfo& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlMessage_dl__info_encoder(const L1ctlDlInfo& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlMessage_dl__info_decoder(OCTETSTRING& input_stream, L1ctlDlInfo& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlMessage_payload_encoder(const L1ctlMsgPayload& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlMessage_payload_decoder(OCTETSTRING& input_stream, L1ctlMsgPayload& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlMessage_encoder(const L1ctlMessage& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlMessage_decoder(OCTETSTRING& input_stream, L1ctlMessage& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern OCTETSTRING enc__L1ctlMessage(const L1ctlMessage& msg);
extern L1ctlMessage dec__L1ctlMessage(const OCTETSTRING& stream);
extern void L1ctlMessageLV_len_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlMessageLV_len_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void L1ctlMessageLV_encoder(const L1ctlMessageLV& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER L1ctlMessageLV_decoder(OCTETSTRING& input_stream, L1ctlMessageLV& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern OCTETSTRING enc__L1ctlMessageLV(const L1ctlMessageLV& msg);
extern L1ctlMessageLV dec__L1ctlMessageLV(const OCTETSTRING& stream);
extern L1ctlMessage_template t__L1ctlResetReq(const L1ctlResetType_template& rst__type);
extern L1ctlMessage_template ts__L1CTL__FBSB__REQ(const GSM__Types::GsmBandArfcn_template& arfcn, const L1ctlFbsbFlags_template& flags, const INTEGER_template& sync__info__idx, const L1ctlCcchMode_template& ccch__mode, const INTEGER_template& rxlev__exp);
extern L1ctlMessage_template tr__L1CTL__FBSB__CONF(const INTEGER_template& result);
extern L1ctlMessage_template ts__L1CTL__CCCH__MODE__REQ(const L1ctlCcchMode_template& ccch__mode);
extern L1ctlMessage_template ts__L1CTL__TCH__MODE__REQ(const L1ctlTchMode_template& tch__mode, const L1ctlAudioMode_template& audio__mode, const L1ctlLoopMode_template& loop__mode, const INTEGER_template& amr__start__codec, const BITSTRING_template& amr__codecs__bitmask);
extern L1ctlMessage_template tr__L1CTL__MsgType(const L1ctlMsgType_template& msg__type);
extern L1ctlMessage_template ts__L1CTL__RACH__REQ(const INTEGER_template& ra, const INTEGER_template& combined, const INTEGER_template& offset, const GSM__Types::RslChannelNr_template& chan__nr, const GSM__Types::RslLinkId_template& link__id);
extern L1ctlMessage_template ts__L1CTL__EXT__RACH__REQ(const INTEGER_template& ra11, const L1ctlRachSynchSeq_template& seq, const INTEGER_template& combined, const INTEGER_template& offset);
extern L1ctlMessage_template ts__L1CTL__PAR__REQ(const INTEGER_template& ta, const INTEGER_template& tx__power);
extern L1ctlMessage_template ts__L1CTL__DM__EST__REQ(const GSM__Types::RslChannelNr_template& chan__nr, const INTEGER_template& tsc);
extern L1ctlMessage_template ts__L1CTL__DM__EST__REQ__H0(const GSM__Types::RslChannelNr_template& chan__nr, const INTEGER_template& tsc, const INTEGER_template& arfcn);
extern L1ctlMessage_template ts__L1CTL__DM__EST__REQ__H1(const GSM__Types::RslChannelNr_template& chan__nr, const INTEGER_template& tsc, const INTEGER_template& hsn, const INTEGER_template& maio, const L1ctlMA_template& ma);
extern L1ctlMessage_template ts__L1CTL__DM__REL__REQ(const GSM__Types::RslChannelNr_template& chan__nr);
extern L1ctlMessage_template ts__L1CTL__DATA__REQ(const GSM__Types::RslChannelNr_template& chan__nr, const GSM__Types::RslLinkId_template& link__id, const OCTETSTRING& l2__data);
extern L1ctlMessage_template ts__L1CTL__DATA__REQ__SACCH(const GSM__Types::RslChannelNr_template& chan__nr, const GSM__Types::RslLinkId_template& link__id, const GSM__RR__Types::SacchL1Header_template& l1h, const OCTETSTRING& l2__data);
extern L1ctlMessage_template ts__L1CTL__TRAFFIC__REQ(const GSM__Types::RslChannelNr_template& chan__nr, const GSM__Types::RslLinkId_template& link__id, const OCTETSTRING& frame);
extern L1ctlMessage_template ts__L1CTL__DATA__IND(const GSM__Types::RslChannelNr_template& chan__nr, const GSM__Types::RslLinkId_template& link__id, const OCTETSTRING_template& l2__data, const GSM__Types::GsmBandArfcn_template& arfcn, const INTEGER_template& fn, const INTEGER_template& rx__level, const INTEGER_template& num__biterr, const INTEGER_template& fire__crc);
extern L1ctlMessage_template tr__L1CTL__DATA__IND(const GSM__Types::RslChannelNr_template& chan__nr, const GSM__Types::RslLinkId_template& link__id, const OCTETSTRING_template& l2__data, const INTEGER_template& num__biterr, const INTEGER_template& fire__crc);
extern L1ctlMessage_template ts__L1CTL__DATA__CONF(const GSM__Types::RslChannelNr_template& chan__nr, const GSM__Types::RslLinkId_template& link__id, const GSM__Types::GsmBandArfcn_template& arfcn, const INTEGER_template& fn);
extern L1ctlMessage_template tr__L1CTL__DATA__CONF(const GSM__Types::RslChannelNr_template& chan__nr, const GSM__Types::RslLinkId_template& link__id, const GSM__Types::GsmBandArfcn_template& arfcn, const INTEGER_template& fn);
extern L1ctlMessage_template ts__L1CTL__TRAFFIC__CONF(const GSM__Types::RslChannelNr_template& chan__nr, const GSM__Types::RslLinkId_template& link__id, const GSM__Types::GsmBandArfcn_template& arfcn, const INTEGER_template& fn);
extern L1ctlMessage_template tr__L1CTL__TRAFFIC__CONF(const GSM__Types::RslChannelNr_template& chan__nr, const GSM__Types::RslLinkId_template& link__id, const GSM__Types::GsmBandArfcn_template& arfcn, const INTEGER_template& fn);
extern L1ctlMessage_template tr__L1CTL__TRAFFIC__IND(const GSM__Types::RslChannelNr_template& chan__nr, const GSM__Types::RslLinkId_template& link__id, const OCTETSTRING_template& frame, const INTEGER_template& num__biterr, const INTEGER_template& fire__crc);
extern L1ctlMessage_template ts__L1CTL__CRYPTO__REQ(const GSM__Types::RslChannelNr_template& chan__nr, const INTEGER_template& algo, const OCTETSTRING_template& key);
extern L1ctlMessage_template ts__L1CTL__GPRS__UL__TBF__CFG__REQ(const INTEGER_template& tbf__ref, const BITSTRING_template& slotmask, const INTEGER_template& start__fn);
extern L1ctlMessage_template tr__L1CTL__GPRS__UL__TBF__CFG__REQ(const INTEGER_template& tbf__ref, const BITSTRING_template& slotmask, const INTEGER_template& start__fn);
extern L1ctlMessage_template ts__L1CTL__GPRS__DL__TBF__CFG__REQ(const INTEGER_template& tbf__ref, const BITSTRING_template& slotmask, const INTEGER_template& start__fn, const INTEGER_template& dl__tfi);
extern L1ctlMessage_template tr__L1CTL__GPRS__DL__TBF__CFG__REQ(const INTEGER_template& tbf__ref, const BITSTRING_template& slotmask, const INTEGER_template& start__fn, const INTEGER_template& dl__tfi);
extern L1ctlMessage_template ts__L1CTL__GPRS__UL__BLOCK__REQ(const INTEGER_template& fn, const INTEGER_template& tn, const OCTETSTRING_template& data);
extern L1ctlMessage_template tr__L1CTL__GPRS__UL__BLOCK__REQ(const INTEGER_template& fn, const INTEGER_template& tn, const OCTETSTRING_template& data);
extern L1ctlMessage_template ts__L1CTL__GPRS__DL__BLOCK__IND(const INTEGER_template& fn, const INTEGER_template& tn, const INTEGER_template& usf, const OCTETSTRING_template& data, const INTEGER_template& ber10k, const INTEGER_template& ci__cb, const INTEGER_template& rx__level);
extern L1ctlMessage_template tr__L1CTL__GPRS__DL__BLOCK__IND(const INTEGER_template& fn, const INTEGER_template& tn, const INTEGER_template& usf, const OCTETSTRING_template& data, const INTEGER_template& ber10k, const INTEGER_template& ci__cb, const INTEGER_template& rx__level);
extern void pre_init_module();
extern void post_init_module();

/* Global variable declarations */

extern const TTCN_RAWdescriptor_t L1ctlMsgType_raw_;
extern const TTCN_Typedescriptor_t L1ctlMsgType_descr_;
extern UNIVERSAL_CHARSTRING L1ctlMsgType_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlCcchMode_raw_;
extern const TTCN_Typedescriptor_t L1ctlCcchMode_descr_;
extern UNIVERSAL_CHARSTRING L1ctlCcchMode_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlNeighMode_raw_;
extern const TTCN_Typedescriptor_t L1ctlNeighMode_descr_;
extern UNIVERSAL_CHARSTRING L1ctlNeighMode_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlResetType_raw_;
extern const TTCN_Typedescriptor_t L1ctlResetType_descr_;
extern UNIVERSAL_CHARSTRING L1ctlResetType_default_coding;
extern const XERdescriptor_t L1ctlHdrFlags_padding_xer_;
extern const TTCN_OERdescriptor_t L1ctlHdrFlags_padding_oer_;
extern const TTCN_Typedescriptor_t L1ctlHdrFlags_padding_descr_;
extern UNIVERSAL_CHARSTRING L1ctlHdrFlags_padding_default_coding;
extern const XERdescriptor_t L1ctlHdrFlags_f__done_xer_;
extern const TTCN_OERdescriptor_t L1ctlHdrFlags_f__done_oer_;
extern const TTCN_Typedescriptor_t L1ctlHdrFlags_f__done_descr_;
extern UNIVERSAL_CHARSTRING L1ctlHdrFlags_f__done_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlHdrFlags_raw_;
extern const TTCN_Typedescriptor_t L1ctlHdrFlags_descr_;
extern UNIVERSAL_CHARSTRING L1ctlHdrFlags_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlHeader_msg__type_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlHeader_flags_default_coding;
extern const XERdescriptor_t L1ctlHeader_padding_xer_;
extern const TTCN_OERdescriptor_t L1ctlHeader_padding_oer_;
extern const TTCN_Typedescriptor_t L1ctlHeader_padding_descr_;
extern UNIVERSAL_CHARSTRING L1ctlHeader_padding_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlHeader_raw_;
extern const TTCN_Typedescriptor_t L1ctlHeader_descr_;
extern UNIVERSAL_CHARSTRING L1ctlHeader_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlDlInfo_chan__nr_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlDlInfo_link__id_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlDlInfo_arfcn_default_coding;
extern const XERdescriptor_t L1ctlDlInfo_frame__nr_xer_;
extern const TTCN_OERdescriptor_t L1ctlDlInfo_frame__nr_oer_;
extern const TTCN_Typedescriptor_t L1ctlDlInfo_frame__nr_descr_;
extern UNIVERSAL_CHARSTRING L1ctlDlInfo_frame__nr_default_coding;
extern const XERdescriptor_t L1ctlDlInfo_rx__level_xer_;
extern const TTCN_OERdescriptor_t L1ctlDlInfo_rx__level_oer_;
extern const TTCN_Typedescriptor_t L1ctlDlInfo_rx__level_descr_;
extern UNIVERSAL_CHARSTRING L1ctlDlInfo_rx__level_default_coding;
extern const XERdescriptor_t L1ctlDlInfo_snr_xer_;
extern const TTCN_OERdescriptor_t L1ctlDlInfo_snr_oer_;
extern const TTCN_Typedescriptor_t L1ctlDlInfo_snr_descr_;
extern UNIVERSAL_CHARSTRING L1ctlDlInfo_snr_default_coding;
extern const XERdescriptor_t L1ctlDlInfo_num__biterr_xer_;
extern const TTCN_OERdescriptor_t L1ctlDlInfo_num__biterr_oer_;
extern const TTCN_Typedescriptor_t L1ctlDlInfo_num__biterr_descr_;
extern UNIVERSAL_CHARSTRING L1ctlDlInfo_num__biterr_default_coding;
extern const XERdescriptor_t L1ctlDlInfo_fire__crc_xer_;
extern const TTCN_OERdescriptor_t L1ctlDlInfo_fire__crc_oer_;
extern const TTCN_Typedescriptor_t L1ctlDlInfo_fire__crc_descr_;
extern UNIVERSAL_CHARSTRING L1ctlDlInfo_fire__crc_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlDlInfo_raw_;
extern const TTCN_Typedescriptor_t L1ctlDlInfo_descr_;
extern UNIVERSAL_CHARSTRING L1ctlDlInfo_default_coding;
extern const XERdescriptor_t L1ctlFbsbConf_initial__freq__err_xer_;
extern const TTCN_OERdescriptor_t L1ctlFbsbConf_initial__freq__err_oer_;
extern const TTCN_Typedescriptor_t L1ctlFbsbConf_initial__freq__err_descr_;
extern UNIVERSAL_CHARSTRING L1ctlFbsbConf_initial__freq__err_default_coding;
extern const XERdescriptor_t L1ctlFbsbConf_result_xer_;
extern const TTCN_OERdescriptor_t L1ctlFbsbConf_result_oer_;
extern const TTCN_Typedescriptor_t L1ctlFbsbConf_result_descr_;
extern UNIVERSAL_CHARSTRING L1ctlFbsbConf_result_default_coding;
extern const XERdescriptor_t L1ctlFbsbConf_bsic_xer_;
extern const TTCN_OERdescriptor_t L1ctlFbsbConf_bsic_oer_;
extern const TTCN_Typedescriptor_t L1ctlFbsbConf_bsic_descr_;
extern UNIVERSAL_CHARSTRING L1ctlFbsbConf_bsic_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlFbsbConf_raw_;
extern const TTCN_Typedescriptor_t L1ctlFbsbConf_descr_;
extern UNIVERSAL_CHARSTRING L1ctlFbsbConf_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlCcchModeConf_ccch__mode_default_coding;
extern const XERdescriptor_t L1ctlCcchModeConf_padding_xer_;
extern const TTCN_OERdescriptor_t L1ctlCcchModeConf_padding_oer_;
extern const TTCN_Typedescriptor_t L1ctlCcchModeConf_padding_descr_;
extern UNIVERSAL_CHARSTRING L1ctlCcchModeConf_padding_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlCcchModeConf_raw_;
extern const TTCN_Typedescriptor_t L1ctlCcchModeConf_descr_;
extern UNIVERSAL_CHARSTRING L1ctlCcchModeConf_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlTchMode_raw_;
extern const TTCN_Typedescriptor_t L1ctlTchMode_descr_;
extern UNIVERSAL_CHARSTRING L1ctlTchMode_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlLoopMode_raw_;
extern const TTCN_Typedescriptor_t L1ctlLoopMode_descr_;
extern UNIVERSAL_CHARSTRING L1ctlLoopMode_default_coding;
extern const XERdescriptor_t L1ctlAudioMode_padding_xer_;
extern const TTCN_OERdescriptor_t L1ctlAudioMode_padding_oer_;
extern const TTCN_Typedescriptor_t L1ctlAudioMode_padding_descr_;
extern UNIVERSAL_CHARSTRING L1ctlAudioMode_padding_default_coding;
extern const XERdescriptor_t L1ctlAudioMode_tx__microphone_xer_;
extern const TTCN_OERdescriptor_t L1ctlAudioMode_tx__microphone_oer_;
extern const TTCN_Typedescriptor_t L1ctlAudioMode_tx__microphone_descr_;
extern UNIVERSAL_CHARSTRING L1ctlAudioMode_tx__microphone_default_coding;
extern const XERdescriptor_t L1ctlAudioMode_tx__traffic__req_xer_;
extern const TTCN_OERdescriptor_t L1ctlAudioMode_tx__traffic__req_oer_;
extern const TTCN_Typedescriptor_t L1ctlAudioMode_tx__traffic__req_descr_;
extern UNIVERSAL_CHARSTRING L1ctlAudioMode_tx__traffic__req_default_coding;
extern const XERdescriptor_t L1ctlAudioMode_rx__speaker_xer_;
extern const TTCN_OERdescriptor_t L1ctlAudioMode_rx__speaker_oer_;
extern const TTCN_Typedescriptor_t L1ctlAudioMode_rx__speaker_descr_;
extern UNIVERSAL_CHARSTRING L1ctlAudioMode_rx__speaker_default_coding;
extern const XERdescriptor_t L1ctlAudioMode_rx__traffic__ind_xer_;
extern const TTCN_OERdescriptor_t L1ctlAudioMode_rx__traffic__ind_oer_;
extern const TTCN_Typedescriptor_t L1ctlAudioMode_rx__traffic__ind_descr_;
extern UNIVERSAL_CHARSTRING L1ctlAudioMode_rx__traffic__ind_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlAudioMode_raw_;
extern const TTCN_Typedescriptor_t L1ctlAudioMode_descr_;
extern UNIVERSAL_CHARSTRING L1ctlAudioMode_default_coding;
extern const L1ctlAudioMode_template& t__L1CTL__AudioModeNone;
extern L1ctlAudioMode_template template_t__L1CTL__AudioModeNone;
extern const L1ctlAudioMode_template& t__L1CTL__AudioModeFwd;
extern L1ctlAudioMode_template template_t__L1CTL__AudioModeFwd;
extern UNIVERSAL_CHARSTRING L1ctlTchModeConf_tch__mode_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlTchModeConf_audio__mode_default_coding;
extern const XERdescriptor_t L1ctlTchModeConf_amr_start__codec_xer_;
extern const TTCN_OERdescriptor_t L1ctlTchModeConf_amr_start__codec_oer_;
extern const TTCN_Typedescriptor_t L1ctlTchModeConf_amr_start__codec_descr_;
extern UNIVERSAL_CHARSTRING L1ctlTchModeConf_amr_start__codec_default_coding;
extern const XERdescriptor_t L1ctlTchModeConf_amr_codecs__bitmask_xer_;
extern const TTCN_OERdescriptor_t L1ctlTchModeConf_amr_codecs__bitmask_oer_;
extern const TTCN_Typedescriptor_t L1ctlTchModeConf_amr_codecs__bitmask_descr_;
extern UNIVERSAL_CHARSTRING L1ctlTchModeConf_amr_codecs__bitmask_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlTchModeConf_amr_raw_;
extern const TTCN_Typedescriptor_t L1ctlTchModeConf_amr_descr_;
extern UNIVERSAL_CHARSTRING L1ctlTchModeConf_amr_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlTchModeConf_raw_;
extern const TTCN_Typedescriptor_t L1ctlTchModeConf_descr_;
extern UNIVERSAL_CHARSTRING L1ctlTchModeConf_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlDataInd_payload_raw_;
extern const XERdescriptor_t L1ctlDataInd_payload_xer_;
extern const TTCN_OERdescriptor_t L1ctlDataInd_payload_oer_;
extern const TTCN_Typedescriptor_t L1ctlDataInd_payload_descr_;
extern UNIVERSAL_CHARSTRING L1ctlDataInd_payload_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlDataInd_raw_;
extern const TTCN_Typedescriptor_t L1ctlDataInd_descr_;
extern UNIVERSAL_CHARSTRING L1ctlDataInd_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlUlInfo_chan__nr_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlUlInfo_link__id_default_coding;
extern const XERdescriptor_t L1ctlUlInfo_padding_xer_;
extern const TTCN_OERdescriptor_t L1ctlUlInfo_padding_oer_;
extern const TTCN_Typedescriptor_t L1ctlUlInfo_padding_descr_;
extern UNIVERSAL_CHARSTRING L1ctlUlInfo_padding_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlUlInfo_raw_;
extern const TTCN_Typedescriptor_t L1ctlUlInfo_descr_;
extern UNIVERSAL_CHARSTRING L1ctlUlInfo_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlFbsbFlags_padding_raw_;
extern const XERdescriptor_t L1ctlFbsbFlags_padding_xer_;
extern const TTCN_OERdescriptor_t L1ctlFbsbFlags_padding_oer_;
extern const TTCN_Typedescriptor_t L1ctlFbsbFlags_padding_descr_;
extern UNIVERSAL_CHARSTRING L1ctlFbsbFlags_padding_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlFbsbFlags_sb_raw_;
extern const XERdescriptor_t L1ctlFbsbFlags_sb_xer_;
extern const TTCN_OERdescriptor_t L1ctlFbsbFlags_sb_oer_;
extern const TTCN_Typedescriptor_t L1ctlFbsbFlags_sb_descr_;
extern UNIVERSAL_CHARSTRING L1ctlFbsbFlags_sb_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlFbsbFlags_fb1_raw_;
extern const XERdescriptor_t L1ctlFbsbFlags_fb1_xer_;
extern const TTCN_OERdescriptor_t L1ctlFbsbFlags_fb1_oer_;
extern const TTCN_Typedescriptor_t L1ctlFbsbFlags_fb1_descr_;
extern UNIVERSAL_CHARSTRING L1ctlFbsbFlags_fb1_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlFbsbFlags_fb0_raw_;
extern const XERdescriptor_t L1ctlFbsbFlags_fb0_xer_;
extern const TTCN_OERdescriptor_t L1ctlFbsbFlags_fb0_oer_;
extern const TTCN_Typedescriptor_t L1ctlFbsbFlags_fb0_descr_;
extern UNIVERSAL_CHARSTRING L1ctlFbsbFlags_fb0_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlFbsbFlags_raw_;
extern const TTCN_Typedescriptor_t L1ctlFbsbFlags_descr_;
extern UNIVERSAL_CHARSTRING L1ctlFbsbFlags_default_coding;
extern const L1ctlFbsbFlags_template& t__L1CTL__FBSB__F__ALL;
extern L1ctlFbsbFlags_template template_t__L1CTL__FBSB__F__ALL;
extern UNIVERSAL_CHARSTRING L1ctlFbsbReq_arfcn_default_coding;
extern const XERdescriptor_t L1ctlFbsbReq_timeout__tdma__frames_xer_;
extern const TTCN_OERdescriptor_t L1ctlFbsbReq_timeout__tdma__frames_oer_;
extern const TTCN_Typedescriptor_t L1ctlFbsbReq_timeout__tdma__frames_descr_;
extern UNIVERSAL_CHARSTRING L1ctlFbsbReq_timeout__tdma__frames_default_coding;
extern const XERdescriptor_t L1ctlFbsbReq_freq__err__thresh1_xer_;
extern const TTCN_OERdescriptor_t L1ctlFbsbReq_freq__err__thresh1_oer_;
extern const TTCN_Typedescriptor_t L1ctlFbsbReq_freq__err__thresh1_descr_;
extern UNIVERSAL_CHARSTRING L1ctlFbsbReq_freq__err__thresh1_default_coding;
extern const XERdescriptor_t L1ctlFbsbReq_freq__err__thresh2_xer_;
extern const TTCN_OERdescriptor_t L1ctlFbsbReq_freq__err__thresh2_oer_;
extern const TTCN_Typedescriptor_t L1ctlFbsbReq_freq__err__thresh2_descr_;
extern UNIVERSAL_CHARSTRING L1ctlFbsbReq_freq__err__thresh2_default_coding;
extern const XERdescriptor_t L1ctlFbsbReq_num__freqerr__avg_xer_;
extern const TTCN_OERdescriptor_t L1ctlFbsbReq_num__freqerr__avg_oer_;
extern const TTCN_Typedescriptor_t L1ctlFbsbReq_num__freqerr__avg_descr_;
extern UNIVERSAL_CHARSTRING L1ctlFbsbReq_num__freqerr__avg_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlFbsbReq_flags_default_coding;
extern const XERdescriptor_t L1ctlFbsbReq_sync__info__idx_xer_;
extern const TTCN_OERdescriptor_t L1ctlFbsbReq_sync__info__idx_oer_;
extern const TTCN_Typedescriptor_t L1ctlFbsbReq_sync__info__idx_descr_;
extern UNIVERSAL_CHARSTRING L1ctlFbsbReq_sync__info__idx_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlFbsbReq_ccch__mode_default_coding;
extern const XERdescriptor_t L1ctlFbsbReq_rxlev__exp_xer_;
extern const TTCN_OERdescriptor_t L1ctlFbsbReq_rxlev__exp_oer_;
extern const TTCN_Typedescriptor_t L1ctlFbsbReq_rxlev__exp_descr_;
extern UNIVERSAL_CHARSTRING L1ctlFbsbReq_rxlev__exp_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlFbsbReq_raw_;
extern const TTCN_Typedescriptor_t L1ctlFbsbReq_descr_;
extern UNIVERSAL_CHARSTRING L1ctlFbsbReq_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlCcchModeReq_ccch__mode_default_coding;
extern const XERdescriptor_t L1ctlCcchModeReq_padding_xer_;
extern const TTCN_OERdescriptor_t L1ctlCcchModeReq_padding_oer_;
extern const TTCN_Typedescriptor_t L1ctlCcchModeReq_padding_descr_;
extern UNIVERSAL_CHARSTRING L1ctlCcchModeReq_padding_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlCcchModeReq_raw_;
extern const TTCN_Typedescriptor_t L1ctlCcchModeReq_descr_;
extern UNIVERSAL_CHARSTRING L1ctlCcchModeReq_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlTchModeReq_tch__mode_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlTchModeReq_audio__mode_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlTchModeReq_loop__mode_default_coding;
extern const XERdescriptor_t L1ctlTchModeReq_amr_start__codec_xer_;
extern const TTCN_OERdescriptor_t L1ctlTchModeReq_amr_start__codec_oer_;
extern const TTCN_Typedescriptor_t L1ctlTchModeReq_amr_start__codec_descr_;
extern UNIVERSAL_CHARSTRING L1ctlTchModeReq_amr_start__codec_default_coding;
extern const XERdescriptor_t L1ctlTchModeReq_amr_codecs__bitmask_xer_;
extern const TTCN_OERdescriptor_t L1ctlTchModeReq_amr_codecs__bitmask_oer_;
extern const TTCN_Typedescriptor_t L1ctlTchModeReq_amr_codecs__bitmask_descr_;
extern UNIVERSAL_CHARSTRING L1ctlTchModeReq_amr_codecs__bitmask_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlTchModeReq_amr_raw_;
extern const TTCN_Typedescriptor_t L1ctlTchModeReq_amr_descr_;
extern UNIVERSAL_CHARSTRING L1ctlTchModeReq_amr_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlTchModeReq_raw_;
extern const TTCN_Typedescriptor_t L1ctlTchModeReq_descr_;
extern UNIVERSAL_CHARSTRING L1ctlTchModeReq_default_coding;
extern const XERdescriptor_t L1ctlRachReq_ra_xer_;
extern const TTCN_OERdescriptor_t L1ctlRachReq_ra_oer_;
extern const TTCN_Typedescriptor_t L1ctlRachReq_ra_descr_;
extern UNIVERSAL_CHARSTRING L1ctlRachReq_ra_default_coding;
extern const XERdescriptor_t L1ctlRachReq_combined_xer_;
extern const TTCN_OERdescriptor_t L1ctlRachReq_combined_oer_;
extern const TTCN_Typedescriptor_t L1ctlRachReq_combined_descr_;
extern UNIVERSAL_CHARSTRING L1ctlRachReq_combined_default_coding;
extern const XERdescriptor_t L1ctlRachReq_offset_xer_;
extern const TTCN_OERdescriptor_t L1ctlRachReq_offset_oer_;
extern const TTCN_Typedescriptor_t L1ctlRachReq_offset_descr_;
extern UNIVERSAL_CHARSTRING L1ctlRachReq_offset_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlRachReq_raw_;
extern const TTCN_Typedescriptor_t L1ctlRachReq_descr_;
extern UNIVERSAL_CHARSTRING L1ctlRachReq_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlRachSynchSeq_raw_;
extern const TTCN_Typedescriptor_t L1ctlRachSynchSeq_descr_;
extern UNIVERSAL_CHARSTRING L1ctlRachSynchSeq_default_coding;
extern const XERdescriptor_t L1ctlExtRachReq_ra11_xer_;
extern const TTCN_OERdescriptor_t L1ctlExtRachReq_ra11_oer_;
extern const TTCN_Typedescriptor_t L1ctlExtRachReq_ra11_descr_;
extern UNIVERSAL_CHARSTRING L1ctlExtRachReq_ra11_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlExtRachReq_synch__seq_default_coding;
extern const XERdescriptor_t L1ctlExtRachReq_combined_xer_;
extern const TTCN_OERdescriptor_t L1ctlExtRachReq_combined_oer_;
extern const TTCN_Typedescriptor_t L1ctlExtRachReq_combined_descr_;
extern UNIVERSAL_CHARSTRING L1ctlExtRachReq_combined_default_coding;
extern const XERdescriptor_t L1ctlExtRachReq_offset_xer_;
extern const TTCN_OERdescriptor_t L1ctlExtRachReq_offset_oer_;
extern const TTCN_Typedescriptor_t L1ctlExtRachReq_offset_descr_;
extern UNIVERSAL_CHARSTRING L1ctlExtRachReq_offset_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlExtRachReq_raw_;
extern const TTCN_Typedescriptor_t L1ctlExtRachReq_descr_;
extern UNIVERSAL_CHARSTRING L1ctlExtRachReq_default_coding;
extern const XERdescriptor_t L1ctlParReq_ta_xer_;
extern const TTCN_Typedescriptor_t L1ctlParReq_ta_descr_;
extern UNIVERSAL_CHARSTRING L1ctlParReq_ta_default_coding;
extern const XERdescriptor_t L1ctlParReq_tx__power_xer_;
extern const TTCN_OERdescriptor_t L1ctlParReq_tx__power_oer_;
extern const TTCN_Typedescriptor_t L1ctlParReq_tx__power_descr_;
extern UNIVERSAL_CHARSTRING L1ctlParReq_tx__power_default_coding;
extern const XERdescriptor_t L1ctlParReq_padding_xer_;
extern const TTCN_OERdescriptor_t L1ctlParReq_padding_oer_;
extern const TTCN_Typedescriptor_t L1ctlParReq_padding_descr_;
extern UNIVERSAL_CHARSTRING L1ctlParReq_padding_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlParReq_raw_;
extern const TTCN_Typedescriptor_t L1ctlParReq_descr_;
extern UNIVERSAL_CHARSTRING L1ctlParReq_default_coding;
extern const XERdescriptor_t L1ctlDataReq_l2__payload_xer_;
extern const TTCN_OERdescriptor_t L1ctlDataReq_l2__payload_oer_;
extern const TTCN_Typedescriptor_t L1ctlDataReq_l2__payload_descr_;
extern UNIVERSAL_CHARSTRING L1ctlDataReq_l2__payload_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlDataReq_raw_;
extern const TTCN_Typedescriptor_t L1ctlDataReq_descr_;
extern UNIVERSAL_CHARSTRING L1ctlDataReq_l1header_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlDataReq_default_coding;
extern const XERdescriptor_t L1ctlH0_h_xer_;
extern const TTCN_OERdescriptor_t L1ctlH0_h_oer_;
extern const TTCN_Typedescriptor_t L1ctlH0_h_descr_;
extern UNIVERSAL_CHARSTRING L1ctlH0_h_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlH0_arfcn_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlH0_padding_raw_;
extern const XERdescriptor_t L1ctlH0_padding_xer_;
extern const TTCN_OERdescriptor_t L1ctlH0_padding_oer_;
extern const TTCN_Typedescriptor_t L1ctlH0_padding_descr_;
extern UNIVERSAL_CHARSTRING L1ctlH0_padding_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlH0_raw_;
extern const TTCN_Typedescriptor_t L1ctlH0_descr_;
extern UNIVERSAL_CHARSTRING L1ctlH0_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlMA_raw_;
extern const TTCN_Typedescriptor_t L1ctlMA_descr_;
extern UNIVERSAL_CHARSTRING L1ctlMA_0_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMA_default_coding;
extern const XERdescriptor_t L1ctlH1_h_xer_;
extern const TTCN_OERdescriptor_t L1ctlH1_h_oer_;
extern const TTCN_Typedescriptor_t L1ctlH1_h_descr_;
extern UNIVERSAL_CHARSTRING L1ctlH1_h_default_coding;
extern const XERdescriptor_t L1ctlH1_hsn_xer_;
extern const TTCN_OERdescriptor_t L1ctlH1_hsn_oer_;
extern const TTCN_Typedescriptor_t L1ctlH1_hsn_descr_;
extern UNIVERSAL_CHARSTRING L1ctlH1_hsn_default_coding;
extern const XERdescriptor_t L1ctlH1_maio_xer_;
extern const TTCN_OERdescriptor_t L1ctlH1_maio_oer_;
extern const TTCN_Typedescriptor_t L1ctlH1_maio_descr_;
extern UNIVERSAL_CHARSTRING L1ctlH1_maio_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlH1_n_raw_;
extern const XERdescriptor_t L1ctlH1_n_xer_;
extern const TTCN_OERdescriptor_t L1ctlH1_n_oer_;
extern const TTCN_Typedescriptor_t L1ctlH1_n_descr_;
extern UNIVERSAL_CHARSTRING L1ctlH1_n_default_coding;
extern const XERdescriptor_t L1ctlH1_spare_xer_;
extern const TTCN_OERdescriptor_t L1ctlH1_spare_oer_;
extern const TTCN_Typedescriptor_t L1ctlH1_spare_descr_;
extern UNIVERSAL_CHARSTRING L1ctlH1_spare_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlH1_ma_default_coding;
extern const XERdescriptor_t L1ctlH1_padding_xer_;
extern const TTCN_OERdescriptor_t L1ctlH1_padding_oer_;
extern const TTCN_Typedescriptor_t L1ctlH1_padding_descr_;
extern UNIVERSAL_CHARSTRING L1ctlH1_padding_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlH1_raw_;
extern const TTCN_Typedescriptor_t L1ctlH1_descr_;
extern UNIVERSAL_CHARSTRING L1ctlH1_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlH0H1_raw_;
extern const TTCN_Typedescriptor_t L1ctlH0H1_descr_;
extern UNIVERSAL_CHARSTRING L1ctlH0H1_h0_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlH0H1_h1_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlH0H1_default_coding;
extern const XERdescriptor_t L1ctlDmEstReq_tsc_xer_;
extern const TTCN_OERdescriptor_t L1ctlDmEstReq_tsc_oer_;
extern const TTCN_Typedescriptor_t L1ctlDmEstReq_tsc_descr_;
extern UNIVERSAL_CHARSTRING L1ctlDmEstReq_tsc_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlDmEstReq_h0h1_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlDmEstReq_tch__mode_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlDmEstReq_audio__mode_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlDmEstReq_raw_;
extern const TTCN_Typedescriptor_t L1ctlDmEstReq_descr_;
extern UNIVERSAL_CHARSTRING L1ctlDmEstReq_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlReset_reset__type_default_coding;
extern const XERdescriptor_t L1ctlReset_padding_xer_;
extern const TTCN_OERdescriptor_t L1ctlReset_padding_oer_;
extern const TTCN_Typedescriptor_t L1ctlReset_padding_descr_;
extern UNIVERSAL_CHARSTRING L1ctlReset_padding_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlReset_raw_;
extern const TTCN_Typedescriptor_t L1ctlReset_descr_;
extern UNIVERSAL_CHARSTRING L1ctlReset_default_coding;
extern const XERdescriptor_t L1CtlCryptoReq_algo_xer_;
extern const TTCN_OERdescriptor_t L1CtlCryptoReq_algo_oer_;
extern const TTCN_Typedescriptor_t L1CtlCryptoReq_algo_descr_;
extern UNIVERSAL_CHARSTRING L1CtlCryptoReq_algo_default_coding;
extern const TTCN_RAWdescriptor_t L1CtlCryptoReq_key__len_raw_;
extern const XERdescriptor_t L1CtlCryptoReq_key__len_xer_;
extern const TTCN_OERdescriptor_t L1CtlCryptoReq_key__len_oer_;
extern const TTCN_Typedescriptor_t L1CtlCryptoReq_key__len_descr_;
extern UNIVERSAL_CHARSTRING L1CtlCryptoReq_key__len_default_coding;
extern const XERdescriptor_t L1CtlCryptoReq_key_xer_;
extern const TTCN_OERdescriptor_t L1CtlCryptoReq_key_oer_;
extern const TTCN_Typedescriptor_t L1CtlCryptoReq_key_descr_;
extern UNIVERSAL_CHARSTRING L1CtlCryptoReq_key_default_coding;
extern const TTCN_RAWdescriptor_t L1CtlCryptoReq_raw_;
extern const TTCN_Typedescriptor_t L1CtlCryptoReq_descr_;
extern UNIVERSAL_CHARSTRING L1CtlCryptoReq_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlTrafficReq_data_raw_;
extern const XERdescriptor_t L1ctlTrafficReq_data_xer_;
extern const TTCN_OERdescriptor_t L1ctlTrafficReq_data_oer_;
extern const TTCN_Typedescriptor_t L1ctlTrafficReq_data_descr_;
extern UNIVERSAL_CHARSTRING L1ctlTrafficReq_data_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlTrafficReq_raw_;
extern const TTCN_Typedescriptor_t L1ctlTrafficReq_descr_;
extern UNIVERSAL_CHARSTRING L1ctlTrafficReq_default_coding;
extern const XERdescriptor_t L1ctlGprsUlTbfCfgReq_tbf__ref_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsUlTbfCfgReq_tbf__ref_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsUlTbfCfgReq_tbf__ref_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsUlTbfCfgReq_tbf__ref_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlGprsUlTbfCfgReq_slotmask_raw_;
extern const XERdescriptor_t L1ctlGprsUlTbfCfgReq_slotmask_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsUlTbfCfgReq_slotmask_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsUlTbfCfgReq_slotmask_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsUlTbfCfgReq_slotmask_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlGprsUlTbfCfgReq_pad_raw_;
extern const XERdescriptor_t L1ctlGprsUlTbfCfgReq_pad_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsUlTbfCfgReq_pad_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsUlTbfCfgReq_pad_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsUlTbfCfgReq_pad_default_coding;
extern const XERdescriptor_t L1ctlGprsUlTbfCfgReq_start__fn_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsUlTbfCfgReq_start__fn_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsUlTbfCfgReq_start__fn_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsUlTbfCfgReq_start__fn_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlGprsUlTbfCfgReq_raw_;
extern const TTCN_Typedescriptor_t L1ctlGprsUlTbfCfgReq_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsUlTbfCfgReq_default_coding;
extern const XERdescriptor_t L1ctlGprsDlTbfCfgReq_tbf__ref_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsDlTbfCfgReq_tbf__ref_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsDlTbfCfgReq_tbf__ref_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsDlTbfCfgReq_tbf__ref_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlGprsDlTbfCfgReq_slotmask_raw_;
extern const XERdescriptor_t L1ctlGprsDlTbfCfgReq_slotmask_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsDlTbfCfgReq_slotmask_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsDlTbfCfgReq_slotmask_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsDlTbfCfgReq_slotmask_default_coding;
extern const XERdescriptor_t L1ctlGprsDlTbfCfgReq_dl__tfi_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsDlTbfCfgReq_dl__tfi_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsDlTbfCfgReq_dl__tfi_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsDlTbfCfgReq_dl__tfi_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlGprsDlTbfCfgReq_pad_raw_;
extern const XERdescriptor_t L1ctlGprsDlTbfCfgReq_pad_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsDlTbfCfgReq_pad_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsDlTbfCfgReq_pad_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsDlTbfCfgReq_pad_default_coding;
extern const XERdescriptor_t L1ctlGprsDlTbfCfgReq_start__fn_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsDlTbfCfgReq_start__fn_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsDlTbfCfgReq_start__fn_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsDlTbfCfgReq_start__fn_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlGprsDlTbfCfgReq_raw_;
extern const TTCN_Typedescriptor_t L1ctlGprsDlTbfCfgReq_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsDlTbfCfgReq_default_coding;
extern const XERdescriptor_t L1ctlGprsBlockHdr_fn_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsBlockHdr_fn_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsBlockHdr_fn_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsBlockHdr_fn_default_coding;
extern const XERdescriptor_t L1ctlGprsBlockHdr_tn_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsBlockHdr_tn_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsBlockHdr_tn_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsBlockHdr_tn_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlGprsBlockHdr_pad_raw_;
extern const XERdescriptor_t L1ctlGprsBlockHdr_pad_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsBlockHdr_pad_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsBlockHdr_pad_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsBlockHdr_pad_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlGprsBlockHdr_raw_;
extern const TTCN_Typedescriptor_t L1ctlGprsBlockHdr_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsBlockHdr_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlGprsUlBlockReq_hdr_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlGprsUlBlockReq_data_raw_;
extern const XERdescriptor_t L1ctlGprsUlBlockReq_data_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsUlBlockReq_data_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsUlBlockReq_data_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsUlBlockReq_data_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlGprsUlBlockReq_raw_;
extern const TTCN_Typedescriptor_t L1ctlGprsUlBlockReq_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsUlBlockReq_default_coding;
extern const XERdescriptor_t L1ctlGprsUlBlockCnf_fn_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsUlBlockCnf_fn_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsUlBlockCnf_fn_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsUlBlockCnf_fn_default_coding;
extern const XERdescriptor_t L1ctlGprsUlBlockCnf_tn_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsUlBlockCnf_tn_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsUlBlockCnf_tn_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsUlBlockCnf_tn_default_coding;
extern const XERdescriptor_t L1ctlGprsUlBlockCnf_data_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsUlBlockCnf_data_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsUlBlockCnf_data_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsUlBlockCnf_data_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlGprsUlBlockCnf_raw_;
extern const TTCN_Typedescriptor_t L1ctlGprsUlBlockCnf_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsUlBlockCnf_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlGprsDlBlockInd_hdr_default_coding;
extern const XERdescriptor_t L1ctlGprsDlBlockInd_meas_ber10k_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsDlBlockInd_meas_ber10k_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsDlBlockInd_meas_ber10k_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsDlBlockInd_meas_ber10k_default_coding;
extern const XERdescriptor_t L1ctlGprsDlBlockInd_meas_ci__cb_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsDlBlockInd_meas_ci__cb_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsDlBlockInd_meas_ci__cb_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsDlBlockInd_meas_ci__cb_default_coding;
extern const XERdescriptor_t L1ctlGprsDlBlockInd_meas_rx__level_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsDlBlockInd_meas_rx__level_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsDlBlockInd_meas_rx__level_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsDlBlockInd_meas_rx__level_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlGprsDlBlockInd_meas_raw_;
extern const TTCN_Typedescriptor_t L1ctlGprsDlBlockInd_meas_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsDlBlockInd_meas_default_coding;
extern const XERdescriptor_t L1ctlGprsDlBlockInd_usf_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsDlBlockInd_usf_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsDlBlockInd_usf_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsDlBlockInd_usf_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlGprsDlBlockInd_data_raw_;
extern const XERdescriptor_t L1ctlGprsDlBlockInd_data_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsDlBlockInd_data_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsDlBlockInd_data_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsDlBlockInd_data_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlGprsDlBlockInd_raw_;
extern const TTCN_Typedescriptor_t L1ctlGprsDlBlockInd_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsDlBlockInd_default_coding;
extern const XERdescriptor_t L1ctlGprsRtsInd_fn_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsRtsInd_fn_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsRtsInd_fn_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsRtsInd_fn_default_coding;
extern const XERdescriptor_t L1ctlGprsRtsInd_tn_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsRtsInd_tn_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsRtsInd_tn_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsRtsInd_tn_default_coding;
extern const XERdescriptor_t L1ctlGprsRtsInd_usf_xer_;
extern const TTCN_OERdescriptor_t L1ctlGprsRtsInd_usf_oer_;
extern const TTCN_Typedescriptor_t L1ctlGprsRtsInd_usf_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsRtsInd_usf_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlGprsRtsInd_raw_;
extern const TTCN_Typedescriptor_t L1ctlGprsRtsInd_descr_;
extern UNIVERSAL_CHARSTRING L1ctlGprsRtsInd_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlMsgPayload_raw_;
extern const TTCN_Typedescriptor_t L1ctlMsgPayload_descr_;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_fbsb__req_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_fbsb__conf_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_data__ind_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_rach__req_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_dm__est__req_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_data__req_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_reset__req_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_ccch__mode__req_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_ccch__mode__conf_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_par__req_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_crypto__req_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_tch__mode__req_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_tch__mode__conf_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_traffic__req_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_traffic__ind_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_ul__tbf__cfg__req_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_dl__tbf__cfg__req_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_ul__block__req_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_ul__block__cnf_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_dl__block__ind_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_ext__rach__req_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_rts__ind_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlMsgPayload_other_raw_;
extern const XERdescriptor_t L1ctlMsgPayload_other_xer_;
extern const TTCN_OERdescriptor_t L1ctlMsgPayload_other_oer_;
extern const TTCN_Typedescriptor_t L1ctlMsgPayload_other_descr_;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_other_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMsgPayload_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMessage_header_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlMessage_raw_;
extern const TTCN_Typedescriptor_t L1ctlMessage_descr_;
extern const TTCN_RAWdescriptor_t L1ctlMessage_ul__info_raw_;
extern const TTCN_Typedescriptor_t L1ctlMessage_ul__info_descr_;
extern UNIVERSAL_CHARSTRING L1ctlMessage_ul__info_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlMessage_dl__info_raw_;
extern const TTCN_Typedescriptor_t L1ctlMessage_dl__info_descr_;
extern UNIVERSAL_CHARSTRING L1ctlMessage_dl__info_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlMessage_payload_raw_;
extern const TTCN_Typedescriptor_t L1ctlMessage_payload_descr_;
extern UNIVERSAL_CHARSTRING L1ctlMessage_payload_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMessage_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlMessageLV_len_raw_;
extern const XERdescriptor_t L1ctlMessageLV_len_xer_;
extern const TTCN_OERdescriptor_t L1ctlMessageLV_len_oer_;
extern const TTCN_Typedescriptor_t L1ctlMessageLV_len_descr_;
extern UNIVERSAL_CHARSTRING L1ctlMessageLV_len_default_coding;
extern UNIVERSAL_CHARSTRING L1ctlMessageLV_msg_default_coding;
extern const TTCN_RAWdescriptor_t L1ctlMessageLV_raw_;
extern const TTCN_Typedescriptor_t L1ctlMessageLV_descr_;
extern UNIVERSAL_CHARSTRING L1ctlMessageLV_default_coding;
extern const L1ctlTchMode_template& ts__L1CTL__TCH__MODE__REQ_tch__mode_defval;
extern L1ctlTchMode_template template_ts__L1CTL__TCH__MODE__REQ_tch__mode_defval;
extern const L1ctlAudioMode_template& ts__L1CTL__TCH__MODE__REQ_audio__mode_defval;
extern L1ctlAudioMode_template template_ts__L1CTL__TCH__MODE__REQ_audio__mode_defval;
extern const L1ctlLoopMode_template& ts__L1CTL__TCH__MODE__REQ_loop__mode_defval;
extern L1ctlLoopMode_template template_ts__L1CTL__TCH__MODE__REQ_loop__mode_defval;
extern const INTEGER_template& ts__L1CTL__TCH__MODE__REQ_amr__start__codec_defval;
extern INTEGER_template template_ts__L1CTL__TCH__MODE__REQ_amr__start__codec_defval;
extern const BITSTRING_template& ts__L1CTL__TCH__MODE__REQ_amr__codecs__bitmask_defval;
extern BITSTRING_template template_ts__L1CTL__TCH__MODE__REQ_amr__codecs__bitmask_defval;
extern const L1ctlMessage_template& tr__L1CTL__CCCH__MODE__CONF;
extern L1ctlMessage_template template_tr__L1CTL__CCCH__MODE__CONF;
extern const GSM__Types::RslChannelNr_template& ts__L1CTL__RACH__REQ_chan__nr_defval;
extern GSM__Types::RslChannelNr_template template_ts__L1CTL__RACH__REQ_chan__nr_defval;
extern const GSM__Types::RslLinkId_template& ts__L1CTL__RACH__REQ_link__id_defval;
extern GSM__Types::RslLinkId_template template_ts__L1CTL__RACH__REQ_link__id_defval;
extern const L1ctlMessage_template& tr__L1CTL__RACH__CONF;
extern L1ctlMessage_template template_tr__L1CTL__RACH__CONF;
extern const INTEGER_template& ts__L1CTL__DATA__IND_fn_defval;
extern INTEGER_template template_ts__L1CTL__DATA__IND_fn_defval;
extern const INTEGER_template& ts__L1CTL__DATA__IND_rx__level_defval;
extern INTEGER_template template_ts__L1CTL__DATA__IND_rx__level_defval;
extern const INTEGER_template& ts__L1CTL__DATA__IND_num__biterr_defval;
extern INTEGER_template template_ts__L1CTL__DATA__IND_num__biterr_defval;
extern const INTEGER_template& ts__L1CTL__DATA__IND_fire__crc_defval;
extern INTEGER_template template_ts__L1CTL__DATA__IND_fire__crc_defval;
extern const GSM__Types::RslLinkId_template& tr__L1CTL__DATA__IND_link__id_defval;
extern GSM__Types::RslLinkId_template template_tr__L1CTL__DATA__IND_link__id_defval;
extern const OCTETSTRING_template& tr__L1CTL__DATA__IND_l2__data_defval;
extern OCTETSTRING_template template_tr__L1CTL__DATA__IND_l2__data_defval;
extern const INTEGER_template& tr__L1CTL__DATA__IND_num__biterr_defval;
extern INTEGER_template template_tr__L1CTL__DATA__IND_num__biterr_defval;
extern const INTEGER_template& tr__L1CTL__DATA__IND_fire__crc_defval;
extern INTEGER_template template_tr__L1CTL__DATA__IND_fire__crc_defval;
extern const GSM__Types::RslLinkId_template& tr__L1CTL__DATA__CONF_link__id_defval;
extern GSM__Types::RslLinkId_template template_tr__L1CTL__DATA__CONF_link__id_defval;
extern const GSM__Types::GsmBandArfcn_template& tr__L1CTL__DATA__CONF_arfcn_defval;
extern GSM__Types::GsmBandArfcn_template template_tr__L1CTL__DATA__CONF_arfcn_defval;
extern const INTEGER_template& tr__L1CTL__DATA__CONF_fn_defval;
extern INTEGER_template template_tr__L1CTL__DATA__CONF_fn_defval;
extern const GSM__Types::RslLinkId_template& tr__L1CTL__TRAFFIC__CONF_link__id_defval;
extern GSM__Types::RslLinkId_template template_tr__L1CTL__TRAFFIC__CONF_link__id_defval;
extern const GSM__Types::GsmBandArfcn_template& tr__L1CTL__TRAFFIC__CONF_arfcn_defval;
extern GSM__Types::GsmBandArfcn_template template_tr__L1CTL__TRAFFIC__CONF_arfcn_defval;
extern const INTEGER_template& tr__L1CTL__TRAFFIC__CONF_fn_defval;
extern INTEGER_template template_tr__L1CTL__TRAFFIC__CONF_fn_defval;
extern const GSM__Types::RslLinkId_template& tr__L1CTL__TRAFFIC__IND_link__id_defval;
extern GSM__Types::RslLinkId_template template_tr__L1CTL__TRAFFIC__IND_link__id_defval;
extern const OCTETSTRING_template& tr__L1CTL__TRAFFIC__IND_frame_defval;
extern OCTETSTRING_template template_tr__L1CTL__TRAFFIC__IND_frame_defval;
extern const INTEGER_template& tr__L1CTL__TRAFFIC__IND_num__biterr_defval;
extern INTEGER_template template_tr__L1CTL__TRAFFIC__IND_num__biterr_defval;
extern const INTEGER_template& tr__L1CTL__TRAFFIC__IND_fire__crc_defval;
extern INTEGER_template template_tr__L1CTL__TRAFFIC__IND_fire__crc_defval;
extern const BITSTRING_template& ts__L1CTL__GPRS__UL__TBF__CFG__REQ_slotmask_defval;
extern BITSTRING_template template_ts__L1CTL__GPRS__UL__TBF__CFG__REQ_slotmask_defval;
extern const INTEGER_template& ts__L1CTL__GPRS__UL__TBF__CFG__REQ_start__fn_defval;
extern INTEGER_template template_ts__L1CTL__GPRS__UL__TBF__CFG__REQ_start__fn_defval;
extern const INTEGER_template& tr__L1CTL__GPRS__UL__TBF__CFG__REQ_tbf__ref_defval;
extern INTEGER_template template_tr__L1CTL__GPRS__UL__TBF__CFG__REQ_tbf__ref_defval;
extern const BITSTRING_template& tr__L1CTL__GPRS__UL__TBF__CFG__REQ_slotmask_defval;
extern BITSTRING_template template_tr__L1CTL__GPRS__UL__TBF__CFG__REQ_slotmask_defval;
extern const INTEGER_template& tr__L1CTL__GPRS__UL__TBF__CFG__REQ_start__fn_defval;
extern INTEGER_template template_tr__L1CTL__GPRS__UL__TBF__CFG__REQ_start__fn_defval;
extern const BITSTRING_template& ts__L1CTL__GPRS__DL__TBF__CFG__REQ_slotmask_defval;
extern BITSTRING_template template_ts__L1CTL__GPRS__DL__TBF__CFG__REQ_slotmask_defval;
extern const INTEGER_template& ts__L1CTL__GPRS__DL__TBF__CFG__REQ_start__fn_defval;
extern INTEGER_template template_ts__L1CTL__GPRS__DL__TBF__CFG__REQ_start__fn_defval;
extern const INTEGER_template& ts__L1CTL__GPRS__DL__TBF__CFG__REQ_dl__tfi_defval;
extern INTEGER_template template_ts__L1CTL__GPRS__DL__TBF__CFG__REQ_dl__tfi_defval;
extern const INTEGER_template& tr__L1CTL__GPRS__DL__TBF__CFG__REQ_tbf__ref_defval;
extern INTEGER_template template_tr__L1CTL__GPRS__DL__TBF__CFG__REQ_tbf__ref_defval;
extern const BITSTRING_template& tr__L1CTL__GPRS__DL__TBF__CFG__REQ_slotmask_defval;
extern BITSTRING_template template_tr__L1CTL__GPRS__DL__TBF__CFG__REQ_slotmask_defval;
extern const INTEGER_template& tr__L1CTL__GPRS__DL__TBF__CFG__REQ_start__fn_defval;
extern INTEGER_template template_tr__L1CTL__GPRS__DL__TBF__CFG__REQ_start__fn_defval;
extern const INTEGER_template& tr__L1CTL__GPRS__DL__TBF__CFG__REQ_dl__tfi_defval;
extern INTEGER_template template_tr__L1CTL__GPRS__DL__TBF__CFG__REQ_dl__tfi_defval;
extern const INTEGER_template& tr__L1CTL__GPRS__UL__BLOCK__REQ_fn_defval;
extern INTEGER_template template_tr__L1CTL__GPRS__UL__BLOCK__REQ_fn_defval;
extern const INTEGER_template& tr__L1CTL__GPRS__UL__BLOCK__REQ_tn_defval;
extern INTEGER_template template_tr__L1CTL__GPRS__UL__BLOCK__REQ_tn_defval;
extern const OCTETSTRING_template& tr__L1CTL__GPRS__UL__BLOCK__REQ_data_defval;
extern OCTETSTRING_template template_tr__L1CTL__GPRS__UL__BLOCK__REQ_data_defval;
extern const INTEGER_template& ts__L1CTL__GPRS__DL__BLOCK__IND_ber10k_defval;
extern INTEGER_template template_ts__L1CTL__GPRS__DL__BLOCK__IND_ber10k_defval;
extern const INTEGER_template& ts__L1CTL__GPRS__DL__BLOCK__IND_ci__cb_defval;
extern INTEGER_template template_ts__L1CTL__GPRS__DL__BLOCK__IND_ci__cb_defval;
extern const INTEGER_template& ts__L1CTL__GPRS__DL__BLOCK__IND_rx__level_defval;
extern INTEGER_template template_ts__L1CTL__GPRS__DL__BLOCK__IND_rx__level_defval;
extern const INTEGER_template& tr__L1CTL__GPRS__DL__BLOCK__IND_fn_defval;
extern INTEGER_template template_tr__L1CTL__GPRS__DL__BLOCK__IND_fn_defval;
extern const INTEGER_template& tr__L1CTL__GPRS__DL__BLOCK__IND_tn_defval;
extern INTEGER_template template_tr__L1CTL__GPRS__DL__BLOCK__IND_tn_defval;
extern const INTEGER_template& tr__L1CTL__GPRS__DL__BLOCK__IND_usf_defval;
extern INTEGER_template template_tr__L1CTL__GPRS__DL__BLOCK__IND_usf_defval;
extern const OCTETSTRING_template& tr__L1CTL__GPRS__DL__BLOCK__IND_data_defval;
extern OCTETSTRING_template template_tr__L1CTL__GPRS__DL__BLOCK__IND_data_defval;
extern const INTEGER_template& tr__L1CTL__GPRS__DL__BLOCK__IND_ber10k_defval;
extern INTEGER_template template_tr__L1CTL__GPRS__DL__BLOCK__IND_ber10k_defval;
extern const INTEGER_template& tr__L1CTL__GPRS__DL__BLOCK__IND_ci__cb_defval;
extern INTEGER_template template_tr__L1CTL__GPRS__DL__BLOCK__IND_ci__cb_defval;
extern const INTEGER_template& tr__L1CTL__GPRS__DL__BLOCK__IND_rx__level_defval;
extern INTEGER_template template_tr__L1CTL__GPRS__DL__BLOCK__IND_rx__level_defval;
extern const OCTETSTRING& c__DummyUI;
extern OCTETSTRING const_c__DummyUI;
extern const BITSTRING bs_1,
bs_2,
bs_0,
bs_3;
extern const OCTETSTRING os_2,
os_3,
os_0,
os_1,
os_4;
extern const unsigned char module_checksum[];
extern TTCN_Module module_object;
extern const RuntimeVersionChecker ver_checker;

} /* end of namespace */

#endif
