// This C++ header file was generated by the TTCN-3 compiler
// of the TTCN-3 Test Executor version 9.0.0
// for  (build@3978f7fbee0c) on Mon Jun 24 02:37:33 2024

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

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

#ifndef GSM__Types_HH
#define GSM__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 "Osmocom_Types.hh"
#include "Misc_Helpers.hh"

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

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

#undef GSM__Types_HH
#endif

namespace GSM__Types {

/* Forward declarations of classes */

class GsmBandArfcn;
class GsmBandArfcn_template;
class PchanConfig;
class PchanConfig_template;
class GprsCodingScheme;
class GprsCodingScheme_template;
class ChannelNeeded;
class ChannelNeeded_template;
class ChannelNeeded12;
class ChannelNeeded12_template;
class RslChanNr0;
class RslChanNr0_template;
class RslChanNr2;
class RslChanNr2_template;
class RslChanNr4;
class RslChanNr4_template;
class RslChanNr8;
class RslChanNr8_template;
class RslChanNrU;
class RslChanNrU_template;
class RslChannelNr;
class RslChannelNr_template;
class RslLinkIdC;
class RslLinkIdC_template;
class RslSapi0Prio;
class RslSapi0Prio_template;
class RslLinkId;
class RslLinkId_template;
class CBCH__BlockType;
class CBCH__BlockType_template;
class CBCH__Block;
class CBCH__Block_template;
class LocationAreaIdentification;
class LocationAreaIdentification_template;
class RoutingAreaIdentification;
class RoutingAreaIdentification_template;

} /* end of namespace */

#ifndef GSM__Types_HH
#define GSM__Types_HH

namespace GSM__Types {

/* Type definitions */

typedef INTEGER GsmArfcn;
typedef INTEGER_template GsmArfcn_template;
typedef INTEGER UmtsArfcn;
typedef INTEGER_template UmtsArfcn_template;
typedef INTEGER UmtsScramblingCode;
typedef INTEGER_template UmtsScramblingCode_template;
typedef INTEGER GsmFrameNumber;
typedef INTEGER_template GsmFrameNumber_template;
typedef INTEGER GsmRxLev;
typedef INTEGER_template GsmRxLev_template;
typedef INTEGER GsmTsc;
typedef INTEGER_template GsmTsc_template;
typedef INTEGER GsmTmsi;
typedef INTEGER_template GsmTmsi_template;
typedef OCTETSTRING GprsTlli;
typedef OCTETSTRING_template GprsTlli_template;
typedef HEXSTRING GsmMcc;
typedef HEXSTRING_template GsmMcc_template;
typedef HEXSTRING GsmMnc;
typedef HEXSTRING_template GsmMnc_template;
typedef INTEGER GsmLac;
typedef INTEGER_template GsmLac_template;
typedef INTEGER GsmCellId;
typedef INTEGER_template GsmCellId_template;
typedef OCTETSTRING GroupCallRef;
typedef OCTETSTRING_template GroupCallRef_template;
typedef INTEGER GsmSapi;
typedef INTEGER_template GsmSapi_template;
typedef HEXSTRING GsmBcdString;
typedef HEXSTRING_template GsmBcdString_template;
typedef HEXSTRING BcdMccMnc;
typedef HEXSTRING_template BcdMccMnc_template;
typedef INTEGER CellIdentity;
typedef INTEGER_template CellIdentity_template;

/* Class definitions */

class GsmBandArfcn : public Base_Type {
  BOOLEAN field_pcs;
  BOOLEAN field_uplink;
  BITSTRING field_spare;
  INTEGER field_arfcn;
public:
  GsmBandArfcn();
  GsmBandArfcn(const BOOLEAN& par_pcs,
    const BOOLEAN& par_uplink,
    const BITSTRING& par_spare,
    const INTEGER& par_arfcn);
  GsmBandArfcn(const GsmBandArfcn& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  GsmBandArfcn& operator=(const GsmBandArfcn& other_value);
  boolean operator==(const GsmBandArfcn& other_value) const;
  inline boolean operator!=(const GsmBandArfcn& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BOOLEAN& pcs()
    {return field_pcs;}
  inline const BOOLEAN& pcs() const
    {return field_pcs;}
  inline BOOLEAN& uplink()
    {return field_uplink;}
  inline const BOOLEAN& uplink() const
    {return field_uplink;}
  inline BITSTRING& spare()
    {return field_spare;}
  inline const BITSTRING& spare() const
    {return field_spare;}
  inline INTEGER& arfcn()
    {return field_arfcn;}
  inline const INTEGER& arfcn() const
    {return field_arfcn;}
  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 GsmBandArfcn_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
GsmBandArfcn_template *list_value;
} value_list;
struct {
GsmBandArfcn_template* precondition;
GsmBandArfcn_template* implied_template;
} implication_;
dynmatch_struct<GsmBandArfcn>* dyn_match;
};

void set_specific();
void copy_value(const GsmBandArfcn& other_value);
void copy_template(const GsmBandArfcn_template& other_value);

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

class PchanConfig : public Base_Type { // enum
friend class PchanConfig_template;
public:
enum enum_type { GSM__PCHAN__NONE = 0, GSM__PCHAN__CCCH = 1, GSM__PCHAN__CCCH__SDCCH4 = 2, GSM__PCHAN__CCCH__SDCCH4__CBCH = 3, GSM__PCHAN__SDCCH8 = 4, GSM__PCHAN__SDCCH8__CBCH = 5, GSM__PCHAN__TCHF = 6, GSM__PCHAN__TCHH = 7, GSM__PCHAN__PDCH = 8, GSM__PCHAN__TCHF__PDCH = 9, GSM__PCHAN__TCHH__TCHF__PDCH = 10, UNKNOWN_VALUE = 11, UNBOUND_VALUE = 12 };
private:
enum_type enum_value;

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

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

boolean operator==(enum_type other_value) const;
boolean operator==(const PchanConfig& other_value) const;
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const PchanConfig& other_value) const { return !(*this == other_value); }
boolean operator<(enum_type other_value) const;
boolean operator<(const PchanConfig& other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const PchanConfig& other_value) const;
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const PchanConfig& other_value) const { return !(*this > other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const PchanConfig& 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);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const PchanConfig& 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 PchanConfig_template : public Base_Template {
union {
PchanConfig::enum_type single_value;
struct {
unsigned int n_values;
PchanConfig_template *list_value;
} value_list;
struct {
PchanConfig_template* precondition;
PchanConfig_template* implied_template;
} implication_;
dynmatch_struct<PchanConfig>* dyn_match;
};

void copy_template(const PchanConfig_template& other_value);

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

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

boolean match(PchanConfig::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const PchanConfig& other_value, boolean legacy = FALSE) const;
PchanConfig::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
PchanConfig_template& list_item(unsigned int list_index);
void log() const;
void log_match(const PchanConfig& 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 GprsCodingScheme : public Base_Type { // enum
friend class GprsCodingScheme_template;
public:
enum enum_type { CS1 = 0, CS2 = 1, CS3 = 2, CS4 = 3, UNKNOWN_VALUE = 4, UNBOUND_VALUE = 5 };
private:
enum_type enum_value;

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

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

boolean operator==(enum_type other_value) const;
boolean operator==(const GprsCodingScheme& other_value) const;
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const GprsCodingScheme& other_value) const { return !(*this == other_value); }
boolean operator<(enum_type other_value) const;
boolean operator<(const GprsCodingScheme& other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const GprsCodingScheme& other_value) const;
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const GprsCodingScheme& other_value) const { return !(*this > other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const GprsCodingScheme& 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);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const GprsCodingScheme& 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 GprsCodingScheme_template : public Base_Template {
union {
GprsCodingScheme::enum_type single_value;
struct {
unsigned int n_values;
GprsCodingScheme_template *list_value;
} value_list;
struct {
GprsCodingScheme_template* precondition;
GprsCodingScheme_template* implied_template;
} implication_;
dynmatch_struct<GprsCodingScheme>* dyn_match;
};

void copy_template(const GprsCodingScheme_template& other_value);

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

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

boolean match(GprsCodingScheme::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const GprsCodingScheme& other_value, boolean legacy = FALSE) const;
GprsCodingScheme::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
GprsCodingScheme_template& list_item(unsigned int list_index);
void log() const;
void log_match(const GprsCodingScheme& 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 ChannelNeeded : public Base_Type { // enum
friend class ChannelNeeded_template;
public:
enum enum_type { CHAN__NEED__ANY = 0, CHAN__NEED__SDCCH = 1, CHAN__NEED__TCH__F = 2, CHAN__NEED__TCH__H = 3, UNKNOWN_VALUE = 4, UNBOUND_VALUE = 5 };
private:
enum_type enum_value;

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

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

boolean operator==(enum_type other_value) const;
boolean operator==(const ChannelNeeded& other_value) const;
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const ChannelNeeded& other_value) const { return !(*this == other_value); }
boolean operator<(enum_type other_value) const;
boolean operator<(const ChannelNeeded& other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const ChannelNeeded& other_value) const;
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const ChannelNeeded& other_value) const { return !(*this > other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const ChannelNeeded& 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);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const ChannelNeeded& 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 ChannelNeeded_template : public Base_Template {
union {
ChannelNeeded::enum_type single_value;
struct {
unsigned int n_values;
ChannelNeeded_template *list_value;
} value_list;
struct {
ChannelNeeded_template* precondition;
ChannelNeeded_template* implied_template;
} implication_;
dynmatch_struct<ChannelNeeded>* dyn_match;
};

void copy_template(const ChannelNeeded_template& other_value);

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

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

boolean match(ChannelNeeded::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const ChannelNeeded& other_value, boolean legacy = FALSE) const;
ChannelNeeded::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
ChannelNeeded_template& list_item(unsigned int list_index);
void log() const;
void log_match(const ChannelNeeded& 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 ChannelNeeded12 : public Base_Type {
  ChannelNeeded field_second;
  ChannelNeeded field_first;
public:
  ChannelNeeded12();
  ChannelNeeded12(const ChannelNeeded& par_second,
    const ChannelNeeded& par_first);
  ChannelNeeded12(const ChannelNeeded12& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  ChannelNeeded12& operator=(const ChannelNeeded12& other_value);
  boolean operator==(const ChannelNeeded12& other_value) const;
  inline boolean operator!=(const ChannelNeeded12& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline ChannelNeeded& second()
    {return field_second;}
  inline const ChannelNeeded& second() const
    {return field_second;}
  inline ChannelNeeded& first()
    {return field_first;}
  inline const ChannelNeeded& first() const
    {return field_first;}
  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 ChannelNeeded12_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
ChannelNeeded12_template *list_value;
} value_list;
struct {
ChannelNeeded12_template* precondition;
ChannelNeeded12_template* implied_template;
} implication_;
dynmatch_struct<ChannelNeeded12>* dyn_match;
};

void set_specific();
void copy_value(const ChannelNeeded12& other_value);
void copy_template(const ChannelNeeded12_template& other_value);

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

class RslChanNr0 : public Base_Type { // enum
friend class RslChanNr0_template;
public:
enum enum_type { RSL__CHAN__NR__INVALID = 0, RSL__CHAN__NR__Bm__ACCH = 1, RSL__CHAN__NR__BCCH = 16, RSL__CHAN__NR__RACH = 17, RSL__CHAN__NR__PCH__AGCH = 18, RSL__CHAN__NR__OSMO__PDCH = 24, RSL__CHAN__NR__OSMO__CBCH4 = 25, RSL__CHAN__NR__OSMO__CBCH8 = 26, RSL__CHAN__NR__OSMO__VAMOS__Bm__ACCH = 29, UNKNOWN_VALUE = 2, UNBOUND_VALUE = 3 };
private:
enum_type enum_value;

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

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

boolean operator==(enum_type other_value) const;
boolean operator==(const RslChanNr0& other_value) const;
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const RslChanNr0& other_value) const { return !(*this == other_value); }
boolean operator<(enum_type other_value) const;
boolean operator<(const RslChanNr0& other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const RslChanNr0& other_value) const;
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const RslChanNr0& other_value) const { return !(*this > other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const RslChanNr0& 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);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const RslChanNr0& 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 RslChanNr0_template : public Base_Template {
union {
RslChanNr0::enum_type single_value;
struct {
unsigned int n_values;
RslChanNr0_template *list_value;
} value_list;
struct {
RslChanNr0_template* precondition;
RslChanNr0_template* implied_template;
} implication_;
dynmatch_struct<RslChanNr0>* dyn_match;
};

void copy_template(const RslChanNr0_template& other_value);

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

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

boolean match(RslChanNr0::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const RslChanNr0& other_value, boolean legacy = FALSE) const;
RslChanNr0::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RslChanNr0_template& list_item(unsigned int list_index);
void log() const;
void log_match(const RslChanNr0& 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 RslChanNr2 : public Base_Type {
  BITSTRING field_tag;
  INTEGER field_sub__chan;
public:
  RslChanNr2();
  RslChanNr2(const BITSTRING& par_tag,
    const INTEGER& par_sub__chan);
  RslChanNr2(const RslChanNr2& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RslChanNr2& operator=(const RslChanNr2& other_value);
  boolean operator==(const RslChanNr2& other_value) const;
  inline boolean operator!=(const RslChanNr2& 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& tag()
    {return field_tag;}
  inline const BITSTRING& tag() const
    {return field_tag;}
  inline INTEGER& sub__chan()
    {return field_sub__chan;}
  inline const INTEGER& sub__chan() const
    {return field_sub__chan;}
  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 RslChanNr2_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RslChanNr2_template *list_value;
} value_list;
struct {
RslChanNr2_template* precondition;
RslChanNr2_template* implied_template;
} implication_;
dynmatch_struct<RslChanNr2>* dyn_match;
};

void set_specific();
void copy_value(const RslChanNr2& other_value);
void copy_template(const RslChanNr2_template& other_value);

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

class RslChanNr4 : public Base_Type {
  BITSTRING field_tag;
  INTEGER field_sub__chan;
public:
  RslChanNr4();
  RslChanNr4(const BITSTRING& par_tag,
    const INTEGER& par_sub__chan);
  RslChanNr4(const RslChanNr4& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RslChanNr4& operator=(const RslChanNr4& other_value);
  boolean operator==(const RslChanNr4& other_value) const;
  inline boolean operator!=(const RslChanNr4& 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& tag()
    {return field_tag;}
  inline const BITSTRING& tag() const
    {return field_tag;}
  inline INTEGER& sub__chan()
    {return field_sub__chan;}
  inline const INTEGER& sub__chan() const
    {return field_sub__chan;}
  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 RslChanNr4_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RslChanNr4_template *list_value;
} value_list;
struct {
RslChanNr4_template* precondition;
RslChanNr4_template* implied_template;
} implication_;
dynmatch_struct<RslChanNr4>* dyn_match;
};

void set_specific();
void copy_value(const RslChanNr4& other_value);
void copy_template(const RslChanNr4_template& other_value);

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

class RslChanNr8 : public Base_Type {
  BITSTRING field_tag;
  INTEGER field_sub__chan;
public:
  RslChanNr8();
  RslChanNr8(const BITSTRING& par_tag,
    const INTEGER& par_sub__chan);
  RslChanNr8(const RslChanNr8& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RslChanNr8& operator=(const RslChanNr8& other_value);
  boolean operator==(const RslChanNr8& other_value) const;
  inline boolean operator!=(const RslChanNr8& 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& tag()
    {return field_tag;}
  inline const BITSTRING& tag() const
    {return field_tag;}
  inline INTEGER& sub__chan()
    {return field_sub__chan;}
  inline const INTEGER& sub__chan() const
    {return field_sub__chan;}
  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 RslChanNr8_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RslChanNr8_template *list_value;
} value_list;
struct {
RslChanNr8_template* precondition;
RslChanNr8_template* implied_template;
} implication_;
dynmatch_struct<RslChanNr8>* dyn_match;
};

void set_specific();
void copy_value(const RslChanNr8& other_value);
void copy_template(const RslChanNr8_template& other_value);

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

class RslChanNrU : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_ch0 = 1, ALT_lm = 2, ALT_sdcch4 = 3, ALT_sdcch8 = 4 };
private:
union_selection_type union_selection;
union {
RslChanNr0 *field_ch0;
RslChanNr2 *field_lm;
RslChanNr4 *field_sdcch4;
RslChanNr8 *field_sdcch8;
};
void copy_value(const RslChanNrU& other_value);

public:
RslChanNrU();
RslChanNrU(const RslChanNrU& other_value);
~RslChanNrU();
RslChanNrU& operator=(const RslChanNrU& other_value);
boolean operator==(const RslChanNrU& other_value) const;
inline boolean operator!=(const RslChanNrU& other_value) const { return !(*this == other_value); }
RslChanNr0& ch0();
const RslChanNr0& ch0() const;
RslChanNr2& lm();
const RslChanNr2& lm() const;
RslChanNr4& sdcch4();
const RslChanNr4& sdcch4() const;
RslChanNr8& sdcch8();
const RslChanNr8& sdcch8() 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 RslChanNrU_template : public Base_Template {
union {
struct {
RslChanNrU::union_selection_type union_selection;
union {
RslChanNr0_template *field_ch0;
RslChanNr2_template *field_lm;
RslChanNr4_template *field_sdcch4;
RslChanNr8_template *field_sdcch8;
};
} single_value;
struct {
unsigned int n_values;
RslChanNrU_template *list_value;
} value_list;
struct {
RslChanNrU_template* precondition;
RslChanNrU_template* implied_template;
} implication_;
dynmatch_struct<RslChanNrU>* dyn_match;
};
void copy_value(const RslChanNrU& other_value);

void copy_template(const RslChanNrU_template& other_value);

public:
RslChanNrU_template();
RslChanNrU_template(template_sel other_value);
RslChanNrU_template(const RslChanNrU& other_value);
RslChanNrU_template(const OPTIONAL<RslChanNrU>& other_value);
RslChanNrU_template(RslChanNrU_template* p_precondition, RslChanNrU_template* p_implied_template);
RslChanNrU_template(Dynamic_Match_Interface<RslChanNrU>* p_dyn_match);
RslChanNrU_template(const RslChanNrU_template& other_value);
~RslChanNrU_template();
void clean_up();
RslChanNrU_template& operator=(template_sel other_value);
RslChanNrU_template& operator=(const RslChanNrU& other_value);
RslChanNrU_template& operator=(const OPTIONAL<RslChanNrU>& other_value);
RslChanNrU_template& operator=(const RslChanNrU_template& other_value);
boolean match(const RslChanNrU& other_value, boolean legacy = FALSE) const;
boolean is_value() const;RslChanNrU valueof() const;
RslChanNrU_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
RslChanNr0_template& ch0();
const RslChanNr0_template& ch0() const;
RslChanNr2_template& lm();
const RslChanNr2_template& lm() const;
RslChanNr4_template& sdcch4();
const RslChanNr4_template& sdcch4() const;
RslChanNr8_template& sdcch8();
const RslChanNr8_template& sdcch8() const;
boolean ischosen(RslChanNrU::union_selection_type checked_selection) const;
void log() const;
void log_match(const RslChanNrU& 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 RslChannelNr : public Base_Type {
  RslChanNrU field_u;
  INTEGER field_tn;
public:
  RslChannelNr();
  RslChannelNr(const RslChanNrU& par_u,
    const INTEGER& par_tn);
  RslChannelNr(const RslChannelNr& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RslChannelNr& operator=(const RslChannelNr& other_value);
  boolean operator==(const RslChannelNr& other_value) const;
  inline boolean operator!=(const RslChannelNr& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline RslChanNrU& u()
    {return field_u;}
  inline const RslChanNrU& u() const
    {return field_u;}
  inline INTEGER& tn()
    {return field_tn;}
  inline const INTEGER& tn() const
    {return field_tn;}
  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 RslChannelNr_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RslChannelNr_template *list_value;
} value_list;
struct {
RslChannelNr_template* precondition;
RslChannelNr_template* implied_template;
} implication_;
dynmatch_struct<RslChannelNr>* dyn_match;
};

void set_specific();
void copy_value(const RslChannelNr& other_value);
void copy_template(const RslChannelNr_template& other_value);

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

class RslLinkIdC : public Base_Type { // enum
friend class RslLinkIdC_template;
public:
enum enum_type { FACCH__SDCCH = 0, SACCH = 1, OSMO__PTCCH = 2, UNKNOWN_VALUE = 3, UNBOUND_VALUE = 4 };
private:
enum_type enum_value;

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

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

boolean operator==(enum_type other_value) const;
boolean operator==(const RslLinkIdC& other_value) const;
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const RslLinkIdC& other_value) const { return !(*this == other_value); }
boolean operator<(enum_type other_value) const;
boolean operator<(const RslLinkIdC& other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const RslLinkIdC& other_value) const;
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const RslLinkIdC& other_value) const { return !(*this > other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const RslLinkIdC& 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);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const RslLinkIdC& 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 RslLinkIdC_template : public Base_Template {
union {
RslLinkIdC::enum_type single_value;
struct {
unsigned int n_values;
RslLinkIdC_template *list_value;
} value_list;
struct {
RslLinkIdC_template* precondition;
RslLinkIdC_template* implied_template;
} implication_;
dynmatch_struct<RslLinkIdC>* dyn_match;
};

void copy_template(const RslLinkIdC_template& other_value);

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

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

boolean match(RslLinkIdC::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const RslLinkIdC& other_value, boolean legacy = FALSE) const;
RslLinkIdC::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RslLinkIdC_template& list_item(unsigned int list_index);
void log() const;
void log_match(const RslLinkIdC& 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 RslSapi0Prio : public Base_Type { // enum
friend class RslSapi0Prio_template;
public:
enum enum_type { SAPI0__PRIO__NORMAL = 0, SAPI0__PRIO__HIGH = 1, SAPI0__PRIO__LOW = 2, UNKNOWN_VALUE = 3, UNBOUND_VALUE = 4 };
private:
enum_type enum_value;

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

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

boolean operator==(enum_type other_value) const;
boolean operator==(const RslSapi0Prio& other_value) const;
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const RslSapi0Prio& other_value) const { return !(*this == other_value); }
boolean operator<(enum_type other_value) const;
boolean operator<(const RslSapi0Prio& other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const RslSapi0Prio& other_value) const;
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const RslSapi0Prio& other_value) const { return !(*this > other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const RslSapi0Prio& 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);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const RslSapi0Prio& 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 RslSapi0Prio_template : public Base_Template {
union {
RslSapi0Prio::enum_type single_value;
struct {
unsigned int n_values;
RslSapi0Prio_template *list_value;
} value_list;
struct {
RslSapi0Prio_template* precondition;
RslSapi0Prio_template* implied_template;
} implication_;
dynmatch_struct<RslSapi0Prio>* dyn_match;
};

void copy_template(const RslSapi0Prio_template& other_value);

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

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

boolean match(RslSapi0Prio::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const RslSapi0Prio& other_value, boolean legacy = FALSE) const;
RslSapi0Prio::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RslSapi0Prio_template& list_item(unsigned int list_index);
void log() const;
void log_match(const RslSapi0Prio& 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 RslLinkId : public Base_Type {
  RslLinkIdC field_c;
  BOOLEAN field_na;
  RslSapi0Prio field_prio;
  INTEGER field_sapi;
public:
  RslLinkId();
  RslLinkId(const RslLinkIdC& par_c,
    const BOOLEAN& par_na,
    const RslSapi0Prio& par_prio,
    const INTEGER& par_sapi);
  RslLinkId(const RslLinkId& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RslLinkId& operator=(const RslLinkId& other_value);
  boolean operator==(const RslLinkId& other_value) const;
  inline boolean operator!=(const RslLinkId& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline RslLinkIdC& c()
    {return field_c;}
  inline const RslLinkIdC& c() const
    {return field_c;}
  inline BOOLEAN& na()
    {return field_na;}
  inline const BOOLEAN& na() const
    {return field_na;}
  inline RslSapi0Prio& prio()
    {return field_prio;}
  inline const RslSapi0Prio& prio() const
    {return field_prio;}
  inline INTEGER& sapi()
    {return field_sapi;}
  inline const INTEGER& sapi() const
    {return field_sapi;}
  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 RslLinkId_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RslLinkId_template *list_value;
} value_list;
struct {
RslLinkId_template* precondition;
RslLinkId_template* implied_template;
} implication_;
dynmatch_struct<RslLinkId>* dyn_match;
};

void set_specific();
void copy_value(const RslLinkId& other_value);
void copy_template(const RslLinkId_template& other_value);

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

class CBCH__BlockType : public Base_Type {
  BITSTRING field_spare;
  BITSTRING field_lpd;
  BOOLEAN field_last__block;
  INTEGER field_seq__nr;
public:
  CBCH__BlockType();
  CBCH__BlockType(const BITSTRING& par_spare,
    const BITSTRING& par_lpd,
    const BOOLEAN& par_last__block,
    const INTEGER& par_seq__nr);
  CBCH__BlockType(const CBCH__BlockType& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  CBCH__BlockType& operator=(const CBCH__BlockType& other_value);
  boolean operator==(const CBCH__BlockType& other_value) const;
  inline boolean operator!=(const CBCH__BlockType& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BITSTRING& spare()
    {return field_spare;}
  inline const BITSTRING& spare() const
    {return field_spare;}
  inline BITSTRING& lpd()
    {return field_lpd;}
  inline const BITSTRING& lpd() const
    {return field_lpd;}
  inline BOOLEAN& last__block()
    {return field_last__block;}
  inline const BOOLEAN& last__block() const
    {return field_last__block;}
  inline INTEGER& seq__nr()
    {return field_seq__nr;}
  inline const INTEGER& seq__nr() const
    {return field_seq__nr;}
  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 CBCH__BlockType_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
CBCH__BlockType_template *list_value;
} value_list;
struct {
CBCH__BlockType_template* precondition;
CBCH__BlockType_template* implied_template;
} implication_;
dynmatch_struct<CBCH__BlockType>* dyn_match;
};

void set_specific();
void copy_value(const CBCH__BlockType& other_value);
void copy_template(const CBCH__BlockType_template& other_value);

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

class CBCH__Block : public Base_Type {
  CBCH__BlockType field_block__type;
  OCTETSTRING field_payload;
public:
  CBCH__Block();
  CBCH__Block(const CBCH__BlockType& par_block__type,
    const OCTETSTRING& par_payload);
  CBCH__Block(const CBCH__Block& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  CBCH__Block& operator=(const CBCH__Block& other_value);
  boolean operator==(const CBCH__Block& other_value) const;
  inline boolean operator!=(const CBCH__Block& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

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

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

void set_specific();
void copy_value(const CBCH__Block& other_value);
void copy_template(const CBCH__Block_template& other_value);

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

class LocationAreaIdentification : public Base_Type {
  HEXSTRING field_mcc__mnc;
  INTEGER field_lac;
public:
  LocationAreaIdentification();
  LocationAreaIdentification(const HEXSTRING& par_mcc__mnc,
    const INTEGER& par_lac);
  LocationAreaIdentification(const LocationAreaIdentification& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  LocationAreaIdentification& operator=(const LocationAreaIdentification& other_value);
  boolean operator==(const LocationAreaIdentification& other_value) const;
  inline boolean operator!=(const LocationAreaIdentification& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline HEXSTRING& mcc__mnc()
    {return field_mcc__mnc;}
  inline const HEXSTRING& mcc__mnc() const
    {return field_mcc__mnc;}
  inline INTEGER& lac()
    {return field_lac;}
  inline const INTEGER& lac() const
    {return field_lac;}
  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 LocationAreaIdentification_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
LocationAreaIdentification_template *list_value;
} value_list;
struct {
LocationAreaIdentification_template* precondition;
LocationAreaIdentification_template* implied_template;
} implication_;
dynmatch_struct<LocationAreaIdentification>* dyn_match;
};

void set_specific();
void copy_value(const LocationAreaIdentification& other_value);
void copy_template(const LocationAreaIdentification_template& other_value);

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

class RoutingAreaIdentification : public Base_Type {
  LocationAreaIdentification field_lai;
  INTEGER field_rac;
public:
  RoutingAreaIdentification();
  RoutingAreaIdentification(const LocationAreaIdentification& par_lai,
    const INTEGER& par_rac);
  RoutingAreaIdentification(const RoutingAreaIdentification& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RoutingAreaIdentification& operator=(const RoutingAreaIdentification& other_value);
  boolean operator==(const RoutingAreaIdentification& other_value) const;
  inline boolean operator!=(const RoutingAreaIdentification& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline LocationAreaIdentification& lai()
    {return field_lai;}
  inline const LocationAreaIdentification& lai() const
    {return field_lai;}
  inline INTEGER& rac()
    {return field_rac;}
  inline const INTEGER& rac() const
    {return field_rac;}
  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 RoutingAreaIdentification_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RoutingAreaIdentification_template *list_value;
} value_list;
struct {
RoutingAreaIdentification_template* precondition;
RoutingAreaIdentification_template* implied_template;
} implication_;
dynmatch_struct<RoutingAreaIdentification>* dyn_match;
};

void set_specific();
void copy_value(const RoutingAreaIdentification& other_value);
void copy_template(const RoutingAreaIdentification_template& other_value);

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


/* Function prototypes */

extern void GsmArfcn_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER GsmArfcn_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void UmtsArfcn_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER UmtsArfcn_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void UmtsScramblingCode_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER UmtsScramblingCode_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void GsmFrameNumber_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER GsmFrameNumber_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void GsmRxLev_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER GsmRxLev_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void GsmTsc_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER GsmTsc_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void GsmTmsi_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER GsmTmsi_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void GprsTlli_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER GprsTlli_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void GsmMcc_encoder(const HEXSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER GsmMcc_decoder(OCTETSTRING& input_stream, HEXSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void GsmMnc_encoder(const HEXSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER GsmMnc_decoder(OCTETSTRING& input_stream, HEXSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void GsmLac_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER GsmLac_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void GsmCellId_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER GsmCellId_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void GroupCallRef_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER GroupCallRef_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void GsmBandArfcn_pcs_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER GsmBandArfcn_pcs_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void GsmBandArfcn_uplink_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER GsmBandArfcn_uplink_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void GsmBandArfcn_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER GsmBandArfcn_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void GsmBandArfcn_arfcn_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER GsmBandArfcn_arfcn_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void GsmBandArfcn_encoder(const GsmBandArfcn& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER GsmBandArfcn_decoder(OCTETSTRING& input_stream, GsmBandArfcn& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern GsmBandArfcn_template ts__GsmBandArfcn(const INTEGER_template& arfcn, const BOOLEAN_template& pcs, const BOOLEAN_template& uplink);
extern GsmBandArfcn_template tr__GsmBandArfcn(const INTEGER_template& arfcn, const BOOLEAN_template& pcs, const BOOLEAN_template& uplink);
extern void PchanConfig_encoder(const PchanConfig& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PchanConfig_decoder(OCTETSTRING& input_stream, PchanConfig& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void GprsCodingScheme_encoder(const GprsCodingScheme& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER GprsCodingScheme_decoder(OCTETSTRING& input_stream, GprsCodingScheme& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER f__gprs__blocksize(const GprsCodingScheme& cs);
extern OCTETSTRING f__gen__tlli();
extern void ChannelNeeded_encoder(const ChannelNeeded& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER ChannelNeeded_decoder(OCTETSTRING& input_stream, ChannelNeeded& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void ChannelNeeded12_second_encoder(const ChannelNeeded& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER ChannelNeeded12_second_decoder(OCTETSTRING& input_stream, ChannelNeeded& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void ChannelNeeded12_first_encoder(const ChannelNeeded& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER ChannelNeeded12_first_decoder(OCTETSTRING& input_stream, ChannelNeeded& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void ChannelNeeded12_encoder(const ChannelNeeded12& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER ChannelNeeded12_decoder(OCTETSTRING& input_stream, ChannelNeeded12& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslChanNr0_encoder(const RslChanNr0& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslChanNr0_decoder(OCTETSTRING& input_stream, RslChanNr0& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslChanNr2_tag_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslChanNr2_tag_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslChanNr2_sub__chan_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslChanNr2_sub__chan_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslChanNr2_encoder(const RslChanNr2& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslChanNr2_decoder(OCTETSTRING& input_stream, RslChanNr2& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslChanNr4_tag_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslChanNr4_tag_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslChanNr4_sub__chan_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslChanNr4_sub__chan_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslChanNr4_encoder(const RslChanNr4& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslChanNr4_decoder(OCTETSTRING& input_stream, RslChanNr4& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslChanNr8_tag_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslChanNr8_tag_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslChanNr8_sub__chan_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslChanNr8_sub__chan_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslChanNr8_encoder(const RslChanNr8& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslChanNr8_decoder(OCTETSTRING& input_stream, RslChanNr8& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslChanNrU_ch0_encoder(const RslChanNr0& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslChanNrU_ch0_decoder(OCTETSTRING& input_stream, RslChanNr0& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslChanNrU_lm_encoder(const RslChanNr2& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslChanNrU_lm_decoder(OCTETSTRING& input_stream, RslChanNr2& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslChanNrU_sdcch4_encoder(const RslChanNr4& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslChanNrU_sdcch4_decoder(OCTETSTRING& input_stream, RslChanNr4& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslChanNrU_sdcch8_encoder(const RslChanNr8& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslChanNrU_sdcch8_decoder(OCTETSTRING& input_stream, RslChanNr8& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslChanNrU_encoder(const RslChanNrU& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslChanNrU_decoder(OCTETSTRING& input_stream, RslChanNrU& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslChannelNr_u_encoder(const RslChanNrU& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslChannelNr_u_decoder(OCTETSTRING& input_stream, RslChanNrU& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslChannelNr_tn_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslChannelNr_tn_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslChannelNr_encoder(const RslChannelNr& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslChannelNr_decoder(OCTETSTRING& input_stream, RslChannelNr& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern RslChannelNr_template t__RslChanNr0(const INTEGER_template& tn, const RslChanNr0_template& cht);
extern RslChannelNr_template t__RslChanNr__RACH(const INTEGER_template& tn);
extern RslChannelNr_template t__RslChanNr__BCCH(const INTEGER_template& tn);
extern RslChannelNr_template t__RslChanNr__PCH__AGCH(const INTEGER_template& tn);
extern RslChannelNr_template t__RslChanNr__Bm(const INTEGER_template& tn);
extern RslChannelNr_template t__RslChanNr__PDCH(const INTEGER_template& tn);
extern RslChannelNr_template t__RslChanNr__CBCH4(const INTEGER_template& tn);
extern RslChannelNr_template t__RslChanNr__CBCH8(const INTEGER_template& tn);
extern RslChannelNr_template t__RslChanNr__Lm(const INTEGER_template& tn, const INTEGER_template& sub__slot);
extern RslChannelNr_template t__RslChanNr__SDCCH4(const INTEGER_template& tn, const INTEGER_template& sub__slot);
extern RslChannelNr_template t__RslChanNr__SDCCH8(const INTEGER_template& tn, const INTEGER_template& sub__slot);
extern RslChannelNr_template t__RslChanNr__Osmo__VAMOS__Bm(const INTEGER_template& tn);
extern RslChannelNr_template t__RslChanNr__Osmo__VAMOS__Lm(const INTEGER_template& tn, const INTEGER_template& sub__slot);
extern RslChannelNr_template ts__RslChanNr0(const INTEGER& tn, const RslChanNr0& cht);
extern RslChannelNr_template ts__RslChanNr__RACH(const INTEGER& tn);
extern RslChannelNr_template ts__RslChanNr__BCCH(const INTEGER& tn);
extern RslChannelNr_template ts__RslChanNr__PCH__AGCH(const INTEGER& tn);
extern RslChannelNr_template ts__RslChanNr__Bm(const INTEGER& tn);
extern RslChannelNr_template ts__RslChanNr__PDCH(const INTEGER& tn);
extern RslChannelNr_template ts__RslChanNr__CBCH4(const INTEGER& tn);
extern RslChannelNr_template ts__RslChanNr__CBCH8(const INTEGER& tn);
extern RslChannelNr_template ts__RslChanNr__Lm(const INTEGER& tn, const INTEGER& sub__slot);
extern RslChannelNr_template ts__RslChanNr__SDCCH4(const INTEGER& tn, const INTEGER& sub__slot);
extern RslChannelNr_template ts__RslChanNr__SDCCH8(const INTEGER& tn, const INTEGER& sub__slot);
extern RslChannelNr_template ts__RslChanNr__Osmo__VAMOS__Bm(const INTEGER& tn);
extern RslChannelNr_template ts__RslChanNr__Osmo__VAMOS__Lm(const INTEGER& tn, const INTEGER& sub__slot);
extern void RslLinkIdC_encoder(const RslLinkIdC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslLinkIdC_decoder(OCTETSTRING& input_stream, RslLinkIdC& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslSapi0Prio_encoder(const RslSapi0Prio& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslSapi0Prio_decoder(OCTETSTRING& input_stream, RslSapi0Prio& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void GsmSapi_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER GsmSapi_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslLinkId_c_encoder(const RslLinkIdC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslLinkId_c_decoder(OCTETSTRING& input_stream, RslLinkIdC& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslLinkId_na_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslLinkId_na_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslLinkId_prio_encoder(const RslSapi0Prio& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslLinkId_prio_decoder(OCTETSTRING& input_stream, RslSapi0Prio& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslLinkId_sapi_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslLinkId_sapi_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RslLinkId_encoder(const RslLinkId& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RslLinkId_decoder(OCTETSTRING& input_stream, RslLinkId& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern RslLinkId_template tr__RslLinkID__DCCH(const INTEGER_template& sapi);
extern RslLinkId_template tr__RslLinkID__SACCH(const INTEGER_template& sapi);
extern RslLinkId_template tr__RslLinkID__OSMO__PTCCH(const INTEGER_template& sapi);
extern RslLinkId_template ts__RslLinkID__DCCH(const INTEGER& sapi);
extern RslLinkId_template ts__RslLinkID__SACCH(const INTEGER& sapi);
extern RslLinkId_template ts__RslLinkID__OSMO__PTCCH(const INTEGER& sapi);
extern BITSTRING f__hex__is__odd__length(const HEXSTRING& digits);
extern void CBCH__BlockType_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER CBCH__BlockType_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void CBCH__BlockType_lpd_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER CBCH__BlockType_lpd_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void CBCH__BlockType_last__block_encoder(const BOOLEAN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER CBCH__BlockType_last__block_decoder(OCTETSTRING& input_stream, BOOLEAN& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void CBCH__BlockType_seq__nr_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER CBCH__BlockType_seq__nr_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void CBCH__BlockType_encoder(const CBCH__BlockType& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER CBCH__BlockType_decoder(OCTETSTRING& input_stream, CBCH__BlockType& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern CBCH__BlockType_template ts__CBCH__BlockType(const INTEGER_template& seq__nr, const BOOLEAN_template& last__block);
extern CBCH__BlockType_template tr__CBCH__BlockType(const INTEGER_template& seq__nr, const BOOLEAN_template& last__block);
extern void CBCH__Block_block__type_encoder(const CBCH__BlockType& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER CBCH__Block_block__type_decoder(OCTETSTRING& input_stream, CBCH__BlockType& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void CBCH__Block_payload_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER CBCH__Block_payload_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void CBCH__Block_encoder(const CBCH__Block& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER CBCH__Block_decoder(OCTETSTRING& input_stream, CBCH__Block& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern CBCH__Block_template ts__CBCH__Block(const INTEGER_template& seq__nr, const BOOLEAN_template& last__block, const OCTETSTRING_template& payload);
extern CBCH__Block_template tr__CBCH__Block(const INTEGER_template& seq__nr, const BOOLEAN_template& last__block, const OCTETSTRING_template& payload);
extern OCTETSTRING enc__CBCH__Block(const CBCH__Block& msg);
extern CBCH__Block dec__CBCH__Block(const OCTETSTRING& stream);
extern INTEGER dbm2rxlev(const INTEGER& dbm);
extern INTEGER rxlev2dbm(const INTEGER& rxlev);
extern INTEGER ber2rxqual(const FLOAT& ber);
extern FLOAT rxqual2ber(const INTEGER& rxqual);
extern INTEGER f__ccch__blocks__per__mframe(const BOOLEAN& combined__ccch);
extern FLOAT f__pch__block__rate__est(const BOOLEAN& combined__ccch, const INTEGER& bs__ag__blks__res);
extern FLOAT f__agch__block__rate__est(const BOOLEAN& combined__ccch, const INTEGER& bs__ag__blks__res);
extern INTEGER f__gsm__compute__tc(const INTEGER& fn);
extern void GsmBcdString_encoder(const HEXSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER GsmBcdString_decoder(OCTETSTRING& input_stream, HEXSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void BcdMccMnc_encoder(const HEXSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER BcdMccMnc_decoder(OCTETSTRING& input_stream, HEXSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern OCTETSTRING enc__BcdMccMnc(const HEXSTRING& str);
extern HEXSTRING dec__BcdMccMnc(const OCTETSTRING& str);
extern HEXSTRING f__build__BcdMccMnc(const HEXSTRING& mcc, const HEXSTRING& mnc);
extern HEXSTRING f__build__BcdMccMnc__int(const INTEGER& mcc, const INTEGER& mnc, const BOOLEAN& mnc__3__digits);
extern verdicttype testcase_TC__selftest__BcdMccMnc(boolean has_timer, double timer_value);
extern void LocationAreaIdentification_mcc__mnc_encoder(const HEXSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER LocationAreaIdentification_mcc__mnc_decoder(OCTETSTRING& input_stream, HEXSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void LocationAreaIdentification_lac_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER LocationAreaIdentification_lac_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void LocationAreaIdentification_encoder(const LocationAreaIdentification& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER LocationAreaIdentification_decoder(OCTETSTRING& input_stream, LocationAreaIdentification& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern LocationAreaIdentification_template ts__LAI(const HEXSTRING& mcc__mnc, const INTEGER& lac);
extern void RoutingAreaIdentification_lai_encoder(const LocationAreaIdentification& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RoutingAreaIdentification_lai_decoder(OCTETSTRING& input_stream, LocationAreaIdentification& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RoutingAreaIdentification_rac_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RoutingAreaIdentification_rac_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void RoutingAreaIdentification_encoder(const RoutingAreaIdentification& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER RoutingAreaIdentification_decoder(OCTETSTRING& input_stream, RoutingAreaIdentification& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern RoutingAreaIdentification_template ts__RAI(const LocationAreaIdentification_template& lai, const INTEGER& rac);
extern OCTETSTRING enc__RoutingAreaIdentification(const RoutingAreaIdentification& rai);
extern void CellIdentity_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER CellIdentity_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void pre_init_module();
extern void post_init_module();

/* Global variable declarations */

extern const TTCN_RAWdescriptor_t GsmArfcn_raw_;
extern const XERdescriptor_t GsmArfcn_xer_;
extern const TTCN_Typedescriptor_t GsmArfcn_descr_;
extern UNIVERSAL_CHARSTRING GsmArfcn_default_coding;
extern const TTCN_RAWdescriptor_t UmtsArfcn_raw_;
extern const XERdescriptor_t UmtsArfcn_xer_;
extern const TTCN_Typedescriptor_t UmtsArfcn_descr_;
extern UNIVERSAL_CHARSTRING UmtsArfcn_default_coding;
extern const TTCN_RAWdescriptor_t UmtsScramblingCode_raw_;
extern const XERdescriptor_t UmtsScramblingCode_xer_;
extern const TTCN_Typedescriptor_t UmtsScramblingCode_descr_;
extern UNIVERSAL_CHARSTRING UmtsScramblingCode_default_coding;
extern const INTEGER& GsmMaxFrameNumber;
extern INTEGER const_GsmMaxFrameNumber;
extern const TTCN_RAWdescriptor_t GsmFrameNumber_raw_;
extern const XERdescriptor_t GsmFrameNumber_xer_;
extern const TTCN_Typedescriptor_t GsmFrameNumber_descr_;
extern UNIVERSAL_CHARSTRING GsmFrameNumber_default_coding;
extern const TTCN_RAWdescriptor_t GsmRxLev_raw_;
extern const XERdescriptor_t GsmRxLev_xer_;
extern const TTCN_Typedescriptor_t GsmRxLev_descr_;
extern UNIVERSAL_CHARSTRING GsmRxLev_default_coding;
extern const TTCN_RAWdescriptor_t GsmTsc_raw_;
extern const XERdescriptor_t GsmTsc_xer_;
extern const TTCN_Typedescriptor_t GsmTsc_descr_;
extern UNIVERSAL_CHARSTRING GsmTsc_default_coding;
extern const TTCN_RAWdescriptor_t GsmTmsi_raw_;
extern const XERdescriptor_t GsmTmsi_xer_;
extern const TTCN_OERdescriptor_t GsmTmsi_oer_;
extern const TTCN_Typedescriptor_t GsmTmsi_descr_;
extern UNIVERSAL_CHARSTRING GsmTmsi_default_coding;
extern const TTCN_RAWdescriptor_t GprsTlli_raw_;
extern const XERdescriptor_t GprsTlli_xer_;
extern const TTCN_OERdescriptor_t GprsTlli_oer_;
extern const TTCN_Typedescriptor_t GprsTlli_descr_;
extern UNIVERSAL_CHARSTRING GprsTlli_default_coding;
extern const TTCN_RAWdescriptor_t GsmMcc_raw_;
extern const XERdescriptor_t GsmMcc_xer_;
extern const TTCN_Typedescriptor_t GsmMcc_descr_;
extern UNIVERSAL_CHARSTRING GsmMcc_default_coding;
extern const TTCN_RAWdescriptor_t GsmMnc_raw_;
extern const XERdescriptor_t GsmMnc_xer_;
extern const TTCN_Typedescriptor_t GsmMnc_descr_;
extern UNIVERSAL_CHARSTRING GsmMnc_default_coding;
extern const TTCN_RAWdescriptor_t GsmLac_raw_;
extern const XERdescriptor_t GsmLac_xer_;
extern const TTCN_Typedescriptor_t GsmLac_descr_;
extern UNIVERSAL_CHARSTRING GsmLac_default_coding;
extern const TTCN_RAWdescriptor_t GsmCellId_raw_;
extern const XERdescriptor_t GsmCellId_xer_;
extern const TTCN_OERdescriptor_t GsmCellId_oer_;
extern const TTCN_Typedescriptor_t GsmCellId_descr_;
extern UNIVERSAL_CHARSTRING GsmCellId_default_coding;
extern const TTCN_RAWdescriptor_t GroupCallRef_raw_;
extern const XERdescriptor_t GroupCallRef_xer_;
extern const TTCN_OERdescriptor_t GroupCallRef_oer_;
extern const TTCN_Typedescriptor_t GroupCallRef_descr_;
extern UNIVERSAL_CHARSTRING GroupCallRef_default_coding;
extern const TTCN_RAWdescriptor_t GsmBandArfcn_pcs_raw_;
extern const XERdescriptor_t GsmBandArfcn_pcs_xer_;
extern const TTCN_OERdescriptor_t GsmBandArfcn_pcs_oer_;
extern const TTCN_Typedescriptor_t GsmBandArfcn_pcs_descr_;
extern UNIVERSAL_CHARSTRING GsmBandArfcn_pcs_default_coding;
extern const TTCN_RAWdescriptor_t GsmBandArfcn_uplink_raw_;
extern const XERdescriptor_t GsmBandArfcn_uplink_xer_;
extern const TTCN_OERdescriptor_t GsmBandArfcn_uplink_oer_;
extern const TTCN_Typedescriptor_t GsmBandArfcn_uplink_descr_;
extern UNIVERSAL_CHARSTRING GsmBandArfcn_uplink_default_coding;
extern const TTCN_RAWdescriptor_t GsmBandArfcn_spare_raw_;
extern const XERdescriptor_t GsmBandArfcn_spare_xer_;
extern const TTCN_OERdescriptor_t GsmBandArfcn_spare_oer_;
extern const TTCN_Typedescriptor_t GsmBandArfcn_spare_descr_;
extern UNIVERSAL_CHARSTRING GsmBandArfcn_spare_default_coding;
extern const TTCN_RAWdescriptor_t GsmBandArfcn_arfcn_raw_;
extern const XERdescriptor_t GsmBandArfcn_arfcn_xer_;
extern const TTCN_OERdescriptor_t GsmBandArfcn_arfcn_oer_;
extern const TTCN_Typedescriptor_t GsmBandArfcn_arfcn_descr_;
extern UNIVERSAL_CHARSTRING GsmBandArfcn_arfcn_default_coding;
extern const TTCN_RAWdescriptor_t GsmBandArfcn_raw_;
extern const TTCN_Typedescriptor_t GsmBandArfcn_descr_;
extern UNIVERSAL_CHARSTRING GsmBandArfcn_default_coding;
extern const BOOLEAN_template& ts__GsmBandArfcn_pcs_defval;
extern BOOLEAN_template template_ts__GsmBandArfcn_pcs_defval;
extern const BOOLEAN_template& ts__GsmBandArfcn_uplink_defval;
extern BOOLEAN_template template_ts__GsmBandArfcn_uplink_defval;
extern const BOOLEAN_template& tr__GsmBandArfcn_pcs_defval;
extern BOOLEAN_template template_tr__GsmBandArfcn_pcs_defval;
extern const BOOLEAN_template& tr__GsmBandArfcn_uplink_defval;
extern BOOLEAN_template template_tr__GsmBandArfcn_uplink_defval;
extern const TTCN_RAWdescriptor_t PchanConfig_raw_;
extern const TTCN_Typedescriptor_t PchanConfig_descr_;
extern UNIVERSAL_CHARSTRING PchanConfig_default_coding;
extern const TTCN_RAWdescriptor_t GprsCodingScheme_raw_;
extern const TTCN_Typedescriptor_t GprsCodingScheme_descr_;
extern UNIVERSAL_CHARSTRING GprsCodingScheme_default_coding;
extern const OCTETSTRING& TLLI__UNUSED;
extern OCTETSTRING const_TLLI__UNUSED;
extern const TTCN_RAWdescriptor_t ChannelNeeded_raw_;
extern const TTCN_Typedescriptor_t ChannelNeeded_descr_;
extern UNIVERSAL_CHARSTRING ChannelNeeded_default_coding;
extern const TTCN_RAWdescriptor_t ChannelNeeded12_second_raw_;
extern const TTCN_Typedescriptor_t ChannelNeeded12_second_descr_;
extern UNIVERSAL_CHARSTRING ChannelNeeded12_second_default_coding;
extern const TTCN_RAWdescriptor_t ChannelNeeded12_first_raw_;
extern const TTCN_Typedescriptor_t ChannelNeeded12_first_descr_;
extern UNIVERSAL_CHARSTRING ChannelNeeded12_first_default_coding;
extern const TTCN_RAWdescriptor_t ChannelNeeded12_raw_;
extern const TTCN_Typedescriptor_t ChannelNeeded12_descr_;
extern UNIVERSAL_CHARSTRING ChannelNeeded12_default_coding;
extern const TTCN_RAWdescriptor_t RslChanNr0_raw_;
extern const TTCN_Typedescriptor_t RslChanNr0_descr_;
extern UNIVERSAL_CHARSTRING RslChanNr0_default_coding;
extern const TTCN_RAWdescriptor_t RslChanNr2_tag_raw_;
extern const XERdescriptor_t RslChanNr2_tag_xer_;
extern const TTCN_OERdescriptor_t RslChanNr2_tag_oer_;
extern const TTCN_Typedescriptor_t RslChanNr2_tag_descr_;
extern UNIVERSAL_CHARSTRING RslChanNr2_tag_default_coding;
extern const TTCN_RAWdescriptor_t RslChanNr2_sub__chan_raw_;
extern const XERdescriptor_t RslChanNr2_sub__chan_xer_;
extern const TTCN_Typedescriptor_t RslChanNr2_sub__chan_descr_;
extern UNIVERSAL_CHARSTRING RslChanNr2_sub__chan_default_coding;
extern const TTCN_RAWdescriptor_t RslChanNr2_raw_;
extern const TTCN_Typedescriptor_t RslChanNr2_descr_;
extern UNIVERSAL_CHARSTRING RslChanNr2_default_coding;
extern const TTCN_RAWdescriptor_t RslChanNr4_tag_raw_;
extern const XERdescriptor_t RslChanNr4_tag_xer_;
extern const TTCN_OERdescriptor_t RslChanNr4_tag_oer_;
extern const TTCN_Typedescriptor_t RslChanNr4_tag_descr_;
extern UNIVERSAL_CHARSTRING RslChanNr4_tag_default_coding;
extern const TTCN_RAWdescriptor_t RslChanNr4_sub__chan_raw_;
extern const XERdescriptor_t RslChanNr4_sub__chan_xer_;
extern const TTCN_Typedescriptor_t RslChanNr4_sub__chan_descr_;
extern UNIVERSAL_CHARSTRING RslChanNr4_sub__chan_default_coding;
extern const TTCN_RAWdescriptor_t RslChanNr4_raw_;
extern const TTCN_Typedescriptor_t RslChanNr4_descr_;
extern UNIVERSAL_CHARSTRING RslChanNr4_default_coding;
extern const TTCN_RAWdescriptor_t RslChanNr8_tag_raw_;
extern const XERdescriptor_t RslChanNr8_tag_xer_;
extern const TTCN_OERdescriptor_t RslChanNr8_tag_oer_;
extern const TTCN_Typedescriptor_t RslChanNr8_tag_descr_;
extern UNIVERSAL_CHARSTRING RslChanNr8_tag_default_coding;
extern const TTCN_RAWdescriptor_t RslChanNr8_sub__chan_raw_;
extern const XERdescriptor_t RslChanNr8_sub__chan_xer_;
extern const TTCN_Typedescriptor_t RslChanNr8_sub__chan_descr_;
extern UNIVERSAL_CHARSTRING RslChanNr8_sub__chan_default_coding;
extern const TTCN_RAWdescriptor_t RslChanNr8_raw_;
extern const TTCN_Typedescriptor_t RslChanNr8_descr_;
extern UNIVERSAL_CHARSTRING RslChanNr8_default_coding;
extern const TTCN_RAWdescriptor_t RslChanNrU_raw_;
extern const TTCN_Typedescriptor_t RslChanNrU_descr_;
extern const TTCN_RAWdescriptor_t RslChanNrU_ch0_raw_;
extern const TTCN_Typedescriptor_t RslChanNrU_ch0_descr_;
extern UNIVERSAL_CHARSTRING RslChanNrU_ch0_default_coding;
extern const TTCN_RAWdescriptor_t RslChanNrU_lm_raw_;
extern const TTCN_Typedescriptor_t RslChanNrU_lm_descr_;
extern UNIVERSAL_CHARSTRING RslChanNrU_lm_default_coding;
extern const TTCN_RAWdescriptor_t RslChanNrU_sdcch4_raw_;
extern const TTCN_Typedescriptor_t RslChanNrU_sdcch4_descr_;
extern UNIVERSAL_CHARSTRING RslChanNrU_sdcch4_default_coding;
extern const TTCN_RAWdescriptor_t RslChanNrU_sdcch8_raw_;
extern const TTCN_Typedescriptor_t RslChanNrU_sdcch8_descr_;
extern UNIVERSAL_CHARSTRING RslChanNrU_sdcch8_default_coding;
extern UNIVERSAL_CHARSTRING RslChanNrU_default_coding;
extern const TTCN_RAWdescriptor_t RslChannelNr_u_raw_;
extern const TTCN_Typedescriptor_t RslChannelNr_u_descr_;
extern UNIVERSAL_CHARSTRING RslChannelNr_u_default_coding;
extern const TTCN_RAWdescriptor_t RslChannelNr_tn_raw_;
extern const XERdescriptor_t RslChannelNr_tn_xer_;
extern const TTCN_OERdescriptor_t RslChannelNr_tn_oer_;
extern const TTCN_Typedescriptor_t RslChannelNr_tn_descr_;
extern UNIVERSAL_CHARSTRING RslChannelNr_tn_default_coding;
extern const TTCN_RAWdescriptor_t RslChannelNr_raw_;
extern const TTCN_Typedescriptor_t RslChannelNr_descr_;
extern UNIVERSAL_CHARSTRING RslChannelNr_default_coding;
extern const TTCN_RAWdescriptor_t RslLinkIdC_raw_;
extern const TTCN_Typedescriptor_t RslLinkIdC_descr_;
extern UNIVERSAL_CHARSTRING RslLinkIdC_default_coding;
extern const TTCN_RAWdescriptor_t RslSapi0Prio_raw_;
extern const TTCN_Typedescriptor_t RslSapi0Prio_descr_;
extern UNIVERSAL_CHARSTRING RslSapi0Prio_default_coding;
extern const TTCN_RAWdescriptor_t GsmSapi_raw_;
extern const XERdescriptor_t GsmSapi_xer_;
extern const TTCN_OERdescriptor_t GsmSapi_oer_;
extern const TTCN_Typedescriptor_t GsmSapi_descr_;
extern UNIVERSAL_CHARSTRING GsmSapi_default_coding;
extern const TTCN_RAWdescriptor_t RslLinkId_c_raw_;
extern const TTCN_Typedescriptor_t RslLinkId_c_descr_;
extern UNIVERSAL_CHARSTRING RslLinkId_c_default_coding;
extern const TTCN_RAWdescriptor_t RslLinkId_na_raw_;
extern const XERdescriptor_t RslLinkId_na_xer_;
extern const TTCN_OERdescriptor_t RslLinkId_na_oer_;
extern const TTCN_Typedescriptor_t RslLinkId_na_descr_;
extern UNIVERSAL_CHARSTRING RslLinkId_na_default_coding;
extern const TTCN_RAWdescriptor_t RslLinkId_prio_raw_;
extern const TTCN_Typedescriptor_t RslLinkId_prio_descr_;
extern UNIVERSAL_CHARSTRING RslLinkId_prio_default_coding;
extern const TTCN_RAWdescriptor_t RslLinkId_sapi_raw_;
extern const XERdescriptor_t RslLinkId_sapi_xer_;
extern const TTCN_OERdescriptor_t RslLinkId_sapi_oer_;
extern const TTCN_Typedescriptor_t RslLinkId_sapi_descr_;
extern UNIVERSAL_CHARSTRING RslLinkId_sapi_default_coding;
extern const TTCN_RAWdescriptor_t RslLinkId_raw_;
extern const TTCN_Typedescriptor_t RslLinkId_descr_;
extern UNIVERSAL_CHARSTRING RslLinkId_default_coding;
extern const RslLinkId_template& tr__RslLinkId;
extern RslLinkId_template template_tr__RslLinkId;
extern const TTCN_RAWdescriptor_t CBCH__BlockType_spare_raw_;
extern const XERdescriptor_t CBCH__BlockType_spare_xer_;
extern const TTCN_OERdescriptor_t CBCH__BlockType_spare_oer_;
extern const TTCN_Typedescriptor_t CBCH__BlockType_spare_descr_;
extern UNIVERSAL_CHARSTRING CBCH__BlockType_spare_default_coding;
extern const TTCN_RAWdescriptor_t CBCH__BlockType_lpd_raw_;
extern const XERdescriptor_t CBCH__BlockType_lpd_xer_;
extern const TTCN_OERdescriptor_t CBCH__BlockType_lpd_oer_;
extern const TTCN_Typedescriptor_t CBCH__BlockType_lpd_descr_;
extern UNIVERSAL_CHARSTRING CBCH__BlockType_lpd_default_coding;
extern const TTCN_RAWdescriptor_t CBCH__BlockType_last__block_raw_;
extern const XERdescriptor_t CBCH__BlockType_last__block_xer_;
extern const TTCN_OERdescriptor_t CBCH__BlockType_last__block_oer_;
extern const TTCN_Typedescriptor_t CBCH__BlockType_last__block_descr_;
extern UNIVERSAL_CHARSTRING CBCH__BlockType_last__block_default_coding;
extern const TTCN_RAWdescriptor_t CBCH__BlockType_seq__nr_raw_;
extern const XERdescriptor_t CBCH__BlockType_seq__nr_xer_;
extern const TTCN_Typedescriptor_t CBCH__BlockType_seq__nr_descr_;
extern UNIVERSAL_CHARSTRING CBCH__BlockType_seq__nr_default_coding;
extern const TTCN_RAWdescriptor_t CBCH__BlockType_raw_;
extern const TTCN_Typedescriptor_t CBCH__BlockType_descr_;
extern UNIVERSAL_CHARSTRING CBCH__BlockType_default_coding;
extern const INTEGER_template& tr__CBCH__BlockType_seq__nr_defval;
extern INTEGER_template template_tr__CBCH__BlockType_seq__nr_defval;
extern const BOOLEAN_template& tr__CBCH__BlockType_last__block_defval;
extern BOOLEAN_template template_tr__CBCH__BlockType_last__block_defval;
extern const TTCN_RAWdescriptor_t CBCH__Block_block__type_raw_;
extern const TTCN_Typedescriptor_t CBCH__Block_block__type_descr_;
extern UNIVERSAL_CHARSTRING CBCH__Block_block__type_default_coding;
extern const TTCN_RAWdescriptor_t CBCH__Block_payload_raw_;
extern const XERdescriptor_t CBCH__Block_payload_xer_;
extern const TTCN_OERdescriptor_t CBCH__Block_payload_oer_;
extern const TTCN_Typedescriptor_t CBCH__Block_payload_descr_;
extern UNIVERSAL_CHARSTRING CBCH__Block_payload_default_coding;
extern const TTCN_RAWdescriptor_t CBCH__Block_raw_;
extern const TTCN_Typedescriptor_t CBCH__Block_descr_;
extern UNIVERSAL_CHARSTRING CBCH__Block_default_coding;
extern const INTEGER_template& tr__CBCH__Block_seq__nr_defval;
extern INTEGER_template template_tr__CBCH__Block_seq__nr_defval;
extern const BOOLEAN_template& tr__CBCH__Block_last__block_defval;
extern BOOLEAN_template template_tr__CBCH__Block_last__block_defval;
extern const OCTETSTRING_template& tr__CBCH__Block_payload_defval;
extern OCTETSTRING_template template_tr__CBCH__Block_payload_defval;
extern const FLOAT& GSM__FRAME__DURATION;
extern FLOAT const_GSM__FRAME__DURATION;
extern const FLOAT& GSM51__MFRAME__DURATION;
extern FLOAT const_GSM51__MFRAME__DURATION;
extern const FLOAT& GSM51__MFRAMES__PER__SEC;
extern FLOAT const_GSM51__MFRAMES__PER__SEC;
extern const TTCN_RAWdescriptor_t GsmBcdString_raw_;
extern const XERdescriptor_t GsmBcdString_xer_;
extern const TTCN_Typedescriptor_t GsmBcdString_descr_;
extern UNIVERSAL_CHARSTRING GsmBcdString_default_coding;
extern const TTCN_RAWdescriptor_t BcdMccMnc_raw_;
extern const XERdescriptor_t BcdMccMnc_xer_;
extern const TTCN_Typedescriptor_t BcdMccMnc_descr_;
extern UNIVERSAL_CHARSTRING BcdMccMnc_default_coding;
extern const TTCN_RAWdescriptor_t LocationAreaIdentification_mcc__mnc_raw_;
extern const XERdescriptor_t LocationAreaIdentification_mcc__mnc_xer_;
extern const TTCN_Typedescriptor_t LocationAreaIdentification_mcc__mnc_descr_;
extern UNIVERSAL_CHARSTRING LocationAreaIdentification_mcc__mnc_default_coding;
extern const TTCN_RAWdescriptor_t LocationAreaIdentification_lac_raw_;
extern const XERdescriptor_t LocationAreaIdentification_lac_xer_;
extern const TTCN_OERdescriptor_t LocationAreaIdentification_lac_oer_;
extern const TTCN_Typedescriptor_t LocationAreaIdentification_lac_descr_;
extern UNIVERSAL_CHARSTRING LocationAreaIdentification_lac_default_coding;
extern const TTCN_RAWdescriptor_t LocationAreaIdentification_raw_;
extern const TTCN_Typedescriptor_t LocationAreaIdentification_descr_;
extern UNIVERSAL_CHARSTRING LocationAreaIdentification_default_coding;
extern const TTCN_RAWdescriptor_t RoutingAreaIdentification_lai_raw_;
extern const TTCN_Typedescriptor_t RoutingAreaIdentification_lai_descr_;
extern UNIVERSAL_CHARSTRING RoutingAreaIdentification_lai_default_coding;
extern const TTCN_RAWdescriptor_t RoutingAreaIdentification_rac_raw_;
extern const XERdescriptor_t RoutingAreaIdentification_rac_xer_;
extern const TTCN_Typedescriptor_t RoutingAreaIdentification_rac_descr_;
extern UNIVERSAL_CHARSTRING RoutingAreaIdentification_rac_default_coding;
extern const TTCN_RAWdescriptor_t RoutingAreaIdentification_raw_;
extern const TTCN_Typedescriptor_t RoutingAreaIdentification_descr_;
extern UNIVERSAL_CHARSTRING RoutingAreaIdentification_default_coding;
extern const TTCN_RAWdescriptor_t CellIdentity_raw_;
extern const XERdescriptor_t CellIdentity_xer_;
extern const TTCN_OERdescriptor_t CellIdentity_oer_;
extern const TTCN_Typedescriptor_t CellIdentity_descr_;
extern UNIVERSAL_CHARSTRING CellIdentity_default_coding;
extern const BITSTRING bs_6,
bs_4,
bs_0,
bs_2,
bs_3,
bs_5,
bs_1;
extern const HEXSTRING hs_6,
hs_3,
hs_2,
hs_4,
hs_1,
hs_5,
hs_7,
hs_8,
hs_0;
extern const OCTETSTRING os_4,
os_3,
os_2,
os_1,
os_0;
extern const CHARSTRING cs_0;
extern const unsigned char module_checksum[];
extern TTCN_Module module_object;
extern const RuntimeVersionChecker ver_checker;

} /* end of namespace */

#endif