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

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

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

#ifndef GBProxy__Tests_HH
#define GBProxy__Tests_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 "BSSGP_Emulation.hh"
#include "SCCPasp_Types.hh"
#include "L3_Templates.hh"
#include "L3_Common.hh"
#include "Osmocom_VTY_Functions.hh"
#include "Osmocom_CTRL_Adapter.hh"

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

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

#undef GBProxy__Tests_HH
#endif

namespace GBProxy__Tests {

/* Forward declarations of classes */

class NSConfigurations;
class NSConfigurations_template;
class BssgpConfigs;
class BssgpConfigs_template;
class BSSGP__BVC__CTs;
class BSSGP__BVC__CTs_template;
class GbInstance;
class GbInstance_template;
class GbInstances;
class GbInstances_template;
class BssgpCellIds;
class BssgpCellIds_template;
class BSSGP__ConnHdlrPars;
class BSSGP__ConnHdlrPars_template;
class SGSN__ConnHdlrNetworkPars;
class SGSN__ConnHdlrNetworkPars_template;
class void__fn;
class void__fn_template;
class ro__default;
class ro__default_template;
class rim__fn;
class rim__fn_template;

} /* end of namespace */

#ifndef GBProxy__Tests_HH
#define GBProxy__Tests_HH

namespace GBProxy__Tests {

/* Type definitions */

typedef COMPONENT test__CT;
typedef COMPONENT_template test__CT_template;
typedef COMPONENT BSSGP__ConnHdlr;
typedef COMPONENT_template BSSGP__ConnHdlr_template;
typedef COMPONENT GlobalTest__CT;
typedef COMPONENT_template GlobalTest__CT_template;
typedef COMPONENT test__CT__NS;
typedef COMPONENT_template test__CT__NS_template;

/* Class definitions */

class NSConfigurations : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
NS__Emulation::NSConfiguration **value_elements;
} *val_ptr;

static const NS__Emulation::NSConfiguration UNBOUND_ELEM;
private:
friend boolean operator==(null_type null_value, const NSConfigurations& other_value);

public:
  typedef NS__Emulation::NSConfiguration of_type;
NSConfigurations();
NSConfigurations(null_type other_value);
NSConfigurations(const NSConfigurations& other_value);
~NSConfigurations();

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

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

NS__Emulation::NSConfiguration& operator[](int index_value);
NS__Emulation::NSConfiguration& operator[](const INTEGER& index_value);
const NS__Emulation::NSConfiguration& operator[](int index_value) const;
const NS__Emulation::NSConfiguration& operator[](const INTEGER& index_value) const;

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

NSConfigurations operator+(const NSConfigurations& other_value) const;

NSConfigurations substr(int index, int returncount) const;

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

NSConfigurations replace(int index, int len, const NSConfigurations_template& repl) const;

void set_size(int new_size);
inline boolean is_bound() const {return val_ptr != NULL; }
inline boolean is_present() const { return is_bound(); }
boolean is_value() const;
int size_of() const;
int n_elem() const { return size_of(); }
int lengthof() const;
void log() const;
  void set_implicit_omit();
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

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

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

void clean_up();
NSConfigurations_template& operator=(template_sel other_value);
NSConfigurations_template& operator=(null_type other_value);
NSConfigurations_template& operator=(const NSConfigurations& other_value);
NSConfigurations_template& operator=(const OPTIONAL<NSConfigurations>& other_value);
NSConfigurations_template& operator=(const NSConfigurations_template& other_value);

NS__Emulation::NSConfiguration_template& operator[](int index_value);
NS__Emulation::NSConfiguration_template& operator[](const INTEGER& index_value);
const NS__Emulation::NSConfiguration_template& operator[](int index_value) const;
const NS__Emulation::NSConfiguration_template& operator[](const INTEGER& index_value) const;

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

NSConfigurations replace(int index, int len, const NSConfigurations_template& repl) const;

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

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

class BssgpConfigs : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
BSSGP__Emulation::BssgpConfig **value_elements;
} *val_ptr;

static const BSSGP__Emulation::BssgpConfig UNBOUND_ELEM;
private:
friend boolean operator==(null_type null_value, const BssgpConfigs& other_value);

public:
  typedef BSSGP__Emulation::BssgpConfig of_type;
BssgpConfigs();
BssgpConfigs(null_type other_value);
BssgpConfigs(const BssgpConfigs& other_value);
~BssgpConfigs();

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

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

BSSGP__Emulation::BssgpConfig& operator[](int index_value);
BSSGP__Emulation::BssgpConfig& operator[](const INTEGER& index_value);
const BSSGP__Emulation::BssgpConfig& operator[](int index_value) const;
const BSSGP__Emulation::BssgpConfig& operator[](const INTEGER& index_value) const;

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

BssgpConfigs operator+(const BssgpConfigs& other_value) const;

BssgpConfigs substr(int index, int returncount) const;

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

BssgpConfigs replace(int index, int len, const BssgpConfigs_template& repl) const;

void set_size(int new_size);
inline boolean is_bound() const {return val_ptr != NULL; }
inline boolean is_present() const { return is_bound(); }
boolean is_value() const;
int size_of() const;
int n_elem() const { return size_of(); }
int lengthof() const;
void log() const;
  void set_implicit_omit();
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

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

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

void clean_up();
BssgpConfigs_template& operator=(template_sel other_value);
BssgpConfigs_template& operator=(null_type other_value);
BssgpConfigs_template& operator=(const BssgpConfigs& other_value);
BssgpConfigs_template& operator=(const OPTIONAL<BssgpConfigs>& other_value);
BssgpConfigs_template& operator=(const BssgpConfigs_template& other_value);

BSSGP__Emulation::BssgpConfig_template& operator[](int index_value);
BSSGP__Emulation::BssgpConfig_template& operator[](const INTEGER& index_value);
const BSSGP__Emulation::BssgpConfig_template& operator[](int index_value) const;
const BSSGP__Emulation::BssgpConfig_template& operator[](const INTEGER& index_value) const;

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

BssgpConfigs replace(int index, int len, const BssgpConfigs_template& repl) const;

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

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

class BSSGP__BVC__CTs : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
COMPONENT **value_elements;
} *val_ptr;

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

public:
  typedef COMPONENT of_type;
BSSGP__BVC__CTs();
BSSGP__BVC__CTs(null_type other_value);
BSSGP__BVC__CTs(const BSSGP__BVC__CTs& other_value);
~BSSGP__BVC__CTs();

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

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

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

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

BSSGP__BVC__CTs operator+(const BSSGP__BVC__CTs& other_value) const;

BSSGP__BVC__CTs substr(int index, int returncount) const;

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

BSSGP__BVC__CTs replace(int index, int len, const BSSGP__BVC__CTs_template& repl) const;

void set_size(int new_size);
inline boolean is_bound() const {return val_ptr != NULL; }
inline boolean is_present() const { return is_bound(); }
boolean is_value() const;
int size_of() const;
int n_elem() const { return size_of(); }
int lengthof() const;
void log() const;
  void set_implicit_omit();
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

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

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

void clean_up();
BSSGP__BVC__CTs_template& operator=(template_sel other_value);
BSSGP__BVC__CTs_template& operator=(null_type other_value);
BSSGP__BVC__CTs_template& operator=(const BSSGP__BVC__CTs& other_value);
BSSGP__BVC__CTs_template& operator=(const OPTIONAL<BSSGP__BVC__CTs>& other_value);
BSSGP__BVC__CTs_template& operator=(const BSSGP__BVC__CTs_template& other_value);

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

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

BSSGP__BVC__CTs replace(int index, int len, const BSSGP__BVC__CTs_template& repl) const;

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

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

class GbInstance {
  COMPONENT field_vc__NS;
  COMPONENT field_vc__BSSGP;
  BSSGP__BVC__CTs field_vc__BSSGP__BVC;
  BSSGP__Emulation::BssgpConfig field_cfg;
public:
  GbInstance();
  GbInstance(const COMPONENT& par_vc__NS,
    const COMPONENT& par_vc__BSSGP,
    const BSSGP__BVC__CTs& par_vc__BSSGP__BVC,
    const BSSGP__Emulation::BssgpConfig& par_cfg);
  GbInstance(const GbInstance& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  GbInstance& operator=(const GbInstance& other_value);
  boolean operator==(const GbInstance& other_value) const;
  inline boolean operator!=(const GbInstance& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline COMPONENT& vc__NS()
    {return field_vc__NS;}
  inline const COMPONENT& vc__NS() const
    {return field_vc__NS;}
  inline COMPONENT& vc__BSSGP()
    {return field_vc__BSSGP;}
  inline const COMPONENT& vc__BSSGP() const
    {return field_vc__BSSGP;}
  inline BSSGP__BVC__CTs& vc__BSSGP__BVC()
    {return field_vc__BSSGP__BVC;}
  inline const BSSGP__BVC__CTs& vc__BSSGP__BVC() const
    {return field_vc__BSSGP__BVC;}
  inline BSSGP__Emulation::BssgpConfig& cfg()
    {return field_cfg;}
  inline const BSSGP__Emulation::BssgpConfig& cfg() const
    {return field_cfg;}
  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);
};

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

void set_specific();
void copy_value(const GbInstance& other_value);
void copy_template(const GbInstance_template& other_value);

public:
GbInstance_template();
GbInstance_template(template_sel other_value);
GbInstance_template(const GbInstance& other_value);
GbInstance_template(const OPTIONAL<GbInstance>& other_value);
GbInstance_template(GbInstance_template* p_precondition, GbInstance_template* p_implied_template);
GbInstance_template(Dynamic_Match_Interface<GbInstance>* p_dyn_match);
GbInstance_template(const GbInstance_template& other_value);
~GbInstance_template();
GbInstance_template& operator=(template_sel other_value);
GbInstance_template& operator=(const GbInstance& other_value);
GbInstance_template& operator=(const OPTIONAL<GbInstance>& other_value);
GbInstance_template& operator=(const GbInstance_template& other_value);
boolean match(const GbInstance& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
GbInstance valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
GbInstance_template& list_item(unsigned int list_index) const;
COMPONENT_template& vc__NS();
const COMPONENT_template& vc__NS() const;
COMPONENT_template& vc__BSSGP();
const COMPONENT_template& vc__BSSGP() const;
BSSGP__BVC__CTs_template& vc__BSSGP__BVC();
const BSSGP__BVC__CTs_template& vc__BSSGP__BVC() const;
BSSGP__Emulation::BssgpConfig_template& cfg();
const BSSGP__Emulation::BssgpConfig_template& cfg() const;
int size_of() const;
void log() const;
void log_match(const GbInstance& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class GbInstances : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
GbInstance **value_elements;
} *val_ptr;

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

public:
  typedef GbInstance of_type;
GbInstances();
GbInstances(null_type other_value);
GbInstances(const GbInstances& other_value);
~GbInstances();

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

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

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

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

GbInstances operator+(const GbInstances& other_value) const;

GbInstances substr(int index, int returncount) const;

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

GbInstances replace(int index, int len, const GbInstances_template& repl) const;

void set_size(int new_size);
inline boolean is_bound() const {return val_ptr != NULL; }
inline boolean is_present() const { return is_bound(); }
boolean is_value() const;
int size_of() const;
int n_elem() const { return size_of(); }
int lengthof() const;
void log() const;
  void set_implicit_omit();
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

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

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

void clean_up();
GbInstances_template& operator=(template_sel other_value);
GbInstances_template& operator=(null_type other_value);
GbInstances_template& operator=(const GbInstances& other_value);
GbInstances_template& operator=(const OPTIONAL<GbInstances>& other_value);
GbInstances_template& operator=(const GbInstances_template& other_value);

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

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

GbInstances replace(int index, int len, const GbInstances_template& repl) const;

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

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

class BssgpCellIds : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
Osmocom__Gb__Types::BssgpCellId **value_elements;
} *val_ptr;

static const Osmocom__Gb__Types::BssgpCellId UNBOUND_ELEM;
private:
friend boolean operator==(null_type null_value, const BssgpCellIds& other_value);

public:
  typedef Osmocom__Gb__Types::BssgpCellId of_type;
BssgpCellIds();
BssgpCellIds(null_type other_value);
BssgpCellIds(const BssgpCellIds& other_value);
~BssgpCellIds();

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

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

Osmocom__Gb__Types::BssgpCellId& operator[](int index_value);
Osmocom__Gb__Types::BssgpCellId& operator[](const INTEGER& index_value);
const Osmocom__Gb__Types::BssgpCellId& operator[](int index_value) const;
const Osmocom__Gb__Types::BssgpCellId& operator[](const INTEGER& index_value) const;

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

BssgpCellIds operator+(const BssgpCellIds& other_value) const;

BssgpCellIds substr(int index, int returncount) const;

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

BssgpCellIds replace(int index, int len, const BssgpCellIds_template& repl) const;

void set_size(int new_size);
inline boolean is_bound() const {return val_ptr != NULL; }
inline boolean is_present() const { return is_bound(); }
boolean is_value() const;
int size_of() const;
int n_elem() const { return size_of(); }
int lengthof() const;
void log() const;
  void set_implicit_omit();
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

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

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

void clean_up();
BssgpCellIds_template& operator=(template_sel other_value);
BssgpCellIds_template& operator=(null_type other_value);
BssgpCellIds_template& operator=(const BssgpCellIds& other_value);
BssgpCellIds_template& operator=(const OPTIONAL<BssgpCellIds>& other_value);
BssgpCellIds_template& operator=(const BssgpCellIds_template& other_value);

Osmocom__Gb__Types::BssgpCellId_template& operator[](int index_value);
Osmocom__Gb__Types::BssgpCellId_template& operator[](const INTEGER& index_value);
const Osmocom__Gb__Types::BssgpCellId_template& operator[](int index_value) const;
const Osmocom__Gb__Types::BssgpCellId_template& operator[](const INTEGER& index_value) const;

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

BssgpCellIds replace(int index, int len, const BssgpCellIds_template& repl) const;

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

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

class BSSGP__ConnHdlrPars {
  HEXSTRING field_imei;
  HEXSTRING field_imsi;
  HEXSTRING field_msisdn;
  OPTIONAL< OCTETSTRING > field_p__tmsi;
  OPTIONAL< OCTETSTRING > field_p__tmsi__sig;
  OCTETSTRING field_tlli;
  OPTIONAL< OCTETSTRING > field_tlli__old;
  OPTIONAL< MobileL3__GMM__SM__Types::RoutingAreaIdentificationV > field_ra;
  GbInstances field_pcu;
  GbInstances field_sgsn;
  INTEGER field_sgsn__idx;
  FLOAT field_t__guard;
public:
  BSSGP__ConnHdlrPars();
  BSSGP__ConnHdlrPars(const HEXSTRING& par_imei,
    const HEXSTRING& par_imsi,
    const HEXSTRING& par_msisdn,
    const OPTIONAL< OCTETSTRING >& par_p__tmsi,
    const OPTIONAL< OCTETSTRING >& par_p__tmsi__sig,
    const OCTETSTRING& par_tlli,
    const OPTIONAL< OCTETSTRING >& par_tlli__old,
    const OPTIONAL< MobileL3__GMM__SM__Types::RoutingAreaIdentificationV >& par_ra,
    const GbInstances& par_pcu,
    const GbInstances& par_sgsn,
    const INTEGER& par_sgsn__idx,
    const FLOAT& par_t__guard);
  BSSGP__ConnHdlrPars(const BSSGP__ConnHdlrPars& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  BSSGP__ConnHdlrPars& operator=(const BSSGP__ConnHdlrPars& other_value);
  boolean operator==(const BSSGP__ConnHdlrPars& other_value) const;
  inline boolean operator!=(const BSSGP__ConnHdlrPars& 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& imei()
    {return field_imei;}
  inline const HEXSTRING& imei() const
    {return field_imei;}
  inline HEXSTRING& imsi()
    {return field_imsi;}
  inline const HEXSTRING& imsi() const
    {return field_imsi;}
  inline HEXSTRING& msisdn()
    {return field_msisdn;}
  inline const HEXSTRING& msisdn() const
    {return field_msisdn;}
  inline OPTIONAL< OCTETSTRING >& p__tmsi()
    {return field_p__tmsi;}
  inline const OPTIONAL< OCTETSTRING >& p__tmsi() const
    {return field_p__tmsi;}
  inline OPTIONAL< OCTETSTRING >& p__tmsi__sig()
    {return field_p__tmsi__sig;}
  inline const OPTIONAL< OCTETSTRING >& p__tmsi__sig() const
    {return field_p__tmsi__sig;}
  inline OCTETSTRING& tlli()
    {return field_tlli;}
  inline const OCTETSTRING& tlli() const
    {return field_tlli;}
  inline OPTIONAL< OCTETSTRING >& tlli__old()
    {return field_tlli__old;}
  inline const OPTIONAL< OCTETSTRING >& tlli__old() const
    {return field_tlli__old;}
  inline OPTIONAL< MobileL3__GMM__SM__Types::RoutingAreaIdentificationV >& ra()
    {return field_ra;}
  inline const OPTIONAL< MobileL3__GMM__SM__Types::RoutingAreaIdentificationV >& ra() const
    {return field_ra;}
  inline GbInstances& pcu()
    {return field_pcu;}
  inline const GbInstances& pcu() const
    {return field_pcu;}
  inline GbInstances& sgsn()
    {return field_sgsn;}
  inline const GbInstances& sgsn() const
    {return field_sgsn;}
  inline INTEGER& sgsn__idx()
    {return field_sgsn__idx;}
  inline const INTEGER& sgsn__idx() const
    {return field_sgsn__idx;}
  inline FLOAT& t__guard()
    {return field_t__guard;}
  inline const FLOAT& t__guard() const
    {return field_t__guard;}
  int size_of() const;
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
};

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

void set_specific();
void copy_value(const BSSGP__ConnHdlrPars& other_value);
void copy_template(const BSSGP__ConnHdlrPars_template& other_value);

public:
BSSGP__ConnHdlrPars_template();
BSSGP__ConnHdlrPars_template(template_sel other_value);
BSSGP__ConnHdlrPars_template(const BSSGP__ConnHdlrPars& other_value);
BSSGP__ConnHdlrPars_template(const OPTIONAL<BSSGP__ConnHdlrPars>& other_value);
BSSGP__ConnHdlrPars_template(BSSGP__ConnHdlrPars_template* p_precondition, BSSGP__ConnHdlrPars_template* p_implied_template);
BSSGP__ConnHdlrPars_template(Dynamic_Match_Interface<BSSGP__ConnHdlrPars>* p_dyn_match);
BSSGP__ConnHdlrPars_template(const BSSGP__ConnHdlrPars_template& other_value);
~BSSGP__ConnHdlrPars_template();
BSSGP__ConnHdlrPars_template& operator=(template_sel other_value);
BSSGP__ConnHdlrPars_template& operator=(const BSSGP__ConnHdlrPars& other_value);
BSSGP__ConnHdlrPars_template& operator=(const OPTIONAL<BSSGP__ConnHdlrPars>& other_value);
BSSGP__ConnHdlrPars_template& operator=(const BSSGP__ConnHdlrPars_template& other_value);
boolean match(const BSSGP__ConnHdlrPars& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
BSSGP__ConnHdlrPars valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
BSSGP__ConnHdlrPars_template& list_item(unsigned int list_index) const;
HEXSTRING_template& imei();
const HEXSTRING_template& imei() const;
HEXSTRING_template& imsi();
const HEXSTRING_template& imsi() const;
HEXSTRING_template& msisdn();
const HEXSTRING_template& msisdn() const;
OCTETSTRING_template& p__tmsi();
const OCTETSTRING_template& p__tmsi() const;
OCTETSTRING_template& p__tmsi__sig();
const OCTETSTRING_template& p__tmsi__sig() const;
OCTETSTRING_template& tlli();
const OCTETSTRING_template& tlli() const;
OCTETSTRING_template& tlli__old();
const OCTETSTRING_template& tlli__old() const;
MobileL3__GMM__SM__Types::RoutingAreaIdentificationV_template& ra();
const MobileL3__GMM__SM__Types::RoutingAreaIdentificationV_template& ra() const;
GbInstances_template& pcu();
const GbInstances_template& pcu() const;
GbInstances_template& sgsn();
const GbInstances_template& sgsn() const;
INTEGER_template& sgsn__idx();
const INTEGER_template& sgsn__idx() const;
FLOAT_template& t__guard();
const FLOAT_template& t__guard() const;
int size_of() const;
void log() const;
void log_match(const BSSGP__ConnHdlrPars& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class SGSN__ConnHdlrNetworkPars {
  BOOLEAN field_expect__ptmsi;
  BOOLEAN field_expect__auth;
  BOOLEAN field_expect__ciph;
public:
  SGSN__ConnHdlrNetworkPars();
  SGSN__ConnHdlrNetworkPars(const BOOLEAN& par_expect__ptmsi,
    const BOOLEAN& par_expect__auth,
    const BOOLEAN& par_expect__ciph);
  SGSN__ConnHdlrNetworkPars(const SGSN__ConnHdlrNetworkPars& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SGSN__ConnHdlrNetworkPars& operator=(const SGSN__ConnHdlrNetworkPars& other_value);
  boolean operator==(const SGSN__ConnHdlrNetworkPars& other_value) const;
  inline boolean operator!=(const SGSN__ConnHdlrNetworkPars& 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& expect__ptmsi()
    {return field_expect__ptmsi;}
  inline const BOOLEAN& expect__ptmsi() const
    {return field_expect__ptmsi;}
  inline BOOLEAN& expect__auth()
    {return field_expect__auth;}
  inline const BOOLEAN& expect__auth() const
    {return field_expect__auth;}
  inline BOOLEAN& expect__ciph()
    {return field_expect__ciph;}
  inline const BOOLEAN& expect__ciph() const
    {return field_expect__ciph;}
  inline int size_of() const
    {return 3;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
};

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

void set_specific();
void copy_value(const SGSN__ConnHdlrNetworkPars& other_value);
void copy_template(const SGSN__ConnHdlrNetworkPars_template& other_value);

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

class void__fn : public Base_Type {
public:
typedef void (*function_pointer)(const CHARSTRING& id);
typedef void (*start_pointer)(const COMPONENT& component_reference, const CHARSTRING& id);
private:
friend class void__fn_template;
friend boolean operator==(void__fn::function_pointer value, const void__fn& other_value);
function_pointer referred_function;
public:
void__fn();
void__fn(function_pointer other_value);
void__fn(const void__fn& other_value);
void__fn& operator=(function_pointer other_value);
void__fn& operator=(const void__fn& other_value);
boolean operator==(function_pointer other_value) const;
boolean operator==(const void__fn& other_value) const;
inline boolean operator!=(function_pointer other_value) const
{ return !(*this == other_value); }
inline boolean operator!=(const void__fn& other_value) const
{ return !(*this == other_value); }

void invoke(const CHARSTRING& id) const;
void start(const COMPONENT& component_reference, const CHARSTRING& id) const;
inline boolean is_bound() const { return referred_function != NULL; }
inline boolean is_value() const { return referred_function != NULL; }
inline void clean_up() { referred_function = NULL; }
inline void must_bound(const char *err_msg) const
{ if (referred_function == NULL) TTCN_error("%s", err_msg); }

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);
};

extern boolean operator==(void__fn::function_pointer value, const void__fn& other_value);
inline boolean operator!=(void__fn::function_pointer value, const void__fn& other_value)
{ return !(value == other_value); } 

class void__fn_template : public Base_Template {
union {
void__fn::function_pointer single_value;
struct {
unsigned int n_values;
void__fn_template *list_value;
} value_list;
};

  void copy_template(const void__fn_template& other_value);
public:
void__fn_template();
void__fn_template(template_sel other_value);
void__fn_template(void__fn::function_pointer other_value);
void__fn_template(const void__fn& other_value);
void__fn_template(const OPTIONAL<void__fn>& other_value);
void__fn_template(const void__fn_template& other_value);
~void__fn_template();
void clean_up();
void__fn_template& operator=(template_sel other_value);
void__fn_template& operator=(void__fn::function_pointer other_value);
void__fn_template& operator=(const void__fn& other_value);
void__fn_template& operator=(const OPTIONAL<void__fn>& other_value);
void__fn_template& operator=(const void__fn_template& other_value);
boolean match(void__fn::function_pointer other_value, boolean legacy = FALSE) const;
boolean match(const void__fn& other_value, boolean legacy = FALSE) const;
void__fn valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
void__fn_template& list_item(unsigned int list_index) const;
void log() const;
void log_match(const void__fn& 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 ro__default : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
DEFAULT **value_elements;
} *val_ptr;

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

public:
  typedef DEFAULT of_type;
ro__default();
ro__default(null_type other_value);
ro__default(const ro__default& other_value);
~ro__default();

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

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

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

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

ro__default operator+(const ro__default& other_value) const;

ro__default substr(int index, int returncount) const;

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

ro__default replace(int index, int len, const ro__default_template& repl) const;

void set_size(int new_size);
inline boolean is_bound() const {return val_ptr != NULL; }
inline boolean is_present() const { return is_bound(); }
boolean is_value() const;
int size_of() const;
int n_elem() const { return size_of(); }
int lengthof() const;
void log() const;
  void set_implicit_omit();
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

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

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

void clean_up();
ro__default_template& operator=(template_sel other_value);
ro__default_template& operator=(null_type other_value);
ro__default_template& operator=(const ro__default& other_value);
ro__default_template& operator=(const OPTIONAL<ro__default>& other_value);
ro__default_template& operator=(const ro__default_template& other_value);

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

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

ro__default replace(int index, int len, const ro__default_template& repl) const;

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

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

class rim__fn : public Base_Type {
public:
typedef void (*function_pointer)(const INTEGER& sgsn__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
typedef void (*start_pointer)(const COMPONENT& component_reference, const INTEGER& sgsn__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
private:
friend class rim__fn_template;
friend boolean operator==(rim__fn::function_pointer value, const rim__fn& other_value);
function_pointer referred_function;
public:
rim__fn();
rim__fn(function_pointer other_value);
rim__fn(const rim__fn& other_value);
rim__fn& operator=(function_pointer other_value);
rim__fn& operator=(const rim__fn& other_value);
boolean operator==(function_pointer other_value) const;
boolean operator==(const rim__fn& other_value) const;
inline boolean operator!=(function_pointer other_value) const
{ return !(*this == other_value); }
inline boolean operator!=(const rim__fn& other_value) const
{ return !(*this == other_value); }

void invoke(const INTEGER& sgsn__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx) const;
void start(const COMPONENT& component_reference, const INTEGER& sgsn__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx) const;
inline boolean is_bound() const { return referred_function != NULL; }
inline boolean is_value() const { return referred_function != NULL; }
inline void clean_up() { referred_function = NULL; }
inline void must_bound(const char *err_msg) const
{ if (referred_function == NULL) TTCN_error("%s", err_msg); }

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);
};

extern boolean operator==(rim__fn::function_pointer value, const rim__fn& other_value);
inline boolean operator!=(rim__fn::function_pointer value, const rim__fn& other_value)
{ return !(value == other_value); } 

class rim__fn_template : public Base_Template {
union {
rim__fn::function_pointer single_value;
struct {
unsigned int n_values;
rim__fn_template *list_value;
} value_list;
};

  void copy_template(const rim__fn_template& other_value);
public:
rim__fn_template();
rim__fn_template(template_sel other_value);
rim__fn_template(rim__fn::function_pointer other_value);
rim__fn_template(const rim__fn& other_value);
rim__fn_template(const OPTIONAL<rim__fn>& other_value);
rim__fn_template(const rim__fn_template& other_value);
~rim__fn_template();
void clean_up();
rim__fn_template& operator=(template_sel other_value);
rim__fn_template& operator=(rim__fn::function_pointer other_value);
rim__fn_template& operator=(const rim__fn& other_value);
rim__fn_template& operator=(const OPTIONAL<rim__fn>& other_value);
rim__fn_template& operator=(const rim__fn_template& other_value);
boolean match(rim__fn::function_pointer other_value, boolean legacy = FALSE) const;
boolean match(const rim__fn& other_value, boolean legacy = FALSE) const;
rim__fn valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
rim__fn_template& list_item(unsigned int list_index) const;
void log() const;
void log_match(const rim__fn& 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 as__count__unblocked4nse_Default : public Default_Base {
INTEGER par_sgsn__idx;
Osmocom__Types::roro__integer& par_bvci__unblocked;
public:
as__count__unblocked4nse_Default(const INTEGER& sgsn__idx, Osmocom__Types::roro__integer& bvci__unblocked);
alt_status call_altstep(boolean first_alt_run);
};

class as__gTguard_Default : public Default_Base {
TIMER& par_Tguard;
public:
as__gTguard_Default(TIMER& Tguard);
alt_status call_altstep(boolean first_alt_run);
};

class as__NsUdiCount_Default : public Default_Base {
INTEGER par_nsvc__idx;
Osmocom__Types::ro__integer& par_roi;
public:
as__NsUdiCount_Default(const INTEGER& nsvc__idx, Osmocom__Types::ro__integer& roi);
alt_status call_altstep(boolean first_alt_run);
};

class as__paging__sig__pcu_Default : public Default_Base {
INTEGER par_pcu__idx;
BSSGP__Types::PDU__BSSGP_template par_exp__rx;
Osmocom__Types::ro__integer& par_roi;
public:
as__paging__sig__pcu_Default(const INTEGER& pcu__idx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, Osmocom__Types::ro__integer& roi);
alt_status call_altstep(boolean first_alt_run);
};

class as__bssgp__g__pcu__count_Default : public Default_Base {
INTEGER par_pcu__idx;
BSSGP__Types::PDU__BSSGP_template par_exp__rx;
Osmocom__Types::ro__integer& par_roi;
public:
as__bssgp__g__pcu__count_Default(const INTEGER& pcu__idx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, Osmocom__Types::ro__integer& roi);
alt_status call_altstep(boolean first_alt_run);
};

class as__count__bvc__reset_Default : public Default_Base {
Osmocom__Types::roro__integer& par_roroi;
public:
as__count__bvc__reset_Default(Osmocom__Types::roro__integer& roroi);
alt_status call_altstep(boolean first_alt_run);
};

class as__ignore__status_Default : public Default_Base {
BSSGP__Emulation::BSSGP__BVC__MGMT__PT& par_pt;
public:
as__ignore__status_Default(BSSGP__Emulation::BSSGP__BVC__MGMT__PT& pt);
alt_status call_altstep(boolean first_alt_run);
};

class as__count__bvc__sts_Default : public Default_Base {
BSSGP__Emulation::BvcState_template par_exp__bvc__state;
Osmocom__Types::roro__integer& par_roroi;
public:
as__count__bvc__sts_Default(const BSSGP__Emulation::BvcState_template& exp__bvc__state, Osmocom__Types::roro__integer& roroi);
alt_status call_altstep(boolean first_alt_run);
};

class as__count__bvc__block_Default : public Default_Base {
Osmocom__Types::roro__integer& par_roroi;
public:
as__count__bvc__block_Default(Osmocom__Types::roro__integer& roroi);
alt_status call_altstep(boolean first_alt_run);
};

class as__count__bvc__unblock_Default : public Default_Base {
Osmocom__Types::roro__integer& par_roroi;
public:
as__count__bvc__unblock_Default(Osmocom__Types::roro__integer& roroi);
alt_status call_altstep(boolean first_alt_run);
};

class as__ignore__mgmt_Default : public Default_Base {
BSSGP__Emulation::BSSGP__BVC__MGMT__PT& par_pt;
public:
as__ignore__mgmt_Default(BSSGP__Emulation::BSSGP__BVC__MGMT__PT& pt);
alt_status call_altstep(boolean first_alt_run);
};

class as__count__bvc0__block_Default : public Default_Base {
Osmocom__Types::ro__integer& par_roi;
public:
as__count__bvc0__block_Default(Osmocom__Types::ro__integer& roi);
alt_status call_altstep(boolean first_alt_run);
};

class as__g__count__sgsn_Default : public Default_Base {
INTEGER par_sgsn__idx;
Osmocom__Types::ro__integer& par_roi;
BSSGP__Types::PDU__BSSGP_template par_exp__rx;
BSSGP__Types::PDU__BSSGP_template par_tx__reply;
public:
as__g__count__sgsn_Default(const INTEGER& sgsn__idx, Osmocom__Types::ro__integer& roi, const BSSGP__Types::PDU__BSSGP_template& exp__rx, const BSSGP__Types::PDU__BSSGP_template& tx__reply);
alt_status call_altstep(boolean first_alt_run);
};


/* Function prototypes */

extern boolean operator==(null_type null_value, const NSConfigurations& other_value);
inline boolean operator!=(null_type null_value, const NSConfigurations& other_value) { return !(null_value == other_value); }
extern boolean operator==(null_type null_value, const BssgpConfigs& other_value);
inline boolean operator!=(null_type null_value, const BssgpConfigs& other_value) { return !(null_value == other_value); }
extern boolean operator==(null_type null_value, const BSSGP__BVC__CTs& other_value);
inline boolean operator!=(null_type null_value, const BSSGP__BVC__CTs& other_value) { return !(null_value == other_value); }
extern boolean operator==(null_type null_value, const GbInstances& other_value);
inline boolean operator!=(null_type null_value, const GbInstances& other_value) { return !(null_value == other_value); }
extern boolean operator==(null_type null_value, const BssgpCellIds& other_value);
inline boolean operator!=(null_type null_value, const BssgpCellIds& other_value) { return !(null_value == other_value); }
extern INTEGER get__bvc__idx__for__bvci(const GbInstance& gbi, const INTEGER& bvci);
extern MobileL3__GMM__SM__Types::RoutingAreaIdentificationV f__cellid__to__RAI(const Osmocom__Gb__Types::BssgpCellId& cell__id);
extern void f__fix__create__cb(BSSGP__Emulation::BssgpConfig& cfg);
extern void f__init__gb__pcu(GbInstance& gb, const CHARSTRING& id, const INTEGER& offset);
extern void start_f__init__gb__pcu(const COMPONENT& component_reference, GbInstance& gb, const CHARSTRING& id, const INTEGER& offset);
extern void f__init__gb__sgsn(GbInstance& gb, const CHARSTRING& id, const INTEGER& offset);
extern void start_f__init__gb__sgsn(const COMPONENT& component_reference, GbInstance& gb, const CHARSTRING& id, const INTEGER& offset);
extern void f__destroy__gb(GbInstance& gb);
extern void start_f__destroy__gb(const COMPONENT& component_reference, GbInstance& gb);
extern void f__init__vty();
extern void start_f__init__vty(const COMPONENT& component_reference);
extern alt_status as__count__unblocked4nse_instance(const INTEGER& sgsn__idx, Osmocom__Types::roro__integer& bvci__unblocked, boolean first_alt_run);
extern void as__count__unblocked4nse(boolean nodefault_modifier, const INTEGER& sgsn__idx, Osmocom__Types::roro__integer& bvci__unblocked);
extern Default_Base *activate_as__count__unblocked4nse(const INTEGER& sgsn__idx, Osmocom__Types::roro__integer& bvci__unblocked);
extern CHARSTRING_template ts__pcu__bvc__fsm__id(const INTEGER& nsei, const INTEGER& bvci);
extern void f__bvc__fsm__ensure__state(const INTEGER& nsei, const INTEGER& bvci, const CHARSTRING_template& exp);
extern void start_f__bvc__fsm__ensure__state(const COMPONENT& component_reference, const INTEGER& nsei, const INTEGER& bvci, const CHARSTRING_template& exp);
extern void f__init(const FLOAT& t__guard);
extern void start_f__init(const COMPONENT& component_reference, const FLOAT& t__guard);
extern void f__cleanup();
extern void start_f__cleanup(const COMPONENT& component_reference);
extern COMPONENT f__start__handler(const void__fn& fn, const CHARSTRING& id, const INTEGER& imsi__suffix, const FLOAT& t__guard, const INTEGER& sgsn__idx, const INTEGER& nri__idx, const BOOLEAN& have__ptmsi);
extern void start_f__start__handler(const COMPONENT& component_reference, const void__fn& fn, const CHARSTRING& id, const INTEGER& imsi__suffix, const FLOAT& t__guard, const INTEGER& sgsn__idx, const INTEGER& nri__idx, const BOOLEAN& have__ptmsi);
extern void f__start__handlers(const void__fn& fn, const CHARSTRING& id, const INTEGER& , const FLOAT& t__guard, const BOOLEAN& have__ptmsi);
extern void start_f__start__handlers(const COMPONENT& component_reference, const void__fn& fn, const CHARSTRING& id, const INTEGER& imsi__suffix, const FLOAT& t__guard, const BOOLEAN& have__ptmsi);
extern void f__connect__to__pcu__bvc(const INTEGER& port__idx, const INTEGER& nse__idx, const INTEGER& bvc__idx);
extern void start_f__connect__to__pcu__bvc(const COMPONENT& component_reference, const INTEGER& port__idx, const INTEGER& nse__idx, const INTEGER& bvc__idx);
extern void f__connect__to__sgsn__bvc(const INTEGER& port__idx, const COMPONENT& bvc__ct);
extern void start_f__connect__to__sgsn__bvc(const COMPONENT& component_reference, const INTEGER& port__idx, const COMPONENT& bvc__ct);
extern alt_status as__gTguard_instance(TIMER& Tguard, boolean first_alt_run);
extern void as__gTguard(boolean nodefault_modifier, TIMER& Tguard);
extern Default_Base *activate_as__gTguard(TIMER& Tguard);
extern void f__handler__init(const void__fn& fn, const CHARSTRING& id, const BSSGP__ConnHdlrPars& pars);
extern void start_f__handler__init(const COMPONENT& component_reference, const void__fn& fn, const CHARSTRING& id, const BSSGP__ConnHdlrPars& pars);
extern void f__client__register(const HEXSTRING& imsi, const OCTETSTRING& tlli, BSSGP__Emulation::BSSGP__PROC__PT& PT);
extern void f__client__unregister(const HEXSTRING& imsi, BSSGP__Emulation::BSSGP__PROC__PT& PT);
extern void f__pcu2sgsn(const BSSGP__Types::PDU__BSSGP_template& tx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, const INTEGER& pcu__idx, const BOOLEAN& use__sig);
extern void start_f__pcu2sgsn(const COMPONENT& component_reference, const BSSGP__Types::PDU__BSSGP_template& tx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, const INTEGER& pcu__idx, const BOOLEAN& use__sig);
extern INTEGER f__pcu2any__sgsn(const BSSGP__Types::PDU__BSSGP_template& tx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, const INTEGER& pcu__idx, const BOOLEAN& use__sig);
extern void start_f__pcu2any__sgsn(const COMPONENT& component_reference, const BSSGP__Types::PDU__BSSGP_template& tx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, const INTEGER& pcu__idx, const BOOLEAN& use__sig);
extern void f__sgsn2pcu(const BSSGP__Types::PDU__BSSGP_template& tx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, const INTEGER& pcu__idx, const BOOLEAN& use__sig);
extern void start_f__sgsn2pcu(const COMPONENT& component_reference, const BSSGP__Types::PDU__BSSGP_template& tx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, const INTEGER& pcu__idx, const BOOLEAN& use__sig);
extern void f__global__init();
extern void start_f__global__init(const COMPONENT& component_reference);
extern void f__global__init__ptp();
extern void start_f__global__init__ptp(const COMPONENT& component_reference);
extern void f__global__ptp__connect__sgsn__bvci(const INTEGER& sgsn__idx, const INTEGER& bvci);
extern void start_f__global__ptp__connect__sgsn__bvci(const COMPONENT& component_reference, const INTEGER& sgsn__idx, const INTEGER& bvci);
extern void f__global__ptp__connect__pcu__bvci(const INTEGER& pcu__idx, const INTEGER& bvci);
extern void start_f__global__ptp__connect__pcu__bvci(const COMPONENT& component_reference, const INTEGER& pcu__idx, const INTEGER& bvci);
extern void f__global__pcu2sgsn(const BSSGP__Types::PDU__BSSGP_template& tx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, const INTEGER& pcu__idx, const INTEGER& sgsn__idx);
extern void start_f__global__pcu2sgsn(const COMPONENT& component_reference, const BSSGP__Types::PDU__BSSGP_template& tx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, const INTEGER& pcu__idx, const INTEGER& sgsn__idx);
extern void f__global__sgsn2pcu(const BSSGP__Types::PDU__BSSGP_template& tx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, const INTEGER& sgsn__idx, const INTEGER& pcu__idx);
extern void start_f__global__sgsn2pcu(const COMPONENT& component_reference, const BSSGP__Types::PDU__BSSGP_template& tx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, const INTEGER& sgsn__idx, const INTEGER& pcu__idx);
extern void f__TC__BVC__bringup(const CHARSTRING& );
extern void start_f__TC__BVC__bringup(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__BVC__bringup(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__BVC__bringup__conflicting(boolean has_timer, double timer_value);
extern OCTETSTRING f__bssgp__suspend(const INTEGER& ran__idx);
extern void start_f__bssgp__suspend(const COMPONENT& component_reference, const INTEGER& ran__idx);
extern void f__bssgp__resume(const OCTETSTRING& susp__ref, const INTEGER& ran__idx);
extern void start_f__bssgp__resume(const COMPONENT& component_reference, const OCTETSTRING& susp__ref, const INTEGER& ran__idx);
extern void f__TC__ul__unitdata(const CHARSTRING& );
extern void start_f__TC__ul__unitdata(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__ul__unitdata(boolean has_timer, double timer_value);
extern void f__TC__ul__unitdata__pool__failure(const CHARSTRING& );
extern void start_f__TC__ul__unitdata__pool__failure(const COMPONENT& component_reference, const CHARSTRING& id);
extern void f__disable__ns__pcu(const INTEGER& pcu__idx);
extern void start_f__disable__ns__pcu(const COMPONENT& component_reference, const INTEGER& pcu__idx);
extern verdicttype testcase_TC__ul__unitdata__pool__failure(boolean has_timer, double timer_value);
extern void f__TC__dl__unitdata(const CHARSTRING& );
extern void start_f__TC__dl__unitdata(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__dl__unitdata(boolean has_timer, double timer_value);
extern void f__TC__ra__capability(const CHARSTRING& );
extern void start_f__TC__ra__capability(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__ra__capability(boolean has_timer, double timer_value);
extern void f__TC__ra__capability__upd(const CHARSTRING& );
extern void start_f__TC__ra__capability__upd(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__ra__capability__upd(boolean has_timer, double timer_value);
extern void f__TC__radio__status(const CHARSTRING& );
extern void start_f__TC__radio__status(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__radio__status(boolean has_timer, double timer_value);
extern void f__TC__radio__status__tmsi(const CHARSTRING& );
extern void start_f__TC__radio__status__tmsi(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__radio__status__tmsi(boolean has_timer, double timer_value);
extern void f__TC__radio__status__imsi(const CHARSTRING& );
extern void start_f__TC__radio__status__imsi(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__radio__status__imsi(boolean has_timer, double timer_value);
extern void f__suspend__one(const INTEGER& sgsn__idx, const INTEGER& nri__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx, const INTEGER& suffix);
extern void start_f__suspend__one(const COMPONENT& component_reference, const INTEGER& sgsn__idx, const INTEGER& nri__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx, const INTEGER& suffix);
extern void f__TC__suspend(const INTEGER& sgsn__idx, const INTEGER& nri__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern void start_f__TC__suspend(const COMPONENT& component_reference, const INTEGER& sgsn__idx, const INTEGER& nri__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern verdicttype testcase_TC__suspend(boolean has_timer, double timer_value);
extern void f__resume__one(const INTEGER& sgsn__idx, const INTEGER& nri__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx, const INTEGER& suffix);
extern void start_f__resume__one(const COMPONENT& component_reference, const INTEGER& sgsn__idx, const INTEGER& nri__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx, const INTEGER& suffix);
extern void f__TC__resume(const INTEGER& sgsn__idx, const INTEGER& nri__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern void start_f__TC__resume(const COMPONENT& component_reference, const INTEGER& sgsn__idx, const INTEGER& nri__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern verdicttype testcase_TC__resume(boolean has_timer, double timer_value);
extern void f__TC__dl__ud__unidir(const CHARSTRING& );
extern void start_f__TC__dl__ud__unidir(const COMPONENT& component_reference, const CHARSTRING& id);
extern void f__TC__load__sharing__dl(const INTEGER& sgsn__idx);
extern void start_f__TC__load__sharing__dl(const COMPONENT& component_reference, const INTEGER& sgsn__idx);
extern verdicttype testcase_TC__load__sharing__dl(boolean has_timer, double timer_value);
extern alt_status as__NsUdiCount_instance(const INTEGER& nsvc__idx, Osmocom__Types::ro__integer& roi, boolean first_alt_run);
extern void as__NsUdiCount(boolean nodefault_modifier, const INTEGER& nsvc__idx, Osmocom__Types::ro__integer& roi);
extern Default_Base *activate_as__NsUdiCount(const INTEGER& nsvc__idx, Osmocom__Types::ro__integer& roi);
extern BSSGP__Types::PDU__BSSGP_template f__send__paging__ps(const BSSGP__Types::Paging__Field4_template& p4, const INTEGER& sgsn__idx, const BOOLEAN& use__sig);
extern void start_f__send__paging__ps(const COMPONENT& component_reference, const BSSGP__Types::Paging__Field4_template& p4, const INTEGER& sgsn__idx, const BOOLEAN& use__sig);
extern void f__send__paging__ps__exp__one__bss(const BSSGP__Types::Paging__Field4_template& p4, const INTEGER& sgsn__idx, const BOOLEAN& use__sig, const INTEGER& pcu__idx);
extern void start_f__send__paging__ps__exp__one__bss(const COMPONENT& component_reference, const BSSGP__Types::Paging__Field4_template& p4, const INTEGER& sgsn__idx, const BOOLEAN& use__sig, const INTEGER& pcu__idx);
extern void f__send__paging__ps__exp__no__bss(const BSSGP__Types::Paging__Field4_template& p4, const INTEGER& sgsn__idx, const BOOLEAN& use__sig);
extern void start_f__send__paging__ps__exp__no__bss(const COMPONENT& component_reference, const BSSGP__Types::Paging__Field4_template& p4, const INTEGER& sgsn__idx, const BOOLEAN& use__sig);
extern void f__TC__paging__ps__ptp__bss(const CHARSTRING& );
extern void start_f__TC__paging__ps__ptp__bss(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__ps__ptp__bss(boolean has_timer, double timer_value);
extern void f__TC__paging__ps__ptp__lac(const CHARSTRING& );
extern void start_f__TC__paging__ps__ptp__lac(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__ps__ptp__lac(boolean has_timer, double timer_value);
extern void f__TC__paging__ps__ptp__lac__unknown(const CHARSTRING& );
extern void start_f__TC__paging__ps__ptp__lac__unknown(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__ps__ptp__lac__unknown(boolean has_timer, double timer_value);
extern void f__TC__paging__ps__ptp__rac(const CHARSTRING& );
extern void start_f__TC__paging__ps__ptp__rac(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__ps__ptp__rac(boolean has_timer, double timer_value);
extern void f__TC__paging__ps__ptp__rac__unknown(const CHARSTRING& );
extern void start_f__TC__paging__ps__ptp__rac__unknown(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__ps__ptp__rac__unknown(boolean has_timer, double timer_value);
extern void f__TC__paging__ps__ptp__bvci(const CHARSTRING& );
extern void start_f__TC__paging__ps__ptp__bvci(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__ps__ptp__bvci(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__paging__ps__ptp__bvci__imsi(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__paging__ps__reject__ptp__bvci(boolean has_timer, double timer_value);
extern void f__TC__paging__ps__reject__ptp__bvci(const CHARSTRING& );
extern void start_f__TC__paging__ps__reject__ptp__bvci(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__ps__reject__ptp__bvci__imsi(boolean has_timer, double timer_value);
extern void f__TC__paging__ps__ptp__bvci__unknown(const CHARSTRING& );
extern void start_f__TC__paging__ps__ptp__bvci__unknown(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__ps__ptp__bvci__unknown(boolean has_timer, double timer_value);
extern void f__TC__dummy__paging__ps__ptp(const CHARSTRING& );
extern void start_f__TC__dummy__paging__ps__ptp(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__dummy__paging__ps__ptp(boolean has_timer, double timer_value);
extern alt_status as__paging__sig__pcu_instance(const INTEGER& pcu__idx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, Osmocom__Types::ro__integer& roi, boolean first_alt_run);
extern void as__paging__sig__pcu(boolean nodefault_modifier, const INTEGER& pcu__idx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, Osmocom__Types::ro__integer& roi);
extern Default_Base *activate_as__paging__sig__pcu(const INTEGER& pcu__idx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, Osmocom__Types::ro__integer& roi);
extern boolean operator==(null_type null_value, const ro__default& other_value);
inline boolean operator!=(null_type null_value, const ro__default& other_value) { return !(null_value == other_value); }
extern void f__send__paging__ps__exp__multi(const BSSGP__Types::Paging__Field4_template& p4, const INTEGER& sgsn__idx, const Osmocom__Types::ro__integer& exp__on__pcu__idx);
extern void start_f__send__paging__ps__exp__multi(const COMPONENT& component_reference, const BSSGP__Types::Paging__Field4_template& p4, const INTEGER& sgsn__idx, const Osmocom__Types::ro__integer& exp__on__pcu__idx);
extern void f__send__paging__ps__rej(const BOOLEAN& use__sig, const INTEGER& pcu__idx);
extern void start_f__send__paging__ps__rej(const COMPONENT& component_reference, const BOOLEAN& use__sig, const INTEGER& pcu__idx);
extern void f__TC__paging__ps__sig__bss(const CHARSTRING& );
extern void start_f__TC__paging__ps__sig__bss(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__ps__sig__bss(boolean has_timer, double timer_value);
extern void f__TC__paging__ps__sig__lac(const CHARSTRING& );
extern void start_f__TC__paging__ps__sig__lac(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__ps__sig__lac(boolean has_timer, double timer_value);
extern void f__TC__paging__ps__sig__lac__unknown(const CHARSTRING& );
extern void start_f__TC__paging__ps__sig__lac__unknown(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__ps__sig__lac__unknown(boolean has_timer, double timer_value);
extern void f__TC__paging__ps__sig__rac(const CHARSTRING& );
extern void start_f__TC__paging__ps__sig__rac(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__ps__sig__rac(boolean has_timer, double timer_value);
extern void f__TC__paging__ps__sig__rac__unknown(const CHARSTRING& );
extern void start_f__TC__paging__ps__sig__rac__unknown(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__ps__sig__rac__unknown(boolean has_timer, double timer_value);
extern void f__TC__paging__ps__sig__bvci(const CHARSTRING& );
extern void start_f__TC__paging__ps__sig__bvci(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__ps__sig__bvci(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__paging__ps__sig__bvci__imsi(boolean has_timer, double timer_value);
extern void f__TC__paging__ps__reject__sig__bvci(const CHARSTRING& );
extern void start_f__TC__paging__ps__reject__sig__bvci(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__ps__reject__sig__bvci(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__paging__ps__reject__sig__bvci__imsi(boolean has_timer, double timer_value);
extern void f__TC__paging__ps__sig__bvci__unknown(const CHARSTRING& );
extern void start_f__TC__paging__ps__sig__bvci__unknown(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__ps__sig__bvci__unknown(boolean has_timer, double timer_value);
extern void f__TC__dummy__paging__ps__sig(const CHARSTRING& );
extern void start_f__TC__dummy__paging__ps__sig(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__dummy__paging__ps__sig(boolean has_timer, double timer_value);
extern BSSGP__Types::PDU__BSSGP_template f__send__paging__cs(const BSSGP__Types::Paging__Field4_template& p4, const INTEGER& sgsn__idx, const BOOLEAN& use__sig);
extern void start_f__send__paging__cs(const COMPONENT& component_reference, const BSSGP__Types::Paging__Field4_template& p4, const INTEGER& sgsn__idx, const BOOLEAN& use__sig);
extern void f__send__paging__cs__exp__one__bss(const BSSGP__Types::Paging__Field4_template& p4, const INTEGER& sgsn__idx, const BOOLEAN& use__sig, const INTEGER& pcu__idx);
extern void start_f__send__paging__cs__exp__one__bss(const COMPONENT& component_reference, const BSSGP__Types::Paging__Field4_template& p4, const INTEGER& sgsn__idx, const BOOLEAN& use__sig, const INTEGER& pcu__idx);
extern void f__send__paging__cs__exp__no__bss(const BSSGP__Types::Paging__Field4_template& p4, const INTEGER& sgsn__idx, const BOOLEAN& use__sig);
extern void start_f__send__paging__cs__exp__no__bss(const COMPONENT& component_reference, const BSSGP__Types::Paging__Field4_template& p4, const INTEGER& sgsn__idx, const BOOLEAN& use__sig);
extern void f__TC__paging__cs__ptp__bss(const CHARSTRING& );
extern void start_f__TC__paging__cs__ptp__bss(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__cs__ptp__bss(boolean has_timer, double timer_value);
extern void f__TC__paging__cs__ptp__lac(const CHARSTRING& );
extern void start_f__TC__paging__cs__ptp__lac(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__cs__ptp__lac(boolean has_timer, double timer_value);
extern void f__TC__paging__cs__ptp__lac__unknown(const CHARSTRING& );
extern void start_f__TC__paging__cs__ptp__lac__unknown(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__cs__ptp__lac__unknown(boolean has_timer, double timer_value);
extern void f__TC__paging__cs__ptp__rac(const CHARSTRING& );
extern void start_f__TC__paging__cs__ptp__rac(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__cs__ptp__rac(boolean has_timer, double timer_value);
extern void f__TC__paging__cs__ptp__rac__unknown(const CHARSTRING& );
extern void start_f__TC__paging__cs__ptp__rac__unknown(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__cs__ptp__rac__unknown(boolean has_timer, double timer_value);
extern void f__TC__paging__cs__ptp__bvci(const CHARSTRING& );
extern void start_f__TC__paging__cs__ptp__bvci(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__cs__ptp__bvci(boolean has_timer, double timer_value);
extern void f__TC__paging__cs__ptp__bvci__unknown(const CHARSTRING& );
extern void start_f__TC__paging__cs__ptp__bvci__unknown(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__cs__ptp__bvci__unknown(boolean has_timer, double timer_value);
extern void f__send__paging__cs__exp__multi(const BSSGP__Types::Paging__Field4_template& p4, const INTEGER& , const Osmocom__Types::ro__integer& exp__on__pcu__idx);
extern void start_f__send__paging__cs__exp__multi(const COMPONENT& component_reference, const BSSGP__Types::Paging__Field4_template& p4, const INTEGER& sgsn__idx, const Osmocom__Types::ro__integer& exp__on__pcu__idx);
extern void f__TC__paging__cs__sig__bss(const CHARSTRING& );
extern void start_f__TC__paging__cs__sig__bss(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__cs__sig__bss(boolean has_timer, double timer_value);
extern void f__TC__paging__cs__sig__lac(const CHARSTRING& );
extern void start_f__TC__paging__cs__sig__lac(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__cs__sig__lac(boolean has_timer, double timer_value);
extern void f__TC__paging__cs__sig__lac__unknown(const CHARSTRING& );
extern void start_f__TC__paging__cs__sig__lac__unknown(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__cs__sig__lac__unknown(boolean has_timer, double timer_value);
extern void f__TC__paging__cs__sig__rac(const CHARSTRING& );
extern void start_f__TC__paging__cs__sig__rac(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__cs__sig__rac(boolean has_timer, double timer_value);
extern void f__TC__paging__cs__sig__rac__unknown(const CHARSTRING& );
extern void start_f__TC__paging__cs__sig__rac__unknown(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__cs__sig__rac__unknown(boolean has_timer, double timer_value);
extern void f__TC__paging__cs__sig__bvci(const CHARSTRING& );
extern void start_f__TC__paging__cs__sig__bvci(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__cs__sig__bvci(boolean has_timer, double timer_value);
extern void f__TC__paging__cs__sig__bvci__unknown(const CHARSTRING& );
extern void start_f__TC__paging__cs__sig__bvci__unknown(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__paging__cs__sig__bvci__unknown(boolean has_timer, double timer_value);
extern void f__TC__flush__ll__bvci__new(const CHARSTRING& );
extern void start_f__TC__flush__ll__bvci__new(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__flush__ll__bvci__new(boolean has_timer, double timer_value);
extern void f__TC__flush__ll__no__bvci__new(const CHARSTRING& );
extern void start_f__TC__flush__ll__no__bvci__new(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__flush__ll__no__bvci__new(boolean has_timer, double timer_value);
extern alt_status as__bssgp__g__pcu__count_instance(const INTEGER& pcu__idx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, Osmocom__Types::ro__integer& roi, boolean first_alt_run);
extern void as__bssgp__g__pcu__count(boolean nodefault_modifier, const INTEGER& pcu__idx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, Osmocom__Types::ro__integer& roi);
extern Default_Base *activate_as__bssgp__g__pcu__count(const INTEGER& pcu__idx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, Osmocom__Types::ro__integer& roi);
extern verdicttype testcase_TC__trace(boolean has_timer, double timer_value);
extern void f__TC__llc__discarded(const CHARSTRING& );
extern void start_f__TC__llc__discarded(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__llc__discarded(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__overload(boolean has_timer, double timer_value);
extern void f__block__ptp__bvc__from__pcu(const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern void start_f__block__ptp__bvc__from__pcu(const COMPONENT& component_reference, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern verdicttype testcase_TC__bvc__block__ptp(boolean has_timer, double timer_value);
extern void f__unblock__ptp__bvc__from__pcu(const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern void start_f__unblock__ptp__bvc__from__pcu(const COMPONENT& component_reference, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern verdicttype testcase_TC__bvc__unblock__ptp(boolean has_timer, double timer_value);
extern COMPONENT f__get__sgsn__bvc__ct(const INTEGER& sgsn__idx, const INTEGER& bvci);
extern void start_f__get__sgsn__bvc__ct(const COMPONENT& component_reference, const INTEGER& sgsn__idx, const INTEGER& bvci);
extern INTEGER f__get__sgsn__idx__bvc__ct(const COMPONENT& sgsn__bvc__ct, const INTEGER& bvci);
extern void start_f__get__sgsn__idx__bvc__ct(const COMPONENT& component_reference, const COMPONENT& sgsn__bvc__ct, const INTEGER& bvci);
extern alt_status as__count__bvc__reset_instance(Osmocom__Types::roro__integer& roroi, boolean first_alt_run);
extern void as__count__bvc__reset(boolean nodefault_modifier, Osmocom__Types::roro__integer& roroi);
extern Default_Base *activate_as__count__bvc__reset(Osmocom__Types::roro__integer& roroi);
extern alt_status as__ignore__status_instance(BSSGP__Emulation::BSSGP__BVC__MGMT__PT& pt, boolean first_alt_run);
extern void as__ignore__status(boolean nodefault_modifier, BSSGP__Emulation::BSSGP__BVC__MGMT__PT& pt);
extern Default_Base *activate_as__ignore__status(BSSGP__Emulation::BSSGP__BVC__MGMT__PT& pt);
extern void f__reset__ptp__bvc__from__pcu(const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern void start_f__reset__ptp__bvc__from__pcu(const COMPONENT& component_reference, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern verdicttype testcase_TC__bvc__reset__ptp__from__bss(boolean has_timer, double timer_value);
extern alt_status as__count__bvc__sts_instance(const BSSGP__Emulation::BvcState_template& exp__bvc__state, Osmocom__Types::roro__integer& roroi, boolean first_alt_run);
extern void as__count__bvc__sts(boolean nodefault_modifier, const BSSGP__Emulation::BvcState_template& exp__bvc__state, Osmocom__Types::roro__integer& roroi);
extern Default_Base *activate_as__count__bvc__sts(const BSSGP__Emulation::BvcState_template& exp__bvc__state, Osmocom__Types::roro__integer& roroi);
extern alt_status as__count__bvc__block_instance(Osmocom__Types::roro__integer& roroi, boolean first_alt_run);
extern void as__count__bvc__block(boolean nodefault_modifier, Osmocom__Types::roro__integer& roroi);
extern Default_Base *activate_as__count__bvc__block(Osmocom__Types::roro__integer& roroi);
extern alt_status as__count__bvc__unblock_instance(Osmocom__Types::roro__integer& roroi, boolean first_alt_run);
extern void as__count__bvc__unblock(boolean nodefault_modifier, Osmocom__Types::roro__integer& roroi);
extern Default_Base *activate_as__count__bvc__unblock(Osmocom__Types::roro__integer& roroi);
extern verdicttype testcase_TC__bvc__reset__sig__from__bss(boolean has_timer, double timer_value);
extern void f__reset__ptp__bvc__from__sgsn(const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern void start_f__reset__ptp__bvc__from__sgsn(const COMPONENT& component_reference, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern verdicttype testcase_TC__bvc__reset__ptp__from__sgsn(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__bvc__reset__blocked__ptp__from__sgsn(boolean has_timer, double timer_value);
extern alt_status as__ignore__mgmt_instance(BSSGP__Emulation::BSSGP__BVC__MGMT__PT& pt, boolean first_alt_run);
extern void as__ignore__mgmt(boolean nodefault_modifier, BSSGP__Emulation::BSSGP__BVC__MGMT__PT& pt);
extern Default_Base *activate_as__ignore__mgmt(BSSGP__Emulation::BSSGP__BVC__MGMT__PT& pt);
extern INTEGER f__get__pcu__idx__ct(const COMPONENT& pcu__ct);
extern void start_f__get__pcu__idx__ct(const COMPONENT& component_reference, const COMPONENT& pcu__ct);
extern alt_status as__count__bvc0__block_instance(Osmocom__Types::ro__integer& roi, boolean first_alt_run);
extern void as__count__bvc0__block(boolean nodefault_modifier, Osmocom__Types::ro__integer& roi);
extern Default_Base *activate_as__count__bvc0__block(Osmocom__Types::ro__integer& roi);
extern verdicttype testcase_TC__bvc__reset__sig__from__sgsn(boolean has_timer, double timer_value);
extern alt_status as__g__count__sgsn_instance(const INTEGER& sgsn__idx, Osmocom__Types::ro__integer& roi, const BSSGP__Types::PDU__BSSGP_template& exp__rx, const BSSGP__Types::PDU__BSSGP_template& tx__reply, boolean first_alt_run);
extern void as__g__count__sgsn(boolean nodefault_modifier, const INTEGER& sgsn__idx, Osmocom__Types::ro__integer& roi, const BSSGP__Types::PDU__BSSGP_template& exp__rx, const BSSGP__Types::PDU__BSSGP_template& tx__reply);
extern Default_Base *activate_as__g__count__sgsn(const INTEGER& sgsn__idx, Osmocom__Types::ro__integer& roi, const BSSGP__Types::PDU__BSSGP_template& exp__rx, const BSSGP__Types::PDU__BSSGP_template& tx__reply);
extern verdicttype testcase_TC__fc__bvc(boolean has_timer, double timer_value);
extern void f__TC__fc__ms(const CHARSTRING& );
extern void start_f__TC__fc__ms(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__fc__ms(boolean has_timer, double timer_value);
extern void f__TC__ms__reg__enq(const CHARSTRING& );
extern void start_f__TC__ms__reg__enq(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__ms__reg__enq(boolean has_timer, double timer_value);
extern void f__rim__pcu2sgsn(const BSSGP__Types::PDU__BSSGP_template& tx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, const INTEGER& pcu__idx);
extern void start_f__rim__pcu2sgsn(const COMPONENT& component_reference, const BSSGP__Types::PDU__BSSGP_template& tx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, const INTEGER& pcu__idx);
extern void f__rim__sgsn2pcu(const BSSGP__Types::PDU__BSSGP_template& tx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, const INTEGER& sgsn__idx, const INTEGER& pcu__idx);
extern void start_f__rim__sgsn2pcu(const COMPONENT& component_reference, const BSSGP__Types::PDU__BSSGP_template& tx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, const INTEGER& sgsn__idx, const INTEGER& pcu__idx);
extern void f__rim__pcu2pcu(const BSSGP__Types::PDU__BSSGP_template& tx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, const INTEGER& src__pcu__idx, const INTEGER& dst__pcu__idx);
extern void start_f__rim__pcu2pcu(const COMPONENT& component_reference, const BSSGP__Types::PDU__BSSGP_template& tx, const BSSGP__Types::PDU__BSSGP_template& exp__rx, const INTEGER& src__pcu__idx, const INTEGER& dst__pcu__idx);
extern void f__rim__iterator(const rim__fn& fn);
extern void start_f__rim__iterator(const COMPONENT& component_reference, const rim__fn& fn);
extern void f__TC__rim__info__req(const INTEGER& sgsn__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern void start_f__TC__rim__info__req(const COMPONENT& component_reference, const INTEGER& sgsn__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern verdicttype testcase_TC__rim__info__req(boolean has_timer, double timer_value);
extern void f__TC__rim__info(const INTEGER& sgsn__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern void start_f__TC__rim__info(const COMPONENT& component_reference, const INTEGER& sgsn__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern verdicttype testcase_TC__rim__info(boolean has_timer, double timer_value);
extern void f__TC__rim__info__ack(const INTEGER& sgsn__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern void start_f__TC__rim__info__ack(const COMPONENT& component_reference, const INTEGER& sgsn__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern verdicttype testcase_TC__rim__info__ack(boolean has_timer, double timer_value);
extern void f__TC__rim__info__error(const INTEGER& sgsn__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern void start_f__TC__rim__info__error(const COMPONENT& component_reference, const INTEGER& sgsn__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern verdicttype testcase_TC__rim__info__error(boolean has_timer, double timer_value);
extern void f__TC__rim__info__app__error(const INTEGER& sgsn__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern void start_f__TC__rim__info__app__error(const COMPONENT& component_reference, const INTEGER& sgsn__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern verdicttype testcase_TC__rim__info__app__error(boolean has_timer, double timer_value);
extern void f__TC__rim__info__pcu2pcu(const INTEGER& src__pcu__idx, const INTEGER& src__bvc__idx, const INTEGER& dst__pcu__idx, const INTEGER& dst__bvc__idx);
extern void start_f__TC__rim__info__pcu2pcu(const COMPONENT& component_reference, const INTEGER& src__pcu__idx, const INTEGER& src__bvc__idx, const INTEGER& dst__pcu__idx, const INTEGER& dst__bvc__idx);
extern verdicttype testcase_TC__rim__info__pcu2pcu(boolean has_timer, double timer_value);
extern void f__TC__rim__from__eutran(const INTEGER& sgsn__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern void start_f__TC__rim__from__eutran(const COMPONENT& component_reference, const INTEGER& sgsn__idx, const INTEGER& pcu__idx, const INTEGER& bvc__idx);
extern verdicttype testcase_TC__rim__from__eutran(boolean has_timer, double timer_value);
extern OCTETSTRING f__gen__tmsi__for__sgsn__nri(const INTEGER& sgsn__idx, const INTEGER& nri__idx);
extern void start_f__gen__tmsi__for__sgsn__nri(const COMPONENT& component_reference, const INTEGER& sgsn__idx, const INTEGER& nri__idx);
extern OCTETSTRING f__gen__tlli__for__sgsn__nri(const INTEGER& sgsn__idx, const INTEGER& nri__idx);
extern void start_f__gen__tlli__for__sgsn__nri(const COMPONENT& component_reference, const INTEGER& sgsn__idx, const INTEGER& nri__idx);
extern void f__TC__status__ul(const INTEGER& pcu__idx, const INTEGER& sgsn__idx, const BSSGP__Types::PDU__BSSGP& inner);
extern void start_f__TC__status__ul(const COMPONENT& component_reference, const INTEGER& pcu__idx, const INTEGER& sgsn__idx, const BSSGP__Types::PDU__BSSGP& inner);
extern void f__TC__status__dl(const INTEGER& sgsn__idx, const INTEGER& pcu__idx, const BSSGP__Types::PDU__BSSGP& inner);
extern void start_f__TC__status__dl(const COMPONENT& component_reference, const INTEGER& sgsn__idx, const INTEGER& pcu__idx, const BSSGP__Types::PDU__BSSGP& inner);
extern verdicttype testcase_TC__status__sig__ul__tlli(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__status__sig__ul__tmsi(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__status__ptp__ul__tlli(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__status__ptp__ul__tmsi(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__status__sig__dl__bvci(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__status__ptp__dl__bvci(boolean has_timer, double timer_value);
extern void module_control_part();
extern void pre_init_module();
extern void post_init_module();
extern boolean set_module_param(Module_Param& param);
extern void log_module_param();
extern boolean init_comp_type(const char *component_type, boolean init_base_comps);
extern boolean init_system_port(const char* component_type, const char* port_name);
extern boolean start_ptc_function(const char *function_name, Text_Buf& function_arguments);

/* Global variable declarations */

extern const HEXSTRING& c__mcc__mnc;
extern HEXSTRING const_c__mcc__mnc;
extern const INTEGER& max__fr__info__size;
extern INTEGER const_max__fr__info__size;
extern const CHARSTRING& mp__gbproxy__ip;
extern CHARSTRING modulepar_mp__gbproxy__ip;
extern const INTEGER& mp__gbproxy__ctrl__port;
extern INTEGER modulepar_mp__gbproxy__ctrl__port;
extern const INTEGER& mp__nri__bitlength;
extern INTEGER modulepar_mp__nri__bitlength;
extern const Osmocom__Types::roro__integer& mp__sgsn__nri;
extern Osmocom__Types::roro__integer modulepar_mp__sgsn__nri;
extern const BOOLEAN& mp__enable__bss__load__sharing;
extern BOOLEAN modulepar_mp__enable__bss__load__sharing;
extern const TTCN_Typedescriptor_t NSConfigurations_descr_;
extern const NSConfigurations& mp__nsconfig__sgsn;
extern NSConfigurations modulepar_mp__nsconfig__sgsn;
extern const NSConfigurations& mp__nsconfig__pcu;
extern NSConfigurations modulepar_mp__nsconfig__pcu;
extern const TTCN_Typedescriptor_t BssgpConfigs_descr_;
extern const BssgpConfigs& mp__gbconfigs;
extern BssgpConfigs modulepar_mp__gbconfigs;
extern const TTCN_Typedescriptor_t BSSGP__BVC__CTs_descr_;
extern const TTCN_Typedescriptor_t GbInstance_descr_;
extern const INTEGER& NUM__PCU;
extern INTEGER const_NUM__PCU;
extern const TTCN_Typedescriptor_t GbInstances_descr_;
extern const TTCN_Typedescriptor_t BssgpCellIds_descr_;
extern UNIVERSAL_CHARSTRING BssgpCellIds_0_default_coding;
extern const INTEGER& NUM__SGSN;
extern INTEGER const_NUM__SGSN;
extern const TTCN_Typedescriptor_t& test__CT_descr_;
extern GbInstances test__CT_component_g__pcu;
extern GbInstances test__CT_component_g__sgsn;
extern NS__Emulation::NS__CTRL__PT test__CT_component_NS__CTRL;
extern BSSGP__Emulation::BSSGP__CT__PROC__PT test__CT_component_PROC;
extern BSSGP__Emulation::BSSGP__BVC__MGMT__PT test__CT_component_SGSN__MGMT;
extern BSSGP__Emulation::BSSGP__BVC__MGMT__PT test__CT_component_PCU__MGMT;
extern TELNETasp__PortType::TELNETasp__PT test__CT_component_GBPVTY;
extern BOOLEAN test__CT_component_g__initialized;
extern BOOLEAN test__CT_component_g__use__echo;
extern Osmocom__Types::ro__integer test__CT_component_g__roi;
extern Osmocom__Types::roro__integer test__CT_component_g__roroi;
extern TIMER test__CT_component_g__Tguard;
extern const TTCN_Typedescriptor_t& BSSGP__ConnHdlr_descr_;
extern PORT_ARRAY<BSSGP__Emulation::BSSGP__PT, 3, 0> BSSGP__ConnHdlr_component_PCU__PTP;
extern PORT_ARRAY<BSSGP__Emulation::BSSGP__PT, 3, 0> BSSGP__ConnHdlr_component_PCU__SIG;
extern PORT_ARRAY<BSSGP__Emulation::BSSGP__PROC__PT, 3, 0> BSSGP__ConnHdlr_component_PCU__PROC;
extern VALUE_ARRAY<COMPONENT, 3, 0> BSSGP__ConnHdlr_component_pcu__ct;
extern VALUE_ARRAY<BSSGP__Emulation::BssgpBvcConfig, 3, 0> BSSGP__ConnHdlr_component_pcu__bvc__cfg;
extern PORT_ARRAY<BSSGP__Emulation::BSSGP__PT, 2, 0> BSSGP__ConnHdlr_component_SGSN__PTP;
extern PORT_ARRAY<BSSGP__Emulation::BSSGP__PT, 2, 0> BSSGP__ConnHdlr_component_SGSN__SIG;
extern PORT_ARRAY<BSSGP__Emulation::BSSGP__PROC__PT, 2, 0> BSSGP__ConnHdlr_component_SGSN__PROC;
extern VALUE_ARRAY<COMPONENT, 3, 0> BSSGP__ConnHdlr_component_sgsn__ct;
extern const XERdescriptor_t BSSGP__ConnHdlrPars_imei_xer_;
extern const TTCN_Typedescriptor_t BSSGP__ConnHdlrPars_imei_descr_;
extern const XERdescriptor_t BSSGP__ConnHdlrPars_imsi_xer_;
extern const TTCN_Typedescriptor_t BSSGP__ConnHdlrPars_imsi_descr_;
extern const XERdescriptor_t BSSGP__ConnHdlrPars_msisdn_xer_;
extern const TTCN_Typedescriptor_t BSSGP__ConnHdlrPars_msisdn_descr_;
extern const XERdescriptor_t BSSGP__ConnHdlrPars_tlli_xer_;
extern const TTCN_OERdescriptor_t BSSGP__ConnHdlrPars_tlli_oer_;
extern const TTCN_Typedescriptor_t BSSGP__ConnHdlrPars_tlli_descr_;
extern UNIVERSAL_CHARSTRING BSSGP__ConnHdlrPars_tlli_default_coding;
extern const XERdescriptor_t BSSGP__ConnHdlrPars_sgsn__idx_xer_;
extern const TTCN_Typedescriptor_t BSSGP__ConnHdlrPars_sgsn__idx_descr_;
extern const XERdescriptor_t BSSGP__ConnHdlrPars_t__guard_xer_;
extern const TTCN_OERdescriptor_t BSSGP__ConnHdlrPars_t__guard_oer_;
extern const TTCN_Typedescriptor_t BSSGP__ConnHdlrPars_t__guard_descr_;
extern const TTCN_Typedescriptor_t BSSGP__ConnHdlrPars_descr_;
extern const XERdescriptor_t BSSGP__ConnHdlrPars_p__tmsi_xer_;
extern const TTCN_OERdescriptor_t BSSGP__ConnHdlrPars_p__tmsi_oer_;
extern const TTCN_Typedescriptor_t BSSGP__ConnHdlrPars_p__tmsi_descr_;
extern UNIVERSAL_CHARSTRING BSSGP__ConnHdlrPars_p__tmsi_default_coding;
extern const XERdescriptor_t BSSGP__ConnHdlrPars_p__tmsi__sig_xer_;
extern const TTCN_OERdescriptor_t BSSGP__ConnHdlrPars_p__tmsi__sig_oer_;
extern const TTCN_Typedescriptor_t BSSGP__ConnHdlrPars_p__tmsi__sig_descr_;
extern UNIVERSAL_CHARSTRING BSSGP__ConnHdlrPars_p__tmsi__sig_default_coding;
extern const XERdescriptor_t BSSGP__ConnHdlrPars_tlli__old_xer_;
extern const TTCN_OERdescriptor_t BSSGP__ConnHdlrPars_tlli__old_oer_;
extern const TTCN_Typedescriptor_t BSSGP__ConnHdlrPars_tlli__old_descr_;
extern UNIVERSAL_CHARSTRING BSSGP__ConnHdlrPars_tlli__old_default_coding;
extern UNIVERSAL_CHARSTRING BSSGP__ConnHdlrPars_ra_default_coding;
extern BSSGP__ConnHdlrPars BSSGP__ConnHdlr_component_g__pars;
extern TIMER BSSGP__ConnHdlr_component_g__Tguard;
extern BSSGP__Emulation::LLC__Entities BSSGP__ConnHdlr_component_llc;
extern Osmocom__Types::ro__integer BSSGP__ConnHdlr_component_g__roi;
extern const XERdescriptor_t SGSN__ConnHdlrNetworkPars_expect__ptmsi_xer_;
extern const TTCN_OERdescriptor_t SGSN__ConnHdlrNetworkPars_expect__ptmsi_oer_;
extern const TTCN_Typedescriptor_t SGSN__ConnHdlrNetworkPars_expect__ptmsi_descr_;
extern const XERdescriptor_t SGSN__ConnHdlrNetworkPars_expect__auth_xer_;
extern const TTCN_OERdescriptor_t SGSN__ConnHdlrNetworkPars_expect__auth_oer_;
extern const TTCN_Typedescriptor_t SGSN__ConnHdlrNetworkPars_expect__auth_descr_;
extern const XERdescriptor_t SGSN__ConnHdlrNetworkPars_expect__ciph_xer_;
extern const TTCN_OERdescriptor_t SGSN__ConnHdlrNetworkPars_expect__ciph_oer_;
extern const TTCN_Typedescriptor_t SGSN__ConnHdlrNetworkPars_expect__ciph_descr_;
extern const TTCN_Typedescriptor_t SGSN__ConnHdlrNetworkPars_descr_;
extern const FLOAT& f__init_t__guard_defval;
extern FLOAT const_f__init_t__guard_defval;
extern const TTCN_Typedescriptor_t void__fn_descr_;
extern const FLOAT& f__start__handler_t__guard_defval;
extern FLOAT const_f__start__handler_t__guard_defval;
extern const INTEGER& f__start__handler_sgsn__idx_defval;
extern INTEGER const_f__start__handler_sgsn__idx_defval;
extern const INTEGER& f__start__handler_nri__idx_defval;
extern INTEGER const_f__start__handler_nri__idx_defval;
extern const BOOLEAN& f__start__handler_have__ptmsi_defval;
extern BOOLEAN const_f__start__handler_have__ptmsi_defval;
extern const FLOAT& f__start__handlers_t__guard_defval;
extern FLOAT const_f__start__handlers_t__guard_defval;
extern const BOOLEAN& f__start__handlers_have__ptmsi_defval;
extern BOOLEAN const_f__start__handlers_have__ptmsi_defval;
extern const INTEGER& f__pcu2sgsn_pcu__idx_defval;
extern INTEGER const_f__pcu2sgsn_pcu__idx_defval;
extern const BOOLEAN& f__pcu2sgsn_use__sig_defval;
extern BOOLEAN const_f__pcu2sgsn_use__sig_defval;
extern const INTEGER& f__pcu2any__sgsn_pcu__idx_defval;
extern INTEGER const_f__pcu2any__sgsn_pcu__idx_defval;
extern const BOOLEAN& f__pcu2any__sgsn_use__sig_defval;
extern BOOLEAN const_f__pcu2any__sgsn_use__sig_defval;
extern const INTEGER& f__sgsn2pcu_pcu__idx_defval;
extern INTEGER const_f__sgsn2pcu_pcu__idx_defval;
extern const BOOLEAN& f__sgsn2pcu_use__sig_defval;
extern BOOLEAN const_f__sgsn2pcu_use__sig_defval;
extern const TTCN_Typedescriptor_t& GlobalTest__CT_descr_;
extern PORT_ARRAY<BSSGP__Emulation::BSSGP__PT, 3, 0> GlobalTest__CT_component_G__PCU;
extern VALUE_ARRAY<INTEGER, 3, 0> GlobalTest__CT_component_g__pcu__idx;
extern PORT_ARRAY<BSSGP__Emulation::BSSGP__PT, 2, 0> GlobalTest__CT_component_G__SGSN;
extern VALUE_ARRAY<INTEGER, 2, 0> GlobalTest__CT_component_g__sgsn__idx;
extern PORT_ARRAY<BSSGP__Emulation::BSSGP__PT, 3, 0> GlobalTest__CT_component_RIM__PCU;
extern PORT_ARRAY<BSSGP__Emulation::BSSGP__PT, 2, 0> GlobalTest__CT_component_RIM__SGSN;
extern const INTEGER& f__global__pcu2sgsn_pcu__idx_defval;
extern INTEGER const_f__global__pcu2sgsn_pcu__idx_defval;
extern const INTEGER& f__global__pcu2sgsn_sgsn__idx_defval;
extern INTEGER const_f__global__pcu2sgsn_sgsn__idx_defval;
extern const INTEGER& f__global__sgsn2pcu_sgsn__idx_defval;
extern INTEGER const_f__global__sgsn2pcu_sgsn__idx_defval;
extern const INTEGER& f__global__sgsn2pcu_pcu__idx_defval;
extern INTEGER const_f__global__sgsn2pcu_pcu__idx_defval;
extern const INTEGER& f__bssgp__suspend_ran__idx_defval;
extern INTEGER const_f__bssgp__suspend_ran__idx_defval;
extern const INTEGER& f__bssgp__resume_ran__idx_defval;
extern INTEGER const_f__bssgp__resume_ran__idx_defval;
extern const TTCN_Typedescriptor_t& test__CT__NS_descr_;
extern NS__Emulation::NS__PT test__CT__NS_component_NS;
extern const INTEGER& f__send__paging__ps_sgsn__idx_defval;
extern INTEGER const_f__send__paging__ps_sgsn__idx_defval;
extern const BOOLEAN& f__send__paging__ps_use__sig_defval;
extern BOOLEAN const_f__send__paging__ps_use__sig_defval;
extern const INTEGER& f__send__paging__ps__exp__one__bss_sgsn__idx_defval;
extern INTEGER const_f__send__paging__ps__exp__one__bss_sgsn__idx_defval;
extern const BOOLEAN& f__send__paging__ps__exp__one__bss_use__sig_defval;
extern BOOLEAN const_f__send__paging__ps__exp__one__bss_use__sig_defval;
extern const INTEGER& f__send__paging__ps__exp__one__bss_pcu__idx_defval;
extern INTEGER const_f__send__paging__ps__exp__one__bss_pcu__idx_defval;
extern const INTEGER& f__send__paging__ps__exp__no__bss_sgsn__idx_defval;
extern INTEGER const_f__send__paging__ps__exp__no__bss_sgsn__idx_defval;
extern const BOOLEAN& f__send__paging__ps__exp__no__bss_use__sig_defval;
extern BOOLEAN const_f__send__paging__ps__exp__no__bss_use__sig_defval;
extern const TTCN_Typedescriptor_t ro__default_descr_;
extern const INTEGER& f__send__paging__ps__exp__multi_sgsn__idx_defval;
extern INTEGER const_f__send__paging__ps__exp__multi_sgsn__idx_defval;
extern const BOOLEAN& f__send__paging__ps__rej_use__sig_defval;
extern BOOLEAN const_f__send__paging__ps__rej_use__sig_defval;
extern const INTEGER& f__send__paging__ps__rej_pcu__idx_defval;
extern INTEGER const_f__send__paging__ps__rej_pcu__idx_defval;
extern const INTEGER& f__send__paging__cs_sgsn__idx_defval;
extern INTEGER const_f__send__paging__cs_sgsn__idx_defval;
extern const BOOLEAN& f__send__paging__cs_use__sig_defval;
extern BOOLEAN const_f__send__paging__cs_use__sig_defval;
extern const INTEGER& f__send__paging__cs__exp__one__bss_sgsn__idx_defval;
extern INTEGER const_f__send__paging__cs__exp__one__bss_sgsn__idx_defval;
extern const BOOLEAN& f__send__paging__cs__exp__one__bss_use__sig_defval;
extern BOOLEAN const_f__send__paging__cs__exp__one__bss_use__sig_defval;
extern const INTEGER& f__send__paging__cs__exp__one__bss_pcu__idx_defval;
extern INTEGER const_f__send__paging__cs__exp__one__bss_pcu__idx_defval;
extern const INTEGER& f__send__paging__cs__exp__no__bss_sgsn__idx_defval;
extern INTEGER const_f__send__paging__cs__exp__no__bss_sgsn__idx_defval;
extern const BOOLEAN& f__send__paging__cs__exp__no__bss_use__sig_defval;
extern BOOLEAN const_f__send__paging__cs__exp__no__bss_use__sig_defval;
extern const INTEGER& f__send__paging__cs__exp__multi_sgsn__idx_defval;
extern INTEGER const_f__send__paging__cs__exp__multi_sgsn__idx_defval;
extern const Osmocom__Gb__Types::BssgpCellId& cell__id__sgsn;
extern Osmocom__Gb__Types::BssgpCellId const_cell__id__sgsn;
extern const INTEGER& f__rim__pcu2sgsn_pcu__idx_defval;
extern INTEGER const_f__rim__pcu2sgsn_pcu__idx_defval;
extern const INTEGER& f__rim__sgsn2pcu_sgsn__idx_defval;
extern INTEGER const_f__rim__sgsn2pcu_sgsn__idx_defval;
extern const INTEGER& f__rim__sgsn2pcu_pcu__idx_defval;
extern INTEGER const_f__rim__sgsn2pcu_pcu__idx_defval;
extern const TTCN_Typedescriptor_t rim__fn_descr_;
extern const INTEGER& f__TC__rim__info__req_bvc__idx_defval;
extern INTEGER const_f__TC__rim__info__req_bvc__idx_defval;
extern const INTEGER& f__TC__rim__info_bvc__idx_defval;
extern INTEGER const_f__TC__rim__info_bvc__idx_defval;
extern const INTEGER& f__TC__rim__info__ack_bvc__idx_defval;
extern INTEGER const_f__TC__rim__info__ack_bvc__idx_defval;
extern const INTEGER& f__TC__rim__info__error_bvc__idx_defval;
extern INTEGER const_f__TC__rim__info__error_bvc__idx_defval;
extern const INTEGER& f__TC__rim__info__app__error_bvc__idx_defval;
extern INTEGER const_f__TC__rim__info__app__error_bvc__idx_defval;
extern const INTEGER& f__TC__rim__from__eutran_bvc__idx_defval;
extern INTEGER const_f__TC__rim__from__eutran_bvc__idx_defval;
extern const BITSTRING bs_0;
extern const HEXSTRING hs_2,
hs_0,
hs_1;
extern const OCTETSTRING os_0,
os_2,
os_5,
os_8,
os_6,
os_3,
os_7,
os_1,
os_9,
os_4;
extern const CHARSTRING cs_17,
cs_19,
cs_9,
cs_11,
cs_14,
cs_7,
cs_10,
cs_21,
cs_0,
cs_1,
cs_2,
cs_4,
cs_3,
cs_5,
cs_6,
cs_15,
cs_26,
cs_25,
cs_20,
cs_13,
cs_23,
cs_22,
cs_38,
cs_28,
cs_29,
cs_32,
cs_49,
cs_60,
cs_78,
cs_75,
cs_76,
cs_77,
cs_79,
cs_61,
cs_66,
cs_67,
cs_62,
cs_63,
cs_64,
cs_65,
cs_68,
cs_73,
cs_74,
cs_69,
cs_70,
cs_71,
cs_72,
cs_39,
cs_44,
cs_45,
cs_48,
cs_40,
cs_41,
cs_42,
cs_43,
cs_46,
cs_47,
cs_57,
cs_58,
cs_50,
cs_55,
cs_56,
cs_59,
cs_51,
cs_52,
cs_53,
cs_54,
cs_33,
cs_34,
cs_35,
cs_37,
cs_36,
cs_30,
cs_31,
cs_27,
cs_24,
cs_8,
cs_18,
cs_12,
cs_16;
extern const unsigned char module_checksum[];
extern TTCN_Module module_object;
extern const RuntimeVersionChecker ver_checker;

} /* end of namespace */

#endif
