//
// Copyright (C) 2012 Calin Cerchez
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  If not, see http://www.gnu.org/licenses/.
//

#ifndef RRCINFORMATIONELEMENTS_H_
#define RRCINFORMATIONELEMENTS_H_

#include "ASNTypes.h"
#include "RRCConstantDefinitions.h"

namespace rrc {

typedef BitString<CONSTRAINED, 14, 14> Ansi41IDNNS;

enum CNDomainIdentityValues {
	cs_domain_CNDomainIdentity = 0,
	ps_domain_CNDomainIdentity = 1,
};
typedef Enumerated<CONSTRAINED, 1> CNDomainIdentity;

typedef OctetString<CONSTRAINED, 1, 8> NASSystemInformationGSMMAP;

class CNDomainInformation : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CNDomainInformation(): Sequence(&theInfo) {}

	void setCnDomainIdentity(const CNDomainIdentity& cnDomainIdentity) { *static_cast<CNDomainIdentity*>(items[0]) = cnDomainIdentity; }
	void setCnDomainSpecificNASInfo(const NASSystemInformationGSMMAP& cnDomainSpecificNASInfo) { *static_cast<NASSystemInformationGSMMAP*>(items[1]) = cnDomainSpecificNASInfo; }
};

typedef Integer<CONSTRAINED, 6, 9> CNDRXCycleLengthCoefficient;

class CNDomainInformationFull : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CNDomainInformationFull(): Sequence(&theInfo) {}

	void setCnDomainIdentity(const CNDomainIdentity& cnDomainIdentity) { *static_cast<CNDomainIdentity*>(items[0]) = cnDomainIdentity; }
	void setCnDomainSpecificNASInfo(const NASSystemInformationGSMMAP& cnDomainSpecificNASInfo) { *static_cast<NASSystemInformationGSMMAP*>(items[1]) = cnDomainSpecificNASInfo; }
	void setCnDRXCycleLengthCoeff(const CNDRXCycleLengthCoefficient& cnDRXCycleLengthCoeff) { *static_cast<CNDRXCycleLengthCoefficient*>(items[2]) = cnDRXCycleLengthCoeff; }
};

typedef SequenceOf<CNDomainInformation, CONSTRAINED, 1, maxCNdomains> CNDomainInformationList;

typedef SequenceOf<CNDomainInformationFull, CONSTRAINED, 1, maxCNdomains> CNDomainInformationListFull;

typedef BitString<CONSTRAINED, 1, 2048> ANSI41NASParameter;

typedef ANSI41NASParameter NASSystemInformationANSI41;

class CNDomainSysInfoCnType : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CNDomainSysInfoCnTypeChoices {
		gsmMAP = 0,
		ansi41 = 1,
	};
	static const Info theInfo;
	CNDomainSysInfoCnType(): Choice(&theInfo) {}
};

class CNDomainSysInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CNDomainSysInfo(): Sequence(&theInfo) {}

	void setCnDomainIdentity(const CNDomainIdentity& cnDomainIdentity) { *static_cast<CNDomainIdentity*>(items[0]) = cnDomainIdentity; }
	void setCNDomainSysInfoCnType(const CNDomainSysInfoCnType& cNDomainSysInfoCnType) { *static_cast<CNDomainSysInfoCnType*>(items[1]) = cNDomainSysInfoCnType; }
	void setCnDRXCycleLengthCoeff(const CNDRXCycleLengthCoefficient& cnDRXCycleLengthCoeff) { *static_cast<CNDRXCycleLengthCoefficient*>(items[2]) = cnDRXCycleLengthCoeff; }
};

typedef SequenceOf<CNDomainSysInfo, CONSTRAINED, 1, maxCNdomains> CNDomainSysInfoList;

typedef Integer<CONSTRAINED, 0, 9> Digit;

typedef SequenceOf<Digit, CONSTRAINED, 3, 3> MCC;

typedef SequenceOf<Digit, CONSTRAINED, 2, 3> MNC;

class PLMNIdentity : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PLMNIdentity(): Sequence(&theInfo) {}

	void setMcc(const MCC& mcc) { *static_cast<MCC*>(items[0]) = mcc; }
	void setMnc(const MNC& mnc) { *static_cast<MNC*>(items[1]) = mnc; }
};

class CNInformationInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CNInformationInfo(): Sequence(&theInfo) {}

	void setPlmnIdentity(const PLMNIdentity& plmnIdentity) { *static_cast<PLMNIdentity*>(items[0]) = plmnIdentity; }
	void setCnCommonGSMMAPNASSysInfo(const NASSystemInformationGSMMAP& cnCommonGSMMAPNASSysInfo) { *static_cast<NASSystemInformationGSMMAP*>(items[1]) = cnCommonGSMMAPNASSysInfo; }
	void setCnDomainInformationList(const CNDomainInformationList& cnDomainInformationList) { *static_cast<CNDomainInformationList*>(items[2]) = cnDomainInformationList; }
};

class CNInformationInfor6 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CNInformationInfor6(): Sequence(&theInfo) {}

	void setPlmnIdentity(const PLMNIdentity& plmnIdentity) { *static_cast<PLMNIdentity*>(items[0]) = plmnIdentity; }
	void setCnCommonGSMMAPNASSysInfo(const NASSystemInformationGSMMAP& cnCommonGSMMAPNASSysInfo) { *static_cast<NASSystemInformationGSMMAP*>(items[1]) = cnCommonGSMMAPNASSysInfo; }
	void setCnDomainInformationList(const CNDomainInformationList& cnDomainInformationList) { *static_cast<CNDomainInformationList*>(items[2]) = cnDomainInformationList; }
	void setPrimaryplmnIdentity(const PLMNIdentity& primaryplmnIdentity) { *static_cast<PLMNIdentity*>(items[3]) = primaryplmnIdentity; }
};

class CNInformationInfoFull : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CNInformationInfoFull(): Sequence(&theInfo) {}

	void setPlmnIdentity(const PLMNIdentity& plmnIdentity) { *static_cast<PLMNIdentity*>(items[0]) = plmnIdentity; }
	void setCnCommonGSMMAPNASSysInfo(const NASSystemInformationGSMMAP& cnCommonGSMMAPNASSysInfo) { *static_cast<NASSystemInformationGSMMAP*>(items[1]) = cnCommonGSMMAPNASSysInfo; }
	void setCnDomainInformationListFull(const CNDomainInformationListFull& cnDomainInformationListFull) { *static_cast<CNDomainInformationListFull*>(items[2]) = cnDomainInformationListFull; }
};

typedef BitString<CONSTRAINED, 10, 10> RoutingParameter;

class GsmmapIDNNSRoutingbasisLocalPTMSI : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	GsmmapIDNNSRoutingbasisLocalPTMSI(): Sequence(&theInfo) {}

	void setRoutingparameter(const RoutingParameter& routingparameter) { *static_cast<RoutingParameter*>(items[0]) = routingparameter; }
};

class GsmmapIDNNSRoutingbasisTMSIofsamePLMN : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	GsmmapIDNNSRoutingbasisTMSIofsamePLMN(): Sequence(&theInfo) {}

	void setRoutingparameter(const RoutingParameter& routingparameter) { *static_cast<RoutingParameter*>(items[0]) = routingparameter; }
};

class GsmmapIDNNSRoutingbasisTMSIofdifferentPLMN : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	GsmmapIDNNSRoutingbasisTMSIofdifferentPLMN(): Sequence(&theInfo) {}

	void setRoutingparameter(const RoutingParameter& routingparameter) { *static_cast<RoutingParameter*>(items[0]) = routingparameter; }
};

class GsmmapIDNNSRoutingbasisIMSIresponsetopaging : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	GsmmapIDNNSRoutingbasisIMSIresponsetopaging(): Sequence(&theInfo) {}

	void setRoutingparameter(const RoutingParameter& routingparameter) { *static_cast<RoutingParameter*>(items[0]) = routingparameter; }
};

class GsmmapIDNNSRoutingbasisIMSIcauseUEinitiatedEvent : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	GsmmapIDNNSRoutingbasisIMSIcauseUEinitiatedEvent(): Sequence(&theInfo) {}

	void setRoutingparameter(const RoutingParameter& routingparameter) { *static_cast<RoutingParameter*>(items[0]) = routingparameter; }
};

class GsmmapIDNNSRoutingbasisIMEI : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	GsmmapIDNNSRoutingbasisIMEI(): Sequence(&theInfo) {}

	void setRoutingparameter(const RoutingParameter& routingparameter) { *static_cast<RoutingParameter*>(items[0]) = routingparameter; }
};

class GsmmapIDNNSRoutingbasisSpare2 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	GsmmapIDNNSRoutingbasisSpare2(): Sequence(&theInfo) {}

	void setRoutingparameter(const RoutingParameter& routingparameter) { *static_cast<RoutingParameter*>(items[0]) = routingparameter; }
};

class GsmmapIDNNSRoutingbasisSpare1 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	GsmmapIDNNSRoutingbasisSpare1(): Sequence(&theInfo) {}

	void setRoutingparameter(const RoutingParameter& routingparameter) { *static_cast<RoutingParameter*>(items[0]) = routingparameter; }
};

class GsmmapIDNNSRoutingbasis : public Choice {
private:
	static const void *choicesInfo[8];
public:
	enum GsmmapIDNNSRoutingbasisChoices {
		gsmmapIDNNSRoutingbasisLocalPTMSI = 0,
		gsmmapIDNNSRoutingbasisTMSIofsamePLMN = 1,
		gsmmapIDNNSRoutingbasisTMSIofdifferentPLMN = 2,
		gsmmapIDNNSRoutingbasisIMSIresponsetopaging = 3,
		gsmmapIDNNSRoutingbasisIMSIcauseUEinitiatedEvent = 4,
		gsmmapIDNNSRoutingbasisIMEI = 5,
		gsmmapIDNNSRoutingbasisSpare2 = 6,
		gsmmapIDNNSRoutingbasisSpare1 = 7,
	};
	static const Info theInfo;
	GsmmapIDNNSRoutingbasis(): Choice(&theInfo) {}
};

typedef Boolean GsmmapIDNNSDummy;

class GsmmapIDNNS : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	GsmmapIDNNS(): Sequence(&theInfo) {}

	void setGsmmapIDNNSRoutingbasis(const GsmmapIDNNSRoutingbasis& gsmmapIDNNSRoutingbasis) { *static_cast<GsmmapIDNNSRoutingbasis*>(items[0]) = gsmmapIDNNSRoutingbasis; }
	void setGsmmapIDNNSDummy(const GsmmapIDNNSDummy& gsmmapIDNNSDummy) { *static_cast<GsmmapIDNNSDummy*>(items[1]) = gsmmapIDNNSDummy; }
};

typedef Integer<CONSTRAINED, 0, 15> IMEIDigit;

typedef SequenceOf<IMEIDigit, CONSTRAINED, 15, 15> IMEI;

typedef SequenceOf<Digit, CONSTRAINED, 6, 21> IMSIGSMMAP;

class IntraDomainNasNodeSelectorVersionRelease99CnType : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum IntraDomainNasNodeSelectorVersionRelease99CnTypeChoices {
		gsmMapIDNNS = 0,
		ansi41IDNNS = 1,
	};
	static const Info theInfo;
	IntraDomainNasNodeSelectorVersionRelease99CnType(): Choice(&theInfo) {}
};

class IntraDomainNasNodeSelectorVersionRelease99 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	IntraDomainNasNodeSelectorVersionRelease99(): Sequence(&theInfo) {}

	void setIntraDomainNasNodeSelectorVersionRelease99CnType(const IntraDomainNasNodeSelectorVersionRelease99CnType& intraDomainNasNodeSelectorVersionRelease99CnType) { *static_cast<IntraDomainNasNodeSelectorVersionRelease99CnType*>(items[0]) = intraDomainNasNodeSelectorVersionRelease99CnType; }
};

typedef BitString<CONSTRAINED, 15, 15> IntraDomainNasNodeSelectorVersionLaterFuturecoding;

class IntraDomainNasNodeSelectorVersionLater : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	IntraDomainNasNodeSelectorVersionLater(): Sequence(&theInfo) {}

	void setIntraDomainNasNodeSelectorVersionLaterFuturecoding(const IntraDomainNasNodeSelectorVersionLaterFuturecoding& intraDomainNasNodeSelectorVersionLaterFuturecoding) { *static_cast<IntraDomainNasNodeSelectorVersionLaterFuturecoding*>(items[0]) = intraDomainNasNodeSelectorVersionLaterFuturecoding; }
};

class IntraDomainNasNodeSelectorVersion : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum IntraDomainNasNodeSelectorVersionChoices {
		intraDomainNasNodeSelectorVersionRelease99 = 0,
		intraDomainNasNodeSelectorVersionLater = 1,
	};
	static const Info theInfo;
	IntraDomainNasNodeSelectorVersion(): Choice(&theInfo) {}
};

class IntraDomainNasNodeSelector : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	IntraDomainNasNodeSelector(): Sequence(&theInfo) {}

	void setIntraDomainNasNodeSelectorVersion(const IntraDomainNasNodeSelectorVersion& intraDomainNasNodeSelectorVersion) { *static_cast<IntraDomainNasNodeSelectorVersion*>(items[0]) = intraDomainNasNodeSelectorVersion; }
};

typedef BitString<CONSTRAINED, 16, 16> LAILac;

class LAI : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	LAI(): Sequence(&theInfo) {}

	void setPlmnIdentity(const PLMNIdentity& plmnIdentity) { *static_cast<PLMNIdentity*>(items[0]) = plmnIdentity; }
	void setLAILac(const LAILac& lAILac) { *static_cast<LAILac*>(items[1]) = lAILac; }
};

enum AccessClassBarredValues {
	barred_AccessClassBarred = 0,
	notBarred_AccessClassBarred = 1,
};
typedef Enumerated<CONSTRAINED, 1> AccessClassBarred;

typedef SequenceOf<AccessClassBarred, CONSTRAINED, 15, 15> LocationRegistrationAccessClassBarredList;

typedef Null LocationRegistrationParametersNoRestriction;

class LocationRegistrationParameters : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum LocationRegistrationParametersChoices {
		locationRegistrationParametersNoRestriction = 0,
		restriction = 1,
	};
	static const Info theInfo;
	LocationRegistrationParameters(): Choice(&theInfo) {}
};

typedef Boolean MultiplePLMNListr6MibPLMNIdentity;

class PLMNIdentityWithOptionalMCCr6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PLMNIdentityWithOptionalMCCr6(): Sequence(&theInfo) {}

	void setMcc(const MCC& mcc) { *static_cast<MCC*>(items[0]) = mcc; }
	void setMnc(const MNC& mnc) { *static_cast<MNC*>(items[1]) = mnc; }
};

typedef SequenceOf<PLMNIdentityWithOptionalMCCr6, CONSTRAINED, 1, 5> MultiplePLMNListr6MultiplePLMNs;

class MultiplePLMNListr6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MultiplePLMNListr6(): Sequence(&theInfo) {}

	void setMultiplePLMNListr6MibPLMNIdentity(const MultiplePLMNListr6MibPLMNIdentity& multiplePLMNListr6MibPLMNIdentity) { *static_cast<MultiplePLMNListr6MibPLMNIdentity*>(items[0]) = multiplePLMNListr6MibPLMNIdentity; }
	void setMultiplePLMNListr6MultiplePLMNs(const MultiplePLMNListr6MultiplePLMNs& multiplePLMNListr6MultiplePLMNs) { *static_cast<MultiplePLMNListr6MultiplePLMNs*>(items[1]) = multiplePLMNListr6MultiplePLMNs; }
};

typedef OctetString<CONSTRAINED, 1, 4095> NASMessage;

typedef BitString<CONSTRAINED, 4, 4> NASSynchronisationIndicator;

typedef BitString<CONSTRAINED, 32, 32> PTMSIGSMMAP;

enum PagingPermissionWithAccessControlParameterspagingResponseRestrictionIndicatorValues {
	all_PagingPermissionWithAccessControlParameterspagingResponseRestrictionIndicator = 0,
	cS_PagingPermissionWithAccessControlParameterspagingResponseRestrictionIndicator = 1,
	pS_PagingPermissionWithAccessControlParameterspagingResponseRestrictionIndicator = 2,
	none_PagingPermissionWithAccessControlParameterspagingResponseRestrictionIndicator = 3,
};
typedef Enumerated<CONSTRAINED, 3> PagingPermissionWithAccessControlParameterspagingResponseRestrictionIndicator;

enum PagingPermissionWithAccessControlParameterslocationRegistrationRestrictionIndicatorValues {
	all_PagingPermissionWithAccessControlParameterslocationRegistrationRestrictionIndicator = 0,
	cS_PagingPermissionWithAccessControlParameterslocationRegistrationRestrictionIndicator = 1,
	pS_PagingPermissionWithAccessControlParameterslocationRegistrationRestrictionIndicator = 2,
};
typedef Enumerated<CONSTRAINED, 2> PagingPermissionWithAccessControlParameterslocationRegistrationRestrictionIndicator;

class PagingPermissionWithAccessControlParameters : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PagingPermissionWithAccessControlParameters(): Sequence(&theInfo) {}

	void setPagingPermissionWithAccessControlParameterspagingResponseRestrictionIndicator(const PagingPermissionWithAccessControlParameterspagingResponseRestrictionIndicator& pagingPermissionWithAccessControlParameterspagingResponseRestrictionIndicator) { *static_cast<PagingPermissionWithAccessControlParameterspagingResponseRestrictionIndicator*>(items[0]) = pagingPermissionWithAccessControlParameterspagingResponseRestrictionIndicator; }
	void setPagingPermissionWithAccessControlParameterslocationRegistrationRestrictionIndicator(const PagingPermissionWithAccessControlParameterslocationRegistrationRestrictionIndicator& pagingPermissionWithAccessControlParameterslocationRegistrationRestrictionIndicator) { *static_cast<PagingPermissionWithAccessControlParameterslocationRegistrationRestrictionIndicator*>(items[1]) = pagingPermissionWithAccessControlParameterslocationRegistrationRestrictionIndicator; }
	void setLocationRegistration(const LocationRegistrationParameters& locationRegistration) { *static_cast<LocationRegistrationParameters*>(items[2]) = locationRegistration; }
};

class PagingPermissionWithAccessControlList : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	PagingPermissionWithAccessControlList(): Sequence(&theInfo) {}

	void setPagingPermissionWithAccessControlParametersForOperator1(const PagingPermissionWithAccessControlParameters& pagingPermissionWithAccessControlParametersForOperator1) { *static_cast<PagingPermissionWithAccessControlParameters*>(items[0]) = pagingPermissionWithAccessControlParametersForOperator1; }
	void setPagingPermissionWithAccessControlParametersForOperator2(const PagingPermissionWithAccessControlParameters& pagingPermissionWithAccessControlParametersForOperator2) { *static_cast<PagingPermissionWithAccessControlParameters*>(items[1]) = pagingPermissionWithAccessControlParametersForOperator2; }
	void setPagingPermissionWithAccessControlParametersForOperator3(const PagingPermissionWithAccessControlParameters& pagingPermissionWithAccessControlParametersForOperator3) { *static_cast<PagingPermissionWithAccessControlParameters*>(items[2]) = pagingPermissionWithAccessControlParametersForOperator3; }
	void setPagingPermissionWithAccessControlParametersForOperator4(const PagingPermissionWithAccessControlParameters& pagingPermissionWithAccessControlParametersForOperator4) { *static_cast<PagingPermissionWithAccessControlParameters*>(items[3]) = pagingPermissionWithAccessControlParametersForOperator4; }
	void setPagingPermissionWithAccessControlParametersForOperator5(const PagingPermissionWithAccessControlParameters& pagingPermissionWithAccessControlParametersForOperator5) { *static_cast<PagingPermissionWithAccessControlParameters*>(items[4]) = pagingPermissionWithAccessControlParametersForOperator5; }
};

class PagingPermissionWithAccessControlForSharedNetwork : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PagingPermissionWithAccessControlForSharedNetworkChoices {
		pagingPermissionWithAccessControlList = 0,
		pagingPermissionWithAccessControlForAll = 1,
	};
	static const Info theInfo;
	PagingPermissionWithAccessControlForSharedNetwork(): Choice(&theInfo) {}
};

enum PagingRecordTypeIDValues {
	imsi_GSM_MAP_PagingRecordTypeID = 0,
	tmsi_GSM_MAP_P_TMSI_PagingRecordTypeID = 1,
	imsi_DS_41_PagingRecordTypeID = 2,
	tmsi_DS_41_PagingRecordTypeID = 3,
};
typedef Enumerated<CONSTRAINED, 3> PagingRecordTypeID;

class PLMNTypeGsmMAP : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PLMNTypeGsmMAP(): Sequence(&theInfo) {}

	void setPlmnIdentity(const PLMNIdentity& plmnIdentity) { *static_cast<PLMNIdentity*>(items[0]) = plmnIdentity; }
};

typedef BitString<CONSTRAINED, 8, 8> PREV;

typedef BitString<CONSTRAINED, 8, 8> MinPREV;

typedef BitString<CONSTRAINED, 15, 15> SID;

typedef BitString<CONSTRAINED, 16, 16> NID;

class PLMNTypeAnsi41 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	PLMNTypeAnsi41(): Sequence(&theInfo) {}

	void setPREV(const PREV& pREV) { *static_cast<PREV*>(items[0]) = pREV; }
	void setMinPREV(const MinPREV& minPREV) { *static_cast<MinPREV*>(items[1]) = minPREV; }
	void setSid(const SID& sid) { *static_cast<SID*>(items[2]) = sid; }
	void setNid(const NID& nid) { *static_cast<NID*>(items[3]) = nid; }
};

class PLMNTypeGsmMAPandANSI41 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	PLMNTypeGsmMAPandANSI41(): Sequence(&theInfo) {}

	void setPlmnIdentity(const PLMNIdentity& plmnIdentity) { *static_cast<PLMNIdentity*>(items[0]) = plmnIdentity; }
	void setPREV(const PREV& pREV) { *static_cast<PREV*>(items[1]) = pREV; }
	void setMinPREV(const MinPREV& minPREV) { *static_cast<MinPREV*>(items[2]) = minPREV; }
	void setSid(const SID& sid) { *static_cast<SID*>(items[3]) = sid; }
	void setNid(const NID& nid) { *static_cast<NID*>(items[4]) = nid; }
};

typedef Null PLMNTypeSpare;

class PLMNType : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum PLMNTypeChoices {
		pLMNTypeGsmMAP = 0,
		pLMNTypeAnsi41 = 1,
		pLMNTypeGsmMAPandANSI41 = 2,
		pLMNTypeSpare = 3,
	};
	static const Info theInfo;
	PLMNType(): Choice(&theInfo) {}
};

typedef BitString<CONSTRAINED, 8, 8> RABIdentityGsmMAPRABIdentity;

typedef BitString<CONSTRAINED, 8, 8> RABIdentityAnsi41RABIdentity;

class RABIdentity : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum RABIdentityChoices {
		rABIdentityGsmMAPRABIdentity = 0,
		rABIdentityAnsi41RABIdentity = 1,
	};
	static const Info theInfo;
	RABIdentity(): Choice(&theInfo) {}
};

typedef BitString<CONSTRAINED, 8, 8> RoutingAreaCode;

class RAI : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RAI(): Sequence(&theInfo) {}

	void setLai(const LAI& lai) { *static_cast<LAI*>(items[0]) = lai; }
	void setRac(const RoutingAreaCode& rac) { *static_cast<RoutingAreaCode*>(items[1]) = rac; }
};

typedef BitString<CONSTRAINED, 32, 32> TMSIGSMMAP;

typedef SequenceOf<AccessClassBarred, CONSTRAINED, maxAC, maxAC> AccessClassBarredList;

enum AllowedIndicatorValues {
	allowed_AllowedIndicator = 0,
	notAllowed_AllowedIndicator = 1,
};
typedef Enumerated<CONSTRAINED, 1> AllowedIndicator;

enum TBarredValues {
	s10_TBarred = 0,
	s20_TBarred = 1,
	s40_TBarred = 2,
	s80_TBarred = 3,
	s160_TBarred = 4,
	s320_TBarred = 5,
	s640_TBarred = 6,
	s1280_TBarred = 7,
};
typedef Enumerated<CONSTRAINED, 7> TBarred;

class CellBarredBarred : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CellBarredBarred(): Sequence(&theInfo) {}

	void setIntraFreqCellReselectionInd(const AllowedIndicator& intraFreqCellReselectionInd) { *static_cast<AllowedIndicator*>(items[0]) = intraFreqCellReselectionInd; }
	void setTBarred(const TBarred& tBarred) { *static_cast<TBarred*>(items[1]) = tBarred; }
};

typedef Null CellBarredNotBarred;

class CellBarred : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CellBarredChoices {
		cellBarredBarred = 0,
		cellBarredNotBarred = 1,
	};
	static const Info theInfo;
	CellBarred(): Choice(&theInfo) {}
};

enum ReservedIndicatorValues {
	reserved_ReservedIndicator = 0,
	notReserved_ReservedIndicator = 1,
};
typedef Enumerated<CONSTRAINED, 1> ReservedIndicator;

class CellAccessRestriction : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellAccessRestriction(): Sequence(&theInfo) {}

	void setCellBarred(const CellBarred& cellBarred) { *static_cast<CellBarred*>(items[0]) = cellBarred; }
	void setCellReservedForOperatorUse(const ReservedIndicator& cellReservedForOperatorUse) { *static_cast<ReservedIndicator*>(items[1]) = cellReservedForOperatorUse; }
	void setCellReservationExtension(const ReservedIndicator& cellReservationExtension) { *static_cast<ReservedIndicator*>(items[2]) = cellReservationExtension; }
	void setAccessClassBarredList(const AccessClassBarredList& accessClassBarredList) { *static_cast<AccessClassBarredList*>(items[3]) = accessClassBarredList; }
};

enum CellAccessRestrictionv870extcellReservedForCSGValues {
	true_CellAccessRestrictionv870extcellReservedForCSG = 0,
};
typedef Enumerated<CONSTRAINED, 0> CellAccessRestrictionv870extcellReservedForCSG;

class CellAccessRestrictionv870ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CellAccessRestrictionv870ext(): Sequence(&theInfo) {}

	void setCellAccessRestrictionv870extcellReservedForCSG(const CellAccessRestrictionv870extcellReservedForCSG& cellAccessRestrictionv870extcellReservedForCSG) { *static_cast<CellAccessRestrictionv870extcellReservedForCSG*>(items[0]) = cellAccessRestrictionv870extcellReservedForCSG; }
};

typedef BitString<CONSTRAINED, 28, 28> CellIdentity;

typedef SequenceOf<CellIdentity, CONSTRAINED, 1, maxRL> CellIdentityPerRLList;

enum RATValues {
	utra_FDD_RAT = 0,
	utra_TDD_RAT = 1,
	gsm_RAT = 2,
	cdma2000_RAT = 3,
};
typedef Enumerated<CONSTRAINED, 3> RAT;

enum MappingFunctionTypeValues {
	linear_MappingFunctionType = 0,
	functionType2_MappingFunctionType = 1,
	functionType3_MappingFunctionType = 2,
	functionType4_MappingFunctionType = 3,
};
typedef Enumerated<CONSTRAINED, 3> MappingFunctionType;

typedef Integer<CONSTRAINED, 0, 127> MapParameter;

typedef Integer<CONSTRAINED, 1, 91> UpperLimit;

class MappingFunctionParameter : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	MappingFunctionParameter(): Sequence(&theInfo) {}

	void setFunctionType(const MappingFunctionType& functionType) { *static_cast<MappingFunctionType*>(items[0]) = functionType; }
	void setMapParameter1(const MapParameter& mapParameter1) { *static_cast<MapParameter*>(items[1]) = mapParameter1; }
	void setMapParameter2(const MapParameter& mapParameter2) { *static_cast<MapParameter*>(items[2]) = mapParameter2; }
	void setUpperLimit(const UpperLimit& upperLimit) { *static_cast<UpperLimit*>(items[3]) = upperLimit; }
};

typedef SequenceOf<MappingFunctionParameter, CONSTRAINED, 1, maxMeasIntervals> MappingFunctionParameterList;

class Mapping : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	Mapping(): Sequence(&theInfo) {}

	void setRat(const RAT& rat) { *static_cast<RAT*>(items[0]) = rat; }
	void setMappingFunctionParameterList(const MappingFunctionParameterList& mappingFunctionParameterList) { *static_cast<MappingFunctionParameterList*>(items[1]) = mappingFunctionParameterList; }
};

typedef SequenceOf<Mapping, CONSTRAINED, 1, maxRAT> MappingInfo;

typedef Integer<CONSTRAINED, 0, 20> QHystS;

class CellSelectReselectInfoSIB34CellSelectQualityMeasureCpichEcN0 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB34CellSelectQualityMeasureCpichEcN0(): Sequence(&theInfo) {}

	void setQHYST2S(const QHystS& qHYST2S) { *static_cast<QHystS*>(items[0]) = qHYST2S; }
};

typedef Null CellSelectReselectInfoSIB34CellSelectQualityMeasureCpichRSCP;

class CellSelectReselectInfoSIB34CellSelectQualityMeasure : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CellSelectReselectInfoSIB34CellSelectQualityMeasureChoices {
		cellSelectReselectInfoSIB34CellSelectQualityMeasureCpichEcN0 = 0,
		cellSelectReselectInfoSIB34CellSelectQualityMeasureCpichRSCP = 1,
	};
	static const Info theInfo;
	CellSelectReselectInfoSIB34CellSelectQualityMeasure(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, -16, 10> SSearchQual;

typedef Integer<CONSTRAINED, -53, 45> SSearchRXLEV;

enum RATIdentifierValues {
	gsm_RATIdentifier = 0,
	cdma2000_RATIdentifier = 1,
};
typedef Enumerated<CONSTRAINED, 1> RATIdentifier;

class RATFDDInfo : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	RATFDDInfo(): Sequence(&theInfo) {}

	void setRatIdentifier(const RATIdentifier& ratIdentifier) { *static_cast<RATIdentifier*>(items[0]) = ratIdentifier; }
	void setSSearchRAT(const SSearchQual& sSearchRAT) { *static_cast<SSearchQual*>(items[1]) = sSearchRAT; }
	void setSHCSRAT(const SSearchRXLEV& sHCSRAT) { *static_cast<SSearchRXLEV*>(items[2]) = sHCSRAT; }
	void setSLimitSearchRAT(const SSearchQual& sLimitSearchRAT) { *static_cast<SSearchQual*>(items[3]) = sLimitSearchRAT; }
};

typedef SequenceOf<RATFDDInfo, CONSTRAINED, 1, maxOtherRAT> RATFDDInfoList;

typedef Integer<CONSTRAINED, -24, 0> QQualMin;

typedef Integer<CONSTRAINED, -58, -13> QRxlevMin;

class CellSelectReselectInfoSIB34ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB34ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setSIntrasearch(const SSearchQual& sIntrasearch) { *static_cast<SSearchQual*>(items[0]) = sIntrasearch; }
	void setSIntersearch(const SSearchQual& sIntersearch) { *static_cast<SSearchQual*>(items[1]) = sIntersearch; }
	void setSSearchHCS(const SSearchRXLEV& sSearchHCS) { *static_cast<SSearchRXLEV*>(items[2]) = sSearchHCS; }
	void setRatList(const RATFDDInfoList& ratList) { *static_cast<RATFDDInfoList*>(items[3]) = ratList; }
	void setQQualMin(const QQualMin& qQualMin) { *static_cast<QQualMin*>(items[4]) = qQualMin; }
	void setQRxlevMin(const QRxlevMin& qRxlevMin) { *static_cast<QRxlevMin*>(items[5]) = qRxlevMin; }
};

class RATTDDInfo : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	RATTDDInfo(): Sequence(&theInfo) {}

	void setRatIdentifier(const RATIdentifier& ratIdentifier) { *static_cast<RATIdentifier*>(items[0]) = ratIdentifier; }
	void setSSearchRAT(const SSearchRXLEV& sSearchRAT) { *static_cast<SSearchRXLEV*>(items[1]) = sSearchRAT; }
	void setSHCSRAT(const SSearchRXLEV& sHCSRAT) { *static_cast<SSearchRXLEV*>(items[2]) = sHCSRAT; }
	void setSLimitSearchRAT(const SSearchRXLEV& sLimitSearchRAT) { *static_cast<SSearchRXLEV*>(items[3]) = sLimitSearchRAT; }
};

typedef SequenceOf<RATTDDInfo, CONSTRAINED, 1, maxOtherRAT> RATTDDInfoList;

class CellSelectReselectInfoSIB34ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB34ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setSIntrasearch(const SSearchRXLEV& sIntrasearch) { *static_cast<SSearchRXLEV*>(items[0]) = sIntrasearch; }
	void setSIntersearch(const SSearchRXLEV& sIntersearch) { *static_cast<SSearchRXLEV*>(items[1]) = sIntersearch; }
	void setSSearchHCS(const SSearchRXLEV& sSearchHCS) { *static_cast<SSearchRXLEV*>(items[2]) = sSearchHCS; }
	void setRatList(const RATTDDInfoList& ratList) { *static_cast<RATTDDInfoList*>(items[3]) = ratList; }
	void setQRxlevMin(const QRxlevMin& qRxlevMin) { *static_cast<QRxlevMin*>(items[4]) = qRxlevMin; }
};

class CellSelectReselectInfoSIB34ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CellSelectReselectInfoSIB34ModeSpecificInfoChoices {
		cellSelectReselectInfoSIB34ModeSpecificInfoFdd = 0,
		cellSelectReselectInfoSIB34ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	CellSelectReselectInfoSIB34ModeSpecificInfo(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 31> TReselectionS;

typedef Integer<CONSTRAINED, 0, 7> HCSPRIO;

typedef Integer<CONSTRAINED, 0, 99> QHCS;

typedef Null TCRMaxNotUsed;

typedef Integer<CONSTRAINED, 1, 16> NCRTCRMaxHystNCR;

enum TCRMaxHystValues {
	notUsed_TCRMaxHyst = 0,
	t10_TCRMaxHyst = 1,
	t20_TCRMaxHyst = 2,
	t30_TCRMaxHyst = 3,
	t40_TCRMaxHyst = 4,
	t50_TCRMaxHyst = 5,
	t60_TCRMaxHyst = 6,
	t70_TCRMaxHyst = 7,
};
typedef Enumerated<CONSTRAINED, 7> TCRMaxHyst;

class NCRTCRMaxHyst : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	NCRTCRMaxHyst(): Sequence(&theInfo) {}

	void setNCRTCRMaxHystNCR(const NCRTCRMaxHystNCR& nCRTCRMaxHystNCR) { *static_cast<NCRTCRMaxHystNCR*>(items[0]) = nCRTCRMaxHystNCR; }
	void setTCRMaxHyst(const TCRMaxHyst& tCRMaxHyst) { *static_cast<TCRMaxHyst*>(items[1]) = tCRMaxHyst; }
};

class TCRMax : public Choice {
private:
	static const void *choicesInfo[6];
public:
	enum TCRMaxChoices {
		tCRMaxNotUsed = 0,
		t30 = 1,
		t60 = 2,
		t120 = 3,
		t180 = 4,
		t240 = 5,
	};
	static const Info theInfo;
	TCRMax(): Choice(&theInfo) {}
};

class HCSServingCellInformation : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	HCSServingCellInformation(): Sequence(&theInfo) {}

	void setHcsPRIO(const HCSPRIO& hcsPRIO) { *static_cast<HCSPRIO*>(items[0]) = hcsPRIO; }
	void setQHCS(const QHCS& qHCS) { *static_cast<QHCS*>(items[1]) = qHCS; }
	void setTCRMax(const TCRMax& tCRMax) { *static_cast<TCRMax*>(items[2]) = tCRMax; }
};

typedef Integer<CONSTRAINED, -50, 33> MaxAllowedULTXPower;

class CellSelectReselectInfoSIB34 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB34(): Sequence(&theInfo) {}

	void setMappingInfo(const MappingInfo& mappingInfo) { *static_cast<MappingInfo*>(items[0]) = mappingInfo; }
	void setCellSelectReselectInfoSIB34CellSelectQualityMeasure(const CellSelectReselectInfoSIB34CellSelectQualityMeasure& cellSelectReselectInfoSIB34CellSelectQualityMeasure) { *static_cast<CellSelectReselectInfoSIB34CellSelectQualityMeasure*>(items[1]) = cellSelectReselectInfoSIB34CellSelectQualityMeasure; }
	void setCellSelectReselectInfoSIB34ModeSpecificInfo(const CellSelectReselectInfoSIB34ModeSpecificInfo& cellSelectReselectInfoSIB34ModeSpecificInfo) { *static_cast<CellSelectReselectInfoSIB34ModeSpecificInfo*>(items[2]) = cellSelectReselectInfoSIB34ModeSpecificInfo; }
	void setQHystlS(const QHystS& qHystlS) { *static_cast<QHystS*>(items[3]) = qHystlS; }
	void setTReselectionS(const TReselectionS& tReselectionS) { *static_cast<TReselectionS*>(items[4]) = tReselectionS; }
	void setHcsServingCellInformation(const HCSServingCellInformation& hcsServingCellInformation) { *static_cast<HCSServingCellInformation*>(items[5]) = hcsServingCellInformation; }
	void setMaxAllowedULTXPower(const MaxAllowedULTXPower& maxAllowedULTXPower) { *static_cast<MaxAllowedULTXPower*>(items[6]) = maxAllowedULTXPower; }
};

typedef Integer<CONSTRAINED, 0, 16383> UARFCN;

class FrequencyInfoFDD : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	FrequencyInfoFDD(): Sequence(&theInfo) {}

	void setUarfcnUL(const UARFCN& uarfcnUL) { *static_cast<UARFCN*>(items[0]) = uarfcnUL; }
	void setUarfcnDL(const UARFCN& uarfcnDL) { *static_cast<UARFCN*>(items[1]) = uarfcnDL; }
};

class FrequencyInfoTDD : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	FrequencyInfoTDD(): Sequence(&theInfo) {}

	void setUarfcnNt(const UARFCN& uarfcnNt) { *static_cast<UARFCN*>(items[0]) = uarfcnNt; }
};

class FrequencyInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum FrequencyInfoModeSpecificInfoChoices {
		fdd = 0,
		tdd = 1,
	};
	static const Info theInfo;
	FrequencyInfoModeSpecificInfo(): Choice(&theInfo) {}
};

class FrequencyInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	FrequencyInfo(): Sequence(&theInfo) {}

	void setFrequencyInfoModeSpecificInfo(const FrequencyInfoModeSpecificInfo& frequencyInfoModeSpecificInfo) { *static_cast<FrequencyInfoModeSpecificInfo*>(items[0]) = frequencyInfoModeSpecificInfo; }
};

typedef SequenceOf<FrequencyInfo, CONSTRAINED, 1, maxDedicatedCSGFreq> CSGDedicatedFrequencyInfoList;

typedef BitString<CONSTRAINED, 27, 27> CSGIdentity;

typedef Integer<CONSTRAINED, 0, 63> CSGPSCSplitInfoStartPSC;

enum CSGPSCSplitInfonumberOfPSCsValues {
	psc5_CSGPSCSplitInfonumberOfPSCs = 0,
	psc10_CSGPSCSplitInfonumberOfPSCs = 1,
	psc15_CSGPSCSplitInfonumberOfPSCs = 2,
	psc20_CSGPSCSplitInfonumberOfPSCs = 3,
	psc30_CSGPSCSplitInfonumberOfPSCs = 4,
	psc40_CSGPSCSplitInfonumberOfPSCs = 5,
	psc50_CSGPSCSplitInfonumberOfPSCs = 6,
	psc64_CSGPSCSplitInfonumberOfPSCs = 7,
	psc80_CSGPSCSplitInfonumberOfPSCs = 8,
	psc120_CSGPSCSplitInfonumberOfPSCs = 9,
	psc160_CSGPSCSplitInfonumberOfPSCs = 10,
	psc256_CSGPSCSplitInfonumberOfPSCs = 11,
	alltheRest_CSGPSCSplitInfonumberOfPSCs = 12,
	spare3_CSGPSCSplitInfonumberOfPSCs = 13,
	spare2_CSGPSCSplitInfonumberOfPSCs = 14,
	spare1_CSGPSCSplitInfonumberOfPSCs = 15,
};
typedef Enumerated<CONSTRAINED, 15> CSGPSCSplitInfonumberOfPSCs;

typedef Integer<CONSTRAINED, 1, 63> CSGPSCSplitInfoPscRange2Offset;

class CSGPSCSplitInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CSGPSCSplitInfo(): Sequence(&theInfo) {}

	void setCSGPSCSplitInfoStartPSC(const CSGPSCSplitInfoStartPSC& cSGPSCSplitInfoStartPSC) { *static_cast<CSGPSCSplitInfoStartPSC*>(items[0]) = cSGPSCSplitInfoStartPSC; }
	void setCSGPSCSplitInfonumberOfPSCs(const CSGPSCSplitInfonumberOfPSCs& cSGPSCSplitInfonumberOfPSCs) { *static_cast<CSGPSCSplitInfonumberOfPSCs*>(items[1]) = cSGPSCSplitInfonumberOfPSCs; }
	void setCSGPSCSplitInfoPscRange2Offset(const CSGPSCSplitInfoPscRange2Offset& cSGPSCSplitInfoPscRange2Offset) { *static_cast<CSGPSCSplitInfoPscRange2Offset*>(items[2]) = cSGPSCSplitInfoPscRange2Offset; }
};

typedef Null DomainSpecificAccessRestrictionv670extNoRestriction;

class DomainSpecificAccessRestrictionv670extRestriction : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DomainSpecificAccessRestrictionv670extRestriction(): Sequence(&theInfo) {}

	void setDomainSpecficAccessClassBarredList(const AccessClassBarredList& domainSpecficAccessClassBarredList) { *static_cast<AccessClassBarredList*>(items[0]) = domainSpecficAccessClassBarredList; }
};

class DomainSpecificAccessRestrictionv670ext : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DomainSpecificAccessRestrictionv670extChoices {
		domainSpecificAccessRestrictionv670extNoRestriction = 0,
		domainSpecificAccessRestrictionv670extRestriction = 1,
	};
	static const Info theInfo;
	DomainSpecificAccessRestrictionv670ext(): Choice(&theInfo) {}
};

class DomainSpecificAccessRestrictionParamv670ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DomainSpecificAccessRestrictionParamv670ext(): Sequence(&theInfo) {}

	void setCSDomainSpecificAccessRestriction(const DomainSpecificAccessRestrictionv670ext& cSDomainSpecificAccessRestriction) { *static_cast<DomainSpecificAccessRestrictionv670ext*>(items[0]) = cSDomainSpecificAccessRestriction; }
	void setPSDomainSpecificAccessRestriction(const DomainSpecificAccessRestrictionv670ext& pSDomainSpecificAccessRestriction) { *static_cast<DomainSpecificAccessRestrictionv670ext*>(items[1]) = pSDomainSpecificAccessRestriction; }
};

class DomainSpecificAccessRestrictionListv670ext : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	DomainSpecificAccessRestrictionListv670ext(): Sequence(&theInfo) {}

	void setDomainSpecificAccessRestrictionParametersForOperator1(const DomainSpecificAccessRestrictionParamv670ext& domainSpecificAccessRestrictionParametersForOperator1) { *static_cast<DomainSpecificAccessRestrictionParamv670ext*>(items[0]) = domainSpecificAccessRestrictionParametersForOperator1; }
	void setDomainSpecificAccessRestrictionParametersForOperator2(const DomainSpecificAccessRestrictionParamv670ext& domainSpecificAccessRestrictionParametersForOperator2) { *static_cast<DomainSpecificAccessRestrictionParamv670ext*>(items[1]) = domainSpecificAccessRestrictionParametersForOperator2; }
	void setDomainSpecificAccessRestrictionParametersForOperator3(const DomainSpecificAccessRestrictionParamv670ext& domainSpecificAccessRestrictionParametersForOperator3) { *static_cast<DomainSpecificAccessRestrictionParamv670ext*>(items[2]) = domainSpecificAccessRestrictionParametersForOperator3; }
	void setDomainSpecificAccessRestrictionParametersForOperator4(const DomainSpecificAccessRestrictionParamv670ext& domainSpecificAccessRestrictionParametersForOperator4) { *static_cast<DomainSpecificAccessRestrictionParamv670ext*>(items[3]) = domainSpecificAccessRestrictionParametersForOperator4; }
	void setDomainSpecificAccessRestrictionParametersForOperator5(const DomainSpecificAccessRestrictionParamv670ext& domainSpecificAccessRestrictionParametersForOperator5) { *static_cast<DomainSpecificAccessRestrictionParamv670ext*>(items[4]) = domainSpecificAccessRestrictionParametersForOperator5; }
};

class DomainSpecificAccessRestrictionForSharedNetworkv670ext : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DomainSpecificAccessRestrictionForSharedNetworkv670extChoices {
		domainSpecificAccessRestictionList = 0,
		domainSpecificAccessRestictionParametersForAll = 1,
	};
	static const Info theInfo;
	DomainSpecificAccessRestrictionForSharedNetworkv670ext(): Choice(&theInfo) {}
};

class MappingLCRr4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MappingLCRr4(): Sequence(&theInfo) {}

	void setMappingFunctionParameterList(const MappingFunctionParameterList& mappingFunctionParameterList) { *static_cast<MappingFunctionParameterList*>(items[0]) = mappingFunctionParameterList; }
};

typedef Integer<CONSTRAINED, 1, maxSCCPCH> OccurrenceSequenceNumberOfPICH;

typedef Null DedicatedPriorityInformationActionClearDedicatedPriorities;

enum T322Values {
	m5_T322 = 0,
	m10_T322 = 1,
	m20_T322 = 2,
	m30_T322 = 3,
	m60_T322 = 4,
	m120_T322 = 5,
	m180_T322 = 6,
	spare1_T322 = 7,
};
typedef Enumerated<CONSTRAINED, 7> T322;

typedef Integer<CONSTRAINED, 0, maxPrio_1> PriorityLevelPriority;

class PriorityLevelRadioAccessTechnologyUtraFDD : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	PriorityLevelRadioAccessTechnologyUtraFDD(): Sequence(&theInfo) {}

};

class PriorityLevelRadioAccessTechnologyUtraTDD : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	PriorityLevelRadioAccessTechnologyUtraTDD(): Sequence(&theInfo) {}

};

class PriorityLevelRadioAccessTechnologyEutra : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	PriorityLevelRadioAccessTechnologyEutra(): Sequence(&theInfo) {}

};

typedef Integer<CONSTRAINED, 0, 1023> BCCHARFCN;

enum GSMCellGroupbandIndicatorValues {
	dcs1800_GSMCellGroupbandIndicator = 0,
	pcs1900_GSMCellGroupbandIndicator = 1,
};
typedef Enumerated<CONSTRAINED, 1> GSMCellGroupbandIndicator;

typedef SequenceOf<BCCHARFCN, CONSTRAINED, 0, 31> GSMCellGroupFollowingARFCNsExplicitListOfARFCNs;

typedef Integer<CONSTRAINED, 1, 8> GSMCellGroupFollowingARFCNsEquallySpacedARFCNsArfcnSpacing;

typedef Integer<CONSTRAINED, 0, 31> GSMCellGroupFollowingARFCNsEquallySpacedARFCNsNumberOfFollowingARFCNs;

class GSMCellGroupFollowingARFCNsEquallySpacedARFCNs : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	GSMCellGroupFollowingARFCNsEquallySpacedARFCNs(): Sequence(&theInfo) {}

	void setGSMCellGroupFollowingARFCNsEquallySpacedARFCNsArfcnSpacing(const GSMCellGroupFollowingARFCNsEquallySpacedARFCNsArfcnSpacing& gSMCellGroupFollowingARFCNsEquallySpacedARFCNsArfcnSpacing) { *static_cast<GSMCellGroupFollowingARFCNsEquallySpacedARFCNsArfcnSpacing*>(items[0]) = gSMCellGroupFollowingARFCNsEquallySpacedARFCNsArfcnSpacing; }
	void setGSMCellGroupFollowingARFCNsEquallySpacedARFCNsNumberOfFollowingARFCNs(const GSMCellGroupFollowingARFCNsEquallySpacedARFCNsNumberOfFollowingARFCNs& gSMCellGroupFollowingARFCNsEquallySpacedARFCNsNumberOfFollowingARFCNs) { *static_cast<GSMCellGroupFollowingARFCNsEquallySpacedARFCNsNumberOfFollowingARFCNs*>(items[1]) = gSMCellGroupFollowingARFCNsEquallySpacedARFCNsNumberOfFollowingARFCNs; }
};

typedef OctetString<CONSTRAINED, 1, 16> GSMCellGroupFollowingARFCNsVariableBitMapOfARFCNs;

class GSMCellGroupFollowingARFCNsContinuousRangeOfARFCNs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	GSMCellGroupFollowingARFCNsContinuousRangeOfARFCNs(): Sequence(&theInfo) {}

	void setEndingARFCN(const BCCHARFCN& endingARFCN) { *static_cast<BCCHARFCN*>(items[0]) = endingARFCN; }
};

class GSMCellGroupFollowingARFCNs : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum GSMCellGroupFollowingARFCNsChoices {
		gSMCellGroupFollowingARFCNsExplicitListOfARFCNs = 0,
		gSMCellGroupFollowingARFCNsEquallySpacedARFCNs = 1,
		gSMCellGroupFollowingARFCNsVariableBitMapOfARFCNs = 2,
		gSMCellGroupFollowingARFCNsContinuousRangeOfARFCNs = 3,
	};
	static const Info theInfo;
	GSMCellGroupFollowingARFCNs(): Choice(&theInfo) {}
};

class GSMCellGroup : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	GSMCellGroup(): Sequence(&theInfo) {}

	void setStartingARFCN(const BCCHARFCN& startingARFCN) { *static_cast<BCCHARFCN*>(items[0]) = startingARFCN; }
	void setGSMCellGroupbandIndicator(const GSMCellGroupbandIndicator& gSMCellGroupbandIndicator) { *static_cast<GSMCellGroupbandIndicator*>(items[1]) = gSMCellGroupbandIndicator; }
	void setGSMCellGroupFollowingARFCNs(const GSMCellGroupFollowingARFCNs& gSMCellGroupFollowingARFCNs) { *static_cast<GSMCellGroupFollowingARFCNs*>(items[2]) = gSMCellGroupFollowingARFCNs; }
};

class PriorityLevelRadioAccessTechnologyGsm : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PriorityLevelRadioAccessTechnologyGsm(): Sequence(&theInfo) {}

	void setGsmCellGroup(const GSMCellGroup& gsmCellGroup) { *static_cast<GSMCellGroup*>(items[0]) = gsmCellGroup; }
};

class PriorityLevelRadioAccessTechnology : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum PriorityLevelRadioAccessTechnologyChoices {
		priorityLevelRadioAccessTechnologyUtraFDD = 0,
		priorityLevelRadioAccessTechnologyUtraTDD = 1,
		priorityLevelRadioAccessTechnologyEutra = 2,
		priorityLevelRadioAccessTechnologyGsm = 3,
	};
	static const Info theInfo;
	PriorityLevelRadioAccessTechnology(): Choice(&theInfo) {}
};

class PriorityLevel : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PriorityLevel(): Sequence(&theInfo) {}

	void setPriorityLevelPriority(const PriorityLevelPriority& priorityLevelPriority) { *static_cast<PriorityLevelPriority*>(items[0]) = priorityLevelPriority; }
	void setPriorityLevelRadioAccessTechnology(const PriorityLevelRadioAccessTechnology& priorityLevelRadioAccessTechnology) { *static_cast<PriorityLevelRadioAccessTechnology*>(items[1]) = priorityLevelRadioAccessTechnology; }
};

typedef SequenceOf<PriorityLevel, CONSTRAINED, 1, maxPrio> PriorityLevelList;

typedef Boolean DedicatedPriorityInformationActionConfigureDedicatedPrioritiesEutraDetection;

class DedicatedPriorityInformationActionConfigureDedicatedPriorities : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DedicatedPriorityInformationActionConfigureDedicatedPriorities(): Sequence(&theInfo) {}

	void setT322(const T322& t322) { *static_cast<T322*>(items[0]) = t322; }
	void setPriorityLevelList(const PriorityLevelList& priorityLevelList) { *static_cast<PriorityLevelList*>(items[1]) = priorityLevelList; }
	void setDedicatedPriorityInformationActionConfigureDedicatedPrioritiesEutraDetection(const DedicatedPriorityInformationActionConfigureDedicatedPrioritiesEutraDetection& dedicatedPriorityInformationActionConfigureDedicatedPrioritiesEutraDetection) { *static_cast<DedicatedPriorityInformationActionConfigureDedicatedPrioritiesEutraDetection*>(items[2]) = dedicatedPriorityInformationActionConfigureDedicatedPrioritiesEutraDetection; }
};

class DedicatedPriorityInformationAction : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DedicatedPriorityInformationActionChoices {
		dedicatedPriorityInformationActionClearDedicatedPriorities = 0,
		dedicatedPriorityInformationActionConfigureDedicatedPriorities = 1,
	};
	static const Info theInfo;
	DedicatedPriorityInformationAction(): Choice(&theInfo) {}
};

class DedicatedPriorityInformation : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DedicatedPriorityInformation(): Sequence(&theInfo) {}

	void setDedicatedPriorityInformationAction(const DedicatedPriorityInformationAction& dedicatedPriorityInformationAction) { *static_cast<DedicatedPriorityInformationAction*>(items[0]) = dedicatedPriorityInformationAction; }
};

typedef Integer<CONSTRAINED, 0, 40> QHystSFine;

typedef Integer<CONSTRAINED, 0, 10> SpeedDependentScalingFactor;

typedef Integer<CONSTRAINED, 0, 31> TReselectionSFine;

typedef Integer<CONSTRAINED, 4, 19> TreselectionScalingFactor;

typedef BitString<CONSTRAINED, 16, 16> URAIdentity;

typedef SequenceOf<URAIdentity, CONSTRAINED, 1, maxURA> URAIdentityList;

enum AccessStratumReleaseIndicatorValues {
	rel_4_AccessStratumReleaseIndicator = 0,
	rel_5_AccessStratumReleaseIndicator = 1,
	rel_6_AccessStratumReleaseIndicator = 2,
	rel_7_AccessStratumReleaseIndicator = 3,
	rel_8_AccessStratumReleaseIndicator = 4,
	rel_9_AccessStratumReleaseIndicator = 5,
	spare10_AccessStratumReleaseIndicator = 6,
	spare9_AccessStratumReleaseIndicator = 7,
	spare8_AccessStratumReleaseIndicator = 8,
	spare7_AccessStratumReleaseIndicator = 9,
	spare6_AccessStratumReleaseIndicator = 10,
	spare5_AccessStratumReleaseIndicator = 11,
	spare4_AccessStratumReleaseIndicator = 12,
	spare3_AccessStratumReleaseIndicator = 13,
	spare2_AccessStratumReleaseIndicator = 14,
	spare1_AccessStratumReleaseIndicator = 15,
};
typedef Enumerated<CONSTRAINED, 15> AccessStratumReleaseIndicator;

typedef Integer<CONSTRAINED, 0, 255> ActivationTime;

typedef Integer<CONSTRAINED, 1, 64> NAPRetransMax;

typedef Integer<CONSTRAINED, 1, 64> NAccessFails;

typedef Integer<CONSTRAINED, 0, 31> NFBONoAICH;

typedef Integer<CONSTRAINED, 0, 63> NSBOBusy;

typedef Integer<CONSTRAINED, 0, 31> NFBOAllBusy;

typedef Integer<CONSTRAINED, 0, 127> NFBOMismatch;

enum TCPCHValues {
	ct0_TCPCH = 0,
	ct1_TCPCH = 1,
};
typedef Enumerated<CONSTRAINED, 1> TCPCH;

class BackoffControlParams : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	BackoffControlParams(): Sequence(&theInfo) {}

	void setNAPRetransMax(const NAPRetransMax& nAPRetransMax) { *static_cast<NAPRetransMax*>(items[0]) = nAPRetransMax; }
	void setNAccessFails(const NAccessFails& nAccessFails) { *static_cast<NAccessFails*>(items[1]) = nAccessFails; }
	void setNfBONoAICH(const NFBONoAICH& nfBONoAICH) { *static_cast<NFBONoAICH*>(items[2]) = nfBONoAICH; }
	void setNsBOBusy(const NSBOBusy& nsBOBusy) { *static_cast<NSBOBusy*>(items[3]) = nsBOBusy; }
	void setNfBOAllBusy(const NFBOAllBusy& nfBOAllBusy) { *static_cast<NFBOAllBusy*>(items[4]) = nfBOAllBusy; }
	void setNfBOMismatch(const NFBOMismatch& nfBOMismatch) { *static_cast<NFBOMismatch*>(items[5]) = nfBOMismatch; }
	void setTCPCH(const TCPCH& tCPCH) { *static_cast<TCPCH*>(items[6]) = tCPCH; }
};

typedef Integer<CONSTRAINED, 1, 256> BandComb;

typedef BitString<CONSTRAINED, 16, 16> CRNTI;

typedef Boolean CapabilityUpdateRequirementUeRadioCapabilityFDDUpdateRequirement;

typedef Boolean CapabilityUpdateRequirementUeRadioCapabilityTDDUpdateRequirement;

enum SystemSpecificCapUpdateReqValues {
	gsm_SystemSpecificCapUpdateReq = 0,
};
typedef Enumerated<CONSTRAINED, 0> SystemSpecificCapUpdateReq;

typedef SequenceOf<SystemSpecificCapUpdateReq, CONSTRAINED, 1, maxSystemCapability> SystemSpecificCapUpdateReqList;

class CapabilityUpdateRequirement : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CapabilityUpdateRequirement(): Sequence(&theInfo) {}

	void setCapabilityUpdateRequirementUeRadioCapabilityFDDUpdateRequirement(const CapabilityUpdateRequirementUeRadioCapabilityFDDUpdateRequirement& capabilityUpdateRequirementUeRadioCapabilityFDDUpdateRequirement) { *static_cast<CapabilityUpdateRequirementUeRadioCapabilityFDDUpdateRequirement*>(items[0]) = capabilityUpdateRequirementUeRadioCapabilityFDDUpdateRequirement; }
	void setCapabilityUpdateRequirementUeRadioCapabilityTDDUpdateRequirement(const CapabilityUpdateRequirementUeRadioCapabilityTDDUpdateRequirement& capabilityUpdateRequirementUeRadioCapabilityTDDUpdateRequirement) { *static_cast<CapabilityUpdateRequirementUeRadioCapabilityTDDUpdateRequirement*>(items[1]) = capabilityUpdateRequirementUeRadioCapabilityTDDUpdateRequirement; }
	void setSystemSpecificCapUpdateReqList(const SystemSpecificCapUpdateReqList& systemSpecificCapUpdateReqList) { *static_cast<SystemSpecificCapUpdateReqList*>(items[2]) = systemSpecificCapUpdateReqList; }
};

typedef Boolean CapabilityUpdateRequirementr4extUeRadioCapabilityUpdateRequirementTDD128;

class CapabilityUpdateRequirementr4ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CapabilityUpdateRequirementr4ext(): Sequence(&theInfo) {}

	void setCapabilityUpdateRequirementr4extUeRadioCapabilityUpdateRequirementTDD128(const CapabilityUpdateRequirementr4extUeRadioCapabilityUpdateRequirementTDD128& capabilityUpdateRequirementr4extUeRadioCapabilityUpdateRequirementTDD128) { *static_cast<CapabilityUpdateRequirementr4extUeRadioCapabilityUpdateRequirementTDD128*>(items[0]) = capabilityUpdateRequirementr4extUeRadioCapabilityUpdateRequirementTDD128; }
};

typedef Boolean CapabilityUpdateRequirementr4UeRadioCapabilityFDDUpdateRequirementFDD;

typedef Boolean CapabilityUpdateRequirementr4UeRadioCapabilityTDDUpdateRequirementTDD384;

typedef Boolean CapabilityUpdateRequirementr4UeRadioCapabilityTDDUpdateRequirementTDD128;

class CapabilityUpdateRequirementr4 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CapabilityUpdateRequirementr4(): Sequence(&theInfo) {}

	void setCapabilityUpdateRequirementr4UeRadioCapabilityFDDUpdateRequirementFDD(const CapabilityUpdateRequirementr4UeRadioCapabilityFDDUpdateRequirementFDD& capabilityUpdateRequirementr4UeRadioCapabilityFDDUpdateRequirementFDD) { *static_cast<CapabilityUpdateRequirementr4UeRadioCapabilityFDDUpdateRequirementFDD*>(items[0]) = capabilityUpdateRequirementr4UeRadioCapabilityFDDUpdateRequirementFDD; }
	void setCapabilityUpdateRequirementr4UeRadioCapabilityTDDUpdateRequirementTDD384(const CapabilityUpdateRequirementr4UeRadioCapabilityTDDUpdateRequirementTDD384& capabilityUpdateRequirementr4UeRadioCapabilityTDDUpdateRequirementTDD384) { *static_cast<CapabilityUpdateRequirementr4UeRadioCapabilityTDDUpdateRequirementTDD384*>(items[1]) = capabilityUpdateRequirementr4UeRadioCapabilityTDDUpdateRequirementTDD384; }
	void setCapabilityUpdateRequirementr4UeRadioCapabilityTDDUpdateRequirementTDD128(const CapabilityUpdateRequirementr4UeRadioCapabilityTDDUpdateRequirementTDD128& capabilityUpdateRequirementr4UeRadioCapabilityTDDUpdateRequirementTDD128) { *static_cast<CapabilityUpdateRequirementr4UeRadioCapabilityTDDUpdateRequirementTDD128*>(items[2]) = capabilityUpdateRequirementr4UeRadioCapabilityTDDUpdateRequirementTDD128; }
	void setSystemSpecificCapUpdateReqList(const SystemSpecificCapUpdateReqList& systemSpecificCapUpdateReqList) { *static_cast<SystemSpecificCapUpdateReqList*>(items[3]) = systemSpecificCapUpdateReqList; }
};

typedef Boolean CapabilityUpdateRequirementr5UeRadioCapabilityFDDUpdateRequirementFDD;

typedef Boolean CapabilityUpdateRequirementr5UeRadioCapabilityTDDUpdateRequirementTDD384;

typedef Boolean CapabilityUpdateRequirementr5UeRadioCapabilityTDDUpdateRequirementTDD128;

enum SystemSpecificCapUpdateReqr5Values {
	gsm_SystemSpecificCapUpdateReqr5 = 0,
	geranIu_SystemSpecificCapUpdateReqr5 = 1,
};
typedef Enumerated<CONSTRAINED, 1> SystemSpecificCapUpdateReqr5;

typedef SequenceOf<SystemSpecificCapUpdateReqr5, CONSTRAINED, 1, maxSystemCapability> SystemSpecificCapUpdateReqListr5;

class CapabilityUpdateRequirementr5 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CapabilityUpdateRequirementr5(): Sequence(&theInfo) {}

	void setCapabilityUpdateRequirementr5UeRadioCapabilityFDDUpdateRequirementFDD(const CapabilityUpdateRequirementr5UeRadioCapabilityFDDUpdateRequirementFDD& capabilityUpdateRequirementr5UeRadioCapabilityFDDUpdateRequirementFDD) { *static_cast<CapabilityUpdateRequirementr5UeRadioCapabilityFDDUpdateRequirementFDD*>(items[0]) = capabilityUpdateRequirementr5UeRadioCapabilityFDDUpdateRequirementFDD; }
	void setCapabilityUpdateRequirementr5UeRadioCapabilityTDDUpdateRequirementTDD384(const CapabilityUpdateRequirementr5UeRadioCapabilityTDDUpdateRequirementTDD384& capabilityUpdateRequirementr5UeRadioCapabilityTDDUpdateRequirementTDD384) { *static_cast<CapabilityUpdateRequirementr5UeRadioCapabilityTDDUpdateRequirementTDD384*>(items[1]) = capabilityUpdateRequirementr5UeRadioCapabilityTDDUpdateRequirementTDD384; }
	void setCapabilityUpdateRequirementr5UeRadioCapabilityTDDUpdateRequirementTDD128(const CapabilityUpdateRequirementr5UeRadioCapabilityTDDUpdateRequirementTDD128& capabilityUpdateRequirementr5UeRadioCapabilityTDDUpdateRequirementTDD128) { *static_cast<CapabilityUpdateRequirementr5UeRadioCapabilityTDDUpdateRequirementTDD128*>(items[2]) = capabilityUpdateRequirementr5UeRadioCapabilityTDDUpdateRequirementTDD128; }
	void setSystemSpecificCapUpdateReqList(const SystemSpecificCapUpdateReqListr5& systemSpecificCapUpdateReqList) { *static_cast<SystemSpecificCapUpdateReqListr5*>(items[3]) = systemSpecificCapUpdateReqList; }
};

typedef Boolean CapabilityUpdateRequirementv770extUeRadioCapabilityTDDUpdateRequirementTDD768;

class CapabilityUpdateRequirementv770ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CapabilityUpdateRequirementv770ext(): Sequence(&theInfo) {}

	void setCapabilityUpdateRequirementv770extUeRadioCapabilityTDDUpdateRequirementTDD768(const CapabilityUpdateRequirementv770extUeRadioCapabilityTDDUpdateRequirementTDD768& capabilityUpdateRequirementv770extUeRadioCapabilityTDDUpdateRequirementTDD768) { *static_cast<CapabilityUpdateRequirementv770extUeRadioCapabilityTDDUpdateRequirementTDD768*>(items[0]) = capabilityUpdateRequirementv770extUeRadioCapabilityTDDUpdateRequirementTDD768; }
};

typedef Boolean CapabilityUpdateRequirementr7UeRadioCapabilityFDDUpdateRequirementFDD;

typedef Boolean CapabilityUpdateRequirementr7UeRadioCapabilityTDDUpdateRequirementTDD384;

typedef Boolean CapabilityUpdateRequirementr7UeRadioCapabilityTDDUpdateRequirementTDD768;

typedef Boolean CapabilityUpdateRequirementr7UeRadioCapabilityTDDUpdateRequirementTDD128;

class CapabilityUpdateRequirementr7 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	CapabilityUpdateRequirementr7(): Sequence(&theInfo) {}

	void setCapabilityUpdateRequirementr7UeRadioCapabilityFDDUpdateRequirementFDD(const CapabilityUpdateRequirementr7UeRadioCapabilityFDDUpdateRequirementFDD& capabilityUpdateRequirementr7UeRadioCapabilityFDDUpdateRequirementFDD) { *static_cast<CapabilityUpdateRequirementr7UeRadioCapabilityFDDUpdateRequirementFDD*>(items[0]) = capabilityUpdateRequirementr7UeRadioCapabilityFDDUpdateRequirementFDD; }
	void setCapabilityUpdateRequirementr7UeRadioCapabilityTDDUpdateRequirementTDD384(const CapabilityUpdateRequirementr7UeRadioCapabilityTDDUpdateRequirementTDD384& capabilityUpdateRequirementr7UeRadioCapabilityTDDUpdateRequirementTDD384) { *static_cast<CapabilityUpdateRequirementr7UeRadioCapabilityTDDUpdateRequirementTDD384*>(items[1]) = capabilityUpdateRequirementr7UeRadioCapabilityTDDUpdateRequirementTDD384; }
	void setCapabilityUpdateRequirementr7UeRadioCapabilityTDDUpdateRequirementTDD768(const CapabilityUpdateRequirementr7UeRadioCapabilityTDDUpdateRequirementTDD768& capabilityUpdateRequirementr7UeRadioCapabilityTDDUpdateRequirementTDD768) { *static_cast<CapabilityUpdateRequirementr7UeRadioCapabilityTDDUpdateRequirementTDD768*>(items[2]) = capabilityUpdateRequirementr7UeRadioCapabilityTDDUpdateRequirementTDD768; }
	void setCapabilityUpdateRequirementr7UeRadioCapabilityTDDUpdateRequirementTDD128(const CapabilityUpdateRequirementr7UeRadioCapabilityTDDUpdateRequirementTDD128& capabilityUpdateRequirementr7UeRadioCapabilityTDDUpdateRequirementTDD128) { *static_cast<CapabilityUpdateRequirementr7UeRadioCapabilityTDDUpdateRequirementTDD128*>(items[3]) = capabilityUpdateRequirementr7UeRadioCapabilityTDDUpdateRequirementTDD128; }
	void setSystemSpecificCapUpdateReqList(const SystemSpecificCapUpdateReqListr5& systemSpecificCapUpdateReqList) { *static_cast<SystemSpecificCapUpdateReqListr5*>(items[4]) = systemSpecificCapUpdateReqList; }
};

enum SystemSpecificCapUpdateReqr8Values {
	gsm_SystemSpecificCapUpdateReqr8 = 0,
	geranIu_SystemSpecificCapUpdateReqr8 = 1,
	eutra_SystemSpecificCapUpdateReqr8 = 2,
	spare5_SystemSpecificCapUpdateReqr8 = 3,
	spare4_SystemSpecificCapUpdateReqr8 = 4,
	spare3_SystemSpecificCapUpdateReqr8 = 5,
	spare2_SystemSpecificCapUpdateReqr8 = 6,
	spare1_SystemSpecificCapUpdateReqr8 = 7,
};
typedef Enumerated<CONSTRAINED, 7> SystemSpecificCapUpdateReqr8;

typedef SequenceOf<SystemSpecificCapUpdateReqr8, CONSTRAINED, 1, maxSystemCapability> SystemSpecificCapUpdateReqListr8;

class CapabilityUpdateRequirementv860ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CapabilityUpdateRequirementv860ext(): Sequence(&theInfo) {}

	void setSystemSpecificCapUpdateReqList(const SystemSpecificCapUpdateReqListr8& systemSpecificCapUpdateReqList) { *static_cast<SystemSpecificCapUpdateReqListr8*>(items[0]) = systemSpecificCapUpdateReqList; }
};

typedef Boolean CapabilityUpdateRequirementr8UeRadioCapabilityFDDUpdateRequirementFDD;

typedef Boolean CapabilityUpdateRequirementr8UeRadioCapabilityTDDUpdateRequirementTDD384;

typedef Boolean CapabilityUpdateRequirementr8UeRadioCapabilityTDDUpdateRequirementTDD768;

typedef Boolean CapabilityUpdateRequirementr8UeRadioCapabilityTDDUpdateRequirementTDD128;

class CapabilityUpdateRequirementr8 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	CapabilityUpdateRequirementr8(): Sequence(&theInfo) {}

	void setCapabilityUpdateRequirementr8UeRadioCapabilityFDDUpdateRequirementFDD(const CapabilityUpdateRequirementr8UeRadioCapabilityFDDUpdateRequirementFDD& capabilityUpdateRequirementr8UeRadioCapabilityFDDUpdateRequirementFDD) { *static_cast<CapabilityUpdateRequirementr8UeRadioCapabilityFDDUpdateRequirementFDD*>(items[0]) = capabilityUpdateRequirementr8UeRadioCapabilityFDDUpdateRequirementFDD; }
	void setCapabilityUpdateRequirementr8UeRadioCapabilityTDDUpdateRequirementTDD384(const CapabilityUpdateRequirementr8UeRadioCapabilityTDDUpdateRequirementTDD384& capabilityUpdateRequirementr8UeRadioCapabilityTDDUpdateRequirementTDD384) { *static_cast<CapabilityUpdateRequirementr8UeRadioCapabilityTDDUpdateRequirementTDD384*>(items[1]) = capabilityUpdateRequirementr8UeRadioCapabilityTDDUpdateRequirementTDD384; }
	void setCapabilityUpdateRequirementr8UeRadioCapabilityTDDUpdateRequirementTDD768(const CapabilityUpdateRequirementr8UeRadioCapabilityTDDUpdateRequirementTDD768& capabilityUpdateRequirementr8UeRadioCapabilityTDDUpdateRequirementTDD768) { *static_cast<CapabilityUpdateRequirementr8UeRadioCapabilityTDDUpdateRequirementTDD768*>(items[2]) = capabilityUpdateRequirementr8UeRadioCapabilityTDDUpdateRequirementTDD768; }
	void setCapabilityUpdateRequirementr8UeRadioCapabilityTDDUpdateRequirementTDD128(const CapabilityUpdateRequirementr8UeRadioCapabilityTDDUpdateRequirementTDD128& capabilityUpdateRequirementr8UeRadioCapabilityTDDUpdateRequirementTDD128) { *static_cast<CapabilityUpdateRequirementr8UeRadioCapabilityTDDUpdateRequirementTDD128*>(items[3]) = capabilityUpdateRequirementr8UeRadioCapabilityTDDUpdateRequirementTDD128; }
	void setSystemSpecificCapUpdateReqList(const SystemSpecificCapUpdateReqListr8& systemSpecificCapUpdateReqList) { *static_cast<SystemSpecificCapUpdateReqListr8*>(items[4]) = systemSpecificCapUpdateReqList; }
};

enum CellUpdateCauseValues {
	cellReselection_CellUpdateCause = 0,
	periodicalCellUpdate_CellUpdateCause = 1,
	uplinkDataTransmission_CellUpdateCause = 2,
	utran_pagingResponse_CellUpdateCause = 3,
	re_enteredServiceArea_CellUpdateCause = 4,
	radiolinkFailure_CellUpdateCause = 5,
	rlc_unrecoverableError_CellUpdateCause = 6,
	cellUpdateCause_ext_CellUpdateCause = 7,
};
typedef Enumerated<CONSTRAINED, 7> CellUpdateCause;

enum CellUpdateCauseextValues {
	mbms_Reception_CellUpdateCauseext = 0,
	mbms_PTP_RB_Request_CellUpdateCauseext = 1,
	dummy_CellUpdateCauseext = 2,
	spare1_CellUpdateCauseext = 3,
};
typedef Enumerated<CONSTRAINED, 3> CellUpdateCauseext;

enum ChipRateCapabilityValues {
	mcps3_84_ChipRateCapability = 0,
	mcps1_28_ChipRateCapability = 1,
};
typedef Enumerated<CONSTRAINED, 1> ChipRateCapability;

enum CipheringAlgorithmValues {
	uea0_CipheringAlgorithm = 0,
	uea1_CipheringAlgorithm = 1,
};
typedef Enumerated<CONSTRAINED, 1> CipheringAlgorithm;

enum CipheringAlgorithmr7Values {
	uea0_CipheringAlgorithmr7 = 0,
	uea1_CipheringAlgorithmr7 = 1,
	uea2_CipheringAlgorithmr7 = 2,
};
typedef Enumerated<CONSTRAINED, 2> CipheringAlgorithmr7;

typedef Null CipheringModeCommandDummy;

class CipheringModeCommand : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CipheringModeCommandChoices {
		startRestart = 0,
		cipheringModeCommandDummy = 1,
	};
	static const Info theInfo;
	CipheringModeCommand(): Choice(&theInfo) {}
};

class CipheringModeCommandr7 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CipheringModeCommandr7(): Sequence(&theInfo) {}

	void setStartRestart(const CipheringAlgorithmr7& startRestart) { *static_cast<CipheringAlgorithmr7*>(items[0]) = startRestart; }
};

typedef Integer<CONSTRAINED, 1, 32> RBIdentity;

typedef Integer<CONSTRAINED, 0, 4095> RLCSequenceNumber;

class RBActivationTimeInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RBActivationTimeInfo(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setRlcSequenceNumber(const RLCSequenceNumber& rlcSequenceNumber) { *static_cast<RLCSequenceNumber*>(items[1]) = rlcSequenceNumber; }
};

typedef SequenceOf<RBActivationTimeInfo, CONSTRAINED, 1, maxRB> RBActivationTimeInfoList;

class CipheringModeInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CipheringModeInfo(): Sequence(&theInfo) {}

	void setCipheringModeCommand(const CipheringModeCommand& cipheringModeCommand) { *static_cast<CipheringModeCommand*>(items[0]) = cipheringModeCommand; }
	void setActivationTimeForDPCH(const ActivationTime& activationTimeForDPCH) { *static_cast<ActivationTime*>(items[1]) = activationTimeForDPCH; }
	void setRbDLCiphActivationTimeInfo(const RBActivationTimeInfoList& rbDLCiphActivationTimeInfo) { *static_cast<RBActivationTimeInfoList*>(items[2]) = rbDLCiphActivationTimeInfo; }
};

class CipheringModeInfor7 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CipheringModeInfor7(): Sequence(&theInfo) {}

	void setCipheringModeCommand(const CipheringModeCommandr7& cipheringModeCommand) { *static_cast<CipheringModeCommandr7*>(items[0]) = cipheringModeCommand; }
	void setActivationTimeForDPCH(const ActivationTime& activationTimeForDPCH) { *static_cast<ActivationTime*>(items[1]) = activationTimeForDPCH; }
	void setRbDLCiphActivationTimeInfo(const RBActivationTimeInfoList& rbDLCiphActivationTimeInfo) { *static_cast<RBActivationTimeInfoList*>(items[2]) = rbDLCiphActivationTimeInfo; }
};

typedef OctetString<CONSTRAINED, 5, 7> IMSIDS41;

typedef OctetString<CONSTRAINED, 2, 17> TMSIDS41;

typedef Null CNPagedUEIdentitySpare3;

typedef Null CNPagedUEIdentitySpare2;

typedef Null CNPagedUEIdentitySpare1;

class CNPagedUEIdentity : public Choice {
private:
	static const void *choicesInfo[8];
public:
	enum CNPagedUEIdentityChoices {
		imsiGSMMAP = 0,
		tmsiGSMMAP = 1,
		pTMSIGSMMAP = 2,
		imsiDS41 = 3,
		tmsiDS41 = 4,
		cNPagedUEIdentitySpare3 = 5,
		cNPagedUEIdentitySpare2 = 6,
		cNPagedUEIdentitySpare1 = 7,
	};
	static const Info theInfo;
	CNPagedUEIdentity(): Choice(&theInfo) {}
};

typedef Boolean CompressedModeMeasCapabilityFddMeasurements;

typedef Boolean CompressedModeMeasCapabilityTddMeasurements;

typedef Boolean GSMMeasurementsGsm900;

typedef Boolean GSMMeasurementsDcs1800;

typedef Boolean GSMMeasurementsGsm1900;

class GSMMeasurements : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	GSMMeasurements(): Sequence(&theInfo) {}

	void setGSMMeasurementsGsm900(const GSMMeasurementsGsm900& gSMMeasurementsGsm900) { *static_cast<GSMMeasurementsGsm900*>(items[0]) = gSMMeasurementsGsm900; }
	void setGSMMeasurementsDcs1800(const GSMMeasurementsDcs1800& gSMMeasurementsDcs1800) { *static_cast<GSMMeasurementsDcs1800*>(items[1]) = gSMMeasurementsDcs1800; }
	void setGSMMeasurementsGsm1900(const GSMMeasurementsGsm1900& gSMMeasurementsGsm1900) { *static_cast<GSMMeasurementsGsm1900*>(items[2]) = gSMMeasurementsGsm1900; }
};

typedef Boolean CompressedModeMeasCapabilityMultiCarrierMeasurements;

class CompressedModeMeasCapability : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CompressedModeMeasCapability(): Sequence(&theInfo) {}

	void setCompressedModeMeasCapabilityFddMeasurements(const CompressedModeMeasCapabilityFddMeasurements& compressedModeMeasCapabilityFddMeasurements) { *static_cast<CompressedModeMeasCapabilityFddMeasurements*>(items[0]) = compressedModeMeasCapabilityFddMeasurements; }
	void setCompressedModeMeasCapabilityTddMeasurements(const CompressedModeMeasCapabilityTddMeasurements& compressedModeMeasCapabilityTddMeasurements) { *static_cast<CompressedModeMeasCapabilityTddMeasurements*>(items[1]) = compressedModeMeasCapabilityTddMeasurements; }
	void setGsmMeasurements(const GSMMeasurements& gsmMeasurements) { *static_cast<GSMMeasurements*>(items[2]) = gsmMeasurements; }
	void setCompressedModeMeasCapabilityMultiCarrierMeasurements(const CompressedModeMeasCapabilityMultiCarrierMeasurements& compressedModeMeasCapabilityMultiCarrierMeasurements) { *static_cast<CompressedModeMeasCapabilityMultiCarrierMeasurements*>(items[3]) = compressedModeMeasCapabilityMultiCarrierMeasurements; }
};

typedef Boolean CompressedModeMeasCapabilityLCRr4Tdd128Measurements;

class CompressedModeMeasCapabilityLCRr4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CompressedModeMeasCapabilityLCRr4(): Sequence(&theInfo) {}

	void setCompressedModeMeasCapabilityLCRr4Tdd128Measurements(const CompressedModeMeasCapabilityLCRr4Tdd128Measurements& compressedModeMeasCapabilityLCRr4Tdd128Measurements) { *static_cast<CompressedModeMeasCapabilityLCRr4Tdd128Measurements*>(items[0]) = compressedModeMeasCapabilityLCRr4Tdd128Measurements; }
};

enum CompressedModeMeasCapabilityv860extadjacentFrequencyMeasurementsValues {
	true_CompressedModeMeasCapabilityv860extadjacentFrequencyMeasurements = 0,
};
typedef Enumerated<CONSTRAINED, 0> CompressedModeMeasCapabilityv860extadjacentFrequencyMeasurements;

class CompressedModeMeasCapabilityv860ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CompressedModeMeasCapabilityv860ext(): Sequence(&theInfo) {}

	void setCompressedModeMeasCapabilityv860extadjacentFrequencyMeasurements(const CompressedModeMeasCapabilityv860extadjacentFrequencyMeasurements& compressedModeMeasCapabilityv860extadjacentFrequencyMeasurements) { *static_cast<CompressedModeMeasCapabilityv860extadjacentFrequencyMeasurements*>(items[0]) = compressedModeMeasCapabilityv860extadjacentFrequencyMeasurements; }
};

enum CompressedModeMeasCapabilityv920extinterBandMeasurementsValues {
	true_CompressedModeMeasCapabilityv920extinterBandMeasurements = 0,
};
typedef Enumerated<CONSTRAINED, 0> CompressedModeMeasCapabilityv920extinterBandMeasurements;

class CompressedModeMeasCapabilityv920ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CompressedModeMeasCapabilityv920ext(): Sequence(&theInfo) {}

	void setCompressedModeMeasCapabilityv920extinterBandMeasurements(const CompressedModeMeasCapabilityv920extinterBandMeasurements& compressedModeMeasCapabilityv920extinterBandMeasurements) { *static_cast<CompressedModeMeasCapabilityv920extinterBandMeasurements*>(items[0]) = compressedModeMeasCapabilityv920extinterBandMeasurements; }
};

typedef Integer<CONSTRAINED, 1, 64> RadioFrequencyBandEUTRA;

typedef Boolean CompressedModeMeasCapabEUTRACompressedMode;

class CompressedModeMeasCapabEUTRA : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CompressedModeMeasCapabEUTRA(): Sequence(&theInfo) {}

	void setRadioFrequencyBandEUTRA(const RadioFrequencyBandEUTRA& radioFrequencyBandEUTRA) { *static_cast<RadioFrequencyBandEUTRA*>(items[0]) = radioFrequencyBandEUTRA; }
	void setCompressedModeMeasCapabEUTRACompressedMode(const CompressedModeMeasCapabEUTRACompressedMode& compressedModeMeasCapabEUTRACompressedMode) { *static_cast<CompressedModeMeasCapabEUTRACompressedMode*>(items[1]) = compressedModeMeasCapabEUTRACompressedMode; }
};

typedef SequenceOf<CompressedModeMeasCapabEUTRA, CONSTRAINED, 1, maxFreqBandsEUTRA> CompressedModeMeasCapabEUTRAList;

enum RadioFrequencyBandFDDValues {
	fdd2100_RadioFrequencyBandFDD = 0,
	fdd1900_RadioFrequencyBandFDD = 1,
	fdd1800_RadioFrequencyBandFDD = 2,
	bandVI_RadioFrequencyBandFDD = 3,
	bandIV_RadioFrequencyBandFDD = 4,
	bandV_RadioFrequencyBandFDD = 5,
	bandVII_RadioFrequencyBandFDD = 6,
	extension_indicator_RadioFrequencyBandFDD = 7,
};
typedef Enumerated<CONSTRAINED, 7> RadioFrequencyBandFDD;

typedef Boolean CompressedModeMeasCapabFDDDlMeasurementsFDD;

typedef Boolean CompressedModeMeasCapabFDDUlMeasurementsFDD;

class CompressedModeMeasCapabFDD : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CompressedModeMeasCapabFDD(): Sequence(&theInfo) {}

	void setRadioFrequencyBandFDD(const RadioFrequencyBandFDD& radioFrequencyBandFDD) { *static_cast<RadioFrequencyBandFDD*>(items[0]) = radioFrequencyBandFDD; }
	void setCompressedModeMeasCapabFDDDlMeasurementsFDD(const CompressedModeMeasCapabFDDDlMeasurementsFDD& compressedModeMeasCapabFDDDlMeasurementsFDD) { *static_cast<CompressedModeMeasCapabFDDDlMeasurementsFDD*>(items[1]) = compressedModeMeasCapabFDDDlMeasurementsFDD; }
	void setCompressedModeMeasCapabFDDUlMeasurementsFDD(const CompressedModeMeasCapabFDDUlMeasurementsFDD& compressedModeMeasCapabFDDUlMeasurementsFDD) { *static_cast<CompressedModeMeasCapabFDDUlMeasurementsFDD*>(items[2]) = compressedModeMeasCapabFDDUlMeasurementsFDD; }
};

typedef SequenceOf<CompressedModeMeasCapabFDD, CONSTRAINED, 1, maxFreqBandsFDD> CompressedModeMeasCapabFDDList;

enum RadioFrequencyBandFDD2Values {
	bandVIII_RadioFrequencyBandFDD2 = 0,
	bandIX_RadioFrequencyBandFDD2 = 1,
	bandX_RadioFrequencyBandFDD2 = 2,
	bandXI_RadioFrequencyBandFDD2 = 3,
	bandXII_RadioFrequencyBandFDD2 = 4,
	bandXIII_RadioFrequencyBandFDD2 = 5,
	bandXIV_RadioFrequencyBandFDD2 = 6,
	bandXV_RadioFrequencyBandFDD2 = 7,
	bandXVI_RadioFrequencyBandFDD2 = 8,
	bandXVII_RadioFrequencyBandFDD2 = 9,
	bandXVIII_RadioFrequencyBandFDD2 = 10,
	bandXIX_RadioFrequencyBandFDD2 = 11,
	bandXX_RadioFrequencyBandFDD2 = 12,
	bandXXI_RadioFrequencyBandFDD2 = 13,
	bandXXII_RadioFrequencyBandFDD2 = 14,
	extension_indicator_RadioFrequencyBandFDD2 = 15,
};
typedef Enumerated<CONSTRAINED, 15> RadioFrequencyBandFDD2;

typedef Boolean CompressedModeMeasCapabFDD2DlMeasurementsFDD;

typedef Boolean CompressedModeMeasCapabFDD2UlMeasurementsFDD;

class CompressedModeMeasCapabFDD2 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CompressedModeMeasCapabFDD2(): Sequence(&theInfo) {}

	void setRadioFrequencyBandFDD(const RadioFrequencyBandFDD& radioFrequencyBandFDD) { *static_cast<RadioFrequencyBandFDD*>(items[0]) = radioFrequencyBandFDD; }
	void setRadioFrequencyBandFDD2(const RadioFrequencyBandFDD2& radioFrequencyBandFDD2) { *static_cast<RadioFrequencyBandFDD2*>(items[1]) = radioFrequencyBandFDD2; }
	void setCompressedModeMeasCapabFDD2DlMeasurementsFDD(const CompressedModeMeasCapabFDD2DlMeasurementsFDD& compressedModeMeasCapabFDD2DlMeasurementsFDD) { *static_cast<CompressedModeMeasCapabFDD2DlMeasurementsFDD*>(items[2]) = compressedModeMeasCapabFDD2DlMeasurementsFDD; }
	void setCompressedModeMeasCapabFDD2UlMeasurementsFDD(const CompressedModeMeasCapabFDD2UlMeasurementsFDD& compressedModeMeasCapabFDD2UlMeasurementsFDD) { *static_cast<CompressedModeMeasCapabFDD2UlMeasurementsFDD*>(items[3]) = compressedModeMeasCapabFDD2UlMeasurementsFDD; }
};

typedef SequenceOf<CompressedModeMeasCapabFDD2, CONSTRAINED, 1, maxFreqBandsFDD> CompressedModeMeasCapabFDDList2;

typedef Boolean CompressedModeMeasCapabFDDextDlMeasurementsFDD;

typedef Boolean CompressedModeMeasCapabFDDextUlMeasurementsFDD;

class CompressedModeMeasCapabFDDext : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CompressedModeMeasCapabFDDext(): Sequence(&theInfo) {}

	void setRadioFrequencyBandFDD2(const RadioFrequencyBandFDD2& radioFrequencyBandFDD2) { *static_cast<RadioFrequencyBandFDD2*>(items[0]) = radioFrequencyBandFDD2; }
	void setCompressedModeMeasCapabFDDextDlMeasurementsFDD(const CompressedModeMeasCapabFDDextDlMeasurementsFDD& compressedModeMeasCapabFDDextDlMeasurementsFDD) { *static_cast<CompressedModeMeasCapabFDDextDlMeasurementsFDD*>(items[1]) = compressedModeMeasCapabFDDextDlMeasurementsFDD; }
	void setCompressedModeMeasCapabFDDextUlMeasurementsFDD(const CompressedModeMeasCapabFDDextUlMeasurementsFDD& compressedModeMeasCapabFDDextUlMeasurementsFDD) { *static_cast<CompressedModeMeasCapabFDDextUlMeasurementsFDD*>(items[2]) = compressedModeMeasCapabFDDextUlMeasurementsFDD; }
};

typedef SequenceOf<CompressedModeMeasCapabFDDext, CONSTRAINED, 1, maxFreqBandsFDD> CompressedModeMeasCapabFDDListext;

enum RadioFrequencyBandTDDValues {
	a_RadioFrequencyBandTDD = 0,
	b_RadioFrequencyBandTDD = 1,
	c_RadioFrequencyBandTDD = 2,
	d_RadioFrequencyBandTDD = 3,
};
typedef Enumerated<CONSTRAINED, 3> RadioFrequencyBandTDD;

typedef Boolean CompressedModeMeasCapabTDDDlMeasurementsTDD;

typedef Boolean CompressedModeMeasCapabTDDUlMeasurementsTDD;

class CompressedModeMeasCapabTDD : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CompressedModeMeasCapabTDD(): Sequence(&theInfo) {}

	void setRadioFrequencyBandTDD(const RadioFrequencyBandTDD& radioFrequencyBandTDD) { *static_cast<RadioFrequencyBandTDD*>(items[0]) = radioFrequencyBandTDD; }
	void setCompressedModeMeasCapabTDDDlMeasurementsTDD(const CompressedModeMeasCapabTDDDlMeasurementsTDD& compressedModeMeasCapabTDDDlMeasurementsTDD) { *static_cast<CompressedModeMeasCapabTDDDlMeasurementsTDD*>(items[1]) = compressedModeMeasCapabTDDDlMeasurementsTDD; }
	void setCompressedModeMeasCapabTDDUlMeasurementsTDD(const CompressedModeMeasCapabTDDUlMeasurementsTDD& compressedModeMeasCapabTDDUlMeasurementsTDD) { *static_cast<CompressedModeMeasCapabTDDUlMeasurementsTDD*>(items[2]) = compressedModeMeasCapabTDDUlMeasurementsTDD; }
};

typedef SequenceOf<CompressedModeMeasCapabTDD, CONSTRAINED, 1, maxFreqBandsTDD> CompressedModeMeasCapabTDDList;

enum RadioFrequencyBandGSMValues {
	gsm450_RadioFrequencyBandGSM = 0,
	gsm480_RadioFrequencyBandGSM = 1,
	gsm850_RadioFrequencyBandGSM = 2,
	gsm900P_RadioFrequencyBandGSM = 3,
	gsm900E_RadioFrequencyBandGSM = 4,
	gsm1800_RadioFrequencyBandGSM = 5,
	gsm1900_RadioFrequencyBandGSM = 6,
	spare9_RadioFrequencyBandGSM = 7,
	spare8_RadioFrequencyBandGSM = 8,
	spare7_RadioFrequencyBandGSM = 9,
	spare6_RadioFrequencyBandGSM = 10,
	spare5_RadioFrequencyBandGSM = 11,
	spare4_RadioFrequencyBandGSM = 12,
	spare3_RadioFrequencyBandGSM = 13,
	spare2_RadioFrequencyBandGSM = 14,
	spare1_RadioFrequencyBandGSM = 15,
};
typedef Enumerated<CONSTRAINED, 15> RadioFrequencyBandGSM;

typedef Boolean CompressedModeMeasCapabGSMDlMeasurementsGSM;

typedef Boolean CompressedModeMeasCapabGSMUlMeasurementsGSM;

class CompressedModeMeasCapabGSM : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CompressedModeMeasCapabGSM(): Sequence(&theInfo) {}

	void setRadioFrequencyBandGSM(const RadioFrequencyBandGSM& radioFrequencyBandGSM) { *static_cast<RadioFrequencyBandGSM*>(items[0]) = radioFrequencyBandGSM; }
	void setCompressedModeMeasCapabGSMDlMeasurementsGSM(const CompressedModeMeasCapabGSMDlMeasurementsGSM& compressedModeMeasCapabGSMDlMeasurementsGSM) { *static_cast<CompressedModeMeasCapabGSMDlMeasurementsGSM*>(items[1]) = compressedModeMeasCapabGSMDlMeasurementsGSM; }
	void setCompressedModeMeasCapabGSMUlMeasurementsGSM(const CompressedModeMeasCapabGSMUlMeasurementsGSM& compressedModeMeasCapabGSMUlMeasurementsGSM) { *static_cast<CompressedModeMeasCapabGSMUlMeasurementsGSM*>(items[2]) = compressedModeMeasCapabGSMUlMeasurementsGSM; }
};

typedef SequenceOf<CompressedModeMeasCapabGSM, CONSTRAINED, 1, maxFreqBandsGSM> CompressedModeMeasCapabGSMList;

typedef Boolean CompressedModeMeasCapabMCDlMeasurementsMC;

typedef Boolean CompressedModeMeasCapabMCUlMeasurementsMC;

class CompressedModeMeasCapabMC : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CompressedModeMeasCapabMC(): Sequence(&theInfo) {}

	void setCompressedModeMeasCapabMCDlMeasurementsMC(const CompressedModeMeasCapabMCDlMeasurementsMC& compressedModeMeasCapabMCDlMeasurementsMC) { *static_cast<CompressedModeMeasCapabMCDlMeasurementsMC*>(items[0]) = compressedModeMeasCapabMCDlMeasurementsMC; }
	void setCompressedModeMeasCapabMCUlMeasurementsMC(const CompressedModeMeasCapabMCUlMeasurementsMC& compressedModeMeasCapabMCUlMeasurementsMC) { *static_cast<CompressedModeMeasCapabMCUlMeasurementsMC*>(items[1]) = compressedModeMeasCapabMCUlMeasurementsMC; }
};

typedef Integer<CONSTRAINED, 0, 28> NSIP;

typedef SequenceOf<NSIP, CONSTRAINED, 1, maxASC> InitialPriorityDelayList;

typedef Integer<CONSTRAINED, 0, 1> TPCStepSizeFDD;

typedef Null PowerControlAlgorithmAlgorithm2;

class PowerControlAlgorithm : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PowerControlAlgorithmChoices {
		algorithm1 = 0,
		powerControlAlgorithmAlgorithm2 = 1,
	};
	static const Info theInfo;
	PowerControlAlgorithm(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 63> DLDPCCHBER;

class CPCHParameters : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CPCHParameters(): Sequence(&theInfo) {}

	void setInitialPriorityDelayList(const InitialPriorityDelayList& initialPriorityDelayList) { *static_cast<InitialPriorityDelayList*>(items[0]) = initialPriorityDelayList; }
	void setBackoffControlParams(const BackoffControlParams& backoffControlParams) { *static_cast<BackoffControlParams*>(items[1]) = backoffControlParams; }
	void setPowerControlAlgorithm(const PowerControlAlgorithm& powerControlAlgorithm) { *static_cast<PowerControlAlgorithm*>(items[2]) = powerControlAlgorithm; }
	void setDlDPCCHBER(const DLDPCCHBER& dlDPCCHBER) { *static_cast<DLDPCCHBER*>(items[3]) = dlDPCCHBER; }
};

enum CSGProximityIndicationCapabilitysupportOfIntraFreqProximityIndicationValues {
	true_CSGProximityIndicationCapabilitysupportOfIntraFreqProximityIndication = 0,
};
typedef Enumerated<CONSTRAINED, 0> CSGProximityIndicationCapabilitysupportOfIntraFreqProximityIndication;

enum CSGProximityIndicationCapabilitysupportOfInterFreqProximityIndicationValues {
	true_CSGProximityIndicationCapabilitysupportOfInterFreqProximityIndication = 0,
};
typedef Enumerated<CONSTRAINED, 0> CSGProximityIndicationCapabilitysupportOfInterFreqProximityIndication;

enum CSGProximityIndicationCapabilitysupportOfE_UtraProximityIndicationValues {
	true_CSGProximityIndicationCapabilitysupportOfE_UtraProximityIndication = 0,
};
typedef Enumerated<CONSTRAINED, 0> CSGProximityIndicationCapabilitysupportOfE_UtraProximityIndication;

class CSGProximityIndicationCapability : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CSGProximityIndicationCapability(): Sequence(&theInfo) {}

	void setCSGProximityIndicationCapabilitysupportOfIntraFreqProximityIndication(const CSGProximityIndicationCapabilitysupportOfIntraFreqProximityIndication& cSGProximityIndicationCapabilitysupportOfIntraFreqProximityIndication) { *static_cast<CSGProximityIndicationCapabilitysupportOfIntraFreqProximityIndication*>(items[0]) = cSGProximityIndicationCapabilitysupportOfIntraFreqProximityIndication; }
	void setCSGProximityIndicationCapabilitysupportOfInterFreqProximityIndication(const CSGProximityIndicationCapabilitysupportOfInterFreqProximityIndication& cSGProximityIndicationCapabilitysupportOfInterFreqProximityIndication) { *static_cast<CSGProximityIndicationCapabilitysupportOfInterFreqProximityIndication*>(items[1]) = cSGProximityIndicationCapabilitysupportOfInterFreqProximityIndication; }
	void setCSGProximityIndicationCapabilitysupportOfE_UtraProximityIndication(const CSGProximityIndicationCapabilitysupportOfE_UtraProximityIndication& cSGProximityIndicationCapabilitysupportOfE_UtraProximityIndication) { *static_cast<CSGProximityIndicationCapabilitysupportOfE_UtraProximityIndication*>(items[2]) = cSGProximityIndicationCapabilitysupportOfE_UtraProximityIndication; }
};

enum DLCapabilityWithSimultaneousHSDSCHConfigValues {
	kbps32_DLCapabilityWithSimultaneousHSDSCHConfig = 0,
	kbps64_DLCapabilityWithSimultaneousHSDSCHConfig = 1,
	kbps128_DLCapabilityWithSimultaneousHSDSCHConfig = 2,
	kbps384_DLCapabilityWithSimultaneousHSDSCHConfig = 3,
};
typedef Enumerated<CONSTRAINED, 3> DLCapabilityWithSimultaneousHSDSCHConfig;

typedef Integer<CONSTRAINED, 0, 511> PrimaryScramblingCode;

class PrimaryCPICHInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PrimaryCPICHInfo(): Sequence(&theInfo) {}

	void setPrimaryScramblingCode(const PrimaryScramblingCode& primaryScramblingCode) { *static_cast<PrimaryScramblingCode*>(items[0]) = primaryScramblingCode; }
};

enum PCPICHUsageForChannelEstValues {
	mayBeUsed_PCPICHUsageForChannelEst = 0,
	shallNotBeUsed_PCPICHUsageForChannelEst = 1,
};
typedef Enumerated<CONSTRAINED, 1> PCPICHUsageForChannelEst;

typedef Integer<CONSTRAINED, 0, 149> DPCHFrameOffset;

typedef Integer<CONSTRAINED, 0, 9> FDPCHSlotFormat;

typedef Integer<CONSTRAINED, 1, 15> SecondaryScramblingCode;

typedef Integer<CONSTRAINED, 0, 255> ChannelisationCode256;

class SecondaryCPICHInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SecondaryCPICHInfo(): Sequence(&theInfo) {}

	void setSecondaryDLScramblingCode(const SecondaryScramblingCode& secondaryDLScramblingCode) { *static_cast<SecondaryScramblingCode*>(items[0]) = secondaryDLScramblingCode; }
	void setChannelisationCode(const ChannelisationCode256& channelisationCode) { *static_cast<ChannelisationCode256*>(items[1]) = channelisationCode; }
};

typedef Integer<CONSTRAINED, 0, 255> DLFDPCHInfoPerRLr7DlChannelisationCode;

typedef Integer<CONSTRAINED, 0, 5> TPCCombinationIndex;

enum STTDIndicationValues {
	true_STTDIndication = 0,
};
typedef Enumerated<CONSTRAINED, 0> STTDIndication;

class DLFDPCHInfoPerRLr7 : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	DLFDPCHInfoPerRLr7(): Sequence(&theInfo) {}

	void setPCPICHUsageForChannelEst(const PCPICHUsageForChannelEst& pCPICHUsageForChannelEst) { *static_cast<PCPICHUsageForChannelEst*>(items[0]) = pCPICHUsageForChannelEst; }
	void setFdpchFrameOffset(const DPCHFrameOffset& fdpchFrameOffset) { *static_cast<DPCHFrameOffset*>(items[1]) = fdpchFrameOffset; }
	void setFdpchSlotFormat(const FDPCHSlotFormat& fdpchSlotFormat) { *static_cast<FDPCHSlotFormat*>(items[2]) = fdpchSlotFormat; }
	void setSecondaryCPICHInfo(const SecondaryCPICHInfo& secondaryCPICHInfo) { *static_cast<SecondaryCPICHInfo*>(items[3]) = secondaryCPICHInfo; }
	void setSecondaryScramblingCode(const SecondaryScramblingCode& secondaryScramblingCode) { *static_cast<SecondaryScramblingCode*>(items[4]) = secondaryScramblingCode; }
	void setDLFDPCHInfoPerRLr7DlChannelisationCode(const DLFDPCHInfoPerRLr7DlChannelisationCode& dLFDPCHInfoPerRLr7DlChannelisationCode) { *static_cast<DLFDPCHInfoPerRLr7DlChannelisationCode*>(items[5]) = dLFDPCHInfoPerRLr7DlChannelisationCode; }
	void setTpcCombinationIndex(const TPCCombinationIndex& tpcCombinationIndex) { *static_cast<TPCCombinationIndex*>(items[6]) = tpcCombinationIndex; }
	void setSttdIndication(const STTDIndication& sttdIndication) { *static_cast<STTDIndication*>(items[7]) = sttdIndication; }
};

typedef Integer<CONSTRAINED, 0, 255> EAGCHChannelisationCode;

class EAGCHInformation : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	EAGCHInformation(): Sequence(&theInfo) {}

	void setEAGCHChannelisationCode(const EAGCHChannelisationCode& eAGCHChannelisationCode) { *static_cast<EAGCHChannelisationCode*>(items[0]) = eAGCHChannelisationCode; }
};

typedef Integer<CONSTRAINED, 0, 127> EHICHChannelisationCode;

typedef Integer<CONSTRAINED, 0, 39> EHICHRGCHSignatureSequence;

class EHICHInformation : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EHICHInformation(): Sequence(&theInfo) {}

	void setChannelisationCode(const EHICHChannelisationCode& channelisationCode) { *static_cast<EHICHChannelisationCode*>(items[0]) = channelisationCode; }
	void setSignatureSequence(const EHICHRGCHSignatureSequence& signatureSequence) { *static_cast<EHICHRGCHSignatureSequence*>(items[1]) = signatureSequence; }
};

typedef Integer<CONSTRAINED, 0, 5> ERGCHCombinationIndex;

class ERGCHInformation : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ERGCHInformation(): Sequence(&theInfo) {}

	void setSignatureSequence(const EHICHRGCHSignatureSequence& signatureSequence) { *static_cast<EHICHRGCHSignatureSequence*>(items[0]) = signatureSequence; }
	void setRgCombinationIndex(const ERGCHCombinationIndex& rgCombinationIndex) { *static_cast<ERGCHCombinationIndex*>(items[1]) = rgCombinationIndex; }
};

typedef Null DLInformationPerSecondaryRLERGCHInfoReleaseIndicator;

class DLInformationPerSecondaryRLERGCHInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerSecondaryRLERGCHInfoChoices {
		eRGCHInformation = 0,
		dLInformationPerSecondaryRLERGCHInfoReleaseIndicator = 1,
	};
	static const Info theInfo;
	DLInformationPerSecondaryRLERGCHInfo(): Choice(&theInfo) {}
};

class DLInformationPerSecondaryRL : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	DLInformationPerSecondaryRL(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setCellid(const CellIdentity& cellid) { *static_cast<CellIdentity*>(items[1]) = cellid; }
	void setDlFDPCHInfoPerRLSecULFreq(const DLFDPCHInfoPerRLr7& dlFDPCHInfoPerRLSecULFreq) { *static_cast<DLFDPCHInfoPerRLr7*>(items[2]) = dlFDPCHInfoPerRLSecULFreq; }
	void setEAGCHInformation(const EAGCHInformation& eAGCHInformation) { *static_cast<EAGCHInformation*>(items[3]) = eAGCHInformation; }
	void setEHICHInformation(const EHICHInformation& eHICHInformation) { *static_cast<EHICHInformation*>(items[4]) = eHICHInformation; }
	void setDLInformationPerSecondaryRLERGCHInfo(const DLInformationPerSecondaryRLERGCHInfo& dLInformationPerSecondaryRLERGCHInfo) { *static_cast<DLInformationPerSecondaryRLERGCHInfo*>(items[5]) = dLInformationPerSecondaryRLERGCHInfo; }
};

typedef SequenceOf<DLInformationPerSecondaryRL, CONSTRAINED, 1, maxEDCHRL> DLInformationPerSecondaryRLList;

typedef Integer<CONSTRAINED, 1, 8> DLPhysChCapabilityFDDMaxNoDPCHPDSCHCodes;

enum MaxNoPhysChBitsReceivedValues {
	dummy_MaxNoPhysChBitsReceived = 0,
	b1200_MaxNoPhysChBitsReceived = 1,
	b2400_MaxNoPhysChBitsReceived = 2,
	b3600_MaxNoPhysChBitsReceived = 3,
	b4800_MaxNoPhysChBitsReceived = 4,
	b7200_MaxNoPhysChBitsReceived = 5,
	b9600_MaxNoPhysChBitsReceived = 6,
	b14400_MaxNoPhysChBitsReceived = 7,
	b19200_MaxNoPhysChBitsReceived = 8,
	b28800_MaxNoPhysChBitsReceived = 9,
	b38400_MaxNoPhysChBitsReceived = 10,
	b48000_MaxNoPhysChBitsReceived = 11,
	b57600_MaxNoPhysChBitsReceived = 12,
	b67200_MaxNoPhysChBitsReceived = 13,
	b76800_MaxNoPhysChBitsReceived = 14,
};
typedef Enumerated<CONSTRAINED, 14> MaxNoPhysChBitsReceived;

typedef Boolean DLPhysChCapabilityFDDSupportForSF512;

typedef Boolean DLPhysChCapabilityFDDDummy;

typedef Null SimultaneousSCCPCHDPCHReceptionNotSupported;

enum MaxNoSCCPCHRLValues {
	rl1_MaxNoSCCPCHRL = 0,
};
typedef Enumerated<CONSTRAINED, 0> MaxNoSCCPCHRL;

typedef Boolean SimultaneousSCCPCHDPCHReceptionSupportedSimultaneousSCCPCHDPCHDPDCHReception;

class SimultaneousSCCPCHDPCHReceptionSupported : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SimultaneousSCCPCHDPCHReceptionSupported(): Sequence(&theInfo) {}

	void setMaxNoSCCPCHRL(const MaxNoSCCPCHRL& maxNoSCCPCHRL) { *static_cast<MaxNoSCCPCHRL*>(items[0]) = maxNoSCCPCHRL; }
	void setSimultaneousSCCPCHDPCHReceptionSupportedSimultaneousSCCPCHDPCHDPDCHReception(const SimultaneousSCCPCHDPCHReceptionSupportedSimultaneousSCCPCHDPCHDPDCHReception& simultaneousSCCPCHDPCHReceptionSupportedSimultaneousSCCPCHDPCHDPDCHReception) { *static_cast<SimultaneousSCCPCHDPCHReceptionSupportedSimultaneousSCCPCHDPCHDPDCHReception*>(items[1]) = simultaneousSCCPCHDPCHReceptionSupportedSimultaneousSCCPCHDPCHDPDCHReception; }
};

class SimultaneousSCCPCHDPCHReception : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum SimultaneousSCCPCHDPCHReceptionChoices {
		simultaneousSCCPCHDPCHReceptionNotSupported = 0,
		simultaneousSCCPCHDPCHReceptionSupported = 1,
	};
	static const Info theInfo;
	SimultaneousSCCPCHDPCHReception(): Choice(&theInfo) {}
};

class DLPhysChCapabilityFDD : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	DLPhysChCapabilityFDD(): Sequence(&theInfo) {}

	void setDLPhysChCapabilityFDDMaxNoDPCHPDSCHCodes(const DLPhysChCapabilityFDDMaxNoDPCHPDSCHCodes& dLPhysChCapabilityFDDMaxNoDPCHPDSCHCodes) { *static_cast<DLPhysChCapabilityFDDMaxNoDPCHPDSCHCodes*>(items[0]) = dLPhysChCapabilityFDDMaxNoDPCHPDSCHCodes; }
	void setMaxNoPhysChBitsReceived(const MaxNoPhysChBitsReceived& maxNoPhysChBitsReceived) { *static_cast<MaxNoPhysChBitsReceived*>(items[1]) = maxNoPhysChBitsReceived; }
	void setDLPhysChCapabilityFDDSupportForSF512(const DLPhysChCapabilityFDDSupportForSF512& dLPhysChCapabilityFDDSupportForSF512) { *static_cast<DLPhysChCapabilityFDDSupportForSF512*>(items[2]) = dLPhysChCapabilityFDDSupportForSF512; }
	void setDLPhysChCapabilityFDDDummy(const DLPhysChCapabilityFDDDummy& dLPhysChCapabilityFDDDummy) { *static_cast<DLPhysChCapabilityFDDDummy*>(items[3]) = dLPhysChCapabilityFDDDummy; }
	void setDummy2(const SimultaneousSCCPCHDPCHReception& dummy2) { *static_cast<SimultaneousSCCPCHDPCHReception*>(items[4]) = dummy2; }
};

enum SupportOfDedicatedPilotsForChEstimationValues {
	true_SupportOfDedicatedPilotsForChEstimation = 0,
};
typedef Enumerated<CONSTRAINED, 0> SupportOfDedicatedPilotsForChEstimation;

class DLPhysChCapabilityFDDv380ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLPhysChCapabilityFDDv380ext(): Sequence(&theInfo) {}

	void setDummy(const SupportOfDedicatedPilotsForChEstimation& dummy) { *static_cast<SupportOfDedicatedPilotsForChEstimation*>(items[0]) = dummy; }
};

typedef Integer<CONSTRAINED, 1, 20> HSDSCHphysicallayercategoryext;

enum DLPhysChCapabilityFDDv770exthsscchlessHsdschOperationValues {
	true_DLPhysChCapabilityFDDv770exthsscchlessHsdschOperation = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLPhysChCapabilityFDDv770exthsscchlessHsdschOperation;

enum DLPhysChCapabilityFDDv770extenhancedFdpchValues {
	true_DLPhysChCapabilityFDDv770extenhancedFdpch = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLPhysChCapabilityFDDv770extenhancedFdpch;

enum DLPhysChCapabilityFDDv770exthsdschReception_CellFachValues {
	true_DLPhysChCapabilityFDDv770exthsdschReception_CellFach = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLPhysChCapabilityFDDv770exthsdschReception_CellFach;

enum DLPhysChCapabilityFDDv770exthsdschReception_CellUraPchValues {
	true_DLPhysChCapabilityFDDv770exthsdschReception_CellUraPch = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLPhysChCapabilityFDDv770exthsdschReception_CellUraPch;

class DLPhysChCapabilityFDDv770ext : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	DLPhysChCapabilityFDDv770ext(): Sequence(&theInfo) {}

	void setHsdschphysicallayercategoryext(const HSDSCHphysicallayercategoryext& hsdschphysicallayercategoryext) { *static_cast<HSDSCHphysicallayercategoryext*>(items[0]) = hsdschphysicallayercategoryext; }
	void setDLPhysChCapabilityFDDv770exthsscchlessHsdschOperation(const DLPhysChCapabilityFDDv770exthsscchlessHsdschOperation& dLPhysChCapabilityFDDv770exthsscchlessHsdschOperation) { *static_cast<DLPhysChCapabilityFDDv770exthsscchlessHsdschOperation*>(items[1]) = dLPhysChCapabilityFDDv770exthsscchlessHsdschOperation; }
	void setDLPhysChCapabilityFDDv770extenhancedFdpch(const DLPhysChCapabilityFDDv770extenhancedFdpch& dLPhysChCapabilityFDDv770extenhancedFdpch) { *static_cast<DLPhysChCapabilityFDDv770extenhancedFdpch*>(items[2]) = dLPhysChCapabilityFDDv770extenhancedFdpch; }
	void setDLPhysChCapabilityFDDv770exthsdschReception_CellFach(const DLPhysChCapabilityFDDv770exthsdschReception_CellFach& dLPhysChCapabilityFDDv770exthsdschReception_CellFach) { *static_cast<DLPhysChCapabilityFDDv770exthsdschReception_CellFach*>(items[3]) = dLPhysChCapabilityFDDv770exthsdschReception_CellFach; }
	void setDLPhysChCapabilityFDDv770exthsdschReception_CellUraPch(const DLPhysChCapabilityFDDv770exthsdschReception_CellUraPch& dLPhysChCapabilityFDDv770exthsdschReception_CellUraPch) { *static_cast<DLPhysChCapabilityFDDv770exthsdschReception_CellUraPch*>(items[4]) = dLPhysChCapabilityFDDv770exthsdschReception_CellUraPch; }
};

typedef Integer<CONSTRAINED, 21, 24> HSDSCHphysicallayercategoryext2;

enum DLPhysChCapabilityFDDv860extsupportOfTargetCellPreConfigValues {
	true_DLPhysChCapabilityFDDv860extsupportOfTargetCellPreConfig = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLPhysChCapabilityFDDv860extsupportOfTargetCellPreConfig;

enum DLPhysChCapabilityFDDv860extsupportOfHsdschDrxOperationValues {
	true_DLPhysChCapabilityFDDv860extsupportOfHsdschDrxOperation = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLPhysChCapabilityFDDv860extsupportOfHsdschDrxOperation;

class DLPhysChCapabilityFDDv860ext : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLPhysChCapabilityFDDv860ext(): Sequence(&theInfo) {}

	void setHsdschphysicallayercategoryext2(const HSDSCHphysicallayercategoryext2& hsdschphysicallayercategoryext2) { *static_cast<HSDSCHphysicallayercategoryext2*>(items[0]) = hsdschphysicallayercategoryext2; }
	void setDLPhysChCapabilityFDDv860extsupportOfTargetCellPreConfig(const DLPhysChCapabilityFDDv860extsupportOfTargetCellPreConfig& dLPhysChCapabilityFDDv860extsupportOfTargetCellPreConfig) { *static_cast<DLPhysChCapabilityFDDv860extsupportOfTargetCellPreConfig*>(items[1]) = dLPhysChCapabilityFDDv860extsupportOfTargetCellPreConfig; }
	void setDLPhysChCapabilityFDDv860extsupportOfHsdschDrxOperation(const DLPhysChCapabilityFDDv860extsupportOfHsdschDrxOperation& dLPhysChCapabilityFDDv860extsupportOfHsdschDrxOperation) { *static_cast<DLPhysChCapabilityFDDv860extsupportOfHsdschDrxOperation*>(items[2]) = dLPhysChCapabilityFDDv860extsupportOfHsdschDrxOperation; }
};

typedef Integer<CONSTRAINED, 25, 28> HSDSCHphysicallayercategoryext3;

enum DLPhysChCapabilityFDDv920extsupportOfMimoOnlySingleStreamValues {
	true_DLPhysChCapabilityFDDv920extsupportOfMimoOnlySingleStream = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLPhysChCapabilityFDDv920extsupportOfMimoOnlySingleStream;

class DLPhysChCapabilityFDDv920ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLPhysChCapabilityFDDv920ext(): Sequence(&theInfo) {}

	void setHsdschphysicallayercategoryext3(const HSDSCHphysicallayercategoryext3& hsdschphysicallayercategoryext3) { *static_cast<HSDSCHphysicallayercategoryext3*>(items[0]) = hsdschphysicallayercategoryext3; }
	void setDLPhysChCapabilityFDDv920extsupportOfMimoOnlySingleStream(const DLPhysChCapabilityFDDv920extsupportOfMimoOnlySingleStream& dLPhysChCapabilityFDDv920extsupportOfMimoOnlySingleStream) { *static_cast<DLPhysChCapabilityFDDv920extsupportOfMimoOnlySingleStream*>(items[1]) = dLPhysChCapabilityFDDv920extsupportOfMimoOnlySingleStream; }
};

typedef Integer<CONSTRAINED, 1, 14> MaxTSPerFrame;

typedef Integer<CONSTRAINED, 1, 224> MaxPhysChPerFrame;

enum MinimumSFDLValues {
	sf1_MinimumSFDL = 0,
	sf16_MinimumSFDL = 1,
};
typedef Enumerated<CONSTRAINED, 1> MinimumSFDL;

typedef Boolean DLPhysChCapabilityTDDSupportOfPDSCH;

typedef Integer<CONSTRAINED, 1, 16> MaxPhysChPerTS;

class DLPhysChCapabilityTDD : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	DLPhysChCapabilityTDD(): Sequence(&theInfo) {}

	void setMaxTSPerFrame(const MaxTSPerFrame& maxTSPerFrame) { *static_cast<MaxTSPerFrame*>(items[0]) = maxTSPerFrame; }
	void setMaxPhysChPerFrame(const MaxPhysChPerFrame& maxPhysChPerFrame) { *static_cast<MaxPhysChPerFrame*>(items[1]) = maxPhysChPerFrame; }
	void setMinimumSF(const MinimumSFDL& minimumSF) { *static_cast<MinimumSFDL*>(items[2]) = minimumSF; }
	void setDLPhysChCapabilityTDDSupportOfPDSCH(const DLPhysChCapabilityTDDSupportOfPDSCH& dLPhysChCapabilityTDDSupportOfPDSCH) { *static_cast<DLPhysChCapabilityTDDSupportOfPDSCH*>(items[3]) = dLPhysChCapabilityTDDSupportOfPDSCH; }
	void setMaxPhysChPerTS(const MaxPhysChPerTS& maxPhysChPerTS) { *static_cast<MaxPhysChPerTS*>(items[4]) = maxPhysChPerTS; }
};

typedef Integer<CONSTRAINED, 1, 6> MaxTSPerSubFramer4;

typedef Integer<CONSTRAINED, 1, 96> MaxPhysChPerSubFramer4;

typedef Boolean DLPhysChCapabilityTDDLCRr4SupportOfPDSCH;

typedef Boolean DLPhysChCapabilityTDDLCRr4SupportOf8PSK;

class DLPhysChCapabilityTDDLCRr4 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	DLPhysChCapabilityTDDLCRr4(): Sequence(&theInfo) {}

	void setMaxTSPerSubFrame(const MaxTSPerSubFramer4& maxTSPerSubFrame) { *static_cast<MaxTSPerSubFramer4*>(items[0]) = maxTSPerSubFrame; }
	void setMaxPhysChPerFrame(const MaxPhysChPerSubFramer4& maxPhysChPerFrame) { *static_cast<MaxPhysChPerSubFramer4*>(items[1]) = maxPhysChPerFrame; }
	void setMinimumSF(const MinimumSFDL& minimumSF) { *static_cast<MinimumSFDL*>(items[2]) = minimumSF; }
	void setDLPhysChCapabilityTDDLCRr4SupportOfPDSCH(const DLPhysChCapabilityTDDLCRr4SupportOfPDSCH& dLPhysChCapabilityTDDLCRr4SupportOfPDSCH) { *static_cast<DLPhysChCapabilityTDDLCRr4SupportOfPDSCH*>(items[3]) = dLPhysChCapabilityTDDLCRr4SupportOfPDSCH; }
	void setMaxPhysChPerTS(const MaxPhysChPerTS& maxPhysChPerTS) { *static_cast<MaxPhysChPerTS*>(items[4]) = maxPhysChPerTS; }
	void setDLPhysChCapabilityTDDLCRr4SupportOf8PSK(const DLPhysChCapabilityTDDLCRr4SupportOf8PSK& dLPhysChCapabilityTDDLCRr4SupportOf8PSK) { *static_cast<DLPhysChCapabilityTDDLCRr4SupportOf8PSK*>(items[5]) = dLPhysChCapabilityTDDLCRr4SupportOf8PSK; }
};

typedef Integer<CONSTRAINED, 1, 64> MultiCarrierHSDSCHphysicallayercategory;

class DLPhysChCapabilityTDD128v770ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLPhysChCapabilityTDD128v770ext(): Sequence(&theInfo) {}

	void setMultiCarrierphysicallayercategory(const MultiCarrierHSDSCHphysicallayercategory& multiCarrierphysicallayercategory) { *static_cast<MultiCarrierHSDSCHphysicallayercategory*>(items[0]) = multiCarrierphysicallayercategory; }
};

typedef Integer<CONSTRAINED, 1, 64> HSDSCHphysicallayercategoryextension;

typedef Integer<CONSTRAINED, 1, 36> MultiCarrierHSDSCHphysicallayercategoryextension;

enum DLPhysChCapabilityTDD128v860extsupportOfSFModeForHSPDSCHDualStreamValues {
	sf1_DLPhysChCapabilityTDD128v860extsupportOfSFModeForHSPDSCHDualStream = 0,
	sf1sf16_DLPhysChCapabilityTDD128v860extsupportOfSFModeForHSPDSCHDualStream = 1,
};
typedef Enumerated<CONSTRAINED, 1> DLPhysChCapabilityTDD128v860extsupportOfSFModeForHSPDSCHDualStream;

class DLPhysChCapabilityTDD128v860ext : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLPhysChCapabilityTDD128v860ext(): Sequence(&theInfo) {}

	void setHSDSCHphysicallayercategoryextension(const HSDSCHphysicallayercategoryextension& hSDSCHphysicallayercategoryextension) { *static_cast<HSDSCHphysicallayercategoryextension*>(items[0]) = hSDSCHphysicallayercategoryextension; }
	void setMultiCarrierphysicallayercategoryextension(const MultiCarrierHSDSCHphysicallayercategoryextension& multiCarrierphysicallayercategoryextension) { *static_cast<MultiCarrierHSDSCHphysicallayercategoryextension*>(items[1]) = multiCarrierphysicallayercategoryextension; }
	void setDLPhysChCapabilityTDD128v860extsupportOfSFModeForHSPDSCHDualStream(const DLPhysChCapabilityTDD128v860extsupportOfSFModeForHSPDSCHDualStream& dLPhysChCapabilityTDD128v860extsupportOfSFModeForHSPDSCHDualStream) { *static_cast<DLPhysChCapabilityTDD128v860extsupportOfSFModeForHSPDSCHDualStream*>(items[2]) = dLPhysChCapabilityTDD128v860extsupportOfSFModeForHSPDSCHDualStream; }
};

typedef Integer<CONSTRAINED, 1, 448> MaxPhysChPerFrame768;

enum MinimumSFDL768Values {
	sf1_MinimumSFDL768 = 0,
	sf32_MinimumSFDL768 = 1,
};
typedef Enumerated<CONSTRAINED, 1> MinimumSFDL768;

typedef Boolean DLPhysChCapabilityTDD768SupportOfPDSCH;

typedef Integer<CONSTRAINED, 1, 64> HSDSCHphysicallayercategory;

typedef Null DLPhysChCapabilityTDD768Tdd768hspdschUnsupported;

class DLPhysChCapabilityTDD768Tdd768hspdsch : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLPhysChCapabilityTDD768Tdd768hspdschChoices {
		supported = 0,
		dLPhysChCapabilityTDD768Tdd768hspdschUnsupported = 1,
	};
	static const Info theInfo;
	DLPhysChCapabilityTDD768Tdd768hspdsch(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, 32> MaxPhysChPerTS768;

class DLPhysChCapabilityTDD768 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	DLPhysChCapabilityTDD768(): Sequence(&theInfo) {}

	void setMaxTSPerFrame(const MaxTSPerFrame& maxTSPerFrame) { *static_cast<MaxTSPerFrame*>(items[0]) = maxTSPerFrame; }
	void setMaxPhysChPerFrame(const MaxPhysChPerFrame768& maxPhysChPerFrame) { *static_cast<MaxPhysChPerFrame768*>(items[1]) = maxPhysChPerFrame; }
	void setMinimumSF(const MinimumSFDL768& minimumSF) { *static_cast<MinimumSFDL768*>(items[2]) = minimumSF; }
	void setDLPhysChCapabilityTDD768SupportOfPDSCH(const DLPhysChCapabilityTDD768SupportOfPDSCH& dLPhysChCapabilityTDD768SupportOfPDSCH) { *static_cast<DLPhysChCapabilityTDD768SupportOfPDSCH*>(items[3]) = dLPhysChCapabilityTDD768SupportOfPDSCH; }
	void setDLPhysChCapabilityTDD768Tdd768hspdsch(const DLPhysChCapabilityTDD768Tdd768hspdsch& dLPhysChCapabilityTDD768Tdd768hspdsch) { *static_cast<DLPhysChCapabilityTDD768Tdd768hspdsch*>(items[4]) = dLPhysChCapabilityTDD768Tdd768hspdsch; }
	void setMaxPhysChPerTS(const MaxPhysChPerTS768& maxPhysChPerTS) { *static_cast<MaxPhysChPerTS768*>(items[5]) = maxPhysChPerTS; }
};

typedef Boolean DLPhysChCapabilityInfoTDD768SupportOfPDSCH;

class DLPhysChCapabilityInfoTDD768 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	DLPhysChCapabilityInfoTDD768(): Sequence(&theInfo) {}

	void setMaxTSPerFrame(const MaxTSPerFrame& maxTSPerFrame) { *static_cast<MaxTSPerFrame*>(items[0]) = maxTSPerFrame; }
	void setMaxPhysChPerFrame(const MaxPhysChPerFrame768& maxPhysChPerFrame) { *static_cast<MaxPhysChPerFrame768*>(items[1]) = maxPhysChPerFrame; }
	void setMinimumSF(const MinimumSFDL768& minimumSF) { *static_cast<MinimumSFDL768*>(items[2]) = minimumSF; }
	void setDLPhysChCapabilityInfoTDD768SupportOfPDSCH(const DLPhysChCapabilityInfoTDD768SupportOfPDSCH& dLPhysChCapabilityInfoTDD768SupportOfPDSCH) { *static_cast<DLPhysChCapabilityInfoTDD768SupportOfPDSCH*>(items[3]) = dLPhysChCapabilityInfoTDD768SupportOfPDSCH; }
	void setMaxPhysChPerTS(const MaxPhysChPerTS768& maxPhysChPerTS) { *static_cast<MaxPhysChPerTS768*>(items[4]) = maxPhysChPerTS; }
};

enum MaxNoBitsValues {
	b640_MaxNoBits = 0,
	b1280_MaxNoBits = 1,
	b2560_MaxNoBits = 2,
	b3840_MaxNoBits = 3,
	b5120_MaxNoBits = 4,
	b6400_MaxNoBits = 5,
	b7680_MaxNoBits = 6,
	b8960_MaxNoBits = 7,
	b10240_MaxNoBits = 8,
	b20480_MaxNoBits = 9,
	b40960_MaxNoBits = 10,
	b81920_MaxNoBits = 11,
	b163840_MaxNoBits = 12,
};
typedef Enumerated<CONSTRAINED, 12> MaxNoBits;

typedef Null TurboSupportNotSupported;

class TurboSupport : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum TurboSupportChoices {
		turboSupportNotSupported = 0,
		supported = 1,
	};
	static const Info theInfo;
	TurboSupport(): Choice(&theInfo) {}
};

enum MaxSimultaneousTransChsDLValues {
	e4_MaxSimultaneousTransChsDL = 0,
	e8_MaxSimultaneousTransChsDL = 1,
	e16_MaxSimultaneousTransChsDL = 2,
	e32_MaxSimultaneousTransChsDL = 3,
};
typedef Enumerated<CONSTRAINED, 3> MaxSimultaneousTransChsDL;

typedef Integer<CONSTRAINED, 1, 8> MaxSimultaneousCCTrCHCount;

enum MaxTransportBlocksDLValues {
	tb4_MaxTransportBlocksDL = 0,
	tb8_MaxTransportBlocksDL = 1,
	tb16_MaxTransportBlocksDL = 2,
	tb32_MaxTransportBlocksDL = 3,
	tb48_MaxTransportBlocksDL = 4,
	tb64_MaxTransportBlocksDL = 5,
	tb96_MaxTransportBlocksDL = 6,
	tb128_MaxTransportBlocksDL = 7,
	tb256_MaxTransportBlocksDL = 8,
	tb512_MaxTransportBlocksDL = 9,
};
typedef Enumerated<CONSTRAINED, 9> MaxTransportBlocksDL;

enum MaxNumberOfTFCDLValues {
	tfc16_MaxNumberOfTFCDL = 0,
	tfc32_MaxNumberOfTFCDL = 1,
	tfc48_MaxNumberOfTFCDL = 2,
	tfc64_MaxNumberOfTFCDL = 3,
	tfc96_MaxNumberOfTFCDL = 4,
	tfc128_MaxNumberOfTFCDL = 5,
	tfc256_MaxNumberOfTFCDL = 6,
	tfc512_MaxNumberOfTFCDL = 7,
	tfc1024_MaxNumberOfTFCDL = 8,
};
typedef Enumerated<CONSTRAINED, 8> MaxNumberOfTFCDL;

enum MaxNumberOfTFValues {
	tf32_MaxNumberOfTF = 0,
	tf64_MaxNumberOfTF = 1,
	tf128_MaxNumberOfTF = 2,
	tf256_MaxNumberOfTF = 3,
	tf512_MaxNumberOfTF = 4,
	tf1024_MaxNumberOfTF = 5,
};
typedef Enumerated<CONSTRAINED, 5> MaxNumberOfTF;

class DLTransChCapability : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	DLTransChCapability(): Sequence(&theInfo) {}

	void setMaxNoBitsReceived(const MaxNoBits& maxNoBitsReceived) { *static_cast<MaxNoBits*>(items[0]) = maxNoBitsReceived; }
	void setMaxConvCodeBitsReceived(const MaxNoBits& maxConvCodeBitsReceived) { *static_cast<MaxNoBits*>(items[1]) = maxConvCodeBitsReceived; }
	void setTurboDecodingSupport(const TurboSupport& turboDecodingSupport) { *static_cast<TurboSupport*>(items[2]) = turboDecodingSupport; }
	void setMaxSimultaneousTransChs(const MaxSimultaneousTransChsDL& maxSimultaneousTransChs) { *static_cast<MaxSimultaneousTransChsDL*>(items[3]) = maxSimultaneousTransChs; }
	void setMaxSimultaneousCCTrCHCount(const MaxSimultaneousCCTrCHCount& maxSimultaneousCCTrCHCount) { *static_cast<MaxSimultaneousCCTrCHCount*>(items[4]) = maxSimultaneousCCTrCHCount; }
	void setMaxReceivedTransportBlocks(const MaxTransportBlocksDL& maxReceivedTransportBlocks) { *static_cast<MaxTransportBlocksDL*>(items[5]) = maxReceivedTransportBlocks; }
	void setMaxNumberOfTFC(const MaxNumberOfTFCDL& maxNumberOfTFC) { *static_cast<MaxNumberOfTFCDL*>(items[6]) = maxNumberOfTFC; }
	void setMaxNumberOfTF(const MaxNumberOfTF& maxNumberOfTF) { *static_cast<MaxNumberOfTF*>(items[7]) = maxNumberOfTF; }
};

typedef Integer<CONSTRAINED, 1, 8> TransmissionProbability;

typedef Integer<CONSTRAINED, 0, 32> MaximumBitRate;

class DRACSysInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DRACSysInfo(): Sequence(&theInfo) {}

	void setTransmissionProbability(const TransmissionProbability& transmissionProbability) { *static_cast<TransmissionProbability*>(items[0]) = transmissionProbability; }
	void setMaximumBitRate(const MaximumBitRate& maximumBitRate) { *static_cast<MaximumBitRate*>(items[1]) = maximumBitRate; }
};

typedef SequenceOf<DRACSysInfo, CONSTRAINED, 1, maxDRACclasses> DRACSysInfoList;

typedef BitString<CONSTRAINED, 16, 16> DSCHRNTI;

enum DelayRestrictionFlagValues {
	true_DelayRestrictionFlag = 0,
};
typedef Enumerated<CONSTRAINED, 0> DelayRestrictionFlag;

typedef BitString<CONSTRAINED, 16, 16> ERNTI;

typedef BitString<CONSTRAINED, 32, 32> ESNDS41;

enum EstablishmentCauseValues {
	originatingConversationalCall_EstablishmentCause = 0,
	originatingStreamingCall_EstablishmentCause = 1,
	originatingInteractiveCall_EstablishmentCause = 2,
	originatingBackgroundCall_EstablishmentCause = 3,
	originatingSubscribedTrafficCall_EstablishmentCause = 4,
	terminatingConversationalCall_EstablishmentCause = 5,
	terminatingStreamingCall_EstablishmentCause = 6,
	terminatingInteractiveCall_EstablishmentCause = 7,
	terminatingBackgroundCall_EstablishmentCause = 8,
	emergencyCall_EstablishmentCause = 9,
	interRAT_CellReselection_EstablishmentCause = 10,
	interRAT_CellChangeOrder_EstablishmentCause = 11,
	registration_EstablishmentCause = 12,
	detach_EstablishmentCause = 13,
	originatingHighPrioritySignalling_EstablishmentCause = 14,
	originatingLowPrioritySignalling_EstablishmentCause = 15,
	callRe_establishment_EstablishmentCause = 16,
	terminatingHighPrioritySignalling_EstablishmentCause = 17,
	terminatingLowPrioritySignalling_EstablishmentCause = 18,
	terminatingCauseUnknown_EstablishmentCause = 19,
	mbms_Reception_EstablishmentCause = 20,
	mbms_PTP_RB_Request_EstablishmentCause = 21,
	spare10_EstablishmentCause = 22,
	spare9_EstablishmentCause = 23,
	spare8_EstablishmentCause = 24,
	spare7_EstablishmentCause = 25,
	spare6_EstablishmentCause = 26,
	spare5_EstablishmentCause = 27,
	spare4_EstablishmentCause = 28,
	spare3_EstablishmentCause = 29,
	spare2_EstablishmentCause = 30,
	spare1_EstablishmentCause = 31,
};
typedef Enumerated<CONSTRAINED, 31> EstablishmentCause;

typedef Null FailureCauseWithProtErrConfigurationUnsupported;

typedef Null FailureCauseWithProtErrPhysicalChannelFailure;

typedef Null FailureCauseWithProtErrIncompatibleSimultaneousReconfiguration;

typedef Integer<CONSTRAINED, 1, maxTGPS> TGPSI;

enum ProtocolErrorCauseValues {
	asn1_ViolationOrEncodingError_ProtocolErrorCause = 0,
	messageTypeNonexistent_ProtocolErrorCause = 1,
	messageNotCompatibleWithReceiverState_ProtocolErrorCause = 2,
	ie_ValueNotComprehended_ProtocolErrorCause = 3,
	informationElementMissing_ProtocolErrorCause = 4,
	messageExtensionNotComprehended_ProtocolErrorCause = 5,
	spare2_ProtocolErrorCause = 6,
	spare1_ProtocolErrorCause = 7,
};
typedef Enumerated<CONSTRAINED, 7> ProtocolErrorCause;

class ProtocolErrorInformationDiagnosticsTypeType1 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ProtocolErrorInformationDiagnosticsTypeType1(): Sequence(&theInfo) {}

	void setProtocolErrorCause(const ProtocolErrorCause& protocolErrorCause) { *static_cast<ProtocolErrorCause*>(items[0]) = protocolErrorCause; }
};

typedef Null ProtocolErrorInformationDiagnosticsTypeSpare;

class ProtocolErrorInformationDiagnosticsType : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ProtocolErrorInformationDiagnosticsTypeChoices {
		protocolErrorInformationDiagnosticsTypeType1 = 0,
		protocolErrorInformationDiagnosticsTypeSpare = 1,
	};
	static const Info theInfo;
	ProtocolErrorInformationDiagnosticsType(): Choice(&theInfo) {}
};

class ProtocolErrorInformation : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ProtocolErrorInformation(): Sequence(&theInfo) {}

	void setProtocolErrorInformationDiagnosticsType(const ProtocolErrorInformationDiagnosticsType& protocolErrorInformationDiagnosticsType) { *static_cast<ProtocolErrorInformationDiagnosticsType*>(items[0]) = protocolErrorInformationDiagnosticsType; }
};

typedef Null FailureCauseWithProtErrCellUpdateOccurred;

typedef Null FailureCauseWithProtErrInvalidConfiguration;

typedef Null FailureCauseWithProtErrConfigurationIncomplete;

typedef Null FailureCauseWithProtErrUnsupportedMeasurement;

typedef Null FailureCauseWithProtErrMbmsSessionAlreadyReceivedCorrectly;

typedef Null FailureCauseWithProtErrLowerPriorityMBMSService;

typedef Null FailureCauseWithProtErrSpare5;

typedef Null FailureCauseWithProtErrSpare4;

typedef Null FailureCauseWithProtErrSpare3;

typedef Null FailureCauseWithProtErrSpare2;

typedef Null FailureCauseWithProtErrSpare1;

class FailureCauseWithProtErr : public Choice {
private:
	static const void *choicesInfo[16];
public:
	enum FailureCauseWithProtErrChoices {
		failureCauseWithProtErrConfigurationUnsupported = 0,
		failureCauseWithProtErrPhysicalChannelFailure = 1,
		failureCauseWithProtErrIncompatibleSimultaneousReconfiguration = 2,
		compressedModeRuntimeError = 3,
		protocolError = 4,
		failureCauseWithProtErrCellUpdateOccurred = 5,
		failureCauseWithProtErrInvalidConfiguration = 6,
		failureCauseWithProtErrConfigurationIncomplete = 7,
		failureCauseWithProtErrUnsupportedMeasurement = 8,
		failureCauseWithProtErrMbmsSessionAlreadyReceivedCorrectly = 9,
		failureCauseWithProtErrLowerPriorityMBMSService = 10,
		failureCauseWithProtErrSpare5 = 11,
		failureCauseWithProtErrSpare4 = 12,
		failureCauseWithProtErrSpare3 = 13,
		failureCauseWithProtErrSpare2 = 14,
		failureCauseWithProtErrSpare1 = 15,
	};
	static const Info theInfo;
	FailureCauseWithProtErr(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 3> RRCTransactionIdentifier;

class FailureCauseWithProtErrTrId : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	FailureCauseWithProtErrTrId(): Sequence(&theInfo) {}

	void setRrcTransactionIdentifier(const RRCTransactionIdentifier& rrcTransactionIdentifier) { *static_cast<RRCTransactionIdentifier*>(items[0]) = rrcTransactionIdentifier; }
	void setFailureCause(const FailureCauseWithProtErr& failureCause) { *static_cast<FailureCauseWithProtErr*>(items[1]) = failureCause; }
};

enum GANSSModeValues {
	networkBased_GANSSMode = 0,
	uEBased_GANSSMode = 1,
	both_GANSSMode = 2,
	none_GANSSMode = 3,
};
typedef Enumerated<CONSTRAINED, 3> GANSSMode;

typedef Null RRCConnectionReleaseInformationNoRelease;

enum ReleaseCauseValues {
	normalEvent_ReleaseCause = 0,
	unspecified_ReleaseCause = 1,
	pre_emptiveRelease_ReleaseCause = 2,
	congestion_ReleaseCause = 3,
	re_establishmentReject_ReleaseCause = 4,
	directedsignallingconnectionre_establishment_ReleaseCause = 5,
	userInactivity_ReleaseCause = 6,
	spare_ReleaseCause = 7,
};
typedef Enumerated<CONSTRAINED, 7> ReleaseCause;

class RRCConnectionReleaseInformationRelease : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	RRCConnectionReleaseInformationRelease(): Sequence(&theInfo) {}

	void setReleaseCause(const ReleaseCause& releaseCause) { *static_cast<ReleaseCause*>(items[0]) = releaseCause; }
};

class RRCConnectionReleaseInformation : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum RRCConnectionReleaseInformationChoices {
		rRCConnectionReleaseInformationNoRelease = 0,
		rRCConnectionReleaseInformationRelease = 1,
	};
	static const Info theInfo;
	RRCConnectionReleaseInformation(): Choice(&theInfo) {}
};

typedef Null URNTIGroupAll;

typedef BitString<CONSTRAINED, 31, 31> URNTIGroupURNTIBitMaskIndexb1;

typedef BitString<CONSTRAINED, 30, 30> URNTIGroupURNTIBitMaskIndexb2;

typedef BitString<CONSTRAINED, 29, 29> URNTIGroupURNTIBitMaskIndexb3;

typedef BitString<CONSTRAINED, 28, 28> URNTIGroupURNTIBitMaskIndexb4;

typedef BitString<CONSTRAINED, 27, 27> URNTIGroupURNTIBitMaskIndexb5;

typedef BitString<CONSTRAINED, 26, 26> URNTIGroupURNTIBitMaskIndexb6;

typedef BitString<CONSTRAINED, 25, 25> URNTIGroupURNTIBitMaskIndexb7;

typedef BitString<CONSTRAINED, 24, 24> URNTIGroupURNTIBitMaskIndexb8;

typedef BitString<CONSTRAINED, 23, 23> URNTIGroupURNTIBitMaskIndexb9;

typedef BitString<CONSTRAINED, 22, 22> URNTIGroupURNTIBitMaskIndexb10;

typedef BitString<CONSTRAINED, 21, 21> URNTIGroupURNTIBitMaskIndexb11;

typedef BitString<CONSTRAINED, 20, 20> URNTIGroupURNTIBitMaskIndexb12;

typedef BitString<CONSTRAINED, 19, 19> URNTIGroupURNTIBitMaskIndexb13;

typedef BitString<CONSTRAINED, 18, 18> URNTIGroupURNTIBitMaskIndexb14;

typedef BitString<CONSTRAINED, 17, 17> URNTIGroupURNTIBitMaskIndexb15;

typedef BitString<CONSTRAINED, 16, 16> URNTIGroupURNTIBitMaskIndexb16;

typedef BitString<CONSTRAINED, 15, 15> URNTIGroupURNTIBitMaskIndexb17;

typedef BitString<CONSTRAINED, 14, 14> URNTIGroupURNTIBitMaskIndexb18;

typedef BitString<CONSTRAINED, 13, 13> URNTIGroupURNTIBitMaskIndexb19;

typedef BitString<CONSTRAINED, 12, 12> URNTIGroupURNTIBitMaskIndexb20;

typedef BitString<CONSTRAINED, 11, 11> URNTIGroupURNTIBitMaskIndexb21;

typedef BitString<CONSTRAINED, 10, 10> URNTIGroupURNTIBitMaskIndexb22;

typedef BitString<CONSTRAINED, 9, 9> URNTIGroupURNTIBitMaskIndexb23;

typedef BitString<CONSTRAINED, 8, 8> URNTIGroupURNTIBitMaskIndexb24;

typedef BitString<CONSTRAINED, 7, 7> URNTIGroupURNTIBitMaskIndexb25;

typedef BitString<CONSTRAINED, 6, 6> URNTIGroupURNTIBitMaskIndexb26;

typedef BitString<CONSTRAINED, 5, 5> URNTIGroupURNTIBitMaskIndexb27;

typedef BitString<CONSTRAINED, 4, 4> URNTIGroupURNTIBitMaskIndexb28;

typedef BitString<CONSTRAINED, 3, 3> URNTIGroupURNTIBitMaskIndexb29;

typedef BitString<CONSTRAINED, 2, 2> URNTIGroupURNTIBitMaskIndexb30;

typedef BitString<CONSTRAINED, 1, 1> URNTIGroupURNTIBitMaskIndexb31;

class URNTIGroup : public Choice {
private:
	static const void *choicesInfo[32];
public:
	enum URNTIGroupChoices {
		uRNTIGroupAll = 0,
		uRNTIGroupURNTIBitMaskIndexb1 = 1,
		uRNTIGroupURNTIBitMaskIndexb2 = 2,
		uRNTIGroupURNTIBitMaskIndexb3 = 3,
		uRNTIGroupURNTIBitMaskIndexb4 = 4,
		uRNTIGroupURNTIBitMaskIndexb5 = 5,
		uRNTIGroupURNTIBitMaskIndexb6 = 6,
		uRNTIGroupURNTIBitMaskIndexb7 = 7,
		uRNTIGroupURNTIBitMaskIndexb8 = 8,
		uRNTIGroupURNTIBitMaskIndexb9 = 9,
		uRNTIGroupURNTIBitMaskIndexb10 = 10,
		uRNTIGroupURNTIBitMaskIndexb11 = 11,
		uRNTIGroupURNTIBitMaskIndexb12 = 12,
		uRNTIGroupURNTIBitMaskIndexb13 = 13,
		uRNTIGroupURNTIBitMaskIndexb14 = 14,
		uRNTIGroupURNTIBitMaskIndexb15 = 15,
		uRNTIGroupURNTIBitMaskIndexb16 = 16,
		uRNTIGroupURNTIBitMaskIndexb17 = 17,
		uRNTIGroupURNTIBitMaskIndexb18 = 18,
		uRNTIGroupURNTIBitMaskIndexb19 = 19,
		uRNTIGroupURNTIBitMaskIndexb20 = 20,
		uRNTIGroupURNTIBitMaskIndexb21 = 21,
		uRNTIGroupURNTIBitMaskIndexb22 = 22,
		uRNTIGroupURNTIBitMaskIndexb23 = 23,
		uRNTIGroupURNTIBitMaskIndexb24 = 24,
		uRNTIGroupURNTIBitMaskIndexb25 = 25,
		uRNTIGroupURNTIBitMaskIndexb26 = 26,
		uRNTIGroupURNTIBitMaskIndexb27 = 27,
		uRNTIGroupURNTIBitMaskIndexb28 = 28,
		uRNTIGroupURNTIBitMaskIndexb29 = 29,
		uRNTIGroupURNTIBitMaskIndexb30 = 30,
		uRNTIGroupURNTIBitMaskIndexb31 = 31,
	};
	static const Info theInfo;
	URNTIGroup(): Choice(&theInfo) {}
};

class GroupReleaseInformation : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	GroupReleaseInformation(): Sequence(&theInfo) {}

	void setURNTIGroup(const URNTIGroup& uRNTIGroup) { *static_cast<URNTIGroup*>(items[0]) = uRNTIGroup; }
};

class GroupIdentityWithReleaseInformation : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	GroupIdentityWithReleaseInformation(): Sequence(&theInfo) {}

	void setRrcConnectionReleaseInformation(const RRCConnectionReleaseInformation& rrcConnectionReleaseInformation) { *static_cast<RRCConnectionReleaseInformation*>(items[0]) = rrcConnectionReleaseInformation; }
	void setGroupReleaseInformation(const GroupReleaseInformation& groupReleaseInformation) { *static_cast<GroupReleaseInformation*>(items[1]) = groupReleaseInformation; }
};

typedef BitString<CONSTRAINED, 16, 16> HRNTI;

enum HighMobilityDetectedValues {
	high_MobilityDetected_HighMobilityDetected = 0,
};
typedef Enumerated<CONSTRAINED, 0> HighMobilityDetected;

typedef BitString<CONSTRAINED, 4, 4> UESpecificBehaviourInformation1idle;

typedef BitString<CONSTRAINED, 8, 8> UESpecificBehaviourInformation1interRAT;

typedef Boolean IdleIntervalMeasCapabEUTRAIdleInterval;

class IdleIntervalMeasCapabEUTRA : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IdleIntervalMeasCapabEUTRA(): Sequence(&theInfo) {}

	void setRadioFrequencyBandEUTRA(const RadioFrequencyBandEUTRA& radioFrequencyBandEUTRA) { *static_cast<RadioFrequencyBandEUTRA*>(items[0]) = radioFrequencyBandEUTRA; }
	void setIdleIntervalMeasCapabEUTRAIdleInterval(const IdleIntervalMeasCapabEUTRAIdleInterval& idleIntervalMeasCapabEUTRAIdleInterval) { *static_cast<IdleIntervalMeasCapabEUTRAIdleInterval*>(items[1]) = idleIntervalMeasCapabEUTRAIdleInterval; }
};

typedef SequenceOf<IdleIntervalMeasCapabEUTRA, CONSTRAINED, 1, maxFreqBandsEUTRA> IdleIntervalMeasCapabEUTRAList;

class IMSIandESNDS41 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IMSIandESNDS41(): Sequence(&theInfo) {}

	void setImsiDS41(const IMSIDS41& imsiDS41) { *static_cast<IMSIDS41*>(items[0]) = imsiDS41; }
	void setEsnDS41(const ESNDS41& esnDS41) { *static_cast<ESNDS41*>(items[1]) = esnDS41; }
};

class TMSIandLAIGSMMAP : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	TMSIandLAIGSMMAP(): Sequence(&theInfo) {}

	void setTmsi(const TMSIGSMMAP& tmsi) { *static_cast<TMSIGSMMAP*>(items[0]) = tmsi; }
	void setLai(const LAI& lai) { *static_cast<LAI*>(items[1]) = lai; }
};

class PTMSIandRAIGSMMAP : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PTMSIandRAIGSMMAP(): Sequence(&theInfo) {}

	void setPTMSI(const PTMSIGSMMAP& pTMSI) { *static_cast<PTMSIGSMMAP*>(items[0]) = pTMSI; }
	void setRai(const RAI& rai) { *static_cast<RAI*>(items[1]) = rai; }
};

class InitialUEIdentity : public Choice {
private:
	static const void *choicesInfo[8];
public:
	enum InitialUEIdentityChoices {
		imsi = 0,
		tmsiandLAI = 1,
		pTMSIandRAI = 2,
		imei = 3,
		esnDS41 = 4,
		imsiDS41 = 5,
		imsiandESNDS41 = 6,
		tmsiDS41 = 7,
	};
	static const Info theInfo;
	InitialUEIdentity(): Choice(&theInfo) {}
};

typedef BitString<CONSTRAINED, 32, 32> MessageAuthenticationCode;

typedef Integer<CONSTRAINED, 0, 15> RRCMessageSequenceNumber;

class IntegrityCheckInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IntegrityCheckInfo(): Sequence(&theInfo) {}

	void setMessageAuthenticationCode(const MessageAuthenticationCode& messageAuthenticationCode) { *static_cast<MessageAuthenticationCode*>(items[0]) = messageAuthenticationCode; }
	void setRrcMessageSequenceNumber(const RRCMessageSequenceNumber& rrcMessageSequenceNumber) { *static_cast<RRCMessageSequenceNumber*>(items[1]) = rrcMessageSequenceNumber; }
};

typedef SequenceOf<RRCMessageSequenceNumber, CONSTRAINED, 4, 5> RRCMessageSequenceNumberList;

class IntegrityProtActivationInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	IntegrityProtActivationInfo(): Sequence(&theInfo) {}

	void setRrcMessageSequenceNumberList(const RRCMessageSequenceNumberList& rrcMessageSequenceNumberList) { *static_cast<RRCMessageSequenceNumberList*>(items[0]) = rrcMessageSequenceNumberList; }
};

enum IntegrityProtectionAlgorithmValues {
	uia1_IntegrityProtectionAlgorithm = 0,
};
typedef Enumerated<CONSTRAINED, 0> IntegrityProtectionAlgorithm;

enum IntegrityProtectionAlgorithmr7Values {
	uia1_IntegrityProtectionAlgorithmr7 = 0,
	uia2_IntegrityProtectionAlgorithmr7 = 1,
};
typedef Enumerated<CONSTRAINED, 1> IntegrityProtectionAlgorithmr7;

typedef BitString<CONSTRAINED, 32, 32> IntegrityProtInitNumber;

class IntegrityProtectionModeCommandStartIntegrityProtection : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	IntegrityProtectionModeCommandStartIntegrityProtection(): Sequence(&theInfo) {}

	void setIntegrityProtInitNumber(const IntegrityProtInitNumber& integrityProtInitNumber) { *static_cast<IntegrityProtInitNumber*>(items[0]) = integrityProtInitNumber; }
};

class IntegrityProtectionModeCommandModify : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	IntegrityProtectionModeCommandModify(): Sequence(&theInfo) {}

	void setDlIntegrityProtActivationInfo(const IntegrityProtActivationInfo& dlIntegrityProtActivationInfo) { *static_cast<IntegrityProtActivationInfo*>(items[0]) = dlIntegrityProtActivationInfo; }
};

class IntegrityProtectionModeCommand : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum IntegrityProtectionModeCommandChoices {
		integrityProtectionModeCommandStartIntegrityProtection = 0,
		integrityProtectionModeCommandModify = 1,
	};
	static const Info theInfo;
	IntegrityProtectionModeCommand(): Choice(&theInfo) {}
};

class IntegrityProtectionModeInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IntegrityProtectionModeInfo(): Sequence(&theInfo) {}

	void setIntegrityProtectionModeCommand(const IntegrityProtectionModeCommand& integrityProtectionModeCommand) { *static_cast<IntegrityProtectionModeCommand*>(items[0]) = integrityProtectionModeCommand; }
	void setIntegrityProtectionAlgorithm(const IntegrityProtectionAlgorithm& integrityProtectionAlgorithm) { *static_cast<IntegrityProtectionAlgorithm*>(items[1]) = integrityProtectionAlgorithm; }
};

class IntegrityProtectionModeInfor7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IntegrityProtectionModeInfor7(): Sequence(&theInfo) {}

	void setIntegrityProtectionModeCommand(const IntegrityProtectionModeCommand& integrityProtectionModeCommand) { *static_cast<IntegrityProtectionModeCommand*>(items[0]) = integrityProtectionModeCommand; }
	void setIntegrityProtectionAlgorithm(const IntegrityProtectionAlgorithmr7& integrityProtectionAlgorithm) { *static_cast<IntegrityProtectionAlgorithmr7*>(items[1]) = integrityProtectionAlgorithm; }
};

enum MaxHcContextSpaceValues {
	dummy_MaxHcContextSpace = 0,
	by1024_MaxHcContextSpace = 1,
	by2048_MaxHcContextSpace = 2,
	by4096_MaxHcContextSpace = 3,
	by8192_MaxHcContextSpace = 4,
};
typedef Enumerated<CONSTRAINED, 4> MaxHcContextSpace;

enum MaxHcContextSpacer5extValues {
	by16384_MaxHcContextSpacer5ext = 0,
	by32768_MaxHcContextSpacer5ext = 1,
	by65536_MaxHcContextSpacer5ext = 2,
	by131072_MaxHcContextSpacer5ext = 3,
};
typedef Enumerated<CONSTRAINED, 3> MaxHcContextSpacer5ext;

enum MaxROHCContextSessionsr4Values {
	s2_MaxROHCContextSessionsr4 = 0,
	s4_MaxROHCContextSessionsr4 = 1,
	s8_MaxROHCContextSessionsr4 = 2,
	s12_MaxROHCContextSessionsr4 = 3,
	s16_MaxROHCContextSessionsr4 = 4,
	s24_MaxROHCContextSessionsr4 = 5,
	s32_MaxROHCContextSessionsr4 = 6,
	s48_MaxROHCContextSessionsr4 = 7,
	s64_MaxROHCContextSessionsr4 = 8,
	s128_MaxROHCContextSessionsr4 = 9,
	s256_MaxROHCContextSessionsr4 = 10,
	s512_MaxROHCContextSessionsr4 = 11,
	s1024_MaxROHCContextSessionsr4 = 12,
	s16384_MaxROHCContextSessionsr4 = 13,
};
typedef Enumerated<CONSTRAINED, 13> MaxROHCContextSessionsr4;

enum MaximumAMEntityNumberRLCCapValues {
	dummy_MaximumAMEntityNumberRLCCap = 0,
	am4_MaximumAMEntityNumberRLCCap = 1,
	am5_MaximumAMEntityNumberRLCCap = 2,
	am6_MaximumAMEntityNumberRLCCap = 3,
	am8_MaximumAMEntityNumberRLCCap = 4,
	am16_MaximumAMEntityNumberRLCCap = 5,
	am30_MaximumAMEntityNumberRLCCap = 6,
};
typedef Enumerated<CONSTRAINED, 6> MaximumAMEntityNumberRLCCap;

enum MaximumRLCWindowSizeValues {
	mws2047_MaximumRLCWindowSize = 0,
	mws4095_MaximumRLCWindowSize = 1,
};
typedef Enumerated<CONSTRAINED, 1> MaximumRLCWindowSize;

enum MaxNoDPDCHBitsTransmittedValues {
	b600_MaxNoDPDCHBitsTransmitted = 0,
	b1200_MaxNoDPDCHBitsTransmitted = 1,
	b2400_MaxNoDPDCHBitsTransmitted = 2,
	b4800_MaxNoDPDCHBitsTransmitted = 3,
	b9600_MaxNoDPDCHBitsTransmitted = 4,
	b19200_MaxNoDPDCHBitsTransmitted = 5,
	b28800_MaxNoDPDCHBitsTransmitted = 6,
	b38400_MaxNoDPDCHBitsTransmitted = 7,
	b48000_MaxNoDPDCHBitsTransmitted = 8,
	b57600_MaxNoDPDCHBitsTransmitted = 9,
};
typedef Enumerated<CONSTRAINED, 9> MaxNoDPDCHBitsTransmitted;

enum MaxNumberOfTFCULValues {
	dummy1_MaxNumberOfTFCUL = 0,
	dummy2_MaxNumberOfTFCUL = 1,
	tfc16_MaxNumberOfTFCUL = 2,
	tfc32_MaxNumberOfTFCUL = 3,
	tfc48_MaxNumberOfTFCUL = 4,
	tfc64_MaxNumberOfTFCUL = 5,
	tfc96_MaxNumberOfTFCUL = 6,
	tfc128_MaxNumberOfTFCUL = 7,
	tfc256_MaxNumberOfTFCUL = 8,
	tfc512_MaxNumberOfTFCUL = 9,
	tfc1024_MaxNumberOfTFCUL = 10,
};
typedef Enumerated<CONSTRAINED, 10> MaxNumberOfTFCUL;

enum MaxPhysChPerTimeslotValues {
	ts1_MaxPhysChPerTimeslot = 0,
	ts2_MaxPhysChPerTimeslot = 1,
};
typedef Enumerated<CONSTRAINED, 1> MaxPhysChPerTimeslot;

typedef Integer<CONSTRAINED, 1, 4> MaxPhysChPerTimeslotLCRr7;

enum MaxSimultaneousTransChsULValues {
	dummy_MaxSimultaneousTransChsUL = 0,
	e4_MaxSimultaneousTransChsUL = 1,
	e8_MaxSimultaneousTransChsUL = 2,
	e16_MaxSimultaneousTransChsUL = 3,
	e32_MaxSimultaneousTransChsUL = 4,
};
typedef Enumerated<CONSTRAINED, 4> MaxSimultaneousTransChsUL;

enum MaxTransportBlocksULValues {
	dummy_MaxTransportBlocksUL = 0,
	tb4_MaxTransportBlocksUL = 1,
	tb8_MaxTransportBlocksUL = 2,
	tb16_MaxTransportBlocksUL = 3,
	tb32_MaxTransportBlocksUL = 4,
	tb48_MaxTransportBlocksUL = 5,
	tb64_MaxTransportBlocksUL = 6,
	tb96_MaxTransportBlocksUL = 7,
	tb128_MaxTransportBlocksUL = 8,
	tb256_MaxTransportBlocksUL = 9,
	tb512_MaxTransportBlocksUL = 10,
};
typedef Enumerated<CONSTRAINED, 10> MaxTransportBlocksUL;

class MeasurementCapability : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementCapability(): Sequence(&theInfo) {}

	void setDownlinkCompressedMode(const CompressedModeMeasCapability& downlinkCompressedMode) { *static_cast<CompressedModeMeasCapability*>(items[0]) = downlinkCompressedMode; }
	void setUplinkCompressedMode(const CompressedModeMeasCapability& uplinkCompressedMode) { *static_cast<CompressedModeMeasCapability*>(items[1]) = uplinkCompressedMode; }
};

class MeasurementCapabilityExt : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	MeasurementCapabilityExt(): Sequence(&theInfo) {}

	void setCompressedModeMeasCapabFDDList(const CompressedModeMeasCapabFDDList& compressedModeMeasCapabFDDList) { *static_cast<CompressedModeMeasCapabFDDList*>(items[0]) = compressedModeMeasCapabFDDList; }
	void setCompressedModeMeasCapabTDDList(const CompressedModeMeasCapabTDDList& compressedModeMeasCapabTDDList) { *static_cast<CompressedModeMeasCapabTDDList*>(items[1]) = compressedModeMeasCapabTDDList; }
	void setCompressedModeMeasCapabGSMList(const CompressedModeMeasCapabGSMList& compressedModeMeasCapabGSMList) { *static_cast<CompressedModeMeasCapabGSMList*>(items[2]) = compressedModeMeasCapabGSMList; }
	void setCompressedModeMeasCapabMC(const CompressedModeMeasCapabMC& compressedModeMeasCapabMC) { *static_cast<CompressedModeMeasCapabMC*>(items[3]) = compressedModeMeasCapabMC; }
};

class MeasurementCapabilityExt2 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	MeasurementCapabilityExt2(): Sequence(&theInfo) {}

	void setCompressedModeMeasCapabFDDList(const CompressedModeMeasCapabFDDList2& compressedModeMeasCapabFDDList) { *static_cast<CompressedModeMeasCapabFDDList2*>(items[0]) = compressedModeMeasCapabFDDList; }
	void setCompressedModeMeasCapabTDDList(const CompressedModeMeasCapabTDDList& compressedModeMeasCapabTDDList) { *static_cast<CompressedModeMeasCapabTDDList*>(items[1]) = compressedModeMeasCapabTDDList; }
	void setCompressedModeMeasCapabGSMList(const CompressedModeMeasCapabGSMList& compressedModeMeasCapabGSMList) { *static_cast<CompressedModeMeasCapabGSMList*>(items[2]) = compressedModeMeasCapabGSMList; }
	void setCompressedModeMeasCapabMC(const CompressedModeMeasCapabMC& compressedModeMeasCapabMC) { *static_cast<CompressedModeMeasCapabMC*>(items[3]) = compressedModeMeasCapabMC; }
};

class MeasurementCapabilityExt3 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasurementCapabilityExt3(): Sequence(&theInfo) {}

	void setCompressedModeMeasCapabEUTRAList(const CompressedModeMeasCapabEUTRAList& compressedModeMeasCapabEUTRAList) { *static_cast<CompressedModeMeasCapabEUTRAList*>(items[0]) = compressedModeMeasCapabEUTRAList; }
};

class MeasurementCapabilityr4ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementCapabilityr4ext(): Sequence(&theInfo) {}

	void setDownlinkCompressedModeLCR(const CompressedModeMeasCapabilityLCRr4& downlinkCompressedModeLCR) { *static_cast<CompressedModeMeasCapabilityLCRr4*>(items[0]) = downlinkCompressedModeLCR; }
	void setUplinkCompressedModeLCR(const CompressedModeMeasCapabilityLCRr4& uplinkCompressedModeLCR) { *static_cast<CompressedModeMeasCapabilityLCRr4*>(items[1]) = uplinkCompressedModeLCR; }
};

class MeasurementCapabilityv860ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasurementCapabilityv860ext(): Sequence(&theInfo) {}

	void setDownlinkCompressedMode(const CompressedModeMeasCapabilityv860ext& downlinkCompressedMode) { *static_cast<CompressedModeMeasCapabilityv860ext*>(items[0]) = downlinkCompressedMode; }
};

class MeasurementCapabilityv920ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasurementCapabilityv920ext(): Sequence(&theInfo) {}

	void setDownlinkCompressedMode(const CompressedModeMeasCapabilityv920ext& downlinkCompressedMode) { *static_cast<CompressedModeMeasCapabilityv920ext*>(items[0]) = downlinkCompressedMode; }
};

class MeasurementCapabilityTDD : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasurementCapabilityTDD(): Sequence(&theInfo) {}

	void setIdleIntervalMeasCapabEUTRAList(const IdleIntervalMeasCapabEUTRAList& idleIntervalMeasCapabEUTRAList) { *static_cast<IdleIntervalMeasCapabEUTRAList*>(items[0]) = idleIntervalMeasCapabEUTRAList; }
};

enum MinimumSFULValues {
	sf1_MinimumSFUL = 0,
	sf2_MinimumSFUL = 1,
	sf4_MinimumSFUL = 2,
	sf8_MinimumSFUL = 3,
	dummy_MinimumSFUL = 4,
};
typedef Enumerated<CONSTRAINED, 4> MinimumSFUL;

enum MultiModeCapabilityValues {
	tdd_MultiModeCapability = 0,
	fdd_MultiModeCapability = 1,
	fdd_tdd_MultiModeCapability = 2,
};
typedef Enumerated<CONSTRAINED, 2> MultiModeCapability;

typedef Boolean MultiRATCapabilitySupportOfGSM;

typedef Boolean MultiRATCapabilitySupportOfMulticarrier;

class MultiRATCapability : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MultiRATCapability(): Sequence(&theInfo) {}

	void setMultiRATCapabilitySupportOfGSM(const MultiRATCapabilitySupportOfGSM& multiRATCapabilitySupportOfGSM) { *static_cast<MultiRATCapabilitySupportOfGSM*>(items[0]) = multiRATCapabilitySupportOfGSM; }
	void setMultiRATCapabilitySupportOfMulticarrier(const MultiRATCapabilitySupportOfMulticarrier& multiRATCapabilitySupportOfMulticarrier) { *static_cast<MultiRATCapabilitySupportOfMulticarrier*>(items[1]) = multiRATCapabilitySupportOfMulticarrier; }
};

typedef Boolean MultiModeRATCapabilityv590extSupportOfUTRANToGERANNACC;

class MultiModeRATCapabilityv590ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MultiModeRATCapabilityv590ext(): Sequence(&theInfo) {}

	void setMultiModeRATCapabilityv590extSupportOfUTRANToGERANNACC(const MultiModeRATCapabilityv590extSupportOfUTRANToGERANNACC& multiModeRATCapabilityv590extSupportOfUTRANToGERANNACC) { *static_cast<MultiModeRATCapabilityv590extSupportOfUTRANToGERANNACC*>(items[0]) = multiModeRATCapabilityv590extSupportOfUTRANToGERANNACC; }
};

enum MultiModeRATCapabilityv680extsupportOfHandoverToGANValues {
	doesSupportHandoverToGAN_MultiModeRATCapabilityv680extsupportOfHandoverToGAN = 0,
};
typedef Enumerated<CONSTRAINED, 0> MultiModeRATCapabilityv680extsupportOfHandoverToGAN;

class MultiModeRATCapabilityv680ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MultiModeRATCapabilityv680ext(): Sequence(&theInfo) {}

	void setMultiModeRATCapabilityv680extsupportOfHandoverToGAN(const MultiModeRATCapabilityv680extsupportOfHandoverToGAN& multiModeRATCapabilityv680extsupportOfHandoverToGAN) { *static_cast<MultiModeRATCapabilityv680extsupportOfHandoverToGAN*>(items[0]) = multiModeRATCapabilityv680extsupportOfHandoverToGAN; }
};

enum MultiModeRATCapabilityv770extsupportOfPSHandoverToGANValues {
	doesSupportPSHandoverToGAN_MultiModeRATCapabilityv770extsupportOfPSHandoverToGAN = 0,
};
typedef Enumerated<CONSTRAINED, 0> MultiModeRATCapabilityv770extsupportOfPSHandoverToGAN;

class MultiModeRATCapabilityv770ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MultiModeRATCapabilityv770ext(): Sequence(&theInfo) {}

	void setMultiModeRATCapabilityv770extsupportOfPSHandoverToGAN(const MultiModeRATCapabilityv770extsupportOfPSHandoverToGAN& multiModeRATCapabilityv770extsupportOfPSHandoverToGAN) { *static_cast<MultiModeRATCapabilityv770extsupportOfPSHandoverToGAN*>(items[0]) = multiModeRATCapabilityv770extsupportOfPSHandoverToGAN; }
};

enum MultiModeRATCapabilityv860extsupportOfEUTRAFDDValues {
	doesSupportEUTRAFDD_MultiModeRATCapabilityv860extsupportOfEUTRAFDD = 0,
};
typedef Enumerated<CONSTRAINED, 0> MultiModeRATCapabilityv860extsupportOfEUTRAFDD;

enum MultiModeRATCapabilityv860extsupportOfInterRATHOToEUTRAFDDValues {
	doesSupportInterRATHOToEUTRAFDD_MultiModeRATCapabilityv860extsupportOfInterRATHOToEUTRAFDD = 0,
};
typedef Enumerated<CONSTRAINED, 0> MultiModeRATCapabilityv860extsupportOfInterRATHOToEUTRAFDD;

enum MultiModeRATCapabilityv860extsupportOfEUTRATDDValues {
	doesSupportEUTRATDD_MultiModeRATCapabilityv860extsupportOfEUTRATDD = 0,
};
typedef Enumerated<CONSTRAINED, 0> MultiModeRATCapabilityv860extsupportOfEUTRATDD;

enum MultiModeRATCapabilityv860extsupportOfInterRATHOToEUTRATDDValues {
	doesSupportInterRATHOToEUTRATDD_MultiModeRATCapabilityv860extsupportOfInterRATHOToEUTRATDD = 0,
};
typedef Enumerated<CONSTRAINED, 0> MultiModeRATCapabilityv860extsupportOfInterRATHOToEUTRATDD;

typedef BitString<CONSTRAINED, 4, 4> MultiModeRATCapabilityv860extEutraFeatureGroupIndicators;

class MultiModeRATCapabilityv860ext : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	MultiModeRATCapabilityv860ext(): Sequence(&theInfo) {}

	void setMultiModeRATCapabilityv860extsupportOfEUTRAFDD(const MultiModeRATCapabilityv860extsupportOfEUTRAFDD& multiModeRATCapabilityv860extsupportOfEUTRAFDD) { *static_cast<MultiModeRATCapabilityv860extsupportOfEUTRAFDD*>(items[0]) = multiModeRATCapabilityv860extsupportOfEUTRAFDD; }
	void setMultiModeRATCapabilityv860extsupportOfInterRATHOToEUTRAFDD(const MultiModeRATCapabilityv860extsupportOfInterRATHOToEUTRAFDD& multiModeRATCapabilityv860extsupportOfInterRATHOToEUTRAFDD) { *static_cast<MultiModeRATCapabilityv860extsupportOfInterRATHOToEUTRAFDD*>(items[1]) = multiModeRATCapabilityv860extsupportOfInterRATHOToEUTRAFDD; }
	void setMultiModeRATCapabilityv860extsupportOfEUTRATDD(const MultiModeRATCapabilityv860extsupportOfEUTRATDD& multiModeRATCapabilityv860extsupportOfEUTRATDD) { *static_cast<MultiModeRATCapabilityv860extsupportOfEUTRATDD*>(items[2]) = multiModeRATCapabilityv860extsupportOfEUTRATDD; }
	void setMultiModeRATCapabilityv860extsupportOfInterRATHOToEUTRATDD(const MultiModeRATCapabilityv860extsupportOfInterRATHOToEUTRATDD& multiModeRATCapabilityv860extsupportOfInterRATHOToEUTRATDD) { *static_cast<MultiModeRATCapabilityv860extsupportOfInterRATHOToEUTRATDD*>(items[3]) = multiModeRATCapabilityv860extsupportOfInterRATHOToEUTRATDD; }
	void setMultiModeRATCapabilityv860extEutraFeatureGroupIndicators(const MultiModeRATCapabilityv860extEutraFeatureGroupIndicators& multiModeRATCapabilityv860extEutraFeatureGroupIndicators) { *static_cast<MultiModeRATCapabilityv860extEutraFeatureGroupIndicators*>(items[4]) = multiModeRATCapabilityv860extEutraFeatureGroupIndicators; }
};

typedef Integer<CONSTRAINED, 0, 7> N300;

typedef Integer<CONSTRAINED, 0, 7> N301;

typedef Integer<CONSTRAINED, 0, 7> N302;

typedef Integer<CONSTRAINED, 0, 7> N304;

typedef Integer<CONSTRAINED, 1, 8> N308;

typedef Integer<CONSTRAINED, 0, 7> N310;

enum N312Values {
	s1_N312 = 0,
	s50_N312 = 1,
	s100_N312 = 2,
	s200_N312 = 3,
	s400_N312 = 4,
	s600_N312 = 5,
	s800_N312 = 6,
	s1000_N312 = 7,
};
typedef Enumerated<CONSTRAINED, 7> N312;

enum N312extValues {
	s2_N312ext = 0,
	s4_N312ext = 1,
	s10_N312ext = 2,
	s20_N312ext = 3,
};
typedef Enumerated<CONSTRAINED, 3> N312ext;

enum N312r5Values {
	s1_N312r5 = 0,
	s2_N312r5 = 1,
	s4_N312r5 = 2,
	s10_N312r5 = 3,
	s20_N312r5 = 4,
	s50_N312r5 = 5,
	s100_N312r5 = 6,
	s200_N312r5 = 7,
	s400_N312r5 = 8,
	s600_N312r5 = 9,
	s800_N312r5 = 10,
	s1000_N312r5 = 11,
};
typedef Enumerated<CONSTRAINED, 11> N312r5;

enum N313Values {
	s1_N313 = 0,
	s2_N313 = 1,
	s4_N313 = 2,
	s10_N313 = 3,
	s20_N313 = 4,
	s50_N313 = 5,
	s100_N313 = 6,
	s200_N313 = 7,
};
typedef Enumerated<CONSTRAINED, 7> N313;

enum N315Values {
	s1_N315 = 0,
	s50_N315 = 1,
	s100_N315 = 2,
	s200_N315 = 3,
	s400_N315 = 4,
	s600_N315 = 5,
	s800_N315 = 6,
	s1000_N315 = 7,
};
typedef Enumerated<CONSTRAINED, 7> N315;

enum N315extValues {
	s2_N315ext = 0,
	s4_N315ext = 1,
	s10_N315ext = 2,
	s20_N315ext = 3,
};
typedef Enumerated<CONSTRAINED, 3> N315ext;

enum N315r5Values {
	s1_N315r5 = 0,
	s2_N315r5 = 1,
	s4_N315r5 = 2,
	s10_N315r5 = 3,
	s20_N315r5 = 4,
	s50_N315r5 = 5,
	s100_N315r5 = 6,
	s200_N315r5 = 7,
	s400_N315r5 = 8,
	s600_N315r5 = 9,
	s800_N315r5 = 10,
	s1000_N315r5 = 11,
};
typedef Enumerated<CONSTRAINED, 11> N315r5;

enum NeighCellSIAcquisitionCapabilitysupportOfIntraFreqSIAcquisitionForHOValues {
	true_NeighCellSIAcquisitionCapabilitysupportOfIntraFreqSIAcquisitionForHO = 0,
};
typedef Enumerated<CONSTRAINED, 0> NeighCellSIAcquisitionCapabilitysupportOfIntraFreqSIAcquisitionForHO;

enum NeighCellSIAcquisitionCapabilitysupportOfInterFreqSIAcquisitionForHOValues {
	true_NeighCellSIAcquisitionCapabilitysupportOfInterFreqSIAcquisitionForHO = 0,
};
typedef Enumerated<CONSTRAINED, 0> NeighCellSIAcquisitionCapabilitysupportOfInterFreqSIAcquisitionForHO;

enum NeighCellSIAcquisitionCapabilitysupportOfE_UtraSIAcquisitionForHOValues {
	true_NeighCellSIAcquisitionCapabilitysupportOfE_UtraSIAcquisitionForHO = 0,
};
typedef Enumerated<CONSTRAINED, 0> NeighCellSIAcquisitionCapabilitysupportOfE_UtraSIAcquisitionForHO;

class NeighCellSIAcquisitionCapability : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	NeighCellSIAcquisitionCapability(): Sequence(&theInfo) {}

	void setNeighCellSIAcquisitionCapabilitysupportOfIntraFreqSIAcquisitionForHO(const NeighCellSIAcquisitionCapabilitysupportOfIntraFreqSIAcquisitionForHO& neighCellSIAcquisitionCapabilitysupportOfIntraFreqSIAcquisitionForHO) { *static_cast<NeighCellSIAcquisitionCapabilitysupportOfIntraFreqSIAcquisitionForHO*>(items[0]) = neighCellSIAcquisitionCapabilitysupportOfIntraFreqSIAcquisitionForHO; }
	void setNeighCellSIAcquisitionCapabilitysupportOfInterFreqSIAcquisitionForHO(const NeighCellSIAcquisitionCapabilitysupportOfInterFreqSIAcquisitionForHO& neighCellSIAcquisitionCapabilitysupportOfInterFreqSIAcquisitionForHO) { *static_cast<NeighCellSIAcquisitionCapabilitysupportOfInterFreqSIAcquisitionForHO*>(items[1]) = neighCellSIAcquisitionCapabilitysupportOfInterFreqSIAcquisitionForHO; }
	void setNeighCellSIAcquisitionCapabilitysupportOfE_UtraSIAcquisitionForHO(const NeighCellSIAcquisitionCapabilitysupportOfE_UtraSIAcquisitionForHO& neighCellSIAcquisitionCapabilitysupportOfE_UtraSIAcquisitionForHO) { *static_cast<NeighCellSIAcquisitionCapabilitysupportOfE_UtraSIAcquisitionForHO*>(items[2]) = neighCellSIAcquisitionCapabilitysupportOfE_UtraSIAcquisitionForHO; }
};

class NetworkAssistedGANSSSupportedList : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	NetworkAssistedGANSSSupportedList(): Sequence(&theInfo) {}

};

class NetworkAssistedGANSSSupportedListv860ext : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	NetworkAssistedGANSSSupportedListv860ext(): Sequence(&theInfo) {}

};

enum NetworkAssistedGPSSupportedValues {
	networkBased_NetworkAssistedGPSSupported = 0,
	ue_Based_NetworkAssistedGPSSupported = 1,
	bothNetworkAndUE_Based_NetworkAssistedGPSSupported = 2,
	noNetworkAssistedGPS_NetworkAssistedGPSSupported = 3,
};
typedef Enumerated<CONSTRAINED, 3> NetworkAssistedGPSSupported;

enum PagingCauseValues {
	terminatingConversationalCall_PagingCause = 0,
	terminatingStreamingCall_PagingCause = 1,
	terminatingInteractiveCall_PagingCause = 2,
	terminatingBackgroundCall_PagingCause = 3,
	terminatingHighPrioritySignalling_PagingCause = 4,
	terminatingLowPrioritySignalling_PagingCause = 5,
	terminatingCauseUnknown_PagingCause = 6,
	spare_PagingCause = 7,
};
typedef Enumerated<CONSTRAINED, 7> PagingCause;

class PagingRecordCnIdentity : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PagingRecordCnIdentity(): Sequence(&theInfo) {}

	void setPagingCause(const PagingCause& pagingCause) { *static_cast<PagingCause*>(items[0]) = pagingCause; }
	void setCnDomainIdentity(const CNDomainIdentity& cnDomainIdentity) { *static_cast<CNDomainIdentity*>(items[1]) = cnDomainIdentity; }
	void setCnpagedUEIdentity(const CNPagedUEIdentity& cnpagedUEIdentity) { *static_cast<CNPagedUEIdentity*>(items[2]) = cnpagedUEIdentity; }
};

typedef BitString<CONSTRAINED, 12, 12> SRNCIdentity;

typedef BitString<CONSTRAINED, 20, 20> SRNTI;

class URNTI : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	URNTI(): Sequence(&theInfo) {}

	void setSrncIdentity(const SRNCIdentity& srncIdentity) { *static_cast<SRNCIdentity*>(items[0]) = srncIdentity; }
	void setSRNTI(const SRNTI& sRNTI) { *static_cast<SRNTI*>(items[1]) = sRNTI; }
};

class PagingRecordUtranIdentityCnOriginatedPageconnectedModeUE : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PagingRecordUtranIdentityCnOriginatedPageconnectedModeUE(): Sequence(&theInfo) {}

	void setPagingCause(const PagingCause& pagingCause) { *static_cast<PagingCause*>(items[0]) = pagingCause; }
	void setCnDomainIdentity(const CNDomainIdentity& cnDomainIdentity) { *static_cast<CNDomainIdentity*>(items[1]) = cnDomainIdentity; }
	void setPagingRecordTypeID(const PagingRecordTypeID& pagingRecordTypeID) { *static_cast<PagingRecordTypeID*>(items[2]) = pagingRecordTypeID; }
};

class PagingRecordUtranIdentity : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PagingRecordUtranIdentity(): Sequence(&theInfo) {}

	void setURNTI(const URNTI& uRNTI) { *static_cast<URNTI*>(items[0]) = uRNTI; }
	void setPagingRecordUtranIdentityCnOriginatedPageconnectedModeUE(const PagingRecordUtranIdentityCnOriginatedPageconnectedModeUE& pagingRecordUtranIdentityCnOriginatedPageconnectedModeUE) { *static_cast<PagingRecordUtranIdentityCnOriginatedPageconnectedModeUE*>(items[1]) = pagingRecordUtranIdentityCnOriginatedPageconnectedModeUE; }
};

class PagingRecord : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PagingRecordChoices {
		pagingRecordCnIdentity = 0,
		pagingRecordUtranIdentity = 1,
	};
	static const Info theInfo;
	PagingRecord(): Choice(&theInfo) {}
};

class PagingRecord2r5UtranSingleUEIdentityCnOriginatedPageconnectedModeUE : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PagingRecord2r5UtranSingleUEIdentityCnOriginatedPageconnectedModeUE(): Sequence(&theInfo) {}

	void setPagingCause(const PagingCause& pagingCause) { *static_cast<PagingCause*>(items[0]) = pagingCause; }
	void setCnDomainIdentity(const CNDomainIdentity& cnDomainIdentity) { *static_cast<CNDomainIdentity*>(items[1]) = cnDomainIdentity; }
	void setPagingRecordTypeID(const PagingRecordTypeID& pagingRecordTypeID) { *static_cast<PagingRecordTypeID*>(items[2]) = pagingRecordTypeID; }
};

class PagingRecord2r5UtranSingleUEIdentity : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PagingRecord2r5UtranSingleUEIdentity(): Sequence(&theInfo) {}

	void setURNTI(const URNTI& uRNTI) { *static_cast<URNTI*>(items[0]) = uRNTI; }
	void setPagingRecord2r5UtranSingleUEIdentityCnOriginatedPageconnectedModeUE(const PagingRecord2r5UtranSingleUEIdentityCnOriginatedPageconnectedModeUE& pagingRecord2r5UtranSingleUEIdentityCnOriginatedPageconnectedModeUE) { *static_cast<PagingRecord2r5UtranSingleUEIdentityCnOriginatedPageconnectedModeUE*>(items[1]) = pagingRecord2r5UtranSingleUEIdentityCnOriginatedPageconnectedModeUE; }
	void setRrcConnectionReleaseInformation(const RRCConnectionReleaseInformation& rrcConnectionReleaseInformation) { *static_cast<RRCConnectionReleaseInformation*>(items[2]) = rrcConnectionReleaseInformation; }
};

typedef SequenceOf<GroupIdentityWithReleaseInformation, CONSTRAINED, 1 ,  maxURNTI_Group> PagingRecord2r5UtranGroupIdentity;

class PagingRecord2r5 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PagingRecord2r5Choices {
		pagingRecord2r5UtranSingleUEIdentity = 0,
		pagingRecord2r5UtranGroupIdentity = 1,
	};
	static const Info theInfo;
	PagingRecord2r5(): Choice(&theInfo) {}
};

typedef SequenceOf<PagingRecord, CONSTRAINED, 1, maxPage1> PagingRecordList;

typedef SequenceOf<PagingRecord2r5, CONSTRAINED, 1, maxPage1> PagingRecord2Listr5;

typedef Boolean PDCPCapabilityLosslessSRNSRelocationSupport;

typedef Null PDCPCapabilitySupportForRfc2507NotSupported;

class PDCPCapabilitySupportForRfc2507 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PDCPCapabilitySupportForRfc2507Choices {
		pDCPCapabilitySupportForRfc2507NotSupported = 0,
		supported = 1,
	};
	static const Info theInfo;
	PDCPCapabilitySupportForRfc2507(): Choice(&theInfo) {}
};

class PDCPCapability : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PDCPCapability(): Sequence(&theInfo) {}

	void setPDCPCapabilityLosslessSRNSRelocationSupport(const PDCPCapabilityLosslessSRNSRelocationSupport& pDCPCapabilityLosslessSRNSRelocationSupport) { *static_cast<PDCPCapabilityLosslessSRNSRelocationSupport*>(items[0]) = pDCPCapabilityLosslessSRNSRelocationSupport; }
	void setPDCPCapabilitySupportForRfc2507(const PDCPCapabilitySupportForRfc2507& pDCPCapabilitySupportForRfc2507) { *static_cast<PDCPCapabilitySupportForRfc2507*>(items[1]) = pDCPCapabilitySupportForRfc2507; }
};

typedef Null PDCPCapabilityr4extSupportForRfc3095NotSupported;

typedef Integer<CONSTRAINED, 0, 65535> PDCPCapabilityr4extSupportForRfc3095SupportedReverseCompressionDepth;

class PDCPCapabilityr4extSupportForRfc3095Supported : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PDCPCapabilityr4extSupportForRfc3095Supported(): Sequence(&theInfo) {}

	void setMaxROHCContextSessions(const MaxROHCContextSessionsr4& maxROHCContextSessions) { *static_cast<MaxROHCContextSessionsr4*>(items[0]) = maxROHCContextSessions; }
	void setPDCPCapabilityr4extSupportForRfc3095SupportedReverseCompressionDepth(const PDCPCapabilityr4extSupportForRfc3095SupportedReverseCompressionDepth& pDCPCapabilityr4extSupportForRfc3095SupportedReverseCompressionDepth) { *static_cast<PDCPCapabilityr4extSupportForRfc3095SupportedReverseCompressionDepth*>(items[1]) = pDCPCapabilityr4extSupportForRfc3095SupportedReverseCompressionDepth; }
};

class PDCPCapabilityr4extSupportForRfc3095 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PDCPCapabilityr4extSupportForRfc3095Choices {
		pDCPCapabilityr4extSupportForRfc3095NotSupported = 0,
		pDCPCapabilityr4extSupportForRfc3095Supported = 1,
	};
	static const Info theInfo;
	PDCPCapabilityr4extSupportForRfc3095(): Choice(&theInfo) {}
};

class PDCPCapabilityr4ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PDCPCapabilityr4ext(): Sequence(&theInfo) {}

	void setPDCPCapabilityr4extSupportForRfc3095(const PDCPCapabilityr4extSupportForRfc3095& pDCPCapabilityr4extSupportForRfc3095) { *static_cast<PDCPCapabilityr4extSupportForRfc3095*>(items[0]) = pDCPCapabilityr4extSupportForRfc3095; }
};

typedef Boolean PDCPCapabilityr5extSupportForRfc3095ContextRelocation;

class PDCPCapabilityr5ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PDCPCapabilityr5ext(): Sequence(&theInfo) {}

	void setPDCPCapabilityr5extSupportForRfc3095ContextRelocation(const PDCPCapabilityr5extSupportForRfc3095ContextRelocation& pDCPCapabilityr5extSupportForRfc3095ContextRelocation) { *static_cast<PDCPCapabilityr5extSupportForRfc3095ContextRelocation*>(items[0]) = pDCPCapabilityr5extSupportForRfc3095ContextRelocation; }
	void setMaxHcContextSpace(const MaxHcContextSpacer5ext& maxHcContextSpace) { *static_cast<MaxHcContextSpacer5ext*>(items[1]) = maxHcContextSpace; }
};

enum PDCPCapabilityr5ext2losslessDLRLC_PDUSizeChangeValues {
	true_PDCPCapabilityr5ext2losslessDLRLC_PDUSizeChange = 0,
};
typedef Enumerated<CONSTRAINED, 0> PDCPCapabilityr5ext2losslessDLRLC_PDUSizeChange;

class PDCPCapabilityr5ext2 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PDCPCapabilityr5ext2(): Sequence(&theInfo) {}

	void setPDCPCapabilityr5ext2losslessDLRLC_PDUSizeChange(const PDCPCapabilityr5ext2losslessDLRLC_PDUSizeChange& pDCPCapabilityr5ext2losslessDLRLC_PDUSizeChange) { *static_cast<PDCPCapabilityr5ext2losslessDLRLC_PDUSizeChange*>(items[0]) = pDCPCapabilityr5ext2losslessDLRLC_PDUSizeChange; }
};

enum PDCPCapabilityv770extsupportForCSVoiceoverHSPAValues {
	true_PDCPCapabilityv770extsupportForCSVoiceoverHSPA = 0,
};
typedef Enumerated<CONSTRAINED, 0> PDCPCapabilityv770extsupportForCSVoiceoverHSPA;

class PDCPCapabilityv770ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PDCPCapabilityv770ext(): Sequence(&theInfo) {}

	void setPDCPCapabilityv770extsupportForCSVoiceoverHSPA(const PDCPCapabilityv770extsupportForCSVoiceoverHSPA& pDCPCapabilityv770extsupportForCSVoiceoverHSPA) { *static_cast<PDCPCapabilityv770extsupportForCSVoiceoverHSPA*>(items[0]) = pDCPCapabilityv770extsupportForCSVoiceoverHSPA; }
};

typedef Boolean ULPhysChCapabilityFDDDummy;

class ULPhysChCapabilityFDD : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULPhysChCapabilityFDD(): Sequence(&theInfo) {}

	void setMaxNoDPDCHBitsTransmitted(const MaxNoDPDCHBitsTransmitted& maxNoDPDCHBitsTransmitted) { *static_cast<MaxNoDPDCHBitsTransmitted*>(items[0]) = maxNoDPDCHBitsTransmitted; }
	void setULPhysChCapabilityFDDDummy(const ULPhysChCapabilityFDDDummy& uLPhysChCapabilityFDDDummy) { *static_cast<ULPhysChCapabilityFDDDummy*>(items[1]) = uLPhysChCapabilityFDDDummy; }
};

class PhysicalChannelCapabilityFddPhysChCapability : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityFddPhysChCapability(): Sequence(&theInfo) {}

	void setDownlinkPhysChCapability(const DLPhysChCapabilityFDD& downlinkPhysChCapability) { *static_cast<DLPhysChCapabilityFDD*>(items[0]) = downlinkPhysChCapability; }
	void setUplinkPhysChCapability(const ULPhysChCapabilityFDD& uplinkPhysChCapability) { *static_cast<ULPhysChCapabilityFDD*>(items[1]) = uplinkPhysChCapability; }
};

typedef Boolean ULPhysChCapabilityTDDSupportOfPUSCH;

class ULPhysChCapabilityTDD : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	ULPhysChCapabilityTDD(): Sequence(&theInfo) {}

	void setMaxTSPerFrame(const MaxTSPerFrame& maxTSPerFrame) { *static_cast<MaxTSPerFrame*>(items[0]) = maxTSPerFrame; }
	void setMaxPhysChPerTimeslot(const MaxPhysChPerTimeslot& maxPhysChPerTimeslot) { *static_cast<MaxPhysChPerTimeslot*>(items[1]) = maxPhysChPerTimeslot; }
	void setMinimumSF(const MinimumSFUL& minimumSF) { *static_cast<MinimumSFUL*>(items[2]) = minimumSF; }
	void setULPhysChCapabilityTDDSupportOfPUSCH(const ULPhysChCapabilityTDDSupportOfPUSCH& uLPhysChCapabilityTDDSupportOfPUSCH) { *static_cast<ULPhysChCapabilityTDDSupportOfPUSCH*>(items[3]) = uLPhysChCapabilityTDDSupportOfPUSCH; }
};

class PhysicalChannelCapabilityTddPhysChCapability : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityTddPhysChCapability(): Sequence(&theInfo) {}

	void setDownlinkPhysChCapability(const DLPhysChCapabilityTDD& downlinkPhysChCapability) { *static_cast<DLPhysChCapabilityTDD*>(items[0]) = downlinkPhysChCapability; }
	void setUplinkPhysChCapability(const ULPhysChCapabilityTDD& uplinkPhysChCapability) { *static_cast<ULPhysChCapabilityTDD*>(items[1]) = uplinkPhysChCapability; }
};

class PhysicalChannelCapability : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PhysicalChannelCapability(): Sequence(&theInfo) {}

	void setPhysicalChannelCapabilityFddPhysChCapability(const PhysicalChannelCapabilityFddPhysChCapability& physicalChannelCapabilityFddPhysChCapability) { *static_cast<PhysicalChannelCapabilityFddPhysChCapability*>(items[0]) = physicalChannelCapabilityFddPhysChCapability; }
	void setPhysicalChannelCapabilityTddPhysChCapability(const PhysicalChannelCapabilityTddPhysChCapability& physicalChannelCapabilityTddPhysChCapability) { *static_cast<PhysicalChannelCapabilityTddPhysChCapability*>(items[1]) = physicalChannelCapabilityTddPhysChCapability; }
};

typedef Integer<CONSTRAINED, 7, 7> ULPhysChCapabilityFDDv770extEdchPhysicalLayerCategoryextension;

enum ULPhysChCapabilityFDDv770extdiscontinuousDpcchTransmissionValues {
	true_ULPhysChCapabilityFDDv770extdiscontinuousDpcchTransmission = 0,
};
typedef Enumerated<CONSTRAINED, 0> ULPhysChCapabilityFDDv770extdiscontinuousDpcchTransmission;

enum ULPhysChCapabilityFDDv770extslotFormat4Values {
	true_ULPhysChCapabilityFDDv770extslotFormat4 = 0,
};
typedef Enumerated<CONSTRAINED, 0> ULPhysChCapabilityFDDv770extslotFormat4;

class ULPhysChCapabilityFDDv770ext : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULPhysChCapabilityFDDv770ext(): Sequence(&theInfo) {}

	void setULPhysChCapabilityFDDv770extEdchPhysicalLayerCategoryextension(const ULPhysChCapabilityFDDv770extEdchPhysicalLayerCategoryextension& uLPhysChCapabilityFDDv770extEdchPhysicalLayerCategoryextension) { *static_cast<ULPhysChCapabilityFDDv770extEdchPhysicalLayerCategoryextension*>(items[0]) = uLPhysChCapabilityFDDv770extEdchPhysicalLayerCategoryextension; }
	void setULPhysChCapabilityFDDv770extdiscontinuousDpcchTransmission(const ULPhysChCapabilityFDDv770extdiscontinuousDpcchTransmission& uLPhysChCapabilityFDDv770extdiscontinuousDpcchTransmission) { *static_cast<ULPhysChCapabilityFDDv770extdiscontinuousDpcchTransmission*>(items[1]) = uLPhysChCapabilityFDDv770extdiscontinuousDpcchTransmission; }
	void setULPhysChCapabilityFDDv770extslotFormat4(const ULPhysChCapabilityFDDv770extslotFormat4& uLPhysChCapabilityFDDv770extslotFormat4) { *static_cast<ULPhysChCapabilityFDDv770extslotFormat4*>(items[2]) = uLPhysChCapabilityFDDv770extslotFormat4; }
};

class PhysicalChannelCapabilityv770extFddPhysChCapability : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityv770extFddPhysChCapability(): Sequence(&theInfo) {}

	void setDownlinkPhysChCapability(const DLPhysChCapabilityFDDv770ext& downlinkPhysChCapability) { *static_cast<DLPhysChCapabilityFDDv770ext*>(items[0]) = downlinkPhysChCapability; }
	void setUplinkPhysChCapability(const ULPhysChCapabilityFDDv770ext& uplinkPhysChCapability) { *static_cast<ULPhysChCapabilityFDDv770ext*>(items[1]) = uplinkPhysChCapability; }
};

typedef Integer<CONSTRAINED, 1, 16> ULPhysChCapabilityTDD384v770extTdd384edchSupportedTddedchPhysicalLayerCategory;

class ULPhysChCapabilityTDD384v770extTdd384edchSupported : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULPhysChCapabilityTDD384v770extTdd384edchSupported(): Sequence(&theInfo) {}

	void setULPhysChCapabilityTDD384v770extTdd384edchSupportedTddedchPhysicalLayerCategory(const ULPhysChCapabilityTDD384v770extTdd384edchSupportedTddedchPhysicalLayerCategory& uLPhysChCapabilityTDD384v770extTdd384edchSupportedTddedchPhysicalLayerCategory) { *static_cast<ULPhysChCapabilityTDD384v770extTdd384edchSupportedTddedchPhysicalLayerCategory*>(items[0]) = uLPhysChCapabilityTDD384v770extTdd384edchSupportedTddedchPhysicalLayerCategory; }
};

typedef Null ULPhysChCapabilityTDD384v770extTdd384edchUnsupported;

class ULPhysChCapabilityTDD384v770extTdd384edch : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULPhysChCapabilityTDD384v770extTdd384edchChoices {
		uLPhysChCapabilityTDD384v770extTdd384edchSupported = 0,
		uLPhysChCapabilityTDD384v770extTdd384edchUnsupported = 1,
	};
	static const Info theInfo;
	ULPhysChCapabilityTDD384v770extTdd384edch(): Choice(&theInfo) {}
};

class ULPhysChCapabilityTDD384v770ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULPhysChCapabilityTDD384v770ext(): Sequence(&theInfo) {}

	void setULPhysChCapabilityTDD384v770extTdd384edch(const ULPhysChCapabilityTDD384v770extTdd384edch& uLPhysChCapabilityTDD384v770extTdd384edch) { *static_cast<ULPhysChCapabilityTDD384v770extTdd384edch*>(items[0]) = uLPhysChCapabilityTDD384v770extTdd384edch; }
};

class PhysicalChannelCapabilityv770extTddPhysChCapability384 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityv770extTddPhysChCapability384(): Sequence(&theInfo) {}

	void setUplinkPhysChCapability(const ULPhysChCapabilityTDD384v770ext& uplinkPhysChCapability) { *static_cast<ULPhysChCapabilityTDD384v770ext*>(items[0]) = uplinkPhysChCapability; }
};

typedef Boolean ULPhysChCapabilityTDD768SupportOfPUSCH;

typedef Integer<CONSTRAINED, 1, 16> ULPhysChCapabilityTDD768Tdd384edchSupportedTddedchPhysicalLayerCategory;

class ULPhysChCapabilityTDD768Tdd384edchSupported : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULPhysChCapabilityTDD768Tdd384edchSupported(): Sequence(&theInfo) {}

	void setULPhysChCapabilityTDD768Tdd384edchSupportedTddedchPhysicalLayerCategory(const ULPhysChCapabilityTDD768Tdd384edchSupportedTddedchPhysicalLayerCategory& uLPhysChCapabilityTDD768Tdd384edchSupportedTddedchPhysicalLayerCategory) { *static_cast<ULPhysChCapabilityTDD768Tdd384edchSupportedTddedchPhysicalLayerCategory*>(items[0]) = uLPhysChCapabilityTDD768Tdd384edchSupportedTddedchPhysicalLayerCategory; }
};

typedef Null ULPhysChCapabilityTDD768Tdd384edchUnsupported;

class ULPhysChCapabilityTDD768Tdd384edch : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULPhysChCapabilityTDD768Tdd384edchChoices {
		uLPhysChCapabilityTDD768Tdd384edchSupported = 0,
		uLPhysChCapabilityTDD768Tdd384edchUnsupported = 1,
	};
	static const Info theInfo;
	ULPhysChCapabilityTDD768Tdd384edch(): Choice(&theInfo) {}
};

class ULPhysChCapabilityTDD768 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	ULPhysChCapabilityTDD768(): Sequence(&theInfo) {}

	void setMaxTSPerFrame(const MaxTSPerFrame& maxTSPerFrame) { *static_cast<MaxTSPerFrame*>(items[0]) = maxTSPerFrame; }
	void setMaxPhysChPerTimeslot(const MaxPhysChPerTimeslot& maxPhysChPerTimeslot) { *static_cast<MaxPhysChPerTimeslot*>(items[1]) = maxPhysChPerTimeslot; }
	void setMinimumSF(const MinimumSFUL& minimumSF) { *static_cast<MinimumSFUL*>(items[2]) = minimumSF; }
	void setULPhysChCapabilityTDD768SupportOfPUSCH(const ULPhysChCapabilityTDD768SupportOfPUSCH& uLPhysChCapabilityTDD768SupportOfPUSCH) { *static_cast<ULPhysChCapabilityTDD768SupportOfPUSCH*>(items[3]) = uLPhysChCapabilityTDD768SupportOfPUSCH; }
	void setULPhysChCapabilityTDD768Tdd384edch(const ULPhysChCapabilityTDD768Tdd384edch& uLPhysChCapabilityTDD768Tdd384edch) { *static_cast<ULPhysChCapabilityTDD768Tdd384edch*>(items[4]) = uLPhysChCapabilityTDD768Tdd384edch; }
};

class PhysicalChannelCapabilityv770extTddPhysChCapability768 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityv770extTddPhysChCapability768(): Sequence(&theInfo) {}

	void setDownlinkPhysChCapability(const DLPhysChCapabilityTDD768& downlinkPhysChCapability) { *static_cast<DLPhysChCapabilityTDD768*>(items[0]) = downlinkPhysChCapability; }
	void setUplinkPhysChCapability(const ULPhysChCapabilityTDD768& uplinkPhysChCapability) { *static_cast<ULPhysChCapabilityTDD768*>(items[1]) = uplinkPhysChCapability; }
};

typedef Integer<CONSTRAINED, 1, 6> ULPhysChCapabilityTDD128v770extTdd128edchSupportedTddedchPhysicalLayerCategory;

class ULPhysChCapabilityTDD128v770extTdd128edchSupported : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULPhysChCapabilityTDD128v770extTdd128edchSupported(): Sequence(&theInfo) {}

	void setULPhysChCapabilityTDD128v770extTdd128edchSupportedTddedchPhysicalLayerCategory(const ULPhysChCapabilityTDD128v770extTdd128edchSupportedTddedchPhysicalLayerCategory& uLPhysChCapabilityTDD128v770extTdd128edchSupportedTddedchPhysicalLayerCategory) { *static_cast<ULPhysChCapabilityTDD128v770extTdd128edchSupportedTddedchPhysicalLayerCategory*>(items[0]) = uLPhysChCapabilityTDD128v770extTdd128edchSupportedTddedchPhysicalLayerCategory; }
};

typedef Null ULPhysChCapabilityTDD128v770extTdd128edchUnsupported;

class ULPhysChCapabilityTDD128v770extTdd128edch : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULPhysChCapabilityTDD128v770extTdd128edchChoices {
		uLPhysChCapabilityTDD128v770extTdd128edchSupported = 0,
		uLPhysChCapabilityTDD128v770extTdd128edchUnsupported = 1,
	};
	static const Info theInfo;
	ULPhysChCapabilityTDD128v770extTdd128edch(): Choice(&theInfo) {}
};

class ULPhysChCapabilityTDD128v770ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULPhysChCapabilityTDD128v770ext(): Sequence(&theInfo) {}

	void setMaxPhysChPerTimeslot(const MaxPhysChPerTimeslotLCRr7& maxPhysChPerTimeslot) { *static_cast<MaxPhysChPerTimeslotLCRr7*>(items[0]) = maxPhysChPerTimeslot; }
	void setULPhysChCapabilityTDD128v770extTdd128edch(const ULPhysChCapabilityTDD128v770extTdd128edch& uLPhysChCapabilityTDD128v770extTdd128edch) { *static_cast<ULPhysChCapabilityTDD128v770extTdd128edch*>(items[1]) = uLPhysChCapabilityTDD128v770extTdd128edch; }
};

class PhysicalChannelCapabilityv770extTddPhysChCapability128 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityv770extTddPhysChCapability128(): Sequence(&theInfo) {}

	void setDownlinkPhysChCapability(const DLPhysChCapabilityTDD128v770ext& downlinkPhysChCapability) { *static_cast<DLPhysChCapabilityTDD128v770ext*>(items[0]) = downlinkPhysChCapability; }
	void setUplinkPhysChCapability(const ULPhysChCapabilityTDD128v770ext& uplinkPhysChCapability) { *static_cast<ULPhysChCapabilityTDD128v770ext*>(items[1]) = uplinkPhysChCapability; }
};

class PhysicalChannelCapabilityv770ext : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityv770ext(): Sequence(&theInfo) {}

	void setPhysicalChannelCapabilityv770extFddPhysChCapability(const PhysicalChannelCapabilityv770extFddPhysChCapability& physicalChannelCapabilityv770extFddPhysChCapability) { *static_cast<PhysicalChannelCapabilityv770extFddPhysChCapability*>(items[0]) = physicalChannelCapabilityv770extFddPhysChCapability; }
	void setPhysicalChannelCapabilityv770extTddPhysChCapability384(const PhysicalChannelCapabilityv770extTddPhysChCapability384& physicalChannelCapabilityv770extTddPhysChCapability384) { *static_cast<PhysicalChannelCapabilityv770extTddPhysChCapability384*>(items[1]) = physicalChannelCapabilityv770extTddPhysChCapability384; }
	void setPhysicalChannelCapabilityv770extTddPhysChCapability768(const PhysicalChannelCapabilityv770extTddPhysChCapability768& physicalChannelCapabilityv770extTddPhysChCapability768) { *static_cast<PhysicalChannelCapabilityv770extTddPhysChCapability768*>(items[2]) = physicalChannelCapabilityv770extTddPhysChCapability768; }
	void setPhysicalChannelCapabilityv770extTddPhysChCapability128(const PhysicalChannelCapabilityv770extTddPhysChCapability128& physicalChannelCapabilityv770extTddPhysChCapability128) { *static_cast<PhysicalChannelCapabilityv770extTddPhysChCapability128*>(items[3]) = physicalChannelCapabilityv770extTddPhysChCapability128; }
};

class PhysicalChannelCapabilityv860extFddPhysChCapability : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityv860extFddPhysChCapability(): Sequence(&theInfo) {}

	void setDownlinkPhysChCapability(const DLPhysChCapabilityFDDv860ext& downlinkPhysChCapability) { *static_cast<DLPhysChCapabilityFDDv860ext*>(items[0]) = downlinkPhysChCapability; }
};

class PhysicalChannelCapabilityv860extTddPhysChCapability128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityv860extTddPhysChCapability128(): Sequence(&theInfo) {}

	void setDownlinkPhysChCapability(const DLPhysChCapabilityTDD128v860ext& downlinkPhysChCapability) { *static_cast<DLPhysChCapabilityTDD128v860ext*>(items[0]) = downlinkPhysChCapability; }
};

class PhysicalChannelCapabilityv860ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityv860ext(): Sequence(&theInfo) {}

	void setPhysicalChannelCapabilityv860extFddPhysChCapability(const PhysicalChannelCapabilityv860extFddPhysChCapability& physicalChannelCapabilityv860extFddPhysChCapability) { *static_cast<PhysicalChannelCapabilityv860extFddPhysChCapability*>(items[0]) = physicalChannelCapabilityv860extFddPhysChCapability; }
	void setPhysicalChannelCapabilityv860extTddPhysChCapability128(const PhysicalChannelCapabilityv860extTddPhysChCapability128& physicalChannelCapabilityv860extTddPhysChCapability128) { *static_cast<PhysicalChannelCapabilityv860extTddPhysChCapability128*>(items[1]) = physicalChannelCapabilityv860extTddPhysChCapability128; }
};

typedef Integer<CONSTRAINED, 8, 9> ULPhysChCapabilityFDDv920extEdchPhysicalLayerCategoryextension2;

class ULPhysChCapabilityFDDv920ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULPhysChCapabilityFDDv920ext(): Sequence(&theInfo) {}

	void setULPhysChCapabilityFDDv920extEdchPhysicalLayerCategoryextension2(const ULPhysChCapabilityFDDv920extEdchPhysicalLayerCategoryextension2& uLPhysChCapabilityFDDv920extEdchPhysicalLayerCategoryextension2) { *static_cast<ULPhysChCapabilityFDDv920extEdchPhysicalLayerCategoryextension2*>(items[0]) = uLPhysChCapabilityFDDv920extEdchPhysicalLayerCategoryextension2; }
};

class PhysicalChannelCapabilityv920extFddPhysChCapability : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityv920extFddPhysChCapability(): Sequence(&theInfo) {}

	void setDownlinkPhysChCapability(const DLPhysChCapabilityFDDv920ext& downlinkPhysChCapability) { *static_cast<DLPhysChCapabilityFDDv920ext*>(items[0]) = downlinkPhysChCapability; }
	void setUplinkPhysChCapability(const ULPhysChCapabilityFDDv920ext& uplinkPhysChCapability) { *static_cast<ULPhysChCapabilityFDDv920ext*>(items[1]) = uplinkPhysChCapability; }
};

class PhysicalChannelCapabilityv920ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityv920ext(): Sequence(&theInfo) {}

	void setPhysicalChannelCapabilityv920extFddPhysChCapability(const PhysicalChannelCapabilityv920extFddPhysChCapability& physicalChannelCapabilityv920extFddPhysChCapability) { *static_cast<PhysicalChannelCapabilityv920extFddPhysChCapability*>(items[0]) = physicalChannelCapabilityv920extFddPhysChCapability; }
};

class PhysicalChannelCapabilityInfov770extTddPhysChCapability768 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityInfov770extTddPhysChCapability768(): Sequence(&theInfo) {}

	void setDownlinkPhysChCapability(const DLPhysChCapabilityInfoTDD768& downlinkPhysChCapability) { *static_cast<DLPhysChCapabilityInfoTDD768*>(items[0]) = downlinkPhysChCapability; }
	void setUplinkPhysChCapability(const ULPhysChCapabilityTDD& uplinkPhysChCapability) { *static_cast<ULPhysChCapabilityTDD*>(items[1]) = uplinkPhysChCapability; }
};

class ULPhysChCapabilityInfoTDD128v770ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULPhysChCapabilityInfoTDD128v770ext(): Sequence(&theInfo) {}

	void setMaxPhysChPerTimeslot(const MaxPhysChPerTimeslotLCRr7& maxPhysChPerTimeslot) { *static_cast<MaxPhysChPerTimeslotLCRr7*>(items[0]) = maxPhysChPerTimeslot; }
};

class PhysicalChannelCapabilityInfov770extTddPhysChCapability128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityInfov770extTddPhysChCapability128(): Sequence(&theInfo) {}

	void setUplinkPhysChCapability(const ULPhysChCapabilityInfoTDD128v770ext& uplinkPhysChCapability) { *static_cast<ULPhysChCapabilityInfoTDD128v770ext*>(items[0]) = uplinkPhysChCapability; }
};

class PhysicalChannelCapabilityInfov770ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityInfov770ext(): Sequence(&theInfo) {}

	void setPhysicalChannelCapabilityInfov770extTddPhysChCapability768(const PhysicalChannelCapabilityInfov770extTddPhysChCapability768& physicalChannelCapabilityInfov770extTddPhysChCapability768) { *static_cast<PhysicalChannelCapabilityInfov770extTddPhysChCapability768*>(items[0]) = physicalChannelCapabilityInfov770extTddPhysChCapability768; }
	void setPhysicalChannelCapabilityInfov770extTddPhysChCapability128(const PhysicalChannelCapabilityInfov770extTddPhysChCapability128& physicalChannelCapabilityInfov770extTddPhysChCapability128) { *static_cast<PhysicalChannelCapabilityInfov770extTddPhysChCapability128*>(items[1]) = physicalChannelCapabilityInfov770extTddPhysChCapability128; }
};

typedef Boolean ULPhysChCapabilityTDDLCRr4SupportOfPUSCH;

typedef Boolean ULPhysChCapabilityTDDLCRr4SupportOf8PSK;

class ULPhysChCapabilityTDDLCRr4 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	ULPhysChCapabilityTDDLCRr4(): Sequence(&theInfo) {}

	void setMaxTSPerSubFrame(const MaxTSPerSubFramer4& maxTSPerSubFrame) { *static_cast<MaxTSPerSubFramer4*>(items[0]) = maxTSPerSubFrame; }
	void setMaxPhysChPerTimeslot(const MaxPhysChPerTimeslot& maxPhysChPerTimeslot) { *static_cast<MaxPhysChPerTimeslot*>(items[1]) = maxPhysChPerTimeslot; }
	void setMinimumSF(const MinimumSFUL& minimumSF) { *static_cast<MinimumSFUL*>(items[2]) = minimumSF; }
	void setULPhysChCapabilityTDDLCRr4SupportOfPUSCH(const ULPhysChCapabilityTDDLCRr4SupportOfPUSCH& uLPhysChCapabilityTDDLCRr4SupportOfPUSCH) { *static_cast<ULPhysChCapabilityTDDLCRr4SupportOfPUSCH*>(items[3]) = uLPhysChCapabilityTDDLCRr4SupportOfPUSCH; }
	void setULPhysChCapabilityTDDLCRr4SupportOf8PSK(const ULPhysChCapabilityTDDLCRr4SupportOf8PSK& uLPhysChCapabilityTDDLCRr4SupportOf8PSK) { *static_cast<ULPhysChCapabilityTDDLCRr4SupportOf8PSK*>(items[4]) = uLPhysChCapabilityTDDLCRr4SupportOf8PSK; }
};

class PhysicalChannelCapabilityLCRr4Tdd128PhysChCapability : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityLCRr4Tdd128PhysChCapability(): Sequence(&theInfo) {}

	void setDownlinkPhysChCapability(const DLPhysChCapabilityTDDLCRr4& downlinkPhysChCapability) { *static_cast<DLPhysChCapabilityTDDLCRr4*>(items[0]) = downlinkPhysChCapability; }
	void setUplinkPhysChCapability(const ULPhysChCapabilityTDDLCRr4& uplinkPhysChCapability) { *static_cast<ULPhysChCapabilityTDDLCRr4*>(items[1]) = uplinkPhysChCapability; }
};

class PhysicalChannelCapabilityLCRr4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityLCRr4(): Sequence(&theInfo) {}

	void setPhysicalChannelCapabilityLCRr4Tdd128PhysChCapability(const PhysicalChannelCapabilityLCRr4Tdd128PhysChCapability& physicalChannelCapabilityLCRr4Tdd128PhysChCapability) { *static_cast<PhysicalChannelCapabilityLCRr4Tdd128PhysChCapability*>(items[0]) = physicalChannelCapabilityLCRr4Tdd128PhysChCapability; }
};

typedef Boolean PhysicalChannelCapabilityhspdschr5FddhspdschSupportedDummy;

typedef Boolean PhysicalChannelCapabilityhspdschr5FddhspdschSupportedDummy2;

class PhysicalChannelCapabilityhspdschr5FddhspdschSupported : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityhspdschr5FddhspdschSupported(): Sequence(&theInfo) {}

	void setHsdschphysicallayercategory(const HSDSCHphysicallayercategory& hsdschphysicallayercategory) { *static_cast<HSDSCHphysicallayercategory*>(items[0]) = hsdschphysicallayercategory; }
	void setPhysicalChannelCapabilityhspdschr5FddhspdschSupportedDummy(const PhysicalChannelCapabilityhspdschr5FddhspdschSupportedDummy& physicalChannelCapabilityhspdschr5FddhspdschSupportedDummy) { *static_cast<PhysicalChannelCapabilityhspdschr5FddhspdschSupportedDummy*>(items[1]) = physicalChannelCapabilityhspdschr5FddhspdschSupportedDummy; }
	void setPhysicalChannelCapabilityhspdschr5FddhspdschSupportedDummy2(const PhysicalChannelCapabilityhspdschr5FddhspdschSupportedDummy2& physicalChannelCapabilityhspdschr5FddhspdschSupportedDummy2) { *static_cast<PhysicalChannelCapabilityhspdschr5FddhspdschSupportedDummy2*>(items[2]) = physicalChannelCapabilityhspdschr5FddhspdschSupportedDummy2; }
};

typedef Null PhysicalChannelCapabilityhspdschr5FddhspdschUnsupported;

class PhysicalChannelCapabilityhspdschr5Fddhspdsch : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PhysicalChannelCapabilityhspdschr5FddhspdschChoices {
		physicalChannelCapabilityhspdschr5FddhspdschSupported = 0,
		physicalChannelCapabilityhspdschr5FddhspdschUnsupported = 1,
	};
	static const Info theInfo;
	PhysicalChannelCapabilityhspdschr5Fddhspdsch(): Choice(&theInfo) {}
};

typedef Null PhysicalChannelCapabilityhspdschr5Tdd384hspdschUnsupported;

class PhysicalChannelCapabilityhspdschr5Tdd384hspdsch : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PhysicalChannelCapabilityhspdschr5Tdd384hspdschChoices {
		supported = 0,
		physicalChannelCapabilityhspdschr5Tdd384hspdschUnsupported = 1,
	};
	static const Info theInfo;
	PhysicalChannelCapabilityhspdschr5Tdd384hspdsch(): Choice(&theInfo) {}
};

typedef Null PhysicalChannelCapabilityhspdschr5Tdd128hspdschUnsupported;

class PhysicalChannelCapabilityhspdschr5Tdd128hspdsch : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PhysicalChannelCapabilityhspdschr5Tdd128hspdschChoices {
		supported = 0,
		physicalChannelCapabilityhspdschr5Tdd128hspdschUnsupported = 1,
	};
	static const Info theInfo;
	PhysicalChannelCapabilityhspdschr5Tdd128hspdsch(): Choice(&theInfo) {}
};

class PhysicalChannelCapabilityhspdschr5 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityhspdschr5(): Sequence(&theInfo) {}

	void setPhysicalChannelCapabilityhspdschr5Fddhspdsch(const PhysicalChannelCapabilityhspdschr5Fddhspdsch& physicalChannelCapabilityhspdschr5Fddhspdsch) { *static_cast<PhysicalChannelCapabilityhspdschr5Fddhspdsch*>(items[0]) = physicalChannelCapabilityhspdschr5Fddhspdsch; }
	void setPhysicalChannelCapabilityhspdschr5Tdd384hspdsch(const PhysicalChannelCapabilityhspdschr5Tdd384hspdsch& physicalChannelCapabilityhspdschr5Tdd384hspdsch) { *static_cast<PhysicalChannelCapabilityhspdschr5Tdd384hspdsch*>(items[1]) = physicalChannelCapabilityhspdschr5Tdd384hspdsch; }
	void setPhysicalChannelCapabilityhspdschr5Tdd128hspdsch(const PhysicalChannelCapabilityhspdschr5Tdd128hspdsch& physicalChannelCapabilityhspdschr5Tdd128hspdsch) { *static_cast<PhysicalChannelCapabilityhspdschr5Tdd128hspdsch*>(items[2]) = physicalChannelCapabilityhspdschr5Tdd128hspdsch; }
};

enum PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriodValues {
	c2_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 0,
	c3_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 1,
	c4_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 2,
	c5_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 3,
	c6_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 4,
	c7_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 5,
	c8_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 6,
	c9_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 7,
	c10_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 8,
	c12_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 9,
	c14_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 10,
	c16_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 11,
	c18_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 12,
	c20_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 13,
	c24_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 14,
	c28_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 15,
	c32_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 16,
	c36_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 17,
	c40_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 18,
	c48_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 19,
	c56_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 20,
	c64_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 21,
	c72_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 22,
	c80_PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod = 23,
};
typedef Enumerated<CONSTRAINED, 23> PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod;

class PNBSCHAllocationr4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PNBSCHAllocationr4(): Sequence(&theInfo) {}

	void setPNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod(const PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod& pNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod) { *static_cast<PNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod*>(items[0]) = pNBSCHAllocationr4numberOfRepetitionsPerSFNPeriod; }
};

typedef Boolean PreRedirectionInfoSupportEUTRAFDD;

typedef Boolean PreRedirectionInfoSupportEUTRATDD;

class PreRedirectionInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PreRedirectionInfo(): Sequence(&theInfo) {}

	void setPreRedirectionInfoSupportEUTRAFDD(const PreRedirectionInfoSupportEUTRAFDD& preRedirectionInfoSupportEUTRAFDD) { *static_cast<PreRedirectionInfoSupportEUTRAFDD*>(items[0]) = preRedirectionInfoSupportEUTRAFDD; }
	void setPreRedirectionInfoSupportEUTRATDD(const PreRedirectionInfoSupportEUTRATDD& preRedirectionInfoSupportEUTRATDD) { *static_cast<PreRedirectionInfoSupportEUTRATDD*>(items[1]) = preRedirectionInfoSupportEUTRATDD; }
};

enum ProtocolErrorIndicatorValues {
	noError_ProtocolErrorIndicator = 0,
	errorOccurred_ProtocolErrorIndicator = 1,
};
typedef Enumerated<CONSTRAINED, 1> ProtocolErrorIndicator;

typedef Null ProtocolErrorIndicatorWithMoreInfoNoError;

class ProtocolErrorIndicatorWithMoreInfoErrorOccurred : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ProtocolErrorIndicatorWithMoreInfoErrorOccurred(): Sequence(&theInfo) {}

	void setRrcTransactionIdentifier(const RRCTransactionIdentifier& rrcTransactionIdentifier) { *static_cast<RRCTransactionIdentifier*>(items[0]) = rrcTransactionIdentifier; }
	void setProtocolErrorInformation(const ProtocolErrorInformation& protocolErrorInformation) { *static_cast<ProtocolErrorInformation*>(items[1]) = protocolErrorInformation; }
};

class ProtocolErrorIndicatorWithMoreInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ProtocolErrorIndicatorWithMoreInfoChoices {
		protocolErrorIndicatorWithMoreInfoNoError = 0,
		protocolErrorIndicatorWithMoreInfoErrorOccurred = 1,
	};
	static const Info theInfo;
	ProtocolErrorIndicatorWithMoreInfo(): Choice(&theInfo) {}
};

typedef Null ProtocolErrorMoreInformationDiagnosticsTypeType1Asn1ViolationOrEncodingError;

typedef Null ProtocolErrorMoreInformationDiagnosticsTypeType1MessageTypeNonexistent;

enum ReceivedMessageTypeValues {
	activeSetUpdate_ReceivedMessageType = 0,
	cellChangeOrderFromUTRAN_ReceivedMessageType = 1,
	cellUpdateConfirm_ReceivedMessageType = 2,
	counterCheck_ReceivedMessageType = 3,
	downlinkDirectTransfer_ReceivedMessageType = 4,
	interRATHandoverCommand_ReceivedMessageType = 5,
	measurementControl_ReceivedMessageType = 6,
	pagingType2_ReceivedMessageType = 7,
	physicalChannelReconfiguration_ReceivedMessageType = 8,
	physicalSharedChannelAllocation_ReceivedMessageType = 9,
	radioBearerReconfiguration_ReceivedMessageType = 10,
	radioBearerRelease_ReceivedMessageType = 11,
	radioBearerSetup_ReceivedMessageType = 12,
	rrcConnectionRelease_ReceivedMessageType = 13,
	rrcConnectionReject_ReceivedMessageType = 14,
	rrcConnectionSetup_ReceivedMessageType = 15,
	securityModeCommand_ReceivedMessageType = 16,
	signallingConnectionRelease_ReceivedMessageType = 17,
	transportChannelReconfiguration_ReceivedMessageType = 18,
	transportFormatCombinationControl_ReceivedMessageType = 19,
	ueCapabilityEnquiry_ReceivedMessageType = 20,
	ueCapabilityInformationConfirm_ReceivedMessageType = 21,
	uplinkPhysicalChannelControl_ReceivedMessageType = 22,
	uraUpdateConfirm_ReceivedMessageType = 23,
	utranMobilityInformation_ReceivedMessageType = 24,
	assistanceDataDelivery_ReceivedMessageType = 25,
	spare6_ReceivedMessageType = 26,
	spare5_ReceivedMessageType = 27,
	spare4_ReceivedMessageType = 28,
	spare3_ReceivedMessageType = 29,
	spare2_ReceivedMessageType = 30,
	spare1_ReceivedMessageType = 31,
};
typedef Enumerated<CONSTRAINED, 31> ReceivedMessageType;

class IdentificationOfReceivedMessage : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IdentificationOfReceivedMessage(): Sequence(&theInfo) {}

	void setRrcTransactionIdentifier(const RRCTransactionIdentifier& rrcTransactionIdentifier) { *static_cast<RRCTransactionIdentifier*>(items[0]) = rrcTransactionIdentifier; }
	void setReceivedMessageType(const ReceivedMessageType& receivedMessageType) { *static_cast<ReceivedMessageType*>(items[1]) = receivedMessageType; }
};

typedef Null ProtocolErrorMoreInformationDiagnosticsTypeType1Spare1;

typedef Null ProtocolErrorMoreInformationDiagnosticsTypeType1Spare2;

class ProtocolErrorMoreInformationDiagnosticsTypeType1 : public Choice {
private:
	static const void *choicesInfo[8];
public:
	enum ProtocolErrorMoreInformationDiagnosticsTypeType1Choices {
		protocolErrorMoreInformationDiagnosticsTypeType1Asn1ViolationOrEncodingError = 0,
		protocolErrorMoreInformationDiagnosticsTypeType1MessageTypeNonexistent = 1,
		messageNotCompatibleWithReceiverState = 2,
		ieValueNotComprehended = 3,
		conditionalInformationElementError = 4,
		messageExtensionNotComprehended = 5,
		protocolErrorMoreInformationDiagnosticsTypeType1Spare1 = 6,
		protocolErrorMoreInformationDiagnosticsTypeType1Spare2 = 7,
	};
	static const Info theInfo;
	ProtocolErrorMoreInformationDiagnosticsTypeType1(): Choice(&theInfo) {}
};

typedef Null ProtocolErrorMoreInformationDiagnosticsTypeSpare;

class ProtocolErrorMoreInformationDiagnosticsType : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ProtocolErrorMoreInformationDiagnosticsTypeChoices {
		protocolErrorMoreInformationDiagnosticsTypeType1 = 0,
		protocolErrorMoreInformationDiagnosticsTypeSpare = 1,
	};
	static const Info theInfo;
	ProtocolErrorMoreInformationDiagnosticsType(): Choice(&theInfo) {}
};

class ProtocolErrorMoreInformation : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ProtocolErrorMoreInformation(): Sequence(&theInfo) {}

	void setProtocolErrorMoreInformationDiagnosticsType(const ProtocolErrorMoreInformationDiagnosticsType& protocolErrorMoreInformationDiagnosticsType) { *static_cast<ProtocolErrorMoreInformationDiagnosticsType*>(items[0]) = protocolErrorMoreInformationDiagnosticsType; }
};

enum RadioFrequencyBandTDDListValues {
	a_RadioFrequencyBandTDDList = 0,
	b_RadioFrequencyBandTDDList = 1,
	c_RadioFrequencyBandTDDList = 2,
	ab_RadioFrequencyBandTDDList = 3,
	ac_RadioFrequencyBandTDDList = 4,
	bc_RadioFrequencyBandTDDList = 5,
	abc_RadioFrequencyBandTDDList = 6,
	spare_RadioFrequencyBandTDDList = 7,
};
typedef Enumerated<CONSTRAINED, 7> RadioFrequencyBandTDDList;

enum RadioFrequencyBandTDDListr7Values {
	a_RadioFrequencyBandTDDListr7 = 0,
	b_RadioFrequencyBandTDDListr7 = 1,
	c_RadioFrequencyBandTDDListr7 = 2,
	d_RadioFrequencyBandTDDListr7 = 3,
	ab_RadioFrequencyBandTDDListr7 = 4,
	ac_RadioFrequencyBandTDDListr7 = 5,
	ad_RadioFrequencyBandTDDListr7 = 6,
	bc_RadioFrequencyBandTDDListr7 = 7,
	bd_RadioFrequencyBandTDDListr7 = 8,
	cd_RadioFrequencyBandTDDListr7 = 9,
	abc_RadioFrequencyBandTDDListr7 = 10,
	abd_RadioFrequencyBandTDDListr7 = 11,
	acd_RadioFrequencyBandTDDListr7 = 12,
	bcd_RadioFrequencyBandTDDListr7 = 13,
	abcd_RadioFrequencyBandTDDListr7 = 14,
	notabcd_RadioFrequencyBandTDDListr7 = 15,
};
typedef Enumerated<CONSTRAINED, 15> RadioFrequencyBandTDDListr7;

enum RadioFrequencyBandTDDextValues {
	e_RadioFrequencyBandTDDext = 0,
	f_RadioFrequencyBandTDDext = 1,
	g_RadioFrequencyBandTDDext = 2,
	h_RadioFrequencyBandTDDext = 3,
	i_RadioFrequencyBandTDDext = 4,
	j_RadioFrequencyBandTDDext = 5,
	k_RadioFrequencyBandTDDext = 6,
	l_RadioFrequencyBandTDDext = 7,
	m_RadioFrequencyBandTDDext = 8,
	n_RadioFrequencyBandTDDext = 9,
	o_RadioFrequencyBandTDDext = 10,
	p_RadioFrequencyBandTDDext = 11,
	spare4_RadioFrequencyBandTDDext = 12,
	spare3_RadioFrequencyBandTDDext = 13,
	spare2_RadioFrequencyBandTDDext = 14,
	spare1_RadioFrequencyBandTDDext = 15,
};
typedef Enumerated<CONSTRAINED, 15> RadioFrequencyBandTDDext;

typedef SequenceOf<RadioFrequencyBandTDDext, CONSTRAINED, 1, maxFreqBandsTDD_ext> RadioFrequencyBandTDDextList;

typedef Boolean RbtimerindicatorT314expired;

typedef Boolean RbtimerindicatorT315expired;

class Rbtimerindicator : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	Rbtimerindicator(): Sequence(&theInfo) {}

	void setRbtimerindicatorT314expired(const RbtimerindicatorT314expired& rbtimerindicatorT314expired) { *static_cast<RbtimerindicatorT314expired*>(items[0]) = rbtimerindicatorT314expired; }
	void setRbtimerindicatorT315expired(const RbtimerindicatorT315expired& rbtimerindicatorT315expired) { *static_cast<RbtimerindicatorT315expired*>(items[1]) = rbtimerindicatorT315expired; }
};

enum ReEstablishmentTimerValues {
	useT314_ReEstablishmentTimer = 0,
	useT315_ReEstablishmentTimer = 1,
};
typedef Enumerated<CONSTRAINED, 1> ReEstablishmentTimer;

enum InterRATInfoValues {
	gsm_InterRATInfo = 0,
};
typedef Enumerated<CONSTRAINED, 0> InterRATInfo;

class RedirectionInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum RedirectionInfoChoices {
		frequencyInfo = 0,
		interRATInfo = 1,
	};
	static const Info theInfo;
	RedirectionInfo(): Choice(&theInfo) {}
};

enum FrequencyBandValues {
	dcs1800BandUsed_FrequencyBand = 0,
	pcs1900BandUsed_FrequencyBand = 1,
};
typedef Enumerated<CONSTRAINED, 1> FrequencyBand;

typedef Integer<CONSTRAINED, 0, 7> NCC;

typedef Integer<CONSTRAINED, 0, 7> BCC;

class BSIC : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	BSIC(): Sequence(&theInfo) {}

	void setNcc(const NCC& ncc) { *static_cast<NCC*>(items[0]) = ncc; }
	void setBcc(const BCC& bcc) { *static_cast<BCC*>(items[1]) = bcc; }
};

class GSMTargetCellInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	GSMTargetCellInfo(): Sequence(&theInfo) {}

	void setBcchARFCN(const BCCHARFCN& bcchARFCN) { *static_cast<BCCHARFCN*>(items[0]) = bcchARFCN; }
	void setFrequencyband(const FrequencyBand& frequencyband) { *static_cast<FrequencyBand*>(items[1]) = frequencyband; }
	void setBsic(const BSIC& bsic) { *static_cast<BSIC*>(items[2]) = bsic; }
};

typedef SequenceOf<GSMTargetCellInfo, CONSTRAINED, 1, maxGSMTargetCells> GSMTargetCellInfoList;

class InterRATInfor6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterRATInfor6(): Sequence(&theInfo) {}

	void setRat(const InterRATInfo& rat) { *static_cast<InterRATInfo*>(items[0]) = rat; }
	void setGsmTargetCellInfoList(const GSMTargetCellInfoList& gsmTargetCellInfoList) { *static_cast<GSMTargetCellInfoList*>(items[1]) = gsmTargetCellInfoList; }
};

class RedirectionInfor6 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum RedirectionInfor6Choices {
		frequencyInfo = 0,
		interRATInfo = 1,
	};
	static const Info theInfo;
	RedirectionInfor6(): Choice(&theInfo) {}
};

typedef Null RedirectionInfov860extFrequencyInfo;

typedef Null InterRATInfov860extGsm;

typedef Integer<CONSTRAINED, 0, 65535> EARFCN;

typedef Integer<CONSTRAINED, 0, 503> EUTRAPhysicalCellIdentity;

class EUTRABlacklistedCell : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	EUTRABlacklistedCell(): Sequence(&theInfo) {}

	void setPhysicalCellIdentity(const EUTRAPhysicalCellIdentity& physicalCellIdentity) { *static_cast<EUTRAPhysicalCellIdentity*>(items[0]) = physicalCellIdentity; }
};

typedef SequenceOf<EUTRABlacklistedCell, CONSTRAINED, 1, maxEUTRACellPerFreq> EUTRABlacklistedCellPerFreqList;

class EUTRATargetFreqInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EUTRATargetFreqInfo(): Sequence(&theInfo) {}

	void setDlEUTRACarrierFreq(const EARFCN& dlEUTRACarrierFreq) { *static_cast<EARFCN*>(items[0]) = dlEUTRACarrierFreq; }
	void setEutraBlacklistedCellPerFreqList(const EUTRABlacklistedCellPerFreqList& eutraBlacklistedCellPerFreqList) { *static_cast<EUTRABlacklistedCellPerFreqList*>(items[1]) = eutraBlacklistedCellPerFreqList; }
};

typedef SequenceOf<EUTRATargetFreqInfo, CONSTRAINED, 1, maxEUTRATargetFreqs> EUTRATargetFreqInfoList;

class InterRATInfov860extEutra : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterRATInfov860extEutra(): Sequence(&theInfo) {}

	void setEutraTargetFreqInfoList(const EUTRATargetFreqInfoList& eutraTargetFreqInfoList) { *static_cast<EUTRATargetFreqInfoList*>(items[0]) = eutraTargetFreqInfoList; }
};

class InterRATInfov860ext : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum InterRATInfov860extChoices {
		interRATInfov860extGsm = 0,
		interRATInfov860extEutra = 1,
	};
	static const Info theInfo;
	InterRATInfov860ext(): Choice(&theInfo) {}
};

class RedirectionInfov860ext : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum RedirectionInfov860extChoices {
		redirectionInfov860extFrequencyInfo = 0,
		interRATInfo = 1,
	};
	static const Info theInfo;
	RedirectionInfov860ext(): Choice(&theInfo) {}
};

enum RejectionCauseValues {
	congestion_RejectionCause = 0,
	unspecified_RejectionCause = 1,
};
typedef Enumerated<CONSTRAINED, 1> RejectionCause;

typedef Integer<CONSTRAINED, 1, 4> UEPowerClass;

enum TxRxFrequencySeparationValues {
	default_TxRx_separation_TxRxFrequencySeparation = 0,
	spare2_TxRxFrequencySeparation = 1,
	spare1_TxRxFrequencySeparation = 2,
};
typedef Enumerated<CONSTRAINED, 2> TxRxFrequencySeparation;

class RFCapabilityFddRFCapability : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RFCapabilityFddRFCapability(): Sequence(&theInfo) {}

	void setUePowerClass(const UEPowerClass& uePowerClass) { *static_cast<UEPowerClass*>(items[0]) = uePowerClass; }
	void setTxRxFrequencySeparation(const TxRxFrequencySeparation& txRxFrequencySeparation) { *static_cast<TxRxFrequencySeparation*>(items[1]) = txRxFrequencySeparation; }
};

class RFCapabilityTddRFCapability : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	RFCapabilityTddRFCapability(): Sequence(&theInfo) {}

	void setUePowerClass(const UEPowerClass& uePowerClass) { *static_cast<UEPowerClass*>(items[0]) = uePowerClass; }
	void setRadioFrequencyTDDBandList(const RadioFrequencyBandTDDList& radioFrequencyTDDBandList) { *static_cast<RadioFrequencyBandTDDList*>(items[1]) = radioFrequencyTDDBandList; }
	void setChipRateCapability(const ChipRateCapability& chipRateCapability) { *static_cast<ChipRateCapability*>(items[2]) = chipRateCapability; }
};

class RFCapability : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RFCapability(): Sequence(&theInfo) {}

	void setRFCapabilityFddRFCapability(const RFCapabilityFddRFCapability& rFCapabilityFddRFCapability) { *static_cast<RFCapabilityFddRFCapability*>(items[0]) = rFCapabilityFddRFCapability; }
	void setRFCapabilityTddRFCapability(const RFCapabilityTddRFCapability& rFCapabilityTddRFCapability) { *static_cast<RFCapabilityTddRFCapability*>(items[1]) = rFCapabilityTddRFCapability; }
};

class RFCapabilityr4extTddRFCapability : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	RFCapabilityr4extTddRFCapability(): Sequence(&theInfo) {}

	void setUePowerClass(const UEPowerClass& uePowerClass) { *static_cast<UEPowerClass*>(items[0]) = uePowerClass; }
	void setRadioFrequencyBandTDDList(const RadioFrequencyBandTDDList& radioFrequencyBandTDDList) { *static_cast<RadioFrequencyBandTDDList*>(items[1]) = radioFrequencyBandTDDList; }
	void setChipRateCapability(const ChipRateCapability& chipRateCapability) { *static_cast<ChipRateCapability*>(items[2]) = chipRateCapability; }
};

class RFCapabilityr4ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	RFCapabilityr4ext(): Sequence(&theInfo) {}

	void setRFCapabilityr4extTddRFCapability(const RFCapabilityr4extTddRFCapability& rFCapabilityr4extTddRFCapability) { *static_cast<RFCapabilityr4extTddRFCapability*>(items[0]) = rFCapabilityr4extTddRFCapability; }
};

class RFCapabilityv770extTdd768RFCapability : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RFCapabilityv770extTdd768RFCapability(): Sequence(&theInfo) {}

	void setUePowerClass(const UEPowerClass& uePowerClass) { *static_cast<UEPowerClass*>(items[0]) = uePowerClass; }
	void setRadioFrequencyBandTDDList(const RadioFrequencyBandTDDListr7& radioFrequencyBandTDDList) { *static_cast<RadioFrequencyBandTDDListr7*>(items[1]) = radioFrequencyBandTDDList; }
};

class RFCapabilityv770ext : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	RFCapabilityv770ext(): Sequence(&theInfo) {}

	void setTdd384RFCapability(const RadioFrequencyBandTDDListr7& tdd384RFCapability) { *static_cast<RadioFrequencyBandTDDListr7*>(items[0]) = tdd384RFCapability; }
	void setRFCapabilityv770extTdd768RFCapability(const RFCapabilityv770extTdd768RFCapability& rFCapabilityv770extTdd768RFCapability) { *static_cast<RFCapabilityv770extTdd768RFCapability*>(items[1]) = rFCapabilityv770extTdd768RFCapability; }
	void setTdd128RFCapability(const RadioFrequencyBandTDDListr7& tdd128RFCapability) { *static_cast<RadioFrequencyBandTDDListr7*>(items[2]) = tdd128RFCapability; }
};

class RFCapabilityv860ext : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	RFCapabilityv860ext(): Sequence(&theInfo) {}

	void setTdd128RFCapability(const RadioFrequencyBandTDDextList& tdd128RFCapability) { *static_cast<RadioFrequencyBandTDDextList*>(items[0]) = tdd128RFCapability; }
	void setTdd384RFCapability(const RadioFrequencyBandTDDextList& tdd384RFCapability) { *static_cast<RadioFrequencyBandTDDextList*>(items[1]) = tdd384RFCapability; }
	void setTdd768RFCapability(const RadioFrequencyBandTDDextList& tdd768RFCapability) { *static_cast<RadioFrequencyBandTDDextList*>(items[2]) = tdd768RFCapability; }
};

enum TotalRLCAMBufferSizeValues {
	dummy_TotalRLCAMBufferSize = 0,
	kb10_TotalRLCAMBufferSize = 1,
	kb50_TotalRLCAMBufferSize = 2,
	kb100_TotalRLCAMBufferSize = 3,
	kb150_TotalRLCAMBufferSize = 4,
	kb500_TotalRLCAMBufferSize = 5,
	kb1000_TotalRLCAMBufferSize = 6,
	spare_TotalRLCAMBufferSize = 7,
};
typedef Enumerated<CONSTRAINED, 7> TotalRLCAMBufferSize;

class RLCCapability : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	RLCCapability(): Sequence(&theInfo) {}

	void setTotalRLCAMBufferSize(const TotalRLCAMBufferSize& totalRLCAMBufferSize) { *static_cast<TotalRLCAMBufferSize*>(items[0]) = totalRLCAMBufferSize; }
	void setMaximumRLCWindowSize(const MaximumRLCWindowSize& maximumRLCWindowSize) { *static_cast<MaximumRLCWindowSize*>(items[1]) = maximumRLCWindowSize; }
	void setMaximumAMEntityNumber(const MaximumAMEntityNumberRLCCap& maximumAMEntityNumber) { *static_cast<MaximumAMEntityNumberRLCCap*>(items[2]) = maximumAMEntityNumber; }
};

enum TotalRLCAMBufferSizer5extValues {
	kb200_TotalRLCAMBufferSizer5ext = 0,
	kb300_TotalRLCAMBufferSizer5ext = 1,
	kb400_TotalRLCAMBufferSizer5ext = 2,
	kb750_TotalRLCAMBufferSizer5ext = 3,
};
typedef Enumerated<CONSTRAINED, 3> TotalRLCAMBufferSizer5ext;

class RLCCapabilityr5ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	RLCCapabilityr5ext(): Sequence(&theInfo) {}

	void setTotalRLCAMBufferSize(const TotalRLCAMBufferSizer5ext& totalRLCAMBufferSize) { *static_cast<TotalRLCAMBufferSizer5ext*>(items[0]) = totalRLCAMBufferSize; }
};

typedef Boolean RLCCapabilityv770extSupportOfTwoLogicalChannel;

class RLCCapabilityv770ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	RLCCapabilityv770ext(): Sequence(&theInfo) {}

	void setRLCCapabilityv770extSupportOfTwoLogicalChannel(const RLCCapabilityv770extSupportOfTwoLogicalChannel& rLCCapabilityv770extSupportOfTwoLogicalChannel) { *static_cast<RLCCapabilityv770extSupportOfTwoLogicalChannel*>(items[0]) = rLCCapabilityv770extSupportOfTwoLogicalChannel; }
};

enum TotalRLCAMBufferSizev920extValues {
	kb1150_TotalRLCAMBufferSizev920ext = 0,
	kb1250_TotalRLCAMBufferSizev920ext = 1,
};
typedef Enumerated<CONSTRAINED, 1> TotalRLCAMBufferSizev920ext;

class RLCCapabilityv920ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	RLCCapabilityv920ext(): Sequence(&theInfo) {}

	void setTotalRLCAMBufferSize(const TotalRLCAMBufferSizev920ext& totalRLCAMBufferSize) { *static_cast<TotalRLCAMBufferSizev920ext*>(items[0]) = totalRLCAMBufferSize; }
};

enum RRCStateIndicatorValues {
	cell_DCH_RRCStateIndicator = 0,
	cell_FACH_RRCStateIndicator = 1,
	cell_PCH_RRCStateIndicator = 2,
	ura_PCH_RRCStateIndicator = 3,
};
typedef Enumerated<CONSTRAINED, 3> RRCStateIndicator;

typedef BitString<CONSTRAINED, 10, 10> SRNTI2;

typedef BitString<CONSTRAINED, 16, 16> SecurityCapabilityCipheringAlgorithmCap;

typedef BitString<CONSTRAINED, 16, 16> SecurityCapabilityIntegrityProtectionAlgorithmCap;

class SecurityCapability : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SecurityCapability(): Sequence(&theInfo) {}

	void setSecurityCapabilityCipheringAlgorithmCap(const SecurityCapabilityCipheringAlgorithmCap& securityCapabilityCipheringAlgorithmCap) { *static_cast<SecurityCapabilityCipheringAlgorithmCap*>(items[0]) = securityCapabilityCipheringAlgorithmCap; }
	void setSecurityCapabilityIntegrityProtectionAlgorithmCap(const SecurityCapabilityIntegrityProtectionAlgorithmCap& securityCapabilityIntegrityProtectionAlgorithmCap) { *static_cast<SecurityCapabilityIntegrityProtectionAlgorithmCap*>(items[1]) = securityCapabilityIntegrityProtectionAlgorithmCap; }
};

class SecondaryServingEDCHCellInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SecondaryServingEDCHCellInfo(): Sequence(&theInfo) {}

	void setPrimaryERNTI(const ERNTI& primaryERNTI) { *static_cast<ERNTI*>(items[0]) = primaryERNTI; }
	void setSecondaryERNTI(const ERNTI& secondaryERNTI) { *static_cast<ERNTI*>(items[1]) = secondaryERNTI; }
};

enum ScramblingCodeTypeValues {
	shortSC_ScramblingCodeType = 0,
	longSC_ScramblingCodeType = 1,
};
typedef Enumerated<CONSTRAINED, 1> ScramblingCodeType;

typedef Integer<CONSTRAINED, 0, 16777215> ULScramblingCode;

typedef BitString<CONSTRAINED, 8, 8> SecondaryEDCHInfoCommonMs2SchedTransmGrantHARQAlloc;

enum SecondaryEDCHInfoCommonServingGrantprimary_Secondary_GrantSelectorValues {
	primary_SecondaryEDCHInfoCommonServingGrantprimary_Secondary_GrantSelector = 0,
	secondary_SecondaryEDCHInfoCommonServingGrantprimary_Secondary_GrantSelector = 1,
};
typedef Enumerated<CONSTRAINED, 1> SecondaryEDCHInfoCommonServingGrantprimary_Secondary_GrantSelector;

class SecondaryEDCHInfoCommonServingGrant : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SecondaryEDCHInfoCommonServingGrant(): Sequence(&theInfo) {}

	void setSecondaryEDCHInfoCommonServingGrantprimary_Secondary_GrantSelector(const SecondaryEDCHInfoCommonServingGrantprimary_Secondary_GrantSelector& secondaryEDCHInfoCommonServingGrantprimary_Secondary_GrantSelector) { *static_cast<SecondaryEDCHInfoCommonServingGrantprimary_Secondary_GrantSelector*>(items[0]) = secondaryEDCHInfoCommonServingGrantprimary_Secondary_GrantSelector; }
};

enum MinReducedEDPDCHGainFactorValues {
	m8_15_MinReducedEDPDCHGainFactor = 0,
	m11_15_MinReducedEDPDCHGainFactor = 1,
	m15_15_MinReducedEDPDCHGainFactor = 2,
	m21_15_MinReducedEDPDCHGainFactor = 3,
	m30_15_MinReducedEDPDCHGainFactor = 4,
	m42_15_MinReducedEDPDCHGainFactor = 5,
	m60_15_MinReducedEDPDCHGainFactor = 6,
	m84_15_MinReducedEDPDCHGainFactor = 7,
};
typedef Enumerated<CONSTRAINED, 7> MinReducedEDPDCHGainFactor;

typedef Integer<CONSTRAINED, 0, 127> EDCHMinimumSetETFCI;

typedef Integer<CONSTRAINED, 0, 7> SecondaryEDCHInfoCommonDpcchPowerOffsetSecondaryULFrequency;

typedef Integer<CONSTRAINED, 0, 7> PCPreamble;

class SecondaryEDCHInfoCommon : public Sequence {
private:
	static const void *itemsInfo[9];
	static bool itemsPres[9];
public:
	static const Info theInfo;
	SecondaryEDCHInfoCommon(): Sequence(&theInfo) {}

	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[0]) = frequencyInfo; }
	void setScramblingCodeType(const ScramblingCodeType& scramblingCodeType) { *static_cast<ScramblingCodeType*>(items[1]) = scramblingCodeType; }
	void setScramblingCodeNumber(const ULScramblingCode& scramblingCodeNumber) { *static_cast<ULScramblingCode*>(items[2]) = scramblingCodeNumber; }
	void setSecondaryEDCHInfoCommonMs2SchedTransmGrantHARQAlloc(const SecondaryEDCHInfoCommonMs2SchedTransmGrantHARQAlloc& secondaryEDCHInfoCommonMs2SchedTransmGrantHARQAlloc) { *static_cast<SecondaryEDCHInfoCommonMs2SchedTransmGrantHARQAlloc*>(items[3]) = secondaryEDCHInfoCommonMs2SchedTransmGrantHARQAlloc; }
	void setSecondaryEDCHInfoCommonServingGrant(const SecondaryEDCHInfoCommonServingGrant& secondaryEDCHInfoCommonServingGrant) { *static_cast<SecondaryEDCHInfoCommonServingGrant*>(items[4]) = secondaryEDCHInfoCommonServingGrant; }
	void setMinReducedEDPDCHGainFactor(const MinReducedEDPDCHGainFactor& minReducedEDPDCHGainFactor) { *static_cast<MinReducedEDPDCHGainFactor*>(items[5]) = minReducedEDPDCHGainFactor; }
	void setEDCHminimumSetETFCI(const EDCHMinimumSetETFCI& eDCHminimumSetETFCI) { *static_cast<EDCHMinimumSetETFCI*>(items[6]) = eDCHminimumSetETFCI; }
	void setSecondaryEDCHInfoCommonDpcchPowerOffsetSecondaryULFrequency(const SecondaryEDCHInfoCommonDpcchPowerOffsetSecondaryULFrequency& secondaryEDCHInfoCommonDpcchPowerOffsetSecondaryULFrequency) { *static_cast<SecondaryEDCHInfoCommonDpcchPowerOffsetSecondaryULFrequency*>(items[7]) = secondaryEDCHInfoCommonDpcchPowerOffsetSecondaryULFrequency; }
	void setPcPreamble(const PCPreamble& pcPreamble) { *static_cast<PCPreamble*>(items[8]) = pcPreamble; }
};

typedef Integer<CONSTRAINED, 0, 8> DeltaACK;

typedef Integer<CONSTRAINED, 0, 8> DeltaNACK;

typedef Integer<CONSTRAINED, 0, 1> HARQPreambleMode;

typedef Integer<CONSTRAINED, 0, 127> HSSCCHCodes;

typedef SequenceOf<HSSCCHCodes, CONSTRAINED, 1, maxHSSCCHs> HSSCCHInfoModeSpecificInfoFddHSSCCHChannelisationCodeInfo;

class HSSCCHInfoModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	HSSCCHInfoModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setHSSCCHInfoModeSpecificInfoFddHSSCCHChannelisationCodeInfo(const HSSCCHInfoModeSpecificInfoFddHSSCCHChannelisationCodeInfo& hSSCCHInfoModeSpecificInfoFddHSSCCHChannelisationCodeInfo) { *static_cast<HSSCCHInfoModeSpecificInfoFddHSSCCHChannelisationCodeInfo*>(items[0]) = hSSCCHInfoModeSpecificInfoFddHSSCCHChannelisationCodeInfo; }
	void setDlScramblingCode(const SecondaryScramblingCode& dlScramblingCode) { *static_cast<SecondaryScramblingCode*>(items[1]) = dlScramblingCode; }
};

typedef Integer<CONSTRAINED, -7, 8> HSSCCHInfoModeSpecificInfoTddTdd384Nackackpoweroffset;

typedef Integer<CONSTRAINED, -22, 40> HSSICHPowerControlInfoTDD384UltargetSIR;

typedef Integer<CONSTRAINED, -35, -10> ConstantValue;

class HSSICHPowerControlInfoTDD384 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	HSSICHPowerControlInfoTDD384(): Sequence(&theInfo) {}

	void setHSSICHPowerControlInfoTDD384UltargetSIR(const HSSICHPowerControlInfoTDD384UltargetSIR& hSSICHPowerControlInfoTDD384UltargetSIR) { *static_cast<HSSICHPowerControlInfoTDD384UltargetSIR*>(items[0]) = hSSICHPowerControlInfoTDD384UltargetSIR; }
	void setHssichConstantValue(const ConstantValue& hssichConstantValue) { *static_cast<ConstantValue*>(items[1]) = hssichConstantValue; }
};

typedef Integer<CONSTRAINED, 0, 14> TimeslotNumber;

enum DLTSChannelisationCodeValues {
	cc16_1_DLTSChannelisationCode = 0,
	cc16_2_DLTSChannelisationCode = 1,
	cc16_3_DLTSChannelisationCode = 2,
	cc16_4_DLTSChannelisationCode = 3,
	cc16_5_DLTSChannelisationCode = 4,
	cc16_6_DLTSChannelisationCode = 5,
	cc16_7_DLTSChannelisationCode = 6,
	cc16_8_DLTSChannelisationCode = 7,
	cc16_9_DLTSChannelisationCode = 8,
	cc16_10_DLTSChannelisationCode = 9,
	cc16_11_DLTSChannelisationCode = 10,
	cc16_12_DLTSChannelisationCode = 11,
	cc16_13_DLTSChannelisationCode = 12,
	cc16_14_DLTSChannelisationCode = 13,
	cc16_15_DLTSChannelisationCode = 14,
	cc16_16_DLTSChannelisationCode = 15,
};
typedef Enumerated<CONSTRAINED, 15> DLTSChannelisationCode;

typedef Null HSSCCHTDD384MidambleAllocationModeDefaultMidamble;

typedef Null HSSCCHTDD384MidambleAllocationModeCommonMidamble;

typedef Integer<CONSTRAINED, 0, 15> MidambleShiftLong;

class HSSCCHTDD384MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	HSSCCHTDD384MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftLong& midambleShift) { *static_cast<MidambleShiftLong*>(items[0]) = midambleShift; }
};

class HSSCCHTDD384MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum HSSCCHTDD384MidambleAllocationModeChoices {
		hSSCCHTDD384MidambleAllocationModeDefaultMidamble = 0,
		hSSCCHTDD384MidambleAllocationModeCommonMidamble = 1,
		hSSCCHTDD384MidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	HSSCCHTDD384MidambleAllocationMode(): Choice(&theInfo) {}
};

enum MidambleConfigurationBurstType1and3Values {
	ms4_MidambleConfigurationBurstType1and3 = 0,
	ms8_MidambleConfigurationBurstType1and3 = 1,
	ms16_MidambleConfigurationBurstType1and3 = 2,
};
typedef Enumerated<CONSTRAINED, 2> MidambleConfigurationBurstType1and3;

typedef Integer<CONSTRAINED, -63, 0> BlerTarget;

typedef Null HSSICHConfigurationTDD384MidambleAllocationModeDefaultMidamble;

class HSSICHConfigurationTDD384MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	HSSICHConfigurationTDD384MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftLong& midambleShift) { *static_cast<MidambleShiftLong*>(items[0]) = midambleShift; }
};

class HSSICHConfigurationTDD384MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum HSSICHConfigurationTDD384MidambleAllocationModeChoices {
		hSSICHConfigurationTDD384MidambleAllocationModeDefaultMidamble = 0,
		hSSICHConfigurationTDD384MidambleAllocationModeUeSpecificMidamble = 1,
	};
	static const Info theInfo;
	HSSICHConfigurationTDD384MidambleAllocationMode(): Choice(&theInfo) {}
};

class HSSICHConfigurationTDD384 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	HSSICHConfigurationTDD384(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumber& timeslotNumber) { *static_cast<TimeslotNumber*>(items[0]) = timeslotNumber; }
	void setChannelisationCode(const DLTSChannelisationCode& channelisationCode) { *static_cast<DLTSChannelisationCode*>(items[1]) = channelisationCode; }
	void setHSSICHConfigurationTDD384MidambleAllocationMode(const HSSICHConfigurationTDD384MidambleAllocationMode& hSSICHConfigurationTDD384MidambleAllocationMode) { *static_cast<HSSICHConfigurationTDD384MidambleAllocationMode*>(items[2]) = hSSICHConfigurationTDD384MidambleAllocationMode; }
	void setMidambleconfiguration(const MidambleConfigurationBurstType1and3& midambleconfiguration) { *static_cast<MidambleConfigurationBurstType1and3*>(items[3]) = midambleconfiguration; }
};

class HSSCCHTDD384 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	HSSCCHTDD384(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumber& timeslotNumber) { *static_cast<TimeslotNumber*>(items[0]) = timeslotNumber; }
	void setChannelisationCode(const DLTSChannelisationCode& channelisationCode) { *static_cast<DLTSChannelisationCode*>(items[1]) = channelisationCode; }
	void setHSSCCHTDD384MidambleAllocationMode(const HSSCCHTDD384MidambleAllocationMode& hSSCCHTDD384MidambleAllocationMode) { *static_cast<HSSCCHTDD384MidambleAllocationMode*>(items[2]) = hSSCCHTDD384MidambleAllocationMode; }
	void setMidambleconfiguration(const MidambleConfigurationBurstType1and3& midambleconfiguration) { *static_cast<MidambleConfigurationBurstType1and3*>(items[3]) = midambleconfiguration; }
	void setBlertarget(const BlerTarget& blertarget) { *static_cast<BlerTarget*>(items[4]) = blertarget; }
	void setHssichconfiguration(const HSSICHConfigurationTDD384& hssichconfiguration) { *static_cast<HSSICHConfigurationTDD384*>(items[5]) = hssichconfiguration; }
};

typedef SequenceOf<HSSCCHTDD384, CONSTRAINED, 1, maxHSSCCHs> HSSCCHInfoModeSpecificInfoTddTdd384HSSCCHSetConfiguration;

class HSSCCHInfoModeSpecificInfoTddTdd384 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	HSSCCHInfoModeSpecificInfoTddTdd384(): Sequence(&theInfo) {}

	void setHSSCCHInfoModeSpecificInfoTddTdd384Nackackpoweroffset(const HSSCCHInfoModeSpecificInfoTddTdd384Nackackpoweroffset& hSSCCHInfoModeSpecificInfoTddTdd384Nackackpoweroffset) { *static_cast<HSSCCHInfoModeSpecificInfoTddTdd384Nackackpoweroffset*>(items[0]) = hSSCCHInfoModeSpecificInfoTddTdd384Nackackpoweroffset; }
	void setHsSICHPowerControlInfo(const HSSICHPowerControlInfoTDD384& hsSICHPowerControlInfo) { *static_cast<HSSICHPowerControlInfoTDD384*>(items[1]) = hsSICHPowerControlInfo; }
	void setHSSCCHInfoModeSpecificInfoTddTdd384HSSCCHSetConfiguration(const HSSCCHInfoModeSpecificInfoTddTdd384HSSCCHSetConfiguration& hSSCCHInfoModeSpecificInfoTddTdd384HSSCCHSetConfiguration) { *static_cast<HSSCCHInfoModeSpecificInfoTddTdd384HSSCCHSetConfiguration*>(items[2]) = hSSCCHInfoModeSpecificInfoTddTdd384HSSCCHSetConfiguration; }
};

typedef Integer<CONSTRAINED, 0, 6> TimeslotNumberLCRr4;

enum HSChannelisationCodeLCRValues {
	cc16_1_HSChannelisationCodeLCR = 0,
	cc16_2_HSChannelisationCodeLCR = 1,
	cc16_3_HSChannelisationCodeLCR = 2,
	cc16_4_HSChannelisationCodeLCR = 3,
	cc16_5_HSChannelisationCodeLCR = 4,
	cc16_6_HSChannelisationCodeLCR = 5,
	cc16_7_HSChannelisationCodeLCR = 6,
	cc16_8_HSChannelisationCodeLCR = 7,
	cc16_9_HSChannelisationCodeLCR = 8,
	cc16_10_HSChannelisationCodeLCR = 9,
	cc16_11_HSChannelisationCodeLCR = 10,
	cc16_12_HSChannelisationCodeLCR = 11,
	cc16_13_HSChannelisationCodeLCR = 12,
	cc16_14_HSChannelisationCodeLCR = 13,
	cc16_15_HSChannelisationCodeLCR = 14,
	cc16_16_HSChannelisationCodeLCR = 15,
};
typedef Enumerated<CONSTRAINED, 15> HSChannelisationCodeLCR;

typedef Null HSSCCHTDD128MidambleAllocationModeDefaultMidamble;

typedef Null HSSCCHTDD128MidambleAllocationModeCommonMidamble;

typedef Integer<CONSTRAINED, 0, 15> HSSCCHTDD128MidambleAllocationModeUeSpecificMidamble;

class HSSCCHTDD128MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum HSSCCHTDD128MidambleAllocationModeChoices {
		hSSCCHTDD128MidambleAllocationModeDefaultMidamble = 0,
		hSSCCHTDD128MidambleAllocationModeCommonMidamble = 1,
		hSSCCHTDD128MidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	HSSCCHTDD128MidambleAllocationMode(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, 8> HSSCCHTDD128MidambleConfiguration;

typedef Null HSSICHConfigurationTDD128MidambleAllocationModeDefaultMidamble;

class HSSICHConfigurationTDD128MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	HSSICHConfigurationTDD128MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftLong& midambleShift) { *static_cast<MidambleShiftLong*>(items[0]) = midambleShift; }
};

class HSSICHConfigurationTDD128MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum HSSICHConfigurationTDD128MidambleAllocationModeChoices {
		hSSICHConfigurationTDD128MidambleAllocationModeDefaultMidamble = 0,
		hSSICHConfigurationTDD128MidambleAllocationModeUeSpecificMidamble = 1,
	};
	static const Info theInfo;
	HSSICHConfigurationTDD128MidambleAllocationMode(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, 8> HSSICHConfigurationTDD128MidambleConfiguration;

typedef Integer<CONSTRAINED, -7, 8> HSSICHConfigurationTDD128Nackackpoweroffset;

typedef Integer<CONSTRAINED, -120, -58> HSSICHConfigurationTDD128PowerlevelHSSICH;

enum HSSICHConfigurationTDD128tpc_step_sizeValues {
	s1_HSSICHConfigurationTDD128tpc_step_size = 0,
	s2_HSSICHConfigurationTDD128tpc_step_size = 1,
	s3_HSSICHConfigurationTDD128tpc_step_size = 2,
	spare1_HSSICHConfigurationTDD128tpc_step_size = 3,
};
typedef Enumerated<CONSTRAINED, 3> HSSICHConfigurationTDD128tpc_step_size;

class HSSICHConfigurationTDD128 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	HSSICHConfigurationTDD128(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumberLCRr4& timeslotNumber) { *static_cast<TimeslotNumberLCRr4*>(items[0]) = timeslotNumber; }
	void setChannelisationCode(const HSChannelisationCodeLCR& channelisationCode) { *static_cast<HSChannelisationCodeLCR*>(items[1]) = channelisationCode; }
	void setHSSICHConfigurationTDD128MidambleAllocationMode(const HSSICHConfigurationTDD128MidambleAllocationMode& hSSICHConfigurationTDD128MidambleAllocationMode) { *static_cast<HSSICHConfigurationTDD128MidambleAllocationMode*>(items[2]) = hSSICHConfigurationTDD128MidambleAllocationMode; }
	void setHSSICHConfigurationTDD128MidambleConfiguration(const HSSICHConfigurationTDD128MidambleConfiguration& hSSICHConfigurationTDD128MidambleConfiguration) { *static_cast<HSSICHConfigurationTDD128MidambleConfiguration*>(items[3]) = hSSICHConfigurationTDD128MidambleConfiguration; }
	void setHSSICHConfigurationTDD128Nackackpoweroffset(const HSSICHConfigurationTDD128Nackackpoweroffset& hSSICHConfigurationTDD128Nackackpoweroffset) { *static_cast<HSSICHConfigurationTDD128Nackackpoweroffset*>(items[4]) = hSSICHConfigurationTDD128Nackackpoweroffset; }
	void setHSSICHConfigurationTDD128PowerlevelHSSICH(const HSSICHConfigurationTDD128PowerlevelHSSICH& hSSICHConfigurationTDD128PowerlevelHSSICH) { *static_cast<HSSICHConfigurationTDD128PowerlevelHSSICH*>(items[5]) = hSSICHConfigurationTDD128PowerlevelHSSICH; }
	void setHSSICHConfigurationTDD128tpc_step_size(const HSSICHConfigurationTDD128tpc_step_size& hSSICHConfigurationTDD128tpc_step_size) { *static_cast<HSSICHConfigurationTDD128tpc_step_size*>(items[6]) = hSSICHConfigurationTDD128tpc_step_size; }
};

class HSSCCHTDD128 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	HSSCCHTDD128(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumberLCRr4& timeslotNumber) { *static_cast<TimeslotNumberLCRr4*>(items[0]) = timeslotNumber; }
	void setFirstChannelisationCode(const HSChannelisationCodeLCR& firstChannelisationCode) { *static_cast<HSChannelisationCodeLCR*>(items[1]) = firstChannelisationCode; }
	void setSecondChannelisationCode(const HSChannelisationCodeLCR& secondChannelisationCode) { *static_cast<HSChannelisationCodeLCR*>(items[2]) = secondChannelisationCode; }
	void setHSSCCHTDD128MidambleAllocationMode(const HSSCCHTDD128MidambleAllocationMode& hSSCCHTDD128MidambleAllocationMode) { *static_cast<HSSCCHTDD128MidambleAllocationMode*>(items[3]) = hSSCCHTDD128MidambleAllocationMode; }
	void setHSSCCHTDD128MidambleConfiguration(const HSSCCHTDD128MidambleConfiguration& hSSCCHTDD128MidambleConfiguration) { *static_cast<HSSCCHTDD128MidambleConfiguration*>(items[4]) = hSSCCHTDD128MidambleConfiguration; }
	void setBlertarget(const BlerTarget& blertarget) { *static_cast<BlerTarget*>(items[5]) = blertarget; }
	void setHssichconfiguration(const HSSICHConfigurationTDD128& hssichconfiguration) { *static_cast<HSSICHConfigurationTDD128*>(items[6]) = hssichconfiguration; }
};

typedef SequenceOf<HSSCCHTDD128, CONSTRAINED, 1, maxHSSCCHs> HSSCCHInfoModeSpecificInfoTddTdd128;

class HSSCCHInfoModeSpecificInfoTdd : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum HSSCCHInfoModeSpecificInfoTddChoices {
		hSSCCHInfoModeSpecificInfoTddTdd384 = 0,
		hSSCCHInfoModeSpecificInfoTddTdd128 = 1,
	};
	static const Info theInfo;
	HSSCCHInfoModeSpecificInfoTdd(): Choice(&theInfo) {}
};

class HSSCCHInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum HSSCCHInfoModeSpecificInfoChoices {
		hSSCCHInfoModeSpecificInfoFdd = 0,
		hSSCCHInfoModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	HSSCCHInfoModeSpecificInfo(): Choice(&theInfo) {}
};

class HSSCCHInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	HSSCCHInfo(): Sequence(&theInfo) {}

	void setHSSCCHInfoModeSpecificInfo(const HSSCCHInfoModeSpecificInfo& hSSCCHInfoModeSpecificInfo) { *static_cast<HSSCCHInfoModeSpecificInfo*>(items[0]) = hSSCCHInfoModeSpecificInfo; }
};

typedef Integer<CONSTRAINED, -12, 26> MeasurementPowerOffset;

enum FeedbackcycleValues {
	fc0_Feedbackcycle = 0,
	fc2_Feedbackcycle = 1,
	fc4_Feedbackcycle = 2,
	fc8_Feedbackcycle = 3,
	fc10_Feedbackcycle = 4,
	fc20_Feedbackcycle = 5,
	fc40_Feedbackcycle = 6,
	fc80_Feedbackcycle = 7,
	fc160_Feedbackcycle = 8,
};
typedef Enumerated<CONSTRAINED, 8> Feedbackcycle;

typedef Integer<CONSTRAINED, 1, 4> CQIRepetitionFactor;

typedef Integer<CONSTRAINED, 0, 8> DeltaCQI;

class MeasurementFeedbackInfoModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	MeasurementFeedbackInfoModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setMeasurementPowerOffset(const MeasurementPowerOffset& measurementPowerOffset) { *static_cast<MeasurementPowerOffset*>(items[0]) = measurementPowerOffset; }
	void setFeedbackcycle(const Feedbackcycle& feedbackcycle) { *static_cast<Feedbackcycle*>(items[1]) = feedbackcycle; }
	void setCqiRepetitionFactor(const CQIRepetitionFactor& cqiRepetitionFactor) { *static_cast<CQIRepetitionFactor*>(items[2]) = cqiRepetitionFactor; }
	void setDeltaCQI(const DeltaCQI& deltaCQI) { *static_cast<DeltaCQI*>(items[3]) = deltaCQI; }
};

typedef Null MeasurementFeedbackInfoModeSpecificInfoTdd;

class MeasurementFeedbackInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MeasurementFeedbackInfoModeSpecificInfoChoices {
		measurementFeedbackInfoModeSpecificInfoFdd = 0,
		measurementFeedbackInfoModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	MeasurementFeedbackInfoModeSpecificInfo(): Choice(&theInfo) {}
};

class MeasurementFeedbackInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasurementFeedbackInfo(): Sequence(&theInfo) {}

	void setMeasurementFeedbackInfoModeSpecificInfo(const MeasurementFeedbackInfoModeSpecificInfo& measurementFeedbackInfoModeSpecificInfo) { *static_cast<MeasurementFeedbackInfoModeSpecificInfo*>(items[0]) = measurementFeedbackInfoModeSpecificInfo; }
};

class DLHSPDSCHTSConfiguration : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	DLHSPDSCHTSConfiguration(): Sequence(&theInfo) {}

};

class DLHSPDSCHInformationModeSpecificInfoTddTdd384 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLHSPDSCHInformationModeSpecificInfoTddTdd384(): Sequence(&theInfo) {}

	void setDlHSPDSCHTSConfiguration(const DLHSPDSCHTSConfiguration& dlHSPDSCHTSConfiguration) { *static_cast<DLHSPDSCHTSConfiguration*>(items[0]) = dlHSPDSCHTSConfiguration; }
};

typedef Null HSPDSCHMidambleConfigurationTDD128MidambleAllocationModeDefaultMidamble;

typedef Null HSPDSCHMidambleConfigurationTDD128MidambleAllocationModeCommonMidamble;

typedef Integer<CONSTRAINED, 0, 15> HSPDSCHMidambleConfigurationTDD128MidambleAllocationModeUeSpecificMidamble;

class HSPDSCHMidambleConfigurationTDD128MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum HSPDSCHMidambleConfigurationTDD128MidambleAllocationModeChoices {
		hSPDSCHMidambleConfigurationTDD128MidambleAllocationModeDefaultMidamble = 0,
		hSPDSCHMidambleConfigurationTDD128MidambleAllocationModeCommonMidamble = 1,
		hSPDSCHMidambleConfigurationTDD128MidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	HSPDSCHMidambleConfigurationTDD128MidambleAllocationMode(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, 8> HSPDSCHMidambleConfigurationTDD128MidambleConfiguration;

class HSPDSCHMidambleConfigurationTDD128 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	HSPDSCHMidambleConfigurationTDD128(): Sequence(&theInfo) {}

	void setHSPDSCHMidambleConfigurationTDD128MidambleAllocationMode(const HSPDSCHMidambleConfigurationTDD128MidambleAllocationMode& hSPDSCHMidambleConfigurationTDD128MidambleAllocationMode) { *static_cast<HSPDSCHMidambleConfigurationTDD128MidambleAllocationMode*>(items[0]) = hSPDSCHMidambleConfigurationTDD128MidambleAllocationMode; }
	void setHSPDSCHMidambleConfigurationTDD128MidambleConfiguration(const HSPDSCHMidambleConfigurationTDD128MidambleConfiguration& hSPDSCHMidambleConfigurationTDD128MidambleConfiguration) { *static_cast<HSPDSCHMidambleConfigurationTDD128MidambleConfiguration*>(items[1]) = hSPDSCHMidambleConfigurationTDD128MidambleConfiguration; }
};

class DLHSPDSCHInformationModeSpecificInfoTddTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLHSPDSCHInformationModeSpecificInfoTddTdd128(): Sequence(&theInfo) {}

	void setHsPDSCHMidambleConfigurationtdd128(const HSPDSCHMidambleConfigurationTDD128& hsPDSCHMidambleConfigurationtdd128) { *static_cast<HSPDSCHMidambleConfigurationTDD128*>(items[0]) = hsPDSCHMidambleConfigurationtdd128; }
};

class DLHSPDSCHInformationModeSpecificInfoTdd : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLHSPDSCHInformationModeSpecificInfoTddChoices {
		dLHSPDSCHInformationModeSpecificInfoTddTdd384 = 0,
		dLHSPDSCHInformationModeSpecificInfoTddTdd128 = 1,
	};
	static const Info theInfo;
	DLHSPDSCHInformationModeSpecificInfoTdd(): Choice(&theInfo) {}
};

typedef Null DLHSPDSCHInformationModeSpecificInfoFdd;

class DLHSPDSCHInformationModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLHSPDSCHInformationModeSpecificInfoChoices {
		dLHSPDSCHInformationModeSpecificInfoTdd = 0,
		dLHSPDSCHInformationModeSpecificInfoFdd = 1,
	};
	static const Info theInfo;
	DLHSPDSCHInformationModeSpecificInfo(): Choice(&theInfo) {}
};

class DLHSPDSCHInformation : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLHSPDSCHInformation(): Sequence(&theInfo) {}

	void setHsscchInfo(const HSSCCHInfo& hsscchInfo) { *static_cast<HSSCCHInfo*>(items[0]) = hsscchInfo; }
	void setMeasurementfeedbackInfo(const MeasurementFeedbackInfo& measurementfeedbackInfo) { *static_cast<MeasurementFeedbackInfo*>(items[1]) = measurementfeedbackInfo; }
	void setDLHSPDSCHInformationModeSpecificInfo(const DLHSPDSCHInformationModeSpecificInfo& dLHSPDSCHInformationModeSpecificInfo) { *static_cast<DLHSPDSCHInformationModeSpecificInfo*>(items[2]) = dLHSPDSCHInformationModeSpecificInfo; }
};

typedef Integer<CONSTRAINED, 1, 8> HARQInfoNumberOfProcesses;

typedef Null HARQInfoMemoryPartitioningImplicit;

enum HARQMemorySizeValues {
	hms800_HARQMemorySize = 0,
	hms1600_HARQMemorySize = 1,
	hms2400_HARQMemorySize = 2,
	hms3200_HARQMemorySize = 3,
	hms4000_HARQMemorySize = 4,
	hms4800_HARQMemorySize = 5,
	hms5600_HARQMemorySize = 6,
	hms6400_HARQMemorySize = 7,
	hms7200_HARQMemorySize = 8,
	hms8000_HARQMemorySize = 9,
	hms8800_HARQMemorySize = 10,
	hms9600_HARQMemorySize = 11,
	hms10400_HARQMemorySize = 12,
	hms11200_HARQMemorySize = 13,
	hms12000_HARQMemorySize = 14,
	hms12800_HARQMemorySize = 15,
	hms13600_HARQMemorySize = 16,
	hms14400_HARQMemorySize = 17,
	hms15200_HARQMemorySize = 18,
	hms16000_HARQMemorySize = 19,
	hms17600_HARQMemorySize = 20,
	hms19200_HARQMemorySize = 21,
	hms20800_HARQMemorySize = 22,
	hms22400_HARQMemorySize = 23,
	hms24000_HARQMemorySize = 24,
	hms25600_HARQMemorySize = 25,
	hms27200_HARQMemorySize = 26,
	hms28800_HARQMemorySize = 27,
	hms30400_HARQMemorySize = 28,
	hms32000_HARQMemorySize = 29,
	hms36000_HARQMemorySize = 30,
	hms40000_HARQMemorySize = 31,
	hms44000_HARQMemorySize = 32,
	hms48000_HARQMemorySize = 33,
	hms52000_HARQMemorySize = 34,
	hms56000_HARQMemorySize = 35,
	hms60000_HARQMemorySize = 36,
	hms64000_HARQMemorySize = 37,
	hms68000_HARQMemorySize = 38,
	hms72000_HARQMemorySize = 39,
	hms76000_HARQMemorySize = 40,
	hms80000_HARQMemorySize = 41,
	hms88000_HARQMemorySize = 42,
	hms96000_HARQMemorySize = 43,
	hms104000_HARQMemorySize = 44,
	hms112000_HARQMemorySize = 45,
	hms120000_HARQMemorySize = 46,
	hms128000_HARQMemorySize = 47,
	hms136000_HARQMemorySize = 48,
	hms144000_HARQMemorySize = 49,
	hms152000_HARQMemorySize = 50,
	hms160000_HARQMemorySize = 51,
	hms176000_HARQMemorySize = 52,
	hms192000_HARQMemorySize = 53,
	hms208000_HARQMemorySize = 54,
	hms224000_HARQMemorySize = 55,
	hms240000_HARQMemorySize = 56,
	hms256000_HARQMemorySize = 57,
	hms272000_HARQMemorySize = 58,
	hms288000_HARQMemorySize = 59,
	hms304000_HARQMemorySize = 60,
};
typedef Enumerated<CONSTRAINED, 60> HARQMemorySize;

typedef SequenceOf<HARQMemorySize, CONSTRAINED, 1, maxHProcesses> HARQInfoMemoryPartitioningExplicit;

class HARQInfoMemoryPartitioning : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum HARQInfoMemoryPartitioningChoices {
		hARQInfoMemoryPartitioningImplicit = 0,
		hARQInfoMemoryPartitioningExplicit = 1,
	};
	static const Info theInfo;
	HARQInfoMemoryPartitioning(): Choice(&theInfo) {}
};

class HARQInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	HARQInfo(): Sequence(&theInfo) {}

	void setHARQInfoNumberOfProcesses(const HARQInfoNumberOfProcesses& hARQInfoNumberOfProcesses) { *static_cast<HARQInfoNumberOfProcesses*>(items[0]) = hARQInfoNumberOfProcesses; }
	void setHARQInfoMemoryPartitioning(const HARQInfoMemoryPartitioning& hARQInfoMemoryPartitioning) { *static_cast<HARQInfoMemoryPartitioning*>(items[1]) = hARQInfoMemoryPartitioning; }
};

enum ServingHSDSCHCellInformationmac_hsResetIndicatorValues {
	true_ServingHSDSCHCellInformationmac_hsResetIndicator = 0,
};
typedef Enumerated<CONSTRAINED, 0> ServingHSDSCHCellInformationmac_hsResetIndicator;

class ServingHSDSCHCellInformation : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	ServingHSDSCHCellInformation(): Sequence(&theInfo) {}

	void setDeltaACK(const DeltaACK& deltaACK) { *static_cast<DeltaACK*>(items[0]) = deltaACK; }
	void setDeltaNACK(const DeltaNACK& deltaNACK) { *static_cast<DeltaNACK*>(items[1]) = deltaNACK; }
	void setHarqPreambleMode(const HARQPreambleMode& harqPreambleMode) { *static_cast<HARQPreambleMode*>(items[2]) = harqPreambleMode; }
	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[3]) = primaryCPICHInfo; }
	void setDlhspdschInformation(const DLHSPDSCHInformation& dlhspdschInformation) { *static_cast<DLHSPDSCHInformation*>(items[4]) = dlhspdschInformation; }
	void setHarqInfo(const HARQInfo& harqInfo) { *static_cast<HARQInfo*>(items[5]) = harqInfo; }
	void setServingHSDSCHCellInformationmac_hsResetIndicator(const ServingHSDSCHCellInformationmac_hsResetIndicator& servingHSDSCHCellInformationmac_hsResetIndicator) { *static_cast<ServingHSDSCHCellInformationmac_hsResetIndicator*>(items[6]) = servingHSDSCHCellInformationmac_hsResetIndicator; }
};

typedef SequenceOf<HSSCCHCodes, CONSTRAINED, 1, maxHSSCCHs> HSSCCHInfor7ModeSpecificInfoFddHSSCCHChannelisationCodeInfo;

class HSSCCHInfor7ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	HSSCCHInfor7ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setHSSCCHInfor7ModeSpecificInfoFddHSSCCHChannelisationCodeInfo(const HSSCCHInfor7ModeSpecificInfoFddHSSCCHChannelisationCodeInfo& hSSCCHInfor7ModeSpecificInfoFddHSSCCHChannelisationCodeInfo) { *static_cast<HSSCCHInfor7ModeSpecificInfoFddHSSCCHChannelisationCodeInfo*>(items[0]) = hSSCCHInfor7ModeSpecificInfoFddHSSCCHChannelisationCodeInfo; }
	void setDlScramblingCode(const SecondaryScramblingCode& dlScramblingCode) { *static_cast<SecondaryScramblingCode*>(items[1]) = dlScramblingCode; }
};

typedef Integer<CONSTRAINED, -7, 8> HSSCCHInfor7ModeSpecificInfoTddTdd384Nackackpoweroffset;

typedef Integer<CONSTRAINED, -20, 10> DHSSync;

typedef Null HSSCCHTDD384r6MidambleAllocationModeDefaultMidamble;

typedef Null HSSCCHTDD384r6MidambleAllocationModeCommonMidamble;

class HSSCCHTDD384r6MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	HSSCCHTDD384r6MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftLong& midambleShift) { *static_cast<MidambleShiftLong*>(items[0]) = midambleShift; }
};

class HSSCCHTDD384r6MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum HSSCCHTDD384r6MidambleAllocationModeChoices {
		hSSCCHTDD384r6MidambleAllocationModeDefaultMidamble = 0,
		hSSCCHTDD384r6MidambleAllocationModeCommonMidamble = 1,
		hSSCCHTDD384r6MidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	HSSCCHTDD384r6MidambleAllocationMode(): Choice(&theInfo) {}
};

class HSSCCHTDD384r6 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	HSSCCHTDD384r6(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumber& timeslotNumber) { *static_cast<TimeslotNumber*>(items[0]) = timeslotNumber; }
	void setChannelisationCode(const DLTSChannelisationCode& channelisationCode) { *static_cast<DLTSChannelisationCode*>(items[1]) = channelisationCode; }
	void setHSSCCHTDD384r6MidambleAllocationMode(const HSSCCHTDD384r6MidambleAllocationMode& hSSCCHTDD384r6MidambleAllocationMode) { *static_cast<HSSCCHTDD384r6MidambleAllocationMode*>(items[2]) = hSSCCHTDD384r6MidambleAllocationMode; }
	void setMidambleconfiguration(const MidambleConfigurationBurstType1and3& midambleconfiguration) { *static_cast<MidambleConfigurationBurstType1and3*>(items[3]) = midambleconfiguration; }
	void setHssichconfiguration(const HSSICHConfigurationTDD384& hssichconfiguration) { *static_cast<HSSICHConfigurationTDD384*>(items[4]) = hssichconfiguration; }
};

typedef SequenceOf<HSSCCHTDD384r6, CONSTRAINED, 1, maxHSSCCHs> HSSCCHInfor7ModeSpecificInfoTddTdd384HSSCCHSetConfiguration;

class HSSCCHInfor7ModeSpecificInfoTddTdd384 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	HSSCCHInfor7ModeSpecificInfoTddTdd384(): Sequence(&theInfo) {}

	void setHSSCCHInfor7ModeSpecificInfoTddTdd384Nackackpoweroffset(const HSSCCHInfor7ModeSpecificInfoTddTdd384Nackackpoweroffset& hSSCCHInfor7ModeSpecificInfoTddTdd384Nackackpoweroffset) { *static_cast<HSSCCHInfor7ModeSpecificInfoTddTdd384Nackackpoweroffset*>(items[0]) = hSSCCHInfor7ModeSpecificInfoTddTdd384Nackackpoweroffset; }
	void setHsSICHPowerControlInfo(const HSSICHPowerControlInfoTDD384& hsSICHPowerControlInfo) { *static_cast<HSSICHPowerControlInfoTDD384*>(items[1]) = hsSICHPowerControlInfo; }
	void setDhssync(const DHSSync& dhssync) { *static_cast<DHSSync*>(items[2]) = dhssync; }
	void setBlertarget(const BlerTarget& blertarget) { *static_cast<BlerTarget*>(items[3]) = blertarget; }
	void setHSSCCHInfor7ModeSpecificInfoTddTdd384HSSCCHSetConfiguration(const HSSCCHInfor7ModeSpecificInfoTddTdd384HSSCCHSetConfiguration& hSSCCHInfor7ModeSpecificInfoTddTdd384HSSCCHSetConfiguration) { *static_cast<HSSCCHInfor7ModeSpecificInfoTddTdd384HSSCCHSetConfiguration*>(items[4]) = hSSCCHInfor7ModeSpecificInfoTddTdd384HSSCCHSetConfiguration; }
};

typedef Integer<CONSTRAINED, -7, 8> HSSCCHInfor7ModeSpecificInfoTddTdd768Nackackpoweroffset;

typedef Integer<CONSTRAINED, -22, 40> HSSICHPowerControlInfoTDD768UltargetSIR;

class HSSICHPowerControlInfoTDD768 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	HSSICHPowerControlInfoTDD768(): Sequence(&theInfo) {}

	void setHSSICHPowerControlInfoTDD768UltargetSIR(const HSSICHPowerControlInfoTDD768UltargetSIR& hSSICHPowerControlInfoTDD768UltargetSIR) { *static_cast<HSSICHPowerControlInfoTDD768UltargetSIR*>(items[0]) = hSSICHPowerControlInfoTDD768UltargetSIR; }
	void setHssichConstantValue(const ConstantValue& hssichConstantValue) { *static_cast<ConstantValue*>(items[1]) = hssichConstantValue; }
};

enum DLTSChannelisationCodeVHCRValues {
	cc32_1_DLTSChannelisationCodeVHCR = 0,
	cc32_2_DLTSChannelisationCodeVHCR = 1,
	cc32_3_DLTSChannelisationCodeVHCR = 2,
	cc32_4_DLTSChannelisationCodeVHCR = 3,
	cc132_5_DLTSChannelisationCodeVHCR = 4,
	cc32_6_DLTSChannelisationCodeVHCR = 5,
	cc32_7_DLTSChannelisationCodeVHCR = 6,
	cc32_8_DLTSChannelisationCodeVHCR = 7,
	cc32_9_DLTSChannelisationCodeVHCR = 8,
	cc32_10_DLTSChannelisationCodeVHCR = 9,
	cc32_11_DLTSChannelisationCodeVHCR = 10,
	cc32_12_DLTSChannelisationCodeVHCR = 11,
	cc32_13_DLTSChannelisationCodeVHCR = 12,
	cc32_14_DLTSChannelisationCodeVHCR = 13,
	cc32_15_DLTSChannelisationCodeVHCR = 14,
	cc32_16_DLTSChannelisationCodeVHCR = 15,
	cc32_17_DLTSChannelisationCodeVHCR = 16,
	cc32_18_DLTSChannelisationCodeVHCR = 17,
	cc32_19_DLTSChannelisationCodeVHCR = 18,
	cc32_20_DLTSChannelisationCodeVHCR = 19,
	cc32_21_DLTSChannelisationCodeVHCR = 20,
	cc32_22_DLTSChannelisationCodeVHCR = 21,
	cc32_23_DLTSChannelisationCodeVHCR = 22,
	cc32_24_DLTSChannelisationCodeVHCR = 23,
	cc32_25_DLTSChannelisationCodeVHCR = 24,
	cc32_26_DLTSChannelisationCodeVHCR = 25,
	cc32_27_DLTSChannelisationCodeVHCR = 26,
	cc32_28_DLTSChannelisationCodeVHCR = 27,
	cc32_29_DLTSChannelisationCodeVHCR = 28,
	cc32_30_DLTSChannelisationCodeVHCR = 29,
	cc32_31_DLTSChannelisationCodeVHCR = 30,
	cc32_32_DLTSChannelisationCodeVHCR = 31,
};
typedef Enumerated<CONSTRAINED, 31> DLTSChannelisationCodeVHCR;

typedef Null HSSCCHTDD768MidambleAllocationModeDefaultMidamble;

typedef Null HSSCCHTDD768MidambleAllocationModeCommonMidamble;

class HSSCCHTDD768MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	HSSCCHTDD768MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftLong& midambleShift) { *static_cast<MidambleShiftLong*>(items[0]) = midambleShift; }
};

class HSSCCHTDD768MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum HSSCCHTDD768MidambleAllocationModeChoices {
		hSSCCHTDD768MidambleAllocationModeDefaultMidamble = 0,
		hSSCCHTDD768MidambleAllocationModeCommonMidamble = 1,
		hSSCCHTDD768MidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	HSSCCHTDD768MidambleAllocationMode(): Choice(&theInfo) {}
};

typedef Null HSSICHConfigurationTDD768MidambleAllocationModeDefaultMidamble;

class HSSICHConfigurationTDD768MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	HSSICHConfigurationTDD768MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftLong& midambleShift) { *static_cast<MidambleShiftLong*>(items[0]) = midambleShift; }
};

class HSSICHConfigurationTDD768MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum HSSICHConfigurationTDD768MidambleAllocationModeChoices {
		hSSICHConfigurationTDD768MidambleAllocationModeDefaultMidamble = 0,
		hSSICHConfigurationTDD768MidambleAllocationModeUeSpecificMidamble = 1,
	};
	static const Info theInfo;
	HSSICHConfigurationTDD768MidambleAllocationMode(): Choice(&theInfo) {}
};

class HSSICHConfigurationTDD768 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	HSSICHConfigurationTDD768(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumber& timeslotNumber) { *static_cast<TimeslotNumber*>(items[0]) = timeslotNumber; }
	void setChannelisationCode(const DLTSChannelisationCodeVHCR& channelisationCode) { *static_cast<DLTSChannelisationCodeVHCR*>(items[1]) = channelisationCode; }
	void setHSSICHConfigurationTDD768MidambleAllocationMode(const HSSICHConfigurationTDD768MidambleAllocationMode& hSSICHConfigurationTDD768MidambleAllocationMode) { *static_cast<HSSICHConfigurationTDD768MidambleAllocationMode*>(items[2]) = hSSICHConfigurationTDD768MidambleAllocationMode; }
	void setMidambleconfiguration(const MidambleConfigurationBurstType1and3& midambleconfiguration) { *static_cast<MidambleConfigurationBurstType1and3*>(items[3]) = midambleconfiguration; }
};

class HSSCCHTDD768 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	HSSCCHTDD768(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumber& timeslotNumber) { *static_cast<TimeslotNumber*>(items[0]) = timeslotNumber; }
	void setChannelisationCode(const DLTSChannelisationCodeVHCR& channelisationCode) { *static_cast<DLTSChannelisationCodeVHCR*>(items[1]) = channelisationCode; }
	void setHSSCCHTDD768MidambleAllocationMode(const HSSCCHTDD768MidambleAllocationMode& hSSCCHTDD768MidambleAllocationMode) { *static_cast<HSSCCHTDD768MidambleAllocationMode*>(items[2]) = hSSCCHTDD768MidambleAllocationMode; }
	void setMidambleconfiguration(const MidambleConfigurationBurstType1and3& midambleconfiguration) { *static_cast<MidambleConfigurationBurstType1and3*>(items[3]) = midambleconfiguration; }
	void setHssichconfiguration(const HSSICHConfigurationTDD768& hssichconfiguration) { *static_cast<HSSICHConfigurationTDD768*>(items[4]) = hssichconfiguration; }
};

typedef SequenceOf<HSSCCHTDD768, CONSTRAINED, 1, maxHSSCCHs> HSSCCHInfor7ModeSpecificInfoTddTdd768HSSCCHSetConfiguration;

class HSSCCHInfor7ModeSpecificInfoTddTdd768 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	HSSCCHInfor7ModeSpecificInfoTddTdd768(): Sequence(&theInfo) {}

	void setHSSCCHInfor7ModeSpecificInfoTddTdd768Nackackpoweroffset(const HSSCCHInfor7ModeSpecificInfoTddTdd768Nackackpoweroffset& hSSCCHInfor7ModeSpecificInfoTddTdd768Nackackpoweroffset) { *static_cast<HSSCCHInfor7ModeSpecificInfoTddTdd768Nackackpoweroffset*>(items[0]) = hSSCCHInfor7ModeSpecificInfoTddTdd768Nackackpoweroffset; }
	void setHsSICHPowerControlInfo(const HSSICHPowerControlInfoTDD768& hsSICHPowerControlInfo) { *static_cast<HSSICHPowerControlInfoTDD768*>(items[1]) = hsSICHPowerControlInfo; }
	void setDhssync(const DHSSync& dhssync) { *static_cast<DHSSync*>(items[2]) = dhssync; }
	void setBlertarget(const BlerTarget& blertarget) { *static_cast<BlerTarget*>(items[3]) = blertarget; }
	void setHSSCCHInfor7ModeSpecificInfoTddTdd768HSSCCHSetConfiguration(const HSSCCHInfor7ModeSpecificInfoTddTdd768HSSCCHSetConfiguration& hSSCCHInfor7ModeSpecificInfoTddTdd768HSSCCHSetConfiguration) { *static_cast<HSSCCHInfor7ModeSpecificInfoTddTdd768HSSCCHSetConfiguration*>(items[4]) = hSSCCHInfor7ModeSpecificInfoTddTdd768HSSCCHSetConfiguration; }
};

typedef Integer<CONSTRAINED, -7, 8> HSSCCHInfor7ModeSpecificInfoTddTdd128Nackackpoweroffset;

typedef Integer<CONSTRAINED, -120, -58> HSSCCHInfor7ModeSpecificInfoTddTdd128PowerlevelHSSICH;

enum HSSCCHInfor7ModeSpecificInfoTddTdd128tpc_step_sizeValues {
	s1_HSSCCHInfor7ModeSpecificInfoTddTdd128tpc_step_size = 0,
	s2_HSSCCHInfor7ModeSpecificInfoTddTdd128tpc_step_size = 1,
	s3_HSSCCHInfor7ModeSpecificInfoTddTdd128tpc_step_size = 2,
	spare1_HSSCCHInfor7ModeSpecificInfoTddTdd128tpc_step_size = 3,
};
typedef Enumerated<CONSTRAINED, 3> HSSCCHInfor7ModeSpecificInfoTddTdd128tpc_step_size;

typedef Integer<CONSTRAINED, 0, 255> PowerControlGAP;

typedef Boolean HSSCCHInfor7ModeSpecificInfoTddTdd128PathlossCompensationSwitch;

typedef Null HSSCCHTDD128r6MidambleAllocationModeDefaultMidamble;

typedef Null HSSCCHTDD128r6MidambleAllocationModeCommonMidamble;

typedef Integer<CONSTRAINED, 0, 15> HSSCCHTDD128r6MidambleAllocationModeUeSpecificMidamble;

class HSSCCHTDD128r6MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum HSSCCHTDD128r6MidambleAllocationModeChoices {
		hSSCCHTDD128r6MidambleAllocationModeDefaultMidamble = 0,
		hSSCCHTDD128r6MidambleAllocationModeCommonMidamble = 1,
		hSSCCHTDD128r6MidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	HSSCCHTDD128r6MidambleAllocationMode(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, 8> HSSCCHTDD128r6MidambleConfiguration;

typedef Null HSSICHConfigurationTDD128r6MidambleAllocationModeDefaultMidamble;

class HSSICHConfigurationTDD128r6MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	HSSICHConfigurationTDD128r6MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftLong& midambleShift) { *static_cast<MidambleShiftLong*>(items[0]) = midambleShift; }
};

class HSSICHConfigurationTDD128r6MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum HSSICHConfigurationTDD128r6MidambleAllocationModeChoices {
		hSSICHConfigurationTDD128r6MidambleAllocationModeDefaultMidamble = 0,
		hSSICHConfigurationTDD128r6MidambleAllocationModeUeSpecificMidamble = 1,
	};
	static const Info theInfo;
	HSSICHConfigurationTDD128r6MidambleAllocationMode(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, 8> HSSICHConfigurationTDD128r6MidambleConfiguration;

class HSSICHConfigurationTDD128r6 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	HSSICHConfigurationTDD128r6(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumberLCRr4& timeslotNumber) { *static_cast<TimeslotNumberLCRr4*>(items[0]) = timeslotNumber; }
	void setChannelisationCode(const HSChannelisationCodeLCR& channelisationCode) { *static_cast<HSChannelisationCodeLCR*>(items[1]) = channelisationCode; }
	void setHSSICHConfigurationTDD128r6MidambleAllocationMode(const HSSICHConfigurationTDD128r6MidambleAllocationMode& hSSICHConfigurationTDD128r6MidambleAllocationMode) { *static_cast<HSSICHConfigurationTDD128r6MidambleAllocationMode*>(items[2]) = hSSICHConfigurationTDD128r6MidambleAllocationMode; }
	void setHSSICHConfigurationTDD128r6MidambleConfiguration(const HSSICHConfigurationTDD128r6MidambleConfiguration& hSSICHConfigurationTDD128r6MidambleConfiguration) { *static_cast<HSSICHConfigurationTDD128r6MidambleConfiguration*>(items[3]) = hSSICHConfigurationTDD128r6MidambleConfiguration; }
};

class HSSCCHTDD128r6 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	HSSCCHTDD128r6(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumberLCRr4& timeslotNumber) { *static_cast<TimeslotNumberLCRr4*>(items[0]) = timeslotNumber; }
	void setFirstChannelisationCode(const HSChannelisationCodeLCR& firstChannelisationCode) { *static_cast<HSChannelisationCodeLCR*>(items[1]) = firstChannelisationCode; }
	void setSecondChannelisationCode(const HSChannelisationCodeLCR& secondChannelisationCode) { *static_cast<HSChannelisationCodeLCR*>(items[2]) = secondChannelisationCode; }
	void setHSSCCHTDD128r6MidambleAllocationMode(const HSSCCHTDD128r6MidambleAllocationMode& hSSCCHTDD128r6MidambleAllocationMode) { *static_cast<HSSCCHTDD128r6MidambleAllocationMode*>(items[3]) = hSSCCHTDD128r6MidambleAllocationMode; }
	void setHSSCCHTDD128r6MidambleConfiguration(const HSSCCHTDD128r6MidambleConfiguration& hSSCCHTDD128r6MidambleConfiguration) { *static_cast<HSSCCHTDD128r6MidambleConfiguration*>(items[4]) = hSSCCHTDD128r6MidambleConfiguration; }
	void setHssichconfiguration(const HSSICHConfigurationTDD128r6& hssichconfiguration) { *static_cast<HSSICHConfigurationTDD128r6*>(items[5]) = hssichconfiguration; }
};

typedef SequenceOf<HSSCCHTDD128r6, CONSTRAINED, 1, maxHSSCCHs> HSSCCHInfor7ModeSpecificInfoTddTdd128HSSCCHSetConfiguration;

class HSSCCHInfor7ModeSpecificInfoTddTdd128 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	HSSCCHInfor7ModeSpecificInfoTddTdd128(): Sequence(&theInfo) {}

	void setHSSCCHInfor7ModeSpecificInfoTddTdd128Nackackpoweroffset(const HSSCCHInfor7ModeSpecificInfoTddTdd128Nackackpoweroffset& hSSCCHInfor7ModeSpecificInfoTddTdd128Nackackpoweroffset) { *static_cast<HSSCCHInfor7ModeSpecificInfoTddTdd128Nackackpoweroffset*>(items[0]) = hSSCCHInfor7ModeSpecificInfoTddTdd128Nackackpoweroffset; }
	void setHSSCCHInfor7ModeSpecificInfoTddTdd128PowerlevelHSSICH(const HSSCCHInfor7ModeSpecificInfoTddTdd128PowerlevelHSSICH& hSSCCHInfor7ModeSpecificInfoTddTdd128PowerlevelHSSICH) { *static_cast<HSSCCHInfor7ModeSpecificInfoTddTdd128PowerlevelHSSICH*>(items[1]) = hSSCCHInfor7ModeSpecificInfoTddTdd128PowerlevelHSSICH; }
	void setHSSCCHInfor7ModeSpecificInfoTddTdd128tpc_step_size(const HSSCCHInfor7ModeSpecificInfoTddTdd128tpc_step_size& hSSCCHInfor7ModeSpecificInfoTddTdd128tpc_step_size) { *static_cast<HSSCCHInfor7ModeSpecificInfoTddTdd128tpc_step_size*>(items[2]) = hSSCCHInfor7ModeSpecificInfoTddTdd128tpc_step_size; }
	void setBlertarget(const BlerTarget& blertarget) { *static_cast<BlerTarget*>(items[3]) = blertarget; }
	void setPowerControlGAP(const PowerControlGAP& powerControlGAP) { *static_cast<PowerControlGAP*>(items[4]) = powerControlGAP; }
	void setHSSCCHInfor7ModeSpecificInfoTddTdd128PathlossCompensationSwitch(const HSSCCHInfor7ModeSpecificInfoTddTdd128PathlossCompensationSwitch& hSSCCHInfor7ModeSpecificInfoTddTdd128PathlossCompensationSwitch) { *static_cast<HSSCCHInfor7ModeSpecificInfoTddTdd128PathlossCompensationSwitch*>(items[5]) = hSSCCHInfor7ModeSpecificInfoTddTdd128PathlossCompensationSwitch; }
	void setHSSCCHInfor7ModeSpecificInfoTddTdd128HSSCCHSetConfiguration(const HSSCCHInfor7ModeSpecificInfoTddTdd128HSSCCHSetConfiguration& hSSCCHInfor7ModeSpecificInfoTddTdd128HSSCCHSetConfiguration) { *static_cast<HSSCCHInfor7ModeSpecificInfoTddTdd128HSSCCHSetConfiguration*>(items[6]) = hSSCCHInfor7ModeSpecificInfoTddTdd128HSSCCHSetConfiguration; }
};

class HSSCCHInfor7ModeSpecificInfoTdd : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum HSSCCHInfor7ModeSpecificInfoTddChoices {
		hSSCCHInfor7ModeSpecificInfoTddTdd384 = 0,
		hSSCCHInfor7ModeSpecificInfoTddTdd768 = 1,
		hSSCCHInfor7ModeSpecificInfoTddTdd128 = 2,
	};
	static const Info theInfo;
	HSSCCHInfor7ModeSpecificInfoTdd(): Choice(&theInfo) {}
};

class HSSCCHInfor7ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum HSSCCHInfor7ModeSpecificInfoChoices {
		hSSCCHInfor7ModeSpecificInfoFdd = 0,
		hSSCCHInfor7ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	HSSCCHInfor7ModeSpecificInfo(): Choice(&theInfo) {}
};

class HSSCCHInfor7 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	HSSCCHInfor7(): Sequence(&theInfo) {}

	void setHSSCCHInfor7ModeSpecificInfo(const HSSCCHInfor7ModeSpecificInfo& hSSCCHInfor7ModeSpecificInfo) { *static_cast<HSSCCHInfor7ModeSpecificInfo*>(items[0]) = hSSCCHInfor7ModeSpecificInfo; }
};

enum Feedbackcycler7Values {
	fc0_Feedbackcycler7 = 0,
	fc2_Feedbackcycler7 = 1,
	fc4_Feedbackcycler7 = 2,
	fc8_Feedbackcycler7 = 3,
	fc10_Feedbackcycler7 = 4,
	fc20_Feedbackcycler7 = 5,
	fc40_Feedbackcycler7 = 6,
	fc80_Feedbackcycler7 = 7,
	fc160_Feedbackcycler7 = 8,
	fc16_Feedbackcycler7 = 9,
	fc32_Feedbackcycler7 = 10,
	fc64_Feedbackcycler7 = 11,
	spare4_Feedbackcycler7 = 12,
	spare3_Feedbackcycler7 = 13,
	spare2_Feedbackcycler7 = 14,
	spare1_Feedbackcycler7 = 15,
};
typedef Enumerated<CONSTRAINED, 15> Feedbackcycler7;

class MeasurementFeedbackInfor7ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	MeasurementFeedbackInfor7ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setMeasurementPowerOffset(const MeasurementPowerOffset& measurementPowerOffset) { *static_cast<MeasurementPowerOffset*>(items[0]) = measurementPowerOffset; }
	void setFeedbackcycle(const Feedbackcycler7& feedbackcycle) { *static_cast<Feedbackcycler7*>(items[1]) = feedbackcycle; }
	void setCqiRepetitionFactor(const CQIRepetitionFactor& cqiRepetitionFactor) { *static_cast<CQIRepetitionFactor*>(items[2]) = cqiRepetitionFactor; }
	void setDeltaCQI(const DeltaCQI& deltaCQI) { *static_cast<DeltaCQI*>(items[3]) = deltaCQI; }
};

typedef Null MeasurementFeedbackInfor7ModeSpecificInfoTdd;

class MeasurementFeedbackInfor7ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MeasurementFeedbackInfor7ModeSpecificInfoChoices {
		measurementFeedbackInfor7ModeSpecificInfoFdd = 0,
		measurementFeedbackInfor7ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	MeasurementFeedbackInfor7ModeSpecificInfo(): Choice(&theInfo) {}
};

class MeasurementFeedbackInfor7 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasurementFeedbackInfor7(): Sequence(&theInfo) {}

	void setMeasurementFeedbackInfor7ModeSpecificInfo(const MeasurementFeedbackInfor7ModeSpecificInfo& measurementFeedbackInfor7ModeSpecificInfo) { *static_cast<MeasurementFeedbackInfor7ModeSpecificInfo*>(items[0]) = measurementFeedbackInfor7ModeSpecificInfo; }
};

class DLHSPDSCHInformationr7ModeSpecificInfoTddTdd384 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr7ModeSpecificInfoTddTdd384(): Sequence(&theInfo) {}

	void setDlHSPDSCHTSConfiguration(const DLHSPDSCHTSConfiguration& dlHSPDSCHTSConfiguration) { *static_cast<DLHSPDSCHTSConfiguration*>(items[0]) = dlHSPDSCHTSConfiguration; }
};

class DLHSPDSCHTSConfigurationVHCR : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	DLHSPDSCHTSConfigurationVHCR(): Sequence(&theInfo) {}

};

class DLHSPDSCHInformationr7ModeSpecificInfoTddTdd768 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr7ModeSpecificInfoTddTdd768(): Sequence(&theInfo) {}

	void setDlHSPDSCHTSConfiguration(const DLHSPDSCHTSConfigurationVHCR& dlHSPDSCHTSConfiguration) { *static_cast<DLHSPDSCHTSConfigurationVHCR*>(items[0]) = dlHSPDSCHTSConfiguration; }
};

enum DLMultiCarrierInformationtsn_LengthValues {
	tsn_6bits_DLMultiCarrierInformationtsn_Length = 0,
	tsn_9bits_DLMultiCarrierInformationtsn_Length = 1,
};
typedef Enumerated<CONSTRAINED, 1> DLMultiCarrierInformationtsn_Length;

typedef Integer<CONSTRAINED, 1, maxTDD128Carrier> DLMultiCarrierInformationMultiCarrierNumber;

class DLHSPDSCHMultiCarrierInformation : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	DLHSPDSCHMultiCarrierInformation(): Sequence(&theInfo) {}

};

class DLMultiCarrierInformation : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLMultiCarrierInformation(): Sequence(&theInfo) {}

	void setDLMultiCarrierInformationtsn_Length(const DLMultiCarrierInformationtsn_Length& dLMultiCarrierInformationtsn_Length) { *static_cast<DLMultiCarrierInformationtsn_Length*>(items[0]) = dLMultiCarrierInformationtsn_Length; }
	void setDLMultiCarrierInformationMultiCarrierNumber(const DLMultiCarrierInformationMultiCarrierNumber& dLMultiCarrierInformationMultiCarrierNumber) { *static_cast<DLMultiCarrierInformationMultiCarrierNumber*>(items[1]) = dLMultiCarrierInformationMultiCarrierNumber; }
	void setDlHSPDSCHMultiCarrierInformation(const DLHSPDSCHMultiCarrierInformation& dlHSPDSCHMultiCarrierInformation) { *static_cast<DLHSPDSCHMultiCarrierInformation*>(items[2]) = dlHSPDSCHMultiCarrierInformation; }
};

class DLHSPDSCHInformationr7ModeSpecificInfoTddTdd128 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr7ModeSpecificInfoTddTdd128(): Sequence(&theInfo) {}

	void setHsPDSCHMidambleConfigurationtdd128(const HSPDSCHMidambleConfigurationTDD128& hsPDSCHMidambleConfigurationtdd128) { *static_cast<HSPDSCHMidambleConfigurationTDD128*>(items[0]) = hsPDSCHMidambleConfigurationtdd128; }
	void setDlMultiCarrierInformation(const DLMultiCarrierInformation& dlMultiCarrierInformation) { *static_cast<DLMultiCarrierInformation*>(items[1]) = dlMultiCarrierInformation; }
};

class DLHSPDSCHInformationr7ModeSpecificInfoTdd : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum DLHSPDSCHInformationr7ModeSpecificInfoTddChoices {
		dLHSPDSCHInformationr7ModeSpecificInfoTddTdd384 = 0,
		dLHSPDSCHInformationr7ModeSpecificInfoTddTdd768 = 1,
		dLHSPDSCHInformationr7ModeSpecificInfoTddTdd128 = 2,
	};
	static const Info theInfo;
	DLHSPDSCHInformationr7ModeSpecificInfoTdd(): Choice(&theInfo) {}
};

enum DLHSPDSCHInformationr7ModeSpecificInfoFdddl_64QAM_ConfiguredValues {
	true_DLHSPDSCHInformationr7ModeSpecificInfoFdddl_64QAM_Configured = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLHSPDSCHInformationr7ModeSpecificInfoFdddl_64QAM_Configured;

class DLHSPDSCHInformationr7ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr7ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setDLHSPDSCHInformationr7ModeSpecificInfoFdddl_64QAM_Configured(const DLHSPDSCHInformationr7ModeSpecificInfoFdddl_64QAM_Configured& dLHSPDSCHInformationr7ModeSpecificInfoFdddl_64QAM_Configured) { *static_cast<DLHSPDSCHInformationr7ModeSpecificInfoFdddl_64QAM_Configured*>(items[0]) = dLHSPDSCHInformationr7ModeSpecificInfoFdddl_64QAM_Configured; }
};

class DLHSPDSCHInformationr7ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLHSPDSCHInformationr7ModeSpecificInfoChoices {
		dLHSPDSCHInformationr7ModeSpecificInfoTdd = 0,
		dLHSPDSCHInformationr7ModeSpecificInfoFdd = 1,
	};
	static const Info theInfo;
	DLHSPDSCHInformationr7ModeSpecificInfo(): Choice(&theInfo) {}
};

class DLHSPDSCHInformationr7 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr7(): Sequence(&theInfo) {}

	void setHsscchInfo(const HSSCCHInfor7& hsscchInfo) { *static_cast<HSSCCHInfor7*>(items[0]) = hsscchInfo; }
	void setMeasurementfeedbackInfo(const MeasurementFeedbackInfor7& measurementfeedbackInfo) { *static_cast<MeasurementFeedbackInfor7*>(items[1]) = measurementfeedbackInfo; }
	void setDLHSPDSCHInformationr7ModeSpecificInfo(const DLHSPDSCHInformationr7ModeSpecificInfo& dLHSPDSCHInformationr7ModeSpecificInfo) { *static_cast<DLHSPDSCHInformationr7ModeSpecificInfo*>(items[2]) = dLHSPDSCHInformationr7ModeSpecificInfo; }
};

enum HARQInfor7numberOfProcessesValues {
	n1_HARQInfor7numberOfProcesses = 0,
	n2_HARQInfor7numberOfProcesses = 1,
	n3_HARQInfor7numberOfProcesses = 2,
	n4_HARQInfor7numberOfProcesses = 3,
	n5_HARQInfor7numberOfProcesses = 4,
	n6_HARQInfor7numberOfProcesses = 5,
	n7_HARQInfor7numberOfProcesses = 6,
	n8_HARQInfor7numberOfProcesses = 7,
	n12_HARQInfor7numberOfProcesses = 8,
	n14_HARQInfor7numberOfProcesses = 9,
	n16_HARQInfor7numberOfProcesses = 10,
};
typedef Enumerated<CONSTRAINED, 10> HARQInfor7numberOfProcesses;

typedef Null HARQInfor7MemoryPartitioningImplicit;

typedef SequenceOf<HARQMemorySize, CONSTRAINED, 1, maxHProcesses> HARQInfor7MemoryPartitioningExplicitMemorySize;

typedef SequenceOf<HARQMemorySize, CONSTRAINED, 1, maxHProcesses> HARQInfor7MemoryPartitioningExplicitAdditionalMemorySizesForMIMO;

class HARQInfor7MemoryPartitioningExplicit : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	HARQInfor7MemoryPartitioningExplicit(): Sequence(&theInfo) {}

	void setHARQInfor7MemoryPartitioningExplicitMemorySize(const HARQInfor7MemoryPartitioningExplicitMemorySize& hARQInfor7MemoryPartitioningExplicitMemorySize) { *static_cast<HARQInfor7MemoryPartitioningExplicitMemorySize*>(items[0]) = hARQInfor7MemoryPartitioningExplicitMemorySize; }
	void setHARQInfor7MemoryPartitioningExplicitAdditionalMemorySizesForMIMO(const HARQInfor7MemoryPartitioningExplicitAdditionalMemorySizesForMIMO& hARQInfor7MemoryPartitioningExplicitAdditionalMemorySizesForMIMO) { *static_cast<HARQInfor7MemoryPartitioningExplicitAdditionalMemorySizesForMIMO*>(items[1]) = hARQInfor7MemoryPartitioningExplicitAdditionalMemorySizesForMIMO; }
};

class HARQInfor7MemoryPartitioning : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum HARQInfor7MemoryPartitioningChoices {
		hARQInfor7MemoryPartitioningImplicit = 0,
		hARQInfor7MemoryPartitioningExplicit = 1,
	};
	static const Info theInfo;
	HARQInfor7MemoryPartitioning(): Choice(&theInfo) {}
};

class HARQInfor7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	HARQInfor7(): Sequence(&theInfo) {}

	void setHARQInfor7numberOfProcesses(const HARQInfor7numberOfProcesses& hARQInfor7numberOfProcesses) { *static_cast<HARQInfor7numberOfProcesses*>(items[0]) = hARQInfor7numberOfProcesses; }
	void setHARQInfor7MemoryPartitioning(const HARQInfor7MemoryPartitioning& hARQInfor7MemoryPartitioning) { *static_cast<HARQInfor7MemoryPartitioning*>(items[1]) = hARQInfor7MemoryPartitioning; }
};

enum ServingHSDSCHCellInformationr7mac_hsResetIndicatorValues {
	true_ServingHSDSCHCellInformationr7mac_hsResetIndicator = 0,
};
typedef Enumerated<CONSTRAINED, 0> ServingHSDSCHCellInformationr7mac_hsResetIndicator;

class ServingHSDSCHCellInformationr7 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	ServingHSDSCHCellInformationr7(): Sequence(&theInfo) {}

	void setDeltaACK(const DeltaACK& deltaACK) { *static_cast<DeltaACK*>(items[0]) = deltaACK; }
	void setDeltaNACK(const DeltaNACK& deltaNACK) { *static_cast<DeltaNACK*>(items[1]) = deltaNACK; }
	void setHarqPreambleMode(const HARQPreambleMode& harqPreambleMode) { *static_cast<HARQPreambleMode*>(items[2]) = harqPreambleMode; }
	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[3]) = primaryCPICHInfo; }
	void setDlhspdschInformation(const DLHSPDSCHInformationr7& dlhspdschInformation) { *static_cast<DLHSPDSCHInformationr7*>(items[4]) = dlhspdschInformation; }
	void setHarqInfo(const HARQInfor7& harqInfo) { *static_cast<HARQInfor7*>(items[5]) = harqInfo; }
	void setServingHSDSCHCellInformationr7mac_hsResetIndicator(const ServingHSDSCHCellInformationr7mac_hsResetIndicator& servingHSDSCHCellInformationr7mac_hsResetIndicator) { *static_cast<ServingHSDSCHCellInformationr7mac_hsResetIndicator*>(items[6]) = servingHSDSCHCellInformationr7mac_hsResetIndicator; }
};

class DLHSPDSCHInformationr8ModeSpecificInfoTddTdd384 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr8ModeSpecificInfoTddTdd384(): Sequence(&theInfo) {}

	void setDlHSPDSCHTSConfiguration(const DLHSPDSCHTSConfiguration& dlHSPDSCHTSConfiguration) { *static_cast<DLHSPDSCHTSConfiguration*>(items[0]) = dlHSPDSCHTSConfiguration; }
};

class DLHSPDSCHInformationr8ModeSpecificInfoTddTdd768 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr8ModeSpecificInfoTddTdd768(): Sequence(&theInfo) {}

	void setDlHSPDSCHTSConfiguration(const DLHSPDSCHTSConfigurationVHCR& dlHSPDSCHTSConfiguration) { *static_cast<DLHSPDSCHTSConfigurationVHCR*>(items[0]) = dlHSPDSCHTSConfiguration; }
};

class DLHSPDSCHInformationr8ModeSpecificInfoTddTdd128 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr8ModeSpecificInfoTddTdd128(): Sequence(&theInfo) {}

	void setHsPDSCHMidambleConfigurationtdd128(const HSPDSCHMidambleConfigurationTDD128& hsPDSCHMidambleConfigurationtdd128) { *static_cast<HSPDSCHMidambleConfigurationTDD128*>(items[0]) = hsPDSCHMidambleConfigurationtdd128; }
	void setDlMultiCarrierInformation(const DLMultiCarrierInformation& dlMultiCarrierInformation) { *static_cast<DLMultiCarrierInformation*>(items[1]) = dlMultiCarrierInformation; }
};

class DLHSPDSCHInformationr8ModeSpecificInfoTdd : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum DLHSPDSCHInformationr8ModeSpecificInfoTddChoices {
		dLHSPDSCHInformationr8ModeSpecificInfoTddTdd384 = 0,
		dLHSPDSCHInformationr8ModeSpecificInfoTddTdd768 = 1,
		dLHSPDSCHInformationr8ModeSpecificInfoTddTdd128 = 2,
	};
	static const Info theInfo;
	DLHSPDSCHInformationr8ModeSpecificInfoTdd(): Choice(&theInfo) {}
};

enum DLHSPDSCHInformationr8ModeSpecificInfoFdddl_64QAM_ConfiguredValues {
	true_DLHSPDSCHInformationr8ModeSpecificInfoFdddl_64QAM_Configured = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLHSPDSCHInformationr8ModeSpecificInfoFdddl_64QAM_Configured;

enum HSDSCHTBSizeTableValues {
	octetAligned_HSDSCHTBSizeTable = 0,
};
typedef Enumerated<CONSTRAINED, 0> HSDSCHTBSizeTable;

class DLHSPDSCHInformationr8ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr8ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setDLHSPDSCHInformationr8ModeSpecificInfoFdddl_64QAM_Configured(const DLHSPDSCHInformationr8ModeSpecificInfoFdddl_64QAM_Configured& dLHSPDSCHInformationr8ModeSpecificInfoFdddl_64QAM_Configured) { *static_cast<DLHSPDSCHInformationr8ModeSpecificInfoFdddl_64QAM_Configured*>(items[0]) = dLHSPDSCHInformationr8ModeSpecificInfoFdddl_64QAM_Configured; }
	void setHsDSCHTBSizeTable(const HSDSCHTBSizeTable& hsDSCHTBSizeTable) { *static_cast<HSDSCHTBSizeTable*>(items[1]) = hsDSCHTBSizeTable; }
};

class DLHSPDSCHInformationr8ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLHSPDSCHInformationr8ModeSpecificInfoChoices {
		dLHSPDSCHInformationr8ModeSpecificInfoTdd = 0,
		dLHSPDSCHInformationr8ModeSpecificInfoFdd = 1,
	};
	static const Info theInfo;
	DLHSPDSCHInformationr8ModeSpecificInfo(): Choice(&theInfo) {}
};

class DLHSPDSCHInformationr8 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr8(): Sequence(&theInfo) {}

	void setHsscchInfo(const HSSCCHInfor7& hsscchInfo) { *static_cast<HSSCCHInfor7*>(items[0]) = hsscchInfo; }
	void setMeasurementfeedbackInfo(const MeasurementFeedbackInfor7& measurementfeedbackInfo) { *static_cast<MeasurementFeedbackInfor7*>(items[1]) = measurementfeedbackInfo; }
	void setDLHSPDSCHInformationr8ModeSpecificInfo(const DLHSPDSCHInformationr8ModeSpecificInfo& dLHSPDSCHInformationr8ModeSpecificInfo) { *static_cast<DLHSPDSCHInformationr8ModeSpecificInfo*>(items[2]) = dLHSPDSCHInformationr8ModeSpecificInfo; }
};

enum ServingHSDSCHCellInformationr8mac_hsResetIndicatorValues {
	true_ServingHSDSCHCellInformationr8mac_hsResetIndicator = 0,
};
typedef Enumerated<CONSTRAINED, 0> ServingHSDSCHCellInformationr8mac_hsResetIndicator;

class ServingHSDSCHCellInformationr8 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	ServingHSDSCHCellInformationr8(): Sequence(&theInfo) {}

	void setDeltaACK(const DeltaACK& deltaACK) { *static_cast<DeltaACK*>(items[0]) = deltaACK; }
	void setDeltaNACK(const DeltaNACK& deltaNACK) { *static_cast<DeltaNACK*>(items[1]) = deltaNACK; }
	void setHarqPreambleMode(const HARQPreambleMode& harqPreambleMode) { *static_cast<HARQPreambleMode*>(items[2]) = harqPreambleMode; }
	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[3]) = primaryCPICHInfo; }
	void setDlhspdschInformation(const DLHSPDSCHInformationr8& dlhspdschInformation) { *static_cast<DLHSPDSCHInformationr8*>(items[4]) = dlhspdschInformation; }
	void setHarqInfo(const HARQInfor7& harqInfo) { *static_cast<HARQInfor7*>(items[5]) = harqInfo; }
	void setServingHSDSCHCellInformationr8mac_hsResetIndicator(const ServingHSDSCHCellInformationr8mac_hsResetIndicator& servingHSDSCHCellInformationr8mac_hsResetIndicator) { *static_cast<ServingHSDSCHCellInformationr8mac_hsResetIndicator*>(items[6]) = servingHSDSCHCellInformationr8mac_hsResetIndicator; }
};

typedef SequenceOf<HSSCCHCodes, CONSTRAINED, 1, maxHSSCCHs> HSSCCHInfor9ModeSpecificInfoFddHSSCCHChannelisationCodeInfo;

class HSSCCHInfor9ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	HSSCCHInfor9ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setHSSCCHInfor9ModeSpecificInfoFddHSSCCHChannelisationCodeInfo(const HSSCCHInfor9ModeSpecificInfoFddHSSCCHChannelisationCodeInfo& hSSCCHInfor9ModeSpecificInfoFddHSSCCHChannelisationCodeInfo) { *static_cast<HSSCCHInfor9ModeSpecificInfoFddHSSCCHChannelisationCodeInfo*>(items[0]) = hSSCCHInfor9ModeSpecificInfoFddHSSCCHChannelisationCodeInfo; }
	void setDlScramblingCode(const SecondaryScramblingCode& dlScramblingCode) { *static_cast<SecondaryScramblingCode*>(items[1]) = dlScramblingCode; }
};

typedef Integer<CONSTRAINED, -7, 8> HSSCCHInfor9ModeSpecificInfoTddTdd384Nackackpoweroffset;

typedef SequenceOf<HSSCCHTDD384r6, CONSTRAINED, 1, maxHSSCCHs> HSSCCHInfor9ModeSpecificInfoTddTdd384HSSCCHSetConfiguration;

class HSSCCHInfor9ModeSpecificInfoTddTdd384 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	HSSCCHInfor9ModeSpecificInfoTddTdd384(): Sequence(&theInfo) {}

	void setHSSCCHInfor9ModeSpecificInfoTddTdd384Nackackpoweroffset(const HSSCCHInfor9ModeSpecificInfoTddTdd384Nackackpoweroffset& hSSCCHInfor9ModeSpecificInfoTddTdd384Nackackpoweroffset) { *static_cast<HSSCCHInfor9ModeSpecificInfoTddTdd384Nackackpoweroffset*>(items[0]) = hSSCCHInfor9ModeSpecificInfoTddTdd384Nackackpoweroffset; }
	void setHsSICHPowerControlInfo(const HSSICHPowerControlInfoTDD384& hsSICHPowerControlInfo) { *static_cast<HSSICHPowerControlInfoTDD384*>(items[1]) = hsSICHPowerControlInfo; }
	void setDhssync(const DHSSync& dhssync) { *static_cast<DHSSync*>(items[2]) = dhssync; }
	void setBlertarget(const BlerTarget& blertarget) { *static_cast<BlerTarget*>(items[3]) = blertarget; }
	void setHSSCCHInfor9ModeSpecificInfoTddTdd384HSSCCHSetConfiguration(const HSSCCHInfor9ModeSpecificInfoTddTdd384HSSCCHSetConfiguration& hSSCCHInfor9ModeSpecificInfoTddTdd384HSSCCHSetConfiguration) { *static_cast<HSSCCHInfor9ModeSpecificInfoTddTdd384HSSCCHSetConfiguration*>(items[4]) = hSSCCHInfor9ModeSpecificInfoTddTdd384HSSCCHSetConfiguration; }
};

typedef Integer<CONSTRAINED, -7, 8> HSSCCHInfor9ModeSpecificInfoTddTdd768Nackackpoweroffset;

typedef SequenceOf<HSSCCHTDD768, CONSTRAINED, 1, maxHSSCCHs> HSSCCHInfor9ModeSpecificInfoTddTdd768HSSCCHSetConfiguration;

class HSSCCHInfor9ModeSpecificInfoTddTdd768 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	HSSCCHInfor9ModeSpecificInfoTddTdd768(): Sequence(&theInfo) {}

	void setHSSCCHInfor9ModeSpecificInfoTddTdd768Nackackpoweroffset(const HSSCCHInfor9ModeSpecificInfoTddTdd768Nackackpoweroffset& hSSCCHInfor9ModeSpecificInfoTddTdd768Nackackpoweroffset) { *static_cast<HSSCCHInfor9ModeSpecificInfoTddTdd768Nackackpoweroffset*>(items[0]) = hSSCCHInfor9ModeSpecificInfoTddTdd768Nackackpoweroffset; }
	void setHsSICHPowerControlInfo(const HSSICHPowerControlInfoTDD768& hsSICHPowerControlInfo) { *static_cast<HSSICHPowerControlInfoTDD768*>(items[1]) = hsSICHPowerControlInfo; }
	void setDhssync(const DHSSync& dhssync) { *static_cast<DHSSync*>(items[2]) = dhssync; }
	void setBlertarget(const BlerTarget& blertarget) { *static_cast<BlerTarget*>(items[3]) = blertarget; }
	void setHSSCCHInfor9ModeSpecificInfoTddTdd768HSSCCHSetConfiguration(const HSSCCHInfor9ModeSpecificInfoTddTdd768HSSCCHSetConfiguration& hSSCCHInfor9ModeSpecificInfoTddTdd768HSSCCHSetConfiguration) { *static_cast<HSSCCHInfor9ModeSpecificInfoTddTdd768HSSCCHSetConfiguration*>(items[4]) = hSSCCHInfor9ModeSpecificInfoTddTdd768HSSCCHSetConfiguration; }
};

typedef Integer<CONSTRAINED, -7, 8> HSSCCHInfor9ModeSpecificInfoTddTdd128Nackackpoweroffset;

typedef Integer<CONSTRAINED, -120, -58> HSSCCHInfor9ModeSpecificInfoTddTdd128PowerlevelHSSICH;

enum HSSCCHInfor9ModeSpecificInfoTddTdd128tpc_step_sizeValues {
	s1_HSSCCHInfor9ModeSpecificInfoTddTdd128tpc_step_size = 0,
	s2_HSSCCHInfor9ModeSpecificInfoTddTdd128tpc_step_size = 1,
	s3_HSSCCHInfor9ModeSpecificInfoTddTdd128tpc_step_size = 2,
	spare1_HSSCCHInfor9ModeSpecificInfoTddTdd128tpc_step_size = 3,
};
typedef Enumerated<CONSTRAINED, 3> HSSCCHInfor9ModeSpecificInfoTddTdd128tpc_step_size;

enum HSSCCHInfor9ModeSpecificInfoTddTdd128hS_SCCH_tpc_step_sizeValues {
	s1_HSSCCHInfor9ModeSpecificInfoTddTdd128hS_SCCH_tpc_step_size = 0,
	s2_HSSCCHInfor9ModeSpecificInfoTddTdd128hS_SCCH_tpc_step_size = 1,
	s3_HSSCCHInfor9ModeSpecificInfoTddTdd128hS_SCCH_tpc_step_size = 2,
	spare1_HSSCCHInfor9ModeSpecificInfoTddTdd128hS_SCCH_tpc_step_size = 3,
};
typedef Enumerated<CONSTRAINED, 3> HSSCCHInfor9ModeSpecificInfoTddTdd128hS_SCCH_tpc_step_size;

typedef Boolean HSSCCHInfor9ModeSpecificInfoTddTdd128PathlossCompensationSwitch;

typedef SequenceOf<HSSCCHTDD128r6, CONSTRAINED, 1, maxHSSCCHs> HSSCCHInfor9ModeSpecificInfoTddTdd128HSSCCHSetConfiguration;

class HSSCCHInfor9ModeSpecificInfoTddTdd128 : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	HSSCCHInfor9ModeSpecificInfoTddTdd128(): Sequence(&theInfo) {}

	void setHSSCCHInfor9ModeSpecificInfoTddTdd128Nackackpoweroffset(const HSSCCHInfor9ModeSpecificInfoTddTdd128Nackackpoweroffset& hSSCCHInfor9ModeSpecificInfoTddTdd128Nackackpoweroffset) { *static_cast<HSSCCHInfor9ModeSpecificInfoTddTdd128Nackackpoweroffset*>(items[0]) = hSSCCHInfor9ModeSpecificInfoTddTdd128Nackackpoweroffset; }
	void setHSSCCHInfor9ModeSpecificInfoTddTdd128PowerlevelHSSICH(const HSSCCHInfor9ModeSpecificInfoTddTdd128PowerlevelHSSICH& hSSCCHInfor9ModeSpecificInfoTddTdd128PowerlevelHSSICH) { *static_cast<HSSCCHInfor9ModeSpecificInfoTddTdd128PowerlevelHSSICH*>(items[1]) = hSSCCHInfor9ModeSpecificInfoTddTdd128PowerlevelHSSICH; }
	void setHSSCCHInfor9ModeSpecificInfoTddTdd128tpc_step_size(const HSSCCHInfor9ModeSpecificInfoTddTdd128tpc_step_size& hSSCCHInfor9ModeSpecificInfoTddTdd128tpc_step_size) { *static_cast<HSSCCHInfor9ModeSpecificInfoTddTdd128tpc_step_size*>(items[2]) = hSSCCHInfor9ModeSpecificInfoTddTdd128tpc_step_size; }
	void setBlertarget(const BlerTarget& blertarget) { *static_cast<BlerTarget*>(items[3]) = blertarget; }
	void setHSSCCHInfor9ModeSpecificInfoTddTdd128hS_SCCH_tpc_step_size(const HSSCCHInfor9ModeSpecificInfoTddTdd128hS_SCCH_tpc_step_size& hSSCCHInfor9ModeSpecificInfoTddTdd128hS_SCCH_tpc_step_size) { *static_cast<HSSCCHInfor9ModeSpecificInfoTddTdd128hS_SCCH_tpc_step_size*>(items[4]) = hSSCCHInfor9ModeSpecificInfoTddTdd128hS_SCCH_tpc_step_size; }
	void setPowerControlGAP(const PowerControlGAP& powerControlGAP) { *static_cast<PowerControlGAP*>(items[5]) = powerControlGAP; }
	void setHSSCCHInfor9ModeSpecificInfoTddTdd128PathlossCompensationSwitch(const HSSCCHInfor9ModeSpecificInfoTddTdd128PathlossCompensationSwitch& hSSCCHInfor9ModeSpecificInfoTddTdd128PathlossCompensationSwitch) { *static_cast<HSSCCHInfor9ModeSpecificInfoTddTdd128PathlossCompensationSwitch*>(items[6]) = hSSCCHInfor9ModeSpecificInfoTddTdd128PathlossCompensationSwitch; }
	void setHSSCCHInfor9ModeSpecificInfoTddTdd128HSSCCHSetConfiguration(const HSSCCHInfor9ModeSpecificInfoTddTdd128HSSCCHSetConfiguration& hSSCCHInfor9ModeSpecificInfoTddTdd128HSSCCHSetConfiguration) { *static_cast<HSSCCHInfor9ModeSpecificInfoTddTdd128HSSCCHSetConfiguration*>(items[7]) = hSSCCHInfor9ModeSpecificInfoTddTdd128HSSCCHSetConfiguration; }
};

class HSSCCHInfor9ModeSpecificInfoTdd : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum HSSCCHInfor9ModeSpecificInfoTddChoices {
		hSSCCHInfor9ModeSpecificInfoTddTdd384 = 0,
		hSSCCHInfor9ModeSpecificInfoTddTdd768 = 1,
		hSSCCHInfor9ModeSpecificInfoTddTdd128 = 2,
	};
	static const Info theInfo;
	HSSCCHInfor9ModeSpecificInfoTdd(): Choice(&theInfo) {}
};

class HSSCCHInfor9ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum HSSCCHInfor9ModeSpecificInfoChoices {
		hSSCCHInfor9ModeSpecificInfoFdd = 0,
		hSSCCHInfor9ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	HSSCCHInfor9ModeSpecificInfo(): Choice(&theInfo) {}
};

class HSSCCHInfor9 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	HSSCCHInfor9(): Sequence(&theInfo) {}

	void setHSSCCHInfor9ModeSpecificInfo(const HSSCCHInfor9ModeSpecificInfo& hSSCCHInfor9ModeSpecificInfo) { *static_cast<HSSCCHInfor9ModeSpecificInfo*>(items[0]) = hSSCCHInfor9ModeSpecificInfo; }
};

class DLHSPDSCHInformationr9ModeSpecificInfoTddTdd384 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr9ModeSpecificInfoTddTdd384(): Sequence(&theInfo) {}

	void setDlHSPDSCHTSConfiguration(const DLHSPDSCHTSConfiguration& dlHSPDSCHTSConfiguration) { *static_cast<DLHSPDSCHTSConfiguration*>(items[0]) = dlHSPDSCHTSConfiguration; }
};

class DLHSPDSCHInformationr9ModeSpecificInfoTddTdd768 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr9ModeSpecificInfoTddTdd768(): Sequence(&theInfo) {}

	void setDlHSPDSCHTSConfiguration(const DLHSPDSCHTSConfigurationVHCR& dlHSPDSCHTSConfiguration) { *static_cast<DLHSPDSCHTSConfigurationVHCR*>(items[0]) = dlHSPDSCHTSConfiguration; }
};

enum DLHSPDSCHInformationr9ModeSpecificInfoTddTdd128tS0_IndicatorValues {
	true_DLHSPDSCHInformationr9ModeSpecificInfoTddTdd128tS0_Indicator = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLHSPDSCHInformationr9ModeSpecificInfoTddTdd128tS0_Indicator;

enum OutofSyncWindowValues {
	ms40_OutofSyncWindow = 0,
	ms80_OutofSyncWindow = 1,
	ms160_OutofSyncWindow = 2,
	ms320_OutofSyncWindow = 3,
	ms640_OutofSyncWindow = 4,
	spare3_OutofSyncWindow = 5,
	spare2_OutofSyncWindow = 6,
	spare1_OutofSyncWindow = 7,
};
typedef Enumerated<CONSTRAINED, 7> OutofSyncWindow;

class DLHSPDSCHInformationr9ModeSpecificInfoTddTdd128 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr9ModeSpecificInfoTddTdd128(): Sequence(&theInfo) {}

	void setHsPDSCHMidambleConfigurationtdd128(const HSPDSCHMidambleConfigurationTDD128& hsPDSCHMidambleConfigurationtdd128) { *static_cast<HSPDSCHMidambleConfigurationTDD128*>(items[0]) = hsPDSCHMidambleConfigurationtdd128; }
	void setDlMultiCarrierInformation(const DLMultiCarrierInformation& dlMultiCarrierInformation) { *static_cast<DLMultiCarrierInformation*>(items[1]) = dlMultiCarrierInformation; }
	void setDLHSPDSCHInformationr9ModeSpecificInfoTddTdd128tS0_Indicator(const DLHSPDSCHInformationr9ModeSpecificInfoTddTdd128tS0_Indicator& dLHSPDSCHInformationr9ModeSpecificInfoTddTdd128tS0_Indicator) { *static_cast<DLHSPDSCHInformationr9ModeSpecificInfoTddTdd128tS0_Indicator*>(items[2]) = dLHSPDSCHInformationr9ModeSpecificInfoTddTdd128tS0_Indicator; }
	void setOutofSyncWindow(const OutofSyncWindow& outofSyncWindow) { *static_cast<OutofSyncWindow*>(items[3]) = outofSyncWindow; }
};

class DLHSPDSCHInformationr9ModeSpecificInfoTdd : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum DLHSPDSCHInformationr9ModeSpecificInfoTddChoices {
		dLHSPDSCHInformationr9ModeSpecificInfoTddTdd384 = 0,
		dLHSPDSCHInformationr9ModeSpecificInfoTddTdd768 = 1,
		dLHSPDSCHInformationr9ModeSpecificInfoTddTdd128 = 2,
	};
	static const Info theInfo;
	DLHSPDSCHInformationr9ModeSpecificInfoTdd(): Choice(&theInfo) {}
};

enum DLHSPDSCHInformationr9ModeSpecificInfoFdddl_64QAM_ConfiguredValues {
	true_DLHSPDSCHInformationr9ModeSpecificInfoFdddl_64QAM_Configured = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLHSPDSCHInformationr9ModeSpecificInfoFdddl_64QAM_Configured;

class DLHSPDSCHInformationr9ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr9ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setDLHSPDSCHInformationr9ModeSpecificInfoFdddl_64QAM_Configured(const DLHSPDSCHInformationr9ModeSpecificInfoFdddl_64QAM_Configured& dLHSPDSCHInformationr9ModeSpecificInfoFdddl_64QAM_Configured) { *static_cast<DLHSPDSCHInformationr9ModeSpecificInfoFdddl_64QAM_Configured*>(items[0]) = dLHSPDSCHInformationr9ModeSpecificInfoFdddl_64QAM_Configured; }
	void setHsDSCHTBSizeTable(const HSDSCHTBSizeTable& hsDSCHTBSizeTable) { *static_cast<HSDSCHTBSizeTable*>(items[1]) = hsDSCHTBSizeTable; }
};

class DLHSPDSCHInformationr9ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLHSPDSCHInformationr9ModeSpecificInfoChoices {
		dLHSPDSCHInformationr9ModeSpecificInfoTdd = 0,
		dLHSPDSCHInformationr9ModeSpecificInfoFdd = 1,
	};
	static const Info theInfo;
	DLHSPDSCHInformationr9ModeSpecificInfo(): Choice(&theInfo) {}
};

class DLHSPDSCHInformationr9 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr9(): Sequence(&theInfo) {}

	void setHsscchInfo(const HSSCCHInfor9& hsscchInfo) { *static_cast<HSSCCHInfor9*>(items[0]) = hsscchInfo; }
	void setMeasurementfeedbackInfo(const MeasurementFeedbackInfor7& measurementfeedbackInfo) { *static_cast<MeasurementFeedbackInfor7*>(items[1]) = measurementfeedbackInfo; }
	void setDLHSPDSCHInformationr9ModeSpecificInfo(const DLHSPDSCHInformationr9ModeSpecificInfo& dLHSPDSCHInformationr9ModeSpecificInfo) { *static_cast<DLHSPDSCHInformationr9ModeSpecificInfo*>(items[2]) = dLHSPDSCHInformationr9ModeSpecificInfo; }
};

enum ServingHSDSCHCellInformationr9mac_hsResetIndicatorValues {
	true_ServingHSDSCHCellInformationr9mac_hsResetIndicator = 0,
};
typedef Enumerated<CONSTRAINED, 0> ServingHSDSCHCellInformationr9mac_hsResetIndicator;

class ServingHSDSCHCellInformationr9 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	ServingHSDSCHCellInformationr9(): Sequence(&theInfo) {}

	void setDeltaACK(const DeltaACK& deltaACK) { *static_cast<DeltaACK*>(items[0]) = deltaACK; }
	void setDeltaNACK(const DeltaNACK& deltaNACK) { *static_cast<DeltaNACK*>(items[1]) = deltaNACK; }
	void setHarqPreambleMode(const HARQPreambleMode& harqPreambleMode) { *static_cast<HARQPreambleMode*>(items[2]) = harqPreambleMode; }
	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[3]) = primaryCPICHInfo; }
	void setDlhspdschInformation(const DLHSPDSCHInformationr9& dlhspdschInformation) { *static_cast<DLHSPDSCHInformationr9*>(items[4]) = dlhspdschInformation; }
	void setHarqInfo(const HARQInfor7& harqInfo) { *static_cast<HARQInfor7*>(items[5]) = harqInfo; }
	void setServingHSDSCHCellInformationr9mac_hsResetIndicator(const ServingHSDSCHCellInformationr9mac_hsResetIndicator& servingHSDSCHCellInformationr9mac_hsResetIndicator) { *static_cast<ServingHSDSCHCellInformationr9mac_hsResetIndicator*>(items[6]) = servingHSDSCHCellInformationr9mac_hsResetIndicator; }
};

typedef BitString<CONSTRAINED, 128, 128> SRVCCInfoNonce;

class SRVCCInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SRVCCInfo(): Sequence(&theInfo) {}

	void setSRVCCInfoNonce(const SRVCCInfoNonce& sRVCCInfoNonce) { *static_cast<SRVCCInfoNonce*>(items[0]) = sRVCCInfoNonce; }
};

class RABInfoReplace : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RABInfoReplace(): Sequence(&theInfo) {}

	void setRabIdentity(const RABIdentity& rabIdentity) { *static_cast<RABIdentity*>(items[0]) = rabIdentity; }
	void setCnDomainIdentity(const CNDomainIdentity& cnDomainIdentity) { *static_cast<CNDomainIdentity*>(items[1]) = cnDomainIdentity; }
};

class SRVCCSecurityRABInfov860ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SRVCCSecurityRABInfov860ext(): Sequence(&theInfo) {}

	void setSrvccInfo(const SRVCCInfo& srvccInfo) { *static_cast<SRVCCInfo*>(items[0]) = srvccInfo; }
	void setRabInfoReplace(const RABInfoReplace& rabInfoReplace) { *static_cast<RABInfoReplace*>(items[1]) = rabInfoReplace; }
};

typedef BitString<CONSTRAINED, 20, 20> STARTValue;

class STARTSingle : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	STARTSingle(): Sequence(&theInfo) {}

	void setCnDomainIdentity(const CNDomainIdentity& cnDomainIdentity) { *static_cast<CNDomainIdentity*>(items[0]) = cnDomainIdentity; }
	void setStartValue(const STARTValue& startValue) { *static_cast<STARTValue*>(items[1]) = startValue; }
};

typedef SequenceOf<STARTSingle, CONSTRAINED, 1, maxCNdomains> STARTList;

enum SystemSpecificCapUpdateReqv590extValues {
	geranIu_SystemSpecificCapUpdateReqv590ext = 0,
};
typedef Enumerated<CONSTRAINED, 0> SystemSpecificCapUpdateReqv590ext;

enum T300Values {
	ms100_T300 = 0,
	ms200_T300 = 1,
	ms400_T300 = 2,
	ms600_T300 = 3,
	ms800_T300 = 4,
	ms1000_T300 = 5,
	ms1200_T300 = 6,
	ms1400_T300 = 7,
	ms1600_T300 = 8,
	ms1800_T300 = 9,
	ms2000_T300 = 10,
	ms3000_T300 = 11,
	ms4000_T300 = 12,
	ms6000_T300 = 13,
	ms8000_T300 = 14,
};
typedef Enumerated<CONSTRAINED, 14> T300;

enum T301Values {
	ms100_T301 = 0,
	ms200_T301 = 1,
	ms400_T301 = 2,
	ms600_T301 = 3,
	ms800_T301 = 4,
	ms1000_T301 = 5,
	ms1200_T301 = 6,
	ms1400_T301 = 7,
	ms1600_T301 = 8,
	ms1800_T301 = 9,
	ms2000_T301 = 10,
	ms3000_T301 = 11,
	ms4000_T301 = 12,
	ms6000_T301 = 13,
	ms8000_T301 = 14,
	spare_T301 = 15,
};
typedef Enumerated<CONSTRAINED, 15> T301;

enum T302Values {
	ms100_T302 = 0,
	ms200_T302 = 1,
	ms400_T302 = 2,
	ms600_T302 = 3,
	ms800_T302 = 4,
	ms1000_T302 = 5,
	ms1200_T302 = 6,
	ms1400_T302 = 7,
	ms1600_T302 = 8,
	ms1800_T302 = 9,
	ms2000_T302 = 10,
	ms3000_T302 = 11,
	ms4000_T302 = 12,
	ms6000_T302 = 13,
	ms8000_T302 = 14,
	spare_T302 = 15,
};
typedef Enumerated<CONSTRAINED, 15> T302;

enum T304Values {
	ms100_T304 = 0,
	ms200_T304 = 1,
	ms400_T304 = 2,
	ms1000_T304 = 3,
	ms2000_T304 = 4,
	spare3_T304 = 5,
	spare2_T304 = 6,
	spare1_T304 = 7,
};
typedef Enumerated<CONSTRAINED, 7> T304;

enum T305Values {
	noUpdate_T305 = 0,
	m5_T305 = 1,
	m10_T305 = 2,
	m30_T305 = 3,
	m60_T305 = 4,
	m120_T305 = 5,
	m360_T305 = 6,
	m720_T305 = 7,
};
typedef Enumerated<CONSTRAINED, 7> T305;

enum T307Values {
	s5_T307 = 0,
	s10_T307 = 1,
	s15_T307 = 2,
	s20_T307 = 3,
	s30_T307 = 4,
	s40_T307 = 5,
	s50_T307 = 6,
	spare_T307 = 7,
};
typedef Enumerated<CONSTRAINED, 7> T307;

enum T308Values {
	ms40_T308 = 0,
	ms80_T308 = 1,
	ms160_T308 = 2,
	ms320_T308 = 3,
};
typedef Enumerated<CONSTRAINED, 3> T308;

typedef Integer<CONSTRAINED, 1, 8> T309;

enum T310Values {
	ms40_T310 = 0,
	ms80_T310 = 1,
	ms120_T310 = 2,
	ms160_T310 = 3,
	ms200_T310 = 4,
	ms240_T310 = 5,
	ms280_T310 = 6,
	ms320_T310 = 7,
};
typedef Enumerated<CONSTRAINED, 7> T310;

enum T311Values {
	ms250_T311 = 0,
	ms500_T311 = 1,
	ms750_T311 = 2,
	ms1000_T311 = 3,
	ms1250_T311 = 4,
	ms1500_T311 = 5,
	ms1750_T311 = 6,
	ms2000_T311 = 7,
};
typedef Enumerated<CONSTRAINED, 7> T311;

typedef Integer<CONSTRAINED, 0, 15> T312;

typedef Integer<CONSTRAINED, 0, 15> T313;

enum T314Values {
	s0_T314 = 0,
	s2_T314 = 1,
	s4_T314 = 2,
	s6_T314 = 3,
	s8_T314 = 4,
	s12_T314 = 5,
	s16_T314 = 6,
	s20_T314 = 7,
};
typedef Enumerated<CONSTRAINED, 7> T314;

enum T315Values {
	s0_T315 = 0,
	s10_T315 = 1,
	s30_T315 = 2,
	s60_T315 = 3,
	s180_T315 = 4,
	s600_T315 = 5,
	s1200_T315 = 6,
	s1800_T315 = 7,
};
typedef Enumerated<CONSTRAINED, 7> T315;

enum T316Values {
	s0_T316 = 0,
	s10_T316 = 1,
	s20_T316 = 2,
	s30_T316 = 3,
	s40_T316 = 4,
	s50_T316 = 5,
	s_inf_T316 = 6,
	spare_T316 = 7,
};
typedef Enumerated<CONSTRAINED, 7> T316;

enum T317Values {
	infinity0_T317 = 0,
	infinity1_T317 = 1,
	infinity2_T317 = 2,
	infinity3_T317 = 3,
	infinity4_T317 = 4,
	infinity5_T317 = 5,
	infinity6_T317 = 6,
	infinity7_T317 = 7,
};
typedef Enumerated<CONSTRAINED, 7> T317;

enum T318Values {
	ms250_T318 = 0,
	ms500_T318 = 1,
	ms750_T318 = 2,
	ms1000_T318 = 3,
	ms1250_T318 = 4,
	ms1500_T318 = 5,
	ms1750_T318 = 6,
	ms2000_T318 = 7,
	ms3000_T318 = 8,
	ms4000_T318 = 9,
	ms6000_T318 = 10,
	ms8000_T318 = 11,
	ms10000_T318 = 12,
	ms12000_T318 = 13,
	ms16000_T318 = 14,
};
typedef Enumerated<CONSTRAINED, 14> T318;

enum T319Values {
	ms80_T319 = 0,
	ms160_T319 = 1,
	ms320_T319 = 2,
	ms640_T319 = 3,
	ms1280_T319 = 4,
	ms2560_T319 = 5,
	ms5120_T319 = 6,
};
typedef Enumerated<CONSTRAINED, 6> T319;

enum T321Values {
	ms100_T321 = 0,
	ms200_T321 = 1,
	ms400_T321 = 2,
	ms800_T321 = 3,
};
typedef Enumerated<CONSTRAINED, 3> T321;

enum T323Values {
	s0_T323 = 0,
	s5_T323 = 1,
	s10_T323 = 2,
	s20_T323 = 3,
	s30_T323 = 4,
	s60_T323 = 5,
	s90_T323 = 6,
	s120_T323 = 7,
};
typedef Enumerated<CONSTRAINED, 7> T323;

typedef Null ULTransChCapabilityModeSpecificInfoFdd;

class ULTransChCapabilityModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULTransChCapabilityModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setMaxSimultaneousCCTrCHCount(const MaxSimultaneousCCTrCHCount& maxSimultaneousCCTrCHCount) { *static_cast<MaxSimultaneousCCTrCHCount*>(items[0]) = maxSimultaneousCCTrCHCount; }
};

class ULTransChCapabilityModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULTransChCapabilityModeSpecificInfoChoices {
		uLTransChCapabilityModeSpecificInfoFdd = 0,
		uLTransChCapabilityModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	ULTransChCapabilityModeSpecificInfo(): Choice(&theInfo) {}
};

class ULTransChCapability : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	ULTransChCapability(): Sequence(&theInfo) {}

	void setMaxNoBitsTransmitted(const MaxNoBits& maxNoBitsTransmitted) { *static_cast<MaxNoBits*>(items[0]) = maxNoBitsTransmitted; }
	void setMaxConvCodeBitsTransmitted(const MaxNoBits& maxConvCodeBitsTransmitted) { *static_cast<MaxNoBits*>(items[1]) = maxConvCodeBitsTransmitted; }
	void setTurboEncodingSupport(const TurboSupport& turboEncodingSupport) { *static_cast<TurboSupport*>(items[2]) = turboEncodingSupport; }
	void setMaxSimultaneousTransChs(const MaxSimultaneousTransChsUL& maxSimultaneousTransChs) { *static_cast<MaxSimultaneousTransChsUL*>(items[3]) = maxSimultaneousTransChs; }
	void setULTransChCapabilityModeSpecificInfo(const ULTransChCapabilityModeSpecificInfo& uLTransChCapabilityModeSpecificInfo) { *static_cast<ULTransChCapabilityModeSpecificInfo*>(items[4]) = uLTransChCapabilityModeSpecificInfo; }
	void setMaxTransmittedBlocks(const MaxTransportBlocksUL& maxTransmittedBlocks) { *static_cast<MaxTransportBlocksUL*>(items[5]) = maxTransmittedBlocks; }
	void setMaxNumberOfTFC(const MaxNumberOfTFCUL& maxNumberOfTFC) { *static_cast<MaxNumberOfTFCUL*>(items[6]) = maxNumberOfTFC; }
	void setMaxNumberOfTF(const MaxNumberOfTF& maxNumberOfTF) { *static_cast<MaxNumberOfTF*>(items[7]) = maxNumberOfTF; }
};

class TransportChannelCapability : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	TransportChannelCapability(): Sequence(&theInfo) {}

	void setDlTransChCapability(const DLTransChCapability& dlTransChCapability) { *static_cast<DLTransChCapability*>(items[0]) = dlTransChCapability; }
	void setUlTransChCapability(const ULTransChCapability& ulTransChCapability) { *static_cast<ULTransChCapability*>(items[1]) = ulTransChCapability; }
};

class URNTIShort : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	URNTIShort(): Sequence(&theInfo) {}

	void setSrncIdentity(const SRNCIdentity& srncIdentity) { *static_cast<SRNCIdentity*>(items[0]) = srncIdentity; }
	void setSRNTI2(const SRNTI2& sRNTI2) { *static_cast<SRNTI2*>(items[1]) = sRNTI2; }
};

typedef Integer<CONSTRAINED, 1, 16> PhysicalChannelCapabilityedchr6FddedchSupportedEdchPhysicalLayerCategory;

class PhysicalChannelCapabilityedchr6FddedchSupported : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityedchr6FddedchSupported(): Sequence(&theInfo) {}

	void setPhysicalChannelCapabilityedchr6FddedchSupportedEdchPhysicalLayerCategory(const PhysicalChannelCapabilityedchr6FddedchSupportedEdchPhysicalLayerCategory& physicalChannelCapabilityedchr6FddedchSupportedEdchPhysicalLayerCategory) { *static_cast<PhysicalChannelCapabilityedchr6FddedchSupportedEdchPhysicalLayerCategory*>(items[0]) = physicalChannelCapabilityedchr6FddedchSupportedEdchPhysicalLayerCategory; }
};

typedef Null PhysicalChannelCapabilityedchr6FddedchUnsupported;

class PhysicalChannelCapabilityedchr6Fddedch : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PhysicalChannelCapabilityedchr6FddedchChoices {
		physicalChannelCapabilityedchr6FddedchSupported = 0,
		physicalChannelCapabilityedchr6FddedchUnsupported = 1,
	};
	static const Info theInfo;
	PhysicalChannelCapabilityedchr6Fddedch(): Choice(&theInfo) {}
};

class PhysicalChannelCapabilityedchr6 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PhysicalChannelCapabilityedchr6(): Sequence(&theInfo) {}

	void setPhysicalChannelCapabilityedchr6Fddedch(const PhysicalChannelCapabilityedchr6Fddedch& physicalChannelCapabilityedchr6Fddedch) { *static_cast<PhysicalChannelCapabilityedchr6Fddedch*>(items[0]) = physicalChannelCapabilityedchr6Fddedch; }
};

enum UERadioAccessCapabilityv690extdeviceTypeValues {
	doesNotBenefitFromBatteryConsumptionOptimisation_UERadioAccessCapabilityv690extdeviceType = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityv690extdeviceType;

class UERadioAccessCapabilityv690ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv690ext(): Sequence(&theInfo) {}

	void setPhysicalchannelcapabilityedch(const PhysicalChannelCapabilityedchr6& physicalchannelcapabilityedch) { *static_cast<PhysicalChannelCapabilityedchr6*>(items[0]) = physicalchannelcapabilityedch; }
	void setUERadioAccessCapabilityv690extdeviceType(const UERadioAccessCapabilityv690extdeviceType& uERadioAccessCapabilityv690extdeviceType) { *static_cast<UERadioAccessCapabilityv690extdeviceType*>(items[1]) = uERadioAccessCapabilityv690extdeviceType; }
};

enum InterRATUERadioAccessCapabilityv690extsupportOfInter_RAT_PS_HandoverValues {
	doesSupporInter_RAT_PS_Handover_InterRATUERadioAccessCapabilityv690extsupportOfInter_RAT_PS_Handover = 0,
};
typedef Enumerated<CONSTRAINED, 0> InterRATUERadioAccessCapabilityv690extsupportOfInter_RAT_PS_Handover;

typedef OctetString<CONSTRAINED, 1, 64> GSMMSRadioAccessCapability;

class InterRATUERadioAccessCapabilityv690ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterRATUERadioAccessCapabilityv690ext(): Sequence(&theInfo) {}

	void setInterRATUERadioAccessCapabilityv690extsupportOfInter_RAT_PS_Handover(const InterRATUERadioAccessCapabilityv690extsupportOfInter_RAT_PS_Handover& interRATUERadioAccessCapabilityv690extsupportOfInter_RAT_PS_Handover) { *static_cast<InterRATUERadioAccessCapabilityv690extsupportOfInter_RAT_PS_Handover*>(items[0]) = interRATUERadioAccessCapabilityv690extsupportOfInter_RAT_PS_Handover; }
	void setGsmMSRadioAccessCapability(const GSMMSRadioAccessCapability& gsmMSRadioAccessCapability) { *static_cast<GSMMSRadioAccessCapability*>(items[1]) = gsmMSRadioAccessCapability; }
};

enum UERadioAccessCapabilityv6b0extIEssupportForSIB11bisValues {
	true_UERadioAccessCapabilityv6b0extIEssupportForSIB11bis = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityv6b0extIEssupportForSIB11bis;

class UERadioAccessCapabilityv6b0extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv6b0extIEs(): Sequence(&theInfo) {}

	void setUERadioAccessCapabilityv6b0extIEssupportForSIB11bis(const UERadioAccessCapabilityv6b0extIEssupportForSIB11bis& uERadioAccessCapabilityv6b0extIEssupportForSIB11bis) { *static_cast<UERadioAccessCapabilityv6b0extIEssupportForSIB11bis*>(items[0]) = uERadioAccessCapabilityv6b0extIEssupportForSIB11bis; }
};

enum UERadioAccessCapabilityv6e0extIEssupportForFDPCHValues {
	true_UERadioAccessCapabilityv6e0extIEssupportForFDPCH = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityv6e0extIEssupportForFDPCH;

class UERadioAccessCapabilityv6e0extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv6e0extIEs(): Sequence(&theInfo) {}

	void setUERadioAccessCapabilityv6e0extIEssupportForFDPCH(const UERadioAccessCapabilityv6e0extIEssupportForFDPCH& uERadioAccessCapabilityv6e0extIEssupportForFDPCH) { *static_cast<UERadioAccessCapabilityv6e0extIEssupportForFDPCH*>(items[0]) = uERadioAccessCapabilityv6e0extIEssupportForFDPCH; }
};

class UEGANSSPositioningCapability : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEGANSSPositioningCapability(): Sequence(&theInfo) {}

	void setNetworkAssistedGANSSsupportedList(const NetworkAssistedGANSSSupportedList& networkAssistedGANSSsupportedList) { *static_cast<NetworkAssistedGANSSSupportedList*>(items[0]) = networkAssistedGANSSsupportedList; }
};

class UEPositioningCapabilityv770ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningCapabilityv770ext(): Sequence(&theInfo) {}

	void setUeGANSSPositioningCapability(const UEGANSSPositioningCapability& ueGANSSPositioningCapability) { *static_cast<UEGANSSPositioningCapability*>(items[0]) = ueGANSSPositioningCapability; }
};

enum UERadioAccessCapabilityv770extIEsmac_ehsSupportValues {
	true_UERadioAccessCapabilityv770extIEsmac_ehsSupport = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityv770extIEsmac_ehsSupport;

enum UESpecificCapabilityInformationLCRTDDValues {
	nF_UESpecificCapabilityInformationLCRTDD = 0,
	nFMc_TriRx_UniTx_UESpecificCapabilityInformationLCRTDD = 1,
	nFMc_TriRx_TriTx_UESpecificCapabilityInformationLCRTDD = 2,
	nFMc_HexRx_UniTx_UESpecificCapabilityInformationLCRTDD = 3,
	nFMc_HexRx_TriTx_UESpecificCapabilityInformationLCRTDD = 4,
	nFMc_HexRx_HexTx_UESpecificCapabilityInformationLCRTDD = 5,
	spare10_UESpecificCapabilityInformationLCRTDD = 6,
	spare9_UESpecificCapabilityInformationLCRTDD = 7,
	spare8_UESpecificCapabilityInformationLCRTDD = 8,
	spare7_UESpecificCapabilityInformationLCRTDD = 9,
	spare6_UESpecificCapabilityInformationLCRTDD = 10,
	spare5_UESpecificCapabilityInformationLCRTDD = 11,
	spare4_UESpecificCapabilityInformationLCRTDD = 12,
	spare3_UESpecificCapabilityInformationLCRTDD = 13,
	spare2_UESpecificCapabilityInformationLCRTDD = 14,
	spare1_UESpecificCapabilityInformationLCRTDD = 15,
};
typedef Enumerated<CONSTRAINED, 15> UESpecificCapabilityInformationLCRTDD;

class UERadioAccessCapabilityv770extIEs : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv770extIEs(): Sequence(&theInfo) {}

	void setPdcpCapability(const PDCPCapabilityv770ext& pdcpCapability) { *static_cast<PDCPCapabilityv770ext*>(items[0]) = pdcpCapability; }
	void setRlcCapability(const RLCCapabilityv770ext& rlcCapability) { *static_cast<RLCCapabilityv770ext*>(items[1]) = rlcCapability; }
	void setRfCapability(const RFCapabilityv770ext& rfCapability) { *static_cast<RFCapabilityv770ext*>(items[2]) = rfCapability; }
	void setPhysicalChannelCapability(const PhysicalChannelCapabilityv770ext& physicalChannelCapability) { *static_cast<PhysicalChannelCapabilityv770ext*>(items[3]) = physicalChannelCapability; }
	void setMultiModeRATCapability(const MultiModeRATCapabilityv770ext& multiModeRATCapability) { *static_cast<MultiModeRATCapabilityv770ext*>(items[4]) = multiModeRATCapability; }
	void setUePositioningCapability(const UEPositioningCapabilityv770ext& uePositioningCapability) { *static_cast<UEPositioningCapabilityv770ext*>(items[5]) = uePositioningCapability; }
	void setUERadioAccessCapabilityv770extIEsmac_ehsSupport(const UERadioAccessCapabilityv770extIEsmac_ehsSupport& uERadioAccessCapabilityv770extIEsmac_ehsSupport) { *static_cast<UERadioAccessCapabilityv770extIEsmac_ehsSupport*>(items[6]) = uERadioAccessCapabilityv770extIEsmac_ehsSupport; }
	void setUespecificCapabilityInformation(const UESpecificCapabilityInformationLCRTDD& uespecificCapabilityInformation) { *static_cast<UESpecificCapabilityInformationLCRTDD*>(items[7]) = uespecificCapabilityInformation; }
};

enum UERadioAccessCapabilityv790extIEssupportForEDPCCHPowerBoostingValues {
	true_UERadioAccessCapabilityv790extIEssupportForEDPCCHPowerBoosting = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityv790extIEssupportForEDPCCHPowerBoosting;

class UERadioAccessCapabilityv790extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv790extIEs(): Sequence(&theInfo) {}

	void setUERadioAccessCapabilityv790extIEssupportForEDPCCHPowerBoosting(const UERadioAccessCapabilityv790extIEssupportForEDPCCHPowerBoosting& uERadioAccessCapabilityv790extIEssupportForEDPCCHPowerBoosting) { *static_cast<UERadioAccessCapabilityv790extIEssupportForEDPCCHPowerBoosting*>(items[0]) = uERadioAccessCapabilityv790extIEssupportForEDPCCHPowerBoosting; }
};

class UEGANSSPositioningCapabilityv860extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEGANSSPositioningCapabilityv860extIEs(): Sequence(&theInfo) {}

	void setNetworkAssistedGANSSsupportedList(const NetworkAssistedGANSSSupportedListv860ext& networkAssistedGANSSsupportedList) { *static_cast<NetworkAssistedGANSSSupportedListv860ext*>(items[0]) = networkAssistedGANSSsupportedList; }
};

class UEPositioningCapabilityv860ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningCapabilityv860ext(): Sequence(&theInfo) {}

	void setUeGANSSPositioningCapabilityv860ext(const UEGANSSPositioningCapabilityv860extIEs& ueGANSSPositioningCapabilityv860ext) { *static_cast<UEGANSSPositioningCapabilityv860extIEs*>(items[0]) = ueGANSSPositioningCapabilityv860ext; }
};

enum UERadioAccessCapabilityv860extIEssupportOfCommonEDCHValues {
	true_UERadioAccessCapabilityv860extIEssupportOfCommonEDCH = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityv860extIEssupportOfCommonEDCH;

enum UERadioAccessCapabilityv860extIEssupportOfMACiisValues {
	true_UERadioAccessCapabilityv860extIEssupportOfMACiis = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityv860extIEssupportOfMACiis;

enum UERadioAccessCapabilityv860extIEssupportOfSPSOperationValues {
	true_UERadioAccessCapabilityv860extIEssupportOfSPSOperation = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityv860extIEssupportOfSPSOperation;

enum UERadioAccessCapabilityv860extIEssupportOfControlChannelDRXOperationValues {
	true_UERadioAccessCapabilityv860extIEssupportOfControlChannelDRXOperation = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityv860extIEssupportOfControlChannelDRXOperation;

enum UERadioAccessCapabilityv860extIEssupportOfCSGValues {
	true_UERadioAccessCapabilityv860extIEssupportOfCSG = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityv860extIEssupportOfCSG;

class UERadioAccessCapabBandFDD3 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UERadioAccessCapabBandFDD3(): Sequence(&theInfo) {}

	void setRadioFrequencyBandFDD(const RadioFrequencyBandFDD& radioFrequencyBandFDD) { *static_cast<RadioFrequencyBandFDD*>(items[0]) = radioFrequencyBandFDD; }
	void setRadioFrequencyBandFDD2(const RadioFrequencyBandFDD2& radioFrequencyBandFDD2) { *static_cast<RadioFrequencyBandFDD2*>(items[1]) = radioFrequencyBandFDD2; }
	void setMeasurementCapability3(const MeasurementCapabilityExt3& measurementCapability3) { *static_cast<MeasurementCapabilityExt3*>(items[2]) = measurementCapability3; }
};

typedef SequenceOf<UERadioAccessCapabBandFDD3, CONSTRAINED, 1, maxFreqBandsFDD> UERadioAccessCapabBandFDDList3;

class UERadioAccessCapabilityv860extIEs : public Sequence {
private:
	static const void *itemsInfo[12];
	static bool itemsPres[12];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv860extIEs(): Sequence(&theInfo) {}

	void setRfCapability(const RFCapabilityv860ext& rfCapability) { *static_cast<RFCapabilityv860ext*>(items[0]) = rfCapability; }
	void setPhysicalChannelCapability(const PhysicalChannelCapabilityv860ext& physicalChannelCapability) { *static_cast<PhysicalChannelCapabilityv860ext*>(items[1]) = physicalChannelCapability; }
	void setMultiModeRATCapability(const MultiModeRATCapabilityv860ext& multiModeRATCapability) { *static_cast<MultiModeRATCapabilityv860ext*>(items[2]) = multiModeRATCapability; }
	void setUePositioningCapability(const UEPositioningCapabilityv860ext& uePositioningCapability) { *static_cast<UEPositioningCapabilityv860ext*>(items[3]) = uePositioningCapability; }
	void setMeasurementCapability(const MeasurementCapabilityv860ext& measurementCapability) { *static_cast<MeasurementCapabilityv860ext*>(items[4]) = measurementCapability; }
	void setMeasurementCapabilityTDD(const MeasurementCapabilityTDD& measurementCapabilityTDD) { *static_cast<MeasurementCapabilityTDD*>(items[5]) = measurementCapabilityTDD; }
	void setUERadioAccessCapabilityv860extIEssupportOfCommonEDCH(const UERadioAccessCapabilityv860extIEssupportOfCommonEDCH& uERadioAccessCapabilityv860extIEssupportOfCommonEDCH) { *static_cast<UERadioAccessCapabilityv860extIEssupportOfCommonEDCH*>(items[6]) = uERadioAccessCapabilityv860extIEssupportOfCommonEDCH; }
	void setUERadioAccessCapabilityv860extIEssupportOfMACiis(const UERadioAccessCapabilityv860extIEssupportOfMACiis& uERadioAccessCapabilityv860extIEssupportOfMACiis) { *static_cast<UERadioAccessCapabilityv860extIEssupportOfMACiis*>(items[7]) = uERadioAccessCapabilityv860extIEssupportOfMACiis; }
	void setUERadioAccessCapabilityv860extIEssupportOfSPSOperation(const UERadioAccessCapabilityv860extIEssupportOfSPSOperation& uERadioAccessCapabilityv860extIEssupportOfSPSOperation) { *static_cast<UERadioAccessCapabilityv860extIEssupportOfSPSOperation*>(items[8]) = uERadioAccessCapabilityv860extIEssupportOfSPSOperation; }
	void setUERadioAccessCapabilityv860extIEssupportOfControlChannelDRXOperation(const UERadioAccessCapabilityv860extIEssupportOfControlChannelDRXOperation& uERadioAccessCapabilityv860extIEssupportOfControlChannelDRXOperation) { *static_cast<UERadioAccessCapabilityv860extIEssupportOfControlChannelDRXOperation*>(items[9]) = uERadioAccessCapabilityv860extIEssupportOfControlChannelDRXOperation; }
	void setUERadioAccessCapabilityv860extIEssupportOfCSG(const UERadioAccessCapabilityv860extIEssupportOfCSG& uERadioAccessCapabilityv860extIEssupportOfCSG) { *static_cast<UERadioAccessCapabilityv860extIEssupportOfCSG*>(items[10]) = uERadioAccessCapabilityv860extIEssupportOfCSG; }
	void setUeRadioAccessCapabBandFDDList3(const UERadioAccessCapabBandFDDList3& ueRadioAccessCapabBandFDDList3) { *static_cast<UERadioAccessCapabBandFDDList3*>(items[11]) = ueRadioAccessCapabBandFDDList3; }
};

typedef OctetStringBase EUTRARadioAccessCapabilityUeEUTRACapability;

class EUTRARadioAccessCapability : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	EUTRARadioAccessCapability(): Sequence(&theInfo) {}

	void setEUTRARadioAccessCapabilityUeEUTRACapability(const EUTRARadioAccessCapabilityUeEUTRACapability& eUTRARadioAccessCapabilityUeEUTRACapability) { *static_cast<EUTRARadioAccessCapabilityUeEUTRACapability*>(items[0]) = eUTRARadioAccessCapabilityUeEUTRACapability; }
};

class InterRATUERadioAccessCapabilityv860ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterRATUERadioAccessCapabilityv860ext(): Sequence(&theInfo) {}

	void setEutraRadioAccessCapability(const EUTRARadioAccessCapability& eutraRadioAccessCapability) { *static_cast<EUTRARadioAccessCapability*>(items[0]) = eutraRadioAccessCapability; }
};

enum UERadioAccessCapabilityv880extIEssupportForPriorityReselectionInUTRANValues {
	true_UERadioAccessCapabilityv880extIEssupportForPriorityReselectionInUTRAN = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityv880extIEssupportForPriorityReselectionInUTRAN;

class UERadioAccessCapabilityv880extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv880extIEs(): Sequence(&theInfo) {}

	void setUERadioAccessCapabilityv880extIEssupportForPriorityReselectionInUTRAN(const UERadioAccessCapabilityv880extIEssupportForPriorityReselectionInUTRAN& uERadioAccessCapabilityv880extIEssupportForPriorityReselectionInUTRAN) { *static_cast<UERadioAccessCapabilityv880extIEssupportForPriorityReselectionInUTRAN*>(items[0]) = uERadioAccessCapabilityv880extIEssupportForPriorityReselectionInUTRAN; }
};

enum UERadioAccessCapabilityv890extIEssupportCellSpecificTxDiversityinDC_OperationValues {
	true_UERadioAccessCapabilityv890extIEssupportCellSpecificTxDiversityinDC_Operation = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityv890extIEssupportCellSpecificTxDiversityinDC_Operation;

class UERadioAccessCapabilityv890extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv890extIEs(): Sequence(&theInfo) {}

	void setUERadioAccessCapabilityv890extIEssupportCellSpecificTxDiversityinDC_Operation(const UERadioAccessCapabilityv890extIEssupportCellSpecificTxDiversityinDC_Operation& uERadioAccessCapabilityv890extIEssupportCellSpecificTxDiversityinDC_Operation) { *static_cast<UERadioAccessCapabilityv890extIEssupportCellSpecificTxDiversityinDC_Operation*>(items[0]) = uERadioAccessCapabilityv890extIEssupportCellSpecificTxDiversityinDC_Operation; }
};

typedef SequenceOf<BandComb, CONSTRAINED, 1, 16> UERadioAccessCapabBandCombList;

enum UERadioAccessCapabilityv920extIEssupportOfenhancedTS0Values {
	true_UERadioAccessCapabilityv920extIEssupportOfenhancedTS0 = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityv920extIEssupportOfenhancedTS0;

class UERadioAccessCapabilityv920extIEs : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv920extIEs(): Sequence(&theInfo) {}

	void setUeRadioAccessCapabBandCombList(const UERadioAccessCapabBandCombList& ueRadioAccessCapabBandCombList) { *static_cast<UERadioAccessCapabBandCombList*>(items[0]) = ueRadioAccessCapabBandCombList; }
	void setPhysicalChannelCapability(const PhysicalChannelCapabilityv920ext& physicalChannelCapability) { *static_cast<PhysicalChannelCapabilityv920ext*>(items[1]) = physicalChannelCapability; }
	void setRlcCapability(const RLCCapabilityv920ext& rlcCapability) { *static_cast<RLCCapabilityv920ext*>(items[2]) = rlcCapability; }
	void setUERadioAccessCapabilityv920extIEssupportOfenhancedTS0(const UERadioAccessCapabilityv920extIEssupportOfenhancedTS0& uERadioAccessCapabilityv920extIEssupportOfenhancedTS0) { *static_cast<UERadioAccessCapabilityv920extIEssupportOfenhancedTS0*>(items[3]) = uERadioAccessCapabilityv920extIEssupportOfenhancedTS0; }
	void setMeasurementCapability(const MeasurementCapabilityv920ext& measurementCapability) { *static_cast<MeasurementCapabilityv920ext*>(items[4]) = measurementCapability; }
	void setCsgProximityIndicationCapability(const CSGProximityIndicationCapability& csgProximityIndicationCapability) { *static_cast<CSGProximityIndicationCapability*>(items[5]) = csgProximityIndicationCapability; }
	void setNeighCellSIAcquisitionCapability(const NeighCellSIAcquisitionCapability& neighCellSIAcquisitionCapability) { *static_cast<NeighCellSIAcquisitionCapability*>(items[6]) = neighCellSIAcquisitionCapability; }
};

enum UERadioAccessCapabilityv970extIEsue_ExtendedMeasurementSupportValues {
	true_UERadioAccessCapabilityv970extIEsue_ExtendedMeasurementSupport = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityv970extIEsue_ExtendedMeasurementSupport;

class UERadioAccessCapabilityv970extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv970extIEs(): Sequence(&theInfo) {}

	void setUERadioAccessCapabilityv970extIEsue_ExtendedMeasurementSupport(const UERadioAccessCapabilityv970extIEsue_ExtendedMeasurementSupport& uERadioAccessCapabilityv970extIEsue_ExtendedMeasurementSupport) { *static_cast<UERadioAccessCapabilityv970extIEsue_ExtendedMeasurementSupport*>(items[0]) = uERadioAccessCapabilityv970extIEsue_ExtendedMeasurementSupport; }
};

class UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensionsV970NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensionsV970NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensionsV970NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensionsV970NonCriticalExtensions(): Sequence(&theInfo) {}

	void setUeRadioAccessCapabilityv970ext(const UERadioAccessCapabilityv970extIEs& ueRadioAccessCapabilityv970ext) { *static_cast<UERadioAccessCapabilityv970extIEs*>(items[0]) = ueRadioAccessCapabilityv970ext; }
	void setUECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensionsV970NonCriticalExtensionsNonCriticalExtensions(const UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensionsV970NonCriticalExtensionsNonCriticalExtensions& uECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensionsV970NonCriticalExtensionsNonCriticalExtensions) { *static_cast<UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensionsV970NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = uECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensionsV970NonCriticalExtensionsNonCriticalExtensions; }
};

class UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensions(): Sequence(&theInfo) {}

	void setUeRadioAccessCapabilityv920ext(const UERadioAccessCapabilityv920extIEs& ueRadioAccessCapabilityv920ext) { *static_cast<UERadioAccessCapabilityv920extIEs*>(items[0]) = ueRadioAccessCapabilityv920ext; }
	void setUECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensionsV970NonCriticalExtensions(const UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensionsV970NonCriticalExtensions& uECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensionsV970NonCriticalExtensions) { *static_cast<UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensionsV970NonCriticalExtensions*>(items[1]) = uECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensionsV970NonCriticalExtensions; }
};

class UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensions(): Sequence(&theInfo) {}

	void setUeRadioAccessCapabilityv890ext(const UERadioAccessCapabilityv890extIEs& ueRadioAccessCapabilityv890ext) { *static_cast<UERadioAccessCapabilityv890extIEs*>(items[0]) = ueRadioAccessCapabilityv890ext; }
	void setUECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensions(const UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensions& uECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensions) { *static_cast<UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensions*>(items[1]) = uECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensionsV920NonCriticalExtensions; }
};

class UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensions(): Sequence(&theInfo) {}

	void setUeRadioAccessCapabilityv880ext(const UERadioAccessCapabilityv880extIEs& ueRadioAccessCapabilityv880ext) { *static_cast<UERadioAccessCapabilityv880extIEs*>(items[0]) = ueRadioAccessCapabilityv880ext; }
	void setUECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensions(const UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensions& uECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensions) { *static_cast<UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensions*>(items[1]) = uECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensionsV890NonCriticalExtensions; }
};

class UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensions(): Sequence(&theInfo) {}

	void setUeRadioAccessCapabilityv860ext(const UERadioAccessCapabilityv860extIEs& ueRadioAccessCapabilityv860ext) { *static_cast<UERadioAccessCapabilityv860extIEs*>(items[0]) = ueRadioAccessCapabilityv860ext; }
	void setUeRATSpecificCapabilityv860ext(const InterRATUERadioAccessCapabilityv860ext& ueRATSpecificCapabilityv860ext) { *static_cast<InterRATUERadioAccessCapabilityv860ext*>(items[1]) = ueRATSpecificCapabilityv860ext; }
	void setUECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensions(const UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensions& uECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensions) { *static_cast<UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensions*>(items[2]) = uECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensionsV880NonCriticalExtensions; }
};

class UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensions(): Sequence(&theInfo) {}

	void setUeRadioAccessCapabilityv790ext(const UERadioAccessCapabilityv790extIEs& ueRadioAccessCapabilityv790ext) { *static_cast<UERadioAccessCapabilityv790extIEs*>(items[0]) = ueRadioAccessCapabilityv790ext; }
	void setUECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensions(const UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensions& uECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensions) { *static_cast<UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensions*>(items[1]) = uECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensionsV860NonCriticalExtensions; }
};

class UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensions(): Sequence(&theInfo) {}

	void setUeRadioAccessCapabilityv770ext(const UERadioAccessCapabilityv770extIEs& ueRadioAccessCapabilityv770ext) { *static_cast<UERadioAccessCapabilityv770extIEs*>(items[0]) = ueRadioAccessCapabilityv770ext; }
	void setUECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensions(const UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensions& uECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensions) { *static_cast<UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensions*>(items[1]) = uECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensionsV790NonCriticalExtensions; }
};

class UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setUeRadioAccessCapabilityv6e0ext(const UERadioAccessCapabilityv6e0extIEs& ueRadioAccessCapabilityv6e0ext) { *static_cast<UERadioAccessCapabilityv6e0extIEs*>(items[0]) = ueRadioAccessCapabilityv6e0ext; }
	void setUECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensions(const UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensions& uECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensions) { *static_cast<UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensions*>(items[1]) = uECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensionsV770NonCriticalExtensions; }
};

class UECapabilityContainerIEsV6b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UECapabilityContainerIEsV6b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setUeRadioAccessCapabilityv6b0ext(const UERadioAccessCapabilityv6b0extIEs& ueRadioAccessCapabilityv6b0ext) { *static_cast<UERadioAccessCapabilityv6b0extIEs*>(items[0]) = ueRadioAccessCapabilityv6b0ext; }
	void setUECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensions(const UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensions& uECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensions) { *static_cast<UECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensions*>(items[1]) = uECapabilityContainerIEsV6b0NonCriticalExtensionsV6e0NonCriticalExtensions; }
};

class UECapabilityContainerIEs : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UECapabilityContainerIEs(): Sequence(&theInfo) {}

	void setUeRadioAccessCapabilityv690ext(const UERadioAccessCapabilityv690ext& ueRadioAccessCapabilityv690ext) { *static_cast<UERadioAccessCapabilityv690ext*>(items[0]) = ueRadioAccessCapabilityv690ext; }
	void setUeRATSpecificCapabilityv690ext(const InterRATUERadioAccessCapabilityv690ext& ueRATSpecificCapabilityv690ext) { *static_cast<InterRATUERadioAccessCapabilityv690ext*>(items[1]) = ueRATSpecificCapabilityv690ext; }
	void setUECapabilityContainerIEsV6b0NonCriticalExtensions(const UECapabilityContainerIEsV6b0NonCriticalExtensions& uECapabilityContainerIEsV6b0NonCriticalExtensions) { *static_cast<UECapabilityContainerIEsV6b0NonCriticalExtensions*>(items[2]) = uECapabilityContainerIEsV6b0NonCriticalExtensions; }
};

class UEConnTimersAndConstants : public Sequence {
private:
	static const void *itemsInfo[22];
	static bool itemsPres[22];
public:
	static const Info theInfo;
	UEConnTimersAndConstants(): Sequence(&theInfo) {}

	void setT301(const T301& t301) { *static_cast<T301*>(items[0]) = t301; }
	void setN301(const N301& n301) { *static_cast<N301*>(items[1]) = n301; }
	void setT302(const T302& t302) { *static_cast<T302*>(items[2]) = t302; }
	void setN302(const N302& n302) { *static_cast<N302*>(items[3]) = n302; }
	void setT304(const T304& t304) { *static_cast<T304*>(items[4]) = t304; }
	void setN304(const N304& n304) { *static_cast<N304*>(items[5]) = n304; }
	void setT305(const T305& t305) { *static_cast<T305*>(items[6]) = t305; }
	void setT307(const T307& t307) { *static_cast<T307*>(items[7]) = t307; }
	void setT308(const T308& t308) { *static_cast<T308*>(items[8]) = t308; }
	void setT309(const T309& t309) { *static_cast<T309*>(items[9]) = t309; }
	void setT310(const T310& t310) { *static_cast<T310*>(items[10]) = t310; }
	void setN310(const N310& n310) { *static_cast<N310*>(items[11]) = n310; }
	void setT311(const T311& t311) { *static_cast<T311*>(items[12]) = t311; }
	void setT312(const T312& t312) { *static_cast<T312*>(items[13]) = t312; }
	void setN312(const N312& n312) { *static_cast<N312*>(items[14]) = n312; }
	void setT313(const T313& t313) { *static_cast<T313*>(items[15]) = t313; }
	void setN313(const N313& n313) { *static_cast<N313*>(items[16]) = n313; }
	void setT314(const T314& t314) { *static_cast<T314*>(items[17]) = t314; }
	void setT315(const T315& t315) { *static_cast<T315*>(items[18]) = t315; }
	void setN315(const N315& n315) { *static_cast<N315*>(items[19]) = n315; }
	void setT316(const T316& t316) { *static_cast<T316*>(items[20]) = t316; }
	void setT317(const T317& t317) { *static_cast<T317*>(items[21]) = t317; }
};

class UEConnTimersAndConstantsv3a0ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEConnTimersAndConstantsv3a0ext(): Sequence(&theInfo) {}

	void setN312(const N312ext& n312) { *static_cast<N312ext*>(items[0]) = n312; }
	void setN315(const N315ext& n315) { *static_cast<N315ext*>(items[1]) = n315; }
};

class UEConnTimersAndConstantsr5 : public Sequence {
private:
	static const void *itemsInfo[22];
	static bool itemsPres[22];
public:
	static const Info theInfo;
	UEConnTimersAndConstantsr5(): Sequence(&theInfo) {}

	void setT301(const T301& t301) { *static_cast<T301*>(items[0]) = t301; }
	void setN301(const N301& n301) { *static_cast<N301*>(items[1]) = n301; }
	void setT302(const T302& t302) { *static_cast<T302*>(items[2]) = t302; }
	void setN302(const N302& n302) { *static_cast<N302*>(items[3]) = n302; }
	void setT304(const T304& t304) { *static_cast<T304*>(items[4]) = t304; }
	void setN304(const N304& n304) { *static_cast<N304*>(items[5]) = n304; }
	void setT305(const T305& t305) { *static_cast<T305*>(items[6]) = t305; }
	void setT307(const T307& t307) { *static_cast<T307*>(items[7]) = t307; }
	void setT308(const T308& t308) { *static_cast<T308*>(items[8]) = t308; }
	void setT309(const T309& t309) { *static_cast<T309*>(items[9]) = t309; }
	void setT310(const T310& t310) { *static_cast<T310*>(items[10]) = t310; }
	void setN310(const N310& n310) { *static_cast<N310*>(items[11]) = n310; }
	void setT311(const T311& t311) { *static_cast<T311*>(items[12]) = t311; }
	void setT312(const T312& t312) { *static_cast<T312*>(items[13]) = t312; }
	void setN312(const N312r5& n312) { *static_cast<N312r5*>(items[14]) = n312; }
	void setT313(const T313& t313) { *static_cast<T313*>(items[15]) = t313; }
	void setN313(const N313& n313) { *static_cast<N313*>(items[16]) = n313; }
	void setT314(const T314& t314) { *static_cast<T314*>(items[17]) = t314; }
	void setT315(const T315& t315) { *static_cast<T315*>(items[18]) = t315; }
	void setN315(const N315r5& n315) { *static_cast<N315r5*>(items[19]) = n315; }
	void setT316(const T316& t316) { *static_cast<T316*>(items[20]) = t316; }
	void setT317(const T317& t317) { *static_cast<T317*>(items[21]) = t317; }
};

class UEConnTimersAndConstantsv860ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEConnTimersAndConstantsv860ext(): Sequence(&theInfo) {}

	void setT323(const T323& t323) { *static_cast<T323*>(items[0]) = t323; }
};

class UEIdleTimersAndConstants : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UEIdleTimersAndConstants(): Sequence(&theInfo) {}

	void setT300(const T300& t300) { *static_cast<T300*>(items[0]) = t300; }
	void setN300(const N300& n300) { *static_cast<N300*>(items[1]) = n300; }
	void setT312(const T312& t312) { *static_cast<T312*>(items[2]) = t312; }
	void setN312(const N312& n312) { *static_cast<N312*>(items[3]) = n312; }
};

class UEHSPAIdentitiesr6 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UEHSPAIdentitiesr6(): Sequence(&theInfo) {}

	void setNewHRNTI(const HRNTI& newHRNTI) { *static_cast<HRNTI*>(items[0]) = newHRNTI; }
	void setNewPrimaryERNTI(const ERNTI& newPrimaryERNTI) { *static_cast<ERNTI*>(items[1]) = newPrimaryERNTI; }
	void setNewSecondaryERNTI(const ERNTI& newSecondaryERNTI) { *static_cast<ERNTI*>(items[2]) = newSecondaryERNTI; }
};

class UEIdleTimersAndConstantsv3a0ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEIdleTimersAndConstantsv3a0ext(): Sequence(&theInfo) {}

	void setN312(const N312ext& n312) { *static_cast<N312ext*>(items[0]) = n312; }
};

class UEMultiModeRATCapability : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEMultiModeRATCapability(): Sequence(&theInfo) {}

	void setMultiRATCapabilityList(const MultiRATCapability& multiRATCapabilityList) { *static_cast<MultiRATCapability*>(items[0]) = multiRATCapabilityList; }
	void setMultiModeCapability(const MultiModeCapability& multiModeCapability) { *static_cast<MultiModeCapability*>(items[1]) = multiModeCapability; }
};

enum UEPowerClassExtValues {
	class1_UEPowerClassExt = 0,
	class2_UEPowerClassExt = 1,
	class3_UEPowerClassExt = 2,
	class4_UEPowerClassExt = 3,
	spare4_UEPowerClassExt = 4,
	spare3_UEPowerClassExt = 5,
	spare2_UEPowerClassExt = 6,
	spare1_UEPowerClassExt = 7,
};
typedef Enumerated<CONSTRAINED, 7> UEPowerClassExt;

typedef Boolean UEPositioningCapabilityStandaloneLocMethodsSupported;

typedef Boolean UEPositioningCapabilityUeBasedOTDOASupported;

typedef Boolean UEPositioningCapabilitySupportForUEGPSTimingOfCellFrames;

typedef Boolean UEPositioningCapabilitySupportForIPDL;

class UEPositioningCapability : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	UEPositioningCapability(): Sequence(&theInfo) {}

	void setUEPositioningCapabilityStandaloneLocMethodsSupported(const UEPositioningCapabilityStandaloneLocMethodsSupported& uEPositioningCapabilityStandaloneLocMethodsSupported) { *static_cast<UEPositioningCapabilityStandaloneLocMethodsSupported*>(items[0]) = uEPositioningCapabilityStandaloneLocMethodsSupported; }
	void setUEPositioningCapabilityUeBasedOTDOASupported(const UEPositioningCapabilityUeBasedOTDOASupported& uEPositioningCapabilityUeBasedOTDOASupported) { *static_cast<UEPositioningCapabilityUeBasedOTDOASupported*>(items[1]) = uEPositioningCapabilityUeBasedOTDOASupported; }
	void setNetworkAssistedGPSSupported(const NetworkAssistedGPSSupported& networkAssistedGPSSupported) { *static_cast<NetworkAssistedGPSSupported*>(items[2]) = networkAssistedGPSSupported; }
	void setUEPositioningCapabilitySupportForUEGPSTimingOfCellFrames(const UEPositioningCapabilitySupportForUEGPSTimingOfCellFrames& uEPositioningCapabilitySupportForUEGPSTimingOfCellFrames) { *static_cast<UEPositioningCapabilitySupportForUEGPSTimingOfCellFrames*>(items[3]) = uEPositioningCapabilitySupportForUEGPSTimingOfCellFrames; }
	void setUEPositioningCapabilitySupportForIPDL(const UEPositioningCapabilitySupportForIPDL& uEPositioningCapabilitySupportForIPDL) { *static_cast<UEPositioningCapabilitySupportForIPDL*>(items[4]) = uEPositioningCapabilitySupportForIPDL; }
};

class UERadioAccessCapability : public Sequence {
private:
	static const void *itemsInfo[9];
	static bool itemsPres[9];
public:
	static const Info theInfo;
	UERadioAccessCapability(): Sequence(&theInfo) {}

	void setPdcpCapability(const PDCPCapability& pdcpCapability) { *static_cast<PDCPCapability*>(items[0]) = pdcpCapability; }
	void setRlcCapability(const RLCCapability& rlcCapability) { *static_cast<RLCCapability*>(items[1]) = rlcCapability; }
	void setTransportChannelCapability(const TransportChannelCapability& transportChannelCapability) { *static_cast<TransportChannelCapability*>(items[2]) = transportChannelCapability; }
	void setRfCapability(const RFCapability& rfCapability) { *static_cast<RFCapability*>(items[3]) = rfCapability; }
	void setPhysicalChannelCapability(const PhysicalChannelCapability& physicalChannelCapability) { *static_cast<PhysicalChannelCapability*>(items[4]) = physicalChannelCapability; }
	void setUeMultiModeRATCapability(const UEMultiModeRATCapability& ueMultiModeRATCapability) { *static_cast<UEMultiModeRATCapability*>(items[5]) = ueMultiModeRATCapability; }
	void setSecurityCapability(const SecurityCapability& securityCapability) { *static_cast<SecurityCapability*>(items[6]) = securityCapability; }
	void setUepositioningCapability(const UEPositioningCapability& uepositioningCapability) { *static_cast<UEPositioningCapability*>(items[7]) = uepositioningCapability; }
	void setMeasurementCapability(const MeasurementCapability& measurementCapability) { *static_cast<MeasurementCapability*>(items[8]) = measurementCapability; }
};

class UERadioAccessCapabBandFDDFddRFCapability : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UERadioAccessCapabBandFDDFddRFCapability(): Sequence(&theInfo) {}

	void setUePowerClass(const UEPowerClassExt& uePowerClass) { *static_cast<UEPowerClassExt*>(items[0]) = uePowerClass; }
	void setTxRxFrequencySeparation(const TxRxFrequencySeparation& txRxFrequencySeparation) { *static_cast<TxRxFrequencySeparation*>(items[1]) = txRxFrequencySeparation; }
};

class UERadioAccessCapabBandFDD : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UERadioAccessCapabBandFDD(): Sequence(&theInfo) {}

	void setRadioFrequencyBandFDD(const RadioFrequencyBandFDD& radioFrequencyBandFDD) { *static_cast<RadioFrequencyBandFDD*>(items[0]) = radioFrequencyBandFDD; }
	void setUERadioAccessCapabBandFDDFddRFCapability(const UERadioAccessCapabBandFDDFddRFCapability& uERadioAccessCapabBandFDDFddRFCapability) { *static_cast<UERadioAccessCapabBandFDDFddRFCapability*>(items[1]) = uERadioAccessCapabBandFDDFddRFCapability; }
	void setMeasurementCapability(const MeasurementCapabilityExt& measurementCapability) { *static_cast<MeasurementCapabilityExt*>(items[2]) = measurementCapability; }
};

typedef SequenceOf<UERadioAccessCapabBandFDD, CONSTRAINED, 1, maxFreqBandsFDD> UERadioAccessCapabBandFDDList;

class UERadioAccessCapabilityv370ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv370ext(): Sequence(&theInfo) {}

	void setUeRadioAccessCapabBandFDDList(const UERadioAccessCapabBandFDDList& ueRadioAccessCapabBandFDDList) { *static_cast<UERadioAccessCapabBandFDDList*>(items[0]) = ueRadioAccessCapabBandFDDList; }
};

class UERadioAccessCapabilityInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UERadioAccessCapabilityInfo(): Sequence(&theInfo) {}

	void setUeRadioAccessCapability(const UERadioAccessCapability& ueRadioAccessCapability) { *static_cast<UERadioAccessCapability*>(items[0]) = ueRadioAccessCapability; }
	void setUeRadioAccessCapabilityv370ext(const UERadioAccessCapabilityv370ext& ueRadioAccessCapabilityv370ext) { *static_cast<UERadioAccessCapabilityv370ext*>(items[1]) = ueRadioAccessCapabilityv370ext; }
};

typedef Boolean UEPositioningCapabilityExtv380RxtxTimeDifferenceType2Capable;

class UEPositioningCapabilityExtv380 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningCapabilityExtv380(): Sequence(&theInfo) {}

	void setUEPositioningCapabilityExtv380RxtxTimeDifferenceType2Capable(const UEPositioningCapabilityExtv380RxtxTimeDifferenceType2Capable& uEPositioningCapabilityExtv380RxtxTimeDifferenceType2Capable) { *static_cast<UEPositioningCapabilityExtv380RxtxTimeDifferenceType2Capable*>(items[0]) = uEPositioningCapabilityExtv380RxtxTimeDifferenceType2Capable; }
};

class UERadioAccessCapabilityv380ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv380ext(): Sequence(&theInfo) {}

	void setUePositioningCapabilityExtv380(const UEPositioningCapabilityExtv380& uePositioningCapabilityExtv380) { *static_cast<UEPositioningCapabilityExtv380*>(items[0]) = uePositioningCapabilityExtv380; }
};

enum UEPositioningCapabilityExtv3a0validity_CellPCH_UraPCHValues {
	true_UEPositioningCapabilityExtv3a0validity_CellPCH_UraPCH = 0,
};
typedef Enumerated<CONSTRAINED, 0> UEPositioningCapabilityExtv3a0validity_CellPCH_UraPCH;

class UEPositioningCapabilityExtv3a0 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningCapabilityExtv3a0(): Sequence(&theInfo) {}

	void setUEPositioningCapabilityExtv3a0validity_CellPCH_UraPCH(const UEPositioningCapabilityExtv3a0validity_CellPCH_UraPCH& uEPositioningCapabilityExtv3a0validity_CellPCH_UraPCH) { *static_cast<UEPositioningCapabilityExtv3a0validity_CellPCH_UraPCH*>(items[0]) = uEPositioningCapabilityExtv3a0validity_CellPCH_UraPCH; }
};

class UERadioAccessCapabilityv3a0ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv3a0ext(): Sequence(&theInfo) {}

	void setUePositioningCapabilityExtv3a0(const UEPositioningCapabilityExtv3a0& uePositioningCapabilityExtv3a0) { *static_cast<UEPositioningCapabilityExtv3a0*>(items[0]) = uePositioningCapabilityExtv3a0; }
};

enum UEPositioningCapabilityExtv3g0sfn_sfnType2CapabilityValues {
	true_UEPositioningCapabilityExtv3g0sfn_sfnType2Capability = 0,
};
typedef Enumerated<CONSTRAINED, 0> UEPositioningCapabilityExtv3g0sfn_sfnType2Capability;

class UEPositioningCapabilityExtv3g0 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningCapabilityExtv3g0(): Sequence(&theInfo) {}

	void setUEPositioningCapabilityExtv3g0sfn_sfnType2Capability(const UEPositioningCapabilityExtv3g0sfn_sfnType2Capability& uEPositioningCapabilityExtv3g0sfn_sfnType2Capability) { *static_cast<UEPositioningCapabilityExtv3g0sfn_sfnType2Capability*>(items[0]) = uEPositioningCapabilityExtv3g0sfn_sfnType2Capability; }
};

class UERadioAccessCapabilityv3g0ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv3g0ext(): Sequence(&theInfo) {}

	void setUePositioningCapabilityExtv3g0(const UEPositioningCapabilityExtv3g0& uePositioningCapabilityExtv3g0) { *static_cast<UEPositioningCapabilityExtv3g0*>(items[0]) = uePositioningCapabilityExtv3g0; }
};

class UERadioAccessCapabBandFDD2FddRFCapability : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UERadioAccessCapabBandFDD2FddRFCapability(): Sequence(&theInfo) {}

	void setUePowerClass(const UEPowerClassExt& uePowerClass) { *static_cast<UEPowerClassExt*>(items[0]) = uePowerClass; }
	void setTxRxFrequencySeparation(const TxRxFrequencySeparation& txRxFrequencySeparation) { *static_cast<TxRxFrequencySeparation*>(items[1]) = txRxFrequencySeparation; }
};

class UERadioAccessCapabBandFDD2 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UERadioAccessCapabBandFDD2(): Sequence(&theInfo) {}

	void setRadioFrequencyBandFDD2(const RadioFrequencyBandFDD2& radioFrequencyBandFDD2) { *static_cast<RadioFrequencyBandFDD2*>(items[0]) = radioFrequencyBandFDD2; }
	void setUERadioAccessCapabBandFDD2FddRFCapability(const UERadioAccessCapabBandFDD2FddRFCapability& uERadioAccessCapabBandFDD2FddRFCapability) { *static_cast<UERadioAccessCapabBandFDD2FddRFCapability*>(items[1]) = uERadioAccessCapabBandFDD2FddRFCapability; }
	void setMeasurementCapability2(const MeasurementCapabilityExt2& measurementCapability2) { *static_cast<MeasurementCapabilityExt2*>(items[2]) = measurementCapability2; }
};

typedef SequenceOf<UERadioAccessCapabBandFDD2, CONSTRAINED, 1, maxFreqBandsFDD> UERadioAccessCapabBandFDDList2;

class UERadioAccessCapabBandFDDext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UERadioAccessCapabBandFDDext(): Sequence(&theInfo) {}

	void setRadioFrequencyBandFDD(const RadioFrequencyBandFDD& radioFrequencyBandFDD) { *static_cast<RadioFrequencyBandFDD*>(items[0]) = radioFrequencyBandFDD; }
	void setCompressedModeMeasCapabFDDListext(const CompressedModeMeasCapabFDDListext& compressedModeMeasCapabFDDListext) { *static_cast<CompressedModeMeasCapabFDDListext*>(items[1]) = compressedModeMeasCapabFDDListext; }
};

typedef SequenceOf<UERadioAccessCapabBandFDDext, CONSTRAINED, 1, maxFreqBandsFDD> UERadioAccessCapabBandFDDListext;

class UERadioAccessCapabilityv650ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv650ext(): Sequence(&theInfo) {}

	void setUeRadioAccessCapabBandFDDList2(const UERadioAccessCapabBandFDDList2& ueRadioAccessCapabBandFDDList2) { *static_cast<UERadioAccessCapabBandFDDList2*>(items[0]) = ueRadioAccessCapabBandFDDList2; }
	void setUeRadioAccessCapabBandFDDListext(const UERadioAccessCapabBandFDDListext& ueRadioAccessCapabBandFDDListext) { *static_cast<UERadioAccessCapabBandFDDListext*>(items[1]) = ueRadioAccessCapabBandFDDListext; }
};

enum UERadioAccessCapabilityv7e0extsupportForTwoDRXSchemesInPCHValues {
	true_UERadioAccessCapabilityv7e0extsupportForTwoDRXSchemesInPCH = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityv7e0extsupportForTwoDRXSchemesInPCH;

enum UERadioAccessCapabilityv7e0extsupportEDPDCHPowerInterpolationValues {
	true_UERadioAccessCapabilityv7e0extsupportEDPDCHPowerInterpolation = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityv7e0extsupportEDPDCHPowerInterpolation;

class UERadioAccessCapabilityv7e0ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv7e0ext(): Sequence(&theInfo) {}

	void setUERadioAccessCapabilityv7e0extsupportForTwoDRXSchemesInPCH(const UERadioAccessCapabilityv7e0extsupportForTwoDRXSchemesInPCH& uERadioAccessCapabilityv7e0extsupportForTwoDRXSchemesInPCH) { *static_cast<UERadioAccessCapabilityv7e0extsupportForTwoDRXSchemesInPCH*>(items[0]) = uERadioAccessCapabilityv7e0extsupportForTwoDRXSchemesInPCH; }
	void setUERadioAccessCapabilityv7e0extsupportEDPDCHPowerInterpolation(const UERadioAccessCapabilityv7e0extsupportEDPDCHPowerInterpolation& uERadioAccessCapabilityv7e0extsupportEDPDCHPowerInterpolation) { *static_cast<UERadioAccessCapabilityv7e0extsupportEDPDCHPowerInterpolation*>(items[1]) = uERadioAccessCapabilityv7e0extsupportEDPDCHPowerInterpolation; }
};

enum UERadioAccessCapabilityv7f0extsupportofTxDivOnNonMIMOChannelValues {
	true_UERadioAccessCapabilityv7f0extsupportofTxDivOnNonMIMOChannel = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityv7f0extsupportofTxDivOnNonMIMOChannel;

typedef Integer<CONSTRAINED, 1, 6> UERadioAccessCapabilityCompTDD128v7f0extTddedchPhysicalLayerCategory;

enum UERadioAccessCapabilityCompTDD128v7f0extsupportForCSVoiceoverHSPAValues {
	true_UERadioAccessCapabilityCompTDD128v7f0extsupportForCSVoiceoverHSPA = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityCompTDD128v7f0extsupportForCSVoiceoverHSPA;

class UERadioAccessCapabilityCompTDD128v7f0ext : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	UERadioAccessCapabilityCompTDD128v7f0ext(): Sequence(&theInfo) {}

	void setHSDSCHphysicallayercategory(const HSDSCHphysicallayercategory& hSDSCHphysicallayercategory) { *static_cast<HSDSCHphysicallayercategory*>(items[0]) = hSDSCHphysicallayercategory; }
	void setMultiCarrierphysicallayercategory(const MultiCarrierHSDSCHphysicallayercategory& multiCarrierphysicallayercategory) { *static_cast<MultiCarrierHSDSCHphysicallayercategory*>(items[1]) = multiCarrierphysicallayercategory; }
	void setUERadioAccessCapabilityCompTDD128v7f0extTddedchPhysicalLayerCategory(const UERadioAccessCapabilityCompTDD128v7f0extTddedchPhysicalLayerCategory& uERadioAccessCapabilityCompTDD128v7f0extTddedchPhysicalLayerCategory) { *static_cast<UERadioAccessCapabilityCompTDD128v7f0extTddedchPhysicalLayerCategory*>(items[2]) = uERadioAccessCapabilityCompTDD128v7f0extTddedchPhysicalLayerCategory; }
	void setDlCapabilityWithSimultaneousHSDSCHConfig(const DLCapabilityWithSimultaneousHSDSCHConfig& dlCapabilityWithSimultaneousHSDSCHConfig) { *static_cast<DLCapabilityWithSimultaneousHSDSCHConfig*>(items[3]) = dlCapabilityWithSimultaneousHSDSCHConfig; }
	void setUERadioAccessCapabilityCompTDD128v7f0extsupportForCSVoiceoverHSPA(const UERadioAccessCapabilityCompTDD128v7f0extsupportForCSVoiceoverHSPA& uERadioAccessCapabilityCompTDD128v7f0extsupportForCSVoiceoverHSPA) { *static_cast<UERadioAccessCapabilityCompTDD128v7f0extsupportForCSVoiceoverHSPA*>(items[4]) = uERadioAccessCapabilityCompTDD128v7f0extsupportForCSVoiceoverHSPA; }
	void setTotalRLCAMBufferSize(const TotalRLCAMBufferSizer5ext& totalRLCAMBufferSize) { *static_cast<TotalRLCAMBufferSizer5ext*>(items[5]) = totalRLCAMBufferSize; }
};

class UERadioAccessCapabilityv7f0ext : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv7f0ext(): Sequence(&theInfo) {}

	void setUERadioAccessCapabilityv7f0extsupportofTxDivOnNonMIMOChannel(const UERadioAccessCapabilityv7f0extsupportofTxDivOnNonMIMOChannel& uERadioAccessCapabilityv7f0extsupportofTxDivOnNonMIMOChannel) { *static_cast<UERadioAccessCapabilityv7f0extsupportofTxDivOnNonMIMOChannel*>(items[0]) = uERadioAccessCapabilityv7f0extsupportofTxDivOnNonMIMOChannel; }
	void setPhysicalChannelCapabilityLCR(const PhysicalChannelCapabilityLCRr4& physicalChannelCapabilityLCR) { *static_cast<PhysicalChannelCapabilityLCRr4*>(items[1]) = physicalChannelCapabilityLCR; }
	void setUeRadioAccessCapabilityCompTDD128(const UERadioAccessCapabilityCompTDD128v7f0ext& ueRadioAccessCapabilityCompTDD128) { *static_cast<UERadioAccessCapabilityCompTDD128v7f0ext*>(items[2]) = ueRadioAccessCapabilityCompTDD128; }
};

enum UERadioAccessCapabilityInfov770extganssSupportIndicationValues {
	true_UERadioAccessCapabilityInfov770extganssSupportIndication = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityInfov770extganssSupportIndication;

enum UERadioAccessCapabilityInfov770extmac_ehsSupportValues {
	true_UERadioAccessCapabilityInfov770extmac_ehsSupport = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityInfov770extmac_ehsSupport;

class UERadioAccessCapabilityInfov770ext : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	UERadioAccessCapabilityInfov770ext(): Sequence(&theInfo) {}

	void setRfCapability(const RFCapabilityv770ext& rfCapability) { *static_cast<RFCapabilityv770ext*>(items[0]) = rfCapability; }
	void setPhysicalChannelCapability(const PhysicalChannelCapabilityInfov770ext& physicalChannelCapability) { *static_cast<PhysicalChannelCapabilityInfov770ext*>(items[1]) = physicalChannelCapability; }
	void setUERadioAccessCapabilityInfov770extganssSupportIndication(const UERadioAccessCapabilityInfov770extganssSupportIndication& uERadioAccessCapabilityInfov770extganssSupportIndication) { *static_cast<UERadioAccessCapabilityInfov770extganssSupportIndication*>(items[2]) = uERadioAccessCapabilityInfov770extganssSupportIndication; }
	void setUERadioAccessCapabilityInfov770extmac_ehsSupport(const UERadioAccessCapabilityInfov770extmac_ehsSupport& uERadioAccessCapabilityInfov770extmac_ehsSupport) { *static_cast<UERadioAccessCapabilityInfov770extmac_ehsSupport*>(items[3]) = uERadioAccessCapabilityInfov770extmac_ehsSupport; }
	void setUeSpecificCapabilityInformation(const UESpecificCapabilityInformationLCRTDD& ueSpecificCapabilityInformation) { *static_cast<UESpecificCapabilityInformationLCRTDD*>(items[4]) = ueSpecificCapabilityInformation; }
};

class UERadioAccessCapabilityInfoTDD128v8b0ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UERadioAccessCapabilityInfoTDD128v8b0ext(): Sequence(&theInfo) {}

	void setMeasurementCapabilityTDD(const MeasurementCapabilityTDD& measurementCapabilityTDD) { *static_cast<MeasurementCapabilityTDD*>(items[0]) = measurementCapabilityTDD; }
	void setHSDSCHphysicallayercategoryextension(const HSDSCHphysicallayercategoryextension& hSDSCHphysicallayercategoryextension) { *static_cast<HSDSCHphysicallayercategoryextension*>(items[1]) = hSDSCHphysicallayercategoryextension; }
};

class UERadioAccessCapabilityv860ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv860ext(): Sequence(&theInfo) {}

	void setUeRadioAccessCapabBandFDDList3(const UERadioAccessCapabBandFDDList3& ueRadioAccessCapabBandFDDList3) { *static_cast<UERadioAccessCapabBandFDDList3*>(items[0]) = ueRadioAccessCapabBandFDDList3; }
};

enum UERadioAccessCapabilityv880extsupportForPriorityReselectionInUTRANValues {
	true_UERadioAccessCapabilityv880extsupportForPriorityReselectionInUTRAN = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityv880extsupportForPriorityReselectionInUTRAN;

class UERadioAccessCapabilityv880ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv880ext(): Sequence(&theInfo) {}

	void setUERadioAccessCapabilityv880extsupportForPriorityReselectionInUTRAN(const UERadioAccessCapabilityv880extsupportForPriorityReselectionInUTRAN& uERadioAccessCapabilityv880extsupportForPriorityReselectionInUTRAN) { *static_cast<UERadioAccessCapabilityv880extsupportForPriorityReselectionInUTRAN*>(items[0]) = uERadioAccessCapabilityv880extsupportForPriorityReselectionInUTRAN; }
};

enum UERadioAccessCapabilityv890extsupportCellSpecificTxDiversityinDC_OperationValues {
	true_UERadioAccessCapabilityv890extsupportCellSpecificTxDiversityinDC_Operation = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityv890extsupportCellSpecificTxDiversityinDC_Operation;

class UERadioAccessCapabilityv890ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv890ext(): Sequence(&theInfo) {}

	void setUERadioAccessCapabilityv890extsupportCellSpecificTxDiversityinDC_Operation(const UERadioAccessCapabilityv890extsupportCellSpecificTxDiversityinDC_Operation& uERadioAccessCapabilityv890extsupportCellSpecificTxDiversityinDC_Operation) { *static_cast<UERadioAccessCapabilityv890extsupportCellSpecificTxDiversityinDC_Operation*>(items[0]) = uERadioAccessCapabilityv890extsupportCellSpecificTxDiversityinDC_Operation; }
};

enum UERadioAccessCapabilityv920extsupportOfenhancedTS0Values {
	true_UERadioAccessCapabilityv920extsupportOfenhancedTS0 = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityv920extsupportOfenhancedTS0;

class UERadioAccessCapabilityv920ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv920ext(): Sequence(&theInfo) {}

	void setUERadioAccessCapabilityv920extsupportOfenhancedTS0(const UERadioAccessCapabilityv920extsupportOfenhancedTS0& uERadioAccessCapabilityv920extsupportOfenhancedTS0) { *static_cast<UERadioAccessCapabilityv920extsupportOfenhancedTS0*>(items[0]) = uERadioAccessCapabilityv920extsupportOfenhancedTS0; }
};

class UERadioAccessCapabilityv4b0extTddCapabilityExt : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv4b0extTddCapabilityExt(): Sequence(&theInfo) {}

	void setRfCapability(const RFCapabilityr4ext& rfCapability) { *static_cast<RFCapabilityr4ext*>(items[0]) = rfCapability; }
	void setPhysicalChannelCapabilityLCR(const PhysicalChannelCapabilityLCRr4& physicalChannelCapabilityLCR) { *static_cast<PhysicalChannelCapabilityLCRr4*>(items[1]) = physicalChannelCapabilityLCR; }
	void setMeasurementCapabilityr4ext(const MeasurementCapabilityr4ext& measurementCapabilityr4ext) { *static_cast<MeasurementCapabilityr4ext*>(items[2]) = measurementCapabilityr4ext; }
};

class UERadioAccessCapabilityv4b0ext : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv4b0ext(): Sequence(&theInfo) {}

	void setPdcpCapabilityr4ext(const PDCPCapabilityr4ext& pdcpCapabilityr4ext) { *static_cast<PDCPCapabilityr4ext*>(items[0]) = pdcpCapabilityr4ext; }
	void setUERadioAccessCapabilityv4b0extTddCapabilityExt(const UERadioAccessCapabilityv4b0extTddCapabilityExt& uERadioAccessCapabilityv4b0extTddCapabilityExt) { *static_cast<UERadioAccessCapabilityv4b0extTddCapabilityExt*>(items[1]) = uERadioAccessCapabilityv4b0extTddCapabilityExt; }
	void setAccessStratumReleaseIndicator(const AccessStratumReleaseIndicator& accessStratumReleaseIndicator) { *static_cast<AccessStratumReleaseIndicator*>(items[2]) = accessStratumReleaseIndicator; }
};

typedef Boolean UERadioAccessCapabilityCompTotalAMRLCMemoryExceeds10kB;

typedef Null RFCapabilityCompFddNotSupported;

enum RFCapabBandFDDCompValues {
	notSupported_RFCapabBandFDDComp = 0,
	default_TxRx_separation_RFCapabBandFDDComp = 1,
	spare2_RFCapabBandFDDComp = 2,
	spare1_RFCapabBandFDDComp = 3,
};
typedef Enumerated<CONSTRAINED, 3> RFCapabBandFDDComp;

typedef SequenceOf<RFCapabBandFDDComp, CONSTRAINED, 1, maxFreqBandsFDD> RFCapabBandListFDDComp;

class RFCapabilityCompFdd : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum RFCapabilityCompFddChoices {
		rFCapabilityCompFddNotSupported = 0,
		supported = 1,
	};
	static const Info theInfo;
	RFCapabilityCompFdd(): Choice(&theInfo) {}
};

typedef Null RFCapabilityCompTdd384RFCapabilityNotSupported;

class RFCapabilityCompTdd384RFCapability : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum RFCapabilityCompTdd384RFCapabilityChoices {
		rFCapabilityCompTdd384RFCapabilityNotSupported = 0,
		supported = 1,
	};
	static const Info theInfo;
	RFCapabilityCompTdd384RFCapability(): Choice(&theInfo) {}
};

typedef Null RFCapabilityCompTdd128RFCapabilityNotSupported;

class RFCapabilityCompTdd128RFCapability : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum RFCapabilityCompTdd128RFCapabilityChoices {
		rFCapabilityCompTdd128RFCapabilityNotSupported = 0,
		supported = 1,
	};
	static const Info theInfo;
	RFCapabilityCompTdd128RFCapability(): Choice(&theInfo) {}
};

class RFCapabilityComp : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	RFCapabilityComp(): Sequence(&theInfo) {}

	void setRFCapabilityCompFdd(const RFCapabilityCompFdd& rFCapabilityCompFdd) { *static_cast<RFCapabilityCompFdd*>(items[0]) = rFCapabilityCompFdd; }
	void setRFCapabilityCompTdd384RFCapability(const RFCapabilityCompTdd384RFCapability& rFCapabilityCompTdd384RFCapability) { *static_cast<RFCapabilityCompTdd384RFCapability*>(items[1]) = rFCapabilityCompTdd384RFCapability; }
	void setRFCapabilityCompTdd128RFCapability(const RFCapabilityCompTdd128RFCapability& rFCapabilityCompTdd128RFCapability) { *static_cast<RFCapabilityCompTdd128RFCapability*>(items[2]) = rFCapabilityCompTdd128RFCapability; }
};

class UERadioAccessCapabilityComp : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UERadioAccessCapabilityComp(): Sequence(&theInfo) {}

	void setUERadioAccessCapabilityCompTotalAMRLCMemoryExceeds10kB(const UERadioAccessCapabilityCompTotalAMRLCMemoryExceeds10kB& uERadioAccessCapabilityCompTotalAMRLCMemoryExceeds10kB) { *static_cast<UERadioAccessCapabilityCompTotalAMRLCMemoryExceeds10kB*>(items[0]) = uERadioAccessCapabilityCompTotalAMRLCMemoryExceeds10kB; }
	void setRfCapabilityComp(const RFCapabilityComp& rfCapabilityComp) { *static_cast<RFCapabilityComp*>(items[1]) = rfCapabilityComp; }
};

typedef SequenceOf<RFCapabBandFDDComp, CONSTRAINED, 1, maxFreqBandsFDD_ext> RFCapabBandListFDDCompext;

class UERadioAccessCapabilityCompext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UERadioAccessCapabilityCompext(): Sequence(&theInfo) {}

	void setRfCapabilityFDDComp(const RFCapabBandListFDDCompext& rfCapabilityFDDComp) { *static_cast<RFCapabBandListFDDCompext*>(items[0]) = rfCapabilityFDDComp; }
};

typedef Null RFCapabilityCompv770extTdd768RFCapabilityNotSupported;

class RFCapabilityCompv770extTdd768RFCapability : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum RFCapabilityCompv770extTdd768RFCapabilityChoices {
		rFCapabilityCompv770extTdd768RFCapabilityNotSupported = 0,
		supported = 1,
	};
	static const Info theInfo;
	RFCapabilityCompv770extTdd768RFCapability(): Choice(&theInfo) {}
};

class RFCapabilityCompv770ext : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	RFCapabilityCompv770ext(): Sequence(&theInfo) {}

	void setTdd384RFCapability(const RadioFrequencyBandTDDListr7& tdd384RFCapability) { *static_cast<RadioFrequencyBandTDDListr7*>(items[0]) = tdd384RFCapability; }
	void setRFCapabilityCompv770extTdd768RFCapability(const RFCapabilityCompv770extTdd768RFCapability& rFCapabilityCompv770extTdd768RFCapability) { *static_cast<RFCapabilityCompv770extTdd768RFCapability*>(items[1]) = rFCapabilityCompv770extTdd768RFCapability; }
	void setTdd128RFCapability(const RadioFrequencyBandTDDListr7& tdd128RFCapability) { *static_cast<RadioFrequencyBandTDDListr7*>(items[2]) = tdd128RFCapability; }
};

enum UERadioAccessCapabilityCompv770extsecurityCapabilityIndicationValues {
	true_UERadioAccessCapabilityCompv770extsecurityCapabilityIndication = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityCompv770extsecurityCapabilityIndication;

enum UERadioAccessCapabilityCompv770extganssSupportIndicationValues {
	true_UERadioAccessCapabilityCompv770extganssSupportIndication = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityCompv770extganssSupportIndication;

enum UERadioAccessCapabilityCompv770extmac_ehsSupportValues {
	true_UERadioAccessCapabilityCompv770extmac_ehsSupport = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityCompv770extmac_ehsSupport;

class UERadioAccessCapabilityCompv770ext : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UERadioAccessCapabilityCompv770ext(): Sequence(&theInfo) {}

	void setRfCapabilityComp(const RFCapabilityCompv770ext& rfCapabilityComp) { *static_cast<RFCapabilityCompv770ext*>(items[0]) = rfCapabilityComp; }
	void setUERadioAccessCapabilityCompv770extsecurityCapabilityIndication(const UERadioAccessCapabilityCompv770extsecurityCapabilityIndication& uERadioAccessCapabilityCompv770extsecurityCapabilityIndication) { *static_cast<UERadioAccessCapabilityCompv770extsecurityCapabilityIndication*>(items[1]) = uERadioAccessCapabilityCompv770extsecurityCapabilityIndication; }
	void setUERadioAccessCapabilityCompv770extganssSupportIndication(const UERadioAccessCapabilityCompv770extganssSupportIndication& uERadioAccessCapabilityCompv770extganssSupportIndication) { *static_cast<UERadioAccessCapabilityCompv770extganssSupportIndication*>(items[2]) = uERadioAccessCapabilityCompv770extganssSupportIndication; }
	void setUERadioAccessCapabilityCompv770extmac_ehsSupport(const UERadioAccessCapabilityCompv770extmac_ehsSupport& uERadioAccessCapabilityCompv770extmac_ehsSupport) { *static_cast<UERadioAccessCapabilityCompv770extmac_ehsSupport*>(items[3]) = uERadioAccessCapabilityCompv770extmac_ehsSupport; }
};

class UERadioAccessCapabilityComp2FddPhysicalChannelCapabhspdschedch : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UERadioAccessCapabilityComp2FddPhysicalChannelCapabhspdschedch(): Sequence(&theInfo) {}

	void setDlCapabilityWithSimultaneousHSDSCHConfig(const DLCapabilityWithSimultaneousHSDSCHConfig& dlCapabilityWithSimultaneousHSDSCHConfig) { *static_cast<DLCapabilityWithSimultaneousHSDSCHConfig*>(items[0]) = dlCapabilityWithSimultaneousHSDSCHConfig; }
	void setPhysicalChannelCapabComphspdschr6(const HSDSCHphysicallayercategory& physicalChannelCapabComphspdschr6) { *static_cast<HSDSCHphysicallayercategory*>(items[1]) = physicalChannelCapabComphspdschr6; }
	void setPhysicalChannelCapabilityedchr6(const PhysicalChannelCapabilityedchr6& physicalChannelCapabilityedchr6) { *static_cast<PhysicalChannelCapabilityedchr6*>(items[2]) = physicalChannelCapabilityedchr6; }
};

class UERadioAccessCapabilityComp2 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UERadioAccessCapabilityComp2(): Sequence(&theInfo) {}

	void setUERadioAccessCapabilityComp2FddPhysicalChannelCapabhspdschedch(const UERadioAccessCapabilityComp2FddPhysicalChannelCapabhspdschedch& uERadioAccessCapabilityComp2FddPhysicalChannelCapabhspdschedch) { *static_cast<UERadioAccessCapabilityComp2FddPhysicalChannelCapabhspdschedch*>(items[0]) = uERadioAccessCapabilityComp2FddPhysicalChannelCapabhspdschedch; }
};

typedef Integer<CONSTRAINED, 7, 7> UERadioAccessCapabilityComp2v770extEdchPhysicalLayerCategoryextension;

enum UERadioAccessCapabilityComp2v770exthsscchlessHsdschOperationValues {
	true_UERadioAccessCapabilityComp2v770exthsscchlessHsdschOperation = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityComp2v770exthsscchlessHsdschOperation;

enum UERadioAccessCapabilityComp2v770extenhancedFdpchValues {
	true_UERadioAccessCapabilityComp2v770extenhancedFdpch = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityComp2v770extenhancedFdpch;

enum UERadioAccessCapabilityComp2v770exthsdschReception_CellFachValues {
	true_UERadioAccessCapabilityComp2v770exthsdschReception_CellFach = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityComp2v770exthsdschReception_CellFach;

enum UERadioAccessCapabilityComp2v770exthsdschReception_CellUraPchValues {
	true_UERadioAccessCapabilityComp2v770exthsdschReception_CellUraPch = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityComp2v770exthsdschReception_CellUraPch;

enum UERadioAccessCapabilityComp2v770extdiscontinuousDpcchTransmissionValues {
	true_UERadioAccessCapabilityComp2v770extdiscontinuousDpcchTransmission = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityComp2v770extdiscontinuousDpcchTransmission;

enum UERadioAccessCapabilityComp2v770extslotFormat4Values {
	true_UERadioAccessCapabilityComp2v770extslotFormat4 = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityComp2v770extslotFormat4;

class UERadioAccessCapabilityComp2v770ext : public Sequence {
private:
	static const void *itemsInfo[9];
	static bool itemsPres[9];
public:
	static const Info theInfo;
	UERadioAccessCapabilityComp2v770ext(): Sequence(&theInfo) {}

	void setHsdschphysicallayercategoryext(const HSDSCHphysicallayercategoryext& hsdschphysicallayercategoryext) { *static_cast<HSDSCHphysicallayercategoryext*>(items[0]) = hsdschphysicallayercategoryext; }
	void setUERadioAccessCapabilityComp2v770extEdchPhysicalLayerCategoryextension(const UERadioAccessCapabilityComp2v770extEdchPhysicalLayerCategoryextension& uERadioAccessCapabilityComp2v770extEdchPhysicalLayerCategoryextension) { *static_cast<UERadioAccessCapabilityComp2v770extEdchPhysicalLayerCategoryextension*>(items[1]) = uERadioAccessCapabilityComp2v770extEdchPhysicalLayerCategoryextension; }
	void setUERadioAccessCapabilityComp2v770exthsscchlessHsdschOperation(const UERadioAccessCapabilityComp2v770exthsscchlessHsdschOperation& uERadioAccessCapabilityComp2v770exthsscchlessHsdschOperation) { *static_cast<UERadioAccessCapabilityComp2v770exthsscchlessHsdschOperation*>(items[2]) = uERadioAccessCapabilityComp2v770exthsscchlessHsdschOperation; }
	void setUERadioAccessCapabilityComp2v770extenhancedFdpch(const UERadioAccessCapabilityComp2v770extenhancedFdpch& uERadioAccessCapabilityComp2v770extenhancedFdpch) { *static_cast<UERadioAccessCapabilityComp2v770extenhancedFdpch*>(items[3]) = uERadioAccessCapabilityComp2v770extenhancedFdpch; }
	void setUERadioAccessCapabilityComp2v770exthsdschReception_CellFach(const UERadioAccessCapabilityComp2v770exthsdschReception_CellFach& uERadioAccessCapabilityComp2v770exthsdschReception_CellFach) { *static_cast<UERadioAccessCapabilityComp2v770exthsdschReception_CellFach*>(items[4]) = uERadioAccessCapabilityComp2v770exthsdschReception_CellFach; }
	void setUERadioAccessCapabilityComp2v770exthsdschReception_CellUraPch(const UERadioAccessCapabilityComp2v770exthsdschReception_CellUraPch& uERadioAccessCapabilityComp2v770exthsdschReception_CellUraPch) { *static_cast<UERadioAccessCapabilityComp2v770exthsdschReception_CellUraPch*>(items[5]) = uERadioAccessCapabilityComp2v770exthsdschReception_CellUraPch; }
	void setUERadioAccessCapabilityComp2v770extdiscontinuousDpcchTransmission(const UERadioAccessCapabilityComp2v770extdiscontinuousDpcchTransmission& uERadioAccessCapabilityComp2v770extdiscontinuousDpcchTransmission) { *static_cast<UERadioAccessCapabilityComp2v770extdiscontinuousDpcchTransmission*>(items[6]) = uERadioAccessCapabilityComp2v770extdiscontinuousDpcchTransmission; }
	void setUERadioAccessCapabilityComp2v770extslotFormat4(const UERadioAccessCapabilityComp2v770extslotFormat4& uERadioAccessCapabilityComp2v770extslotFormat4) { *static_cast<UERadioAccessCapabilityComp2v770extslotFormat4*>(items[7]) = uERadioAccessCapabilityComp2v770extslotFormat4; }
	void setPdcpCapability(const PDCPCapabilityv770ext& pdcpCapability) { *static_cast<PDCPCapabilityv770ext*>(items[8]) = pdcpCapability; }
};

enum UERadioAccessCapabilityComp2v7f0extsupportofTxDivOnNonMIMOChannelValues {
	true_UERadioAccessCapabilityComp2v7f0extsupportofTxDivOnNonMIMOChannel = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityComp2v7f0extsupportofTxDivOnNonMIMOChannel;

class UERadioAccessCapabilityComp2v7f0ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UERadioAccessCapabilityComp2v7f0ext(): Sequence(&theInfo) {}

	void setUERadioAccessCapabilityComp2v7f0extsupportofTxDivOnNonMIMOChannel(const UERadioAccessCapabilityComp2v7f0extsupportofTxDivOnNonMIMOChannel& uERadioAccessCapabilityComp2v7f0extsupportofTxDivOnNonMIMOChannel) { *static_cast<UERadioAccessCapabilityComp2v7f0extsupportofTxDivOnNonMIMOChannel*>(items[0]) = uERadioAccessCapabilityComp2v7f0extsupportofTxDivOnNonMIMOChannel; }
};

enum UERadioAccessCapabilityComp2v860extsupportOfMACiisValues {
	true_UERadioAccessCapabilityComp2v860extsupportOfMACiis = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityComp2v860extsupportOfMACiis;

class UERadioAccessCapabilityComp2v860ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UERadioAccessCapabilityComp2v860ext(): Sequence(&theInfo) {}

	void setHsdschphysicallayercategoryext2(const HSDSCHphysicallayercategoryext2& hsdschphysicallayercategoryext2) { *static_cast<HSDSCHphysicallayercategoryext2*>(items[0]) = hsdschphysicallayercategoryext2; }
	void setUERadioAccessCapabilityComp2v860extsupportOfMACiis(const UERadioAccessCapabilityComp2v860extsupportOfMACiis& uERadioAccessCapabilityComp2v860extsupportOfMACiis) { *static_cast<UERadioAccessCapabilityComp2v860extsupportOfMACiis*>(items[1]) = uERadioAccessCapabilityComp2v860extsupportOfMACiis; }
};

typedef Integer<CONSTRAINED, 8, 9> UERadioAccessCapabilityComp2v920extEdchPhysicalLayerCategoryextension2;

class UERadioAccessCapabilityComp2v920ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UERadioAccessCapabilityComp2v920ext(): Sequence(&theInfo) {}

	void setHsdschphysicallayercategoryext3(const HSDSCHphysicallayercategoryext3& hsdschphysicallayercategoryext3) { *static_cast<HSDSCHphysicallayercategoryext3*>(items[0]) = hsdschphysicallayercategoryext3; }
	void setUERadioAccessCapabilityComp2v920extEdchPhysicalLayerCategoryextension2(const UERadioAccessCapabilityComp2v920extEdchPhysicalLayerCategoryextension2& uERadioAccessCapabilityComp2v920extEdchPhysicalLayerCategoryextension2) { *static_cast<UERadioAccessCapabilityComp2v920extEdchPhysicalLayerCategoryextension2*>(items[1]) = uERadioAccessCapabilityComp2v920extEdchPhysicalLayerCategoryextension2; }
};

enum UERadioAccessCapabilityCompTDD128supportOfSFModeForHSPDSCHDualStreamValues {
	sf1_UERadioAccessCapabilityCompTDD128supportOfSFModeForHSPDSCHDualStream = 0,
	sf1sf16_UERadioAccessCapabilityCompTDD128supportOfSFModeForHSPDSCHDualStream = 1,
};
typedef Enumerated<CONSTRAINED, 1> UERadioAccessCapabilityCompTDD128supportOfSFModeForHSPDSCHDualStream;

enum UERadioAccessCapabilityCompTDD128supportOfCommonEDCHValues {
	true_UERadioAccessCapabilityCompTDD128supportOfCommonEDCH = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityCompTDD128supportOfCommonEDCH;

enum UERadioAccessCapabilityCompTDD128supportOfMACiisValues {
	true_UERadioAccessCapabilityCompTDD128supportOfMACiis = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityCompTDD128supportOfMACiis;

enum UERadioAccessCapabilityCompTDD128supportOfSPSOperationValues {
	true_UERadioAccessCapabilityCompTDD128supportOfSPSOperation = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityCompTDD128supportOfSPSOperation;

enum UERadioAccessCapabilityCompTDD128supportOfControlChannelDRXOperationValues {
	true_UERadioAccessCapabilityCompTDD128supportOfControlChannelDRXOperation = 0,
};
typedef Enumerated<CONSTRAINED, 0> UERadioAccessCapabilityCompTDD128supportOfControlChannelDRXOperation;

class UERadioAccessCapabilityCompTDD128 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	UERadioAccessCapabilityCompTDD128(): Sequence(&theInfo) {}

	void setTdd128RFCapability(const RadioFrequencyBandTDDextList& tdd128RFCapability) { *static_cast<RadioFrequencyBandTDDextList*>(items[0]) = tdd128RFCapability; }
	void setUERadioAccessCapabilityCompTDD128supportOfSFModeForHSPDSCHDualStream(const UERadioAccessCapabilityCompTDD128supportOfSFModeForHSPDSCHDualStream& uERadioAccessCapabilityCompTDD128supportOfSFModeForHSPDSCHDualStream) { *static_cast<UERadioAccessCapabilityCompTDD128supportOfSFModeForHSPDSCHDualStream*>(items[1]) = uERadioAccessCapabilityCompTDD128supportOfSFModeForHSPDSCHDualStream; }
	void setUERadioAccessCapabilityCompTDD128supportOfCommonEDCH(const UERadioAccessCapabilityCompTDD128supportOfCommonEDCH& uERadioAccessCapabilityCompTDD128supportOfCommonEDCH) { *static_cast<UERadioAccessCapabilityCompTDD128supportOfCommonEDCH*>(items[2]) = uERadioAccessCapabilityCompTDD128supportOfCommonEDCH; }
	void setUERadioAccessCapabilityCompTDD128supportOfMACiis(const UERadioAccessCapabilityCompTDD128supportOfMACiis& uERadioAccessCapabilityCompTDD128supportOfMACiis) { *static_cast<UERadioAccessCapabilityCompTDD128supportOfMACiis*>(items[3]) = uERadioAccessCapabilityCompTDD128supportOfMACiis; }
	void setUERadioAccessCapabilityCompTDD128supportOfSPSOperation(const UERadioAccessCapabilityCompTDD128supportOfSPSOperation& uERadioAccessCapabilityCompTDD128supportOfSPSOperation) { *static_cast<UERadioAccessCapabilityCompTDD128supportOfSPSOperation*>(items[4]) = uERadioAccessCapabilityCompTDD128supportOfSPSOperation; }
	void setUERadioAccessCapabilityCompTDD128supportOfControlChannelDRXOperation(const UERadioAccessCapabilityCompTDD128supportOfControlChannelDRXOperation& uERadioAccessCapabilityCompTDD128supportOfControlChannelDRXOperation) { *static_cast<UERadioAccessCapabilityCompTDD128supportOfControlChannelDRXOperation*>(items[5]) = uERadioAccessCapabilityCompTDD128supportOfControlChannelDRXOperation; }
};

class UERadioAccessCapabilityv590ext : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv590ext(): Sequence(&theInfo) {}

	void setDlCapabilityWithSimultaneousHSDSCHConfig(const DLCapabilityWithSimultaneousHSDSCHConfig& dlCapabilityWithSimultaneousHSDSCHConfig) { *static_cast<DLCapabilityWithSimultaneousHSDSCHConfig*>(items[0]) = dlCapabilityWithSimultaneousHSDSCHConfig; }
	void setPdcpCapabilityr5ext(const PDCPCapabilityr5ext& pdcpCapabilityr5ext) { *static_cast<PDCPCapabilityr5ext*>(items[1]) = pdcpCapabilityr5ext; }
	void setRlcCapabilityr5ext(const RLCCapabilityr5ext& rlcCapabilityr5ext) { *static_cast<RLCCapabilityr5ext*>(items[2]) = rlcCapabilityr5ext; }
	void setPhysicalChannelCapability(const PhysicalChannelCapabilityhspdschr5& physicalChannelCapability) { *static_cast<PhysicalChannelCapabilityhspdschr5*>(items[3]) = physicalChannelCapability; }
	void setMultiModeRATCapabilityv590ext(const MultiModeRATCapabilityv590ext& multiModeRATCapabilityv590ext) { *static_cast<MultiModeRATCapabilityv590ext*>(items[4]) = multiModeRATCapabilityv590ext; }
};

class UERadioAccessCapabilityv5c0ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv5c0ext(): Sequence(&theInfo) {}

	void setPdcpCapabilityr5ext2(const PDCPCapabilityr5ext2& pdcpCapabilityr5ext2) { *static_cast<PDCPCapabilityr5ext2*>(items[0]) = pdcpCapabilityr5ext2; }
};

class UERadioAccessCapabilityv680ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UERadioAccessCapabilityv680ext(): Sequence(&theInfo) {}

	void setMultiModeRATCapabilityv680ext(const MultiModeRATCapabilityv680ext& multiModeRATCapabilityv680ext) { *static_cast<MultiModeRATCapabilityv680ext*>(items[0]) = multiModeRATCapabilityv680ext; }
};

class ULPhysChCapabilityFDDr6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULPhysChCapabilityFDDr6(): Sequence(&theInfo) {}

	void setMaxNoDPDCHBitsTransmitted(const MaxNoDPDCHBitsTransmitted& maxNoDPDCHBitsTransmitted) { *static_cast<MaxNoDPDCHBitsTransmitted*>(items[0]) = maxNoDPDCHBitsTransmitted; }
	void setPhysicalchannelcapabilityedch(const PhysicalChannelCapabilityedchr6& physicalchannelcapabilityedch) { *static_cast<PhysicalChannelCapabilityedchr6*>(items[1]) = physicalchannelcapabilityedch; }
};

typedef Null ULSecondaryCellInfoFDDContinue;

class ULSecondaryCellInfoFDDNewConfiguration : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULSecondaryCellInfoFDDNewConfiguration(): Sequence(&theInfo) {}

	void setSecondaryServingEDCHCellInfo(const SecondaryServingEDCHCellInfo& secondaryServingEDCHCellInfo) { *static_cast<SecondaryServingEDCHCellInfo*>(items[0]) = secondaryServingEDCHCellInfo; }
	void setSecondaryEDCHInfoCommon(const SecondaryEDCHInfoCommon& secondaryEDCHInfoCommon) { *static_cast<SecondaryEDCHInfoCommon*>(items[1]) = secondaryEDCHInfoCommon; }
	void setDlInformationPerSecondaryRLList(const DLInformationPerSecondaryRLList& dlInformationPerSecondaryRLList) { *static_cast<DLInformationPerSecondaryRLList*>(items[2]) = dlInformationPerSecondaryRLList; }
};

class ULSecondaryCellInfoFDD : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULSecondaryCellInfoFDDChoices {
		uLSecondaryCellInfoFDDContinue = 0,
		uLSecondaryCellInfoFDDNewConfiguration = 1,
	};
	static const Info theInfo;
	ULSecondaryCellInfoFDD(): Choice(&theInfo) {}
};

class UESecurityInformation : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UESecurityInformation(): Sequence(&theInfo) {}

	void setStartCS(const STARTValue& startCS) { *static_cast<STARTValue*>(items[0]) = startCS; }
};

class UESecurityInformation2 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UESecurityInformation2(): Sequence(&theInfo) {}

	void setStartPS(const STARTValue& startPS) { *static_cast<STARTValue*>(items[0]) = startPS; }
};

enum URAUpdateCauseValues {
	changeOfURA_URAUpdateCause = 0,
	periodicURAUpdate_URAUpdateCause = 1,
	dummy_URAUpdateCause = 2,
	spare1_URAUpdateCause = 3,
};
typedef Enumerated<CONSTRAINED, 3> URAUpdateCause;

typedef Integer<CONSTRAINED, 3, 9> UTRANDRXCycleLengthCoefficient;

typedef Integer<CONSTRAINED, 3, 9> UTRANDRXCycleLengthCoefficientr7DrxCycleLengthCoefficient;

typedef Integer<CONSTRAINED, 3, 9> UTRANDRXCycleLengthCoefficientr7DrxCycleLengthCoefficient2;

class UTRANDRXCycleLengthCoefficientr7 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UTRANDRXCycleLengthCoefficientr7(): Sequence(&theInfo) {}

	void setUTRANDRXCycleLengthCoefficientr7DrxCycleLengthCoefficient(const UTRANDRXCycleLengthCoefficientr7DrxCycleLengthCoefficient& uTRANDRXCycleLengthCoefficientr7DrxCycleLengthCoefficient) { *static_cast<UTRANDRXCycleLengthCoefficientr7DrxCycleLengthCoefficient*>(items[0]) = uTRANDRXCycleLengthCoefficientr7DrxCycleLengthCoefficient; }
	void setUTRANDRXCycleLengthCoefficientr7DrxCycleLengthCoefficient2(const UTRANDRXCycleLengthCoefficientr7DrxCycleLengthCoefficient2& uTRANDRXCycleLengthCoefficientr7DrxCycleLengthCoefficient2) { *static_cast<UTRANDRXCycleLengthCoefficientr7DrxCycleLengthCoefficient2*>(items[1]) = uTRANDRXCycleLengthCoefficientr7DrxCycleLengthCoefficient2; }
	void setTimeForDRXCycle2(const T319& timeForDRXCycle2) { *static_cast<T319*>(items[2]) = timeForDRXCycle2; }
};

typedef Integer<CONSTRAINED, 0, 15> WaitTime;

typedef Integer<CONSTRAINED, 1, 65535> RFC2507InfoFMAXPERIOD;

typedef Integer<CONSTRAINED, 1, 255> RFC2507InfoFMAXTIME;

typedef Integer<CONSTRAINED, 60, 65535> RFC2507InfoMaxHEADER;

typedef Integer<CONSTRAINED, 3, 255> RFC2507InfoTcpSPACE;

typedef Integer<CONSTRAINED, 3, 65535> RFC2507InfoNonTCPSPACE;

enum ExpectReorderingValues {
	reorderingNotExpected_ExpectReordering = 0,
	reorderingExpected_ExpectReordering = 1,
};
typedef Enumerated<CONSTRAINED, 1> ExpectReordering;

class RFC2507Info : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	RFC2507Info(): Sequence(&theInfo) {}

	void setRFC2507InfoFMAXPERIOD(const RFC2507InfoFMAXPERIOD& rFC2507InfoFMAXPERIOD) { *static_cast<RFC2507InfoFMAXPERIOD*>(items[0]) = rFC2507InfoFMAXPERIOD; }
	void setRFC2507InfoFMAXTIME(const RFC2507InfoFMAXTIME& rFC2507InfoFMAXTIME) { *static_cast<RFC2507InfoFMAXTIME*>(items[1]) = rFC2507InfoFMAXTIME; }
	void setRFC2507InfoMaxHEADER(const RFC2507InfoMaxHEADER& rFC2507InfoMaxHEADER) { *static_cast<RFC2507InfoMaxHEADER*>(items[2]) = rFC2507InfoMaxHEADER; }
	void setRFC2507InfoTcpSPACE(const RFC2507InfoTcpSPACE& rFC2507InfoTcpSPACE) { *static_cast<RFC2507InfoTcpSPACE*>(items[3]) = rFC2507InfoTcpSPACE; }
	void setRFC2507InfoNonTCPSPACE(const RFC2507InfoNonTCPSPACE& rFC2507InfoNonTCPSPACE) { *static_cast<RFC2507InfoNonTCPSPACE*>(items[4]) = rFC2507InfoNonTCPSPACE; }
	void setExpectReordering(const ExpectReordering& expectReordering) { *static_cast<ExpectReordering*>(items[5]) = expectReordering; }
};

class AlgorithmSpecificInfo : public Choice {
private:
	static const void *choicesInfo[1];
public:
	enum AlgorithmSpecificInfoChoices {
		rfc2507Info = 0,
	};
	static const Info theInfo;
	AlgorithmSpecificInfo(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, 3> ROHCProfiler4;

typedef SequenceOf<ROHCProfiler4, CONSTRAINED, 1, maxROHC_Profile_r4> ROHCProfileListr4;

enum CIDInclusionInfor4Values {
	pdcp_Header_CIDInclusionInfor4 = 0,
	rfc3095_PacketFormat_CIDInclusionInfor4 = 1,
};
typedef Enumerated<CONSTRAINED, 1> CIDInclusionInfor4;

typedef Integer<CONSTRAINED, 1, 16383> ULRFC3095r4MaxCID;

typedef Integer<CONSTRAINED, 2, 1500> ROHCPacketSizer4;

typedef SequenceOf<ROHCPacketSizer4, CONSTRAINED, 1, maxROHC_PacketSizes_r4> ROHCPacketSizeListr4;

class ULRFC3095r4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULRFC3095r4(): Sequence(&theInfo) {}

	void setDummy1(const CIDInclusionInfor4& dummy1) { *static_cast<CIDInclusionInfor4*>(items[0]) = dummy1; }
	void setULRFC3095r4MaxCID(const ULRFC3095r4MaxCID& uLRFC3095r4MaxCID) { *static_cast<ULRFC3095r4MaxCID*>(items[1]) = uLRFC3095r4MaxCID; }
	void setDummy(const ROHCPacketSizeListr4& dummy) { *static_cast<ROHCPacketSizeListr4*>(items[2]) = dummy; }
};

typedef Integer<CONSTRAINED, 1, 16383> DLRFC3095r4MaxCID;

typedef Integer<CONSTRAINED, 0, 65535> DLRFC3095r4ReverseDecompressionDepth;

class DLRFC3095r4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLRFC3095r4(): Sequence(&theInfo) {}

	void setDummy(const CIDInclusionInfor4& dummy) { *static_cast<CIDInclusionInfor4*>(items[0]) = dummy; }
	void setDLRFC3095r4MaxCID(const DLRFC3095r4MaxCID& dLRFC3095r4MaxCID) { *static_cast<DLRFC3095r4MaxCID*>(items[1]) = dLRFC3095r4MaxCID; }
	void setDLRFC3095r4ReverseDecompressionDepth(const DLRFC3095r4ReverseDecompressionDepth& dLRFC3095r4ReverseDecompressionDepth) { *static_cast<DLRFC3095r4ReverseDecompressionDepth*>(items[2]) = dLRFC3095r4ReverseDecompressionDepth; }
};

class RFC3095Infor4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	RFC3095Infor4(): Sequence(&theInfo) {}

	void setRohcProfileList(const ROHCProfileListr4& rohcProfileList) { *static_cast<ROHCProfileListr4*>(items[0]) = rohcProfileList; }
	void setUlRFC3095(const ULRFC3095r4& ulRFC3095) { *static_cast<ULRFC3095r4*>(items[1]) = ulRFC3095; }
	void setDlRFC3095(const DLRFC3095r4& dlRFC3095) { *static_cast<DLRFC3095r4*>(items[2]) = dlRFC3095; }
};

class AlgorithmSpecificInfor4 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum AlgorithmSpecificInfor4Choices {
		rfc2507Info = 0,
		rfc3095Info = 1,
	};
	static const Info theInfo;
	AlgorithmSpecificInfor4(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, 15> LogicalChannelIdentity;

typedef Integer<CONSTRAINED, 0, 7> MACehsQueueId;

class CommonRBMappingInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CommonRBMappingInfo(): Sequence(&theInfo) {}

	void setLogicalChannelIdentity(const LogicalChannelIdentity& logicalChannelIdentity) { *static_cast<LogicalChannelIdentity*>(items[0]) = logicalChannelIdentity; }
	void setMacehsQueueId(const MACehsQueueId& macehsQueueId) { *static_cast<MACehsQueueId*>(items[1]) = macehsQueueId; }
};

typedef Integer<CONSTRAINED, 0, 4294967295> COUNTC;

typedef Integer<CONSTRAINED, 0, 33554431> COUNTCMSB;

enum ULAMRRateValues {
	t0_ULAMRRate = 0,
	t1_ULAMRRate = 1,
	t2_ULAMRRate = 2,
	t3_ULAMRRate = 3,
	t4_ULAMRRate = 4,
	t5_ULAMRRate = 5,
	t6_ULAMRRate = 6,
	t7_ULAMRRate = 7,
	t8_ULAMRRate = 8,
	spare7_ULAMRRate = 9,
	spare6_ULAMRRate = 10,
	spare5_ULAMRRate = 11,
	spare4_ULAMRRate = 12,
	spare3_ULAMRRate = 13,
	spare2_ULAMRRate = 14,
	spare1_ULAMRRate = 15,
};
typedef Enumerated<CONSTRAINED, 15> ULAMRRate;

typedef Integer<CONSTRAINED, 0, 18> MaxCSDelay;

class CSHSPAInformation : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CSHSPAInformation(): Sequence(&theInfo) {}

	void setUlAMRRate(const ULAMRRate& ulAMRRate) { *static_cast<ULAMRRate*>(items[0]) = ulAMRRate; }
	void setMaxCSDelay(const MaxCSDelay& maxCSDelay) { *static_cast<MaxCSDelay*>(items[1]) = maxCSDelay; }
};

enum DefaultConfigModeValues {
	fdd_DefaultConfigMode = 0,
	tdd_DefaultConfigMode = 1,
};
typedef Enumerated<CONSTRAINED, 1> DefaultConfigMode;

typedef Integer<CONSTRAINED, 0, 15> DefaultConfigIdForCellFACH;

class DefaultConfigForCellFACH : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DefaultConfigForCellFACH(): Sequence(&theInfo) {}

	void setDefaultConfigMode(const DefaultConfigMode& defaultConfigMode) { *static_cast<DefaultConfigMode*>(items[0]) = defaultConfigMode; }
	void setDefaultConfigIdForCellFACH(const DefaultConfigIdForCellFACH& defaultConfigIdForCellFACH) { *static_cast<DefaultConfigIdForCellFACH*>(items[1]) = defaultConfigIdForCellFACH; }
};

typedef Integer<CONSTRAINED, 0, 10> DefaultConfigIdentity;

typedef Integer<CONSTRAINED, 0, 12> DefaultConfigIdentityr4;

typedef Integer<CONSTRAINED, 0, 13> DefaultConfigIdentityr5;

typedef Integer<CONSTRAINED, 0, 31> DefaultConfigIdentityr6;

typedef Integer<CONSTRAINED, 0, 62> DDI;

typedef Boolean DLAMRLCModeInSequenceDelivery;

enum ReceivingWindowSizeValues {
	rw1_ReceivingWindowSize = 0,
	rw8_ReceivingWindowSize = 1,
	rw16_ReceivingWindowSize = 2,
	rw32_ReceivingWindowSize = 3,
	rw64_ReceivingWindowSize = 4,
	rw128_ReceivingWindowSize = 5,
	rw256_ReceivingWindowSize = 6,
	rw512_ReceivingWindowSize = 7,
	rw768_ReceivingWindowSize = 8,
	rw1024_ReceivingWindowSize = 9,
	rw1536_ReceivingWindowSize = 10,
	rw2047_ReceivingWindowSize = 11,
	rw2560_ReceivingWindowSize = 12,
	rw3072_ReceivingWindowSize = 13,
	rw3584_ReceivingWindowSize = 14,
	rw4095_ReceivingWindowSize = 15,
};
typedef Enumerated<CONSTRAINED, 15> ReceivingWindowSize;

enum TimerStatusProhibitValues {
	tsp10_TimerStatusProhibit = 0,
	tsp20_TimerStatusProhibit = 1,
	tsp30_TimerStatusProhibit = 2,
	tsp40_TimerStatusProhibit = 3,
	tsp50_TimerStatusProhibit = 4,
	tsp60_TimerStatusProhibit = 5,
	tsp70_TimerStatusProhibit = 6,
	tsp80_TimerStatusProhibit = 7,
	tsp90_TimerStatusProhibit = 8,
	tsp100_TimerStatusProhibit = 9,
	tsp110_TimerStatusProhibit = 10,
	tsp120_TimerStatusProhibit = 11,
	tsp130_TimerStatusProhibit = 12,
	tsp140_TimerStatusProhibit = 13,
	tsp150_TimerStatusProhibit = 14,
	tsp160_TimerStatusProhibit = 15,
	tsp170_TimerStatusProhibit = 16,
	tsp180_TimerStatusProhibit = 17,
	tsp190_TimerStatusProhibit = 18,
	tsp200_TimerStatusProhibit = 19,
	tsp210_TimerStatusProhibit = 20,
	tsp220_TimerStatusProhibit = 21,
	tsp230_TimerStatusProhibit = 22,
	tsp240_TimerStatusProhibit = 23,
	tsp250_TimerStatusProhibit = 24,
	tsp260_TimerStatusProhibit = 25,
	tsp270_TimerStatusProhibit = 26,
	tsp280_TimerStatusProhibit = 27,
	tsp290_TimerStatusProhibit = 28,
	tsp300_TimerStatusProhibit = 29,
	tsp310_TimerStatusProhibit = 30,
	tsp320_TimerStatusProhibit = 31,
	tsp330_TimerStatusProhibit = 32,
	tsp340_TimerStatusProhibit = 33,
	tsp350_TimerStatusProhibit = 34,
	tsp360_TimerStatusProhibit = 35,
	tsp370_TimerStatusProhibit = 36,
	tsp380_TimerStatusProhibit = 37,
	tsp390_TimerStatusProhibit = 38,
	tsp400_TimerStatusProhibit = 39,
	tsp410_TimerStatusProhibit = 40,
	tsp420_TimerStatusProhibit = 41,
	tsp430_TimerStatusProhibit = 42,
	tsp440_TimerStatusProhibit = 43,
	tsp450_TimerStatusProhibit = 44,
	tsp460_TimerStatusProhibit = 45,
	tsp470_TimerStatusProhibit = 46,
	tsp480_TimerStatusProhibit = 47,
	tsp490_TimerStatusProhibit = 48,
	tsp500_TimerStatusProhibit = 49,
	tsp510_TimerStatusProhibit = 50,
	tsp520_TimerStatusProhibit = 51,
	tsp530_TimerStatusProhibit = 52,
	tsp540_TimerStatusProhibit = 53,
	tsp550_TimerStatusProhibit = 54,
	tsp600_TimerStatusProhibit = 55,
	tsp650_TimerStatusProhibit = 56,
	tsp700_TimerStatusProhibit = 57,
	tsp750_TimerStatusProhibit = 58,
	tsp800_TimerStatusProhibit = 59,
	tsp850_TimerStatusProhibit = 60,
	tsp900_TimerStatusProhibit = 61,
	tsp950_TimerStatusProhibit = 62,
	tsp1000_TimerStatusProhibit = 63,
};
typedef Enumerated<CONSTRAINED, 63> TimerStatusProhibit;

enum TimerEPCValues {
	te50_TimerEPC = 0,
	te60_TimerEPC = 1,
	te70_TimerEPC = 2,
	te80_TimerEPC = 3,
	te90_TimerEPC = 4,
	te100_TimerEPC = 5,
	te120_TimerEPC = 6,
	te140_TimerEPC = 7,
	te160_TimerEPC = 8,
	te180_TimerEPC = 9,
	te200_TimerEPC = 10,
	te300_TimerEPC = 11,
	te400_TimerEPC = 12,
	te500_TimerEPC = 13,
	te700_TimerEPC = 14,
	te900_TimerEPC = 15,
};
typedef Enumerated<CONSTRAINED, 15> TimerEPC;

typedef Boolean DLRLCStatusInfoMissingPDUIndicator;

enum TimerStatusPeriodicValues {
	tsp100_TimerStatusPeriodic = 0,
	tsp200_TimerStatusPeriodic = 1,
	tsp300_TimerStatusPeriodic = 2,
	tsp400_TimerStatusPeriodic = 3,
	tsp500_TimerStatusPeriodic = 4,
	tsp750_TimerStatusPeriodic = 5,
	tsp1000_TimerStatusPeriodic = 6,
	tsp2000_TimerStatusPeriodic = 7,
};
typedef Enumerated<CONSTRAINED, 7> TimerStatusPeriodic;

class DLRLCStatusInfo : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	DLRLCStatusInfo(): Sequence(&theInfo) {}

	void setTimerStatusProhibit(const TimerStatusProhibit& timerStatusProhibit) { *static_cast<TimerStatusProhibit*>(items[0]) = timerStatusProhibit; }
	void setDummy(const TimerEPC& dummy) { *static_cast<TimerEPC*>(items[1]) = dummy; }
	void setDLRLCStatusInfoMissingPDUIndicator(const DLRLCStatusInfoMissingPDUIndicator& dLRLCStatusInfoMissingPDUIndicator) { *static_cast<DLRLCStatusInfoMissingPDUIndicator*>(items[2]) = dLRLCStatusInfoMissingPDUIndicator; }
	void setTimerStatusPeriodic(const TimerStatusPeriodic& timerStatusPeriodic) { *static_cast<TimerStatusPeriodic*>(items[3]) = timerStatusPeriodic; }
};

class DLAMRLCMode : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLAMRLCMode(): Sequence(&theInfo) {}

	void setDLAMRLCModeInSequenceDelivery(const DLAMRLCModeInSequenceDelivery& dLAMRLCModeInSequenceDelivery) { *static_cast<DLAMRLCModeInSequenceDelivery*>(items[0]) = dLAMRLCModeInSequenceDelivery; }
	void setReceivingWindowSize(const ReceivingWindowSize& receivingWindowSize) { *static_cast<ReceivingWindowSize*>(items[1]) = receivingWindowSize; }
	void setDlRLCStatusInfo(const DLRLCStatusInfo& dlRLCStatusInfo) { *static_cast<DLRLCStatusInfo*>(items[2]) = dlRLCStatusInfo; }
};

typedef Integer<CONSTRAINED, 0, 31> OctetModeRLCSizeInfoType1SizeType1;

typedef Integer<CONSTRAINED, 0, 23> OctetModeRLCSizeInfoType1SizeType2Part1;

typedef Integer<CONSTRAINED, 1, 3> OctetModeRLCSizeInfoType1SizeType2Part2;

class OctetModeRLCSizeInfoType1SizeType2 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	OctetModeRLCSizeInfoType1SizeType2(): Sequence(&theInfo) {}

	void setOctetModeRLCSizeInfoType1SizeType2Part1(const OctetModeRLCSizeInfoType1SizeType2Part1& octetModeRLCSizeInfoType1SizeType2Part1) { *static_cast<OctetModeRLCSizeInfoType1SizeType2Part1*>(items[0]) = octetModeRLCSizeInfoType1SizeType2Part1; }
	void setOctetModeRLCSizeInfoType1SizeType2Part2(const OctetModeRLCSizeInfoType1SizeType2Part2& octetModeRLCSizeInfoType1SizeType2Part2) { *static_cast<OctetModeRLCSizeInfoType1SizeType2Part2*>(items[1]) = octetModeRLCSizeInfoType1SizeType2Part2; }
};

typedef Integer<CONSTRAINED, 0, 61> OctetModeRLCSizeInfoType1SizeType3Part1;

typedef Integer<CONSTRAINED, 1, 7> OctetModeRLCSizeInfoType1SizeType3Part2;

class OctetModeRLCSizeInfoType1SizeType3 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	OctetModeRLCSizeInfoType1SizeType3(): Sequence(&theInfo) {}

	void setOctetModeRLCSizeInfoType1SizeType3Part1(const OctetModeRLCSizeInfoType1SizeType3Part1& octetModeRLCSizeInfoType1SizeType3Part1) { *static_cast<OctetModeRLCSizeInfoType1SizeType3Part1*>(items[0]) = octetModeRLCSizeInfoType1SizeType3Part1; }
	void setOctetModeRLCSizeInfoType1SizeType3Part2(const OctetModeRLCSizeInfoType1SizeType3Part2& octetModeRLCSizeInfoType1SizeType3Part2) { *static_cast<OctetModeRLCSizeInfoType1SizeType3Part2*>(items[1]) = octetModeRLCSizeInfoType1SizeType3Part2; }
};

class OctetModeRLCSizeInfoType1 : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum OctetModeRLCSizeInfoType1Choices {
		octetModeRLCSizeInfoType1SizeType1 = 0,
		octetModeRLCSizeInfoType1SizeType2 = 1,
		octetModeRLCSizeInfoType1SizeType3 = 2,
	};
	static const Info theInfo;
	OctetModeRLCSizeInfoType1(): Choice(&theInfo) {}
};

typedef Boolean DLAMRLCModer5InSequenceDelivery;

class DLAMRLCModer5 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	DLAMRLCModer5(): Sequence(&theInfo) {}

	void setDlRLCPDUsize(const OctetModeRLCSizeInfoType1& dlRLCPDUsize) { *static_cast<OctetModeRLCSizeInfoType1*>(items[0]) = dlRLCPDUsize; }
	void setDLAMRLCModer5InSequenceDelivery(const DLAMRLCModer5InSequenceDelivery& dLAMRLCModer5InSequenceDelivery) { *static_cast<DLAMRLCModer5InSequenceDelivery*>(items[1]) = dLAMRLCModer5InSequenceDelivery; }
	void setReceivingWindowSize(const ReceivingWindowSize& receivingWindowSize) { *static_cast<ReceivingWindowSize*>(items[2]) = receivingWindowSize; }
	void setDlRLCStatusInfo(const DLRLCStatusInfo& dlRLCStatusInfo) { *static_cast<DLRLCStatusInfo*>(items[3]) = dlRLCStatusInfo; }
};

enum DLAMRLCModer7DlRLCPDUsizeflexibleSizeValues {
	size7_DLAMRLCModer7DlRLCPDUsizeflexibleSize = 0,
	size15_DLAMRLCModer7DlRLCPDUsizeflexibleSize = 1,
};
typedef Enumerated<CONSTRAINED, 1> DLAMRLCModer7DlRLCPDUsizeflexibleSize;

class DLAMRLCModer7DlRLCPDUsize : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLAMRLCModer7DlRLCPDUsizeChoices {
		fixedSize = 0,
		dLAMRLCModer7DlRLCPDUsizeflexibleSize = 1,
	};
	static const Info theInfo;
	DLAMRLCModer7DlRLCPDUsize(): Choice(&theInfo) {}
};

typedef Boolean DLAMRLCModer7InSequenceDelivery;

class DLAMRLCModer7 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	DLAMRLCModer7(): Sequence(&theInfo) {}

	void setDLAMRLCModer7DlRLCPDUsize(const DLAMRLCModer7DlRLCPDUsize& dLAMRLCModer7DlRLCPDUsize) { *static_cast<DLAMRLCModer7DlRLCPDUsize*>(items[0]) = dLAMRLCModer7DlRLCPDUsize; }
	void setDLAMRLCModer7InSequenceDelivery(const DLAMRLCModer7InSequenceDelivery& dLAMRLCModer7InSequenceDelivery) { *static_cast<DLAMRLCModer7InSequenceDelivery*>(items[1]) = dLAMRLCModer7InSequenceDelivery; }
	void setReceivingWindowSize(const ReceivingWindowSize& receivingWindowSize) { *static_cast<ReceivingWindowSize*>(items[2]) = receivingWindowSize; }
	void setDlRLCStatusInfo(const DLRLCStatusInfo& dlRLCStatusInfo) { *static_cast<DLRLCStatusInfo*>(items[3]) = dlRLCStatusInfo; }
};

typedef Integer<CONSTRAINED, 0, 65535> PDCPSNInfo;

class RBWithPDCPInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RBWithPDCPInfo(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setPdcpSNInfo(const PDCPSNInfo& pdcpSNInfo) { *static_cast<PDCPSNInfo*>(items[1]) = pdcpSNInfo; }
};

typedef SequenceOf<RBWithPDCPInfo, CONSTRAINED, 1, maxRBallRABs> RBWithPDCPInfoList;

class DLCounterSynchronisationInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLCounterSynchronisationInfo(): Sequence(&theInfo) {}

	void setRBWithPDCPInfoList(const RBWithPDCPInfoList& rBWithPDCPInfoList) { *static_cast<RBWithPDCPInfoList*>(items[0]) = rBWithPDCPInfoList; }
};

typedef Boolean RBPDCPContextRelocationDlRFC3095ContextRelocation;

typedef Boolean RBPDCPContextRelocationUlRFC3095ContextRelocation;

class RBPDCPContextRelocation : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	RBPDCPContextRelocation(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setRBPDCPContextRelocationDlRFC3095ContextRelocation(const RBPDCPContextRelocationDlRFC3095ContextRelocation& rBPDCPContextRelocationDlRFC3095ContextRelocation) { *static_cast<RBPDCPContextRelocationDlRFC3095ContextRelocation*>(items[1]) = rBPDCPContextRelocationDlRFC3095ContextRelocation; }
	void setRBPDCPContextRelocationUlRFC3095ContextRelocation(const RBPDCPContextRelocationUlRFC3095ContextRelocation& rBPDCPContextRelocationUlRFC3095ContextRelocation) { *static_cast<RBPDCPContextRelocationUlRFC3095ContextRelocation*>(items[2]) = rBPDCPContextRelocationUlRFC3095ContextRelocation; }
};

typedef SequenceOf<RBPDCPContextRelocation, CONSTRAINED, 1, maxRBallRABs> RBPDCPContextRelocationList;

class DLCounterSynchronisationInfor5 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLCounterSynchronisationInfor5(): Sequence(&theInfo) {}

	void setRbWithPDCPInfoList(const RBWithPDCPInfoList& rbWithPDCPInfoList) { *static_cast<RBWithPDCPInfoList*>(items[0]) = rbWithPDCPInfoList; }
	void setRbPDCPContextRelocationList(const RBPDCPContextRelocationList& rbPDCPContextRelocationList) { *static_cast<RBPDCPContextRelocationList*>(items[1]) = rbPDCPContextRelocationList; }
};

typedef Integer<CONSTRAINED, 1, 32> TransportChannelIdentity;

typedef Null DLTransportChannelTypeFach;

class TransportChannelIdentityDCHandDSCH : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	TransportChannelIdentityDCHandDSCH(): Sequence(&theInfo) {}

	void setDchtransportchid(const TransportChannelIdentity& dchtransportchid) { *static_cast<TransportChannelIdentity*>(items[0]) = dchtransportchid; }
	void setDschtransportchid(const TransportChannelIdentity& dschtransportchid) { *static_cast<TransportChannelIdentity*>(items[1]) = dschtransportchid; }
};

class DLTransportChannelType : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum DLTransportChannelTypeChoices {
		dch = 0,
		dLTransportChannelTypeFach = 1,
		dsch = 2,
		dchanddsch = 3,
	};
	static const Info theInfo;
	DLTransportChannelType(): Choice(&theInfo) {}
};

class DLLogicalChannelMapping : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLLogicalChannelMapping(): Sequence(&theInfo) {}

	void setDlTransportChannelType(const DLTransportChannelType& dlTransportChannelType) { *static_cast<DLTransportChannelType*>(items[0]) = dlTransportChannelType; }
	void setLogicalChannelIdentity(const LogicalChannelIdentity& logicalChannelIdentity) { *static_cast<LogicalChannelIdentity*>(items[1]) = logicalChannelIdentity; }
};

typedef Null DLTransportChannelTyper5Fach;

typedef Integer<CONSTRAINED, 0, 7> MACdFlowIdentity;

class MACdFlowIdentityDCHandHSDSCH : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MACdFlowIdentityDCHandHSDSCH(): Sequence(&theInfo) {}

	void setDchtransportchid(const TransportChannelIdentity& dchtransportchid) { *static_cast<TransportChannelIdentity*>(items[0]) = dchtransportchid; }
	void setHsdschmacdflowid(const MACdFlowIdentity& hsdschmacdflowid) { *static_cast<MACdFlowIdentity*>(items[1]) = hsdschmacdflowid; }
};

class DLTransportChannelTyper5 : public Choice {
private:
	static const void *choicesInfo[6];
public:
	enum DLTransportChannelTyper5Choices {
		dch = 0,
		dLTransportChannelTyper5Fach = 1,
		dsch = 2,
		dchanddsch = 3,
		hsdsch = 4,
		dchandhsdsch = 5,
	};
	static const Info theInfo;
	DLTransportChannelTyper5(): Choice(&theInfo) {}
};

class DLLogicalChannelMappingr5 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLLogicalChannelMappingr5(): Sequence(&theInfo) {}

	void setDlTransportChannelType(const DLTransportChannelTyper5& dlTransportChannelType) { *static_cast<DLTransportChannelTyper5*>(items[0]) = dlTransportChannelType; }
	void setLogicalChannelIdentity(const LogicalChannelIdentity& logicalChannelIdentity) { *static_cast<LogicalChannelIdentity*>(items[1]) = logicalChannelIdentity; }
};

typedef Null DLTransportChannelTyper7Fach;

class DLTransportChannelTyper7Hsdsch : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLTransportChannelTyper7HsdschChoices {
		machs = 0,
		macehs = 1,
	};
	static const Info theInfo;
	DLTransportChannelTyper7Hsdsch(): Choice(&theInfo) {}
};

class MACehsQueueIdDCHandHSDSCH : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MACehsQueueIdDCHandHSDSCH(): Sequence(&theInfo) {}

	void setDchtransportchid(const TransportChannelIdentity& dchtransportchid) { *static_cast<TransportChannelIdentity*>(items[0]) = dchtransportchid; }
	void setHsdschmacehsQueueId(const MACehsQueueId& hsdschmacehsQueueId) { *static_cast<MACehsQueueId*>(items[1]) = hsdschmacehsQueueId; }
};

class DLTransportChannelTyper7Dchandhsdsch : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLTransportChannelTyper7DchandhsdschChoices {
		machs = 0,
		macehs = 1,
	};
	static const Info theInfo;
	DLTransportChannelTyper7Dchandhsdsch(): Choice(&theInfo) {}
};

class DLTransportChannelTyper7 : public Choice {
private:
	static const void *choicesInfo[6];
public:
	enum DLTransportChannelTyper7Choices {
		dch = 0,
		dLTransportChannelTyper7Fach = 1,
		dsch = 2,
		dchanddsch = 3,
		dLTransportChannelTyper7Hsdsch = 4,
		dLTransportChannelTyper7Dchandhsdsch = 5,
	};
	static const Info theInfo;
	DLTransportChannelTyper7(): Choice(&theInfo) {}
};

class DLLogicalChannelMappingr7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLLogicalChannelMappingr7(): Sequence(&theInfo) {}

	void setDlTransportChannelType(const DLTransportChannelTyper7& dlTransportChannelType) { *static_cast<DLTransportChannelTyper7*>(items[0]) = dlTransportChannelType; }
	void setLogicalChannelIdentity(const LogicalChannelIdentity& logicalChannelIdentity) { *static_cast<LogicalChannelIdentity*>(items[1]) = logicalChannelIdentity; }
};

typedef SequenceOf<DLLogicalChannelMapping, CONSTRAINED, 1, maxLoCHperRLC> DLLogicalChannelMappingList;

typedef SequenceOf<DLLogicalChannelMappingr5, CONSTRAINED, 1, maxLoCHperRLC> DLLogicalChannelMappingListr5;

typedef SequenceOf<DLLogicalChannelMappingr7, CONSTRAINED, 1, maxLoCHperRLC> DLLogicalChannelMappingListr7;

enum DLReceptionWindowSizer6Values {
	size32_DLReceptionWindowSizer6 = 0,
	size48_DLReceptionWindowSizer6 = 1,
	size64_DLReceptionWindowSizer6 = 2,
	size80_DLReceptionWindowSizer6 = 3,
	size96_DLReceptionWindowSizer6 = 4,
	size112_DLReceptionWindowSizer6 = 5,
};
typedef Enumerated<CONSTRAINED, 5> DLReceptionWindowSizer6;

typedef Null DLRLCModeDlUMRLCMode;

typedef Boolean DLTMRLCModeSegmentationIndication;

class DLTMRLCMode : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLTMRLCMode(): Sequence(&theInfo) {}

	void setDLTMRLCModeSegmentationIndication(const DLTMRLCModeSegmentationIndication& dLTMRLCModeSegmentationIndication) { *static_cast<DLTMRLCModeSegmentationIndication*>(items[0]) = dLTMRLCModeSegmentationIndication; }
};

class DLRLCMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum DLRLCModeChoices {
		dlAMRLCMode = 0,
		dLRLCModeDlUMRLCMode = 1,
		dlTMRLCMode = 2,
	};
	static const Info theInfo;
	DLRLCMode(): Choice(&theInfo) {}
};

enum DLUMRLCLIsizeValues {
	size7_DLUMRLCLIsize = 0,
	size15_DLUMRLCLIsize = 1,
};
typedef Enumerated<CONSTRAINED, 1> DLUMRLCLIsize;

class DLUMRLCModer5 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLUMRLCModer5(): Sequence(&theInfo) {}

	void setDlUMRLCLIsize(const DLUMRLCLIsize& dlUMRLCLIsize) { *static_cast<DLUMRLCLIsize*>(items[0]) = dlUMRLCLIsize; }
};

class DLRLCModer5 : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum DLRLCModer5Choices {
		dlAMRLCMode = 0,
		dlUMRLCMode = 1,
		dlTMRLCMode = 2,
	};
	static const Info theInfo;
	DLRLCModer5(): Choice(&theInfo) {}
};

class DLUMRLCModer6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLUMRLCModer6(): Sequence(&theInfo) {}

	void setDlUMRLCLIsize(const DLUMRLCLIsize& dlUMRLCLIsize) { *static_cast<DLUMRLCLIsize*>(items[0]) = dlUMRLCLIsize; }
	void setDlReceptionWindowSize(const DLReceptionWindowSizer6& dlReceptionWindowSize) { *static_cast<DLReceptionWindowSizer6*>(items[1]) = dlReceptionWindowSize; }
};

class DLRLCModer6 : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum DLRLCModer6Choices {
		dlAMRLCMode = 0,
		dlUMRLCMode = 1,
		dlTMRLCMode = 2,
	};
	static const Info theInfo;
	DLRLCModer6(): Choice(&theInfo) {}
};

class DLRLCModer7 : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum DLRLCModer7Choices {
		dlAMRLCMode = 0,
		dlUMRLCMode = 1,
		dlTMRLCMode = 2,
	};
	static const Info theInfo;
	DLRLCModer7(): Choice(&theInfo) {}
};

enum TimerMRWValues {
	te50_TimerMRW = 0,
	te60_TimerMRW = 1,
	te70_TimerMRW = 2,
	te80_TimerMRW = 3,
	te90_TimerMRW = 4,
	te100_TimerMRW = 5,
	te120_TimerMRW = 6,
	te140_TimerMRW = 7,
	te160_TimerMRW = 8,
	te180_TimerMRW = 9,
	te200_TimerMRW = 10,
	te300_TimerMRW = 11,
	te400_TimerMRW = 12,
	te500_TimerMRW = 13,
	te700_TimerMRW = 14,
	te900_TimerMRW = 15,
};
typedef Enumerated<CONSTRAINED, 15> TimerMRW;

enum TimerDiscardValues {
	td0_1_TimerDiscard = 0,
	td0_25_TimerDiscard = 1,
	td0_5_TimerDiscard = 2,
	td0_75_TimerDiscard = 3,
	td1_TimerDiscard = 4,
	td1_25_TimerDiscard = 5,
	td1_5_TimerDiscard = 6,
	td1_75_TimerDiscard = 7,
	td2_TimerDiscard = 8,
	td2_5_TimerDiscard = 9,
	td3_TimerDiscard = 10,
	td3_5_TimerDiscard = 11,
	td4_TimerDiscard = 12,
	td4_5_TimerDiscard = 13,
	td5_TimerDiscard = 14,
	td7_5_TimerDiscard = 15,
};
typedef Enumerated<CONSTRAINED, 15> TimerDiscard;

enum MaxMRWValues {
	mm1_MaxMRW = 0,
	mm4_MaxMRW = 1,
	mm6_MaxMRW = 2,
	mm8_MaxMRW = 3,
	mm12_MaxMRW = 4,
	mm16_MaxMRW = 5,
	mm24_MaxMRW = 6,
	mm32_MaxMRW = 7,
};
typedef Enumerated<CONSTRAINED, 7> MaxMRW;

class ExplicitDiscard : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ExplicitDiscard(): Sequence(&theInfo) {}

	void setTimerMRW(const TimerMRW& timerMRW) { *static_cast<TimerMRW*>(items[0]) = timerMRW; }
	void setTimerDiscard(const TimerDiscard& timerDiscard) { *static_cast<TimerDiscard*>(items[1]) = timerDiscard; }
	void setMaxMRW(const MaxMRW& maxMRW) { *static_cast<MaxMRW*>(items[2]) = maxMRW; }
};

class HeaderCompressionInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	HeaderCompressionInfo(): Sequence(&theInfo) {}

	void setAlgorithmSpecificInfo(const AlgorithmSpecificInfo& algorithmSpecificInfo) { *static_cast<AlgorithmSpecificInfo*>(items[0]) = algorithmSpecificInfo; }
};

typedef SequenceOf<HeaderCompressionInfo, CONSTRAINED, 1, maxPDCPAlgoType> HeaderCompressionInfoList;

class HeaderCompressionInfor4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	HeaderCompressionInfor4(): Sequence(&theInfo) {}

	void setAlgorithmSpecificInfo(const AlgorithmSpecificInfor4& algorithmSpecificInfo) { *static_cast<AlgorithmSpecificInfor4*>(items[0]) = algorithmSpecificInfo; }
};

typedef SequenceOf<HeaderCompressionInfor4, CONSTRAINED, 1, maxPDCPAlgoType> HeaderCompressionInfoListr4;

enum MaxPDCPSNWindowSizeValues {
	sn255_MaxPDCPSNWindowSize = 0,
	sn65535_MaxPDCPSNWindowSize = 1,
};
typedef Enumerated<CONSTRAINED, 1> MaxPDCPSNWindowSize;

typedef Null LosslessSRNSRelocSupportNotSupported;

class LosslessSRNSRelocSupport : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum LosslessSRNSRelocSupportChoices {
		supported = 0,
		losslessSRNSRelocSupportNotSupported = 1,
	};
	static const Info theInfo;
	LosslessSRNSRelocSupport(): Choice(&theInfo) {}
};

typedef BitString<CONSTRAINED, 24, 24> MACdHFNinitialvalue;

typedef Integer<CONSTRAINED, 1, 8> MACLogicalChannelPriority;

enum MaxDATValues {
	dat1_MaxDAT = 0,
	dat2_MaxDAT = 1,
	dat3_MaxDAT = 2,
	dat4_MaxDAT = 3,
	dat5_MaxDAT = 4,
	dat6_MaxDAT = 5,
	dat7_MaxDAT = 6,
	dat8_MaxDAT = 7,
	dat9_MaxDAT = 8,
	dat10_MaxDAT = 9,
	dat15_MaxDAT = 10,
	dat20_MaxDAT = 11,
	dat25_MaxDAT = 12,
	dat30_MaxDAT = 13,
	dat35_MaxDAT = 14,
	dat40_MaxDAT = 15,
};
typedef Enumerated<CONSTRAINED, 15> MaxDAT;

class MaxDATRetransmissions : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MaxDATRetransmissions(): Sequence(&theInfo) {}

	void setMaxDAT(const MaxDAT& maxDAT) { *static_cast<MaxDAT*>(items[0]) = maxDAT; }
	void setTimerMRW(const TimerMRW& timerMRW) { *static_cast<TimerMRW*>(items[1]) = timerMRW; }
	void setMaxMRW(const MaxMRW& maxMRW) { *static_cast<MaxMRW*>(items[2]) = maxMRW; }
};

enum MaxRSTValues {
	rst1_MaxRST = 0,
	rst4_MaxRST = 1,
	rst6_MaxRST = 2,
	rst8_MaxRST = 3,
	rst12_MaxRST = 4,
	rst16_MaxRST = 5,
	rst24_MaxRST = 6,
	rst32_MaxRST = 7,
};
typedef Enumerated<CONSTRAINED, 7> MaxRST;

enum NoExplicitDiscardValues {
	dt10_NoExplicitDiscard = 0,
	dt20_NoExplicitDiscard = 1,
	dt30_NoExplicitDiscard = 2,
	dt40_NoExplicitDiscard = 3,
	dt50_NoExplicitDiscard = 4,
	dt60_NoExplicitDiscard = 5,
	dt70_NoExplicitDiscard = 6,
	dt80_NoExplicitDiscard = 7,
	dt90_NoExplicitDiscard = 8,
	dt100_NoExplicitDiscard = 9,
};
typedef Enumerated<CONSTRAINED, 9> NoExplicitDiscard;

enum PDCPPDUHeaderValues {
	present_PDCPPDUHeader = 0,
	absent_PDCPPDUHeader = 1,
};
typedef Enumerated<CONSTRAINED, 1> PDCPPDUHeader;

class PDCPInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PDCPInfo(): Sequence(&theInfo) {}

	void setLosslessSRNSRelocSupport(const LosslessSRNSRelocSupport& losslessSRNSRelocSupport) { *static_cast<LosslessSRNSRelocSupport*>(items[0]) = losslessSRNSRelocSupport; }
	void setPdcpPDUHeader(const PDCPPDUHeader& pdcpPDUHeader) { *static_cast<PDCPPDUHeader*>(items[1]) = pdcpPDUHeader; }
	void setHeaderCompressionInfoList(const HeaderCompressionInfoList& headerCompressionInfoList) { *static_cast<HeaderCompressionInfoList*>(items[2]) = headerCompressionInfoList; }
};

class PDCPInfor4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PDCPInfor4(): Sequence(&theInfo) {}

	void setLosslessSRNSRelocSupport(const LosslessSRNSRelocSupport& losslessSRNSRelocSupport) { *static_cast<LosslessSRNSRelocSupport*>(items[0]) = losslessSRNSRelocSupport; }
	void setPdcpPDUHeader(const PDCPPDUHeader& pdcpPDUHeader) { *static_cast<PDCPPDUHeader*>(items[1]) = pdcpPDUHeader; }
	void setHeaderCompressionInfoList(const HeaderCompressionInfoListr4& headerCompressionInfoList) { *static_cast<HeaderCompressionInfoListr4*>(items[2]) = headerCompressionInfoList; }
};

typedef Integer<CONSTRAINED, 0, 65535> PDCPInfoReconfigDummy;

class PDCPInfoReconfig : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PDCPInfoReconfig(): Sequence(&theInfo) {}

	void setPdcpInfo(const PDCPInfo& pdcpInfo) { *static_cast<PDCPInfo*>(items[0]) = pdcpInfo; }
	void setPDCPInfoReconfigDummy(const PDCPInfoReconfigDummy& pDCPInfoReconfigDummy) { *static_cast<PDCPInfoReconfigDummy*>(items[1]) = pDCPInfoReconfigDummy; }
};

class PDCPInfoReconfigr4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PDCPInfoReconfigr4(): Sequence(&theInfo) {}

	void setPdcpInfo(const PDCPInfor4& pdcpInfo) { *static_cast<PDCPInfor4*>(items[0]) = pdcpInfo; }
};

enum PDCPROHCTargetModeValues {
	o_Mode_PDCPROHCTargetMode = 0,
	r_Mode_PDCPROHCTargetMode = 1,
};
typedef Enumerated<CONSTRAINED, 1> PDCPROHCTargetMode;

enum PollPDUValues {
	pdu1_PollPDU = 0,
	pdu2_PollPDU = 1,
	pdu4_PollPDU = 2,
	pdu8_PollPDU = 3,
	pdu16_PollPDU = 4,
	pdu32_PollPDU = 5,
	pdu64_PollPDU = 6,
	pdu128_PollPDU = 7,
};
typedef Enumerated<CONSTRAINED, 7> PollPDU;

enum PollSDUValues {
	sdu1_PollSDU = 0,
	sdu4_PollSDU = 1,
	sdu16_PollSDU = 2,
	sdu64_PollSDU = 3,
};
typedef Enumerated<CONSTRAINED, 3> PollSDU;

enum TimerPollProhibitValues {
	tpp10_TimerPollProhibit = 0,
	tpp20_TimerPollProhibit = 1,
	tpp30_TimerPollProhibit = 2,
	tpp40_TimerPollProhibit = 3,
	tpp50_TimerPollProhibit = 4,
	tpp60_TimerPollProhibit = 5,
	tpp70_TimerPollProhibit = 6,
	tpp80_TimerPollProhibit = 7,
	tpp90_TimerPollProhibit = 8,
	tpp100_TimerPollProhibit = 9,
	tpp110_TimerPollProhibit = 10,
	tpp120_TimerPollProhibit = 11,
	tpp130_TimerPollProhibit = 12,
	tpp140_TimerPollProhibit = 13,
	tpp150_TimerPollProhibit = 14,
	tpp160_TimerPollProhibit = 15,
	tpp170_TimerPollProhibit = 16,
	tpp180_TimerPollProhibit = 17,
	tpp190_TimerPollProhibit = 18,
	tpp200_TimerPollProhibit = 19,
	tpp210_TimerPollProhibit = 20,
	tpp220_TimerPollProhibit = 21,
	tpp230_TimerPollProhibit = 22,
	tpp240_TimerPollProhibit = 23,
	tpp250_TimerPollProhibit = 24,
	tpp260_TimerPollProhibit = 25,
	tpp270_TimerPollProhibit = 26,
	tpp280_TimerPollProhibit = 27,
	tpp290_TimerPollProhibit = 28,
	tpp300_TimerPollProhibit = 29,
	tpp310_TimerPollProhibit = 30,
	tpp320_TimerPollProhibit = 31,
	tpp330_TimerPollProhibit = 32,
	tpp340_TimerPollProhibit = 33,
	tpp350_TimerPollProhibit = 34,
	tpp360_TimerPollProhibit = 35,
	tpp370_TimerPollProhibit = 36,
	tpp380_TimerPollProhibit = 37,
	tpp390_TimerPollProhibit = 38,
	tpp400_TimerPollProhibit = 39,
	tpp410_TimerPollProhibit = 40,
	tpp420_TimerPollProhibit = 41,
	tpp430_TimerPollProhibit = 42,
	tpp440_TimerPollProhibit = 43,
	tpp450_TimerPollProhibit = 44,
	tpp460_TimerPollProhibit = 45,
	tpp470_TimerPollProhibit = 46,
	tpp480_TimerPollProhibit = 47,
	tpp490_TimerPollProhibit = 48,
	tpp500_TimerPollProhibit = 49,
	tpp510_TimerPollProhibit = 50,
	tpp520_TimerPollProhibit = 51,
	tpp530_TimerPollProhibit = 52,
	tpp540_TimerPollProhibit = 53,
	tpp550_TimerPollProhibit = 54,
	tpp600_TimerPollProhibit = 55,
	tpp650_TimerPollProhibit = 56,
	tpp700_TimerPollProhibit = 57,
	tpp750_TimerPollProhibit = 58,
	tpp800_TimerPollProhibit = 59,
	tpp850_TimerPollProhibit = 60,
	tpp900_TimerPollProhibit = 61,
	tpp950_TimerPollProhibit = 62,
	tpp1000_TimerPollProhibit = 63,
};
typedef Enumerated<CONSTRAINED, 63> TimerPollProhibit;

enum TimerPollValues {
	tp10_TimerPoll = 0,
	tp20_TimerPoll = 1,
	tp30_TimerPoll = 2,
	tp40_TimerPoll = 3,
	tp50_TimerPoll = 4,
	tp60_TimerPoll = 5,
	tp70_TimerPoll = 6,
	tp80_TimerPoll = 7,
	tp90_TimerPoll = 8,
	tp100_TimerPoll = 9,
	tp110_TimerPoll = 10,
	tp120_TimerPoll = 11,
	tp130_TimerPoll = 12,
	tp140_TimerPoll = 13,
	tp150_TimerPoll = 14,
	tp160_TimerPoll = 15,
	tp170_TimerPoll = 16,
	tp180_TimerPoll = 17,
	tp190_TimerPoll = 18,
	tp200_TimerPoll = 19,
	tp210_TimerPoll = 20,
	tp220_TimerPoll = 21,
	tp230_TimerPoll = 22,
	tp240_TimerPoll = 23,
	tp250_TimerPoll = 24,
	tp260_TimerPoll = 25,
	tp270_TimerPoll = 26,
	tp280_TimerPoll = 27,
	tp290_TimerPoll = 28,
	tp300_TimerPoll = 29,
	tp310_TimerPoll = 30,
	tp320_TimerPoll = 31,
	tp330_TimerPoll = 32,
	tp340_TimerPoll = 33,
	tp350_TimerPoll = 34,
	tp360_TimerPoll = 35,
	tp370_TimerPoll = 36,
	tp380_TimerPoll = 37,
	tp390_TimerPoll = 38,
	tp400_TimerPoll = 39,
	tp410_TimerPoll = 40,
	tp420_TimerPoll = 41,
	tp430_TimerPoll = 42,
	tp440_TimerPoll = 43,
	tp450_TimerPoll = 44,
	tp460_TimerPoll = 45,
	tp470_TimerPoll = 46,
	tp480_TimerPoll = 47,
	tp490_TimerPoll = 48,
	tp500_TimerPoll = 49,
	tp510_TimerPoll = 50,
	tp520_TimerPoll = 51,
	tp530_TimerPoll = 52,
	tp540_TimerPoll = 53,
	tp550_TimerPoll = 54,
	tp600_TimerPoll = 55,
	tp650_TimerPoll = 56,
	tp700_TimerPoll = 57,
	tp750_TimerPoll = 58,
	tp800_TimerPoll = 59,
	tp850_TimerPoll = 60,
	tp900_TimerPoll = 61,
	tp950_TimerPoll = 62,
	tp1000_TimerPoll = 63,
};
typedef Enumerated<CONSTRAINED, 63> TimerPoll;

typedef Boolean PollingInfoLastTransmissionPDUPoll;

typedef Boolean PollingInfoLastRetransmissionPDUPoll;

enum PollWindowValues {
	pw50_PollWindow = 0,
	pw60_PollWindow = 1,
	pw70_PollWindow = 2,
	pw80_PollWindow = 3,
	pw85_PollWindow = 4,
	pw90_PollWindow = 5,
	pw95_PollWindow = 6,
	pw99_PollWindow = 7,
};
typedef Enumerated<CONSTRAINED, 7> PollWindow;

enum TimerPollPeriodicValues {
	tper100_TimerPollPeriodic = 0,
	tper200_TimerPollPeriodic = 1,
	tper300_TimerPollPeriodic = 2,
	tper400_TimerPollPeriodic = 3,
	tper500_TimerPollPeriodic = 4,
	tper750_TimerPollPeriodic = 5,
	tper1000_TimerPollPeriodic = 6,
	tper2000_TimerPollPeriodic = 7,
};
typedef Enumerated<CONSTRAINED, 7> TimerPollPeriodic;

class PollingInfo : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	PollingInfo(): Sequence(&theInfo) {}

	void setTimerPollProhibit(const TimerPollProhibit& timerPollProhibit) { *static_cast<TimerPollProhibit*>(items[0]) = timerPollProhibit; }
	void setTimerPoll(const TimerPoll& timerPoll) { *static_cast<TimerPoll*>(items[1]) = timerPoll; }
	void setPollPDU(const PollPDU& pollPDU) { *static_cast<PollPDU*>(items[2]) = pollPDU; }
	void setPollSDU(const PollSDU& pollSDU) { *static_cast<PollSDU*>(items[3]) = pollSDU; }
	void setPollingInfoLastTransmissionPDUPoll(const PollingInfoLastTransmissionPDUPoll& pollingInfoLastTransmissionPDUPoll) { *static_cast<PollingInfoLastTransmissionPDUPoll*>(items[4]) = pollingInfoLastTransmissionPDUPoll; }
	void setPollingInfoLastRetransmissionPDUPoll(const PollingInfoLastRetransmissionPDUPoll& pollingInfoLastRetransmissionPDUPoll) { *static_cast<PollingInfoLastRetransmissionPDUPoll*>(items[5]) = pollingInfoLastRetransmissionPDUPoll; }
	void setPollWindow(const PollWindow& pollWindow) { *static_cast<PollWindow*>(items[6]) = pollWindow; }
	void setTimerPollPeriodic(const TimerPollPeriodic& timerPollPeriodic) { *static_cast<TimerPollPeriodic*>(items[7]) = timerPollPeriodic; }
};

typedef Integer<CONSTRAINED, 0, 15> PredefinedConfigIdentity;

typedef Integer<CONSTRAINED, 0, 15> PredefinedConfigValueTag;

class TransmissionRLCDiscard : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum TransmissionRLCDiscardChoices {
		timerBasedExplicit = 0,
		timerBasedNoExplicit = 1,
		maxDATRetransmissions = 2,
		noDiscard = 3,
	};
	static const Info theInfo;
	TransmissionRLCDiscard(): Choice(&theInfo) {}
};

enum TransmissionWindowSizeValues {
	tw1_TransmissionWindowSize = 0,
	tw8_TransmissionWindowSize = 1,
	tw16_TransmissionWindowSize = 2,
	tw32_TransmissionWindowSize = 3,
	tw64_TransmissionWindowSize = 4,
	tw128_TransmissionWindowSize = 5,
	tw256_TransmissionWindowSize = 6,
	tw512_TransmissionWindowSize = 7,
	tw768_TransmissionWindowSize = 8,
	tw1024_TransmissionWindowSize = 9,
	tw1536_TransmissionWindowSize = 10,
	tw2047_TransmissionWindowSize = 11,
	tw2560_TransmissionWindowSize = 12,
	tw3072_TransmissionWindowSize = 13,
	tw3584_TransmissionWindowSize = 14,
	tw4095_TransmissionWindowSize = 15,
};
typedef Enumerated<CONSTRAINED, 15> TransmissionWindowSize;

enum TimerRSTValues {
	tr50_TimerRST = 0,
	tr100_TimerRST = 1,
	tr150_TimerRST = 2,
	tr200_TimerRST = 3,
	tr250_TimerRST = 4,
	tr300_TimerRST = 5,
	tr350_TimerRST = 6,
	tr400_TimerRST = 7,
	tr450_TimerRST = 8,
	tr500_TimerRST = 9,
	tr550_TimerRST = 10,
	tr600_TimerRST = 11,
	tr700_TimerRST = 12,
	tr800_TimerRST = 13,
	tr900_TimerRST = 14,
	tr1000_TimerRST = 15,
};
typedef Enumerated<CONSTRAINED, 15> TimerRST;

class ULAMRLCMode : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	ULAMRLCMode(): Sequence(&theInfo) {}

	void setTransmissionRLCDiscard(const TransmissionRLCDiscard& transmissionRLCDiscard) { *static_cast<TransmissionRLCDiscard*>(items[0]) = transmissionRLCDiscard; }
	void setTransmissionWindowSize(const TransmissionWindowSize& transmissionWindowSize) { *static_cast<TransmissionWindowSize*>(items[1]) = transmissionWindowSize; }
	void setTimerRST(const TimerRST& timerRST) { *static_cast<TimerRST*>(items[2]) = timerRST; }
	void setMaxRST(const MaxRST& maxRST) { *static_cast<MaxRST*>(items[3]) = maxRST; }
	void setPollingInfo(const PollingInfo& pollingInfo) { *static_cast<PollingInfo*>(items[4]) = pollingInfo; }
};

class ULUMRLCMode : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULUMRLCMode(): Sequence(&theInfo) {}

	void setTransmissionRLCDiscard(const TransmissionRLCDiscard& transmissionRLCDiscard) { *static_cast<TransmissionRLCDiscard*>(items[0]) = transmissionRLCDiscard; }
};

typedef Boolean ULTMRLCModeSegmentationIndication;

class ULTMRLCMode : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULTMRLCMode(): Sequence(&theInfo) {}

	void setTransmissionRLCDiscard(const TransmissionRLCDiscard& transmissionRLCDiscard) { *static_cast<TransmissionRLCDiscard*>(items[0]) = transmissionRLCDiscard; }
	void setULTMRLCModeSegmentationIndication(const ULTMRLCModeSegmentationIndication& uLTMRLCModeSegmentationIndication) { *static_cast<ULTMRLCModeSegmentationIndication*>(items[1]) = uLTMRLCModeSegmentationIndication; }
};

typedef Null ULRLCModeSpare;

class ULRLCMode : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum ULRLCModeChoices {
		ulAMRLCMode = 0,
		ulUMRLCMode = 1,
		ulTMRLCMode = 2,
		uLRLCModeSpare = 3,
	};
	static const Info theInfo;
	ULRLCMode(): Choice(&theInfo) {}
};

class RLCInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RLCInfo(): Sequence(&theInfo) {}

	void setUlRLCMode(const ULRLCMode& ulRLCMode) { *static_cast<ULRLCMode*>(items[0]) = ulRLCMode; }
	void setDlRLCMode(const DLRLCMode& dlRLCMode) { *static_cast<DLRLCMode*>(items[1]) = dlRLCMode; }
};

class RLCInfoChoice : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum RLCInfoChoiceChoices {
		rlcInfo = 0,
		sameasRB = 1,
	};
	static const Info theInfo;
	RLCInfoChoice(): Choice(&theInfo) {}
};

typedef Null ULTransportChannelTypeRach;

typedef Null ULTransportChannelTypeDummy;

class ULTransportChannelType : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum ULTransportChannelTypeChoices {
		dch = 0,
		uLTransportChannelTypeRach = 1,
		uLTransportChannelTypeDummy = 2,
		usch = 3,
	};
	static const Info theInfo;
	ULTransportChannelType(): Choice(&theInfo) {}
};

typedef Null ULLogicalChannelMappingRlcSizeListAllSizes;

typedef Null ULLogicalChannelMappingRlcSizeListConfigured;

typedef Integer<CONSTRAINED, 1, maxTF> RLCSizeInfoRlcSizeIndex;

class RLCSizeInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	RLCSizeInfo(): Sequence(&theInfo) {}

	void setRLCSizeInfoRlcSizeIndex(const RLCSizeInfoRlcSizeIndex& rLCSizeInfoRlcSizeIndex) { *static_cast<RLCSizeInfoRlcSizeIndex*>(items[0]) = rLCSizeInfoRlcSizeIndex; }
};

typedef SequenceOf<RLCSizeInfo, CONSTRAINED, 1, maxTF> RLCSizeExplicitList;

class ULLogicalChannelMappingRlcSizeList : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum ULLogicalChannelMappingRlcSizeListChoices {
		uLLogicalChannelMappingRlcSizeListAllSizes = 0,
		uLLogicalChannelMappingRlcSizeListConfigured = 1,
		explicitList = 2,
	};
	static const Info theInfo;
	ULLogicalChannelMappingRlcSizeList(): Choice(&theInfo) {}
};

class ULLogicalChannelMapping : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	ULLogicalChannelMapping(): Sequence(&theInfo) {}

	void setUlTransportChannelType(const ULTransportChannelType& ulTransportChannelType) { *static_cast<ULTransportChannelType*>(items[0]) = ulTransportChannelType; }
	void setLogicalChannelIdentity(const LogicalChannelIdentity& logicalChannelIdentity) { *static_cast<LogicalChannelIdentity*>(items[1]) = logicalChannelIdentity; }
	void setULLogicalChannelMappingRlcSizeList(const ULLogicalChannelMappingRlcSizeList& uLLogicalChannelMappingRlcSizeList) { *static_cast<ULLogicalChannelMappingRlcSizeList*>(items[2]) = uLLogicalChannelMappingRlcSizeList; }
	void setMacLogicalChannelPriority(const MACLogicalChannelPriority& macLogicalChannelPriority) { *static_cast<MACLogicalChannelPriority*>(items[3]) = macLogicalChannelPriority; }
};

typedef Boolean ULLogicalChannelMappingListRlcLogicalChannelMappingIndicator;

typedef SequenceOf<ULLogicalChannelMapping, CONSTRAINED, maxLoCHperRLC, maxLoCHperRLC> ULLogicalChannelMappingListUlLogicalChannelMapping;

class ULLogicalChannelMappingList : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULLogicalChannelMappingList(): Sequence(&theInfo) {}

	void setULLogicalChannelMappingListRlcLogicalChannelMappingIndicator(const ULLogicalChannelMappingListRlcLogicalChannelMappingIndicator& uLLogicalChannelMappingListRlcLogicalChannelMappingIndicator) { *static_cast<ULLogicalChannelMappingListRlcLogicalChannelMappingIndicator*>(items[0]) = uLLogicalChannelMappingListRlcLogicalChannelMappingIndicator; }
	void setULLogicalChannelMappingListUlLogicalChannelMapping(const ULLogicalChannelMappingListUlLogicalChannelMapping& uLLogicalChannelMappingListUlLogicalChannelMapping) { *static_cast<ULLogicalChannelMappingListUlLogicalChannelMapping*>(items[1]) = uLLogicalChannelMappingListUlLogicalChannelMapping; }
};

class ULLogicalChannelMappings : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULLogicalChannelMappingsChoices {
		oneLogicalChannel = 0,
		twoLogicalChannels = 1,
	};
	static const Info theInfo;
	ULLogicalChannelMappings(): Choice(&theInfo) {}
};

class RBMappingOption : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RBMappingOption(): Sequence(&theInfo) {}

	void setUlLogicalChannelMappings(const ULLogicalChannelMappings& ulLogicalChannelMappings) { *static_cast<ULLogicalChannelMappings*>(items[0]) = ulLogicalChannelMappings; }
	void setDlLogicalChannelMappingList(const DLLogicalChannelMappingList& dlLogicalChannelMappingList) { *static_cast<DLLogicalChannelMappingList*>(items[1]) = dlLogicalChannelMappingList; }
};

typedef SequenceOf<RBMappingOption, CONSTRAINED, 1, maxRBMuxOptions> RBMappingInfo;

class SRBInformationSetup : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SRBInformationSetup(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setRlcInfoChoice(const RLCInfoChoice& rlcInfoChoice) { *static_cast<RLCInfoChoice*>(items[1]) = rlcInfoChoice; }
	void setRbMappingInfo(const RBMappingInfo& rbMappingInfo) { *static_cast<RBMappingInfo*>(items[2]) = rbMappingInfo; }
};

typedef SequenceOf<SRBInformationSetup, CONSTRAINED, 1, maxSRBsetup> SRBInformationSetupList;

class RBInformationSetup : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	RBInformationSetup(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setPdcpInfo(const PDCPInfo& pdcpInfo) { *static_cast<PDCPInfo*>(items[1]) = pdcpInfo; }
	void setRlcInfoChoice(const RLCInfoChoice& rlcInfoChoice) { *static_cast<RLCInfoChoice*>(items[2]) = rlcInfoChoice; }
	void setRbMappingInfo(const RBMappingInfo& rbMappingInfo) { *static_cast<RBMappingInfo*>(items[3]) = rbMappingInfo; }
};

typedef SequenceOf<RBInformationSetup, CONSTRAINED, 1, maxRBperRAB> RBInformationSetupList;

class PredefinedRBConfiguration : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PredefinedRBConfiguration(): Sequence(&theInfo) {}

	void setReEstablishmentTimer(const ReEstablishmentTimer& reEstablishmentTimer) { *static_cast<ReEstablishmentTimer*>(items[0]) = reEstablishmentTimer; }
	void setSrbInformationList(const SRBInformationSetupList& srbInformationList) { *static_cast<SRBInformationSetupList*>(items[1]) = srbInformationList; }
	void setRbInformationList(const RBInformationSetupList& rbInformationList) { *static_cast<RBInformationSetupList*>(items[2]) = rbInformationList; }
};

typedef Integer<CONSTRAINED, 0, 1023> TFCValue;

typedef SequenceOf<TFCValue, CONSTRAINED, 1, maxTFC> AllowedTFCList;

typedef SequenceOf<TFCValue, CONSTRAINED, 1, maxTFC> NonallowedTFCList;

enum ULTrCHTypeValues {
	dch_ULTrCHType = 0,
	usch_ULTrCHType = 1,
};
typedef Enumerated<CONSTRAINED, 1> ULTrCHType;

typedef Integer<CONSTRAINED, 0, 31> AllowedTFIListItem;

typedef SequenceOf<AllowedTFIListItem, CONSTRAINED, 1, maxTF> AllowedTFIList;

class RestrictedTrChInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	RestrictedTrChInfo(): Sequence(&theInfo) {}

	void setUlTransportChannelType(const ULTrCHType& ulTransportChannelType) { *static_cast<ULTrCHType*>(items[0]) = ulTransportChannelType; }
	void setRestrictedTrChIdentity(const TransportChannelIdentity& restrictedTrChIdentity) { *static_cast<TransportChannelIdentity*>(items[1]) = restrictedTrChIdentity; }
	void setAllowedTFIList(const AllowedTFIList& allowedTFIList) { *static_cast<AllowedTFIList*>(items[2]) = allowedTFIList; }
};

typedef SequenceOf<RestrictedTrChInfo, CONSTRAINED, 1, maxTrCH> RestrictedTrChInfoList;

typedef Null TFCSubsetFullTFCS;

class TFCSubset : public Choice {
private:
	static const void *choicesInfo[5];
public:
	enum TFCSubsetChoices {
		minimumAllowedTFCNumber = 0,
		allowedTFCList = 1,
		nonallowedTFCList = 2,
		restrictedTrChInfoList = 3,
		tFCSubsetFullTFCS = 4,
	};
	static const Info theInfo;
	TFCSubset(): Choice(&theInfo) {}
};

class TFCSReconfAddCtfcSizeCtfc2Bit : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	TFCSReconfAddCtfcSizeCtfc2Bit(): Sequence(&theInfo) {}

};

class TFCSReconfAddCtfcSizeCtfc4Bit : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	TFCSReconfAddCtfcSizeCtfc4Bit(): Sequence(&theInfo) {}

};

class TFCSReconfAddCtfcSizeCtfc6Bit : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	TFCSReconfAddCtfcSizeCtfc6Bit(): Sequence(&theInfo) {}

};

class TFCSReconfAddCtfcSizeCtfc8Bit : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	TFCSReconfAddCtfcSizeCtfc8Bit(): Sequence(&theInfo) {}

};

class TFCSReconfAddCtfcSizeCtfc12Bit : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	TFCSReconfAddCtfcSizeCtfc12Bit(): Sequence(&theInfo) {}

};

class TFCSReconfAddCtfcSizeCtfc16Bit : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	TFCSReconfAddCtfcSizeCtfc16Bit(): Sequence(&theInfo) {}

};

class TFCSReconfAddCtfcSizeCtfc24Bit : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	TFCSReconfAddCtfcSizeCtfc24Bit(): Sequence(&theInfo) {}

};

class TFCSReconfAddCtfcSize : public Choice {
private:
	static const void *choicesInfo[7];
public:
	enum TFCSReconfAddCtfcSizeChoices {
		tFCSReconfAddCtfcSizeCtfc2Bit = 0,
		tFCSReconfAddCtfcSizeCtfc4Bit = 1,
		tFCSReconfAddCtfcSizeCtfc6Bit = 2,
		tFCSReconfAddCtfcSizeCtfc8Bit = 3,
		tFCSReconfAddCtfcSizeCtfc12Bit = 4,
		tFCSReconfAddCtfcSizeCtfc16Bit = 5,
		tFCSReconfAddCtfcSizeCtfc24Bit = 6,
	};
	static const Info theInfo;
	TFCSReconfAddCtfcSize(): Choice(&theInfo) {}
};

class TFCSReconfAdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	TFCSReconfAdd(): Sequence(&theInfo) {}

	void setTFCSReconfAddCtfcSize(const TFCSReconfAddCtfcSize& tFCSReconfAddCtfcSize) { *static_cast<TFCSReconfAddCtfcSize*>(items[0]) = tFCSReconfAddCtfcSize; }
};

typedef Integer<CONSTRAINED, 0, 1023> TFCSRemovalTfci;

class TFCSRemoval : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	TFCSRemoval(): Sequence(&theInfo) {}

	void setTFCSRemovalTfci(const TFCSRemovalTfci& tFCSRemovalTfci) { *static_cast<TFCSRemovalTfci*>(items[0]) = tFCSRemovalTfci; }
};

typedef SequenceOf<TFCSRemoval, CONSTRAINED, 1, maxTFC> TFCSRemovalList;

class ExplicitTFCSConfigurationReplacement : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ExplicitTFCSConfigurationReplacement(): Sequence(&theInfo) {}

	void setTfcsRemoval(const TFCSRemovalList& tfcsRemoval) { *static_cast<TFCSRemovalList*>(items[0]) = tfcsRemoval; }
	void setTfcsAdd(const TFCSReconfAdd& tfcsAdd) { *static_cast<TFCSReconfAdd*>(items[1]) = tfcsAdd; }
};

class ExplicitTFCSConfiguration : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum ExplicitTFCSConfigurationChoices {
		complete = 0,
		addition = 1,
		removal = 2,
		explicitTFCSConfigurationReplacement = 3,
	};
	static const Info theInfo;
	ExplicitTFCSConfiguration(): Choice(&theInfo) {}
};

enum SplitTypeValues {
	hardSplit_SplitType = 0,
	logicalSplit_SplitType = 1,
};
typedef Enumerated<CONSTRAINED, 1> SplitType;

typedef Integer<CONSTRAINED, 1, 10> SplitTFCISignallingTfciField2Length;

typedef Integer<CONSTRAINED, 1, 1023> TFCIRangeMaxTFCIField2Value;

typedef Integer<CONSTRAINED, 0, 3> TFCSInfoForDSCHCtfc2bit;

typedef Integer<CONSTRAINED, 0, 15> TFCSInfoForDSCHCtfc4bit;

typedef Integer<CONSTRAINED, 0, 63> TFCSInfoForDSCHCtfc6bit;

typedef Integer<CONSTRAINED, 0, 255> TFCSInfoForDSCHCtfc8bit;

typedef Integer<CONSTRAINED, 0, 4095> TFCSInfoForDSCHCtfc12bit;

typedef Integer<CONSTRAINED, 0, 65535> TFCSInfoForDSCHCtfc16bit;

typedef Integer<CONSTRAINED, 0, 16777215> TFCSInfoForDSCHCtfc24bit;

class TFCSInfoForDSCH : public Choice {
private:
	static const void *choicesInfo[7];
public:
	enum TFCSInfoForDSCHChoices {
		tFCSInfoForDSCHCtfc2bit = 0,
		tFCSInfoForDSCHCtfc4bit = 1,
		tFCSInfoForDSCHCtfc6bit = 2,
		tFCSInfoForDSCHCtfc8bit = 3,
		tFCSInfoForDSCHCtfc12bit = 4,
		tFCSInfoForDSCHCtfc16bit = 5,
		tFCSInfoForDSCHCtfc24bit = 6,
	};
	static const Info theInfo;
	TFCSInfoForDSCH(): Choice(&theInfo) {}
};

class TFCIRange : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	TFCIRange(): Sequence(&theInfo) {}

	void setTFCIRangeMaxTFCIField2Value(const TFCIRangeMaxTFCIField2Value& tFCIRangeMaxTFCIField2Value) { *static_cast<TFCIRangeMaxTFCIField2Value*>(items[0]) = tFCIRangeMaxTFCIField2Value; }
	void setTfcsInfoForDSCH(const TFCSInfoForDSCH& tfcsInfoForDSCH) { *static_cast<TFCSInfoForDSCH*>(items[1]) = tfcsInfoForDSCH; }
};

typedef SequenceOf<TFCIRange, CONSTRAINED, 1, maxPDSCH_TFCIgroups> TFCIRangeList;

class TFCIField2Information : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum TFCIField2InformationChoices {
		tfciRange = 0,
		explicitconfig = 1,
	};
	static const Info theInfo;
	TFCIField2Information(): Choice(&theInfo) {}
};

class SplitTFCISignalling : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SplitTFCISignalling(): Sequence(&theInfo) {}

	void setSplitType(const SplitType& splitType) { *static_cast<SplitType*>(items[0]) = splitType; }
	void setSplitTFCISignallingTfciField2Length(const SplitTFCISignallingTfciField2Length& splitTFCISignallingTfciField2Length) { *static_cast<SplitTFCISignallingTfciField2Length*>(items[1]) = splitTFCISignallingTfciField2Length; }
	void setTfciField1Information(const ExplicitTFCSConfiguration& tfciField1Information) { *static_cast<ExplicitTFCSConfiguration*>(items[2]) = tfciField1Information; }
	void setTfciField2Information(const TFCIField2Information& tfciField2Information) { *static_cast<TFCIField2Information*>(items[3]) = tfciField2Information; }
};

class TFCS : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum TFCSChoices {
		normalTFCISignalling = 0,
		dummy = 1,
	};
	static const Info theInfo;
	TFCS(): Choice(&theInfo) {}
};

class ULCommonTransChInfoModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULCommonTransChInfoModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setUlTFCS(const TFCS& ulTFCS) { *static_cast<TFCS*>(items[0]) = ulTFCS; }
};

typedef Integer<CONSTRAINED, 1, 8> TFCSIdentityPlain;

typedef Boolean TFCSIdentitySharedChannelIndicator;

class TFCSIdentity : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	TFCSIdentity(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setTFCSIdentitySharedChannelIndicator(const TFCSIdentitySharedChannelIndicator& tFCSIdentitySharedChannelIndicator) { *static_cast<TFCSIdentitySharedChannelIndicator*>(items[1]) = tFCSIdentitySharedChannelIndicator; }
};

class IndividualULCCTrCHInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	IndividualULCCTrCHInfo(): Sequence(&theInfo) {}

	void setUlTFCSIdentity(const TFCSIdentity& ulTFCSIdentity) { *static_cast<TFCSIdentity*>(items[0]) = ulTFCSIdentity; }
	void setUlTFCS(const TFCS& ulTFCS) { *static_cast<TFCS*>(items[1]) = ulTFCS; }
	void setTfcSubset(const TFCSubset& tfcSubset) { *static_cast<TFCSubset*>(items[2]) = tfcSubset; }
};

typedef SequenceOf<IndividualULCCTrCHInfo, CONSTRAINED, 1, maxCCTrCH> IndividualULCCTrCHInfoList;

class ULCommonTransChInfoModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULCommonTransChInfoModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setIndividualULCCTrCHInfoList(const IndividualULCCTrCHInfoList& individualULCCTrCHInfoList) { *static_cast<IndividualULCCTrCHInfoList*>(items[0]) = individualULCCTrCHInfoList; }
};

class ULCommonTransChInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULCommonTransChInfoModeSpecificInfoChoices {
		uLCommonTransChInfoModeSpecificInfoFdd = 0,
		uLCommonTransChInfoModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	ULCommonTransChInfoModeSpecificInfo(): Choice(&theInfo) {}
};

class ULCommonTransChInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULCommonTransChInfo(): Sequence(&theInfo) {}

	void setTfcSubset(const TFCSubset& tfcSubset) { *static_cast<TFCSubset*>(items[0]) = tfcSubset; }
	void setPrachTFCS(const TFCS& prachTFCS) { *static_cast<TFCS*>(items[1]) = prachTFCS; }
	void setULCommonTransChInfoModeSpecificInfo(const ULCommonTransChInfoModeSpecificInfo& uLCommonTransChInfoModeSpecificInfo) { *static_cast<ULCommonTransChInfoModeSpecificInfo*>(items[2]) = uLCommonTransChInfoModeSpecificInfo; }
};

typedef Integer<CONSTRAINED, 0, 127> BitModeRLCSizeInfoSizeType1;

typedef Integer<CONSTRAINED, 0, 15> BitModeRLCSizeInfoSizeType2Part1;

typedef Integer<CONSTRAINED, 1, 7> BitModeRLCSizeInfoSizeType2Part2;

class BitModeRLCSizeInfoSizeType2 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	BitModeRLCSizeInfoSizeType2(): Sequence(&theInfo) {}

	void setBitModeRLCSizeInfoSizeType2Part1(const BitModeRLCSizeInfoSizeType2Part1& bitModeRLCSizeInfoSizeType2Part1) { *static_cast<BitModeRLCSizeInfoSizeType2Part1*>(items[0]) = bitModeRLCSizeInfoSizeType2Part1; }
	void setBitModeRLCSizeInfoSizeType2Part2(const BitModeRLCSizeInfoSizeType2Part2& bitModeRLCSizeInfoSizeType2Part2) { *static_cast<BitModeRLCSizeInfoSizeType2Part2*>(items[1]) = bitModeRLCSizeInfoSizeType2Part2; }
};

typedef Integer<CONSTRAINED, 0, 47> BitModeRLCSizeInfoSizeType3Part1;

typedef Integer<CONSTRAINED, 1, 15> BitModeRLCSizeInfoSizeType3Part2;

class BitModeRLCSizeInfoSizeType3 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	BitModeRLCSizeInfoSizeType3(): Sequence(&theInfo) {}

	void setBitModeRLCSizeInfoSizeType3Part1(const BitModeRLCSizeInfoSizeType3Part1& bitModeRLCSizeInfoSizeType3Part1) { *static_cast<BitModeRLCSizeInfoSizeType3Part1*>(items[0]) = bitModeRLCSizeInfoSizeType3Part1; }
	void setBitModeRLCSizeInfoSizeType3Part2(const BitModeRLCSizeInfoSizeType3Part2& bitModeRLCSizeInfoSizeType3Part2) { *static_cast<BitModeRLCSizeInfoSizeType3Part2*>(items[1]) = bitModeRLCSizeInfoSizeType3Part2; }
};

typedef Integer<CONSTRAINED, 0, 62> BitModeRLCSizeInfoSizeType4Part1;

typedef Integer<CONSTRAINED, 1, 63> BitModeRLCSizeInfoSizeType4Part2;

class BitModeRLCSizeInfoSizeType4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	BitModeRLCSizeInfoSizeType4(): Sequence(&theInfo) {}

	void setBitModeRLCSizeInfoSizeType4Part1(const BitModeRLCSizeInfoSizeType4Part1& bitModeRLCSizeInfoSizeType4Part1) { *static_cast<BitModeRLCSizeInfoSizeType4Part1*>(items[0]) = bitModeRLCSizeInfoSizeType4Part1; }
	void setBitModeRLCSizeInfoSizeType4Part2(const BitModeRLCSizeInfoSizeType4Part2& bitModeRLCSizeInfoSizeType4Part2) { *static_cast<BitModeRLCSizeInfoSizeType4Part2*>(items[1]) = bitModeRLCSizeInfoSizeType4Part2; }
};

class BitModeRLCSizeInfo : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum BitModeRLCSizeInfoChoices {
		bitModeRLCSizeInfoSizeType1 = 0,
		bitModeRLCSizeInfoSizeType2 = 1,
		bitModeRLCSizeInfoSizeType3 = 2,
		bitModeRLCSizeInfoSizeType4 = 3,
	};
	static const Info theInfo;
	BitModeRLCSizeInfo(): Choice(&theInfo) {}
};

class DedicatedDynamicTFInfoRlcSize : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DedicatedDynamicTFInfoRlcSizeChoices {
		bitMode = 0,
		octetModeType1 = 1,
	};
	static const Info theInfo;
	DedicatedDynamicTFInfoRlcSize(): Choice(&theInfo) {}
};

typedef Null NumberOfTransportBlocksZero;

typedef Null NumberOfTransportBlocksOne;

typedef Integer<CONSTRAINED, 2, 17> NumberOfTransportBlocksSmall;

typedef Integer<CONSTRAINED, 18, 512> NumberOfTransportBlocksLarge;

class NumberOfTransportBlocks : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum NumberOfTransportBlocksChoices {
		numberOfTransportBlocksZero = 0,
		numberOfTransportBlocksOne = 1,
		numberOfTransportBlocksSmall = 2,
		numberOfTransportBlocksLarge = 3,
	};
	static const Info theInfo;
	NumberOfTransportBlocks(): Choice(&theInfo) {}
};

typedef SequenceOf<NumberOfTransportBlocks, CONSTRAINED, 1, maxTF> DedicatedDynamicTFInfoNumberOfTbSizeList;

typedef Null LogicalChannelListAllSizes;

typedef Null LogicalChannelListConfigured;

typedef Integer<CONSTRAINED, 0, 1> LogicalChannelByRBLogChOfRb;

class LogicalChannelByRB : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	LogicalChannelByRB(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setLogicalChannelByRBLogChOfRb(const LogicalChannelByRBLogChOfRb& logicalChannelByRBLogChOfRb) { *static_cast<LogicalChannelByRBLogChOfRb*>(items[1]) = logicalChannelByRBLogChOfRb; }
};

typedef SequenceOf<LogicalChannelByRB, CONSTRAINED, 1, 15> LogicalChannelListExplicitList;

class LogicalChannelList : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum LogicalChannelListChoices {
		logicalChannelListAllSizes = 0,
		logicalChannelListConfigured = 1,
		logicalChannelListExplicitList = 2,
	};
	static const Info theInfo;
	LogicalChannelList(): Choice(&theInfo) {}
};

class DedicatedDynamicTFInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DedicatedDynamicTFInfo(): Sequence(&theInfo) {}

	void setDedicatedDynamicTFInfoRlcSize(const DedicatedDynamicTFInfoRlcSize& dedicatedDynamicTFInfoRlcSize) { *static_cast<DedicatedDynamicTFInfoRlcSize*>(items[0]) = dedicatedDynamicTFInfoRlcSize; }
	void setDedicatedDynamicTFInfoNumberOfTbSizeList(const DedicatedDynamicTFInfoNumberOfTbSizeList& dedicatedDynamicTFInfoNumberOfTbSizeList) { *static_cast<DedicatedDynamicTFInfoNumberOfTbSizeList*>(items[1]) = dedicatedDynamicTFInfoNumberOfTbSizeList; }
	void setLogicalChannelList(const LogicalChannelList& logicalChannelList) { *static_cast<LogicalChannelList*>(items[2]) = logicalChannelList; }
};

typedef SequenceOf<DedicatedDynamicTFInfo, CONSTRAINED, 1, maxTF> DedicatedDynamicTFInfoList;

class DedicatedDynamicTFInfoDynamicTTIRlcSize : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DedicatedDynamicTFInfoDynamicTTIRlcSizeChoices {
		bitMode = 0,
		octetModeType1 = 1,
	};
	static const Info theInfo;
	DedicatedDynamicTFInfoDynamicTTIRlcSize(): Choice(&theInfo) {}
};

class NumberOfTbSizeAndTTIList : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	NumberOfTbSizeAndTTIList(): Sequence(&theInfo) {}

};

class DedicatedDynamicTFInfoDynamicTTI : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DedicatedDynamicTFInfoDynamicTTI(): Sequence(&theInfo) {}

	void setDedicatedDynamicTFInfoDynamicTTIRlcSize(const DedicatedDynamicTFInfoDynamicTTIRlcSize& dedicatedDynamicTFInfoDynamicTTIRlcSize) { *static_cast<DedicatedDynamicTFInfoDynamicTTIRlcSize*>(items[0]) = dedicatedDynamicTFInfoDynamicTTIRlcSize; }
	void setNumberOfTbSizeAndTTIList(const NumberOfTbSizeAndTTIList& numberOfTbSizeAndTTIList) { *static_cast<NumberOfTbSizeAndTTIList*>(items[1]) = numberOfTbSizeAndTTIList; }
	void setLogicalChannelList(const LogicalChannelList& logicalChannelList) { *static_cast<LogicalChannelList*>(items[2]) = logicalChannelList; }
};

typedef SequenceOf<DedicatedDynamicTFInfoDynamicTTI, CONSTRAINED, 1, maxTF> DedicatedDynamicTFInfoListDynamicTTI;

class DedicatedTransChTFSTti : public Choice {
private:
	static const void *choicesInfo[5];
public:
	enum DedicatedTransChTFSTtiChoices {
		tti10 = 0,
		tti20 = 1,
		tti40 = 2,
		tti80 = 3,
		dynamic = 4,
	};
	static const Info theInfo;
	DedicatedTransChTFSTti(): Choice(&theInfo) {}
};

typedef Null ChannelCodingTypeNoCoding;

enum CodingRateValues {
	half_CodingRate = 0,
	third_CodingRate = 1,
};
typedef Enumerated<CONSTRAINED, 1> CodingRate;

typedef Null ChannelCodingTypeTurbo;

class ChannelCodingType : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum ChannelCodingTypeChoices {
		channelCodingTypeNoCoding = 0,
		convolutional = 1,
		channelCodingTypeTurbo = 2,
	};
	static const Info theInfo;
	ChannelCodingType(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, hiRM> RateMatchingAttribute;

enum CRCSizeValues {
	crc0_CRCSize = 0,
	crc8_CRCSize = 1,
	crc12_CRCSize = 2,
	crc16_CRCSize = 3,
	crc24_CRCSize = 4,
};
typedef Enumerated<CONSTRAINED, 4> CRCSize;

class SemistaticTFInformation : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SemistaticTFInformation(): Sequence(&theInfo) {}

	void setChannelCodingType(const ChannelCodingType& channelCodingType) { *static_cast<ChannelCodingType*>(items[0]) = channelCodingType; }
	void setRateMatchingAttribute(const RateMatchingAttribute& rateMatchingAttribute) { *static_cast<RateMatchingAttribute*>(items[1]) = rateMatchingAttribute; }
	void setCrcSize(const CRCSize& crcSize) { *static_cast<CRCSize*>(items[2]) = crcSize; }
};

class DedicatedTransChTFS : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DedicatedTransChTFS(): Sequence(&theInfo) {}

	void setDedicatedTransChTFSTti(const DedicatedTransChTFSTti& dedicatedTransChTFSTti) { *static_cast<DedicatedTransChTFSTti*>(items[0]) = dedicatedTransChTFSTti; }
	void setSemistaticTFInformation(const SemistaticTFInformation& semistaticTFInformation) { *static_cast<SemistaticTFInformation*>(items[1]) = semistaticTFInformation; }
};

typedef Integer<CONSTRAINED, 0, 31> OctetModeRLCSizeInfoType2SizeType1;

typedef Integer<CONSTRAINED, 0, 63> OctetModeRLCSizeInfoType2SizeType2;

typedef Integer<CONSTRAINED, 0, 56> OctetModeRLCSizeInfoType2SizeType3;

class OctetModeRLCSizeInfoType2 : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum OctetModeRLCSizeInfoType2Choices {
		octetModeRLCSizeInfoType2SizeType1 = 0,
		octetModeRLCSizeInfoType2SizeType2 = 1,
		octetModeRLCSizeInfoType2SizeType3 = 2,
	};
	static const Info theInfo;
	OctetModeRLCSizeInfoType2(): Choice(&theInfo) {}
};

class CommonDynamicTFInfoRlcSizeFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CommonDynamicTFInfoRlcSizeFdd(): Sequence(&theInfo) {}

	void setOctetModeRLCSizeInfoType2(const OctetModeRLCSizeInfoType2& octetModeRLCSizeInfoType2) { *static_cast<OctetModeRLCSizeInfoType2*>(items[0]) = octetModeRLCSizeInfoType2; }
};

class CommonDynamicTFInfoRlcSizeTddCommonTDDChoice : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CommonDynamicTFInfoRlcSizeTddCommonTDDChoiceChoices {
		bitModeRLCSizeInfo = 0,
		octetModeRLCSizeInfoType1 = 1,
	};
	static const Info theInfo;
	CommonDynamicTFInfoRlcSizeTddCommonTDDChoice(): Choice(&theInfo) {}
};

class CommonDynamicTFInfoRlcSizeTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CommonDynamicTFInfoRlcSizeTdd(): Sequence(&theInfo) {}

	void setCommonDynamicTFInfoRlcSizeTddCommonTDDChoice(const CommonDynamicTFInfoRlcSizeTddCommonTDDChoice& commonDynamicTFInfoRlcSizeTddCommonTDDChoice) { *static_cast<CommonDynamicTFInfoRlcSizeTddCommonTDDChoice*>(items[0]) = commonDynamicTFInfoRlcSizeTddCommonTDDChoice; }
};

class CommonDynamicTFInfoRlcSize : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CommonDynamicTFInfoRlcSizeChoices {
		commonDynamicTFInfoRlcSizeFdd = 0,
		commonDynamicTFInfoRlcSizeTdd = 1,
	};
	static const Info theInfo;
	CommonDynamicTFInfoRlcSize(): Choice(&theInfo) {}
};

typedef SequenceOf<NumberOfTransportBlocks, CONSTRAINED, 1, maxTF> CommonDynamicTFInfoNumberOfTbSizeList;

class CommonDynamicTFInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CommonDynamicTFInfo(): Sequence(&theInfo) {}

	void setCommonDynamicTFInfoRlcSize(const CommonDynamicTFInfoRlcSize& commonDynamicTFInfoRlcSize) { *static_cast<CommonDynamicTFInfoRlcSize*>(items[0]) = commonDynamicTFInfoRlcSize; }
	void setCommonDynamicTFInfoNumberOfTbSizeList(const CommonDynamicTFInfoNumberOfTbSizeList& commonDynamicTFInfoNumberOfTbSizeList) { *static_cast<CommonDynamicTFInfoNumberOfTbSizeList*>(items[1]) = commonDynamicTFInfoNumberOfTbSizeList; }
	void setLogicalChannelList(const LogicalChannelList& logicalChannelList) { *static_cast<LogicalChannelList*>(items[2]) = logicalChannelList; }
};

typedef SequenceOf<CommonDynamicTFInfo, CONSTRAINED, 1, maxTF> CommonDynamicTFInfoList;

class CommonDynamicTFInfoDynamicTTICommonTDDChoice : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CommonDynamicTFInfoDynamicTTICommonTDDChoiceChoices {
		bitModeRLCSizeInfo = 0,
		octetModeRLCSizeInfoType1 = 1,
	};
	static const Info theInfo;
	CommonDynamicTFInfoDynamicTTICommonTDDChoice(): Choice(&theInfo) {}
};

class CommonDynamicTFInfoDynamicTTI : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CommonDynamicTFInfoDynamicTTI(): Sequence(&theInfo) {}

	void setCommonDynamicTFInfoDynamicTTICommonTDDChoice(const CommonDynamicTFInfoDynamicTTICommonTDDChoice& commonDynamicTFInfoDynamicTTICommonTDDChoice) { *static_cast<CommonDynamicTFInfoDynamicTTICommonTDDChoice*>(items[0]) = commonDynamicTFInfoDynamicTTICommonTDDChoice; }
	void setNumberOfTbSizeAndTTIList(const NumberOfTbSizeAndTTIList& numberOfTbSizeAndTTIList) { *static_cast<NumberOfTbSizeAndTTIList*>(items[1]) = numberOfTbSizeAndTTIList; }
	void setLogicalChannelList(const LogicalChannelList& logicalChannelList) { *static_cast<LogicalChannelList*>(items[2]) = logicalChannelList; }
};

typedef SequenceOf<CommonDynamicTFInfoDynamicTTI, CONSTRAINED, 1, maxTF> CommonDynamicTFInfoListDynamicTTI;

class CommonTransChTFSTti : public Choice {
private:
	static const void *choicesInfo[5];
public:
	enum CommonTransChTFSTtiChoices {
		tti10 = 0,
		tti20 = 1,
		tti40 = 2,
		tti80 = 3,
		dynamic = 4,
	};
	static const Info theInfo;
	CommonTransChTFSTti(): Choice(&theInfo) {}
};

class CommonTransChTFS : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CommonTransChTFS(): Sequence(&theInfo) {}

	void setCommonTransChTFSTti(const CommonTransChTFSTti& commonTransChTFSTti) { *static_cast<CommonTransChTFSTti*>(items[0]) = commonTransChTFSTti; }
	void setSemistaticTFInformation(const SemistaticTFInformation& semistaticTFInformation) { *static_cast<SemistaticTFInformation*>(items[1]) = semistaticTFInformation; }
};

class TransportFormatSet : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum TransportFormatSetChoices {
		dedicatedTransChTFS = 0,
		commonTransChTFS = 1,
	};
	static const Info theInfo;
	TransportFormatSet(): Choice(&theInfo) {}
};

class ULAddReconfTransChInformation : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULAddReconfTransChInformation(): Sequence(&theInfo) {}

	void setUlTransportChannelType(const ULTrCHType& ulTransportChannelType) { *static_cast<ULTrCHType*>(items[0]) = ulTransportChannelType; }
	void setTransportChannelIdentity(const TransportChannelIdentity& transportChannelIdentity) { *static_cast<TransportChannelIdentity*>(items[1]) = transportChannelIdentity; }
	void setTransportFormatSet(const TransportFormatSet& transportFormatSet) { *static_cast<TransportFormatSet*>(items[2]) = transportFormatSet; }
};

typedef SequenceOf<ULAddReconfTransChInformation, CONSTRAINED, 1, maxTrCHpreconf> ULAddReconfTransChInfoList;

typedef Null DLCommonTransChInfoModeSpecificInfoFddDlParametersSameAsUL;

class DLCommonTransChInfoModeSpecificInfoFddDlParameters : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLCommonTransChInfoModeSpecificInfoFddDlParametersChoices {
		dlDCHTFCS = 0,
		dLCommonTransChInfoModeSpecificInfoFddDlParametersSameAsUL = 1,
	};
	static const Info theInfo;
	DLCommonTransChInfoModeSpecificInfoFddDlParameters(): Choice(&theInfo) {}
};

class DLCommonTransChInfoModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLCommonTransChInfoModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setDLCommonTransChInfoModeSpecificInfoFddDlParameters(const DLCommonTransChInfoModeSpecificInfoFddDlParameters& dLCommonTransChInfoModeSpecificInfoFddDlParameters) { *static_cast<DLCommonTransChInfoModeSpecificInfoFddDlParameters*>(items[0]) = dLCommonTransChInfoModeSpecificInfoFddDlParameters; }
};

class IndividualDLCCTrCHInfoTfcsSignallingMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum IndividualDLCCTrCHInfoTfcsSignallingModeChoices {
		explicitconfig = 0,
		sameAsUL = 1,
	};
	static const Info theInfo;
	IndividualDLCCTrCHInfoTfcsSignallingMode(): Choice(&theInfo) {}
};

class IndividualDLCCTrCHInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IndividualDLCCTrCHInfo(): Sequence(&theInfo) {}

	void setDlTFCSIdentity(const TFCSIdentity& dlTFCSIdentity) { *static_cast<TFCSIdentity*>(items[0]) = dlTFCSIdentity; }
	void setIndividualDLCCTrCHInfoTfcsSignallingMode(const IndividualDLCCTrCHInfoTfcsSignallingMode& individualDLCCTrCHInfoTfcsSignallingMode) { *static_cast<IndividualDLCCTrCHInfoTfcsSignallingMode*>(items[1]) = individualDLCCTrCHInfoTfcsSignallingMode; }
};

typedef SequenceOf<IndividualDLCCTrCHInfo, CONSTRAINED, 1, maxCCTrCH> IndividualDLCCTrCHInfoList;

class DLCommonTransChInfoModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLCommonTransChInfoModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setIndividualDLCCTrCHInfoList(const IndividualDLCCTrCHInfoList& individualDLCCTrCHInfoList) { *static_cast<IndividualDLCCTrCHInfoList*>(items[0]) = individualDLCCTrCHInfoList; }
};

class DLCommonTransChInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLCommonTransChInfoModeSpecificInfoChoices {
		dLCommonTransChInfoModeSpecificInfoFdd = 0,
		dLCommonTransChInfoModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	DLCommonTransChInfoModeSpecificInfo(): Choice(&theInfo) {}
};

class DLCommonTransChInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLCommonTransChInfo(): Sequence(&theInfo) {}

	void setSccpchTFCS(const TFCS& sccpchTFCS) { *static_cast<TFCS*>(items[0]) = sccpchTFCS; }
	void setDLCommonTransChInfoModeSpecificInfo(const DLCommonTransChInfoModeSpecificInfo& dLCommonTransChInfoModeSpecificInfo) { *static_cast<DLCommonTransChInfoModeSpecificInfo*>(items[1]) = dLCommonTransChInfoModeSpecificInfo; }
};

enum DLTrCHTypeValues {
	dch_DLTrCHType = 0,
	dsch_DLTrCHType = 1,
};
typedef Enumerated<CONSTRAINED, 1> DLTrCHType;

class ULTransportChannelIdentity : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULTransportChannelIdentity(): Sequence(&theInfo) {}

	void setUlTransportChannelType(const ULTrCHType& ulTransportChannelType) { *static_cast<ULTrCHType*>(items[0]) = ulTransportChannelType; }
	void setUlTransportChannelIdentity(const TransportChannelIdentity& ulTransportChannelIdentity) { *static_cast<TransportChannelIdentity*>(items[1]) = ulTransportChannelIdentity; }
};

class DLAddReconfTransChInformationTfsSignallingMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLAddReconfTransChInformationTfsSignallingModeChoices {
		explicitconfig = 0,
		sameAsULTrCH = 1,
	};
	static const Info theInfo;
	DLAddReconfTransChInformationTfsSignallingMode(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, -63, 0> BLERQualityValue;

class QualityTarget : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	QualityTarget(): Sequence(&theInfo) {}

	void setBlerQualityValue(const BLERQualityValue& blerQualityValue) { *static_cast<BLERQualityValue*>(items[0]) = blerQualityValue; }
};

enum MessTypeValues {
	transportFormatCombinationControl_MessType = 0,
};
typedef Enumerated<CONSTRAINED, 0> MessType;

typedef Null TMSignallingInfoTmSignallingModeMode1;

typedef SequenceOf<TransportChannelIdentity, CONSTRAINED, 1, maxTrCH> ULControlledTrChList;

class TMSignallingInfoTmSignallingModeMode2 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	TMSignallingInfoTmSignallingModeMode2(): Sequence(&theInfo) {}

	void setUlcontrolledTrChList(const ULControlledTrChList& ulcontrolledTrChList) { *static_cast<ULControlledTrChList*>(items[0]) = ulcontrolledTrChList; }
};

class TMSignallingInfoTmSignallingMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum TMSignallingInfoTmSignallingModeChoices {
		tMSignallingInfoTmSignallingModeMode1 = 0,
		tMSignallingInfoTmSignallingModeMode2 = 1,
	};
	static const Info theInfo;
	TMSignallingInfoTmSignallingMode(): Choice(&theInfo) {}
};

class TMSignallingInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	TMSignallingInfo(): Sequence(&theInfo) {}

	void setMessType(const MessType& messType) { *static_cast<MessType*>(items[0]) = messType; }
	void setTMSignallingInfoTmSignallingMode(const TMSignallingInfoTmSignallingMode& tMSignallingInfoTmSignallingMode) { *static_cast<TMSignallingInfoTmSignallingMode*>(items[1]) = tMSignallingInfoTmSignallingMode; }
};

class DLAddReconfTransChInformation : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	DLAddReconfTransChInformation(): Sequence(&theInfo) {}

	void setDlTransportChannelType(const DLTrCHType& dlTransportChannelType) { *static_cast<DLTrCHType*>(items[0]) = dlTransportChannelType; }
	void setDltransportChannelIdentity(const TransportChannelIdentity& dltransportChannelIdentity) { *static_cast<TransportChannelIdentity*>(items[1]) = dltransportChannelIdentity; }
	void setDLAddReconfTransChInformationTfsSignallingMode(const DLAddReconfTransChInformationTfsSignallingMode& dLAddReconfTransChInformationTfsSignallingMode) { *static_cast<DLAddReconfTransChInformationTfsSignallingMode*>(items[2]) = dLAddReconfTransChInformationTfsSignallingMode; }
	void setDchQualityTarget(const QualityTarget& dchQualityTarget) { *static_cast<QualityTarget*>(items[3]) = dchQualityTarget; }
	void setDummy(const TMSignallingInfo& dummy) { *static_cast<TMSignallingInfo*>(items[4]) = dummy; }
};

typedef SequenceOf<DLAddReconfTransChInformation, CONSTRAINED, 1, maxTrCHpreconf> DLAddReconfTransChInfoList;

class PreDefTransChConfiguration : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	PreDefTransChConfiguration(): Sequence(&theInfo) {}

	void setUlCommonTransChInfo(const ULCommonTransChInfo& ulCommonTransChInfo) { *static_cast<ULCommonTransChInfo*>(items[0]) = ulCommonTransChInfo; }
	void setUlAddReconfTrChInfoList(const ULAddReconfTransChInfoList& ulAddReconfTrChInfoList) { *static_cast<ULAddReconfTransChInfoList*>(items[1]) = ulAddReconfTrChInfoList; }
	void setDlCommonTransChInfo(const DLCommonTransChInfo& dlCommonTransChInfo) { *static_cast<DLCommonTransChInfo*>(items[2]) = dlCommonTransChInfo; }
	void setDlTrChInfoList(const DLAddReconfTransChInfoList& dlTrChInfoList) { *static_cast<DLAddReconfTransChInfoList*>(items[3]) = dlTrChInfoList; }
};

class ULDPCHPowerControlInfoPredefFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfoPredefFdd(): Sequence(&theInfo) {}

	void setPowerControlAlgorithm(const PowerControlAlgorithm& powerControlAlgorithm) { *static_cast<PowerControlAlgorithm*>(items[0]) = powerControlAlgorithm; }
};

typedef Integer<CONSTRAINED, -35, 10> ConstantValueTdd;

class ULDPCHPowerControlInfoPredefTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfoPredefTdd(): Sequence(&theInfo) {}

	void setDpchConstantValue(const ConstantValueTdd& dpchConstantValue) { *static_cast<ConstantValueTdd*>(items[0]) = dpchConstantValue; }
};

class ULDPCHPowerControlInfoPredef : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHPowerControlInfoPredefChoices {
		uLDPCHPowerControlInfoPredefFdd = 0,
		uLDPCHPowerControlInfoPredefTdd = 1,
	};
	static const Info theInfo;
	ULDPCHPowerControlInfoPredef(): Choice(&theInfo) {}
};

typedef Boolean ULDPCHInfoPredefModeSpecificInfoFddTfciExistence;

enum PuncturingLimitValues {
	pl0_40_PuncturingLimit = 0,
	pl0_44_PuncturingLimit = 1,
	pl0_48_PuncturingLimit = 2,
	pl0_52_PuncturingLimit = 3,
	pl0_56_PuncturingLimit = 4,
	pl0_60_PuncturingLimit = 5,
	pl0_64_PuncturingLimit = 6,
	pl0_68_PuncturingLimit = 7,
	pl0_72_PuncturingLimit = 8,
	pl0_76_PuncturingLimit = 9,
	pl0_80_PuncturingLimit = 10,
	pl0_84_PuncturingLimit = 11,
	pl0_88_PuncturingLimit = 12,
	pl0_92_PuncturingLimit = 13,
	pl0_96_PuncturingLimit = 14,
	pl1_PuncturingLimit = 15,
};
typedef Enumerated<CONSTRAINED, 15> PuncturingLimit;

class ULDPCHInfoPredefModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHInfoPredefModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setULDPCHInfoPredefModeSpecificInfoFddTfciExistence(const ULDPCHInfoPredefModeSpecificInfoFddTfciExistence& uLDPCHInfoPredefModeSpecificInfoFddTfciExistence) { *static_cast<ULDPCHInfoPredefModeSpecificInfoFddTfciExistence*>(items[0]) = uLDPCHInfoPredefModeSpecificInfoFddTfciExistence; }
	void setPuncturingLimit(const PuncturingLimit& puncturingLimit) { *static_cast<PuncturingLimit*>(items[1]) = puncturingLimit; }
};

enum SecondInterleavingModeValues {
	frameRelated_SecondInterleavingMode = 0,
	timeslotRelated_SecondInterleavingMode = 1,
};
typedef Enumerated<CONSTRAINED, 1> SecondInterleavingMode;

enum TFCICodingValues {
	tfci_bits_4_TFCICoding = 0,
	tfci_bits_8_TFCICoding = 1,
	tfci_bits_16_TFCICoding = 2,
	tfci_bits_32_TFCICoding = 3,
};
typedef Enumerated<CONSTRAINED, 3> TFCICoding;

typedef Null RepetitionPeriodAndLengthRepetitionPeriod1;

typedef Integer<CONSTRAINED, 1, 1> RepetitionPeriodAndLengthRepetitionPeriod2;

typedef Integer<CONSTRAINED, 1, 3> RepetitionPeriodAndLengthRepetitionPeriod4;

typedef Integer<CONSTRAINED, 1, 7> RepetitionPeriodAndLengthRepetitionPeriod8;

typedef Integer<CONSTRAINED, 1, 15> RepetitionPeriodAndLengthRepetitionPeriod16;

typedef Integer<CONSTRAINED, 1, 31> RepetitionPeriodAndLengthRepetitionPeriod32;

typedef Integer<CONSTRAINED, 1, 63> RepetitionPeriodAndLengthRepetitionPeriod64;

class RepetitionPeriodAndLength : public Choice {
private:
	static const void *choicesInfo[7];
public:
	enum RepetitionPeriodAndLengthChoices {
		repetitionPeriodAndLengthRepetitionPeriod1 = 0,
		repetitionPeriodAndLengthRepetitionPeriod2 = 1,
		repetitionPeriodAndLengthRepetitionPeriod4 = 2,
		repetitionPeriodAndLengthRepetitionPeriod8 = 3,
		repetitionPeriodAndLengthRepetitionPeriod16 = 4,
		repetitionPeriodAndLengthRepetitionPeriod32 = 5,
		repetitionPeriodAndLengthRepetitionPeriod64 = 6,
	};
	static const Info theInfo;
	RepetitionPeriodAndLength(): Choice(&theInfo) {}
};

class CommonTimeslotInfo : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CommonTimeslotInfo(): Sequence(&theInfo) {}

	void setSecondInterleavingMode(const SecondInterleavingMode& secondInterleavingMode) { *static_cast<SecondInterleavingMode*>(items[0]) = secondInterleavingMode; }
	void setTfciCoding(const TFCICoding& tfciCoding) { *static_cast<TFCICoding*>(items[1]) = tfciCoding; }
	void setPuncturingLimit(const PuncturingLimit& puncturingLimit) { *static_cast<PuncturingLimit*>(items[2]) = puncturingLimit; }
	void setRepetitionPeriodAndLength(const RepetitionPeriodAndLength& repetitionPeriodAndLength) { *static_cast<RepetitionPeriodAndLength*>(items[3]) = repetitionPeriodAndLength; }
};

class ULDPCHInfoPredefModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULDPCHInfoPredefModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setCommonTimeslotInfo(const CommonTimeslotInfo& commonTimeslotInfo) { *static_cast<CommonTimeslotInfo*>(items[0]) = commonTimeslotInfo; }
};

class ULDPCHInfoPredefModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHInfoPredefModeSpecificInfoChoices {
		uLDPCHInfoPredefModeSpecificInfoFdd = 0,
		uLDPCHInfoPredefModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	ULDPCHInfoPredefModeSpecificInfo(): Choice(&theInfo) {}
};

class ULDPCHInfoPredef : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHInfoPredef(): Sequence(&theInfo) {}

	void setUlDPCHPowerControlInfo(const ULDPCHPowerControlInfoPredef& ulDPCHPowerControlInfo) { *static_cast<ULDPCHPowerControlInfoPredef*>(items[0]) = ulDPCHPowerControlInfo; }
	void setULDPCHInfoPredefModeSpecificInfo(const ULDPCHInfoPredefModeSpecificInfo& uLDPCHInfoPredefModeSpecificInfo) { *static_cast<ULDPCHInfoPredefModeSpecificInfo*>(items[1]) = uLDPCHInfoPredefModeSpecificInfo; }
};

typedef Null SF512AndPilotSfd4;

typedef Null SF512AndPilotSfd8;

typedef Null SF512AndPilotSfd16;

typedef Null SF512AndPilotSfd32;

typedef Null SF512AndPilotSfd64;

enum PilotBits128Values {
	pb4_PilotBits128 = 0,
	pb8_PilotBits128 = 1,
};
typedef Enumerated<CONSTRAINED, 1> PilotBits128;

enum PilotBits256Values {
	pb2_PilotBits256 = 0,
	pb4_PilotBits256 = 1,
	pb8_PilotBits256 = 2,
};
typedef Enumerated<CONSTRAINED, 2> PilotBits256;

typedef Null SF512AndPilotSfd512;

class SF512AndPilot : public Choice {
private:
	static const void *choicesInfo[8];
public:
	enum SF512AndPilotChoices {
		sF512AndPilotSfd4 = 0,
		sF512AndPilotSfd8 = 1,
		sF512AndPilotSfd16 = 2,
		sF512AndPilotSfd32 = 3,
		sF512AndPilotSfd64 = 4,
		sfd128 = 5,
		sfd256 = 6,
		sF512AndPilotSfd512 = 7,
	};
	static const Info theInfo;
	SF512AndPilot(): Choice(&theInfo) {}
};

enum PositionFixedOrFlexibleValues {
	fixed_PositionFixedOrFlexible = 0,
	flexible_PositionFixedOrFlexible = 1,
};
typedef Enumerated<CONSTRAINED, 1> PositionFixedOrFlexible;

typedef Boolean DLDPCHInfoCommonPredefModeSpecificInfoFddTfciExistence;

class DLDPCHInfoCommonPredefModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLDPCHInfoCommonPredefModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setSpreadingFactorAndPilot(const SF512AndPilot& spreadingFactorAndPilot) { *static_cast<SF512AndPilot*>(items[0]) = spreadingFactorAndPilot; }
	void setPositionFixedOrFlexible(const PositionFixedOrFlexible& positionFixedOrFlexible) { *static_cast<PositionFixedOrFlexible*>(items[1]) = positionFixedOrFlexible; }
	void setDLDPCHInfoCommonPredefModeSpecificInfoFddTfciExistence(const DLDPCHInfoCommonPredefModeSpecificInfoFddTfciExistence& dLDPCHInfoCommonPredefModeSpecificInfoFddTfciExistence) { *static_cast<DLDPCHInfoCommonPredefModeSpecificInfoFddTfciExistence*>(items[2]) = dLDPCHInfoCommonPredefModeSpecificInfoFddTfciExistence; }
};

class DLDPCHInfoCommonPredefModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLDPCHInfoCommonPredefModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setCommonTimeslotInfo(const CommonTimeslotInfo& commonTimeslotInfo) { *static_cast<CommonTimeslotInfo*>(items[0]) = commonTimeslotInfo; }
};

class DLDPCHInfoCommonPredefModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLDPCHInfoCommonPredefModeSpecificInfoChoices {
		dLDPCHInfoCommonPredefModeSpecificInfoFdd = 0,
		dLDPCHInfoCommonPredefModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	DLDPCHInfoCommonPredefModeSpecificInfo(): Choice(&theInfo) {}
};

class DLDPCHInfoCommonPredef : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLDPCHInfoCommonPredef(): Sequence(&theInfo) {}

	void setDLDPCHInfoCommonPredefModeSpecificInfo(const DLDPCHInfoCommonPredefModeSpecificInfo& dLDPCHInfoCommonPredefModeSpecificInfo) { *static_cast<DLDPCHInfoCommonPredefModeSpecificInfo*>(items[0]) = dLDPCHInfoCommonPredefModeSpecificInfo; }
};

class DLCommonInformationPredef : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLCommonInformationPredef(): Sequence(&theInfo) {}

	void setDlDPCHInfoCommon(const DLDPCHInfoCommonPredef& dlDPCHInfoCommon) { *static_cast<DLDPCHInfoCommonPredef*>(items[0]) = dlDPCHInfoCommon; }
};

class PreDefPhyChConfiguration : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PreDefPhyChConfiguration(): Sequence(&theInfo) {}

	void setUlDPCHInfoPredef(const ULDPCHInfoPredef& ulDPCHInfoPredef) { *static_cast<ULDPCHInfoPredef*>(items[0]) = ulDPCHInfoPredef; }
	void setDlCommonInformationPredef(const DLCommonInformationPredef& dlCommonInformationPredef) { *static_cast<DLCommonInformationPredef*>(items[1]) = dlCommonInformationPredef; }
};

class PreDefRadioConfiguration : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PreDefRadioConfiguration(): Sequence(&theInfo) {}

	void setPredefinedRBConfiguration(const PredefinedRBConfiguration& predefinedRBConfiguration) { *static_cast<PredefinedRBConfiguration*>(items[0]) = predefinedRBConfiguration; }
	void setPreDefTransChConfiguration(const PreDefTransChConfiguration& preDefTransChConfiguration) { *static_cast<PreDefTransChConfiguration*>(items[1]) = preDefTransChConfiguration; }
	void setPreDefPhyChConfiguration(const PreDefPhyChConfiguration& preDefPhyChConfiguration) { *static_cast<PreDefPhyChConfiguration*>(items[2]) = preDefPhyChConfiguration; }
};

enum NumberOfTPCBitsValues {
	tpc4_NumberOfTPCBits = 0,
};
typedef Enumerated<CONSTRAINED, 0> NumberOfTPCBits;

class ULDPCHInfoPredefv770extModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULDPCHInfoPredefv770extModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setNumberOfTPCBits(const NumberOfTPCBits& numberOfTPCBits) { *static_cast<NumberOfTPCBits*>(items[0]) = numberOfTPCBits; }
};

typedef Null ULDPCHInfoPredefv770extModeSpecificInfoTdd;

class ULDPCHInfoPredefv770extModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHInfoPredefv770extModeSpecificInfoChoices {
		uLDPCHInfoPredefv770extModeSpecificInfoFdd = 0,
		uLDPCHInfoPredefv770extModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	ULDPCHInfoPredefv770extModeSpecificInfo(): Choice(&theInfo) {}
};

class ULDPCHInfoPredefv770ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULDPCHInfoPredefv770ext(): Sequence(&theInfo) {}

	void setULDPCHInfoPredefv770extModeSpecificInfo(const ULDPCHInfoPredefv770extModeSpecificInfo& uLDPCHInfoPredefv770extModeSpecificInfo) { *static_cast<ULDPCHInfoPredefv770extModeSpecificInfo*>(items[0]) = uLDPCHInfoPredefv770extModeSpecificInfo; }
};

class PreDefPhyChConfigurationv770ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PreDefPhyChConfigurationv770ext(): Sequence(&theInfo) {}

	void setUlDPCHInfoPredef(const ULDPCHInfoPredefv770ext& ulDPCHInfoPredef) { *static_cast<ULDPCHInfoPredefv770ext*>(items[0]) = ulDPCHInfoPredef; }
};

class PreDefRadioConfigurationv770ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PreDefRadioConfigurationv770ext(): Sequence(&theInfo) {}

	void setPreDefPhyChConfiguration(const PreDefPhyChConfigurationv770ext& preDefPhyChConfiguration) { *static_cast<PreDefPhyChConfigurationv770ext*>(items[0]) = preDefPhyChConfiguration; }
};

enum MAChsWindowSizer9Values {
	mws4_MAChsWindowSizer9 = 0,
	mws6_MAChsWindowSizer9 = 1,
	mws8_MAChsWindowSizer9 = 2,
	mws12_MAChsWindowSizer9 = 3,
	mws16_MAChsWindowSizer9 = 4,
	mws24_MAChsWindowSizer9 = 5,
	mws32_MAChsWindowSizer9 = 6,
	mw64_MAChsWindowSizer9 = 7,
	mw128_MAChsWindowSizer9 = 8,
};
typedef Enumerated<CONSTRAINED, 8> MAChsWindowSizer9;

class PreDefRadioConfigurationv920ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PreDefRadioConfigurationv920ext(): Sequence(&theInfo) {}

	void setMacehsWindowSize(const MAChsWindowSizer9& macehsWindowSize) { *static_cast<MAChsWindowSizer9*>(items[0]) = macehsWindowSize; }
};

typedef Null PredefinedConfigStatusInfoStoredWithValueTagSameAsPrevius;

typedef Null PredefinedConfigStatusInfoOtherNotStored;

class PredefinedConfigStatusInfoOther : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PredefinedConfigStatusInfoOtherChoices {
		predefinedConfigStatusInfoOtherNotStored = 0,
		storedWithDifferentValueTag = 1,
	};
	static const Info theInfo;
	PredefinedConfigStatusInfoOther(): Choice(&theInfo) {}
};

class PredefinedConfigStatusInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PredefinedConfigStatusInfoChoices {
		predefinedConfigStatusInfoStoredWithValueTagSameAsPrevius = 0,
		predefinedConfigStatusInfoOther = 1,
	};
	static const Info theInfo;
	PredefinedConfigStatusInfo(): Choice(&theInfo) {}
};

typedef SequenceOf<PredefinedConfigStatusInfo, CONSTRAINED, maxPredefConfig, maxPredefConfig> PredefinedConfigStatusList;

typedef Integer<CONSTRAINED, 0, 10> PredefinedConfigSetWithDifferentValueTagStartPosition;

typedef SequenceOf<PredefinedConfigValueTag, CONSTRAINED, 1, maxPredefConfig> PredefinedConfigValueTagList;

class PredefinedConfigSetWithDifferentValueTag : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PredefinedConfigSetWithDifferentValueTag(): Sequence(&theInfo) {}

	void setPredefinedConfigSetWithDifferentValueTagStartPosition(const PredefinedConfigSetWithDifferentValueTagStartPosition& predefinedConfigSetWithDifferentValueTagStartPosition) { *static_cast<PredefinedConfigSetWithDifferentValueTagStartPosition*>(items[0]) = predefinedConfigSetWithDifferentValueTagStartPosition; }
	void setValueTagList(const PredefinedConfigValueTagList& valueTagList) { *static_cast<PredefinedConfigValueTagList*>(items[1]) = valueTagList; }
};

typedef SequenceOf<PredefinedConfigSetWithDifferentValueTag, CONSTRAINED, 1, 2> PredefinedConfigSetsWithDifferentValueTag;

typedef SequenceOf<PredefinedConfigStatusInfo, CONSTRAINED, 1, maxPredefConfig> PredefinedConfigStatusListVarSz;

class PredefinedConfigStatusListComp : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PredefinedConfigStatusListComp(): Sequence(&theInfo) {}

	void setSetsWithDifferentValueTag(const PredefinedConfigSetsWithDifferentValueTag& setsWithDifferentValueTag) { *static_cast<PredefinedConfigSetsWithDifferentValueTag*>(items[0]) = setsWithDifferentValueTag; }
	void setOtherEntries(const PredefinedConfigStatusListVarSz& otherEntries) { *static_cast<PredefinedConfigStatusListVarSz*>(items[1]) = otherEntries; }
};

class RABInfo : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	RABInfo(): Sequence(&theInfo) {}

	void setRabIdentity(const RABIdentity& rabIdentity) { *static_cast<RABIdentity*>(items[0]) = rabIdentity; }
	void setCnDomainIdentity(const CNDomainIdentity& cnDomainIdentity) { *static_cast<CNDomainIdentity*>(items[1]) = cnDomainIdentity; }
	void setNasSynchronisationIndicator(const NASSynchronisationIndicator& nasSynchronisationIndicator) { *static_cast<NASSynchronisationIndicator*>(items[2]) = nasSynchronisationIndicator; }
	void setReEstablishmentTimer(const ReEstablishmentTimer& reEstablishmentTimer) { *static_cast<ReEstablishmentTimer*>(items[3]) = reEstablishmentTimer; }
};

typedef OctetString<CONSTRAINED, 1, 1> MBMSSessionIdentity;

class RABInfor6ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	RABInfor6ext(): Sequence(&theInfo) {}

	void setMbmsSessionIdentity(const MBMSSessionIdentity& mbmsSessionIdentity) { *static_cast<MBMSSessionIdentity*>(items[0]) = mbmsSessionIdentity; }
};

typedef OctetString<CONSTRAINED, 3, 3> RABInfov6b0extMbmsServiceIdentity;

class RABInfov6b0ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	RABInfov6b0ext(): Sequence(&theInfo) {}

	void setRABInfov6b0extMbmsServiceIdentity(const RABInfov6b0extMbmsServiceIdentity& rABInfov6b0extMbmsServiceIdentity) { *static_cast<RABInfov6b0extMbmsServiceIdentity*>(items[0]) = rABInfov6b0extMbmsServiceIdentity; }
};

class RABInfor6 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	RABInfor6(): Sequence(&theInfo) {}

	void setRabIdentity(const RABIdentity& rabIdentity) { *static_cast<RABIdentity*>(items[0]) = rabIdentity; }
	void setMbmsSessionIdentity(const MBMSSessionIdentity& mbmsSessionIdentity) { *static_cast<MBMSSessionIdentity*>(items[1]) = mbmsSessionIdentity; }
	void setCnDomainIdentity(const CNDomainIdentity& cnDomainIdentity) { *static_cast<CNDomainIdentity*>(items[2]) = cnDomainIdentity; }
	void setNasSynchronisationIndicator(const NASSynchronisationIndicator& nasSynchronisationIndicator) { *static_cast<NASSynchronisationIndicator*>(items[3]) = nasSynchronisationIndicator; }
	void setReEstablishmentTimer(const ReEstablishmentTimer& reEstablishmentTimer) { *static_cast<ReEstablishmentTimer*>(items[4]) = reEstablishmentTimer; }
};

typedef OctetString<CONSTRAINED, 3, 3> RABInfor7MbmsServiceIdentity;

class RABInfor7 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	RABInfor7(): Sequence(&theInfo) {}

	void setRabIdentity(const RABIdentity& rabIdentity) { *static_cast<RABIdentity*>(items[0]) = rabIdentity; }
	void setMbmsSessionIdentity(const MBMSSessionIdentity& mbmsSessionIdentity) { *static_cast<MBMSSessionIdentity*>(items[1]) = mbmsSessionIdentity; }
	void setRABInfor7MbmsServiceIdentity(const RABInfor7MbmsServiceIdentity& rABInfor7MbmsServiceIdentity) { *static_cast<RABInfor7MbmsServiceIdentity*>(items[2]) = rABInfor7MbmsServiceIdentity; }
	void setCnDomainIdentity(const CNDomainIdentity& cnDomainIdentity) { *static_cast<CNDomainIdentity*>(items[3]) = cnDomainIdentity; }
	void setNasSynchronisationIndicator(const NASSynchronisationIndicator& nasSynchronisationIndicator) { *static_cast<NASSynchronisationIndicator*>(items[4]) = nasSynchronisationIndicator; }
	void setReEstablishmentTimer(const ReEstablishmentTimer& reEstablishmentTimer) { *static_cast<ReEstablishmentTimer*>(items[5]) = reEstablishmentTimer; }
};

typedef SequenceOf<RABInfo, CONSTRAINED, 1, maxRABsetup> RABInformationList;

typedef SequenceOf<RABInfor6, CONSTRAINED, 1, maxRABsetup> RABInformationListr6;

class RABInformationReconfig : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	RABInformationReconfig(): Sequence(&theInfo) {}

	void setRabIdentity(const RABIdentity& rabIdentity) { *static_cast<RABIdentity*>(items[0]) = rabIdentity; }
	void setCnDomainIdentity(const CNDomainIdentity& cnDomainIdentity) { *static_cast<CNDomainIdentity*>(items[1]) = cnDomainIdentity; }
	void setNasSynchronisationIndicator(const NASSynchronisationIndicator& nasSynchronisationIndicator) { *static_cast<NASSynchronisationIndicator*>(items[2]) = nasSynchronisationIndicator; }
};

typedef SequenceOf<RABInformationReconfig, CONSTRAINED, 1,  maxRABsetup> RABInformationReconfigList;

class RABInformationReconfigr8 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	RABInformationReconfigr8(): Sequence(&theInfo) {}

	void setRabIdentity(const RABIdentity& rabIdentity) { *static_cast<RABIdentity*>(items[0]) = rabIdentity; }
	void setCnDomainIdentity(const CNDomainIdentity& cnDomainIdentity) { *static_cast<CNDomainIdentity*>(items[1]) = cnDomainIdentity; }
	void setNasSynchronisationIndicator(const NASSynchronisationIndicator& nasSynchronisationIndicator) { *static_cast<NASSynchronisationIndicator*>(items[2]) = nasSynchronisationIndicator; }
	void setCsHSPAInformation(const CSHSPAInformation& csHSPAInformation) { *static_cast<CSHSPAInformation*>(items[3]) = csHSPAInformation; }
};

typedef SequenceOf<RABInformationReconfigr8, CONSTRAINED, 1, maxRABsetup> RABInformationReconfigListr8;

class RABInfoPost : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	RABInfoPost(): Sequence(&theInfo) {}

	void setRabIdentity(const RABIdentity& rabIdentity) { *static_cast<RABIdentity*>(items[0]) = rabIdentity; }
	void setCnDomainIdentity(const CNDomainIdentity& cnDomainIdentity) { *static_cast<CNDomainIdentity*>(items[1]) = cnDomainIdentity; }
	void setNasSynchronisationIndicator(const NASSynchronisationIndicator& nasSynchronisationIndicator) { *static_cast<NASSynchronisationIndicator*>(items[2]) = nasSynchronisationIndicator; }
};

typedef OctetString<CONSTRAINED, 3, 3> RABInformationMBMSPtpMbmsServiceIdentity;

class RABInformationMBMSPtp : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	RABInformationMBMSPtp(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setRABInformationMBMSPtpMbmsServiceIdentity(const RABInformationMBMSPtpMbmsServiceIdentity& rABInformationMBMSPtpMbmsServiceIdentity) { *static_cast<RABInformationMBMSPtpMbmsServiceIdentity*>(items[1]) = rABInformationMBMSPtpMbmsServiceIdentity; }
	void setMbmsSessionIdentity(const MBMSSessionIdentity& mbmsSessionIdentity) { *static_cast<MBMSSessionIdentity*>(items[2]) = mbmsSessionIdentity; }
};

typedef SequenceOf<RABInformationMBMSPtp, CONSTRAINED, 1, maxMBMSservSelect> RABInformationMBMSPtpList;

class RABInformationSetup : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RABInformationSetup(): Sequence(&theInfo) {}

	void setRabInfo(const RABInfo& rabInfo) { *static_cast<RABInfo*>(items[0]) = rabInfo; }
	void setRbInformationSetupList(const RBInformationSetupList& rbInformationSetupList) { *static_cast<RBInformationSetupList*>(items[1]) = rbInformationSetupList; }
};

class RBInformationSetupr4 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	RBInformationSetupr4(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setPdcpInfo(const PDCPInfor4& pdcpInfo) { *static_cast<PDCPInfor4*>(items[1]) = pdcpInfo; }
	void setRlcInfoChoice(const RLCInfoChoice& rlcInfoChoice) { *static_cast<RLCInfoChoice*>(items[2]) = rlcInfoChoice; }
	void setRbMappingInfo(const RBMappingInfo& rbMappingInfo) { *static_cast<RBMappingInfo*>(items[3]) = rbMappingInfo; }
};

typedef SequenceOf<RBInformationSetupr4, CONSTRAINED, 1, maxRBperRAB> RBInformationSetupListr4;

class RABInformationSetupr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RABInformationSetupr4(): Sequence(&theInfo) {}

	void setRabInfo(const RABInfo& rabInfo) { *static_cast<RABInfo*>(items[0]) = rabInfo; }
	void setRbInformationSetupList(const RBInformationSetupListr4& rbInformationSetupList) { *static_cast<RBInformationSetupListr4*>(items[1]) = rbInformationSetupList; }
};

typedef Boolean RLCInfor5RlcOneSidedReEst;

class RLCInfor5 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	RLCInfor5(): Sequence(&theInfo) {}

	void setUlRLCMode(const ULRLCMode& ulRLCMode) { *static_cast<ULRLCMode*>(items[0]) = ulRLCMode; }
	void setDlRLCMode(const DLRLCModer5& dlRLCMode) { *static_cast<DLRLCModer5*>(items[1]) = dlRLCMode; }
	void setRLCInfor5RlcOneSidedReEst(const RLCInfor5RlcOneSidedReEst& rLCInfor5RlcOneSidedReEst) { *static_cast<RLCInfor5RlcOneSidedReEst*>(items[2]) = rLCInfor5RlcOneSidedReEst; }
};

class RLCInfoChoicer5 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum RLCInfoChoicer5Choices {
		rlcInfo = 0,
		sameasRB = 1,
	};
	static const Info theInfo;
	RLCInfoChoicer5(): Choice(&theInfo) {}
};

class RBMappingOptionr5 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RBMappingOptionr5(): Sequence(&theInfo) {}

	void setUlLogicalChannelMappings(const ULLogicalChannelMappings& ulLogicalChannelMappings) { *static_cast<ULLogicalChannelMappings*>(items[0]) = ulLogicalChannelMappings; }
	void setDlLogicalChannelMappingList(const DLLogicalChannelMappingListr5& dlLogicalChannelMappingList) { *static_cast<DLLogicalChannelMappingListr5*>(items[1]) = dlLogicalChannelMappingList; }
};

typedef SequenceOf<RBMappingOptionr5, CONSTRAINED, 1, maxRBMuxOptions> RBMappingInfor5;

class RBInformationSetupr5 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	RBInformationSetupr5(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setPdcpInfo(const PDCPInfor4& pdcpInfo) { *static_cast<PDCPInfor4*>(items[1]) = pdcpInfo; }
	void setRlcInfoChoice(const RLCInfoChoicer5& rlcInfoChoice) { *static_cast<RLCInfoChoicer5*>(items[2]) = rlcInfoChoice; }
	void setRbMappingInfo(const RBMappingInfor5& rbMappingInfo) { *static_cast<RBMappingInfor5*>(items[3]) = rbMappingInfo; }
};

typedef SequenceOf<RBInformationSetupr5, CONSTRAINED, 1, maxRBperRAB> RBInformationSetupListr5;

class RABInformationSetupr5 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RABInformationSetupr5(): Sequence(&theInfo) {}

	void setRabInfo(const RABInfo& rabInfo) { *static_cast<RABInfo*>(items[0]) = rabInfo; }
	void setRbInformationSetupList(const RBInformationSetupListr5& rbInformationSetupList) { *static_cast<RBInformationSetupListr5*>(items[1]) = rbInformationSetupList; }
};

class RABInformationSetupr6ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	RABInformationSetupr6ext(): Sequence(&theInfo) {}

	void setRabInfor6ext(const RABInfor6ext& rabInfor6ext) { *static_cast<RABInfor6ext*>(items[0]) = rabInfor6ext; }
};

typedef Boolean RLCInfor6RlcOneSidedReEst;

enum RLCInfor6altE_bitInterpretationValues {
	true_RLCInfor6altE_bitInterpretation = 0,
};
typedef Enumerated<CONSTRAINED, 0> RLCInfor6altE_bitInterpretation;

class RLCInfor6 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	RLCInfor6(): Sequence(&theInfo) {}

	void setUlRLCMode(const ULRLCMode& ulRLCMode) { *static_cast<ULRLCMode*>(items[0]) = ulRLCMode; }
	void setDlRLCMode(const DLRLCModer6& dlRLCMode) { *static_cast<DLRLCModer6*>(items[1]) = dlRLCMode; }
	void setRLCInfor6RlcOneSidedReEst(const RLCInfor6RlcOneSidedReEst& rLCInfor6RlcOneSidedReEst) { *static_cast<RLCInfor6RlcOneSidedReEst*>(items[2]) = rLCInfor6RlcOneSidedReEst; }
	void setRLCInfor6altE_bitInterpretation(const RLCInfor6altE_bitInterpretation& rLCInfor6altE_bitInterpretation) { *static_cast<RLCInfor6altE_bitInterpretation*>(items[3]) = rLCInfor6altE_bitInterpretation; }
};

class RLCInfoChoicer6 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum RLCInfoChoicer6Choices {
		rlcInfo = 0,
		sameasRB = 1,
	};
	static const Info theInfo;
	RLCInfoChoicer6(): Choice(&theInfo) {}
};

typedef Null ULLogicalChannelMappingr6UlTrCHTypeDchrachuschRlcSizeListAllSizes;

typedef Null ULLogicalChannelMappingr6UlTrCHTypeDchrachuschRlcSizeListConfigured;

class ULLogicalChannelMappingr6UlTrCHTypeDchrachuschRlcSizeList : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum ULLogicalChannelMappingr6UlTrCHTypeDchrachuschRlcSizeListChoices {
		uLLogicalChannelMappingr6UlTrCHTypeDchrachuschRlcSizeListAllSizes = 0,
		uLLogicalChannelMappingr6UlTrCHTypeDchrachuschRlcSizeListConfigured = 1,
		explicitList = 2,
	};
	static const Info theInfo;
	ULLogicalChannelMappingr6UlTrCHTypeDchrachuschRlcSizeList(): Choice(&theInfo) {}
};

class ULLogicalChannelMappingr6UlTrCHTypeDchrachusch : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULLogicalChannelMappingr6UlTrCHTypeDchrachusch(): Sequence(&theInfo) {}

	void setUlTransportChannelType(const ULTransportChannelType& ulTransportChannelType) { *static_cast<ULTransportChannelType*>(items[0]) = ulTransportChannelType; }
	void setLogicalChannelIdentity(const LogicalChannelIdentity& logicalChannelIdentity) { *static_cast<LogicalChannelIdentity*>(items[1]) = logicalChannelIdentity; }
	void setULLogicalChannelMappingr6UlTrCHTypeDchrachuschRlcSizeList(const ULLogicalChannelMappingr6UlTrCHTypeDchrachuschRlcSizeList& uLLogicalChannelMappingr6UlTrCHTypeDchrachuschRlcSizeList) { *static_cast<ULLogicalChannelMappingr6UlTrCHTypeDchrachuschRlcSizeList*>(items[2]) = uLLogicalChannelMappingr6UlTrCHTypeDchrachuschRlcSizeList; }
};

typedef Integer<CONSTRAINED, 0, maxE_DCHMACdFlow_1> EDCHMACdFlowIdentity;

typedef OctetModeRLCSizeInfoType1 RLCPDUSize;

typedef SequenceOf<RLCPDUSize, CONSTRAINED, 1, maxRLCPDUsizePerLogChan> RLCPDUSizeList;

typedef Boolean ULLogicalChannelMappingr6UlTrCHTypeEdchIncludeInSchedulingInfo;

class ULLogicalChannelMappingr6UlTrCHTypeEdch : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	ULLogicalChannelMappingr6UlTrCHTypeEdch(): Sequence(&theInfo) {}

	void setLogicalChannelIdentity(const LogicalChannelIdentity& logicalChannelIdentity) { *static_cast<LogicalChannelIdentity*>(items[0]) = logicalChannelIdentity; }
	void setEDCHMACdFlowIdentity(const EDCHMACdFlowIdentity& eDCHMACdFlowIdentity) { *static_cast<EDCHMACdFlowIdentity*>(items[1]) = eDCHMACdFlowIdentity; }
	void setDdi(const DDI& ddi) { *static_cast<DDI*>(items[2]) = ddi; }
	void setRlcPDUSizeList(const RLCPDUSizeList& rlcPDUSizeList) { *static_cast<RLCPDUSizeList*>(items[3]) = rlcPDUSizeList; }
	void setULLogicalChannelMappingr6UlTrCHTypeEdchIncludeInSchedulingInfo(const ULLogicalChannelMappingr6UlTrCHTypeEdchIncludeInSchedulingInfo& uLLogicalChannelMappingr6UlTrCHTypeEdchIncludeInSchedulingInfo) { *static_cast<ULLogicalChannelMappingr6UlTrCHTypeEdchIncludeInSchedulingInfo*>(items[4]) = uLLogicalChannelMappingr6UlTrCHTypeEdchIncludeInSchedulingInfo; }
};

class ULLogicalChannelMappingr6UlTrCHType : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULLogicalChannelMappingr6UlTrCHTypeChoices {
		uLLogicalChannelMappingr6UlTrCHTypeDchrachusch = 0,
		uLLogicalChannelMappingr6UlTrCHTypeEdch = 1,
	};
	static const Info theInfo;
	ULLogicalChannelMappingr6UlTrCHType(): Choice(&theInfo) {}
};

class ULLogicalChannelMappingr6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULLogicalChannelMappingr6(): Sequence(&theInfo) {}

	void setULLogicalChannelMappingr6UlTrCHType(const ULLogicalChannelMappingr6UlTrCHType& uLLogicalChannelMappingr6UlTrCHType) { *static_cast<ULLogicalChannelMappingr6UlTrCHType*>(items[0]) = uLLogicalChannelMappingr6UlTrCHType; }
	void setMacLogicalChannelPriority(const MACLogicalChannelPriority& macLogicalChannelPriority) { *static_cast<MACLogicalChannelPriority*>(items[1]) = macLogicalChannelPriority; }
};

typedef Boolean ULLogicalChannelMappingListr6RlcLogicalChannelMappingIndicator;

typedef SequenceOf<ULLogicalChannelMappingr6, CONSTRAINED, maxLoCHperRLC, maxLoCHperRLC> ULLogicalChannelMappingListr6UlLogicalChannelMapping;

class ULLogicalChannelMappingListr6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULLogicalChannelMappingListr6(): Sequence(&theInfo) {}

	void setULLogicalChannelMappingListr6RlcLogicalChannelMappingIndicator(const ULLogicalChannelMappingListr6RlcLogicalChannelMappingIndicator& uLLogicalChannelMappingListr6RlcLogicalChannelMappingIndicator) { *static_cast<ULLogicalChannelMappingListr6RlcLogicalChannelMappingIndicator*>(items[0]) = uLLogicalChannelMappingListr6RlcLogicalChannelMappingIndicator; }
	void setULLogicalChannelMappingListr6UlLogicalChannelMapping(const ULLogicalChannelMappingListr6UlLogicalChannelMapping& uLLogicalChannelMappingListr6UlLogicalChannelMapping) { *static_cast<ULLogicalChannelMappingListr6UlLogicalChannelMapping*>(items[1]) = uLLogicalChannelMappingListr6UlLogicalChannelMapping; }
};

class ULLogicalChannelMappingsr6 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULLogicalChannelMappingsr6Choices {
		oneLogicalChannel = 0,
		twoLogicalChannels = 1,
	};
	static const Info theInfo;
	ULLogicalChannelMappingsr6(): Choice(&theInfo) {}
};

class RBMappingOptionr6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RBMappingOptionr6(): Sequence(&theInfo) {}

	void setUlLogicalChannelMappings(const ULLogicalChannelMappingsr6& ulLogicalChannelMappings) { *static_cast<ULLogicalChannelMappingsr6*>(items[0]) = ulLogicalChannelMappings; }
	void setDlLogicalChannelMappingList(const DLLogicalChannelMappingListr5& dlLogicalChannelMappingList) { *static_cast<DLLogicalChannelMappingListr5*>(items[1]) = dlLogicalChannelMappingList; }
};

typedef SequenceOf<RBMappingOptionr6, CONSTRAINED, 1, maxRBMuxOptions> RBMappingInfor6;

class RBInformationSetupr6 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	RBInformationSetupr6(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setPdcpInfo(const PDCPInfor4& pdcpInfo) { *static_cast<PDCPInfor4*>(items[1]) = pdcpInfo; }
	void setRlcInfoChoice(const RLCInfoChoicer6& rlcInfoChoice) { *static_cast<RLCInfoChoicer6*>(items[2]) = rlcInfoChoice; }
	void setRbMappingInfo(const RBMappingInfor6& rbMappingInfo) { *static_cast<RBMappingInfor6*>(items[3]) = rbMappingInfo; }
};

typedef SequenceOf<RBInformationSetupr6, CONSTRAINED, 1, maxRBperRAB> RBInformationSetupListr6;

class RABInformationSetupr6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RABInformationSetupr6(): Sequence(&theInfo) {}

	void setRabInfo(const RABInfor6& rabInfo) { *static_cast<RABInfor6*>(items[0]) = rabInfo; }
	void setRbInformationSetupList(const RBInformationSetupListr6& rbInformationSetupList) { *static_cast<RBInformationSetupListr6*>(items[1]) = rbInformationSetupList; }
};

class RABInformationSetupv6b0ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	RABInformationSetupv6b0ext(): Sequence(&theInfo) {}

	void setRabInfov6b0ext(const RABInfov6b0ext& rabInfov6b0ext) { *static_cast<RABInfov6b0ext*>(items[0]) = rabInfov6b0ext; }
};

typedef Boolean RLCInfor7RlcOneSidedReEst;

enum RLCInfor7altE_bitInterpretationValues {
	true_RLCInfor7altE_bitInterpretation = 0,
};
typedef Enumerated<CONSTRAINED, 0> RLCInfor7altE_bitInterpretation;

enum RLCInfor7useSpecialValueOfHEFieldValues {
	true_RLCInfor7useSpecialValueOfHEField = 0,
};
typedef Enumerated<CONSTRAINED, 0> RLCInfor7useSpecialValueOfHEField;

class RLCInfor7 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	RLCInfor7(): Sequence(&theInfo) {}

	void setUlRLCMode(const ULRLCMode& ulRLCMode) { *static_cast<ULRLCMode*>(items[0]) = ulRLCMode; }
	void setDlRLCMode(const DLRLCModer7& dlRLCMode) { *static_cast<DLRLCModer7*>(items[1]) = dlRLCMode; }
	void setRLCInfor7RlcOneSidedReEst(const RLCInfor7RlcOneSidedReEst& rLCInfor7RlcOneSidedReEst) { *static_cast<RLCInfor7RlcOneSidedReEst*>(items[2]) = rLCInfor7RlcOneSidedReEst; }
	void setRLCInfor7altE_bitInterpretation(const RLCInfor7altE_bitInterpretation& rLCInfor7altE_bitInterpretation) { *static_cast<RLCInfor7altE_bitInterpretation*>(items[3]) = rLCInfor7altE_bitInterpretation; }
	void setRLCInfor7useSpecialValueOfHEField(const RLCInfor7useSpecialValueOfHEField& rLCInfor7useSpecialValueOfHEField) { *static_cast<RLCInfor7useSpecialValueOfHEField*>(items[4]) = rLCInfor7useSpecialValueOfHEField; }
};

class RLCInfoChoicer7 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum RLCInfoChoicer7Choices {
		rlcInfo = 0,
		sameasRB = 1,
	};
	static const Info theInfo;
	RLCInfoChoicer7(): Choice(&theInfo) {}
};

class RBMappingOptionr7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RBMappingOptionr7(): Sequence(&theInfo) {}

	void setUlLogicalChannelMappings(const ULLogicalChannelMappingsr6& ulLogicalChannelMappings) { *static_cast<ULLogicalChannelMappingsr6*>(items[0]) = ulLogicalChannelMappings; }
	void setDlLogicalChannelMappingList(const DLLogicalChannelMappingListr7& dlLogicalChannelMappingList) { *static_cast<DLLogicalChannelMappingListr7*>(items[1]) = dlLogicalChannelMappingList; }
};

typedef SequenceOf<RBMappingOptionr7, CONSTRAINED, 1, maxRBMuxOptions> RBMappingInfor7;

class RBInformationSetupr7 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	RBInformationSetupr7(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setPdcpInfo(const PDCPInfor4& pdcpInfo) { *static_cast<PDCPInfor4*>(items[1]) = pdcpInfo; }
	void setRlcInfoChoice(const RLCInfoChoicer7& rlcInfoChoice) { *static_cast<RLCInfoChoicer7*>(items[2]) = rlcInfoChoice; }
	void setRbMappingInfo(const RBMappingInfor7& rbMappingInfo) { *static_cast<RBMappingInfor7*>(items[3]) = rbMappingInfo; }
};

typedef SequenceOf<RBInformationSetupr7, CONSTRAINED, 1, maxRBperRAB> RBInformationSetupListr7;

class RABInformationSetupr7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RABInformationSetupr7(): Sequence(&theInfo) {}

	void setRabInfo(const RABInfor7& rabInfo) { *static_cast<RABInfor7*>(items[0]) = rabInfo; }
	void setRbInformationSetupList(const RBInformationSetupListr7& rbInformationSetupList) { *static_cast<RBInformationSetupListr7*>(items[1]) = rbInformationSetupList; }
};

typedef Null ULLogicalChannelMappingr8UlTrCHTypeDchrachuschRlcSizeListAllSizes;

typedef Null ULLogicalChannelMappingr8UlTrCHTypeDchrachuschRlcSizeListConfigured;

class ULLogicalChannelMappingr8UlTrCHTypeDchrachuschRlcSizeList : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum ULLogicalChannelMappingr8UlTrCHTypeDchrachuschRlcSizeListChoices {
		uLLogicalChannelMappingr8UlTrCHTypeDchrachuschRlcSizeListAllSizes = 0,
		uLLogicalChannelMappingr8UlTrCHTypeDchrachuschRlcSizeListConfigured = 1,
		explicitList = 2,
	};
	static const Info theInfo;
	ULLogicalChannelMappingr8UlTrCHTypeDchrachuschRlcSizeList(): Choice(&theInfo) {}
};

class ULLogicalChannelMappingr8UlTrCHTypeDchrachusch : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULLogicalChannelMappingr8UlTrCHTypeDchrachusch(): Sequence(&theInfo) {}

	void setUlTransportChannelType(const ULTransportChannelType& ulTransportChannelType) { *static_cast<ULTransportChannelType*>(items[0]) = ulTransportChannelType; }
	void setLogicalChannelIdentity(const LogicalChannelIdentity& logicalChannelIdentity) { *static_cast<LogicalChannelIdentity*>(items[1]) = logicalChannelIdentity; }
	void setULLogicalChannelMappingr8UlTrCHTypeDchrachuschRlcSizeList(const ULLogicalChannelMappingr8UlTrCHTypeDchrachuschRlcSizeList& uLLogicalChannelMappingr8UlTrCHTypeDchrachuschRlcSizeList) { *static_cast<ULLogicalChannelMappingr8UlTrCHTypeDchrachuschRlcSizeList*>(items[2]) = uLLogicalChannelMappingr8UlTrCHTypeDchrachuschRlcSizeList; }
};

class ULLogicalChannelMappingr8UlTrCHTypeEdchRlcPDUSizeFixedSize : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULLogicalChannelMappingr8UlTrCHTypeEdchRlcPDUSizeFixedSize(): Sequence(&theInfo) {}

	void setDdi(const DDI& ddi) { *static_cast<DDI*>(items[0]) = ddi; }
	void setRlcPDUSizeList(const RLCPDUSizeList& rlcPDUSizeList) { *static_cast<RLCPDUSizeList*>(items[1]) = rlcPDUSizeList; }
};

enum RLCPDUSizeConstraintlengthIndicatorSizeValues {
	size7_RLCPDUSizeConstraintlengthIndicatorSize = 0,
	size15_RLCPDUSizeConstraintlengthIndicatorSize = 1,
};
typedef Enumerated<CONSTRAINED, 1> RLCPDUSizeConstraintlengthIndicatorSize;

typedef Integer<CONSTRAINED, 0, 1503> RLCPDUSizeConstraintMinRLCPDUSize;

typedef Integer<CONSTRAINED, 0, 1503> RLCPDUSizeConstraintLargestRLCPDUSize;

class RLCPDUSizeConstraint : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	RLCPDUSizeConstraint(): Sequence(&theInfo) {}

	void setRLCPDUSizeConstraintlengthIndicatorSize(const RLCPDUSizeConstraintlengthIndicatorSize& rLCPDUSizeConstraintlengthIndicatorSize) { *static_cast<RLCPDUSizeConstraintlengthIndicatorSize*>(items[0]) = rLCPDUSizeConstraintlengthIndicatorSize; }
	void setRLCPDUSizeConstraintMinRLCPDUSize(const RLCPDUSizeConstraintMinRLCPDUSize& rLCPDUSizeConstraintMinRLCPDUSize) { *static_cast<RLCPDUSizeConstraintMinRLCPDUSize*>(items[1]) = rLCPDUSizeConstraintMinRLCPDUSize; }
	void setRLCPDUSizeConstraintLargestRLCPDUSize(const RLCPDUSizeConstraintLargestRLCPDUSize& rLCPDUSizeConstraintLargestRLCPDUSize) { *static_cast<RLCPDUSizeConstraintLargestRLCPDUSize*>(items[2]) = rLCPDUSizeConstraintLargestRLCPDUSize; }
};

class ULLogicalChannelMappingr8UlTrCHTypeEdchRlcPDUSize : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULLogicalChannelMappingr8UlTrCHTypeEdchRlcPDUSizeChoices {
		uLLogicalChannelMappingr8UlTrCHTypeEdchRlcPDUSizeFixedSize = 0,
		flexibleSize = 1,
	};
	static const Info theInfo;
	ULLogicalChannelMappingr8UlTrCHTypeEdchRlcPDUSize(): Choice(&theInfo) {}
};

typedef Boolean ULLogicalChannelMappingr8UlTrCHTypeEdchIncludeInSchedulingInfo;

class ULLogicalChannelMappingr8UlTrCHTypeEdch : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	ULLogicalChannelMappingr8UlTrCHTypeEdch(): Sequence(&theInfo) {}

	void setLogicalChannelIdentity(const LogicalChannelIdentity& logicalChannelIdentity) { *static_cast<LogicalChannelIdentity*>(items[0]) = logicalChannelIdentity; }
	void setEDCHMACdFlowIdentity(const EDCHMACdFlowIdentity& eDCHMACdFlowIdentity) { *static_cast<EDCHMACdFlowIdentity*>(items[1]) = eDCHMACdFlowIdentity; }
	void setULLogicalChannelMappingr8UlTrCHTypeEdchRlcPDUSize(const ULLogicalChannelMappingr8UlTrCHTypeEdchRlcPDUSize& uLLogicalChannelMappingr8UlTrCHTypeEdchRlcPDUSize) { *static_cast<ULLogicalChannelMappingr8UlTrCHTypeEdchRlcPDUSize*>(items[2]) = uLLogicalChannelMappingr8UlTrCHTypeEdchRlcPDUSize; }
	void setULLogicalChannelMappingr8UlTrCHTypeEdchIncludeInSchedulingInfo(const ULLogicalChannelMappingr8UlTrCHTypeEdchIncludeInSchedulingInfo& uLLogicalChannelMappingr8UlTrCHTypeEdchIncludeInSchedulingInfo) { *static_cast<ULLogicalChannelMappingr8UlTrCHTypeEdchIncludeInSchedulingInfo*>(items[3]) = uLLogicalChannelMappingr8UlTrCHTypeEdchIncludeInSchedulingInfo; }
};

class ULLogicalChannelMappingr8UlTrCHType : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULLogicalChannelMappingr8UlTrCHTypeChoices {
		uLLogicalChannelMappingr8UlTrCHTypeDchrachusch = 0,
		uLLogicalChannelMappingr8UlTrCHTypeEdch = 1,
	};
	static const Info theInfo;
	ULLogicalChannelMappingr8UlTrCHType(): Choice(&theInfo) {}
};

class ULLogicalChannelMappingr8 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULLogicalChannelMappingr8(): Sequence(&theInfo) {}

	void setULLogicalChannelMappingr8UlTrCHType(const ULLogicalChannelMappingr8UlTrCHType& uLLogicalChannelMappingr8UlTrCHType) { *static_cast<ULLogicalChannelMappingr8UlTrCHType*>(items[0]) = uLLogicalChannelMappingr8UlTrCHType; }
	void setMacLogicalChannelPriority(const MACLogicalChannelPriority& macLogicalChannelPriority) { *static_cast<MACLogicalChannelPriority*>(items[1]) = macLogicalChannelPriority; }
};

typedef Boolean ULLogicalChannelMappingListr8RlcLogicalChannelMappingIndicator;

typedef SequenceOf<ULLogicalChannelMappingr8, CONSTRAINED, maxLoCHperRLC, maxLoCHperRLC> ULLogicalChannelMappingListr8UlLogicalChannelMapping;

class ULLogicalChannelMappingListr8 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULLogicalChannelMappingListr8(): Sequence(&theInfo) {}

	void setULLogicalChannelMappingListr8RlcLogicalChannelMappingIndicator(const ULLogicalChannelMappingListr8RlcLogicalChannelMappingIndicator& uLLogicalChannelMappingListr8RlcLogicalChannelMappingIndicator) { *static_cast<ULLogicalChannelMappingListr8RlcLogicalChannelMappingIndicator*>(items[0]) = uLLogicalChannelMappingListr8RlcLogicalChannelMappingIndicator; }
	void setULLogicalChannelMappingListr8UlLogicalChannelMapping(const ULLogicalChannelMappingListr8UlLogicalChannelMapping& uLLogicalChannelMappingListr8UlLogicalChannelMapping) { *static_cast<ULLogicalChannelMappingListr8UlLogicalChannelMapping*>(items[1]) = uLLogicalChannelMappingListr8UlLogicalChannelMapping; }
};

class ULLogicalChannelMappingsr8 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULLogicalChannelMappingsr8Choices {
		oneLogicalChannel = 0,
		twoLogicalChannels = 1,
	};
	static const Info theInfo;
	ULLogicalChannelMappingsr8(): Choice(&theInfo) {}
};

class RBMappingOptionr8 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RBMappingOptionr8(): Sequence(&theInfo) {}

	void setUlLogicalChannelMappings(const ULLogicalChannelMappingsr8& ulLogicalChannelMappings) { *static_cast<ULLogicalChannelMappingsr8*>(items[0]) = ulLogicalChannelMappings; }
	void setDlLogicalChannelMappingList(const DLLogicalChannelMappingListr7& dlLogicalChannelMappingList) { *static_cast<DLLogicalChannelMappingListr7*>(items[1]) = dlLogicalChannelMappingList; }
};

typedef SequenceOf<RBMappingOptionr8, CONSTRAINED, 1, maxRBMuxOptions> RBMappingInfor8;

class RBInformationSetupr8 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	RBInformationSetupr8(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setPdcpInfo(const PDCPInfor4& pdcpInfo) { *static_cast<PDCPInfor4*>(items[1]) = pdcpInfo; }
	void setRlcInfoChoice(const RLCInfoChoicer7& rlcInfoChoice) { *static_cast<RLCInfoChoicer7*>(items[2]) = rlcInfoChoice; }
	void setRbMappingInfo(const RBMappingInfor8& rbMappingInfo) { *static_cast<RBMappingInfor8*>(items[3]) = rbMappingInfo; }
};

typedef SequenceOf<RBInformationSetupr8, CONSTRAINED, 1, maxRBperRAB> RBInformationSetupListr8;

class RABInformationSetupr8 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	RABInformationSetupr8(): Sequence(&theInfo) {}

	void setRabInfo(const RABInfor7& rabInfo) { *static_cast<RABInfor7*>(items[0]) = rabInfo; }
	void setCsHSPAInformation(const CSHSPAInformation& csHSPAInformation) { *static_cast<CSHSPAInformation*>(items[1]) = csHSPAInformation; }
	void setRabInfoReplace(const RABInfoReplace& rabInfoReplace) { *static_cast<RABInfoReplace*>(items[2]) = rabInfoReplace; }
	void setRbInformationSetupList(const RBInformationSetupListr8& rbInformationSetupList) { *static_cast<RBInformationSetupListr8*>(items[3]) = rbInformationSetupList; }
};

class RABInformationSetupv820ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	RABInformationSetupv820ext(): Sequence(&theInfo) {}

	void setCsHSPAInformation(const CSHSPAInformation& csHSPAInformation) { *static_cast<CSHSPAInformation*>(items[0]) = csHSPAInformation; }
};

typedef SequenceOf<RABInformationSetup, CONSTRAINED, 1, maxRABsetup> RABInformationSetupList;

typedef SequenceOf<RABInformationSetupr4, CONSTRAINED, 1, maxRABsetup> RABInformationSetupListr4;

typedef SequenceOf<RABInformationSetupr5, CONSTRAINED, 1, maxRABsetup> RABInformationSetupListr5;

typedef SequenceOf<RABInformationSetupr6, CONSTRAINED, 1, maxRABsetup> RABInformationSetupListr6;

typedef SequenceOf<RABInformationSetupr6ext, CONSTRAINED, 1, maxRABsetup> RABInformationSetupListr6ext;

typedef SequenceOf<RABInformationSetupv6b0ext, CONSTRAINED, 1, maxRABsetup> RABInformationSetupListv6b0ext;

typedef SequenceOf<RABInformationSetupr7, CONSTRAINED, 1, maxRABsetup> RABInformationSetupListr7;

typedef SequenceOf<RABInformationSetupr8, CONSTRAINED, 1, maxRABsetup> RABInformationSetupListr8;

typedef SequenceOf<RABInformationSetupv820ext, CONSTRAINED, 1, maxRABsetup> RABInformationSetupListv820ext;

class RBCOUNTCInformation : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	RBCOUNTCInformation(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setCountCUL(const COUNTC& countCUL) { *static_cast<COUNTC*>(items[1]) = countCUL; }
	void setCountCDL(const COUNTC& countCDL) { *static_cast<COUNTC*>(items[2]) = countCDL; }
};

typedef SequenceOf<RBCOUNTCInformation, CONSTRAINED, 1, maxRBallRABs> RBCOUNTCInformationList;

class RBCOUNTCMSBInformation : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	RBCOUNTCMSBInformation(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setCountCMSBUL(const COUNTCMSB& countCMSBUL) { *static_cast<COUNTCMSB*>(items[1]) = countCMSBUL; }
	void setCountCMSBDL(const COUNTCMSB& countCMSBDL) { *static_cast<COUNTCMSB*>(items[2]) = countCMSBDL; }
};

typedef SequenceOf<RBCOUNTCMSBInformation, CONSTRAINED, 1, maxRBallRABs> RBCOUNTCMSBInformationList;

typedef SequenceOf<RBIdentity, CONSTRAINED, 1, maxRB> RBIdentityList;

class RBInformationAffected : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RBInformationAffected(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setRbMappingInfo(const RBMappingInfo& rbMappingInfo) { *static_cast<RBMappingInfo*>(items[1]) = rbMappingInfo; }
};

class RBInformationAffectedr5 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RBInformationAffectedr5(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setRbMappingInfo(const RBMappingInfor5& rbMappingInfo) { *static_cast<RBMappingInfor5*>(items[1]) = rbMappingInfo; }
};

class RBInformationAffectedr6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RBInformationAffectedr6(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setRbMappingInfo(const RBMappingInfor6& rbMappingInfo) { *static_cast<RBMappingInfor6*>(items[1]) = rbMappingInfo; }
};

class RBInformationAffectedr7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RBInformationAffectedr7(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setRbMappingInfo(const RBMappingInfor7& rbMappingInfo) { *static_cast<RBMappingInfor7*>(items[1]) = rbMappingInfo; }
};

class RBInformationAffectedr8 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RBInformationAffectedr8(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setRbMappingInfo(const RBMappingInfor8& rbMappingInfo) { *static_cast<RBMappingInfor8*>(items[1]) = rbMappingInfo; }
};

typedef SequenceOf<RBInformationAffected, CONSTRAINED, 1, maxRB> RBInformationAffectedList;

typedef SequenceOf<RBInformationAffectedr5, CONSTRAINED, 1, maxRB> RBInformationAffectedListr5;

typedef SequenceOf<RBInformationAffectedr6, CONSTRAINED, 1, maxRB> RBInformationAffectedListr6;

typedef SequenceOf<RBInformationAffectedr7, CONSTRAINED, 1, maxRB> RBInformationAffectedListr7;

typedef SequenceOf<RBInformationAffectedr8, CONSTRAINED, 1, maxRB> RBInformationAffectedListr8;

typedef Null RBInformationChangedr6RbChangeRelease;

class RBInformationChangedr6RbChange : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum RBInformationChangedr6RbChangeChoices {
		rBInformationChangedr6RbChangeRelease = 0,
		remapToDefaultRb = 1,
	};
	static const Info theInfo;
	RBInformationChangedr6RbChange(): Choice(&theInfo) {}
};

class RBInformationChangedr6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RBInformationChangedr6(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setRBInformationChangedr6RbChange(const RBInformationChangedr6RbChange& rBInformationChangedr6RbChange) { *static_cast<RBInformationChangedr6RbChange*>(items[1]) = rBInformationChangedr6RbChange; }
};

typedef SequenceOf<RBInformationChangedr6, CONSTRAINED, 1, maxRB> RBInformationChangedListr6;

enum RBStopContinueValues {
	stopRB_RBStopContinue = 0,
	continueRB_RBStopContinue = 1,
};
typedef Enumerated<CONSTRAINED, 1> RBStopContinue;

class RBInformationReconfig : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	RBInformationReconfig(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setPdcpInfo(const PDCPInfoReconfig& pdcpInfo) { *static_cast<PDCPInfoReconfig*>(items[1]) = pdcpInfo; }
	void setPdcpSNInfo(const PDCPSNInfo& pdcpSNInfo) { *static_cast<PDCPSNInfo*>(items[2]) = pdcpSNInfo; }
	void setRlcInfo(const RLCInfo& rlcInfo) { *static_cast<RLCInfo*>(items[3]) = rlcInfo; }
	void setRbMappingInfo(const RBMappingInfo& rbMappingInfo) { *static_cast<RBMappingInfo*>(items[4]) = rbMappingInfo; }
	void setRbStopContinue(const RBStopContinue& rbStopContinue) { *static_cast<RBStopContinue*>(items[5]) = rbStopContinue; }
};

class RBInformationReconfigr4 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	RBInformationReconfigr4(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setPdcpInfo(const PDCPInfoReconfigr4& pdcpInfo) { *static_cast<PDCPInfoReconfigr4*>(items[1]) = pdcpInfo; }
	void setPdcpSNInfo(const PDCPSNInfo& pdcpSNInfo) { *static_cast<PDCPSNInfo*>(items[2]) = pdcpSNInfo; }
	void setRlcInfo(const RLCInfo& rlcInfo) { *static_cast<RLCInfo*>(items[3]) = rlcInfo; }
	void setRbMappingInfo(const RBMappingInfo& rbMappingInfo) { *static_cast<RBMappingInfo*>(items[4]) = rbMappingInfo; }
	void setRbStopContinue(const RBStopContinue& rbStopContinue) { *static_cast<RBStopContinue*>(items[5]) = rbStopContinue; }
};

class RBInformationReconfigr5 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	RBInformationReconfigr5(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setPdcpInfo(const PDCPInfoReconfigr4& pdcpInfo) { *static_cast<PDCPInfoReconfigr4*>(items[1]) = pdcpInfo; }
	void setPdcpSNInfo(const PDCPSNInfo& pdcpSNInfo) { *static_cast<PDCPSNInfo*>(items[2]) = pdcpSNInfo; }
	void setRlcInfo(const RLCInfor5& rlcInfo) { *static_cast<RLCInfor5*>(items[3]) = rlcInfo; }
	void setRbMappingInfo(const RBMappingInfor5& rbMappingInfo) { *static_cast<RBMappingInfor5*>(items[4]) = rbMappingInfo; }
	void setRbStopContinue(const RBStopContinue& rbStopContinue) { *static_cast<RBStopContinue*>(items[5]) = rbStopContinue; }
};

class RBInformationReconfigr6 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	RBInformationReconfigr6(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setPdcpInfo(const PDCPInfoReconfigr4& pdcpInfo) { *static_cast<PDCPInfoReconfigr4*>(items[1]) = pdcpInfo; }
	void setPdcpSNInfo(const PDCPSNInfo& pdcpSNInfo) { *static_cast<PDCPSNInfo*>(items[2]) = pdcpSNInfo; }
	void setRlcInfo(const RLCInfor6& rlcInfo) { *static_cast<RLCInfor6*>(items[3]) = rlcInfo; }
	void setRbMappingInfo(const RBMappingInfor6& rbMappingInfo) { *static_cast<RBMappingInfor6*>(items[4]) = rbMappingInfo; }
	void setRbStopContinue(const RBStopContinue& rbStopContinue) { *static_cast<RBStopContinue*>(items[5]) = rbStopContinue; }
};

class RBInformationReconfigr7 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	RBInformationReconfigr7(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setPdcpInfo(const PDCPInfoReconfigr4& pdcpInfo) { *static_cast<PDCPInfoReconfigr4*>(items[1]) = pdcpInfo; }
	void setPdcpSNInfo(const PDCPSNInfo& pdcpSNInfo) { *static_cast<PDCPSNInfo*>(items[2]) = pdcpSNInfo; }
	void setRlcInfo(const RLCInfor7& rlcInfo) { *static_cast<RLCInfor7*>(items[3]) = rlcInfo; }
	void setRbMappingInfo(const RBMappingInfor7& rbMappingInfo) { *static_cast<RBMappingInfor7*>(items[4]) = rbMappingInfo; }
	void setRbStopContinue(const RBStopContinue& rbStopContinue) { *static_cast<RBStopContinue*>(items[5]) = rbStopContinue; }
};

class RBInformationReconfigr8 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	RBInformationReconfigr8(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setPdcpInfo(const PDCPInfoReconfigr4& pdcpInfo) { *static_cast<PDCPInfoReconfigr4*>(items[1]) = pdcpInfo; }
	void setPdcpSNInfo(const PDCPSNInfo& pdcpSNInfo) { *static_cast<PDCPSNInfo*>(items[2]) = pdcpSNInfo; }
	void setRlcInfo(const RLCInfor7& rlcInfo) { *static_cast<RLCInfor7*>(items[3]) = rlcInfo; }
	void setRbMappingInfo(const RBMappingInfor8& rbMappingInfo) { *static_cast<RBMappingInfor8*>(items[4]) = rbMappingInfo; }
	void setRbStopContinue(const RBStopContinue& rbStopContinue) { *static_cast<RBStopContinue*>(items[5]) = rbStopContinue; }
};

typedef SequenceOf<RBInformationReconfig, CONSTRAINED, 1, maxRB> RBInformationReconfigList;

typedef SequenceOf<RBInformationReconfigr4, CONSTRAINED, 1, maxRB> RBInformationReconfigListr4;

typedef SequenceOf<RBInformationReconfigr5, CONSTRAINED, 1, maxRB> RBInformationReconfigListr5;

typedef SequenceOf<RBInformationReconfigr6, CONSTRAINED, 1, maxRB> RBInformationReconfigListr6;

typedef SequenceOf<RBInformationReconfigr7, CONSTRAINED, 1, maxRB> RBInformationReconfigListr7;

typedef SequenceOf<RBInformationReconfigr8, CONSTRAINED, 1, maxRB> RBInformationReconfigListr8;

typedef SequenceOf<RBIdentity, CONSTRAINED, 1, maxRB> RBInformationReleaseList;

enum TimerOSDr6Values {
	ms40_TimerOSDr6 = 0,
	ms80_TimerOSDr6 = 1,
	ms120_TimerOSDr6 = 2,
	ms160_TimerOSDr6 = 3,
	ms240_TimerOSDr6 = 4,
	ms320_TimerOSDr6 = 5,
	ms480_TimerOSDr6 = 6,
	ms640_TimerOSDr6 = 7,
	ms960_TimerOSDr6 = 8,
	ms1280_TimerOSDr6 = 9,
	ms1920_TimerOSDr6 = 10,
	ms2560_TimerOSDr6 = 11,
	ms3840_TimerOSDr6 = 12,
	ms5120_TimerOSDr6 = 13,
};
typedef Enumerated<CONSTRAINED, 13> TimerOSDr6;

enum WindowSizeOSDr6Values {
	ws8_WindowSizeOSDr6 = 0,
	ws16_WindowSizeOSDr6 = 1,
	ws32_WindowSizeOSDr6 = 2,
	ws40_WindowSizeOSDr6 = 3,
	ws48_WindowSizeOSDr6 = 4,
	ws56_WindowSizeOSDr6 = 5,
	ws64_WindowSizeOSDr6 = 6,
};
typedef Enumerated<CONSTRAINED, 6> WindowSizeOSDr6;

class UMRLCOutOSeqDeliveryInfor6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UMRLCOutOSeqDeliveryInfor6(): Sequence(&theInfo) {}

	void setTimerOSD(const TimerOSDr6& timerOSD) { *static_cast<TimerOSDr6*>(items[0]) = timerOSD; }
	void setWindowSizeOSD(const WindowSizeOSDr6& windowSizeOSD) { *static_cast<WindowSizeOSDr6*>(items[1]) = windowSizeOSD; }
};

class RLCInfoMCCHr6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RLCInfoMCCHr6(): Sequence(&theInfo) {}

	void setDlUMRLCLIsize(const DLUMRLCLIsize& dlUMRLCLIsize) { *static_cast<DLUMRLCLIsize*>(items[0]) = dlUMRLCLIsize; }
	void setDlUMRLCOutOSeqDeliveryInfo(const UMRLCOutOSeqDeliveryInfor6& dlUMRLCOutOSeqDeliveryInfo) { *static_cast<UMRLCOutOSeqDeliveryInfor6*>(items[1]) = dlUMRLCOutOSeqDeliveryInfo; }
};

class RLCInfoMSCHr6 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	RLCInfoMSCHr6(): Sequence(&theInfo) {}

	void setDlUMRLCLIsize(const DLUMRLCLIsize& dlUMRLCLIsize) { *static_cast<DLUMRLCLIsize*>(items[0]) = dlUMRLCLIsize; }
};

enum TimerDARr6Values {
	ms40_TimerDARr6 = 0,
	ms80_TimerDARr6 = 1,
	ms120_TimerDARr6 = 2,
	ms160_TimerDARr6 = 3,
	ms240_TimerDARr6 = 4,
	ms320_TimerDARr6 = 5,
	ms480_TimerDARr6 = 6,
	ms640_TimerDARr6 = 7,
	ms960_TimerDARr6 = 8,
	ms1280_TimerDARr6 = 9,
	ms1920_TimerDARr6 = 10,
	ms2560_TimerDARr6 = 11,
	ms3840_TimerDARr6 = 12,
	ms5120_TimerDARr6 = 13,
};
typedef Enumerated<CONSTRAINED, 13> TimerDARr6;

enum WindowSizeDARr6Values {
	ws4_WindowSizeDARr6 = 0,
	ws8_WindowSizeDARr6 = 1,
	ws16_WindowSizeDARr6 = 2,
	ws32_WindowSizeDARr6 = 3,
	ws40_WindowSizeDARr6 = 4,
	ws48_WindowSizeDARr6 = 5,
	ws56_WindowSizeDARr6 = 6,
	ws64_WindowSizeDARr6 = 7,
};
typedef Enumerated<CONSTRAINED, 7> WindowSizeDARr6;

class UMRLCDuplAvoidReordInfor6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UMRLCDuplAvoidReordInfor6(): Sequence(&theInfo) {}

	void setTimerDAR(const TimerDARr6& timerDAR) { *static_cast<TimerDARr6*>(items[0]) = timerDAR; }
	void setWidowSizeDAR(const WindowSizeDARr6& widowSizeDAR) { *static_cast<WindowSizeDARr6*>(items[1]) = widowSizeDAR; }
};

class RLCInfoMTCHr6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RLCInfoMTCHr6(): Sequence(&theInfo) {}

	void setDlUMRLCLIsize(const DLUMRLCLIsize& dlUMRLCLIsize) { *static_cast<DLUMRLCLIsize*>(items[0]) = dlUMRLCLIsize; }
	void setDlUMRLCDuplAvoidReordInfo(const UMRLCDuplAvoidReordInfor6& dlUMRLCDuplAvoidReordInfo) { *static_cast<UMRLCDuplAvoidReordInfor6*>(items[1]) = dlUMRLCDuplAvoidReordInfo; }
};

class SRBInformationSetupr5 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SRBInformationSetupr5(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setRlcInfoChoice(const RLCInfoChoicer5& rlcInfoChoice) { *static_cast<RLCInfoChoicer5*>(items[1]) = rlcInfoChoice; }
	void setRbMappingInfo(const RBMappingInfor5& rbMappingInfo) { *static_cast<RBMappingInfor5*>(items[2]) = rbMappingInfo; }
};

class SRBInformationSetupr6 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SRBInformationSetupr6(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setRlcInfoChoice(const RLCInfoChoicer6& rlcInfoChoice) { *static_cast<RLCInfoChoicer6*>(items[1]) = rlcInfoChoice; }
	void setRbMappingInfo(const RBMappingInfor6& rbMappingInfo) { *static_cast<RBMappingInfor6*>(items[2]) = rbMappingInfo; }
};

class SRBInformationSetupr7 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SRBInformationSetupr7(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setRlcInfoChoice(const RLCInfoChoicer7& rlcInfoChoice) { *static_cast<RLCInfoChoicer7*>(items[1]) = rlcInfoChoice; }
	void setRbMappingInfo(const RBMappingInfor7& rbMappingInfo) { *static_cast<RBMappingInfor7*>(items[2]) = rbMappingInfo; }
};

class SRBInformationSetupr8 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SRBInformationSetupr8(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setRlcInfoChoice(const RLCInfoChoicer7& rlcInfoChoice) { *static_cast<RLCInfoChoicer7*>(items[1]) = rlcInfoChoice; }
	void setRbMappingInfo(const RBMappingInfor8& rbMappingInfo) { *static_cast<RBMappingInfor8*>(items[2]) = rbMappingInfo; }
};

typedef SequenceOf<SRBInformationSetupr5, CONSTRAINED, 1, maxSRBsetup> SRBInformationSetupListr5;

typedef SequenceOf<SRBInformationSetupr6, CONSTRAINED, 1, maxSRBsetup> SRBInformationSetupListr6;

typedef SequenceOf<SRBInformationSetupr7, CONSTRAINED, 1, maxSRBsetup> SRBInformationSetupListr7;

typedef SequenceOf<SRBInformationSetupr8, CONSTRAINED, 1, maxSRBsetup> SRBInformationSetupListr8;

typedef SequenceOf<SRBInformationSetup, CONSTRAINED, 3, 4> SRBInformationSetupList2;

typedef SequenceOf<SRBInformationSetupr6, CONSTRAINED, 3, 4> SRBInformationSetupList2r6;

typedef SequenceOf<SRBInformationSetupr7, CONSTRAINED, 3, 4> SRBInformationSetupList2r7;

typedef SequenceOf<SRBInformationSetupr8, CONSTRAINED, 3, 4> SRBInformationSetupList2r8;

class ULCounterSynchronisationInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULCounterSynchronisationInfo(): Sequence(&theInfo) {}

	void setRBWithPDCPInfoList(const RBWithPDCPInfoList& rBWithPDCPInfoList) { *static_cast<RBWithPDCPInfoList*>(items[0]) = rBWithPDCPInfoList; }
	void setStartList(const STARTList& startList) { *static_cast<STARTList*>(items[1]) = startList; }
};

typedef Integer<CONSTRAINED, 0, 7> MAChsAddReconfQueueMachsQueueId;

enum T1ReleaseTimerValues {
	rt10_T1ReleaseTimer = 0,
	rt20_T1ReleaseTimer = 1,
	rt30_T1ReleaseTimer = 2,
	rt40_T1ReleaseTimer = 3,
	rt50_T1ReleaseTimer = 4,
	rt60_T1ReleaseTimer = 5,
	rt70_T1ReleaseTimer = 6,
	rt80_T1ReleaseTimer = 7,
	rt90_T1ReleaseTimer = 8,
	rt100_T1ReleaseTimer = 9,
	rt120_T1ReleaseTimer = 10,
	rt140_T1ReleaseTimer = 11,
	rt160_T1ReleaseTimer = 12,
	rt200_T1ReleaseTimer = 13,
	rt300_T1ReleaseTimer = 14,
	rt400_T1ReleaseTimer = 15,
};
typedef Enumerated<CONSTRAINED, 15> T1ReleaseTimer;

enum MAChsWindowSizeValues {
	mws4_MAChsWindowSize = 0,
	mws6_MAChsWindowSize = 1,
	mws8_MAChsWindowSize = 2,
	mws12_MAChsWindowSize = 3,
	mws16_MAChsWindowSize = 4,
	mws24_MAChsWindowSize = 5,
	mws32_MAChsWindowSize = 6,
};
typedef Enumerated<CONSTRAINED, 6> MAChsWindowSize;

typedef Integer<CONSTRAINED, 1, 5000> MACdPDUsizeInfoMacdPDUSize;

typedef Integer<CONSTRAINED, 0, 7> MACdPDUsizeInfoMacdPDUIndex;

class MACdPDUsizeInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MACdPDUsizeInfo(): Sequence(&theInfo) {}

	void setMACdPDUsizeInfoMacdPDUSize(const MACdPDUsizeInfoMacdPDUSize& mACdPDUsizeInfoMacdPDUSize) { *static_cast<MACdPDUsizeInfoMacdPDUSize*>(items[0]) = mACdPDUsizeInfoMacdPDUSize; }
	void setMACdPDUsizeInfoMacdPDUIndex(const MACdPDUsizeInfoMacdPDUIndex& mACdPDUsizeInfoMacdPDUIndex) { *static_cast<MACdPDUsizeInfoMacdPDUIndex*>(items[1]) = mACdPDUsizeInfoMacdPDUIndex; }
};

typedef SequenceOf<MACdPDUsizeInfo, CONSTRAINED, 1,  maxMAC_d_PDUsizes> MACdPDUSizeInfoList;

class MAChsAddReconfQueue : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	MAChsAddReconfQueue(): Sequence(&theInfo) {}

	void setMAChsAddReconfQueueMachsQueueId(const MAChsAddReconfQueueMachsQueueId& mAChsAddReconfQueueMachsQueueId) { *static_cast<MAChsAddReconfQueueMachsQueueId*>(items[0]) = mAChsAddReconfQueueMachsQueueId; }
	void setMacdFlowId(const MACdFlowIdentity& macdFlowId) { *static_cast<MACdFlowIdentity*>(items[1]) = macdFlowId; }
	void setReorderingReleaseTimer(const T1ReleaseTimer& reorderingReleaseTimer) { *static_cast<T1ReleaseTimer*>(items[2]) = reorderingReleaseTimer; }
	void setMachsWindowSize(const MAChsWindowSize& machsWindowSize) { *static_cast<MAChsWindowSize*>(items[3]) = machsWindowSize; }
	void setMacdPDUSizeInfoList(const MACdPDUSizeInfoList& macdPDUSizeInfoList) { *static_cast<MACdPDUSizeInfoList*>(items[4]) = macdPDUSizeInfoList; }
};

typedef SequenceOf<MAChsAddReconfQueue, CONSTRAINED, 1, maxQueueIDs> MAChsAddReconfQueueList;

typedef Integer<CONSTRAINED, 0, 7> MAChsDelQueueMachsQueueId;

class MAChsDelQueue : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MAChsDelQueue(): Sequence(&theInfo) {}

	void setMAChsDelQueueMachsQueueId(const MAChsDelQueueMachsQueueId& mAChsDelQueueMachsQueueId) { *static_cast<MAChsDelQueueMachsQueueId*>(items[0]) = mAChsDelQueueMachsQueueId; }
};

typedef SequenceOf<MAChsDelQueue, CONSTRAINED, 1, maxQueueIDs> MAChsDelQueueList;

class AddOrReconfMACdFlow : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	AddOrReconfMACdFlow(): Sequence(&theInfo) {}

	void setMachsAddReconfQueueList(const MAChsAddReconfQueueList& machsAddReconfQueueList) { *static_cast<MAChsAddReconfQueueList*>(items[0]) = machsAddReconfQueueList; }
	void setMachsDelQueueList(const MAChsDelQueueList& machsDelQueueList) { *static_cast<MAChsDelQueueList*>(items[1]) = machsDelQueueList; }
};

enum TresetResetTimerValues {
	rt1_TresetResetTimer = 0,
	rt2_TresetResetTimer = 1,
	rt3_TresetResetTimer = 2,
	rt4_TresetResetTimer = 3,
};
typedef Enumerated<CONSTRAINED, 3> TresetResetTimer;

class MACehsAddReconfReordQ : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	MACehsAddReconfReordQ(): Sequence(&theInfo) {}

	void setMacehsQueueId(const MACehsQueueId& macehsQueueId) { *static_cast<MACehsQueueId*>(items[0]) = macehsQueueId; }
	void setReorderingReleaseTimer(const T1ReleaseTimer& reorderingReleaseTimer) { *static_cast<T1ReleaseTimer*>(items[1]) = reorderingReleaseTimer; }
	void setReorderingResetTimer(const TresetResetTimer& reorderingResetTimer) { *static_cast<TresetResetTimer*>(items[2]) = reorderingResetTimer; }
	void setMacehsWindowSize(const MAChsWindowSize& macehsWindowSize) { *static_cast<MAChsWindowSize*>(items[3]) = macehsWindowSize; }
};

typedef SequenceOf<MACehsAddReconfReordQ, CONSTRAINED, 1, maxQueueIDs> MACehsAddReconfReordQList;

class MACehsDelReordQ : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MACehsDelReordQ(): Sequence(&theInfo) {}

	void setMacehsQueueId(const MACehsQueueId& macehsQueueId) { *static_cast<MACehsQueueId*>(items[0]) = macehsQueueId; }
};

typedef SequenceOf<MACehsDelReordQ, CONSTRAINED, 1, maxQueueIDs> MACehsDelReordQList;

class AddOrReconfMACehsReordQ : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	AddOrReconfMACehsReordQ(): Sequence(&theInfo) {}

	void setMacehsAddReconfQueueList(const MACehsAddReconfReordQList& macehsAddReconfQueueList) { *static_cast<MACehsAddReconfReordQList*>(items[0]) = macehsAddReconfQueueList; }
	void setDummy(const MACehsDelReordQList& dummy) { *static_cast<MACehsDelReordQList*>(items[1]) = dummy; }
};

class MACehsAddReconfReordQr9 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	MACehsAddReconfReordQr9(): Sequence(&theInfo) {}

	void setMacehsQueueId(const MACehsQueueId& macehsQueueId) { *static_cast<MACehsQueueId*>(items[0]) = macehsQueueId; }
	void setReorderingReleaseTimer(const T1ReleaseTimer& reorderingReleaseTimer) { *static_cast<T1ReleaseTimer*>(items[1]) = reorderingReleaseTimer; }
	void setReorderingResetTimer(const TresetResetTimer& reorderingResetTimer) { *static_cast<TresetResetTimer*>(items[2]) = reorderingResetTimer; }
	void setMacehsWindowSize(const MAChsWindowSizer9& macehsWindowSize) { *static_cast<MAChsWindowSizer9*>(items[3]) = macehsWindowSize; }
};

typedef SequenceOf<MACehsAddReconfReordQr9, CONSTRAINED, 1, maxQueueIDs> MACehsAddReconfReordQListr9;

class AddOrReconfMACehsReordQr9 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	AddOrReconfMACehsReordQr9(): Sequence(&theInfo) {}

	void setMacehsAddReconfQueueList(const MACehsAddReconfReordQListr9& macehsAddReconfQueueList) { *static_cast<MACehsAddReconfReordQListr9*>(items[0]) = macehsAddReconfQueueList; }
};

typedef Integer<CONSTRAINED, 0, 6> EDCHMACdFlowPowerOffset;

typedef Integer<CONSTRAINED, 0, 15> EDCHMACdFlowMaxRetrans;

typedef BitString<CONSTRAINED, maxE_DCHMACdFlow, maxE_DCHMACdFlow> EDCHMACdFlowMultiplexingList;

enum EDCHMACdFlowRetransTimerValues {
	ms10_EDCHMACdFlowRetransTimer = 0,
	ms15_EDCHMACdFlowRetransTimer = 1,
	ms20_EDCHMACdFlowRetransTimer = 2,
	ms25_EDCHMACdFlowRetransTimer = 3,
	ms30_EDCHMACdFlowRetransTimer = 4,
	ms35_EDCHMACdFlowRetransTimer = 5,
	ms40_EDCHMACdFlowRetransTimer = 6,
	ms45_EDCHMACdFlowRetransTimer = 7,
	ms50_EDCHMACdFlowRetransTimer = 8,
	ms55_EDCHMACdFlowRetransTimer = 9,
	ms60_EDCHMACdFlowRetransTimer = 10,
	ms65_EDCHMACdFlowRetransTimer = 11,
	ms70_EDCHMACdFlowRetransTimer = 12,
	ms75_EDCHMACdFlowRetransTimer = 13,
	ms80_EDCHMACdFlowRetransTimer = 14,
	ms85_EDCHMACdFlowRetransTimer = 15,
	ms90_EDCHMACdFlowRetransTimer = 16,
	ms95_EDCHMACdFlowRetransTimer = 17,
	ms100_EDCHMACdFlowRetransTimer = 18,
	ms110_EDCHMACdFlowRetransTimer = 19,
	ms120_EDCHMACdFlowRetransTimer = 20,
	ms140_EDCHMACdFlowRetransTimer = 21,
	ms160_EDCHMACdFlowRetransTimer = 22,
	ms200_EDCHMACdFlowRetransTimer = 23,
	ms240_EDCHMACdFlowRetransTimer = 24,
	ms280_EDCHMACdFlowRetransTimer = 25,
	ms320_EDCHMACdFlowRetransTimer = 26,
	ms400_EDCHMACdFlowRetransTimer = 27,
	ms480_EDCHMACdFlowRetransTimer = 28,
	ms560_EDCHMACdFlowRetransTimer = 29,
};
typedef Enumerated<CONSTRAINED, 29> EDCHMACdFlowRetransTimer;

class CommonEDCHMACdFlow : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	CommonEDCHMACdFlow(): Sequence(&theInfo) {}

	void setMacdFlowIdentity(const EDCHMACdFlowIdentity& macdFlowIdentity) { *static_cast<EDCHMACdFlowIdentity*>(items[0]) = macdFlowIdentity; }
	void setMacdFlowPowerOffset(const EDCHMACdFlowPowerOffset& macdFlowPowerOffset) { *static_cast<EDCHMACdFlowPowerOffset*>(items[1]) = macdFlowPowerOffset; }
	void setMacdFlowMaxRetrans(const EDCHMACdFlowMaxRetrans& macdFlowMaxRetrans) { *static_cast<EDCHMACdFlowMaxRetrans*>(items[2]) = macdFlowMaxRetrans; }
	void setMacdFlowMultiplexingList(const EDCHMACdFlowMultiplexingList& macdFlowMultiplexingList) { *static_cast<EDCHMACdFlowMultiplexingList*>(items[3]) = macdFlowMultiplexingList; }
	void setEdchmacdflowretransmissiontimer(const EDCHMACdFlowRetransTimer& edchmacdflowretransmissiontimer) { *static_cast<EDCHMACdFlowRetransTimer*>(items[4]) = edchmacdflowretransmissiontimer; }
};

typedef SequenceOf<CommonEDCHMACdFlow, CONSTRAINED, 1, maxE_DCHMACdFlow> CommonEDCHMACdFlowList;

class CommonTransChTFSLCRTti : public Choice {
private:
	static const void *choicesInfo[6];
public:
	enum CommonTransChTFSLCRTtiChoices {
		tti5 = 0,
		tti10 = 1,
		tti20 = 2,
		tti40 = 3,
		tti80 = 4,
		dynamic = 5,
	};
	static const Info theInfo;
	CommonTransChTFSLCRTti(): Choice(&theInfo) {}
};

class CommonTransChTFSLCR : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CommonTransChTFSLCR(): Sequence(&theInfo) {}

	void setCommonTransChTFSLCRTti(const CommonTransChTFSLCRTti& commonTransChTFSLCRTti) { *static_cast<CommonTransChTFSLCRTti*>(items[0]) = commonTransChTFSLCRTti; }
	void setSemistaticTFInformation(const SemistaticTFInformation& semistaticTFInformation) { *static_cast<SemistaticTFInformation*>(items[1]) = semistaticTFInformation; }
};

class CommonMACehsReorderingQueue : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CommonMACehsReorderingQueue(): Sequence(&theInfo) {}

	void setMacehsQueueId(const MACehsQueueId& macehsQueueId) { *static_cast<MACehsQueueId*>(items[0]) = macehsQueueId; }
	void setT1ReleaseTimer(const T1ReleaseTimer& t1ReleaseTimer) { *static_cast<T1ReleaseTimer*>(items[1]) = t1ReleaseTimer; }
	void setReorderingResetTimer(const TresetResetTimer& reorderingResetTimer) { *static_cast<TresetResetTimer*>(items[2]) = reorderingResetTimer; }
	void setMacehsWindowSize(const MAChsWindowSize& macehsWindowSize) { *static_cast<MAChsWindowSize*>(items[3]) = macehsWindowSize; }
};

typedef SequenceOf<CommonMACehsReorderingQueue, CONSTRAINED, 1,  maxCommonQueueID> CommonMACehsReorderingQueueList;

typedef Integer<CONSTRAINED, 1, maxCPCHsets> CPCHSetID;

class DLAddReconfTransChInformation2TfsSignallingMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLAddReconfTransChInformation2TfsSignallingModeChoices {
		explicitconfig = 0,
		sameAsULTrCH = 1,
	};
	static const Info theInfo;
	DLAddReconfTransChInformation2TfsSignallingMode(): Choice(&theInfo) {}
};

class DLAddReconfTransChInformation2 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	DLAddReconfTransChInformation2(): Sequence(&theInfo) {}

	void setDlTransportChannelType(const DLTrCHType& dlTransportChannelType) { *static_cast<DLTrCHType*>(items[0]) = dlTransportChannelType; }
	void setTransportChannelIdentity(const TransportChannelIdentity& transportChannelIdentity) { *static_cast<TransportChannelIdentity*>(items[1]) = transportChannelIdentity; }
	void setDLAddReconfTransChInformation2TfsSignallingMode(const DLAddReconfTransChInformation2TfsSignallingMode& dLAddReconfTransChInformation2TfsSignallingMode) { *static_cast<DLAddReconfTransChInformation2TfsSignallingMode*>(items[2]) = dLAddReconfTransChInformation2TfsSignallingMode; }
	void setQualityTarget(const QualityTarget& qualityTarget) { *static_cast<QualityTarget*>(items[3]) = qualityTarget; }
};

typedef SequenceOf<DLAddReconfTransChInformation2, CONSTRAINED, 1, maxTrCHpreconf> DLAddReconfTransChInfo2List;

class DLAddReconfTransChInformationr4TfsSignallingMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLAddReconfTransChInformationr4TfsSignallingModeChoices {
		explicitconfig = 0,
		sameAsULTrCH = 1,
	};
	static const Info theInfo;
	DLAddReconfTransChInformationr4TfsSignallingMode(): Choice(&theInfo) {}
};

class DLAddReconfTransChInformationr4 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	DLAddReconfTransChInformationr4(): Sequence(&theInfo) {}

	void setDlTransportChannelType(const DLTrCHType& dlTransportChannelType) { *static_cast<DLTrCHType*>(items[0]) = dlTransportChannelType; }
	void setDltransportChannelIdentity(const TransportChannelIdentity& dltransportChannelIdentity) { *static_cast<TransportChannelIdentity*>(items[1]) = dltransportChannelIdentity; }
	void setDLAddReconfTransChInformationr4TfsSignallingMode(const DLAddReconfTransChInformationr4TfsSignallingMode& dLAddReconfTransChInformationr4TfsSignallingMode) { *static_cast<DLAddReconfTransChInformationr4TfsSignallingMode*>(items[2]) = dLAddReconfTransChInformationr4TfsSignallingMode; }
	void setDchQualityTarget(const QualityTarget& dchQualityTarget) { *static_cast<QualityTarget*>(items[3]) = dchQualityTarget; }
};

typedef SequenceOf<DLAddReconfTransChInformationr4, CONSTRAINED, 1, maxTrCHpreconf> DLAddReconfTransChInfoListr4;

typedef Null DLTrCHTypeId1r5Hsdsch;

class DLTrCHTypeId1r5 : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum DLTrCHTypeId1r5Choices {
		dch = 0,
		dsch = 1,
		dLTrCHTypeId1r5Hsdsch = 2,
	};
	static const Info theInfo;
	DLTrCHTypeId1r5(): Choice(&theInfo) {}
};

class HSDSCHInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	HSDSCHInfo(): Sequence(&theInfo) {}

	void setHarqInfo(const HARQInfo& harqInfo) { *static_cast<HARQInfo*>(items[0]) = harqInfo; }
	void setAddOrReconfMACdFlow(const AddOrReconfMACdFlow& addOrReconfMACdFlow) { *static_cast<AddOrReconfMACdFlow*>(items[1]) = addOrReconfMACdFlow; }
};

class DLAddReconfTransChInformationr5TfsSignallingMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum DLAddReconfTransChInformationr5TfsSignallingModeChoices {
		explicitconfig = 0,
		sameAsULTrCH = 1,
		hsdsch = 2,
	};
	static const Info theInfo;
	DLAddReconfTransChInformationr5TfsSignallingMode(): Choice(&theInfo) {}
};

class DLAddReconfTransChInformationr5 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLAddReconfTransChInformationr5(): Sequence(&theInfo) {}

	void setDlTransportChannelType(const DLTrCHTypeId1r5& dlTransportChannelType) { *static_cast<DLTrCHTypeId1r5*>(items[0]) = dlTransportChannelType; }
	void setDLAddReconfTransChInformationr5TfsSignallingMode(const DLAddReconfTransChInformationr5TfsSignallingMode& dLAddReconfTransChInformationr5TfsSignallingMode) { *static_cast<DLAddReconfTransChInformationr5TfsSignallingMode*>(items[1]) = dLAddReconfTransChInformationr5TfsSignallingMode; }
	void setDchQualityTarget(const QualityTarget& dchQualityTarget) { *static_cast<QualityTarget*>(items[2]) = dchQualityTarget; }
};

typedef SequenceOf<DLAddReconfTransChInformationr5, CONSTRAINED, 1, maxTrCHpreconf> DLAddReconfTransChInfoListr5;

class HSDSCHInfor7DlMACHeaderType : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum HSDSCHInfor7DlMACHeaderTypeChoices {
		machs = 0,
		macehs = 1,
	};
	static const Info theInfo;
	HSDSCHInfor7DlMACHeaderType(): Choice(&theInfo) {}
};

class HSDSCHInfor7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	HSDSCHInfor7(): Sequence(&theInfo) {}

	void setHarqInfo(const HARQInfor7& harqInfo) { *static_cast<HARQInfor7*>(items[0]) = harqInfo; }
	void setHSDSCHInfor7DlMACHeaderType(const HSDSCHInfor7DlMACHeaderType& hSDSCHInfor7DlMACHeaderType) { *static_cast<HSDSCHInfor7DlMACHeaderType*>(items[1]) = hSDSCHInfor7DlMACHeaderType; }
};

class DLAddReconfTransChInformationr7TfsSignallingMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum DLAddReconfTransChInformationr7TfsSignallingModeChoices {
		explicitconfig = 0,
		sameAsULTrCH = 1,
		hsdsch = 2,
	};
	static const Info theInfo;
	DLAddReconfTransChInformationr7TfsSignallingMode(): Choice(&theInfo) {}
};

class DLAddReconfTransChInformationr7 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLAddReconfTransChInformationr7(): Sequence(&theInfo) {}

	void setDlTransportChannelType(const DLTrCHTypeId1r5& dlTransportChannelType) { *static_cast<DLTrCHTypeId1r5*>(items[0]) = dlTransportChannelType; }
	void setDLAddReconfTransChInformationr7TfsSignallingMode(const DLAddReconfTransChInformationr7TfsSignallingMode& dLAddReconfTransChInformationr7TfsSignallingMode) { *static_cast<DLAddReconfTransChInformationr7TfsSignallingMode*>(items[1]) = dLAddReconfTransChInformationr7TfsSignallingMode; }
	void setDchQualityTarget(const QualityTarget& dchQualityTarget) { *static_cast<QualityTarget*>(items[2]) = dchQualityTarget; }
};

typedef SequenceOf<DLAddReconfTransChInformationr7, CONSTRAINED, 1, maxTrCHpreconf> DLAddReconfTransChInfoListr7;

class HSDSCHInfor9DlMACHeaderType : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum HSDSCHInfor9DlMACHeaderTypeChoices {
		machs = 0,
		macehs = 1,
	};
	static const Info theInfo;
	HSDSCHInfor9DlMACHeaderType(): Choice(&theInfo) {}
};

class HSDSCHInfor9 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	HSDSCHInfor9(): Sequence(&theInfo) {}

	void setHarqInfo(const HARQInfor7& harqInfo) { *static_cast<HARQInfor7*>(items[0]) = harqInfo; }
	void setHSDSCHInfor9DlMACHeaderType(const HSDSCHInfor9DlMACHeaderType& hSDSCHInfor9DlMACHeaderType) { *static_cast<HSDSCHInfor9DlMACHeaderType*>(items[1]) = hSDSCHInfor9DlMACHeaderType; }
};

class DLAddReconfTransChInformationr9TfsSignallingMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum DLAddReconfTransChInformationr9TfsSignallingModeChoices {
		explicitconfig = 0,
		sameAsULTrCH = 1,
		hsdsch = 2,
	};
	static const Info theInfo;
	DLAddReconfTransChInformationr9TfsSignallingMode(): Choice(&theInfo) {}
};

class DLAddReconfTransChInformationr9 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLAddReconfTransChInformationr9(): Sequence(&theInfo) {}

	void setDlTransportChannelType(const DLTrCHTypeId1r5& dlTransportChannelType) { *static_cast<DLTrCHTypeId1r5*>(items[0]) = dlTransportChannelType; }
	void setDLAddReconfTransChInformationr9TfsSignallingMode(const DLAddReconfTransChInformationr9TfsSignallingMode& dLAddReconfTransChInformationr9TfsSignallingMode) { *static_cast<DLAddReconfTransChInformationr9TfsSignallingMode*>(items[1]) = dLAddReconfTransChInformationr9TfsSignallingMode; }
	void setDchQualityTarget(const QualityTarget& dchQualityTarget) { *static_cast<QualityTarget*>(items[2]) = dchQualityTarget; }
};

typedef SequenceOf<DLAddReconfTransChInformationr9, CONSTRAINED, 1, maxTrCHpreconf> DLAddReconfTransChInfoListr9;

class DLCommonTransChInfor4ModeSpecificInfoFddDlParametersDlDCHTFCS : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLCommonTransChInfor4ModeSpecificInfoFddDlParametersDlDCHTFCS(): Sequence(&theInfo) {}

	void setTfcs(const TFCS& tfcs) { *static_cast<TFCS*>(items[0]) = tfcs; }
};

typedef Null DLCommonTransChInfor4ModeSpecificInfoFddDlParametersSameAsUL;

class DLCommonTransChInfor4ModeSpecificInfoFddDlParameters : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLCommonTransChInfor4ModeSpecificInfoFddDlParametersChoices {
		dLCommonTransChInfor4ModeSpecificInfoFddDlParametersDlDCHTFCS = 0,
		dLCommonTransChInfor4ModeSpecificInfoFddDlParametersSameAsUL = 1,
	};
	static const Info theInfo;
	DLCommonTransChInfor4ModeSpecificInfoFddDlParameters(): Choice(&theInfo) {}
};

class DLCommonTransChInfor4ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLCommonTransChInfor4ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setDLCommonTransChInfor4ModeSpecificInfoFddDlParameters(const DLCommonTransChInfor4ModeSpecificInfoFddDlParameters& dLCommonTransChInfor4ModeSpecificInfoFddDlParameters) { *static_cast<DLCommonTransChInfor4ModeSpecificInfoFddDlParameters*>(items[0]) = dLCommonTransChInfor4ModeSpecificInfoFddDlParameters; }
};

class DLCommonTransChInfor4ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLCommonTransChInfor4ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setIndividualDLCCTrCHInfoList(const IndividualDLCCTrCHInfoList& individualDLCCTrCHInfoList) { *static_cast<IndividualDLCCTrCHInfoList*>(items[0]) = individualDLCCTrCHInfoList; }
};

class DLCommonTransChInfor4ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLCommonTransChInfor4ModeSpecificInfoChoices {
		dLCommonTransChInfor4ModeSpecificInfoFdd = 0,
		dLCommonTransChInfor4ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	DLCommonTransChInfor4ModeSpecificInfo(): Choice(&theInfo) {}
};

class DLCommonTransChInfor4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLCommonTransChInfor4(): Sequence(&theInfo) {}

	void setSccpchTFCS(const TFCS& sccpchTFCS) { *static_cast<TFCS*>(items[0]) = sccpchTFCS; }
	void setDLCommonTransChInfor4ModeSpecificInfo(const DLCommonTransChInfor4ModeSpecificInfo& dLCommonTransChInfor4ModeSpecificInfo) { *static_cast<DLCommonTransChInfor4ModeSpecificInfo*>(items[1]) = dLCommonTransChInfor4ModeSpecificInfo; }
};

class DLTransportChannelIdentity : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLTransportChannelIdentity(): Sequence(&theInfo) {}

	void setDlTransportChannelType(const DLTrCHType& dlTransportChannelType) { *static_cast<DLTrCHType*>(items[0]) = dlTransportChannelType; }
	void setDlTransportChannelIdentity(const TransportChannelIdentity& dlTransportChannelIdentity) { *static_cast<TransportChannelIdentity*>(items[1]) = dlTransportChannelIdentity; }
};

typedef SequenceOf<DLTransportChannelIdentity, CONSTRAINED, 1, maxTrCH> DLDeletedTransChInfoList;

class DLTrCHTypeId2r5 : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum DLTrCHTypeId2r5Choices {
		dch = 0,
		dsch = 1,
		hsdsch = 2,
	};
	static const Info theInfo;
	DLTrCHTypeId2r5(): Choice(&theInfo) {}
};

class DLTransportChannelIdentityr5 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLTransportChannelIdentityr5(): Sequence(&theInfo) {}

	void setDlTransportChannelType(const DLTrCHTypeId2r5& dlTransportChannelType) { *static_cast<DLTrCHTypeId2r5*>(items[0]) = dlTransportChannelType; }
};

typedef SequenceOf<DLTransportChannelIdentityr5, CONSTRAINED, 1, maxTrCH> DLDeletedTransChInfoListr5;

class DLTrCHTypeId2r7Hsdsch : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLTrCHTypeId2r7HsdschChoices {
		machs = 0,
		macehs = 1,
	};
	static const Info theInfo;
	DLTrCHTypeId2r7Hsdsch(): Choice(&theInfo) {}
};

class DLTrCHTypeId2r7 : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum DLTrCHTypeId2r7Choices {
		dch = 0,
		dsch = 1,
		dLTrCHTypeId2r7Hsdsch = 2,
	};
	static const Info theInfo;
	DLTrCHTypeId2r7(): Choice(&theInfo) {}
};

class DLTransportChannelIdentityr7 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLTransportChannelIdentityr7(): Sequence(&theInfo) {}

	void setDlTransportChannelType(const DLTrCHTypeId2r7& dlTransportChannelType) { *static_cast<DLTrCHTypeId2r7*>(items[0]) = dlTransportChannelType; }
};

typedef SequenceOf<DLTransportChannelIdentityr7, CONSTRAINED, 1, maxTrCH> DLDeletedTransChInfoListr7;

typedef Integer<CONSTRAINED, 1, maxDRACclasses> DRACClassIdentity;

typedef Integer<CONSTRAINED, 1, 256> TransmissionTimeValidity;

typedef Integer<CONSTRAINED, 1, 256> TimeDurationBeforeRetry;

class DRACStaticInformation : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DRACStaticInformation(): Sequence(&theInfo) {}

	void setTransmissionTimeValidity(const TransmissionTimeValidity& transmissionTimeValidity) { *static_cast<TransmissionTimeValidity*>(items[0]) = transmissionTimeValidity; }
	void setTimeDurationBeforeRetry(const TimeDurationBeforeRetry& timeDurationBeforeRetry) { *static_cast<TimeDurationBeforeRetry*>(items[1]) = timeDurationBeforeRetry; }
	void setDracClassIdentity(const DRACClassIdentity& dracClassIdentity) { *static_cast<DRACClassIdentity*>(items[2]) = dracClassIdentity; }
};

typedef SequenceOf<DRACStaticInformation, CONSTRAINED, 1, maxTrCH> DRACStaticInformationList;

typedef Integer<CONSTRAINED, 1, 19982> EDCHAddReconfMACdFlowTransmissionGrantTypeNonScheduledTransGrantInfoMaxMACePDUContents;

typedef BitString<CONSTRAINED, 8, 8> EDCHAddReconfMACdFlowTransmissionGrantTypeNonScheduledTransGrantInfoMs2NonSchedTransmGrantHARQAlloc;

class EDCHAddReconfMACdFlowTransmissionGrantTypeNonScheduledTransGrantInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EDCHAddReconfMACdFlowTransmissionGrantTypeNonScheduledTransGrantInfo(): Sequence(&theInfo) {}

	void setEDCHAddReconfMACdFlowTransmissionGrantTypeNonScheduledTransGrantInfoMaxMACePDUContents(const EDCHAddReconfMACdFlowTransmissionGrantTypeNonScheduledTransGrantInfoMaxMACePDUContents& eDCHAddReconfMACdFlowTransmissionGrantTypeNonScheduledTransGrantInfoMaxMACePDUContents) { *static_cast<EDCHAddReconfMACdFlowTransmissionGrantTypeNonScheduledTransGrantInfoMaxMACePDUContents*>(items[0]) = eDCHAddReconfMACdFlowTransmissionGrantTypeNonScheduledTransGrantInfoMaxMACePDUContents; }
	void setEDCHAddReconfMACdFlowTransmissionGrantTypeNonScheduledTransGrantInfoMs2NonSchedTransmGrantHARQAlloc(const EDCHAddReconfMACdFlowTransmissionGrantTypeNonScheduledTransGrantInfoMs2NonSchedTransmGrantHARQAlloc& eDCHAddReconfMACdFlowTransmissionGrantTypeNonScheduledTransGrantInfoMs2NonSchedTransmGrantHARQAlloc) { *static_cast<EDCHAddReconfMACdFlowTransmissionGrantTypeNonScheduledTransGrantInfoMs2NonSchedTransmGrantHARQAlloc*>(items[1]) = eDCHAddReconfMACdFlowTransmissionGrantTypeNonScheduledTransGrantInfoMs2NonSchedTransmGrantHARQAlloc; }
};

typedef Null EDCHAddReconfMACdFlowTransmissionGrantTypeScheduledTransmissionGrantInfo;

class EDCHAddReconfMACdFlowTransmissionGrantType : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum EDCHAddReconfMACdFlowTransmissionGrantTypeChoices {
		eDCHAddReconfMACdFlowTransmissionGrantTypeNonScheduledTransGrantInfo = 0,
		eDCHAddReconfMACdFlowTransmissionGrantTypeScheduledTransmissionGrantInfo = 1,
	};
	static const Info theInfo;
	EDCHAddReconfMACdFlowTransmissionGrantType(): Choice(&theInfo) {}
};

class EDCHAddReconfMACdFlow : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	EDCHAddReconfMACdFlow(): Sequence(&theInfo) {}

	void setMacdFlowIdentity(const EDCHMACdFlowIdentity& macdFlowIdentity) { *static_cast<EDCHMACdFlowIdentity*>(items[0]) = macdFlowIdentity; }
	void setMacdFlowPowerOffset(const EDCHMACdFlowPowerOffset& macdFlowPowerOffset) { *static_cast<EDCHMACdFlowPowerOffset*>(items[1]) = macdFlowPowerOffset; }
	void setMacdFlowMaxRetrans(const EDCHMACdFlowMaxRetrans& macdFlowMaxRetrans) { *static_cast<EDCHMACdFlowMaxRetrans*>(items[2]) = macdFlowMaxRetrans; }
	void setMacdFlowMultiplexingList(const EDCHMACdFlowMultiplexingList& macdFlowMultiplexingList) { *static_cast<EDCHMACdFlowMultiplexingList*>(items[3]) = macdFlowMultiplexingList; }
	void setEDCHAddReconfMACdFlowTransmissionGrantType(const EDCHAddReconfMACdFlowTransmissionGrantType& eDCHAddReconfMACdFlowTransmissionGrantType) { *static_cast<EDCHAddReconfMACdFlowTransmissionGrantType*>(items[4]) = eDCHAddReconfMACdFlowTransmissionGrantType; }
};

typedef Integer<CONSTRAINED, 1, 19982> EDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfoFddMaxMACePDUContents;

typedef BitString<CONSTRAINED, 8, 8> EDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfoFddMs2NonSchedTransmGrantHARQAlloc;

class EDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setEDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfoFddMaxMACePDUContents(const EDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfoFddMaxMACePDUContents& eDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfoFddMaxMACePDUContents) { *static_cast<EDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfoFddMaxMACePDUContents*>(items[0]) = eDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfoFddMaxMACePDUContents; }
	void setEDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfoFddMs2NonSchedTransmGrantHARQAlloc(const EDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfoFddMs2NonSchedTransmGrantHARQAlloc& eDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfoFddMs2NonSchedTransmGrantHARQAlloc) { *static_cast<EDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfoFddMs2NonSchedTransmGrantHARQAlloc*>(items[1]) = eDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfoFddMs2NonSchedTransmGrantHARQAlloc; }
};

typedef Null EDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfoTdd;

class EDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum EDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfoChoices {
		eDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfoFdd = 0,
		eDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	EDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfo(): Choice(&theInfo) {}
};

class EDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	EDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfo(): Sequence(&theInfo) {}

	void setEDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfo(const EDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfo& eDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfo) { *static_cast<EDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfo*>(items[0]) = eDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfoModeSpecificInfo; }
};

typedef Null EDCHAddReconfMACdFlowr7TransmissionGrantTypeScheduledTransmissionGrantInfo;

class EDCHAddReconfMACdFlowr7TransmissionGrantType : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum EDCHAddReconfMACdFlowr7TransmissionGrantTypeChoices {
		eDCHAddReconfMACdFlowr7TransmissionGrantTypeNonScheduledTransGrantInfo = 0,
		eDCHAddReconfMACdFlowr7TransmissionGrantTypeScheduledTransmissionGrantInfo = 1,
	};
	static const Info theInfo;
	EDCHAddReconfMACdFlowr7TransmissionGrantType(): Choice(&theInfo) {}
};

class EDCHAddReconfMACdFlowr7 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	EDCHAddReconfMACdFlowr7(): Sequence(&theInfo) {}

	void setMacdFlowIdentity(const EDCHMACdFlowIdentity& macdFlowIdentity) { *static_cast<EDCHMACdFlowIdentity*>(items[0]) = macdFlowIdentity; }
	void setMacdFlowPowerOffset(const EDCHMACdFlowPowerOffset& macdFlowPowerOffset) { *static_cast<EDCHMACdFlowPowerOffset*>(items[1]) = macdFlowPowerOffset; }
	void setMacdFlowMaxRetrans(const EDCHMACdFlowMaxRetrans& macdFlowMaxRetrans) { *static_cast<EDCHMACdFlowMaxRetrans*>(items[2]) = macdFlowMaxRetrans; }
	void setMacdFlowRetransTimer(const EDCHMACdFlowRetransTimer& macdFlowRetransTimer) { *static_cast<EDCHMACdFlowRetransTimer*>(items[3]) = macdFlowRetransTimer; }
	void setMacdFlowMultiplexingList(const EDCHMACdFlowMultiplexingList& macdFlowMultiplexingList) { *static_cast<EDCHMACdFlowMultiplexingList*>(items[4]) = macdFlowMultiplexingList; }
	void setEDCHAddReconfMACdFlowr7TransmissionGrantType(const EDCHAddReconfMACdFlowr7TransmissionGrantType& eDCHAddReconfMACdFlowr7TransmissionGrantType) { *static_cast<EDCHAddReconfMACdFlowr7TransmissionGrantType*>(items[5]) = eDCHAddReconfMACdFlowr7TransmissionGrantType; }
};

typedef SequenceOf<EDCHAddReconfMACdFlow, CONSTRAINED, 1, maxE_DCHMACdFlow> EDCHAddReconfMACdFlowList;

typedef SequenceOf<EDCHAddReconfMACdFlowr7, CONSTRAINED, 1, maxE_DCHMACdFlow> EDCHAddReconfMACdFlowListr7;

enum EDCHTTIValues {
	tti2_EDCHTTI = 0,
	tti10_EDCHTTI = 1,
};
typedef Enumerated<CONSTRAINED, 1> EDCHTTI;

typedef Integer<CONSTRAINED, 0, 15> GainFactor;

class SignalledGainFactorsModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SignalledGainFactorsModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setGainFactorBetaC(const GainFactor& gainFactorBetaC) { *static_cast<GainFactor*>(items[0]) = gainFactorBetaC; }
};

typedef Null SignalledGainFactorsModeSpecificInfoTdd;

class SignalledGainFactorsModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum SignalledGainFactorsModeSpecificInfoChoices {
		signalledGainFactorsModeSpecificInfoFdd = 0,
		signalledGainFactorsModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	SignalledGainFactorsModeSpecificInfo(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 3> ReferenceTFCID;

class SignalledGainFactors : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SignalledGainFactors(): Sequence(&theInfo) {}

	void setSignalledGainFactorsModeSpecificInfo(const SignalledGainFactorsModeSpecificInfo& signalledGainFactorsModeSpecificInfo) { *static_cast<SignalledGainFactorsModeSpecificInfo*>(items[0]) = signalledGainFactorsModeSpecificInfo; }
	void setGainFactorBetaD(const GainFactor& gainFactorBetaD) { *static_cast<GainFactor*>(items[1]) = gainFactorBetaD; }
	void setReferenceTFCID(const ReferenceTFCID& referenceTFCID) { *static_cast<ReferenceTFCID*>(items[2]) = referenceTFCID; }
};

class GainFactorInformation : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum GainFactorInformationChoices {
		signalledGainFactors = 0,
		computedGainFactors = 1,
	};
	static const Info theInfo;
	GainFactorInformation(): Choice(&theInfo) {}
};

class PowerOffsetInfoShortModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PowerOffsetInfoShortModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setGainFactorBetaC(const GainFactor& gainFactorBetaC) { *static_cast<GainFactor*>(items[0]) = gainFactorBetaC; }
};

typedef Null PowerOffsetInfoShortModeSpecificInfoTdd;

class PowerOffsetInfoShortModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PowerOffsetInfoShortModeSpecificInfoChoices {
		powerOffsetInfoShortModeSpecificInfoFdd = 0,
		powerOffsetInfoShortModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	PowerOffsetInfoShortModeSpecificInfo(): Choice(&theInfo) {}
};

class PowerOffsetInfoShort : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PowerOffsetInfoShort(): Sequence(&theInfo) {}

	void setReferenceTFC(const TFCValue& referenceTFC) { *static_cast<TFCValue*>(items[0]) = referenceTFC; }
	void setPowerOffsetInfoShortModeSpecificInfo(const PowerOffsetInfoShortModeSpecificInfo& powerOffsetInfoShortModeSpecificInfo) { *static_cast<PowerOffsetInfoShortModeSpecificInfo*>(items[1]) = powerOffsetInfoShortModeSpecificInfo; }
	void setGainFactorBetaD(const GainFactor& gainFactorBetaD) { *static_cast<GainFactor*>(items[2]) = gainFactorBetaD; }
};

typedef Integer<CONSTRAINED, -5, 10> PowerOffsetPpm;

class PowerOffsetInformation : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PowerOffsetInformation(): Sequence(&theInfo) {}

	void setGainFactorInformation(const GainFactorInformation& gainFactorInformation) { *static_cast<GainFactorInformation*>(items[0]) = gainFactorInformation; }
	void setPowerOffsetPpm(const PowerOffsetPpm& powerOffsetPpm) { *static_cast<PowerOffsetPpm*>(items[1]) = powerOffsetPpm; }
};

class TFCSubsetList : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	TFCSubsetList(): Sequence(&theInfo) {}

};

enum TransmissionTimeIntervalValues {
	tti10_TransmissionTimeInterval = 0,
	tti20_TransmissionTimeInterval = 1,
	tti40_TransmissionTimeInterval = 2,
	tti80_TransmissionTimeInterval = 3,
};
typedef Enumerated<CONSTRAINED, 3> TransmissionTimeInterval;

class TransportFormatSetLCR : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum TransportFormatSetLCRChoices {
		dedicatedTransChTFS = 0,
		commonTransChTFSLCR = 1,
	};
	static const Info theInfo;
	TransportFormatSetLCR(): Choice(&theInfo) {}
};

class ULAddReconfTransChInformationr6Dchusch : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULAddReconfTransChInformationr6Dchusch(): Sequence(&theInfo) {}

	void setUlTransportChannelType(const ULTrCHType& ulTransportChannelType) { *static_cast<ULTrCHType*>(items[0]) = ulTransportChannelType; }
	void setTransportChannelIdentity(const TransportChannelIdentity& transportChannelIdentity) { *static_cast<TransportChannelIdentity*>(items[1]) = transportChannelIdentity; }
	void setTransportFormatSet(const TransportFormatSet& transportFormatSet) { *static_cast<TransportFormatSet*>(items[2]) = transportFormatSet; }
};

enum ULAddReconfTransChInformationr6Edchharq_InfoValues {
	rv0_ULAddReconfTransChInformationr6Edchharq_Info = 0,
	rvtable_ULAddReconfTransChInformationr6Edchharq_Info = 1,
};
typedef Enumerated<CONSTRAINED, 1> ULAddReconfTransChInformationr6Edchharq_Info;

class ULAddReconfTransChInformationr6Edch : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULAddReconfTransChInformationr6Edch(): Sequence(&theInfo) {}

	void setTti(const EDCHTTI& tti) { *static_cast<EDCHTTI*>(items[0]) = tti; }
	void setULAddReconfTransChInformationr6Edchharq_Info(const ULAddReconfTransChInformationr6Edchharq_Info& uLAddReconfTransChInformationr6Edchharq_Info) { *static_cast<ULAddReconfTransChInformationr6Edchharq_Info*>(items[1]) = uLAddReconfTransChInformationr6Edchharq_Info; }
	void setAddReconfMACdFlowList(const EDCHAddReconfMACdFlowList& addReconfMACdFlowList) { *static_cast<EDCHAddReconfMACdFlowList*>(items[2]) = addReconfMACdFlowList; }
};

class ULAddReconfTransChInformationr6 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULAddReconfTransChInformationr6Choices {
		uLAddReconfTransChInformationr6Dchusch = 0,
		uLAddReconfTransChInformationr6Edch = 1,
	};
	static const Info theInfo;
	ULAddReconfTransChInformationr6(): Choice(&theInfo) {}
};

typedef SequenceOf<ULAddReconfTransChInformationr6, CONSTRAINED, 1, maxTrCH> ULAddReconfTransChInfoListr6;

class ULAddReconfTransChInformationr7Dchusch : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULAddReconfTransChInformationr7Dchusch(): Sequence(&theInfo) {}

	void setUlTransportChannelType(const ULTrCHType& ulTransportChannelType) { *static_cast<ULTrCHType*>(items[0]) = ulTransportChannelType; }
	void setTransportChannelIdentity(const TransportChannelIdentity& transportChannelIdentity) { *static_cast<TransportChannelIdentity*>(items[1]) = transportChannelIdentity; }
	void setTransportFormatSet(const TransportFormatSet& transportFormatSet) { *static_cast<TransportFormatSet*>(items[2]) = transportFormatSet; }
};

class ULAddReconfTransChInformationr7EdchModeSpecificFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULAddReconfTransChInformationr7EdchModeSpecificFdd(): Sequence(&theInfo) {}

	void setTti(const EDCHTTI& tti) { *static_cast<EDCHTTI*>(items[0]) = tti; }
};

typedef Null ULAddReconfTransChInformationr7EdchModeSpecificTdd;

class ULAddReconfTransChInformationr7EdchModeSpecific : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULAddReconfTransChInformationr7EdchModeSpecificChoices {
		uLAddReconfTransChInformationr7EdchModeSpecificFdd = 0,
		uLAddReconfTransChInformationr7EdchModeSpecificTdd = 1,
	};
	static const Info theInfo;
	ULAddReconfTransChInformationr7EdchModeSpecific(): Choice(&theInfo) {}
};

enum ULAddReconfTransChInformationr7Edchharq_InfoValues {
	rv0_ULAddReconfTransChInformationr7Edchharq_Info = 0,
	rvtable_ULAddReconfTransChInformationr7Edchharq_Info = 1,
};
typedef Enumerated<CONSTRAINED, 1> ULAddReconfTransChInformationr7Edchharq_Info;

class ULAddReconfTransChInformationr7Edch : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULAddReconfTransChInformationr7Edch(): Sequence(&theInfo) {}

	void setULAddReconfTransChInformationr7EdchModeSpecific(const ULAddReconfTransChInformationr7EdchModeSpecific& uLAddReconfTransChInformationr7EdchModeSpecific) { *static_cast<ULAddReconfTransChInformationr7EdchModeSpecific*>(items[0]) = uLAddReconfTransChInformationr7EdchModeSpecific; }
	void setULAddReconfTransChInformationr7Edchharq_Info(const ULAddReconfTransChInformationr7Edchharq_Info& uLAddReconfTransChInformationr7Edchharq_Info) { *static_cast<ULAddReconfTransChInformationr7Edchharq_Info*>(items[1]) = uLAddReconfTransChInformationr7Edchharq_Info; }
	void setAddReconfMACdFlowList(const EDCHAddReconfMACdFlowListr7& addReconfMACdFlowList) { *static_cast<EDCHAddReconfMACdFlowListr7*>(items[2]) = addReconfMACdFlowList; }
};

class ULAddReconfTransChInformationr7 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULAddReconfTransChInformationr7Choices {
		uLAddReconfTransChInformationr7Dchusch = 0,
		uLAddReconfTransChInformationr7Edch = 1,
	};
	static const Info theInfo;
	ULAddReconfTransChInformationr7(): Choice(&theInfo) {}
};

typedef SequenceOf<ULAddReconfTransChInformationr7, CONSTRAINED, 1, maxTrCH> ULAddReconfTransChInfoListr7;

class ULAddReconfTransChInformationr8Dchusch : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULAddReconfTransChInformationr8Dchusch(): Sequence(&theInfo) {}

	void setUlTransportChannelType(const ULTrCHType& ulTransportChannelType) { *static_cast<ULTrCHType*>(items[0]) = ulTransportChannelType; }
	void setTransportChannelIdentity(const TransportChannelIdentity& transportChannelIdentity) { *static_cast<TransportChannelIdentity*>(items[1]) = transportChannelIdentity; }
	void setTransportFormatSet(const TransportFormatSet& transportFormatSet) { *static_cast<TransportFormatSet*>(items[2]) = transportFormatSet; }
};

enum ULAddReconfTransChInformationr8Edchul_MAC_HeaderTypeValues {
	mac_iis_ULAddReconfTransChInformationr8Edchul_MAC_HeaderType = 0,
};
typedef Enumerated<CONSTRAINED, 0> ULAddReconfTransChInformationr8Edchul_MAC_HeaderType;

class ULAddReconfTransChInformationr8EdchModeSpecificFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULAddReconfTransChInformationr8EdchModeSpecificFdd(): Sequence(&theInfo) {}

	void setTti(const EDCHTTI& tti) { *static_cast<EDCHTTI*>(items[0]) = tti; }
};

typedef Null ULAddReconfTransChInformationr8EdchModeSpecificTdd;

class ULAddReconfTransChInformationr8EdchModeSpecific : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULAddReconfTransChInformationr8EdchModeSpecificChoices {
		uLAddReconfTransChInformationr8EdchModeSpecificFdd = 0,
		uLAddReconfTransChInformationr8EdchModeSpecificTdd = 1,
	};
	static const Info theInfo;
	ULAddReconfTransChInformationr8EdchModeSpecific(): Choice(&theInfo) {}
};

enum ULAddReconfTransChInformationr8Edchharq_InfoValues {
	rv0_ULAddReconfTransChInformationr8Edchharq_Info = 0,
	rvtable_ULAddReconfTransChInformationr8Edchharq_Info = 1,
};
typedef Enumerated<CONSTRAINED, 1> ULAddReconfTransChInformationr8Edchharq_Info;

class ULAddReconfTransChInformationr8Edch : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	ULAddReconfTransChInformationr8Edch(): Sequence(&theInfo) {}

	void setULAddReconfTransChInformationr8Edchul_MAC_HeaderType(const ULAddReconfTransChInformationr8Edchul_MAC_HeaderType& uLAddReconfTransChInformationr8Edchul_MAC_HeaderType) { *static_cast<ULAddReconfTransChInformationr8Edchul_MAC_HeaderType*>(items[0]) = uLAddReconfTransChInformationr8Edchul_MAC_HeaderType; }
	void setULAddReconfTransChInformationr8EdchModeSpecific(const ULAddReconfTransChInformationr8EdchModeSpecific& uLAddReconfTransChInformationr8EdchModeSpecific) { *static_cast<ULAddReconfTransChInformationr8EdchModeSpecific*>(items[1]) = uLAddReconfTransChInformationr8EdchModeSpecific; }
	void setULAddReconfTransChInformationr8Edchharq_Info(const ULAddReconfTransChInformationr8Edchharq_Info& uLAddReconfTransChInformationr8Edchharq_Info) { *static_cast<ULAddReconfTransChInformationr8Edchharq_Info*>(items[2]) = uLAddReconfTransChInformationr8Edchharq_Info; }
	void setAddReconfMACdFlowList(const EDCHAddReconfMACdFlowListr7& addReconfMACdFlowList) { *static_cast<EDCHAddReconfMACdFlowListr7*>(items[3]) = addReconfMACdFlowList; }
};

class ULAddReconfTransChInformationr8 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULAddReconfTransChInformationr8Choices {
		uLAddReconfTransChInformationr8Dchusch = 0,
		uLAddReconfTransChInformationr8Edch = 1,
	};
	static const Info theInfo;
	ULAddReconfTransChInformationr8(): Choice(&theInfo) {}
};

typedef SequenceOf<ULAddReconfTransChInformationr8, CONSTRAINED, 1, maxTrCH> ULAddReconfTransChInfoListr8;

class ULCommonTransChInfor4ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULCommonTransChInfor4ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setUlTFCS(const TFCS& ulTFCS) { *static_cast<TFCS*>(items[0]) = ulTFCS; }
};

class ULCommonTransChInfor4ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULCommonTransChInfor4ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setIndividualULCCTrCHInfoList(const IndividualULCCTrCHInfoList& individualULCCTrCHInfoList) { *static_cast<IndividualULCCTrCHInfoList*>(items[0]) = individualULCCTrCHInfoList; }
};

class ULCommonTransChInfor4ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULCommonTransChInfor4ModeSpecificInfoChoices {
		uLCommonTransChInfor4ModeSpecificInfoFdd = 0,
		uLCommonTransChInfor4ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	ULCommonTransChInfor4ModeSpecificInfo(): Choice(&theInfo) {}
};

class ULCommonTransChInfor4 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	ULCommonTransChInfor4(): Sequence(&theInfo) {}

	void setTfcSubset(const TFCSubset& tfcSubset) { *static_cast<TFCSubset*>(items[0]) = tfcSubset; }
	void setPrachTFCS(const TFCS& prachTFCS) { *static_cast<TFCS*>(items[1]) = prachTFCS; }
	void setULCommonTransChInfor4ModeSpecificInfo(const ULCommonTransChInfor4ModeSpecificInfo& uLCommonTransChInfor4ModeSpecificInfo) { *static_cast<ULCommonTransChInfor4ModeSpecificInfo*>(items[2]) = uLCommonTransChInfor4ModeSpecificInfo; }
	void setTfcSubsetList(const TFCSubsetList& tfcSubsetList) { *static_cast<TFCSubsetList*>(items[3]) = tfcSubsetList; }
};

typedef SequenceOf<ULTransportChannelIdentity, CONSTRAINED, 1, maxTrCH> ULDeletedTransChInfoList;

class ULTransportChannelIdentityr6Dchusch : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULTransportChannelIdentityr6Dchusch(): Sequence(&theInfo) {}

	void setUlTransportChannelType(const ULTrCHType& ulTransportChannelType) { *static_cast<ULTrCHType*>(items[0]) = ulTransportChannelType; }
	void setUlTransportChannelIdentity(const TransportChannelIdentity& ulTransportChannelIdentity) { *static_cast<TransportChannelIdentity*>(items[1]) = ulTransportChannelIdentity; }
};

class ULTransportChannelIdentityr6 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULTransportChannelIdentityr6Choices {
		uLTransportChannelIdentityr6Dchusch = 0,
		edch = 1,
	};
	static const Info theInfo;
	ULTransportChannelIdentityr6(): Choice(&theInfo) {}
};

typedef SequenceOf<ULTransportChannelIdentityr6, CONSTRAINED, 1, maxTrCH> ULDeletedTransChInfoListr6;

class USCHTransportChannelsInfo : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	USCHTransportChannelsInfo(): Sequence(&theInfo) {}

};

typedef Integer<CONSTRAINED, 1, 4> ACKNACKrepetitionFactor;

typedef Integer<CONSTRAINED, 0, 7> ACToASCMapping;

typedef SequenceOf<ACToASCMapping, CONSTRAINED, maxASCmap, maxASCmap> ACToASCMappingTable;

typedef Integer<CONSTRAINED, 0, 15> AccessServiceClassFDDAvailableSignatureStartIndex;

typedef Integer<CONSTRAINED, 0, 15> AccessServiceClassFDDAvailableSignatureEndIndex;

typedef BitString<CONSTRAINED, 4, 4> AccessServiceClassFDDAssignedSubChannelNumber;

class AccessServiceClassFDD : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	AccessServiceClassFDD(): Sequence(&theInfo) {}

	void setAccessServiceClassFDDAvailableSignatureStartIndex(const AccessServiceClassFDDAvailableSignatureStartIndex& accessServiceClassFDDAvailableSignatureStartIndex) { *static_cast<AccessServiceClassFDDAvailableSignatureStartIndex*>(items[0]) = accessServiceClassFDDAvailableSignatureStartIndex; }
	void setAccessServiceClassFDDAvailableSignatureEndIndex(const AccessServiceClassFDDAvailableSignatureEndIndex& accessServiceClassFDDAvailableSignatureEndIndex) { *static_cast<AccessServiceClassFDDAvailableSignatureEndIndex*>(items[1]) = accessServiceClassFDDAvailableSignatureEndIndex; }
	void setAccessServiceClassFDDAssignedSubChannelNumber(const AccessServiceClassFDDAssignedSubChannelNumber& accessServiceClassFDDAssignedSubChannelNumber) { *static_cast<AccessServiceClassFDDAssignedSubChannelNumber*>(items[2]) = accessServiceClassFDDAssignedSubChannelNumber; }
};

typedef BitString<CONSTRAINED, 8, 8> AccessServiceClassTDDChannelisationCodeIndices;

typedef Null AccessServiceClassTDDSubchannelSizeSize1;

enum AccessServiceClassTDDSubchannelSizeSize2subchannelsValues {
	subch0_AccessServiceClassTDDSubchannelSizeSize2subchannels = 0,
	subch1_AccessServiceClassTDDSubchannelSizeSize2subchannels = 1,
};
typedef Enumerated<CONSTRAINED, 1> AccessServiceClassTDDSubchannelSizeSize2subchannels;

class AccessServiceClassTDDSubchannelSizeSize2 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	AccessServiceClassTDDSubchannelSizeSize2(): Sequence(&theInfo) {}

	void setAccessServiceClassTDDSubchannelSizeSize2subchannels(const AccessServiceClassTDDSubchannelSizeSize2subchannels& accessServiceClassTDDSubchannelSizeSize2subchannels) { *static_cast<AccessServiceClassTDDSubchannelSizeSize2subchannels*>(items[0]) = accessServiceClassTDDSubchannelSizeSize2subchannels; }
};

typedef BitString<CONSTRAINED, 4, 4> AccessServiceClassTDDSubchannelSizeSize4Subchannels;

class AccessServiceClassTDDSubchannelSizeSize4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	AccessServiceClassTDDSubchannelSizeSize4(): Sequence(&theInfo) {}

	void setAccessServiceClassTDDSubchannelSizeSize4Subchannels(const AccessServiceClassTDDSubchannelSizeSize4Subchannels& accessServiceClassTDDSubchannelSizeSize4Subchannels) { *static_cast<AccessServiceClassTDDSubchannelSizeSize4Subchannels*>(items[0]) = accessServiceClassTDDSubchannelSizeSize4Subchannels; }
};

typedef BitString<CONSTRAINED, 8, 8> AccessServiceClassTDDSubchannelSizeSize8Subchannels;

class AccessServiceClassTDDSubchannelSizeSize8 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	AccessServiceClassTDDSubchannelSizeSize8(): Sequence(&theInfo) {}

	void setAccessServiceClassTDDSubchannelSizeSize8Subchannels(const AccessServiceClassTDDSubchannelSizeSize8Subchannels& accessServiceClassTDDSubchannelSizeSize8Subchannels) { *static_cast<AccessServiceClassTDDSubchannelSizeSize8Subchannels*>(items[0]) = accessServiceClassTDDSubchannelSizeSize8Subchannels; }
};

class AccessServiceClassTDDSubchannelSize : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum AccessServiceClassTDDSubchannelSizeChoices {
		accessServiceClassTDDSubchannelSizeSize1 = 0,
		accessServiceClassTDDSubchannelSizeSize2 = 1,
		accessServiceClassTDDSubchannelSizeSize4 = 2,
		accessServiceClassTDDSubchannelSizeSize8 = 3,
	};
	static const Info theInfo;
	AccessServiceClassTDDSubchannelSize(): Choice(&theInfo) {}
};

class AccessServiceClassTDD : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	AccessServiceClassTDD(): Sequence(&theInfo) {}

	void setAccessServiceClassTDDChannelisationCodeIndices(const AccessServiceClassTDDChannelisationCodeIndices& accessServiceClassTDDChannelisationCodeIndices) { *static_cast<AccessServiceClassTDDChannelisationCodeIndices*>(items[0]) = accessServiceClassTDDChannelisationCodeIndices; }
	void setAccessServiceClassTDDSubchannelSize(const AccessServiceClassTDDSubchannelSize& accessServiceClassTDDSubchannelSize) { *static_cast<AccessServiceClassTDDSubchannelSize*>(items[1]) = accessServiceClassTDDSubchannelSize; }
};

typedef BitString<CONSTRAINED, 16, 16> AccessServiceClassTDDr7ChannelisationCodeIndices;

typedef Null AccessServiceClassTDDr7SubchannelSizeSize1;

enum AccessServiceClassTDDr7SubchannelSizeSize2subchannelsValues {
	subch0_AccessServiceClassTDDr7SubchannelSizeSize2subchannels = 0,
	subch1_AccessServiceClassTDDr7SubchannelSizeSize2subchannels = 1,
};
typedef Enumerated<CONSTRAINED, 1> AccessServiceClassTDDr7SubchannelSizeSize2subchannels;

class AccessServiceClassTDDr7SubchannelSizeSize2 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	AccessServiceClassTDDr7SubchannelSizeSize2(): Sequence(&theInfo) {}

	void setAccessServiceClassTDDr7SubchannelSizeSize2subchannels(const AccessServiceClassTDDr7SubchannelSizeSize2subchannels& accessServiceClassTDDr7SubchannelSizeSize2subchannels) { *static_cast<AccessServiceClassTDDr7SubchannelSizeSize2subchannels*>(items[0]) = accessServiceClassTDDr7SubchannelSizeSize2subchannels; }
};

typedef BitString<CONSTRAINED, 4, 4> AccessServiceClassTDDr7SubchannelSizeSize4Subchannels;

class AccessServiceClassTDDr7SubchannelSizeSize4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	AccessServiceClassTDDr7SubchannelSizeSize4(): Sequence(&theInfo) {}

	void setAccessServiceClassTDDr7SubchannelSizeSize4Subchannels(const AccessServiceClassTDDr7SubchannelSizeSize4Subchannels& accessServiceClassTDDr7SubchannelSizeSize4Subchannels) { *static_cast<AccessServiceClassTDDr7SubchannelSizeSize4Subchannels*>(items[0]) = accessServiceClassTDDr7SubchannelSizeSize4Subchannels; }
};

typedef BitString<CONSTRAINED, 8, 8> AccessServiceClassTDDr7SubchannelSizeSize8Subchannels;

class AccessServiceClassTDDr7SubchannelSizeSize8 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	AccessServiceClassTDDr7SubchannelSizeSize8(): Sequence(&theInfo) {}

	void setAccessServiceClassTDDr7SubchannelSizeSize8Subchannels(const AccessServiceClassTDDr7SubchannelSizeSize8Subchannels& accessServiceClassTDDr7SubchannelSizeSize8Subchannels) { *static_cast<AccessServiceClassTDDr7SubchannelSizeSize8Subchannels*>(items[0]) = accessServiceClassTDDr7SubchannelSizeSize8Subchannels; }
};

typedef BitString<CONSTRAINED, 16, 16> AccessServiceClassTDDr7SubchannelSizeSize16Subchannels;

class AccessServiceClassTDDr7SubchannelSizeSize16 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	AccessServiceClassTDDr7SubchannelSizeSize16(): Sequence(&theInfo) {}

	void setAccessServiceClassTDDr7SubchannelSizeSize16Subchannels(const AccessServiceClassTDDr7SubchannelSizeSize16Subchannels& accessServiceClassTDDr7SubchannelSizeSize16Subchannels) { *static_cast<AccessServiceClassTDDr7SubchannelSizeSize16Subchannels*>(items[0]) = accessServiceClassTDDr7SubchannelSizeSize16Subchannels; }
};

class AccessServiceClassTDDr7SubchannelSize : public Choice {
private:
	static const void *choicesInfo[5];
public:
	enum AccessServiceClassTDDr7SubchannelSizeChoices {
		accessServiceClassTDDr7SubchannelSizeSize1 = 0,
		accessServiceClassTDDr7SubchannelSizeSize2 = 1,
		accessServiceClassTDDr7SubchannelSizeSize4 = 2,
		accessServiceClassTDDr7SubchannelSizeSize8 = 3,
		accessServiceClassTDDr7SubchannelSizeSize16 = 4,
	};
	static const Info theInfo;
	AccessServiceClassTDDr7SubchannelSize(): Choice(&theInfo) {}
};

class AccessServiceClassTDDr7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	AccessServiceClassTDDr7(): Sequence(&theInfo) {}

	void setAccessServiceClassTDDr7ChannelisationCodeIndices(const AccessServiceClassTDDr7ChannelisationCodeIndices& accessServiceClassTDDr7ChannelisationCodeIndices) { *static_cast<AccessServiceClassTDDr7ChannelisationCodeIndices*>(items[0]) = accessServiceClassTDDr7ChannelisationCodeIndices; }
	void setAccessServiceClassTDDr7SubchannelSize(const AccessServiceClassTDDr7SubchannelSize& accessServiceClassTDDr7SubchannelSize) { *static_cast<AccessServiceClassTDDr7SubchannelSize*>(items[1]) = accessServiceClassTDDr7SubchannelSize; }
};

typedef BitString<CONSTRAINED, 8, 8> AccessServiceClassTDDLCRr4AvailableSYNCUlCodesIndics;

typedef Null AccessServiceClassTDDLCRr4SubchannelSizeSize1;

enum AccessServiceClassTDDLCRr4SubchannelSizeSize2subchannelsValues {
	subch0_AccessServiceClassTDDLCRr4SubchannelSizeSize2subchannels = 0,
	subch1_AccessServiceClassTDDLCRr4SubchannelSizeSize2subchannels = 1,
};
typedef Enumerated<CONSTRAINED, 1> AccessServiceClassTDDLCRr4SubchannelSizeSize2subchannels;

class AccessServiceClassTDDLCRr4SubchannelSizeSize2 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	AccessServiceClassTDDLCRr4SubchannelSizeSize2(): Sequence(&theInfo) {}

	void setAccessServiceClassTDDLCRr4SubchannelSizeSize2subchannels(const AccessServiceClassTDDLCRr4SubchannelSizeSize2subchannels& accessServiceClassTDDLCRr4SubchannelSizeSize2subchannels) { *static_cast<AccessServiceClassTDDLCRr4SubchannelSizeSize2subchannels*>(items[0]) = accessServiceClassTDDLCRr4SubchannelSizeSize2subchannels; }
};

typedef BitString<CONSTRAINED, 4, 4> AccessServiceClassTDDLCRr4SubchannelSizeSize4Subchannels;

class AccessServiceClassTDDLCRr4SubchannelSizeSize4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	AccessServiceClassTDDLCRr4SubchannelSizeSize4(): Sequence(&theInfo) {}

	void setAccessServiceClassTDDLCRr4SubchannelSizeSize4Subchannels(const AccessServiceClassTDDLCRr4SubchannelSizeSize4Subchannels& accessServiceClassTDDLCRr4SubchannelSizeSize4Subchannels) { *static_cast<AccessServiceClassTDDLCRr4SubchannelSizeSize4Subchannels*>(items[0]) = accessServiceClassTDDLCRr4SubchannelSizeSize4Subchannels; }
};

typedef BitString<CONSTRAINED, 8, 8> AccessServiceClassTDDLCRr4SubchannelSizeSize8Subchannels;

class AccessServiceClassTDDLCRr4SubchannelSizeSize8 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	AccessServiceClassTDDLCRr4SubchannelSizeSize8(): Sequence(&theInfo) {}

	void setAccessServiceClassTDDLCRr4SubchannelSizeSize8Subchannels(const AccessServiceClassTDDLCRr4SubchannelSizeSize8Subchannels& accessServiceClassTDDLCRr4SubchannelSizeSize8Subchannels) { *static_cast<AccessServiceClassTDDLCRr4SubchannelSizeSize8Subchannels*>(items[0]) = accessServiceClassTDDLCRr4SubchannelSizeSize8Subchannels; }
};

class AccessServiceClassTDDLCRr4SubchannelSize : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum AccessServiceClassTDDLCRr4SubchannelSizeChoices {
		accessServiceClassTDDLCRr4SubchannelSizeSize1 = 0,
		accessServiceClassTDDLCRr4SubchannelSizeSize2 = 1,
		accessServiceClassTDDLCRr4SubchannelSizeSize4 = 2,
		accessServiceClassTDDLCRr4SubchannelSizeSize8 = 3,
	};
	static const Info theInfo;
	AccessServiceClassTDDLCRr4SubchannelSize(): Choice(&theInfo) {}
};

class AccessServiceClassTDDLCRr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	AccessServiceClassTDDLCRr4(): Sequence(&theInfo) {}

	void setAccessServiceClassTDDLCRr4AvailableSYNCUlCodesIndics(const AccessServiceClassTDDLCRr4AvailableSYNCUlCodesIndics& accessServiceClassTDDLCRr4AvailableSYNCUlCodesIndics) { *static_cast<AccessServiceClassTDDLCRr4AvailableSYNCUlCodesIndics*>(items[0]) = accessServiceClassTDDLCRr4AvailableSYNCUlCodesIndics; }
	void setAccessServiceClassTDDLCRr4SubchannelSize(const AccessServiceClassTDDLCRr4SubchannelSize& accessServiceClassTDDLCRr4SubchannelSize) { *static_cast<AccessServiceClassTDDLCRr4SubchannelSize*>(items[1]) = accessServiceClassTDDLCRr4SubchannelSize; }
};

typedef Integer<CONSTRAINED, 0 ,  255> ActivationTimeOffset;

class DynamicTFInformationCCCH : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DynamicTFInformationCCCH(): Sequence(&theInfo) {}

	void setOctetModeRLCSizeInfoType2(const OctetModeRLCSizeInfoType2& octetModeRLCSizeInfoType2) { *static_cast<OctetModeRLCSizeInfoType2*>(items[0]) = octetModeRLCSizeInfoType2; }
};

class AdditionalPRACHTFandTFCSCCCHIEs : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	AdditionalPRACHTFandTFCSCCCHIEs(): Sequence(&theInfo) {}

	void setPowerOffsetInformation(const PowerOffsetInformation& powerOffsetInformation) { *static_cast<PowerOffsetInformation*>(items[0]) = powerOffsetInformation; }
	void setDynamicTFInformationCCCH(const DynamicTFInformationCCCH& dynamicTFInformationCCCH) { *static_cast<DynamicTFInformationCCCH*>(items[1]) = dynamicTFInformationCCCH; }
};

class AdditionalPRACHTFandTFCSCCCH : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	AdditionalPRACHTFandTFCSCCCH(): Sequence(&theInfo) {}

	void setAdditionalPRACHTFandTFCSCCCHIEs(const AdditionalPRACHTFandTFCSCCCHIEs& additionalPRACHTFandTFCSCCCHIEs) { *static_cast<AdditionalPRACHTFandTFCSCCCHIEs*>(items[0]) = additionalPRACHTFandTFCSCCCHIEs; }
};

typedef SequenceOf<AdditionalPRACHTFandTFCSCCCH, CONSTRAINED, 1, maxPRACH> AdditionalPRACHTFandTFCSCCCHList;

typedef Boolean AICHInfoSttdIndicator;

enum AICHTransmissionTimingValues {
	e0_AICHTransmissionTiming = 0,
	e1_AICHTransmissionTiming = 1,
};
typedef Enumerated<CONSTRAINED, 1> AICHTransmissionTiming;

class AICHInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	AICHInfo(): Sequence(&theInfo) {}

	void setChannelisationCode256(const ChannelisationCode256& channelisationCode256) { *static_cast<ChannelisationCode256*>(items[0]) = channelisationCode256; }
	void setAICHInfoSttdIndicator(const AICHInfoSttdIndicator& aICHInfoSttdIndicator) { *static_cast<AICHInfoSttdIndicator*>(items[1]) = aICHInfoSttdIndicator; }
	void setAichTransmissionTiming(const AICHTransmissionTiming& aichTransmissionTiming) { *static_cast<AICHTransmissionTiming*>(items[2]) = aichTransmissionTiming; }
};

typedef Integer<CONSTRAINED, -22, 5> AICHPowerOffset;

typedef Integer<CONSTRAINED, 0, 255> AllocationPeriodInfoAllocationActivationTime;

typedef Integer<CONSTRAINED, 1, 256> AllocationPeriodInfoAllocationDuration;

class AllocationPeriodInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	AllocationPeriodInfo(): Sequence(&theInfo) {}

	void setAllocationPeriodInfoAllocationActivationTime(const AllocationPeriodInfoAllocationActivationTime& allocationPeriodInfoAllocationActivationTime) { *static_cast<AllocationPeriodInfoAllocationActivationTime*>(items[0]) = allocationPeriodInfoAllocationActivationTime; }
	void setAllocationPeriodInfoAllocationDuration(const AllocationPeriodInfoAllocationDuration& allocationPeriodInfoAllocationDuration) { *static_cast<AllocationPeriodInfoAllocationDuration*>(items[1]) = allocationPeriodInfoAllocationDuration; }
};

typedef Integer<CONSTRAINED, 0, 8> Alpha;

typedef Integer<CONSTRAINED, 0, 255> APAICHChannelisationCode;

typedef Integer<CONSTRAINED, 0, 79> APPreambleScramblingCode;

typedef Integer<CONSTRAINED, 0, 15> APSignature;

typedef Integer<CONSTRAINED, 0, 11> APSubchannel;

typedef SequenceOf<APSubchannel, CONSTRAINED, 1, maxPCPCH_APsubCh> AvailableAPSubchannelList;

class APSignatureVCAM : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	APSignatureVCAM(): Sequence(&theInfo) {}

	void setApSignature(const APSignature& apSignature) { *static_cast<APSignature*>(items[0]) = apSignature; }
	void setAvailableAPSubchannelList(const AvailableAPSubchannelList& availableAPSubchannelList) { *static_cast<AvailableAPSubchannelList*>(items[1]) = availableAPSubchannelList; }
};

class ASCSettingFDD : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ASCSettingFDD(): Sequence(&theInfo) {}

	void setAccessServiceClassFDD(const AccessServiceClassFDD& accessServiceClassFDD) { *static_cast<AccessServiceClassFDD*>(items[0]) = accessServiceClassFDD; }
};

class ASCSettingTDD : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ASCSettingTDD(): Sequence(&theInfo) {}

	void setAccessServiceClassTDD(const AccessServiceClassTDD& accessServiceClassTDD) { *static_cast<AccessServiceClassTDD*>(items[0]) = accessServiceClassTDD; }
};

class ASCSettingTDDr7 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ASCSettingTDDr7(): Sequence(&theInfo) {}

	void setAccessServiceClassTDD(const AccessServiceClassTDDr7& accessServiceClassTDD) { *static_cast<AccessServiceClassTDDr7*>(items[0]) = accessServiceClassTDD; }
};

class ASCSettingTDDLCRr4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ASCSettingTDDLCRr4(): Sequence(&theInfo) {}

	void setAccessServiceClassTDDLCR(const AccessServiceClassTDDLCRr4& accessServiceClassTDDLCR) { *static_cast<AccessServiceClassTDDLCRr4*>(items[0]) = accessServiceClassTDDLCR; }
};

typedef SequenceOf<APSignatureVCAM, CONSTRAINED, 1, maxPCPCH_APsig> AvailableAPSignatureVCAMList;

typedef SequenceOf<APSignature, CONSTRAINED, 1, maxPCPCH_APsig> AvailableAPSignatureList;

enum MinimumSpreadingFactorValues {
	sf4_MinimumSpreadingFactor = 0,
	sf8_MinimumSpreadingFactor = 1,
	sf16_MinimumSpreadingFactor = 2,
	sf32_MinimumSpreadingFactor = 3,
	sf64_MinimumSpreadingFactor = 4,
	sf128_MinimumSpreadingFactor = 5,
	sf256_MinimumSpreadingFactor = 6,
};
typedef Enumerated<CONSTRAINED, 6> MinimumSpreadingFactor;

typedef Integer<CONSTRAINED, 1, 64> NFMax;

typedef Integer<CONSTRAINED, 1, 64> MaxAvailablePCPCHNumber;

class AvailableMinimumSFVCAM : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	AvailableMinimumSFVCAM(): Sequence(&theInfo) {}

	void setMinimumSpreadingFactor(const MinimumSpreadingFactor& minimumSpreadingFactor) { *static_cast<MinimumSpreadingFactor*>(items[0]) = minimumSpreadingFactor; }
	void setNfMax(const NFMax& nfMax) { *static_cast<NFMax*>(items[1]) = nfMax; }
	void setMaxAvailablePCPCHNumber(const MaxAvailablePCPCHNumber& maxAvailablePCPCHNumber) { *static_cast<MaxAvailablePCPCHNumber*>(items[2]) = maxAvailablePCPCHNumber; }
	void setAvailableAPSignatureVCAMList(const AvailableAPSignatureVCAMList& availableAPSignatureVCAMList) { *static_cast<AvailableAPSignatureVCAMList*>(items[3]) = availableAPSignatureVCAMList; }
};

typedef SequenceOf<AvailableMinimumSFVCAM, CONSTRAINED, 1, maxPCPCH_SF> AvailableMinimumSFListVCAM;

typedef BitString<CONSTRAINED, 16, 16> AvailableSignatures;

typedef BitString<CONSTRAINED, 12, 12> AvailableSubChannelNumbers;

enum BEACONPLEstValues {
	true_BEACONPLEst = 0,
};
typedef Enumerated<CONSTRAINED, 0> BEACONPLEst;

enum BurstTypeValues {
	type1_BurstType = 0,
	type2_BurstType = 1,
};
typedef Enumerated<CONSTRAINED, 1> BurstType;

typedef Integer<CONSTRAINED, -82, -3> DPCCHPowerOffset;

typedef Integer<CONSTRAINED, 0, 7> SRBdelay;

class ULDPCHPowerControlInfoFdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfoFdd(): Sequence(&theInfo) {}

	void setDpcchPowerOffset(const DPCCHPowerOffset& dpcchPowerOffset) { *static_cast<DPCCHPowerOffset*>(items[0]) = dpcchPowerOffset; }
	void setPcPreamble(const PCPreamble& pcPreamble) { *static_cast<PCPreamble*>(items[1]) = pcPreamble; }
	void setSRBdelay(const SRBdelay& sRBdelay) { *static_cast<SRBdelay*>(items[2]) = sRBdelay; }
	void setPowerControlAlgorithm(const PowerControlAlgorithm& powerControlAlgorithm) { *static_cast<PowerControlAlgorithm*>(items[3]) = powerControlAlgorithm; }
};

typedef Integer<CONSTRAINED, 0, 62> ULTargetSIR;

typedef Null ULDPCHPowerControlInfoTddUlOLPCSignallingBroadcastULOLPCinfo;

typedef Integer<CONSTRAINED, -110, -52> TDDULInterference;

class IndividualTSInterference : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IndividualTSInterference(): Sequence(&theInfo) {}

	void setTimeslot(const TimeslotNumber& timeslot) { *static_cast<TimeslotNumber*>(items[0]) = timeslot; }
	void setUlTimeslotInterference(const TDDULInterference& ulTimeslotInterference) { *static_cast<TDDULInterference*>(items[1]) = ulTimeslotInterference; }
};

typedef SequenceOf<IndividualTSInterference, CONSTRAINED, 1, maxTS> IndividualTSInterferenceList;

typedef Integer<CONSTRAINED, 6, 43> PrimaryCCPCHTXPower;

class ULDPCHPowerControlInfoTddUlOLPCSignallingIndividuallySignalled : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfoTddUlOLPCSignallingIndividuallySignalled(): Sequence(&theInfo) {}

	void setIndividualTSInterferenceList(const IndividualTSInterferenceList& individualTSInterferenceList) { *static_cast<IndividualTSInterferenceList*>(items[0]) = individualTSInterferenceList; }
	void setDpchConstantValue(const ConstantValueTdd& dpchConstantValue) { *static_cast<ConstantValueTdd*>(items[1]) = dpchConstantValue; }
	void setPrimaryCCPCHTXPower(const PrimaryCCPCHTXPower& primaryCCPCHTXPower) { *static_cast<PrimaryCCPCHTXPower*>(items[2]) = primaryCCPCHTXPower; }
};

class ULDPCHPowerControlInfoTddUlOLPCSignalling : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHPowerControlInfoTddUlOLPCSignallingChoices {
		uLDPCHPowerControlInfoTddUlOLPCSignallingBroadcastULOLPCinfo = 0,
		uLDPCHPowerControlInfoTddUlOLPCSignallingIndividuallySignalled = 1,
	};
	static const Info theInfo;
	ULDPCHPowerControlInfoTddUlOLPCSignalling(): Choice(&theInfo) {}
};

class ULDPCHPowerControlInfoTdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfoTdd(): Sequence(&theInfo) {}

	void setUlTargetSIR(const ULTargetSIR& ulTargetSIR) { *static_cast<ULTargetSIR*>(items[0]) = ulTargetSIR; }
	void setULDPCHPowerControlInfoTddUlOLPCSignalling(const ULDPCHPowerControlInfoTddUlOLPCSignalling& uLDPCHPowerControlInfoTddUlOLPCSignalling) { *static_cast<ULDPCHPowerControlInfoTddUlOLPCSignalling*>(items[1]) = uLDPCHPowerControlInfoTddUlOLPCSignalling; }
};

class ULDPCHPowerControlInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHPowerControlInfoChoices {
		uLDPCHPowerControlInfoFdd = 0,
		uLDPCHPowerControlInfoTdd = 1,
	};
	static const Info theInfo;
	ULDPCHPowerControlInfo(): Choice(&theInfo) {}
};

class CCTrCHPowerControlInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CCTrCHPowerControlInfo(): Sequence(&theInfo) {}

	void setTfcsIdentity(const TFCSIdentity& tfcsIdentity) { *static_cast<TFCSIdentity*>(items[0]) = tfcsIdentity; }
	void setUlDPCHPowerControlInfo(const ULDPCHPowerControlInfo& ulDPCHPowerControlInfo) { *static_cast<ULDPCHPowerControlInfo*>(items[1]) = ulDPCHPowerControlInfo; }
};

class ULDPCHPowerControlInfor4Fdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor4Fdd(): Sequence(&theInfo) {}

	void setDpcchPowerOffset(const DPCCHPowerOffset& dpcchPowerOffset) { *static_cast<DPCCHPowerOffset*>(items[0]) = dpcchPowerOffset; }
	void setPcPreamble(const PCPreamble& pcPreamble) { *static_cast<PCPreamble*>(items[1]) = pcPreamble; }
	void setSRBdelay(const SRBdelay& sRBdelay) { *static_cast<SRBdelay*>(items[2]) = sRBdelay; }
	void setPowerControlAlgorithm(const PowerControlAlgorithm& powerControlAlgorithm) { *static_cast<PowerControlAlgorithm*>(items[3]) = powerControlAlgorithm; }
};

typedef Null ULDPCHPowerControlInfor4TddUlOLPCSignallingBroadcastULOLPCinfo;

class ULDPCHPowerControlInfor4TddUlOLPCSignallingIndividuallySignalledTddOptionTdd384 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor4TddUlOLPCSignallingIndividuallySignalledTddOptionTdd384(): Sequence(&theInfo) {}

	void setIndividualTSInterferenceList(const IndividualTSInterferenceList& individualTSInterferenceList) { *static_cast<IndividualTSInterferenceList*>(items[0]) = individualTSInterferenceList; }
	void setDpchConstantValue(const ConstantValue& dpchConstantValue) { *static_cast<ConstantValue*>(items[1]) = dpchConstantValue; }
};

typedef Integer<CONSTRAINED, 1, 3> TPCStepSizeTDD;

class ULDPCHPowerControlInfor4TddUlOLPCSignallingIndividuallySignalledTddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor4TddUlOLPCSignallingIndividuallySignalledTddOptionTdd128(): Sequence(&theInfo) {}

	void setTpcStepSize(const TPCStepSizeTDD& tpcStepSize) { *static_cast<TPCStepSizeTDD*>(items[0]) = tpcStepSize; }
};

class ULDPCHPowerControlInfor4TddUlOLPCSignallingIndividuallySignalledTddOption : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHPowerControlInfor4TddUlOLPCSignallingIndividuallySignalledTddOptionChoices {
		uLDPCHPowerControlInfor4TddUlOLPCSignallingIndividuallySignalledTddOptionTdd384 = 0,
		uLDPCHPowerControlInfor4TddUlOLPCSignallingIndividuallySignalledTddOptionTdd128 = 1,
	};
	static const Info theInfo;
	ULDPCHPowerControlInfor4TddUlOLPCSignallingIndividuallySignalledTddOption(): Choice(&theInfo) {}
};

class ULDPCHPowerControlInfor4TddUlOLPCSignallingIndividuallySignalled : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor4TddUlOLPCSignallingIndividuallySignalled(): Sequence(&theInfo) {}

	void setULDPCHPowerControlInfor4TddUlOLPCSignallingIndividuallySignalledTddOption(const ULDPCHPowerControlInfor4TddUlOLPCSignallingIndividuallySignalledTddOption& uLDPCHPowerControlInfor4TddUlOLPCSignallingIndividuallySignalledTddOption) { *static_cast<ULDPCHPowerControlInfor4TddUlOLPCSignallingIndividuallySignalledTddOption*>(items[0]) = uLDPCHPowerControlInfor4TddUlOLPCSignallingIndividuallySignalledTddOption; }
	void setPrimaryCCPCHTXPower(const PrimaryCCPCHTXPower& primaryCCPCHTXPower) { *static_cast<PrimaryCCPCHTXPower*>(items[1]) = primaryCCPCHTXPower; }
};

class ULDPCHPowerControlInfor4TddUlOLPCSignalling : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHPowerControlInfor4TddUlOLPCSignallingChoices {
		uLDPCHPowerControlInfor4TddUlOLPCSignallingBroadcastULOLPCinfo = 0,
		uLDPCHPowerControlInfor4TddUlOLPCSignallingIndividuallySignalled = 1,
	};
	static const Info theInfo;
	ULDPCHPowerControlInfor4TddUlOLPCSignalling(): Choice(&theInfo) {}
};

class ULDPCHPowerControlInfor4Tdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor4Tdd(): Sequence(&theInfo) {}

	void setUlTargetSIR(const ULTargetSIR& ulTargetSIR) { *static_cast<ULTargetSIR*>(items[0]) = ulTargetSIR; }
	void setULDPCHPowerControlInfor4TddUlOLPCSignalling(const ULDPCHPowerControlInfor4TddUlOLPCSignalling& uLDPCHPowerControlInfor4TddUlOLPCSignalling) { *static_cast<ULDPCHPowerControlInfor4TddUlOLPCSignalling*>(items[1]) = uLDPCHPowerControlInfor4TddUlOLPCSignalling; }
};

class ULDPCHPowerControlInfor4 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHPowerControlInfor4Choices {
		uLDPCHPowerControlInfor4Fdd = 0,
		uLDPCHPowerControlInfor4Tdd = 1,
	};
	static const Info theInfo;
	ULDPCHPowerControlInfor4(): Choice(&theInfo) {}
};

class CCTrCHPowerControlInfor4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CCTrCHPowerControlInfor4(): Sequence(&theInfo) {}

	void setTfcsIdentity(const TFCSIdentity& tfcsIdentity) { *static_cast<TFCSIdentity*>(items[0]) = tfcsIdentity; }
	void setUlDPCHPowerControlInfo(const ULDPCHPowerControlInfor4& ulDPCHPowerControlInfo) { *static_cast<ULDPCHPowerControlInfor4*>(items[1]) = ulDPCHPowerControlInfo; }
};

class ULDPCHPowerControlInfor5Fdd : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor5Fdd(): Sequence(&theInfo) {}

	void setDpcchPowerOffset(const DPCCHPowerOffset& dpcchPowerOffset) { *static_cast<DPCCHPowerOffset*>(items[0]) = dpcchPowerOffset; }
	void setPcPreamble(const PCPreamble& pcPreamble) { *static_cast<PCPreamble*>(items[1]) = pcPreamble; }
	void setSRBdelay(const SRBdelay& sRBdelay) { *static_cast<SRBdelay*>(items[2]) = sRBdelay; }
	void setPowerControlAlgorithm(const PowerControlAlgorithm& powerControlAlgorithm) { *static_cast<PowerControlAlgorithm*>(items[3]) = powerControlAlgorithm; }
	void setDeltaACK(const DeltaACK& deltaACK) { *static_cast<DeltaACK*>(items[4]) = deltaACK; }
	void setDeltaNACK(const DeltaNACK& deltaNACK) { *static_cast<DeltaNACK*>(items[5]) = deltaNACK; }
	void setAckNACKrepetitionfactor(const ACKNACKrepetitionFactor& ackNACKrepetitionfactor) { *static_cast<ACKNACKrepetitionFactor*>(items[6]) = ackNACKrepetitionfactor; }
};

typedef Null ULDPCHPowerControlInfor5TddUlOLPCSignallingBroadcastULOLPCinfo;

class ULDPCHPowerControlInfor5TddUlOLPCSignallingIndividuallySignalledTddOptionTdd384 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor5TddUlOLPCSignallingIndividuallySignalledTddOptionTdd384(): Sequence(&theInfo) {}

	void setIndividualTSInterferenceList(const IndividualTSInterferenceList& individualTSInterferenceList) { *static_cast<IndividualTSInterferenceList*>(items[0]) = individualTSInterferenceList; }
	void setDpchConstantValue(const ConstantValue& dpchConstantValue) { *static_cast<ConstantValue*>(items[1]) = dpchConstantValue; }
};

class ULDPCHPowerControlInfor5TddUlOLPCSignallingIndividuallySignalledTddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor5TddUlOLPCSignallingIndividuallySignalledTddOptionTdd128(): Sequence(&theInfo) {}

	void setTpcStepSize(const TPCStepSizeTDD& tpcStepSize) { *static_cast<TPCStepSizeTDD*>(items[0]) = tpcStepSize; }
};

class ULDPCHPowerControlInfor5TddUlOLPCSignallingIndividuallySignalledTddOption : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHPowerControlInfor5TddUlOLPCSignallingIndividuallySignalledTddOptionChoices {
		uLDPCHPowerControlInfor5TddUlOLPCSignallingIndividuallySignalledTddOptionTdd384 = 0,
		uLDPCHPowerControlInfor5TddUlOLPCSignallingIndividuallySignalledTddOptionTdd128 = 1,
	};
	static const Info theInfo;
	ULDPCHPowerControlInfor5TddUlOLPCSignallingIndividuallySignalledTddOption(): Choice(&theInfo) {}
};

class ULDPCHPowerControlInfor5TddUlOLPCSignallingIndividuallySignalled : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor5TddUlOLPCSignallingIndividuallySignalled(): Sequence(&theInfo) {}

	void setULDPCHPowerControlInfor5TddUlOLPCSignallingIndividuallySignalledTddOption(const ULDPCHPowerControlInfor5TddUlOLPCSignallingIndividuallySignalledTddOption& uLDPCHPowerControlInfor5TddUlOLPCSignallingIndividuallySignalledTddOption) { *static_cast<ULDPCHPowerControlInfor5TddUlOLPCSignallingIndividuallySignalledTddOption*>(items[0]) = uLDPCHPowerControlInfor5TddUlOLPCSignallingIndividuallySignalledTddOption; }
	void setPrimaryCCPCHTXPower(const PrimaryCCPCHTXPower& primaryCCPCHTXPower) { *static_cast<PrimaryCCPCHTXPower*>(items[1]) = primaryCCPCHTXPower; }
};

class ULDPCHPowerControlInfor5TddUlOLPCSignalling : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHPowerControlInfor5TddUlOLPCSignallingChoices {
		uLDPCHPowerControlInfor5TddUlOLPCSignallingBroadcastULOLPCinfo = 0,
		uLDPCHPowerControlInfor5TddUlOLPCSignallingIndividuallySignalled = 1,
	};
	static const Info theInfo;
	ULDPCHPowerControlInfor5TddUlOLPCSignalling(): Choice(&theInfo) {}
};

class ULDPCHPowerControlInfor5Tdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor5Tdd(): Sequence(&theInfo) {}

	void setUlTargetSIR(const ULTargetSIR& ulTargetSIR) { *static_cast<ULTargetSIR*>(items[0]) = ulTargetSIR; }
	void setULDPCHPowerControlInfor5TddUlOLPCSignalling(const ULDPCHPowerControlInfor5TddUlOLPCSignalling& uLDPCHPowerControlInfor5TddUlOLPCSignalling) { *static_cast<ULDPCHPowerControlInfor5TddUlOLPCSignalling*>(items[1]) = uLDPCHPowerControlInfor5TddUlOLPCSignalling; }
};

class ULDPCHPowerControlInfor5 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHPowerControlInfor5Choices {
		uLDPCHPowerControlInfor5Fdd = 0,
		uLDPCHPowerControlInfor5Tdd = 1,
	};
	static const Info theInfo;
	ULDPCHPowerControlInfor5(): Choice(&theInfo) {}
};

class CCTrCHPowerControlInfor5 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CCTrCHPowerControlInfor5(): Sequence(&theInfo) {}

	void setTfcsIdentity(const TFCSIdentity& tfcsIdentity) { *static_cast<TFCSIdentity*>(items[0]) = tfcsIdentity; }
	void setUlDPCHPowerControlInfo(const ULDPCHPowerControlInfor5& ulDPCHPowerControlInfo) { *static_cast<ULDPCHPowerControlInfor5*>(items[1]) = ulDPCHPowerControlInfo; }
};

class ULDPCHPowerControlInfor7Fdd : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor7Fdd(): Sequence(&theInfo) {}

	void setDpcchPowerOffset(const DPCCHPowerOffset& dpcchPowerOffset) { *static_cast<DPCCHPowerOffset*>(items[0]) = dpcchPowerOffset; }
	void setPcPreamble(const PCPreamble& pcPreamble) { *static_cast<PCPreamble*>(items[1]) = pcPreamble; }
	void setSRBdelay(const SRBdelay& sRBdelay) { *static_cast<SRBdelay*>(items[2]) = sRBdelay; }
	void setPowerControlAlgorithm(const PowerControlAlgorithm& powerControlAlgorithm) { *static_cast<PowerControlAlgorithm*>(items[3]) = powerControlAlgorithm; }
	void setDeltaACK(const DeltaACK& deltaACK) { *static_cast<DeltaACK*>(items[4]) = deltaACK; }
	void setDeltaNACK(const DeltaNACK& deltaNACK) { *static_cast<DeltaNACK*>(items[5]) = deltaNACK; }
	void setAckNACKrepetitionfactor(const ACKNACKrepetitionFactor& ackNACKrepetitionfactor) { *static_cast<ACKNACKrepetitionFactor*>(items[6]) = ackNACKrepetitionfactor; }
	void setHarqPreambleMode(const HARQPreambleMode& harqPreambleMode) { *static_cast<HARQPreambleMode*>(items[7]) = harqPreambleMode; }
};

typedef Null ULDPCHPowerControlInfor7TddUlOLPCSignallingBroadcastULOLPCinfo;

class ULDPCHPowerControlInfor7TddUlOLPCSignallingIndividuallySignalledTddOptionTdd384 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor7TddUlOLPCSignallingIndividuallySignalledTddOptionTdd384(): Sequence(&theInfo) {}

	void setIndividualTSInterferenceList(const IndividualTSInterferenceList& individualTSInterferenceList) { *static_cast<IndividualTSInterferenceList*>(items[0]) = individualTSInterferenceList; }
	void setDpchConstantValue(const ConstantValue& dpchConstantValue) { *static_cast<ConstantValue*>(items[1]) = dpchConstantValue; }
};

class ULDPCHPowerControlInfor7TddUlOLPCSignallingIndividuallySignalledTddOptionTdd768 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor7TddUlOLPCSignallingIndividuallySignalledTddOptionTdd768(): Sequence(&theInfo) {}

	void setIndividualTSInterferenceList(const IndividualTSInterferenceList& individualTSInterferenceList) { *static_cast<IndividualTSInterferenceList*>(items[0]) = individualTSInterferenceList; }
	void setDpchConstantValue(const ConstantValue& dpchConstantValue) { *static_cast<ConstantValue*>(items[1]) = dpchConstantValue; }
};

class ULDPCHPowerControlInfor7TddUlOLPCSignallingIndividuallySignalledTddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor7TddUlOLPCSignallingIndividuallySignalledTddOptionTdd128(): Sequence(&theInfo) {}

	void setBeaconPLEst(const BEACONPLEst& beaconPLEst) { *static_cast<BEACONPLEst*>(items[0]) = beaconPLEst; }
	void setTpcStepSize(const TPCStepSizeTDD& tpcStepSize) { *static_cast<TPCStepSizeTDD*>(items[1]) = tpcStepSize; }
};

class ULDPCHPowerControlInfor7TddUlOLPCSignallingIndividuallySignalledTddOption : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum ULDPCHPowerControlInfor7TddUlOLPCSignallingIndividuallySignalledTddOptionChoices {
		uLDPCHPowerControlInfor7TddUlOLPCSignallingIndividuallySignalledTddOptionTdd384 = 0,
		uLDPCHPowerControlInfor7TddUlOLPCSignallingIndividuallySignalledTddOptionTdd768 = 1,
		uLDPCHPowerControlInfor7TddUlOLPCSignallingIndividuallySignalledTddOptionTdd128 = 2,
	};
	static const Info theInfo;
	ULDPCHPowerControlInfor7TddUlOLPCSignallingIndividuallySignalledTddOption(): Choice(&theInfo) {}
};

class ULDPCHPowerControlInfor7TddUlOLPCSignallingIndividuallySignalled : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor7TddUlOLPCSignallingIndividuallySignalled(): Sequence(&theInfo) {}

	void setULDPCHPowerControlInfor7TddUlOLPCSignallingIndividuallySignalledTddOption(const ULDPCHPowerControlInfor7TddUlOLPCSignallingIndividuallySignalledTddOption& uLDPCHPowerControlInfor7TddUlOLPCSignallingIndividuallySignalledTddOption) { *static_cast<ULDPCHPowerControlInfor7TddUlOLPCSignallingIndividuallySignalledTddOption*>(items[0]) = uLDPCHPowerControlInfor7TddUlOLPCSignallingIndividuallySignalledTddOption; }
	void setPrimaryCCPCHTXPower(const PrimaryCCPCHTXPower& primaryCCPCHTXPower) { *static_cast<PrimaryCCPCHTXPower*>(items[1]) = primaryCCPCHTXPower; }
};

class ULDPCHPowerControlInfor7TddUlOLPCSignalling : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHPowerControlInfor7TddUlOLPCSignallingChoices {
		uLDPCHPowerControlInfor7TddUlOLPCSignallingBroadcastULOLPCinfo = 0,
		uLDPCHPowerControlInfor7TddUlOLPCSignallingIndividuallySignalled = 1,
	};
	static const Info theInfo;
	ULDPCHPowerControlInfor7TddUlOLPCSignalling(): Choice(&theInfo) {}
};

class ULDPCHPowerControlInfor7Tdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor7Tdd(): Sequence(&theInfo) {}

	void setUlTargetSIR(const ULTargetSIR& ulTargetSIR) { *static_cast<ULTargetSIR*>(items[0]) = ulTargetSIR; }
	void setULDPCHPowerControlInfor7TddUlOLPCSignalling(const ULDPCHPowerControlInfor7TddUlOLPCSignalling& uLDPCHPowerControlInfor7TddUlOLPCSignalling) { *static_cast<ULDPCHPowerControlInfor7TddUlOLPCSignalling*>(items[1]) = uLDPCHPowerControlInfor7TddUlOLPCSignalling; }
};

class ULDPCHPowerControlInfor7 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHPowerControlInfor7Choices {
		uLDPCHPowerControlInfor7Fdd = 0,
		uLDPCHPowerControlInfor7Tdd = 1,
	};
	static const Info theInfo;
	ULDPCHPowerControlInfor7(): Choice(&theInfo) {}
};

class CCTrCHPowerControlInfor7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CCTrCHPowerControlInfor7(): Sequence(&theInfo) {}

	void setTfcsIdentity(const TFCSIdentity& tfcsIdentity) { *static_cast<TFCSIdentity*>(items[0]) = tfcsIdentity; }
	void setUlDPCHPowerControlInfo(const ULDPCHPowerControlInfor7& ulDPCHPowerControlInfo) { *static_cast<ULDPCHPowerControlInfor7*>(items[1]) = ulDPCHPowerControlInfo; }
};

typedef Integer<CONSTRAINED, 0, 11> CDAccessSlotSubchannel;

typedef SequenceOf<CDAccessSlotSubchannel, CONSTRAINED, 1, maxPCPCH_CDsubCh> CDAccessSlotSubchannelList;

typedef Integer<CONSTRAINED, 0, 255> CDCAICHChannelisationCode;

typedef Integer<CONSTRAINED, 0, 79> CDPreambleScramblingCode;

typedef Integer<CONSTRAINED, 0, 15> CDSignatureCode;

typedef SequenceOf<CDSignatureCode, CONSTRAINED, 1, maxPCPCH_CDsig> CDSignatureCodeList;

typedef Integer<CONSTRAINED, 0, 127> CellParametersID;

class CellAndChannelIdentity : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellAndChannelIdentity(): Sequence(&theInfo) {}

	void setBurstType(const BurstType& burstType) { *static_cast<BurstType*>(items[0]) = burstType; }
	void setMidambleShift(const MidambleShiftLong& midambleShift) { *static_cast<MidambleShiftLong*>(items[1]) = midambleShift; }
	void setTimeslot(const TimeslotNumber& timeslot) { *static_cast<TimeslotNumber*>(items[2]) = timeslot; }
	void setCellParametersID(const CellParametersID& cellParametersID) { *static_cast<CellParametersID*>(items[3]) = cellParametersID; }
};

typedef Integer<CONSTRAINED, 0, 255> Cfntargetsfnframeoffset;

typedef Null ChannelAssignmentActiveNotActive;

class ChannelAssignmentActive : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ChannelAssignmentActiveChoices {
		channelAssignmentActiveNotActive = 0,
		isActive = 1,
	};
	static const Info theInfo;
	ChannelAssignmentActive(): Choice(&theInfo) {}
};

class ChannelReqParamsForUCSM : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ChannelReqParamsForUCSM(): Sequence(&theInfo) {}

	void setAvailableAPSignatureList(const AvailableAPSignatureList& availableAPSignatureList) { *static_cast<AvailableAPSignatureList*>(items[0]) = availableAPSignatureList; }
	void setAvailableAPSubchannelList(const AvailableAPSubchannelList& availableAPSubchannelList) { *static_cast<AvailableAPSubchannelList*>(items[1]) = availableAPSubchannelList; }
};

enum ClosedLoopTimingAdjModeValues {
	slot1_ClosedLoopTimingAdjMode = 0,
	slot2_ClosedLoopTimingAdjMode = 1,
};
typedef Enumerated<CONSTRAINED, 1> ClosedLoopTimingAdjMode;

typedef Integer<CONSTRAINED, 0, 255> CodeNumberDSCH;

enum SFPDSCHValues {
	sfp4_SFPDSCH = 0,
	sfp8_SFPDSCH = 1,
	sfp16_SFPDSCH = 2,
	sfp32_SFPDSCH = 3,
	sfp64_SFPDSCH = 4,
	sfp128_SFPDSCH = 5,
	sfp256_SFPDSCH = 6,
};
typedef Enumerated<CONSTRAINED, 6> SFPDSCH;

typedef Integer<CONSTRAINED, 1, 16> MultiCodeInfo;

class PDSCHCodeMap : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	PDSCHCodeMap(): Sequence(&theInfo) {}

	void setSpreadingFactor(const SFPDSCH& spreadingFactor) { *static_cast<SFPDSCH*>(items[0]) = spreadingFactor; }
	void setMultiCodeInfo(const MultiCodeInfo& multiCodeInfo) { *static_cast<MultiCodeInfo*>(items[1]) = multiCodeInfo; }
	void setCodeNumberStart(const CodeNumberDSCH& codeNumberStart) { *static_cast<CodeNumberDSCH*>(items[2]) = codeNumberStart; }
	void setCodeNumberStop(const CodeNumberDSCH& codeNumberStop) { *static_cast<CodeNumberDSCH*>(items[3]) = codeNumberStop; }
};

typedef SequenceOf<PDSCHCodeMap, CONSTRAINED, 1, maxPDSCH_TFCIgroups> PDSCHCodeMapList;

class CodeRange : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CodeRange(): Sequence(&theInfo) {}

	void setPdschCodeMapList(const PDSCHCodeMapList& pdschCodeMapList) { *static_cast<PDSCHCodeMapList*>(items[0]) = pdschCodeMapList; }
};

class CodeResourceInformationTDD128 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CodeResourceInformationTDD128(): Sequence(&theInfo) {}

	void setStartcode(const HSChannelisationCodeLCR& startcode) { *static_cast<HSChannelisationCodeLCR*>(items[0]) = startcode; }
	void setStopcode(const HSChannelisationCodeLCR& stopcode) { *static_cast<HSChannelisationCodeLCR*>(items[1]) = stopcode; }
};

enum CodeWordSetValues {
	longCWS_CodeWordSet = 0,
	mediumCWS_CodeWordSet = 1,
	shortCWS_CodeWordSet = 2,
	ssdtOff_CodeWordSet = 3,
};
typedef Enumerated<CONSTRAINED, 3> CodeWordSet;

typedef Integer<CONSTRAINED, 0, 9> CommonEDCHResourceInfoListSoffset;

typedef Integer<CONSTRAINED, 0, 255> CommonEDCHResourceInfoListFdpchChannelisationCodeNumber;

class ERGCHInformationCommonEdch : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ERGCHInformationCommonEdch(): Sequence(&theInfo) {}

	void setSignatureSequence(const EHICHRGCHSignatureSequence& signatureSequence) { *static_cast<EHICHRGCHSignatureSequence*>(items[0]) = signatureSequence; }
};

class EHICHInformationCommonEdch : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EHICHInformationCommonEdch(): Sequence(&theInfo) {}

	void setChannelisationCode(const EHICHChannelisationCode& channelisationCode) { *static_cast<EHICHChannelisationCode*>(items[0]) = channelisationCode; }
	void setSignatureSequence(const EHICHRGCHSignatureSequence& signatureSequence) { *static_cast<EHICHRGCHSignatureSequence*>(items[1]) = signatureSequence; }
};

class ULDPCHCodeInfoForCommonEDCH : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHCodeInfoForCommonEDCH(): Sequence(&theInfo) {}

	void setUlDPCCHscramblingCodeType(const ScramblingCodeType& ulDPCCHscramblingCodeType) { *static_cast<ScramblingCodeType*>(items[0]) = ulDPCCHscramblingCodeType; }
	void setUlDPCCHscramblingCode(const ULScramblingCode& ulDPCCHscramblingCode) { *static_cast<ULScramblingCode*>(items[1]) = ulDPCCHscramblingCode; }
};

class CommonEDCHResourceInfoList : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	CommonEDCHResourceInfoList(): Sequence(&theInfo) {}

	void setCommonEDCHResourceInfoListSoffset(const CommonEDCHResourceInfoListSoffset& commonEDCHResourceInfoListSoffset) { *static_cast<CommonEDCHResourceInfoListSoffset*>(items[0]) = commonEDCHResourceInfoListSoffset; }
	void setCommonEDCHResourceInfoListFdpchChannelisationCodeNumber(const CommonEDCHResourceInfoListFdpchChannelisationCodeNumber& commonEDCHResourceInfoListFdpchChannelisationCodeNumber) { *static_cast<CommonEDCHResourceInfoListFdpchChannelisationCodeNumber*>(items[1]) = commonEDCHResourceInfoListFdpchChannelisationCodeNumber; }
	void setERGCHInformation(const ERGCHInformationCommonEdch& eRGCHInformation) { *static_cast<ERGCHInformationCommonEdch*>(items[2]) = eRGCHInformation; }
	void setEhichInfo(const EHICHInformationCommonEdch& ehichInfo) { *static_cast<EHICHInformationCommonEdch*>(items[3]) = ehichInfo; }
	void setUlDPCHCodeInfoForCommonEDCH(const ULDPCHCodeInfoForCommonEDCH& ulDPCHCodeInfoForCommonEDCH) { *static_cast<ULDPCHCodeInfoForCommonEDCH*>(items[4]) = ulDPCHCodeInfoForCommonEDCH; }
};

class CommonERNTIInfo : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	CommonERNTIInfo(): Sequence(&theInfo) {}

};

typedef Integer<CONSTRAINED, -110, -70> ULInterference;

class CommonEDCHSystemInfoModeSpecificInfoDummy : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	CommonEDCHSystemInfoModeSpecificInfoDummy(): Sequence(&theInfo) {}

};

typedef Null CommonEDCHSystemInfoModeSpecificInfoTddTdd768;

typedef Null CommonEDCHSystemInfoModeSpecificInfoTddTdd384;

enum ERUCCHInfoTDD128t_RUCCHValues {
	ms20_ERUCCHInfoTDD128t_RUCCH = 0,
	ms40_ERUCCHInfoTDD128t_RUCCH = 1,
	ms60_ERUCCHInfoTDD128t_RUCCH = 2,
	ms80_ERUCCHInfoTDD128t_RUCCH = 3,
	ms120_ERUCCHInfoTDD128t_RUCCH = 4,
	ms160_ERUCCHInfoTDD128t_RUCCH = 5,
	ms200_ERUCCHInfoTDD128t_RUCCH = 6,
	ms240_ERUCCHInfoTDD128t_RUCCH = 7,
	ms280_ERUCCHInfoTDD128t_RUCCH = 8,
	ms320_ERUCCHInfoTDD128t_RUCCH = 9,
	ms400_ERUCCHInfoTDD128t_RUCCH = 10,
	ms500_ERUCCHInfoTDD128t_RUCCH = 11,
	ms600_ERUCCHInfoTDD128t_RUCCH = 12,
	ms800_ERUCCHInfoTDD128t_RUCCH = 13,
	ms1000_ERUCCHInfoTDD128t_RUCCH = 14,
	ms2000_ERUCCHInfoTDD128t_RUCCH = 15,
};
typedef Enumerated<CONSTRAINED, 15> ERUCCHInfoTDD128t_RUCCH;

typedef Integer<CONSTRAINED, 0, 7> ERUCCHInfoTDD128NRUCCH;

enum ERUCCHInfoTDD128t_WAITValues {
	everyEDCHTTI_ERUCCHInfoTDD128t_WAIT = 0,
	ms40_ERUCCHInfoTDD128t_WAIT = 1,
	ms80_ERUCCHInfoTDD128t_WAIT = 2,
	ms160_ERUCCHInfoTDD128t_WAIT = 3,
	ms320_ERUCCHInfoTDD128t_WAIT = 4,
	ms640_ERUCCHInfoTDD128t_WAIT = 5,
	ms1000_ERUCCHInfoTDD128t_WAIT = 6,
	ms2000_ERUCCHInfoTDD128t_WAIT = 7,
};
typedef Enumerated<CONSTRAINED, 7> ERUCCHInfoTDD128t_WAIT;

enum ERUCCHInfoTDD128t_SIValues {
	everyEDCHTTI_ERUCCHInfoTDD128t_SI = 0,
	ms20_ERUCCHInfoTDD128t_SI = 1,
	ms40_ERUCCHInfoTDD128t_SI = 2,
	ms60_ERUCCHInfoTDD128t_SI = 3,
	ms80_ERUCCHInfoTDD128t_SI = 4,
	ms160_ERUCCHInfoTDD128t_SI = 5,
	ms200_ERUCCHInfoTDD128t_SI = 6,
};
typedef Enumerated<CONSTRAINED, 6> ERUCCHInfoTDD128t_SI;

typedef Integer<CONSTRAINED, 2, 5> ERUCCHInfoTDD128ExtendedEstimationWindow;

typedef SequenceOf<ASCSettingTDDLCRr4, CONSTRAINED, 1, maxASC> PRACHPartitioningLCRr4;

typedef PRACHPartitioningLCRr4 ERUCCHAccessServiceClass;

enum PersistenceScalingFactorValues {
	psf0_9_PersistenceScalingFactor = 0,
	psf0_8_PersistenceScalingFactor = 1,
	psf0_7_PersistenceScalingFactor = 2,
	psf0_6_PersistenceScalingFactor = 3,
	psf0_5_PersistenceScalingFactor = 4,
	psf0_4_PersistenceScalingFactor = 5,
	psf0_3_PersistenceScalingFactor = 6,
	psf0_2_PersistenceScalingFactor = 7,
};
typedef Enumerated<CONSTRAINED, 7> PersistenceScalingFactor;

typedef SequenceOf<PersistenceScalingFactor, CONSTRAINED, 1, maxASCpersist> PersistenceScalingFactorList;

typedef Integer<CONSTRAINED, 0, 62> SYNCULInfoForERUCCHPrxUpPCHdes;

typedef Integer<CONSTRAINED, 0, 3> SYNCULInfoForERUCCHPowerRampStep;

enum SYNCULInfoForERUCCHmax_SYNC_UL_TransmissionsValues {
	tr1_SYNCULInfoForERUCCHmax_SYNC_UL_Transmissions = 0,
	tr2_SYNCULInfoForERUCCHmax_SYNC_UL_Transmissions = 1,
	tr4_SYNCULInfoForERUCCHmax_SYNC_UL_Transmissions = 2,
	tr8_SYNCULInfoForERUCCHmax_SYNC_UL_Transmissions = 3,
};
typedef Enumerated<CONSTRAINED, 3> SYNCULInfoForERUCCHmax_SYNC_UL_Transmissions;

typedef BitString<CONSTRAINED, 8, 8> SyncULCodesBitmap;

typedef Integer<CONSTRAINED, 1, 32> SYNCULInfoForERUCCHMmax;

class SYNCULInfoForERUCCH : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	SYNCULInfoForERUCCH(): Sequence(&theInfo) {}

	void setSYNCULInfoForERUCCHPrxUpPCHdes(const SYNCULInfoForERUCCHPrxUpPCHdes& sYNCULInfoForERUCCHPrxUpPCHdes) { *static_cast<SYNCULInfoForERUCCHPrxUpPCHdes*>(items[0]) = sYNCULInfoForERUCCHPrxUpPCHdes; }
	void setSYNCULInfoForERUCCHPowerRampStep(const SYNCULInfoForERUCCHPowerRampStep& sYNCULInfoForERUCCHPowerRampStep) { *static_cast<SYNCULInfoForERUCCHPowerRampStep*>(items[1]) = sYNCULInfoForERUCCHPowerRampStep; }
	void setSYNCULInfoForERUCCHmax_SYNC_UL_Transmissions(const SYNCULInfoForERUCCHmax_SYNC_UL_Transmissions& sYNCULInfoForERUCCHmax_SYNC_UL_Transmissions) { *static_cast<SYNCULInfoForERUCCHmax_SYNC_UL_Transmissions*>(items[2]) = sYNCULInfoForERUCCHmax_SYNC_UL_Transmissions; }
	void setERUCCHSyncULCodesBitmap(const SyncULCodesBitmap& eRUCCHSyncULCodesBitmap) { *static_cast<SyncULCodesBitmap*>(items[3]) = eRUCCHSyncULCodesBitmap; }
	void setSYNCULInfoForERUCCHMmax(const SYNCULInfoForERUCCHMmax& sYNCULInfoForERUCCHMmax) { *static_cast<SYNCULInfoForERUCCHMmax*>(items[4]) = sYNCULInfoForERUCCHMmax; }
};

typedef Integer<CONSTRAINED, 1, 6> TimeslotNumberPRACHLCRr4;

enum TDDPRACHCCodeLCRr4Values {
	cc4_1_TDDPRACHCCodeLCRr4 = 0,
	cc4_2_TDDPRACHCCodeLCRr4 = 1,
	cc4_3_TDDPRACHCCodeLCRr4 = 2,
	cc4_4_TDDPRACHCCodeLCRr4 = 3,
	cc8_1_TDDPRACHCCodeLCRr4 = 4,
	cc8_2_TDDPRACHCCodeLCRr4 = 5,
	cc8_3_TDDPRACHCCodeLCRr4 = 6,
	cc8_4_TDDPRACHCCodeLCRr4 = 7,
	cc8_5_TDDPRACHCCodeLCRr4 = 8,
	cc8_6_TDDPRACHCCodeLCRr4 = 9,
	cc8_7_TDDPRACHCCodeLCRr4 = 10,
	cc8_8_TDDPRACHCCodeLCRr4 = 11,
	cc16_1_TDDPRACHCCodeLCRr4 = 12,
	cc16_2_TDDPRACHCCodeLCRr4 = 13,
	cc16_3_TDDPRACHCCodeLCRr4 = 14,
	cc16_4_TDDPRACHCCodeLCRr4 = 15,
	cc16_5_TDDPRACHCCodeLCRr4 = 16,
	cc16_6_TDDPRACHCCodeLCRr4 = 17,
	cc16_7_TDDPRACHCCodeLCRr4 = 18,
	cc16_8_TDDPRACHCCodeLCRr4 = 19,
	cc16_9_TDDPRACHCCodeLCRr4 = 20,
	cc16_10_TDDPRACHCCodeLCRr4 = 21,
	cc16_11_TDDPRACHCCodeLCRr4 = 22,
	cc16_12_TDDPRACHCCodeLCRr4 = 23,
	cc16_13_TDDPRACHCCodeLCRr4 = 24,
	cc16_14_TDDPRACHCCodeLCRr4 = 25,
	cc16_15_TDDPRACHCCodeLCRr4 = 26,
	cc16_16_TDDPRACHCCodeLCRr4 = 27,
};
typedef Enumerated<CONSTRAINED, 27> TDDPRACHCCodeLCRr4;

typedef SequenceOf<TDDPRACHCCodeLCRr4, CONSTRAINED, 1, 2> PRACHChanCodesListLCR;

typedef Null MidambleShiftAndBurstTypeLCRr4MidambleAllocationModeDefaultMidamble;

typedef Null MidambleShiftAndBurstTypeLCRr4MidambleAllocationModeCommonMidamble;

typedef Integer<CONSTRAINED, 0, 15> MidambleShiftAndBurstTypeLCRr4MidambleAllocationModeUeSpecificMidambleMidambleShift;

class MidambleShiftAndBurstTypeLCRr4MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeLCRr4MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShiftAndBurstTypeLCRr4MidambleAllocationModeUeSpecificMidambleMidambleShift(const MidambleShiftAndBurstTypeLCRr4MidambleAllocationModeUeSpecificMidambleMidambleShift& midambleShiftAndBurstTypeLCRr4MidambleAllocationModeUeSpecificMidambleMidambleShift) { *static_cast<MidambleShiftAndBurstTypeLCRr4MidambleAllocationModeUeSpecificMidambleMidambleShift*>(items[0]) = midambleShiftAndBurstTypeLCRr4MidambleAllocationModeUeSpecificMidambleMidambleShift; }
};

class MidambleShiftAndBurstTypeLCRr4MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MidambleShiftAndBurstTypeLCRr4MidambleAllocationModeChoices {
		midambleShiftAndBurstTypeLCRr4MidambleAllocationModeDefaultMidamble = 0,
		midambleShiftAndBurstTypeLCRr4MidambleAllocationModeCommonMidamble = 1,
		midambleShiftAndBurstTypeLCRr4MidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTypeLCRr4MidambleAllocationMode(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, 8> MidambleShiftAndBurstTypeLCRr4MidambleConfiguration;

class MidambleShiftAndBurstTypeLCRr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeLCRr4(): Sequence(&theInfo) {}

	void setMidambleShiftAndBurstTypeLCRr4MidambleAllocationMode(const MidambleShiftAndBurstTypeLCRr4MidambleAllocationMode& midambleShiftAndBurstTypeLCRr4MidambleAllocationMode) { *static_cast<MidambleShiftAndBurstTypeLCRr4MidambleAllocationMode*>(items[0]) = midambleShiftAndBurstTypeLCRr4MidambleAllocationMode; }
	void setMidambleShiftAndBurstTypeLCRr4MidambleConfiguration(const MidambleShiftAndBurstTypeLCRr4MidambleConfiguration& midambleShiftAndBurstTypeLCRr4MidambleConfiguration) { *static_cast<MidambleShiftAndBurstTypeLCRr4MidambleConfiguration*>(items[1]) = midambleShiftAndBurstTypeLCRr4MidambleConfiguration; }
};

enum TDDFPACHCCode16r4Values {
	cc16_1_TDDFPACHCCode16r4 = 0,
	cc16_2_TDDFPACHCCode16r4 = 1,
	cc16_3_TDDFPACHCCode16r4 = 2,
	cc16_4_TDDFPACHCCode16r4 = 3,
	cc16_5_TDDFPACHCCode16r4 = 4,
	cc16_6_TDDFPACHCCode16r4 = 5,
	cc16_7_TDDFPACHCCode16r4 = 6,
	cc16_8_TDDFPACHCCode16r4 = 7,
	cc16_9_TDDFPACHCCode16r4 = 8,
	cc16_10_TDDFPACHCCode16r4 = 9,
	cc16_11_TDDFPACHCCode16r4 = 10,
	cc16_12_TDDFPACHCCode16r4 = 11,
	cc16_13_TDDFPACHCCode16r4 = 12,
	cc16_14_TDDFPACHCCode16r4 = 13,
	cc16_15_TDDFPACHCCode16r4 = 14,
	cc16_16_TDDFPACHCCode16r4 = 15,
};
typedef Enumerated<CONSTRAINED, 15> TDDFPACHCCode16r4;

typedef Integer<CONSTRAINED, 1, 4> WiLCR;

class FPACHInfor4 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	FPACHInfor4(): Sequence(&theInfo) {}

	void setTimeslot(const TimeslotNumberLCRr4& timeslot) { *static_cast<TimeslotNumberLCRr4*>(items[0]) = timeslot; }
	void setChannelisationCode(const TDDFPACHCCode16r4& channelisationCode) { *static_cast<TDDFPACHCCode16r4*>(items[1]) = channelisationCode; }
	void setMidambleShiftAndBurstType(const MidambleShiftAndBurstTypeLCRr4& midambleShiftAndBurstType) { *static_cast<MidambleShiftAndBurstTypeLCRr4*>(items[2]) = midambleShiftAndBurstType; }
	void setWi(const WiLCR& wi) { *static_cast<WiLCR*>(items[3]) = wi; }
};

class PRACHInformationLCR : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	PRACHInformationLCR(): Sequence(&theInfo) {}

	void setTimeslot(const TimeslotNumberPRACHLCRr4& timeslot) { *static_cast<TimeslotNumberPRACHLCRr4*>(items[0]) = timeslot; }
	void setPrachChanCodeslistLCR(const PRACHChanCodesListLCR& prachChanCodeslistLCR) { *static_cast<PRACHChanCodesListLCR*>(items[1]) = prachChanCodeslistLCR; }
	void setMidambleShiftAndBurstType(const MidambleShiftAndBurstTypeLCRr4& midambleShiftAndBurstType) { *static_cast<MidambleShiftAndBurstTypeLCRr4*>(items[2]) = midambleShiftAndBurstType; }
	void setFpachInfo(const FPACHInfor4& fpachInfo) { *static_cast<FPACHInfor4*>(items[3]) = fpachInfo; }
};

typedef SequenceOf<PRACHInformationLCR, CONSTRAINED, 1, maxPRACH_FPACH> PRACHInformationLCRList;

class ERUCCHInfoTDD128 : public Sequence {
private:
	static const void *itemsInfo[9];
	static bool itemsPres[9];
public:
	static const Info theInfo;
	ERUCCHInfoTDD128(): Sequence(&theInfo) {}

	void setERUCCHInfoTDD128t_RUCCH(const ERUCCHInfoTDD128t_RUCCH& eRUCCHInfoTDD128t_RUCCH) { *static_cast<ERUCCHInfoTDD128t_RUCCH*>(items[0]) = eRUCCHInfoTDD128t_RUCCH; }
	void setERUCCHInfoTDD128NRUCCH(const ERUCCHInfoTDD128NRUCCH& eRUCCHInfoTDD128NRUCCH) { *static_cast<ERUCCHInfoTDD128NRUCCH*>(items[1]) = eRUCCHInfoTDD128NRUCCH; }
	void setERUCCHInfoTDD128t_WAIT(const ERUCCHInfoTDD128t_WAIT& eRUCCHInfoTDD128t_WAIT) { *static_cast<ERUCCHInfoTDD128t_WAIT*>(items[2]) = eRUCCHInfoTDD128t_WAIT; }
	void setERUCCHInfoTDD128t_SI(const ERUCCHInfoTDD128t_SI& eRUCCHInfoTDD128t_SI) { *static_cast<ERUCCHInfoTDD128t_SI*>(items[3]) = eRUCCHInfoTDD128t_SI; }
	void setERUCCHInfoTDD128ExtendedEstimationWindow(const ERUCCHInfoTDD128ExtendedEstimationWindow& eRUCCHInfoTDD128ExtendedEstimationWindow) { *static_cast<ERUCCHInfoTDD128ExtendedEstimationWindow*>(items[4]) = eRUCCHInfoTDD128ExtendedEstimationWindow; }
	void setERUCCHAccessServiceClass(const ERUCCHAccessServiceClass& eRUCCHAccessServiceClass) { *static_cast<ERUCCHAccessServiceClass*>(items[5]) = eRUCCHAccessServiceClass; }
	void setERUCCHPersistenceScalingFactor(const PersistenceScalingFactorList& eRUCCHPersistenceScalingFactor) { *static_cast<PersistenceScalingFactorList*>(items[6]) = eRUCCHPersistenceScalingFactor; }
	void setSyncULInfoForERUCCH(const SYNCULInfoForERUCCH& syncULInfoForERUCCH) { *static_cast<SYNCULInfoForERUCCH*>(items[7]) = syncULInfoForERUCCH; }
	void setPrachinformation(const PRACHInformationLCRList& prachinformation) { *static_cast<PRACHInformationLCRList*>(items[8]) = prachinformation; }
};

typedef Integer<CONSTRAINED, 0, 10> ReferenceBetaQPSKReferenceCodeRate;

typedef Integer<CONSTRAINED, -15, 16> ReferenceBetaQPSKReferenceBeta;

class ReferenceBetaQPSK : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ReferenceBetaQPSK(): Sequence(&theInfo) {}

	void setReferenceBetaQPSKReferenceCodeRate(const ReferenceBetaQPSKReferenceCodeRate& referenceBetaQPSKReferenceCodeRate) { *static_cast<ReferenceBetaQPSKReferenceCodeRate*>(items[0]) = referenceBetaQPSKReferenceCodeRate; }
	void setReferenceBetaQPSKReferenceBeta(const ReferenceBetaQPSKReferenceBeta& referenceBetaQPSKReferenceBeta) { *static_cast<ReferenceBetaQPSKReferenceBeta*>(items[1]) = referenceBetaQPSKReferenceBeta; }
};

typedef SequenceOf<ReferenceBetaQPSK, CONSTRAINED, 1, 8> ETFCSInfoReferenceBetaQPSKList;

typedef Integer<CONSTRAINED, 0, 10> ReferenceBeta16QAMReferenceCodeRate;

typedef Integer<CONSTRAINED, -15, 16> ReferenceBeta16QAMReferenceBeta;

class ReferenceBeta16QAM : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ReferenceBeta16QAM(): Sequence(&theInfo) {}

	void setReferenceBeta16QAMReferenceCodeRate(const ReferenceBeta16QAMReferenceCodeRate& referenceBeta16QAMReferenceCodeRate) { *static_cast<ReferenceBeta16QAMReferenceCodeRate*>(items[0]) = referenceBeta16QAMReferenceCodeRate; }
	void setReferenceBeta16QAMReferenceBeta(const ReferenceBeta16QAMReferenceBeta& referenceBeta16QAMReferenceBeta) { *static_cast<ReferenceBeta16QAMReferenceBeta*>(items[1]) = referenceBeta16QAMReferenceBeta; }
};

typedef SequenceOf<ReferenceBeta16QAM, CONSTRAINED, 1, 8> ETFCSInfoReferenceBeta16QAMList;

class ETFCSInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ETFCSInfo(): Sequence(&theInfo) {}

	void setETFCSInfoReferenceBetaQPSKList(const ETFCSInfoReferenceBetaQPSKList& eTFCSInfoReferenceBetaQPSKList) { *static_cast<ETFCSInfoReferenceBetaQPSKList*>(items[0]) = eTFCSInfoReferenceBetaQPSKList; }
	void setETFCSInfoReferenceBeta16QAMList(const ETFCSInfoReferenceBeta16QAMList& eTFCSInfoReferenceBeta16QAMList) { *static_cast<ETFCSInfoReferenceBeta16QAMList*>(items[1]) = eTFCSInfoReferenceBeta16QAMList; }
};

enum EPUCHInfoTDD128snpl_ReportTypeValues {
	type1_EPUCHInfoTDD128snpl_ReportType = 0,
	type2_EPUCHInfoTDD128snpl_ReportType = 1,
};
typedef Enumerated<CONSTRAINED, 1> EPUCHInfoTDD128snpl_ReportType;

typedef Integer<CONSTRAINED, -112, -50> EPUCHInfoTDD128PrxBASEdes;

typedef Boolean EPUCHInfoTDD128BeaconPLEst;

typedef Integer<CONSTRAINED, 1, 255> EPUCHInfoTDD128PebasePowerControlGAP;

typedef Integer<CONSTRAINED, 1, 8> ULSynchronisationParametersr4StepSize;

typedef Integer<CONSTRAINED, 1, 8> ULSynchronisationParametersr4Frequency;

class ULSynchronisationParametersr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULSynchronisationParametersr4(): Sequence(&theInfo) {}

	void setULSynchronisationParametersr4StepSize(const ULSynchronisationParametersr4StepSize& uLSynchronisationParametersr4StepSize) { *static_cast<ULSynchronisationParametersr4StepSize*>(items[0]) = uLSynchronisationParametersr4StepSize; }
	void setULSynchronisationParametersr4Frequency(const ULSynchronisationParametersr4Frequency& uLSynchronisationParametersr4Frequency) { *static_cast<ULSynchronisationParametersr4Frequency*>(items[1]) = uLSynchronisationParametersr4Frequency; }
};

typedef Null EPUCHTSSlotsLCRMidambleAllocationModeDefaultMidamble;

typedef Integer<CONSTRAINED, 0, 15> EPUCHTSSlotsLCRMidambleAllocationModeUeSpecificMidamble;

class EPUCHTSSlotsLCRMidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum EPUCHTSSlotsLCRMidambleAllocationModeChoices {
		ePUCHTSSlotsLCRMidambleAllocationModeDefaultMidamble = 0,
		ePUCHTSSlotsLCRMidambleAllocationModeUeSpecificMidamble = 1,
	};
	static const Info theInfo;
	EPUCHTSSlotsLCRMidambleAllocationMode(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, 8> EPUCHTSSlotsLCRMidambleConfiguration;

class EPUCHTSSlotsLCR : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	EPUCHTSSlotsLCR(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumberLCRr4& timeslotNumber) { *static_cast<TimeslotNumberLCRr4*>(items[0]) = timeslotNumber; }
	void setEPUCHTSSlotsLCRMidambleAllocationMode(const EPUCHTSSlotsLCRMidambleAllocationMode& ePUCHTSSlotsLCRMidambleAllocationMode) { *static_cast<EPUCHTSSlotsLCRMidambleAllocationMode*>(items[1]) = ePUCHTSSlotsLCRMidambleAllocationMode; }
	void setEPUCHTSSlotsLCRMidambleConfiguration(const EPUCHTSSlotsLCRMidambleConfiguration& ePUCHTSSlotsLCRMidambleConfiguration) { *static_cast<EPUCHTSSlotsLCRMidambleConfiguration*>(items[2]) = ePUCHTSSlotsLCRMidambleConfiguration; }
};

typedef SequenceOf<EPUCHTSSlotsLCR, CONSTRAINED, 1, maxTS_LCR_1> EPUCHInfoTDD128EPUCHTSConfigurationList;

typedef Integer<CONSTRAINED, 0, 63> EPUCHInfoTDD128MinimumAllowedCodeRate;

typedef Integer<CONSTRAINED, 0, 63> EPUCHInfoTDD128MaximumAllowedCodeRate;

typedef Integer<CONSTRAINED, 0, 15> EPUCHInfoTDD128MaximumNumOfRetransSchedInfo;

enum EPUCHInfoTDD128retransTimerForSchedInfoValues {
	ms10_EPUCHInfoTDD128retransTimerForSchedInfo = 0,
	ms15_EPUCHInfoTDD128retransTimerForSchedInfo = 1,
	ms20_EPUCHInfoTDD128retransTimerForSchedInfo = 2,
	ms25_EPUCHInfoTDD128retransTimerForSchedInfo = 3,
	ms30_EPUCHInfoTDD128retransTimerForSchedInfo = 4,
	ms35_EPUCHInfoTDD128retransTimerForSchedInfo = 5,
	ms40_EPUCHInfoTDD128retransTimerForSchedInfo = 6,
	ms45_EPUCHInfoTDD128retransTimerForSchedInfo = 7,
	ms50_EPUCHInfoTDD128retransTimerForSchedInfo = 8,
	ms55_EPUCHInfoTDD128retransTimerForSchedInfo = 9,
	ms60_EPUCHInfoTDD128retransTimerForSchedInfo = 10,
	ms65_EPUCHInfoTDD128retransTimerForSchedInfo = 11,
	ms70_EPUCHInfoTDD128retransTimerForSchedInfo = 12,
	ms75_EPUCHInfoTDD128retransTimerForSchedInfo = 13,
	ms80_EPUCHInfoTDD128retransTimerForSchedInfo = 14,
	ms85_EPUCHInfoTDD128retransTimerForSchedInfo = 15,
	ms90_EPUCHInfoTDD128retransTimerForSchedInfo = 16,
	ms95_EPUCHInfoTDD128retransTimerForSchedInfo = 17,
	ms100_EPUCHInfoTDD128retransTimerForSchedInfo = 18,
	ms110_EPUCHInfoTDD128retransTimerForSchedInfo = 19,
	ms120_EPUCHInfoTDD128retransTimerForSchedInfo = 20,
	ms140_EPUCHInfoTDD128retransTimerForSchedInfo = 21,
	ms160_EPUCHInfoTDD128retransTimerForSchedInfo = 22,
	ms200_EPUCHInfoTDD128retransTimerForSchedInfo = 23,
	ms240_EPUCHInfoTDD128retransTimerForSchedInfo = 24,
	ms280_EPUCHInfoTDD128retransTimerForSchedInfo = 25,
	ms320_EPUCHInfoTDD128retransTimerForSchedInfo = 26,
	ms400_EPUCHInfoTDD128retransTimerForSchedInfo = 27,
	ms480_EPUCHInfoTDD128retransTimerForSchedInfo = 28,
	ms560_EPUCHInfoTDD128retransTimerForSchedInfo = 29,
};
typedef Enumerated<CONSTRAINED, 29> EPUCHInfoTDD128retransTimerForSchedInfo;

typedef Integer<CONSTRAINED, 0, 6> EPUCHInfoTDD128Dummy;

class EPUCHInfoTDD128 : public Sequence {
private:
	static const void *itemsInfo[13];
	static bool itemsPres[13];
public:
	static const Info theInfo;
	EPUCHInfoTDD128(): Sequence(&theInfo) {}

	void setETFCSInfo(const ETFCSInfo& eTFCSInfo) { *static_cast<ETFCSInfo*>(items[0]) = eTFCSInfo; }
	void setEPUCHInfoTDD128snpl_ReportType(const EPUCHInfoTDD128snpl_ReportType& ePUCHInfoTDD128snpl_ReportType) { *static_cast<EPUCHInfoTDD128snpl_ReportType*>(items[1]) = ePUCHInfoTDD128snpl_ReportType; }
	void setEPUCHInfoTDD128PrxBASEdes(const EPUCHInfoTDD128PrxBASEdes& ePUCHInfoTDD128PrxBASEdes) { *static_cast<EPUCHInfoTDD128PrxBASEdes*>(items[2]) = ePUCHInfoTDD128PrxBASEdes; }
	void setEPUCHInfoTDD128BeaconPLEst(const EPUCHInfoTDD128BeaconPLEst& ePUCHInfoTDD128BeaconPLEst) { *static_cast<EPUCHInfoTDD128BeaconPLEst*>(items[3]) = ePUCHInfoTDD128BeaconPLEst; }
	void setTpcStepSize(const TPCStepSizeTDD& tpcStepSize) { *static_cast<TPCStepSizeTDD*>(items[4]) = tpcStepSize; }
	void setEPUCHInfoTDD128PebasePowerControlGAP(const EPUCHInfoTDD128PebasePowerControlGAP& ePUCHInfoTDD128PebasePowerControlGAP) { *static_cast<EPUCHInfoTDD128PebasePowerControlGAP*>(items[5]) = ePUCHInfoTDD128PebasePowerControlGAP; }
	void setUlSynchronisationParameters(const ULSynchronisationParametersr4& ulSynchronisationParameters) { *static_cast<ULSynchronisationParametersr4*>(items[6]) = ulSynchronisationParameters; }
	void setEPUCHInfoTDD128EPUCHTSConfigurationList(const EPUCHInfoTDD128EPUCHTSConfigurationList& ePUCHInfoTDD128EPUCHTSConfigurationList) { *static_cast<EPUCHInfoTDD128EPUCHTSConfigurationList*>(items[7]) = ePUCHInfoTDD128EPUCHTSConfigurationList; }
	void setEPUCHInfoTDD128MinimumAllowedCodeRate(const EPUCHInfoTDD128MinimumAllowedCodeRate& ePUCHInfoTDD128MinimumAllowedCodeRate) { *static_cast<EPUCHInfoTDD128MinimumAllowedCodeRate*>(items[8]) = ePUCHInfoTDD128MinimumAllowedCodeRate; }
	void setEPUCHInfoTDD128MaximumAllowedCodeRate(const EPUCHInfoTDD128MaximumAllowedCodeRate& ePUCHInfoTDD128MaximumAllowedCodeRate) { *static_cast<EPUCHInfoTDD128MaximumAllowedCodeRate*>(items[9]) = ePUCHInfoTDD128MaximumAllowedCodeRate; }
	void setEPUCHInfoTDD128MaximumNumOfRetransSchedInfo(const EPUCHInfoTDD128MaximumNumOfRetransSchedInfo& ePUCHInfoTDD128MaximumNumOfRetransSchedInfo) { *static_cast<EPUCHInfoTDD128MaximumNumOfRetransSchedInfo*>(items[10]) = ePUCHInfoTDD128MaximumNumOfRetransSchedInfo; }
	void setEPUCHInfoTDD128retransTimerForSchedInfo(const EPUCHInfoTDD128retransTimerForSchedInfo& ePUCHInfoTDD128retransTimerForSchedInfo) { *static_cast<EPUCHInfoTDD128retransTimerForSchedInfo*>(items[11]) = ePUCHInfoTDD128retransTimerForSchedInfo; }
	void setEPUCHInfoTDD128Dummy(const EPUCHInfoTDD128Dummy& ePUCHInfoTDD128Dummy) { *static_cast<EPUCHInfoTDD128Dummy*>(items[12]) = ePUCHInfoTDD128Dummy; }
};

typedef Integer<CONSTRAINED, 4, 15> EHICHInformationTDD128NEHICH;

typedef Integer<CONSTRAINED, 0, 3> EHICHInformationLCREi;

typedef Null EHICHInformationLCRMidambleAllocationModeDefaultMidamble;

typedef Integer<CONSTRAINED, 0, 15> EHICHInformationLCRMidambleAllocationModeUeSpecificMidamble;

class EHICHInformationLCRMidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum EHICHInformationLCRMidambleAllocationModeChoices {
		eHICHInformationLCRMidambleAllocationModeDefaultMidamble = 0,
		eHICHInformationLCRMidambleAllocationModeUeSpecificMidamble = 1,
	};
	static const Info theInfo;
	EHICHInformationLCRMidambleAllocationMode(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, 8> EHICHInformationLCRMidambleConfiguration;

class EHICHInformationLCR : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	EHICHInformationLCR(): Sequence(&theInfo) {}

	void setEHICHInformationLCREi(const EHICHInformationLCREi& eHICHInformationLCREi) { *static_cast<EHICHInformationLCREi*>(items[0]) = eHICHInformationLCREi; }
	void setTimeslotNumber(const TimeslotNumberLCRr4& timeslotNumber) { *static_cast<TimeslotNumberLCRr4*>(items[1]) = timeslotNumber; }
	void setChannelisationCode(const HSChannelisationCodeLCR& channelisationCode) { *static_cast<HSChannelisationCodeLCR*>(items[2]) = channelisationCode; }
	void setEHICHInformationLCRMidambleAllocationMode(const EHICHInformationLCRMidambleAllocationMode& eHICHInformationLCRMidambleAllocationMode) { *static_cast<EHICHInformationLCRMidambleAllocationMode*>(items[3]) = eHICHInformationLCRMidambleAllocationMode; }
	void setEHICHInformationLCRMidambleConfiguration(const EHICHInformationLCRMidambleConfiguration& eHICHInformationLCRMidambleConfiguration) { *static_cast<EHICHInformationLCRMidambleConfiguration*>(items[4]) = eHICHInformationLCRMidambleConfiguration; }
};

typedef SequenceOf<EHICHInformationLCR, CONSTRAINED, 1, maxNumE_HICH> EHICHInformationLCRList;

class EHICHInformationTDD128 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EHICHInformationTDD128(): Sequence(&theInfo) {}

	void setEHICHInformationTDD128NEHICH(const EHICHInformationTDD128NEHICH& eHICHInformationTDD128NEHICH) { *static_cast<EHICHInformationTDD128NEHICH*>(items[0]) = eHICHInformationTDD128NEHICH; }
	void setEHICHInfoList(const EHICHInformationLCRList& eHICHInfoList) { *static_cast<EHICHInformationLCRList*>(items[1]) = eHICHInfoList; }
};

typedef Boolean EAGCHInformationTDD128RdiIndicator;

typedef Null EAGCHIndividualLCRMidambleAllocationModeDefaultMidamble;

typedef Null EAGCHIndividualLCRMidambleAllocationModeCommonMidamble;

typedef Integer<CONSTRAINED, 0, 15> EAGCHIndividualLCRMidambleAllocationModeUeSpecificMidamble;

class EAGCHIndividualLCRMidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum EAGCHIndividualLCRMidambleAllocationModeChoices {
		eAGCHIndividualLCRMidambleAllocationModeDefaultMidamble = 0,
		eAGCHIndividualLCRMidambleAllocationModeCommonMidamble = 1,
		eAGCHIndividualLCRMidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	EAGCHIndividualLCRMidambleAllocationMode(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, 8> EAGCHIndividualLCRMidambleConfiguration;

class EAGCHIndividualLCR : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	EAGCHIndividualLCR(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumberLCRr4& timeslotNumber) { *static_cast<TimeslotNumberLCRr4*>(items[0]) = timeslotNumber; }
	void setFirstChannelisationCode(const HSChannelisationCodeLCR& firstChannelisationCode) { *static_cast<HSChannelisationCodeLCR*>(items[1]) = firstChannelisationCode; }
	void setSecondChannelisationCode(const HSChannelisationCodeLCR& secondChannelisationCode) { *static_cast<HSChannelisationCodeLCR*>(items[2]) = secondChannelisationCode; }
	void setEAGCHIndividualLCRMidambleAllocationMode(const EAGCHIndividualLCRMidambleAllocationMode& eAGCHIndividualLCRMidambleAllocationMode) { *static_cast<EAGCHIndividualLCRMidambleAllocationMode*>(items[3]) = eAGCHIndividualLCRMidambleAllocationMode; }
	void setEAGCHIndividualLCRMidambleConfiguration(const EAGCHIndividualLCRMidambleConfiguration& eAGCHIndividualLCRMidambleConfiguration) { *static_cast<EAGCHIndividualLCRMidambleConfiguration*>(items[4]) = eAGCHIndividualLCRMidambleConfiguration; }
};

typedef SequenceOf<EAGCHIndividualLCR, CONSTRAINED, 1, maxNumE_AGCH> EAGCHSetConfigLCR;

class EAGCHInformationTDD128 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	EAGCHInformationTDD128(): Sequence(&theInfo) {}

	void setEAGCHInformationTDD128RdiIndicator(const EAGCHInformationTDD128RdiIndicator& eAGCHInformationTDD128RdiIndicator) { *static_cast<EAGCHInformationTDD128RdiIndicator*>(items[0]) = eAGCHInformationTDD128RdiIndicator; }
	void setTpcStepSize(const TPCStepSizeTDD& tpcStepSize) { *static_cast<TPCStepSizeTDD*>(items[1]) = tpcStepSize; }
	void setEAGCHSetConfig(const EAGCHSetConfigLCR& eAGCHSetConfig) { *static_cast<EAGCHSetConfigLCR*>(items[2]) = eAGCHSetConfig; }
	void setEAGCHBLERTarget(const BlerTarget& eAGCHBLERTarget) { *static_cast<BlerTarget*>(items[3]) = eAGCHBLERTarget; }
};

enum CommonEDCHSystemInfoModeSpecificInfoTddTdd128harq_InfoValues {
	rv0_CommonEDCHSystemInfoModeSpecificInfoTddTdd128harq_Info = 0,
	rvtable_CommonEDCHSystemInfoModeSpecificInfoTddTdd128harq_Info = 1,
};
typedef Enumerated<CONSTRAINED, 1> CommonEDCHSystemInfoModeSpecificInfoTddTdd128harq_Info;

typedef Integer<CONSTRAINED, 0, 7> CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoHarqMaximumNumberOfRetransmissions;

enum CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timerValues {
	ms10_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 0,
	ms15_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 1,
	ms20_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 2,
	ms25_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 3,
	ms30_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 4,
	ms35_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 5,
	ms40_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 6,
	ms45_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 7,
	ms50_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 8,
	ms55_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 9,
	ms60_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 10,
	ms65_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 11,
	ms70_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 12,
	ms75_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 13,
	ms80_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 14,
	ms85_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 15,
	ms90_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 16,
	ms95_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 17,
	ms100_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 18,
	ms110_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 19,
	ms120_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 20,
	ms140_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 21,
	ms160_CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer = 22,
};
typedef Enumerated<CONSTRAINED, 22> CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer;

typedef Integer<CONSTRAINED, 0, 6> CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoHarqpoweroffset;

class CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfo : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfo(): Sequence(&theInfo) {}

	void setCommonerntiInfo(const CommonERNTIInfo& commonerntiInfo) { *static_cast<CommonERNTIInfo*>(items[0]) = commonerntiInfo; }
	void setCommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoHarqMaximumNumberOfRetransmissions(const CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoHarqMaximumNumberOfRetransmissions& commonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoHarqMaximumNumberOfRetransmissions) { *static_cast<CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoHarqMaximumNumberOfRetransmissions*>(items[1]) = commonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoHarqMaximumNumberOfRetransmissions; }
	void setCommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer(const CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer& commonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer) { *static_cast<CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer*>(items[2]) = commonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoharq_retransmission_timer; }
	void setCommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoHarqpoweroffset(const CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoHarqpoweroffset& commonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoHarqpoweroffset) { *static_cast<CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoHarqpoweroffset*>(items[3]) = commonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfoHarqpoweroffset; }
};

class CommonEDCHSystemInfoModeSpecificInfoTddTdd128 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	CommonEDCHSystemInfoModeSpecificInfoTddTdd128(): Sequence(&theInfo) {}

	void setERUCCHInfo(const ERUCCHInfoTDD128& eRUCCHInfo) { *static_cast<ERUCCHInfoTDD128*>(items[0]) = eRUCCHInfo; }
	void setEPUCHInfo(const EPUCHInfoTDD128& ePUCHInfo) { *static_cast<EPUCHInfoTDD128*>(items[1]) = ePUCHInfo; }
	void setEhichInformation(const EHICHInformationTDD128& ehichInformation) { *static_cast<EHICHInformationTDD128*>(items[2]) = ehichInformation; }
	void setEagchInformation(const EAGCHInformationTDD128& eagchInformation) { *static_cast<EAGCHInformationTDD128*>(items[3]) = eagchInformation; }
	void setCommonEDCHSystemInfoModeSpecificInfoTddTdd128harq_Info(const CommonEDCHSystemInfoModeSpecificInfoTddTdd128harq_Info& commonEDCHSystemInfoModeSpecificInfoTddTdd128harq_Info) { *static_cast<CommonEDCHSystemInfoModeSpecificInfoTddTdd128harq_Info*>(items[4]) = commonEDCHSystemInfoModeSpecificInfoTddTdd128harq_Info; }
	void setCommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfo(const CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfo& commonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfo) { *static_cast<CommonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfo*>(items[5]) = commonEDCHSystemInfoModeSpecificInfoTddTdd128CcchtransmissionInfo; }
};

class CommonEDCHSystemInfoModeSpecificInfoTdd : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum CommonEDCHSystemInfoModeSpecificInfoTddChoices {
		commonEDCHSystemInfoModeSpecificInfoTddTdd768 = 0,
		commonEDCHSystemInfoModeSpecificInfoTddTdd384 = 1,
		commonEDCHSystemInfoModeSpecificInfoTddTdd128 = 2,
	};
	static const Info theInfo;
	CommonEDCHSystemInfoModeSpecificInfoTdd(): Choice(&theInfo) {}
};

class CommonEDCHSystemInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CommonEDCHSystemInfoModeSpecificInfoChoices {
		commonEDCHSystemInfoModeSpecificInfoDummy = 0,
		commonEDCHSystemInfoModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	CommonEDCHSystemInfoModeSpecificInfo(): Choice(&theInfo) {}
};

class CommonEDCHSystemInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CommonEDCHSystemInfo(): Sequence(&theInfo) {}

	void setUlInterferenceForCommonEDCH(const ULInterference& ulInterferenceForCommonEDCH) { *static_cast<ULInterference*>(items[0]) = ulInterferenceForCommonEDCH; }
	void setCommonEDCHMACdFlowList(const CommonEDCHMACdFlowList& commonEDCHMACdFlowList) { *static_cast<CommonEDCHMACdFlowList*>(items[1]) = commonEDCHMACdFlowList; }
	void setCommonEDCHSystemInfoModeSpecificInfo(const CommonEDCHSystemInfoModeSpecificInfo& commonEDCHSystemInfoModeSpecificInfo) { *static_cast<CommonEDCHSystemInfoModeSpecificInfo*>(items[2]) = commonEDCHSystemInfoModeSpecificInfo; }
};

typedef Boolean PRACHPreambleForEnhancedUplinkEaiIndication;

typedef Integer<CONSTRAINED, 0, 15> PreambleScramblingCodeWordNumber;

typedef SequenceOf<ASCSettingFDD, CONSTRAINED, 1, maxASC> PRACHPartitioningr7Fdd;

typedef SequenceOf<ASCSettingTDDr7, CONSTRAINED, 1, maxASC> PRACHPartitioningr7Tdd;

class PRACHPartitioningr7 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PRACHPartitioningr7Choices {
		pRACHPartitioningr7Fdd = 0,
		pRACHPartitioningr7Tdd = 1,
	};
	static const Info theInfo;
	PRACHPartitioningr7(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, -10, 50> PrimaryCPICHTXPower;

typedef Integer<CONSTRAINED, 1, 8> PowerRampStep;

typedef Integer<CONSTRAINED, 1, 64> PreambleRetransMax;

class PRACHPowerOffset : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PRACHPowerOffset(): Sequence(&theInfo) {}

	void setPowerRampStep(const PowerRampStep& powerRampStep) { *static_cast<PowerRampStep*>(items[0]) = powerRampStep; }
	void setPreambleRetransMax(const PreambleRetransMax& preambleRetransMax) { *static_cast<PreambleRetransMax*>(items[1]) = preambleRetransMax; }
};

typedef Integer<CONSTRAINED, 1, 32> RACHTransmissionParametersMmax;

typedef Integer<CONSTRAINED, 0, 50> NB01;

class RACHTransmissionParameters : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	RACHTransmissionParameters(): Sequence(&theInfo) {}

	void setRACHTransmissionParametersMmax(const RACHTransmissionParametersMmax& rACHTransmissionParametersMmax) { *static_cast<RACHTransmissionParametersMmax*>(items[0]) = rACHTransmissionParametersMmax; }
	void setNb01Min(const NB01& nb01Min) { *static_cast<NB01*>(items[1]) = nb01Min; }
	void setNb01Max(const NB01& nb01Max) { *static_cast<NB01*>(items[2]) = nb01Max; }
};

typedef Integer<CONSTRAINED, -5, 10> PRACHPreambleForEnhancedUplinkPowerOffsetPpe;

class PRACHPreambleForEnhancedUplink : public Sequence {
private:
	static const void *itemsInfo[13];
	static bool itemsPres[13];
public:
	static const Info theInfo;
	PRACHPreambleForEnhancedUplink(): Sequence(&theInfo) {}

	void setAvailableSignatures(const AvailableSignatures& availableSignatures) { *static_cast<AvailableSignatures*>(items[0]) = availableSignatures; }
	void setPRACHPreambleForEnhancedUplinkEaiIndication(const PRACHPreambleForEnhancedUplinkEaiIndication& pRACHPreambleForEnhancedUplinkEaiIndication) { *static_cast<PRACHPreambleForEnhancedUplinkEaiIndication*>(items[1]) = pRACHPreambleForEnhancedUplinkEaiIndication; }
	void setPreambleScramblingCodeWordNumber(const PreambleScramblingCodeWordNumber& preambleScramblingCodeWordNumber) { *static_cast<PreambleScramblingCodeWordNumber*>(items[2]) = preambleScramblingCodeWordNumber; }
	void setAvailableSubChannelNumbers(const AvailableSubChannelNumbers& availableSubChannelNumbers) { *static_cast<AvailableSubChannelNumbers*>(items[3]) = availableSubChannelNumbers; }
	void setPrachPartitioning(const PRACHPartitioningr7& prachPartitioning) { *static_cast<PRACHPartitioningr7*>(items[4]) = prachPartitioning; }
	void setPersistenceScalingFactorList(const PersistenceScalingFactorList& persistenceScalingFactorList) { *static_cast<PersistenceScalingFactorList*>(items[5]) = persistenceScalingFactorList; }
	void setAcToASCMappingTable(const ACToASCMappingTable& acToASCMappingTable) { *static_cast<ACToASCMappingTable*>(items[6]) = acToASCMappingTable; }
	void setPrimaryCPICHTXPower(const PrimaryCPICHTXPower& primaryCPICHTXPower) { *static_cast<PrimaryCPICHTXPower*>(items[7]) = primaryCPICHTXPower; }
	void setConstantValue(const ConstantValue& constantValue) { *static_cast<ConstantValue*>(items[8]) = constantValue; }
	void setPrachPowerOffset(const PRACHPowerOffset& prachPowerOffset) { *static_cast<PRACHPowerOffset*>(items[9]) = prachPowerOffset; }
	void setRachTransmissionParameters(const RACHTransmissionParameters& rachTransmissionParameters) { *static_cast<RACHTransmissionParameters*>(items[10]) = rachTransmissionParameters; }
	void setAichInfo(const AICHInfo& aichInfo) { *static_cast<AICHInfo*>(items[11]) = aichInfo; }
	void setPRACHPreambleForEnhancedUplinkPowerOffsetPpe(const PRACHPreambleForEnhancedUplinkPowerOffsetPpe& pRACHPreambleForEnhancedUplinkPowerOffsetPpe) { *static_cast<PRACHPreambleForEnhancedUplinkPowerOffsetPpe*>(items[12]) = pRACHPreambleForEnhancedUplinkPowerOffsetPpe; }
};

typedef Integer<CONSTRAINED, 0, 37> CommonEDCHSystemInfoFDDInitialServingGrantValue;

enum CommonEDCHSystemInfoFDDharq_InfoValues {
	rv0_CommonEDCHSystemInfoFDDharq_Info = 0,
	rvtable_CommonEDCHSystemInfoFDDharq_Info = 1,
};
typedef Enumerated<CONSTRAINED, 1> CommonEDCHSystemInfoFDDharq_Info;

class ULDPCHpowerControlInfoForCommonEDCH : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	ULDPCHpowerControlInfoForCommonEDCH(): Sequence(&theInfo) {}

	void setPowerControlAlgorithm(const PowerControlAlgorithm& powerControlAlgorithm) { *static_cast<PowerControlAlgorithm*>(items[0]) = powerControlAlgorithm; }
	void setDeltaACK(const DeltaACK& deltaACK) { *static_cast<DeltaACK*>(items[1]) = deltaACK; }
	void setDeltaNACK(const DeltaNACK& deltaNACK) { *static_cast<DeltaNACK*>(items[2]) = deltaNACK; }
	void setAckNACKrepetitionfactor(const ACKNACKrepetitionFactor& ackNACKrepetitionfactor) { *static_cast<ACKNACKrepetitionFactor*>(items[3]) = ackNACKrepetitionfactor; }
};

typedef Integer<CONSTRAINED, 0, 8> EDPCCHDPCCHPowerOffset;

enum HappyBitDelayConditionValues {
	ms2_HappyBitDelayCondition = 0,
	ms10_HappyBitDelayCondition = 1,
	ms20_HappyBitDelayCondition = 2,
	ms50_HappyBitDelayCondition = 3,
	ms100_HappyBitDelayCondition = 4,
	ms200_HappyBitDelayCondition = 5,
	ms500_HappyBitDelayCondition = 6,
	ms1000_HappyBitDelayCondition = 7,
};
typedef Enumerated<CONSTRAINED, 7> HappyBitDelayCondition;

typedef Integer<CONSTRAINED, 0, 127> ETFCBoostInfor7ETFCIBoost;

typedef Integer<CONSTRAINED, 0, 6> ETFCBoostInfor7DeltaT2TP;

class ETFCBoostInfor7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ETFCBoostInfor7(): Sequence(&theInfo) {}

	void setETFCBoostInfor7ETFCIBoost(const ETFCBoostInfor7ETFCIBoost& eTFCBoostInfor7ETFCIBoost) { *static_cast<ETFCBoostInfor7ETFCIBoost*>(items[0]) = eTFCBoostInfor7ETFCIBoost; }
	void setETFCBoostInfor7DeltaT2TP(const ETFCBoostInfor7DeltaT2TP& eTFCBoostInfor7DeltaT2TP) { *static_cast<ETFCBoostInfor7DeltaT2TP*>(items[1]) = eTFCBoostInfor7DeltaT2TP; }
};

typedef Boolean EDPDCHPowerInterpolation;

class EDPCCHInfor7 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	EDPCCHInfor7(): Sequence(&theInfo) {}

	void setEDPCCHDPCCHPowerOffset(const EDPCCHDPCCHPowerOffset& eDPCCHDPCCHPowerOffset) { *static_cast<EDPCCHDPCCHPowerOffset*>(items[0]) = eDPCCHDPCCHPowerOffset; }
	void setHappyBitDelayCondition(const HappyBitDelayCondition& happyBitDelayCondition) { *static_cast<HappyBitDelayCondition*>(items[1]) = happyBitDelayCondition; }
	void setETFCBoostInfo(const ETFCBoostInfor7& eTFCBoostInfo) { *static_cast<ETFCBoostInfor7*>(items[2]) = eTFCBoostInfo; }
	void setEDPDCHPowerInterpolation(const EDPDCHPowerInterpolation& eDPDCHPowerInterpolation) { *static_cast<EDPDCHPowerInterpolation*>(items[3]) = eDPDCHPowerInterpolation; }
};

typedef Integer<CONSTRAINED, 0, 1> ETFCITableIndex;

typedef Integer<CONSTRAINED, 0, 127> EDPDCHReferenceETFCIr7ReferenceETFCI;

typedef Integer<CONSTRAINED, 0, 31> EDPDCHReferenceETFCIr7ReferenceETFCIPOr7;

class EDPDCHReferenceETFCIr7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EDPDCHReferenceETFCIr7(): Sequence(&theInfo) {}

	void setEDPDCHReferenceETFCIr7ReferenceETFCI(const EDPDCHReferenceETFCIr7ReferenceETFCI& eDPDCHReferenceETFCIr7ReferenceETFCI) { *static_cast<EDPDCHReferenceETFCIr7ReferenceETFCI*>(items[0]) = eDPDCHReferenceETFCIr7ReferenceETFCI; }
	void setEDPDCHReferenceETFCIr7ReferenceETFCIPOr7(const EDPDCHReferenceETFCIr7ReferenceETFCIPOr7& eDPDCHReferenceETFCIr7ReferenceETFCIPOr7) { *static_cast<EDPDCHReferenceETFCIr7ReferenceETFCIPOr7*>(items[1]) = eDPDCHReferenceETFCIr7ReferenceETFCIPOr7; }
};

typedef SequenceOf<EDPDCHReferenceETFCIr7, CONSTRAINED, 1, 8> EDPDCHReferenceETFCIListr7;

enum EDPDCHMaxChannelisationCodesValues {
	sf256_EDPDCHMaxChannelisationCodes = 0,
	sf128_EDPDCHMaxChannelisationCodes = 1,
	sf64_EDPDCHMaxChannelisationCodes = 2,
	sf32_EDPDCHMaxChannelisationCodes = 3,
	sf16_EDPDCHMaxChannelisationCodes = 4,
	sf8_EDPDCHMaxChannelisationCodes = 5,
	sf4_EDPDCHMaxChannelisationCodes = 6,
	sf4x2_EDPDCHMaxChannelisationCodes = 7,
	sf2x2_EDPDCHMaxChannelisationCodes = 8,
	sf4x2_and_sf2x2_EDPDCHMaxChannelisationCodes = 9,
};
typedef Enumerated<CONSTRAINED, 9> EDPDCHMaxChannelisationCodes;

typedef Integer<CONSTRAINED, 11, 25> EDPDCHPLNonMax;

enum EDPDCHPeriodicyOfSchedInfoValues {
	everyEDCHTTI_EDPDCHPeriodicyOfSchedInfo = 0,
	ms4_EDPDCHPeriodicyOfSchedInfo = 1,
	ms10_EDPDCHPeriodicyOfSchedInfo = 2,
	ms20_EDPDCHPeriodicyOfSchedInfo = 3,
	ms50_EDPDCHPeriodicyOfSchedInfo = 4,
	ms100_EDPDCHPeriodicyOfSchedInfo = 5,
	ms200_EDPDCHPeriodicyOfSchedInfo = 6,
	ms500_EDPDCHPeriodicyOfSchedInfo = 7,
	ms1000_EDPDCHPeriodicyOfSchedInfo = 8,
};
typedef Enumerated<CONSTRAINED, 8> EDPDCHPeriodicyOfSchedInfo;

typedef Integer<CONSTRAINED, 0, 6> EDPDCHSchedulingInfoConfigurationPowerOffsetForSchedInfo;

class EDPDCHSchedulingInfoConfiguration : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	EDPDCHSchedulingInfoConfiguration(): Sequence(&theInfo) {}

	void setPeriodicityOfSchedInfoNoGrant(const EDPDCHPeriodicyOfSchedInfo& periodicityOfSchedInfoNoGrant) { *static_cast<EDPDCHPeriodicyOfSchedInfo*>(items[0]) = periodicityOfSchedInfoNoGrant; }
	void setPeriodicityOfSchedInfoGrant(const EDPDCHPeriodicyOfSchedInfo& periodicityOfSchedInfoGrant) { *static_cast<EDPDCHPeriodicyOfSchedInfo*>(items[1]) = periodicityOfSchedInfoGrant; }
	void setEDPDCHSchedulingInfoConfigurationPowerOffsetForSchedInfo(const EDPDCHSchedulingInfoConfigurationPowerOffsetForSchedInfo& eDPDCHSchedulingInfoConfigurationPowerOffsetForSchedInfo) { *static_cast<EDPDCHSchedulingInfoConfigurationPowerOffsetForSchedInfo*>(items[2]) = eDPDCHSchedulingInfoConfigurationPowerOffsetForSchedInfo; }
};

typedef Integer<CONSTRAINED, 0, 37> EDPDCHInfor8ThreeIndexStepThreshold;

typedef Integer<CONSTRAINED, 0, 37> EDPDCHInfor8TwoIndexStepThreshold;

class EDPDCHInfor8 : public Sequence {
private:
	static const void *itemsInfo[9];
	static bool itemsPres[9];
public:
	static const Info theInfo;
	EDPDCHInfor8(): Sequence(&theInfo) {}

	void setETFCITableIndex(const ETFCITableIndex& eTFCITableIndex) { *static_cast<ETFCITableIndex*>(items[0]) = eTFCITableIndex; }
	void setEDCHMinimumSetETFCI(const EDCHMinimumSetETFCI& eDCHMinimumSetETFCI) { *static_cast<EDCHMinimumSetETFCI*>(items[1]) = eDCHMinimumSetETFCI; }
	void setReferenceETFCIs(const EDPDCHReferenceETFCIListr7& referenceETFCIs) { *static_cast<EDPDCHReferenceETFCIListr7*>(items[2]) = referenceETFCIs; }
	void setMinReducedEDPDCHGainFactor(const MinReducedEDPDCHGainFactor& minReducedEDPDCHGainFactor) { *static_cast<MinReducedEDPDCHGainFactor*>(items[3]) = minReducedEDPDCHGainFactor; }
	void setMaxChannelisationCodes(const EDPDCHMaxChannelisationCodes& maxChannelisationCodes) { *static_cast<EDPDCHMaxChannelisationCodes*>(items[4]) = maxChannelisationCodes; }
	void setPlNonMax(const EDPDCHPLNonMax& plNonMax) { *static_cast<EDPDCHPLNonMax*>(items[5]) = plNonMax; }
	void setSchedulingInfoConfiguration(const EDPDCHSchedulingInfoConfiguration& schedulingInfoConfiguration) { *static_cast<EDPDCHSchedulingInfoConfiguration*>(items[6]) = schedulingInfoConfiguration; }
	void setEDPDCHInfor8ThreeIndexStepThreshold(const EDPDCHInfor8ThreeIndexStepThreshold& eDPDCHInfor8ThreeIndexStepThreshold) { *static_cast<EDPDCHInfor8ThreeIndexStepThreshold*>(items[7]) = eDPDCHInfor8ThreeIndexStepThreshold; }
	void setEDPDCHInfor8TwoIndexStepThreshold(const EDPDCHInfor8TwoIndexStepThreshold& eDPDCHInfor8TwoIndexStepThreshold) { *static_cast<EDPDCHInfor8TwoIndexStepThreshold*>(items[8]) = eDPDCHInfor8TwoIndexStepThreshold; }
};

typedef Integer<CONSTRAINED, 1, 10> CommonEDCHSystemInfoFDDDlFDPCHTPCcommandErrorRate;

typedef Integer<CONSTRAINED, 0, 15> CommonEDCHSystemInfoFDDAdditionalEDCHTransmitBackoff;

enum CommonEDCHSystemInfoFDDmax_CCCH_ResourceAllocationValues {
	tti8_CommonEDCHSystemInfoFDDmax_CCCH_ResourceAllocation = 0,
	tti12_CommonEDCHSystemInfoFDDmax_CCCH_ResourceAllocation = 1,
	tti16_CommonEDCHSystemInfoFDDmax_CCCH_ResourceAllocation = 2,
	tti20_CommonEDCHSystemInfoFDDmax_CCCH_ResourceAllocation = 3,
	tti24_CommonEDCHSystemInfoFDDmax_CCCH_ResourceAllocation = 4,
	tti32_CommonEDCHSystemInfoFDDmax_CCCH_ResourceAllocation = 5,
	tti40_CommonEDCHSystemInfoFDDmax_CCCH_ResourceAllocation = 6,
	tti80_CommonEDCHSystemInfoFDDmax_CCCH_ResourceAllocation = 7,
};
typedef Enumerated<CONSTRAINED, 7> CommonEDCHSystemInfoFDDmax_CCCH_ResourceAllocation;

typedef Integer<CONSTRAINED, 8, 24> CommonEDCHSystemInfoFDDMaxPeriodForCollisionResolution;

enum CommonEDCHSystemInfoFDDe_dch_TransmitContinuationOffsetValues {
	tti0_CommonEDCHSystemInfoFDDe_dch_TransmitContinuationOffset = 0,
	tti4_CommonEDCHSystemInfoFDDe_dch_TransmitContinuationOffset = 1,
	tti8_CommonEDCHSystemInfoFDDe_dch_TransmitContinuationOffset = 2,
	tti16_CommonEDCHSystemInfoFDDe_dch_TransmitContinuationOffset = 3,
	tti24_CommonEDCHSystemInfoFDDe_dch_TransmitContinuationOffset = 4,
	tti40_CommonEDCHSystemInfoFDDe_dch_TransmitContinuationOffset = 5,
	tti80_CommonEDCHSystemInfoFDDe_dch_TransmitContinuationOffset = 6,
	infinity_CommonEDCHSystemInfoFDDe_dch_TransmitContinuationOffset = 7,
};
typedef Enumerated<CONSTRAINED, 7> CommonEDCHSystemInfoFDDe_dch_TransmitContinuationOffset;

typedef Boolean CommonEDCHSystemInfoFDDAcknacksupportonHSDPCCH;

typedef SequenceOf<CommonEDCHResourceInfoList, CONSTRAINED, 1, maxEDCHs> CommonEDCHSystemInfoFDDCommonEDCHResourceInfoList;

class CommonEDCHSystemInfoFDD : public Sequence {
private:
	static const void *itemsInfo[18];
	static bool itemsPres[18];
public:
	static const Info theInfo;
	CommonEDCHSystemInfoFDD(): Sequence(&theInfo) {}

	void setUlInterferenceForCommonEDCH(const ULInterference& ulInterferenceForCommonEDCH) { *static_cast<ULInterference*>(items[0]) = ulInterferenceForCommonEDCH; }
	void setCommonEDCHMACdFlowList(const CommonEDCHMACdFlowList& commonEDCHMACdFlowList) { *static_cast<CommonEDCHMACdFlowList*>(items[1]) = commonEDCHMACdFlowList; }
	void setPrachPreambleForEnhancedUplink(const PRACHPreambleForEnhancedUplink& prachPreambleForEnhancedUplink) { *static_cast<PRACHPreambleForEnhancedUplink*>(items[2]) = prachPreambleForEnhancedUplink; }
	void setCommonEDCHSystemInfoFDDInitialServingGrantValue(const CommonEDCHSystemInfoFDDInitialServingGrantValue& commonEDCHSystemInfoFDDInitialServingGrantValue) { *static_cast<CommonEDCHSystemInfoFDDInitialServingGrantValue*>(items[3]) = commonEDCHSystemInfoFDDInitialServingGrantValue; }
	void setEdchTTI(const EDCHTTI& edchTTI) { *static_cast<EDCHTTI*>(items[4]) = edchTTI; }
	void setEagchInformation(const EAGCHInformation& eagchInformation) { *static_cast<EAGCHInformation*>(items[5]) = eagchInformation; }
	void setCommonEDCHSystemInfoFDDharq_Info(const CommonEDCHSystemInfoFDDharq_Info& commonEDCHSystemInfoFDDharq_Info) { *static_cast<CommonEDCHSystemInfoFDDharq_Info*>(items[6]) = commonEDCHSystemInfoFDDharq_Info; }
	void setUlDPCHpowerControlInfoForCommonEDCH(const ULDPCHpowerControlInfoForCommonEDCH& ulDPCHpowerControlInfoForCommonEDCH) { *static_cast<ULDPCHpowerControlInfoForCommonEDCH*>(items[7]) = ulDPCHpowerControlInfoForCommonEDCH; }
	void setEdpcchInfo(const EDPCCHInfor7& edpcchInfo) { *static_cast<EDPCCHInfor7*>(items[8]) = edpcchInfo; }
	void setEdpdchInfo(const EDPDCHInfor8& edpdchInfo) { *static_cast<EDPDCHInfor8*>(items[9]) = edpdchInfo; }
	void setCommonEDCHSystemInfoFDDDlFDPCHTPCcommandErrorRate(const CommonEDCHSystemInfoFDDDlFDPCHTPCcommandErrorRate& commonEDCHSystemInfoFDDDlFDPCHTPCcommandErrorRate) { *static_cast<CommonEDCHSystemInfoFDDDlFDPCHTPCcommandErrorRate*>(items[10]) = commonEDCHSystemInfoFDDDlFDPCHTPCcommandErrorRate; }
	void setCommonEDCHSystemInfoFDDAdditionalEDCHTransmitBackoff(const CommonEDCHSystemInfoFDDAdditionalEDCHTransmitBackoff& commonEDCHSystemInfoFDDAdditionalEDCHTransmitBackoff) { *static_cast<CommonEDCHSystemInfoFDDAdditionalEDCHTransmitBackoff*>(items[11]) = commonEDCHSystemInfoFDDAdditionalEDCHTransmitBackoff; }
	void setCommonEDCHSystemInfoFDDmax_CCCH_ResourceAllocation(const CommonEDCHSystemInfoFDDmax_CCCH_ResourceAllocation& commonEDCHSystemInfoFDDmax_CCCH_ResourceAllocation) { *static_cast<CommonEDCHSystemInfoFDDmax_CCCH_ResourceAllocation*>(items[12]) = commonEDCHSystemInfoFDDmax_CCCH_ResourceAllocation; }
	void setCommonEDCHSystemInfoFDDMaxPeriodForCollisionResolution(const CommonEDCHSystemInfoFDDMaxPeriodForCollisionResolution& commonEDCHSystemInfoFDDMaxPeriodForCollisionResolution) { *static_cast<CommonEDCHSystemInfoFDDMaxPeriodForCollisionResolution*>(items[13]) = commonEDCHSystemInfoFDDMaxPeriodForCollisionResolution; }
	void setCommonEDCHSystemInfoFDDe_dch_TransmitContinuationOffset(const CommonEDCHSystemInfoFDDe_dch_TransmitContinuationOffset& commonEDCHSystemInfoFDDe_dch_TransmitContinuationOffset) { *static_cast<CommonEDCHSystemInfoFDDe_dch_TransmitContinuationOffset*>(items[14]) = commonEDCHSystemInfoFDDe_dch_TransmitContinuationOffset; }
	void setCommonEDCHSystemInfoFDDAcknacksupportonHSDPCCH(const CommonEDCHSystemInfoFDDAcknacksupportonHSDPCCH& commonEDCHSystemInfoFDDAcknacksupportonHSDPCCH) { *static_cast<CommonEDCHSystemInfoFDDAcknacksupportonHSDPCCH*>(items[15]) = commonEDCHSystemInfoFDDAcknacksupportonHSDPCCH; }
	void setMeasurementFeedbackInfo(const MeasurementFeedbackInfor7& measurementFeedbackInfo) { *static_cast<MeasurementFeedbackInfor7*>(items[16]) = measurementFeedbackInfo; }
	void setCommonEDCHSystemInfoFDDCommonEDCHResourceInfoList(const CommonEDCHSystemInfoFDDCommonEDCHResourceInfoList& commonEDCHSystemInfoFDDCommonEDCHResourceInfoList) { *static_cast<CommonEDCHSystemInfoFDDCommonEDCHResourceInfoList*>(items[17]) = commonEDCHSystemInfoFDDCommonEDCHResourceInfoList; }
};

class CommonTimeslotInfoMBMS : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CommonTimeslotInfoMBMS(): Sequence(&theInfo) {}

	void setSecondInterleavingMode(const SecondInterleavingMode& secondInterleavingMode) { *static_cast<SecondInterleavingMode*>(items[0]) = secondInterleavingMode; }
	void setTfciCoding(const TFCICoding& tfciCoding) { *static_cast<TFCICoding*>(items[1]) = tfciCoding; }
	void setPuncturingLimit(const PuncturingLimit& puncturingLimit) { *static_cast<PuncturingLimit*>(items[2]) = puncturingLimit; }
};

typedef Null RepetitionPeriodLengthAndOffsetRepetitionPeriod1;

typedef Null RepetitionPeriodLengthAndOffsetRepetitionPeriod2Length;

typedef Integer<CONSTRAINED, 0, 1> RepetitionPeriodLengthAndOffsetRepetitionPeriod2Offset;

class RepetitionPeriodLengthAndOffsetRepetitionPeriod2 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RepetitionPeriodLengthAndOffsetRepetitionPeriod2(): Sequence(&theInfo) {}

	void setRepetitionPeriodLengthAndOffsetRepetitionPeriod2Length(const RepetitionPeriodLengthAndOffsetRepetitionPeriod2Length& repetitionPeriodLengthAndOffsetRepetitionPeriod2Length) { *static_cast<RepetitionPeriodLengthAndOffsetRepetitionPeriod2Length*>(items[0]) = repetitionPeriodLengthAndOffsetRepetitionPeriod2Length; }
	void setRepetitionPeriodLengthAndOffsetRepetitionPeriod2Offset(const RepetitionPeriodLengthAndOffsetRepetitionPeriod2Offset& repetitionPeriodLengthAndOffsetRepetitionPeriod2Offset) { *static_cast<RepetitionPeriodLengthAndOffsetRepetitionPeriod2Offset*>(items[1]) = repetitionPeriodLengthAndOffsetRepetitionPeriod2Offset; }
};

typedef Integer<CONSTRAINED, 1, 3> RepetitionPeriodLengthAndOffsetRepetitionPeriod4Length;

typedef Integer<CONSTRAINED, 0, 3> RepetitionPeriodLengthAndOffsetRepetitionPeriod4Offset;

class RepetitionPeriodLengthAndOffsetRepetitionPeriod4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RepetitionPeriodLengthAndOffsetRepetitionPeriod4(): Sequence(&theInfo) {}

	void setRepetitionPeriodLengthAndOffsetRepetitionPeriod4Length(const RepetitionPeriodLengthAndOffsetRepetitionPeriod4Length& repetitionPeriodLengthAndOffsetRepetitionPeriod4Length) { *static_cast<RepetitionPeriodLengthAndOffsetRepetitionPeriod4Length*>(items[0]) = repetitionPeriodLengthAndOffsetRepetitionPeriod4Length; }
	void setRepetitionPeriodLengthAndOffsetRepetitionPeriod4Offset(const RepetitionPeriodLengthAndOffsetRepetitionPeriod4Offset& repetitionPeriodLengthAndOffsetRepetitionPeriod4Offset) { *static_cast<RepetitionPeriodLengthAndOffsetRepetitionPeriod4Offset*>(items[1]) = repetitionPeriodLengthAndOffsetRepetitionPeriod4Offset; }
};

typedef Integer<CONSTRAINED, 1, 7> RepetitionPeriodLengthAndOffsetRepetitionPeriod8Length;

typedef Integer<CONSTRAINED, 0, 7> RepetitionPeriodLengthAndOffsetRepetitionPeriod8Offset;

class RepetitionPeriodLengthAndOffsetRepetitionPeriod8 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RepetitionPeriodLengthAndOffsetRepetitionPeriod8(): Sequence(&theInfo) {}

	void setRepetitionPeriodLengthAndOffsetRepetitionPeriod8Length(const RepetitionPeriodLengthAndOffsetRepetitionPeriod8Length& repetitionPeriodLengthAndOffsetRepetitionPeriod8Length) { *static_cast<RepetitionPeriodLengthAndOffsetRepetitionPeriod8Length*>(items[0]) = repetitionPeriodLengthAndOffsetRepetitionPeriod8Length; }
	void setRepetitionPeriodLengthAndOffsetRepetitionPeriod8Offset(const RepetitionPeriodLengthAndOffsetRepetitionPeriod8Offset& repetitionPeriodLengthAndOffsetRepetitionPeriod8Offset) { *static_cast<RepetitionPeriodLengthAndOffsetRepetitionPeriod8Offset*>(items[1]) = repetitionPeriodLengthAndOffsetRepetitionPeriod8Offset; }
};

typedef Integer<CONSTRAINED, 1, 15> RepetitionPeriodLengthAndOffsetRepetitionPeriod16Length;

typedef Integer<CONSTRAINED, 0, 15> RepetitionPeriodLengthAndOffsetRepetitionPeriod16Offset;

class RepetitionPeriodLengthAndOffsetRepetitionPeriod16 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RepetitionPeriodLengthAndOffsetRepetitionPeriod16(): Sequence(&theInfo) {}

	void setRepetitionPeriodLengthAndOffsetRepetitionPeriod16Length(const RepetitionPeriodLengthAndOffsetRepetitionPeriod16Length& repetitionPeriodLengthAndOffsetRepetitionPeriod16Length) { *static_cast<RepetitionPeriodLengthAndOffsetRepetitionPeriod16Length*>(items[0]) = repetitionPeriodLengthAndOffsetRepetitionPeriod16Length; }
	void setRepetitionPeriodLengthAndOffsetRepetitionPeriod16Offset(const RepetitionPeriodLengthAndOffsetRepetitionPeriod16Offset& repetitionPeriodLengthAndOffsetRepetitionPeriod16Offset) { *static_cast<RepetitionPeriodLengthAndOffsetRepetitionPeriod16Offset*>(items[1]) = repetitionPeriodLengthAndOffsetRepetitionPeriod16Offset; }
};

typedef Integer<CONSTRAINED, 1, 31> RepetitionPeriodLengthAndOffsetRepetitionPeriod32Length;

typedef Integer<CONSTRAINED, 0, 31> RepetitionPeriodLengthAndOffsetRepetitionPeriod32Offset;

class RepetitionPeriodLengthAndOffsetRepetitionPeriod32 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RepetitionPeriodLengthAndOffsetRepetitionPeriod32(): Sequence(&theInfo) {}

	void setRepetitionPeriodLengthAndOffsetRepetitionPeriod32Length(const RepetitionPeriodLengthAndOffsetRepetitionPeriod32Length& repetitionPeriodLengthAndOffsetRepetitionPeriod32Length) { *static_cast<RepetitionPeriodLengthAndOffsetRepetitionPeriod32Length*>(items[0]) = repetitionPeriodLengthAndOffsetRepetitionPeriod32Length; }
	void setRepetitionPeriodLengthAndOffsetRepetitionPeriod32Offset(const RepetitionPeriodLengthAndOffsetRepetitionPeriod32Offset& repetitionPeriodLengthAndOffsetRepetitionPeriod32Offset) { *static_cast<RepetitionPeriodLengthAndOffsetRepetitionPeriod32Offset*>(items[1]) = repetitionPeriodLengthAndOffsetRepetitionPeriod32Offset; }
};

typedef Integer<CONSTRAINED, 1, 63> RepetitionPeriodLengthAndOffsetRepetitionPeriod64Length;

typedef Integer<CONSTRAINED, 0, 63> RepetitionPeriodLengthAndOffsetRepetitionPeriod64Offset;

class RepetitionPeriodLengthAndOffsetRepetitionPeriod64 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RepetitionPeriodLengthAndOffsetRepetitionPeriod64(): Sequence(&theInfo) {}

	void setRepetitionPeriodLengthAndOffsetRepetitionPeriod64Length(const RepetitionPeriodLengthAndOffsetRepetitionPeriod64Length& repetitionPeriodLengthAndOffsetRepetitionPeriod64Length) { *static_cast<RepetitionPeriodLengthAndOffsetRepetitionPeriod64Length*>(items[0]) = repetitionPeriodLengthAndOffsetRepetitionPeriod64Length; }
	void setRepetitionPeriodLengthAndOffsetRepetitionPeriod64Offset(const RepetitionPeriodLengthAndOffsetRepetitionPeriod64Offset& repetitionPeriodLengthAndOffsetRepetitionPeriod64Offset) { *static_cast<RepetitionPeriodLengthAndOffsetRepetitionPeriod64Offset*>(items[1]) = repetitionPeriodLengthAndOffsetRepetitionPeriod64Offset; }
};

class RepetitionPeriodLengthAndOffset : public Choice {
private:
	static const void *choicesInfo[7];
public:
	enum RepetitionPeriodLengthAndOffsetChoices {
		repetitionPeriodLengthAndOffsetRepetitionPeriod1 = 0,
		repetitionPeriodLengthAndOffsetRepetitionPeriod2 = 1,
		repetitionPeriodLengthAndOffsetRepetitionPeriod4 = 2,
		repetitionPeriodLengthAndOffsetRepetitionPeriod8 = 3,
		repetitionPeriodLengthAndOffsetRepetitionPeriod16 = 4,
		repetitionPeriodLengthAndOffsetRepetitionPeriod32 = 5,
		repetitionPeriodLengthAndOffsetRepetitionPeriod64 = 6,
	};
	static const Info theInfo;
	RepetitionPeriodLengthAndOffset(): Choice(&theInfo) {}
};

class CommonTimeslotInfoSCCPCH : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CommonTimeslotInfoSCCPCH(): Sequence(&theInfo) {}

	void setSecondInterleavingMode(const SecondInterleavingMode& secondInterleavingMode) { *static_cast<SecondInterleavingMode*>(items[0]) = secondInterleavingMode; }
	void setTfciCoding(const TFCICoding& tfciCoding) { *static_cast<TFCICoding*>(items[1]) = tfciCoding; }
	void setPuncturingLimit(const PuncturingLimit& puncturingLimit) { *static_cast<PuncturingLimit*>(items[2]) = puncturingLimit; }
	void setRepetitionPeriodLengthAndOffset(const RepetitionPeriodLengthAndOffset& repetitionPeriodLengthAndOffset) { *static_cast<RepetitionPeriodLengthAndOffset*>(items[3]) = repetitionPeriodLengthAndOffset; }
};

enum ControlChannelDRXCycleTDD128Values {
	sub_frames_1_ControlChannelDRXCycleTDD128 = 0,
	sub_frames_2_ControlChannelDRXCycleTDD128 = 1,
	sub_frames_4_ControlChannelDRXCycleTDD128 = 2,
	sub_frames_8_ControlChannelDRXCycleTDD128 = 3,
	sub_frames_16_ControlChannelDRXCycleTDD128 = 4,
	sub_frames_32_ControlChannelDRXCycleTDD128 = 5,
	sub_frames_64_ControlChannelDRXCycleTDD128 = 6,
	spare1_ControlChannelDRXCycleTDD128 = 7,
};
typedef Enumerated<CONSTRAINED, 7> ControlChannelDRXCycleTDD128;

enum EnablingDelayTDD128Values {
	radio_frames_0_EnablingDelayTDD128 = 0,
	radio_frames_1_EnablingDelayTDD128 = 1,
	radio_frames_2_EnablingDelayTDD128 = 2,
	radio_frames_4_EnablingDelayTDD128 = 3,
	radio_frames_8_EnablingDelayTDD128 = 4,
	radio_frames_16_EnablingDelayTDD128 = 5,
	radio_frames_32_EnablingDelayTDD128 = 6,
	radio_frames_64_EnablingDelayTDD128 = 7,
	radio_frames_128_EnablingDelayTDD128 = 8,
	spare7_EnablingDelayTDD128 = 9,
	spare6_EnablingDelayTDD128 = 10,
	spare5_EnablingDelayTDD128 = 11,
	spare4_EnablingDelayTDD128 = 12,
	spare3_EnablingDelayTDD128 = 13,
	spare2_EnablingDelayTDD128 = 14,
	infinity_EnablingDelayTDD128 = 15,
};
typedef Enumerated<CONSTRAINED, 15> EnablingDelayTDD128;

class ControlChannelDRXInfoTDD128r8ControlChannelDrxOperationContinue : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ControlChannelDRXInfoTDD128r8ControlChannelDrxOperationContinue(): Sequence(&theInfo) {}

	void setEnablingDelay(const EnablingDelayTDD128& enablingDelay) { *static_cast<EnablingDelayTDD128*>(items[0]) = enablingDelay; }
};

enum HSSCCHDRXInactivityThresholdTDD128Values {
	sub_frames_1_HSSCCHDRXInactivityThresholdTDD128 = 0,
	sub_frames_2_HSSCCHDRXInactivityThresholdTDD128 = 1,
	sub_frames_4_HSSCCHDRXInactivityThresholdTDD128 = 2,
	sub_frames_8_HSSCCHDRXInactivityThresholdTDD128 = 3,
	sub_frames_16_HSSCCHDRXInactivityThresholdTDD128 = 4,
	sub_frames_32_HSSCCHDRXInactivityThresholdTDD128 = 5,
	sub_frames_64_HSSCCHDRXInactivityThresholdTDD128 = 6,
	sub_frames_128_HSSCCHDRXInactivityThresholdTDD128 = 7,
	sub_frames_256_HSSCCHDRXInactivityThresholdTDD128 = 8,
	sub_frames_512_HSSCCHDRXInactivityThresholdTDD128 = 9,
	spare6_HSSCCHDRXInactivityThresholdTDD128 = 10,
	spare5_HSSCCHDRXInactivityThresholdTDD128 = 11,
	spare4_HSSCCHDRXInactivityThresholdTDD128 = 12,
	spare3_HSSCCHDRXInactivityThresholdTDD128 = 13,
	spare2_HSSCCHDRXInactivityThresholdTDD128 = 14,
	infinity_HSSCCHDRXInactivityThresholdTDD128 = 15,
};
typedef Enumerated<CONSTRAINED, 15> HSSCCHDRXInactivityThresholdTDD128;

typedef Integer<CONSTRAINED, 0, 63> HSSCCHDRXInfoTDD128HSSCCHDRXOffset;

class HSSCCHDRXInfoTDD128 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	HSSCCHDRXInfoTDD128(): Sequence(&theInfo) {}

	void setHSSCCHDRXCycle(const ControlChannelDRXCycleTDD128& hSSCCHDRXCycle) { *static_cast<ControlChannelDRXCycleTDD128*>(items[0]) = hSSCCHDRXCycle; }
	void setHSSCCHDRXInactivityThreshold(const HSSCCHDRXInactivityThresholdTDD128& hSSCCHDRXInactivityThreshold) { *static_cast<HSSCCHDRXInactivityThresholdTDD128*>(items[1]) = hSSCCHDRXInactivityThreshold; }
	void setHSSCCHDRXInfoTDD128HSSCCHDRXOffset(const HSSCCHDRXInfoTDD128HSSCCHDRXOffset& hSSCCHDRXInfoTDD128HSSCCHDRXOffset) { *static_cast<HSSCCHDRXInfoTDD128HSSCCHDRXOffset*>(items[2]) = hSSCCHDRXInfoTDD128HSSCCHDRXOffset; }
};

typedef Null EAGCHDRXInfoTDD128EAGCHDRXInfoTypeSameAsHSSCCH;

enum EAGCHInactivityMonitorThresholdTDD128Values {
	radio_frames_0_EAGCHInactivityMonitorThresholdTDD128 = 0,
	radio_frames_1_EAGCHInactivityMonitorThresholdTDD128 = 1,
	radio_frames_2_EAGCHInactivityMonitorThresholdTDD128 = 2,
	radio_frames_4_EAGCHInactivityMonitorThresholdTDD128 = 3,
	radio_frames_8_EAGCHInactivityMonitorThresholdTDD128 = 4,
	radio_frames_16_EAGCHInactivityMonitorThresholdTDD128 = 5,
	radio_frames_32_EAGCHInactivityMonitorThresholdTDD128 = 6,
	radio_frames_64_EAGCHInactivityMonitorThresholdTDD128 = 7,
	radio_frames_128_EAGCHInactivityMonitorThresholdTDD128 = 8,
	radio_frames_256_EAGCHInactivityMonitorThresholdTDD128 = 9,
	radio_frames_512_EAGCHInactivityMonitorThresholdTDD128 = 10,
	spare5_EAGCHInactivityMonitorThresholdTDD128 = 11,
	spare4_EAGCHInactivityMonitorThresholdTDD128 = 12,
	spare3_EAGCHInactivityMonitorThresholdTDD128 = 13,
	spare2_EAGCHInactivityMonitorThresholdTDD128 = 14,
	infinity_EAGCHInactivityMonitorThresholdTDD128 = 15,
};
typedef Enumerated<CONSTRAINED, 15> EAGCHInactivityMonitorThresholdTDD128;

typedef Integer<CONSTRAINED, 0, 63> EAGCHDRXInfoTDD128EAGCHDRXInfoTypeEAGCHDRXParametersEAGCHDRXOffset;

class EAGCHDRXInfoTDD128EAGCHDRXInfoTypeEAGCHDRXParameters : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	EAGCHDRXInfoTDD128EAGCHDRXInfoTypeEAGCHDRXParameters(): Sequence(&theInfo) {}

	void setEAGCHDRXCycle(const ControlChannelDRXCycleTDD128& eAGCHDRXCycle) { *static_cast<ControlChannelDRXCycleTDD128*>(items[0]) = eAGCHDRXCycle; }
	void setEAGCHInactivityMonitorThreshold(const EAGCHInactivityMonitorThresholdTDD128& eAGCHInactivityMonitorThreshold) { *static_cast<EAGCHInactivityMonitorThresholdTDD128*>(items[1]) = eAGCHInactivityMonitorThreshold; }
	void setEAGCHDRXInfoTDD128EAGCHDRXInfoTypeEAGCHDRXParametersEAGCHDRXOffset(const EAGCHDRXInfoTDD128EAGCHDRXInfoTypeEAGCHDRXParametersEAGCHDRXOffset& eAGCHDRXInfoTDD128EAGCHDRXInfoTypeEAGCHDRXParametersEAGCHDRXOffset) { *static_cast<EAGCHDRXInfoTDD128EAGCHDRXInfoTypeEAGCHDRXParametersEAGCHDRXOffset*>(items[2]) = eAGCHDRXInfoTDD128EAGCHDRXInfoTypeEAGCHDRXParametersEAGCHDRXOffset; }
};

class EAGCHDRXInfoTDD128EAGCHDRXInfoType : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum EAGCHDRXInfoTDD128EAGCHDRXInfoTypeChoices {
		eAGCHDRXInfoTDD128EAGCHDRXInfoTypeSameAsHSSCCH = 0,
		eAGCHDRXInfoTDD128EAGCHDRXInfoTypeEAGCHDRXParameters = 1,
	};
	static const Info theInfo;
	EAGCHDRXInfoTDD128EAGCHDRXInfoType(): Choice(&theInfo) {}
};

class EAGCHDRXInfoTDD128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	EAGCHDRXInfoTDD128(): Sequence(&theInfo) {}

	void setEAGCHDRXInfoTDD128EAGCHDRXInfoType(const EAGCHDRXInfoTDD128EAGCHDRXInfoType& eAGCHDRXInfoTDD128EAGCHDRXInfoType) { *static_cast<EAGCHDRXInfoTDD128EAGCHDRXInfoType*>(items[0]) = eAGCHDRXInfoTDD128EAGCHDRXInfoType; }
};

class ControlChannelDRXInfoTDD128r8ControlChannelDrxOperationNewOperation : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ControlChannelDRXInfoTDD128r8ControlChannelDrxOperationNewOperation(): Sequence(&theInfo) {}

	void setHSSCCHDrxInfo(const HSSCCHDRXInfoTDD128& hSSCCHDrxInfo) { *static_cast<HSSCCHDRXInfoTDD128*>(items[0]) = hSSCCHDrxInfo; }
	void setEAGCHDrxInfo(const EAGCHDRXInfoTDD128& eAGCHDrxInfo) { *static_cast<EAGCHDRXInfoTDD128*>(items[1]) = eAGCHDrxInfo; }
	void setEnablingDelay(const EnablingDelayTDD128& enablingDelay) { *static_cast<EnablingDelayTDD128*>(items[2]) = enablingDelay; }
};

class ControlChannelDRXInfoTDD128r8ControlChannelDrxOperation : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ControlChannelDRXInfoTDD128r8ControlChannelDrxOperationChoices {
		controlChannelDRXInfoTDD128r8ControlChannelDrxOperationContinue = 0,
		controlChannelDRXInfoTDD128r8ControlChannelDrxOperationNewOperation = 1,
	};
	static const Info theInfo;
	ControlChannelDRXInfoTDD128r8ControlChannelDrxOperation(): Choice(&theInfo) {}
};

class ControlChannelDRXInfoTDD128r8 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ControlChannelDRXInfoTDD128r8(): Sequence(&theInfo) {}

	void setControlChannelDRXInfoTDD128r8ControlChannelDrxOperation(const ControlChannelDRXInfoTDD128r8ControlChannelDrxOperation& controlChannelDRXInfoTDD128r8ControlChannelDrxOperation) { *static_cast<ControlChannelDRXInfoTDD128r8ControlChannelDrxOperation*>(items[0]) = controlChannelDRXInfoTDD128r8ControlChannelDrxOperation; }
};

typedef Integer<CONSTRAINED, 1, 8> DynamicPersistenceLevel;

typedef SequenceOf<DynamicPersistenceLevel, CONSTRAINED, 1, maxTF_CPCH> DynamicPersistenceLevelTFList;

class CPCHPersistenceLevels : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CPCHPersistenceLevels(): Sequence(&theInfo) {}

	void setCpchSetID(const CPCHSetID& cpchSetID) { *static_cast<CPCHSetID*>(items[0]) = cpchSetID; }
	void setDynamicPersistenceLevelTFList(const DynamicPersistenceLevelTFList& dynamicPersistenceLevelTFList) { *static_cast<DynamicPersistenceLevelTFList*>(items[1]) = dynamicPersistenceLevelTFList; }
};

typedef SequenceOf<CPCHPersistenceLevels, CONSTRAINED, 1, maxCPCHsets> CPCHPersistenceLevelsList;

typedef Integer<CONSTRAINED, -10, 10> DeltaPpm;

enum ULDPCCHSlotFormatValues {
	slf0_ULDPCCHSlotFormat = 0,
	slf1_ULDPCCHSlotFormat = 1,
	slf2_ULDPCCHSlotFormat = 2,
};
typedef Enumerated<CONSTRAINED, 2> ULDPCCHSlotFormat;

typedef Integer<CONSTRAINED, 1, 8> NStartMessage;

typedef Integer<CONSTRAINED, 0, 7> NEOT;

enum CPCHStatusIndicationModeValues {
	pa_mode_CPCHStatusIndicationMode = 0,
	pamsf_mode_CPCHStatusIndicationMode = 1,
};
typedef Enumerated<CONSTRAINED, 1> CPCHStatusIndicationMode;

typedef Integer<CONSTRAINED, 0, 79> PCPCHChannelInfoPcpchULScramblingCode;

typedef Integer<CONSTRAINED, 0, 511> PCPCHChannelInfoPcpchDLChannelisationCode;

enum PCPLengthValues {
	as0_PCPLength = 0,
	as8_PCPLength = 1,
};
typedef Enumerated<CONSTRAINED, 1> PCPLength;

class UCSMInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UCSMInfo(): Sequence(&theInfo) {}

	void setMinimumSpreadingFactor(const MinimumSpreadingFactor& minimumSpreadingFactor) { *static_cast<MinimumSpreadingFactor*>(items[0]) = minimumSpreadingFactor; }
	void setNfMax(const NFMax& nfMax) { *static_cast<NFMax*>(items[1]) = nfMax; }
	void setChannelReqParamsForUCSM(const ChannelReqParamsForUCSM& channelReqParamsForUCSM) { *static_cast<ChannelReqParamsForUCSM*>(items[2]) = channelReqParamsForUCSM; }
};

class PCPCHChannelInfo : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	PCPCHChannelInfo(): Sequence(&theInfo) {}

	void setPCPCHChannelInfoPcpchULScramblingCode(const PCPCHChannelInfoPcpchULScramblingCode& pCPCHChannelInfoPcpchULScramblingCode) { *static_cast<PCPCHChannelInfoPcpchULScramblingCode*>(items[0]) = pCPCHChannelInfoPcpchULScramblingCode; }
	void setPCPCHChannelInfoPcpchDLChannelisationCode(const PCPCHChannelInfoPcpchDLChannelisationCode& pCPCHChannelInfoPcpchDLChannelisationCode) { *static_cast<PCPCHChannelInfoPcpchDLChannelisationCode*>(items[1]) = pCPCHChannelInfoPcpchDLChannelisationCode; }
	void setPcpchDLScramblingCode(const SecondaryScramblingCode& pcpchDLScramblingCode) { *static_cast<SecondaryScramblingCode*>(items[2]) = pcpchDLScramblingCode; }
	void setPcpLength(const PCPLength& pcpLength) { *static_cast<PCPLength*>(items[3]) = pcpLength; }
	void setUcsmInfo(const UCSMInfo& ucsmInfo) { *static_cast<UCSMInfo*>(items[4]) = ucsmInfo; }
};

typedef SequenceOf<PCPCHChannelInfo, CONSTRAINED, 1, maxPCPCHs> PCPCHChannelInfoList;

class CPCHSetInfo : public Sequence {
private:
	static const void *itemsInfo[16];
	static bool itemsPres[16];
public:
	static const Info theInfo;
	CPCHSetInfo(): Sequence(&theInfo) {}

	void setCpchSetID(const CPCHSetID& cpchSetID) { *static_cast<CPCHSetID*>(items[0]) = cpchSetID; }
	void setTransportFormatSet(const TransportFormatSet& transportFormatSet) { *static_cast<TransportFormatSet*>(items[1]) = transportFormatSet; }
	void setTfcs(const TFCS& tfcs) { *static_cast<TFCS*>(items[2]) = tfcs; }
	void setApPreambleScramblingCode(const APPreambleScramblingCode& apPreambleScramblingCode) { *static_cast<APPreambleScramblingCode*>(items[3]) = apPreambleScramblingCode; }
	void setApAICHChannelisationCode(const APAICHChannelisationCode& apAICHChannelisationCode) { *static_cast<APAICHChannelisationCode*>(items[4]) = apAICHChannelisationCode; }
	void setCdPreambleScramblingCode(const CDPreambleScramblingCode& cdPreambleScramblingCode) { *static_cast<CDPreambleScramblingCode*>(items[5]) = cdPreambleScramblingCode; }
	void setCdCAICHChannelisationCode(const CDCAICHChannelisationCode& cdCAICHChannelisationCode) { *static_cast<CDCAICHChannelisationCode*>(items[6]) = cdCAICHChannelisationCode; }
	void setCdAccessSlotSubchannelList(const CDAccessSlotSubchannelList& cdAccessSlotSubchannelList) { *static_cast<CDAccessSlotSubchannelList*>(items[7]) = cdAccessSlotSubchannelList; }
	void setCdSignatureCodeList(const CDSignatureCodeList& cdSignatureCodeList) { *static_cast<CDSignatureCodeList*>(items[8]) = cdSignatureCodeList; }
	void setDeltaPpm(const DeltaPpm& deltaPpm) { *static_cast<DeltaPpm*>(items[9]) = deltaPpm; }
	void setUlDPCCHSlotFormat(const ULDPCCHSlotFormat& ulDPCCHSlotFormat) { *static_cast<ULDPCCHSlotFormat*>(items[10]) = ulDPCCHSlotFormat; }
	void setNStartMessage(const NStartMessage& nStartMessage) { *static_cast<NStartMessage*>(items[11]) = nStartMessage; }
	void setNEOT(const NEOT& nEOT) { *static_cast<NEOT*>(items[12]) = nEOT; }
	void setChannelAssignmentActive(const ChannelAssignmentActive& channelAssignmentActive) { *static_cast<ChannelAssignmentActive*>(items[13]) = channelAssignmentActive; }
	void setCpchStatusIndicationMode(const CPCHStatusIndicationMode& cpchStatusIndicationMode) { *static_cast<CPCHStatusIndicationMode*>(items[14]) = cpchStatusIndicationMode; }
	void setPcpchChannelInfoList(const PCPCHChannelInfoList& pcpchChannelInfoList) { *static_cast<PCPCHChannelInfoList*>(items[15]) = pcpchChannelInfoList; }
};

typedef SequenceOf<CPCHSetInfo, CONSTRAINED, 1, maxCPCHsets> CPCHSetInfoList;

enum CQIDTXTimerValues {
	sub_frames_0_CQIDTXTimer = 0,
	sub_frames_1_CQIDTXTimer = 1,
	sub_frames_2_CQIDTXTimer = 2,
	sub_frames_4_CQIDTXTimer = 3,
	sub_frames_8_CQIDTXTimer = 4,
	sub_frames_16_CQIDTXTimer = 5,
	sub_frames_32_CQIDTXTimer = 6,
	sub_frames_64_CQIDTXTimer = 7,
	sub_frames_128_CQIDTXTimer = 8,
	sub_frames_256_CQIDTXTimer = 9,
	sub_frames_512_CQIDTXTimer = 10,
	sub_frames_Infinity_CQIDTXTimer = 11,
	spare4_CQIDTXTimer = 12,
	spare3_CQIDTXTimer = 13,
	spare2_CQIDTXTimer = 14,
	spare1_CQIDTXTimer = 15,
};
typedef Enumerated<CONSTRAINED, 15> CQIDTXTimer;

typedef Integer<CONSTRAINED, -10, 5> CSICHPowerOffset;

typedef Integer<CONSTRAINED, 0, 599> DefaultDPCHOffsetValueFDD;

typedef Integer<CONSTRAINED, 0, 7> DefaultDPCHOffsetValueTDD;

typedef Integer<CONSTRAINED, 0, 30> DeltaSIR;

typedef Integer<CONSTRAINED, 1, 4096> DurationTimeInfo;

class TimeInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	TimeInfo(): Sequence(&theInfo) {}

	void setActivationTime(const ActivationTime& activationTime) { *static_cast<ActivationTime*>(items[0]) = activationTime; }
	void setDurationTimeInfo(const DurationTimeInfo& durationTimeInfo) { *static_cast<DurationTimeInfo*>(items[1]) = durationTimeInfo; }
};

typedef Boolean IndividualTimeslotInfoTfciExistence;

typedef Null MidambleShiftAndBurstTypeBurstTypeType1MidambleAllocationModeDefaultMidamble;

typedef Null MidambleShiftAndBurstTypeBurstTypeType1MidambleAllocationModeCommonMidamble;

class MidambleShiftAndBurstTypeBurstTypeType1MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeBurstTypeType1MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftLong& midambleShift) { *static_cast<MidambleShiftLong*>(items[0]) = midambleShift; }
};

class MidambleShiftAndBurstTypeBurstTypeType1MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MidambleShiftAndBurstTypeBurstTypeType1MidambleAllocationModeChoices {
		midambleShiftAndBurstTypeBurstTypeType1MidambleAllocationModeDefaultMidamble = 0,
		midambleShiftAndBurstTypeBurstTypeType1MidambleAllocationModeCommonMidamble = 1,
		midambleShiftAndBurstTypeBurstTypeType1MidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTypeBurstTypeType1MidambleAllocationMode(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstTypeBurstTypeType1 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeBurstTypeType1(): Sequence(&theInfo) {}

	void setMidambleConfigurationBurstType1and3(const MidambleConfigurationBurstType1and3& midambleConfigurationBurstType1and3) { *static_cast<MidambleConfigurationBurstType1and3*>(items[0]) = midambleConfigurationBurstType1and3; }
	void setMidambleShiftAndBurstTypeBurstTypeType1MidambleAllocationMode(const MidambleShiftAndBurstTypeBurstTypeType1MidambleAllocationMode& midambleShiftAndBurstTypeBurstTypeType1MidambleAllocationMode) { *static_cast<MidambleShiftAndBurstTypeBurstTypeType1MidambleAllocationMode*>(items[1]) = midambleShiftAndBurstTypeBurstTypeType1MidambleAllocationMode; }
};

enum MidambleConfigurationBurstType2Values {
	ms3_MidambleConfigurationBurstType2 = 0,
	ms6_MidambleConfigurationBurstType2 = 1,
};
typedef Enumerated<CONSTRAINED, 1> MidambleConfigurationBurstType2;

typedef Null MidambleShiftAndBurstTypeBurstTypeType2MidambleAllocationModeDefaultMidamble;

typedef Null MidambleShiftAndBurstTypeBurstTypeType2MidambleAllocationModeCommonMidamble;

typedef Integer<CONSTRAINED, 0, 5> MidambleShiftShort;

class MidambleShiftAndBurstTypeBurstTypeType2MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeBurstTypeType2MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftShort& midambleShift) { *static_cast<MidambleShiftShort*>(items[0]) = midambleShift; }
};

class MidambleShiftAndBurstTypeBurstTypeType2MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MidambleShiftAndBurstTypeBurstTypeType2MidambleAllocationModeChoices {
		midambleShiftAndBurstTypeBurstTypeType2MidambleAllocationModeDefaultMidamble = 0,
		midambleShiftAndBurstTypeBurstTypeType2MidambleAllocationModeCommonMidamble = 1,
		midambleShiftAndBurstTypeBurstTypeType2MidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTypeBurstTypeType2MidambleAllocationMode(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstTypeBurstTypeType2 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeBurstTypeType2(): Sequence(&theInfo) {}

	void setMidambleConfigurationBurstType2(const MidambleConfigurationBurstType2& midambleConfigurationBurstType2) { *static_cast<MidambleConfigurationBurstType2*>(items[0]) = midambleConfigurationBurstType2; }
	void setMidambleShiftAndBurstTypeBurstTypeType2MidambleAllocationMode(const MidambleShiftAndBurstTypeBurstTypeType2MidambleAllocationMode& midambleShiftAndBurstTypeBurstTypeType2MidambleAllocationMode) { *static_cast<MidambleShiftAndBurstTypeBurstTypeType2MidambleAllocationMode*>(items[1]) = midambleShiftAndBurstTypeBurstTypeType2MidambleAllocationMode; }
};

typedef Null MidambleShiftAndBurstTypeBurstTypeType3MidambleAllocationModeDefaultMidamble;

class MidambleShiftAndBurstTypeBurstTypeType3MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeBurstTypeType3MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftLong& midambleShift) { *static_cast<MidambleShiftLong*>(items[0]) = midambleShift; }
};

class MidambleShiftAndBurstTypeBurstTypeType3MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MidambleShiftAndBurstTypeBurstTypeType3MidambleAllocationModeChoices {
		midambleShiftAndBurstTypeBurstTypeType3MidambleAllocationModeDefaultMidamble = 0,
		midambleShiftAndBurstTypeBurstTypeType3MidambleAllocationModeUeSpecificMidamble = 1,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTypeBurstTypeType3MidambleAllocationMode(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstTypeBurstTypeType3 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeBurstTypeType3(): Sequence(&theInfo) {}

	void setMidambleConfigurationBurstType1and3(const MidambleConfigurationBurstType1and3& midambleConfigurationBurstType1and3) { *static_cast<MidambleConfigurationBurstType1and3*>(items[0]) = midambleConfigurationBurstType1and3; }
	void setMidambleShiftAndBurstTypeBurstTypeType3MidambleAllocationMode(const MidambleShiftAndBurstTypeBurstTypeType3MidambleAllocationMode& midambleShiftAndBurstTypeBurstTypeType3MidambleAllocationMode) { *static_cast<MidambleShiftAndBurstTypeBurstTypeType3MidambleAllocationMode*>(items[1]) = midambleShiftAndBurstTypeBurstTypeType3MidambleAllocationMode; }
};

class MidambleShiftAndBurstTypeBurstType : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MidambleShiftAndBurstTypeBurstTypeChoices {
		midambleShiftAndBurstTypeBurstTypeType1 = 0,
		midambleShiftAndBurstTypeBurstTypeType2 = 1,
		midambleShiftAndBurstTypeBurstTypeType3 = 2,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTypeBurstType(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstType : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstType(): Sequence(&theInfo) {}

	void setMidambleShiftAndBurstTypeBurstType(const MidambleShiftAndBurstTypeBurstType& midambleShiftAndBurstTypeBurstType) { *static_cast<MidambleShiftAndBurstTypeBurstType*>(items[0]) = midambleShiftAndBurstTypeBurstType; }
};

class IndividualTimeslotInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	IndividualTimeslotInfo(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumber& timeslotNumber) { *static_cast<TimeslotNumber*>(items[0]) = timeslotNumber; }
	void setIndividualTimeslotInfoTfciExistence(const IndividualTimeslotInfoTfciExistence& individualTimeslotInfoTfciExistence) { *static_cast<IndividualTimeslotInfoTfciExistence*>(items[1]) = individualTimeslotInfoTfciExistence; }
	void setMidambleShiftAndBurstType(const MidambleShiftAndBurstType& midambleShiftAndBurstType) { *static_cast<MidambleShiftAndBurstType*>(items[2]) = midambleShiftAndBurstType; }
};

class DLTSChannelisationCodesShortCodesRepresentationConsecutive : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLTSChannelisationCodesShortCodesRepresentationConsecutive(): Sequence(&theInfo) {}

	void setFirstChannelisationCode(const DLTSChannelisationCode& firstChannelisationCode) { *static_cast<DLTSChannelisationCode*>(items[0]) = firstChannelisationCode; }
	void setLastChannelisationCode(const DLTSChannelisationCode& lastChannelisationCode) { *static_cast<DLTSChannelisationCode*>(items[1]) = lastChannelisationCode; }
};

typedef BitString<CONSTRAINED, 16, 16> DLTSChannelisationCodesShortCodesRepresentationBitmap;

class DLTSChannelisationCodesShortCodesRepresentation : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLTSChannelisationCodesShortCodesRepresentationChoices {
		dLTSChannelisationCodesShortCodesRepresentationConsecutive = 0,
		dLTSChannelisationCodesShortCodesRepresentationBitmap = 1,
	};
	static const Info theInfo;
	DLTSChannelisationCodesShortCodesRepresentation(): Choice(&theInfo) {}
};

class DLTSChannelisationCodesShort : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLTSChannelisationCodesShort(): Sequence(&theInfo) {}

	void setDLTSChannelisationCodesShortCodesRepresentation(const DLTSChannelisationCodesShortCodesRepresentation& dLTSChannelisationCodesShortCodesRepresentation) { *static_cast<DLTSChannelisationCodesShortCodesRepresentation*>(items[0]) = dLTSChannelisationCodesShortCodesRepresentation; }
};

typedef Null DownlinkTimeslotsCodesMoreTimeslotsNoMore;

typedef Integer<CONSTRAINED, 1, maxTS_1> DownlinkTimeslotsCodesMoreTimeslotsAdditionalTimeslotsConsecutive;

class DownlinkAdditionalTimeslotsParametersSameAsLast : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DownlinkAdditionalTimeslotsParametersSameAsLast(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumber& timeslotNumber) { *static_cast<TimeslotNumber*>(items[0]) = timeslotNumber; }
};

class DownlinkAdditionalTimeslotsParametersNewParameters : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DownlinkAdditionalTimeslotsParametersNewParameters(): Sequence(&theInfo) {}

	void setIndividualTimeslotInfo(const IndividualTimeslotInfo& individualTimeslotInfo) { *static_cast<IndividualTimeslotInfo*>(items[0]) = individualTimeslotInfo; }
	void setDlTSChannelisationCodesShort(const DLTSChannelisationCodesShort& dlTSChannelisationCodesShort) { *static_cast<DLTSChannelisationCodesShort*>(items[1]) = dlTSChannelisationCodesShort; }
};

class DownlinkAdditionalTimeslotsParameters : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DownlinkAdditionalTimeslotsParametersChoices {
		downlinkAdditionalTimeslotsParametersSameAsLast = 0,
		downlinkAdditionalTimeslotsParametersNewParameters = 1,
	};
	static const Info theInfo;
	DownlinkAdditionalTimeslotsParameters(): Choice(&theInfo) {}
};

class DownlinkAdditionalTimeslots : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DownlinkAdditionalTimeslots(): Sequence(&theInfo) {}

	void setDownlinkAdditionalTimeslotsParameters(const DownlinkAdditionalTimeslotsParameters& downlinkAdditionalTimeslotsParameters) { *static_cast<DownlinkAdditionalTimeslotsParameters*>(items[0]) = downlinkAdditionalTimeslotsParameters; }
};

typedef SequenceOf<DownlinkAdditionalTimeslots, CONSTRAINED, 1, maxTS_1> DownlinkTimeslotsCodesMoreTimeslotsAdditionalTimeslotsTimeslotList;

class DownlinkTimeslotsCodesMoreTimeslotsAdditionalTimeslots : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DownlinkTimeslotsCodesMoreTimeslotsAdditionalTimeslotsChoices {
		downlinkTimeslotsCodesMoreTimeslotsAdditionalTimeslotsConsecutive = 0,
		downlinkTimeslotsCodesMoreTimeslotsAdditionalTimeslotsTimeslotList = 1,
	};
	static const Info theInfo;
	DownlinkTimeslotsCodesMoreTimeslotsAdditionalTimeslots(): Choice(&theInfo) {}
};

class DownlinkTimeslotsCodesMoreTimeslots : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DownlinkTimeslotsCodesMoreTimeslotsChoices {
		downlinkTimeslotsCodesMoreTimeslotsNoMore = 0,
		downlinkTimeslotsCodesMoreTimeslotsAdditionalTimeslots = 1,
	};
	static const Info theInfo;
	DownlinkTimeslotsCodesMoreTimeslots(): Choice(&theInfo) {}
};

class DownlinkTimeslotsCodes : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DownlinkTimeslotsCodes(): Sequence(&theInfo) {}

	void setFirstIndividualTimeslotInfo(const IndividualTimeslotInfo& firstIndividualTimeslotInfo) { *static_cast<IndividualTimeslotInfo*>(items[0]) = firstIndividualTimeslotInfo; }
	void setDlTSChannelisationCodesShort(const DLTSChannelisationCodesShort& dlTSChannelisationCodesShort) { *static_cast<DLTSChannelisationCodesShort*>(items[1]) = dlTSChannelisationCodesShort; }
	void setDownlinkTimeslotsCodesMoreTimeslots(const DownlinkTimeslotsCodesMoreTimeslots& downlinkTimeslotsCodesMoreTimeslots) { *static_cast<DownlinkTimeslotsCodesMoreTimeslots*>(items[2]) = downlinkTimeslotsCodesMoreTimeslots; }
};

typedef SequenceOf<TFCSIdentity, CONSTRAINED, 0, maxCCTrCH> ULCCTrChTPCList;

class DLCCTrCh : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	DLCCTrCh(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setTimeInfo(const TimeInfo& timeInfo) { *static_cast<TimeInfo*>(items[1]) = timeInfo; }
	void setCommonTimeslotInfo(const CommonTimeslotInfo& commonTimeslotInfo) { *static_cast<CommonTimeslotInfo*>(items[2]) = commonTimeslotInfo; }
	void setDlCCTrCHTimeslotsCodes(const DownlinkTimeslotsCodes& dlCCTrCHTimeslotsCodes) { *static_cast<DownlinkTimeslotsCodes*>(items[3]) = dlCCTrCHTimeslotsCodes; }
	void setUlCCTrChTPCList(const ULCCTrChTPCList& ulCCTrChTPCList) { *static_cast<ULCCTrChTPCList*>(items[4]) = ulCCTrChTPCList; }
};

class DLCCTrChr4TddOptionTdd384 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLCCTrChr4TddOptionTdd384(): Sequence(&theInfo) {}

	void setDlCCTrCHTimeslotsCodes(const DownlinkTimeslotsCodes& dlCCTrCHTimeslotsCodes) { *static_cast<DownlinkTimeslotsCodes*>(items[0]) = dlCCTrCHTimeslotsCodes; }
};

typedef Boolean IndividualTimeslotInfoLCRr4TfciExistence;

enum IndividualTimeslotInfoLCRr4modulationValues {
	mod_QPSK_IndividualTimeslotInfoLCRr4modulation = 0,
	mod_8PSK_IndividualTimeslotInfoLCRr4modulation = 1,
};
typedef Enumerated<CONSTRAINED, 1> IndividualTimeslotInfoLCRr4modulation;

enum IndividualTimeslotInfoLCRr4ss_TPC_SymbolsValues {
	zero_IndividualTimeslotInfoLCRr4ss_TPC_Symbols = 0,
	one_IndividualTimeslotInfoLCRr4ss_TPC_Symbols = 1,
	sixteenOverSF_IndividualTimeslotInfoLCRr4ss_TPC_Symbols = 2,
};
typedef Enumerated<CONSTRAINED, 2> IndividualTimeslotInfoLCRr4ss_TPC_Symbols;

typedef Integer<CONSTRAINED, 1, 15> IndividualTimeslotInfoLCRr4AdditionalSSTPCSymbols;

class IndividualTimeslotInfoLCRr4 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	IndividualTimeslotInfoLCRr4(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumberLCRr4& timeslotNumber) { *static_cast<TimeslotNumberLCRr4*>(items[0]) = timeslotNumber; }
	void setIndividualTimeslotInfoLCRr4TfciExistence(const IndividualTimeslotInfoLCRr4TfciExistence& individualTimeslotInfoLCRr4TfciExistence) { *static_cast<IndividualTimeslotInfoLCRr4TfciExistence*>(items[1]) = individualTimeslotInfoLCRr4TfciExistence; }
	void setMidambleShiftAndBurstType(const MidambleShiftAndBurstTypeLCRr4& midambleShiftAndBurstType) { *static_cast<MidambleShiftAndBurstTypeLCRr4*>(items[2]) = midambleShiftAndBurstType; }
	void setIndividualTimeslotInfoLCRr4modulation(const IndividualTimeslotInfoLCRr4modulation& individualTimeslotInfoLCRr4modulation) { *static_cast<IndividualTimeslotInfoLCRr4modulation*>(items[3]) = individualTimeslotInfoLCRr4modulation; }
	void setIndividualTimeslotInfoLCRr4ss_TPC_Symbols(const IndividualTimeslotInfoLCRr4ss_TPC_Symbols& individualTimeslotInfoLCRr4ss_TPC_Symbols) { *static_cast<IndividualTimeslotInfoLCRr4ss_TPC_Symbols*>(items[4]) = individualTimeslotInfoLCRr4ss_TPC_Symbols; }
	void setIndividualTimeslotInfoLCRr4AdditionalSSTPCSymbols(const IndividualTimeslotInfoLCRr4AdditionalSSTPCSymbols& individualTimeslotInfoLCRr4AdditionalSSTPCSymbols) { *static_cast<IndividualTimeslotInfoLCRr4AdditionalSSTPCSymbols*>(items[5]) = individualTimeslotInfoLCRr4AdditionalSSTPCSymbols; }
};

typedef Null DownlinkTimeslotsCodesLCRr4MoreTimeslotsNoMore;

typedef Integer<CONSTRAINED, 1, maxTS_LCR_1> DownlinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslotsConsecutive;

class DownlinkAdditionalTimeslotsLCRr4ParametersSameAsLast : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DownlinkAdditionalTimeslotsLCRr4ParametersSameAsLast(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumberLCRr4& timeslotNumber) { *static_cast<TimeslotNumberLCRr4*>(items[0]) = timeslotNumber; }
};

class DownlinkAdditionalTimeslotsLCRr4ParametersNewParameters : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DownlinkAdditionalTimeslotsLCRr4ParametersNewParameters(): Sequence(&theInfo) {}

	void setIndividualTimeslotInfo(const IndividualTimeslotInfoLCRr4& individualTimeslotInfo) { *static_cast<IndividualTimeslotInfoLCRr4*>(items[0]) = individualTimeslotInfo; }
	void setDlTSChannelisationCodesShort(const DLTSChannelisationCodesShort& dlTSChannelisationCodesShort) { *static_cast<DLTSChannelisationCodesShort*>(items[1]) = dlTSChannelisationCodesShort; }
};

class DownlinkAdditionalTimeslotsLCRr4Parameters : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DownlinkAdditionalTimeslotsLCRr4ParametersChoices {
		downlinkAdditionalTimeslotsLCRr4ParametersSameAsLast = 0,
		downlinkAdditionalTimeslotsLCRr4ParametersNewParameters = 1,
	};
	static const Info theInfo;
	DownlinkAdditionalTimeslotsLCRr4Parameters(): Choice(&theInfo) {}
};

class DownlinkAdditionalTimeslotsLCRr4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DownlinkAdditionalTimeslotsLCRr4(): Sequence(&theInfo) {}

	void setDownlinkAdditionalTimeslotsLCRr4Parameters(const DownlinkAdditionalTimeslotsLCRr4Parameters& downlinkAdditionalTimeslotsLCRr4Parameters) { *static_cast<DownlinkAdditionalTimeslotsLCRr4Parameters*>(items[0]) = downlinkAdditionalTimeslotsLCRr4Parameters; }
};

typedef SequenceOf<DownlinkAdditionalTimeslotsLCRr4, CONSTRAINED, 1, maxTS_LCR_1> DownlinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslotsTimeslotList;

class DownlinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslots : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DownlinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslotsChoices {
		downlinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslotsConsecutive = 0,
		downlinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslotsTimeslotList = 1,
	};
	static const Info theInfo;
	DownlinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslots(): Choice(&theInfo) {}
};

class DownlinkTimeslotsCodesLCRr4MoreTimeslots : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DownlinkTimeslotsCodesLCRr4MoreTimeslotsChoices {
		downlinkTimeslotsCodesLCRr4MoreTimeslotsNoMore = 0,
		downlinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslots = 1,
	};
	static const Info theInfo;
	DownlinkTimeslotsCodesLCRr4MoreTimeslots(): Choice(&theInfo) {}
};

class DownlinkTimeslotsCodesLCRr4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DownlinkTimeslotsCodesLCRr4(): Sequence(&theInfo) {}

	void setFirstIndividualTimeslotInfo(const IndividualTimeslotInfoLCRr4& firstIndividualTimeslotInfo) { *static_cast<IndividualTimeslotInfoLCRr4*>(items[0]) = firstIndividualTimeslotInfo; }
	void setDlTSChannelisationCodesShort(const DLTSChannelisationCodesShort& dlTSChannelisationCodesShort) { *static_cast<DLTSChannelisationCodesShort*>(items[1]) = dlTSChannelisationCodesShort; }
	void setDownlinkTimeslotsCodesLCRr4MoreTimeslots(const DownlinkTimeslotsCodesLCRr4MoreTimeslots& downlinkTimeslotsCodesLCRr4MoreTimeslots) { *static_cast<DownlinkTimeslotsCodesLCRr4MoreTimeslots*>(items[2]) = downlinkTimeslotsCodesLCRr4MoreTimeslots; }
};

class DLCCTrChr4TddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLCCTrChr4TddOptionTdd128(): Sequence(&theInfo) {}

	void setDlCCTrCHTimeslotsCodes(const DownlinkTimeslotsCodesLCRr4& dlCCTrCHTimeslotsCodes) { *static_cast<DownlinkTimeslotsCodesLCRr4*>(items[0]) = dlCCTrCHTimeslotsCodes; }
};

class DLCCTrChr4TddOption : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLCCTrChr4TddOptionChoices {
		dLCCTrChr4TddOptionTdd384 = 0,
		dLCCTrChr4TddOptionTdd128 = 1,
	};
	static const Info theInfo;
	DLCCTrChr4TddOption(): Choice(&theInfo) {}
};

class DLCCTrChr4 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	DLCCTrChr4(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setTimeInfo(const TimeInfo& timeInfo) { *static_cast<TimeInfo*>(items[1]) = timeInfo; }
	void setCommonTimeslotInfo(const CommonTimeslotInfo& commonTimeslotInfo) { *static_cast<CommonTimeslotInfo*>(items[2]) = commonTimeslotInfo; }
	void setDLCCTrChr4TddOption(const DLCCTrChr4TddOption& dLCCTrChr4TddOption) { *static_cast<DLCCTrChr4TddOption*>(items[3]) = dLCCTrChr4TddOption; }
	void setUlCCTrChTPCList(const ULCCTrChTPCList& ulCCTrChTPCList) { *static_cast<ULCCTrChTPCList*>(items[4]) = ulCCTrChTPCList; }
};

typedef Boolean IndividualTimeslotInfor7TfciExistence;

typedef Null MidambleShiftAndBurstTyper7BurstTypeType1MidambleAllocationModeDefaultMidamble;

typedef Null MidambleShiftAndBurstTyper7BurstTypeType1MidambleAllocationModeCommonMidamble;

class MidambleShiftAndBurstTyper7BurstTypeType1MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTyper7BurstTypeType1MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftLong& midambleShift) { *static_cast<MidambleShiftLong*>(items[0]) = midambleShift; }
};

class MidambleShiftAndBurstTyper7BurstTypeType1MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MidambleShiftAndBurstTyper7BurstTypeType1MidambleAllocationModeChoices {
		midambleShiftAndBurstTyper7BurstTypeType1MidambleAllocationModeDefaultMidamble = 0,
		midambleShiftAndBurstTyper7BurstTypeType1MidambleAllocationModeCommonMidamble = 1,
		midambleShiftAndBurstTyper7BurstTypeType1MidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTyper7BurstTypeType1MidambleAllocationMode(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstTyper7BurstTypeType1 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTyper7BurstTypeType1(): Sequence(&theInfo) {}

	void setMidambleConfigurationBurstType1and3(const MidambleConfigurationBurstType1and3& midambleConfigurationBurstType1and3) { *static_cast<MidambleConfigurationBurstType1and3*>(items[0]) = midambleConfigurationBurstType1and3; }
	void setMidambleShiftAndBurstTyper7BurstTypeType1MidambleAllocationMode(const MidambleShiftAndBurstTyper7BurstTypeType1MidambleAllocationMode& midambleShiftAndBurstTyper7BurstTypeType1MidambleAllocationMode) { *static_cast<MidambleShiftAndBurstTyper7BurstTypeType1MidambleAllocationMode*>(items[1]) = midambleShiftAndBurstTyper7BurstTypeType1MidambleAllocationMode; }
};

typedef Null MidambleShiftAndBurstTyper7BurstTypeType2MidambleAllocationModeDefaultMidamble;

typedef Null MidambleShiftAndBurstTyper7BurstTypeType2MidambleAllocationModeCommonMidamble;

class MidambleShiftAndBurstTyper7BurstTypeType2MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTyper7BurstTypeType2MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftShort& midambleShift) { *static_cast<MidambleShiftShort*>(items[0]) = midambleShift; }
};

class MidambleShiftAndBurstTyper7BurstTypeType2MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MidambleShiftAndBurstTyper7BurstTypeType2MidambleAllocationModeChoices {
		midambleShiftAndBurstTyper7BurstTypeType2MidambleAllocationModeDefaultMidamble = 0,
		midambleShiftAndBurstTyper7BurstTypeType2MidambleAllocationModeCommonMidamble = 1,
		midambleShiftAndBurstTyper7BurstTypeType2MidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTyper7BurstTypeType2MidambleAllocationMode(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstTyper7BurstTypeType2 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTyper7BurstTypeType2(): Sequence(&theInfo) {}

	void setMidambleConfigurationBurstType2(const MidambleConfigurationBurstType2& midambleConfigurationBurstType2) { *static_cast<MidambleConfigurationBurstType2*>(items[0]) = midambleConfigurationBurstType2; }
	void setMidambleShiftAndBurstTyper7BurstTypeType2MidambleAllocationMode(const MidambleShiftAndBurstTyper7BurstTypeType2MidambleAllocationMode& midambleShiftAndBurstTyper7BurstTypeType2MidambleAllocationMode) { *static_cast<MidambleShiftAndBurstTyper7BurstTypeType2MidambleAllocationMode*>(items[1]) = midambleShiftAndBurstTyper7BurstTypeType2MidambleAllocationMode; }
};

typedef Null MidambleShiftAndBurstTyper7BurstTypeType3MidambleAllocationModeDefaultMidamble;

class MidambleShiftAndBurstTyper7BurstTypeType3MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTyper7BurstTypeType3MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftLong& midambleShift) { *static_cast<MidambleShiftLong*>(items[0]) = midambleShift; }
};

class MidambleShiftAndBurstTyper7BurstTypeType3MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MidambleShiftAndBurstTyper7BurstTypeType3MidambleAllocationModeChoices {
		midambleShiftAndBurstTyper7BurstTypeType3MidambleAllocationModeDefaultMidamble = 0,
		midambleShiftAndBurstTyper7BurstTypeType3MidambleAllocationModeUeSpecificMidamble = 1,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTyper7BurstTypeType3MidambleAllocationMode(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstTyper7BurstTypeType3 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTyper7BurstTypeType3(): Sequence(&theInfo) {}

	void setMidambleConfigurationBurstType1and3(const MidambleConfigurationBurstType1and3& midambleConfigurationBurstType1and3) { *static_cast<MidambleConfigurationBurstType1and3*>(items[0]) = midambleConfigurationBurstType1and3; }
	void setMidambleShiftAndBurstTyper7BurstTypeType3MidambleAllocationMode(const MidambleShiftAndBurstTyper7BurstTypeType3MidambleAllocationMode& midambleShiftAndBurstTyper7BurstTypeType3MidambleAllocationMode) { *static_cast<MidambleShiftAndBurstTyper7BurstTypeType3MidambleAllocationMode*>(items[1]) = midambleShiftAndBurstTyper7BurstTypeType3MidambleAllocationMode; }
};

typedef Null MidambleShiftAndBurstTyper7BurstTypeMbsfnBurstType4;

class MidambleShiftAndBurstTyper7BurstType : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum MidambleShiftAndBurstTyper7BurstTypeChoices {
		midambleShiftAndBurstTyper7BurstTypeType1 = 0,
		midambleShiftAndBurstTyper7BurstTypeType2 = 1,
		midambleShiftAndBurstTyper7BurstTypeType3 = 2,
		midambleShiftAndBurstTyper7BurstTypeMbsfnBurstType4 = 3,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTyper7BurstType(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstTyper7 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTyper7(): Sequence(&theInfo) {}

	void setMidambleShiftAndBurstTyper7BurstType(const MidambleShiftAndBurstTyper7BurstType& midambleShiftAndBurstTyper7BurstType) { *static_cast<MidambleShiftAndBurstTyper7BurstType*>(items[0]) = midambleShiftAndBurstTyper7BurstType; }
};

class IndividualTimeslotInfor7 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	IndividualTimeslotInfor7(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumber& timeslotNumber) { *static_cast<TimeslotNumber*>(items[0]) = timeslotNumber; }
	void setIndividualTimeslotInfor7TfciExistence(const IndividualTimeslotInfor7TfciExistence& individualTimeslotInfor7TfciExistence) { *static_cast<IndividualTimeslotInfor7TfciExistence*>(items[1]) = individualTimeslotInfor7TfciExistence; }
	void setMidambleShiftAndBurstType(const MidambleShiftAndBurstTyper7& midambleShiftAndBurstType) { *static_cast<MidambleShiftAndBurstTyper7*>(items[2]) = midambleShiftAndBurstType; }
};

typedef Null DownlinkTimeslotsCodesr7MoreTimeslotsNoMore;

typedef Integer<CONSTRAINED, 1, maxTS_1> DownlinkTimeslotsCodesr7MoreTimeslotsAdditionalTimeslotsConsecutive;

class DownlinkAdditionalTimeslotsr7ParametersSameAsLast : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DownlinkAdditionalTimeslotsr7ParametersSameAsLast(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumber& timeslotNumber) { *static_cast<TimeslotNumber*>(items[0]) = timeslotNumber; }
};

class DownlinkAdditionalTimeslotsr7ParametersNewParameters : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DownlinkAdditionalTimeslotsr7ParametersNewParameters(): Sequence(&theInfo) {}

	void setIndividualTimeslotInfo(const IndividualTimeslotInfor7& individualTimeslotInfo) { *static_cast<IndividualTimeslotInfor7*>(items[0]) = individualTimeslotInfo; }
	void setDlTSChannelisationCodesShort(const DLTSChannelisationCodesShort& dlTSChannelisationCodesShort) { *static_cast<DLTSChannelisationCodesShort*>(items[1]) = dlTSChannelisationCodesShort; }
};

class DownlinkAdditionalTimeslotsr7Parameters : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DownlinkAdditionalTimeslotsr7ParametersChoices {
		downlinkAdditionalTimeslotsr7ParametersSameAsLast = 0,
		downlinkAdditionalTimeslotsr7ParametersNewParameters = 1,
	};
	static const Info theInfo;
	DownlinkAdditionalTimeslotsr7Parameters(): Choice(&theInfo) {}
};

class DownlinkAdditionalTimeslotsr7 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DownlinkAdditionalTimeslotsr7(): Sequence(&theInfo) {}

	void setDownlinkAdditionalTimeslotsr7Parameters(const DownlinkAdditionalTimeslotsr7Parameters& downlinkAdditionalTimeslotsr7Parameters) { *static_cast<DownlinkAdditionalTimeslotsr7Parameters*>(items[0]) = downlinkAdditionalTimeslotsr7Parameters; }
};

typedef SequenceOf<DownlinkAdditionalTimeslotsr7, CONSTRAINED, 1, maxTS_1> DownlinkTimeslotsCodesr7MoreTimeslotsAdditionalTimeslotsTimeslotList;

class DownlinkTimeslotsCodesr7MoreTimeslotsAdditionalTimeslots : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DownlinkTimeslotsCodesr7MoreTimeslotsAdditionalTimeslotsChoices {
		downlinkTimeslotsCodesr7MoreTimeslotsAdditionalTimeslotsConsecutive = 0,
		downlinkTimeslotsCodesr7MoreTimeslotsAdditionalTimeslotsTimeslotList = 1,
	};
	static const Info theInfo;
	DownlinkTimeslotsCodesr7MoreTimeslotsAdditionalTimeslots(): Choice(&theInfo) {}
};

class DownlinkTimeslotsCodesr7MoreTimeslots : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DownlinkTimeslotsCodesr7MoreTimeslotsChoices {
		downlinkTimeslotsCodesr7MoreTimeslotsNoMore = 0,
		downlinkTimeslotsCodesr7MoreTimeslotsAdditionalTimeslots = 1,
	};
	static const Info theInfo;
	DownlinkTimeslotsCodesr7MoreTimeslots(): Choice(&theInfo) {}
};

class DownlinkTimeslotsCodesr7 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DownlinkTimeslotsCodesr7(): Sequence(&theInfo) {}

	void setFirstIndividualTimeslotInfo(const IndividualTimeslotInfor7& firstIndividualTimeslotInfo) { *static_cast<IndividualTimeslotInfor7*>(items[0]) = firstIndividualTimeslotInfo; }
	void setDlTSChannelisationCodesShort(const DLTSChannelisationCodesShort& dlTSChannelisationCodesShort) { *static_cast<DLTSChannelisationCodesShort*>(items[1]) = dlTSChannelisationCodesShort; }
	void setDownlinkTimeslotsCodesr7MoreTimeslots(const DownlinkTimeslotsCodesr7MoreTimeslots& downlinkTimeslotsCodesr7MoreTimeslots) { *static_cast<DownlinkTimeslotsCodesr7MoreTimeslots*>(items[2]) = downlinkTimeslotsCodesr7MoreTimeslots; }
};

class DLCCTrChr7TddOptionTdd384 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLCCTrChr7TddOptionTdd384(): Sequence(&theInfo) {}

	void setDlCCTrCHTimeslotsCodes(const DownlinkTimeslotsCodesr7& dlCCTrCHTimeslotsCodes) { *static_cast<DownlinkTimeslotsCodesr7*>(items[0]) = dlCCTrCHTimeslotsCodes; }
};

typedef Boolean IndividualTimeslotInfoVHCRTfciExistence;

typedef Null MidambleShiftAndBurstTypeVHCRBurstTypeType1MidambleAllocationModeDefaultMidamble;

typedef Null MidambleShiftAndBurstTypeVHCRBurstTypeType1MidambleAllocationModeCommonMidamble;

class MidambleShiftAndBurstTypeVHCRBurstTypeType1MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeVHCRBurstTypeType1MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftLong& midambleShift) { *static_cast<MidambleShiftLong*>(items[0]) = midambleShift; }
};

class MidambleShiftAndBurstTypeVHCRBurstTypeType1MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MidambleShiftAndBurstTypeVHCRBurstTypeType1MidambleAllocationModeChoices {
		midambleShiftAndBurstTypeVHCRBurstTypeType1MidambleAllocationModeDefaultMidamble = 0,
		midambleShiftAndBurstTypeVHCRBurstTypeType1MidambleAllocationModeCommonMidamble = 1,
		midambleShiftAndBurstTypeVHCRBurstTypeType1MidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTypeVHCRBurstTypeType1MidambleAllocationMode(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstTypeVHCRBurstTypeType1 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeVHCRBurstTypeType1(): Sequence(&theInfo) {}

	void setMidambleConfigurationBurstType1and3(const MidambleConfigurationBurstType1and3& midambleConfigurationBurstType1and3) { *static_cast<MidambleConfigurationBurstType1and3*>(items[0]) = midambleConfigurationBurstType1and3; }
	void setMidambleShiftAndBurstTypeVHCRBurstTypeType1MidambleAllocationMode(const MidambleShiftAndBurstTypeVHCRBurstTypeType1MidambleAllocationMode& midambleShiftAndBurstTypeVHCRBurstTypeType1MidambleAllocationMode) { *static_cast<MidambleShiftAndBurstTypeVHCRBurstTypeType1MidambleAllocationMode*>(items[1]) = midambleShiftAndBurstTypeVHCRBurstTypeType1MidambleAllocationMode; }
};

enum MidambleConfigurationBurstType2VHCRValues {
	ms4_MidambleConfigurationBurstType2VHCR = 0,
	ms8_MidambleConfigurationBurstType2VHCR = 1,
};
typedef Enumerated<CONSTRAINED, 1> MidambleConfigurationBurstType2VHCR;

typedef Null MidambleShiftAndBurstTypeVHCRBurstTypeType2MidambleAllocationModeDefaultMidamble;

typedef Null MidambleShiftAndBurstTypeVHCRBurstTypeType2MidambleAllocationModeCommonMidamble;

typedef Integer<CONSTRAINED, 0, 7> MidambleShiftShortVHCR;

class MidambleShiftAndBurstTypeVHCRBurstTypeType2MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeVHCRBurstTypeType2MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftShortVHCR& midambleShift) { *static_cast<MidambleShiftShortVHCR*>(items[0]) = midambleShift; }
};

class MidambleShiftAndBurstTypeVHCRBurstTypeType2MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MidambleShiftAndBurstTypeVHCRBurstTypeType2MidambleAllocationModeChoices {
		midambleShiftAndBurstTypeVHCRBurstTypeType2MidambleAllocationModeDefaultMidamble = 0,
		midambleShiftAndBurstTypeVHCRBurstTypeType2MidambleAllocationModeCommonMidamble = 1,
		midambleShiftAndBurstTypeVHCRBurstTypeType2MidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTypeVHCRBurstTypeType2MidambleAllocationMode(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstTypeVHCRBurstTypeType2 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeVHCRBurstTypeType2(): Sequence(&theInfo) {}

	void setMidambleConfigurationBurstType2(const MidambleConfigurationBurstType2VHCR& midambleConfigurationBurstType2) { *static_cast<MidambleConfigurationBurstType2VHCR*>(items[0]) = midambleConfigurationBurstType2; }
	void setMidambleShiftAndBurstTypeVHCRBurstTypeType2MidambleAllocationMode(const MidambleShiftAndBurstTypeVHCRBurstTypeType2MidambleAllocationMode& midambleShiftAndBurstTypeVHCRBurstTypeType2MidambleAllocationMode) { *static_cast<MidambleShiftAndBurstTypeVHCRBurstTypeType2MidambleAllocationMode*>(items[1]) = midambleShiftAndBurstTypeVHCRBurstTypeType2MidambleAllocationMode; }
};

typedef Null MidambleShiftAndBurstTypeVHCRBurstTypeType3MidambleAllocationModeDefaultMidamble;

class MidambleShiftAndBurstTypeVHCRBurstTypeType3MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeVHCRBurstTypeType3MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftLong& midambleShift) { *static_cast<MidambleShiftLong*>(items[0]) = midambleShift; }
};

class MidambleShiftAndBurstTypeVHCRBurstTypeType3MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MidambleShiftAndBurstTypeVHCRBurstTypeType3MidambleAllocationModeChoices {
		midambleShiftAndBurstTypeVHCRBurstTypeType3MidambleAllocationModeDefaultMidamble = 0,
		midambleShiftAndBurstTypeVHCRBurstTypeType3MidambleAllocationModeUeSpecificMidamble = 1,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTypeVHCRBurstTypeType3MidambleAllocationMode(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstTypeVHCRBurstTypeType3 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeVHCRBurstTypeType3(): Sequence(&theInfo) {}

	void setMidambleConfigurationBurstType1and3(const MidambleConfigurationBurstType1and3& midambleConfigurationBurstType1and3) { *static_cast<MidambleConfigurationBurstType1and3*>(items[0]) = midambleConfigurationBurstType1and3; }
	void setMidambleShiftAndBurstTypeVHCRBurstTypeType3MidambleAllocationMode(const MidambleShiftAndBurstTypeVHCRBurstTypeType3MidambleAllocationMode& midambleShiftAndBurstTypeVHCRBurstTypeType3MidambleAllocationMode) { *static_cast<MidambleShiftAndBurstTypeVHCRBurstTypeType3MidambleAllocationMode*>(items[1]) = midambleShiftAndBurstTypeVHCRBurstTypeType3MidambleAllocationMode; }
};

typedef Null MidambleShiftAndBurstTypeVHCRBurstTypeMbsfnBurstType4;

class MidambleShiftAndBurstTypeVHCRBurstType : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum MidambleShiftAndBurstTypeVHCRBurstTypeChoices {
		midambleShiftAndBurstTypeVHCRBurstTypeType1 = 0,
		midambleShiftAndBurstTypeVHCRBurstTypeType2 = 1,
		midambleShiftAndBurstTypeVHCRBurstTypeType3 = 2,
		midambleShiftAndBurstTypeVHCRBurstTypeMbsfnBurstType4 = 3,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTypeVHCRBurstType(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstTypeVHCR : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeVHCR(): Sequence(&theInfo) {}

	void setMidambleShiftAndBurstTypeVHCRBurstType(const MidambleShiftAndBurstTypeVHCRBurstType& midambleShiftAndBurstTypeVHCRBurstType) { *static_cast<MidambleShiftAndBurstTypeVHCRBurstType*>(items[0]) = midambleShiftAndBurstTypeVHCRBurstType; }
};

class IndividualTimeslotInfoVHCR : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	IndividualTimeslotInfoVHCR(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumber& timeslotNumber) { *static_cast<TimeslotNumber*>(items[0]) = timeslotNumber; }
	void setIndividualTimeslotInfoVHCRTfciExistence(const IndividualTimeslotInfoVHCRTfciExistence& individualTimeslotInfoVHCRTfciExistence) { *static_cast<IndividualTimeslotInfoVHCRTfciExistence*>(items[1]) = individualTimeslotInfoVHCRTfciExistence; }
	void setMidambleShiftAndBurstTypeVHCR(const MidambleShiftAndBurstTypeVHCR& midambleShiftAndBurstTypeVHCR) { *static_cast<MidambleShiftAndBurstTypeVHCR*>(items[2]) = midambleShiftAndBurstTypeVHCR; }
};

class DLTSChannelisationCodesShortVHCRCodesRepresentationConsecutive : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLTSChannelisationCodesShortVHCRCodesRepresentationConsecutive(): Sequence(&theInfo) {}

	void setFirstChannelisationCode(const DLTSChannelisationCodeVHCR& firstChannelisationCode) { *static_cast<DLTSChannelisationCodeVHCR*>(items[0]) = firstChannelisationCode; }
	void setLastChannelisationCode(const DLTSChannelisationCodeVHCR& lastChannelisationCode) { *static_cast<DLTSChannelisationCodeVHCR*>(items[1]) = lastChannelisationCode; }
};

typedef BitString<CONSTRAINED, 32, 32> DLTSChannelisationCodesShortVHCRCodesRepresentationBitmap;

class DLTSChannelisationCodesShortVHCRCodesRepresentation : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLTSChannelisationCodesShortVHCRCodesRepresentationChoices {
		dLTSChannelisationCodesShortVHCRCodesRepresentationConsecutive = 0,
		dLTSChannelisationCodesShortVHCRCodesRepresentationBitmap = 1,
	};
	static const Info theInfo;
	DLTSChannelisationCodesShortVHCRCodesRepresentation(): Choice(&theInfo) {}
};

class DLTSChannelisationCodesShortVHCR : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLTSChannelisationCodesShortVHCR(): Sequence(&theInfo) {}

	void setDLTSChannelisationCodesShortVHCRCodesRepresentation(const DLTSChannelisationCodesShortVHCRCodesRepresentation& dLTSChannelisationCodesShortVHCRCodesRepresentation) { *static_cast<DLTSChannelisationCodesShortVHCRCodesRepresentation*>(items[0]) = dLTSChannelisationCodesShortVHCRCodesRepresentation; }
};

typedef Null DownlinkTimeslotsCodesVHCRMoreTimeslotsNoMore;

typedef Integer<CONSTRAINED, 1, maxTS_1> DownlinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslotsConsecutive;

class DownlinkAdditionalTimeslotsVHCRParametersSameAsLast : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DownlinkAdditionalTimeslotsVHCRParametersSameAsLast(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumber& timeslotNumber) { *static_cast<TimeslotNumber*>(items[0]) = timeslotNumber; }
};

class DownlinkAdditionalTimeslotsVHCRParametersNewParameters : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DownlinkAdditionalTimeslotsVHCRParametersNewParameters(): Sequence(&theInfo) {}

	void setIndividualTimeslotInfo(const IndividualTimeslotInfoVHCR& individualTimeslotInfo) { *static_cast<IndividualTimeslotInfoVHCR*>(items[0]) = individualTimeslotInfo; }
	void setDlTSChannelisationCodesShort(const DLTSChannelisationCodesShortVHCR& dlTSChannelisationCodesShort) { *static_cast<DLTSChannelisationCodesShortVHCR*>(items[1]) = dlTSChannelisationCodesShort; }
};

class DownlinkAdditionalTimeslotsVHCRParameters : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DownlinkAdditionalTimeslotsVHCRParametersChoices {
		downlinkAdditionalTimeslotsVHCRParametersSameAsLast = 0,
		downlinkAdditionalTimeslotsVHCRParametersNewParameters = 1,
	};
	static const Info theInfo;
	DownlinkAdditionalTimeslotsVHCRParameters(): Choice(&theInfo) {}
};

class DownlinkAdditionalTimeslotsVHCR : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DownlinkAdditionalTimeslotsVHCR(): Sequence(&theInfo) {}

	void setDownlinkAdditionalTimeslotsVHCRParameters(const DownlinkAdditionalTimeslotsVHCRParameters& downlinkAdditionalTimeslotsVHCRParameters) { *static_cast<DownlinkAdditionalTimeslotsVHCRParameters*>(items[0]) = downlinkAdditionalTimeslotsVHCRParameters; }
};

typedef SequenceOf<DownlinkAdditionalTimeslotsVHCR, CONSTRAINED, 1, maxTS_1> DownlinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslotsTimeslotList;

class DownlinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslots : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DownlinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslotsChoices {
		downlinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslotsConsecutive = 0,
		downlinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslotsTimeslotList = 1,
	};
	static const Info theInfo;
	DownlinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslots(): Choice(&theInfo) {}
};

class DownlinkTimeslotsCodesVHCRMoreTimeslots : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DownlinkTimeslotsCodesVHCRMoreTimeslotsChoices {
		downlinkTimeslotsCodesVHCRMoreTimeslotsNoMore = 0,
		downlinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslots = 1,
	};
	static const Info theInfo;
	DownlinkTimeslotsCodesVHCRMoreTimeslots(): Choice(&theInfo) {}
};

class DownlinkTimeslotsCodesVHCR : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DownlinkTimeslotsCodesVHCR(): Sequence(&theInfo) {}

	void setFirstIndividualTimeslotInfo(const IndividualTimeslotInfoVHCR& firstIndividualTimeslotInfo) { *static_cast<IndividualTimeslotInfoVHCR*>(items[0]) = firstIndividualTimeslotInfo; }
	void setDlTSChannelisationCodesShort(const DLTSChannelisationCodesShortVHCR& dlTSChannelisationCodesShort) { *static_cast<DLTSChannelisationCodesShortVHCR*>(items[1]) = dlTSChannelisationCodesShort; }
	void setDownlinkTimeslotsCodesVHCRMoreTimeslots(const DownlinkTimeslotsCodesVHCRMoreTimeslots& downlinkTimeslotsCodesVHCRMoreTimeslots) { *static_cast<DownlinkTimeslotsCodesVHCRMoreTimeslots*>(items[2]) = downlinkTimeslotsCodesVHCRMoreTimeslots; }
};

class DLCCTrChr7TddOptionTdd768 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLCCTrChr7TddOptionTdd768(): Sequence(&theInfo) {}

	void setDlCCTrCHTimeslotsCodes(const DownlinkTimeslotsCodesVHCR& dlCCTrCHTimeslotsCodes) { *static_cast<DownlinkTimeslotsCodesVHCR*>(items[0]) = dlCCTrCHTimeslotsCodes; }
};

class DLCCTrChr7TddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLCCTrChr7TddOptionTdd128(): Sequence(&theInfo) {}

	void setDlCCTrCHTimeslotsCodes(const DownlinkTimeslotsCodesLCRr4& dlCCTrCHTimeslotsCodes) { *static_cast<DownlinkTimeslotsCodesLCRr4*>(items[0]) = dlCCTrCHTimeslotsCodes; }
};

class DLCCTrChr7TddOption : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum DLCCTrChr7TddOptionChoices {
		dLCCTrChr7TddOptionTdd384 = 0,
		dLCCTrChr7TddOptionTdd768 = 1,
		dLCCTrChr7TddOptionTdd128 = 2,
	};
	static const Info theInfo;
	DLCCTrChr7TddOption(): Choice(&theInfo) {}
};

class DLCCTrChr7 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	DLCCTrChr7(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setTimeInfo(const TimeInfo& timeInfo) { *static_cast<TimeInfo*>(items[1]) = timeInfo; }
	void setCommonTimeslotInfo(const CommonTimeslotInfo& commonTimeslotInfo) { *static_cast<CommonTimeslotInfo*>(items[2]) = commonTimeslotInfo; }
	void setDLCCTrChr7TddOption(const DLCCTrChr7TddOption& dLCCTrChr7TddOption) { *static_cast<DLCCTrChr7TddOption*>(items[3]) = dLCCTrChr7TddOption; }
	void setUlCCTrChTPCList(const ULCCTrChTPCList& ulCCTrChTPCList) { *static_cast<ULCCTrChTPCList*>(items[4]) = ulCCTrChTPCList; }
};

typedef SequenceOf<DLCCTrCh, CONSTRAINED, 1, maxCCTrCH> DLCCTrChList;

typedef SequenceOf<DLCCTrChr7, CONSTRAINED, 1, maxCCTrCH> DLCCTrChListr7;

typedef SequenceOf<DLCCTrChr4, CONSTRAINED, 1, maxCCTrCH> DLCCTrChListr4;

typedef SequenceOf<TFCSIdentityPlain, CONSTRAINED, 1, maxCCTrCH> DLCCTrChListToRemove;

typedef Integer<CONSTRAINED, 0, 3> SF512AndCodeNumberSf4;

typedef Integer<CONSTRAINED, 0, 7> SF512AndCodeNumberSf8;

typedef Integer<CONSTRAINED, 0, 15> SF512AndCodeNumberSf16;

typedef Integer<CONSTRAINED, 0, 31> SF512AndCodeNumberSf32;

typedef Integer<CONSTRAINED, 0, 63> SF512AndCodeNumberSf64;

typedef Integer<CONSTRAINED, 0, 127> SF512AndCodeNumberSf128;

typedef Integer<CONSTRAINED, 0, 255> SF512AndCodeNumberSf256;

typedef Integer<CONSTRAINED, 0, 511> SF512AndCodeNumberSf512;

class SF512AndCodeNumber : public Choice {
private:
	static const void *choicesInfo[8];
public:
	enum SF512AndCodeNumberChoices {
		sF512AndCodeNumberSf4 = 0,
		sF512AndCodeNumberSf8 = 1,
		sF512AndCodeNumberSf16 = 2,
		sF512AndCodeNumberSf32 = 3,
		sF512AndCodeNumberSf64 = 4,
		sF512AndCodeNumberSf128 = 5,
		sF512AndCodeNumberSf256 = 6,
		sF512AndCodeNumberSf512 = 7,
	};
	static const Info theInfo;
	SF512AndCodeNumber(): Choice(&theInfo) {}
};

enum ScramblingCodeChangeValues {
	codeChange_ScramblingCodeChange = 0,
	noCodeChange_ScramblingCodeChange = 1,
};
typedef Enumerated<CONSTRAINED, 1> ScramblingCodeChange;

class DLChannelisationCode : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLChannelisationCode(): Sequence(&theInfo) {}

	void setSecondaryScramblingCode(const SecondaryScramblingCode& secondaryScramblingCode) { *static_cast<SecondaryScramblingCode*>(items[0]) = secondaryScramblingCode; }
	void setSfAndCodeNumber(const SF512AndCodeNumber& sfAndCodeNumber) { *static_cast<SF512AndCodeNumber*>(items[1]) = sfAndCodeNumber; }
	void setScramblingCodeChange(const ScramblingCodeChange& scramblingCodeChange) { *static_cast<ScramblingCodeChange*>(items[2]) = scramblingCodeChange; }
};

typedef SequenceOf<DLChannelisationCode, CONSTRAINED, 1, maxDPCH_DLchan> DLChannelisationCodeList;

typedef Null DLDPCHInfoCommonCfnHandlingMaintain;

class DLDPCHInfoCommonCfnHandlingInitialise : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLDPCHInfoCommonCfnHandlingInitialise(): Sequence(&theInfo) {}

	void setDummy(const Cfntargetsfnframeoffset& dummy) { *static_cast<Cfntargetsfnframeoffset*>(items[0]) = dummy; }
};

class DLDPCHInfoCommonCfnHandling : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLDPCHInfoCommonCfnHandlingChoices {
		dLDPCHInfoCommonCfnHandlingMaintain = 0,
		dLDPCHInfoCommonCfnHandlingInitialise = 1,
	};
	static const Info theInfo;
	DLDPCHInfoCommonCfnHandling(): Choice(&theInfo) {}
};

enum DPCModeValues {
	singleTPC_DPCMode = 0,
	tpcTripletInSoft_DPCMode = 1,
};
typedef Enumerated<CONSTRAINED, 1> DPCMode;

class DLDPCHPowerControlInfoModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLDPCHPowerControlInfoModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setDpcMode(const DPCMode& dpcMode) { *static_cast<DPCMode*>(items[0]) = dpcMode; }
};

class DLDPCHPowerControlInfoModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLDPCHPowerControlInfoModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setTpcStepSizeTDD(const TPCStepSizeTDD& tpcStepSizeTDD) { *static_cast<TPCStepSizeTDD*>(items[0]) = tpcStepSizeTDD; }
};

class DLDPCHPowerControlInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLDPCHPowerControlInfoModeSpecificInfoChoices {
		dLDPCHPowerControlInfoModeSpecificInfoFdd = 0,
		dLDPCHPowerControlInfoModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	DLDPCHPowerControlInfoModeSpecificInfo(): Choice(&theInfo) {}
};

class DLDPCHPowerControlInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLDPCHPowerControlInfo(): Sequence(&theInfo) {}

	void setDLDPCHPowerControlInfoModeSpecificInfo(const DLDPCHPowerControlInfoModeSpecificInfo& dLDPCHPowerControlInfoModeSpecificInfo) { *static_cast<DLDPCHPowerControlInfoModeSpecificInfo*>(items[0]) = dLDPCHPowerControlInfoModeSpecificInfo; }
};

typedef Integer<CONSTRAINED, 0, 24> PowerOffsetPilotpdpdch;

class RestrictedTrCH : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	RestrictedTrCH(): Sequence(&theInfo) {}

	void setDlrestrictedTrChType(const DLTrCHType& dlrestrictedTrChType) { *static_cast<DLTrCHType*>(items[0]) = dlrestrictedTrChType; }
	void setRestrictedDLTrCHIdentity(const TransportChannelIdentity& restrictedDLTrCHIdentity) { *static_cast<TransportChannelIdentity*>(items[1]) = restrictedDLTrCHIdentity; }
	void setAllowedTFIList(const AllowedTFIList& allowedTFIList) { *static_cast<AllowedTFIList*>(items[2]) = allowedTFIList; }
};

typedef SequenceOf<RestrictedTrCH, CONSTRAINED, 1, maxTrCH> RestrictedTrCHInfoList;

class Dlratematchingrestriction : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	Dlratematchingrestriction(): Sequence(&theInfo) {}

	void setRestrictedTrCHInfoList(const RestrictedTrCHInfoList& restrictedTrCHInfoList) { *static_cast<RestrictedTrCHInfoList*>(items[0]) = restrictedTrCHInfoList; }
};

typedef Boolean DLDPCHInfoCommonModeSpecificInfoFddTfciExistence;

class DLDPCHInfoCommonModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	DLDPCHInfoCommonModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setDlDPCHPowerControlInfo(const DLDPCHPowerControlInfo& dlDPCHPowerControlInfo) { *static_cast<DLDPCHPowerControlInfo*>(items[0]) = dlDPCHPowerControlInfo; }
	void setPowerOffsetPilotpdpdch(const PowerOffsetPilotpdpdch& powerOffsetPilotpdpdch) { *static_cast<PowerOffsetPilotpdpdch*>(items[1]) = powerOffsetPilotpdpdch; }
	void setDlratematchingrestriction(const Dlratematchingrestriction& dlratematchingrestriction) { *static_cast<Dlratematchingrestriction*>(items[2]) = dlratematchingrestriction; }
	void setSpreadingFactorAndPilot(const SF512AndPilot& spreadingFactorAndPilot) { *static_cast<SF512AndPilot*>(items[3]) = spreadingFactorAndPilot; }
	void setPositionFixedOrFlexible(const PositionFixedOrFlexible& positionFixedOrFlexible) { *static_cast<PositionFixedOrFlexible*>(items[4]) = positionFixedOrFlexible; }
	void setDLDPCHInfoCommonModeSpecificInfoFddTfciExistence(const DLDPCHInfoCommonModeSpecificInfoFddTfciExistence& dLDPCHInfoCommonModeSpecificInfoFddTfciExistence) { *static_cast<DLDPCHInfoCommonModeSpecificInfoFddTfciExistence*>(items[5]) = dLDPCHInfoCommonModeSpecificInfoFddTfciExistence; }
};

class DLDPCHInfoCommonModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLDPCHInfoCommonModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setDlDPCHPowerControlInfo(const DLDPCHPowerControlInfo& dlDPCHPowerControlInfo) { *static_cast<DLDPCHPowerControlInfo*>(items[0]) = dlDPCHPowerControlInfo; }
};

class DLDPCHInfoCommonModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLDPCHInfoCommonModeSpecificInfoChoices {
		dLDPCHInfoCommonModeSpecificInfoFdd = 0,
		dLDPCHInfoCommonModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	DLDPCHInfoCommonModeSpecificInfo(): Choice(&theInfo) {}
};

class DLDPCHInfoCommon : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLDPCHInfoCommon(): Sequence(&theInfo) {}

	void setDLDPCHInfoCommonCfnHandling(const DLDPCHInfoCommonCfnHandling& dLDPCHInfoCommonCfnHandling) { *static_cast<DLDPCHInfoCommonCfnHandling*>(items[0]) = dLDPCHInfoCommonCfnHandling; }
	void setDLDPCHInfoCommonModeSpecificInfo(const DLDPCHInfoCommonModeSpecificInfo& dLDPCHInfoCommonModeSpecificInfo) { *static_cast<DLDPCHInfoCommonModeSpecificInfo*>(items[1]) = dLDPCHInfoCommonModeSpecificInfo; }
};

typedef Integer<CONSTRAINED, 0, 255> TGCFN;

class TGPSequenceTgpsStatusActivate : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	TGPSequenceTgpsStatusActivate(): Sequence(&theInfo) {}

	void setTgcfn(const TGCFN& tgcfn) { *static_cast<TGCFN*>(items[0]) = tgcfn; }
};

typedef Null TGPSequenceTgpsStatusDeactivate;

class TGPSequenceTgpsStatus : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum TGPSequenceTgpsStatusChoices {
		tGPSequenceTgpsStatusActivate = 0,
		tGPSequenceTgpsStatusDeactivate = 1,
	};
	static const Info theInfo;
	TGPSequenceTgpsStatus(): Choice(&theInfo) {}
};

enum TGMPValues {
	tdd_Measurement_TGMP = 0,
	fdd_Measurement_TGMP = 1,
	gsm_CarrierRSSIMeasurement_TGMP = 2,
	gsm_initialBSICIdentification_TGMP = 3,
	gsmBSICReconfirmation_TGMP = 4,
	multi_carrier_TGMP = 5,
};
typedef Enumerated<CONSTRAINED, 5> TGMP;

typedef Integer<CONSTRAINED, 0, 511> TGPRC;

typedef Integer<CONSTRAINED, 0, 14> TGSN;

typedef Integer<CONSTRAINED, 1, 14> TGL;

typedef Integer<CONSTRAINED, 15, 270> TGD;

typedef Integer<CONSTRAINED, 1, 144> TGPL;

enum RPPValues {
	mode0_RPP = 0,
	mode1_RPP = 1,
};
typedef Enumerated<CONSTRAINED, 1> RPP;

enum ITPValues {
	mode0_ITP = 0,
	mode1_ITP = 1,
};
typedef Enumerated<CONSTRAINED, 1> ITP;

enum ULCompressedModeMethodValues {
	sf_2_ULCompressedModeMethod = 0,
	higherLayerScheduling_ULCompressedModeMethod = 1,
};
typedef Enumerated<CONSTRAINED, 1> ULCompressedModeMethod;

enum DLCompressedModeMethodValues {
	dummy_DLCompressedModeMethod = 0,
	sf_2_DLCompressedModeMethod = 1,
	higherLayerScheduling_DLCompressedModeMethod = 2,
};
typedef Enumerated<CONSTRAINED, 2> DLCompressedModeMethod;

class ULDLModeUlanddl : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDLModeUlanddl(): Sequence(&theInfo) {}

	void setUl(const ULCompressedModeMethod& ul) { *static_cast<ULCompressedModeMethod*>(items[0]) = ul; }
	void setDl(const DLCompressedModeMethod& dl) { *static_cast<DLCompressedModeMethod*>(items[1]) = dl; }
};

class ULDLMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum ULDLModeChoices {
		ul = 0,
		dl = 1,
		uLDLModeUlanddl = 2,
	};
	static const Info theInfo;
	ULDLMode(): Choice(&theInfo) {}
};

enum DLFrameTypeValues {
	dl_FrameTypeA_DLFrameType = 0,
	dl_FrameTypeB_DLFrameType = 1,
};
typedef Enumerated<CONSTRAINED, 1> DLFrameType;

typedef Integer<CONSTRAINED, 1, 128> NidentifyAbort;

typedef Integer<CONSTRAINED, 1, 20> TreconfirmAbort;

class TGPSConfigurationParams : public Sequence {
private:
	static const void *itemsInfo[18];
	static bool itemsPres[18];
public:
	static const Info theInfo;
	TGPSConfigurationParams(): Sequence(&theInfo) {}

	void setTgmp(const TGMP& tgmp) { *static_cast<TGMP*>(items[0]) = tgmp; }
	void setTgprc(const TGPRC& tgprc) { *static_cast<TGPRC*>(items[1]) = tgprc; }
	void setTgsn(const TGSN& tgsn) { *static_cast<TGSN*>(items[2]) = tgsn; }
	void setTgl1(const TGL& tgl1) { *static_cast<TGL*>(items[3]) = tgl1; }
	void setTgl2(const TGL& tgl2) { *static_cast<TGL*>(items[4]) = tgl2; }
	void setTgd(const TGD& tgd) { *static_cast<TGD*>(items[5]) = tgd; }
	void setTgpl1(const TGPL& tgpl1) { *static_cast<TGPL*>(items[6]) = tgpl1; }
	void setDummy(const TGPL& dummy) { *static_cast<TGPL*>(items[7]) = dummy; }
	void setRpp(const RPP& rpp) { *static_cast<RPP*>(items[8]) = rpp; }
	void setItp(const ITP& itp) { *static_cast<ITP*>(items[9]) = itp; }
	void setUlDLMode(const ULDLMode& ulDLMode) { *static_cast<ULDLMode*>(items[10]) = ulDLMode; }
	void setDlFrameType(const DLFrameType& dlFrameType) { *static_cast<DLFrameType*>(items[11]) = dlFrameType; }
	void setDeltaSIR1(const DeltaSIR& deltaSIR1) { *static_cast<DeltaSIR*>(items[12]) = deltaSIR1; }
	void setDeltaSIRAfter1(const DeltaSIR& deltaSIRAfter1) { *static_cast<DeltaSIR*>(items[13]) = deltaSIRAfter1; }
	void setDeltaSIR2(const DeltaSIR& deltaSIR2) { *static_cast<DeltaSIR*>(items[14]) = deltaSIR2; }
	void setDeltaSIRAfter2(const DeltaSIR& deltaSIRAfter2) { *static_cast<DeltaSIR*>(items[15]) = deltaSIRAfter2; }
	void setNidentifyAbort(const NidentifyAbort& nidentifyAbort) { *static_cast<NidentifyAbort*>(items[16]) = nidentifyAbort; }
	void setTreconfirmAbort(const TreconfirmAbort& treconfirmAbort) { *static_cast<TreconfirmAbort*>(items[17]) = treconfirmAbort; }
};

class TGPSequence : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	TGPSequence(): Sequence(&theInfo) {}

	void setTgpsi(const TGPSI& tgpsi) { *static_cast<TGPSI*>(items[0]) = tgpsi; }
	void setTGPSequenceTgpsStatus(const TGPSequenceTgpsStatus& tGPSequenceTgpsStatus) { *static_cast<TGPSequenceTgpsStatus*>(items[1]) = tGPSequenceTgpsStatus; }
	void setTgpsConfigurationParams(const TGPSConfigurationParams& tgpsConfigurationParams) { *static_cast<TGPSConfigurationParams*>(items[2]) = tgpsConfigurationParams; }
};

typedef SequenceOf<TGPSequence, CONSTRAINED, 1, maxTGPS> TGPSequenceList;

class DPCHCompressedModeInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DPCHCompressedModeInfo(): Sequence(&theInfo) {}

	void setTgpSequenceList(const TGPSequenceList& tgpSequenceList) { *static_cast<TGPSequenceList*>(items[0]) = tgpSequenceList; }
};

enum TXDiversityModeValues {
	noDiversity_TXDiversityMode = 0,
	sttd_TXDiversityMode = 1,
	closedLoopMode1_TXDiversityMode = 2,
	dummy_TXDiversityMode = 3,
};
typedef Enumerated<CONSTRAINED, 3> TXDiversityMode;

enum SFieldValues {
	e1bit_SField = 0,
	e2bits_SField = 1,
};
typedef Enumerated<CONSTRAINED, 1> SField;

class SSDTInformation : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SSDTInformation(): Sequence(&theInfo) {}

	void setSField(const SField& sField) { *static_cast<SField*>(items[0]) = sField; }
	void setCodeWordSet(const CodeWordSet& codeWordSet) { *static_cast<CodeWordSet*>(items[1]) = codeWordSet; }
};

class DLCommonInformationModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	DLCommonInformationModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setDefaultDPCHOffsetValue(const DefaultDPCHOffsetValueFDD& defaultDPCHOffsetValue) { *static_cast<DefaultDPCHOffsetValueFDD*>(items[0]) = defaultDPCHOffsetValue; }
	void setDpchCompressedModeInfo(const DPCHCompressedModeInfo& dpchCompressedModeInfo) { *static_cast<DPCHCompressedModeInfo*>(items[1]) = dpchCompressedModeInfo; }
	void setTxDiversityMode(const TXDiversityMode& txDiversityMode) { *static_cast<TXDiversityMode*>(items[2]) = txDiversityMode; }
	void setDummy(const SSDTInformation& dummy) { *static_cast<SSDTInformation*>(items[3]) = dummy; }
};

class DLCommonInformationModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLCommonInformationModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setDefaultDPCHOffsetValue(const DefaultDPCHOffsetValueTDD& defaultDPCHOffsetValue) { *static_cast<DefaultDPCHOffsetValueTDD*>(items[0]) = defaultDPCHOffsetValue; }
};

class DLCommonInformationModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLCommonInformationModeSpecificInfoChoices {
		dLCommonInformationModeSpecificInfoFdd = 0,
		dLCommonInformationModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	DLCommonInformationModeSpecificInfo(): Choice(&theInfo) {}
};

class DLCommonInformation : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLCommonInformation(): Sequence(&theInfo) {}

	void setDlDPCHInfoCommon(const DLDPCHInfoCommon& dlDPCHInfoCommon) { *static_cast<DLDPCHInfoCommon*>(items[0]) = dlDPCHInfoCommon; }
	void setDLCommonInformationModeSpecificInfo(const DLCommonInformationModeSpecificInfo& dLCommonInformationModeSpecificInfo) { *static_cast<DLCommonInformationModeSpecificInfo*>(items[1]) = dLCommonInformationModeSpecificInfo; }
};

typedef Null DLDPCHInfoCommonr4CfnHandlingMaintain;

class DLDPCHInfoCommonr4CfnHandlingInitialise : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLDPCHInfoCommonr4CfnHandlingInitialise(): Sequence(&theInfo) {}

	void setDummy(const Cfntargetsfnframeoffset& dummy) { *static_cast<Cfntargetsfnframeoffset*>(items[0]) = dummy; }
};

class DLDPCHInfoCommonr4CfnHandling : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLDPCHInfoCommonr4CfnHandlingChoices {
		dLDPCHInfoCommonr4CfnHandlingMaintain = 0,
		dLDPCHInfoCommonr4CfnHandlingInitialise = 1,
	};
	static const Info theInfo;
	DLDPCHInfoCommonr4CfnHandling(): Choice(&theInfo) {}
};

typedef Boolean DLDPCHInfoCommonr4ModeSpecificInfoFddTfciExistence;

class DLDPCHInfoCommonr4ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	DLDPCHInfoCommonr4ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setDlDPCHPowerControlInfo(const DLDPCHPowerControlInfo& dlDPCHPowerControlInfo) { *static_cast<DLDPCHPowerControlInfo*>(items[0]) = dlDPCHPowerControlInfo; }
	void setPowerOffsetPilotpdpdch(const PowerOffsetPilotpdpdch& powerOffsetPilotpdpdch) { *static_cast<PowerOffsetPilotpdpdch*>(items[1]) = powerOffsetPilotpdpdch; }
	void setDlratematchingrestriction(const Dlratematchingrestriction& dlratematchingrestriction) { *static_cast<Dlratematchingrestriction*>(items[2]) = dlratematchingrestriction; }
	void setSpreadingFactorAndPilot(const SF512AndPilot& spreadingFactorAndPilot) { *static_cast<SF512AndPilot*>(items[3]) = spreadingFactorAndPilot; }
	void setPositionFixedOrFlexible(const PositionFixedOrFlexible& positionFixedOrFlexible) { *static_cast<PositionFixedOrFlexible*>(items[4]) = positionFixedOrFlexible; }
	void setDLDPCHInfoCommonr4ModeSpecificInfoFddTfciExistence(const DLDPCHInfoCommonr4ModeSpecificInfoFddTfciExistence& dLDPCHInfoCommonr4ModeSpecificInfoFddTfciExistence) { *static_cast<DLDPCHInfoCommonr4ModeSpecificInfoFddTfciExistence*>(items[5]) = dLDPCHInfoCommonr4ModeSpecificInfoFddTfciExistence; }
};

class DLDPCHInfoCommonr4ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLDPCHInfoCommonr4ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setDlDPCHPowerControlInfo(const DLDPCHPowerControlInfo& dlDPCHPowerControlInfo) { *static_cast<DLDPCHPowerControlInfo*>(items[0]) = dlDPCHPowerControlInfo; }
};

class DLDPCHInfoCommonr4ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLDPCHInfoCommonr4ModeSpecificInfoChoices {
		dLDPCHInfoCommonr4ModeSpecificInfoFdd = 0,
		dLDPCHInfoCommonr4ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	DLDPCHInfoCommonr4ModeSpecificInfo(): Choice(&theInfo) {}
};

class DLDPCHInfoCommonr4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLDPCHInfoCommonr4(): Sequence(&theInfo) {}

	void setDLDPCHInfoCommonr4CfnHandling(const DLDPCHInfoCommonr4CfnHandling& dLDPCHInfoCommonr4CfnHandling) { *static_cast<DLDPCHInfoCommonr4CfnHandling*>(items[0]) = dLDPCHInfoCommonr4CfnHandling; }
	void setDLDPCHInfoCommonr4ModeSpecificInfo(const DLDPCHInfoCommonr4ModeSpecificInfo& dLDPCHInfoCommonr4ModeSpecificInfo) { *static_cast<DLDPCHInfoCommonr4ModeSpecificInfo*>(items[1]) = dLDPCHInfoCommonr4ModeSpecificInfo; }
	void setMacdHFNinitialvalue(const MACdHFNinitialvalue& macdHFNinitialvalue) { *static_cast<MACdHFNinitialvalue*>(items[2]) = macdHFNinitialvalue; }
};

enum SSDTULValues {
	ul_SSDTUL = 0,
	ul_AndDL_SSDTUL = 1,
};
typedef Enumerated<CONSTRAINED, 1> SSDTUL;

class SSDTInformationr4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SSDTInformationr4(): Sequence(&theInfo) {}

	void setSField(const SField& sField) { *static_cast<SField*>(items[0]) = sField; }
	void setCodeWordSet(const CodeWordSet& codeWordSet) { *static_cast<CodeWordSet*>(items[1]) = codeWordSet; }
	void setSsdtULr4(const SSDTUL& ssdtULr4) { *static_cast<SSDTUL*>(items[2]) = ssdtULr4; }
};

class DLCommonInformationr4ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	DLCommonInformationr4ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setDefaultDPCHOffsetValue(const DefaultDPCHOffsetValueFDD& defaultDPCHOffsetValue) { *static_cast<DefaultDPCHOffsetValueFDD*>(items[0]) = defaultDPCHOffsetValue; }
	void setDpchCompressedModeInfo(const DPCHCompressedModeInfo& dpchCompressedModeInfo) { *static_cast<DPCHCompressedModeInfo*>(items[1]) = dpchCompressedModeInfo; }
	void setTxDiversityMode(const TXDiversityMode& txDiversityMode) { *static_cast<TXDiversityMode*>(items[2]) = txDiversityMode; }
	void setDummy(const SSDTInformationr4& dummy) { *static_cast<SSDTInformationr4*>(items[3]) = dummy; }
};

typedef Null DLCommonInformationr4ModeSpecificInfoTddTddOptionTdd384;

typedef Boolean DLCommonInformationr4ModeSpecificInfoTddTddOptionTdd128TstdIndicator;

class DLCommonInformationr4ModeSpecificInfoTddTddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLCommonInformationr4ModeSpecificInfoTddTddOptionTdd128(): Sequence(&theInfo) {}

	void setDLCommonInformationr4ModeSpecificInfoTddTddOptionTdd128TstdIndicator(const DLCommonInformationr4ModeSpecificInfoTddTddOptionTdd128TstdIndicator& dLCommonInformationr4ModeSpecificInfoTddTddOptionTdd128TstdIndicator) { *static_cast<DLCommonInformationr4ModeSpecificInfoTddTddOptionTdd128TstdIndicator*>(items[0]) = dLCommonInformationr4ModeSpecificInfoTddTddOptionTdd128TstdIndicator; }
};

class DLCommonInformationr4ModeSpecificInfoTddTddOption : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLCommonInformationr4ModeSpecificInfoTddTddOptionChoices {
		dLCommonInformationr4ModeSpecificInfoTddTddOptionTdd384 = 0,
		dLCommonInformationr4ModeSpecificInfoTddTddOptionTdd128 = 1,
	};
	static const Info theInfo;
	DLCommonInformationr4ModeSpecificInfoTddTddOption(): Choice(&theInfo) {}
};

class DLCommonInformationr4ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLCommonInformationr4ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setDLCommonInformationr4ModeSpecificInfoTddTddOption(const DLCommonInformationr4ModeSpecificInfoTddTddOption& dLCommonInformationr4ModeSpecificInfoTddTddOption) { *static_cast<DLCommonInformationr4ModeSpecificInfoTddTddOption*>(items[0]) = dLCommonInformationr4ModeSpecificInfoTddTddOption; }
	void setDefaultDPCHOffsetValue(const DefaultDPCHOffsetValueTDD& defaultDPCHOffsetValue) { *static_cast<DefaultDPCHOffsetValueTDD*>(items[1]) = defaultDPCHOffsetValue; }
};

class DLCommonInformationr4ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLCommonInformationr4ModeSpecificInfoChoices {
		dLCommonInformationr4ModeSpecificInfoFdd = 0,
		dLCommonInformationr4ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	DLCommonInformationr4ModeSpecificInfo(): Choice(&theInfo) {}
};

class DLCommonInformationr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLCommonInformationr4(): Sequence(&theInfo) {}

	void setDlDPCHInfoCommon(const DLDPCHInfoCommonr4& dlDPCHInfoCommon) { *static_cast<DLDPCHInfoCommonr4*>(items[0]) = dlDPCHInfoCommon; }
	void setDLCommonInformationr4ModeSpecificInfo(const DLCommonInformationr4ModeSpecificInfo& dLCommonInformationr4ModeSpecificInfo) { *static_cast<DLCommonInformationr4ModeSpecificInfo*>(items[1]) = dLCommonInformationr4ModeSpecificInfo; }
};

class DLCommonInformationr5ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	DLCommonInformationr5ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setDefaultDPCHOffsetValue(const DefaultDPCHOffsetValueFDD& defaultDPCHOffsetValue) { *static_cast<DefaultDPCHOffsetValueFDD*>(items[0]) = defaultDPCHOffsetValue; }
	void setDpchCompressedModeInfo(const DPCHCompressedModeInfo& dpchCompressedModeInfo) { *static_cast<DPCHCompressedModeInfo*>(items[1]) = dpchCompressedModeInfo; }
	void setTxDiversityMode(const TXDiversityMode& txDiversityMode) { *static_cast<TXDiversityMode*>(items[2]) = txDiversityMode; }
	void setDummy(const SSDTInformationr4& dummy) { *static_cast<SSDTInformationr4*>(items[3]) = dummy; }
};

typedef Null DLCommonInformationr5ModeSpecificInfoTddTddOptionTdd384;

typedef Boolean DLCommonInformationr5ModeSpecificInfoTddTddOptionTdd128TstdIndicator;

class DLCommonInformationr5ModeSpecificInfoTddTddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLCommonInformationr5ModeSpecificInfoTddTddOptionTdd128(): Sequence(&theInfo) {}

	void setDLCommonInformationr5ModeSpecificInfoTddTddOptionTdd128TstdIndicator(const DLCommonInformationr5ModeSpecificInfoTddTddOptionTdd128TstdIndicator& dLCommonInformationr5ModeSpecificInfoTddTddOptionTdd128TstdIndicator) { *static_cast<DLCommonInformationr5ModeSpecificInfoTddTddOptionTdd128TstdIndicator*>(items[0]) = dLCommonInformationr5ModeSpecificInfoTddTddOptionTdd128TstdIndicator; }
};

class DLCommonInformationr5ModeSpecificInfoTddTddOption : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLCommonInformationr5ModeSpecificInfoTddTddOptionChoices {
		dLCommonInformationr5ModeSpecificInfoTddTddOptionTdd384 = 0,
		dLCommonInformationr5ModeSpecificInfoTddTddOptionTdd128 = 1,
	};
	static const Info theInfo;
	DLCommonInformationr5ModeSpecificInfoTddTddOption(): Choice(&theInfo) {}
};

class DLCommonInformationr5ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLCommonInformationr5ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setDLCommonInformationr5ModeSpecificInfoTddTddOption(const DLCommonInformationr5ModeSpecificInfoTddTddOption& dLCommonInformationr5ModeSpecificInfoTddTddOption) { *static_cast<DLCommonInformationr5ModeSpecificInfoTddTddOption*>(items[0]) = dLCommonInformationr5ModeSpecificInfoTddTddOption; }
	void setDefaultDPCHOffsetValue(const DefaultDPCHOffsetValueTDD& defaultDPCHOffsetValue) { *static_cast<DefaultDPCHOffsetValueTDD*>(items[1]) = defaultDPCHOffsetValue; }
};

class DLCommonInformationr5ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLCommonInformationr5ModeSpecificInfoChoices {
		dLCommonInformationr5ModeSpecificInfoFdd = 0,
		dLCommonInformationr5ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	DLCommonInformationr5ModeSpecificInfo(): Choice(&theInfo) {}
};

enum DLCommonInformationr5mac_hsResetIndicatorValues {
	true_DLCommonInformationr5mac_hsResetIndicator = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLCommonInformationr5mac_hsResetIndicator;

class DLCommonInformationr5 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLCommonInformationr5(): Sequence(&theInfo) {}

	void setDlDPCHInfoCommon(const DLDPCHInfoCommonr4& dlDPCHInfoCommon) { *static_cast<DLDPCHInfoCommonr4*>(items[0]) = dlDPCHInfoCommon; }
	void setDLCommonInformationr5ModeSpecificInfo(const DLCommonInformationr5ModeSpecificInfo& dLCommonInformationr5ModeSpecificInfo) { *static_cast<DLCommonInformationr5ModeSpecificInfo*>(items[1]) = dLCommonInformationr5ModeSpecificInfo; }
	void setDLCommonInformationr5mac_hsResetIndicator(const DLCommonInformationr5mac_hsResetIndicator& dLCommonInformationr5mac_hsResetIndicator) { *static_cast<DLCommonInformationr5mac_hsResetIndicator*>(items[2]) = dLCommonInformationr5mac_hsResetIndicator; }
};

enum TimingMaintainedSynchIndValues {
	false_TimingMaintainedSynchInd = 0,
};
typedef Enumerated<CONSTRAINED, 0> TimingMaintainedSynchInd;

class DLDPCHInfoCommonr6CfnHandlingMaintain : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLDPCHInfoCommonr6CfnHandlingMaintain(): Sequence(&theInfo) {}

	void setTimingmaintainedsynchind(const TimingMaintainedSynchInd& timingmaintainedsynchind) { *static_cast<TimingMaintainedSynchInd*>(items[0]) = timingmaintainedsynchind; }
};

typedef Null DLDPCHInfoCommonr6CfnHandlingInitialise;

class DLDPCHInfoCommonr6CfnHandling : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLDPCHInfoCommonr6CfnHandlingChoices {
		dLDPCHInfoCommonr6CfnHandlingMaintain = 0,
		dLDPCHInfoCommonr6CfnHandlingInitialise = 1,
	};
	static const Info theInfo;
	DLDPCHInfoCommonr6CfnHandling(): Choice(&theInfo) {}
};

typedef Boolean DLDPCHInfoCommonr6ModeSpecificInfoFddTfciExistence;

class DLDPCHInfoCommonr6ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	DLDPCHInfoCommonr6ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setDlDPCHPowerControlInfo(const DLDPCHPowerControlInfo& dlDPCHPowerControlInfo) { *static_cast<DLDPCHPowerControlInfo*>(items[0]) = dlDPCHPowerControlInfo; }
	void setPowerOffsetPilotpdpdch(const PowerOffsetPilotpdpdch& powerOffsetPilotpdpdch) { *static_cast<PowerOffsetPilotpdpdch*>(items[1]) = powerOffsetPilotpdpdch; }
	void setDlratematchingrestriction(const Dlratematchingrestriction& dlratematchingrestriction) { *static_cast<Dlratematchingrestriction*>(items[2]) = dlratematchingrestriction; }
	void setSpreadingFactorAndPilot(const SF512AndPilot& spreadingFactorAndPilot) { *static_cast<SF512AndPilot*>(items[3]) = spreadingFactorAndPilot; }
	void setPositionFixedOrFlexible(const PositionFixedOrFlexible& positionFixedOrFlexible) { *static_cast<PositionFixedOrFlexible*>(items[4]) = positionFixedOrFlexible; }
	void setDLDPCHInfoCommonr6ModeSpecificInfoFddTfciExistence(const DLDPCHInfoCommonr6ModeSpecificInfoFddTfciExistence& dLDPCHInfoCommonr6ModeSpecificInfoFddTfciExistence) { *static_cast<DLDPCHInfoCommonr6ModeSpecificInfoFddTfciExistence*>(items[5]) = dLDPCHInfoCommonr6ModeSpecificInfoFddTfciExistence; }
};

class DLDPCHInfoCommonr6ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLDPCHInfoCommonr6ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setDlDPCHPowerControlInfo(const DLDPCHPowerControlInfo& dlDPCHPowerControlInfo) { *static_cast<DLDPCHPowerControlInfo*>(items[0]) = dlDPCHPowerControlInfo; }
};

class DLDPCHInfoCommonr6ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLDPCHInfoCommonr6ModeSpecificInfoChoices {
		dLDPCHInfoCommonr6ModeSpecificInfoFdd = 0,
		dLDPCHInfoCommonr6ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	DLDPCHInfoCommonr6ModeSpecificInfo(): Choice(&theInfo) {}
};

class DLDPCHInfoCommonr6 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLDPCHInfoCommonr6(): Sequence(&theInfo) {}

	void setDLDPCHInfoCommonr6CfnHandling(const DLDPCHInfoCommonr6CfnHandling& dLDPCHInfoCommonr6CfnHandling) { *static_cast<DLDPCHInfoCommonr6CfnHandling*>(items[0]) = dLDPCHInfoCommonr6CfnHandling; }
	void setDLDPCHInfoCommonr6ModeSpecificInfo(const DLDPCHInfoCommonr6ModeSpecificInfo& dLDPCHInfoCommonr6ModeSpecificInfo) { *static_cast<DLDPCHInfoCommonr6ModeSpecificInfo*>(items[1]) = dLDPCHInfoCommonr6ModeSpecificInfo; }
	void setMacdHFNinitialvalue(const MACdHFNinitialvalue& macdHFNinitialvalue) { *static_cast<MACdHFNinitialvalue*>(items[2]) = macdHFNinitialvalue; }
};

class DLFDPCHInfoCommonr6CfnHandlingMaintain : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLFDPCHInfoCommonr6CfnHandlingMaintain(): Sequence(&theInfo) {}

	void setTimingmaintainedsynchind(const TimingMaintainedSynchInd& timingmaintainedsynchind) { *static_cast<TimingMaintainedSynchInd*>(items[0]) = timingmaintainedsynchind; }
};

typedef Null DLFDPCHInfoCommonr6CfnHandlingInitialise;

class DLFDPCHInfoCommonr6CfnHandling : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLFDPCHInfoCommonr6CfnHandlingChoices {
		dLFDPCHInfoCommonr6CfnHandlingMaintain = 0,
		dLFDPCHInfoCommonr6CfnHandlingInitialise = 1,
	};
	static const Info theInfo;
	DLFDPCHInfoCommonr6CfnHandling(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, 16> DLFDPCHInfoCommonr6DlFDPCHTPCcommandErrorRate;

class DLFDPCHInfoCommonr6 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLFDPCHInfoCommonr6(): Sequence(&theInfo) {}

	void setDLFDPCHInfoCommonr6CfnHandling(const DLFDPCHInfoCommonr6CfnHandling& dLFDPCHInfoCommonr6CfnHandling) { *static_cast<DLFDPCHInfoCommonr6CfnHandling*>(items[0]) = dLFDPCHInfoCommonr6CfnHandling; }
	void setDlFDPCHPowerControlInfo(const DLDPCHPowerControlInfo& dlFDPCHPowerControlInfo) { *static_cast<DLDPCHPowerControlInfo*>(items[1]) = dlFDPCHPowerControlInfo; }
	void setDLFDPCHInfoCommonr6DlFDPCHTPCcommandErrorRate(const DLFDPCHInfoCommonr6DlFDPCHTPCcommandErrorRate& dLFDPCHInfoCommonr6DlFDPCHTPCcommandErrorRate) { *static_cast<DLFDPCHInfoCommonr6DlFDPCHTPCcommandErrorRate*>(items[2]) = dLFDPCHInfoCommonr6DlFDPCHTPCcommandErrorRate; }
};

class DLCommonInformationr6DldpchInfoCommon : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLCommonInformationr6DldpchInfoCommonChoices {
		dlDPCHInfoCommon = 0,
		dlFDPCHInfoCommon = 1,
	};
	static const Info theInfo;
	DLCommonInformationr6DldpchInfoCommon(): Choice(&theInfo) {}
};

class DLCommonInformationr6ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLCommonInformationr6ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setDefaultDPCHOffsetValue(const DefaultDPCHOffsetValueFDD& defaultDPCHOffsetValue) { *static_cast<DefaultDPCHOffsetValueFDD*>(items[0]) = defaultDPCHOffsetValue; }
	void setDpchCompressedModeInfo(const DPCHCompressedModeInfo& dpchCompressedModeInfo) { *static_cast<DPCHCompressedModeInfo*>(items[1]) = dpchCompressedModeInfo; }
	void setTxDiversityMode(const TXDiversityMode& txDiversityMode) { *static_cast<TXDiversityMode*>(items[2]) = txDiversityMode; }
};

typedef Null DLCommonInformationr6ModeSpecificInfoTddTddOptionTdd384;

typedef Boolean DLCommonInformationr6ModeSpecificInfoTddTddOptionTdd128TstdIndicator;

class DLCommonInformationr6ModeSpecificInfoTddTddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLCommonInformationr6ModeSpecificInfoTddTddOptionTdd128(): Sequence(&theInfo) {}

	void setDLCommonInformationr6ModeSpecificInfoTddTddOptionTdd128TstdIndicator(const DLCommonInformationr6ModeSpecificInfoTddTddOptionTdd128TstdIndicator& dLCommonInformationr6ModeSpecificInfoTddTddOptionTdd128TstdIndicator) { *static_cast<DLCommonInformationr6ModeSpecificInfoTddTddOptionTdd128TstdIndicator*>(items[0]) = dLCommonInformationr6ModeSpecificInfoTddTddOptionTdd128TstdIndicator; }
};

class DLCommonInformationr6ModeSpecificInfoTddTddOption : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLCommonInformationr6ModeSpecificInfoTddTddOptionChoices {
		dLCommonInformationr6ModeSpecificInfoTddTddOptionTdd384 = 0,
		dLCommonInformationr6ModeSpecificInfoTddTddOptionTdd128 = 1,
	};
	static const Info theInfo;
	DLCommonInformationr6ModeSpecificInfoTddTddOption(): Choice(&theInfo) {}
};

class DLCommonInformationr6ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLCommonInformationr6ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setDLCommonInformationr6ModeSpecificInfoTddTddOption(const DLCommonInformationr6ModeSpecificInfoTddTddOption& dLCommonInformationr6ModeSpecificInfoTddTddOption) { *static_cast<DLCommonInformationr6ModeSpecificInfoTddTddOption*>(items[0]) = dLCommonInformationr6ModeSpecificInfoTddTddOption; }
	void setDefaultDPCHOffsetValue(const DefaultDPCHOffsetValueTDD& defaultDPCHOffsetValue) { *static_cast<DefaultDPCHOffsetValueTDD*>(items[1]) = defaultDPCHOffsetValue; }
};

class DLCommonInformationr6ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLCommonInformationr6ModeSpecificInfoChoices {
		dLCommonInformationr6ModeSpecificInfoFdd = 0,
		dLCommonInformationr6ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	DLCommonInformationr6ModeSpecificInfo(): Choice(&theInfo) {}
};

enum DLCommonInformationr6mac_hsResetIndicatorValues {
	true_DLCommonInformationr6mac_hsResetIndicator = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLCommonInformationr6mac_hsResetIndicator;

enum DLCommonInformationr6postVerificationPeriodValues {
	true_DLCommonInformationr6postVerificationPeriod = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLCommonInformationr6postVerificationPeriod;

class DLCommonInformationr6 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	DLCommonInformationr6(): Sequence(&theInfo) {}

	void setDLCommonInformationr6DldpchInfoCommon(const DLCommonInformationr6DldpchInfoCommon& dLCommonInformationr6DldpchInfoCommon) { *static_cast<DLCommonInformationr6DldpchInfoCommon*>(items[0]) = dLCommonInformationr6DldpchInfoCommon; }
	void setDLCommonInformationr6ModeSpecificInfo(const DLCommonInformationr6ModeSpecificInfo& dLCommonInformationr6ModeSpecificInfo) { *static_cast<DLCommonInformationr6ModeSpecificInfo*>(items[1]) = dLCommonInformationr6ModeSpecificInfo; }
	void setDLCommonInformationr6mac_hsResetIndicator(const DLCommonInformationr6mac_hsResetIndicator& dLCommonInformationr6mac_hsResetIndicator) { *static_cast<DLCommonInformationr6mac_hsResetIndicator*>(items[2]) = dLCommonInformationr6mac_hsResetIndicator; }
	void setDLCommonInformationr6postVerificationPeriod(const DLCommonInformationr6postVerificationPeriod& dLCommonInformationr6postVerificationPeriod) { *static_cast<DLCommonInformationr6postVerificationPeriod*>(items[3]) = dLCommonInformationr6postVerificationPeriod; }
};

class DLCommonInformationr7DldpchInfoCommon : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLCommonInformationr7DldpchInfoCommonChoices {
		dlDPCHInfoCommon = 0,
		dlFDPCHInfoCommon = 1,
	};
	static const Info theInfo;
	DLCommonInformationr7DldpchInfoCommon(): Choice(&theInfo) {}
};

class DLCommonInformationr7ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLCommonInformationr7ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setDefaultDPCHOffsetValue(const DefaultDPCHOffsetValueFDD& defaultDPCHOffsetValue) { *static_cast<DefaultDPCHOffsetValueFDD*>(items[0]) = defaultDPCHOffsetValue; }
	void setDpchCompressedModeInfo(const DPCHCompressedModeInfo& dpchCompressedModeInfo) { *static_cast<DPCHCompressedModeInfo*>(items[1]) = dpchCompressedModeInfo; }
	void setTxDiversityMode(const TXDiversityMode& txDiversityMode) { *static_cast<TXDiversityMode*>(items[2]) = txDiversityMode; }
};

typedef Null DLCommonInformationr7ModeSpecificInfoTddTddOptionTdd384;

typedef Null DLCommonInformationr7ModeSpecificInfoTddTddOptionTdd768;

typedef Boolean DLCommonInformationr7ModeSpecificInfoTddTddOptionTdd128TstdIndicator;

class DLCommonInformationr7ModeSpecificInfoTddTddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLCommonInformationr7ModeSpecificInfoTddTddOptionTdd128(): Sequence(&theInfo) {}

	void setDLCommonInformationr7ModeSpecificInfoTddTddOptionTdd128TstdIndicator(const DLCommonInformationr7ModeSpecificInfoTddTddOptionTdd128TstdIndicator& dLCommonInformationr7ModeSpecificInfoTddTddOptionTdd128TstdIndicator) { *static_cast<DLCommonInformationr7ModeSpecificInfoTddTddOptionTdd128TstdIndicator*>(items[0]) = dLCommonInformationr7ModeSpecificInfoTddTddOptionTdd128TstdIndicator; }
};

class DLCommonInformationr7ModeSpecificInfoTddTddOption : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum DLCommonInformationr7ModeSpecificInfoTddTddOptionChoices {
		dLCommonInformationr7ModeSpecificInfoTddTddOptionTdd384 = 0,
		dLCommonInformationr7ModeSpecificInfoTddTddOptionTdd768 = 1,
		dLCommonInformationr7ModeSpecificInfoTddTddOptionTdd128 = 2,
	};
	static const Info theInfo;
	DLCommonInformationr7ModeSpecificInfoTddTddOption(): Choice(&theInfo) {}
};

class DLCommonInformationr7ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLCommonInformationr7ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setDLCommonInformationr7ModeSpecificInfoTddTddOption(const DLCommonInformationr7ModeSpecificInfoTddTddOption& dLCommonInformationr7ModeSpecificInfoTddTddOption) { *static_cast<DLCommonInformationr7ModeSpecificInfoTddTddOption*>(items[0]) = dLCommonInformationr7ModeSpecificInfoTddTddOption; }
	void setDefaultDPCHOffsetValue(const DefaultDPCHOffsetValueTDD& defaultDPCHOffsetValue) { *static_cast<DefaultDPCHOffsetValueTDD*>(items[1]) = defaultDPCHOffsetValue; }
};

class DLCommonInformationr7ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLCommonInformationr7ModeSpecificInfoChoices {
		dLCommonInformationr7ModeSpecificInfoFdd = 0,
		dLCommonInformationr7ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	DLCommonInformationr7ModeSpecificInfo(): Choice(&theInfo) {}
};

enum DLCommonInformationr7mac_hsResetIndicatorValues {
	true_DLCommonInformationr7mac_hsResetIndicator = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLCommonInformationr7mac_hsResetIndicator;

enum DLCommonInformationr7postVerificationPeriodValues {
	true_DLCommonInformationr7postVerificationPeriod = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLCommonInformationr7postVerificationPeriod;

class DLCommonInformationr7 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	DLCommonInformationr7(): Sequence(&theInfo) {}

	void setDLCommonInformationr7DldpchInfoCommon(const DLCommonInformationr7DldpchInfoCommon& dLCommonInformationr7DldpchInfoCommon) { *static_cast<DLCommonInformationr7DldpchInfoCommon*>(items[0]) = dLCommonInformationr7DldpchInfoCommon; }
	void setDLCommonInformationr7ModeSpecificInfo(const DLCommonInformationr7ModeSpecificInfo& dLCommonInformationr7ModeSpecificInfo) { *static_cast<DLCommonInformationr7ModeSpecificInfo*>(items[1]) = dLCommonInformationr7ModeSpecificInfo; }
	void setDLCommonInformationr7mac_hsResetIndicator(const DLCommonInformationr7mac_hsResetIndicator& dLCommonInformationr7mac_hsResetIndicator) { *static_cast<DLCommonInformationr7mac_hsResetIndicator*>(items[2]) = dLCommonInformationr7mac_hsResetIndicator; }
	void setDLCommonInformationr7postVerificationPeriod(const DLCommonInformationr7postVerificationPeriod& dLCommonInformationr7postVerificationPeriod) { *static_cast<DLCommonInformationr7postVerificationPeriod*>(items[3]) = dLCommonInformationr7postVerificationPeriod; }
};

class DLCommonInformationr8DldpchInfoCommon : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLCommonInformationr8DldpchInfoCommonChoices {
		dlDPCHInfoCommon = 0,
		dlFDPCHInfoCommon = 1,
	};
	static const Info theInfo;
	DLCommonInformationr8DldpchInfoCommon(): Choice(&theInfo) {}
};

class TGPSequencer8TgpsStatusActivate : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	TGPSequencer8TgpsStatusActivate(): Sequence(&theInfo) {}

	void setTgcfn(const TGCFN& tgcfn) { *static_cast<TGCFN*>(items[0]) = tgcfn; }
};

typedef Null TGPSequencer8TgpsStatusDeactivate;

class TGPSequencer8TgpsStatus : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum TGPSequencer8TgpsStatusChoices {
		tGPSequencer8TgpsStatusActivate = 0,
		tGPSequencer8TgpsStatusDeactivate = 1,
	};
	static const Info theInfo;
	TGPSequencer8TgpsStatus(): Choice(&theInfo) {}
};

enum TGMPr8Values {
	tdd_Measurement_TGMPr8 = 0,
	fdd_Measurement_TGMPr8 = 1,
	gsm_CarrierRSSIMeasurement_TGMPr8 = 2,
	gsm_initialBSICIdentification_TGMPr8 = 3,
	gsmBSICReconfirmation_TGMPr8 = 4,
	multi_carrier_TGMPr8 = 5,
	e_UTRA_TGMPr8 = 6,
	spare_TGMPr8 = 7,
};
typedef Enumerated<CONSTRAINED, 7> TGMPr8;

class TGPSConfigurationParamsr8 : public Sequence {
private:
	static const void *itemsInfo[17];
	static bool itemsPres[17];
public:
	static const Info theInfo;
	TGPSConfigurationParamsr8(): Sequence(&theInfo) {}

	void setTgmp(const TGMPr8& tgmp) { *static_cast<TGMPr8*>(items[0]) = tgmp; }
	void setTgprc(const TGPRC& tgprc) { *static_cast<TGPRC*>(items[1]) = tgprc; }
	void setTgsn(const TGSN& tgsn) { *static_cast<TGSN*>(items[2]) = tgsn; }
	void setTgl1(const TGL& tgl1) { *static_cast<TGL*>(items[3]) = tgl1; }
	void setTgl2(const TGL& tgl2) { *static_cast<TGL*>(items[4]) = tgl2; }
	void setTgd(const TGD& tgd) { *static_cast<TGD*>(items[5]) = tgd; }
	void setTgpl1(const TGPL& tgpl1) { *static_cast<TGPL*>(items[6]) = tgpl1; }
	void setRpp(const RPP& rpp) { *static_cast<RPP*>(items[7]) = rpp; }
	void setItp(const ITP& itp) { *static_cast<ITP*>(items[8]) = itp; }
	void setUlDLMode(const ULDLMode& ulDLMode) { *static_cast<ULDLMode*>(items[9]) = ulDLMode; }
	void setDlFrameType(const DLFrameType& dlFrameType) { *static_cast<DLFrameType*>(items[10]) = dlFrameType; }
	void setDeltaSIR1(const DeltaSIR& deltaSIR1) { *static_cast<DeltaSIR*>(items[11]) = deltaSIR1; }
	void setDeltaSIRAfter1(const DeltaSIR& deltaSIRAfter1) { *static_cast<DeltaSIR*>(items[12]) = deltaSIRAfter1; }
	void setDeltaSIR2(const DeltaSIR& deltaSIR2) { *static_cast<DeltaSIR*>(items[13]) = deltaSIR2; }
	void setDeltaSIRAfter2(const DeltaSIR& deltaSIRAfter2) { *static_cast<DeltaSIR*>(items[14]) = deltaSIRAfter2; }
	void setNidentifyAbort(const NidentifyAbort& nidentifyAbort) { *static_cast<NidentifyAbort*>(items[15]) = nidentifyAbort; }
	void setTreconfirmAbort(const TreconfirmAbort& treconfirmAbort) { *static_cast<TreconfirmAbort*>(items[16]) = treconfirmAbort; }
};

class TGPSequencer8 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	TGPSequencer8(): Sequence(&theInfo) {}

	void setTgpsi(const TGPSI& tgpsi) { *static_cast<TGPSI*>(items[0]) = tgpsi; }
	void setTGPSequencer8TgpsStatus(const TGPSequencer8TgpsStatus& tGPSequencer8TgpsStatus) { *static_cast<TGPSequencer8TgpsStatus*>(items[1]) = tGPSequencer8TgpsStatus; }
	void setTgpsConfigurationParams(const TGPSConfigurationParamsr8& tgpsConfigurationParams) { *static_cast<TGPSConfigurationParamsr8*>(items[2]) = tgpsConfigurationParams; }
};

typedef SequenceOf<TGPSequencer8, CONSTRAINED, 1, maxTGPS> TGPSequenceListr8;

class DPCHCompressedModeInfor8 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DPCHCompressedModeInfor8(): Sequence(&theInfo) {}

	void setTgpSequenceList(const TGPSequenceListr8& tgpSequenceList) { *static_cast<TGPSequenceListr8*>(items[0]) = tgpSequenceList; }
};

class DLCommonInformationr8ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLCommonInformationr8ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setDefaultDPCHOffsetValue(const DefaultDPCHOffsetValueFDD& defaultDPCHOffsetValue) { *static_cast<DefaultDPCHOffsetValueFDD*>(items[0]) = defaultDPCHOffsetValue; }
	void setDpchCompressedModeInfo(const DPCHCompressedModeInfor8& dpchCompressedModeInfo) { *static_cast<DPCHCompressedModeInfor8*>(items[1]) = dpchCompressedModeInfo; }
	void setTxDiversityMode(const TXDiversityMode& txDiversityMode) { *static_cast<TXDiversityMode*>(items[2]) = txDiversityMode; }
};

typedef Null DLCommonInformationr8ModeSpecificInfoTddTddOptionTdd384;

typedef Null DLCommonInformationr8ModeSpecificInfoTddTddOptionTdd768;

typedef Boolean DLCommonInformationr8ModeSpecificInfoTddTddOptionTdd128TstdIndicator;

class DLCommonInformationr8ModeSpecificInfoTddTddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLCommonInformationr8ModeSpecificInfoTddTddOptionTdd128(): Sequence(&theInfo) {}

	void setDLCommonInformationr8ModeSpecificInfoTddTddOptionTdd128TstdIndicator(const DLCommonInformationr8ModeSpecificInfoTddTddOptionTdd128TstdIndicator& dLCommonInformationr8ModeSpecificInfoTddTddOptionTdd128TstdIndicator) { *static_cast<DLCommonInformationr8ModeSpecificInfoTddTddOptionTdd128TstdIndicator*>(items[0]) = dLCommonInformationr8ModeSpecificInfoTddTddOptionTdd128TstdIndicator; }
};

class DLCommonInformationr8ModeSpecificInfoTddTddOption : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum DLCommonInformationr8ModeSpecificInfoTddTddOptionChoices {
		dLCommonInformationr8ModeSpecificInfoTddTddOptionTdd384 = 0,
		dLCommonInformationr8ModeSpecificInfoTddTddOptionTdd768 = 1,
		dLCommonInformationr8ModeSpecificInfoTddTddOptionTdd128 = 2,
	};
	static const Info theInfo;
	DLCommonInformationr8ModeSpecificInfoTddTddOption(): Choice(&theInfo) {}
};

class DLCommonInformationr8ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLCommonInformationr8ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setDLCommonInformationr8ModeSpecificInfoTddTddOption(const DLCommonInformationr8ModeSpecificInfoTddTddOption& dLCommonInformationr8ModeSpecificInfoTddTddOption) { *static_cast<DLCommonInformationr8ModeSpecificInfoTddTddOption*>(items[0]) = dLCommonInformationr8ModeSpecificInfoTddTddOption; }
	void setDefaultDPCHOffsetValue(const DefaultDPCHOffsetValueTDD& defaultDPCHOffsetValue) { *static_cast<DefaultDPCHOffsetValueTDD*>(items[1]) = defaultDPCHOffsetValue; }
};

class DLCommonInformationr8ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLCommonInformationr8ModeSpecificInfoChoices {
		dLCommonInformationr8ModeSpecificInfoFdd = 0,
		dLCommonInformationr8ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	DLCommonInformationr8ModeSpecificInfo(): Choice(&theInfo) {}
};

enum DLCommonInformationr8mac_hsResetIndicatorValues {
	true_DLCommonInformationr8mac_hsResetIndicator = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLCommonInformationr8mac_hsResetIndicator;

enum DLCommonInformationr8postVerificationPeriodValues {
	true_DLCommonInformationr8postVerificationPeriod = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLCommonInformationr8postVerificationPeriod;

class DLCommonInformationr8 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	DLCommonInformationr8(): Sequence(&theInfo) {}

	void setDLCommonInformationr8DldpchInfoCommon(const DLCommonInformationr8DldpchInfoCommon& dLCommonInformationr8DldpchInfoCommon) { *static_cast<DLCommonInformationr8DldpchInfoCommon*>(items[0]) = dLCommonInformationr8DldpchInfoCommon; }
	void setDLCommonInformationr8ModeSpecificInfo(const DLCommonInformationr8ModeSpecificInfo& dLCommonInformationr8ModeSpecificInfo) { *static_cast<DLCommonInformationr8ModeSpecificInfo*>(items[1]) = dLCommonInformationr8ModeSpecificInfo; }
	void setDLCommonInformationr8mac_hsResetIndicator(const DLCommonInformationr8mac_hsResetIndicator& dLCommonInformationr8mac_hsResetIndicator) { *static_cast<DLCommonInformationr8mac_hsResetIndicator*>(items[2]) = dLCommonInformationr8mac_hsResetIndicator; }
	void setDLCommonInformationr8postVerificationPeriod(const DLCommonInformationr8postVerificationPeriod& dLCommonInformationr8postVerificationPeriod) { *static_cast<DLCommonInformationr8postVerificationPeriod*>(items[3]) = dLCommonInformationr8postVerificationPeriod; }
};

class DLDPCHInfoCommonPost : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLDPCHInfoCommonPost(): Sequence(&theInfo) {}

	void setDlDPCHPowerControlInfo(const DLDPCHPowerControlInfo& dlDPCHPowerControlInfo) { *static_cast<DLDPCHPowerControlInfo*>(items[0]) = dlDPCHPowerControlInfo; }
};

class DLCommonInformationPost : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLCommonInformationPost(): Sequence(&theInfo) {}

	void setDlDPCHInfoCommon(const DLDPCHInfoCommonPost& dlDPCHInfoCommon) { *static_cast<DLDPCHInfoCommonPost*>(items[0]) = dlDPCHInfoCommon; }
};

enum SSDTCellIdentityValues {
	ssdt_id_a_SSDTCellIdentity = 0,
	ssdt_id_b_SSDTCellIdentity = 1,
	ssdt_id_c_SSDTCellIdentity = 2,
	ssdt_id_d_SSDTCellIdentity = 3,
	ssdt_id_e_SSDTCellIdentity = 4,
	ssdt_id_f_SSDTCellIdentity = 5,
	ssdt_id_g_SSDTCellIdentity = 6,
	ssdt_id_h_SSDTCellIdentity = 7,
};
typedef Enumerated<CONSTRAINED, 7> SSDTCellIdentity;

class DLDPCHInfoPerRLFdd : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	DLDPCHInfoPerRLFdd(): Sequence(&theInfo) {}

	void setPCPICHUsageForChannelEst(const PCPICHUsageForChannelEst& pCPICHUsageForChannelEst) { *static_cast<PCPICHUsageForChannelEst*>(items[0]) = pCPICHUsageForChannelEst; }
	void setDpchFrameOffset(const DPCHFrameOffset& dpchFrameOffset) { *static_cast<DPCHFrameOffset*>(items[1]) = dpchFrameOffset; }
	void setSecondaryCPICHInfo(const SecondaryCPICHInfo& secondaryCPICHInfo) { *static_cast<SecondaryCPICHInfo*>(items[2]) = secondaryCPICHInfo; }
	void setDlChannelisationCodeList(const DLChannelisationCodeList& dlChannelisationCodeList) { *static_cast<DLChannelisationCodeList*>(items[3]) = dlChannelisationCodeList; }
	void setTpcCombinationIndex(const TPCCombinationIndex& tpcCombinationIndex) { *static_cast<TPCCombinationIndex*>(items[4]) = tpcCombinationIndex; }
	void setDummy(const SSDTCellIdentity& dummy) { *static_cast<SSDTCellIdentity*>(items[5]) = dummy; }
	void setClosedLoopTimingAdjMode(const ClosedLoopTimingAdjMode& closedLoopTimingAdjMode) { *static_cast<ClosedLoopTimingAdjMode*>(items[6]) = closedLoopTimingAdjMode; }
};

class DLDPCHInfoPerRLTdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLDPCHInfoPerRLTdd(): Sequence(&theInfo) {}

	void setDlCCTrChListToEstablish(const DLCCTrChList& dlCCTrChListToEstablish) { *static_cast<DLCCTrChList*>(items[0]) = dlCCTrChListToEstablish; }
	void setDlCCTrChListToRemove(const DLCCTrChListToRemove& dlCCTrChListToRemove) { *static_cast<DLCCTrChListToRemove*>(items[1]) = dlCCTrChListToRemove; }
};

class DLDPCHInfoPerRL : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLDPCHInfoPerRLChoices {
		dLDPCHInfoPerRLFdd = 0,
		dLDPCHInfoPerRLTdd = 1,
	};
	static const Info theInfo;
	DLDPCHInfoPerRL(): Choice(&theInfo) {}
};

class DLDPCHInfoPerRLr4Fdd : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	DLDPCHInfoPerRLr4Fdd(): Sequence(&theInfo) {}

	void setPCPICHUsageForChannelEst(const PCPICHUsageForChannelEst& pCPICHUsageForChannelEst) { *static_cast<PCPICHUsageForChannelEst*>(items[0]) = pCPICHUsageForChannelEst; }
	void setDpchFrameOffset(const DPCHFrameOffset& dpchFrameOffset) { *static_cast<DPCHFrameOffset*>(items[1]) = dpchFrameOffset; }
	void setSecondaryCPICHInfo(const SecondaryCPICHInfo& secondaryCPICHInfo) { *static_cast<SecondaryCPICHInfo*>(items[2]) = secondaryCPICHInfo; }
	void setDlChannelisationCodeList(const DLChannelisationCodeList& dlChannelisationCodeList) { *static_cast<DLChannelisationCodeList*>(items[3]) = dlChannelisationCodeList; }
	void setTpcCombinationIndex(const TPCCombinationIndex& tpcCombinationIndex) { *static_cast<TPCCombinationIndex*>(items[4]) = tpcCombinationIndex; }
	void setDummy(const SSDTCellIdentity& dummy) { *static_cast<SSDTCellIdentity*>(items[5]) = dummy; }
	void setClosedLoopTimingAdjMode(const ClosedLoopTimingAdjMode& closedLoopTimingAdjMode) { *static_cast<ClosedLoopTimingAdjMode*>(items[6]) = closedLoopTimingAdjMode; }
};

class DLDPCHInfoPerRLr4Tdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLDPCHInfoPerRLr4Tdd(): Sequence(&theInfo) {}

	void setDlCCTrChListToEstablish(const DLCCTrChListr4& dlCCTrChListToEstablish) { *static_cast<DLCCTrChListr4*>(items[0]) = dlCCTrChListToEstablish; }
	void setDlCCTrChListToRemove(const DLCCTrChListToRemove& dlCCTrChListToRemove) { *static_cast<DLCCTrChListToRemove*>(items[1]) = dlCCTrChListToRemove; }
};

class DLDPCHInfoPerRLr4 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLDPCHInfoPerRLr4Choices {
		dLDPCHInfoPerRLr4Fdd = 0,
		dLDPCHInfoPerRLr4Tdd = 1,
	};
	static const Info theInfo;
	DLDPCHInfoPerRLr4(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 24> PowerOffsetTPCpdpdch;

class DLDPCHInfoPerRLr5Fdd : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	DLDPCHInfoPerRLr5Fdd(): Sequence(&theInfo) {}

	void setPCPICHUsageForChannelEst(const PCPICHUsageForChannelEst& pCPICHUsageForChannelEst) { *static_cast<PCPICHUsageForChannelEst*>(items[0]) = pCPICHUsageForChannelEst; }
	void setDpchFrameOffset(const DPCHFrameOffset& dpchFrameOffset) { *static_cast<DPCHFrameOffset*>(items[1]) = dpchFrameOffset; }
	void setSecondaryCPICHInfo(const SecondaryCPICHInfo& secondaryCPICHInfo) { *static_cast<SecondaryCPICHInfo*>(items[2]) = secondaryCPICHInfo; }
	void setDlChannelisationCodeList(const DLChannelisationCodeList& dlChannelisationCodeList) { *static_cast<DLChannelisationCodeList*>(items[3]) = dlChannelisationCodeList; }
	void setTpcCombinationIndex(const TPCCombinationIndex& tpcCombinationIndex) { *static_cast<TPCCombinationIndex*>(items[4]) = tpcCombinationIndex; }
	void setPowerOffsetTPCpdpdch(const PowerOffsetTPCpdpdch& powerOffsetTPCpdpdch) { *static_cast<PowerOffsetTPCpdpdch*>(items[5]) = powerOffsetTPCpdpdch; }
	void setDummy(const SSDTCellIdentity& dummy) { *static_cast<SSDTCellIdentity*>(items[6]) = dummy; }
	void setClosedLoopTimingAdjMode(const ClosedLoopTimingAdjMode& closedLoopTimingAdjMode) { *static_cast<ClosedLoopTimingAdjMode*>(items[7]) = closedLoopTimingAdjMode; }
};

class DLDPCHInfoPerRLr5Tdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLDPCHInfoPerRLr5Tdd(): Sequence(&theInfo) {}

	void setDlCCTrChListToEstablish(const DLCCTrChListr4& dlCCTrChListToEstablish) { *static_cast<DLCCTrChListr4*>(items[0]) = dlCCTrChListToEstablish; }
	void setDlCCTrChListToRemove(const DLCCTrChListToRemove& dlCCTrChListToRemove) { *static_cast<DLCCTrChListToRemove*>(items[1]) = dlCCTrChListToRemove; }
};

class DLDPCHInfoPerRLr5 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLDPCHInfoPerRLr5Choices {
		dLDPCHInfoPerRLr5Fdd = 0,
		dLDPCHInfoPerRLr5Tdd = 1,
	};
	static const Info theInfo;
	DLDPCHInfoPerRLr5(): Choice(&theInfo) {}
};

class DLDPCHInfoPerRLr6Fdd : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	DLDPCHInfoPerRLr6Fdd(): Sequence(&theInfo) {}

	void setPCPICHUsageForChannelEst(const PCPICHUsageForChannelEst& pCPICHUsageForChannelEst) { *static_cast<PCPICHUsageForChannelEst*>(items[0]) = pCPICHUsageForChannelEst; }
	void setDpchFrameOffset(const DPCHFrameOffset& dpchFrameOffset) { *static_cast<DPCHFrameOffset*>(items[1]) = dpchFrameOffset; }
	void setSecondaryCPICHInfo(const SecondaryCPICHInfo& secondaryCPICHInfo) { *static_cast<SecondaryCPICHInfo*>(items[2]) = secondaryCPICHInfo; }
	void setDlChannelisationCodeList(const DLChannelisationCodeList& dlChannelisationCodeList) { *static_cast<DLChannelisationCodeList*>(items[3]) = dlChannelisationCodeList; }
	void setTpcCombinationIndex(const TPCCombinationIndex& tpcCombinationIndex) { *static_cast<TPCCombinationIndex*>(items[4]) = tpcCombinationIndex; }
	void setPowerOffsetTPCpdpdch(const PowerOffsetTPCpdpdch& powerOffsetTPCpdpdch) { *static_cast<PowerOffsetTPCpdpdch*>(items[5]) = powerOffsetTPCpdpdch; }
	void setClosedLoopTimingAdjMode(const ClosedLoopTimingAdjMode& closedLoopTimingAdjMode) { *static_cast<ClosedLoopTimingAdjMode*>(items[6]) = closedLoopTimingAdjMode; }
};

class DLDPCHInfoPerRLr6Tdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLDPCHInfoPerRLr6Tdd(): Sequence(&theInfo) {}

	void setDlCCTrChListToEstablish(const DLCCTrChListr4& dlCCTrChListToEstablish) { *static_cast<DLCCTrChListr4*>(items[0]) = dlCCTrChListToEstablish; }
	void setDlCCTrChListToRemove(const DLCCTrChListToRemove& dlCCTrChListToRemove) { *static_cast<DLCCTrChListToRemove*>(items[1]) = dlCCTrChListToRemove; }
};

class DLDPCHInfoPerRLr6 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLDPCHInfoPerRLr6Choices {
		dLDPCHInfoPerRLr6Fdd = 0,
		dLDPCHInfoPerRLr6Tdd = 1,
	};
	static const Info theInfo;
	DLDPCHInfoPerRLr6(): Choice(&theInfo) {}
};

class DLDPCHInfoPerRLr7Fdd : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	DLDPCHInfoPerRLr7Fdd(): Sequence(&theInfo) {}

	void setPCPICHUsageForChannelEst(const PCPICHUsageForChannelEst& pCPICHUsageForChannelEst) { *static_cast<PCPICHUsageForChannelEst*>(items[0]) = pCPICHUsageForChannelEst; }
	void setDpchFrameOffset(const DPCHFrameOffset& dpchFrameOffset) { *static_cast<DPCHFrameOffset*>(items[1]) = dpchFrameOffset; }
	void setSecondaryCPICHInfo(const SecondaryCPICHInfo& secondaryCPICHInfo) { *static_cast<SecondaryCPICHInfo*>(items[2]) = secondaryCPICHInfo; }
	void setDlChannelisationCodeList(const DLChannelisationCodeList& dlChannelisationCodeList) { *static_cast<DLChannelisationCodeList*>(items[3]) = dlChannelisationCodeList; }
	void setTpcCombinationIndex(const TPCCombinationIndex& tpcCombinationIndex) { *static_cast<TPCCombinationIndex*>(items[4]) = tpcCombinationIndex; }
	void setPowerOffsetTPCpdpdch(const PowerOffsetTPCpdpdch& powerOffsetTPCpdpdch) { *static_cast<PowerOffsetTPCpdpdch*>(items[5]) = powerOffsetTPCpdpdch; }
	void setClosedLoopTimingAdjMode(const ClosedLoopTimingAdjMode& closedLoopTimingAdjMode) { *static_cast<ClosedLoopTimingAdjMode*>(items[6]) = closedLoopTimingAdjMode; }
};

class DLDPCHInfoPerRLr7Tdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLDPCHInfoPerRLr7Tdd(): Sequence(&theInfo) {}

	void setDlCCTrChListToEstablish(const DLCCTrChListr7& dlCCTrChListToEstablish) { *static_cast<DLCCTrChListr7*>(items[0]) = dlCCTrChListToEstablish; }
	void setDlCCTrChListToRemove(const DLCCTrChListToRemove& dlCCTrChListToRemove) { *static_cast<DLCCTrChListToRemove*>(items[1]) = dlCCTrChListToRemove; }
};

class DLDPCHInfoPerRLr7 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLDPCHInfoPerRLr7Choices {
		dLDPCHInfoPerRLr7Fdd = 0,
		dLDPCHInfoPerRLr7Tdd = 1,
	};
	static const Info theInfo;
	DLDPCHInfoPerRLr7(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 255> DLFDPCHInfoPerRLr6DlChannelisationCode;

class DLFDPCHInfoPerRLr6 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	DLFDPCHInfoPerRLr6(): Sequence(&theInfo) {}

	void setPCPICHUsageForChannelEst(const PCPICHUsageForChannelEst& pCPICHUsageForChannelEst) { *static_cast<PCPICHUsageForChannelEst*>(items[0]) = pCPICHUsageForChannelEst; }
	void setFdpchFrameOffset(const DPCHFrameOffset& fdpchFrameOffset) { *static_cast<DPCHFrameOffset*>(items[1]) = fdpchFrameOffset; }
	void setSecondaryCPICHInfo(const SecondaryCPICHInfo& secondaryCPICHInfo) { *static_cast<SecondaryCPICHInfo*>(items[2]) = secondaryCPICHInfo; }
	void setSecondaryScramblingCode(const SecondaryScramblingCode& secondaryScramblingCode) { *static_cast<SecondaryScramblingCode*>(items[3]) = secondaryScramblingCode; }
	void setDLFDPCHInfoPerRLr6DlChannelisationCode(const DLFDPCHInfoPerRLr6DlChannelisationCode& dLFDPCHInfoPerRLr6DlChannelisationCode) { *static_cast<DLFDPCHInfoPerRLr6DlChannelisationCode*>(items[4]) = dLFDPCHInfoPerRLr6DlChannelisationCode; }
	void setTpcCombinationIndex(const TPCCombinationIndex& tpcCombinationIndex) { *static_cast<TPCCombinationIndex*>(items[5]) = tpcCombinationIndex; }
};

class DLDPCHInfoPerRLPostFDD : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLDPCHInfoPerRLPostFDD(): Sequence(&theInfo) {}

	void setPCPICHUsageForChannelEst(const PCPICHUsageForChannelEst& pCPICHUsageForChannelEst) { *static_cast<PCPICHUsageForChannelEst*>(items[0]) = pCPICHUsageForChannelEst; }
	void setDlChannelisationCode(const DLChannelisationCode& dlChannelisationCode) { *static_cast<DLChannelisationCode*>(items[1]) = dlChannelisationCode; }
	void setTpcCombinationIndex(const TPCCombinationIndex& tpcCombinationIndex) { *static_cast<TPCCombinationIndex*>(items[2]) = tpcCombinationIndex; }
};

class DLDPCHInfoPerRLPostTDD : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLDPCHInfoPerRLPostTDD(): Sequence(&theInfo) {}

	void setDlDPCHTimeslotsCodes(const DownlinkTimeslotsCodes& dlDPCHTimeslotsCodes) { *static_cast<DownlinkTimeslotsCodes*>(items[0]) = dlDPCHTimeslotsCodes; }
};

class DLDPCHInfoPerRLPostTDDLCRr4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLDPCHInfoPerRLPostTDDLCRr4(): Sequence(&theInfo) {}

	void setDlCCTrCHTimeslotsCodes(const DownlinkTimeslotsCodesLCRr4& dlCCTrCHTimeslotsCodes) { *static_cast<DownlinkTimeslotsCodesLCRr4*>(items[0]) = dlCCTrCHTimeslotsCodes; }
};

typedef SequenceOf<HSSCCHCodes, CONSTRAINED, 1, maxHSSCCHs> HSSCCHInfor6ModeSpecificInfoFddHSSCCHChannelisationCodeInfo;

class HSSCCHInfor6ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	HSSCCHInfor6ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setHSSCCHInfor6ModeSpecificInfoFddHSSCCHChannelisationCodeInfo(const HSSCCHInfor6ModeSpecificInfoFddHSSCCHChannelisationCodeInfo& hSSCCHInfor6ModeSpecificInfoFddHSSCCHChannelisationCodeInfo) { *static_cast<HSSCCHInfor6ModeSpecificInfoFddHSSCCHChannelisationCodeInfo*>(items[0]) = hSSCCHInfor6ModeSpecificInfoFddHSSCCHChannelisationCodeInfo; }
	void setDlScramblingCode(const SecondaryScramblingCode& dlScramblingCode) { *static_cast<SecondaryScramblingCode*>(items[1]) = dlScramblingCode; }
};

typedef Integer<CONSTRAINED, -7, 8> HSSCCHInfor6ModeSpecificInfoTddTdd384Nackackpoweroffset;

typedef SequenceOf<HSSCCHTDD384r6, CONSTRAINED, 1, maxHSSCCHs> HSSCCHInfor6ModeSpecificInfoTddTdd384HSSCCHSetConfiguration;

class HSSCCHInfor6ModeSpecificInfoTddTdd384 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	HSSCCHInfor6ModeSpecificInfoTddTdd384(): Sequence(&theInfo) {}

	void setHSSCCHInfor6ModeSpecificInfoTddTdd384Nackackpoweroffset(const HSSCCHInfor6ModeSpecificInfoTddTdd384Nackackpoweroffset& hSSCCHInfor6ModeSpecificInfoTddTdd384Nackackpoweroffset) { *static_cast<HSSCCHInfor6ModeSpecificInfoTddTdd384Nackackpoweroffset*>(items[0]) = hSSCCHInfor6ModeSpecificInfoTddTdd384Nackackpoweroffset; }
	void setHsSICHPowerControlInfo(const HSSICHPowerControlInfoTDD384& hsSICHPowerControlInfo) { *static_cast<HSSICHPowerControlInfoTDD384*>(items[1]) = hsSICHPowerControlInfo; }
	void setDhssync(const DHSSync& dhssync) { *static_cast<DHSSync*>(items[2]) = dhssync; }
	void setBlertarget(const BlerTarget& blertarget) { *static_cast<BlerTarget*>(items[3]) = blertarget; }
	void setHSSCCHInfor6ModeSpecificInfoTddTdd384HSSCCHSetConfiguration(const HSSCCHInfor6ModeSpecificInfoTddTdd384HSSCCHSetConfiguration& hSSCCHInfor6ModeSpecificInfoTddTdd384HSSCCHSetConfiguration) { *static_cast<HSSCCHInfor6ModeSpecificInfoTddTdd384HSSCCHSetConfiguration*>(items[4]) = hSSCCHInfor6ModeSpecificInfoTddTdd384HSSCCHSetConfiguration; }
};

typedef Integer<CONSTRAINED, -7, 8> HSSCCHInfor6ModeSpecificInfoTddTdd128Nackackpoweroffset;

typedef Integer<CONSTRAINED, -120, -58> HSSCCHInfor6ModeSpecificInfoTddTdd128PowerlevelHSSICH;

enum HSSCCHInfor6ModeSpecificInfoTddTdd128tpc_step_sizeValues {
	s1_HSSCCHInfor6ModeSpecificInfoTddTdd128tpc_step_size = 0,
	s2_HSSCCHInfor6ModeSpecificInfoTddTdd128tpc_step_size = 1,
	s3_HSSCCHInfor6ModeSpecificInfoTddTdd128tpc_step_size = 2,
	spare1_HSSCCHInfor6ModeSpecificInfoTddTdd128tpc_step_size = 3,
};
typedef Enumerated<CONSTRAINED, 3> HSSCCHInfor6ModeSpecificInfoTddTdd128tpc_step_size;

typedef SequenceOf<HSSCCHTDD128r6, CONSTRAINED, 1, maxHSSCCHs> HSSCCHInfor6ModeSpecificInfoTddTdd128HSSCCHSetConfiguration;

class HSSCCHInfor6ModeSpecificInfoTddTdd128 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	HSSCCHInfor6ModeSpecificInfoTddTdd128(): Sequence(&theInfo) {}

	void setHSSCCHInfor6ModeSpecificInfoTddTdd128Nackackpoweroffset(const HSSCCHInfor6ModeSpecificInfoTddTdd128Nackackpoweroffset& hSSCCHInfor6ModeSpecificInfoTddTdd128Nackackpoweroffset) { *static_cast<HSSCCHInfor6ModeSpecificInfoTddTdd128Nackackpoweroffset*>(items[0]) = hSSCCHInfor6ModeSpecificInfoTddTdd128Nackackpoweroffset; }
	void setHSSCCHInfor6ModeSpecificInfoTddTdd128PowerlevelHSSICH(const HSSCCHInfor6ModeSpecificInfoTddTdd128PowerlevelHSSICH& hSSCCHInfor6ModeSpecificInfoTddTdd128PowerlevelHSSICH) { *static_cast<HSSCCHInfor6ModeSpecificInfoTddTdd128PowerlevelHSSICH*>(items[1]) = hSSCCHInfor6ModeSpecificInfoTddTdd128PowerlevelHSSICH; }
	void setHSSCCHInfor6ModeSpecificInfoTddTdd128tpc_step_size(const HSSCCHInfor6ModeSpecificInfoTddTdd128tpc_step_size& hSSCCHInfor6ModeSpecificInfoTddTdd128tpc_step_size) { *static_cast<HSSCCHInfor6ModeSpecificInfoTddTdd128tpc_step_size*>(items[2]) = hSSCCHInfor6ModeSpecificInfoTddTdd128tpc_step_size; }
	void setBlertarget(const BlerTarget& blertarget) { *static_cast<BlerTarget*>(items[3]) = blertarget; }
	void setHSSCCHInfor6ModeSpecificInfoTddTdd128HSSCCHSetConfiguration(const HSSCCHInfor6ModeSpecificInfoTddTdd128HSSCCHSetConfiguration& hSSCCHInfor6ModeSpecificInfoTddTdd128HSSCCHSetConfiguration) { *static_cast<HSSCCHInfor6ModeSpecificInfoTddTdd128HSSCCHSetConfiguration*>(items[4]) = hSSCCHInfor6ModeSpecificInfoTddTdd128HSSCCHSetConfiguration; }
};

class HSSCCHInfor6ModeSpecificInfoTdd : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum HSSCCHInfor6ModeSpecificInfoTddChoices {
		hSSCCHInfor6ModeSpecificInfoTddTdd384 = 0,
		hSSCCHInfor6ModeSpecificInfoTddTdd128 = 1,
	};
	static const Info theInfo;
	HSSCCHInfor6ModeSpecificInfoTdd(): Choice(&theInfo) {}
};

class HSSCCHInfor6ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum HSSCCHInfor6ModeSpecificInfoChoices {
		hSSCCHInfor6ModeSpecificInfoFdd = 0,
		hSSCCHInfor6ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	HSSCCHInfor6ModeSpecificInfo(): Choice(&theInfo) {}
};

class HSSCCHInfor6 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	HSSCCHInfor6(): Sequence(&theInfo) {}

	void setHSSCCHInfor6ModeSpecificInfo(const HSSCCHInfor6ModeSpecificInfo& hSSCCHInfor6ModeSpecificInfo) { *static_cast<HSSCCHInfor6ModeSpecificInfo*>(items[0]) = hSSCCHInfor6ModeSpecificInfo; }
};

class DLHSPDSCHInformationr6ModeSpecificInfoTddTdd384 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr6ModeSpecificInfoTddTdd384(): Sequence(&theInfo) {}

	void setDlHSPDSCHTSConfiguration(const DLHSPDSCHTSConfiguration& dlHSPDSCHTSConfiguration) { *static_cast<DLHSPDSCHTSConfiguration*>(items[0]) = dlHSPDSCHTSConfiguration; }
};

class DLHSPDSCHInformationr6ModeSpecificInfoTddTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr6ModeSpecificInfoTddTdd128(): Sequence(&theInfo) {}

	void setHsPDSCHMidambleConfigurationtdd128(const HSPDSCHMidambleConfigurationTDD128& hsPDSCHMidambleConfigurationtdd128) { *static_cast<HSPDSCHMidambleConfigurationTDD128*>(items[0]) = hsPDSCHMidambleConfigurationtdd128; }
};

class DLHSPDSCHInformationr6ModeSpecificInfoTdd : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLHSPDSCHInformationr6ModeSpecificInfoTddChoices {
		dLHSPDSCHInformationr6ModeSpecificInfoTddTdd384 = 0,
		dLHSPDSCHInformationr6ModeSpecificInfoTddTdd128 = 1,
	};
	static const Info theInfo;
	DLHSPDSCHInformationr6ModeSpecificInfoTdd(): Choice(&theInfo) {}
};

typedef Null DLHSPDSCHInformationr6ModeSpecificInfoFdd;

class DLHSPDSCHInformationr6ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLHSPDSCHInformationr6ModeSpecificInfoChoices {
		dLHSPDSCHInformationr6ModeSpecificInfoTdd = 0,
		dLHSPDSCHInformationr6ModeSpecificInfoFdd = 1,
	};
	static const Info theInfo;
	DLHSPDSCHInformationr6ModeSpecificInfo(): Choice(&theInfo) {}
};

class DLHSPDSCHInformationr6 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr6(): Sequence(&theInfo) {}

	void setHsscchInfo(const HSSCCHInfor6& hsscchInfo) { *static_cast<HSSCCHInfor6*>(items[0]) = hsscchInfo; }
	void setMeasurementfeedbackInfo(const MeasurementFeedbackInfo& measurementfeedbackInfo) { *static_cast<MeasurementFeedbackInfo*>(items[1]) = measurementfeedbackInfo; }
	void setDLHSPDSCHInformationr6ModeSpecificInfo(const DLHSPDSCHInformationr6ModeSpecificInfo& dLHSPDSCHInformationr6ModeSpecificInfo) { *static_cast<DLHSPDSCHInformationr6ModeSpecificInfo*>(items[2]) = dLHSPDSCHInformationr6ModeSpecificInfo; }
};

typedef Null DLHSPDSCHInformationr8extModeSpecificInfoTddTdd384;

typedef Null DLHSPDSCHInformationr8extModeSpecificInfoTddTdd768;

class DLHSPDSCHInformationr8extModeSpecificInfoTddTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr8extModeSpecificInfoTddTdd128(): Sequence(&theInfo) {}

	void setOutofSyncWindow(const OutofSyncWindow& outofSyncWindow) { *static_cast<OutofSyncWindow*>(items[0]) = outofSyncWindow; }
};

class DLHSPDSCHInformationr8extModeSpecificInfoTdd : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum DLHSPDSCHInformationr8extModeSpecificInfoTddChoices {
		dLHSPDSCHInformationr8extModeSpecificInfoTddTdd384 = 0,
		dLHSPDSCHInformationr8extModeSpecificInfoTddTdd768 = 1,
		dLHSPDSCHInformationr8extModeSpecificInfoTddTdd128 = 2,
	};
	static const Info theInfo;
	DLHSPDSCHInformationr8extModeSpecificInfoTdd(): Choice(&theInfo) {}
};

typedef Null DLHSPDSCHInformationr8extModeSpecificInfoFdd;

class DLHSPDSCHInformationr8extModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLHSPDSCHInformationr8extModeSpecificInfoChoices {
		dLHSPDSCHInformationr8extModeSpecificInfoTdd = 0,
		dLHSPDSCHInformationr8extModeSpecificInfoFdd = 1,
	};
	static const Info theInfo;
	DLHSPDSCHInformationr8extModeSpecificInfo(): Choice(&theInfo) {}
};

class DLHSPDSCHInformationr8ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr8ext(): Sequence(&theInfo) {}

	void setDLHSPDSCHInformationr8extModeSpecificInfo(const DLHSPDSCHInformationr8extModeSpecificInfo& dLHSPDSCHInformationr8extModeSpecificInfo) { *static_cast<DLHSPDSCHInformationr8extModeSpecificInfo*>(items[0]) = dLHSPDSCHInformationr8extModeSpecificInfo; }
};

typedef Null HSSCCHInfor8extModeSpecificInfoFdd;

typedef Null HSSCCHInfor8extModeSpecificInfoTddTdd384;

typedef Null HSSCCHInfor8extModeSpecificInfoTddTdd768;

enum HSSCCHInfor8extModeSpecificInfoTddTdd128hS_SCCH_tpc_step_sizeValues {
	s1_HSSCCHInfor8extModeSpecificInfoTddTdd128hS_SCCH_tpc_step_size = 0,
	s2_HSSCCHInfor8extModeSpecificInfoTddTdd128hS_SCCH_tpc_step_size = 1,
	s3_HSSCCHInfor8extModeSpecificInfoTddTdd128hS_SCCH_tpc_step_size = 2,
	spare1_HSSCCHInfor8extModeSpecificInfoTddTdd128hS_SCCH_tpc_step_size = 3,
};
typedef Enumerated<CONSTRAINED, 3> HSSCCHInfor8extModeSpecificInfoTddTdd128hS_SCCH_tpc_step_size;

class HSSCCHInfor8extModeSpecificInfoTddTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	HSSCCHInfor8extModeSpecificInfoTddTdd128(): Sequence(&theInfo) {}

	void setHSSCCHInfor8extModeSpecificInfoTddTdd128hS_SCCH_tpc_step_size(const HSSCCHInfor8extModeSpecificInfoTddTdd128hS_SCCH_tpc_step_size& hSSCCHInfor8extModeSpecificInfoTddTdd128hS_SCCH_tpc_step_size) { *static_cast<HSSCCHInfor8extModeSpecificInfoTddTdd128hS_SCCH_tpc_step_size*>(items[0]) = hSSCCHInfor8extModeSpecificInfoTddTdd128hS_SCCH_tpc_step_size; }
};

class HSSCCHInfor8extModeSpecificInfoTdd : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum HSSCCHInfor8extModeSpecificInfoTddChoices {
		hSSCCHInfor8extModeSpecificInfoTddTdd384 = 0,
		hSSCCHInfor8extModeSpecificInfoTddTdd768 = 1,
		hSSCCHInfor8extModeSpecificInfoTddTdd128 = 2,
	};
	static const Info theInfo;
	HSSCCHInfor8extModeSpecificInfoTdd(): Choice(&theInfo) {}
};

class HSSCCHInfor8extModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum HSSCCHInfor8extModeSpecificInfoChoices {
		hSSCCHInfor8extModeSpecificInfoFdd = 0,
		hSSCCHInfor8extModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	HSSCCHInfor8extModeSpecificInfo(): Choice(&theInfo) {}
};

class HSSCCHInfor8ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	HSSCCHInfor8ext(): Sequence(&theInfo) {}

	void setHSSCCHInfor8extModeSpecificInfo(const HSSCCHInfor8extModeSpecificInfo& hSSCCHInfor8extModeSpecificInfo) { *static_cast<HSSCCHInfor8extModeSpecificInfo*>(items[0]) = hSSCCHInfor8extModeSpecificInfo; }
};

class DLHSPDSCHInformationr8ext2 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLHSPDSCHInformationr8ext2(): Sequence(&theInfo) {}

	void setHsscchInfo(const HSSCCHInfor8ext& hsscchInfo) { *static_cast<HSSCCHInfor8ext*>(items[0]) = hsscchInfo; }
};

typedef Integer<CONSTRAINED, 0, 511> DSCHRadioLinkIdentifier;

typedef SequenceOf<PrimaryCPICHInfo, CONSTRAINED, 1, maxRL> RLIdentifierList;

class PDSCHSHODCHInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PDSCHSHODCHInfo(): Sequence(&theInfo) {}

	void setDschRadioLinkIdentifier(const DSCHRadioLinkIdentifier& dschRadioLinkIdentifier) { *static_cast<DSCHRadioLinkIdentifier*>(items[0]) = dschRadioLinkIdentifier; }
	void setRlIdentifierList(const RLIdentifierList& rlIdentifierList) { *static_cast<RLIdentifierList*>(items[1]) = rlIdentifierList; }
};

typedef Integer<CONSTRAINED, 1, 1023> MaxTFCIField2Value;

class DSCHMapping : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	DSCHMapping(): Sequence(&theInfo) {}

	void setMaxTFCIField2Value(const MaxTFCIField2Value& maxTFCIField2Value) { *static_cast<MaxTFCIField2Value*>(items[0]) = maxTFCIField2Value; }
	void setSpreadingFactor(const SFPDSCH& spreadingFactor) { *static_cast<SFPDSCH*>(items[1]) = spreadingFactor; }
	void setCodeNumber(const CodeNumberDSCH& codeNumber) { *static_cast<CodeNumberDSCH*>(items[2]) = codeNumber; }
	void setMultiCodeInfo(const MultiCodeInfo& multiCodeInfo) { *static_cast<MultiCodeInfo*>(items[3]) = multiCodeInfo; }
};

typedef SequenceOf<DSCHMapping, CONSTRAINED, 1, maxPDSCH_TFCIgroups> DSCHMappingList;

class PDSCHCodeInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PDSCHCodeInfo(): Sequence(&theInfo) {}

	void setSpreadingFactor(const SFPDSCH& spreadingFactor) { *static_cast<SFPDSCH*>(items[0]) = spreadingFactor; }
	void setCodeNumber(const CodeNumberDSCH& codeNumber) { *static_cast<CodeNumberDSCH*>(items[1]) = codeNumber; }
	void setMultiCodeInfo(const MultiCodeInfo& multiCodeInfo) { *static_cast<MultiCodeInfo*>(items[2]) = multiCodeInfo; }
};

typedef SequenceOf<PDSCHCodeInfo, CONSTRAINED, 1, maxTFCI_2_Combs> PDSCHCodeInfoList;

class ReplacedPDSCHCodeInfo : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	ReplacedPDSCHCodeInfo(): Sequence(&theInfo) {}

	void setTfciField2(const MaxTFCIField2Value& tfciField2) { *static_cast<MaxTFCIField2Value*>(items[0]) = tfciField2; }
	void setSpreadingFactor(const SFPDSCH& spreadingFactor) { *static_cast<SFPDSCH*>(items[1]) = spreadingFactor; }
	void setCodeNumber(const CodeNumberDSCH& codeNumber) { *static_cast<CodeNumberDSCH*>(items[2]) = codeNumber; }
	void setMultiCodeInfo(const MultiCodeInfo& multiCodeInfo) { *static_cast<MultiCodeInfo*>(items[3]) = multiCodeInfo; }
};

typedef SequenceOf<ReplacedPDSCHCodeInfo, CONSTRAINED, 1, maxTFCI_2_Combs> ReplacedPDSCHCodeInfoList;

class PDSCHCodeMappingSignallingMethod : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum PDSCHCodeMappingSignallingMethodChoices {
		codeRange = 0,
		tfciRange = 1,
		explicitconfig = 2,
		replace = 3,
	};
	static const Info theInfo;
	PDSCHCodeMappingSignallingMethod(): Choice(&theInfo) {}
};

class PDSCHCodeMapping : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PDSCHCodeMapping(): Sequence(&theInfo) {}

	void setDlScramblingCode(const SecondaryScramblingCode& dlScramblingCode) { *static_cast<SecondaryScramblingCode*>(items[0]) = dlScramblingCode; }
	void setPDSCHCodeMappingSignallingMethod(const PDSCHCodeMappingSignallingMethod& pDSCHCodeMappingSignallingMethod) { *static_cast<PDSCHCodeMappingSignallingMethod*>(items[1]) = pDSCHCodeMappingSignallingMethod; }
};

class DLInformationPerRLModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLInformationPerRLModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setDummy1(const PDSCHSHODCHInfo& dummy1) { *static_cast<PDSCHSHODCHInfo*>(items[1]) = dummy1; }
	void setDummy2(const PDSCHCodeMapping& dummy2) { *static_cast<PDSCHCodeMapping*>(items[2]) = dummy2; }
};

typedef Boolean PrimaryCCPCHInfoFddTxDiversityIndicator;

class PrimaryCCPCHInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PrimaryCCPCHInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCCPCHInfoFddTxDiversityIndicator(const PrimaryCCPCHInfoFddTxDiversityIndicator& primaryCCPCHInfoFddTxDiversityIndicator) { *static_cast<PrimaryCCPCHInfoFddTxDiversityIndicator*>(items[0]) = primaryCCPCHInfoFddTxDiversityIndicator; }
};

class PrimaryCCPCHInfoTddSyncCaseSyncCase1 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PrimaryCCPCHInfoTddSyncCaseSyncCase1(): Sequence(&theInfo) {}

	void setTimeslot(const TimeslotNumber& timeslot) { *static_cast<TimeslotNumber*>(items[0]) = timeslot; }
};

typedef Integer<CONSTRAINED, 0, 6> TimeslotSync2;

class PrimaryCCPCHInfoTddSyncCaseSyncCase2 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PrimaryCCPCHInfoTddSyncCaseSyncCase2(): Sequence(&theInfo) {}

	void setTimeslotSync2(const TimeslotSync2& timeslotSync2) { *static_cast<TimeslotSync2*>(items[0]) = timeslotSync2; }
};

class PrimaryCCPCHInfoTddSyncCase : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PrimaryCCPCHInfoTddSyncCaseChoices {
		primaryCCPCHInfoTddSyncCaseSyncCase1 = 0,
		primaryCCPCHInfoTddSyncCaseSyncCase2 = 1,
	};
	static const Info theInfo;
	PrimaryCCPCHInfoTddSyncCase(): Choice(&theInfo) {}
};

typedef Boolean PrimaryCCPCHInfoTddSctdIndicator;

class PrimaryCCPCHInfoTdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PrimaryCCPCHInfoTdd(): Sequence(&theInfo) {}

	void setPrimaryCCPCHInfoTddSyncCase(const PrimaryCCPCHInfoTddSyncCase& primaryCCPCHInfoTddSyncCase) { *static_cast<PrimaryCCPCHInfoTddSyncCase*>(items[0]) = primaryCCPCHInfoTddSyncCase; }
	void setCellParametersID(const CellParametersID& cellParametersID) { *static_cast<CellParametersID*>(items[1]) = cellParametersID; }
	void setPrimaryCCPCHInfoTddSctdIndicator(const PrimaryCCPCHInfoTddSctdIndicator& primaryCCPCHInfoTddSctdIndicator) { *static_cast<PrimaryCCPCHInfoTddSctdIndicator*>(items[2]) = primaryCCPCHInfoTddSctdIndicator; }
};

class PrimaryCCPCHInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PrimaryCCPCHInfoChoices {
		primaryCCPCHInfoFdd = 0,
		primaryCCPCHInfoTdd = 1,
	};
	static const Info theInfo;
	PrimaryCCPCHInfo(): Choice(&theInfo) {}
};

class DLInformationPerRLModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerRLModeSpecificInfoChoices {
		dLInformationPerRLModeSpecificInfoFdd = 0,
		tdd = 1,
	};
	static const Info theInfo;
	DLInformationPerRLModeSpecificInfo(): Choice(&theInfo) {}
};

typedef Boolean SecondaryCCPCHInfoModeSpecificInfoFddSttdIndicator;

typedef Integer<CONSTRAINED, 0, 3> SF256AndCodeNumberSf4;

typedef Integer<CONSTRAINED, 0, 7> SF256AndCodeNumberSf8;

typedef Integer<CONSTRAINED, 0, 15> SF256AndCodeNumberSf16;

typedef Integer<CONSTRAINED, 0, 31> SF256AndCodeNumberSf32;

typedef Integer<CONSTRAINED, 0, 63> SF256AndCodeNumberSf64;

typedef Integer<CONSTRAINED, 0, 127> SF256AndCodeNumberSf128;

typedef Integer<CONSTRAINED, 0, 255> SF256AndCodeNumberSf256;

class SF256AndCodeNumber : public Choice {
private:
	static const void *choicesInfo[7];
public:
	enum SF256AndCodeNumberChoices {
		sF256AndCodeNumberSf4 = 0,
		sF256AndCodeNumberSf8 = 1,
		sF256AndCodeNumberSf16 = 2,
		sF256AndCodeNumberSf32 = 3,
		sF256AndCodeNumberSf64 = 4,
		sF256AndCodeNumberSf128 = 5,
		sF256AndCodeNumberSf256 = 6,
	};
	static const Info theInfo;
	SF256AndCodeNumber(): Choice(&theInfo) {}
};

typedef Boolean SecondaryCCPCHInfoModeSpecificInfoFddPilotSymbolExistence;

typedef Boolean SecondaryCCPCHInfoModeSpecificInfoFddTfciExistence;

typedef Integer<CONSTRAINED, 0, 149> TimingOffset;

class SecondaryCCPCHInfoModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[9];
	static bool itemsPres[9];
public:
	static const Info theInfo;
	SecondaryCCPCHInfoModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setDummy1(const PCPICHUsageForChannelEst& dummy1) { *static_cast<PCPICHUsageForChannelEst*>(items[0]) = dummy1; }
	void setDummy2(const SecondaryCPICHInfo& dummy2) { *static_cast<SecondaryCPICHInfo*>(items[1]) = dummy2; }
	void setSecondaryScramblingCode(const SecondaryScramblingCode& secondaryScramblingCode) { *static_cast<SecondaryScramblingCode*>(items[2]) = secondaryScramblingCode; }
	void setSecondaryCCPCHInfoModeSpecificInfoFddSttdIndicator(const SecondaryCCPCHInfoModeSpecificInfoFddSttdIndicator& secondaryCCPCHInfoModeSpecificInfoFddSttdIndicator) { *static_cast<SecondaryCCPCHInfoModeSpecificInfoFddSttdIndicator*>(items[3]) = secondaryCCPCHInfoModeSpecificInfoFddSttdIndicator; }
	void setSfAndCodeNumber(const SF256AndCodeNumber& sfAndCodeNumber) { *static_cast<SF256AndCodeNumber*>(items[4]) = sfAndCodeNumber; }
	void setSecondaryCCPCHInfoModeSpecificInfoFddPilotSymbolExistence(const SecondaryCCPCHInfoModeSpecificInfoFddPilotSymbolExistence& secondaryCCPCHInfoModeSpecificInfoFddPilotSymbolExistence) { *static_cast<SecondaryCCPCHInfoModeSpecificInfoFddPilotSymbolExistence*>(items[5]) = secondaryCCPCHInfoModeSpecificInfoFddPilotSymbolExistence; }
	void setSecondaryCCPCHInfoModeSpecificInfoFddTfciExistence(const SecondaryCCPCHInfoModeSpecificInfoFddTfciExistence& secondaryCCPCHInfoModeSpecificInfoFddTfciExistence) { *static_cast<SecondaryCCPCHInfoModeSpecificInfoFddTfciExistence*>(items[6]) = secondaryCCPCHInfoModeSpecificInfoFddTfciExistence; }
	void setPositionFixedOrFlexible(const PositionFixedOrFlexible& positionFixedOrFlexible) { *static_cast<PositionFixedOrFlexible*>(items[7]) = positionFixedOrFlexible; }
	void setTimingOffset(const TimingOffset& timingOffset) { *static_cast<TimingOffset*>(items[8]) = timingOffset; }
};

enum SCCPCHChannelisationCodeValues {
	cc16_1_SCCPCHChannelisationCode = 0,
	cc16_2_SCCPCHChannelisationCode = 1,
	cc16_3_SCCPCHChannelisationCode = 2,
	cc16_4_SCCPCHChannelisationCode = 3,
	cc16_5_SCCPCHChannelisationCode = 4,
	cc16_6_SCCPCHChannelisationCode = 5,
	cc16_7_SCCPCHChannelisationCode = 6,
	cc16_8_SCCPCHChannelisationCode = 7,
	cc16_9_SCCPCHChannelisationCode = 8,
	cc16_10_SCCPCHChannelisationCode = 9,
	cc16_11_SCCPCHChannelisationCode = 10,
	cc16_12_SCCPCHChannelisationCode = 11,
	cc16_13_SCCPCHChannelisationCode = 12,
	cc16_14_SCCPCHChannelisationCode = 13,
	cc16_15_SCCPCHChannelisationCode = 14,
	cc16_16_SCCPCHChannelisationCode = 15,
};
typedef Enumerated<CONSTRAINED, 15> SCCPCHChannelisationCode;

typedef SequenceOf<SCCPCHChannelisationCode, CONSTRAINED, 1, 16> SCCPCHChannelisationCodeList;

class SecondaryCCPCHInfoModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SecondaryCCPCHInfoModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setCommonTimeslotInfo(const CommonTimeslotInfoSCCPCH& commonTimeslotInfo) { *static_cast<CommonTimeslotInfoSCCPCH*>(items[0]) = commonTimeslotInfo; }
	void setIndividualTimeslotInfo(const IndividualTimeslotInfo& individualTimeslotInfo) { *static_cast<IndividualTimeslotInfo*>(items[1]) = individualTimeslotInfo; }
	void setChannelisationCode(const SCCPCHChannelisationCodeList& channelisationCode) { *static_cast<SCCPCHChannelisationCodeList*>(items[2]) = channelisationCode; }
};

class SecondaryCCPCHInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum SecondaryCCPCHInfoModeSpecificInfoChoices {
		secondaryCCPCHInfoModeSpecificInfoFdd = 0,
		secondaryCCPCHInfoModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	SecondaryCCPCHInfoModeSpecificInfo(): Choice(&theInfo) {}
};

class SecondaryCCPCHInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SecondaryCCPCHInfo(): Sequence(&theInfo) {}

	void setSecondaryCCPCHInfoModeSpecificInfo(const SecondaryCCPCHInfoModeSpecificInfo& secondaryCCPCHInfoModeSpecificInfo) { *static_cast<SecondaryCCPCHInfoModeSpecificInfo*>(items[0]) = secondaryCCPCHInfoModeSpecificInfo; }
};

typedef Boolean FACHPCHInformationCtchIndicator;

class FACHPCHInformation : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	FACHPCHInformation(): Sequence(&theInfo) {}

	void setTransportFormatSet(const TransportFormatSet& transportFormatSet) { *static_cast<TransportFormatSet*>(items[0]) = transportFormatSet; }
	void setTransportChannelIdentity(const TransportChannelIdentity& transportChannelIdentity) { *static_cast<TransportChannelIdentity*>(items[1]) = transportChannelIdentity; }
	void setFACHPCHInformationCtchIndicator(const FACHPCHInformationCtchIndicator& fACHPCHInformationCtchIndicator) { *static_cast<FACHPCHInformationCtchIndicator*>(items[2]) = fACHPCHInformationCtchIndicator; }
};

typedef SequenceOf<FACHPCHInformation, CONSTRAINED, 1, maxFACHPCH> FACHPCHInformationList;

typedef Integer<CONSTRAINED, 1, 256> PLMNValueTag;

typedef Integer<CONSTRAINED, 1, 4> CellValueTag;

typedef Null SIBTypeAndTagSysInfoType7;

typedef Null SIBTypeAndTagDummy2;

typedef Null SIBTypeAndTagDummy3;

typedef Null SIBTypeAndTagSysInfoType14;

class PredefinedConfigIdentityAndValueTag : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PredefinedConfigIdentityAndValueTag(): Sequence(&theInfo) {}

	void setPredefinedConfigIdentity(const PredefinedConfigIdentity& predefinedConfigIdentity) { *static_cast<PredefinedConfigIdentity*>(items[0]) = predefinedConfigIdentity; }
	void setPredefinedConfigValueTag(const PredefinedConfigValueTag& predefinedConfigValueTag) { *static_cast<PredefinedConfigValueTag*>(items[1]) = predefinedConfigValueTag; }
};

typedef Null SIBTypeAndTagSysInfoType17;

typedef Integer<CONSTRAINED, 0, 15> SIBOccurIdentity;

typedef Integer<CONSTRAINED, 0, 15> SIBOccurValueTag;

class SIBOccurrenceIdentityAndValueTag : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SIBOccurrenceIdentityAndValueTag(): Sequence(&theInfo) {}

	void setSibOccurIdentity(const SIBOccurIdentity& sibOccurIdentity) { *static_cast<SIBOccurIdentity*>(items[0]) = sibOccurIdentity; }
	void setSibOccurValueTag(const SIBOccurValueTag& sibOccurValueTag) { *static_cast<SIBOccurValueTag*>(items[1]) = sibOccurValueTag; }
};

typedef Null SIBTypeAndTagSpare4;

typedef Null SIBTypeAndTagSpare3;

typedef Null SIBTypeAndTagSpare2;

typedef Null SIBTypeAndTagSpare1;

class SIBTypeAndTag : public Choice {
private:
	static const void *choicesInfo[32];
public:
	enum SIBTypeAndTagChoices {
		sysInfoType1 = 0,
		sysInfoType2 = 1,
		sysInfoType3 = 2,
		sysInfoType4 = 3,
		sysInfoType5 = 4,
		sysInfoType6 = 5,
		sIBTypeAndTagSysInfoType7 = 6,
		dummy = 7,
		sIBTypeAndTagDummy2 = 8,
		sIBTypeAndTagDummy3 = 9,
		sysInfoType11 = 10,
		sysInfoType12 = 11,
		sysInfoType13 = 12,
		sysInfoType131 = 13,
		sysInfoType132 = 14,
		sysInfoType133 = 15,
		sysInfoType134 = 16,
		sIBTypeAndTagSysInfoType14 = 17,
		sysInfoType15 = 18,
		sysInfoType16 = 19,
		sIBTypeAndTagSysInfoType17 = 20,
		sysInfoType151 = 21,
		sysInfoType152 = 22,
		sysInfoType153 = 23,
		sysInfoType154 = 24,
		sysInfoType18 = 25,
		sysInfoType155 = 26,
		sysInfoType5bis = 27,
		sIBTypeAndTagSpare4 = 28,
		sIBTypeAndTagSpare3 = 29,
		sIBTypeAndTagSpare2 = 30,
		sIBTypeAndTagSpare1 = 31,
	};
	static const Info theInfo;
	SIBTypeAndTag(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, 16> SegCount;

typedef Integer<CONSTRAINED, 0, 1> SchedulingInformationSchedulingSibPosRep4;

typedef Integer<CONSTRAINED, 0, 3> SchedulingInformationSchedulingSibPosRep8;

typedef Integer<CONSTRAINED, 0, 7> SchedulingInformationSchedulingSibPosRep16;

typedef Integer<CONSTRAINED, 0, 15> SchedulingInformationSchedulingSibPosRep32;

typedef Integer<CONSTRAINED, 0, 31> SchedulingInformationSchedulingSibPosRep64;

typedef Integer<CONSTRAINED, 0, 63> SchedulingInformationSchedulingSibPosRep128;

typedef Integer<CONSTRAINED, 0, 127> SchedulingInformationSchedulingSibPosRep256;

typedef Integer<CONSTRAINED, 0, 255> SchedulingInformationSchedulingSibPosRep512;

typedef Integer<CONSTRAINED, 0, 511> SchedulingInformationSchedulingSibPosRep1024;

typedef Integer<CONSTRAINED, 0, 1023> SchedulingInformationSchedulingSibPosRep2048;

typedef Integer<CONSTRAINED, 0, 2047> SchedulingInformationSchedulingSibPosRep4096;

class SchedulingInformationSchedulingSibPos : public Choice {
private:
	static const void *choicesInfo[11];
public:
	enum SchedulingInformationSchedulingSibPosChoices {
		schedulingInformationSchedulingSibPosRep4 = 0,
		schedulingInformationSchedulingSibPosRep8 = 1,
		schedulingInformationSchedulingSibPosRep16 = 2,
		schedulingInformationSchedulingSibPosRep32 = 3,
		schedulingInformationSchedulingSibPosRep64 = 4,
		schedulingInformationSchedulingSibPosRep128 = 5,
		schedulingInformationSchedulingSibPosRep256 = 6,
		schedulingInformationSchedulingSibPosRep512 = 7,
		schedulingInformationSchedulingSibPosRep1024 = 8,
		schedulingInformationSchedulingSibPosRep2048 = 9,
		schedulingInformationSchedulingSibPosRep4096 = 10,
	};
	static const Info theInfo;
	SchedulingInformationSchedulingSibPos(): Choice(&theInfo) {}
};

enum SibOFFValues {
	so2_SibOFF = 0,
	so4_SibOFF = 1,
	so6_SibOFF = 2,
	so8_SibOFF = 3,
	so10_SibOFF = 4,
	so12_SibOFF = 5,
	so14_SibOFF = 6,
	so16_SibOFF = 7,
	so18_SibOFF = 8,
	so20_SibOFF = 9,
	so22_SibOFF = 10,
	so24_SibOFF = 11,
	so26_SibOFF = 12,
	so28_SibOFF = 13,
	so30_SibOFF = 14,
	so32_SibOFF = 15,
};
typedef Enumerated<CONSTRAINED, 15> SibOFF;

typedef SequenceOf<SibOFF, CONSTRAINED, 1, 15> SibOFFList;

class SchedulingInformationScheduling : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SchedulingInformationScheduling(): Sequence(&theInfo) {}

	void setSegCount(const SegCount& segCount) { *static_cast<SegCount*>(items[0]) = segCount; }
	void setSchedulingInformationSchedulingSibPos(const SchedulingInformationSchedulingSibPos& schedulingInformationSchedulingSibPos) { *static_cast<SchedulingInformationSchedulingSibPos*>(items[1]) = schedulingInformationSchedulingSibPos; }
	void setSibPosOffsetInfo(const SibOFFList& sibPosOffsetInfo) { *static_cast<SibOFFList*>(items[2]) = sibPosOffsetInfo; }
};

class SchedulingInformation : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SchedulingInformation(): Sequence(&theInfo) {}

	void setSchedulingInformationScheduling(const SchedulingInformationScheduling& schedulingInformationScheduling) { *static_cast<SchedulingInformationScheduling*>(items[0]) = schedulingInformationScheduling; }
};

class SchedulingInformationSIB : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SchedulingInformationSIB(): Sequence(&theInfo) {}

	void setSibType(const SIBTypeAndTag& sibType) { *static_cast<SIBTypeAndTag*>(items[0]) = sibType; }
	void setScheduling(const SchedulingInformation& scheduling) { *static_cast<SchedulingInformation*>(items[1]) = scheduling; }
};

typedef SequenceOf<SchedulingInformationSIB, CONSTRAINED, 1, maxSIB_FACH> SIBReferenceListFACH;

class SCCPCHInfoForFACHModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SCCPCHInfoForFACHModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setFachPCHInformationList(const FACHPCHInformationList& fachPCHInformationList) { *static_cast<FACHPCHInformationList*>(items[0]) = fachPCHInformationList; }
	void setSibReferenceListFACH(const SIBReferenceListFACH& sibReferenceListFACH) { *static_cast<SIBReferenceListFACH*>(items[1]) = sibReferenceListFACH; }
};

class SCCPCHInfoForFACHModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SCCPCHInfoForFACHModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setFachPCHInformationList(const FACHPCHInformationList& fachPCHInformationList) { *static_cast<FACHPCHInformationList*>(items[0]) = fachPCHInformationList; }
};

class SCCPCHInfoForFACHModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum SCCPCHInfoForFACHModeSpecificInfoChoices {
		sCCPCHInfoForFACHModeSpecificInfoFdd = 0,
		sCCPCHInfoForFACHModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	SCCPCHInfoForFACHModeSpecificInfo(): Choice(&theInfo) {}
};

class SCCPCHInfoForFACH : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SCCPCHInfoForFACH(): Sequence(&theInfo) {}

	void setSecondaryCCPCHInfo(const SecondaryCCPCHInfo& secondaryCCPCHInfo) { *static_cast<SecondaryCCPCHInfo*>(items[0]) = secondaryCCPCHInfo; }
	void setTfcs(const TFCS& tfcs) { *static_cast<TFCS*>(items[1]) = tfcs; }
	void setSCCPCHInfoForFACHModeSpecificInfo(const SCCPCHInfoForFACHModeSpecificInfo& sCCPCHInfoForFACHModeSpecificInfo) { *static_cast<SCCPCHInfoForFACHModeSpecificInfo*>(items[2]) = sCCPCHInfoForFACHModeSpecificInfo; }
};

class DLInformationPerRL : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLInformationPerRL(): Sequence(&theInfo) {}

	void setDLInformationPerRLModeSpecificInfo(const DLInformationPerRLModeSpecificInfo& dLInformationPerRLModeSpecificInfo) { *static_cast<DLInformationPerRLModeSpecificInfo*>(items[0]) = dLInformationPerRLModeSpecificInfo; }
	void setDlDPCHInfoPerRL(const DLDPCHInfoPerRL& dlDPCHInfoPerRL) { *static_cast<DLDPCHInfoPerRL*>(items[1]) = dlDPCHInfoPerRL; }
	void setDummy(const SCCPCHInfoForFACH& dummy) { *static_cast<SCCPCHInfoForFACH*>(items[2]) = dummy; }
};

class DLInformationPerRLr4ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLInformationPerRLr4ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setDummy1(const PDSCHSHODCHInfo& dummy1) { *static_cast<PDSCHSHODCHInfo*>(items[1]) = dummy1; }
	void setDummy2(const PDSCHCodeMapping& dummy2) { *static_cast<PDSCHCodeMapping*>(items[2]) = dummy2; }
};

typedef Boolean PrimaryCCPCHInfor4FddTxDiversityIndicator;

class PrimaryCCPCHInfor4Fdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PrimaryCCPCHInfor4Fdd(): Sequence(&theInfo) {}

	void setPrimaryCCPCHInfor4FddTxDiversityIndicator(const PrimaryCCPCHInfor4FddTxDiversityIndicator& primaryCCPCHInfor4FddTxDiversityIndicator) { *static_cast<PrimaryCCPCHInfor4FddTxDiversityIndicator*>(items[0]) = primaryCCPCHInfor4FddTxDiversityIndicator; }
};

class PrimaryCCPCHInfor4TddTddOptionTdd384tdd768SyncCaseSyncCase1 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PrimaryCCPCHInfor4TddTddOptionTdd384tdd768SyncCaseSyncCase1(): Sequence(&theInfo) {}

	void setTimeslot(const TimeslotNumber& timeslot) { *static_cast<TimeslotNumber*>(items[0]) = timeslot; }
};

class PrimaryCCPCHInfor4TddTddOptionTdd384tdd768SyncCaseSyncCase2 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PrimaryCCPCHInfor4TddTddOptionTdd384tdd768SyncCaseSyncCase2(): Sequence(&theInfo) {}

	void setTimeslotSync2(const TimeslotSync2& timeslotSync2) { *static_cast<TimeslotSync2*>(items[0]) = timeslotSync2; }
};

class PrimaryCCPCHInfor4TddTddOptionTdd384tdd768SyncCase : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PrimaryCCPCHInfor4TddTddOptionTdd384tdd768SyncCaseChoices {
		primaryCCPCHInfor4TddTddOptionTdd384tdd768SyncCaseSyncCase1 = 0,
		primaryCCPCHInfor4TddTddOptionTdd384tdd768SyncCaseSyncCase2 = 1,
	};
	static const Info theInfo;
	PrimaryCCPCHInfor4TddTddOptionTdd384tdd768SyncCase(): Choice(&theInfo) {}
};

class PrimaryCCPCHInfor4TddTddOptionTdd384tdd768 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PrimaryCCPCHInfor4TddTddOptionTdd384tdd768(): Sequence(&theInfo) {}

	void setPrimaryCCPCHInfor4TddTddOptionTdd384tdd768SyncCase(const PrimaryCCPCHInfor4TddTddOptionTdd384tdd768SyncCase& primaryCCPCHInfor4TddTddOptionTdd384tdd768SyncCase) { *static_cast<PrimaryCCPCHInfor4TddTddOptionTdd384tdd768SyncCase*>(items[0]) = primaryCCPCHInfor4TddTddOptionTdd384tdd768SyncCase; }
};

typedef Boolean PrimaryCCPCHInfor4TddTddOptionTdd128TstdIndicator;

class PrimaryCCPCHInfor4TddTddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PrimaryCCPCHInfor4TddTddOptionTdd128(): Sequence(&theInfo) {}

	void setPrimaryCCPCHInfor4TddTddOptionTdd128TstdIndicator(const PrimaryCCPCHInfor4TddTddOptionTdd128TstdIndicator& primaryCCPCHInfor4TddTddOptionTdd128TstdIndicator) { *static_cast<PrimaryCCPCHInfor4TddTddOptionTdd128TstdIndicator*>(items[0]) = primaryCCPCHInfor4TddTddOptionTdd128TstdIndicator; }
};

class PrimaryCCPCHInfor4TddTddOption : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PrimaryCCPCHInfor4TddTddOptionChoices {
		primaryCCPCHInfor4TddTddOptionTdd384tdd768 = 0,
		primaryCCPCHInfor4TddTddOptionTdd128 = 1,
	};
	static const Info theInfo;
	PrimaryCCPCHInfor4TddTddOption(): Choice(&theInfo) {}
};

typedef Boolean PrimaryCCPCHInfor4TddSctdIndicator;

class PrimaryCCPCHInfor4Tdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PrimaryCCPCHInfor4Tdd(): Sequence(&theInfo) {}

	void setPrimaryCCPCHInfor4TddTddOption(const PrimaryCCPCHInfor4TddTddOption& primaryCCPCHInfor4TddTddOption) { *static_cast<PrimaryCCPCHInfor4TddTddOption*>(items[0]) = primaryCCPCHInfor4TddTddOption; }
	void setCellParametersID(const CellParametersID& cellParametersID) { *static_cast<CellParametersID*>(items[1]) = cellParametersID; }
	void setPrimaryCCPCHInfor4TddSctdIndicator(const PrimaryCCPCHInfor4TddSctdIndicator& primaryCCPCHInfor4TddSctdIndicator) { *static_cast<PrimaryCCPCHInfor4TddSctdIndicator*>(items[2]) = primaryCCPCHInfor4TddSctdIndicator; }
};

class PrimaryCCPCHInfor4 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PrimaryCCPCHInfor4Choices {
		primaryCCPCHInfor4Fdd = 0,
		primaryCCPCHInfor4Tdd = 1,
	};
	static const Info theInfo;
	PrimaryCCPCHInfor4(): Choice(&theInfo) {}
};

class DLInformationPerRLr4ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerRLr4ModeSpecificInfoChoices {
		dLInformationPerRLr4ModeSpecificInfoFdd = 0,
		tdd = 1,
	};
	static const Info theInfo;
	DLInformationPerRLr4ModeSpecificInfo(): Choice(&theInfo) {}
};

typedef Boolean SecondaryCCPCHInfor4ModeSpecificInfoFddSttdIndicator;

typedef Boolean SecondaryCCPCHInfor4ModeSpecificInfoFddPilotSymbolExistence;

typedef Boolean SecondaryCCPCHInfor4ModeSpecificInfoFddTfciExistence;

class SecondaryCCPCHInfor4ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	SecondaryCCPCHInfor4ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setSecondaryScramblingCode(const SecondaryScramblingCode& secondaryScramblingCode) { *static_cast<SecondaryScramblingCode*>(items[0]) = secondaryScramblingCode; }
	void setSecondaryCCPCHInfor4ModeSpecificInfoFddSttdIndicator(const SecondaryCCPCHInfor4ModeSpecificInfoFddSttdIndicator& secondaryCCPCHInfor4ModeSpecificInfoFddSttdIndicator) { *static_cast<SecondaryCCPCHInfor4ModeSpecificInfoFddSttdIndicator*>(items[1]) = secondaryCCPCHInfor4ModeSpecificInfoFddSttdIndicator; }
	void setSfAndCodeNumber(const SF256AndCodeNumber& sfAndCodeNumber) { *static_cast<SF256AndCodeNumber*>(items[2]) = sfAndCodeNumber; }
	void setSecondaryCCPCHInfor4ModeSpecificInfoFddPilotSymbolExistence(const SecondaryCCPCHInfor4ModeSpecificInfoFddPilotSymbolExistence& secondaryCCPCHInfor4ModeSpecificInfoFddPilotSymbolExistence) { *static_cast<SecondaryCCPCHInfor4ModeSpecificInfoFddPilotSymbolExistence*>(items[3]) = secondaryCCPCHInfor4ModeSpecificInfoFddPilotSymbolExistence; }
	void setSecondaryCCPCHInfor4ModeSpecificInfoFddTfciExistence(const SecondaryCCPCHInfor4ModeSpecificInfoFddTfciExistence& secondaryCCPCHInfor4ModeSpecificInfoFddTfciExistence) { *static_cast<SecondaryCCPCHInfor4ModeSpecificInfoFddTfciExistence*>(items[4]) = secondaryCCPCHInfor4ModeSpecificInfoFddTfciExistence; }
	void setPositionFixedOrFlexible(const PositionFixedOrFlexible& positionFixedOrFlexible) { *static_cast<PositionFixedOrFlexible*>(items[5]) = positionFixedOrFlexible; }
	void setTimingOffset(const TimingOffset& timingOffset) { *static_cast<TimingOffset*>(items[6]) = timingOffset; }
};

class SecondaryCCPCHInfor4ModeSpecificInfoTddTddOptionTdd384 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SecondaryCCPCHInfor4ModeSpecificInfoTddTddOptionTdd384(): Sequence(&theInfo) {}

	void setIndividualTimeslotInfo(const IndividualTimeslotInfo& individualTimeslotInfo) { *static_cast<IndividualTimeslotInfo*>(items[0]) = individualTimeslotInfo; }
};

class SecondaryCCPCHInfor4ModeSpecificInfoTddTddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SecondaryCCPCHInfor4ModeSpecificInfoTddTddOptionTdd128(): Sequence(&theInfo) {}

	void setIndividualTimeslotInfo(const IndividualTimeslotInfoLCRr4& individualTimeslotInfo) { *static_cast<IndividualTimeslotInfoLCRr4*>(items[0]) = individualTimeslotInfo; }
};

class SecondaryCCPCHInfor4ModeSpecificInfoTddTddOption : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum SecondaryCCPCHInfor4ModeSpecificInfoTddTddOptionChoices {
		secondaryCCPCHInfor4ModeSpecificInfoTddTddOptionTdd384 = 0,
		secondaryCCPCHInfor4ModeSpecificInfoTddTddOptionTdd128 = 1,
	};
	static const Info theInfo;
	SecondaryCCPCHInfor4ModeSpecificInfoTddTddOption(): Choice(&theInfo) {}
};

class SecondaryCCPCHInfor4ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SecondaryCCPCHInfor4ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setCommonTimeslotInfo(const CommonTimeslotInfoSCCPCH& commonTimeslotInfo) { *static_cast<CommonTimeslotInfoSCCPCH*>(items[0]) = commonTimeslotInfo; }
	void setSecondaryCCPCHInfor4ModeSpecificInfoTddTddOption(const SecondaryCCPCHInfor4ModeSpecificInfoTddTddOption& secondaryCCPCHInfor4ModeSpecificInfoTddTddOption) { *static_cast<SecondaryCCPCHInfor4ModeSpecificInfoTddTddOption*>(items[1]) = secondaryCCPCHInfor4ModeSpecificInfoTddTddOption; }
	void setChannelisationCode(const SCCPCHChannelisationCodeList& channelisationCode) { *static_cast<SCCPCHChannelisationCodeList*>(items[2]) = channelisationCode; }
};

class SecondaryCCPCHInfor4ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum SecondaryCCPCHInfor4ModeSpecificInfoChoices {
		secondaryCCPCHInfor4ModeSpecificInfoFdd = 0,
		secondaryCCPCHInfor4ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	SecondaryCCPCHInfor4ModeSpecificInfo(): Choice(&theInfo) {}
};

class SecondaryCCPCHInfor4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SecondaryCCPCHInfor4(): Sequence(&theInfo) {}

	void setSecondaryCCPCHInfor4ModeSpecificInfo(const SecondaryCCPCHInfor4ModeSpecificInfo& secondaryCCPCHInfor4ModeSpecificInfo) { *static_cast<SecondaryCCPCHInfor4ModeSpecificInfo*>(items[0]) = secondaryCCPCHInfor4ModeSpecificInfo; }
};

class SCCPCHInfoForFACHr4ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SCCPCHInfoForFACHr4ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setSibReferenceListFACH(const SIBReferenceListFACH& sibReferenceListFACH) { *static_cast<SIBReferenceListFACH*>(items[0]) = sibReferenceListFACH; }
};

typedef Null SCCPCHInfoForFACHr4ModeSpecificInfoTdd;

class SCCPCHInfoForFACHr4ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum SCCPCHInfoForFACHr4ModeSpecificInfoChoices {
		sCCPCHInfoForFACHr4ModeSpecificInfoFdd = 0,
		sCCPCHInfoForFACHr4ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	SCCPCHInfoForFACHr4ModeSpecificInfo(): Choice(&theInfo) {}
};

class SCCPCHInfoForFACHr4 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SCCPCHInfoForFACHr4(): Sequence(&theInfo) {}

	void setSecondaryCCPCHInfo(const SecondaryCCPCHInfor4& secondaryCCPCHInfo) { *static_cast<SecondaryCCPCHInfor4*>(items[0]) = secondaryCCPCHInfo; }
	void setTfcs(const TFCS& tfcs) { *static_cast<TFCS*>(items[1]) = tfcs; }
	void setFachPCHInformationList(const FACHPCHInformationList& fachPCHInformationList) { *static_cast<FACHPCHInformationList*>(items[2]) = fachPCHInformationList; }
	void setSCCPCHInfoForFACHr4ModeSpecificInfo(const SCCPCHInfoForFACHr4ModeSpecificInfo& sCCPCHInfoForFACHr4ModeSpecificInfo) { *static_cast<SCCPCHInfoForFACHr4ModeSpecificInfo*>(items[3]) = sCCPCHInfoForFACHr4ModeSpecificInfo; }
};

class DLInformationPerRLr4 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	DLInformationPerRLr4(): Sequence(&theInfo) {}

	void setDLInformationPerRLr4ModeSpecificInfo(const DLInformationPerRLr4ModeSpecificInfo& dLInformationPerRLr4ModeSpecificInfo) { *static_cast<DLInformationPerRLr4ModeSpecificInfo*>(items[0]) = dLInformationPerRLr4ModeSpecificInfo; }
	void setDlDPCHInfoPerRL(const DLDPCHInfoPerRLr4& dlDPCHInfoPerRL) { *static_cast<DLDPCHInfoPerRLr4*>(items[1]) = dlDPCHInfoPerRL; }
	void setDummy(const SCCPCHInfoForFACHr4& dummy) { *static_cast<SCCPCHInfoForFACHr4*>(items[2]) = dummy; }
	void setCellid(const CellIdentity& cellid) { *static_cast<CellIdentity*>(items[3]) = cellid; }
};

typedef Boolean DLInformationPerRLr5ModeSpecificInfoFddServingHSDSCHRLindicator;

class DLInformationPerRLr5ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	DLInformationPerRLr5ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setDummy1(const PDSCHSHODCHInfo& dummy1) { *static_cast<PDSCHSHODCHInfo*>(items[1]) = dummy1; }
	void setDummy2(const PDSCHCodeMapping& dummy2) { *static_cast<PDSCHCodeMapping*>(items[2]) = dummy2; }
	void setDLInformationPerRLr5ModeSpecificInfoFddServingHSDSCHRLindicator(const DLInformationPerRLr5ModeSpecificInfoFddServingHSDSCHRLindicator& dLInformationPerRLr5ModeSpecificInfoFddServingHSDSCHRLindicator) { *static_cast<DLInformationPerRLr5ModeSpecificInfoFddServingHSDSCHRLindicator*>(items[3]) = dLInformationPerRLr5ModeSpecificInfoFddServingHSDSCHRLindicator; }
};

class DLInformationPerRLr5ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerRLr5ModeSpecificInfoChoices {
		dLInformationPerRLr5ModeSpecificInfoFdd = 0,
		tdd = 1,
	};
	static const Info theInfo;
	DLInformationPerRLr5ModeSpecificInfo(): Choice(&theInfo) {}
};

class DLInformationPerRLr5 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	DLInformationPerRLr5(): Sequence(&theInfo) {}

	void setDLInformationPerRLr5ModeSpecificInfo(const DLInformationPerRLr5ModeSpecificInfo& dLInformationPerRLr5ModeSpecificInfo) { *static_cast<DLInformationPerRLr5ModeSpecificInfo*>(items[0]) = dLInformationPerRLr5ModeSpecificInfo; }
	void setDlDPCHInfoPerRL(const DLDPCHInfoPerRLr5& dlDPCHInfoPerRL) { *static_cast<DLDPCHInfoPerRLr5*>(items[1]) = dlDPCHInfoPerRL; }
	void setDummy(const SCCPCHInfoForFACHr4& dummy) { *static_cast<SCCPCHInfoForFACHr4*>(items[2]) = dummy; }
	void setCellid(const CellIdentity& cellid) { *static_cast<CellIdentity*>(items[3]) = cellid; }
};

class DLInformationPerRLr5bisModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLInformationPerRLr5bisModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setDummy1(const PDSCHSHODCHInfo& dummy1) { *static_cast<PDSCHSHODCHInfo*>(items[1]) = dummy1; }
	void setDummy2(const PDSCHCodeMapping& dummy2) { *static_cast<PDSCHCodeMapping*>(items[2]) = dummy2; }
};

class DLInformationPerRLr5bisModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerRLr5bisModeSpecificInfoChoices {
		dLInformationPerRLr5bisModeSpecificInfoFdd = 0,
		tdd = 1,
	};
	static const Info theInfo;
	DLInformationPerRLr5bisModeSpecificInfo(): Choice(&theInfo) {}
};

class DLInformationPerRLr5bis : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	DLInformationPerRLr5bis(): Sequence(&theInfo) {}

	void setDLInformationPerRLr5bisModeSpecificInfo(const DLInformationPerRLr5bisModeSpecificInfo& dLInformationPerRLr5bisModeSpecificInfo) { *static_cast<DLInformationPerRLr5bisModeSpecificInfo*>(items[0]) = dLInformationPerRLr5bisModeSpecificInfo; }
	void setDlDPCHInfoPerRL(const DLDPCHInfoPerRLr5& dlDPCHInfoPerRL) { *static_cast<DLDPCHInfoPerRLr5*>(items[1]) = dlDPCHInfoPerRL; }
	void setDummy(const SCCPCHInfoForFACHr4& dummy) { *static_cast<SCCPCHInfoForFACHr4*>(items[2]) = dummy; }
	void setCellid(const CellIdentity& cellid) { *static_cast<CellIdentity*>(items[3]) = cellid; }
};

typedef Boolean DLInformationPerRLr6ModeSpecificInfoFddServingHSDSCHRLindicator;

typedef Boolean DLInformationPerRLr6ModeSpecificInfoFddServingEDCHRLindicator;

class DLInformationPerRLr6ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLInformationPerRLr6ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setDLInformationPerRLr6ModeSpecificInfoFddServingHSDSCHRLindicator(const DLInformationPerRLr6ModeSpecificInfoFddServingHSDSCHRLindicator& dLInformationPerRLr6ModeSpecificInfoFddServingHSDSCHRLindicator) { *static_cast<DLInformationPerRLr6ModeSpecificInfoFddServingHSDSCHRLindicator*>(items[1]) = dLInformationPerRLr6ModeSpecificInfoFddServingHSDSCHRLindicator; }
	void setDLInformationPerRLr6ModeSpecificInfoFddServingEDCHRLindicator(const DLInformationPerRLr6ModeSpecificInfoFddServingEDCHRLindicator& dLInformationPerRLr6ModeSpecificInfoFddServingEDCHRLindicator) { *static_cast<DLInformationPerRLr6ModeSpecificInfoFddServingEDCHRLindicator*>(items[2]) = dLInformationPerRLr6ModeSpecificInfoFddServingEDCHRLindicator; }
};

class DLInformationPerRLr6ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerRLr6ModeSpecificInfoChoices {
		dLInformationPerRLr6ModeSpecificInfoFdd = 0,
		tdd = 1,
	};
	static const Info theInfo;
	DLInformationPerRLr6ModeSpecificInfo(): Choice(&theInfo) {}
};

class DLInformationPerRLr6DldpchInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerRLr6DldpchInfoChoices {
		dlDPCHInfoPerRL = 0,
		dlFDPCHInfoPerRL = 1,
	};
	static const Info theInfo;
	DLInformationPerRLr6DldpchInfo(): Choice(&theInfo) {}
};

typedef Null DLInformationPerRLr6EHICHInfoReleaseIndicator;

class DLInformationPerRLr6EHICHInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerRLr6EHICHInfoChoices {
		eHICHInformation = 0,
		dLInformationPerRLr6EHICHInfoReleaseIndicator = 1,
	};
	static const Info theInfo;
	DLInformationPerRLr6EHICHInfo(): Choice(&theInfo) {}
};

typedef Null DLInformationPerRLr6ERGCHInfoReleaseIndicator;

class DLInformationPerRLr6ERGCHInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerRLr6ERGCHInfoChoices {
		eRGCHInformation = 0,
		dLInformationPerRLr6ERGCHInfoReleaseIndicator = 1,
	};
	static const Info theInfo;
	DLInformationPerRLr6ERGCHInfo(): Choice(&theInfo) {}
};

class DLInformationPerRLr6 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	DLInformationPerRLr6(): Sequence(&theInfo) {}

	void setDLInformationPerRLr6ModeSpecificInfo(const DLInformationPerRLr6ModeSpecificInfo& dLInformationPerRLr6ModeSpecificInfo) { *static_cast<DLInformationPerRLr6ModeSpecificInfo*>(items[0]) = dLInformationPerRLr6ModeSpecificInfo; }
	void setDLInformationPerRLr6DldpchInfo(const DLInformationPerRLr6DldpchInfo& dLInformationPerRLr6DldpchInfo) { *static_cast<DLInformationPerRLr6DldpchInfo*>(items[1]) = dLInformationPerRLr6DldpchInfo; }
	void setEAGCHInformation(const EAGCHInformation& eAGCHInformation) { *static_cast<EAGCHInformation*>(items[2]) = eAGCHInformation; }
	void setDLInformationPerRLr6EHICHInfo(const DLInformationPerRLr6EHICHInfo& dLInformationPerRLr6EHICHInfo) { *static_cast<DLInformationPerRLr6EHICHInfo*>(items[3]) = dLInformationPerRLr6EHICHInfo; }
	void setDLInformationPerRLr6ERGCHInfo(const DLInformationPerRLr6ERGCHInfo& dLInformationPerRLr6ERGCHInfo) { *static_cast<DLInformationPerRLr6ERGCHInfo*>(items[4]) = dLInformationPerRLr6ERGCHInfo; }
	void setCellid(const CellIdentity& cellid) { *static_cast<CellIdentity*>(items[5]) = cellid; }
};

class DLInformationPerRLv6b0ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLInformationPerRLv6b0ext(): Sequence(&theInfo) {}

	void setSttdIndication(const STTDIndication& sttdIndication) { *static_cast<STTDIndication*>(items[0]) = sttdIndication; }
};

typedef Boolean DLInformationPerRLr7ModeSpecificInfoFddServingHSDSCHRLindicator;

typedef Boolean DLInformationPerRLr7ModeSpecificInfoFddServingEDCHRLindicator;

class DLInformationPerRLr7ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLInformationPerRLr7ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setDLInformationPerRLr7ModeSpecificInfoFddServingHSDSCHRLindicator(const DLInformationPerRLr7ModeSpecificInfoFddServingHSDSCHRLindicator& dLInformationPerRLr7ModeSpecificInfoFddServingHSDSCHRLindicator) { *static_cast<DLInformationPerRLr7ModeSpecificInfoFddServingHSDSCHRLindicator*>(items[1]) = dLInformationPerRLr7ModeSpecificInfoFddServingHSDSCHRLindicator; }
	void setDLInformationPerRLr7ModeSpecificInfoFddServingEDCHRLindicator(const DLInformationPerRLr7ModeSpecificInfoFddServingEDCHRLindicator& dLInformationPerRLr7ModeSpecificInfoFddServingEDCHRLindicator) { *static_cast<DLInformationPerRLr7ModeSpecificInfoFddServingEDCHRLindicator*>(items[2]) = dLInformationPerRLr7ModeSpecificInfoFddServingEDCHRLindicator; }
};

class DLInformationPerRLr7ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerRLr7ModeSpecificInfoChoices {
		dLInformationPerRLr7ModeSpecificInfoFdd = 0,
		tdd = 1,
	};
	static const Info theInfo;
	DLInformationPerRLr7ModeSpecificInfo(): Choice(&theInfo) {}
};

class DLInformationPerRLr7DldpchInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerRLr7DldpchInfoChoices {
		dlDPCHInfoPerRL = 0,
		dlFDPCHInfoPerRL = 1,
	};
	static const Info theInfo;
	DLInformationPerRLr7DldpchInfo(): Choice(&theInfo) {}
};

class EAGCHInformationr7ModeSpecificFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	EAGCHInformationr7ModeSpecificFdd(): Sequence(&theInfo) {}

	void setEAGCHChannelisationCode(const EAGCHChannelisationCode& eAGCHChannelisationCode) { *static_cast<EAGCHChannelisationCode*>(items[0]) = eAGCHChannelisationCode; }
};

typedef Boolean EAGCHInformationr7ModeSpecificTddTdd384LongTermGrantIndicator;

typedef Integer<CONSTRAINED, 1, 12> EAGCHInformationr7ModeSpecificTddTdd384LengthofTTRIfield;

typedef Integer<CONSTRAINED, 0, 14> EAGCHIndividualTSnumber;

enum MidambleConfigurationBurstType1Values {
	ms4_MidambleConfigurationBurstType1 = 0,
	ms8_MidambleConfigurationBurstType1 = 1,
	ms16_MidambleConfigurationBurstType1 = 2,
};
typedef Enumerated<CONSTRAINED, 2> MidambleConfigurationBurstType1;

typedef Null MidambleShiftAndBurstTypeEDCHBurstTypeType1MidambleAllocationModeDefaultMidamble;

typedef Null MidambleShiftAndBurstTypeEDCHBurstTypeType1MidambleAllocationModeCommonMidamble;

class MidambleShiftAndBurstTypeEDCHBurstTypeType1MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeEDCHBurstTypeType1MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftLong& midambleShift) { *static_cast<MidambleShiftLong*>(items[0]) = midambleShift; }
};

class MidambleShiftAndBurstTypeEDCHBurstTypeType1MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MidambleShiftAndBurstTypeEDCHBurstTypeType1MidambleAllocationModeChoices {
		midambleShiftAndBurstTypeEDCHBurstTypeType1MidambleAllocationModeDefaultMidamble = 0,
		midambleShiftAndBurstTypeEDCHBurstTypeType1MidambleAllocationModeCommonMidamble = 1,
		midambleShiftAndBurstTypeEDCHBurstTypeType1MidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTypeEDCHBurstTypeType1MidambleAllocationMode(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstTypeEDCHBurstTypeType1 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeEDCHBurstTypeType1(): Sequence(&theInfo) {}

	void setMidambleConfigurationBurstType1(const MidambleConfigurationBurstType1& midambleConfigurationBurstType1) { *static_cast<MidambleConfigurationBurstType1*>(items[0]) = midambleConfigurationBurstType1; }
	void setMidambleShiftAndBurstTypeEDCHBurstTypeType1MidambleAllocationMode(const MidambleShiftAndBurstTypeEDCHBurstTypeType1MidambleAllocationMode& midambleShiftAndBurstTypeEDCHBurstTypeType1MidambleAllocationMode) { *static_cast<MidambleShiftAndBurstTypeEDCHBurstTypeType1MidambleAllocationMode*>(items[1]) = midambleShiftAndBurstTypeEDCHBurstTypeType1MidambleAllocationMode; }
};

typedef Null MidambleShiftAndBurstTypeEDCHBurstTypeType2MidambleAllocationModeDefaultMidamble;

typedef Null MidambleShiftAndBurstTypeEDCHBurstTypeType2MidambleAllocationModeCommonMidamble;

class MidambleShiftAndBurstTypeEDCHBurstTypeType2MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeEDCHBurstTypeType2MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftShort& midambleShift) { *static_cast<MidambleShiftShort*>(items[0]) = midambleShift; }
};

class MidambleShiftAndBurstTypeEDCHBurstTypeType2MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MidambleShiftAndBurstTypeEDCHBurstTypeType2MidambleAllocationModeChoices {
		midambleShiftAndBurstTypeEDCHBurstTypeType2MidambleAllocationModeDefaultMidamble = 0,
		midambleShiftAndBurstTypeEDCHBurstTypeType2MidambleAllocationModeCommonMidamble = 1,
		midambleShiftAndBurstTypeEDCHBurstTypeType2MidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTypeEDCHBurstTypeType2MidambleAllocationMode(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstTypeEDCHBurstTypeType2 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeEDCHBurstTypeType2(): Sequence(&theInfo) {}

	void setMidambleConfigurationBurstType2(const MidambleConfigurationBurstType2& midambleConfigurationBurstType2) { *static_cast<MidambleConfigurationBurstType2*>(items[0]) = midambleConfigurationBurstType2; }
	void setMidambleShiftAndBurstTypeEDCHBurstTypeType2MidambleAllocationMode(const MidambleShiftAndBurstTypeEDCHBurstTypeType2MidambleAllocationMode& midambleShiftAndBurstTypeEDCHBurstTypeType2MidambleAllocationMode) { *static_cast<MidambleShiftAndBurstTypeEDCHBurstTypeType2MidambleAllocationMode*>(items[1]) = midambleShiftAndBurstTypeEDCHBurstTypeType2MidambleAllocationMode; }
};

class MidambleShiftAndBurstTypeEDCHBurstType : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MidambleShiftAndBurstTypeEDCHBurstTypeChoices {
		midambleShiftAndBurstTypeEDCHBurstTypeType1 = 0,
		midambleShiftAndBurstTypeEDCHBurstTypeType2 = 1,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTypeEDCHBurstType(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstTypeEDCH : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeEDCH(): Sequence(&theInfo) {}

	void setMidambleShiftAndBurstTypeEDCHBurstType(const MidambleShiftAndBurstTypeEDCHBurstType& midambleShiftAndBurstTypeEDCHBurstType) { *static_cast<MidambleShiftAndBurstTypeEDCHBurstType*>(items[0]) = midambleShiftAndBurstTypeEDCHBurstType; }
};

class EAGCHIndividual : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	EAGCHIndividual(): Sequence(&theInfo) {}

	void setEAGCHIndividualTSnumber(const EAGCHIndividualTSnumber& eAGCHIndividualTSnumber) { *static_cast<EAGCHIndividualTSnumber*>(items[0]) = eAGCHIndividualTSnumber; }
	void setChannelisationcode(const DLTSChannelisationCode& channelisationcode) { *static_cast<DLTSChannelisationCode*>(items[1]) = channelisationcode; }
	void setMidambleShiftAndBurstType(const MidambleShiftAndBurstTypeEDCH& midambleShiftAndBurstType) { *static_cast<MidambleShiftAndBurstTypeEDCH*>(items[2]) = midambleShiftAndBurstType; }
};

typedef SequenceOf<EAGCHIndividual, CONSTRAINED, 1, maxNumE_AGCH> EAGCHSetConfig;

class EAGCHInformationr7ModeSpecificTddTdd384 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	EAGCHInformationr7ModeSpecificTddTdd384(): Sequence(&theInfo) {}

	void setEAGCHInformationr7ModeSpecificTddTdd384LongTermGrantIndicator(const EAGCHInformationr7ModeSpecificTddTdd384LongTermGrantIndicator& eAGCHInformationr7ModeSpecificTddTdd384LongTermGrantIndicator) { *static_cast<EAGCHInformationr7ModeSpecificTddTdd384LongTermGrantIndicator*>(items[0]) = eAGCHInformationr7ModeSpecificTddTdd384LongTermGrantIndicator; }
	void setEAGCHInformationr7ModeSpecificTddTdd384LengthofTTRIfield(const EAGCHInformationr7ModeSpecificTddTdd384LengthofTTRIfield& eAGCHInformationr7ModeSpecificTddTdd384LengthofTTRIfield) { *static_cast<EAGCHInformationr7ModeSpecificTddTdd384LengthofTTRIfield*>(items[1]) = eAGCHInformationr7ModeSpecificTddTdd384LengthofTTRIfield; }
	void setEAGCHSetConfig(const EAGCHSetConfig& eAGCHSetConfig) { *static_cast<EAGCHSetConfig*>(items[2]) = eAGCHSetConfig; }
	void setEAGCHBLERTarget(const BlerTarget& eAGCHBLERTarget) { *static_cast<BlerTarget*>(items[3]) = eAGCHBLERTarget; }
};

typedef Boolean EAGCHInformationr7ModeSpecificTddTdd768LongTermGrantIndicator;

typedef Integer<CONSTRAINED, 1, 12> EAGCHInformationr7ModeSpecificTddTdd768LengthofTTRIfield;

typedef Integer<CONSTRAINED, 0, 14> EAGCHIndividualVHCRTSnumber;

class EAGCHIndividualVHCR : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	EAGCHIndividualVHCR(): Sequence(&theInfo) {}

	void setEAGCHIndividualVHCRTSnumber(const EAGCHIndividualVHCRTSnumber& eAGCHIndividualVHCRTSnumber) { *static_cast<EAGCHIndividualVHCRTSnumber*>(items[0]) = eAGCHIndividualVHCRTSnumber; }
	void setChannelisationcode(const DLTSChannelisationCodeVHCR& channelisationcode) { *static_cast<DLTSChannelisationCodeVHCR*>(items[1]) = channelisationcode; }
	void setMidambleShiftAndBurstType(const MidambleShiftAndBurstTypeEDCH& midambleShiftAndBurstType) { *static_cast<MidambleShiftAndBurstTypeEDCH*>(items[2]) = midambleShiftAndBurstType; }
};

typedef SequenceOf<EAGCHIndividualVHCR, CONSTRAINED, 1, maxNumE_AGCH> EAGCHSetConfigVHCR;

class EAGCHInformationr7ModeSpecificTddTdd768 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	EAGCHInformationr7ModeSpecificTddTdd768(): Sequence(&theInfo) {}

	void setEAGCHInformationr7ModeSpecificTddTdd768LongTermGrantIndicator(const EAGCHInformationr7ModeSpecificTddTdd768LongTermGrantIndicator& eAGCHInformationr7ModeSpecificTddTdd768LongTermGrantIndicator) { *static_cast<EAGCHInformationr7ModeSpecificTddTdd768LongTermGrantIndicator*>(items[0]) = eAGCHInformationr7ModeSpecificTddTdd768LongTermGrantIndicator; }
	void setEAGCHInformationr7ModeSpecificTddTdd768LengthofTTRIfield(const EAGCHInformationr7ModeSpecificTddTdd768LengthofTTRIfield& eAGCHInformationr7ModeSpecificTddTdd768LengthofTTRIfield) { *static_cast<EAGCHInformationr7ModeSpecificTddTdd768LengthofTTRIfield*>(items[1]) = eAGCHInformationr7ModeSpecificTddTdd768LengthofTTRIfield; }
	void setEAGCHSetConfig(const EAGCHSetConfigVHCR& eAGCHSetConfig) { *static_cast<EAGCHSetConfigVHCR*>(items[2]) = eAGCHSetConfig; }
	void setEAGCHBLERTarget(const BlerTarget& eAGCHBLERTarget) { *static_cast<BlerTarget*>(items[3]) = eAGCHBLERTarget; }
};

typedef Boolean EAGCHInformationr7ModeSpecificTddTdd128RdiIndicator;

class EAGCHInformationr7ModeSpecificTddTdd128 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	EAGCHInformationr7ModeSpecificTddTdd128(): Sequence(&theInfo) {}

	void setEAGCHInformationr7ModeSpecificTddTdd128RdiIndicator(const EAGCHInformationr7ModeSpecificTddTdd128RdiIndicator& eAGCHInformationr7ModeSpecificTddTdd128RdiIndicator) { *static_cast<EAGCHInformationr7ModeSpecificTddTdd128RdiIndicator*>(items[0]) = eAGCHInformationr7ModeSpecificTddTdd128RdiIndicator; }
	void setTpcStepSize(const TPCStepSizeTDD& tpcStepSize) { *static_cast<TPCStepSizeTDD*>(items[1]) = tpcStepSize; }
	void setEAGCHSetConfig(const EAGCHSetConfigLCR& eAGCHSetConfig) { *static_cast<EAGCHSetConfigLCR*>(items[2]) = eAGCHSetConfig; }
	void setEAGCHBLERTarget(const BlerTarget& eAGCHBLERTarget) { *static_cast<BlerTarget*>(items[3]) = eAGCHBLERTarget; }
};

class EAGCHInformationr7ModeSpecificTdd : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum EAGCHInformationr7ModeSpecificTddChoices {
		eAGCHInformationr7ModeSpecificTddTdd384 = 0,
		eAGCHInformationr7ModeSpecificTddTdd768 = 1,
		eAGCHInformationr7ModeSpecificTddTdd128 = 2,
	};
	static const Info theInfo;
	EAGCHInformationr7ModeSpecificTdd(): Choice(&theInfo) {}
};

class EAGCHInformationr7ModeSpecific : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum EAGCHInformationr7ModeSpecificChoices {
		eAGCHInformationr7ModeSpecificFdd = 0,
		eAGCHInformationr7ModeSpecificTdd = 1,
	};
	static const Info theInfo;
	EAGCHInformationr7ModeSpecific(): Choice(&theInfo) {}
};

class EAGCHInformationr7 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	EAGCHInformationr7(): Sequence(&theInfo) {}

	void setEAGCHInformationr7ModeSpecific(const EAGCHInformationr7ModeSpecific& eAGCHInformationr7ModeSpecific) { *static_cast<EAGCHInformationr7ModeSpecific*>(items[0]) = eAGCHInformationr7ModeSpecific; }
};

typedef Null DLInformationPerRLr7ModeSpecificInfo2FddEHICHInfoReleaseIndicator;

class DLInformationPerRLr7ModeSpecificInfo2FddEHICHInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerRLr7ModeSpecificInfo2FddEHICHInfoChoices {
		eHICHInformation = 0,
		dLInformationPerRLr7ModeSpecificInfo2FddEHICHInfoReleaseIndicator = 1,
	};
	static const Info theInfo;
	DLInformationPerRLr7ModeSpecificInfo2FddEHICHInfo(): Choice(&theInfo) {}
};

typedef Null DLInformationPerRLr7ModeSpecificInfo2FddERGCHInfoReleaseIndicator;

class DLInformationPerRLr7ModeSpecificInfo2FddERGCHInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerRLr7ModeSpecificInfo2FddERGCHInfoChoices {
		eRGCHInformation = 0,
		dLInformationPerRLr7ModeSpecificInfo2FddERGCHInfoReleaseIndicator = 1,
	};
	static const Info theInfo;
	DLInformationPerRLr7ModeSpecificInfo2FddERGCHInfo(): Choice(&theInfo) {}
};

class DLInformationPerRLr7ModeSpecificInfo2Fdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLInformationPerRLr7ModeSpecificInfo2Fdd(): Sequence(&theInfo) {}

	void setDLInformationPerRLr7ModeSpecificInfo2FddEHICHInfo(const DLInformationPerRLr7ModeSpecificInfo2FddEHICHInfo& dLInformationPerRLr7ModeSpecificInfo2FddEHICHInfo) { *static_cast<DLInformationPerRLr7ModeSpecificInfo2FddEHICHInfo*>(items[0]) = dLInformationPerRLr7ModeSpecificInfo2FddEHICHInfo; }
	void setDLInformationPerRLr7ModeSpecificInfo2FddERGCHInfo(const DLInformationPerRLr7ModeSpecificInfo2FddERGCHInfo& dLInformationPerRLr7ModeSpecificInfo2FddERGCHInfo) { *static_cast<DLInformationPerRLr7ModeSpecificInfo2FddERGCHInfo*>(items[1]) = dLInformationPerRLr7ModeSpecificInfo2FddERGCHInfo; }
};

typedef Integer<CONSTRAINED, 4, 44> EHICHInformationTDD384768NEHICH;

typedef Integer<CONSTRAINED, 0, 14> EHICHInformationTDD384768TSNumber;

class EHICHInformationTDD384768ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum EHICHInformationTDD384768ModeSpecificInfoChoices {
		tdd384 = 0,
		tdd768 = 1,
	};
	static const Info theInfo;
	EHICHInformationTDD384768ModeSpecificInfo(): Choice(&theInfo) {}
};

enum EHICHInformationTDD384768burst_TypeValues {
	type1_EHICHInformationTDD384768burst_Type = 0,
	type2_EHICHInformationTDD384768burst_Type = 1,
};
typedef Enumerated<CONSTRAINED, 1> EHICHInformationTDD384768burst_Type;

enum EHICHInformationTDD384768midamble_Allocation_ModeValues {
	default_EHICHInformationTDD384768midamble_Allocation_Mode = 0,
	common_EHICHInformationTDD384768midamble_Allocation_Mode = 1,
};
typedef Enumerated<CONSTRAINED, 1> EHICHInformationTDD384768midamble_Allocation_Mode;

class EHICHInformationTDD384768 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	EHICHInformationTDD384768(): Sequence(&theInfo) {}

	void setEHICHInformationTDD384768NEHICH(const EHICHInformationTDD384768NEHICH& eHICHInformationTDD384768NEHICH) { *static_cast<EHICHInformationTDD384768NEHICH*>(items[0]) = eHICHInformationTDD384768NEHICH; }
	void setEHICHInformationTDD384768TSNumber(const EHICHInformationTDD384768TSNumber& eHICHInformationTDD384768TSNumber) { *static_cast<EHICHInformationTDD384768TSNumber*>(items[1]) = eHICHInformationTDD384768TSNumber; }
	void setEHICHInformationTDD384768ModeSpecificInfo(const EHICHInformationTDD384768ModeSpecificInfo& eHICHInformationTDD384768ModeSpecificInfo) { *static_cast<EHICHInformationTDD384768ModeSpecificInfo*>(items[2]) = eHICHInformationTDD384768ModeSpecificInfo; }
	void setEHICHInformationTDD384768burst_Type(const EHICHInformationTDD384768burst_Type& eHICHInformationTDD384768burst_Type) { *static_cast<EHICHInformationTDD384768burst_Type*>(items[3]) = eHICHInformationTDD384768burst_Type; }
	void setEHICHInformationTDD384768midamble_Allocation_Mode(const EHICHInformationTDD384768midamble_Allocation_Mode& eHICHInformationTDD384768midamble_Allocation_Mode) { *static_cast<EHICHInformationTDD384768midamble_Allocation_Mode*>(items[4]) = eHICHInformationTDD384768midamble_Allocation_Mode; }
};

class DLInformationPerRLr7ModeSpecificInfo2TddTdd384tdd768 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLInformationPerRLr7ModeSpecificInfo2TddTdd384tdd768(): Sequence(&theInfo) {}

	void setEHICHInfo(const EHICHInformationTDD384768& eHICHInfo) { *static_cast<EHICHInformationTDD384768*>(items[0]) = eHICHInfo; }
};

class DLInformationPerRLr7ModeSpecificInfo2TddTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLInformationPerRLr7ModeSpecificInfo2TddTdd128(): Sequence(&theInfo) {}

	void setEHICHInfo(const EHICHInformationTDD128& eHICHInfo) { *static_cast<EHICHInformationTDD128*>(items[0]) = eHICHInfo; }
};

class DLInformationPerRLr7ModeSpecificInfo2Tdd : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerRLr7ModeSpecificInfo2TddChoices {
		dLInformationPerRLr7ModeSpecificInfo2TddTdd384tdd768 = 0,
		dLInformationPerRLr7ModeSpecificInfo2TddTdd128 = 1,
	};
	static const Info theInfo;
	DLInformationPerRLr7ModeSpecificInfo2Tdd(): Choice(&theInfo) {}
};

class DLInformationPerRLr7ModeSpecificInfo2 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerRLr7ModeSpecificInfo2Choices {
		dLInformationPerRLr7ModeSpecificInfo2Fdd = 0,
		dLInformationPerRLr7ModeSpecificInfo2Tdd = 1,
	};
	static const Info theInfo;
	DLInformationPerRLr7ModeSpecificInfo2(): Choice(&theInfo) {}
};

class DLInformationPerRLr7 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	DLInformationPerRLr7(): Sequence(&theInfo) {}

	void setDLInformationPerRLr7ModeSpecificInfo(const DLInformationPerRLr7ModeSpecificInfo& dLInformationPerRLr7ModeSpecificInfo) { *static_cast<DLInformationPerRLr7ModeSpecificInfo*>(items[0]) = dLInformationPerRLr7ModeSpecificInfo; }
	void setDLInformationPerRLr7DldpchInfo(const DLInformationPerRLr7DldpchInfo& dLInformationPerRLr7DldpchInfo) { *static_cast<DLInformationPerRLr7DldpchInfo*>(items[1]) = dLInformationPerRLr7DldpchInfo; }
	void setEAGCHInformation(const EAGCHInformationr7& eAGCHInformation) { *static_cast<EAGCHInformationr7*>(items[2]) = eAGCHInformation; }
	void setDLInformationPerRLr7ModeSpecificInfo2(const DLInformationPerRLr7ModeSpecificInfo2& dLInformationPerRLr7ModeSpecificInfo2) { *static_cast<DLInformationPerRLr7ModeSpecificInfo2*>(items[3]) = dLInformationPerRLr7ModeSpecificInfo2; }
	void setCellid(const CellIdentity& cellid) { *static_cast<CellIdentity*>(items[4]) = cellid; }
};

typedef Boolean DLInformationPerRLr8ModeSpecificInfoFddServingHSDSCHRLindicator;

typedef Boolean DLInformationPerRLr8ModeSpecificInfoFddServingEDCHRLindicator;

class DLInformationPerRLr8ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DLInformationPerRLr8ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setDLInformationPerRLr8ModeSpecificInfoFddServingHSDSCHRLindicator(const DLInformationPerRLr8ModeSpecificInfoFddServingHSDSCHRLindicator& dLInformationPerRLr8ModeSpecificInfoFddServingHSDSCHRLindicator) { *static_cast<DLInformationPerRLr8ModeSpecificInfoFddServingHSDSCHRLindicator*>(items[1]) = dLInformationPerRLr8ModeSpecificInfoFddServingHSDSCHRLindicator; }
	void setDLInformationPerRLr8ModeSpecificInfoFddServingEDCHRLindicator(const DLInformationPerRLr8ModeSpecificInfoFddServingEDCHRLindicator& dLInformationPerRLr8ModeSpecificInfoFddServingEDCHRLindicator) { *static_cast<DLInformationPerRLr8ModeSpecificInfoFddServingEDCHRLindicator*>(items[2]) = dLInformationPerRLr8ModeSpecificInfoFddServingEDCHRLindicator; }
};

class DLInformationPerRLr8ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerRLr8ModeSpecificInfoChoices {
		dLInformationPerRLr8ModeSpecificInfoFdd = 0,
		tdd = 1,
	};
	static const Info theInfo;
	DLInformationPerRLr8ModeSpecificInfo(): Choice(&theInfo) {}
};

class DLInformationPerRLr8DldpchInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerRLr8DldpchInfoChoices {
		dlDPCHInfoPerRL = 0,
		dlFDPCHInfoPerRL = 1,
	};
	static const Info theInfo;
	DLInformationPerRLr8DldpchInfo(): Choice(&theInfo) {}
};

class EAGCHInformationr8ModeSpecificFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	EAGCHInformationr8ModeSpecificFdd(): Sequence(&theInfo) {}

	void setEAGCHChannelisationCode(const EAGCHChannelisationCode& eAGCHChannelisationCode) { *static_cast<EAGCHChannelisationCode*>(items[0]) = eAGCHChannelisationCode; }
};

typedef Boolean EAGCHInformationr8ModeSpecificTddTdd384LongTermGrantIndicator;

typedef Integer<CONSTRAINED, 1, 12> EAGCHInformationr8ModeSpecificTddTdd384LengthofTTRIfield;

class EAGCHInformationr8ModeSpecificTddTdd384 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	EAGCHInformationr8ModeSpecificTddTdd384(): Sequence(&theInfo) {}

	void setEAGCHInformationr8ModeSpecificTddTdd384LongTermGrantIndicator(const EAGCHInformationr8ModeSpecificTddTdd384LongTermGrantIndicator& eAGCHInformationr8ModeSpecificTddTdd384LongTermGrantIndicator) { *static_cast<EAGCHInformationr8ModeSpecificTddTdd384LongTermGrantIndicator*>(items[0]) = eAGCHInformationr8ModeSpecificTddTdd384LongTermGrantIndicator; }
	void setEAGCHInformationr8ModeSpecificTddTdd384LengthofTTRIfield(const EAGCHInformationr8ModeSpecificTddTdd384LengthofTTRIfield& eAGCHInformationr8ModeSpecificTddTdd384LengthofTTRIfield) { *static_cast<EAGCHInformationr8ModeSpecificTddTdd384LengthofTTRIfield*>(items[1]) = eAGCHInformationr8ModeSpecificTddTdd384LengthofTTRIfield; }
	void setEAGCHSetConfig(const EAGCHSetConfig& eAGCHSetConfig) { *static_cast<EAGCHSetConfig*>(items[2]) = eAGCHSetConfig; }
	void setEAGCHBLERTarget(const BlerTarget& eAGCHBLERTarget) { *static_cast<BlerTarget*>(items[3]) = eAGCHBLERTarget; }
};

typedef Boolean EAGCHInformationr8ModeSpecificTddTdd768LongTermGrantIndicator;

typedef Integer<CONSTRAINED, 1, 12> EAGCHInformationr8ModeSpecificTddTdd768LengthofTTRIfield;

class EAGCHInformationr8ModeSpecificTddTdd768 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	EAGCHInformationr8ModeSpecificTddTdd768(): Sequence(&theInfo) {}

	void setEAGCHInformationr8ModeSpecificTddTdd768LongTermGrantIndicator(const EAGCHInformationr8ModeSpecificTddTdd768LongTermGrantIndicator& eAGCHInformationr8ModeSpecificTddTdd768LongTermGrantIndicator) { *static_cast<EAGCHInformationr8ModeSpecificTddTdd768LongTermGrantIndicator*>(items[0]) = eAGCHInformationr8ModeSpecificTddTdd768LongTermGrantIndicator; }
	void setEAGCHInformationr8ModeSpecificTddTdd768LengthofTTRIfield(const EAGCHInformationr8ModeSpecificTddTdd768LengthofTTRIfield& eAGCHInformationr8ModeSpecificTddTdd768LengthofTTRIfield) { *static_cast<EAGCHInformationr8ModeSpecificTddTdd768LengthofTTRIfield*>(items[1]) = eAGCHInformationr8ModeSpecificTddTdd768LengthofTTRIfield; }
	void setEAGCHSetConfig(const EAGCHSetConfigVHCR& eAGCHSetConfig) { *static_cast<EAGCHSetConfigVHCR*>(items[2]) = eAGCHSetConfig; }
	void setEAGCHBLERTarget(const BlerTarget& eAGCHBLERTarget) { *static_cast<BlerTarget*>(items[3]) = eAGCHBLERTarget; }
};

typedef Boolean EAGCHInformationr8ModeSpecificTddTdd128RdiIndicator;

class EAGCHInformationr8ModeSpecificTddTdd128 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	EAGCHInformationr8ModeSpecificTddTdd128(): Sequence(&theInfo) {}

	void setEAGCHInformationr8ModeSpecificTddTdd128RdiIndicator(const EAGCHInformationr8ModeSpecificTddTdd128RdiIndicator& eAGCHInformationr8ModeSpecificTddTdd128RdiIndicator) { *static_cast<EAGCHInformationr8ModeSpecificTddTdd128RdiIndicator*>(items[0]) = eAGCHInformationr8ModeSpecificTddTdd128RdiIndicator; }
	void setTpcStepSize(const TPCStepSizeTDD& tpcStepSize) { *static_cast<TPCStepSizeTDD*>(items[1]) = tpcStepSize; }
	void setEAGCHSetConfig(const EAGCHSetConfigLCR& eAGCHSetConfig) { *static_cast<EAGCHSetConfigLCR*>(items[2]) = eAGCHSetConfig; }
	void setEAGCHBLERTarget(const BlerTarget& eAGCHBLERTarget) { *static_cast<BlerTarget*>(items[3]) = eAGCHBLERTarget; }
	void setEAGCHInactivityMonitorThreshold(const EAGCHInactivityMonitorThresholdTDD128& eAGCHInactivityMonitorThreshold) { *static_cast<EAGCHInactivityMonitorThresholdTDD128*>(items[4]) = eAGCHInactivityMonitorThreshold; }
};

class EAGCHInformationr8ModeSpecificTdd : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum EAGCHInformationr8ModeSpecificTddChoices {
		eAGCHInformationr8ModeSpecificTddTdd384 = 0,
		eAGCHInformationr8ModeSpecificTddTdd768 = 1,
		eAGCHInformationr8ModeSpecificTddTdd128 = 2,
	};
	static const Info theInfo;
	EAGCHInformationr8ModeSpecificTdd(): Choice(&theInfo) {}
};

class EAGCHInformationr8ModeSpecific : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum EAGCHInformationr8ModeSpecificChoices {
		eAGCHInformationr8ModeSpecificFdd = 0,
		eAGCHInformationr8ModeSpecificTdd = 1,
	};
	static const Info theInfo;
	EAGCHInformationr8ModeSpecific(): Choice(&theInfo) {}
};

class EAGCHInformationr8 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	EAGCHInformationr8(): Sequence(&theInfo) {}

	void setEAGCHInformationr8ModeSpecific(const EAGCHInformationr8ModeSpecific& eAGCHInformationr8ModeSpecific) { *static_cast<EAGCHInformationr8ModeSpecific*>(items[0]) = eAGCHInformationr8ModeSpecific; }
};

typedef Null DLInformationPerRLr8ModeSpecificInfo2FddEHICHInfoReleaseIndicator;

class DLInformationPerRLr8ModeSpecificInfo2FddEHICHInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerRLr8ModeSpecificInfo2FddEHICHInfoChoices {
		eHICHInformation = 0,
		dLInformationPerRLr8ModeSpecificInfo2FddEHICHInfoReleaseIndicator = 1,
	};
	static const Info theInfo;
	DLInformationPerRLr8ModeSpecificInfo2FddEHICHInfo(): Choice(&theInfo) {}
};

typedef Null DLInformationPerRLr8ModeSpecificInfo2FddERGCHInfoReleaseIndicator;

class DLInformationPerRLr8ModeSpecificInfo2FddERGCHInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerRLr8ModeSpecificInfo2FddERGCHInfoChoices {
		eRGCHInformation = 0,
		dLInformationPerRLr8ModeSpecificInfo2FddERGCHInfoReleaseIndicator = 1,
	};
	static const Info theInfo;
	DLInformationPerRLr8ModeSpecificInfo2FddERGCHInfo(): Choice(&theInfo) {}
};

class DLInformationPerRLr8ModeSpecificInfo2Fdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLInformationPerRLr8ModeSpecificInfo2Fdd(): Sequence(&theInfo) {}

	void setDLInformationPerRLr8ModeSpecificInfo2FddEHICHInfo(const DLInformationPerRLr8ModeSpecificInfo2FddEHICHInfo& dLInformationPerRLr8ModeSpecificInfo2FddEHICHInfo) { *static_cast<DLInformationPerRLr8ModeSpecificInfo2FddEHICHInfo*>(items[0]) = dLInformationPerRLr8ModeSpecificInfo2FddEHICHInfo; }
	void setDLInformationPerRLr8ModeSpecificInfo2FddERGCHInfo(const DLInformationPerRLr8ModeSpecificInfo2FddERGCHInfo& dLInformationPerRLr8ModeSpecificInfo2FddERGCHInfo) { *static_cast<DLInformationPerRLr8ModeSpecificInfo2FddERGCHInfo*>(items[1]) = dLInformationPerRLr8ModeSpecificInfo2FddERGCHInfo; }
};

class DLInformationPerRLr8ModeSpecificInfo2TddTdd384tdd768 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLInformationPerRLr8ModeSpecificInfo2TddTdd384tdd768(): Sequence(&theInfo) {}

	void setEHICHInfo(const EHICHInformationTDD384768& eHICHInfo) { *static_cast<EHICHInformationTDD384768*>(items[0]) = eHICHInfo; }
};

class DLInformationPerRLr8ModeSpecificInfo2TddTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLInformationPerRLr8ModeSpecificInfo2TddTdd128(): Sequence(&theInfo) {}

	void setEHICHInfo(const EHICHInformationTDD128& eHICHInfo) { *static_cast<EHICHInformationTDD128*>(items[0]) = eHICHInfo; }
};

class DLInformationPerRLr8ModeSpecificInfo2Tdd : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerRLr8ModeSpecificInfo2TddChoices {
		dLInformationPerRLr8ModeSpecificInfo2TddTdd384tdd768 = 0,
		dLInformationPerRLr8ModeSpecificInfo2TddTdd128 = 1,
	};
	static const Info theInfo;
	DLInformationPerRLr8ModeSpecificInfo2Tdd(): Choice(&theInfo) {}
};

class DLInformationPerRLr8ModeSpecificInfo2 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLInformationPerRLr8ModeSpecificInfo2Choices {
		dLInformationPerRLr8ModeSpecificInfo2Fdd = 0,
		dLInformationPerRLr8ModeSpecificInfo2Tdd = 1,
	};
	static const Info theInfo;
	DLInformationPerRLr8ModeSpecificInfo2(): Choice(&theInfo) {}
};

class DLInformationPerRLr8 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	DLInformationPerRLr8(): Sequence(&theInfo) {}

	void setDLInformationPerRLr8ModeSpecificInfo(const DLInformationPerRLr8ModeSpecificInfo& dLInformationPerRLr8ModeSpecificInfo) { *static_cast<DLInformationPerRLr8ModeSpecificInfo*>(items[0]) = dLInformationPerRLr8ModeSpecificInfo; }
	void setDLInformationPerRLr8DldpchInfo(const DLInformationPerRLr8DldpchInfo& dLInformationPerRLr8DldpchInfo) { *static_cast<DLInformationPerRLr8DldpchInfo*>(items[1]) = dLInformationPerRLr8DldpchInfo; }
	void setEAGCHInformation(const EAGCHInformationr8& eAGCHInformation) { *static_cast<EAGCHInformationr8*>(items[2]) = eAGCHInformation; }
	void setDLInformationPerRLr8ModeSpecificInfo2(const DLInformationPerRLr8ModeSpecificInfo2& dLInformationPerRLr8ModeSpecificInfo2) { *static_cast<DLInformationPerRLr8ModeSpecificInfo2*>(items[3]) = dLInformationPerRLr8ModeSpecificInfo2; }
	void setCellid(const CellIdentity& cellid) { *static_cast<CellIdentity*>(items[4]) = cellid; }
};

typedef SequenceOf<DLInformationPerRL, CONSTRAINED, 1, maxRL> DLInformationPerRLList;

typedef SequenceOf<DLInformationPerRLr4, CONSTRAINED, 1, maxRL> DLInformationPerRLListr4;

typedef SequenceOf<DLInformationPerRLr5, CONSTRAINED, 1, maxRL> DLInformationPerRLListr5;

typedef SequenceOf<DLInformationPerRLr6, CONSTRAINED, 1, maxRL> DLInformationPerRLListr6;

typedef SequenceOf<DLInformationPerRLv6b0ext, CONSTRAINED, 1, maxRL> DLInformationPerRLListv6b0ext;

typedef SequenceOf<DLInformationPerRLr5bis, CONSTRAINED, 1, maxRL> DLInformationPerRLListr5bis;

typedef SequenceOf<DLInformationPerRLr7, CONSTRAINED, 1, maxRL> DLInformationPerRLListr7;

typedef SequenceOf<DLInformationPerRLr8, CONSTRAINED, 1, maxRL> DLInformationPerRLListr8;

class DLInformationPerRLPostFDD : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLInformationPerRLPostFDD(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setDlDPCHInfoPerRL(const DLDPCHInfoPerRLPostFDD& dlDPCHInfoPerRL) { *static_cast<DLDPCHInfoPerRLPostFDD*>(items[1]) = dlDPCHInfoPerRL; }
};

typedef SequenceOf<DLInformationPerRLPostFDD, CONSTRAINED, 1, maxRL> DLInformationPerRLListPostFDD;

class PrimaryCCPCHInfoPostSyncCaseSyncCase1 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PrimaryCCPCHInfoPostSyncCaseSyncCase1(): Sequence(&theInfo) {}

	void setTimeslot(const TimeslotNumber& timeslot) { *static_cast<TimeslotNumber*>(items[0]) = timeslot; }
};

class PrimaryCCPCHInfoPostSyncCaseSyncCase2 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PrimaryCCPCHInfoPostSyncCaseSyncCase2(): Sequence(&theInfo) {}

	void setTimeslotSync2(const TimeslotSync2& timeslotSync2) { *static_cast<TimeslotSync2*>(items[0]) = timeslotSync2; }
};

class PrimaryCCPCHInfoPostSyncCase : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PrimaryCCPCHInfoPostSyncCaseChoices {
		primaryCCPCHInfoPostSyncCaseSyncCase1 = 0,
		primaryCCPCHInfoPostSyncCaseSyncCase2 = 1,
	};
	static const Info theInfo;
	PrimaryCCPCHInfoPostSyncCase(): Choice(&theInfo) {}
};

typedef Boolean PrimaryCCPCHInfoPostSctdIndicator;

class PrimaryCCPCHInfoPost : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PrimaryCCPCHInfoPost(): Sequence(&theInfo) {}

	void setPrimaryCCPCHInfoPostSyncCase(const PrimaryCCPCHInfoPostSyncCase& primaryCCPCHInfoPostSyncCase) { *static_cast<PrimaryCCPCHInfoPostSyncCase*>(items[0]) = primaryCCPCHInfoPostSyncCase; }
	void setCellParametersID(const CellParametersID& cellParametersID) { *static_cast<CellParametersID*>(items[1]) = cellParametersID; }
	void setPrimaryCCPCHInfoPostSctdIndicator(const PrimaryCCPCHInfoPostSctdIndicator& primaryCCPCHInfoPostSctdIndicator) { *static_cast<PrimaryCCPCHInfoPostSctdIndicator*>(items[2]) = primaryCCPCHInfoPostSctdIndicator; }
};

class DLInformationPerRLPostTDD : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLInformationPerRLPostTDD(): Sequence(&theInfo) {}

	void setPrimaryCCPCHInfo(const PrimaryCCPCHInfoPost& primaryCCPCHInfo) { *static_cast<PrimaryCCPCHInfoPost*>(items[0]) = primaryCCPCHInfo; }
	void setDlDPCHInfoPerRL(const DLDPCHInfoPerRLPostTDD& dlDPCHInfoPerRL) { *static_cast<DLDPCHInfoPerRLPostTDD*>(items[1]) = dlDPCHInfoPerRL; }
};

typedef Boolean PrimaryCCPCHInfoPostTDDLCRr4TstdIndicator;

typedef Boolean PrimaryCCPCHInfoPostTDDLCRr4SctdIndicator;

class PrimaryCCPCHInfoPostTDDLCRr4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PrimaryCCPCHInfoPostTDDLCRr4(): Sequence(&theInfo) {}

	void setPrimaryCCPCHInfoPostTDDLCRr4TstdIndicator(const PrimaryCCPCHInfoPostTDDLCRr4TstdIndicator& primaryCCPCHInfoPostTDDLCRr4TstdIndicator) { *static_cast<PrimaryCCPCHInfoPostTDDLCRr4TstdIndicator*>(items[0]) = primaryCCPCHInfoPostTDDLCRr4TstdIndicator; }
	void setCellParametersID(const CellParametersID& cellParametersID) { *static_cast<CellParametersID*>(items[1]) = cellParametersID; }
	void setPrimaryCCPCHInfoPostTDDLCRr4SctdIndicator(const PrimaryCCPCHInfoPostTDDLCRr4SctdIndicator& primaryCCPCHInfoPostTDDLCRr4SctdIndicator) { *static_cast<PrimaryCCPCHInfoPostTDDLCRr4SctdIndicator*>(items[2]) = primaryCCPCHInfoPostTDDLCRr4SctdIndicator; }
};

class DLInformationPerRLPostTDDLCRr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLInformationPerRLPostTDDLCRr4(): Sequence(&theInfo) {}

	void setPrimaryCCPCHInfo(const PrimaryCCPCHInfoPostTDDLCRr4& primaryCCPCHInfo) { *static_cast<PrimaryCCPCHInfoPostTDDLCRr4*>(items[0]) = primaryCCPCHInfo; }
	void setDlDPCHInfoPerRL(const DLDPCHInfoPerRLPostTDDLCRr4& dlDPCHInfoPerRL) { *static_cast<DLDPCHInfoPerRLPostTDDLCRr4*>(items[1]) = dlDPCHInfoPerRL; }
};

class DLPDSCHInformation : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLPDSCHInformation(): Sequence(&theInfo) {}

	void setDummy1(const PDSCHSHODCHInfo& dummy1) { *static_cast<PDSCHSHODCHInfo*>(items[0]) = dummy1; }
	void setDummy2(const PDSCHCodeMapping& dummy2) { *static_cast<PDSCHCodeMapping*>(items[1]) = dummy2; }
};

typedef Null DLSecondaryCellInfoFDDContinue;

enum DLSecondaryCellInfoFDDNewConfigurationdl_64QAM_ConfiguredValues {
	true_DLSecondaryCellInfoFDDNewConfigurationdl_64QAM_Configured = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLSecondaryCellInfoFDDNewConfigurationdl_64QAM_Configured;

typedef SequenceOf<HSSCCHCodes, CONSTRAINED, 1, maxHSSCCHs> DLSecondaryCellInfoFDDNewConfigurationHSSCCHChannelisationCodeInfo;

class DLSecondaryCellInfoFDDNewConfiguration : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	DLSecondaryCellInfoFDDNewConfiguration(): Sequence(&theInfo) {}

	void setNewHRNTI(const HRNTI& newHRNTI) { *static_cast<HRNTI*>(items[0]) = newHRNTI; }
	void setDLSecondaryCellInfoFDDNewConfigurationdl_64QAM_Configured(const DLSecondaryCellInfoFDDNewConfigurationdl_64QAM_Configured& dLSecondaryCellInfoFDDNewConfigurationdl_64QAM_Configured) { *static_cast<DLSecondaryCellInfoFDDNewConfigurationdl_64QAM_Configured*>(items[1]) = dLSecondaryCellInfoFDDNewConfigurationdl_64QAM_Configured; }
	void setHsDSCHTBSizeTable(const HSDSCHTBSizeTable& hsDSCHTBSizeTable) { *static_cast<HSDSCHTBSizeTable*>(items[2]) = hsDSCHTBSizeTable; }
	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[3]) = primaryCPICHInfo; }
	void setDlScramblingCode(const SecondaryScramblingCode& dlScramblingCode) { *static_cast<SecondaryScramblingCode*>(items[4]) = dlScramblingCode; }
	void setDLSecondaryCellInfoFDDNewConfigurationHSSCCHChannelisationCodeInfo(const DLSecondaryCellInfoFDDNewConfigurationHSSCCHChannelisationCodeInfo& dLSecondaryCellInfoFDDNewConfigurationHSSCCHChannelisationCodeInfo) { *static_cast<DLSecondaryCellInfoFDDNewConfigurationHSSCCHChannelisationCodeInfo*>(items[5]) = dLSecondaryCellInfoFDDNewConfigurationHSSCCHChannelisationCodeInfo; }
	void setMeasurementPowerOffset(const MeasurementPowerOffset& measurementPowerOffset) { *static_cast<MeasurementPowerOffset*>(items[6]) = measurementPowerOffset; }
	void setUarfcnDL(const UARFCN& uarfcnDL) { *static_cast<UARFCN*>(items[7]) = uarfcnDL; }
};

class DLSecondaryCellInfoFDD : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLSecondaryCellInfoFDDChoices {
		dLSecondaryCellInfoFDDContinue = 0,
		dLSecondaryCellInfoFDDNewConfiguration = 1,
	};
	static const Info theInfo;
	DLSecondaryCellInfoFDD(): Choice(&theInfo) {}
};

enum DLSecondaryCellInfoFDDv890extdifferentTxModeFromServingHS_DSCHCellValues {
	different_DLSecondaryCellInfoFDDv890extdifferentTxModeFromServingHS_DSCHCell = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLSecondaryCellInfoFDDv890extdifferentTxModeFromServingHS_DSCHCell;

class DLSecondaryCellInfoFDDv890ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLSecondaryCellInfoFDDv890ext(): Sequence(&theInfo) {}

	void setDLSecondaryCellInfoFDDv890extdifferentTxModeFromServingHS_DSCHCell(const DLSecondaryCellInfoFDDv890extdifferentTxModeFromServingHS_DSCHCell& dLSecondaryCellInfoFDDv890extdifferentTxModeFromServingHS_DSCHCell) { *static_cast<DLSecondaryCellInfoFDDv890extdifferentTxModeFromServingHS_DSCHCell*>(items[0]) = dLSecondaryCellInfoFDDv890extdifferentTxModeFromServingHS_DSCHCell; }
};

typedef Null DLSecondaryCellInfoFDDr9ConfigurationInfoContinue;

enum DLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationdl_64QAM_ConfiguredValues {
	true_DLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationdl_64QAM_Configured = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationdl_64QAM_Configured;

typedef SequenceOf<HSSCCHCodes, CONSTRAINED, 1, maxHSSCCHs> DLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationHSSCCHChannelisationCodeInfo;

enum DLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationdifferentTxModeFromServingHS_DSCHCellValues {
	different_DLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationdifferentTxModeFromServingHS_DSCHCell = 0,
};
typedef Enumerated<CONSTRAINED, 0> DLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationdifferentTxModeFromServingHS_DSCHCell;

class DLSecondaryCellInfoFDDr9ConfigurationInfoNewConfiguration : public Sequence {
private:
	static const void *itemsInfo[9];
	static bool itemsPres[9];
public:
	static const Info theInfo;
	DLSecondaryCellInfoFDDr9ConfigurationInfoNewConfiguration(): Sequence(&theInfo) {}

	void setNewHRNTI(const HRNTI& newHRNTI) { *static_cast<HRNTI*>(items[0]) = newHRNTI; }
	void setDLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationdl_64QAM_Configured(const DLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationdl_64QAM_Configured& dLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationdl_64QAM_Configured) { *static_cast<DLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationdl_64QAM_Configured*>(items[1]) = dLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationdl_64QAM_Configured; }
	void setHsDSCHTBSizeTable(const HSDSCHTBSizeTable& hsDSCHTBSizeTable) { *static_cast<HSDSCHTBSizeTable*>(items[2]) = hsDSCHTBSizeTable; }
	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[3]) = primaryCPICHInfo; }
	void setDlScramblingCode(const SecondaryScramblingCode& dlScramblingCode) { *static_cast<SecondaryScramblingCode*>(items[4]) = dlScramblingCode; }
	void setDLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationHSSCCHChannelisationCodeInfo(const DLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationHSSCCHChannelisationCodeInfo& dLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationHSSCCHChannelisationCodeInfo) { *static_cast<DLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationHSSCCHChannelisationCodeInfo*>(items[5]) = dLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationHSSCCHChannelisationCodeInfo; }
	void setMeasurementPowerOffset(const MeasurementPowerOffset& measurementPowerOffset) { *static_cast<MeasurementPowerOffset*>(items[6]) = measurementPowerOffset; }
	void setUarfcnDL(const UARFCN& uarfcnDL) { *static_cast<UARFCN*>(items[7]) = uarfcnDL; }
	void setDLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationdifferentTxModeFromServingHS_DSCHCell(const DLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationdifferentTxModeFromServingHS_DSCHCell& dLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationdifferentTxModeFromServingHS_DSCHCell) { *static_cast<DLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationdifferentTxModeFromServingHS_DSCHCell*>(items[8]) = dLSecondaryCellInfoFDDr9ConfigurationInfoNewConfigurationdifferentTxModeFromServingHS_DSCHCell; }
};

class DLSecondaryCellInfoFDDr9ConfigurationInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DLSecondaryCellInfoFDDr9ConfigurationInfoChoices {
		dLSecondaryCellInfoFDDr9ConfigurationInfoContinue = 0,
		dLSecondaryCellInfoFDDr9ConfigurationInfoNewConfiguration = 1,
	};
	static const Info theInfo;
	DLSecondaryCellInfoFDDr9ConfigurationInfo(): Choice(&theInfo) {}
};

typedef Null SecondaryCellMIMOparametersFDDContinue;

enum MIMONMRatioValues {
	mnm1_2_MIMONMRatio = 0,
	mnm2_3_MIMONMRatio = 1,
	mnm3_4_MIMONMRatio = 2,
	mnm4_5_MIMONMRatio = 3,
	mnm5_6_MIMONMRatio = 4,
	mnm6_7_MIMONMRatio = 5,
	mnm7_8_MIMONMRatio = 6,
	mnm8_9_MIMONMRatio = 7,
	mnm9_10_MIMONMRatio = 8,
	mnm1_1_MIMONMRatio = 9,
};
typedef Enumerated<CONSTRAINED, 9> MIMONMRatio;

typedef Null MIMOPilotConfigurationr9SecondCPICHPatternNormalPattern;

typedef Integer<CONSTRAINED, -6, 0> SCPICHPowerOffsetMIMO;

class MIMOPilotConfigurationr9SecondCPICHPatternDiversityPattern : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MIMOPilotConfigurationr9SecondCPICHPatternDiversityPattern(): Sequence(&theInfo) {}

	void setChannelisationCode(const ChannelisationCode256& channelisationCode) { *static_cast<ChannelisationCode256*>(items[0]) = channelisationCode; }
	void setScpichPowerOffsetMimo(const SCPICHPowerOffsetMIMO& scpichPowerOffsetMimo) { *static_cast<SCPICHPowerOffsetMIMO*>(items[1]) = scpichPowerOffsetMimo; }
};

class MIMOPilotConfigurationr9SecondCPICHPattern : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MIMOPilotConfigurationr9SecondCPICHPatternChoices {
		mIMOPilotConfigurationr9SecondCPICHPatternNormalPattern = 0,
		mIMOPilotConfigurationr9SecondCPICHPatternDiversityPattern = 1,
	};
	static const Info theInfo;
	MIMOPilotConfigurationr9SecondCPICHPattern(): Choice(&theInfo) {}
};

class MIMOPilotConfigurationr9 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MIMOPilotConfigurationr9(): Sequence(&theInfo) {}

	void setMIMOPilotConfigurationr9SecondCPICHPattern(const MIMOPilotConfigurationr9SecondCPICHPattern& mIMOPilotConfigurationr9SecondCPICHPattern) { *static_cast<MIMOPilotConfigurationr9SecondCPICHPattern*>(items[0]) = mIMOPilotConfigurationr9SecondCPICHPattern; }
};

class SecondaryCellMIMOparametersFDDNewConfiguration : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SecondaryCellMIMOparametersFDDNewConfiguration(): Sequence(&theInfo) {}

	void setMimoNMRatio(const MIMONMRatio& mimoNMRatio) { *static_cast<MIMONMRatio*>(items[0]) = mimoNMRatio; }
	void setMimoPilotConfiguration(const MIMOPilotConfigurationr9& mimoPilotConfiguration) { *static_cast<MIMOPilotConfigurationr9*>(items[1]) = mimoPilotConfiguration; }
};

class SecondaryCellMIMOparametersFDD : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum SecondaryCellMIMOparametersFDDChoices {
		secondaryCellMIMOparametersFDDContinue = 0,
		secondaryCellMIMOparametersFDDNewConfiguration = 1,
	};
	static const Info theInfo;
	SecondaryCellMIMOparametersFDD(): Choice(&theInfo) {}
};

class DLSecondaryCellInfoFDDr9 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLSecondaryCellInfoFDDr9(): Sequence(&theInfo) {}

	void setDLSecondaryCellInfoFDDr9ConfigurationInfo(const DLSecondaryCellInfoFDDr9ConfigurationInfo& dLSecondaryCellInfoFDDr9ConfigurationInfo) { *static_cast<DLSecondaryCellInfoFDDr9ConfigurationInfo*>(items[0]) = dLSecondaryCellInfoFDDr9ConfigurationInfo; }
	void setSecondaryCellMIMOparameters(const SecondaryCellMIMOparametersFDD& secondaryCellMIMOparameters) { *static_cast<SecondaryCellMIMOparametersFDD*>(items[1]) = secondaryCellMIMOparameters; }
};

class DLTPCPowerOffsetPerRL : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DLTPCPowerOffsetPerRL(): Sequence(&theInfo) {}

	void setPowerOffsetTPCpdpdch(const PowerOffsetTPCpdpdch& powerOffsetTPCpdpdch) { *static_cast<PowerOffsetTPCpdpdch*>(items[0]) = powerOffsetTPCpdpdch; }
};

typedef SequenceOf<DLTPCPowerOffsetPerRL, CONSTRAINED, 1, maxRL> DLTPCPowerOffsetPerRLList;

typedef Integer<CONSTRAINED, 1, 15> DLChannelCodesMBSFNIMB384FirstChannelisationCode;

typedef Integer<CONSTRAINED, 1, 15> DLChannelCodesMBSFNIMB384LastChannelisationCode;

class DLChannelCodesMBSFNIMB384 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DLChannelCodesMBSFNIMB384(): Sequence(&theInfo) {}

	void setDLChannelCodesMBSFNIMB384FirstChannelisationCode(const DLChannelCodesMBSFNIMB384FirstChannelisationCode& dLChannelCodesMBSFNIMB384FirstChannelisationCode) { *static_cast<DLChannelCodesMBSFNIMB384FirstChannelisationCode*>(items[0]) = dLChannelCodesMBSFNIMB384FirstChannelisationCode; }
	void setDLChannelCodesMBSFNIMB384LastChannelisationCode(const DLChannelCodesMBSFNIMB384LastChannelisationCode& dLChannelCodesMBSFNIMB384LastChannelisationCode) { *static_cast<DLChannelCodesMBSFNIMB384LastChannelisationCode*>(items[1]) = dLChannelCodesMBSFNIMB384LastChannelisationCode; }
};

enum ULEDCHInformationr8mac_es_e_resetIndicatorValues {
	true_ULEDCHInformationr8mac_es_e_resetIndicator = 0,
};
typedef Enumerated<CONSTRAINED, 0> ULEDCHInformationr8mac_es_e_resetIndicator;

typedef BitString<CONSTRAINED, 8, 8> EDPDCHSchedulingTransmConfigurationMs2SchedTransmGrantHARQAlloc;

typedef Integer<CONSTRAINED, 0, 38> EDPDCHSchedulingTransmConfigurationServingGrantValue;

enum EDPDCHSchedulingTransmConfigurationServingGrantprimary_Secondary_GrantSelectorValues {
	primary_EDPDCHSchedulingTransmConfigurationServingGrantprimary_Secondary_GrantSelector = 0,
	secondary_EDPDCHSchedulingTransmConfigurationServingGrantprimary_Secondary_GrantSelector = 1,
};
typedef Enumerated<CONSTRAINED, 1> EDPDCHSchedulingTransmConfigurationServingGrantprimary_Secondary_GrantSelector;

class EDPDCHSchedulingTransmConfigurationServingGrant : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EDPDCHSchedulingTransmConfigurationServingGrant(): Sequence(&theInfo) {}

	void setEDPDCHSchedulingTransmConfigurationServingGrantValue(const EDPDCHSchedulingTransmConfigurationServingGrantValue& eDPDCHSchedulingTransmConfigurationServingGrantValue) { *static_cast<EDPDCHSchedulingTransmConfigurationServingGrantValue*>(items[0]) = eDPDCHSchedulingTransmConfigurationServingGrantValue; }
	void setEDPDCHSchedulingTransmConfigurationServingGrantprimary_Secondary_GrantSelector(const EDPDCHSchedulingTransmConfigurationServingGrantprimary_Secondary_GrantSelector& eDPDCHSchedulingTransmConfigurationServingGrantprimary_Secondary_GrantSelector) { *static_cast<EDPDCHSchedulingTransmConfigurationServingGrantprimary_Secondary_GrantSelector*>(items[1]) = eDPDCHSchedulingTransmConfigurationServingGrantprimary_Secondary_GrantSelector; }
};

class EDPDCHSchedulingTransmConfiguration : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EDPDCHSchedulingTransmConfiguration(): Sequence(&theInfo) {}

	void setEDPDCHSchedulingTransmConfigurationMs2SchedTransmGrantHARQAlloc(const EDPDCHSchedulingTransmConfigurationMs2SchedTransmGrantHARQAlloc& eDPDCHSchedulingTransmConfigurationMs2SchedTransmGrantHARQAlloc) { *static_cast<EDPDCHSchedulingTransmConfigurationMs2SchedTransmGrantHARQAlloc*>(items[0]) = eDPDCHSchedulingTransmConfigurationMs2SchedTransmGrantHARQAlloc; }
	void setEDPDCHSchedulingTransmConfigurationServingGrant(const EDPDCHSchedulingTransmConfigurationServingGrant& eDPDCHSchedulingTransmConfigurationServingGrant) { *static_cast<EDPDCHSchedulingTransmConfigurationServingGrant*>(items[1]) = eDPDCHSchedulingTransmConfigurationServingGrant; }
};

typedef Integer<CONSTRAINED, 0, 1> UL16QAMSettingsBetaEdGainEAGCHTableSelection;

class UL16QAMSettings : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UL16QAMSettings(): Sequence(&theInfo) {}

	void setUL16QAMSettingsBetaEdGainEAGCHTableSelection(const UL16QAMSettingsBetaEdGainEAGCHTableSelection& uL16QAMSettingsBetaEdGainEAGCHTableSelection) { *static_cast<UL16QAMSettingsBetaEdGainEAGCHTableSelection*>(items[0]) = uL16QAMSettingsBetaEdGainEAGCHTableSelection; }
};

class ULEDCHInformationr8ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	ULEDCHInformationr8ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setEDPCCHInfo(const EDPCCHInfor7& eDPCCHInfo) { *static_cast<EDPCCHInfor7*>(items[0]) = eDPCCHInfo; }
	void setEDPDCHInfo(const EDPDCHInfor8& eDPDCHInfo) { *static_cast<EDPDCHInfor8*>(items[1]) = eDPDCHInfo; }
	void setSchedulingTransmConfiguration(const EDPDCHSchedulingTransmConfiguration& schedulingTransmConfiguration) { *static_cast<EDPDCHSchedulingTransmConfiguration*>(items[2]) = schedulingTransmConfiguration; }
	void setUl16QAMSettings(const UL16QAMSettings& ul16QAMSettings) { *static_cast<UL16QAMSettings*>(items[3]) = ul16QAMSettings; }
};

typedef Integer<CONSTRAINED, -35, 10> ERUCCHInfoModeSpecificInfoTdd384tdd768ERUCCHConstantValue;

enum ERUCCHInfoModeSpecificInfoTdd384tdd768t_RUCCHValues {
	ms40_ERUCCHInfoModeSpecificInfoTdd384tdd768t_RUCCH = 0,
	ms80_ERUCCHInfoModeSpecificInfoTdd384tdd768t_RUCCH = 1,
	ms120_ERUCCHInfoModeSpecificInfoTdd384tdd768t_RUCCH = 2,
	ms160_ERUCCHInfoModeSpecificInfoTdd384tdd768t_RUCCH = 3,
	ms200_ERUCCHInfoModeSpecificInfoTdd384tdd768t_RUCCH = 4,
	ms240_ERUCCHInfoModeSpecificInfoTdd384tdd768t_RUCCH = 5,
	ms280_ERUCCHInfoModeSpecificInfoTdd384tdd768t_RUCCH = 6,
	ms320_ERUCCHInfoModeSpecificInfoTdd384tdd768t_RUCCH = 7,
};
typedef Enumerated<CONSTRAINED, 7> ERUCCHInfoModeSpecificInfoTdd384tdd768t_RUCCH;

typedef Integer<CONSTRAINED, 0, 14> ERUCCHInfoModeSpecificInfoTdd384tdd768ERUCCHTSNumber;

enum ERUCCHInfoModeSpecificInfoTdd384tdd768e_RUCCH_MidambleValues {
	direct_ERUCCHInfoModeSpecificInfoTdd384tdd768e_RUCCH_Midamble = 0,
	direct_Inverted_ERUCCHInfoModeSpecificInfoTdd384tdd768e_RUCCH_Midamble = 1,
};
typedef Enumerated<CONSTRAINED, 1> ERUCCHInfoModeSpecificInfoTdd384tdd768e_RUCCH_Midamble;

enum ERUCCHInfoModeSpecificInfoTdd384tdd768t_advValues {
	sec1_ERUCCHInfoModeSpecificInfoTdd384tdd768t_adv = 0,
	sec2_ERUCCHInfoModeSpecificInfoTdd384tdd768t_adv = 1,
	sec4_ERUCCHInfoModeSpecificInfoTdd384tdd768t_adv = 2,
	sec8_ERUCCHInfoModeSpecificInfoTdd384tdd768t_adv = 3,
	sec16_ERUCCHInfoModeSpecificInfoTdd384tdd768t_adv = 4,
	sec32_ERUCCHInfoModeSpecificInfoTdd384tdd768t_adv = 5,
	sec128_ERUCCHInfoModeSpecificInfoTdd384tdd768t_adv = 6,
	infinity_ERUCCHInfoModeSpecificInfoTdd384tdd768t_adv = 7,
};
typedef Enumerated<CONSTRAINED, 7> ERUCCHInfoModeSpecificInfoTdd384tdd768t_adv;

enum ERUCCHInfoModeSpecificInfoTdd384tdd768t_SCHEDValues {
	zero_ERUCCHInfoModeSpecificInfoTdd384tdd768t_SCHED = 0,
	ms40_ERUCCHInfoModeSpecificInfoTdd384tdd768t_SCHED = 1,
	ms80_ERUCCHInfoModeSpecificInfoTdd384tdd768t_SCHED = 2,
	ms160_ERUCCHInfoModeSpecificInfoTdd384tdd768t_SCHED = 3,
	ms250_ERUCCHInfoModeSpecificInfoTdd384tdd768t_SCHED = 4,
	sec1_ERUCCHInfoModeSpecificInfoTdd384tdd768t_SCHED = 5,
	sec2_ERUCCHInfoModeSpecificInfoTdd384tdd768t_SCHED = 6,
	sec4_ERUCCHInfoModeSpecificInfoTdd384tdd768t_SCHED = 7,
};
typedef Enumerated<CONSTRAINED, 7> ERUCCHInfoModeSpecificInfoTdd384tdd768t_SCHED;

enum SF16CodesValues {
	cc16_1_SF16Codes = 0,
	cc16_2_SF16Codes = 1,
	cc16_3_SF16Codes = 2,
	cc16_4_SF16Codes = 3,
	cc16_5_SF16Codes = 4,
	cc16_6_SF16Codes = 5,
	cc16_7_SF16Codes = 6,
	cc16_8_SF16Codes = 7,
};
typedef Enumerated<CONSTRAINED, 7> SF16Codes;

typedef SequenceOf<SF16Codes, CONSTRAINED, 1, 8> ERUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfoTdd384SF16;

enum SF8CodesValues {
	cc8_1_SF8Codes = 0,
	cc8_2_SF8Codes = 1,
	cc8_3_SF8Codes = 2,
	cc8_4_SF8Codes = 3,
	cc8_5_SF8Codes = 4,
	cc8_6_SF8Codes = 5,
	cc8_7_SF8Codes = 6,
	cc8_8_SF8Codes = 7,
};
typedef Enumerated<CONSTRAINED, 7> SF8Codes;

typedef SequenceOf<SF8Codes, CONSTRAINED, 1, 8> ERUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfoTdd384SF8;

class ERUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfoTdd384 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ERUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfoTdd384Choices {
		eRUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfoTdd384SF16 = 0,
		eRUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfoTdd384SF8 = 1,
	};
	static const Info theInfo;
	ERUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfoTdd384(): Choice(&theInfo) {}
};

enum SF32CodesValues {
	cc32_1_SF32Codes = 0,
	cc32_2_SF32Codes = 1,
	cc32_3_SF32Codes = 2,
	cc32_4_SF32Codes = 3,
	cc32_5_SF32Codes = 4,
	cc32_6_SF32Codes = 5,
	cc32_7_SF32Codes = 6,
	cc32_8_SF32Codes = 7,
	cc32_9_SF32Codes = 8,
	cc32_10_SF32Codes = 9,
	cc32_11_SF32Codes = 10,
	cc32_12_SF32Codes = 11,
	cc32_13_SF32Codes = 12,
	cc32_14_SF32Codes = 13,
	cc32_15_SF32Codes = 14,
	cc32_16_SF32Codes = 15,
};
typedef Enumerated<CONSTRAINED, 15> SF32Codes;

typedef SequenceOf<SF32Codes, CONSTRAINED, 1, 16> ERUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfoTdd768SF32;

enum SF16Codes2Values {
	cc16_1_SF16Codes2 = 0,
	cc16_2_SF16Codes2 = 1,
	cc16_3_SF16Codes2 = 2,
	cc16_4_SF16Codes2 = 3,
	cc16_5_SF16Codes2 = 4,
	cc16_6_SF16Codes2 = 5,
	cc16_7_SF16Codes2 = 6,
	cc16_8_SF16Codes2 = 7,
	cc16_9_SF16Codes2 = 8,
	cc16_10_SF16Codes2 = 9,
	cc16_11_SF16Codes2 = 10,
	cc16_12_SF16Codes2 = 11,
	cc16_13_SF16Codes2 = 12,
	cc16_14_SF16Codes2 = 13,
	cc16_15_SF16Codes2 = 14,
	cc16_16_SF16Codes2 = 15,
};
typedef Enumerated<CONSTRAINED, 15> SF16Codes2;

typedef SequenceOf<SF16Codes2, CONSTRAINED, 1, 16> ERUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfoTdd768SF816;

class ERUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfoTdd768 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ERUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfoTdd768Choices {
		eRUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfoTdd768SF32 = 0,
		eRUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfoTdd768SF816 = 1,
	};
	static const Info theInfo;
	ERUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfoTdd768(): Choice(&theInfo) {}
};

class ERUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ERUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfoChoices {
		eRUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfoTdd384 = 0,
		eRUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfoTdd768 = 1,
	};
	static const Info theInfo;
	ERUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfo(): Choice(&theInfo) {}
};

class ERUCCHInfoModeSpecificInfoTdd384tdd768 : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	ERUCCHInfoModeSpecificInfoTdd384tdd768(): Sequence(&theInfo) {}

	void setERUCCHInfoModeSpecificInfoTdd384tdd768ERUCCHConstantValue(const ERUCCHInfoModeSpecificInfoTdd384tdd768ERUCCHConstantValue& eRUCCHInfoModeSpecificInfoTdd384tdd768ERUCCHConstantValue) { *static_cast<ERUCCHInfoModeSpecificInfoTdd384tdd768ERUCCHConstantValue*>(items[0]) = eRUCCHInfoModeSpecificInfoTdd384tdd768ERUCCHConstantValue; }
	void setERUCCHPersistenceScalingFactor(const PersistenceScalingFactor& eRUCCHPersistenceScalingFactor) { *static_cast<PersistenceScalingFactor*>(items[1]) = eRUCCHPersistenceScalingFactor; }
	void setERUCCHInfoModeSpecificInfoTdd384tdd768t_RUCCH(const ERUCCHInfoModeSpecificInfoTdd384tdd768t_RUCCH& eRUCCHInfoModeSpecificInfoTdd384tdd768t_RUCCH) { *static_cast<ERUCCHInfoModeSpecificInfoTdd384tdd768t_RUCCH*>(items[2]) = eRUCCHInfoModeSpecificInfoTdd384tdd768t_RUCCH; }
	void setERUCCHInfoModeSpecificInfoTdd384tdd768ERUCCHTSNumber(const ERUCCHInfoModeSpecificInfoTdd384tdd768ERUCCHTSNumber& eRUCCHInfoModeSpecificInfoTdd384tdd768ERUCCHTSNumber) { *static_cast<ERUCCHInfoModeSpecificInfoTdd384tdd768ERUCCHTSNumber*>(items[3]) = eRUCCHInfoModeSpecificInfoTdd384tdd768ERUCCHTSNumber; }
	void setERUCCHInfoModeSpecificInfoTdd384tdd768e_RUCCH_Midamble(const ERUCCHInfoModeSpecificInfoTdd384tdd768e_RUCCH_Midamble& eRUCCHInfoModeSpecificInfoTdd384tdd768e_RUCCH_Midamble) { *static_cast<ERUCCHInfoModeSpecificInfoTdd384tdd768e_RUCCH_Midamble*>(items[4]) = eRUCCHInfoModeSpecificInfoTdd384tdd768e_RUCCH_Midamble; }
	void setERUCCHInfoModeSpecificInfoTdd384tdd768t_adv(const ERUCCHInfoModeSpecificInfoTdd384tdd768t_adv& eRUCCHInfoModeSpecificInfoTdd384tdd768t_adv) { *static_cast<ERUCCHInfoModeSpecificInfoTdd384tdd768t_adv*>(items[5]) = eRUCCHInfoModeSpecificInfoTdd384tdd768t_adv; }
	void setERUCCHInfoModeSpecificInfoTdd384tdd768t_SCHED(const ERUCCHInfoModeSpecificInfoTdd384tdd768t_SCHED& eRUCCHInfoModeSpecificInfoTdd384tdd768t_SCHED) { *static_cast<ERUCCHInfoModeSpecificInfoTdd384tdd768t_SCHED*>(items[6]) = eRUCCHInfoModeSpecificInfoTdd384tdd768t_SCHED; }
	void setERUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfo(const ERUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfo& eRUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfo) { *static_cast<ERUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfo*>(items[7]) = eRUCCHInfoModeSpecificInfoTdd384tdd768ModeSpecificInfo; }
};

enum ERUCCHInfoModeSpecificInfoTdd128t_RUCCHValues {
	ms20_ERUCCHInfoModeSpecificInfoTdd128t_RUCCH = 0,
	ms40_ERUCCHInfoModeSpecificInfoTdd128t_RUCCH = 1,
	ms60_ERUCCHInfoModeSpecificInfoTdd128t_RUCCH = 2,
	ms80_ERUCCHInfoModeSpecificInfoTdd128t_RUCCH = 3,
	ms120_ERUCCHInfoModeSpecificInfoTdd128t_RUCCH = 4,
	ms160_ERUCCHInfoModeSpecificInfoTdd128t_RUCCH = 5,
	ms200_ERUCCHInfoModeSpecificInfoTdd128t_RUCCH = 6,
	ms240_ERUCCHInfoModeSpecificInfoTdd128t_RUCCH = 7,
	ms280_ERUCCHInfoModeSpecificInfoTdd128t_RUCCH = 8,
	ms320_ERUCCHInfoModeSpecificInfoTdd128t_RUCCH = 9,
	ms400_ERUCCHInfoModeSpecificInfoTdd128t_RUCCH = 10,
	ms500_ERUCCHInfoModeSpecificInfoTdd128t_RUCCH = 11,
	ms600_ERUCCHInfoModeSpecificInfoTdd128t_RUCCH = 12,
	ms800_ERUCCHInfoModeSpecificInfoTdd128t_RUCCH = 13,
	ms1000_ERUCCHInfoModeSpecificInfoTdd128t_RUCCH = 14,
	ms2000_ERUCCHInfoModeSpecificInfoTdd128t_RUCCH = 15,
};
typedef Enumerated<CONSTRAINED, 15> ERUCCHInfoModeSpecificInfoTdd128t_RUCCH;

typedef Integer<CONSTRAINED, 0, 7> ERUCCHInfoModeSpecificInfoTdd128NRUCCH;

enum ERUCCHInfoModeSpecificInfoTdd128t_WAITValues {
	everyEDCHTTI_ERUCCHInfoModeSpecificInfoTdd128t_WAIT = 0,
	ms40_ERUCCHInfoModeSpecificInfoTdd128t_WAIT = 1,
	ms80_ERUCCHInfoModeSpecificInfoTdd128t_WAIT = 2,
	ms160_ERUCCHInfoModeSpecificInfoTdd128t_WAIT = 3,
	ms320_ERUCCHInfoModeSpecificInfoTdd128t_WAIT = 4,
	ms640_ERUCCHInfoModeSpecificInfoTdd128t_WAIT = 5,
	ms1000_ERUCCHInfoModeSpecificInfoTdd128t_WAIT = 6,
	ms2000_ERUCCHInfoModeSpecificInfoTdd128t_WAIT = 7,
};
typedef Enumerated<CONSTRAINED, 7> ERUCCHInfoModeSpecificInfoTdd128t_WAIT;

enum ERUCCHInfoModeSpecificInfoTdd128t_SIValues {
	everyEDCHTTI_ERUCCHInfoModeSpecificInfoTdd128t_SI = 0,
	ms20_ERUCCHInfoModeSpecificInfoTdd128t_SI = 1,
	ms40_ERUCCHInfoModeSpecificInfoTdd128t_SI = 2,
	ms60_ERUCCHInfoModeSpecificInfoTdd128t_SI = 3,
	ms80_ERUCCHInfoModeSpecificInfoTdd128t_SI = 4,
	ms160_ERUCCHInfoModeSpecificInfoTdd128t_SI = 5,
	ms200_ERUCCHInfoModeSpecificInfoTdd128t_SI = 6,
};
typedef Enumerated<CONSTRAINED, 6> ERUCCHInfoModeSpecificInfoTdd128t_SI;

typedef Integer<CONSTRAINED, 2, 5> ERUCCHInfoModeSpecificInfoTdd128ExtendedEstimationWindow;

class ERUCCHInfoModeSpecificInfoTdd128 : public Sequence {
private:
	static const void *itemsInfo[9];
	static bool itemsPres[9];
public:
	static const Info theInfo;
	ERUCCHInfoModeSpecificInfoTdd128(): Sequence(&theInfo) {}

	void setERUCCHInfoModeSpecificInfoTdd128t_RUCCH(const ERUCCHInfoModeSpecificInfoTdd128t_RUCCH& eRUCCHInfoModeSpecificInfoTdd128t_RUCCH) { *static_cast<ERUCCHInfoModeSpecificInfoTdd128t_RUCCH*>(items[0]) = eRUCCHInfoModeSpecificInfoTdd128t_RUCCH; }
	void setERUCCHInfoModeSpecificInfoTdd128NRUCCH(const ERUCCHInfoModeSpecificInfoTdd128NRUCCH& eRUCCHInfoModeSpecificInfoTdd128NRUCCH) { *static_cast<ERUCCHInfoModeSpecificInfoTdd128NRUCCH*>(items[1]) = eRUCCHInfoModeSpecificInfoTdd128NRUCCH; }
	void setERUCCHInfoModeSpecificInfoTdd128t_WAIT(const ERUCCHInfoModeSpecificInfoTdd128t_WAIT& eRUCCHInfoModeSpecificInfoTdd128t_WAIT) { *static_cast<ERUCCHInfoModeSpecificInfoTdd128t_WAIT*>(items[2]) = eRUCCHInfoModeSpecificInfoTdd128t_WAIT; }
	void setERUCCHInfoModeSpecificInfoTdd128t_SI(const ERUCCHInfoModeSpecificInfoTdd128t_SI& eRUCCHInfoModeSpecificInfoTdd128t_SI) { *static_cast<ERUCCHInfoModeSpecificInfoTdd128t_SI*>(items[3]) = eRUCCHInfoModeSpecificInfoTdd128t_SI; }
	void setERUCCHInfoModeSpecificInfoTdd128ExtendedEstimationWindow(const ERUCCHInfoModeSpecificInfoTdd128ExtendedEstimationWindow& eRUCCHInfoModeSpecificInfoTdd128ExtendedEstimationWindow) { *static_cast<ERUCCHInfoModeSpecificInfoTdd128ExtendedEstimationWindow*>(items[4]) = eRUCCHInfoModeSpecificInfoTdd128ExtendedEstimationWindow; }
	void setERUCCHAccessServiceClass(const ERUCCHAccessServiceClass& eRUCCHAccessServiceClass) { *static_cast<ERUCCHAccessServiceClass*>(items[5]) = eRUCCHAccessServiceClass; }
	void setERUCCHPersistenceScalingFactor(const PersistenceScalingFactorList& eRUCCHPersistenceScalingFactor) { *static_cast<PersistenceScalingFactorList*>(items[6]) = eRUCCHPersistenceScalingFactor; }
	void setSyncULInfoForERUCCH(const SYNCULInfoForERUCCH& syncULInfoForERUCCH) { *static_cast<SYNCULInfoForERUCCH*>(items[7]) = syncULInfoForERUCCH; }
	void setPrachinformation(const PRACHInformationLCRList& prachinformation) { *static_cast<PRACHInformationLCRList*>(items[8]) = prachinformation; }
};

class ERUCCHInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ERUCCHInfoModeSpecificInfoChoices {
		eRUCCHInfoModeSpecificInfoTdd384tdd768 = 0,
		eRUCCHInfoModeSpecificInfoTdd128 = 1,
	};
	static const Info theInfo;
	ERUCCHInfoModeSpecificInfo(): Choice(&theInfo) {}
};

class ERUCCHInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ERUCCHInfo(): Sequence(&theInfo) {}

	void setERUCCHInfoModeSpecificInfo(const ERUCCHInfoModeSpecificInfo& eRUCCHInfoModeSpecificInfo) { *static_cast<ERUCCHInfoModeSpecificInfo*>(items[0]) = eRUCCHInfoModeSpecificInfo; }
};

typedef Integer<CONSTRAINED, 1, 12> EPUCHInfoModeSpecificInfoTdd348tdd768NoSlotsForTFCIandTPC;

typedef Integer<CONSTRAINED, -35, 10> EPUCHInfoModeSpecificInfoTdd348tdd768EPUCHContantValue;

typedef Integer<CONSTRAINED, 0, 14> EPUCHTSSlotsTsNumber;

class EPUCHTSSlots : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EPUCHTSSlots(): Sequence(&theInfo) {}

	void setEPUCHTSSlotsTsNumber(const EPUCHTSSlotsTsNumber& ePUCHTSSlotsTsNumber) { *static_cast<EPUCHTSSlotsTsNumber*>(items[0]) = ePUCHTSSlotsTsNumber; }
	void setMidambleShiftAndBurstType(const MidambleShiftAndBurstTypeEDCH& midambleShiftAndBurstType) { *static_cast<MidambleShiftAndBurstTypeEDCH*>(items[1]) = midambleShiftAndBurstType; }
};

typedef SequenceOf<EPUCHTSSlots, CONSTRAINED, 1, maxTS_2> EPUCHInfoModeSpecificInfoTdd348tdd768EPUCHTSConfigurationList;

typedef Boolean EPUCHInfoModeSpecificInfoTdd348tdd768EPUCHCodeHopping;

typedef Integer<CONSTRAINED, 1, 3> EPUCHInfoModeSpecificInfoTdd348tdd768EPUCHTPCStepSize;

typedef Integer<CONSTRAINED, 0, 63> EPUCHInfoModeSpecificInfoTdd348tdd768MinimumAllowedCodeRate;

typedef Integer<CONSTRAINED, 0, 63> EPUCHInfoModeSpecificInfoTdd348tdd768MaximumAllowedCodeRate;

class EPUCHInfoModeSpecificInfoTdd348tdd768 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	EPUCHInfoModeSpecificInfoTdd348tdd768(): Sequence(&theInfo) {}

	void setEPUCHInfoModeSpecificInfoTdd348tdd768NoSlotsForTFCIandTPC(const EPUCHInfoModeSpecificInfoTdd348tdd768NoSlotsForTFCIandTPC& ePUCHInfoModeSpecificInfoTdd348tdd768NoSlotsForTFCIandTPC) { *static_cast<EPUCHInfoModeSpecificInfoTdd348tdd768NoSlotsForTFCIandTPC*>(items[0]) = ePUCHInfoModeSpecificInfoTdd348tdd768NoSlotsForTFCIandTPC; }
	void setEPUCHInfoModeSpecificInfoTdd348tdd768EPUCHContantValue(const EPUCHInfoModeSpecificInfoTdd348tdd768EPUCHContantValue& ePUCHInfoModeSpecificInfoTdd348tdd768EPUCHContantValue) { *static_cast<EPUCHInfoModeSpecificInfoTdd348tdd768EPUCHContantValue*>(items[1]) = ePUCHInfoModeSpecificInfoTdd348tdd768EPUCHContantValue; }
	void setEPUCHInfoModeSpecificInfoTdd348tdd768EPUCHTSConfigurationList(const EPUCHInfoModeSpecificInfoTdd348tdd768EPUCHTSConfigurationList& ePUCHInfoModeSpecificInfoTdd348tdd768EPUCHTSConfigurationList) { *static_cast<EPUCHInfoModeSpecificInfoTdd348tdd768EPUCHTSConfigurationList*>(items[2]) = ePUCHInfoModeSpecificInfoTdd348tdd768EPUCHTSConfigurationList; }
	void setEPUCHInfoModeSpecificInfoTdd348tdd768EPUCHCodeHopping(const EPUCHInfoModeSpecificInfoTdd348tdd768EPUCHCodeHopping& ePUCHInfoModeSpecificInfoTdd348tdd768EPUCHCodeHopping) { *static_cast<EPUCHInfoModeSpecificInfoTdd348tdd768EPUCHCodeHopping*>(items[3]) = ePUCHInfoModeSpecificInfoTdd348tdd768EPUCHCodeHopping; }
	void setEPUCHInfoModeSpecificInfoTdd348tdd768EPUCHTPCStepSize(const EPUCHInfoModeSpecificInfoTdd348tdd768EPUCHTPCStepSize& ePUCHInfoModeSpecificInfoTdd348tdd768EPUCHTPCStepSize) { *static_cast<EPUCHInfoModeSpecificInfoTdd348tdd768EPUCHTPCStepSize*>(items[4]) = ePUCHInfoModeSpecificInfoTdd348tdd768EPUCHTPCStepSize; }
	void setEPUCHInfoModeSpecificInfoTdd348tdd768MinimumAllowedCodeRate(const EPUCHInfoModeSpecificInfoTdd348tdd768MinimumAllowedCodeRate& ePUCHInfoModeSpecificInfoTdd348tdd768MinimumAllowedCodeRate) { *static_cast<EPUCHInfoModeSpecificInfoTdd348tdd768MinimumAllowedCodeRate*>(items[5]) = ePUCHInfoModeSpecificInfoTdd348tdd768MinimumAllowedCodeRate; }
	void setEPUCHInfoModeSpecificInfoTdd348tdd768MaximumAllowedCodeRate(const EPUCHInfoModeSpecificInfoTdd348tdd768MaximumAllowedCodeRate& ePUCHInfoModeSpecificInfoTdd348tdd768MaximumAllowedCodeRate) { *static_cast<EPUCHInfoModeSpecificInfoTdd348tdd768MaximumAllowedCodeRate*>(items[6]) = ePUCHInfoModeSpecificInfoTdd348tdd768MaximumAllowedCodeRate; }
};

enum EPUCHInfoModeSpecificInfoTdd128snpl_ReportTypeValues {
	type1_EPUCHInfoModeSpecificInfoTdd128snpl_ReportType = 0,
	type2_EPUCHInfoModeSpecificInfoTdd128snpl_ReportType = 1,
};
typedef Enumerated<CONSTRAINED, 1> EPUCHInfoModeSpecificInfoTdd128snpl_ReportType;

typedef Integer<CONSTRAINED, -112, -50> EPUCHInfoModeSpecificInfoTdd128PrxBASEdes;

typedef Boolean EPUCHInfoModeSpecificInfoTdd128BeaconPLEst;

typedef SequenceOf<EPUCHTSSlotsLCR, CONSTRAINED, 1, maxTS_LCR_1> EPUCHInfoModeSpecificInfoTdd128EPUCHTSConfigurationList;

typedef Integer<CONSTRAINED, 0, 63> EPUCHInfoModeSpecificInfoTdd128MinimumAllowedCodeRate;

typedef Integer<CONSTRAINED, 0, 63> EPUCHInfoModeSpecificInfoTdd128MaximumAllowedCodeRate;

typedef Integer<CONSTRAINED, 0, 15> EPUCHInfoModeSpecificInfoTdd128MaximumNumOfRetransSchedInfo;

enum EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfoValues {
	ms10_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 0,
	ms15_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 1,
	ms20_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 2,
	ms25_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 3,
	ms30_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 4,
	ms35_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 5,
	ms40_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 6,
	ms45_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 7,
	ms50_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 8,
	ms55_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 9,
	ms60_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 10,
	ms65_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 11,
	ms70_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 12,
	ms75_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 13,
	ms80_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 14,
	ms85_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 15,
	ms90_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 16,
	ms95_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 17,
	ms100_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 18,
	ms110_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 19,
	ms120_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 20,
	ms140_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 21,
	ms160_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 22,
	ms200_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 23,
	ms240_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 24,
	ms280_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 25,
	ms320_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 26,
	ms400_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 27,
	ms480_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 28,
	ms560_EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo = 29,
};
typedef Enumerated<CONSTRAINED, 29> EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo;

class EPUCHInfoModeSpecificInfoTdd128 : public Sequence {
private:
	static const void *itemsInfo[11];
	static bool itemsPres[11];
public:
	static const Info theInfo;
	EPUCHInfoModeSpecificInfoTdd128(): Sequence(&theInfo) {}

	void setEPUCHInfoModeSpecificInfoTdd128snpl_ReportType(const EPUCHInfoModeSpecificInfoTdd128snpl_ReportType& ePUCHInfoModeSpecificInfoTdd128snpl_ReportType) { *static_cast<EPUCHInfoModeSpecificInfoTdd128snpl_ReportType*>(items[0]) = ePUCHInfoModeSpecificInfoTdd128snpl_ReportType; }
	void setEPUCHInfoModeSpecificInfoTdd128PrxBASEdes(const EPUCHInfoModeSpecificInfoTdd128PrxBASEdes& ePUCHInfoModeSpecificInfoTdd128PrxBASEdes) { *static_cast<EPUCHInfoModeSpecificInfoTdd128PrxBASEdes*>(items[1]) = ePUCHInfoModeSpecificInfoTdd128PrxBASEdes; }
	void setEPUCHInfoModeSpecificInfoTdd128BeaconPLEst(const EPUCHInfoModeSpecificInfoTdd128BeaconPLEst& ePUCHInfoModeSpecificInfoTdd128BeaconPLEst) { *static_cast<EPUCHInfoModeSpecificInfoTdd128BeaconPLEst*>(items[2]) = ePUCHInfoModeSpecificInfoTdd128BeaconPLEst; }
	void setTpcStepSize(const TPCStepSizeTDD& tpcStepSize) { *static_cast<TPCStepSizeTDD*>(items[3]) = tpcStepSize; }
	void setPebasePowerControlGAP(const PowerControlGAP& pebasePowerControlGAP) { *static_cast<PowerControlGAP*>(items[4]) = pebasePowerControlGAP; }
	void setUlSynchronisationParameters(const ULSynchronisationParametersr4& ulSynchronisationParameters) { *static_cast<ULSynchronisationParametersr4*>(items[5]) = ulSynchronisationParameters; }
	void setEPUCHInfoModeSpecificInfoTdd128EPUCHTSConfigurationList(const EPUCHInfoModeSpecificInfoTdd128EPUCHTSConfigurationList& ePUCHInfoModeSpecificInfoTdd128EPUCHTSConfigurationList) { *static_cast<EPUCHInfoModeSpecificInfoTdd128EPUCHTSConfigurationList*>(items[6]) = ePUCHInfoModeSpecificInfoTdd128EPUCHTSConfigurationList; }
	void setEPUCHInfoModeSpecificInfoTdd128MinimumAllowedCodeRate(const EPUCHInfoModeSpecificInfoTdd128MinimumAllowedCodeRate& ePUCHInfoModeSpecificInfoTdd128MinimumAllowedCodeRate) { *static_cast<EPUCHInfoModeSpecificInfoTdd128MinimumAllowedCodeRate*>(items[7]) = ePUCHInfoModeSpecificInfoTdd128MinimumAllowedCodeRate; }
	void setEPUCHInfoModeSpecificInfoTdd128MaximumAllowedCodeRate(const EPUCHInfoModeSpecificInfoTdd128MaximumAllowedCodeRate& ePUCHInfoModeSpecificInfoTdd128MaximumAllowedCodeRate) { *static_cast<EPUCHInfoModeSpecificInfoTdd128MaximumAllowedCodeRate*>(items[8]) = ePUCHInfoModeSpecificInfoTdd128MaximumAllowedCodeRate; }
	void setEPUCHInfoModeSpecificInfoTdd128MaximumNumOfRetransSchedInfo(const EPUCHInfoModeSpecificInfoTdd128MaximumNumOfRetransSchedInfo& ePUCHInfoModeSpecificInfoTdd128MaximumNumOfRetransSchedInfo) { *static_cast<EPUCHInfoModeSpecificInfoTdd128MaximumNumOfRetransSchedInfo*>(items[9]) = ePUCHInfoModeSpecificInfoTdd128MaximumNumOfRetransSchedInfo; }
	void setEPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo(const EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo& ePUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo) { *static_cast<EPUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo*>(items[10]) = ePUCHInfoModeSpecificInfoTdd128retransTimerForSchedInfo; }
};

class EPUCHInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum EPUCHInfoModeSpecificInfoChoices {
		ePUCHInfoModeSpecificInfoTdd348tdd768 = 0,
		ePUCHInfoModeSpecificInfoTdd128 = 1,
	};
	static const Info theInfo;
	EPUCHInfoModeSpecificInfo(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 6> EPUCHInfoPowerOffsetForSchedInfo;

class EPUCHInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	EPUCHInfo(): Sequence(&theInfo) {}

	void setETFCSInfo(const ETFCSInfo& eTFCSInfo) { *static_cast<ETFCSInfo*>(items[0]) = eTFCSInfo; }
	void setEPUCHInfoModeSpecificInfo(const EPUCHInfoModeSpecificInfo& ePUCHInfoModeSpecificInfo) { *static_cast<EPUCHInfoModeSpecificInfo*>(items[1]) = ePUCHInfoModeSpecificInfo; }
	void setEPUCHInfoPowerOffsetForSchedInfo(const EPUCHInfoPowerOffsetForSchedInfo& ePUCHInfoPowerOffsetForSchedInfo) { *static_cast<EPUCHInfoPowerOffsetForSchedInfo*>(items[2]) = ePUCHInfoPowerOffsetForSchedInfo; }
};

typedef BitString<CONSTRAINED, 13, 13> NonScheduledTransGrantInfoTDDTdd384768TimeslotResourceRelatedInfo;

typedef Integer<CONSTRAINED, 1, 32> NonScheduledTransGrantInfoTDDTdd384768PowerResourceRelatedInfo;

enum ULTSChannelisationCodeValues {
	cc1_1_ULTSChannelisationCode = 0,
	cc2_1_ULTSChannelisationCode = 1,
	cc2_2_ULTSChannelisationCode = 2,
	cc4_1_ULTSChannelisationCode = 3,
	cc4_2_ULTSChannelisationCode = 4,
	cc4_3_ULTSChannelisationCode = 5,
	cc4_4_ULTSChannelisationCode = 6,
	cc8_1_ULTSChannelisationCode = 7,
	cc8_2_ULTSChannelisationCode = 8,
	cc8_3_ULTSChannelisationCode = 9,
	cc8_4_ULTSChannelisationCode = 10,
	cc8_5_ULTSChannelisationCode = 11,
	cc8_6_ULTSChannelisationCode = 12,
	cc8_7_ULTSChannelisationCode = 13,
	cc8_8_ULTSChannelisationCode = 14,
	cc16_1_ULTSChannelisationCode = 15,
	cc16_2_ULTSChannelisationCode = 16,
	cc16_3_ULTSChannelisationCode = 17,
	cc16_4_ULTSChannelisationCode = 18,
	cc16_5_ULTSChannelisationCode = 19,
	cc16_6_ULTSChannelisationCode = 20,
	cc16_7_ULTSChannelisationCode = 21,
	cc16_8_ULTSChannelisationCode = 22,
	cc16_9_ULTSChannelisationCode = 23,
	cc16_10_ULTSChannelisationCode = 24,
	cc16_11_ULTSChannelisationCode = 25,
	cc16_12_ULTSChannelisationCode = 26,
	cc16_13_ULTSChannelisationCode = 27,
	cc16_14_ULTSChannelisationCode = 28,
	cc16_15_ULTSChannelisationCode = 29,
	cc16_16_ULTSChannelisationCode = 30,
};
typedef Enumerated<CONSTRAINED, 30> ULTSChannelisationCode;

class NonScheduledTransGrantInfoTDDTdd384768 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	NonScheduledTransGrantInfoTDDTdd384768(): Sequence(&theInfo) {}

	void setNonScheduledTransGrantInfoTDDTdd384768TimeslotResourceRelatedInfo(const NonScheduledTransGrantInfoTDDTdd384768TimeslotResourceRelatedInfo& nonScheduledTransGrantInfoTDDTdd384768TimeslotResourceRelatedInfo) { *static_cast<NonScheduledTransGrantInfoTDDTdd384768TimeslotResourceRelatedInfo*>(items[0]) = nonScheduledTransGrantInfoTDDTdd384768TimeslotResourceRelatedInfo; }
	void setNonScheduledTransGrantInfoTDDTdd384768PowerResourceRelatedInfo(const NonScheduledTransGrantInfoTDDTdd384768PowerResourceRelatedInfo& nonScheduledTransGrantInfoTDDTdd384768PowerResourceRelatedInfo) { *static_cast<NonScheduledTransGrantInfoTDDTdd384768PowerResourceRelatedInfo*>(items[1]) = nonScheduledTransGrantInfoTDDTdd384768PowerResourceRelatedInfo; }
	void setActivationTime(const ActivationTime& activationTime) { *static_cast<ActivationTime*>(items[2]) = activationTime; }
	void setRepetitionPeriodAndLength(const RepetitionPeriodAndLength& repetitionPeriodAndLength) { *static_cast<RepetitionPeriodAndLength*>(items[3]) = repetitionPeriodAndLength; }
	void setCodeResourceInfo(const ULTSChannelisationCode& codeResourceInfo) { *static_cast<ULTSChannelisationCode*>(items[4]) = codeResourceInfo; }
};

typedef Integer<CONSTRAINED, 1, 8> NonScheduledTransGrantInfoTDDTdd128NEUCCH;

typedef Integer<CONSTRAINED, 4, 15> NonScheduledTransGrantInfoTDDTdd128NEHICH;

typedef BitString<CONSTRAINED, 5, 5> NonScheduledTransGrantInfoTDDTdd128TimeslotResourceRelatedInfo;

typedef Integer<CONSTRAINED, 1, 32> NonScheduledTransGrantInfoTDDTdd128PowerResourceRelatedInfo;

typedef Integer<CONSTRAINED, 0, 1> NonScheduledTransGrantInfoTDDTdd128SfnNum;

typedef Null NonScheduledTransGrantInfoTDDTdd128EHICHInfoMidambleAllocationModeDefaultMidamble;

typedef Integer<CONSTRAINED, 0, 15> NonScheduledTransGrantInfoTDDTdd128EHICHInfoMidambleAllocationModeUeSpecificMidamble;

class NonScheduledTransGrantInfoTDDTdd128EHICHInfoMidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum NonScheduledTransGrantInfoTDDTdd128EHICHInfoMidambleAllocationModeChoices {
		nonScheduledTransGrantInfoTDDTdd128EHICHInfoMidambleAllocationModeDefaultMidamble = 0,
		nonScheduledTransGrantInfoTDDTdd128EHICHInfoMidambleAllocationModeUeSpecificMidamble = 1,
	};
	static const Info theInfo;
	NonScheduledTransGrantInfoTDDTdd128EHICHInfoMidambleAllocationMode(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, 8> NonScheduledTransGrantInfoTDDTdd128EHICHInfoMidambleConfiguration;

typedef Integer<CONSTRAINED, 0, 19> NonScheduledTransGrantInfoTDDTdd128EHICHInfoSignatureSequenceGroupIndex;

class NonScheduledTransGrantInfoTDDTdd128EHICHInfo : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	NonScheduledTransGrantInfoTDDTdd128EHICHInfo(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumberLCRr4& timeslotNumber) { *static_cast<TimeslotNumberLCRr4*>(items[0]) = timeslotNumber; }
	void setChannelisationCode(const HSChannelisationCodeLCR& channelisationCode) { *static_cast<HSChannelisationCodeLCR*>(items[1]) = channelisationCode; }
	void setNonScheduledTransGrantInfoTDDTdd128EHICHInfoMidambleAllocationMode(const NonScheduledTransGrantInfoTDDTdd128EHICHInfoMidambleAllocationMode& nonScheduledTransGrantInfoTDDTdd128EHICHInfoMidambleAllocationMode) { *static_cast<NonScheduledTransGrantInfoTDDTdd128EHICHInfoMidambleAllocationMode*>(items[2]) = nonScheduledTransGrantInfoTDDTdd128EHICHInfoMidambleAllocationMode; }
	void setNonScheduledTransGrantInfoTDDTdd128EHICHInfoMidambleConfiguration(const NonScheduledTransGrantInfoTDDTdd128EHICHInfoMidambleConfiguration& nonScheduledTransGrantInfoTDDTdd128EHICHInfoMidambleConfiguration) { *static_cast<NonScheduledTransGrantInfoTDDTdd128EHICHInfoMidambleConfiguration*>(items[3]) = nonScheduledTransGrantInfoTDDTdd128EHICHInfoMidambleConfiguration; }
	void setNonScheduledTransGrantInfoTDDTdd128EHICHInfoSignatureSequenceGroupIndex(const NonScheduledTransGrantInfoTDDTdd128EHICHInfoSignatureSequenceGroupIndex& nonScheduledTransGrantInfoTDDTdd128EHICHInfoSignatureSequenceGroupIndex) { *static_cast<NonScheduledTransGrantInfoTDDTdd128EHICHInfoSignatureSequenceGroupIndex*>(items[4]) = nonScheduledTransGrantInfoTDDTdd128EHICHInfoSignatureSequenceGroupIndex; }
};

class NonScheduledTransGrantInfoTDDTdd128 : public Sequence {
private:
	static const void *itemsInfo[9];
	static bool itemsPres[9];
public:
	static const Info theInfo;
	NonScheduledTransGrantInfoTDDTdd128(): Sequence(&theInfo) {}

	void setNonScheduledTransGrantInfoTDDTdd128NEUCCH(const NonScheduledTransGrantInfoTDDTdd128NEUCCH& nonScheduledTransGrantInfoTDDTdd128NEUCCH) { *static_cast<NonScheduledTransGrantInfoTDDTdd128NEUCCH*>(items[0]) = nonScheduledTransGrantInfoTDDTdd128NEUCCH; }
	void setNonScheduledTransGrantInfoTDDTdd128NEHICH(const NonScheduledTransGrantInfoTDDTdd128NEHICH& nonScheduledTransGrantInfoTDDTdd128NEHICH) { *static_cast<NonScheduledTransGrantInfoTDDTdd128NEHICH*>(items[1]) = nonScheduledTransGrantInfoTDDTdd128NEHICH; }
	void setNonScheduledTransGrantInfoTDDTdd128TimeslotResourceRelatedInfo(const NonScheduledTransGrantInfoTDDTdd128TimeslotResourceRelatedInfo& nonScheduledTransGrantInfoTDDTdd128TimeslotResourceRelatedInfo) { *static_cast<NonScheduledTransGrantInfoTDDTdd128TimeslotResourceRelatedInfo*>(items[2]) = nonScheduledTransGrantInfoTDDTdd128TimeslotResourceRelatedInfo; }
	void setNonScheduledTransGrantInfoTDDTdd128PowerResourceRelatedInfo(const NonScheduledTransGrantInfoTDDTdd128PowerResourceRelatedInfo& nonScheduledTransGrantInfoTDDTdd128PowerResourceRelatedInfo) { *static_cast<NonScheduledTransGrantInfoTDDTdd128PowerResourceRelatedInfo*>(items[3]) = nonScheduledTransGrantInfoTDDTdd128PowerResourceRelatedInfo; }
	void setActivationTime(const ActivationTime& activationTime) { *static_cast<ActivationTime*>(items[4]) = activationTime; }
	void setNonScheduledTransGrantInfoTDDTdd128SfnNum(const NonScheduledTransGrantInfoTDDTdd128SfnNum& nonScheduledTransGrantInfoTDDTdd128SfnNum) { *static_cast<NonScheduledTransGrantInfoTDDTdd128SfnNum*>(items[5]) = nonScheduledTransGrantInfoTDDTdd128SfnNum; }
	void setRepetitionPeriodAndLength(const RepetitionPeriodAndLength& repetitionPeriodAndLength) { *static_cast<RepetitionPeriodAndLength*>(items[6]) = repetitionPeriodAndLength; }
	void setCodeResourceInfo(const ULTSChannelisationCode& codeResourceInfo) { *static_cast<ULTSChannelisationCode*>(items[7]) = codeResourceInfo; }
	void setNonScheduledTransGrantInfoTDDTdd128EHICHInfo(const NonScheduledTransGrantInfoTDDTdd128EHICHInfo& nonScheduledTransGrantInfoTDDTdd128EHICHInfo) { *static_cast<NonScheduledTransGrantInfoTDDTdd128EHICHInfo*>(items[8]) = nonScheduledTransGrantInfoTDDTdd128EHICHInfo; }
};

class NonScheduledTransGrantInfoTDD : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum NonScheduledTransGrantInfoTDDChoices {
		nonScheduledTransGrantInfoTDDTdd384768 = 0,
		nonScheduledTransGrantInfoTDDTdd128 = 1,
	};
	static const Info theInfo;
	NonScheduledTransGrantInfoTDD(): Choice(&theInfo) {}
};

class ULEDCHInformationr8ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULEDCHInformationr8ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setERUCCHInfo(const ERUCCHInfo& eRUCCHInfo) { *static_cast<ERUCCHInfo*>(items[0]) = eRUCCHInfo; }
	void setEPUCHInfo(const EPUCHInfo& ePUCHInfo) { *static_cast<EPUCHInfo*>(items[1]) = ePUCHInfo; }
	void setNonScheduledTransGrantInfo(const NonScheduledTransGrantInfoTDD& nonScheduledTransGrantInfo) { *static_cast<NonScheduledTransGrantInfoTDD*>(items[2]) = nonScheduledTransGrantInfo; }
};

class ULEDCHInformationr8ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULEDCHInformationr8ModeSpecificInfoChoices {
		uLEDCHInformationr8ModeSpecificInfoFdd = 0,
		uLEDCHInformationr8ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	ULEDCHInformationr8ModeSpecificInfo(): Choice(&theInfo) {}
};

class ULEDCHInformationr8 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULEDCHInformationr8(): Sequence(&theInfo) {}

	void setULEDCHInformationr8mac_es_e_resetIndicator(const ULEDCHInformationr8mac_es_e_resetIndicator& uLEDCHInformationr8mac_es_e_resetIndicator) { *static_cast<ULEDCHInformationr8mac_es_e_resetIndicator*>(items[0]) = uLEDCHInformationr8mac_es_e_resetIndicator; }
	void setULEDCHInformationr8ModeSpecificInfo(const ULEDCHInformationr8ModeSpecificInfo& uLEDCHInformationr8ModeSpecificInfo) { *static_cast<ULEDCHInformationr8ModeSpecificInfo*>(items[1]) = uLEDCHInformationr8ModeSpecificInfo; }
};

class DLULHSPAInformationr8 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	DLULHSPAInformationr8(): Sequence(&theInfo) {}

	void setUlEDCHInformation(const ULEDCHInformationr8& ulEDCHInformation) { *static_cast<ULEDCHInformationr8*>(items[0]) = ulEDCHInformation; }
	void setDlCommonInformation(const DLCommonInformationr8& dlCommonInformation) { *static_cast<DLCommonInformationr8*>(items[1]) = dlCommonInformation; }
	void setDlInformationPerRLList(const DLInformationPerRLListr7& dlInformationPerRLList) { *static_cast<DLInformationPerRLListr7*>(items[2]) = dlInformationPerRLList; }
	void setDlHSPDSCHInformation(const DLHSPDSCHInformationr8& dlHSPDSCHInformation) { *static_cast<DLHSPDSCHInformationr8*>(items[3]) = dlHSPDSCHInformation; }
};

enum ULEDCHInformationr9mac_es_e_resetIndicatorValues {
	true_ULEDCHInformationr9mac_es_e_resetIndicator = 0,
};
typedef Enumerated<CONSTRAINED, 0> ULEDCHInformationr9mac_es_e_resetIndicator;

class ULEDCHInformationr9ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	ULEDCHInformationr9ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setEDPCCHInfo(const EDPCCHInfor7& eDPCCHInfo) { *static_cast<EDPCCHInfor7*>(items[0]) = eDPCCHInfo; }
	void setEDPDCHInfo(const EDPDCHInfor8& eDPDCHInfo) { *static_cast<EDPDCHInfor8*>(items[1]) = eDPDCHInfo; }
	void setSchedulingTransmConfiguration(const EDPDCHSchedulingTransmConfiguration& schedulingTransmConfiguration) { *static_cast<EDPDCHSchedulingTransmConfiguration*>(items[2]) = schedulingTransmConfiguration; }
	void setUl16QAMSettings(const UL16QAMSettings& ul16QAMSettings) { *static_cast<UL16QAMSettings*>(items[3]) = ul16QAMSettings; }
};

typedef BitString<CONSTRAINED, 13, 13> NonScheduledTransGrantInfoTDDr9Tdd384768TimeslotResourceRelatedInfo;

typedef Integer<CONSTRAINED, 1, 32> NonScheduledTransGrantInfoTDDr9Tdd384768PowerResourceRelatedInfo;

class NonScheduledTransGrantInfoTDDr9Tdd384768 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	NonScheduledTransGrantInfoTDDr9Tdd384768(): Sequence(&theInfo) {}

	void setNonScheduledTransGrantInfoTDDr9Tdd384768TimeslotResourceRelatedInfo(const NonScheduledTransGrantInfoTDDr9Tdd384768TimeslotResourceRelatedInfo& nonScheduledTransGrantInfoTDDr9Tdd384768TimeslotResourceRelatedInfo) { *static_cast<NonScheduledTransGrantInfoTDDr9Tdd384768TimeslotResourceRelatedInfo*>(items[0]) = nonScheduledTransGrantInfoTDDr9Tdd384768TimeslotResourceRelatedInfo; }
	void setNonScheduledTransGrantInfoTDDr9Tdd384768PowerResourceRelatedInfo(const NonScheduledTransGrantInfoTDDr9Tdd384768PowerResourceRelatedInfo& nonScheduledTransGrantInfoTDDr9Tdd384768PowerResourceRelatedInfo) { *static_cast<NonScheduledTransGrantInfoTDDr9Tdd384768PowerResourceRelatedInfo*>(items[1]) = nonScheduledTransGrantInfoTDDr9Tdd384768PowerResourceRelatedInfo; }
	void setActivationTime(const ActivationTime& activationTime) { *static_cast<ActivationTime*>(items[2]) = activationTime; }
	void setRepetitionPeriodAndLength(const RepetitionPeriodAndLength& repetitionPeriodAndLength) { *static_cast<RepetitionPeriodAndLength*>(items[3]) = repetitionPeriodAndLength; }
	void setCodeResourceInfo(const ULTSChannelisationCode& codeResourceInfo) { *static_cast<ULTSChannelisationCode*>(items[4]) = codeResourceInfo; }
};

typedef Integer<CONSTRAINED, 1, 8> NonScheduledTransGrantInfoTDDr9Tdd128NEUCCH;

typedef Integer<CONSTRAINED, 4, 15> NonScheduledTransGrantInfoTDDr9Tdd128NEHICH;

typedef BitString<CONSTRAINED, 5, 5> NonScheduledTransGrantInfoTDDr9Tdd128TimeslotResourceRelatedInfo;

typedef Integer<CONSTRAINED, 1, 32> NonScheduledTransGrantInfoTDDr9Tdd128PowerResourceRelatedInfo;

typedef Integer<CONSTRAINED, 0, 1> NonScheduledTransGrantInfoTDDr9Tdd128SfnNum;

typedef Null NonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoMidambleAllocationModeDefaultMidamble;

typedef Integer<CONSTRAINED, 0, 15> NonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoMidambleAllocationModeUeSpecificMidamble;

class NonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoMidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum NonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoMidambleAllocationModeChoices {
		nonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoMidambleAllocationModeDefaultMidamble = 0,
		nonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoMidambleAllocationModeUeSpecificMidamble = 1,
	};
	static const Info theInfo;
	NonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoMidambleAllocationMode(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, 8> NonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoMidambleConfiguration;

typedef Integer<CONSTRAINED, 0, 19> NonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoSignatureSequenceGroupIndex;

class NonScheduledTransGrantInfoTDDr9Tdd128EHICHInfo : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	NonScheduledTransGrantInfoTDDr9Tdd128EHICHInfo(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumberLCRr4& timeslotNumber) { *static_cast<TimeslotNumberLCRr4*>(items[0]) = timeslotNumber; }
	void setChannelisationCode(const HSChannelisationCodeLCR& channelisationCode) { *static_cast<HSChannelisationCodeLCR*>(items[1]) = channelisationCode; }
	void setNonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoMidambleAllocationMode(const NonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoMidambleAllocationMode& nonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoMidambleAllocationMode) { *static_cast<NonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoMidambleAllocationMode*>(items[2]) = nonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoMidambleAllocationMode; }
	void setNonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoMidambleConfiguration(const NonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoMidambleConfiguration& nonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoMidambleConfiguration) { *static_cast<NonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoMidambleConfiguration*>(items[3]) = nonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoMidambleConfiguration; }
	void setNonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoSignatureSequenceGroupIndex(const NonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoSignatureSequenceGroupIndex& nonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoSignatureSequenceGroupIndex) { *static_cast<NonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoSignatureSequenceGroupIndex*>(items[4]) = nonScheduledTransGrantInfoTDDr9Tdd128EHICHInfoSignatureSequenceGroupIndex; }
};

enum NonScheduledTransGrantInfoTDDr9Tdd128t_SI_nstValues {
	everyEDCHTTI_NonScheduledTransGrantInfoTDDr9Tdd128t_SI_nst = 0,
	ms20_NonScheduledTransGrantInfoTDDr9Tdd128t_SI_nst = 1,
	ms40_NonScheduledTransGrantInfoTDDr9Tdd128t_SI_nst = 2,
	ms60_NonScheduledTransGrantInfoTDDr9Tdd128t_SI_nst = 3,
	ms80_NonScheduledTransGrantInfoTDDr9Tdd128t_SI_nst = 4,
	ms160_NonScheduledTransGrantInfoTDDr9Tdd128t_SI_nst = 5,
	ms200_NonScheduledTransGrantInfoTDDr9Tdd128t_SI_nst = 6,
};
typedef Enumerated<CONSTRAINED, 6> NonScheduledTransGrantInfoTDDr9Tdd128t_SI_nst;

class NonScheduledTransGrantInfoTDDr9Tdd128 : public Sequence {
private:
	static const void *itemsInfo[10];
	static bool itemsPres[10];
public:
	static const Info theInfo;
	NonScheduledTransGrantInfoTDDr9Tdd128(): Sequence(&theInfo) {}

	void setNonScheduledTransGrantInfoTDDr9Tdd128NEUCCH(const NonScheduledTransGrantInfoTDDr9Tdd128NEUCCH& nonScheduledTransGrantInfoTDDr9Tdd128NEUCCH) { *static_cast<NonScheduledTransGrantInfoTDDr9Tdd128NEUCCH*>(items[0]) = nonScheduledTransGrantInfoTDDr9Tdd128NEUCCH; }
	void setNonScheduledTransGrantInfoTDDr9Tdd128NEHICH(const NonScheduledTransGrantInfoTDDr9Tdd128NEHICH& nonScheduledTransGrantInfoTDDr9Tdd128NEHICH) { *static_cast<NonScheduledTransGrantInfoTDDr9Tdd128NEHICH*>(items[1]) = nonScheduledTransGrantInfoTDDr9Tdd128NEHICH; }
	void setNonScheduledTransGrantInfoTDDr9Tdd128TimeslotResourceRelatedInfo(const NonScheduledTransGrantInfoTDDr9Tdd128TimeslotResourceRelatedInfo& nonScheduledTransGrantInfoTDDr9Tdd128TimeslotResourceRelatedInfo) { *static_cast<NonScheduledTransGrantInfoTDDr9Tdd128TimeslotResourceRelatedInfo*>(items[2]) = nonScheduledTransGrantInfoTDDr9Tdd128TimeslotResourceRelatedInfo; }
	void setNonScheduledTransGrantInfoTDDr9Tdd128PowerResourceRelatedInfo(const NonScheduledTransGrantInfoTDDr9Tdd128PowerResourceRelatedInfo& nonScheduledTransGrantInfoTDDr9Tdd128PowerResourceRelatedInfo) { *static_cast<NonScheduledTransGrantInfoTDDr9Tdd128PowerResourceRelatedInfo*>(items[3]) = nonScheduledTransGrantInfoTDDr9Tdd128PowerResourceRelatedInfo; }
	void setActivationTime(const ActivationTime& activationTime) { *static_cast<ActivationTime*>(items[4]) = activationTime; }
	void setNonScheduledTransGrantInfoTDDr9Tdd128SfnNum(const NonScheduledTransGrantInfoTDDr9Tdd128SfnNum& nonScheduledTransGrantInfoTDDr9Tdd128SfnNum) { *static_cast<NonScheduledTransGrantInfoTDDr9Tdd128SfnNum*>(items[5]) = nonScheduledTransGrantInfoTDDr9Tdd128SfnNum; }
	void setRepetitionPeriodAndLength(const RepetitionPeriodAndLength& repetitionPeriodAndLength) { *static_cast<RepetitionPeriodAndLength*>(items[6]) = repetitionPeriodAndLength; }
	void setCodeResourceInfo(const ULTSChannelisationCode& codeResourceInfo) { *static_cast<ULTSChannelisationCode*>(items[7]) = codeResourceInfo; }
	void setNonScheduledTransGrantInfoTDDr9Tdd128EHICHInfo(const NonScheduledTransGrantInfoTDDr9Tdd128EHICHInfo& nonScheduledTransGrantInfoTDDr9Tdd128EHICHInfo) { *static_cast<NonScheduledTransGrantInfoTDDr9Tdd128EHICHInfo*>(items[8]) = nonScheduledTransGrantInfoTDDr9Tdd128EHICHInfo; }
	void setNonScheduledTransGrantInfoTDDr9Tdd128t_SI_nst(const NonScheduledTransGrantInfoTDDr9Tdd128t_SI_nst& nonScheduledTransGrantInfoTDDr9Tdd128t_SI_nst) { *static_cast<NonScheduledTransGrantInfoTDDr9Tdd128t_SI_nst*>(items[9]) = nonScheduledTransGrantInfoTDDr9Tdd128t_SI_nst; }
};

class NonScheduledTransGrantInfoTDDr9 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum NonScheduledTransGrantInfoTDDr9Choices {
		nonScheduledTransGrantInfoTDDr9Tdd384768 = 0,
		nonScheduledTransGrantInfoTDDr9Tdd128 = 1,
	};
	static const Info theInfo;
	NonScheduledTransGrantInfoTDDr9(): Choice(&theInfo) {}
};

class ULEDCHInformationr9ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULEDCHInformationr9ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setERUCCHInfo(const ERUCCHInfo& eRUCCHInfo) { *static_cast<ERUCCHInfo*>(items[0]) = eRUCCHInfo; }
	void setEPUCHInfo(const EPUCHInfo& ePUCHInfo) { *static_cast<EPUCHInfo*>(items[1]) = ePUCHInfo; }
	void setNonScheduledTransGrantInfo(const NonScheduledTransGrantInfoTDDr9& nonScheduledTransGrantInfo) { *static_cast<NonScheduledTransGrantInfoTDDr9*>(items[2]) = nonScheduledTransGrantInfo; }
};

class ULEDCHInformationr9ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULEDCHInformationr9ModeSpecificInfoChoices {
		uLEDCHInformationr9ModeSpecificInfoFdd = 0,
		uLEDCHInformationr9ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	ULEDCHInformationr9ModeSpecificInfo(): Choice(&theInfo) {}
};

class ULEDCHInformationr9 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULEDCHInformationr9(): Sequence(&theInfo) {}

	void setULEDCHInformationr9mac_es_e_resetIndicator(const ULEDCHInformationr9mac_es_e_resetIndicator& uLEDCHInformationr9mac_es_e_resetIndicator) { *static_cast<ULEDCHInformationr9mac_es_e_resetIndicator*>(items[0]) = uLEDCHInformationr9mac_es_e_resetIndicator; }
	void setULEDCHInformationr9ModeSpecificInfo(const ULEDCHInformationr9ModeSpecificInfo& uLEDCHInformationr9ModeSpecificInfo) { *static_cast<ULEDCHInformationr9ModeSpecificInfo*>(items[1]) = uLEDCHInformationr9ModeSpecificInfo; }
};

class DLULHSPAInformationr9 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	DLULHSPAInformationr9(): Sequence(&theInfo) {}

	void setUlEDCHInformation(const ULEDCHInformationr9& ulEDCHInformation) { *static_cast<ULEDCHInformationr9*>(items[0]) = ulEDCHInformation; }
	void setDlCommonInformation(const DLCommonInformationr8& dlCommonInformation) { *static_cast<DLCommonInformationr8*>(items[1]) = dlCommonInformation; }
	void setDlInformationPerRLList(const DLInformationPerRLListr7& dlInformationPerRLList) { *static_cast<DLInformationPerRLListr7*>(items[2]) = dlInformationPerRLList; }
	void setDlHSPDSCHInformation(const DLHSPDSCHInformationr9& dlHSPDSCHInformation) { *static_cast<DLHSPDSCHInformationr9*>(items[3]) = dlHSPDSCHInformation; }
};

typedef Integer<CONSTRAINED, -28, -13> DPCCHPowerOffset2;

typedef Integer<CONSTRAINED, 0, 255> TGPSReconfigurationCFN;

class TGPSequenceShortTgpsStatusActivate : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	TGPSequenceShortTgpsStatusActivate(): Sequence(&theInfo) {}

	void setTgcfn(const TGCFN& tgcfn) { *static_cast<TGCFN*>(items[0]) = tgcfn; }
};

typedef Null TGPSequenceShortTgpsStatusDeactivate;

class TGPSequenceShortTgpsStatus : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum TGPSequenceShortTgpsStatusChoices {
		tGPSequenceShortTgpsStatusActivate = 0,
		tGPSequenceShortTgpsStatusDeactivate = 1,
	};
	static const Info theInfo;
	TGPSequenceShortTgpsStatus(): Choice(&theInfo) {}
};

class TGPSequenceShort : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	TGPSequenceShort(): Sequence(&theInfo) {}

	void setTgpsi(const TGPSI& tgpsi) { *static_cast<TGPSI*>(items[0]) = tgpsi; }
	void setTGPSequenceShortTgpsStatus(const TGPSequenceShortTgpsStatus& tGPSequenceShortTgpsStatus) { *static_cast<TGPSequenceShortTgpsStatus*>(items[1]) = tGPSequenceShortTgpsStatus; }
};

typedef SequenceOf<TGPSequenceShort, CONSTRAINED, 1, maxTGPS> DPCHCompressedModeStatusInfoTgpSequenceShortList;

class DPCHCompressedModeStatusInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DPCHCompressedModeStatusInfo(): Sequence(&theInfo) {}

	void setTgpsReconfigurationCFN(const TGPSReconfigurationCFN& tgpsReconfigurationCFN) { *static_cast<TGPSReconfigurationCFN*>(items[0]) = tgpsReconfigurationCFN; }
	void setDPCHCompressedModeStatusInfoTgpSequenceShortList(const DPCHCompressedModeStatusInfoTgpSequenceShortList& dPCHCompressedModeStatusInfoTgpSequenceShortList) { *static_cast<DPCHCompressedModeStatusInfoTgpSequenceShortList*>(items[1]) = dPCHCompressedModeStatusInfoTgpSequenceShortList; }
};

enum UEDRXCycleInactivityThresholdValues {
	sub_frames_0_UEDRXCycleInactivityThreshold = 0,
	sub_frames_1_UEDRXCycleInactivityThreshold = 1,
	sub_frames_2_UEDRXCycleInactivityThreshold = 2,
	sub_frames_4_UEDRXCycleInactivityThreshold = 3,
	sub_frames_8_UEDRXCycleInactivityThreshold = 4,
	sub_frames_16_UEDRXCycleInactivityThreshold = 5,
	sub_frames_32_UEDRXCycleInactivityThreshold = 6,
	sub_frames_64_UEDRXCycleInactivityThreshold = 7,
	sub_frames_128_UEDRXCycleInactivityThreshold = 8,
	sub_frames_256_UEDRXCycleInactivityThreshold = 9,
	sub_frames_512_UEDRXCycleInactivityThreshold = 10,
	spare5_UEDRXCycleInactivityThreshold = 11,
	spare4_UEDRXCycleInactivityThreshold = 12,
	spare3_UEDRXCycleInactivityThreshold = 13,
	spare2_UEDRXCycleInactivityThreshold = 14,
	spare1_UEDRXCycleInactivityThreshold = 15,
};
typedef Enumerated<CONSTRAINED, 15> UEDRXCycleInactivityThreshold;

enum UEDRXCycleValues {
	sub_frames_4_UEDRXCycle = 0,
	sub_frames_5_UEDRXCycle = 1,
	sub_frames_8_UEDRXCycle = 2,
	sub_frames_10_UEDRXCycle = 3,
	sub_frames_16_UEDRXCycle = 4,
	sub_frames_20_UEDRXCycle = 5,
	spare2_UEDRXCycle = 6,
	spare1_UEDRXCycle = 7,
};
typedef Enumerated<CONSTRAINED, 7> UEDRXCycle;

enum UEGrantMonitoringInactivityThresholdValues {
	e_dch_tti_0_UEGrantMonitoringInactivityThreshold = 0,
	e_dch_tti_1_UEGrantMonitoringInactivityThreshold = 1,
	e_dch_tti_2_UEGrantMonitoringInactivityThreshold = 2,
	e_dch_tti_4_UEGrantMonitoringInactivityThreshold = 3,
	e_dch_tti_8_UEGrantMonitoringInactivityThreshold = 4,
	e_dch_tti_16_UEGrantMonitoringInactivityThreshold = 5,
	e_dch_tti_32_UEGrantMonitoringInactivityThreshold = 6,
	e_dch_tti_64_UEGrantMonitoringInactivityThreshold = 7,
	e_dch_tti_128_UEGrantMonitoringInactivityThreshold = 8,
	e_dch_tti_256_UEGrantMonitoringInactivityThreshold = 9,
	spare6_UEGrantMonitoringInactivityThreshold = 10,
	spare5_UEGrantMonitoringInactivityThreshold = 11,
	spare4_UEGrantMonitoringInactivityThreshold = 12,
	spare3_UEGrantMonitoringInactivityThreshold = 13,
	spare2_UEGrantMonitoringInactivityThreshold = 14,
	spare1_UEGrantMonitoringInactivityThreshold = 15,
};
typedef Enumerated<CONSTRAINED, 15> UEGrantMonitoringInactivityThreshold;

typedef Boolean DRXInfoUedrxGrantMonitoring;

class DRXInfo : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	DRXInfo(): Sequence(&theInfo) {}

	void setUedrxCycle(const UEDRXCycle& uedrxCycle) { *static_cast<UEDRXCycle*>(items[0]) = uedrxCycle; }
	void setUedrxCycleInactivityThreshold(const UEDRXCycleInactivityThreshold& uedrxCycleInactivityThreshold) { *static_cast<UEDRXCycleInactivityThreshold*>(items[1]) = uedrxCycleInactivityThreshold; }
	void setUeGrantMonitoringInactivityThreshold(const UEGrantMonitoringInactivityThreshold& ueGrantMonitoringInactivityThreshold) { *static_cast<UEGrantMonitoringInactivityThreshold*>(items[2]) = ueGrantMonitoringInactivityThreshold; }
	void setDRXInfoUedrxGrantMonitoring(const DRXInfoUedrxGrantMonitoring& dRXInfoUedrxGrantMonitoring) { *static_cast<DRXInfoUedrxGrantMonitoring*>(items[3]) = dRXInfoUedrxGrantMonitoring; }
};

class DSCHTransportChannelsInfo : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	DSCHTransportChannelsInfo(): Sequence(&theInfo) {}

};

enum UEDTXCycle110msValues {
	sub_frames_1_UEDTXCycle110ms = 0,
	sub_frames_5_UEDTXCycle110ms = 1,
	sub_frames_10_UEDTXCycle110ms = 2,
	sub_frames_20_UEDTXCycle110ms = 3,
};
typedef Enumerated<CONSTRAINED, 3> UEDTXCycle110ms;

enum UEDTXCycle210msValues {
	sub_frames_5_UEDTXCycle210ms = 0,
	sub_frames_10_UEDTXCycle210ms = 1,
	sub_frames_20_UEDTXCycle210ms = 2,
	sub_frames_40_UEDTXCycle210ms = 3,
	sub_frames_80_UEDTXCycle210ms = 4,
	sub_frames_160_UEDTXCycle210ms = 5,
	spare2_UEDTXCycle210ms = 6,
	spare1_UEDTXCycle210ms = 7,
};
typedef Enumerated<CONSTRAINED, 7> UEDTXCycle210ms;

enum MACDTXCycle10msValues {
	sub_frames_5_MACDTXCycle10ms = 0,
	sub_frames_10_MACDTXCycle10ms = 1,
	sub_frames_20_MACDTXCycle10ms = 2,
	spare1_MACDTXCycle10ms = 3,
};
typedef Enumerated<CONSTRAINED, 3> MACDTXCycle10ms;

class DTXEDCHTTI10ms : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DTXEDCHTTI10ms(): Sequence(&theInfo) {}

	void setUedtxCycle110ms(const UEDTXCycle110ms& uedtxCycle110ms) { *static_cast<UEDTXCycle110ms*>(items[0]) = uedtxCycle110ms; }
	void setUedtxCycle210ms(const UEDTXCycle210ms& uedtxCycle210ms) { *static_cast<UEDTXCycle210ms*>(items[1]) = uedtxCycle210ms; }
	void setMacdtxCycle10ms(const MACDTXCycle10ms& macdtxCycle10ms) { *static_cast<MACDTXCycle10ms*>(items[2]) = macdtxCycle10ms; }
};

enum UEDTXCycle12msValues {
	sub_frames_1_UEDTXCycle12ms = 0,
	sub_frames_4_UEDTXCycle12ms = 1,
	sub_frames_5_UEDTXCycle12ms = 2,
	sub_frames_8_UEDTXCycle12ms = 3,
	sub_frames_10_UEDTXCycle12ms = 4,
	sub_frames_16_UEDTXCycle12ms = 5,
	sub_frames_20_UEDTXCycle12ms = 6,
	spare1_UEDTXCycle12ms = 7,
};
typedef Enumerated<CONSTRAINED, 7> UEDTXCycle12ms;

enum UEDTXCycle22msValues {
	sub_frames_4_UEDTXCycle22ms = 0,
	sub_frames_5_UEDTXCycle22ms = 1,
	sub_frames_8_UEDTXCycle22ms = 2,
	sub_frames_10_UEDTXCycle22ms = 3,
	sub_frames_16_UEDTXCycle22ms = 4,
	sub_frames_20_UEDTXCycle22ms = 5,
	sub_frames_32_UEDTXCycle22ms = 6,
	sub_frames_40_UEDTXCycle22ms = 7,
	sub_frames_64_UEDTXCycle22ms = 8,
	sub_frames_80_UEDTXCycle22ms = 9,
	sub_frames_128_UEDTXCycle22ms = 10,
	sub_frames_160_UEDTXCycle22ms = 11,
	spare4_UEDTXCycle22ms = 12,
	spare3_UEDTXCycle22ms = 13,
	spare2_UEDTXCycle22ms = 14,
	spare1_UEDTXCycle22ms = 15,
};
typedef Enumerated<CONSTRAINED, 15> UEDTXCycle22ms;

enum MACDTXCycle2msValues {
	sub_frames_1_MACDTXCycle2ms = 0,
	sub_frames_4_MACDTXCycle2ms = 1,
	sub_frames_5_MACDTXCycle2ms = 2,
	sub_frames_8_MACDTXCycle2ms = 3,
	sub_frames_10_MACDTXCycle2ms = 4,
	sub_frames_16_MACDTXCycle2ms = 5,
	sub_frames_20_MACDTXCycle2ms = 6,
	spare1_MACDTXCycle2ms = 7,
};
typedef Enumerated<CONSTRAINED, 7> MACDTXCycle2ms;

class DTXEDCHTTI2ms : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DTXEDCHTTI2ms(): Sequence(&theInfo) {}

	void setUedtxCycle12ms(const UEDTXCycle12ms& uedtxCycle12ms) { *static_cast<UEDTXCycle12ms*>(items[0]) = uedtxCycle12ms; }
	void setUedtxCycle22ms(const UEDTXCycle22ms& uedtxCycle22ms) { *static_cast<UEDTXCycle22ms*>(items[1]) = uedtxCycle22ms; }
	void setMacdtxCycle2ms(const MACDTXCycle2ms& macdtxCycle2ms) { *static_cast<MACDTXCycle2ms*>(items[2]) = macdtxCycle2ms; }
};

class DTXInfoEdchTTILength : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DTXInfoEdchTTILengthChoices {
		dtxedchTTI10ms = 0,
		dtxedchTTI2ms = 1,
	};
	static const Info theInfo;
	DTXInfoEdchTTILength(): Choice(&theInfo) {}
};

enum UEDTXCycle2InactivityThresholdValues {
	e_dch_tti_1_UEDTXCycle2InactivityThreshold = 0,
	e_dch_tti_4_UEDTXCycle2InactivityThreshold = 1,
	e_dch_tti_8_UEDTXCycle2InactivityThreshold = 2,
	e_dch_tti_16_UEDTXCycle2InactivityThreshold = 3,
	e_dch_tti_32_UEDTXCycle2InactivityThreshold = 4,
	e_dch_tti_64_UEDTXCycle2InactivityThreshold = 5,
	e_dch_tti_128_UEDTXCycle2InactivityThreshold = 6,
	e_dch_tti_256_UEDTXCycle2InactivityThreshold = 7,
	spare8_UEDTXCycle2InactivityThreshold = 8,
	spare7_UEDTXCycle2InactivityThreshold = 9,
	spare6_UEDTXCycle2InactivityThreshold = 10,
	spare5_UEDTXCycle2InactivityThreshold = 11,
	spare4_UEDTXCycle2InactivityThreshold = 12,
	spare3_UEDTXCycle2InactivityThreshold = 13,
	spare2_UEDTXCycle2InactivityThreshold = 14,
	spare1_UEDTXCycle2InactivityThreshold = 15,
};
typedef Enumerated<CONSTRAINED, 15> UEDTXCycle2InactivityThreshold;

typedef Integer<CONSTRAINED, 0, 38> DTXInfoUedtxcycle2DefaultSG;

enum UEDTXlongpreamblelengthValues {
	slots_4_UEDTXlongpreamblelength = 0,
	slots_15_UEDTXlongpreamblelength = 1,
};
typedef Enumerated<CONSTRAINED, 1> UEDTXlongpreamblelength;

enum MACInactivityThresholdValues {
	e_dch_tti_1_MACInactivityThreshold = 0,
	e_dch_tti_2_MACInactivityThreshold = 1,
	e_dch_tti_4_MACInactivityThreshold = 2,
	e_dch_tti_8_MACInactivityThreshold = 3,
	e_dch_tti_16_MACInactivityThreshold = 4,
	e_dch_tti_32_MACInactivityThreshold = 5,
	e_dch_tti_64_MACInactivityThreshold = 6,
	e_dch_tti_128_MACInactivityThreshold = 7,
	e_dch_tti_256_MACInactivityThreshold = 8,
	e_dch_tti_512_MACInactivityThreshold = 9,
	e_dch_tti_Infinity_MACInactivityThreshold = 10,
	spare5_MACInactivityThreshold = 11,
	spare4_MACInactivityThreshold = 12,
	spare3_MACInactivityThreshold = 13,
	spare2_MACInactivityThreshold = 14,
	spare1_MACInactivityThreshold = 15,
};
typedef Enumerated<CONSTRAINED, 15> MACInactivityThreshold;

enum UEDPCCHBurstValues {
	sub_frames_1_UEDPCCHBurst = 0,
	sub_frames_2_UEDPCCHBurst = 1,
	sub_frames_5_UEDPCCHBurst = 2,
	spare1_UEDPCCHBurst = 3,
};
typedef Enumerated<CONSTRAINED, 3> UEDPCCHBurst;

class DTXInfo : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	DTXInfo(): Sequence(&theInfo) {}

	void setDTXInfoEdchTTILength(const DTXInfoEdchTTILength& dTXInfoEdchTTILength) { *static_cast<DTXInfoEdchTTILength*>(items[0]) = dTXInfoEdchTTILength; }
	void setUedtxcycle2InactivityThreshold(const UEDTXCycle2InactivityThreshold& uedtxcycle2InactivityThreshold) { *static_cast<UEDTXCycle2InactivityThreshold*>(items[1]) = uedtxcycle2InactivityThreshold; }
	void setDTXInfoUedtxcycle2DefaultSG(const DTXInfoUedtxcycle2DefaultSG& dTXInfoUedtxcycle2DefaultSG) { *static_cast<DTXInfoUedtxcycle2DefaultSG*>(items[2]) = dTXInfoUedtxcycle2DefaultSG; }
	void setUedtxlongpreamblelength(const UEDTXlongpreamblelength& uedtxlongpreamblelength) { *static_cast<UEDTXlongpreamblelength*>(items[3]) = uedtxlongpreamblelength; }
	void setMacInactivityThreshold(const MACInactivityThreshold& macInactivityThreshold) { *static_cast<MACInactivityThreshold*>(items[4]) = macInactivityThreshold; }
	void setCqidtxTimer(const CQIDTXTimer& cqidtxTimer) { *static_cast<CQIDTXTimer*>(items[5]) = cqidtxTimer; }
	void setUedpcchBurst1(const UEDPCCHBurst& uedpcchBurst1) { *static_cast<UEDPCCHBurst*>(items[6]) = uedpcchBurst1; }
	void setUedpcchBurst2(const UEDPCCHBurst& uedpcchBurst2) { *static_cast<UEDPCCHBurst*>(items[7]) = uedpcchBurst2; }
};

enum UplinkDPCCHSlotFormatInformationValues {
	slot_format_1_UplinkDPCCHSlotFormatInformation = 0,
	dummy_UplinkDPCCHSlotFormatInformation = 1,
	slot_format_4_UplinkDPCCHSlotFormatInformation = 2,
	spare1_UplinkDPCCHSlotFormatInformation = 3,
};
typedef Enumerated<CONSTRAINED, 3> UplinkDPCCHSlotFormatInformation;

class DTXDRXInfor7 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DTXDRXInfor7(): Sequence(&theInfo) {}

	void setDtxInfo(const DTXInfo& dtxInfo) { *static_cast<DTXInfo*>(items[0]) = dtxInfo; }
	void setDrxInfo(const DRXInfo& drxInfo) { *static_cast<DRXInfo*>(items[1]) = drxInfo; }
	void setUplinkDPCCHSlotFormatInformation(const UplinkDPCCHSlotFormatInformation& uplinkDPCCHSlotFormatInformation) { *static_cast<UplinkDPCCHSlotFormatInformation*>(items[2]) = uplinkDPCCHSlotFormatInformation; }
};

typedef SequenceOf<DynamicPersistenceLevel, CONSTRAINED, 1, maxPRACH> DynamicPersistenceLevelList;

typedef Integer<CONSTRAINED, 0, 38> EDCHRLInfoNewServingCellServingGrantValue;

enum EDCHRLInfoNewServingCellServingGrantprimary_Secondary_GrantSelectorValues {
	primary_EDCHRLInfoNewServingCellServingGrantprimary_Secondary_GrantSelector = 0,
	secondary_EDCHRLInfoNewServingCellServingGrantprimary_Secondary_GrantSelector = 1,
};
typedef Enumerated<CONSTRAINED, 1> EDCHRLInfoNewServingCellServingGrantprimary_Secondary_GrantSelector;

class EDCHRLInfoNewServingCellServingGrant : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EDCHRLInfoNewServingCellServingGrant(): Sequence(&theInfo) {}

	void setEDCHRLInfoNewServingCellServingGrantValue(const EDCHRLInfoNewServingCellServingGrantValue& eDCHRLInfoNewServingCellServingGrantValue) { *static_cast<EDCHRLInfoNewServingCellServingGrantValue*>(items[0]) = eDCHRLInfoNewServingCellServingGrantValue; }
	void setEDCHRLInfoNewServingCellServingGrantprimary_Secondary_GrantSelector(const EDCHRLInfoNewServingCellServingGrantprimary_Secondary_GrantSelector& eDCHRLInfoNewServingCellServingGrantprimary_Secondary_GrantSelector) { *static_cast<EDCHRLInfoNewServingCellServingGrantprimary_Secondary_GrantSelector*>(items[1]) = eDCHRLInfoNewServingCellServingGrantprimary_Secondary_GrantSelector; }
};

typedef Integer<CONSTRAINED, 0, 127> EDPDCHReferenceETFCIReferenceETFCI;

typedef Integer<CONSTRAINED, 0, 29> EDPDCHReferenceETFCIReferenceETFCIPO;

class EDPDCHReferenceETFCI : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EDPDCHReferenceETFCI(): Sequence(&theInfo) {}

	void setEDPDCHReferenceETFCIReferenceETFCI(const EDPDCHReferenceETFCIReferenceETFCI& eDPDCHReferenceETFCIReferenceETFCI) { *static_cast<EDPDCHReferenceETFCIReferenceETFCI*>(items[0]) = eDPDCHReferenceETFCIReferenceETFCI; }
	void setEDPDCHReferenceETFCIReferenceETFCIPO(const EDPDCHReferenceETFCIReferenceETFCIPO& eDPDCHReferenceETFCIReferenceETFCIPO) { *static_cast<EDPDCHReferenceETFCIReferenceETFCIPO*>(items[1]) = eDPDCHReferenceETFCIReferenceETFCIPO; }
};

typedef SequenceOf<EDPDCHReferenceETFCI, CONSTRAINED, 1, 8> EDPDCHReferenceETFCIList;

typedef Integer<CONSTRAINED, 0, 6> EDCHRLInfoNewServingCellPowerOffsetForSchedInfo;

typedef Integer<CONSTRAINED, 0, 37> EDCHRLInfoNewServingCellThreeIndexStepThreshold;

typedef Integer<CONSTRAINED, 0, 37> EDCHRLInfoNewServingCellTwoIndexStepThreshold;

typedef Null EDCHRLInfoNewServingCellERGCHInfoReleaseIndicator;

class EDCHRLInfoNewServingCellERGCHInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum EDCHRLInfoNewServingCellERGCHInfoChoices {
		eRGCHInformation = 0,
		eDCHRLInfoNewServingCellERGCHInfoReleaseIndicator = 1,
	};
	static const Info theInfo;
	EDCHRLInfoNewServingCellERGCHInfo(): Choice(&theInfo) {}
};

class EDCHRLInfoNewServingCell : public Sequence {
private:
	static const void *itemsInfo[10];
	static bool itemsPres[10];
public:
	static const Info theInfo;
	EDCHRLInfoNewServingCell(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setEAGCHInformation(const EAGCHInformation& eAGCHInformation) { *static_cast<EAGCHInformation*>(items[1]) = eAGCHInformation; }
	void setEDCHRLInfoNewServingCellServingGrant(const EDCHRLInfoNewServingCellServingGrant& eDCHRLInfoNewServingCellServingGrant) { *static_cast<EDCHRLInfoNewServingCellServingGrant*>(items[2]) = eDCHRLInfoNewServingCellServingGrant; }
	void setEDPCCHDPCCHPowerOffset(const EDPCCHDPCCHPowerOffset& eDPCCHDPCCHPowerOffset) { *static_cast<EDPCCHDPCCHPowerOffset*>(items[3]) = eDPCCHDPCCHPowerOffset; }
	void setReferenceETFCIs(const EDPDCHReferenceETFCIList& referenceETFCIs) { *static_cast<EDPDCHReferenceETFCIList*>(items[4]) = referenceETFCIs; }
	void setEDCHRLInfoNewServingCellPowerOffsetForSchedInfo(const EDCHRLInfoNewServingCellPowerOffsetForSchedInfo& eDCHRLInfoNewServingCellPowerOffsetForSchedInfo) { *static_cast<EDCHRLInfoNewServingCellPowerOffsetForSchedInfo*>(items[5]) = eDCHRLInfoNewServingCellPowerOffsetForSchedInfo; }
	void setEDCHRLInfoNewServingCellThreeIndexStepThreshold(const EDCHRLInfoNewServingCellThreeIndexStepThreshold& eDCHRLInfoNewServingCellThreeIndexStepThreshold) { *static_cast<EDCHRLInfoNewServingCellThreeIndexStepThreshold*>(items[6]) = eDCHRLInfoNewServingCellThreeIndexStepThreshold; }
	void setEDCHRLInfoNewServingCellTwoIndexStepThreshold(const EDCHRLInfoNewServingCellTwoIndexStepThreshold& eDCHRLInfoNewServingCellTwoIndexStepThreshold) { *static_cast<EDCHRLInfoNewServingCellTwoIndexStepThreshold*>(items[7]) = eDCHRLInfoNewServingCellTwoIndexStepThreshold; }
	void setEHICHInformation(const EHICHInformation& eHICHInformation) { *static_cast<EHICHInformation*>(items[8]) = eHICHInformation; }
	void setEDCHRLInfoNewServingCellERGCHInfo(const EDCHRLInfoNewServingCellERGCHInfo& eDCHRLInfoNewServingCellERGCHInfo) { *static_cast<EDCHRLInfoNewServingCellERGCHInfo*>(items[9]) = eDCHRLInfoNewServingCellERGCHInfo; }
};

typedef Null EDCHRLInfoOtherCellEHICHInfoReleaseIndicator;

class EDCHRLInfoOtherCellEHICHInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum EDCHRLInfoOtherCellEHICHInfoChoices {
		eHICHInformation = 0,
		eDCHRLInfoOtherCellEHICHInfoReleaseIndicator = 1,
	};
	static const Info theInfo;
	EDCHRLInfoOtherCellEHICHInfo(): Choice(&theInfo) {}
};

typedef Null EDCHRLInfoOtherCellERGCHInfoReleaseIndicator;

class EDCHRLInfoOtherCellERGCHInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum EDCHRLInfoOtherCellERGCHInfoChoices {
		eRGCHInformation = 0,
		eDCHRLInfoOtherCellERGCHInfoReleaseIndicator = 1,
	};
	static const Info theInfo;
	EDCHRLInfoOtherCellERGCHInfo(): Choice(&theInfo) {}
};

class EDCHRLInfoOtherCell : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	EDCHRLInfoOtherCell(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setEDCHRLInfoOtherCellEHICHInfo(const EDCHRLInfoOtherCellEHICHInfo& eDCHRLInfoOtherCellEHICHInfo) { *static_cast<EDCHRLInfoOtherCellEHICHInfo*>(items[1]) = eDCHRLInfoOtherCellEHICHInfo; }
	void setEDCHRLInfoOtherCellERGCHInfo(const EDCHRLInfoOtherCellERGCHInfo& eDCHRLInfoOtherCellERGCHInfo) { *static_cast<EDCHRLInfoOtherCellERGCHInfo*>(items[2]) = eDCHRLInfoOtherCellERGCHInfo; }
};

typedef SequenceOf<EDCHRLInfoOtherCell, CONSTRAINED, 1, maxEDCHRL> EDCHReconfigurationInfoEDCHRLInfoOtherCellList;

class EDCHReconfigurationInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EDCHReconfigurationInfo(): Sequence(&theInfo) {}

	void setEDCHRLInfoNewServingCell(const EDCHRLInfoNewServingCell& eDCHRLInfoNewServingCell) { *static_cast<EDCHRLInfoNewServingCell*>(items[0]) = eDCHRLInfoNewServingCell; }
	void setEDCHReconfigurationInfoEDCHRLInfoOtherCellList(const EDCHReconfigurationInfoEDCHRLInfoOtherCellList& eDCHReconfigurationInfoEDCHRLInfoOtherCellList) { *static_cast<EDCHReconfigurationInfoEDCHRLInfoOtherCellList*>(items[1]) = eDCHReconfigurationInfoEDCHRLInfoOtherCellList; }
};

typedef Integer<CONSTRAINED, 0, 38> EDCHRLInfoNewServingCellr7ServingGrantValue;

enum EDCHRLInfoNewServingCellr7ServingGrantprimary_Secondary_GrantSelectorValues {
	primary_EDCHRLInfoNewServingCellr7ServingGrantprimary_Secondary_GrantSelector = 0,
	secondary_EDCHRLInfoNewServingCellr7ServingGrantprimary_Secondary_GrantSelector = 1,
};
typedef Enumerated<CONSTRAINED, 1> EDCHRLInfoNewServingCellr7ServingGrantprimary_Secondary_GrantSelector;

class EDCHRLInfoNewServingCellr7ServingGrant : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EDCHRLInfoNewServingCellr7ServingGrant(): Sequence(&theInfo) {}

	void setEDCHRLInfoNewServingCellr7ServingGrantValue(const EDCHRLInfoNewServingCellr7ServingGrantValue& eDCHRLInfoNewServingCellr7ServingGrantValue) { *static_cast<EDCHRLInfoNewServingCellr7ServingGrantValue*>(items[0]) = eDCHRLInfoNewServingCellr7ServingGrantValue; }
	void setEDCHRLInfoNewServingCellr7ServingGrantprimary_Secondary_GrantSelector(const EDCHRLInfoNewServingCellr7ServingGrantprimary_Secondary_GrantSelector& eDCHRLInfoNewServingCellr7ServingGrantprimary_Secondary_GrantSelector) { *static_cast<EDCHRLInfoNewServingCellr7ServingGrantprimary_Secondary_GrantSelector*>(items[1]) = eDCHRLInfoNewServingCellr7ServingGrantprimary_Secondary_GrantSelector; }
};

typedef Integer<CONSTRAINED, 0, 6> EDCHRLInfoNewServingCellr7PowerOffsetForSchedInfo;

typedef Integer<CONSTRAINED, 0, 37> EDCHRLInfoNewServingCellr7ThreeIndexStepThreshold;

typedef Integer<CONSTRAINED, 0, 37> EDCHRLInfoNewServingCellr7TwoIndexStepThreshold;

typedef Null EDCHRLInfoNewServingCellr7ERGCHInfoReleaseIndicator;

class EDCHRLInfoNewServingCellr7ERGCHInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum EDCHRLInfoNewServingCellr7ERGCHInfoChoices {
		eRGCHInformation = 0,
		eDCHRLInfoNewServingCellr7ERGCHInfoReleaseIndicator = 1,
	};
	static const Info theInfo;
	EDCHRLInfoNewServingCellr7ERGCHInfo(): Choice(&theInfo) {}
};

class EDCHRLInfoNewServingCellr7 : public Sequence {
private:
	static const void *itemsInfo[10];
	static bool itemsPres[10];
public:
	static const Info theInfo;
	EDCHRLInfoNewServingCellr7(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setEAGCHInformation(const EAGCHInformation& eAGCHInformation) { *static_cast<EAGCHInformation*>(items[1]) = eAGCHInformation; }
	void setEDCHRLInfoNewServingCellr7ServingGrant(const EDCHRLInfoNewServingCellr7ServingGrant& eDCHRLInfoNewServingCellr7ServingGrant) { *static_cast<EDCHRLInfoNewServingCellr7ServingGrant*>(items[2]) = eDCHRLInfoNewServingCellr7ServingGrant; }
	void setEDPCCHDPCCHPowerOffset(const EDPCCHDPCCHPowerOffset& eDPCCHDPCCHPowerOffset) { *static_cast<EDPCCHDPCCHPowerOffset*>(items[3]) = eDPCCHDPCCHPowerOffset; }
	void setReferenceETFCIs(const EDPDCHReferenceETFCIListr7& referenceETFCIs) { *static_cast<EDPDCHReferenceETFCIListr7*>(items[4]) = referenceETFCIs; }
	void setEDCHRLInfoNewServingCellr7PowerOffsetForSchedInfo(const EDCHRLInfoNewServingCellr7PowerOffsetForSchedInfo& eDCHRLInfoNewServingCellr7PowerOffsetForSchedInfo) { *static_cast<EDCHRLInfoNewServingCellr7PowerOffsetForSchedInfo*>(items[5]) = eDCHRLInfoNewServingCellr7PowerOffsetForSchedInfo; }
	void setEDCHRLInfoNewServingCellr7ThreeIndexStepThreshold(const EDCHRLInfoNewServingCellr7ThreeIndexStepThreshold& eDCHRLInfoNewServingCellr7ThreeIndexStepThreshold) { *static_cast<EDCHRLInfoNewServingCellr7ThreeIndexStepThreshold*>(items[6]) = eDCHRLInfoNewServingCellr7ThreeIndexStepThreshold; }
	void setEDCHRLInfoNewServingCellr7TwoIndexStepThreshold(const EDCHRLInfoNewServingCellr7TwoIndexStepThreshold& eDCHRLInfoNewServingCellr7TwoIndexStepThreshold) { *static_cast<EDCHRLInfoNewServingCellr7TwoIndexStepThreshold*>(items[7]) = eDCHRLInfoNewServingCellr7TwoIndexStepThreshold; }
	void setEHICHInformation(const EHICHInformation& eHICHInformation) { *static_cast<EHICHInformation*>(items[8]) = eHICHInformation; }
	void setEDCHRLInfoNewServingCellr7ERGCHInfo(const EDCHRLInfoNewServingCellr7ERGCHInfo& eDCHRLInfoNewServingCellr7ERGCHInfo) { *static_cast<EDCHRLInfoNewServingCellr7ERGCHInfo*>(items[9]) = eDCHRLInfoNewServingCellr7ERGCHInfo; }
};

typedef SequenceOf<EDCHRLInfoOtherCell, CONSTRAINED, 1, maxEDCHRL> EDCHReconfigurationInfor7EDCHRLInfoOtherCellList;

class EDCHReconfigurationInfor7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EDCHReconfigurationInfor7(): Sequence(&theInfo) {}

	void setEDCHRLInfoNewServingCell(const EDCHRLInfoNewServingCellr7& eDCHRLInfoNewServingCell) { *static_cast<EDCHRLInfoNewServingCellr7*>(items[0]) = eDCHRLInfoNewServingCell; }
	void setEDCHReconfigurationInfor7EDCHRLInfoOtherCellList(const EDCHReconfigurationInfor7EDCHRLInfoOtherCellList& eDCHReconfigurationInfor7EDCHRLInfoOtherCellList) { *static_cast<EDCHReconfigurationInfor7EDCHRLInfoOtherCellList*>(items[1]) = eDCHReconfigurationInfor7EDCHRLInfoOtherCellList; }
};

typedef Null EDCHRLInfoNewSecServingCellERGCHInfoReleaseIndicator;

class EDCHRLInfoNewSecServingCellERGCHInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum EDCHRLInfoNewSecServingCellERGCHInfoChoices {
		eRGCHInformation = 0,
		eDCHRLInfoNewSecServingCellERGCHInfoReleaseIndicator = 1,
	};
	static const Info theInfo;
	EDCHRLInfoNewSecServingCellERGCHInfo(): Choice(&theInfo) {}
};

class EDCHRLInfoNewSecServingCell : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	EDCHRLInfoNewSecServingCell(): Sequence(&theInfo) {}

	void setEAGCHInformation(const EAGCHInformation& eAGCHInformation) { *static_cast<EAGCHInformation*>(items[0]) = eAGCHInformation; }
	void setEHICHInformation(const EHICHInformation& eHICHInformation) { *static_cast<EHICHInformation*>(items[1]) = eHICHInformation; }
	void setEDCHRLInfoNewSecServingCellERGCHInfo(const EDCHRLInfoNewSecServingCellERGCHInfo& eDCHRLInfoNewSecServingCellERGCHInfo) { *static_cast<EDCHRLInfoNewSecServingCellERGCHInfo*>(items[2]) = eDCHRLInfoNewSecServingCellERGCHInfo; }
};

typedef Null EDCHRLInfoOtherCellSecULFreqERGCHInfoReleaseIndicator;

class EDCHRLInfoOtherCellSecULFreqERGCHInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum EDCHRLInfoOtherCellSecULFreqERGCHInfoChoices {
		eRGCHInformation = 0,
		eDCHRLInfoOtherCellSecULFreqERGCHInfoReleaseIndicator = 1,
	};
	static const Info theInfo;
	EDCHRLInfoOtherCellSecULFreqERGCHInfo(): Choice(&theInfo) {}
};

class EDCHRLInfoOtherCellSecULFreq : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	EDCHRLInfoOtherCellSecULFreq(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setEHICHInformation(const EHICHInformation& eHICHInformation) { *static_cast<EHICHInformation*>(items[1]) = eHICHInformation; }
	void setEDCHRLInfoOtherCellSecULFreqERGCHInfo(const EDCHRLInfoOtherCellSecULFreqERGCHInfo& eDCHRLInfoOtherCellSecULFreqERGCHInfo) { *static_cast<EDCHRLInfoOtherCellSecULFreqERGCHInfo*>(items[2]) = eDCHRLInfoOtherCellSecULFreqERGCHInfo; }
};

typedef SequenceOf<EDCHRLInfoOtherCellSecULFreq, CONSTRAINED, 1, maxEDCHRL> EDCHReconfigurationInfoSecULFrequencyEDCHRLInfoOtherCellListSecULFreq;

class EDCHReconfigurationInfoSecULFrequency : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EDCHReconfigurationInfoSecULFrequency(): Sequence(&theInfo) {}

	void setEDCHRLInfoNewSecServingCell(const EDCHRLInfoNewSecServingCell& eDCHRLInfoNewSecServingCell) { *static_cast<EDCHRLInfoNewSecServingCell*>(items[0]) = eDCHRLInfoNewSecServingCell; }
	void setEDCHReconfigurationInfoSecULFrequencyEDCHRLInfoOtherCellListSecULFreq(const EDCHReconfigurationInfoSecULFrequencyEDCHRLInfoOtherCellListSecULFreq& eDCHReconfigurationInfoSecULFrequencyEDCHRLInfoOtherCellListSecULFreq) { *static_cast<EDCHReconfigurationInfoSecULFrequencyEDCHRLInfoOtherCellListSecULFreq*>(items[1]) = eDCHReconfigurationInfoSecULFrequencyEDCHRLInfoOtherCellListSecULFreq; }
};

class EDCHRLInfoSameServingCell : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EDCHRLInfoSameServingCell(): Sequence(&theInfo) {}

	void setEDPCCHDPCCHPowerOffset(const EDPCCHDPCCHPowerOffset& eDPCCHDPCCHPowerOffset) { *static_cast<EDPCCHDPCCHPowerOffset*>(items[0]) = eDPCCHDPCCHPowerOffset; }
	void setReferenceETFCIs(const EDPDCHReferenceETFCIListr7& referenceETFCIs) { *static_cast<EDPDCHReferenceETFCIListr7*>(items[1]) = referenceETFCIs; }
};

typedef Null EDCHSPSInformationTDD128EdchSPSOperationContinue;

typedef Integer<CONSTRAINED, 0, 3> EHICHInformationForSPSTDD128ConfigurationmodeImplicitEi;

class EHICHInformationForSPSTDD128ConfigurationmodeImplicit : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	EHICHInformationForSPSTDD128ConfigurationmodeImplicit(): Sequence(&theInfo) {}

	void setEHICHInformationForSPSTDD128ConfigurationmodeImplicitEi(const EHICHInformationForSPSTDD128ConfigurationmodeImplicitEi& eHICHInformationForSPSTDD128ConfigurationmodeImplicitEi) { *static_cast<EHICHInformationForSPSTDD128ConfigurationmodeImplicitEi*>(items[0]) = eHICHInformationForSPSTDD128ConfigurationmodeImplicitEi; }
};

typedef Null EHICHInformationForSPSTDD128ConfigurationmodeExplicitMidambleAllocationModeDefaultMidamble;

typedef Integer<CONSTRAINED, 0, 15> EHICHInformationForSPSTDD128ConfigurationmodeExplicitMidambleAllocationModeUeSpecificMidamble;

class EHICHInformationForSPSTDD128ConfigurationmodeExplicitMidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum EHICHInformationForSPSTDD128ConfigurationmodeExplicitMidambleAllocationModeChoices {
		eHICHInformationForSPSTDD128ConfigurationmodeExplicitMidambleAllocationModeDefaultMidamble = 0,
		eHICHInformationForSPSTDD128ConfigurationmodeExplicitMidambleAllocationModeUeSpecificMidamble = 1,
	};
	static const Info theInfo;
	EHICHInformationForSPSTDD128ConfigurationmodeExplicitMidambleAllocationMode(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, 8> EHICHInformationForSPSTDD128ConfigurationmodeExplicitMidambleConfiguration;

class EHICHInformationForSPSTDD128ConfigurationmodeExplicit : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	EHICHInformationForSPSTDD128ConfigurationmodeExplicit(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumberLCRr4& timeslotNumber) { *static_cast<TimeslotNumberLCRr4*>(items[0]) = timeslotNumber; }
	void setChannelisationCode(const HSChannelisationCodeLCR& channelisationCode) { *static_cast<HSChannelisationCodeLCR*>(items[1]) = channelisationCode; }
	void setEHICHInformationForSPSTDD128ConfigurationmodeExplicitMidambleAllocationMode(const EHICHInformationForSPSTDD128ConfigurationmodeExplicitMidambleAllocationMode& eHICHInformationForSPSTDD128ConfigurationmodeExplicitMidambleAllocationMode) { *static_cast<EHICHInformationForSPSTDD128ConfigurationmodeExplicitMidambleAllocationMode*>(items[2]) = eHICHInformationForSPSTDD128ConfigurationmodeExplicitMidambleAllocationMode; }
	void setEHICHInformationForSPSTDD128ConfigurationmodeExplicitMidambleConfiguration(const EHICHInformationForSPSTDD128ConfigurationmodeExplicitMidambleConfiguration& eHICHInformationForSPSTDD128ConfigurationmodeExplicitMidambleConfiguration) { *static_cast<EHICHInformationForSPSTDD128ConfigurationmodeExplicitMidambleConfiguration*>(items[3]) = eHICHInformationForSPSTDD128ConfigurationmodeExplicitMidambleConfiguration; }
};

class EHICHInformationForSPSTDD128Configurationmode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum EHICHInformationForSPSTDD128ConfigurationmodeChoices {
		eHICHInformationForSPSTDD128ConfigurationmodeImplicit = 0,
		eHICHInformationForSPSTDD128ConfigurationmodeExplicit = 1,
	};
	static const Info theInfo;
	EHICHInformationForSPSTDD128Configurationmode(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 19> EHICHInformationForSPSTDD128SignatureSequenceGroupIndex;

class EHICHInformationForSPSTDD128 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EHICHInformationForSPSTDD128(): Sequence(&theInfo) {}

	void setEHICHInformationForSPSTDD128Configurationmode(const EHICHInformationForSPSTDD128Configurationmode& eHICHInformationForSPSTDD128Configurationmode) { *static_cast<EHICHInformationForSPSTDD128Configurationmode*>(items[0]) = eHICHInformationForSPSTDD128Configurationmode; }
	void setEHICHInformationForSPSTDD128SignatureSequenceGroupIndex(const EHICHInformationForSPSTDD128SignatureSequenceGroupIndex& eHICHInformationForSPSTDD128SignatureSequenceGroupIndex) { *static_cast<EHICHInformationForSPSTDD128SignatureSequenceGroupIndex*>(items[1]) = eHICHInformationForSPSTDD128SignatureSequenceGroupIndex; }
};

class EDCHTxPatternListTDD128 : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	EDCHTxPatternListTDD128(): Sequence(&theInfo) {}

};

typedef Integer<CONSTRAINED, 1, 8> EDCHSPSNewOperationTDD128InitialSPSInfoForEDCHNEUCCH;

typedef BitString<CONSTRAINED, 5, 5> EDCHSPSNewOperationTDD128InitialSPSInfoForEDCHTimeslotResourceRelatedInfo;

typedef Integer<CONSTRAINED, 1, 32> EDCHSPSNewOperationTDD128InitialSPSInfoForEDCHPowerResourceRelatedInfo;

typedef Integer<CONSTRAINED, 0, 1> EDCHSPSNewOperationTDD128InitialSPSInfoForEDCHSubframeNum;

typedef Integer<CONSTRAINED, 0, maxEDCHTxPattern_TDD128_1> EDCHSPSNewOperationTDD128InitialSPSInfoForEDCHInitialTxPatternIndex;

class EDCHSPSNewOperationTDD128InitialSPSInfoForEDCH : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	EDCHSPSNewOperationTDD128InitialSPSInfoForEDCH(): Sequence(&theInfo) {}

	void setEDCHSPSNewOperationTDD128InitialSPSInfoForEDCHNEUCCH(const EDCHSPSNewOperationTDD128InitialSPSInfoForEDCHNEUCCH& eDCHSPSNewOperationTDD128InitialSPSInfoForEDCHNEUCCH) { *static_cast<EDCHSPSNewOperationTDD128InitialSPSInfoForEDCHNEUCCH*>(items[0]) = eDCHSPSNewOperationTDD128InitialSPSInfoForEDCHNEUCCH; }
	void setCodeResourceInfo(const ULTSChannelisationCode& codeResourceInfo) { *static_cast<ULTSChannelisationCode*>(items[1]) = codeResourceInfo; }
	void setEDCHSPSNewOperationTDD128InitialSPSInfoForEDCHTimeslotResourceRelatedInfo(const EDCHSPSNewOperationTDD128InitialSPSInfoForEDCHTimeslotResourceRelatedInfo& eDCHSPSNewOperationTDD128InitialSPSInfoForEDCHTimeslotResourceRelatedInfo) { *static_cast<EDCHSPSNewOperationTDD128InitialSPSInfoForEDCHTimeslotResourceRelatedInfo*>(items[2]) = eDCHSPSNewOperationTDD128InitialSPSInfoForEDCHTimeslotResourceRelatedInfo; }
	void setEDCHSPSNewOperationTDD128InitialSPSInfoForEDCHPowerResourceRelatedInfo(const EDCHSPSNewOperationTDD128InitialSPSInfoForEDCHPowerResourceRelatedInfo& eDCHSPSNewOperationTDD128InitialSPSInfoForEDCHPowerResourceRelatedInfo) { *static_cast<EDCHSPSNewOperationTDD128InitialSPSInfoForEDCHPowerResourceRelatedInfo*>(items[3]) = eDCHSPSNewOperationTDD128InitialSPSInfoForEDCHPowerResourceRelatedInfo; }
	void setActivationTime(const ActivationTime& activationTime) { *static_cast<ActivationTime*>(items[4]) = activationTime; }
	void setEDCHSPSNewOperationTDD128InitialSPSInfoForEDCHSubframeNum(const EDCHSPSNewOperationTDD128InitialSPSInfoForEDCHSubframeNum& eDCHSPSNewOperationTDD128InitialSPSInfoForEDCHSubframeNum) { *static_cast<EDCHSPSNewOperationTDD128InitialSPSInfoForEDCHSubframeNum*>(items[5]) = eDCHSPSNewOperationTDD128InitialSPSInfoForEDCHSubframeNum; }
	void setEDCHSPSNewOperationTDD128InitialSPSInfoForEDCHInitialTxPatternIndex(const EDCHSPSNewOperationTDD128InitialSPSInfoForEDCHInitialTxPatternIndex& eDCHSPSNewOperationTDD128InitialSPSInfoForEDCHInitialTxPatternIndex) { *static_cast<EDCHSPSNewOperationTDD128InitialSPSInfoForEDCHInitialTxPatternIndex*>(items[6]) = eDCHSPSNewOperationTDD128InitialSPSInfoForEDCHInitialTxPatternIndex; }
};

class EDCHSPSNewOperationTDD128 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	EDCHSPSNewOperationTDD128(): Sequence(&theInfo) {}

	void setEhichInfo(const EHICHInformationForSPSTDD128& ehichInfo) { *static_cast<EHICHInformationForSPSTDD128*>(items[0]) = ehichInfo; }
	void setEdchTxPattern(const EDCHTxPatternListTDD128& edchTxPattern) { *static_cast<EDCHTxPatternListTDD128*>(items[1]) = edchTxPattern; }
	void setEDCHSPSNewOperationTDD128InitialSPSInfoForEDCH(const EDCHSPSNewOperationTDD128InitialSPSInfoForEDCH& eDCHSPSNewOperationTDD128InitialSPSInfoForEDCH) { *static_cast<EDCHSPSNewOperationTDD128InitialSPSInfoForEDCH*>(items[2]) = eDCHSPSNewOperationTDD128InitialSPSInfoForEDCH; }
};

class EDCHSPSInformationTDD128EdchSPSOperation : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum EDCHSPSInformationTDD128EdchSPSOperationChoices {
		eDCHSPSInformationTDD128EdchSPSOperationContinue = 0,
		newOperation = 1,
	};
	static const Info theInfo;
	EDCHSPSInformationTDD128EdchSPSOperation(): Choice(&theInfo) {}
};

class EDCHSPSInformationTDD128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	EDCHSPSInformationTDD128(): Sequence(&theInfo) {}

	void setEDCHSPSInformationTDD128EdchSPSOperation(const EDCHSPSInformationTDD128EdchSPSOperation& eDCHSPSInformationTDD128EdchSPSOperation) { *static_cast<EDCHSPSInformationTDD128EdchSPSOperation*>(items[0]) = eDCHSPSInformationTDD128EdchSPSOperation; }
};

class EDPCCHInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EDPCCHInfo(): Sequence(&theInfo) {}

	void setEDPCCHDPCCHPowerOffset(const EDPCCHDPCCHPowerOffset& eDPCCHDPCCHPowerOffset) { *static_cast<EDPCCHDPCCHPowerOffset*>(items[0]) = eDPCCHDPCCHPowerOffset; }
	void setHappyBitDelayCondition(const HappyBitDelayCondition& happyBitDelayCondition) { *static_cast<HappyBitDelayCondition*>(items[1]) = happyBitDelayCondition; }
};

typedef Integer<CONSTRAINED, 0, 37> EDPDCHInfoThreeIndexStepThreshold;

typedef Integer<CONSTRAINED, 0, 37> EDPDCHInfoTwoIndexStepThreshold;

class EDPDCHInfo : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	EDPDCHInfo(): Sequence(&theInfo) {}

	void setETFCITableIndex(const ETFCITableIndex& eTFCITableIndex) { *static_cast<ETFCITableIndex*>(items[0]) = eTFCITableIndex; }
	void setEDCHMinimumSetETFCI(const EDCHMinimumSetETFCI& eDCHMinimumSetETFCI) { *static_cast<EDCHMinimumSetETFCI*>(items[1]) = eDCHMinimumSetETFCI; }
	void setReferenceETFCIs(const EDPDCHReferenceETFCIList& referenceETFCIs) { *static_cast<EDPDCHReferenceETFCIList*>(items[2]) = referenceETFCIs; }
	void setMaxChannelisationCodes(const EDPDCHMaxChannelisationCodes& maxChannelisationCodes) { *static_cast<EDPDCHMaxChannelisationCodes*>(items[3]) = maxChannelisationCodes; }
	void setPlNonMax(const EDPDCHPLNonMax& plNonMax) { *static_cast<EDPDCHPLNonMax*>(items[4]) = plNonMax; }
	void setSchedulingInfoConfiguration(const EDPDCHSchedulingInfoConfiguration& schedulingInfoConfiguration) { *static_cast<EDPDCHSchedulingInfoConfiguration*>(items[5]) = schedulingInfoConfiguration; }
	void setEDPDCHInfoThreeIndexStepThreshold(const EDPDCHInfoThreeIndexStepThreshold& eDPDCHInfoThreeIndexStepThreshold) { *static_cast<EDPDCHInfoThreeIndexStepThreshold*>(items[6]) = eDPDCHInfoThreeIndexStepThreshold; }
	void setEDPDCHInfoTwoIndexStepThreshold(const EDPDCHInfoTwoIndexStepThreshold& eDPDCHInfoTwoIndexStepThreshold) { *static_cast<EDPDCHInfoTwoIndexStepThreshold*>(items[7]) = eDPDCHInfoTwoIndexStepThreshold; }
};

typedef Integer<CONSTRAINED, 0, 37> EDPDCHInfor7ThreeIndexStepThreshold;

typedef Integer<CONSTRAINED, 0, 37> EDPDCHInfor7TwoIndexStepThreshold;

class EDPDCHInfor7 : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	EDPDCHInfor7(): Sequence(&theInfo) {}

	void setETFCITableIndex(const ETFCITableIndex& eTFCITableIndex) { *static_cast<ETFCITableIndex*>(items[0]) = eTFCITableIndex; }
	void setEDCHMinimumSetETFCI(const EDCHMinimumSetETFCI& eDCHMinimumSetETFCI) { *static_cast<EDCHMinimumSetETFCI*>(items[1]) = eDCHMinimumSetETFCI; }
	void setReferenceETFCIs(const EDPDCHReferenceETFCIListr7& referenceETFCIs) { *static_cast<EDPDCHReferenceETFCIListr7*>(items[2]) = referenceETFCIs; }
	void setMaxChannelisationCodes(const EDPDCHMaxChannelisationCodes& maxChannelisationCodes) { *static_cast<EDPDCHMaxChannelisationCodes*>(items[3]) = maxChannelisationCodes; }
	void setPlNonMax(const EDPDCHPLNonMax& plNonMax) { *static_cast<EDPDCHPLNonMax*>(items[4]) = plNonMax; }
	void setSchedulingInfoConfiguration(const EDPDCHSchedulingInfoConfiguration& schedulingInfoConfiguration) { *static_cast<EDPDCHSchedulingInfoConfiguration*>(items[5]) = schedulingInfoConfiguration; }
	void setEDPDCHInfor7ThreeIndexStepThreshold(const EDPDCHInfor7ThreeIndexStepThreshold& eDPDCHInfor7ThreeIndexStepThreshold) { *static_cast<EDPDCHInfor7ThreeIndexStepThreshold*>(items[6]) = eDPDCHInfor7ThreeIndexStepThreshold; }
	void setEDPDCHInfor7TwoIndexStepThreshold(const EDPDCHInfor7TwoIndexStepThreshold& eDPDCHInfor7TwoIndexStepThreshold) { *static_cast<EDPDCHInfor7TwoIndexStepThreshold*>(items[7]) = eDPDCHInfor7TwoIndexStepThreshold; }
};

enum EnablingDelayValues {
	radio_frames_0_EnablingDelay = 0,
	radio_frames_1_EnablingDelay = 1,
	radio_frames_2_EnablingDelay = 2,
	radio_frames_4_EnablingDelay = 3,
	radio_frames_8_EnablingDelay = 4,
	radio_frames_16_EnablingDelay = 5,
	radio_frames_32_EnablingDelay = 6,
	radio_frames_64_EnablingDelay = 7,
	radio_frames_128_EnablingDelay = 8,
	spare7_EnablingDelay = 9,
	spare6_EnablingDelay = 10,
	spare5_EnablingDelay = 11,
	spare4_EnablingDelay = 12,
	spare3_EnablingDelay = 13,
	spare2_EnablingDelay = 14,
	spare1_EnablingDelay = 15,
};
typedef Enumerated<CONSTRAINED, 15> EnablingDelay;

typedef Integer<CONSTRAINED, 0, 255> EXTULTimingAdvanceModeSpecificInfoTdd384ExulTimingAdvance;

class EXTULTimingAdvanceModeSpecificInfoTdd384 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	EXTULTimingAdvanceModeSpecificInfoTdd384(): Sequence(&theInfo) {}

	void setEXTULTimingAdvanceModeSpecificInfoTdd384ExulTimingAdvance(const EXTULTimingAdvanceModeSpecificInfoTdd384ExulTimingAdvance& eXTULTimingAdvanceModeSpecificInfoTdd384ExulTimingAdvance) { *static_cast<EXTULTimingAdvanceModeSpecificInfoTdd384ExulTimingAdvance*>(items[0]) = eXTULTimingAdvanceModeSpecificInfoTdd384ExulTimingAdvance; }
};

typedef Integer<CONSTRAINED, 0, 511> EXTULTimingAdvanceModeSpecificInfoTdd768ExulTimingAdvance;

class EXTULTimingAdvanceModeSpecificInfoTdd768 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	EXTULTimingAdvanceModeSpecificInfoTdd768(): Sequence(&theInfo) {}

	void setEXTULTimingAdvanceModeSpecificInfoTdd768ExulTimingAdvance(const EXTULTimingAdvanceModeSpecificInfoTdd768ExulTimingAdvance& eXTULTimingAdvanceModeSpecificInfoTdd768ExulTimingAdvance) { *static_cast<EXTULTimingAdvanceModeSpecificInfoTdd768ExulTimingAdvance*>(items[0]) = eXTULTimingAdvanceModeSpecificInfoTdd768ExulTimingAdvance; }
};

class EXTULTimingAdvanceModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum EXTULTimingAdvanceModeSpecificInfoChoices {
		eXTULTimingAdvanceModeSpecificInfoTdd384 = 0,
		eXTULTimingAdvanceModeSpecificInfoTdd768 = 1,
	};
	static const Info theInfo;
	EXTULTimingAdvanceModeSpecificInfo(): Choice(&theInfo) {}
};

class EXTULTimingAdvance : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	EXTULTimingAdvance(): Sequence(&theInfo) {}

	void setEXTULTimingAdvanceModeSpecificInfo(const EXTULTimingAdvanceModeSpecificInfo& eXTULTimingAdvanceModeSpecificInfo) { *static_cast<EXTULTimingAdvanceModeSpecificInfo*>(items[0]) = eXTULTimingAdvanceModeSpecificInfo; }
};

class HSChannelisationCodeSetInfoLCR : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	HSChannelisationCodeSetInfoLCR(): Sequence(&theInfo) {}

	void setStartCode(const HSChannelisationCodeLCR& startCode) { *static_cast<HSChannelisationCodeLCR*>(items[0]) = startCode; }
	void setStopCode(const HSChannelisationCodeLCR& stopCode) { *static_cast<HSChannelisationCodeLCR*>(items[1]) = stopCode; }
};

typedef SequenceOf<HSSCCHCodes, CONSTRAINED, 1, maxHSSCCHs> HSSCCHSystemInfoHSSCCHChannelisationCodeInfo;

class HSSCCHSystemInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	HSSCCHSystemInfo(): Sequence(&theInfo) {}

	void setDlScramblingCode(const SecondaryScramblingCode& dlScramblingCode) { *static_cast<SecondaryScramblingCode*>(items[0]) = dlScramblingCode; }
	void setHSSCCHSystemInfoHSSCCHChannelisationCodeInfo(const HSSCCHSystemInfoHSSCCHChannelisationCodeInfo& hSSCCHSystemInfoHSSCCHChannelisationCodeInfo) { *static_cast<HSSCCHSystemInfoHSSCCHChannelisationCodeInfo*>(items[1]) = hSSCCHSystemInfoHSSCCHChannelisationCodeInfo; }
};

typedef SequenceOf<HRNTI, CONSTRAINED, 1, maxCommonHRNTI> HSDSCHCommonSystemInformationCommonHRNTIinformation;

class HSDSCHCommonSystemInformation : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	HSDSCHCommonSystemInformation(): Sequence(&theInfo) {}

	void setCcchMappingInfo(const CommonRBMappingInfo& ccchMappingInfo) { *static_cast<CommonRBMappingInfo*>(items[0]) = ccchMappingInfo; }
	void setSrb1MappingInfo(const CommonRBMappingInfo& srb1MappingInfo) { *static_cast<CommonRBMappingInfo*>(items[1]) = srb1MappingInfo; }
	void setCommonMACehsReorderingQueueList(const CommonMACehsReorderingQueueList& commonMACehsReorderingQueueList) { *static_cast<CommonMACehsReorderingQueueList*>(items[2]) = commonMACehsReorderingQueueList; }
	void setHsscchSystemInfo(const HSSCCHSystemInfo& hsscchSystemInfo) { *static_cast<HSSCCHSystemInfo*>(items[3]) = hsscchSystemInfo; }
	void setHarqSystemInfo(const HARQInfo& harqSystemInfo) { *static_cast<HARQInfo*>(items[4]) = harqSystemInfo; }
	void setHSDSCHCommonSystemInformationCommonHRNTIinformation(const HSDSCHCommonSystemInformationCommonHRNTIinformation& hSDSCHCommonSystemInformationCommonHRNTIinformation) { *static_cast<HSDSCHCommonSystemInformationCommonHRNTIinformation*>(items[5]) = hSDSCHCommonSystemInformationCommonHRNTIinformation; }
	void setBcchSpecificHRNTI(const HRNTI& bcchSpecificHRNTI) { *static_cast<HRNTI*>(items[6]) = bcchSpecificHRNTI; }
};

typedef SequenceOf<HSSCCHTDD128r6, CONSTRAINED, 1, maxHSSCCHs> HSSCCHSystemInfoTDD128HsSCCHSetConfiguration;

typedef Integer<CONSTRAINED, -120, -58> HSSCCHSystemInfoTDD128PowerlevelHSSICH;

typedef Integer<CONSTRAINED, -7, 8> HSSCCHSystemInfoTDD128Nackackpoweroffset;

enum HSSCCHSystemInfoTDD128tpc_step_sizeValues {
	s1_HSSCCHSystemInfoTDD128tpc_step_size = 0,
	s2_HSSCCHSystemInfoTDD128tpc_step_size = 1,
	s3_HSSCCHSystemInfoTDD128tpc_step_size = 2,
	spare1_HSSCCHSystemInfoTDD128tpc_step_size = 3,
};
typedef Enumerated<CONSTRAINED, 3> HSSCCHSystemInfoTDD128tpc_step_size;

typedef Integer<CONSTRAINED, 1, 255> HSSCCHSystemInfoTDD128Powercontrolgap;

typedef Boolean HSSCCHSystemInfoTDD128Pathlosscompensationswitch;

class HSSCCHSystemInfoTDD128 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	HSSCCHSystemInfoTDD128(): Sequence(&theInfo) {}

	void setHSSCCHSystemInfoTDD128HsSCCHSetConfiguration(const HSSCCHSystemInfoTDD128HsSCCHSetConfiguration& hSSCCHSystemInfoTDD128HsSCCHSetConfiguration) { *static_cast<HSSCCHSystemInfoTDD128HsSCCHSetConfiguration*>(items[0]) = hSSCCHSystemInfoTDD128HsSCCHSetConfiguration; }
	void setHSSCCHSystemInfoTDD128PowerlevelHSSICH(const HSSCCHSystemInfoTDD128PowerlevelHSSICH& hSSCCHSystemInfoTDD128PowerlevelHSSICH) { *static_cast<HSSCCHSystemInfoTDD128PowerlevelHSSICH*>(items[1]) = hSSCCHSystemInfoTDD128PowerlevelHSSICH; }
	void setHSSCCHSystemInfoTDD128Nackackpoweroffset(const HSSCCHSystemInfoTDD128Nackackpoweroffset& hSSCCHSystemInfoTDD128Nackackpoweroffset) { *static_cast<HSSCCHSystemInfoTDD128Nackackpoweroffset*>(items[2]) = hSSCCHSystemInfoTDD128Nackackpoweroffset; }
	void setHSSCCHSystemInfoTDD128tpc_step_size(const HSSCCHSystemInfoTDD128tpc_step_size& hSSCCHSystemInfoTDD128tpc_step_size) { *static_cast<HSSCCHSystemInfoTDD128tpc_step_size*>(items[3]) = hSSCCHSystemInfoTDD128tpc_step_size; }
	void setBlertarget(const BlerTarget& blertarget) { *static_cast<BlerTarget*>(items[4]) = blertarget; }
	void setHSSCCHSystemInfoTDD128Powercontrolgap(const HSSCCHSystemInfoTDD128Powercontrolgap& hSSCCHSystemInfoTDD128Powercontrolgap) { *static_cast<HSSCCHSystemInfoTDD128Powercontrolgap*>(items[5]) = hSSCCHSystemInfoTDD128Powercontrolgap; }
	void setHSSCCHSystemInfoTDD128Pathlosscompensationswitch(const HSSCCHSystemInfoTDD128Pathlosscompensationswitch& hSSCCHSystemInfoTDD128Pathlosscompensationswitch) { *static_cast<HSSCCHSystemInfoTDD128Pathlosscompensationswitch*>(items[6]) = hSSCCHSystemInfoTDD128Pathlosscompensationswitch; }
};

typedef SequenceOf<HRNTI, CONSTRAINED, 1, maxCommonHRNTI> HSDSCHCommonSystemInformationTDD128CommonHRNTIinformation;

class HSDSCHCommonSystemInformationTDD128 : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	HSDSCHCommonSystemInformationTDD128(): Sequence(&theInfo) {}

	void setCcchMappingInfo(const CommonRBMappingInfo& ccchMappingInfo) { *static_cast<CommonRBMappingInfo*>(items[0]) = ccchMappingInfo; }
	void setSrb1MappingInfo(const CommonRBMappingInfo& srb1MappingInfo) { *static_cast<CommonRBMappingInfo*>(items[1]) = srb1MappingInfo; }
	void setCommonMACehsReorderingQueueList(const CommonMACehsReorderingQueueList& commonMACehsReorderingQueueList) { *static_cast<CommonMACehsReorderingQueueList*>(items[2]) = commonMACehsReorderingQueueList; }
	void setHsscchSystemInfotdd128(const HSSCCHSystemInfoTDD128& hsscchSystemInfotdd128) { *static_cast<HSSCCHSystemInfoTDD128*>(items[3]) = hsscchSystemInfotdd128; }
	void setHarqSystemInfo(const HARQInfo& harqSystemInfo) { *static_cast<HARQInfo*>(items[4]) = harqSystemInfo; }
	void setHspdschMidambleConfiguration(const HSPDSCHMidambleConfigurationTDD128& hspdschMidambleConfiguration) { *static_cast<HSPDSCHMidambleConfigurationTDD128*>(items[5]) = hspdschMidambleConfiguration; }
	void setHSDSCHCommonSystemInformationTDD128CommonHRNTIinformation(const HSDSCHCommonSystemInformationTDD128CommonHRNTIinformation& hSDSCHCommonSystemInformationTDD128CommonHRNTIinformation) { *static_cast<HSDSCHCommonSystemInformationTDD128CommonHRNTIinformation*>(items[6]) = hSDSCHCommonSystemInformationTDD128CommonHRNTIinformation; }
	void setBcchSpecificHRNTI(const HRNTI& bcchSpecificHRNTI) { *static_cast<HRNTI*>(items[7]) = bcchSpecificHRNTI; }
};

enum HSDSCHDrxBurstFachValues {
	f1_HSDSCHDrxBurstFach = 0,
	f2_HSDSCHDrxBurstFach = 1,
	f4_HSDSCHDrxBurstFach = 2,
	f8_HSDSCHDrxBurstFach = 3,
	f16_HSDSCHDrxBurstFach = 4,
	spare3_HSDSCHDrxBurstFach = 5,
	spare2_HSDSCHDrxBurstFach = 6,
	spare1_HSDSCHDrxBurstFach = 7,
};
typedef Enumerated<CONSTRAINED, 7> HSDSCHDrxBurstFach;

enum HSDSCHDrxCycleFachValues {
	f4_HSDSCHDrxCycleFach = 0,
	f8_HSDSCHDrxCycleFach = 1,
	f16_HSDSCHDrxCycleFach = 2,
	f32_HSDSCHDrxCycleFach = 3,
};
typedef Enumerated<CONSTRAINED, 3> HSDSCHDrxCycleFach;

typedef Boolean HSDSCHDrxCellfachinfoDrxInterruptionhsdsch;

class HSDSCHDrxCellfachinfo : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	HSDSCHDrxCellfachinfo(): Sequence(&theInfo) {}

	void setT321(const T321& t321) { *static_cast<T321*>(items[0]) = t321; }
	void setHsdschDrxCycleFach(const HSDSCHDrxCycleFach& hsdschDrxCycleFach) { *static_cast<HSDSCHDrxCycleFach*>(items[1]) = hsdschDrxCycleFach; }
	void setHsdschDrxBurstFach(const HSDSCHDrxBurstFach& hsdschDrxBurstFach) { *static_cast<HSDSCHDrxBurstFach*>(items[2]) = hsdschDrxBurstFach; }
	void setHSDSCHDrxCellfachinfoDrxInterruptionhsdsch(const HSDSCHDrxCellfachinfoDrxInterruptionhsdsch& hSDSCHDrxCellfachinfoDrxInterruptionhsdsch) { *static_cast<HSDSCHDrxCellfachinfoDrxInterruptionhsdsch*>(items[3]) = hSDSCHDrxCellfachinfoDrxInterruptionhsdsch; }
};

class HSDSCHDrxCellfachinfoTDD128 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	HSDSCHDrxCellfachinfoTDD128(): Sequence(&theInfo) {}

	void setT321(const T321& t321) { *static_cast<T321*>(items[0]) = t321; }
	void setHsdschDrxCycleFach(const HSDSCHDrxCycleFach& hsdschDrxCycleFach) { *static_cast<HSDSCHDrxCycleFach*>(items[1]) = hsdschDrxCycleFach; }
	void setHsdschDrxBurstFach(const HSDSCHDrxBurstFach& hsdschDrxBurstFach) { *static_cast<HSDSCHDrxBurstFach*>(items[2]) = hsdschDrxBurstFach; }
};

enum PICountPerFrameValues {
	e18_PICountPerFrame = 0,
	e36_PICountPerFrame = 1,
	e72_PICountPerFrame = 2,
	e144_PICountPerFrame = 3,
};
typedef Enumerated<CONSTRAINED, 3> PICountPerFrame;

typedef Boolean PICHInfoFddSttdIndicator;

class PICHInfoFdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PICHInfoFdd(): Sequence(&theInfo) {}

	void setChannelisationCode256(const ChannelisationCode256& channelisationCode256) { *static_cast<ChannelisationCode256*>(items[0]) = channelisationCode256; }
	void setPiCountPerFrame(const PICountPerFrame& piCountPerFrame) { *static_cast<PICountPerFrame*>(items[1]) = piCountPerFrame; }
	void setPICHInfoFddSttdIndicator(const PICHInfoFddSttdIndicator& pICHInfoFddSttdIndicator) { *static_cast<PICHInfoFddSttdIndicator*>(items[2]) = pICHInfoFddSttdIndicator; }
};

enum TDDPICHCCodeValues {
	cc16_1_TDDPICHCCode = 0,
	cc16_2_TDDPICHCCode = 1,
	cc16_3_TDDPICHCCode = 2,
	cc16_4_TDDPICHCCode = 3,
	cc16_5_TDDPICHCCode = 4,
	cc16_6_TDDPICHCCode = 5,
	cc16_7_TDDPICHCCode = 6,
	cc16_8_TDDPICHCCode = 7,
	cc16_9_TDDPICHCCode = 8,
	cc16_10_TDDPICHCCode = 9,
	cc16_11_TDDPICHCCode = 10,
	cc16_12_TDDPICHCCode = 11,
	cc16_13_TDDPICHCCode = 12,
	cc16_14_TDDPICHCCode = 13,
	cc16_15_TDDPICHCCode = 14,
	cc16_16_TDDPICHCCode = 15,
};
typedef Enumerated<CONSTRAINED, 15> TDDPICHCCode;

typedef Integer<CONSTRAINED, 0, 3> RepPerLengthOffsetPICHRpp42;

typedef Integer<CONSTRAINED, 0, 7> RepPerLengthOffsetPICHRpp82;

typedef Integer<CONSTRAINED, 0, 7> RepPerLengthOffsetPICHRpp84;

typedef Integer<CONSTRAINED, 0, 15> RepPerLengthOffsetPICHRpp162;

typedef Integer<CONSTRAINED, 0, 15> RepPerLengthOffsetPICHRpp164;

typedef Integer<CONSTRAINED, 0, 31> RepPerLengthOffsetPICHRpp322;

typedef Integer<CONSTRAINED, 0, 31> RepPerLengthOffsetPICHRpp324;

typedef Integer<CONSTRAINED, 0, 63> RepPerLengthOffsetPICHRpp642;

typedef Integer<CONSTRAINED, 0, 63> RepPerLengthOffsetPICHRpp644;

class RepPerLengthOffsetPICH : public Choice {
private:
	static const void *choicesInfo[9];
public:
	enum RepPerLengthOffsetPICHChoices {
		repPerLengthOffsetPICHRpp42 = 0,
		repPerLengthOffsetPICHRpp82 = 1,
		repPerLengthOffsetPICHRpp84 = 2,
		repPerLengthOffsetPICHRpp162 = 3,
		repPerLengthOffsetPICHRpp164 = 4,
		repPerLengthOffsetPICHRpp322 = 5,
		repPerLengthOffsetPICHRpp324 = 6,
		repPerLengthOffsetPICHRpp642 = 7,
		repPerLengthOffsetPICHRpp644 = 8,
	};
	static const Info theInfo;
	RepPerLengthOffsetPICH(): Choice(&theInfo) {}
};

enum PagingIndicatorLengthValues {
	pi4_PagingIndicatorLength = 0,
	pi8_PagingIndicatorLength = 1,
	pi16_PagingIndicatorLength = 2,
};
typedef Enumerated<CONSTRAINED, 2> PagingIndicatorLength;

enum NGAPValues {
	f2_NGAP = 0,
	f4_NGAP = 1,
	f8_NGAP = 2,
};
typedef Enumerated<CONSTRAINED, 2> NGAP;

typedef Integer<CONSTRAINED, 1, 8> NPCH;

class PICHInfoTdd : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	PICHInfoTdd(): Sequence(&theInfo) {}

	void setChannelisationCode(const TDDPICHCCode& channelisationCode) { *static_cast<TDDPICHCCode*>(items[0]) = channelisationCode; }
	void setTimeslot(const TimeslotNumber& timeslot) { *static_cast<TimeslotNumber*>(items[1]) = timeslot; }
	void setMidambleShiftAndBurstType(const MidambleShiftAndBurstType& midambleShiftAndBurstType) { *static_cast<MidambleShiftAndBurstType*>(items[2]) = midambleShiftAndBurstType; }
	void setRepetitionPeriodLengthOffset(const RepPerLengthOffsetPICH& repetitionPeriodLengthOffset) { *static_cast<RepPerLengthOffsetPICH*>(items[3]) = repetitionPeriodLengthOffset; }
	void setPagingIndicatorLength(const PagingIndicatorLength& pagingIndicatorLength) { *static_cast<PagingIndicatorLength*>(items[4]) = pagingIndicatorLength; }
	void setNGAP(const NGAP& nGAP) { *static_cast<NGAP*>(items[5]) = nGAP; }
	void setNPCH(const NPCH& nPCH) { *static_cast<NPCH*>(items[6]) = nPCH; }
};

class PICHInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PICHInfoChoices {
		pICHInfoFdd = 0,
		pICHInfoTdd = 1,
	};
	static const Info theInfo;
	PICHInfo(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, 15> PICHForHSDPASupportedPagingHspdschChannelisationCode;

class PICHForHSDPASupportedPaging : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PICHForHSDPASupportedPaging(): Sequence(&theInfo) {}

	void setHsdpaAssociatedPichInfo(const PICHInfo& hsdpaAssociatedPichInfo) { *static_cast<PICHInfo*>(items[0]) = hsdpaAssociatedPichInfo; }
	void setPICHForHSDPASupportedPagingHspdschChannelisationCode(const PICHForHSDPASupportedPagingHspdschChannelisationCode& pICHForHSDPASupportedPagingHspdschChannelisationCode) { *static_cast<PICHForHSDPASupportedPagingHspdschChannelisationCode*>(items[1]) = pICHForHSDPASupportedPagingHspdschChannelisationCode; }
};

typedef SequenceOf<PICHForHSDPASupportedPaging, CONSTRAINED, 1, maxSCCPCH> HSDSCHPagingSystemInformationPichForHSDPASupportedPagingList;

typedef Integer<CONSTRAINED, 1, 5> HSDSCHPagingSystemInformationNumberOfPcchTransmissions;

typedef Integer<CONSTRAINED, 1, 32> TransportBlockSizeIndex;

typedef SequenceOf<TransportBlockSizeIndex, CONSTRAINED, 1, 2> HSDSCHPagingSystemInformationTransportBlockSizeList;

class HSDSCHPagingSystemInformation : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	HSDSCHPagingSystemInformation(): Sequence(&theInfo) {}

	void setDlScramblingCode(const SecondaryScramblingCode& dlScramblingCode) { *static_cast<SecondaryScramblingCode*>(items[0]) = dlScramblingCode; }
	void setHSDSCHPagingSystemInformationPichForHSDPASupportedPagingList(const HSDSCHPagingSystemInformationPichForHSDPASupportedPagingList& hSDSCHPagingSystemInformationPichForHSDPASupportedPagingList) { *static_cast<HSDSCHPagingSystemInformationPichForHSDPASupportedPagingList*>(items[1]) = hSDSCHPagingSystemInformationPichForHSDPASupportedPagingList; }
	void setHSDSCHPagingSystemInformationNumberOfPcchTransmissions(const HSDSCHPagingSystemInformationNumberOfPcchTransmissions& hSDSCHPagingSystemInformationNumberOfPcchTransmissions) { *static_cast<HSDSCHPagingSystemInformationNumberOfPcchTransmissions*>(items[2]) = hSDSCHPagingSystemInformationNumberOfPcchTransmissions; }
	void setHSDSCHPagingSystemInformationTransportBlockSizeList(const HSDSCHPagingSystemInformationTransportBlockSizeList& hSDSCHPagingSystemInformationTransportBlockSizeList) { *static_cast<HSDSCHPagingSystemInformationTransportBlockSizeList*>(items[3]) = hSDSCHPagingSystemInformationTransportBlockSizeList; }
};

class PICHForHSDPASupportedPagingTDD128Implicit : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PICHForHSDPASupportedPagingTDD128Implicit(): Sequence(&theInfo) {}

	void setOccurrenceSequenceNumberOfPICH(const OccurrenceSequenceNumberOfPICH& occurrenceSequenceNumberOfPICH) { *static_cast<OccurrenceSequenceNumberOfPICH*>(items[0]) = occurrenceSequenceNumberOfPICH; }
};

typedef SequenceOf<DLTSChannelisationCode, CONSTRAINED, 1, 2> PichChannelisationCodeListLCRr4;

class PICHInfoLCRr4 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	PICHInfoLCRr4(): Sequence(&theInfo) {}

	void setTimeslot(const TimeslotNumberLCRr4& timeslot) { *static_cast<TimeslotNumberLCRr4*>(items[0]) = timeslot; }
	void setPichChannelisationCodeListLCRr4(const PichChannelisationCodeListLCRr4& pichChannelisationCodeListLCRr4) { *static_cast<PichChannelisationCodeListLCRr4*>(items[1]) = pichChannelisationCodeListLCRr4; }
	void setMidambleShiftAndBurstType(const MidambleShiftAndBurstTypeLCRr4& midambleShiftAndBurstType) { *static_cast<MidambleShiftAndBurstTypeLCRr4*>(items[2]) = midambleShiftAndBurstType; }
	void setRepetitionPeriodLengthOffset(const RepPerLengthOffsetPICH& repetitionPeriodLengthOffset) { *static_cast<RepPerLengthOffsetPICH*>(items[3]) = repetitionPeriodLengthOffset; }
	void setPagingIndicatorLength(const PagingIndicatorLength& pagingIndicatorLength) { *static_cast<PagingIndicatorLength*>(items[4]) = pagingIndicatorLength; }
	void setNGAP(const NGAP& nGAP) { *static_cast<NGAP*>(items[5]) = nGAP; }
	void setNPCH(const NPCH& nPCH) { *static_cast<NPCH*>(items[6]) = nPCH; }
};

class PICHForHSDPASupportedPagingTDD128 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PICHForHSDPASupportedPagingTDD128Choices {
		pICHForHSDPASupportedPagingTDD128Implicit = 0,
		explicit = 1,
	};
	static const Info theInfo;
	PICHForHSDPASupportedPagingTDD128(): Choice(&theInfo) {}
};

typedef SequenceOf<PICHForHSDPASupportedPagingTDD128, CONSTRAINED, 1, maxSCCPCH> HSDSCHPagingSystemInformationTDD128PichForHsdschList;

typedef Integer<CONSTRAINED, 1, 16> HSDSCHPagingSystemInformationTDD128DtchDCCHreceptionwindowsize;

class PCCHInformationListPagingassociatedHspdschInfo : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	PCCHInformationListPagingassociatedHspdschInfo(): Sequence(&theInfo) {}

};

typedef Integer<CONSTRAINED, 1, 3> PCCHInformationListPagingsubChannelsize;

typedef SequenceOf<TransportBlockSizeIndex, CONSTRAINED, 1, 2> PCCHInformationListTransportBlockSizeList;

class PCCHInformationList : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PCCHInformationList(): Sequence(&theInfo) {}

	void setPCCHInformationListPagingassociatedHspdschInfo(const PCCHInformationListPagingassociatedHspdschInfo& pCCHInformationListPagingassociatedHspdschInfo) { *static_cast<PCCHInformationListPagingassociatedHspdschInfo*>(items[0]) = pCCHInformationListPagingassociatedHspdschInfo; }
	void setPCCHInformationListPagingsubChannelsize(const PCCHInformationListPagingsubChannelsize& pCCHInformationListPagingsubChannelsize) { *static_cast<PCCHInformationListPagingsubChannelsize*>(items[1]) = pCCHInformationListPagingsubChannelsize; }
	void setPCCHInformationListTransportBlockSizeList(const PCCHInformationListTransportBlockSizeList& pCCHInformationListTransportBlockSizeList) { *static_cast<PCCHInformationListTransportBlockSizeList*>(items[2]) = pCCHInformationListTransportBlockSizeList; }
};

class HSDSCHPagingSystemInformationTDD128 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	HSDSCHPagingSystemInformationTDD128(): Sequence(&theInfo) {}

	void setHSDSCHPagingSystemInformationTDD128PichForHsdschList(const HSDSCHPagingSystemInformationTDD128PichForHsdschList& hSDSCHPagingSystemInformationTDD128PichForHsdschList) { *static_cast<HSDSCHPagingSystemInformationTDD128PichForHsdschList*>(items[0]) = hSDSCHPagingSystemInformationTDD128PichForHsdschList; }
	void setHSDSCHPagingSystemInformationTDD128DtchDCCHreceptionwindowsize(const HSDSCHPagingSystemInformationTDD128DtchDCCHreceptionwindowsize& hSDSCHPagingSystemInformationTDD128DtchDCCHreceptionwindowsize) { *static_cast<HSDSCHPagingSystemInformationTDD128DtchDCCHreceptionwindowsize*>(items[1]) = hSDSCHPagingSystemInformationTDD128DtchDCCHreceptionwindowsize; }
	void setPcchInformationList(const PCCHInformationList& pcchInformationList) { *static_cast<PCCHInformationList*>(items[2]) = pcchInformationList; }
};

class HSDSCHRxPatternListTDD128 : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	HSDSCHRxPatternListTDD128(): Sequence(&theInfo) {}

};

class HSDSCHTbsListTDD128 : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	HSDSCHTbsListTDD128(): Sequence(&theInfo) {}

};

typedef Null HSDSCHSPSInformationTDD128HsdschSPSOperationContinue;

typedef Integer<CONSTRAINED, 1, 8> HSDSCHSPSNewOperationTDD128HARQInfoForSPSNumberOfProcesses;

class HSDSCHSPSNewOperationTDD128HARQInfoForSPS : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	HSDSCHSPSNewOperationTDD128HARQInfoForSPS(): Sequence(&theInfo) {}

	void setHSDSCHSPSNewOperationTDD128HARQInfoForSPSNumberOfProcesses(const HSDSCHSPSNewOperationTDD128HARQInfoForSPSNumberOfProcesses& hSDSCHSPSNewOperationTDD128HARQInfoForSPSNumberOfProcesses) { *static_cast<HSDSCHSPSNewOperationTDD128HARQInfoForSPSNumberOfProcesses*>(items[0]) = hSDSCHSPSNewOperationTDD128HARQInfoForSPSNumberOfProcesses; }
	void setMemorySize(const HARQMemorySize& memorySize) { *static_cast<HARQMemorySize*>(items[1]) = memorySize; }
};

class HSSICHListTDD128 : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	HSSICHListTDD128(): Sequence(&theInfo) {}

};

typedef BitString<CONSTRAINED, 5, 5> HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHTimeslotInfo;

typedef Integer<CONSTRAINED, 0, 1> HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHSfnNum;

typedef Integer<CONSTRAINED, 0, maxRxPatternForHSDSCH_TDD128_1> HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHInitialRxPatternIndex;

typedef Integer<CONSTRAINED, 0, maxTbsForHSDSCH_TDD128_1> HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHInitialTfsIndex;

enum HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHmodulationValues {
	modQPSK_HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHmodulation = 0,
	mod16QAM_HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHmodulation = 1,
};
typedef Enumerated<CONSTRAINED, 1> HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHmodulation;

typedef Integer<CONSTRAINED, 0, maxHSSICH_TDD128_1> HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHHssichIndex;

class HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCH : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCH(): Sequence(&theInfo) {}

	void setHSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHTimeslotInfo(const HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHTimeslotInfo& hSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHTimeslotInfo) { *static_cast<HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHTimeslotInfo*>(items[0]) = hSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHTimeslotInfo; }
	void setCodeResourceInfo(const HSChannelisationCodeSetInfoLCR& codeResourceInfo) { *static_cast<HSChannelisationCodeSetInfoLCR*>(items[1]) = codeResourceInfo; }
	void setActivationTime(const ActivationTime& activationTime) { *static_cast<ActivationTime*>(items[2]) = activationTime; }
	void setHSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHSfnNum(const HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHSfnNum& hSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHSfnNum) { *static_cast<HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHSfnNum*>(items[3]) = hSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHSfnNum; }
	void setHSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHInitialRxPatternIndex(const HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHInitialRxPatternIndex& hSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHInitialRxPatternIndex) { *static_cast<HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHInitialRxPatternIndex*>(items[4]) = hSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHInitialRxPatternIndex; }
	void setHSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHInitialTfsIndex(const HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHInitialTfsIndex& hSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHInitialTfsIndex) { *static_cast<HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHInitialTfsIndex*>(items[5]) = hSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHInitialTfsIndex; }
	void setHSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHmodulation(const HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHmodulation& hSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHmodulation) { *static_cast<HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHmodulation*>(items[6]) = hSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHmodulation; }
	void setHSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHHssichIndex(const HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHHssichIndex& hSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHHssichIndex) { *static_cast<HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHHssichIndex*>(items[7]) = hSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCHHssichIndex; }
};

class HSDSCHSPSNewOperationTDD128 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	HSDSCHSPSNewOperationTDD128(): Sequence(&theInfo) {}

	void setHsdschTbsList(const HSDSCHTbsListTDD128& hsdschTbsList) { *static_cast<HSDSCHTbsListTDD128*>(items[0]) = hsdschTbsList; }
	void setHsdschRxPatternList(const HSDSCHRxPatternListTDD128& hsdschRxPatternList) { *static_cast<HSDSCHRxPatternListTDD128*>(items[1]) = hsdschRxPatternList; }
	void setHSDSCHSPSNewOperationTDD128HARQInfoForSPS(const HSDSCHSPSNewOperationTDD128HARQInfoForSPS& hSDSCHSPSNewOperationTDD128HARQInfoForSPS) { *static_cast<HSDSCHSPSNewOperationTDD128HARQInfoForSPS*>(items[2]) = hSDSCHSPSNewOperationTDD128HARQInfoForSPS; }
	void setHssichList(const HSSICHListTDD128& hssichList) { *static_cast<HSSICHListTDD128*>(items[3]) = hssichList; }
	void setHSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCH(const HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCH& hSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCH) { *static_cast<HSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCH*>(items[4]) = hSDSCHSPSNewOperationTDD128InitialSPSInfoForHSDSCH; }
};

class HSDSCHSPSInformationTDD128HsdschSPSOperation : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum HSDSCHSPSInformationTDD128HsdschSPSOperationChoices {
		hSDSCHSPSInformationTDD128HsdschSPSOperationContinue = 0,
		newOperation = 1,
	};
	static const Info theInfo;
	HSDSCHSPSInformationTDD128HsdschSPSOperation(): Choice(&theInfo) {}
};

class HSDSCHSPSInformationTDD128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	HSDSCHSPSInformationTDD128(): Sequence(&theInfo) {}

	void setHSDSCHSPSInformationTDD128HsdschSPSOperation(const HSDSCHSPSInformationTDD128HsdschSPSOperation& hSDSCHSPSInformationTDD128HsdschSPSOperation) { *static_cast<HSDSCHSPSInformationTDD128HsdschSPSOperation*>(items[0]) = hSDSCHSPSInformationTDD128HsdschSPSOperation; }
};

typedef Integer<CONSTRAINED, 1, 15> HSSCCHLessNewOperationHspdschCodeIndex;

class HSSCCHLessTFSList : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	HSSCCHLessTFSList(): Sequence(&theInfo) {}

};

class HSSCCHLessNewOperation : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	HSSCCHLessNewOperation(): Sequence(&theInfo) {}

	void setHSSCCHLessNewOperationHspdschCodeIndex(const HSSCCHLessNewOperationHspdschCodeIndex& hSSCCHLessNewOperationHspdschCodeIndex) { *static_cast<HSSCCHLessNewOperationHspdschCodeIndex*>(items[0]) = hSSCCHLessNewOperationHspdschCodeIndex; }
	void setHsscchLessTFS(const HSSCCHLessTFSList& hsscchLessTFS) { *static_cast<HSSCCHLessTFSList*>(items[1]) = hsscchLessTFS; }
};

typedef Null HSSCCHLessInfor7HsscchLessOperationContinue;

class HSSCCHLessInfor7HsscchLessOperation : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum HSSCCHLessInfor7HsscchLessOperationChoices {
		hSSCCHLessInfor7HsscchLessOperationContinue = 0,
		newOperation = 1,
	};
	static const Info theInfo;
	HSSCCHLessInfor7HsscchLessOperation(): Choice(&theInfo) {}
};

class HSSCCHLessInfor7 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	HSSCCHLessInfor7(): Sequence(&theInfo) {}

	void setHSSCCHLessInfor7HsscchLessOperation(const HSSCCHLessInfor7HsscchLessOperation& hSSCCHLessInfor7HsscchLessOperation) { *static_cast<HSSCCHLessInfor7HsscchLessOperation*>(items[0]) = hSSCCHLessInfor7HsscchLessOperation; }
};

typedef Null HSSCCHTDD128MultiCarrierMidambleAllocationModeDefaultMidamble;

typedef Null HSSCCHTDD128MultiCarrierMidambleAllocationModeCommonMidamble;

typedef Integer<CONSTRAINED, 0, 15> HSSCCHTDD128MultiCarrierMidambleAllocationModeUeSpecificMidamble;

class HSSCCHTDD128MultiCarrierMidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum HSSCCHTDD128MultiCarrierMidambleAllocationModeChoices {
		hSSCCHTDD128MultiCarrierMidambleAllocationModeDefaultMidamble = 0,
		hSSCCHTDD128MultiCarrierMidambleAllocationModeCommonMidamble = 1,
		hSSCCHTDD128MultiCarrierMidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	HSSCCHTDD128MultiCarrierMidambleAllocationMode(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, 8> HSSCCHTDD128MultiCarrierMidambleConfiguration;

class HSSCCHTDD128MultiCarrier : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	HSSCCHTDD128MultiCarrier(): Sequence(&theInfo) {}

	void setUarfcnHSSCCHRx(const UARFCN& uarfcnHSSCCHRx) { *static_cast<UARFCN*>(items[0]) = uarfcnHSSCCHRx; }
	void setTimeslotNumber(const TimeslotNumberLCRr4& timeslotNumber) { *static_cast<TimeslotNumberLCRr4*>(items[1]) = timeslotNumber; }
	void setFirstChannelisationCode(const HSChannelisationCodeLCR& firstChannelisationCode) { *static_cast<HSChannelisationCodeLCR*>(items[2]) = firstChannelisationCode; }
	void setSecondChannelisationCode(const HSChannelisationCodeLCR& secondChannelisationCode) { *static_cast<HSChannelisationCodeLCR*>(items[3]) = secondChannelisationCode; }
	void setHSSCCHTDD128MultiCarrierMidambleAllocationMode(const HSSCCHTDD128MultiCarrierMidambleAllocationMode& hSSCCHTDD128MultiCarrierMidambleAllocationMode) { *static_cast<HSSCCHTDD128MultiCarrierMidambleAllocationMode*>(items[4]) = hSSCCHTDD128MultiCarrierMidambleAllocationMode; }
	void setHSSCCHTDD128MultiCarrierMidambleConfiguration(const HSSCCHTDD128MultiCarrierMidambleConfiguration& hSSCCHTDD128MultiCarrierMidambleConfiguration) { *static_cast<HSSCCHTDD128MultiCarrierMidambleConfiguration*>(items[5]) = hSSCCHTDD128MultiCarrierMidambleConfiguration; }
	void setBlertarget(const BlerTarget& blertarget) { *static_cast<BlerTarget*>(items[6]) = blertarget; }
	void setHssichconfiguration(const HSSICHConfigurationTDD128& hssichconfiguration) { *static_cast<HSSICHConfigurationTDD128*>(items[7]) = hssichconfiguration; }
};

class HSSICHReferenceSignalInfoList : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	HSSICHReferenceSignalInfoList(): Sequence(&theInfo) {}

};

enum IndividualTimeslotInfoLCRr4extmodulationValues {
	mod_QPSK_IndividualTimeslotInfoLCRr4extmodulation = 0,
	mod_8PSK_IndividualTimeslotInfoLCRr4extmodulation = 1,
};
typedef Enumerated<CONSTRAINED, 1> IndividualTimeslotInfoLCRr4extmodulation;

enum IndividualTimeslotInfoLCRr4extss_TPC_SymbolsValues {
	zero_IndividualTimeslotInfoLCRr4extss_TPC_Symbols = 0,
	one_IndividualTimeslotInfoLCRr4extss_TPC_Symbols = 1,
	sixteenOverSF_IndividualTimeslotInfoLCRr4extss_TPC_Symbols = 2,
};
typedef Enumerated<CONSTRAINED, 2> IndividualTimeslotInfoLCRr4extss_TPC_Symbols;

class IndividualTimeslotInfoLCRr4ext : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	IndividualTimeslotInfoLCRr4ext(): Sequence(&theInfo) {}

	void setMidambleShiftAndBurstType(const MidambleShiftAndBurstTypeLCRr4& midambleShiftAndBurstType) { *static_cast<MidambleShiftAndBurstTypeLCRr4*>(items[0]) = midambleShiftAndBurstType; }
	void setIndividualTimeslotInfoLCRr4extmodulation(const IndividualTimeslotInfoLCRr4extmodulation& individualTimeslotInfoLCRr4extmodulation) { *static_cast<IndividualTimeslotInfoLCRr4extmodulation*>(items[1]) = individualTimeslotInfoLCRr4extmodulation; }
	void setIndividualTimeslotInfoLCRr4extss_TPC_Symbols(const IndividualTimeslotInfoLCRr4extss_TPC_Symbols& individualTimeslotInfoLCRr4extss_TPC_Symbols) { *static_cast<IndividualTimeslotInfoLCRr4extss_TPC_Symbols*>(items[2]) = individualTimeslotInfoLCRr4extss_TPC_Symbols; }
};

typedef Integer<CONSTRAINED, 0, 3> MaxPowerIncreaser4;

typedef Null MidambleShiftAndBurstTypeDLBurstTypeType1MidambleAllocationModeDefaultMidamble;

typedef Null MidambleShiftAndBurstTypeDLBurstTypeType1MidambleAllocationModeCommonMidamble;

class MidambleShiftAndBurstTypeDLBurstTypeType1MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeDLBurstTypeType1MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftLong& midambleShift) { *static_cast<MidambleShiftLong*>(items[0]) = midambleShift; }
};

class MidambleShiftAndBurstTypeDLBurstTypeType1MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MidambleShiftAndBurstTypeDLBurstTypeType1MidambleAllocationModeChoices {
		midambleShiftAndBurstTypeDLBurstTypeType1MidambleAllocationModeDefaultMidamble = 0,
		midambleShiftAndBurstTypeDLBurstTypeType1MidambleAllocationModeCommonMidamble = 1,
		midambleShiftAndBurstTypeDLBurstTypeType1MidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTypeDLBurstTypeType1MidambleAllocationMode(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstTypeDLBurstTypeType1 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeDLBurstTypeType1(): Sequence(&theInfo) {}

	void setMidambleConfigurationBurstType1and3(const MidambleConfigurationBurstType1and3& midambleConfigurationBurstType1and3) { *static_cast<MidambleConfigurationBurstType1and3*>(items[0]) = midambleConfigurationBurstType1and3; }
	void setMidambleShiftAndBurstTypeDLBurstTypeType1MidambleAllocationMode(const MidambleShiftAndBurstTypeDLBurstTypeType1MidambleAllocationMode& midambleShiftAndBurstTypeDLBurstTypeType1MidambleAllocationMode) { *static_cast<MidambleShiftAndBurstTypeDLBurstTypeType1MidambleAllocationMode*>(items[1]) = midambleShiftAndBurstTypeDLBurstTypeType1MidambleAllocationMode; }
};

typedef Null MidambleShiftAndBurstTypeDLBurstTypeType2MidambleAllocationModeDefaultMidamble;

typedef Null MidambleShiftAndBurstTypeDLBurstTypeType2MidambleAllocationModeCommonMidamble;

class MidambleShiftAndBurstTypeDLBurstTypeType2MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeDLBurstTypeType2MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftShort& midambleShift) { *static_cast<MidambleShiftShort*>(items[0]) = midambleShift; }
};

class MidambleShiftAndBurstTypeDLBurstTypeType2MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MidambleShiftAndBurstTypeDLBurstTypeType2MidambleAllocationModeChoices {
		midambleShiftAndBurstTypeDLBurstTypeType2MidambleAllocationModeDefaultMidamble = 0,
		midambleShiftAndBurstTypeDLBurstTypeType2MidambleAllocationModeCommonMidamble = 1,
		midambleShiftAndBurstTypeDLBurstTypeType2MidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTypeDLBurstTypeType2MidambleAllocationMode(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstTypeDLBurstTypeType2 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeDLBurstTypeType2(): Sequence(&theInfo) {}

	void setMidambleConfigurationBurstType2(const MidambleConfigurationBurstType2& midambleConfigurationBurstType2) { *static_cast<MidambleConfigurationBurstType2*>(items[0]) = midambleConfigurationBurstType2; }
	void setMidambleShiftAndBurstTypeDLBurstTypeType2MidambleAllocationMode(const MidambleShiftAndBurstTypeDLBurstTypeType2MidambleAllocationMode& midambleShiftAndBurstTypeDLBurstTypeType2MidambleAllocationMode) { *static_cast<MidambleShiftAndBurstTypeDLBurstTypeType2MidambleAllocationMode*>(items[1]) = midambleShiftAndBurstTypeDLBurstTypeType2MidambleAllocationMode; }
};

class MidambleShiftAndBurstTypeDLBurstType : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MidambleShiftAndBurstTypeDLBurstTypeChoices {
		midambleShiftAndBurstTypeDLBurstTypeType1 = 0,
		midambleShiftAndBurstTypeDLBurstTypeType2 = 1,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTypeDLBurstType(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstTypeDL : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeDL(): Sequence(&theInfo) {}

	void setMidambleShiftAndBurstTypeDLBurstType(const MidambleShiftAndBurstTypeDLBurstType& midambleShiftAndBurstTypeDLBurstType) { *static_cast<MidambleShiftAndBurstTypeDLBurstType*>(items[0]) = midambleShiftAndBurstTypeDLBurstType; }
};

typedef Null MidambleShiftAndBurstTypeDLVHCRBurstTypeType1MidambleAllocationModeDefaultMidamble;

typedef Null MidambleShiftAndBurstTypeDLVHCRBurstTypeType1MidambleAllocationModeCommonMidamble;

class MidambleShiftAndBurstTypeDLVHCRBurstTypeType1MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeDLVHCRBurstTypeType1MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftLong& midambleShift) { *static_cast<MidambleShiftLong*>(items[0]) = midambleShift; }
};

class MidambleShiftAndBurstTypeDLVHCRBurstTypeType1MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MidambleShiftAndBurstTypeDLVHCRBurstTypeType1MidambleAllocationModeChoices {
		midambleShiftAndBurstTypeDLVHCRBurstTypeType1MidambleAllocationModeDefaultMidamble = 0,
		midambleShiftAndBurstTypeDLVHCRBurstTypeType1MidambleAllocationModeCommonMidamble = 1,
		midambleShiftAndBurstTypeDLVHCRBurstTypeType1MidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTypeDLVHCRBurstTypeType1MidambleAllocationMode(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstTypeDLVHCRBurstTypeType1 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeDLVHCRBurstTypeType1(): Sequence(&theInfo) {}

	void setMidambleConfigurationBurstType1and3(const MidambleConfigurationBurstType1and3& midambleConfigurationBurstType1and3) { *static_cast<MidambleConfigurationBurstType1and3*>(items[0]) = midambleConfigurationBurstType1and3; }
	void setMidambleShiftAndBurstTypeDLVHCRBurstTypeType1MidambleAllocationMode(const MidambleShiftAndBurstTypeDLVHCRBurstTypeType1MidambleAllocationMode& midambleShiftAndBurstTypeDLVHCRBurstTypeType1MidambleAllocationMode) { *static_cast<MidambleShiftAndBurstTypeDLVHCRBurstTypeType1MidambleAllocationMode*>(items[1]) = midambleShiftAndBurstTypeDLVHCRBurstTypeType1MidambleAllocationMode; }
};

typedef Null MidambleShiftAndBurstTypeDLVHCRBurstTypeType2MidambleAllocationModeDefaultMidamble;

typedef Null MidambleShiftAndBurstTypeDLVHCRBurstTypeType2MidambleAllocationModeCommonMidamble;

class MidambleShiftAndBurstTypeDLVHCRBurstTypeType2MidambleAllocationModeUeSpecificMidamble : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeDLVHCRBurstTypeType2MidambleAllocationModeUeSpecificMidamble(): Sequence(&theInfo) {}

	void setMidambleShift(const MidambleShiftShortVHCR& midambleShift) { *static_cast<MidambleShiftShortVHCR*>(items[0]) = midambleShift; }
};

class MidambleShiftAndBurstTypeDLVHCRBurstTypeType2MidambleAllocationMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MidambleShiftAndBurstTypeDLVHCRBurstTypeType2MidambleAllocationModeChoices {
		midambleShiftAndBurstTypeDLVHCRBurstTypeType2MidambleAllocationModeDefaultMidamble = 0,
		midambleShiftAndBurstTypeDLVHCRBurstTypeType2MidambleAllocationModeCommonMidamble = 1,
		midambleShiftAndBurstTypeDLVHCRBurstTypeType2MidambleAllocationModeUeSpecificMidamble = 2,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTypeDLVHCRBurstTypeType2MidambleAllocationMode(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstTypeDLVHCRBurstTypeType2 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeDLVHCRBurstTypeType2(): Sequence(&theInfo) {}

	void setMidambleConfigurationBurstType2(const MidambleConfigurationBurstType2VHCR& midambleConfigurationBurstType2) { *static_cast<MidambleConfigurationBurstType2VHCR*>(items[0]) = midambleConfigurationBurstType2; }
	void setMidambleShiftAndBurstTypeDLVHCRBurstTypeType2MidambleAllocationMode(const MidambleShiftAndBurstTypeDLVHCRBurstTypeType2MidambleAllocationMode& midambleShiftAndBurstTypeDLVHCRBurstTypeType2MidambleAllocationMode) { *static_cast<MidambleShiftAndBurstTypeDLVHCRBurstTypeType2MidambleAllocationMode*>(items[1]) = midambleShiftAndBurstTypeDLVHCRBurstTypeType2MidambleAllocationMode; }
};

class MidambleShiftAndBurstTypeDLVHCRBurstType : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MidambleShiftAndBurstTypeDLVHCRBurstTypeChoices {
		midambleShiftAndBurstTypeDLVHCRBurstTypeType1 = 0,
		midambleShiftAndBurstTypeDLVHCRBurstTypeType2 = 1,
	};
	static const Info theInfo;
	MidambleShiftAndBurstTypeDLVHCRBurstType(): Choice(&theInfo) {}
};

class MidambleShiftAndBurstTypeDLVHCR : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MidambleShiftAndBurstTypeDLVHCR(): Sequence(&theInfo) {}

	void setMidambleShiftAndBurstTypeDLVHCRBurstType(const MidambleShiftAndBurstTypeDLVHCRBurstType& midambleShiftAndBurstTypeDLVHCRBurstType) { *static_cast<MidambleShiftAndBurstTypeDLVHCRBurstType*>(items[0]) = midambleShiftAndBurstTypeDLVHCRBurstType; }
};

enum MIMOOperationValues {
	start_MIMOOperation = 0,
	continue_MIMOOperation = 1,
};
typedef Enumerated<CONSTRAINED, 1> MIMOOperation;

typedef Null MIMOPilotConfigurationSecondCPICHPatternNormalPattern;

class MIMOPilotConfigurationSecondCPICHPatternDiversityPattern : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MIMOPilotConfigurationSecondCPICHPatternDiversityPattern(): Sequence(&theInfo) {}

	void setChannelisationCode(const ChannelisationCode256& channelisationCode) { *static_cast<ChannelisationCode256*>(items[0]) = channelisationCode; }
};

class MIMOPilotConfigurationSecondCPICHPattern : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MIMOPilotConfigurationSecondCPICHPatternChoices {
		mIMOPilotConfigurationSecondCPICHPatternNormalPattern = 0,
		mIMOPilotConfigurationSecondCPICHPatternDiversityPattern = 1,
	};
	static const Info theInfo;
	MIMOPilotConfigurationSecondCPICHPattern(): Choice(&theInfo) {}
};

class MIMOPilotConfiguration : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MIMOPilotConfiguration(): Sequence(&theInfo) {}

	void setMIMOPilotConfigurationSecondCPICHPattern(const MIMOPilotConfigurationSecondCPICHPattern& mIMOPilotConfigurationSecondCPICHPattern) { *static_cast<MIMOPilotConfigurationSecondCPICHPattern*>(items[0]) = mIMOPilotConfigurationSecondCPICHPattern; }
};

class MIMOParametersr7 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MIMOParametersr7(): Sequence(&theInfo) {}

	void setMimoOperation(const MIMOOperation& mimoOperation) { *static_cast<MIMOOperation*>(items[0]) = mimoOperation; }
	void setMimoNMRatio(const MIMONMRatio& mimoNMRatio) { *static_cast<MIMONMRatio*>(items[1]) = mimoNMRatio; }
	void setMimoPilotConfiguration(const MIMOPilotConfiguration& mimoPilotConfiguration) { *static_cast<MIMOPilotConfiguration*>(items[2]) = mimoPilotConfiguration; }
};

class MIMOPilotConfigurationv7f0ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MIMOPilotConfigurationv7f0ext(): Sequence(&theInfo) {}

	void setScpichPowerOffsetMimo(const SCPICHPowerOffsetMIMO& scpichPowerOffsetMimo) { *static_cast<SCPICHPowerOffsetMIMO*>(items[0]) = scpichPowerOffsetMimo; }
};

typedef MIMOPilotConfigurationv7f0ext MIMOParametersv7f0ext;

enum MIMOParametersv7g0extprecodingWeightSetRestrictionValues {
	true_MIMOParametersv7g0extprecodingWeightSetRestriction = 0,
};
typedef Enumerated<CONSTRAINED, 0> MIMOParametersv7g0extprecodingWeightSetRestriction;

class MIMOParametersv7g0ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MIMOParametersv7g0ext(): Sequence(&theInfo) {}

	void setMIMOParametersv7g0extprecodingWeightSetRestriction(const MIMOParametersv7g0extprecodingWeightSetRestriction& mIMOParametersv7g0extprecodingWeightSetRestriction) { *static_cast<MIMOParametersv7g0extprecodingWeightSetRestriction*>(items[0]) = mIMOParametersv7g0extprecodingWeightSetRestriction; }
};

class MIMOParametersr8ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MIMOParametersr8ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setMimoNMRatio(const MIMONMRatio& mimoNMRatio) { *static_cast<MIMONMRatio*>(items[0]) = mimoNMRatio; }
	void setMimoPilotConfiguration(const MIMOPilotConfiguration& mimoPilotConfiguration) { *static_cast<MIMOPilotConfiguration*>(items[1]) = mimoPilotConfiguration; }
};

enum MIMOParametersr8ModeSpecificInfoTddTdd128mimoSFModeForHSPDSCHDualStreamValues {
	sf1_MIMOParametersr8ModeSpecificInfoTddTdd128mimoSFModeForHSPDSCHDualStream = 0,
	sf1sf16_MIMOParametersr8ModeSpecificInfoTddTdd128mimoSFModeForHSPDSCHDualStream = 1,
};
typedef Enumerated<CONSTRAINED, 1> MIMOParametersr8ModeSpecificInfoTddTdd128mimoSFModeForHSPDSCHDualStream;

class MIMOParametersr8ModeSpecificInfoTddTdd128 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MIMOParametersr8ModeSpecificInfoTddTdd128(): Sequence(&theInfo) {}

	void setMIMOParametersr8ModeSpecificInfoTddTdd128mimoSFModeForHSPDSCHDualStream(const MIMOParametersr8ModeSpecificInfoTddTdd128mimoSFModeForHSPDSCHDualStream& mIMOParametersr8ModeSpecificInfoTddTdd128mimoSFModeForHSPDSCHDualStream) { *static_cast<MIMOParametersr8ModeSpecificInfoTddTdd128mimoSFModeForHSPDSCHDualStream*>(items[0]) = mIMOParametersr8ModeSpecificInfoTddTdd128mimoSFModeForHSPDSCHDualStream; }
	void setHssichReferenceSignalInfoList(const HSSICHReferenceSignalInfoList& hssichReferenceSignalInfoList) { *static_cast<HSSICHReferenceSignalInfoList*>(items[1]) = hssichReferenceSignalInfoList; }
};

typedef Null MIMOParametersr8ModeSpecificInfoTddTdd384tdd768;

class MIMOParametersr8ModeSpecificInfoTdd : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MIMOParametersr8ModeSpecificInfoTddChoices {
		mIMOParametersr8ModeSpecificInfoTddTdd128 = 0,
		mIMOParametersr8ModeSpecificInfoTddTdd384tdd768 = 1,
	};
	static const Info theInfo;
	MIMOParametersr8ModeSpecificInfoTdd(): Choice(&theInfo) {}
};

class MIMOParametersr8ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MIMOParametersr8ModeSpecificInfoChoices {
		mIMOParametersr8ModeSpecificInfoFdd = 0,
		mIMOParametersr8ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	MIMOParametersr8ModeSpecificInfo(): Choice(&theInfo) {}
};

class MIMOParametersr8 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MIMOParametersr8(): Sequence(&theInfo) {}

	void setMimoOperation(const MIMOOperation& mimoOperation) { *static_cast<MIMOOperation*>(items[0]) = mimoOperation; }
	void setMIMOParametersr8ModeSpecificInfo(const MIMOParametersr8ModeSpecificInfo& mIMOParametersr8ModeSpecificInfo) { *static_cast<MIMOParametersr8ModeSpecificInfo*>(items[1]) = mIMOParametersr8ModeSpecificInfo; }
};

enum MIMOParametersr9ModeSpecificInfoFddprecodingWeightSetRestrictionValues {
	true_MIMOParametersr9ModeSpecificInfoFddprecodingWeightSetRestriction = 0,
};
typedef Enumerated<CONSTRAINED, 0> MIMOParametersr9ModeSpecificInfoFddprecodingWeightSetRestriction;

class MIMOParametersr9ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MIMOParametersr9ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setMimoNMRatio(const MIMONMRatio& mimoNMRatio) { *static_cast<MIMONMRatio*>(items[0]) = mimoNMRatio; }
	void setMimoPilotConfiguration(const MIMOPilotConfigurationr9& mimoPilotConfiguration) { *static_cast<MIMOPilotConfigurationr9*>(items[1]) = mimoPilotConfiguration; }
	void setMIMOParametersr9ModeSpecificInfoFddprecodingWeightSetRestriction(const MIMOParametersr9ModeSpecificInfoFddprecodingWeightSetRestriction& mIMOParametersr9ModeSpecificInfoFddprecodingWeightSetRestriction) { *static_cast<MIMOParametersr9ModeSpecificInfoFddprecodingWeightSetRestriction*>(items[2]) = mIMOParametersr9ModeSpecificInfoFddprecodingWeightSetRestriction; }
};

enum MIMOParametersr9ModeSpecificInfoTddTdd128mimoSFModeForHSPDSCHDualStreamValues {
	sf1_MIMOParametersr9ModeSpecificInfoTddTdd128mimoSFModeForHSPDSCHDualStream = 0,
	sf1sf16_MIMOParametersr9ModeSpecificInfoTddTdd128mimoSFModeForHSPDSCHDualStream = 1,
};
typedef Enumerated<CONSTRAINED, 1> MIMOParametersr9ModeSpecificInfoTddTdd128mimoSFModeForHSPDSCHDualStream;

class MIMOParametersr9ModeSpecificInfoTddTdd128 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MIMOParametersr9ModeSpecificInfoTddTdd128(): Sequence(&theInfo) {}

	void setMIMOParametersr9ModeSpecificInfoTddTdd128mimoSFModeForHSPDSCHDualStream(const MIMOParametersr9ModeSpecificInfoTddTdd128mimoSFModeForHSPDSCHDualStream& mIMOParametersr9ModeSpecificInfoTddTdd128mimoSFModeForHSPDSCHDualStream) { *static_cast<MIMOParametersr9ModeSpecificInfoTddTdd128mimoSFModeForHSPDSCHDualStream*>(items[0]) = mIMOParametersr9ModeSpecificInfoTddTdd128mimoSFModeForHSPDSCHDualStream; }
	void setHssichReferenceSignalInfoList(const HSSICHReferenceSignalInfoList& hssichReferenceSignalInfoList) { *static_cast<HSSICHReferenceSignalInfoList*>(items[1]) = hssichReferenceSignalInfoList; }
};

typedef Null MIMOParametersr9ModeSpecificInfoTddTdd384tdd768;

class MIMOParametersr9ModeSpecificInfoTdd : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MIMOParametersr9ModeSpecificInfoTddChoices {
		mIMOParametersr9ModeSpecificInfoTddTdd128 = 0,
		mIMOParametersr9ModeSpecificInfoTddTdd384tdd768 = 1,
	};
	static const Info theInfo;
	MIMOParametersr9ModeSpecificInfoTdd(): Choice(&theInfo) {}
};

class MIMOParametersr9ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MIMOParametersr9ModeSpecificInfoChoices {
		mIMOParametersr9ModeSpecificInfoFdd = 0,
		mIMOParametersr9ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	MIMOParametersr9ModeSpecificInfo(): Choice(&theInfo) {}
};

class MIMOParametersr9 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MIMOParametersr9(): Sequence(&theInfo) {}

	void setMimoOperation(const MIMOOperation& mimoOperation) { *static_cast<MIMOOperation*>(items[0]) = mimoOperation; }
	void setMIMOParametersr9ModeSpecificInfo(const MIMOParametersr9ModeSpecificInfo& mIMOParametersr9ModeSpecificInfo) { *static_cast<MIMOParametersr9ModeSpecificInfo*>(items[1]) = mIMOParametersr9ModeSpecificInfo; }
};

typedef Integer<CONSTRAINED, 0, 127> UpPCHpositionLCR;

class MultifrequencyInfoLCRr7 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MultifrequencyInfoLCRr7(): Sequence(&theInfo) {}

	void setSecondFrequencyInfo(const FrequencyInfoTDD& secondFrequencyInfo) { *static_cast<FrequencyInfoTDD*>(items[0]) = secondFrequencyInfo; }
	void setFPachFrequencyInfo(const FrequencyInfoTDD& fPachFrequencyInfo) { *static_cast<FrequencyInfoTDD*>(items[1]) = fPachFrequencyInfo; }
	void setUpPCHpositionInfo(const UpPCHpositionLCR& upPCHpositionInfo) { *static_cast<UpPCHpositionLCR*>(items[2]) = upPCHpositionInfo; }
};

typedef Integer<CONSTRAINED, 0, 159> UEDTXDRXOffset;

class NewTiming : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	NewTiming(): Sequence(&theInfo) {}

	void setEnablingDelay(const EnablingDelay& enablingDelay) { *static_cast<EnablingDelay*>(items[0]) = enablingDelay; }
	void setUedtxdrxOffset(const UEDTXDRXOffset& uedtxdrxOffset) { *static_cast<UEDTXDRXOffset*>(items[1]) = uedtxdrxOffset; }
};

typedef Null NonScheduledTransGrantInfoTDDextTdd384768;

enum NonScheduledTransGrantInfoTDDextTdd128t_SI_nstValues {
	everyEDCHTTI_NonScheduledTransGrantInfoTDDextTdd128t_SI_nst = 0,
	ms20_NonScheduledTransGrantInfoTDDextTdd128t_SI_nst = 1,
	ms40_NonScheduledTransGrantInfoTDDextTdd128t_SI_nst = 2,
	ms60_NonScheduledTransGrantInfoTDDextTdd128t_SI_nst = 3,
	ms80_NonScheduledTransGrantInfoTDDextTdd128t_SI_nst = 4,
	ms160_NonScheduledTransGrantInfoTDDextTdd128t_SI_nst = 5,
	ms200_NonScheduledTransGrantInfoTDDextTdd128t_SI_nst = 6,
};
typedef Enumerated<CONSTRAINED, 6> NonScheduledTransGrantInfoTDDextTdd128t_SI_nst;

class NonScheduledTransGrantInfoTDDextTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	NonScheduledTransGrantInfoTDDextTdd128(): Sequence(&theInfo) {}

	void setNonScheduledTransGrantInfoTDDextTdd128t_SI_nst(const NonScheduledTransGrantInfoTDDextTdd128t_SI_nst& nonScheduledTransGrantInfoTDDextTdd128t_SI_nst) { *static_cast<NonScheduledTransGrantInfoTDDextTdd128t_SI_nst*>(items[0]) = nonScheduledTransGrantInfoTDDextTdd128t_SI_nst; }
};

class NonScheduledTransGrantInfoTDDext : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum NonScheduledTransGrantInfoTDDextChoices {
		nonScheduledTransGrantInfoTDDextTdd384768 = 0,
		nonScheduledTransGrantInfoTDDextTdd128 = 1,
	};
	static const Info theInfo;
	NonScheduledTransGrantInfoTDDext(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 1, maxDPDCH_UL> NumberOfDPDCH;

typedef Integer<CONSTRAINED, 1, 2> NumberOfFBIBits;

class OpenLoopPowerControlTDD : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	OpenLoopPowerControlTDD(): Sequence(&theInfo) {}

	void setPrimaryCCPCHTXPower(const PrimaryCCPCHTXPower& primaryCCPCHTXPower) { *static_cast<PrimaryCCPCHTXPower*>(items[0]) = primaryCCPCHTXPower; }
	void setAlpha(const Alpha& alpha) { *static_cast<Alpha*>(items[1]) = alpha; }
	void setPrachConstantValue(const ConstantValueTdd& prachConstantValue) { *static_cast<ConstantValueTdd*>(items[2]) = prachConstantValue; }
	void setDpchConstantValue(const ConstantValueTdd& dpchConstantValue) { *static_cast<ConstantValueTdd*>(items[3]) = dpchConstantValue; }
	void setPuschConstantValue(const ConstantValueTdd& puschConstantValue) { *static_cast<ConstantValueTdd*>(items[4]) = puschConstantValue; }
};

class OpenLoopPowerControlIPDLTDDr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	OpenLoopPowerControlIPDLTDDr4(): Sequence(&theInfo) {}

	void setIpdlalpha(const Alpha& ipdlalpha) { *static_cast<Alpha*>(items[0]) = ipdlalpha; }
	void setMaxPowerIncrease(const MaxPowerIncreaser4& maxPowerIncrease) { *static_cast<MaxPowerIncreaser4*>(items[1]) = maxPowerIncrease; }
};

class PDSCHPowerControlInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PDSCHPowerControlInfo(): Sequence(&theInfo) {}

	void setTpcStepSizeTDD(const TPCStepSizeTDD& tpcStepSizeTDD) { *static_cast<TPCStepSizeTDD*>(items[0]) = tpcStepSizeTDD; }
	void setUlCCTrChTPCList(const ULCCTrChTPCList& ulCCTrChTPCList) { *static_cast<ULCCTrChTPCList*>(items[1]) = ulCCTrChTPCList; }
};

typedef Integer<CONSTRAINED, 1, hiPDSCHidentities> PDSCHIdentity;

class PDSCHCapacityAllocationInfoConfigurationOldConfiguration : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PDSCHCapacityAllocationInfoConfigurationOldConfiguration(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setPdschIdentity(const PDSCHIdentity& pdschIdentity) { *static_cast<PDSCHIdentity*>(items[1]) = pdschIdentity; }
};

class PDSCHInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PDSCHInfo(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setCommonTimeslotInfo(const CommonTimeslotInfo& commonTimeslotInfo) { *static_cast<CommonTimeslotInfo*>(items[1]) = commonTimeslotInfo; }
	void setPdschTimeslotsCodes(const DownlinkTimeslotsCodes& pdschTimeslotsCodes) { *static_cast<DownlinkTimeslotsCodes*>(items[2]) = pdschTimeslotsCodes; }
};

class PDSCHCapacityAllocationInfoConfigurationNewConfiguration : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PDSCHCapacityAllocationInfoConfigurationNewConfiguration(): Sequence(&theInfo) {}

	void setPdschInfo(const PDSCHInfo& pdschInfo) { *static_cast<PDSCHInfo*>(items[0]) = pdschInfo; }
	void setPdschIdentity(const PDSCHIdentity& pdschIdentity) { *static_cast<PDSCHIdentity*>(items[1]) = pdschIdentity; }
};

class PDSCHCapacityAllocationInfoConfiguration : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PDSCHCapacityAllocationInfoConfigurationChoices {
		pDSCHCapacityAllocationInfoConfigurationOldConfiguration = 0,
		pDSCHCapacityAllocationInfoConfigurationNewConfiguration = 1,
	};
	static const Info theInfo;
	PDSCHCapacityAllocationInfoConfiguration(): Choice(&theInfo) {}
};

class PDSCHCapacityAllocationInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PDSCHCapacityAllocationInfo(): Sequence(&theInfo) {}

	void setPdschPowerControlInfo(const PDSCHPowerControlInfo& pdschPowerControlInfo) { *static_cast<PDSCHPowerControlInfo*>(items[0]) = pdschPowerControlInfo; }
	void setPdschAllocationPeriodInfo(const AllocationPeriodInfo& pdschAllocationPeriodInfo) { *static_cast<AllocationPeriodInfo*>(items[1]) = pdschAllocationPeriodInfo; }
	void setPDSCHCapacityAllocationInfoConfiguration(const PDSCHCapacityAllocationInfoConfiguration& pDSCHCapacityAllocationInfoConfiguration) { *static_cast<PDSCHCapacityAllocationInfoConfiguration*>(items[2]) = pDSCHCapacityAllocationInfoConfiguration; }
};

class PDSCHCapacityAllocationInfor4ConfigurationOldConfiguration : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PDSCHCapacityAllocationInfor4ConfigurationOldConfiguration(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setPdschIdentity(const PDSCHIdentity& pdschIdentity) { *static_cast<PDSCHIdentity*>(items[1]) = pdschIdentity; }
};

class PDSCHInfor4TddOptionTdd384 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PDSCHInfor4TddOptionTdd384(): Sequence(&theInfo) {}

	void setPdschTimeslotsCodes(const DownlinkTimeslotsCodes& pdschTimeslotsCodes) { *static_cast<DownlinkTimeslotsCodes*>(items[0]) = pdschTimeslotsCodes; }
};

class PDSCHInfor4TddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PDSCHInfor4TddOptionTdd128(): Sequence(&theInfo) {}

	void setPdschTimeslotsCodes(const DownlinkTimeslotsCodesLCRr4& pdschTimeslotsCodes) { *static_cast<DownlinkTimeslotsCodesLCRr4*>(items[0]) = pdschTimeslotsCodes; }
};

class PDSCHInfor4TddOption : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PDSCHInfor4TddOptionChoices {
		pDSCHInfor4TddOptionTdd384 = 0,
		pDSCHInfor4TddOptionTdd128 = 1,
	};
	static const Info theInfo;
	PDSCHInfor4TddOption(): Choice(&theInfo) {}
};

class PDSCHInfor4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PDSCHInfor4(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setCommonTimeslotInfo(const CommonTimeslotInfo& commonTimeslotInfo) { *static_cast<CommonTimeslotInfo*>(items[1]) = commonTimeslotInfo; }
	void setPDSCHInfor4TddOption(const PDSCHInfor4TddOption& pDSCHInfor4TddOption) { *static_cast<PDSCHInfor4TddOption*>(items[2]) = pDSCHInfor4TddOption; }
};

class PDSCHCapacityAllocationInfor4ConfigurationNewConfiguration : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PDSCHCapacityAllocationInfor4ConfigurationNewConfiguration(): Sequence(&theInfo) {}

	void setPdschInfo(const PDSCHInfor4& pdschInfo) { *static_cast<PDSCHInfor4*>(items[0]) = pdschInfo; }
	void setPdschIdentity(const PDSCHIdentity& pdschIdentity) { *static_cast<PDSCHIdentity*>(items[1]) = pdschIdentity; }
	void setPdschPowerControlInfo(const PDSCHPowerControlInfo& pdschPowerControlInfo) { *static_cast<PDSCHPowerControlInfo*>(items[2]) = pdschPowerControlInfo; }
};

class PDSCHCapacityAllocationInfor4Configuration : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PDSCHCapacityAllocationInfor4ConfigurationChoices {
		pDSCHCapacityAllocationInfor4ConfigurationOldConfiguration = 0,
		pDSCHCapacityAllocationInfor4ConfigurationNewConfiguration = 1,
	};
	static const Info theInfo;
	PDSCHCapacityAllocationInfor4Configuration(): Choice(&theInfo) {}
};

class PDSCHCapacityAllocationInfor4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PDSCHCapacityAllocationInfor4(): Sequence(&theInfo) {}

	void setPdschAllocationPeriodInfo(const AllocationPeriodInfo& pdschAllocationPeriodInfo) { *static_cast<AllocationPeriodInfo*>(items[0]) = pdschAllocationPeriodInfo; }
	void setPDSCHCapacityAllocationInfor4Configuration(const PDSCHCapacityAllocationInfor4Configuration& pDSCHCapacityAllocationInfor4Configuration) { *static_cast<PDSCHCapacityAllocationInfor4Configuration*>(items[1]) = pDSCHCapacityAllocationInfor4Configuration; }
};

class PDSCHCapacityAllocationInfor7ConfigurationOldConfiguration : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PDSCHCapacityAllocationInfor7ConfigurationOldConfiguration(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setPdschIdentity(const PDSCHIdentity& pdschIdentity) { *static_cast<PDSCHIdentity*>(items[1]) = pdschIdentity; }
};

class PDSCHInfor7TddOptionTdd384 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PDSCHInfor7TddOptionTdd384(): Sequence(&theInfo) {}

	void setPdschTimeslotsCodes(const DownlinkTimeslotsCodes& pdschTimeslotsCodes) { *static_cast<DownlinkTimeslotsCodes*>(items[0]) = pdschTimeslotsCodes; }
};

class PDSCHInfor7TddOptionTdd768 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PDSCHInfor7TddOptionTdd768(): Sequence(&theInfo) {}

	void setPdschTimeslotsCodes(const DownlinkTimeslotsCodesVHCR& pdschTimeslotsCodes) { *static_cast<DownlinkTimeslotsCodesVHCR*>(items[0]) = pdschTimeslotsCodes; }
};

class PDSCHInfor7TddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PDSCHInfor7TddOptionTdd128(): Sequence(&theInfo) {}

	void setPdschTimeslotsCodes(const DownlinkTimeslotsCodesLCRr4& pdschTimeslotsCodes) { *static_cast<DownlinkTimeslotsCodesLCRr4*>(items[0]) = pdschTimeslotsCodes; }
};

class PDSCHInfor7TddOption : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum PDSCHInfor7TddOptionChoices {
		pDSCHInfor7TddOptionTdd384 = 0,
		pDSCHInfor7TddOptionTdd768 = 1,
		pDSCHInfor7TddOptionTdd128 = 2,
	};
	static const Info theInfo;
	PDSCHInfor7TddOption(): Choice(&theInfo) {}
};

class PDSCHInfor7 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PDSCHInfor7(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setCommonTimeslotInfo(const CommonTimeslotInfo& commonTimeslotInfo) { *static_cast<CommonTimeslotInfo*>(items[1]) = commonTimeslotInfo; }
	void setPDSCHInfor7TddOption(const PDSCHInfor7TddOption& pDSCHInfor7TddOption) { *static_cast<PDSCHInfor7TddOption*>(items[2]) = pDSCHInfor7TddOption; }
};

class PDSCHCapacityAllocationInfor7ConfigurationNewConfiguration : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PDSCHCapacityAllocationInfor7ConfigurationNewConfiguration(): Sequence(&theInfo) {}

	void setPdschInfo(const PDSCHInfor7& pdschInfo) { *static_cast<PDSCHInfor7*>(items[0]) = pdschInfo; }
	void setPdschIdentity(const PDSCHIdentity& pdschIdentity) { *static_cast<PDSCHIdentity*>(items[1]) = pdschIdentity; }
	void setPdschPowerControlInfo(const PDSCHPowerControlInfo& pdschPowerControlInfo) { *static_cast<PDSCHPowerControlInfo*>(items[2]) = pdschPowerControlInfo; }
};

class PDSCHCapacityAllocationInfor7Configuration : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PDSCHCapacityAllocationInfor7ConfigurationChoices {
		pDSCHCapacityAllocationInfor7ConfigurationOldConfiguration = 0,
		pDSCHCapacityAllocationInfor7ConfigurationNewConfiguration = 1,
	};
	static const Info theInfo;
	PDSCHCapacityAllocationInfor7Configuration(): Choice(&theInfo) {}
};

class PDSCHCapacityAllocationInfor7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PDSCHCapacityAllocationInfor7(): Sequence(&theInfo) {}

	void setPdschAllocationPeriodInfo(const AllocationPeriodInfo& pdschAllocationPeriodInfo) { *static_cast<AllocationPeriodInfo*>(items[0]) = pdschAllocationPeriodInfo; }
	void setPDSCHCapacityAllocationInfor7Configuration(const PDSCHCapacityAllocationInfor7Configuration& pDSCHCapacityAllocationInfor7Configuration) { *static_cast<PDSCHCapacityAllocationInfor7Configuration*>(items[1]) = pDSCHCapacityAllocationInfor7Configuration; }
};

class PDSCHInfoLCRr4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PDSCHInfoLCRr4(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setCommonTimeslotInfo(const CommonTimeslotInfo& commonTimeslotInfo) { *static_cast<CommonTimeslotInfo*>(items[1]) = commonTimeslotInfo; }
	void setPdschTimeslotsCodes(const DownlinkTimeslotsCodesLCRr4& pdschTimeslotsCodes) { *static_cast<DownlinkTimeslotsCodesLCRr4*>(items[2]) = pdschTimeslotsCodes; }
};

class PDSCHSysInfo : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	PDSCHSysInfo(): Sequence(&theInfo) {}

	void setPdschIdentity(const PDSCHIdentity& pdschIdentity) { *static_cast<PDSCHIdentity*>(items[0]) = pdschIdentity; }
	void setPdschInfo(const PDSCHInfo& pdschInfo) { *static_cast<PDSCHInfo*>(items[1]) = pdschInfo; }
	void setDschTFS(const TransportFormatSet& dschTFS) { *static_cast<TransportFormatSet*>(items[2]) = dschTFS; }
	void setDschTFCS(const TFCS& dschTFCS) { *static_cast<TFCS*>(items[3]) = dschTFCS; }
};

class PDSCHSysInfoVHCRr7 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	PDSCHSysInfoVHCRr7(): Sequence(&theInfo) {}

	void setPdschIdentity(const PDSCHIdentity& pdschIdentity) { *static_cast<PDSCHIdentity*>(items[0]) = pdschIdentity; }
	void setPdschInfo(const PDSCHInfor7& pdschInfo) { *static_cast<PDSCHInfor7*>(items[1]) = pdschInfo; }
	void setDschTransportChannelsInfo(const DSCHTransportChannelsInfo& dschTransportChannelsInfo) { *static_cast<DSCHTransportChannelsInfo*>(items[2]) = dschTransportChannelsInfo; }
	void setDschTFCS(const TFCS& dschTFCS) { *static_cast<TFCS*>(items[3]) = dschTFCS; }
};

class PDSCHSysInfoHCRr5 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	PDSCHSysInfoHCRr5(): Sequence(&theInfo) {}

	void setPdschIdentity(const PDSCHIdentity& pdschIdentity) { *static_cast<PDSCHIdentity*>(items[0]) = pdschIdentity; }
	void setPdschInfo(const PDSCHInfo& pdschInfo) { *static_cast<PDSCHInfo*>(items[1]) = pdschInfo; }
	void setDschTransportChannelsInfo(const DSCHTransportChannelsInfo& dschTransportChannelsInfo) { *static_cast<DSCHTransportChannelsInfo*>(items[2]) = dschTransportChannelsInfo; }
	void setDschTFCS(const TFCS& dschTFCS) { *static_cast<TFCS*>(items[3]) = dschTFCS; }
};

class PDSCHSysInfoLCRr4 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	PDSCHSysInfoLCRr4(): Sequence(&theInfo) {}

	void setPdschIdentity(const PDSCHIdentity& pdschIdentity) { *static_cast<PDSCHIdentity*>(items[0]) = pdschIdentity; }
	void setPdschInfo(const PDSCHInfoLCRr4& pdschInfo) { *static_cast<PDSCHInfoLCRr4*>(items[1]) = pdschInfo; }
	void setDschTFS(const TransportFormatSet& dschTFS) { *static_cast<TransportFormatSet*>(items[2]) = dschTFS; }
	void setDschTFCS(const TFCS& dschTFCS) { *static_cast<TFCS*>(items[3]) = dschTFCS; }
};

typedef SequenceOf<PDSCHSysInfo, CONSTRAINED, 1, maxPDSCH> PDSCHSysInfoList;

typedef SequenceOf<PDSCHSysInfoVHCRr7, CONSTRAINED, 1, maxPDSCH> PDSCHSysInfoListVHCRr7;

typedef SequenceOf<PDSCHSysInfoHCRr5, CONSTRAINED, 1, maxPDSCH> PDSCHSysInfoListHCRr5;

typedef SequenceOf<PDSCHSysInfoLCRr4, CONSTRAINED, 1, maxPDSCH> PDSCHSysInfoListLCRr4;

class PDSCHSysInfoListSFN : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	PDSCHSysInfoListSFN(): Sequence(&theInfo) {}

};

class PDSCHSysInfoListSFNHCRr5 : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	PDSCHSysInfoListSFNHCRr5(): Sequence(&theInfo) {}

};

class PDSCHSysInfoListSFNLCRr4 : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	PDSCHSysInfoListSFNLCRr4(): Sequence(&theInfo) {}

};

enum TDD768PICHCCodeValues {
	cc32_1_TDD768PICHCCode = 0,
	cc32_2_TDD768PICHCCode = 1,
	cc32_3_TDD768PICHCCode = 2,
	cc32_4_TDD768PICHCCode = 3,
	cc32_5_TDD768PICHCCode = 4,
	cc32_6_TDD768PICHCCode = 5,
	cc32_7_TDD768PICHCCode = 6,
	cc32_8_TDD768PICHCCode = 7,
	cc32_9_TDD768PICHCCode = 8,
	cc32_10_TDD768PICHCCode = 9,
	cc32_11_TDD768PICHCCode = 10,
	cc32_12_TDD768PICHCCode = 11,
	cc32_13_TDD768PICHCCode = 12,
	cc32_14_TDD768PICHCCode = 13,
	cc32_15_TDD768PICHCCode = 14,
	cc32_16_TDD768PICHCCode = 15,
	cc32_17_TDD768PICHCCode = 16,
	cc32_18_TDD768PICHCCode = 17,
	cc32_19_TDD768PICHCCode = 18,
	cc32_20_TDD768PICHCCode = 19,
	cc32_21_TDD768PICHCCode = 20,
	cc32_22_TDD768PICHCCode = 21,
	cc32_23_TDD768PICHCCode = 22,
	cc32_24_TDD768PICHCCode = 23,
	cc32_25_TDD768PICHCCode = 24,
	cc32_26_TDD768PICHCCode = 25,
	cc32_27_TDD768PICHCCode = 26,
	cc32_28_TDD768PICHCCode = 27,
	cc32_29_TDD768PICHCCode = 28,
	cc32_30_TDD768PICHCCode = 29,
	cc32_31_TDD768PICHCCode = 30,
	cc32_32_TDD768PICHCCode = 31,
};
typedef Enumerated<CONSTRAINED, 31> TDD768PICHCCode;

class PICHInfoHCRVHCRr7ChannelisationCode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PICHInfoHCRVHCRr7ChannelisationCodeChoices {
		tdd384 = 0,
		tdd768 = 1,
	};
	static const Info theInfo;
	PICHInfoHCRVHCRr7ChannelisationCode(): Choice(&theInfo) {}
};

class PICHInfoHCRVHCRr7 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	PICHInfoHCRVHCRr7(): Sequence(&theInfo) {}

	void setPICHInfoHCRVHCRr7ChannelisationCode(const PICHInfoHCRVHCRr7ChannelisationCode& pICHInfoHCRVHCRr7ChannelisationCode) { *static_cast<PICHInfoHCRVHCRr7ChannelisationCode*>(items[0]) = pICHInfoHCRVHCRr7ChannelisationCode; }
	void setTimeslot(const TimeslotNumber& timeslot) { *static_cast<TimeslotNumber*>(items[1]) = timeslot; }
	void setMidambleShiftAndBurstType(const MidambleShiftAndBurstType& midambleShiftAndBurstType) { *static_cast<MidambleShiftAndBurstType*>(items[2]) = midambleShiftAndBurstType; }
	void setRepetitionPeriodLengthOffset(const RepPerLengthOffsetPICH& repetitionPeriodLengthOffset) { *static_cast<RepPerLengthOffsetPICH*>(items[3]) = repetitionPeriodLengthOffset; }
	void setPagingIndicatorLength(const PagingIndicatorLength& pagingIndicatorLength) { *static_cast<PagingIndicatorLength*>(items[4]) = pagingIndicatorLength; }
	void setNGAP(const NGAP& nGAP) { *static_cast<NGAP*>(items[5]) = nGAP; }
	void setNPCH(const NPCH& nPCH) { *static_cast<NPCH*>(items[6]) = nPCH; }
};

typedef Integer<CONSTRAINED, -10, 5> PICHPowerOffset;

typedef Integer<CONSTRAINED, 1, 14> PLCCHInfoPlcchSequenceNumber;

typedef Integer<CONSTRAINED, 0, 10> TPCCommandTargetRate;

class PLCCHInfo : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	PLCCHInfo(): Sequence(&theInfo) {}

	void setPLCCHInfoPlcchSequenceNumber(const PLCCHInfoPlcchSequenceNumber& pLCCHInfoPlcchSequenceNumber) { *static_cast<PLCCHInfoPlcchSequenceNumber*>(items[0]) = pLCCHInfoPlcchSequenceNumber; }
	void setTimeslotNumber(const TimeslotNumberLCRr4& timeslotNumber) { *static_cast<TimeslotNumberLCRr4*>(items[1]) = timeslotNumber; }
	void setChannelisationCode(const DLTSChannelisationCode& channelisationCode) { *static_cast<DLTSChannelisationCode*>(items[2]) = channelisationCode; }
	void setTpcCommandTargetRate(const TPCCommandTargetRate& tpcCommandTargetRate) { *static_cast<TPCCommandTargetRate*>(items[3]) = tpcCommandTargetRate; }
};

typedef SequenceOf<TDDPRACHCCodeLCRr4, CONSTRAINED, 1, 4> PRACHChanCodesLCRr4;

class PRACHDefinitionLCRr4 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	PRACHDefinitionLCRr4(): Sequence(&theInfo) {}

	void setTimeslot(const TimeslotNumberPRACHLCRr4& timeslot) { *static_cast<TimeslotNumberPRACHLCRr4*>(items[0]) = timeslot; }
	void setPrachChanCodesLCR(const PRACHChanCodesLCRr4& prachChanCodesLCR) { *static_cast<PRACHChanCodesLCRr4*>(items[1]) = prachChanCodesLCR; }
	void setMidambleShiftAndBurstType(const MidambleShiftAndBurstTypeLCRr4& midambleShiftAndBurstType) { *static_cast<MidambleShiftAndBurstTypeLCRr4*>(items[2]) = midambleShiftAndBurstType; }
	void setFpachInfo(const FPACHInfor4& fpachInfo) { *static_cast<FPACHInfor4*>(items[3]) = fpachInfo; }
};

enum PRACHMidambleValues {
	direct_PRACHMidamble = 0,
	direct_Inverted_PRACHMidamble = 1,
};
typedef Enumerated<CONSTRAINED, 1> PRACHMidamble;

typedef SequenceOf<ASCSettingFDD, CONSTRAINED, 1, maxASC> PRACHPartitioningFdd;

typedef SequenceOf<ASCSettingTDD, CONSTRAINED, 1, maxASC> PRACHPartitioningTdd;

class PRACHPartitioning : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PRACHPartitioningChoices {
		pRACHPartitioningFdd = 0,
		pRACHPartitioningTdd = 1,
	};
	static const Info theInfo;
	PRACHPartitioning(): Choice(&theInfo) {}
};

enum SFPRACHValues {
	sfpr32_SFPRACH = 0,
	sfpr64_SFPRACH = 1,
	sfpr128_SFPRACH = 2,
	sfpr256_SFPRACH = 3,
};
typedef Enumerated<CONSTRAINED, 3> SFPRACH;

class PRACHRACHInfoModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	PRACHRACHInfoModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setAvailableSignatures(const AvailableSignatures& availableSignatures) { *static_cast<AvailableSignatures*>(items[0]) = availableSignatures; }
	void setAvailableSF(const SFPRACH& availableSF) { *static_cast<SFPRACH*>(items[1]) = availableSF; }
	void setPreambleScramblingCodeWordNumber(const PreambleScramblingCodeWordNumber& preambleScramblingCodeWordNumber) { *static_cast<PreambleScramblingCodeWordNumber*>(items[2]) = preambleScramblingCodeWordNumber; }
	void setPuncturingLimit(const PuncturingLimit& puncturingLimit) { *static_cast<PuncturingLimit*>(items[3]) = puncturingLimit; }
	void setAvailableSubChannelNumbers(const AvailableSubChannelNumbers& availableSubChannelNumbers) { *static_cast<AvailableSubChannelNumbers*>(items[4]) = availableSubChannelNumbers; }
};

enum TDDPRACHCCode8Values {
	cc8_1_TDDPRACHCCode8 = 0,
	cc8_2_TDDPRACHCCode8 = 1,
	cc8_3_TDDPRACHCCode8 = 2,
	cc8_4_TDDPRACHCCode8 = 3,
	cc8_5_TDDPRACHCCode8 = 4,
	cc8_6_TDDPRACHCCode8 = 5,
	cc8_7_TDDPRACHCCode8 = 6,
	cc8_8_TDDPRACHCCode8 = 7,
};
typedef Enumerated<CONSTRAINED, 7> TDDPRACHCCode8;

typedef SequenceOf<TDDPRACHCCode8, CONSTRAINED, 1, 8> TDDPRACHCCodeListSf8;

enum TDDPRACHCCode16Values {
	cc16_1_TDDPRACHCCode16 = 0,
	cc16_2_TDDPRACHCCode16 = 1,
	cc16_3_TDDPRACHCCode16 = 2,
	cc16_4_TDDPRACHCCode16 = 3,
	cc16_5_TDDPRACHCCode16 = 4,
	cc16_6_TDDPRACHCCode16 = 5,
	cc16_7_TDDPRACHCCode16 = 6,
	cc16_8_TDDPRACHCCode16 = 7,
	cc16_9_TDDPRACHCCode16 = 8,
	cc16_10_TDDPRACHCCode16 = 9,
	cc16_11_TDDPRACHCCode16 = 10,
	cc16_12_TDDPRACHCCode16 = 11,
	cc16_13_TDDPRACHCCode16 = 12,
	cc16_14_TDDPRACHCCode16 = 13,
	cc16_15_TDDPRACHCCode16 = 14,
	cc16_16_TDDPRACHCCode16 = 15,
};
typedef Enumerated<CONSTRAINED, 15> TDDPRACHCCode16;

typedef SequenceOf<TDDPRACHCCode16, CONSTRAINED, 1, 8> TDDPRACHCCodeListSf16;

class TDDPRACHCCodeList : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum TDDPRACHCCodeListChoices {
		tDDPRACHCCodeListSf8 = 0,
		tDDPRACHCCodeListSf16 = 1,
	};
	static const Info theInfo;
	TDDPRACHCCodeList(): Choice(&theInfo) {}
};

class PRACHRACHInfoModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PRACHRACHInfoModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setTimeslot(const TimeslotNumber& timeslot) { *static_cast<TimeslotNumber*>(items[0]) = timeslot; }
	void setChannelisationCodeList(const TDDPRACHCCodeList& channelisationCodeList) { *static_cast<TDDPRACHCCodeList*>(items[1]) = channelisationCodeList; }
	void setPrachMidamble(const PRACHMidamble& prachMidamble) { *static_cast<PRACHMidamble*>(items[2]) = prachMidamble; }
};

class PRACHRACHInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PRACHRACHInfoModeSpecificInfoChoices {
		pRACHRACHInfoModeSpecificInfoFdd = 0,
		pRACHRACHInfoModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	PRACHRACHInfoModeSpecificInfo(): Choice(&theInfo) {}
};

class PRACHRACHInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PRACHRACHInfo(): Sequence(&theInfo) {}

	void setPRACHRACHInfoModeSpecificInfo(const PRACHRACHInfoModeSpecificInfo& pRACHRACHInfoModeSpecificInfo) { *static_cast<PRACHRACHInfoModeSpecificInfo*>(items[0]) = pRACHRACHInfoModeSpecificInfo; }
};

enum TDD768PRACHCCode32Values {
	cc32_1_TDD768PRACHCCode32 = 0,
	cc32_2_TDD768PRACHCCode32 = 1,
	cc32_3_TDD768PRACHCCode32 = 2,
	cc32_4_TDD768PRACHCCode32 = 3,
	cc32_5_TDD768PRACHCCode32 = 4,
	cc32_6_TDD768PRACHCCode32 = 5,
	cc32_7_TDD768PRACHCCode32 = 6,
	cc32_8_TDD768PRACHCCode32 = 7,
	cc32_9_TDD768PRACHCCode32 = 8,
	cc32_10_TDD768PRACHCCode32 = 9,
	cc32_11_TDD768PRACHCCode32 = 10,
	cc32_12_TDD768PRACHCCode32 = 11,
	cc32_13_TDD768PRACHCCode32 = 12,
	cc32_14_TDD768PRACHCCode32 = 13,
	cc32_15_TDD768PRACHCCode32 = 14,
	cc32_16_TDD768PRACHCCode32 = 15,
};
typedef Enumerated<CONSTRAINED, 15> TDD768PRACHCCode32;

typedef SequenceOf<TDD768PRACHCCode32, CONSTRAINED, 1, 16> TDD768PRACHCCodeListSf32;

enum TDD768PRACHCCode16Values {
	cc16_1_TDD768PRACHCCode16 = 0,
	cc16_2_TDD768PRACHCCode16 = 1,
	cc16_3_TDD768PRACHCCode16 = 2,
	cc16_4_TDD768PRACHCCode16 = 3,
	cc16_5_TDD768PRACHCCode16 = 4,
	cc16_6_TDD768PRACHCCode16 = 5,
	cc16_7_TDD768PRACHCCode16 = 6,
	cc16_8_TDD768PRACHCCode16 = 7,
	cc16_9_TDD768PRACHCCode16 = 8,
	cc16_10_TDD768PRACHCCode16 = 9,
	cc16_11_TDD768PRACHCCode16 = 10,
	cc16_12_TDD768PRACHCCode16 = 11,
	cc16_13_TDD768PRACHCCode16 = 12,
	cc16_14_TDD768PRACHCCode16 = 13,
	cc16_15_TDD768PRACHCCode16 = 14,
	cc16_16_TDD768PRACHCCode16 = 15,
};
typedef Enumerated<CONSTRAINED, 15> TDD768PRACHCCode16;

typedef SequenceOf<TDD768PRACHCCode16, CONSTRAINED, 1, 16> TDD768PRACHCCodeListSf16;

class TDD768PRACHCCodeList : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum TDD768PRACHCCodeListChoices {
		tDD768PRACHCCodeListSf32 = 0,
		tDD768PRACHCCodeListSf16 = 1,
	};
	static const Info theInfo;
	TDD768PRACHCCodeList(): Choice(&theInfo) {}
};

class PRACHRACHInfoVHCRr7 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PRACHRACHInfoVHCRr7(): Sequence(&theInfo) {}

	void setTimeslot(const TimeslotNumber& timeslot) { *static_cast<TimeslotNumber*>(items[0]) = timeslot; }
	void setChannelisationCodeList(const TDD768PRACHCCodeList& channelisationCodeList) { *static_cast<TDD768PRACHCCodeList*>(items[1]) = channelisationCodeList; }
	void setPrachMidamble(const PRACHMidamble& prachMidamble) { *static_cast<PRACHMidamble*>(items[2]) = prachMidamble; }
};

class PRACHRACHInfoLCRv770ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PRACHRACHInfoLCRv770ext(): Sequence(&theInfo) {}

	void setERUCCHSyncULCodesBitmap(const SyncULCodesBitmap& eRUCCHSyncULCodesBitmap) { *static_cast<SyncULCodesBitmap*>(items[0]) = eRUCCHSyncULCodesBitmap; }
};

typedef Integer<CONSTRAINED, 0, 62> SYNCULInfor4PrxUpPCHdes;

typedef Integer<CONSTRAINED, 0, 3> SYNCULInfor4PowerRampStep;

enum SYNCULInfor4max_SYNC_UL_TransmissionsValues {
	tr1_SYNCULInfor4max_SYNC_UL_Transmissions = 0,
	tr2_SYNCULInfor4max_SYNC_UL_Transmissions = 1,
	tr4_SYNCULInfor4max_SYNC_UL_Transmissions = 2,
	tr8_SYNCULInfor4max_SYNC_UL_Transmissions = 3,
};
typedef Enumerated<CONSTRAINED, 3> SYNCULInfor4max_SYNC_UL_Transmissions;

typedef Integer<CONSTRAINED, 1, 32> SYNCULInfor4Mmax;

class SYNCULInfor4 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	SYNCULInfor4(): Sequence(&theInfo) {}

	void setSyncULCodesBitmap(const SyncULCodesBitmap& syncULCodesBitmap) { *static_cast<SyncULCodesBitmap*>(items[0]) = syncULCodesBitmap; }
	void setSYNCULInfor4PrxUpPCHdes(const SYNCULInfor4PrxUpPCHdes& sYNCULInfor4PrxUpPCHdes) { *static_cast<SYNCULInfor4PrxUpPCHdes*>(items[1]) = sYNCULInfor4PrxUpPCHdes; }
	void setSYNCULInfor4PowerRampStep(const SYNCULInfor4PowerRampStep& sYNCULInfor4PowerRampStep) { *static_cast<SYNCULInfor4PowerRampStep*>(items[2]) = sYNCULInfor4PowerRampStep; }
	void setSYNCULInfor4max_SYNC_UL_Transmissions(const SYNCULInfor4max_SYNC_UL_Transmissions& sYNCULInfor4max_SYNC_UL_Transmissions) { *static_cast<SYNCULInfor4max_SYNC_UL_Transmissions*>(items[3]) = sYNCULInfor4max_SYNC_UL_Transmissions; }
	void setSYNCULInfor4Mmax(const SYNCULInfor4Mmax& sYNCULInfor4Mmax) { *static_cast<SYNCULInfor4Mmax*>(items[4]) = sYNCULInfor4Mmax; }
};

typedef SequenceOf<PRACHDefinitionLCRr4, CONSTRAINED, 1, maxPRACH_FPACH> PRACHRACHInfoLCRr4PrachDefinitionList;

class PRACHRACHInfoLCRr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PRACHRACHInfoLCRr4(): Sequence(&theInfo) {}

	void setSyncULInfo(const SYNCULInfor4& syncULInfo) { *static_cast<SYNCULInfor4*>(items[0]) = syncULInfo; }
	void setPRACHRACHInfoLCRr4PrachDefinitionList(const PRACHRACHInfoLCRr4PrachDefinitionList& pRACHRACHInfoLCRr4PrachDefinitionList) { *static_cast<PRACHRACHInfoLCRr4PrachDefinitionList*>(items[1]) = pRACHRACHInfoLCRr4PrachDefinitionList; }
};

class PRACHSystemInformationModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	PRACHSystemInformationModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHTXPower(const PrimaryCPICHTXPower& primaryCPICHTXPower) { *static_cast<PrimaryCPICHTXPower*>(items[0]) = primaryCPICHTXPower; }
	void setConstantValue(const ConstantValue& constantValue) { *static_cast<ConstantValue*>(items[1]) = constantValue; }
	void setPrachPowerOffset(const PRACHPowerOffset& prachPowerOffset) { *static_cast<PRACHPowerOffset*>(items[2]) = prachPowerOffset; }
	void setRachTransmissionParameters(const RACHTransmissionParameters& rachTransmissionParameters) { *static_cast<RACHTransmissionParameters*>(items[3]) = rachTransmissionParameters; }
	void setAichInfo(const AICHInfo& aichInfo) { *static_cast<AICHInfo*>(items[4]) = aichInfo; }
};

typedef Null PRACHSystemInformationModeSpecificInfoTdd;

class PRACHSystemInformationModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PRACHSystemInformationModeSpecificInfoChoices {
		pRACHSystemInformationModeSpecificInfoFdd = 0,
		pRACHSystemInformationModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	PRACHSystemInformationModeSpecificInfo(): Choice(&theInfo) {}
};

class PRACHSystemInformation : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	PRACHSystemInformation(): Sequence(&theInfo) {}

	void setPrachRACHInfo(const PRACHRACHInfo& prachRACHInfo) { *static_cast<PRACHRACHInfo*>(items[0]) = prachRACHInfo; }
	void setTransportChannelIdentity(const TransportChannelIdentity& transportChannelIdentity) { *static_cast<TransportChannelIdentity*>(items[1]) = transportChannelIdentity; }
	void setRachTransportFormatSet(const TransportFormatSet& rachTransportFormatSet) { *static_cast<TransportFormatSet*>(items[2]) = rachTransportFormatSet; }
	void setRachTFCS(const TFCS& rachTFCS) { *static_cast<TFCS*>(items[3]) = rachTFCS; }
	void setPrachPartitioning(const PRACHPartitioning& prachPartitioning) { *static_cast<PRACHPartitioning*>(items[4]) = prachPartitioning; }
	void setPersistenceScalingFactorList(const PersistenceScalingFactorList& persistenceScalingFactorList) { *static_cast<PersistenceScalingFactorList*>(items[5]) = persistenceScalingFactorList; }
	void setAcToASCMappingTable(const ACToASCMappingTable& acToASCMappingTable) { *static_cast<ACToASCMappingTable*>(items[6]) = acToASCMappingTable; }
	void setPRACHSystemInformationModeSpecificInfo(const PRACHSystemInformationModeSpecificInfo& pRACHSystemInformationModeSpecificInfo) { *static_cast<PRACHSystemInformationModeSpecificInfo*>(items[7]) = pRACHSystemInformationModeSpecificInfo; }
};

class PRACHSystemInformationVHCRr7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PRACHSystemInformationVHCRr7(): Sequence(&theInfo) {}

	void setPrachRACHInfo(const PRACHRACHInfoVHCRr7& prachRACHInfo) { *static_cast<PRACHRACHInfoVHCRr7*>(items[0]) = prachRACHInfo; }
	void setPrachPartitioning(const PRACHPartitioningr7& prachPartitioning) { *static_cast<PRACHPartitioningr7*>(items[1]) = prachPartitioning; }
};

class PRACHSystemInformationLCRr4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PRACHSystemInformationLCRr4(): Sequence(&theInfo) {}

	void setPrachRACHInfoLCR(const PRACHRACHInfoLCRr4& prachRACHInfoLCR) { *static_cast<PRACHRACHInfoLCRr4*>(items[0]) = prachRACHInfoLCR; }
	void setRachTransportFormatSetLCR(const TransportFormatSetLCR& rachTransportFormatSetLCR) { *static_cast<TransportFormatSetLCR*>(items[1]) = rachTransportFormatSetLCR; }
	void setPrachPartitioningLCR(const PRACHPartitioningLCRr4& prachPartitioningLCR) { *static_cast<PRACHPartitioningLCRr4*>(items[2]) = prachPartitioningLCR; }
};

class PRACHSystemInformationLCRv770ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PRACHSystemInformationLCRv770ext(): Sequence(&theInfo) {}

	void setPrachRACHInfoLCR(const PRACHRACHInfoLCRv770ext& prachRACHInfoLCR) { *static_cast<PRACHRACHInfoLCRv770ext*>(items[0]) = prachRACHInfoLCR; }
};

typedef SequenceOf<PRACHSystemInformation, CONSTRAINED, 1, maxPRACH> PRACHSystemInformationList;

typedef SequenceOf<PRACHSystemInformationVHCRr7, CONSTRAINED, 1, maxPRACH> PRACHSystemInformationListVHCRr7;

typedef SequenceOf<PRACHSystemInformationLCRr4, CONSTRAINED, 1, maxPRACH> PRACHSystemInformationListLCRr4;

typedef SequenceOf<PRACHSystemInformationLCRv770ext, CONSTRAINED, 1, maxPRACH> PRACHSystemInformationListLCRv770ext;

typedef Boolean PrimaryCCPCHInfoLCRr4TstdIndicator;

typedef Boolean PrimaryCCPCHInfoLCRr4SctdIndicator;

class PrimaryCCPCHInfoLCRr4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PrimaryCCPCHInfoLCRr4(): Sequence(&theInfo) {}

	void setPrimaryCCPCHInfoLCRr4TstdIndicator(const PrimaryCCPCHInfoLCRr4TstdIndicator& primaryCCPCHInfoLCRr4TstdIndicator) { *static_cast<PrimaryCCPCHInfoLCRr4TstdIndicator*>(items[0]) = primaryCCPCHInfoLCRr4TstdIndicator; }
	void setCellParametersID(const CellParametersID& cellParametersID) { *static_cast<CellParametersID*>(items[1]) = cellParametersID; }
	void setPrimaryCCPCHInfoLCRr4SctdIndicator(const PrimaryCCPCHInfoLCRr4SctdIndicator& primaryCCPCHInfoLCRr4SctdIndicator) { *static_cast<PrimaryCCPCHInfoLCRr4SctdIndicator*>(items[2]) = primaryCCPCHInfoLCRr4SctdIndicator; }
};

typedef Boolean PrimaryCCPCHInfoLCRr4extTstdIndicator;

class PrimaryCCPCHInfoLCRr4ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PrimaryCCPCHInfoLCRr4ext(): Sequence(&theInfo) {}

	void setPrimaryCCPCHInfoLCRr4extTstdIndicator(const PrimaryCCPCHInfoLCRr4extTstdIndicator& primaryCCPCHInfoLCRr4extTstdIndicator) { *static_cast<PrimaryCCPCHInfoLCRr4extTstdIndicator*>(items[0]) = primaryCCPCHInfoLCRr4extTstdIndicator; }
};

typedef Null PUSCHCapacityAllocationInfoPuschAllocationPuschAllocationPending;

typedef Integer<CONSTRAINED, 1, hiPUSCHidentities> PUSCHIdentity;

class PUSCHCapacityAllocationInfoPuschAllocationPuschAllocationAssignmentConfigurationOldConfiguration : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PUSCHCapacityAllocationInfoPuschAllocationPuschAllocationAssignmentConfigurationOldConfiguration(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setPuschIdentity(const PUSCHIdentity& puschIdentity) { *static_cast<PUSCHIdentity*>(items[1]) = puschIdentity; }
};

typedef Boolean UplinkTimeslotsCodesDynamicSFusage;

typedef SequenceOf<ULTSChannelisationCode, CONSTRAINED, 1, 2> ULTSChannelisationCodeList;

typedef Null UplinkTimeslotsCodesMoreTimeslotsNoMore;

typedef Integer<CONSTRAINED, 1, maxTS_1> UplinkTimeslotsCodesMoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots;

class UplinkTimeslotsCodesMoreTimeslotsAdditionalTimeslotsConsecutive : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UplinkTimeslotsCodesMoreTimeslotsAdditionalTimeslotsConsecutive(): Sequence(&theInfo) {}

	void setUplinkTimeslotsCodesMoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots(const UplinkTimeslotsCodesMoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots& uplinkTimeslotsCodesMoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots) { *static_cast<UplinkTimeslotsCodesMoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots*>(items[0]) = uplinkTimeslotsCodesMoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots; }
};

class UplinkAdditionalTimeslotsParametersSameAsLast : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UplinkAdditionalTimeslotsParametersSameAsLast(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumber& timeslotNumber) { *static_cast<TimeslotNumber*>(items[0]) = timeslotNumber; }
};

class UplinkAdditionalTimeslotsParametersNewParameters : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UplinkAdditionalTimeslotsParametersNewParameters(): Sequence(&theInfo) {}

	void setIndividualTimeslotInfo(const IndividualTimeslotInfo& individualTimeslotInfo) { *static_cast<IndividualTimeslotInfo*>(items[0]) = individualTimeslotInfo; }
	void setUlTSChannelisationCodeList(const ULTSChannelisationCodeList& ulTSChannelisationCodeList) { *static_cast<ULTSChannelisationCodeList*>(items[1]) = ulTSChannelisationCodeList; }
};

class UplinkAdditionalTimeslotsParameters : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UplinkAdditionalTimeslotsParametersChoices {
		uplinkAdditionalTimeslotsParametersSameAsLast = 0,
		uplinkAdditionalTimeslotsParametersNewParameters = 1,
	};
	static const Info theInfo;
	UplinkAdditionalTimeslotsParameters(): Choice(&theInfo) {}
};

class UplinkAdditionalTimeslots : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UplinkAdditionalTimeslots(): Sequence(&theInfo) {}

	void setUplinkAdditionalTimeslotsParameters(const UplinkAdditionalTimeslotsParameters& uplinkAdditionalTimeslotsParameters) { *static_cast<UplinkAdditionalTimeslotsParameters*>(items[0]) = uplinkAdditionalTimeslotsParameters; }
};

typedef SequenceOf<UplinkAdditionalTimeslots, CONSTRAINED, 1, maxTS_1> UplinkTimeslotsCodesMoreTimeslotsAdditionalTimeslotsTimeslotList;

class UplinkTimeslotsCodesMoreTimeslotsAdditionalTimeslots : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UplinkTimeslotsCodesMoreTimeslotsAdditionalTimeslotsChoices {
		uplinkTimeslotsCodesMoreTimeslotsAdditionalTimeslotsConsecutive = 0,
		uplinkTimeslotsCodesMoreTimeslotsAdditionalTimeslotsTimeslotList = 1,
	};
	static const Info theInfo;
	UplinkTimeslotsCodesMoreTimeslotsAdditionalTimeslots(): Choice(&theInfo) {}
};

class UplinkTimeslotsCodesMoreTimeslots : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UplinkTimeslotsCodesMoreTimeslotsChoices {
		uplinkTimeslotsCodesMoreTimeslotsNoMore = 0,
		uplinkTimeslotsCodesMoreTimeslotsAdditionalTimeslots = 1,
	};
	static const Info theInfo;
	UplinkTimeslotsCodesMoreTimeslots(): Choice(&theInfo) {}
};

class UplinkTimeslotsCodes : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UplinkTimeslotsCodes(): Sequence(&theInfo) {}

	void setUplinkTimeslotsCodesDynamicSFusage(const UplinkTimeslotsCodesDynamicSFusage& uplinkTimeslotsCodesDynamicSFusage) { *static_cast<UplinkTimeslotsCodesDynamicSFusage*>(items[0]) = uplinkTimeslotsCodesDynamicSFusage; }
	void setFirstIndividualTimeslotInfo(const IndividualTimeslotInfo& firstIndividualTimeslotInfo) { *static_cast<IndividualTimeslotInfo*>(items[1]) = firstIndividualTimeslotInfo; }
	void setUlTSChannelisationCodeList(const ULTSChannelisationCodeList& ulTSChannelisationCodeList) { *static_cast<ULTSChannelisationCodeList*>(items[2]) = ulTSChannelisationCodeList; }
	void setUplinkTimeslotsCodesMoreTimeslots(const UplinkTimeslotsCodesMoreTimeslots& uplinkTimeslotsCodesMoreTimeslots) { *static_cast<UplinkTimeslotsCodesMoreTimeslots*>(items[3]) = uplinkTimeslotsCodesMoreTimeslots; }
};

class PUSCHInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PUSCHInfo(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setCommonTimeslotInfo(const CommonTimeslotInfo& commonTimeslotInfo) { *static_cast<CommonTimeslotInfo*>(items[1]) = commonTimeslotInfo; }
	void setPuschTimeslotsCodes(const UplinkTimeslotsCodes& puschTimeslotsCodes) { *static_cast<UplinkTimeslotsCodes*>(items[2]) = puschTimeslotsCodes; }
};

class PUSCHCapacityAllocationInfoPuschAllocationPuschAllocationAssignmentConfigurationNewConfiguration : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PUSCHCapacityAllocationInfoPuschAllocationPuschAllocationAssignmentConfigurationNewConfiguration(): Sequence(&theInfo) {}

	void setPuschInfo(const PUSCHInfo& puschInfo) { *static_cast<PUSCHInfo*>(items[0]) = puschInfo; }
	void setPuschIdentity(const PUSCHIdentity& puschIdentity) { *static_cast<PUSCHIdentity*>(items[1]) = puschIdentity; }
};

class PUSCHCapacityAllocationInfoPuschAllocationPuschAllocationAssignmentConfiguration : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PUSCHCapacityAllocationInfoPuschAllocationPuschAllocationAssignmentConfigurationChoices {
		pUSCHCapacityAllocationInfoPuschAllocationPuschAllocationAssignmentConfigurationOldConfiguration = 0,
		pUSCHCapacityAllocationInfoPuschAllocationPuschAllocationAssignmentConfigurationNewConfiguration = 1,
	};
	static const Info theInfo;
	PUSCHCapacityAllocationInfoPuschAllocationPuschAllocationAssignmentConfiguration(): Choice(&theInfo) {}
};

class PUSCHCapacityAllocationInfoPuschAllocationPuschAllocationAssignment : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PUSCHCapacityAllocationInfoPuschAllocationPuschAllocationAssignment(): Sequence(&theInfo) {}

	void setPuschAllocationPeriodInfo(const AllocationPeriodInfo& puschAllocationPeriodInfo) { *static_cast<AllocationPeriodInfo*>(items[0]) = puschAllocationPeriodInfo; }
	void setPuschPowerControlInfo(const ULTargetSIR& puschPowerControlInfo) { *static_cast<ULTargetSIR*>(items[1]) = puschPowerControlInfo; }
	void setPUSCHCapacityAllocationInfoPuschAllocationPuschAllocationAssignmentConfiguration(const PUSCHCapacityAllocationInfoPuschAllocationPuschAllocationAssignmentConfiguration& pUSCHCapacityAllocationInfoPuschAllocationPuschAllocationAssignmentConfiguration) { *static_cast<PUSCHCapacityAllocationInfoPuschAllocationPuschAllocationAssignmentConfiguration*>(items[2]) = pUSCHCapacityAllocationInfoPuschAllocationPuschAllocationAssignmentConfiguration; }
};

class PUSCHCapacityAllocationInfoPuschAllocation : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PUSCHCapacityAllocationInfoPuschAllocationChoices {
		pUSCHCapacityAllocationInfoPuschAllocationPuschAllocationPending = 0,
		pUSCHCapacityAllocationInfoPuschAllocationPuschAllocationAssignment = 1,
	};
	static const Info theInfo;
	PUSCHCapacityAllocationInfoPuschAllocation(): Choice(&theInfo) {}
};

class PUSCHCapacityAllocationInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PUSCHCapacityAllocationInfo(): Sequence(&theInfo) {}

	void setPUSCHCapacityAllocationInfoPuschAllocation(const PUSCHCapacityAllocationInfoPuschAllocation& pUSCHCapacityAllocationInfoPuschAllocation) { *static_cast<PUSCHCapacityAllocationInfoPuschAllocation*>(items[0]) = pUSCHCapacityAllocationInfoPuschAllocation; }
};

typedef Null PUSCHCapacityAllocationInfor4PuschAllocationPuschAllocationPending;

typedef Null PUSCHPowerControlInfor4TddOptionTdd384;

class PUSCHPowerControlInfor4TddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PUSCHPowerControlInfor4TddOptionTdd128(): Sequence(&theInfo) {}

	void setTpcStepSize(const TPCStepSizeTDD& tpcStepSize) { *static_cast<TPCStepSizeTDD*>(items[0]) = tpcStepSize; }
};

class PUSCHPowerControlInfor4TddOption : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PUSCHPowerControlInfor4TddOptionChoices {
		pUSCHPowerControlInfor4TddOptionTdd384 = 0,
		pUSCHPowerControlInfor4TddOptionTdd128 = 1,
	};
	static const Info theInfo;
	PUSCHPowerControlInfor4TddOption(): Choice(&theInfo) {}
};

class PUSCHPowerControlInfor4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PUSCHPowerControlInfor4(): Sequence(&theInfo) {}

	void setUlTargetSIR(const ULTargetSIR& ulTargetSIR) { *static_cast<ULTargetSIR*>(items[0]) = ulTargetSIR; }
	void setPUSCHPowerControlInfor4TddOption(const PUSCHPowerControlInfor4TddOption& pUSCHPowerControlInfor4TddOption) { *static_cast<PUSCHPowerControlInfor4TddOption*>(items[1]) = pUSCHPowerControlInfor4TddOption; }
};

class PUSCHCapacityAllocationInfor4PuschAllocationPuschAllocationAssignmentConfigurationOldConfiguration : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PUSCHCapacityAllocationInfor4PuschAllocationPuschAllocationAssignmentConfigurationOldConfiguration(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setPuschIdentity(const PUSCHIdentity& puschIdentity) { *static_cast<PUSCHIdentity*>(items[1]) = puschIdentity; }
};

class PUSCHInfor4TddOptionTdd384 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PUSCHInfor4TddOptionTdd384(): Sequence(&theInfo) {}

	void setPuschTimeslotsCodes(const UplinkTimeslotsCodes& puschTimeslotsCodes) { *static_cast<UplinkTimeslotsCodes*>(items[0]) = puschTimeslotsCodes; }
};

typedef Boolean UplinkTimeslotsCodesLCRr4DynamicSFusage;

typedef Null UplinkTimeslotsCodesLCRr4MoreTimeslotsNoMore;

typedef Integer<CONSTRAINED, 1, maxTS_LCR_1> UplinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots;

class UplinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslotsConsecutive : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UplinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslotsConsecutive(): Sequence(&theInfo) {}

	void setUplinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots(const UplinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots& uplinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots) { *static_cast<UplinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots*>(items[0]) = uplinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots; }
};

class UplinkAdditionalTimeslotsLCRr4ParametersSameAsLast : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UplinkAdditionalTimeslotsLCRr4ParametersSameAsLast(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumber& timeslotNumber) { *static_cast<TimeslotNumber*>(items[0]) = timeslotNumber; }
};

class UplinkAdditionalTimeslotsLCRr4ParametersNewParameters : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UplinkAdditionalTimeslotsLCRr4ParametersNewParameters(): Sequence(&theInfo) {}

	void setIndividualTimeslotInfo(const IndividualTimeslotInfoLCRr4& individualTimeslotInfo) { *static_cast<IndividualTimeslotInfoLCRr4*>(items[0]) = individualTimeslotInfo; }
	void setUlTSChannelisationCodeList(const ULTSChannelisationCodeList& ulTSChannelisationCodeList) { *static_cast<ULTSChannelisationCodeList*>(items[1]) = ulTSChannelisationCodeList; }
};

class UplinkAdditionalTimeslotsLCRr4Parameters : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UplinkAdditionalTimeslotsLCRr4ParametersChoices {
		uplinkAdditionalTimeslotsLCRr4ParametersSameAsLast = 0,
		uplinkAdditionalTimeslotsLCRr4ParametersNewParameters = 1,
	};
	static const Info theInfo;
	UplinkAdditionalTimeslotsLCRr4Parameters(): Choice(&theInfo) {}
};

class UplinkAdditionalTimeslotsLCRr4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UplinkAdditionalTimeslotsLCRr4(): Sequence(&theInfo) {}

	void setUplinkAdditionalTimeslotsLCRr4Parameters(const UplinkAdditionalTimeslotsLCRr4Parameters& uplinkAdditionalTimeslotsLCRr4Parameters) { *static_cast<UplinkAdditionalTimeslotsLCRr4Parameters*>(items[0]) = uplinkAdditionalTimeslotsLCRr4Parameters; }
};

typedef SequenceOf<UplinkAdditionalTimeslotsLCRr4, CONSTRAINED, 1, maxTS_LCR_1> UplinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslotsTimeslotList;

class UplinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslots : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UplinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslotsChoices {
		uplinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslotsConsecutive = 0,
		uplinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslotsTimeslotList = 1,
	};
	static const Info theInfo;
	UplinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslots(): Choice(&theInfo) {}
};

class UplinkTimeslotsCodesLCRr4MoreTimeslots : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UplinkTimeslotsCodesLCRr4MoreTimeslotsChoices {
		uplinkTimeslotsCodesLCRr4MoreTimeslotsNoMore = 0,
		uplinkTimeslotsCodesLCRr4MoreTimeslotsAdditionalTimeslots = 1,
	};
	static const Info theInfo;
	UplinkTimeslotsCodesLCRr4MoreTimeslots(): Choice(&theInfo) {}
};

class UplinkTimeslotsCodesLCRr4 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UplinkTimeslotsCodesLCRr4(): Sequence(&theInfo) {}

	void setUplinkTimeslotsCodesLCRr4DynamicSFusage(const UplinkTimeslotsCodesLCRr4DynamicSFusage& uplinkTimeslotsCodesLCRr4DynamicSFusage) { *static_cast<UplinkTimeslotsCodesLCRr4DynamicSFusage*>(items[0]) = uplinkTimeslotsCodesLCRr4DynamicSFusage; }
	void setFirstIndividualTimeslotInfo(const IndividualTimeslotInfoLCRr4& firstIndividualTimeslotInfo) { *static_cast<IndividualTimeslotInfoLCRr4*>(items[1]) = firstIndividualTimeslotInfo; }
	void setUlTSChannelisationCodeList(const ULTSChannelisationCodeList& ulTSChannelisationCodeList) { *static_cast<ULTSChannelisationCodeList*>(items[2]) = ulTSChannelisationCodeList; }
	void setUplinkTimeslotsCodesLCRr4MoreTimeslots(const UplinkTimeslotsCodesLCRr4MoreTimeslots& uplinkTimeslotsCodesLCRr4MoreTimeslots) { *static_cast<UplinkTimeslotsCodesLCRr4MoreTimeslots*>(items[3]) = uplinkTimeslotsCodesLCRr4MoreTimeslots; }
};

class PUSCHInfor4TddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PUSCHInfor4TddOptionTdd128(): Sequence(&theInfo) {}

	void setPuschTimeslotsCodes(const UplinkTimeslotsCodesLCRr4& puschTimeslotsCodes) { *static_cast<UplinkTimeslotsCodesLCRr4*>(items[0]) = puschTimeslotsCodes; }
};

class PUSCHInfor4TddOption : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PUSCHInfor4TddOptionChoices {
		pUSCHInfor4TddOptionTdd384 = 0,
		pUSCHInfor4TddOptionTdd128 = 1,
	};
	static const Info theInfo;
	PUSCHInfor4TddOption(): Choice(&theInfo) {}
};

class PUSCHInfor4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PUSCHInfor4(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setCommonTimeslotInfo(const CommonTimeslotInfo& commonTimeslotInfo) { *static_cast<CommonTimeslotInfo*>(items[1]) = commonTimeslotInfo; }
	void setPUSCHInfor4TddOption(const PUSCHInfor4TddOption& pUSCHInfor4TddOption) { *static_cast<PUSCHInfor4TddOption*>(items[2]) = pUSCHInfor4TddOption; }
};

class PUSCHCapacityAllocationInfor4PuschAllocationPuschAllocationAssignmentConfigurationNewConfiguration : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PUSCHCapacityAllocationInfor4PuschAllocationPuschAllocationAssignmentConfigurationNewConfiguration(): Sequence(&theInfo) {}

	void setPuschInfo(const PUSCHInfor4& puschInfo) { *static_cast<PUSCHInfor4*>(items[0]) = puschInfo; }
	void setPuschIdentity(const PUSCHIdentity& puschIdentity) { *static_cast<PUSCHIdentity*>(items[1]) = puschIdentity; }
};

class PUSCHCapacityAllocationInfor4PuschAllocationPuschAllocationAssignmentConfiguration : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PUSCHCapacityAllocationInfor4PuschAllocationPuschAllocationAssignmentConfigurationChoices {
		pUSCHCapacityAllocationInfor4PuschAllocationPuschAllocationAssignmentConfigurationOldConfiguration = 0,
		pUSCHCapacityAllocationInfor4PuschAllocationPuschAllocationAssignmentConfigurationNewConfiguration = 1,
	};
	static const Info theInfo;
	PUSCHCapacityAllocationInfor4PuschAllocationPuschAllocationAssignmentConfiguration(): Choice(&theInfo) {}
};

class PUSCHCapacityAllocationInfor4PuschAllocationPuschAllocationAssignment : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PUSCHCapacityAllocationInfor4PuschAllocationPuschAllocationAssignment(): Sequence(&theInfo) {}

	void setPuschAllocationPeriodInfo(const AllocationPeriodInfo& puschAllocationPeriodInfo) { *static_cast<AllocationPeriodInfo*>(items[0]) = puschAllocationPeriodInfo; }
	void setPuschPowerControlInfo(const PUSCHPowerControlInfor4& puschPowerControlInfo) { *static_cast<PUSCHPowerControlInfor4*>(items[1]) = puschPowerControlInfo; }
	void setPUSCHCapacityAllocationInfor4PuschAllocationPuschAllocationAssignmentConfiguration(const PUSCHCapacityAllocationInfor4PuschAllocationPuschAllocationAssignmentConfiguration& pUSCHCapacityAllocationInfor4PuschAllocationPuschAllocationAssignmentConfiguration) { *static_cast<PUSCHCapacityAllocationInfor4PuschAllocationPuschAllocationAssignmentConfiguration*>(items[2]) = pUSCHCapacityAllocationInfor4PuschAllocationPuschAllocationAssignmentConfiguration; }
};

class PUSCHCapacityAllocationInfor4PuschAllocation : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PUSCHCapacityAllocationInfor4PuschAllocationChoices {
		pUSCHCapacityAllocationInfor4PuschAllocationPuschAllocationPending = 0,
		pUSCHCapacityAllocationInfor4PuschAllocationPuschAllocationAssignment = 1,
	};
	static const Info theInfo;
	PUSCHCapacityAllocationInfor4PuschAllocation(): Choice(&theInfo) {}
};

class PUSCHCapacityAllocationInfor4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PUSCHCapacityAllocationInfor4(): Sequence(&theInfo) {}

	void setPUSCHCapacityAllocationInfor4PuschAllocation(const PUSCHCapacityAllocationInfor4PuschAllocation& pUSCHCapacityAllocationInfor4PuschAllocation) { *static_cast<PUSCHCapacityAllocationInfor4PuschAllocation*>(items[0]) = pUSCHCapacityAllocationInfor4PuschAllocation; }
};

typedef Null PUSCHCapacityAllocationInfor7PuschAllocationPuschAllocationPending;

typedef Null PUSCHPowerControlInfor7TddOptionTdd384;

typedef Null PUSCHPowerControlInfor7TddOptionTdd768;

class PUSCHPowerControlInfor7TddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PUSCHPowerControlInfor7TddOptionTdd128(): Sequence(&theInfo) {}

	void setTpcStepSize(const TPCStepSizeTDD& tpcStepSize) { *static_cast<TPCStepSizeTDD*>(items[0]) = tpcStepSize; }
};

class PUSCHPowerControlInfor7TddOption : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum PUSCHPowerControlInfor7TddOptionChoices {
		pUSCHPowerControlInfor7TddOptionTdd384 = 0,
		pUSCHPowerControlInfor7TddOptionTdd768 = 1,
		pUSCHPowerControlInfor7TddOptionTdd128 = 2,
	};
	static const Info theInfo;
	PUSCHPowerControlInfor7TddOption(): Choice(&theInfo) {}
};

class PUSCHPowerControlInfor7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PUSCHPowerControlInfor7(): Sequence(&theInfo) {}

	void setUlTargetSIR(const ULTargetSIR& ulTargetSIR) { *static_cast<ULTargetSIR*>(items[0]) = ulTargetSIR; }
	void setPUSCHPowerControlInfor7TddOption(const PUSCHPowerControlInfor7TddOption& pUSCHPowerControlInfor7TddOption) { *static_cast<PUSCHPowerControlInfor7TddOption*>(items[1]) = pUSCHPowerControlInfor7TddOption; }
};

class PUSCHCapacityAllocationInfor7PuschAllocationPuschAllocationAssignmentConfigurationOldConfiguration : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PUSCHCapacityAllocationInfor7PuschAllocationPuschAllocationAssignmentConfigurationOldConfiguration(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setPuschIdentity(const PUSCHIdentity& puschIdentity) { *static_cast<PUSCHIdentity*>(items[1]) = puschIdentity; }
};

typedef Boolean UplinkTimeslotsCodesVHCRDynamicSFusage;

enum ULTSChannelisationCodeVHCRValues {
	cc1_1_ULTSChannelisationCodeVHCR = 0,
	cc2_1_ULTSChannelisationCodeVHCR = 1,
	cc2_2_ULTSChannelisationCodeVHCR = 2,
	cc4_1_ULTSChannelisationCodeVHCR = 3,
	cc4_2_ULTSChannelisationCodeVHCR = 4,
	cc4_3_ULTSChannelisationCodeVHCR = 5,
	cc4_4_ULTSChannelisationCodeVHCR = 6,
	cc8_1_ULTSChannelisationCodeVHCR = 7,
	cc8_2_ULTSChannelisationCodeVHCR = 8,
	cc8_3_ULTSChannelisationCodeVHCR = 9,
	cc8_4_ULTSChannelisationCodeVHCR = 10,
	cc8_5_ULTSChannelisationCodeVHCR = 11,
	cc8_6_ULTSChannelisationCodeVHCR = 12,
	cc8_7_ULTSChannelisationCodeVHCR = 13,
	cc8_8_ULTSChannelisationCodeVHCR = 14,
	cc16_1_ULTSChannelisationCodeVHCR = 15,
	cc16_2_ULTSChannelisationCodeVHCR = 16,
	cc16_3_ULTSChannelisationCodeVHCR = 17,
	cc16_4_ULTSChannelisationCodeVHCR = 18,
	cc16_5_ULTSChannelisationCodeVHCR = 19,
	cc16_6_ULTSChannelisationCodeVHCR = 20,
	cc16_7_ULTSChannelisationCodeVHCR = 21,
	cc16_8_ULTSChannelisationCodeVHCR = 22,
	cc16_9_ULTSChannelisationCodeVHCR = 23,
	cc16_10_ULTSChannelisationCodeVHCR = 24,
	cc16_11_ULTSChannelisationCodeVHCR = 25,
	cc16_12_ULTSChannelisationCodeVHCR = 26,
	cc16_13_ULTSChannelisationCodeVHCR = 27,
	cc16_14_ULTSChannelisationCodeVHCR = 28,
	cc16_15_ULTSChannelisationCodeVHCR = 29,
	cc16_16_ULTSChannelisationCodeVHCR = 30,
	cc32_1_ULTSChannelisationCodeVHCR = 31,
	cc32_2_ULTSChannelisationCodeVHCR = 32,
	cc32_3_ULTSChannelisationCodeVHCR = 33,
	cc32_4_ULTSChannelisationCodeVHCR = 34,
	cc32_5_ULTSChannelisationCodeVHCR = 35,
	cc32_6_ULTSChannelisationCodeVHCR = 36,
	cc32_7_ULTSChannelisationCodeVHCR = 37,
	cc32_8_ULTSChannelisationCodeVHCR = 38,
	cc32_9_ULTSChannelisationCodeVHCR = 39,
	cc32_10_ULTSChannelisationCodeVHCR = 40,
	cc32_11_ULTSChannelisationCodeVHCR = 41,
	cc32_12_ULTSChannelisationCodeVHCR = 42,
	cc32_13_ULTSChannelisationCodeVHCR = 43,
	cc32_14_ULTSChannelisationCodeVHCR = 44,
	cc32_15_ULTSChannelisationCodeVHCR = 45,
	cc32_16_ULTSChannelisationCodeVHCR = 46,
	cc32_17_ULTSChannelisationCodeVHCR = 47,
	cc32_18_ULTSChannelisationCodeVHCR = 48,
	cc32_19_ULTSChannelisationCodeVHCR = 49,
	cc32_20_ULTSChannelisationCodeVHCR = 50,
	cc32_21_ULTSChannelisationCodeVHCR = 51,
	cc32_22_ULTSChannelisationCodeVHCR = 52,
	cc32_23_ULTSChannelisationCodeVHCR = 53,
	cc32_24_ULTSChannelisationCodeVHCR = 54,
	cc32_25_ULTSChannelisationCodeVHCR = 55,
	cc32_26_ULTSChannelisationCodeVHCR = 56,
	cc32_27_ULTSChannelisationCodeVHCR = 57,
	cc32_28_ULTSChannelisationCodeVHCR = 58,
	cc32_29_ULTSChannelisationCodeVHCR = 59,
	cc32_30_ULTSChannelisationCodeVHCR = 60,
	cc32_31_ULTSChannelisationCodeVHCR = 61,
	cc32_32_ULTSChannelisationCodeVHCR = 62,
};
typedef Enumerated<CONSTRAINED, 62> ULTSChannelisationCodeVHCR;

typedef SequenceOf<ULTSChannelisationCodeVHCR, CONSTRAINED, 1, 2> ULTSChannelisationCodeListVHCR;

typedef Null UplinkTimeslotsCodesVHCRMoreTimeslotsNoMore;

typedef Integer<CONSTRAINED, 1, maxTS_1> UplinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots;

class UplinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslotsConsecutive : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UplinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslotsConsecutive(): Sequence(&theInfo) {}

	void setUplinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots(const UplinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots& uplinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots) { *static_cast<UplinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots*>(items[0]) = uplinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots; }
};

class UplinkAdditionalTimeslotsVHCRParametersSameAsLast : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UplinkAdditionalTimeslotsVHCRParametersSameAsLast(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumber& timeslotNumber) { *static_cast<TimeslotNumber*>(items[0]) = timeslotNumber; }
};

class UplinkAdditionalTimeslotsVHCRParametersNewParameters : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UplinkAdditionalTimeslotsVHCRParametersNewParameters(): Sequence(&theInfo) {}

	void setIndividualTimeslotInfo(const IndividualTimeslotInfoVHCR& individualTimeslotInfo) { *static_cast<IndividualTimeslotInfoVHCR*>(items[0]) = individualTimeslotInfo; }
	void setUlTSChannelisationCodeList(const ULTSChannelisationCodeList& ulTSChannelisationCodeList) { *static_cast<ULTSChannelisationCodeList*>(items[1]) = ulTSChannelisationCodeList; }
};

class UplinkAdditionalTimeslotsVHCRParameters : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UplinkAdditionalTimeslotsVHCRParametersChoices {
		uplinkAdditionalTimeslotsVHCRParametersSameAsLast = 0,
		uplinkAdditionalTimeslotsVHCRParametersNewParameters = 1,
	};
	static const Info theInfo;
	UplinkAdditionalTimeslotsVHCRParameters(): Choice(&theInfo) {}
};

class UplinkAdditionalTimeslotsVHCR : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UplinkAdditionalTimeslotsVHCR(): Sequence(&theInfo) {}

	void setUplinkAdditionalTimeslotsVHCRParameters(const UplinkAdditionalTimeslotsVHCRParameters& uplinkAdditionalTimeslotsVHCRParameters) { *static_cast<UplinkAdditionalTimeslotsVHCRParameters*>(items[0]) = uplinkAdditionalTimeslotsVHCRParameters; }
};

typedef SequenceOf<UplinkAdditionalTimeslotsVHCR, CONSTRAINED, 1, maxTS_1> UplinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslotsTimeslotList;

class UplinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslots : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UplinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslotsChoices {
		uplinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslotsConsecutive = 0,
		uplinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslotsTimeslotList = 1,
	};
	static const Info theInfo;
	UplinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslots(): Choice(&theInfo) {}
};

class UplinkTimeslotsCodesVHCRMoreTimeslots : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UplinkTimeslotsCodesVHCRMoreTimeslotsChoices {
		uplinkTimeslotsCodesVHCRMoreTimeslotsNoMore = 0,
		uplinkTimeslotsCodesVHCRMoreTimeslotsAdditionalTimeslots = 1,
	};
	static const Info theInfo;
	UplinkTimeslotsCodesVHCRMoreTimeslots(): Choice(&theInfo) {}
};

class UplinkTimeslotsCodesVHCR : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UplinkTimeslotsCodesVHCR(): Sequence(&theInfo) {}

	void setUplinkTimeslotsCodesVHCRDynamicSFusage(const UplinkTimeslotsCodesVHCRDynamicSFusage& uplinkTimeslotsCodesVHCRDynamicSFusage) { *static_cast<UplinkTimeslotsCodesVHCRDynamicSFusage*>(items[0]) = uplinkTimeslotsCodesVHCRDynamicSFusage; }
	void setFirstIndividualTimeslotInfo(const IndividualTimeslotInfoVHCR& firstIndividualTimeslotInfo) { *static_cast<IndividualTimeslotInfoVHCR*>(items[1]) = firstIndividualTimeslotInfo; }
	void setUlTSChannelisationCodeList(const ULTSChannelisationCodeListVHCR& ulTSChannelisationCodeList) { *static_cast<ULTSChannelisationCodeListVHCR*>(items[2]) = ulTSChannelisationCodeList; }
	void setUplinkTimeslotsCodesVHCRMoreTimeslots(const UplinkTimeslotsCodesVHCRMoreTimeslots& uplinkTimeslotsCodesVHCRMoreTimeslots) { *static_cast<UplinkTimeslotsCodesVHCRMoreTimeslots*>(items[3]) = uplinkTimeslotsCodesVHCRMoreTimeslots; }
};

class PUSCHInfoVHCR : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PUSCHInfoVHCR(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setCommonTimeslotInfo(const CommonTimeslotInfo& commonTimeslotInfo) { *static_cast<CommonTimeslotInfo*>(items[1]) = commonTimeslotInfo; }
	void setPuschTimeslotsCodesVHCR(const UplinkTimeslotsCodesVHCR& puschTimeslotsCodesVHCR) { *static_cast<UplinkTimeslotsCodesVHCR*>(items[2]) = puschTimeslotsCodesVHCR; }
};

class PUSCHCapacityAllocationInfor7PuschAllocationPuschAllocationAssignmentConfigurationNewConfiguration : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PUSCHCapacityAllocationInfor7PuschAllocationPuschAllocationAssignmentConfigurationNewConfiguration(): Sequence(&theInfo) {}

	void setPuschInfo(const PUSCHInfoVHCR& puschInfo) { *static_cast<PUSCHInfoVHCR*>(items[0]) = puschInfo; }
	void setPuschIdentity(const PUSCHIdentity& puschIdentity) { *static_cast<PUSCHIdentity*>(items[1]) = puschIdentity; }
};

class PUSCHCapacityAllocationInfor7PuschAllocationPuschAllocationAssignmentConfiguration : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PUSCHCapacityAllocationInfor7PuschAllocationPuschAllocationAssignmentConfigurationChoices {
		pUSCHCapacityAllocationInfor7PuschAllocationPuschAllocationAssignmentConfigurationOldConfiguration = 0,
		pUSCHCapacityAllocationInfor7PuschAllocationPuschAllocationAssignmentConfigurationNewConfiguration = 1,
	};
	static const Info theInfo;
	PUSCHCapacityAllocationInfor7PuschAllocationPuschAllocationAssignmentConfiguration(): Choice(&theInfo) {}
};

class PUSCHCapacityAllocationInfor7PuschAllocationPuschAllocationAssignment : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PUSCHCapacityAllocationInfor7PuschAllocationPuschAllocationAssignment(): Sequence(&theInfo) {}

	void setPuschAllocationPeriodInfo(const AllocationPeriodInfo& puschAllocationPeriodInfo) { *static_cast<AllocationPeriodInfo*>(items[0]) = puschAllocationPeriodInfo; }
	void setPuschPowerControlInfo(const PUSCHPowerControlInfor7& puschPowerControlInfo) { *static_cast<PUSCHPowerControlInfor7*>(items[1]) = puschPowerControlInfo; }
	void setPUSCHCapacityAllocationInfor7PuschAllocationPuschAllocationAssignmentConfiguration(const PUSCHCapacityAllocationInfor7PuschAllocationPuschAllocationAssignmentConfiguration& pUSCHCapacityAllocationInfor7PuschAllocationPuschAllocationAssignmentConfiguration) { *static_cast<PUSCHCapacityAllocationInfor7PuschAllocationPuschAllocationAssignmentConfiguration*>(items[2]) = pUSCHCapacityAllocationInfor7PuschAllocationPuschAllocationAssignmentConfiguration; }
};

class PUSCHCapacityAllocationInfor7PuschAllocation : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum PUSCHCapacityAllocationInfor7PuschAllocationChoices {
		pUSCHCapacityAllocationInfor7PuschAllocationPuschAllocationPending = 0,
		pUSCHCapacityAllocationInfor7PuschAllocationPuschAllocationAssignment = 1,
	};
	static const Info theInfo;
	PUSCHCapacityAllocationInfor7PuschAllocation(): Choice(&theInfo) {}
};

class PUSCHCapacityAllocationInfor7 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	PUSCHCapacityAllocationInfor7(): Sequence(&theInfo) {}

	void setPUSCHCapacityAllocationInfor7PuschAllocation(const PUSCHCapacityAllocationInfor7PuschAllocation& pUSCHCapacityAllocationInfor7PuschAllocation) { *static_cast<PUSCHCapacityAllocationInfor7PuschAllocation*>(items[0]) = pUSCHCapacityAllocationInfor7PuschAllocation; }
};

class PUSCHInfoLCRr4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PUSCHInfoLCRr4(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setCommonTimeslotInfo(const CommonTimeslotInfo& commonTimeslotInfo) { *static_cast<CommonTimeslotInfo*>(items[1]) = commonTimeslotInfo; }
	void setPuschTimeslotsCodes(const UplinkTimeslotsCodesLCRr4& puschTimeslotsCodes) { *static_cast<UplinkTimeslotsCodesLCRr4*>(items[2]) = puschTimeslotsCodes; }
};

class PUSCHSysInfo : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	PUSCHSysInfo(): Sequence(&theInfo) {}

	void setPuschIdentity(const PUSCHIdentity& puschIdentity) { *static_cast<PUSCHIdentity*>(items[0]) = puschIdentity; }
	void setPuschInfo(const PUSCHInfo& puschInfo) { *static_cast<PUSCHInfo*>(items[1]) = puschInfo; }
	void setUschTFS(const TransportFormatSet& uschTFS) { *static_cast<TransportFormatSet*>(items[2]) = uschTFS; }
	void setUschTFCS(const TFCS& uschTFCS) { *static_cast<TFCS*>(items[3]) = uschTFCS; }
};

class PUSCHSysInfoVHCR : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	PUSCHSysInfoVHCR(): Sequence(&theInfo) {}

	void setPuschIdentity(const PUSCHIdentity& puschIdentity) { *static_cast<PUSCHIdentity*>(items[0]) = puschIdentity; }
	void setPuschInfoVHCR(const PUSCHInfoVHCR& puschInfoVHCR) { *static_cast<PUSCHInfoVHCR*>(items[1]) = puschInfoVHCR; }
	void setUschTransportChannelsInfo(const USCHTransportChannelsInfo& uschTransportChannelsInfo) { *static_cast<USCHTransportChannelsInfo*>(items[2]) = uschTransportChannelsInfo; }
	void setUschTFCS(const TFCS& uschTFCS) { *static_cast<TFCS*>(items[3]) = uschTFCS; }
};

class PUSCHSysInfoHCRr5 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	PUSCHSysInfoHCRr5(): Sequence(&theInfo) {}

	void setPuschIdentity(const PUSCHIdentity& puschIdentity) { *static_cast<PUSCHIdentity*>(items[0]) = puschIdentity; }
	void setPuschInfo(const PUSCHInfo& puschInfo) { *static_cast<PUSCHInfo*>(items[1]) = puschInfo; }
	void setUschTransportChannelsInfo(const USCHTransportChannelsInfo& uschTransportChannelsInfo) { *static_cast<USCHTransportChannelsInfo*>(items[2]) = uschTransportChannelsInfo; }
	void setUschTFCS(const TFCS& uschTFCS) { *static_cast<TFCS*>(items[3]) = uschTFCS; }
};

class PUSCHSysInfoLCRr4 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	PUSCHSysInfoLCRr4(): Sequence(&theInfo) {}

	void setPuschIdentity(const PUSCHIdentity& puschIdentity) { *static_cast<PUSCHIdentity*>(items[0]) = puschIdentity; }
	void setPuschInfo(const PUSCHInfoLCRr4& puschInfo) { *static_cast<PUSCHInfoLCRr4*>(items[1]) = puschInfo; }
	void setUschTFS(const TransportFormatSet& uschTFS) { *static_cast<TransportFormatSet*>(items[2]) = uschTFS; }
	void setUschTFCS(const TFCS& uschTFCS) { *static_cast<TFCS*>(items[3]) = uschTFCS; }
};

typedef SequenceOf<PUSCHSysInfo, CONSTRAINED, 1, maxPUSCH> PUSCHSysInfoList;

typedef SequenceOf<PUSCHSysInfoHCRr5, CONSTRAINED, 1, maxPUSCH> PUSCHSysInfoListHCRr5;

typedef SequenceOf<PUSCHSysInfoLCRr4, CONSTRAINED, 1, maxPUSCH> PUSCHSysInfoListLCRr4;

class PUSCHSysInfoListSFN : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	PUSCHSysInfoListSFN(): Sequence(&theInfo) {}

};

class PUSCHSysInfoListSFNHCRr5 : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	PUSCHSysInfoListSFNHCRr5(): Sequence(&theInfo) {}

};

class PUSCHSysInfoListSFNLCRr4 : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	PUSCHSysInfoListSFNLCRr4(): Sequence(&theInfo) {}

};

class PUSCHSysInfoListSFNVHCR : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	PUSCHSysInfoListSFNVHCR(): Sequence(&theInfo) {}

};

typedef Integer<CONSTRAINED, 0, 8191> ReducedScramblingCodeNumber;

typedef Null RepetitionPeriodAndLengthForSPSRepetitionPeriod1;

typedef Integer<CONSTRAINED, 1, 1> RepetitionPeriodAndLengthForSPSRepetitionPeriod2;

typedef Integer<CONSTRAINED, 1, 3> RepetitionPeriodAndLengthForSPSRepetitionPeriod4;

typedef Integer<CONSTRAINED, 1, 7> RepetitionPeriodAndLengthForSPSRepetitionPeriod8;

typedef Integer<CONSTRAINED, 1, 15> RepetitionPeriodAndLengthForSPSRepetitionPeriod16;

typedef Integer<CONSTRAINED, 1, 31> RepetitionPeriodAndLengthForSPSRepetitionPeriod32;

class RepetitionPeriodAndLengthForSPS : public Choice {
private:
	static const void *choicesInfo[6];
public:
	enum RepetitionPeriodAndLengthForSPSChoices {
		repetitionPeriodAndLengthForSPSRepetitionPeriod1 = 0,
		repetitionPeriodAndLengthForSPSRepetitionPeriod2 = 1,
		repetitionPeriodAndLengthForSPSRepetitionPeriod4 = 2,
		repetitionPeriodAndLengthForSPSRepetitionPeriod8 = 3,
		repetitionPeriodAndLengthForSPSRepetitionPeriod16 = 4,
		repetitionPeriodAndLengthForSPSRepetitionPeriod32 = 5,
	};
	static const Info theInfo;
	RepetitionPeriodAndLengthForSPS(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 3> RepPerLengthOffsetMICHRpp42;

typedef Integer<CONSTRAINED, 0, 7> RepPerLengthOffsetMICHRpp82;

typedef Integer<CONSTRAINED, 0, 7> RepPerLengthOffsetMICHRpp84;

typedef Integer<CONSTRAINED, 0, 15> RepPerLengthOffsetMICHRpp162;

typedef Integer<CONSTRAINED, 0, 15> RepPerLengthOffsetMICHRpp164;

typedef Integer<CONSTRAINED, 0, 31> RepPerLengthOffsetMICHRpp322;

typedef Integer<CONSTRAINED, 0, 31> RepPerLengthOffsetMICHRpp324;

typedef Integer<CONSTRAINED, 0, 63> RepPerLengthOffsetMICHRpp642;

typedef Integer<CONSTRAINED, 0, 63> RepPerLengthOffsetMICHRpp644;

class RepPerLengthOffsetMICH : public Choice {
private:
	static const void *choicesInfo[9];
public:
	enum RepPerLengthOffsetMICHChoices {
		repPerLengthOffsetMICHRpp42 = 0,
		repPerLengthOffsetMICHRpp82 = 1,
		repPerLengthOffsetMICHRpp84 = 2,
		repPerLengthOffsetMICHRpp162 = 3,
		repPerLengthOffsetMICHRpp164 = 4,
		repPerLengthOffsetMICHRpp322 = 5,
		repPerLengthOffsetMICHRpp324 = 6,
		repPerLengthOffsetMICHRpp642 = 7,
		repPerLengthOffsetMICHRpp644 = 8,
	};
	static const Info theInfo;
	RepPerLengthOffsetMICH(): Choice(&theInfo) {}
};

typedef Boolean RLAdditionInformationDummy;

class RLAdditionInformation : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	RLAdditionInformation(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setDlDPCHInfoPerRL(const DLDPCHInfoPerRL& dlDPCHInfoPerRL) { *static_cast<DLDPCHInfoPerRL*>(items[1]) = dlDPCHInfoPerRL; }
	void setRLAdditionInformationDummy(const RLAdditionInformationDummy& rLAdditionInformationDummy) { *static_cast<RLAdditionInformationDummy*>(items[2]) = rLAdditionInformationDummy; }
	void setDummy2(const SCCPCHInfoForFACH& dummy2) { *static_cast<SCCPCHInfoForFACH*>(items[3]) = dummy2; }
};

class RLAdditionInformationr6DldpchInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum RLAdditionInformationr6DldpchInfoChoices {
		dlDPCHInfoPerRL = 0,
		dlFDPCHInfoPerRL = 1,
	};
	static const Info theInfo;
	RLAdditionInformationr6DldpchInfo(): Choice(&theInfo) {}
};

class RLAdditionInformationr6 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	RLAdditionInformationr6(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setCellId(const CellIdentity& cellId) { *static_cast<CellIdentity*>(items[1]) = cellId; }
	void setRLAdditionInformationr6DldpchInfo(const RLAdditionInformationr6DldpchInfo& rLAdditionInformationr6DldpchInfo) { *static_cast<RLAdditionInformationr6DldpchInfo*>(items[2]) = rLAdditionInformationr6DldpchInfo; }
	void setEHICHInformation(const EHICHInformation& eHICHInformation) { *static_cast<EHICHInformation*>(items[3]) = eHICHInformation; }
	void setERGCHInformation(const ERGCHInformation& eRGCHInformation) { *static_cast<ERGCHInformation*>(items[4]) = eRGCHInformation; }
};

class RLAdditionInformationr7DldpchInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum RLAdditionInformationr7DldpchInfoChoices {
		dlDPCHInfoPerRL = 0,
		dlFDPCHInfoPerRL = 1,
	};
	static const Info theInfo;
	RLAdditionInformationr7DldpchInfo(): Choice(&theInfo) {}
};

class RLAdditionInformationr7 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	RLAdditionInformationr7(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setCellId(const CellIdentity& cellId) { *static_cast<CellIdentity*>(items[1]) = cellId; }
	void setRLAdditionInformationr7DldpchInfo(const RLAdditionInformationr7DldpchInfo& rLAdditionInformationr7DldpchInfo) { *static_cast<RLAdditionInformationr7DldpchInfo*>(items[2]) = rLAdditionInformationr7DldpchInfo; }
	void setEHICHInformation(const EHICHInformation& eHICHInformation) { *static_cast<EHICHInformation*>(items[3]) = eHICHInformation; }
	void setERGCHInformation(const ERGCHInformation& eRGCHInformation) { *static_cast<ERGCHInformation*>(items[4]) = eRGCHInformation; }
};

class RLAdditionInformationr8DldpchInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum RLAdditionInformationr8DldpchInfoChoices {
		dlDPCHInfoPerRL = 0,
		dlFDPCHInfoPerRL = 1,
	};
	static const Info theInfo;
	RLAdditionInformationr8DldpchInfo(): Choice(&theInfo) {}
};

typedef Null DTXDRXTimingInfor7TimingContinue;

class DTXDRXTimingInfor7Timing : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DTXDRXTimingInfor7TimingChoices {
		dTXDRXTimingInfor7TimingContinue = 0,
		newTiming = 1,
	};
	static const Info theInfo;
	DTXDRXTimingInfor7Timing(): Choice(&theInfo) {}
};

class DTXDRXTimingInfor7 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DTXDRXTimingInfor7(): Sequence(&theInfo) {}

	void setDTXDRXTimingInfor7Timing(const DTXDRXTimingInfor7Timing& dTXDRXTimingInfor7Timing) { *static_cast<DTXDRXTimingInfor7Timing*>(items[0]) = dTXDRXTimingInfor7Timing; }
};

class TargetCellPreconfigInfo : public Sequence {
private:
	static const void *itemsInfo[11];
	static bool itemsPres[11];
public:
	static const Info theInfo;
	TargetCellPreconfigInfo(): Sequence(&theInfo) {}

	void setActivationTimeOffset(const ActivationTimeOffset& activationTimeOffset) { *static_cast<ActivationTimeOffset*>(items[0]) = activationTimeOffset; }
	void setNewHRNTI(const HRNTI& newHRNTI) { *static_cast<HRNTI*>(items[1]) = newHRNTI; }
	void setNewPrimaryERNTI(const ERNTI& newPrimaryERNTI) { *static_cast<ERNTI*>(items[2]) = newPrimaryERNTI; }
	void setNewSecondaryERNTI(const ERNTI& newSecondaryERNTI) { *static_cast<ERNTI*>(items[3]) = newSecondaryERNTI; }
	void setServingHSDSCHCellInformation(const ServingHSDSCHCellInformationr8& servingHSDSCHCellInformation) { *static_cast<ServingHSDSCHCellInformationr8*>(items[4]) = servingHSDSCHCellInformation; }
	void setEdchReconfigurationInfo(const EDCHReconfigurationInfor7& edchReconfigurationInfo) { *static_cast<EDCHReconfigurationInfor7*>(items[5]) = edchReconfigurationInfo; }
	void setDtxdrxTimingInfo(const DTXDRXTimingInfor7& dtxdrxTimingInfo) { *static_cast<DTXDRXTimingInfor7*>(items[6]) = dtxdrxTimingInfo; }
	void setDtxdrxInfo(const DTXDRXInfor7& dtxdrxInfo) { *static_cast<DTXDRXInfor7*>(items[7]) = dtxdrxInfo; }
	void setHsscchLessInfo(const HSSCCHLessInfor7& hsscchLessInfo) { *static_cast<HSSCCHLessInfor7*>(items[8]) = hsscchLessInfo; }
	void setMimoParameters(const MIMOParametersr8& mimoParameters) { *static_cast<MIMOParametersr8*>(items[9]) = mimoParameters; }
	void setDlSecondaryCellInfoFDD(const DLSecondaryCellInfoFDD& dlSecondaryCellInfoFDD) { *static_cast<DLSecondaryCellInfoFDD*>(items[10]) = dlSecondaryCellInfoFDD; }
};

class RLAdditionInformationr8 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	RLAdditionInformationr8(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setCellId(const CellIdentity& cellId) { *static_cast<CellIdentity*>(items[1]) = cellId; }
	void setRLAdditionInformationr8DldpchInfo(const RLAdditionInformationr8DldpchInfo& rLAdditionInformationr8DldpchInfo) { *static_cast<RLAdditionInformationr8DldpchInfo*>(items[2]) = rLAdditionInformationr8DldpchInfo; }
	void setEHICHInformation(const EHICHInformation& eHICHInformation) { *static_cast<EHICHInformation*>(items[3]) = eHICHInformation; }
	void setERGCHInformation(const ERGCHInformation& eRGCHInformation) { *static_cast<ERGCHInformation*>(items[4]) = eRGCHInformation; }
	void setTargetCellPreconfigInfo(const TargetCellPreconfigInfo& targetCellPreconfigInfo) { *static_cast<TargetCellPreconfigInfo*>(items[5]) = targetCellPreconfigInfo; }
};

class RLAdditionInformationr9DldpchInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum RLAdditionInformationr9DldpchInfoChoices {
		dlDPCHInfoPerRL = 0,
		dlFDPCHInfoPerRL = 1,
	};
	static const Info theInfo;
	RLAdditionInformationr9DldpchInfo(): Choice(&theInfo) {}
};

class TargetCellPreconfigInfor9 : public Sequence {
private:
	static const void *itemsInfo[13];
	static bool itemsPres[13];
public:
	static const Info theInfo;
	TargetCellPreconfigInfor9(): Sequence(&theInfo) {}

	void setActivationTimeOffset(const ActivationTimeOffset& activationTimeOffset) { *static_cast<ActivationTimeOffset*>(items[0]) = activationTimeOffset; }
	void setNewHRNTI(const HRNTI& newHRNTI) { *static_cast<HRNTI*>(items[1]) = newHRNTI; }
	void setNewPrimaryERNTI(const ERNTI& newPrimaryERNTI) { *static_cast<ERNTI*>(items[2]) = newPrimaryERNTI; }
	void setNewSecondaryERNTI(const ERNTI& newSecondaryERNTI) { *static_cast<ERNTI*>(items[3]) = newSecondaryERNTI; }
	void setServingHSDSCHCellInformation(const ServingHSDSCHCellInformationr9& servingHSDSCHCellInformation) { *static_cast<ServingHSDSCHCellInformationr9*>(items[4]) = servingHSDSCHCellInformation; }
	void setEdchReconfigurationInfo(const EDCHReconfigurationInfor7& edchReconfigurationInfo) { *static_cast<EDCHReconfigurationInfor7*>(items[5]) = edchReconfigurationInfo; }
	void setDtxdrxTimingInfo(const DTXDRXTimingInfor7& dtxdrxTimingInfo) { *static_cast<DTXDRXTimingInfor7*>(items[6]) = dtxdrxTimingInfo; }
	void setDtxdrxInfo(const DTXDRXInfor7& dtxdrxInfo) { *static_cast<DTXDRXInfor7*>(items[7]) = dtxdrxInfo; }
	void setHsscchLessInfo(const HSSCCHLessInfor7& hsscchLessInfo) { *static_cast<HSSCCHLessInfor7*>(items[8]) = hsscchLessInfo; }
	void setMimoParameters(const MIMOParametersr9& mimoParameters) { *static_cast<MIMOParametersr9*>(items[9]) = mimoParameters; }
	void setDlSecondaryCellInfoFDD(const DLSecondaryCellInfoFDDr9& dlSecondaryCellInfoFDD) { *static_cast<DLSecondaryCellInfoFDDr9*>(items[10]) = dlSecondaryCellInfoFDD; }
	void setUlSecondaryCellInfoFDD(const ULSecondaryCellInfoFDD& ulSecondaryCellInfoFDD) { *static_cast<ULSecondaryCellInfoFDD*>(items[11]) = ulSecondaryCellInfoFDD; }
	void setEdchReconfigurationInfoSecULFrequency(const EDCHReconfigurationInfoSecULFrequency& edchReconfigurationInfoSecULFrequency) { *static_cast<EDCHReconfigurationInfoSecULFrequency*>(items[12]) = edchReconfigurationInfoSecULFrequency; }
};

class RLAdditionInformationr9 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	RLAdditionInformationr9(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setCellId(const CellIdentity& cellId) { *static_cast<CellIdentity*>(items[1]) = cellId; }
	void setRLAdditionInformationr9DldpchInfo(const RLAdditionInformationr9DldpchInfo& rLAdditionInformationr9DldpchInfo) { *static_cast<RLAdditionInformationr9DldpchInfo*>(items[2]) = rLAdditionInformationr9DldpchInfo; }
	void setEHICHInformation(const EHICHInformation& eHICHInformation) { *static_cast<EHICHInformation*>(items[3]) = eHICHInformation; }
	void setERGCHInformation(const ERGCHInformation& eRGCHInformation) { *static_cast<ERGCHInformation*>(items[4]) = eRGCHInformation; }
	void setTargetCellPreconfigInfo(const TargetCellPreconfigInfor9& targetCellPreconfigInfo) { *static_cast<TargetCellPreconfigInfor9*>(items[5]) = targetCellPreconfigInfo; }
};

class RLAdditionInformationv6b0ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	RLAdditionInformationv6b0ext(): Sequence(&theInfo) {}

	void setSttdIndication(const STTDIndication& sttdIndication) { *static_cast<STTDIndication*>(items[0]) = sttdIndication; }
};

typedef MIMOParametersv7f0ext TargetCellPreconfigInfov890ext;

class RLAdditionInformationv890ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	RLAdditionInformationv890ext(): Sequence(&theInfo) {}

	void setTargetCellPreconfigInfo(const TargetCellPreconfigInfov890ext& targetCellPreconfigInfo) { *static_cast<TargetCellPreconfigInfov890ext*>(items[0]) = targetCellPreconfigInfo; }
};

enum SecondaryCellMIMOparametersFDDv950extprecodingWeightSetRestrictionValues {
	true_SecondaryCellMIMOparametersFDDv950extprecodingWeightSetRestriction = 0,
};
typedef Enumerated<CONSTRAINED, 0> SecondaryCellMIMOparametersFDDv950extprecodingWeightSetRestriction;

class SecondaryCellMIMOparametersFDDv950ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SecondaryCellMIMOparametersFDDv950ext(): Sequence(&theInfo) {}

	void setSecondaryCellMIMOparametersFDDv950extprecodingWeightSetRestriction(const SecondaryCellMIMOparametersFDDv950extprecodingWeightSetRestriction& secondaryCellMIMOparametersFDDv950extprecodingWeightSetRestriction) { *static_cast<SecondaryCellMIMOparametersFDDv950extprecodingWeightSetRestriction*>(items[0]) = secondaryCellMIMOparametersFDDv950extprecodingWeightSetRestriction; }
};

typedef SecondaryCellMIMOparametersFDDv950ext TargetCellPreconfigInfov950ext;

class RLAdditionInformationv950ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	RLAdditionInformationv950ext(): Sequence(&theInfo) {}

	void setTargetCellPreconfigInfo(const TargetCellPreconfigInfov950ext& targetCellPreconfigInfo) { *static_cast<TargetCellPreconfigInfov950ext*>(items[0]) = targetCellPreconfigInfo; }
};

typedef SequenceOf<RLAdditionInformation, CONSTRAINED, 1, maxRL_1> RLAdditionInformationList;

typedef SequenceOf<RLAdditionInformationr6, CONSTRAINED, 1, maxRL_1> RLAdditionInformationListr6;

typedef SequenceOf<RLAdditionInformationr7, CONSTRAINED, 1, maxRL_1> RLAdditionInformationListr7;

typedef SequenceOf<RLAdditionInformationv6b0ext, CONSTRAINED, 1, maxRL> RLAdditionInformationlistv6b0ext;

typedef SequenceOf<RLAdditionInformationr8, CONSTRAINED, 1, maxRL_1> RLAdditionInformationListr8;

typedef SequenceOf<RLAdditionInformationv890ext, CONSTRAINED, 1, maxRL_1> RLAdditionInformationListv890ext;

typedef SequenceOf<RLAdditionInformationr9, CONSTRAINED, 1, maxRL_1> RLAdditionInformationListr9;

typedef SequenceOf<RLAdditionInformationv950ext, CONSTRAINED, 1, maxRL_1> RLAdditionInformationListv950ext;

class RLAdditionInformationSecULFreq : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	RLAdditionInformationSecULFreq(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setCellid(const CellIdentity& cellid) { *static_cast<CellIdentity*>(items[1]) = cellid; }
	void setDlFDPCHInfoPerRL(const DLFDPCHInfoPerRLr7& dlFDPCHInfoPerRL) { *static_cast<DLFDPCHInfoPerRLr7*>(items[2]) = dlFDPCHInfoPerRL; }
	void setEHICHInformation(const EHICHInformation& eHICHInformation) { *static_cast<EHICHInformation*>(items[3]) = eHICHInformation; }
	void setERGCHInformation(const ERGCHInformation& eRGCHInformation) { *static_cast<ERGCHInformation*>(items[4]) = eRGCHInformation; }
};

typedef SequenceOf<RLAdditionInformationSecULFreq, CONSTRAINED, 1, maxEDCHRL_1> RLAdditionInformationListSecULFreq;

typedef SequenceOf<PrimaryCPICHInfo, CONSTRAINED, 1, maxRL> RLRemovalInformationList;

typedef SequenceOf<PrimaryCPICHInfo, CONSTRAINED, 1, maxEDCHRL> RLRemovalInformationListSecULFreq;

enum SCCPCHChannelisationCodeVHCRValues {
	cc32_1_SCCPCHChannelisationCodeVHCR = 0,
	cc32_2_SCCPCHChannelisationCodeVHCR = 1,
	cc32_3_SCCPCHChannelisationCodeVHCR = 2,
	cc32_4_SCCPCHChannelisationCodeVHCR = 3,
	cc32_5_SCCPCHChannelisationCodeVHCR = 4,
	cc32_6_SCCPCHChannelisationCodeVHCR = 5,
	cc32_7_SCCPCHChannelisationCodeVHCR = 6,
	cc32_8_SCCPCHChannelisationCodeVHCR = 7,
	cc32_9_SCCPCHChannelisationCodeVHCR = 8,
	cc32_10_SCCPCHChannelisationCodeVHCR = 9,
	cc32_11_SCCPCHChannelisationCodeVHCR = 10,
	cc32_12_SCCPCHChannelisationCodeVHCR = 11,
	cc32_13_SCCPCHChannelisationCodeVHCR = 12,
	cc32_14_SCCPCHChannelisationCodeVHCR = 13,
	cc32_15_SCCPCHChannelisationCodeVHCR = 14,
	cc32_16_SCCPCHChannelisationCodeVHCR = 15,
	cc32_17_SCCPCHChannelisationCodeVHCR = 16,
	cc32_18_SCCPCHChannelisationCodeVHCR = 17,
	cc32_19_SCCPCHChannelisationCodeVHCR = 18,
	cc32_20_SCCPCHChannelisationCodeVHCR = 19,
	cc32_21_SCCPCHChannelisationCodeVHCR = 20,
	cc32_22_SCCPCHChannelisationCodeVHCR = 21,
	cc32_23_SCCPCHChannelisationCodeVHCR = 22,
	cc32_24_SCCPCHChannelisationCodeVHCR = 23,
	cc32_25_SCCPCHChannelisationCodeVHCR = 24,
	cc32_26_SCCPCHChannelisationCodeVHCR = 25,
	cc32_27_SCCPCHChannelisationCodeVHCR = 26,
	cc32_28_SCCPCHChannelisationCodeVHCR = 27,
	cc32_29_SCCPCHChannelisationCodeVHCR = 28,
	cc32_30_SCCPCHChannelisationCodeVHCR = 29,
	cc32_31_SCCPCHChannelisationCodeVHCR = 30,
	cc32_32_SCCPCHChannelisationCodeVHCR = 31,
};
typedef Enumerated<CONSTRAINED, 31> SCCPCHChannelisationCodeVHCR;

typedef SequenceOf<SCCPCHChannelisationCodeVHCR, CONSTRAINED, 1, 32> SCCPCHChannelisationCodeListVHCR;

class SCCPCHSystemInformation : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SCCPCHSystemInformation(): Sequence(&theInfo) {}

	void setSecondaryCCPCHInfo(const SecondaryCCPCHInfo& secondaryCCPCHInfo) { *static_cast<SecondaryCCPCHInfo*>(items[0]) = secondaryCCPCHInfo; }
	void setTfcs(const TFCS& tfcs) { *static_cast<TFCS*>(items[1]) = tfcs; }
	void setFachPCHInformationList(const FACHPCHInformationList& fachPCHInformationList) { *static_cast<FACHPCHInformationList*>(items[2]) = fachPCHInformationList; }
	void setPichInfo(const PICHInfo& pichInfo) { *static_cast<PICHInfo*>(items[3]) = pichInfo; }
};

class SecondaryCCPCHInfoLCRr4ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SecondaryCCPCHInfoLCRr4ext(): Sequence(&theInfo) {}

	void setIndividualTimeslotLCRExt(const IndividualTimeslotInfoLCRr4ext& individualTimeslotLCRExt) { *static_cast<IndividualTimeslotInfoLCRr4ext*>(items[0]) = individualTimeslotLCRExt; }
};

class SCCPCHSystemInformationLCRr4ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SCCPCHSystemInformationLCRr4ext(): Sequence(&theInfo) {}

	void setSecondaryCCPCHLCRExtensions(const SecondaryCCPCHInfoLCRr4ext& secondaryCCPCHLCRExtensions) { *static_cast<SecondaryCCPCHInfoLCRr4ext*>(items[0]) = secondaryCCPCHLCRExtensions; }
	void setPichInfo(const PICHInfoLCRr4& pichInfo) { *static_cast<PICHInfoLCRr4*>(items[1]) = pichInfo; }
};

class SecondaryCCPCHInfoHCRVHCRr7ModeSpecificInfoTdd384 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SecondaryCCPCHInfoHCRVHCRr7ModeSpecificInfoTdd384(): Sequence(&theInfo) {}

	void setIndividualTimeslotInfo(const IndividualTimeslotInfor7& individualTimeslotInfo) { *static_cast<IndividualTimeslotInfor7*>(items[0]) = individualTimeslotInfo; }
	void setChannelisationCode(const SCCPCHChannelisationCodeList& channelisationCode) { *static_cast<SCCPCHChannelisationCodeList*>(items[1]) = channelisationCode; }
};

class SecondaryCCPCHInfoHCRVHCRr7ModeSpecificInfoTdd768 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SecondaryCCPCHInfoHCRVHCRr7ModeSpecificInfoTdd768(): Sequence(&theInfo) {}

	void setIndividualTimeslotInfo(const IndividualTimeslotInfoVHCR& individualTimeslotInfo) { *static_cast<IndividualTimeslotInfoVHCR*>(items[0]) = individualTimeslotInfo; }
	void setChannelisationCode(const SCCPCHChannelisationCodeListVHCR& channelisationCode) { *static_cast<SCCPCHChannelisationCodeListVHCR*>(items[1]) = channelisationCode; }
};

class SecondaryCCPCHInfoHCRVHCRr7ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum SecondaryCCPCHInfoHCRVHCRr7ModeSpecificInfoChoices {
		secondaryCCPCHInfoHCRVHCRr7ModeSpecificInfoTdd384 = 0,
		secondaryCCPCHInfoHCRVHCRr7ModeSpecificInfoTdd768 = 1,
	};
	static const Info theInfo;
	SecondaryCCPCHInfoHCRVHCRr7ModeSpecificInfo(): Choice(&theInfo) {}
};

class SecondaryCCPCHInfoHCRVHCRr7 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SecondaryCCPCHInfoHCRVHCRr7(): Sequence(&theInfo) {}

	void setSecondaryCCPCHInfoHCRVHCRr7ModeSpecificInfo(const SecondaryCCPCHInfoHCRVHCRr7ModeSpecificInfo& secondaryCCPCHInfoHCRVHCRr7ModeSpecificInfo) { *static_cast<SecondaryCCPCHInfoHCRVHCRr7ModeSpecificInfo*>(items[0]) = secondaryCCPCHInfoHCRVHCRr7ModeSpecificInfo; }
};

class SCCPCHSystemInformationHCRVHCRr7 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SCCPCHSystemInformationHCRVHCRr7(): Sequence(&theInfo) {}

	void setSecondaryCCPCHInfo(const SecondaryCCPCHInfoHCRVHCRr7& secondaryCCPCHInfo) { *static_cast<SecondaryCCPCHInfoHCRVHCRr7*>(items[0]) = secondaryCCPCHInfo; }
	void setTfcs(const TFCS& tfcs) { *static_cast<TFCS*>(items[1]) = tfcs; }
	void setFachPCHInformationList(const FACHPCHInformationList& fachPCHInformationList) { *static_cast<FACHPCHInformationList*>(items[2]) = fachPCHInformationList; }
	void setPichInfo(const PICHInfoHCRVHCRr7& pichInfo) { *static_cast<PICHInfoHCRVHCRr7*>(items[3]) = pichInfo; }
};

typedef SequenceOf<SCCPCHSystemInformation, CONSTRAINED, 1, maxSCCPCH> SCCPCHSystemInformationList;

typedef SequenceOf<SCCPCHSystemInformationHCRVHCRr7, CONSTRAINED, 1, maxSCCPCH> SCCPCHSystemInformationListHCRVHCRr7;

typedef SequenceOf<SCCPCHSystemInformationLCRr4ext, CONSTRAINED, 1, maxSCCPCH> SCCPCHSystemInformationListLCRr4ext;

typedef Boolean SecondaryCCPCHInfoMBMSr6ModeSpecificInfoFddSttdIndicator;

class SecondaryCCPCHInfoMBMSr6ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SecondaryCCPCHInfoMBMSr6ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setSecondaryScramblingCode(const SecondaryScramblingCode& secondaryScramblingCode) { *static_cast<SecondaryScramblingCode*>(items[0]) = secondaryScramblingCode; }
	void setSecondaryCCPCHInfoMBMSr6ModeSpecificInfoFddSttdIndicator(const SecondaryCCPCHInfoMBMSr6ModeSpecificInfoFddSttdIndicator& secondaryCCPCHInfoMBMSr6ModeSpecificInfoFddSttdIndicator) { *static_cast<SecondaryCCPCHInfoMBMSr6ModeSpecificInfoFddSttdIndicator*>(items[1]) = secondaryCCPCHInfoMBMSr6ModeSpecificInfoFddSttdIndicator; }
	void setSfAndCodeNumber(const SF256AndCodeNumber& sfAndCodeNumber) { *static_cast<SF256AndCodeNumber*>(items[2]) = sfAndCodeNumber; }
	void setTimingOffset(const TimingOffset& timingOffset) { *static_cast<TimingOffset*>(items[3]) = timingOffset; }
};

class SecondaryCCPCHInfoMBMSr6ModeSpecificInfoTdd384 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SecondaryCCPCHInfoMBMSr6ModeSpecificInfoTdd384(): Sequence(&theInfo) {}

	void setCommonTimeslotInfoMBMS(const CommonTimeslotInfoMBMS& commonTimeslotInfoMBMS) { *static_cast<CommonTimeslotInfoMBMS*>(items[0]) = commonTimeslotInfoMBMS; }
	void setDownlinkTimeslotsCodes(const DownlinkTimeslotsCodes& downlinkTimeslotsCodes) { *static_cast<DownlinkTimeslotsCodes*>(items[1]) = downlinkTimeslotsCodes; }
};

class SecondaryCCPCHInfoMBMSr6ModeSpecificInfoTdd128 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SecondaryCCPCHInfoMBMSr6ModeSpecificInfoTdd128(): Sequence(&theInfo) {}

	void setCommonTimeslotInfoMBMS(const CommonTimeslotInfoMBMS& commonTimeslotInfoMBMS) { *static_cast<CommonTimeslotInfoMBMS*>(items[0]) = commonTimeslotInfoMBMS; }
	void setDownlinkTimeslotsCodes(const DownlinkTimeslotsCodesLCRr4& downlinkTimeslotsCodes) { *static_cast<DownlinkTimeslotsCodesLCRr4*>(items[1]) = downlinkTimeslotsCodes; }
};

class SecondaryCCPCHInfoMBMSr6ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum SecondaryCCPCHInfoMBMSr6ModeSpecificInfoChoices {
		secondaryCCPCHInfoMBMSr6ModeSpecificInfoFdd = 0,
		secondaryCCPCHInfoMBMSr6ModeSpecificInfoTdd384 = 1,
		secondaryCCPCHInfoMBMSr6ModeSpecificInfoTdd128 = 2,
	};
	static const Info theInfo;
	SecondaryCCPCHInfoMBMSr6ModeSpecificInfo(): Choice(&theInfo) {}
};

class SecondaryCCPCHInfoMBMSr6 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SecondaryCCPCHInfoMBMSr6(): Sequence(&theInfo) {}

	void setSecondaryCCPCHInfoMBMSr6ModeSpecificInfo(const SecondaryCCPCHInfoMBMSr6ModeSpecificInfo& secondaryCCPCHInfoMBMSr6ModeSpecificInfo) { *static_cast<SecondaryCCPCHInfoMBMSr6ModeSpecificInfo*>(items[0]) = secondaryCCPCHInfoMBMSr6ModeSpecificInfo; }
};

typedef Integer<CONSTRAINED, 0, 3> MBMSMCCHConfigurationInfor6AccessInfoPeriodCoefficient;

typedef Integer<CONSTRAINED, 0, 3> MBMSMCCHConfigurationInfor6RepetitionPeriodCoefficient;

typedef Integer<CONSTRAINED, 7, 10> MBMSMCCHConfigurationInfor6ModificationPeriodCoefficient;

enum MBMSTCTFPresenceValues {
	false_MBMSTCTFPresence = 0,
};
typedef Enumerated<CONSTRAINED, 0> MBMSTCTFPresence;

class MBMSMCCHConfigurationInfor6 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	MBMSMCCHConfigurationInfor6(): Sequence(&theInfo) {}

	void setMBMSMCCHConfigurationInfor6AccessInfoPeriodCoefficient(const MBMSMCCHConfigurationInfor6AccessInfoPeriodCoefficient& mBMSMCCHConfigurationInfor6AccessInfoPeriodCoefficient) { *static_cast<MBMSMCCHConfigurationInfor6AccessInfoPeriodCoefficient*>(items[0]) = mBMSMCCHConfigurationInfor6AccessInfoPeriodCoefficient; }
	void setMBMSMCCHConfigurationInfor6RepetitionPeriodCoefficient(const MBMSMCCHConfigurationInfor6RepetitionPeriodCoefficient& mBMSMCCHConfigurationInfor6RepetitionPeriodCoefficient) { *static_cast<MBMSMCCHConfigurationInfor6RepetitionPeriodCoefficient*>(items[1]) = mBMSMCCHConfigurationInfor6RepetitionPeriodCoefficient; }
	void setMBMSMCCHConfigurationInfor6ModificationPeriodCoefficient(const MBMSMCCHConfigurationInfor6ModificationPeriodCoefficient& mBMSMCCHConfigurationInfor6ModificationPeriodCoefficient) { *static_cast<MBMSMCCHConfigurationInfor6ModificationPeriodCoefficient*>(items[2]) = mBMSMCCHConfigurationInfor6ModificationPeriodCoefficient; }
	void setRlcInfo(const RLCInfoMCCHr6& rlcInfo) { *static_cast<RLCInfoMCCHr6*>(items[3]) = rlcInfo; }
	void setTctfPresence(const MBMSTCTFPresence& tctfPresence) { *static_cast<MBMSTCTFPresence*>(items[4]) = tctfPresence; }
};

class SCCPCHSystemInformationMBMSr6FachCarryingMCCH : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SCCPCHSystemInformationMBMSr6FachCarryingMCCH(): Sequence(&theInfo) {}

	void setMcchtransportFormatSet(const TransportFormatSet& mcchtransportFormatSet) { *static_cast<TransportFormatSet*>(items[0]) = mcchtransportFormatSet; }
	void setMcchConfigurationInfo(const MBMSMCCHConfigurationInfor6& mcchConfigurationInfo) { *static_cast<MBMSMCCHConfigurationInfor6*>(items[1]) = mcchConfigurationInfo; }
};

typedef SequenceOf<TransportFormatSet, CONSTRAINED, 1, maxFACHPCH> MBMSFACHCarryingMTCHList;

typedef Integer<CONSTRAINED, 0, 31> MBMSMSCHSchedulingInfoSchedulingPeriod32Offset;

typedef Integer<CONSTRAINED, 0, 63> MBMSMSCHSchedulingInfoSchedulingPeriod64Offset;

typedef Integer<CONSTRAINED, 0, 127> MBMSMSCHSchedulingInfoSchedulingPeriod128Offset;

typedef Integer<CONSTRAINED, 0, 255> MBMSMSCHSchedulingInfoSchedulingPeriod256Offset;

typedef Integer<CONSTRAINED, 0, 511> MBMSMSCHSchedulingInfoSchedulingPeriod512Offset;

typedef Integer<CONSTRAINED, 0, 1023> MBMSMSCHSchedulingInfoSchedulingPeriod1024Offset;

class MBMSMSCHSchedulingInfo : public Choice {
private:
	static const void *choicesInfo[6];
public:
	enum MBMSMSCHSchedulingInfoChoices {
		mBMSMSCHSchedulingInfoSchedulingPeriod32Offset = 0,
		mBMSMSCHSchedulingInfoSchedulingPeriod64Offset = 1,
		mBMSMSCHSchedulingInfoSchedulingPeriod128Offset = 2,
		mBMSMSCHSchedulingInfoSchedulingPeriod256Offset = 3,
		mBMSMSCHSchedulingInfoSchedulingPeriod512Offset = 4,
		mBMSMSCHSchedulingInfoSchedulingPeriod1024Offset = 5,
	};
	static const Info theInfo;
	MBMSMSCHSchedulingInfo(): Choice(&theInfo) {}
};

class MBMSMSCHConfigurationInfor6 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MBMSMSCHConfigurationInfor6(): Sequence(&theInfo) {}

	void setMschShedulingInfo(const MBMSMSCHSchedulingInfo& mschShedulingInfo) { *static_cast<MBMSMSCHSchedulingInfo*>(items[0]) = mschShedulingInfo; }
	void setRlcInfo(const RLCInfoMSCHr6& rlcInfo) { *static_cast<RLCInfoMSCHr6*>(items[1]) = rlcInfo; }
	void setTctfPresence(const MBMSTCTFPresence& tctfPresence) { *static_cast<MBMSTCTFPresence*>(items[2]) = tctfPresence; }
};

class SCCPCHSystemInformationMBMSr6FachCarryingMSCH : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SCCPCHSystemInformationMBMSr6FachCarryingMSCH(): Sequence(&theInfo) {}

	void setMschtransportFormatSet(const TransportFormatSet& mschtransportFormatSet) { *static_cast<TransportFormatSet*>(items[0]) = mschtransportFormatSet; }
	void setDummy(const MBMSMSCHConfigurationInfor6& dummy) { *static_cast<MBMSMSCHConfigurationInfor6*>(items[1]) = dummy; }
};

class SCCPCHSystemInformationMBMSr6 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	SCCPCHSystemInformationMBMSr6(): Sequence(&theInfo) {}

	void setSecondaryCCPCHInfoMBMS(const SecondaryCCPCHInfoMBMSr6& secondaryCCPCHInfoMBMS) { *static_cast<SecondaryCCPCHInfoMBMSr6*>(items[0]) = secondaryCCPCHInfoMBMS; }
	void setTransportFormatCombinationSet(const TFCS& transportFormatCombinationSet) { *static_cast<TFCS*>(items[1]) = transportFormatCombinationSet; }
	void setSCCPCHSystemInformationMBMSr6FachCarryingMCCH(const SCCPCHSystemInformationMBMSr6FachCarryingMCCH& sCCPCHSystemInformationMBMSr6FachCarryingMCCH) { *static_cast<SCCPCHSystemInformationMBMSr6FachCarryingMCCH*>(items[2]) = sCCPCHSystemInformationMBMSr6FachCarryingMCCH; }
	void setFachCarryingMTCHList(const MBMSFACHCarryingMTCHList& fachCarryingMTCHList) { *static_cast<MBMSFACHCarryingMTCHList*>(items[3]) = fachCarryingMTCHList; }
	void setSCCPCHSystemInformationMBMSr6FachCarryingMSCH(const SCCPCHSystemInformationMBMSr6FachCarryingMSCH& sCCPCHSystemInformationMBMSr6FachCarryingMSCH) { *static_cast<SCCPCHSystemInformationMBMSr6FachCarryingMSCH*>(items[4]) = sCCPCHSystemInformationMBMSr6FachCarryingMSCH; }
};

typedef Boolean SecondaryCCPCHInfoMBMSr7ModeSpecificInfoFddSttdIndicator;

typedef Null SecondaryCCPCHInfoMBMSr7ModeSpecificInfoFddModulationModQPSK;

typedef Integer<CONSTRAINED, -11, 4> SecondaryCCPCHInfoMBMSr7ModeSpecificInfoFddModulationMod16QAM;

class SecondaryCCPCHInfoMBMSr7ModeSpecificInfoFddModulation : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum SecondaryCCPCHInfoMBMSr7ModeSpecificInfoFddModulationChoices {
		secondaryCCPCHInfoMBMSr7ModeSpecificInfoFddModulationModQPSK = 0,
		secondaryCCPCHInfoMBMSr7ModeSpecificInfoFddModulationMod16QAM = 1,
	};
	static const Info theInfo;
	SecondaryCCPCHInfoMBMSr7ModeSpecificInfoFddModulation(): Choice(&theInfo) {}
};

class SecondaryCCPCHInfoMBMSr7ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	SecondaryCCPCHInfoMBMSr7ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setSecondaryScramblingCode(const SecondaryScramblingCode& secondaryScramblingCode) { *static_cast<SecondaryScramblingCode*>(items[0]) = secondaryScramblingCode; }
	void setSecondaryCCPCHInfoMBMSr7ModeSpecificInfoFddSttdIndicator(const SecondaryCCPCHInfoMBMSr7ModeSpecificInfoFddSttdIndicator& secondaryCCPCHInfoMBMSr7ModeSpecificInfoFddSttdIndicator) { *static_cast<SecondaryCCPCHInfoMBMSr7ModeSpecificInfoFddSttdIndicator*>(items[1]) = secondaryCCPCHInfoMBMSr7ModeSpecificInfoFddSttdIndicator; }
	void setSfAndCodeNumber(const SF256AndCodeNumber& sfAndCodeNumber) { *static_cast<SF256AndCodeNumber*>(items[2]) = sfAndCodeNumber; }
	void setTimingOffset(const TimingOffset& timingOffset) { *static_cast<TimingOffset*>(items[3]) = timingOffset; }
	void setSecondaryCCPCHInfoMBMSr7ModeSpecificInfoFddModulation(const SecondaryCCPCHInfoMBMSr7ModeSpecificInfoFddModulation& secondaryCCPCHInfoMBMSr7ModeSpecificInfoFddModulation) { *static_cast<SecondaryCCPCHInfoMBMSr7ModeSpecificInfoFddModulation*>(items[4]) = secondaryCCPCHInfoMBMSr7ModeSpecificInfoFddModulation; }
};

enum SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd384modulationValues {
	modQPSK_SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd384modulation = 0,
	mod16QAM_SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd384modulation = 1,
};
typedef Enumerated<CONSTRAINED, 1> SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd384modulation;

class SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd384 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd384(): Sequence(&theInfo) {}

	void setCommonTimeslotInfoMBMS(const CommonTimeslotInfoMBMS& commonTimeslotInfoMBMS) { *static_cast<CommonTimeslotInfoMBMS*>(items[0]) = commonTimeslotInfoMBMS; }
	void setDownlinkTimeslotsCodes(const DownlinkTimeslotsCodesr7& downlinkTimeslotsCodes) { *static_cast<DownlinkTimeslotsCodesr7*>(items[1]) = downlinkTimeslotsCodes; }
	void setSecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd384modulation(const SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd384modulation& secondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd384modulation) { *static_cast<SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd384modulation*>(items[2]) = secondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd384modulation; }
};

enum SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd768modulationValues {
	modQPSK_SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd768modulation = 0,
	mod16QAM_SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd768modulation = 1,
};
typedef Enumerated<CONSTRAINED, 1> SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd768modulation;

class SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd768 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd768(): Sequence(&theInfo) {}

	void setCommonTimeslotInfoMBMS(const CommonTimeslotInfoMBMS& commonTimeslotInfoMBMS) { *static_cast<CommonTimeslotInfoMBMS*>(items[0]) = commonTimeslotInfoMBMS; }
	void setDownlinkTimeslotsCodes(const DownlinkTimeslotsCodesVHCR& downlinkTimeslotsCodes) { *static_cast<DownlinkTimeslotsCodesVHCR*>(items[1]) = downlinkTimeslotsCodes; }
	void setSecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd768modulation(const SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd768modulation& secondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd768modulation) { *static_cast<SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd768modulation*>(items[2]) = secondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd768modulation; }
};

enum TimeSlotLCRextValues {
	ts7_TimeSlotLCRext = 0,
	spare3_TimeSlotLCRext = 1,
	spare2_TimeSlotLCRext = 2,
	spare1_TimeSlotLCRext = 3,
};
typedef Enumerated<CONSTRAINED, 3> TimeSlotLCRext;

enum SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd128modulationValues {
	modQPSK_SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd128modulation = 0,
	mod16QAM_SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd128modulation = 1,
};
typedef Enumerated<CONSTRAINED, 1> SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd128modulation;

class SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd128 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd128(): Sequence(&theInfo) {}

	void setCommonTimeslotInfoMBMS(const CommonTimeslotInfoMBMS& commonTimeslotInfoMBMS) { *static_cast<CommonTimeslotInfoMBMS*>(items[0]) = commonTimeslotInfoMBMS; }
	void setDownlinkTimeslotsCodes(const DownlinkTimeslotsCodesLCRr4& downlinkTimeslotsCodes) { *static_cast<DownlinkTimeslotsCodesLCRr4*>(items[1]) = downlinkTimeslotsCodes; }
	void setMbsfnSpecialTimeSlot(const TimeSlotLCRext& mbsfnSpecialTimeSlot) { *static_cast<TimeSlotLCRext*>(items[2]) = mbsfnSpecialTimeSlot; }
	void setSecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd128modulation(const SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd128modulation& secondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd128modulation) { *static_cast<SecondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd128modulation*>(items[3]) = secondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd128modulation; }
};

class SecondaryCCPCHInfoMBMSr7ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum SecondaryCCPCHInfoMBMSr7ModeSpecificInfoChoices {
		secondaryCCPCHInfoMBMSr7ModeSpecificInfoFdd = 0,
		secondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd384 = 1,
		secondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd768 = 2,
		secondaryCCPCHInfoMBMSr7ModeSpecificInfoTdd128 = 3,
	};
	static const Info theInfo;
	SecondaryCCPCHInfoMBMSr7ModeSpecificInfo(): Choice(&theInfo) {}
};

class SecondaryCCPCHInfoMBMSr7 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SecondaryCCPCHInfoMBMSr7(): Sequence(&theInfo) {}

	void setSecondaryCCPCHInfoMBMSr7ModeSpecificInfo(const SecondaryCCPCHInfoMBMSr7ModeSpecificInfo& secondaryCCPCHInfoMBMSr7ModeSpecificInfo) { *static_cast<SecondaryCCPCHInfoMBMSr7ModeSpecificInfo*>(items[0]) = secondaryCCPCHInfoMBMSr7ModeSpecificInfo; }
};

class SCCPCHSystemInformationMBMSr7FachCarryingMCCH : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SCCPCHSystemInformationMBMSr7FachCarryingMCCH(): Sequence(&theInfo) {}

	void setMcchtransportFormatSet(const TransportFormatSet& mcchtransportFormatSet) { *static_cast<TransportFormatSet*>(items[0]) = mcchtransportFormatSet; }
	void setMcchConfigurationInfo(const MBMSMCCHConfigurationInfor6& mcchConfigurationInfo) { *static_cast<MBMSMCCHConfigurationInfor6*>(items[1]) = mcchConfigurationInfo; }
};

class SCCPCHSystemInformationMBMSr7FachCarryingMSCH : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SCCPCHSystemInformationMBMSr7FachCarryingMSCH(): Sequence(&theInfo) {}

	void setMschtransportFormatSet(const TransportFormatSet& mschtransportFormatSet) { *static_cast<TransportFormatSet*>(items[0]) = mschtransportFormatSet; }
};

class SCCPCHSystemInformationMBMSr7 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	SCCPCHSystemInformationMBMSr7(): Sequence(&theInfo) {}

	void setSecondaryCCPCHInfoMBMS(const SecondaryCCPCHInfoMBMSr7& secondaryCCPCHInfoMBMS) { *static_cast<SecondaryCCPCHInfoMBMSr7*>(items[0]) = secondaryCCPCHInfoMBMS; }
	void setTransportFormatCombinationSet(const TFCS& transportFormatCombinationSet) { *static_cast<TFCS*>(items[1]) = transportFormatCombinationSet; }
	void setSCCPCHSystemInformationMBMSr7FachCarryingMCCH(const SCCPCHSystemInformationMBMSr7FachCarryingMCCH& sCCPCHSystemInformationMBMSr7FachCarryingMCCH) { *static_cast<SCCPCHSystemInformationMBMSr7FachCarryingMCCH*>(items[2]) = sCCPCHSystemInformationMBMSr7FachCarryingMCCH; }
	void setFachCarryingMTCHList(const MBMSFACHCarryingMTCHList& fachCarryingMTCHList) { *static_cast<MBMSFACHCarryingMTCHList*>(items[3]) = fachCarryingMTCHList; }
	void setSCCPCHSystemInformationMBMSr7FachCarryingMSCH(const SCCPCHSystemInformationMBMSr7FachCarryingMSCH& sCCPCHSystemInformationMBMSr7FachCarryingMSCH) { *static_cast<SCCPCHSystemInformationMBMSr7FachCarryingMSCH*>(items[4]) = sCCPCHSystemInformationMBMSr7FachCarryingMSCH; }
};

typedef Integer<CONSTRAINED, 0, 4> SecondaryCCPCHFrameType2InfoSubFrameNumber;

typedef Null SecondaryCCPCHFrameType2InfoModulationModQPSK;

typedef Integer<CONSTRAINED, -11, 4> SecondaryCCPCHFrameType2InfoModulationMod16QAMCpichSecCCPCHPowerOffset;

class SecondaryCCPCHFrameType2InfoModulationMod16QAM : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SecondaryCCPCHFrameType2InfoModulationMod16QAM(): Sequence(&theInfo) {}

	void setSecondaryCCPCHFrameType2InfoModulationMod16QAMCpichSecCCPCHPowerOffset(const SecondaryCCPCHFrameType2InfoModulationMod16QAMCpichSecCCPCHPowerOffset& secondaryCCPCHFrameType2InfoModulationMod16QAMCpichSecCCPCHPowerOffset) { *static_cast<SecondaryCCPCHFrameType2InfoModulationMod16QAMCpichSecCCPCHPowerOffset*>(items[0]) = secondaryCCPCHFrameType2InfoModulationMod16QAMCpichSecCCPCHPowerOffset; }
};

class SecondaryCCPCHFrameType2InfoModulation : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum SecondaryCCPCHFrameType2InfoModulationChoices {
		secondaryCCPCHFrameType2InfoModulationModQPSK = 0,
		secondaryCCPCHFrameType2InfoModulationMod16QAM = 1,
	};
	static const Info theInfo;
	SecondaryCCPCHFrameType2InfoModulation(): Choice(&theInfo) {}
};

class SecondaryCCPCHFrameType2Info : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SecondaryCCPCHFrameType2Info(): Sequence(&theInfo) {}

	void setSecondaryCCPCHFrameType2InfoSubFrameNumber(const SecondaryCCPCHFrameType2InfoSubFrameNumber& secondaryCCPCHFrameType2InfoSubFrameNumber) { *static_cast<SecondaryCCPCHFrameType2InfoSubFrameNumber*>(items[0]) = secondaryCCPCHFrameType2InfoSubFrameNumber; }
	void setDlChannelisationCodes(const DLChannelCodesMBSFNIMB384& dlChannelisationCodes) { *static_cast<DLChannelCodesMBSFNIMB384*>(items[1]) = dlChannelisationCodes; }
	void setSecondaryCCPCHFrameType2InfoModulation(const SecondaryCCPCHFrameType2InfoModulation& secondaryCCPCHFrameType2InfoModulation) { *static_cast<SecondaryCCPCHFrameType2InfoModulation*>(items[2]) = secondaryCCPCHFrameType2InfoModulation; }
};

typedef Boolean SecondaryCCPCHInfoDiffMBMSSttdIndicator;

class SecondaryCCPCHInfoDiffMBMS : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SecondaryCCPCHInfoDiffMBMS(): Sequence(&theInfo) {}

	void setSecondaryScramblingCode(const SecondaryScramblingCode& secondaryScramblingCode) { *static_cast<SecondaryScramblingCode*>(items[0]) = secondaryScramblingCode; }
	void setSecondaryCCPCHInfoDiffMBMSSttdIndicator(const SecondaryCCPCHInfoDiffMBMSSttdIndicator& secondaryCCPCHInfoDiffMBMSSttdIndicator) { *static_cast<SecondaryCCPCHInfoDiffMBMSSttdIndicator*>(items[1]) = secondaryCCPCHInfoDiffMBMSSttdIndicator; }
	void setSfAndCodeNumber(const SF256AndCodeNumber& sfAndCodeNumber) { *static_cast<SF256AndCodeNumber*>(items[2]) = sfAndCodeNumber; }
	void setTimingOffset(const TimingOffset& timingOffset) { *static_cast<TimingOffset*>(items[3]) = timingOffset; }
};

typedef Boolean ServingCellChangeMACreset;

enum ServingCellChangeMsgTypeValues {
	radioBearerSetup_ServingCellChangeMsgType = 0,
	radioBearerReconfiguration_ServingCellChangeMsgType = 1,
	transportChannelReconfiguration_ServingCellChangeMsgType = 2,
	physicalChannelReconfiguration_ServingCellChangeMsgType = 3,
};
typedef Enumerated<CONSTRAINED, 3> ServingCellChangeMsgType;

typedef Integer<CONSTRAINED, 0, 3> ServingCellChangeTrId;

class ServingCellChangeParameters : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ServingCellChangeParameters(): Sequence(&theInfo) {}

	void setServingCellChangeMACreset(const ServingCellChangeMACreset& servingCellChangeMACreset) { *static_cast<ServingCellChangeMACreset*>(items[0]) = servingCellChangeMACreset; }
	void setServingCellChangeMsgType(const ServingCellChangeMsgType& servingCellChangeMsgType) { *static_cast<ServingCellChangeMsgType*>(items[1]) = servingCellChangeMsgType; }
	void setServingCellChangeTrId(const ServingCellChangeTrId& servingCellChangeTrId) { *static_cast<ServingCellChangeTrId*>(items[2]) = servingCellChangeTrId; }
};

typedef Integer<CONSTRAINED, 0, 4095> SFNTimeInfoActivationTimeSFN;

class SFNTimeInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SFNTimeInfo(): Sequence(&theInfo) {}

	void setSFNTimeInfoActivationTimeSFN(const SFNTimeInfoActivationTimeSFN& sFNTimeInfoActivationTimeSFN) { *static_cast<SFNTimeInfoActivationTimeSFN*>(items[0]) = sFNTimeInfoActivationTimeSFN; }
	void setPhysChDuration(const DurationTimeInfo& physChDuration) { *static_cast<DurationTimeInfo*>(items[1]) = physChDuration; }
};

typedef Integer<CONSTRAINED, 0, 7> SpecialBurstScheduling;

enum SpreadingFactorValues {
	sf4_SpreadingFactor = 0,
	sf8_SpreadingFactor = 1,
	sf16_SpreadingFactor = 2,
	sf32_SpreadingFactor = 3,
	sf64_SpreadingFactor = 4,
	sf128_SpreadingFactor = 5,
	sf256_SpreadingFactor = 6,
};
typedef Enumerated<CONSTRAINED, 6> SpreadingFactor;

class SPSInformationTDD128r8 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SPSInformationTDD128r8(): Sequence(&theInfo) {}

	void setEdchSPSInfo(const EDCHSPSInformationTDD128& edchSPSInfo) { *static_cast<EDCHSPSInformationTDD128*>(items[0]) = edchSPSInfo; }
	void setHsdschSPSInfo(const HSDSCHSPSInformationTDD128& hsdschSPSInfo) { *static_cast<HSDSCHSPSInformationTDD128*>(items[1]) = hsdschSPSInfo; }
};

typedef BitString<CONSTRAINED, 8, 8> SynchronisationParametersr4SyncULCodesBitmap;

typedef Integer<CONSTRAINED, 0, 62> SynchronisationParametersr4PrxUpPCHdes;

enum SYNCULProcedurer4max_SYNC_UL_TransmissionsValues {
	tr1_SYNCULProcedurer4max_SYNC_UL_Transmissions = 0,
	tr2_SYNCULProcedurer4max_SYNC_UL_Transmissions = 1,
	tr4_SYNCULProcedurer4max_SYNC_UL_Transmissions = 2,
	tr8_SYNCULProcedurer4max_SYNC_UL_Transmissions = 3,
};
typedef Enumerated<CONSTRAINED, 3> SYNCULProcedurer4max_SYNC_UL_Transmissions;

typedef Integer<CONSTRAINED, 0, 3> SYNCULProcedurer4PowerRampStep;

class SYNCULProcedurer4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SYNCULProcedurer4(): Sequence(&theInfo) {}

	void setSYNCULProcedurer4max_SYNC_UL_Transmissions(const SYNCULProcedurer4max_SYNC_UL_Transmissions& sYNCULProcedurer4max_SYNC_UL_Transmissions) { *static_cast<SYNCULProcedurer4max_SYNC_UL_Transmissions*>(items[0]) = sYNCULProcedurer4max_SYNC_UL_Transmissions; }
	void setSYNCULProcedurer4PowerRampStep(const SYNCULProcedurer4PowerRampStep& sYNCULProcedurer4PowerRampStep) { *static_cast<SYNCULProcedurer4PowerRampStep*>(items[1]) = sYNCULProcedurer4PowerRampStep; }
};

class SynchronisationParametersr4 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SynchronisationParametersr4(): Sequence(&theInfo) {}

	void setSynchronisationParametersr4SyncULCodesBitmap(const SynchronisationParametersr4SyncULCodesBitmap& synchronisationParametersr4SyncULCodesBitmap) { *static_cast<SynchronisationParametersr4SyncULCodesBitmap*>(items[0]) = synchronisationParametersr4SyncULCodesBitmap; }
	void setFpachInfo(const FPACHInfor4& fpachInfo) { *static_cast<FPACHInfor4*>(items[1]) = fpachInfo; }
	void setSynchronisationParametersr4PrxUpPCHdes(const SynchronisationParametersr4PrxUpPCHdes& synchronisationParametersr4PrxUpPCHdes) { *static_cast<SynchronisationParametersr4PrxUpPCHdes*>(items[2]) = synchronisationParametersr4PrxUpPCHdes; }
	void setSyncULProcedure(const SYNCULProcedurer4& syncULProcedure) { *static_cast<SYNCULProcedurer4*>(items[3]) = syncULProcedure; }
};

class TDDMBSFNTSlotInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	TDDMBSFNTSlotInfo(): Sequence(&theInfo) {}

	void setTimeSlotNumber(const TimeslotNumber& timeSlotNumber) { *static_cast<TimeslotNumber*>(items[0]) = timeSlotNumber; }
	void setCellParametersID(const CellParametersID& cellParametersID) { *static_cast<CellParametersID*>(items[1]) = cellParametersID; }
};

typedef SequenceOf<TDDMBSFNTSlotInfo, CONSTRAINED, 1, maxTS> TDDMBSFNInformation;

enum TFCControlDurationValues {
	tfc_cd1_TFCControlDuration = 0,
	tfc_cd2_TFCControlDuration = 1,
	tfc_cd4_TFCControlDuration = 2,
	tfc_cd8_TFCControlDuration = 3,
	tfc_cd16_TFCControlDuration = 4,
	tfc_cd24_TFCControlDuration = 5,
	tfc_cd32_TFCControlDuration = 6,
	tfc_cd48_TFCControlDuration = 7,
	tfc_cd64_TFCControlDuration = 8,
	tfc_cd128_TFCControlDuration = 9,
	tfc_cd192_TFCControlDuration = 10,
	tfc_cd256_TFCControlDuration = 11,
	tfc_cd512_TFCControlDuration = 12,
};
typedef Enumerated<CONSTRAINED, 12> TFCControlDuration;

typedef SequenceOf<TimeslotNumber, CONSTRAINED, 1, maxTS> TimeslotList;

typedef SequenceOf<TimeslotNumber, CONSTRAINED, 1, maxTS> TimeslotListr4Tdd384;

typedef SequenceOf<TimeslotNumberLCRr4, CONSTRAINED, 1, maxTS_LCR> TimeslotListr4Tdd128;

class TimeslotListr4 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum TimeslotListr4Choices {
		timeslotListr4Tdd384 = 0,
		timeslotListr4Tdd128 = 1,
	};
	static const Info theInfo;
	TimeslotListr4(): Choice(&theInfo) {}
};

enum UL16QAMConfigmac_es_e_resetIndicatorValues {
	true_UL16QAMConfigmac_es_e_resetIndicator = 0,
};
typedef Enumerated<CONSTRAINED, 0> UL16QAMConfigmac_es_e_resetIndicator;

class UL16QAMConfig : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UL16QAMConfig(): Sequence(&theInfo) {}

	void setUl16QAMSettings(const UL16QAMSettings& ul16QAMSettings) { *static_cast<UL16QAMSettings*>(items[0]) = ul16QAMSettings; }
	void setETFCITableIndex(const ETFCITableIndex& eTFCITableIndex) { *static_cast<ETFCITableIndex*>(items[1]) = eTFCITableIndex; }
	void setUL16QAMConfigmac_es_e_resetIndicator(const UL16QAMConfigmac_es_e_resetIndicator& uL16QAMConfigmac_es_e_resetIndicator) { *static_cast<UL16QAMConfigmac_es_e_resetIndicator*>(items[2]) = uL16QAMConfigmac_es_e_resetIndicator; }
};

class ULCCTrCH : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	ULCCTrCH(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setUlTargetSIR(const ULTargetSIR& ulTargetSIR) { *static_cast<ULTargetSIR*>(items[1]) = ulTargetSIR; }
	void setTimeInfo(const TimeInfo& timeInfo) { *static_cast<TimeInfo*>(items[2]) = timeInfo; }
	void setCommonTimeslotInfo(const CommonTimeslotInfo& commonTimeslotInfo) { *static_cast<CommonTimeslotInfo*>(items[3]) = commonTimeslotInfo; }
	void setUlCCTrCHTimeslotsCodes(const UplinkTimeslotsCodes& ulCCTrCHTimeslotsCodes) { *static_cast<UplinkTimeslotsCodes*>(items[4]) = ulCCTrCHTimeslotsCodes; }
};

class ULCCTrCHr4TddOptionTdd384 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULCCTrCHr4TddOptionTdd384(): Sequence(&theInfo) {}

	void setUlCCTrCHTimeslotsCodes(const UplinkTimeslotsCodes& ulCCTrCHTimeslotsCodes) { *static_cast<UplinkTimeslotsCodes*>(items[0]) = ulCCTrCHTimeslotsCodes; }
};

class ULCCTrCHr4TddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULCCTrCHr4TddOptionTdd128(): Sequence(&theInfo) {}

	void setUlCCTrCHTimeslotsCodes(const UplinkTimeslotsCodesLCRr4& ulCCTrCHTimeslotsCodes) { *static_cast<UplinkTimeslotsCodesLCRr4*>(items[0]) = ulCCTrCHTimeslotsCodes; }
};

class ULCCTrCHr4TddOption : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULCCTrCHr4TddOptionChoices {
		uLCCTrCHr4TddOptionTdd384 = 0,
		uLCCTrCHr4TddOptionTdd128 = 1,
	};
	static const Info theInfo;
	ULCCTrCHr4TddOption(): Choice(&theInfo) {}
};

class ULCCTrCHr4 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	ULCCTrCHr4(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setUlTargetSIR(const ULTargetSIR& ulTargetSIR) { *static_cast<ULTargetSIR*>(items[1]) = ulTargetSIR; }
	void setTimeInfo(const TimeInfo& timeInfo) { *static_cast<TimeInfo*>(items[2]) = timeInfo; }
	void setCommonTimeslotInfo(const CommonTimeslotInfo& commonTimeslotInfo) { *static_cast<CommonTimeslotInfo*>(items[3]) = commonTimeslotInfo; }
	void setULCCTrCHr4TddOption(const ULCCTrCHr4TddOption& uLCCTrCHr4TddOption) { *static_cast<ULCCTrCHr4TddOption*>(items[4]) = uLCCTrCHr4TddOption; }
};

class ULCCTrCHr7TddOptionTdd384 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULCCTrCHr7TddOptionTdd384(): Sequence(&theInfo) {}

	void setUlCCTrCHTimeslotsCodes(const UplinkTimeslotsCodes& ulCCTrCHTimeslotsCodes) { *static_cast<UplinkTimeslotsCodes*>(items[0]) = ulCCTrCHTimeslotsCodes; }
};

class ULCCTrCHr7TddOptionTdd768 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULCCTrCHr7TddOptionTdd768(): Sequence(&theInfo) {}

	void setUlCCTrCHTimeslotsCodes(const UplinkTimeslotsCodesVHCR& ulCCTrCHTimeslotsCodes) { *static_cast<UplinkTimeslotsCodesVHCR*>(items[0]) = ulCCTrCHTimeslotsCodes; }
};

typedef Boolean UplinkTimeslotsCodesLCRr7DynamicSFusage;

class ULTSChannelisationCodeListr7 : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	ULTSChannelisationCodeListr7(): Sequence(&theInfo) {}

};

typedef Null UplinkTimeslotsCodesLCRr7MoreTimeslotsNoMore;

typedef Integer<CONSTRAINED, 1, maxTS_LCR_1> UplinkTimeslotsCodesLCRr7MoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots;

class UplinkTimeslotsCodesLCRr7MoreTimeslotsAdditionalTimeslotsConsecutive : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UplinkTimeslotsCodesLCRr7MoreTimeslotsAdditionalTimeslotsConsecutive(): Sequence(&theInfo) {}

	void setUplinkTimeslotsCodesLCRr7MoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots(const UplinkTimeslotsCodesLCRr7MoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots& uplinkTimeslotsCodesLCRr7MoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots) { *static_cast<UplinkTimeslotsCodesLCRr7MoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots*>(items[0]) = uplinkTimeslotsCodesLCRr7MoreTimeslotsAdditionalTimeslotsConsecutiveNumAdditionalTimeslots; }
};

class UplinkAdditionalTimeslotsLCRr7ParametersSameAsLast : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UplinkAdditionalTimeslotsLCRr7ParametersSameAsLast(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumber& timeslotNumber) { *static_cast<TimeslotNumber*>(items[0]) = timeslotNumber; }
};

class UplinkAdditionalTimeslotsLCRr7ParametersNewParameters : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UplinkAdditionalTimeslotsLCRr7ParametersNewParameters(): Sequence(&theInfo) {}

	void setIndividualTimeslotInfo(const IndividualTimeslotInfoLCRr4& individualTimeslotInfo) { *static_cast<IndividualTimeslotInfoLCRr4*>(items[0]) = individualTimeslotInfo; }
	void setUlTSChannelisationCodeList(const ULTSChannelisationCodeListr7& ulTSChannelisationCodeList) { *static_cast<ULTSChannelisationCodeListr7*>(items[1]) = ulTSChannelisationCodeList; }
};

class UplinkAdditionalTimeslotsLCRr7Parameters : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UplinkAdditionalTimeslotsLCRr7ParametersChoices {
		uplinkAdditionalTimeslotsLCRr7ParametersSameAsLast = 0,
		uplinkAdditionalTimeslotsLCRr7ParametersNewParameters = 1,
	};
	static const Info theInfo;
	UplinkAdditionalTimeslotsLCRr7Parameters(): Choice(&theInfo) {}
};

class UplinkAdditionalTimeslotsLCRr7 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UplinkAdditionalTimeslotsLCRr7(): Sequence(&theInfo) {}

	void setUplinkAdditionalTimeslotsLCRr7Parameters(const UplinkAdditionalTimeslotsLCRr7Parameters& uplinkAdditionalTimeslotsLCRr7Parameters) { *static_cast<UplinkAdditionalTimeslotsLCRr7Parameters*>(items[0]) = uplinkAdditionalTimeslotsLCRr7Parameters; }
};

typedef SequenceOf<UplinkAdditionalTimeslotsLCRr7, CONSTRAINED, 1, maxTS_LCR_1> UplinkTimeslotsCodesLCRr7MoreTimeslotsAdditionalTimeslotsTimeslotList;

class UplinkTimeslotsCodesLCRr7MoreTimeslotsAdditionalTimeslots : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UplinkTimeslotsCodesLCRr7MoreTimeslotsAdditionalTimeslotsChoices {
		uplinkTimeslotsCodesLCRr7MoreTimeslotsAdditionalTimeslotsConsecutive = 0,
		uplinkTimeslotsCodesLCRr7MoreTimeslotsAdditionalTimeslotsTimeslotList = 1,
	};
	static const Info theInfo;
	UplinkTimeslotsCodesLCRr7MoreTimeslotsAdditionalTimeslots(): Choice(&theInfo) {}
};

class UplinkTimeslotsCodesLCRr7MoreTimeslots : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UplinkTimeslotsCodesLCRr7MoreTimeslotsChoices {
		uplinkTimeslotsCodesLCRr7MoreTimeslotsNoMore = 0,
		uplinkTimeslotsCodesLCRr7MoreTimeslotsAdditionalTimeslots = 1,
	};
	static const Info theInfo;
	UplinkTimeslotsCodesLCRr7MoreTimeslots(): Choice(&theInfo) {}
};

class UplinkTimeslotsCodesLCRr7 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UplinkTimeslotsCodesLCRr7(): Sequence(&theInfo) {}

	void setUplinkTimeslotsCodesLCRr7DynamicSFusage(const UplinkTimeslotsCodesLCRr7DynamicSFusage& uplinkTimeslotsCodesLCRr7DynamicSFusage) { *static_cast<UplinkTimeslotsCodesLCRr7DynamicSFusage*>(items[0]) = uplinkTimeslotsCodesLCRr7DynamicSFusage; }
	void setFirstIndividualTimeslotInfo(const IndividualTimeslotInfoLCRr4& firstIndividualTimeslotInfo) { *static_cast<IndividualTimeslotInfoLCRr4*>(items[1]) = firstIndividualTimeslotInfo; }
	void setUlTSChannelisationCodeList(const ULTSChannelisationCodeListr7& ulTSChannelisationCodeList) { *static_cast<ULTSChannelisationCodeListr7*>(items[2]) = ulTSChannelisationCodeList; }
	void setUplinkTimeslotsCodesLCRr7MoreTimeslots(const UplinkTimeslotsCodesLCRr7MoreTimeslots& uplinkTimeslotsCodesLCRr7MoreTimeslots) { *static_cast<UplinkTimeslotsCodesLCRr7MoreTimeslots*>(items[3]) = uplinkTimeslotsCodesLCRr7MoreTimeslots; }
};

class ULCCTrCHr7TddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULCCTrCHr7TddOptionTdd128(): Sequence(&theInfo) {}

	void setUlCCTrCHTimeslotsCodes(const UplinkTimeslotsCodesLCRr7& ulCCTrCHTimeslotsCodes) { *static_cast<UplinkTimeslotsCodesLCRr7*>(items[0]) = ulCCTrCHTimeslotsCodes; }
};

class ULCCTrCHr7TddOption : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum ULCCTrCHr7TddOptionChoices {
		uLCCTrCHr7TddOptionTdd384 = 0,
		uLCCTrCHr7TddOptionTdd768 = 1,
		uLCCTrCHr7TddOptionTdd128 = 2,
	};
	static const Info theInfo;
	ULCCTrCHr7TddOption(): Choice(&theInfo) {}
};

class ULCCTrCHr7 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	ULCCTrCHr7(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setUlTargetSIR(const ULTargetSIR& ulTargetSIR) { *static_cast<ULTargetSIR*>(items[1]) = ulTargetSIR; }
	void setTimeInfo(const TimeInfo& timeInfo) { *static_cast<TimeInfo*>(items[2]) = timeInfo; }
	void setCommonTimeslotInfo(const CommonTimeslotInfo& commonTimeslotInfo) { *static_cast<CommonTimeslotInfo*>(items[3]) = commonTimeslotInfo; }
	void setULCCTrCHr7TddOption(const ULCCTrCHr7TddOption& uLCCTrCHr7TddOption) { *static_cast<ULCCTrCHr7TddOption*>(items[4]) = uLCCTrCHr7TddOption; }
};

typedef SequenceOf<ULCCTrCH, CONSTRAINED, 1, maxCCTrCH> ULCCTrCHList;

typedef SequenceOf<ULCCTrCHr4, CONSTRAINED, 1, maxCCTrCH> ULCCTrCHListr4;

typedef SequenceOf<ULCCTrCHr7, CONSTRAINED, 1, maxCCTrCH> ULCCTrCHListr7;

typedef SequenceOf<TFCSIdentityPlain, CONSTRAINED, 1, maxCCTrCH> ULCCTrCHListToRemove;

typedef Boolean ULDPCHInfoModeSpecificInfoFddTfciExistence;

class ULDPCHInfoModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	ULDPCHInfoModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setScramblingCodeType(const ScramblingCodeType& scramblingCodeType) { *static_cast<ScramblingCodeType*>(items[0]) = scramblingCodeType; }
	void setScramblingCode(const ULScramblingCode& scramblingCode) { *static_cast<ULScramblingCode*>(items[1]) = scramblingCode; }
	void setNumberOfDPDCH(const NumberOfDPDCH& numberOfDPDCH) { *static_cast<NumberOfDPDCH*>(items[2]) = numberOfDPDCH; }
	void setSpreadingFactor(const SpreadingFactor& spreadingFactor) { *static_cast<SpreadingFactor*>(items[3]) = spreadingFactor; }
	void setULDPCHInfoModeSpecificInfoFddTfciExistence(const ULDPCHInfoModeSpecificInfoFddTfciExistence& uLDPCHInfoModeSpecificInfoFddTfciExistence) { *static_cast<ULDPCHInfoModeSpecificInfoFddTfciExistence*>(items[4]) = uLDPCHInfoModeSpecificInfoFddTfciExistence; }
	void setNumberOfFBIBits(const NumberOfFBIBits& numberOfFBIBits) { *static_cast<NumberOfFBIBits*>(items[5]) = numberOfFBIBits; }
	void setPuncturingLimit(const PuncturingLimit& puncturingLimit) { *static_cast<PuncturingLimit*>(items[6]) = puncturingLimit; }
};

typedef Null ULTimingAdvanceControlDisabled;

typedef Integer<CONSTRAINED, 0, 63> ULTimingAdvance;

class ULTimingAdvanceControlEnabled : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULTimingAdvanceControlEnabled(): Sequence(&theInfo) {}

	void setUlTimingAdvance(const ULTimingAdvance& ulTimingAdvance) { *static_cast<ULTimingAdvance*>(items[0]) = ulTimingAdvance; }
	void setActivationTime(const ActivationTime& activationTime) { *static_cast<ActivationTime*>(items[1]) = activationTime; }
};

class ULTimingAdvanceControl : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULTimingAdvanceControlChoices {
		uLTimingAdvanceControlDisabled = 0,
		uLTimingAdvanceControlEnabled = 1,
	};
	static const Info theInfo;
	ULTimingAdvanceControl(): Choice(&theInfo) {}
};

class ULDPCHInfoModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULDPCHInfoModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setUlTimingAdvance(const ULTimingAdvanceControl& ulTimingAdvance) { *static_cast<ULTimingAdvanceControl*>(items[0]) = ulTimingAdvance; }
	void setUlCCTrCHList(const ULCCTrCHList& ulCCTrCHList) { *static_cast<ULCCTrCHList*>(items[1]) = ulCCTrCHList; }
	void setUlCCTrCHListToRemove(const ULCCTrCHListToRemove& ulCCTrCHListToRemove) { *static_cast<ULCCTrCHListToRemove*>(items[2]) = ulCCTrCHListToRemove; }
};

class ULDPCHInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHInfoModeSpecificInfoChoices {
		uLDPCHInfoModeSpecificInfoFdd = 0,
		uLDPCHInfoModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	ULDPCHInfoModeSpecificInfo(): Choice(&theInfo) {}
};

class ULDPCHInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHInfo(): Sequence(&theInfo) {}

	void setUlDPCHPowerControlInfo(const ULDPCHPowerControlInfo& ulDPCHPowerControlInfo) { *static_cast<ULDPCHPowerControlInfo*>(items[0]) = ulDPCHPowerControlInfo; }
	void setULDPCHInfoModeSpecificInfo(const ULDPCHInfoModeSpecificInfo& uLDPCHInfoModeSpecificInfo) { *static_cast<ULDPCHInfoModeSpecificInfo*>(items[1]) = uLDPCHInfoModeSpecificInfo; }
};

class ULChannelRequirement : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULChannelRequirementChoices {
		ulDPCHInfo = 0,
		dummy = 1,
	};
	static const Info theInfo;
	ULChannelRequirement(): Choice(&theInfo) {}
};

typedef Boolean ULDPCHInfor4ModeSpecificInfoFddTfciExistence;

class ULDPCHInfor4ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	ULDPCHInfor4ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setScramblingCodeType(const ScramblingCodeType& scramblingCodeType) { *static_cast<ScramblingCodeType*>(items[0]) = scramblingCodeType; }
	void setScramblingCode(const ULScramblingCode& scramblingCode) { *static_cast<ULScramblingCode*>(items[1]) = scramblingCode; }
	void setNumberOfDPDCH(const NumberOfDPDCH& numberOfDPDCH) { *static_cast<NumberOfDPDCH*>(items[2]) = numberOfDPDCH; }
	void setSpreadingFactor(const SpreadingFactor& spreadingFactor) { *static_cast<SpreadingFactor*>(items[3]) = spreadingFactor; }
	void setULDPCHInfor4ModeSpecificInfoFddTfciExistence(const ULDPCHInfor4ModeSpecificInfoFddTfciExistence& uLDPCHInfor4ModeSpecificInfoFddTfciExistence) { *static_cast<ULDPCHInfor4ModeSpecificInfoFddTfciExistence*>(items[4]) = uLDPCHInfor4ModeSpecificInfoFddTfciExistence; }
	void setNumberOfFBIBits(const NumberOfFBIBits& numberOfFBIBits) { *static_cast<NumberOfFBIBits*>(items[5]) = numberOfFBIBits; }
	void setPuncturingLimit(const PuncturingLimit& puncturingLimit) { *static_cast<PuncturingLimit*>(items[6]) = puncturingLimit; }
};

typedef Null ULTimingAdvanceControlr4Disabled;

class ULTimingAdvanceControlr4EnabledTddOptionTdd384 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULTimingAdvanceControlr4EnabledTddOptionTdd384(): Sequence(&theInfo) {}

	void setUlTimingAdvance(const ULTimingAdvance& ulTimingAdvance) { *static_cast<ULTimingAdvance*>(items[0]) = ulTimingAdvance; }
	void setActivationTime(const ActivationTime& activationTime) { *static_cast<ActivationTime*>(items[1]) = activationTime; }
};

class ULTimingAdvanceControlr4EnabledTddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULTimingAdvanceControlr4EnabledTddOptionTdd128(): Sequence(&theInfo) {}

	void setUlSynchronisationParameters(const ULSynchronisationParametersr4& ulSynchronisationParameters) { *static_cast<ULSynchronisationParametersr4*>(items[0]) = ulSynchronisationParameters; }
	void setSynchronisationParameters(const SynchronisationParametersr4& synchronisationParameters) { *static_cast<SynchronisationParametersr4*>(items[1]) = synchronisationParameters; }
};

class ULTimingAdvanceControlr4EnabledTddOption : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULTimingAdvanceControlr4EnabledTddOptionChoices {
		uLTimingAdvanceControlr4EnabledTddOptionTdd384 = 0,
		uLTimingAdvanceControlr4EnabledTddOptionTdd128 = 1,
	};
	static const Info theInfo;
	ULTimingAdvanceControlr4EnabledTddOption(): Choice(&theInfo) {}
};

class ULTimingAdvanceControlr4Enabled : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULTimingAdvanceControlr4Enabled(): Sequence(&theInfo) {}

	void setULTimingAdvanceControlr4EnabledTddOption(const ULTimingAdvanceControlr4EnabledTddOption& uLTimingAdvanceControlr4EnabledTddOption) { *static_cast<ULTimingAdvanceControlr4EnabledTddOption*>(items[0]) = uLTimingAdvanceControlr4EnabledTddOption; }
};

class ULTimingAdvanceControlr4 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULTimingAdvanceControlr4Choices {
		uLTimingAdvanceControlr4Disabled = 0,
		uLTimingAdvanceControlr4Enabled = 1,
	};
	static const Info theInfo;
	ULTimingAdvanceControlr4(): Choice(&theInfo) {}
};

class ULDPCHInfor4ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULDPCHInfor4ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setUlTimingAdvance(const ULTimingAdvanceControlr4& ulTimingAdvance) { *static_cast<ULTimingAdvanceControlr4*>(items[0]) = ulTimingAdvance; }
	void setUlCCTrCHList(const ULCCTrCHListr4& ulCCTrCHList) { *static_cast<ULCCTrCHListr4*>(items[1]) = ulCCTrCHList; }
	void setUlCCTrCHListToRemove(const ULCCTrCHListToRemove& ulCCTrCHListToRemove) { *static_cast<ULCCTrCHListToRemove*>(items[2]) = ulCCTrCHListToRemove; }
};

class ULDPCHInfor4ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHInfor4ModeSpecificInfoChoices {
		uLDPCHInfor4ModeSpecificInfoFdd = 0,
		uLDPCHInfor4ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	ULDPCHInfor4ModeSpecificInfo(): Choice(&theInfo) {}
};

class ULDPCHInfor4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHInfor4(): Sequence(&theInfo) {}

	void setUlDPCHPowerControlInfo(const ULDPCHPowerControlInfor4& ulDPCHPowerControlInfo) { *static_cast<ULDPCHPowerControlInfor4*>(items[0]) = ulDPCHPowerControlInfo; }
	void setULDPCHInfor4ModeSpecificInfo(const ULDPCHInfor4ModeSpecificInfo& uLDPCHInfor4ModeSpecificInfo) { *static_cast<ULDPCHInfor4ModeSpecificInfo*>(items[1]) = uLDPCHInfor4ModeSpecificInfo; }
};

class ULChannelRequirementr4 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULChannelRequirementr4Choices {
		ulDPCHInfo = 0,
		dummy = 1,
	};
	static const Info theInfo;
	ULChannelRequirementr4(): Choice(&theInfo) {}
};

typedef Boolean ULDPCHInfor5ModeSpecificInfoFddTfciExistence;

class ULDPCHInfor5ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	ULDPCHInfor5ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setScramblingCodeType(const ScramblingCodeType& scramblingCodeType) { *static_cast<ScramblingCodeType*>(items[0]) = scramblingCodeType; }
	void setScramblingCode(const ULScramblingCode& scramblingCode) { *static_cast<ULScramblingCode*>(items[1]) = scramblingCode; }
	void setNumberOfDPDCH(const NumberOfDPDCH& numberOfDPDCH) { *static_cast<NumberOfDPDCH*>(items[2]) = numberOfDPDCH; }
	void setSpreadingFactor(const SpreadingFactor& spreadingFactor) { *static_cast<SpreadingFactor*>(items[3]) = spreadingFactor; }
	void setULDPCHInfor5ModeSpecificInfoFddTfciExistence(const ULDPCHInfor5ModeSpecificInfoFddTfciExistence& uLDPCHInfor5ModeSpecificInfoFddTfciExistence) { *static_cast<ULDPCHInfor5ModeSpecificInfoFddTfciExistence*>(items[4]) = uLDPCHInfor5ModeSpecificInfoFddTfciExistence; }
	void setNumberOfFBIBits(const NumberOfFBIBits& numberOfFBIBits) { *static_cast<NumberOfFBIBits*>(items[5]) = numberOfFBIBits; }
	void setPuncturingLimit(const PuncturingLimit& puncturingLimit) { *static_cast<PuncturingLimit*>(items[6]) = puncturingLimit; }
};

class ULDPCHInfor5ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULDPCHInfor5ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setUlTimingAdvance(const ULTimingAdvanceControlr4& ulTimingAdvance) { *static_cast<ULTimingAdvanceControlr4*>(items[0]) = ulTimingAdvance; }
	void setUlCCTrCHList(const ULCCTrCHListr4& ulCCTrCHList) { *static_cast<ULCCTrCHListr4*>(items[1]) = ulCCTrCHList; }
	void setUlCCTrCHListToRemove(const ULCCTrCHListToRemove& ulCCTrCHListToRemove) { *static_cast<ULCCTrCHListToRemove*>(items[2]) = ulCCTrCHListToRemove; }
};

class ULDPCHInfor5ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHInfor5ModeSpecificInfoChoices {
		uLDPCHInfor5ModeSpecificInfoFdd = 0,
		uLDPCHInfor5ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	ULDPCHInfor5ModeSpecificInfo(): Choice(&theInfo) {}
};

class ULDPCHInfor5 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHInfor5(): Sequence(&theInfo) {}

	void setUlDPCHPowerControlInfo(const ULDPCHPowerControlInfor5& ulDPCHPowerControlInfo) { *static_cast<ULDPCHPowerControlInfor5*>(items[0]) = ulDPCHPowerControlInfo; }
	void setULDPCHInfor5ModeSpecificInfo(const ULDPCHInfor5ModeSpecificInfo& uLDPCHInfor5ModeSpecificInfo) { *static_cast<ULDPCHInfor5ModeSpecificInfo*>(items[1]) = uLDPCHInfor5ModeSpecificInfo; }
};

class ULChannelRequirementr5 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULChannelRequirementr5Choices {
		ulDPCHInfo = 0,
		dummy = 1,
	};
	static const Info theInfo;
	ULChannelRequirementr5(): Choice(&theInfo) {}
};

class ULChannelRequirementWithCPCHSetID : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum ULChannelRequirementWithCPCHSetIDChoices {
		ulDPCHInfo = 0,
		dummy1 = 1,
		dummy2 = 2,
	};
	static const Info theInfo;
	ULChannelRequirementWithCPCHSetID(): Choice(&theInfo) {}
};

class ULChannelRequirementWithCPCHSetIDr4 : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum ULChannelRequirementWithCPCHSetIDr4Choices {
		ulDPCHInfo = 0,
		dummy1 = 1,
		dummy2 = 2,
	};
	static const Info theInfo;
	ULChannelRequirementWithCPCHSetIDr4(): Choice(&theInfo) {}
};

class ULChannelRequirementWithCPCHSetIDr5 : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum ULChannelRequirementWithCPCHSetIDr5Choices {
		ulDPCHInfo = 0,
		dummy1 = 1,
		dummy2 = 2,
	};
	static const Info theInfo;
	ULChannelRequirementWithCPCHSetIDr5(): Choice(&theInfo) {}
};

class ULDPCHPowerControlInfor6Fdd : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor6Fdd(): Sequence(&theInfo) {}

	void setDpcchPowerOffset(const DPCCHPowerOffset& dpcchPowerOffset) { *static_cast<DPCCHPowerOffset*>(items[0]) = dpcchPowerOffset; }
	void setPcPreamble(const PCPreamble& pcPreamble) { *static_cast<PCPreamble*>(items[1]) = pcPreamble; }
	void setSRBdelay(const SRBdelay& sRBdelay) { *static_cast<SRBdelay*>(items[2]) = sRBdelay; }
	void setPowerControlAlgorithm(const PowerControlAlgorithm& powerControlAlgorithm) { *static_cast<PowerControlAlgorithm*>(items[3]) = powerControlAlgorithm; }
	void setDeltaACK(const DeltaACK& deltaACK) { *static_cast<DeltaACK*>(items[4]) = deltaACK; }
	void setDeltaNACK(const DeltaNACK& deltaNACK) { *static_cast<DeltaNACK*>(items[5]) = deltaNACK; }
	void setAckNACKrepetitionfactor(const ACKNACKrepetitionFactor& ackNACKrepetitionfactor) { *static_cast<ACKNACKrepetitionFactor*>(items[6]) = ackNACKrepetitionfactor; }
	void setHarqPreambleMode(const HARQPreambleMode& harqPreambleMode) { *static_cast<HARQPreambleMode*>(items[7]) = harqPreambleMode; }
};

typedef Null ULDPCHPowerControlInfor6TddUlOLPCSignallingBroadcastULOLPCinfo;

class ULDPCHPowerControlInfor6TddUlOLPCSignallingIndividuallySignalledTddOptionTdd384 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor6TddUlOLPCSignallingIndividuallySignalledTddOptionTdd384(): Sequence(&theInfo) {}

	void setIndividualTSInterferenceList(const IndividualTSInterferenceList& individualTSInterferenceList) { *static_cast<IndividualTSInterferenceList*>(items[0]) = individualTSInterferenceList; }
	void setDpchConstantValue(const ConstantValue& dpchConstantValue) { *static_cast<ConstantValue*>(items[1]) = dpchConstantValue; }
};

class ULDPCHPowerControlInfor6TddUlOLPCSignallingIndividuallySignalledTddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor6TddUlOLPCSignallingIndividuallySignalledTddOptionTdd128(): Sequence(&theInfo) {}

	void setBeaconPLEst(const BEACONPLEst& beaconPLEst) { *static_cast<BEACONPLEst*>(items[0]) = beaconPLEst; }
	void setTpcStepSize(const TPCStepSizeTDD& tpcStepSize) { *static_cast<TPCStepSizeTDD*>(items[1]) = tpcStepSize; }
};

class ULDPCHPowerControlInfor6TddUlOLPCSignallingIndividuallySignalledTddOption : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHPowerControlInfor6TddUlOLPCSignallingIndividuallySignalledTddOptionChoices {
		uLDPCHPowerControlInfor6TddUlOLPCSignallingIndividuallySignalledTddOptionTdd384 = 0,
		uLDPCHPowerControlInfor6TddUlOLPCSignallingIndividuallySignalledTddOptionTdd128 = 1,
	};
	static const Info theInfo;
	ULDPCHPowerControlInfor6TddUlOLPCSignallingIndividuallySignalledTddOption(): Choice(&theInfo) {}
};

class ULDPCHPowerControlInfor6TddUlOLPCSignallingIndividuallySignalled : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor6TddUlOLPCSignallingIndividuallySignalled(): Sequence(&theInfo) {}

	void setULDPCHPowerControlInfor6TddUlOLPCSignallingIndividuallySignalledTddOption(const ULDPCHPowerControlInfor6TddUlOLPCSignallingIndividuallySignalledTddOption& uLDPCHPowerControlInfor6TddUlOLPCSignallingIndividuallySignalledTddOption) { *static_cast<ULDPCHPowerControlInfor6TddUlOLPCSignallingIndividuallySignalledTddOption*>(items[0]) = uLDPCHPowerControlInfor6TddUlOLPCSignallingIndividuallySignalledTddOption; }
	void setPrimaryCCPCHTXPower(const PrimaryCCPCHTXPower& primaryCCPCHTXPower) { *static_cast<PrimaryCCPCHTXPower*>(items[1]) = primaryCCPCHTXPower; }
};

class ULDPCHPowerControlInfor6TddUlOLPCSignalling : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHPowerControlInfor6TddUlOLPCSignallingChoices {
		uLDPCHPowerControlInfor6TddUlOLPCSignallingBroadcastULOLPCinfo = 0,
		uLDPCHPowerControlInfor6TddUlOLPCSignallingIndividuallySignalled = 1,
	};
	static const Info theInfo;
	ULDPCHPowerControlInfor6TddUlOLPCSignalling(): Choice(&theInfo) {}
};

class ULDPCHPowerControlInfor6Tdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfor6Tdd(): Sequence(&theInfo) {}

	void setUlTargetSIR(const ULTargetSIR& ulTargetSIR) { *static_cast<ULTargetSIR*>(items[0]) = ulTargetSIR; }
	void setULDPCHPowerControlInfor6TddUlOLPCSignalling(const ULDPCHPowerControlInfor6TddUlOLPCSignalling& uLDPCHPowerControlInfor6TddUlOLPCSignalling) { *static_cast<ULDPCHPowerControlInfor6TddUlOLPCSignalling*>(items[1]) = uLDPCHPowerControlInfor6TddUlOLPCSignalling; }
};

class ULDPCHPowerControlInfor6 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHPowerControlInfor6Choices {
		uLDPCHPowerControlInfor6Fdd = 0,
		uLDPCHPowerControlInfor6Tdd = 1,
	};
	static const Info theInfo;
	ULDPCHPowerControlInfor6(): Choice(&theInfo) {}
};

typedef Boolean ULDPCHInfor6ModeSpecificInfoFddDpdchPresencePresentTfciExistence;

class ULDPCHInfor6ModeSpecificInfoFddDpdchPresencePresent : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	ULDPCHInfor6ModeSpecificInfoFddDpdchPresencePresent(): Sequence(&theInfo) {}

	void setNumberOfDPDCH(const NumberOfDPDCH& numberOfDPDCH) { *static_cast<NumberOfDPDCH*>(items[0]) = numberOfDPDCH; }
	void setSpreadingFactor(const SpreadingFactor& spreadingFactor) { *static_cast<SpreadingFactor*>(items[1]) = spreadingFactor; }
	void setULDPCHInfor6ModeSpecificInfoFddDpdchPresencePresentTfciExistence(const ULDPCHInfor6ModeSpecificInfoFddDpdchPresencePresentTfciExistence& uLDPCHInfor6ModeSpecificInfoFddDpdchPresencePresentTfciExistence) { *static_cast<ULDPCHInfor6ModeSpecificInfoFddDpdchPresencePresentTfciExistence*>(items[2]) = uLDPCHInfor6ModeSpecificInfoFddDpdchPresencePresentTfciExistence; }
	void setNumberOfFBIBits(const NumberOfFBIBits& numberOfFBIBits) { *static_cast<NumberOfFBIBits*>(items[3]) = numberOfFBIBits; }
	void setPuncturingLimit(const PuncturingLimit& puncturingLimit) { *static_cast<PuncturingLimit*>(items[4]) = puncturingLimit; }
};

typedef Boolean ULDPCHInfor6ModeSpecificInfoFddDpdchPresenceNotPresentTfciExistence;

class ULDPCHInfor6ModeSpecificInfoFddDpdchPresenceNotPresent : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHInfor6ModeSpecificInfoFddDpdchPresenceNotPresent(): Sequence(&theInfo) {}

	void setULDPCHInfor6ModeSpecificInfoFddDpdchPresenceNotPresentTfciExistence(const ULDPCHInfor6ModeSpecificInfoFddDpdchPresenceNotPresentTfciExistence& uLDPCHInfor6ModeSpecificInfoFddDpdchPresenceNotPresentTfciExistence) { *static_cast<ULDPCHInfor6ModeSpecificInfoFddDpdchPresenceNotPresentTfciExistence*>(items[0]) = uLDPCHInfor6ModeSpecificInfoFddDpdchPresenceNotPresentTfciExistence; }
	void setNumberOfFBIBits(const NumberOfFBIBits& numberOfFBIBits) { *static_cast<NumberOfFBIBits*>(items[1]) = numberOfFBIBits; }
};

class ULDPCHInfor6ModeSpecificInfoFddDpdchPresence : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHInfor6ModeSpecificInfoFddDpdchPresenceChoices {
		uLDPCHInfor6ModeSpecificInfoFddDpdchPresencePresent = 0,
		uLDPCHInfor6ModeSpecificInfoFddDpdchPresenceNotPresent = 1,
	};
	static const Info theInfo;
	ULDPCHInfor6ModeSpecificInfoFddDpdchPresence(): Choice(&theInfo) {}
};

class ULDPCHInfor6ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULDPCHInfor6ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setScramblingCodeType(const ScramblingCodeType& scramblingCodeType) { *static_cast<ScramblingCodeType*>(items[0]) = scramblingCodeType; }
	void setScramblingCode(const ULScramblingCode& scramblingCode) { *static_cast<ULScramblingCode*>(items[1]) = scramblingCode; }
	void setULDPCHInfor6ModeSpecificInfoFddDpdchPresence(const ULDPCHInfor6ModeSpecificInfoFddDpdchPresence& uLDPCHInfor6ModeSpecificInfoFddDpdchPresence) { *static_cast<ULDPCHInfor6ModeSpecificInfoFddDpdchPresence*>(items[2]) = uLDPCHInfor6ModeSpecificInfoFddDpdchPresence; }
};

class ULDPCHInfor6ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULDPCHInfor6ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setUlTimingAdvance(const ULTimingAdvanceControlr4& ulTimingAdvance) { *static_cast<ULTimingAdvanceControlr4*>(items[0]) = ulTimingAdvance; }
	void setUlCCTrCHList(const ULCCTrCHListr4& ulCCTrCHList) { *static_cast<ULCCTrCHListr4*>(items[1]) = ulCCTrCHList; }
	void setUlCCTrCHListToRemove(const ULCCTrCHListToRemove& ulCCTrCHListToRemove) { *static_cast<ULCCTrCHListToRemove*>(items[2]) = ulCCTrCHListToRemove; }
};

class ULDPCHInfor6ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHInfor6ModeSpecificInfoChoices {
		uLDPCHInfor6ModeSpecificInfoFdd = 0,
		uLDPCHInfor6ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	ULDPCHInfor6ModeSpecificInfo(): Choice(&theInfo) {}
};

class ULDPCHInfor6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHInfor6(): Sequence(&theInfo) {}

	void setUlDPCHPowerControlInfo(const ULDPCHPowerControlInfor6& ulDPCHPowerControlInfo) { *static_cast<ULDPCHPowerControlInfor6*>(items[0]) = ulDPCHPowerControlInfo; }
	void setULDPCHInfor6ModeSpecificInfo(const ULDPCHInfor6ModeSpecificInfo& uLDPCHInfor6ModeSpecificInfo) { *static_cast<ULDPCHInfor6ModeSpecificInfo*>(items[1]) = uLDPCHInfor6ModeSpecificInfo; }
};

typedef Boolean ULDPCHInfor7ModeSpecificInfoFddDpdchPresencePresentTfciExistence;

class ULDPCHInfor7ModeSpecificInfoFddDpdchPresencePresent : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	ULDPCHInfor7ModeSpecificInfoFddDpdchPresencePresent(): Sequence(&theInfo) {}

	void setNumberOfDPDCH(const NumberOfDPDCH& numberOfDPDCH) { *static_cast<NumberOfDPDCH*>(items[0]) = numberOfDPDCH; }
	void setSpreadingFactor(const SpreadingFactor& spreadingFactor) { *static_cast<SpreadingFactor*>(items[1]) = spreadingFactor; }
	void setULDPCHInfor7ModeSpecificInfoFddDpdchPresencePresentTfciExistence(const ULDPCHInfor7ModeSpecificInfoFddDpdchPresencePresentTfciExistence& uLDPCHInfor7ModeSpecificInfoFddDpdchPresencePresentTfciExistence) { *static_cast<ULDPCHInfor7ModeSpecificInfoFddDpdchPresencePresentTfciExistence*>(items[2]) = uLDPCHInfor7ModeSpecificInfoFddDpdchPresencePresentTfciExistence; }
	void setNumberOfFBIBits(const NumberOfFBIBits& numberOfFBIBits) { *static_cast<NumberOfFBIBits*>(items[3]) = numberOfFBIBits; }
	void setNumberOfTPCBits(const NumberOfTPCBits& numberOfTPCBits) { *static_cast<NumberOfTPCBits*>(items[4]) = numberOfTPCBits; }
	void setPuncturingLimit(const PuncturingLimit& puncturingLimit) { *static_cast<PuncturingLimit*>(items[5]) = puncturingLimit; }
};

typedef Boolean ULDPCHInfor7ModeSpecificInfoFddDpdchPresenceNotPresentTfciExistence;

class ULDPCHInfor7ModeSpecificInfoFddDpdchPresenceNotPresent : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULDPCHInfor7ModeSpecificInfoFddDpdchPresenceNotPresent(): Sequence(&theInfo) {}

	void setULDPCHInfor7ModeSpecificInfoFddDpdchPresenceNotPresentTfciExistence(const ULDPCHInfor7ModeSpecificInfoFddDpdchPresenceNotPresentTfciExistence& uLDPCHInfor7ModeSpecificInfoFddDpdchPresenceNotPresentTfciExistence) { *static_cast<ULDPCHInfor7ModeSpecificInfoFddDpdchPresenceNotPresentTfciExistence*>(items[0]) = uLDPCHInfor7ModeSpecificInfoFddDpdchPresenceNotPresentTfciExistence; }
	void setNumberOfFBIBits(const NumberOfFBIBits& numberOfFBIBits) { *static_cast<NumberOfFBIBits*>(items[1]) = numberOfFBIBits; }
	void setNumberOfTPCBits(const NumberOfTPCBits& numberOfTPCBits) { *static_cast<NumberOfTPCBits*>(items[2]) = numberOfTPCBits; }
};

class ULDPCHInfor7ModeSpecificInfoFddDpdchPresence : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHInfor7ModeSpecificInfoFddDpdchPresenceChoices {
		uLDPCHInfor7ModeSpecificInfoFddDpdchPresencePresent = 0,
		uLDPCHInfor7ModeSpecificInfoFddDpdchPresenceNotPresent = 1,
	};
	static const Info theInfo;
	ULDPCHInfor7ModeSpecificInfoFddDpdchPresence(): Choice(&theInfo) {}
};

class ULDPCHInfor7ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULDPCHInfor7ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setScramblingCodeType(const ScramblingCodeType& scramblingCodeType) { *static_cast<ScramblingCodeType*>(items[0]) = scramblingCodeType; }
	void setScramblingCode(const ULScramblingCode& scramblingCode) { *static_cast<ULScramblingCode*>(items[1]) = scramblingCode; }
	void setULDPCHInfor7ModeSpecificInfoFddDpdchPresence(const ULDPCHInfor7ModeSpecificInfoFddDpdchPresence& uLDPCHInfor7ModeSpecificInfoFddDpdchPresence) { *static_cast<ULDPCHInfor7ModeSpecificInfoFddDpdchPresence*>(items[2]) = uLDPCHInfor7ModeSpecificInfoFddDpdchPresence; }
};

typedef Null ULTimingAdvanceControlr7Disabled;

class ULTimingAdvanceControlr7EnabledTddOptionTdd384 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULTimingAdvanceControlr7EnabledTddOptionTdd384(): Sequence(&theInfo) {}

	void setUlTimingAdvance(const ULTimingAdvance& ulTimingAdvance) { *static_cast<ULTimingAdvance*>(items[0]) = ulTimingAdvance; }
	void setExtULTimingAdvance(const EXTULTimingAdvance& extULTimingAdvance) { *static_cast<EXTULTimingAdvance*>(items[1]) = extULTimingAdvance; }
	void setActivationTime(const ActivationTime& activationTime) { *static_cast<ActivationTime*>(items[2]) = activationTime; }
};

class ULTimingAdvanceControlr7EnabledTddOptionTdd768 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULTimingAdvanceControlr7EnabledTddOptionTdd768(): Sequence(&theInfo) {}

	void setExtULTimingAdvance(const EXTULTimingAdvance& extULTimingAdvance) { *static_cast<EXTULTimingAdvance*>(items[0]) = extULTimingAdvance; }
	void setActivationTime(const ActivationTime& activationTime) { *static_cast<ActivationTime*>(items[1]) = activationTime; }
};

class ULTimingAdvanceControlr7EnabledTddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULTimingAdvanceControlr7EnabledTddOptionTdd128(): Sequence(&theInfo) {}

	void setUlSynchronisationParameters(const ULSynchronisationParametersr4& ulSynchronisationParameters) { *static_cast<ULSynchronisationParametersr4*>(items[0]) = ulSynchronisationParameters; }
	void setSynchronisationParameters(const SynchronisationParametersr4& synchronisationParameters) { *static_cast<SynchronisationParametersr4*>(items[1]) = synchronisationParameters; }
};

class ULTimingAdvanceControlr7EnabledTddOption : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum ULTimingAdvanceControlr7EnabledTddOptionChoices {
		uLTimingAdvanceControlr7EnabledTddOptionTdd384 = 0,
		uLTimingAdvanceControlr7EnabledTddOptionTdd768 = 1,
		uLTimingAdvanceControlr7EnabledTddOptionTdd128 = 2,
	};
	static const Info theInfo;
	ULTimingAdvanceControlr7EnabledTddOption(): Choice(&theInfo) {}
};

class ULTimingAdvanceControlr7Enabled : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULTimingAdvanceControlr7Enabled(): Sequence(&theInfo) {}

	void setULTimingAdvanceControlr7EnabledTddOption(const ULTimingAdvanceControlr7EnabledTddOption& uLTimingAdvanceControlr7EnabledTddOption) { *static_cast<ULTimingAdvanceControlr7EnabledTddOption*>(items[0]) = uLTimingAdvanceControlr7EnabledTddOption; }
};

class ULTimingAdvanceControlr7 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULTimingAdvanceControlr7Choices {
		uLTimingAdvanceControlr7Disabled = 0,
		uLTimingAdvanceControlr7Enabled = 1,
	};
	static const Info theInfo;
	ULTimingAdvanceControlr7(): Choice(&theInfo) {}
};

class ULDPCHInfor7ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULDPCHInfor7ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setUlTimingAdvance(const ULTimingAdvanceControlr7& ulTimingAdvance) { *static_cast<ULTimingAdvanceControlr7*>(items[0]) = ulTimingAdvance; }
	void setUlCCTrCHList(const ULCCTrCHListr7& ulCCTrCHList) { *static_cast<ULCCTrCHListr7*>(items[1]) = ulCCTrCHList; }
	void setUlCCTrCHListToRemove(const ULCCTrCHListToRemove& ulCCTrCHListToRemove) { *static_cast<ULCCTrCHListToRemove*>(items[2]) = ulCCTrCHListToRemove; }
};

class ULDPCHInfor7ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULDPCHInfor7ModeSpecificInfoChoices {
		uLDPCHInfor7ModeSpecificInfoFdd = 0,
		uLDPCHInfor7ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	ULDPCHInfor7ModeSpecificInfo(): Choice(&theInfo) {}
};

class ULDPCHInfor7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHInfor7(): Sequence(&theInfo) {}

	void setUlDPCHPowerControlInfo(const ULDPCHPowerControlInfor7& ulDPCHPowerControlInfo) { *static_cast<ULDPCHPowerControlInfor7*>(items[0]) = ulDPCHPowerControlInfo; }
	void setULDPCHInfor7ModeSpecificInfo(const ULDPCHInfor7ModeSpecificInfo& uLDPCHInfor7ModeSpecificInfo) { *static_cast<ULDPCHInfor7ModeSpecificInfo*>(items[1]) = uLDPCHInfor7ModeSpecificInfo; }
};

class ULDPCHPowerControlInfoPostFDD : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfoPostFDD(): Sequence(&theInfo) {}

	void setDpcchPowerOffset(const DPCCHPowerOffset2& dpcchPowerOffset) { *static_cast<DPCCHPowerOffset2*>(items[0]) = dpcchPowerOffset; }
	void setPcPreamble(const PCPreamble& pcPreamble) { *static_cast<PCPreamble*>(items[1]) = pcPreamble; }
	void setSRBdelay(const SRBdelay& sRBdelay) { *static_cast<SRBdelay*>(items[2]) = sRBdelay; }
};

class ULDPCHInfoPostFDD : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	ULDPCHInfoPostFDD(): Sequence(&theInfo) {}

	void setUlDPCHPowerControlInfo(const ULDPCHPowerControlInfoPostFDD& ulDPCHPowerControlInfo) { *static_cast<ULDPCHPowerControlInfoPostFDD*>(items[0]) = ulDPCHPowerControlInfo; }
	void setScramblingCodeType(const ScramblingCodeType& scramblingCodeType) { *static_cast<ScramblingCodeType*>(items[1]) = scramblingCodeType; }
	void setReducedScramblingCodeNumber(const ReducedScramblingCodeNumber& reducedScramblingCodeNumber) { *static_cast<ReducedScramblingCodeNumber*>(items[2]) = reducedScramblingCodeNumber; }
	void setSpreadingFactor(const SpreadingFactor& spreadingFactor) { *static_cast<SpreadingFactor*>(items[3]) = spreadingFactor; }
};

class ULDPCHPowerControlInfoPostTDD : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfoPostTDD(): Sequence(&theInfo) {}

	void setUlTargetSIR(const ULTargetSIR& ulTargetSIR) { *static_cast<ULTargetSIR*>(items[0]) = ulTargetSIR; }
	void setUlTimeslotInterference(const TDDULInterference& ulTimeslotInterference) { *static_cast<TDDULInterference*>(items[1]) = ulTimeslotInterference; }
};

class ULDPCHInfoPostTDD : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULDPCHInfoPostTDD(): Sequence(&theInfo) {}

	void setUlDPCHPowerControlInfo(const ULDPCHPowerControlInfoPostTDD& ulDPCHPowerControlInfo) { *static_cast<ULDPCHPowerControlInfoPostTDD*>(items[0]) = ulDPCHPowerControlInfo; }
	void setUlTimingAdvance(const ULTimingAdvanceControl& ulTimingAdvance) { *static_cast<ULTimingAdvanceControl*>(items[1]) = ulTimingAdvance; }
	void setUlCCTrCHTimeslotsCodes(const UplinkTimeslotsCodes& ulCCTrCHTimeslotsCodes) { *static_cast<UplinkTimeslotsCodes*>(items[2]) = ulCCTrCHTimeslotsCodes; }
};

class ULDPCHPowerControlInfoPostTDDLCRr4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULDPCHPowerControlInfoPostTDDLCRr4(): Sequence(&theInfo) {}

	void setUlTargetSIR(const ULTargetSIR& ulTargetSIR) { *static_cast<ULTargetSIR*>(items[0]) = ulTargetSIR; }
};

typedef Null ULTimingAdvanceControlLCRr4Disabled;

class ULTimingAdvanceControlLCRr4Enabled : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULTimingAdvanceControlLCRr4Enabled(): Sequence(&theInfo) {}

	void setUlSynchronisationParameters(const ULSynchronisationParametersr4& ulSynchronisationParameters) { *static_cast<ULSynchronisationParametersr4*>(items[0]) = ulSynchronisationParameters; }
	void setSynchronisationParameters(const SynchronisationParametersr4& synchronisationParameters) { *static_cast<SynchronisationParametersr4*>(items[1]) = synchronisationParameters; }
};

class ULTimingAdvanceControlLCRr4 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULTimingAdvanceControlLCRr4Choices {
		uLTimingAdvanceControlLCRr4Disabled = 0,
		uLTimingAdvanceControlLCRr4Enabled = 1,
	};
	static const Info theInfo;
	ULTimingAdvanceControlLCRr4(): Choice(&theInfo) {}
};

class ULDPCHInfoPostTDDLCRr4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULDPCHInfoPostTDDLCRr4(): Sequence(&theInfo) {}

	void setUlDPCHPowerControlInfo(const ULDPCHPowerControlInfoPostTDDLCRr4& ulDPCHPowerControlInfo) { *static_cast<ULDPCHPowerControlInfoPostTDDLCRr4*>(items[0]) = ulDPCHPowerControlInfo; }
	void setUlTimingAdvance(const ULTimingAdvanceControlLCRr4& ulTimingAdvance) { *static_cast<ULTimingAdvanceControlLCRr4*>(items[1]) = ulTimingAdvance; }
	void setUlCCTrCHTimeslotsCodes(const UplinkTimeslotsCodesLCRr4& ulCCTrCHTimeslotsCodes) { *static_cast<UplinkTimeslotsCodesLCRr4*>(items[2]) = ulCCTrCHTimeslotsCodes; }
};

typedef Null ULEDCHInformationextFdd;

class ULEDCHInformationextTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ULEDCHInformationextTdd(): Sequence(&theInfo) {}

	void setNonScheduledTransGrantInfo(const NonScheduledTransGrantInfoTDDext& nonScheduledTransGrantInfo) { *static_cast<NonScheduledTransGrantInfoTDDext*>(items[0]) = nonScheduledTransGrantInfo; }
};

class ULEDCHInformationext : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULEDCHInformationextChoices {
		uLEDCHInformationextFdd = 0,
		uLEDCHInformationextTdd = 1,
	};
	static const Info theInfo;
	ULEDCHInformationext(): Choice(&theInfo) {}
};

enum ULEDCHInformationr6mac_es_e_resetIndicatorValues {
	true_ULEDCHInformationr6mac_es_e_resetIndicator = 0,
};
typedef Enumerated<CONSTRAINED, 0> ULEDCHInformationr6mac_es_e_resetIndicator;

class ULEDCHInformationr6 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	ULEDCHInformationr6(): Sequence(&theInfo) {}

	void setULEDCHInformationr6mac_es_e_resetIndicator(const ULEDCHInformationr6mac_es_e_resetIndicator& uLEDCHInformationr6mac_es_e_resetIndicator) { *static_cast<ULEDCHInformationr6mac_es_e_resetIndicator*>(items[0]) = uLEDCHInformationr6mac_es_e_resetIndicator; }
	void setEDPCCHInfo(const EDPCCHInfo& eDPCCHInfo) { *static_cast<EDPCCHInfo*>(items[1]) = eDPCCHInfo; }
	void setEDPDCHInfo(const EDPDCHInfo& eDPDCHInfo) { *static_cast<EDPDCHInfo*>(items[2]) = eDPDCHInfo; }
	void setSchedulingTransmConfiguration(const EDPDCHSchedulingTransmConfiguration& schedulingTransmConfiguration) { *static_cast<EDPDCHSchedulingTransmConfiguration*>(items[3]) = schedulingTransmConfiguration; }
};

enum ULEDCHInformationr7mac_es_e_resetIndicatorValues {
	true_ULEDCHInformationr7mac_es_e_resetIndicator = 0,
};
typedef Enumerated<CONSTRAINED, 0> ULEDCHInformationr7mac_es_e_resetIndicator;

class ULEDCHInformationr7ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	ULEDCHInformationr7ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setEDPCCHInfo(const EDPCCHInfor7& eDPCCHInfo) { *static_cast<EDPCCHInfor7*>(items[0]) = eDPCCHInfo; }
	void setEDPDCHInfo(const EDPDCHInfor7& eDPDCHInfo) { *static_cast<EDPDCHInfor7*>(items[1]) = eDPDCHInfo; }
	void setSchedulingTransmConfiguration(const EDPDCHSchedulingTransmConfiguration& schedulingTransmConfiguration) { *static_cast<EDPDCHSchedulingTransmConfiguration*>(items[2]) = schedulingTransmConfiguration; }
	void setUl16QAMSettings(const UL16QAMSettings& ul16QAMSettings) { *static_cast<UL16QAMSettings*>(items[3]) = ul16QAMSettings; }
};

class ULEDCHInformationr7ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ULEDCHInformationr7ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setERUCCHInfo(const ERUCCHInfo& eRUCCHInfo) { *static_cast<ERUCCHInfo*>(items[0]) = eRUCCHInfo; }
	void setEPUCHInfo(const EPUCHInfo& ePUCHInfo) { *static_cast<EPUCHInfo*>(items[1]) = ePUCHInfo; }
	void setNonScheduledTransGrantInfo(const NonScheduledTransGrantInfoTDD& nonScheduledTransGrantInfo) { *static_cast<NonScheduledTransGrantInfoTDD*>(items[2]) = nonScheduledTransGrantInfo; }
};

class ULEDCHInformationr7ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ULEDCHInformationr7ModeSpecificInfoChoices {
		uLEDCHInformationr7ModeSpecificInfoFdd = 0,
		uLEDCHInformationr7ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	ULEDCHInformationr7ModeSpecificInfo(): Choice(&theInfo) {}
};

class ULEDCHInformationr7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ULEDCHInformationr7(): Sequence(&theInfo) {}

	void setULEDCHInformationr7mac_es_e_resetIndicator(const ULEDCHInformationr7mac_es_e_resetIndicator& uLEDCHInformationr7mac_es_e_resetIndicator) { *static_cast<ULEDCHInformationr7mac_es_e_resetIndicator*>(items[0]) = uLEDCHInformationr7mac_es_e_resetIndicator; }
	void setULEDCHInformationr7ModeSpecificInfo(const ULEDCHInformationr7ModeSpecificInfo& uLEDCHInformationr7ModeSpecificInfo) { *static_cast<ULEDCHInformationr7ModeSpecificInfo*>(items[1]) = uLEDCHInformationr7ModeSpecificInfo; }
};

typedef Integer<CONSTRAINED, 0, 63> SatID;

typedef Integer<CONSTRAINED, -2048, 2047> AcquisitionSatInfoDoppler0thOrder;

typedef Integer<CONSTRAINED, -42, 21> ExtraDopplerInfoDoppler1stOrder;

enum DopplerUncertaintyValues {
	hz12_5_DopplerUncertainty = 0,
	hz25_DopplerUncertainty = 1,
	hz50_DopplerUncertainty = 2,
	hz100_DopplerUncertainty = 3,
	hz200_DopplerUncertainty = 4,
	spare3_DopplerUncertainty = 5,
	spare2_DopplerUncertainty = 6,
	spare1_DopplerUncertainty = 7,
};
typedef Enumerated<CONSTRAINED, 7> DopplerUncertainty;

class ExtraDopplerInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ExtraDopplerInfo(): Sequence(&theInfo) {}

	void setExtraDopplerInfoDoppler1stOrder(const ExtraDopplerInfoDoppler1stOrder& extraDopplerInfoDoppler1stOrder) { *static_cast<ExtraDopplerInfoDoppler1stOrder*>(items[0]) = extraDopplerInfoDoppler1stOrder; }
	void setDopplerUncertainty(const DopplerUncertainty& dopplerUncertainty) { *static_cast<DopplerUncertainty*>(items[1]) = dopplerUncertainty; }
};

typedef Integer<CONSTRAINED, 0, 1022> AcquisitionSatInfoCodePhase;

typedef Integer<CONSTRAINED, 0, 19> AcquisitionSatInfoIntegerCodePhase;

typedef Integer<CONSTRAINED, 0, 3> AcquisitionSatInfoGpsBitNumber;

enum CodePhaseSearchWindowValues {
	w1023_CodePhaseSearchWindow = 0,
	w1_CodePhaseSearchWindow = 1,
	w2_CodePhaseSearchWindow = 2,
	w3_CodePhaseSearchWindow = 3,
	w4_CodePhaseSearchWindow = 4,
	w6_CodePhaseSearchWindow = 5,
	w8_CodePhaseSearchWindow = 6,
	w12_CodePhaseSearchWindow = 7,
	w16_CodePhaseSearchWindow = 8,
	w24_CodePhaseSearchWindow = 9,
	w32_CodePhaseSearchWindow = 10,
	w48_CodePhaseSearchWindow = 11,
	w64_CodePhaseSearchWindow = 12,
	w96_CodePhaseSearchWindow = 13,
	w128_CodePhaseSearchWindow = 14,
	w192_CodePhaseSearchWindow = 15,
};
typedef Enumerated<CONSTRAINED, 15> CodePhaseSearchWindow;

typedef Integer<CONSTRAINED, 0, 31> AzimuthAndElevationAzimuth;

typedef Integer<CONSTRAINED, 0, 7> AzimuthAndElevationElevation;

class AzimuthAndElevation : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	AzimuthAndElevation(): Sequence(&theInfo) {}

	void setAzimuthAndElevationAzimuth(const AzimuthAndElevationAzimuth& azimuthAndElevationAzimuth) { *static_cast<AzimuthAndElevationAzimuth*>(items[0]) = azimuthAndElevationAzimuth; }
	void setAzimuthAndElevationElevation(const AzimuthAndElevationElevation& azimuthAndElevationElevation) { *static_cast<AzimuthAndElevationElevation*>(items[1]) = azimuthAndElevationElevation; }
};

class AcquisitionSatInfo : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	AcquisitionSatInfo(): Sequence(&theInfo) {}

	void setSatID(const SatID& satID) { *static_cast<SatID*>(items[0]) = satID; }
	void setAcquisitionSatInfoDoppler0thOrder(const AcquisitionSatInfoDoppler0thOrder& acquisitionSatInfoDoppler0thOrder) { *static_cast<AcquisitionSatInfoDoppler0thOrder*>(items[1]) = acquisitionSatInfoDoppler0thOrder; }
	void setExtraDopplerInfo(const ExtraDopplerInfo& extraDopplerInfo) { *static_cast<ExtraDopplerInfo*>(items[2]) = extraDopplerInfo; }
	void setAcquisitionSatInfoCodePhase(const AcquisitionSatInfoCodePhase& acquisitionSatInfoCodePhase) { *static_cast<AcquisitionSatInfoCodePhase*>(items[3]) = acquisitionSatInfoCodePhase; }
	void setAcquisitionSatInfoIntegerCodePhase(const AcquisitionSatInfoIntegerCodePhase& acquisitionSatInfoIntegerCodePhase) { *static_cast<AcquisitionSatInfoIntegerCodePhase*>(items[4]) = acquisitionSatInfoIntegerCodePhase; }
	void setAcquisitionSatInfoGpsBitNumber(const AcquisitionSatInfoGpsBitNumber& acquisitionSatInfoGpsBitNumber) { *static_cast<AcquisitionSatInfoGpsBitNumber*>(items[5]) = acquisitionSatInfoGpsBitNumber; }
	void setCodePhaseSearchWindow(const CodePhaseSearchWindow& codePhaseSearchWindow) { *static_cast<CodePhaseSearchWindow*>(items[6]) = codePhaseSearchWindow; }
	void setAzimuthAndElevation(const AzimuthAndElevation& azimuthAndElevation) { *static_cast<AzimuthAndElevation*>(items[7]) = azimuthAndElevation; }
};

typedef SequenceOf<AcquisitionSatInfo, CONSTRAINED, 1, maxSat> AcquisitionSatInfoList;

typedef Integer<CONSTRAINED, 1, 16> MeasurementIdentity;

typedef SequenceOf<MeasurementIdentity, CONSTRAINED, 1, maxAdditionalMeas> AdditionalMeasurementIDList;

typedef Integer<CONSTRAINED, 1, 32> MeasurementIdentityr9;

typedef SequenceOf<MeasurementIdentityr9, CONSTRAINED, 1, maxAdditionalMeas> AdditionalMeasurementIDListr9;

typedef Integer<CONSTRAINED, 0, 3> AlmanacSatInfoDataID;

typedef BitString<CONSTRAINED, 16, 16> AlmanacSatInfoE;

typedef BitString<CONSTRAINED, 8, 8> AlmanacSatInfoToa;

typedef BitString<CONSTRAINED, 16, 16> AlmanacSatInfoDeltaI;

typedef BitString<CONSTRAINED, 16, 16> AlmanacSatInfoOmegaDot;

typedef BitString<CONSTRAINED, 8, 8> AlmanacSatInfoSatHealth;

typedef BitString<CONSTRAINED, 24, 24> AlmanacSatInfoASqrt;

typedef BitString<CONSTRAINED, 24, 24> AlmanacSatInfoOmega0;

typedef BitString<CONSTRAINED, 24, 24> AlmanacSatInfoM0;

typedef BitString<CONSTRAINED, 24, 24> AlmanacSatInfoOmega;

typedef BitString<CONSTRAINED, 11, 11> AlmanacSatInfoAf0;

typedef BitString<CONSTRAINED, 11, 11> AlmanacSatInfoAf1;

class AlmanacSatInfo : public Sequence {
private:
	static const void *itemsInfo[13];
	static bool itemsPres[13];
public:
	static const Info theInfo;
	AlmanacSatInfo(): Sequence(&theInfo) {}

	void setAlmanacSatInfoDataID(const AlmanacSatInfoDataID& almanacSatInfoDataID) { *static_cast<AlmanacSatInfoDataID*>(items[0]) = almanacSatInfoDataID; }
	void setSatID(const SatID& satID) { *static_cast<SatID*>(items[1]) = satID; }
	void setAlmanacSatInfoE(const AlmanacSatInfoE& almanacSatInfoE) { *static_cast<AlmanacSatInfoE*>(items[2]) = almanacSatInfoE; }
	void setAlmanacSatInfoToa(const AlmanacSatInfoToa& almanacSatInfoToa) { *static_cast<AlmanacSatInfoToa*>(items[3]) = almanacSatInfoToa; }
	void setAlmanacSatInfoDeltaI(const AlmanacSatInfoDeltaI& almanacSatInfoDeltaI) { *static_cast<AlmanacSatInfoDeltaI*>(items[4]) = almanacSatInfoDeltaI; }
	void setAlmanacSatInfoOmegaDot(const AlmanacSatInfoOmegaDot& almanacSatInfoOmegaDot) { *static_cast<AlmanacSatInfoOmegaDot*>(items[5]) = almanacSatInfoOmegaDot; }
	void setAlmanacSatInfoSatHealth(const AlmanacSatInfoSatHealth& almanacSatInfoSatHealth) { *static_cast<AlmanacSatInfoSatHealth*>(items[6]) = almanacSatInfoSatHealth; }
	void setAlmanacSatInfoASqrt(const AlmanacSatInfoASqrt& almanacSatInfoASqrt) { *static_cast<AlmanacSatInfoASqrt*>(items[7]) = almanacSatInfoASqrt; }
	void setAlmanacSatInfoOmega0(const AlmanacSatInfoOmega0& almanacSatInfoOmega0) { *static_cast<AlmanacSatInfoOmega0*>(items[8]) = almanacSatInfoOmega0; }
	void setAlmanacSatInfoM0(const AlmanacSatInfoM0& almanacSatInfoM0) { *static_cast<AlmanacSatInfoM0*>(items[9]) = almanacSatInfoM0; }
	void setAlmanacSatInfoOmega(const AlmanacSatInfoOmega& almanacSatInfoOmega) { *static_cast<AlmanacSatInfoOmega*>(items[10]) = almanacSatInfoOmega; }
	void setAlmanacSatInfoAf0(const AlmanacSatInfoAf0& almanacSatInfoAf0) { *static_cast<AlmanacSatInfoAf0*>(items[11]) = almanacSatInfoAf0; }
	void setAlmanacSatInfoAf1(const AlmanacSatInfoAf1& almanacSatInfoAf1) { *static_cast<AlmanacSatInfoAf1*>(items[12]) = almanacSatInfoAf1; }
};

typedef SequenceOf<AlmanacSatInfo, CONSTRAINED, 1, maxSat> AlmanacSatInfoList;

typedef BitString<CONSTRAINED, 2, 2> GANSSSATInfoAlmanacSBASecefSbasAlmDataID;

typedef Integer<CONSTRAINED, 0, 63> GANSSSATInfoAlmanacSBASecefSvID;

typedef BitString<CONSTRAINED, 8, 8> GANSSSATInfoAlmanacSBASecefSbasAlmHealth;

typedef BitString<CONSTRAINED, 15, 15> GANSSSATInfoAlmanacSBASecefSbasAlmXg;

typedef BitString<CONSTRAINED, 15, 15> GANSSSATInfoAlmanacSBASecefSbasAlmYg;

typedef BitString<CONSTRAINED, 9, 9> GANSSSATInfoAlmanacSBASecefSbasAlmZg;

typedef BitString<CONSTRAINED, 3, 3> GANSSSATInfoAlmanacSBASecefSbasAlmXgdot;

typedef BitString<CONSTRAINED, 3, 3> GANSSSATInfoAlmanacSBASecefSbasAlmYgDot;

typedef BitString<CONSTRAINED, 4, 4> GANSSSATInfoAlmanacSBASecefSbasAlmZgDot;

typedef BitString<CONSTRAINED, 11, 11> GANSSSATInfoAlmanacSBASecefSbasAlmTo;

class GANSSSATInfoAlmanacSBASecef : public Sequence {
private:
	static const void *itemsInfo[10];
	static bool itemsPres[10];
public:
	static const Info theInfo;
	GANSSSATInfoAlmanacSBASecef(): Sequence(&theInfo) {}

	void setGANSSSATInfoAlmanacSBASecefSbasAlmDataID(const GANSSSATInfoAlmanacSBASecefSbasAlmDataID& gANSSSATInfoAlmanacSBASecefSbasAlmDataID) { *static_cast<GANSSSATInfoAlmanacSBASecefSbasAlmDataID*>(items[0]) = gANSSSATInfoAlmanacSBASecefSbasAlmDataID; }
	void setGANSSSATInfoAlmanacSBASecefSvID(const GANSSSATInfoAlmanacSBASecefSvID& gANSSSATInfoAlmanacSBASecefSvID) { *static_cast<GANSSSATInfoAlmanacSBASecefSvID*>(items[1]) = gANSSSATInfoAlmanacSBASecefSvID; }
	void setGANSSSATInfoAlmanacSBASecefSbasAlmHealth(const GANSSSATInfoAlmanacSBASecefSbasAlmHealth& gANSSSATInfoAlmanacSBASecefSbasAlmHealth) { *static_cast<GANSSSATInfoAlmanacSBASecefSbasAlmHealth*>(items[2]) = gANSSSATInfoAlmanacSBASecefSbasAlmHealth; }
	void setGANSSSATInfoAlmanacSBASecefSbasAlmXg(const GANSSSATInfoAlmanacSBASecefSbasAlmXg& gANSSSATInfoAlmanacSBASecefSbasAlmXg) { *static_cast<GANSSSATInfoAlmanacSBASecefSbasAlmXg*>(items[3]) = gANSSSATInfoAlmanacSBASecefSbasAlmXg; }
	void setGANSSSATInfoAlmanacSBASecefSbasAlmYg(const GANSSSATInfoAlmanacSBASecefSbasAlmYg& gANSSSATInfoAlmanacSBASecefSbasAlmYg) { *static_cast<GANSSSATInfoAlmanacSBASecefSbasAlmYg*>(items[4]) = gANSSSATInfoAlmanacSBASecefSbasAlmYg; }
	void setGANSSSATInfoAlmanacSBASecefSbasAlmZg(const GANSSSATInfoAlmanacSBASecefSbasAlmZg& gANSSSATInfoAlmanacSBASecefSbasAlmZg) { *static_cast<GANSSSATInfoAlmanacSBASecefSbasAlmZg*>(items[5]) = gANSSSATInfoAlmanacSBASecefSbasAlmZg; }
	void setGANSSSATInfoAlmanacSBASecefSbasAlmXgdot(const GANSSSATInfoAlmanacSBASecefSbasAlmXgdot& gANSSSATInfoAlmanacSBASecefSbasAlmXgdot) { *static_cast<GANSSSATInfoAlmanacSBASecefSbasAlmXgdot*>(items[6]) = gANSSSATInfoAlmanacSBASecefSbasAlmXgdot; }
	void setGANSSSATInfoAlmanacSBASecefSbasAlmYgDot(const GANSSSATInfoAlmanacSBASecefSbasAlmYgDot& gANSSSATInfoAlmanacSBASecefSbasAlmYgDot) { *static_cast<GANSSSATInfoAlmanacSBASecefSbasAlmYgDot*>(items[7]) = gANSSSATInfoAlmanacSBASecefSbasAlmYgDot; }
	void setGANSSSATInfoAlmanacSBASecefSbasAlmZgDot(const GANSSSATInfoAlmanacSBASecefSbasAlmZgDot& gANSSSATInfoAlmanacSBASecefSbasAlmZgDot) { *static_cast<GANSSSATInfoAlmanacSBASecefSbasAlmZgDot*>(items[8]) = gANSSSATInfoAlmanacSBASecefSbasAlmZgDot; }
	void setGANSSSATInfoAlmanacSBASecefSbasAlmTo(const GANSSSATInfoAlmanacSBASecefSbasAlmTo& gANSSSATInfoAlmanacSBASecefSbasAlmTo) { *static_cast<GANSSSATInfoAlmanacSBASecefSbasAlmTo*>(items[9]) = gANSSSATInfoAlmanacSBASecefSbasAlmTo; }
};

typedef SequenceOf<GANSSSATInfoAlmanacSBASecef, CONSTRAINED, 1, maxGANSSSat> GANSSSATInfoAlmanacSBASecefList;

class ALMECEFsbasAlmanacSet : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ALMECEFsbasAlmanacSet(): Sequence(&theInfo) {}

	void setSatinfoSBASecefList(const GANSSSATInfoAlmanacSBASecefList& satinfoSBASecefList) { *static_cast<GANSSSATInfoAlmanacSBASecefList*>(items[0]) = satinfoSBASecefList; }
};

typedef BitString<CONSTRAINED, 11, 11> GANSSSATInfoAlmanacGLOkpGloAlmNA;

typedef BitString<CONSTRAINED, 5, 5> GANSSSATInfoAlmanacGLOkpGloAlmnA;

typedef BitString<CONSTRAINED, 5, 5> GANSSSATInfoAlmanacGLOkpGloAlmHA;

typedef BitString<CONSTRAINED, 21, 21> GANSSSATInfoAlmanacGLOkpGloAlmLambdaA;

typedef BitString<CONSTRAINED, 21, 21> GANSSSATInfoAlmanacGLOkpGloAlmTlambdaA;

typedef BitString<CONSTRAINED, 18, 18> GANSSSATInfoAlmanacGLOkpGloAlmDeltaIA;

typedef BitString<CONSTRAINED, 22, 22> GANSSSATInfoAlmanacGLOkpGloAkmDeltaTA;

typedef BitString<CONSTRAINED, 7, 7> GANSSSATInfoAlmanacGLOkpGloAlmDeltaTdotA;

typedef BitString<CONSTRAINED, 15, 15> GANSSSATInfoAlmanacGLOkpGloAlmEpsilonA;

typedef BitString<CONSTRAINED, 16, 16> GANSSSATInfoAlmanacGLOkpGloAlmOmegaA;

typedef BitString<CONSTRAINED, 10, 10> GANSSSATInfoAlmanacGLOkpGloAlmTauA;

typedef BitString<CONSTRAINED, 1, 1> GANSSSATInfoAlmanacGLOkpGloAlmCA;

typedef BitString<CONSTRAINED, 2, 2> GANSSSATInfoAlmanacGLOkpGloAlmMA;

class GANSSSATInfoAlmanacGLOkp : public Sequence {
private:
	static const void *itemsInfo[13];
	static bool itemsPres[13];
public:
	static const Info theInfo;
	GANSSSATInfoAlmanacGLOkp(): Sequence(&theInfo) {}

	void setGANSSSATInfoAlmanacGLOkpGloAlmNA(const GANSSSATInfoAlmanacGLOkpGloAlmNA& gANSSSATInfoAlmanacGLOkpGloAlmNA) { *static_cast<GANSSSATInfoAlmanacGLOkpGloAlmNA*>(items[0]) = gANSSSATInfoAlmanacGLOkpGloAlmNA; }
	void setGANSSSATInfoAlmanacGLOkpGloAlmnA(const GANSSSATInfoAlmanacGLOkpGloAlmnA& gANSSSATInfoAlmanacGLOkpGloAlmnA) { *static_cast<GANSSSATInfoAlmanacGLOkpGloAlmnA*>(items[1]) = gANSSSATInfoAlmanacGLOkpGloAlmnA; }
	void setGANSSSATInfoAlmanacGLOkpGloAlmHA(const GANSSSATInfoAlmanacGLOkpGloAlmHA& gANSSSATInfoAlmanacGLOkpGloAlmHA) { *static_cast<GANSSSATInfoAlmanacGLOkpGloAlmHA*>(items[2]) = gANSSSATInfoAlmanacGLOkpGloAlmHA; }
	void setGANSSSATInfoAlmanacGLOkpGloAlmLambdaA(const GANSSSATInfoAlmanacGLOkpGloAlmLambdaA& gANSSSATInfoAlmanacGLOkpGloAlmLambdaA) { *static_cast<GANSSSATInfoAlmanacGLOkpGloAlmLambdaA*>(items[3]) = gANSSSATInfoAlmanacGLOkpGloAlmLambdaA; }
	void setGANSSSATInfoAlmanacGLOkpGloAlmTlambdaA(const GANSSSATInfoAlmanacGLOkpGloAlmTlambdaA& gANSSSATInfoAlmanacGLOkpGloAlmTlambdaA) { *static_cast<GANSSSATInfoAlmanacGLOkpGloAlmTlambdaA*>(items[4]) = gANSSSATInfoAlmanacGLOkpGloAlmTlambdaA; }
	void setGANSSSATInfoAlmanacGLOkpGloAlmDeltaIA(const GANSSSATInfoAlmanacGLOkpGloAlmDeltaIA& gANSSSATInfoAlmanacGLOkpGloAlmDeltaIA) { *static_cast<GANSSSATInfoAlmanacGLOkpGloAlmDeltaIA*>(items[5]) = gANSSSATInfoAlmanacGLOkpGloAlmDeltaIA; }
	void setGANSSSATInfoAlmanacGLOkpGloAkmDeltaTA(const GANSSSATInfoAlmanacGLOkpGloAkmDeltaTA& gANSSSATInfoAlmanacGLOkpGloAkmDeltaTA) { *static_cast<GANSSSATInfoAlmanacGLOkpGloAkmDeltaTA*>(items[6]) = gANSSSATInfoAlmanacGLOkpGloAkmDeltaTA; }
	void setGANSSSATInfoAlmanacGLOkpGloAlmDeltaTdotA(const GANSSSATInfoAlmanacGLOkpGloAlmDeltaTdotA& gANSSSATInfoAlmanacGLOkpGloAlmDeltaTdotA) { *static_cast<GANSSSATInfoAlmanacGLOkpGloAlmDeltaTdotA*>(items[7]) = gANSSSATInfoAlmanacGLOkpGloAlmDeltaTdotA; }
	void setGANSSSATInfoAlmanacGLOkpGloAlmEpsilonA(const GANSSSATInfoAlmanacGLOkpGloAlmEpsilonA& gANSSSATInfoAlmanacGLOkpGloAlmEpsilonA) { *static_cast<GANSSSATInfoAlmanacGLOkpGloAlmEpsilonA*>(items[8]) = gANSSSATInfoAlmanacGLOkpGloAlmEpsilonA; }
	void setGANSSSATInfoAlmanacGLOkpGloAlmOmegaA(const GANSSSATInfoAlmanacGLOkpGloAlmOmegaA& gANSSSATInfoAlmanacGLOkpGloAlmOmegaA) { *static_cast<GANSSSATInfoAlmanacGLOkpGloAlmOmegaA*>(items[9]) = gANSSSATInfoAlmanacGLOkpGloAlmOmegaA; }
	void setGANSSSATInfoAlmanacGLOkpGloAlmTauA(const GANSSSATInfoAlmanacGLOkpGloAlmTauA& gANSSSATInfoAlmanacGLOkpGloAlmTauA) { *static_cast<GANSSSATInfoAlmanacGLOkpGloAlmTauA*>(items[10]) = gANSSSATInfoAlmanacGLOkpGloAlmTauA; }
	void setGANSSSATInfoAlmanacGLOkpGloAlmCA(const GANSSSATInfoAlmanacGLOkpGloAlmCA& gANSSSATInfoAlmanacGLOkpGloAlmCA) { *static_cast<GANSSSATInfoAlmanacGLOkpGloAlmCA*>(items[11]) = gANSSSATInfoAlmanacGLOkpGloAlmCA; }
	void setGANSSSATInfoAlmanacGLOkpGloAlmMA(const GANSSSATInfoAlmanacGLOkpGloAlmMA& gANSSSATInfoAlmanacGLOkpGloAlmMA) { *static_cast<GANSSSATInfoAlmanacGLOkpGloAlmMA*>(items[12]) = gANSSSATInfoAlmanacGLOkpGloAlmMA; }
};

typedef SequenceOf<GANSSSATInfoAlmanacGLOkp, CONSTRAINED, 1, maxGANSSSat> GANSSSATInfoAlmanacGLOkpList;

class ALMGlonassAlmanacSet : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ALMGlonassAlmanacSet(): Sequence(&theInfo) {}

	void setSatinfoGLOkpList(const GANSSSATInfoAlmanacGLOkpList& satinfoGLOkpList) { *static_cast<GANSSSATInfoAlmanacGLOkpList*>(items[0]) = satinfoGLOkpList; }
};

typedef Integer<CONSTRAINED, 0, 147> ALMkeplerianParametersToa;

typedef Integer<CONSTRAINED, 0, 3> ALMkeplerianParametersIoda;

typedef Integer<CONSTRAINED, 0, 63> GANSSSATInfoAlmanacKpSvId;

typedef BitString<CONSTRAINED, 11, 11> GANSSSATInfoAlmanacKpGanssalme;

typedef BitString<CONSTRAINED, 11, 11> GANSSSATInfoAlmanacKpGanssdeltaIalm;

typedef BitString<CONSTRAINED, 11, 11> GANSSSATInfoAlmanacKpGanssomegadotalm;

typedef BitString<CONSTRAINED, 4, 4> GANSSSATInfoAlmanacKpGansssvhealthalm;

typedef BitString<CONSTRAINED, 17, 17> GANSSSATInfoAlmanacKpGanssdeltaasqrtalm;

typedef BitString<CONSTRAINED, 16, 16> GANSSSATInfoAlmanacKpGanssomegazeroalm;

typedef BitString<CONSTRAINED, 16, 16> GANSSSATInfoAlmanacKpGanssmzeroalm;

typedef BitString<CONSTRAINED, 16, 16> GANSSSATInfoAlmanacKpGanssomegaalm;

typedef BitString<CONSTRAINED, 14, 14> GANSSSATInfoAlmanacKpGanssafzeroalm;

typedef BitString<CONSTRAINED, 11, 11> GANSSSATInfoAlmanacKpGanssafonealm;

class GANSSSATInfoAlmanacKp : public Sequence {
private:
	static const void *itemsInfo[11];
	static bool itemsPres[11];
public:
	static const Info theInfo;
	GANSSSATInfoAlmanacKp(): Sequence(&theInfo) {}

	void setGANSSSATInfoAlmanacKpSvId(const GANSSSATInfoAlmanacKpSvId& gANSSSATInfoAlmanacKpSvId) { *static_cast<GANSSSATInfoAlmanacKpSvId*>(items[0]) = gANSSSATInfoAlmanacKpSvId; }
	void setGANSSSATInfoAlmanacKpGanssalme(const GANSSSATInfoAlmanacKpGanssalme& gANSSSATInfoAlmanacKpGanssalme) { *static_cast<GANSSSATInfoAlmanacKpGanssalme*>(items[1]) = gANSSSATInfoAlmanacKpGanssalme; }
	void setGANSSSATInfoAlmanacKpGanssdeltaIalm(const GANSSSATInfoAlmanacKpGanssdeltaIalm& gANSSSATInfoAlmanacKpGanssdeltaIalm) { *static_cast<GANSSSATInfoAlmanacKpGanssdeltaIalm*>(items[2]) = gANSSSATInfoAlmanacKpGanssdeltaIalm; }
	void setGANSSSATInfoAlmanacKpGanssomegadotalm(const GANSSSATInfoAlmanacKpGanssomegadotalm& gANSSSATInfoAlmanacKpGanssomegadotalm) { *static_cast<GANSSSATInfoAlmanacKpGanssomegadotalm*>(items[3]) = gANSSSATInfoAlmanacKpGanssomegadotalm; }
	void setGANSSSATInfoAlmanacKpGansssvhealthalm(const GANSSSATInfoAlmanacKpGansssvhealthalm& gANSSSATInfoAlmanacKpGansssvhealthalm) { *static_cast<GANSSSATInfoAlmanacKpGansssvhealthalm*>(items[4]) = gANSSSATInfoAlmanacKpGansssvhealthalm; }
	void setGANSSSATInfoAlmanacKpGanssdeltaasqrtalm(const GANSSSATInfoAlmanacKpGanssdeltaasqrtalm& gANSSSATInfoAlmanacKpGanssdeltaasqrtalm) { *static_cast<GANSSSATInfoAlmanacKpGanssdeltaasqrtalm*>(items[5]) = gANSSSATInfoAlmanacKpGanssdeltaasqrtalm; }
	void setGANSSSATInfoAlmanacKpGanssomegazeroalm(const GANSSSATInfoAlmanacKpGanssomegazeroalm& gANSSSATInfoAlmanacKpGanssomegazeroalm) { *static_cast<GANSSSATInfoAlmanacKpGanssomegazeroalm*>(items[6]) = gANSSSATInfoAlmanacKpGanssomegazeroalm; }
	void setGANSSSATInfoAlmanacKpGanssmzeroalm(const GANSSSATInfoAlmanacKpGanssmzeroalm& gANSSSATInfoAlmanacKpGanssmzeroalm) { *static_cast<GANSSSATInfoAlmanacKpGanssmzeroalm*>(items[7]) = gANSSSATInfoAlmanacKpGanssmzeroalm; }
	void setGANSSSATInfoAlmanacKpGanssomegaalm(const GANSSSATInfoAlmanacKpGanssomegaalm& gANSSSATInfoAlmanacKpGanssomegaalm) { *static_cast<GANSSSATInfoAlmanacKpGanssomegaalm*>(items[8]) = gANSSSATInfoAlmanacKpGanssomegaalm; }
	void setGANSSSATInfoAlmanacKpGanssafzeroalm(const GANSSSATInfoAlmanacKpGanssafzeroalm& gANSSSATInfoAlmanacKpGanssafzeroalm) { *static_cast<GANSSSATInfoAlmanacKpGanssafzeroalm*>(items[9]) = gANSSSATInfoAlmanacKpGanssafzeroalm; }
	void setGANSSSATInfoAlmanacKpGanssafonealm(const GANSSSATInfoAlmanacKpGanssafonealm& gANSSSATInfoAlmanacKpGanssafonealm) { *static_cast<GANSSSATInfoAlmanacKpGanssafonealm*>(items[10]) = gANSSSATInfoAlmanacKpGanssafonealm; }
};

typedef SequenceOf<GANSSSATInfoAlmanacKp, CONSTRAINED, 1, maxGANSSSat> GANSSSATInfoAlmanacKpList;

class ALMkeplerianParameters : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ALMkeplerianParameters(): Sequence(&theInfo) {}

	void setALMkeplerianParametersToa(const ALMkeplerianParametersToa& aLMkeplerianParametersToa) { *static_cast<ALMkeplerianParametersToa*>(items[0]) = aLMkeplerianParametersToa; }
	void setALMkeplerianParametersIoda(const ALMkeplerianParametersIoda& aLMkeplerianParametersIoda) { *static_cast<ALMkeplerianParametersIoda*>(items[1]) = aLMkeplerianParametersIoda; }
	void setSatinfokpList(const GANSSSATInfoAlmanacKpList& satinfokpList) { *static_cast<GANSSSATInfoAlmanacKpList*>(items[2]) = satinfokpList; }
};

typedef Integer<CONSTRAINED, 0, 147> ALMMidiAlmanacSetToa;

typedef Integer<CONSTRAINED, 0, 63> GANSSSATInfoAlmanacMIDIkpSvID;

typedef BitString<CONSTRAINED, 11, 11> GANSSSATInfoAlmanacMIDIkpMidiAlmE;

typedef BitString<CONSTRAINED, 11, 11> GANSSSATInfoAlmanacMIDIkpMidiAlmDeltaI;

typedef BitString<CONSTRAINED, 11, 11> GANSSSATInfoAlmanacMIDIkpMidiAlmOmegaDot;

typedef BitString<CONSTRAINED, 17, 17> GANSSSATInfoAlmanacMIDIkpMidiAlmSqrtA;

typedef BitString<CONSTRAINED, 16, 16> GANSSSATInfoAlmanacMIDIkpMidiAlmOmega0;

typedef BitString<CONSTRAINED, 16, 16> GANSSSATInfoAlmanacMIDIkpMidiAlmOmega;

typedef BitString<CONSTRAINED, 16, 16> GANSSSATInfoAlmanacMIDIkpMidiAlmMo;

typedef BitString<CONSTRAINED, 11, 11> GANSSSATInfoAlmanacMIDIkpMidiAlmaf0;

typedef BitString<CONSTRAINED, 10, 10> GANSSSATInfoAlmanacMIDIkpMidiAlmaf1;

typedef BitString<CONSTRAINED, 1, 1> GANSSSATInfoAlmanacMIDIkpMidiAlmL1Health;

typedef BitString<CONSTRAINED, 1, 1> GANSSSATInfoAlmanacMIDIkpMidiAlmL2Health;

typedef BitString<CONSTRAINED, 1, 1> GANSSSATInfoAlmanacMIDIkpMidiAlmL5Health;

class GANSSSATInfoAlmanacMIDIkp : public Sequence {
private:
	static const void *itemsInfo[13];
	static bool itemsPres[13];
public:
	static const Info theInfo;
	GANSSSATInfoAlmanacMIDIkp(): Sequence(&theInfo) {}

	void setGANSSSATInfoAlmanacMIDIkpSvID(const GANSSSATInfoAlmanacMIDIkpSvID& gANSSSATInfoAlmanacMIDIkpSvID) { *static_cast<GANSSSATInfoAlmanacMIDIkpSvID*>(items[0]) = gANSSSATInfoAlmanacMIDIkpSvID; }
	void setGANSSSATInfoAlmanacMIDIkpMidiAlmE(const GANSSSATInfoAlmanacMIDIkpMidiAlmE& gANSSSATInfoAlmanacMIDIkpMidiAlmE) { *static_cast<GANSSSATInfoAlmanacMIDIkpMidiAlmE*>(items[1]) = gANSSSATInfoAlmanacMIDIkpMidiAlmE; }
	void setGANSSSATInfoAlmanacMIDIkpMidiAlmDeltaI(const GANSSSATInfoAlmanacMIDIkpMidiAlmDeltaI& gANSSSATInfoAlmanacMIDIkpMidiAlmDeltaI) { *static_cast<GANSSSATInfoAlmanacMIDIkpMidiAlmDeltaI*>(items[2]) = gANSSSATInfoAlmanacMIDIkpMidiAlmDeltaI; }
	void setGANSSSATInfoAlmanacMIDIkpMidiAlmOmegaDot(const GANSSSATInfoAlmanacMIDIkpMidiAlmOmegaDot& gANSSSATInfoAlmanacMIDIkpMidiAlmOmegaDot) { *static_cast<GANSSSATInfoAlmanacMIDIkpMidiAlmOmegaDot*>(items[3]) = gANSSSATInfoAlmanacMIDIkpMidiAlmOmegaDot; }
	void setGANSSSATInfoAlmanacMIDIkpMidiAlmSqrtA(const GANSSSATInfoAlmanacMIDIkpMidiAlmSqrtA& gANSSSATInfoAlmanacMIDIkpMidiAlmSqrtA) { *static_cast<GANSSSATInfoAlmanacMIDIkpMidiAlmSqrtA*>(items[4]) = gANSSSATInfoAlmanacMIDIkpMidiAlmSqrtA; }
	void setGANSSSATInfoAlmanacMIDIkpMidiAlmOmega0(const GANSSSATInfoAlmanacMIDIkpMidiAlmOmega0& gANSSSATInfoAlmanacMIDIkpMidiAlmOmega0) { *static_cast<GANSSSATInfoAlmanacMIDIkpMidiAlmOmega0*>(items[5]) = gANSSSATInfoAlmanacMIDIkpMidiAlmOmega0; }
	void setGANSSSATInfoAlmanacMIDIkpMidiAlmOmega(const GANSSSATInfoAlmanacMIDIkpMidiAlmOmega& gANSSSATInfoAlmanacMIDIkpMidiAlmOmega) { *static_cast<GANSSSATInfoAlmanacMIDIkpMidiAlmOmega*>(items[6]) = gANSSSATInfoAlmanacMIDIkpMidiAlmOmega; }
	void setGANSSSATInfoAlmanacMIDIkpMidiAlmMo(const GANSSSATInfoAlmanacMIDIkpMidiAlmMo& gANSSSATInfoAlmanacMIDIkpMidiAlmMo) { *static_cast<GANSSSATInfoAlmanacMIDIkpMidiAlmMo*>(items[7]) = gANSSSATInfoAlmanacMIDIkpMidiAlmMo; }
	void setGANSSSATInfoAlmanacMIDIkpMidiAlmaf0(const GANSSSATInfoAlmanacMIDIkpMidiAlmaf0& gANSSSATInfoAlmanacMIDIkpMidiAlmaf0) { *static_cast<GANSSSATInfoAlmanacMIDIkpMidiAlmaf0*>(items[8]) = gANSSSATInfoAlmanacMIDIkpMidiAlmaf0; }
	void setGANSSSATInfoAlmanacMIDIkpMidiAlmaf1(const GANSSSATInfoAlmanacMIDIkpMidiAlmaf1& gANSSSATInfoAlmanacMIDIkpMidiAlmaf1) { *static_cast<GANSSSATInfoAlmanacMIDIkpMidiAlmaf1*>(items[9]) = gANSSSATInfoAlmanacMIDIkpMidiAlmaf1; }
	void setGANSSSATInfoAlmanacMIDIkpMidiAlmL1Health(const GANSSSATInfoAlmanacMIDIkpMidiAlmL1Health& gANSSSATInfoAlmanacMIDIkpMidiAlmL1Health) { *static_cast<GANSSSATInfoAlmanacMIDIkpMidiAlmL1Health*>(items[10]) = gANSSSATInfoAlmanacMIDIkpMidiAlmL1Health; }
	void setGANSSSATInfoAlmanacMIDIkpMidiAlmL2Health(const GANSSSATInfoAlmanacMIDIkpMidiAlmL2Health& gANSSSATInfoAlmanacMIDIkpMidiAlmL2Health) { *static_cast<GANSSSATInfoAlmanacMIDIkpMidiAlmL2Health*>(items[11]) = gANSSSATInfoAlmanacMIDIkpMidiAlmL2Health; }
	void setGANSSSATInfoAlmanacMIDIkpMidiAlmL5Health(const GANSSSATInfoAlmanacMIDIkpMidiAlmL5Health& gANSSSATInfoAlmanacMIDIkpMidiAlmL5Health) { *static_cast<GANSSSATInfoAlmanacMIDIkpMidiAlmL5Health*>(items[12]) = gANSSSATInfoAlmanacMIDIkpMidiAlmL5Health; }
};

typedef SequenceOf<GANSSSATInfoAlmanacMIDIkp, CONSTRAINED, 1, maxGANSSSat> GANSSSATInfoAlmanacMIDIkpList;

class ALMMidiAlmanacSet : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ALMMidiAlmanacSet(): Sequence(&theInfo) {}

	void setALMMidiAlmanacSetToa(const ALMMidiAlmanacSetToa& aLMMidiAlmanacSetToa) { *static_cast<ALMMidiAlmanacSetToa*>(items[0]) = aLMMidiAlmanacSetToa; }
	void setSatinfoMIDIkpList(const GANSSSATInfoAlmanacMIDIkpList& satinfoMIDIkpList) { *static_cast<GANSSSATInfoAlmanacMIDIkpList*>(items[1]) = satinfoMIDIkpList; }
};

typedef Integer<CONSTRAINED, 0, 147> ALMNAVKeplerianSetToa;

typedef Integer<CONSTRAINED, 0, 63> GANSSSATInfoAlmanacNAVkpSvID;

typedef BitString<CONSTRAINED, 16, 16> GANSSSATInfoAlmanacNAVkpNavAlmE;

typedef BitString<CONSTRAINED, 16, 16> GANSSSATInfoAlmanacNAVkpNavAlmDeltaI;

typedef BitString<CONSTRAINED, 16, 16> GANSSSATInfoAlmanacNAVkpNavAlmOMEGADOT;

typedef BitString<CONSTRAINED, 8, 8> GANSSSATInfoAlmanacNAVkpNavAlmSVHealth;

typedef BitString<CONSTRAINED, 24, 24> GANSSSATInfoAlmanacNAVkpNavAlmSqrtA;

typedef BitString<CONSTRAINED, 24, 24> GANSSSATInfoAlmanacNAVkpNavAlmOMEGAo;

typedef BitString<CONSTRAINED, 24, 24> GANSSSATInfoAlmanacNAVkpNavAlmOmega;

typedef BitString<CONSTRAINED, 24, 24> GANSSSATInfoAlmanacNAVkpNavAlmMo;

typedef BitString<CONSTRAINED, 11, 11> GANSSSATInfoAlmanacNAVkpNavAlmaf0;

typedef BitString<CONSTRAINED, 11, 11> GANSSSATInfoAlmanacNAVkpNavAlmaf1;

class GANSSSATInfoAlmanacNAVkp : public Sequence {
private:
	static const void *itemsInfo[11];
	static bool itemsPres[11];
public:
	static const Info theInfo;
	GANSSSATInfoAlmanacNAVkp(): Sequence(&theInfo) {}

	void setGANSSSATInfoAlmanacNAVkpSvID(const GANSSSATInfoAlmanacNAVkpSvID& gANSSSATInfoAlmanacNAVkpSvID) { *static_cast<GANSSSATInfoAlmanacNAVkpSvID*>(items[0]) = gANSSSATInfoAlmanacNAVkpSvID; }
	void setGANSSSATInfoAlmanacNAVkpNavAlmE(const GANSSSATInfoAlmanacNAVkpNavAlmE& gANSSSATInfoAlmanacNAVkpNavAlmE) { *static_cast<GANSSSATInfoAlmanacNAVkpNavAlmE*>(items[1]) = gANSSSATInfoAlmanacNAVkpNavAlmE; }
	void setGANSSSATInfoAlmanacNAVkpNavAlmDeltaI(const GANSSSATInfoAlmanacNAVkpNavAlmDeltaI& gANSSSATInfoAlmanacNAVkpNavAlmDeltaI) { *static_cast<GANSSSATInfoAlmanacNAVkpNavAlmDeltaI*>(items[2]) = gANSSSATInfoAlmanacNAVkpNavAlmDeltaI; }
	void setGANSSSATInfoAlmanacNAVkpNavAlmOMEGADOT(const GANSSSATInfoAlmanacNAVkpNavAlmOMEGADOT& gANSSSATInfoAlmanacNAVkpNavAlmOMEGADOT) { *static_cast<GANSSSATInfoAlmanacNAVkpNavAlmOMEGADOT*>(items[3]) = gANSSSATInfoAlmanacNAVkpNavAlmOMEGADOT; }
	void setGANSSSATInfoAlmanacNAVkpNavAlmSVHealth(const GANSSSATInfoAlmanacNAVkpNavAlmSVHealth& gANSSSATInfoAlmanacNAVkpNavAlmSVHealth) { *static_cast<GANSSSATInfoAlmanacNAVkpNavAlmSVHealth*>(items[4]) = gANSSSATInfoAlmanacNAVkpNavAlmSVHealth; }
	void setGANSSSATInfoAlmanacNAVkpNavAlmSqrtA(const GANSSSATInfoAlmanacNAVkpNavAlmSqrtA& gANSSSATInfoAlmanacNAVkpNavAlmSqrtA) { *static_cast<GANSSSATInfoAlmanacNAVkpNavAlmSqrtA*>(items[5]) = gANSSSATInfoAlmanacNAVkpNavAlmSqrtA; }
	void setGANSSSATInfoAlmanacNAVkpNavAlmOMEGAo(const GANSSSATInfoAlmanacNAVkpNavAlmOMEGAo& gANSSSATInfoAlmanacNAVkpNavAlmOMEGAo) { *static_cast<GANSSSATInfoAlmanacNAVkpNavAlmOMEGAo*>(items[6]) = gANSSSATInfoAlmanacNAVkpNavAlmOMEGAo; }
	void setGANSSSATInfoAlmanacNAVkpNavAlmOmega(const GANSSSATInfoAlmanacNAVkpNavAlmOmega& gANSSSATInfoAlmanacNAVkpNavAlmOmega) { *static_cast<GANSSSATInfoAlmanacNAVkpNavAlmOmega*>(items[7]) = gANSSSATInfoAlmanacNAVkpNavAlmOmega; }
	void setGANSSSATInfoAlmanacNAVkpNavAlmMo(const GANSSSATInfoAlmanacNAVkpNavAlmMo& gANSSSATInfoAlmanacNAVkpNavAlmMo) { *static_cast<GANSSSATInfoAlmanacNAVkpNavAlmMo*>(items[8]) = gANSSSATInfoAlmanacNAVkpNavAlmMo; }
	void setGANSSSATInfoAlmanacNAVkpNavAlmaf0(const GANSSSATInfoAlmanacNAVkpNavAlmaf0& gANSSSATInfoAlmanacNAVkpNavAlmaf0) { *static_cast<GANSSSATInfoAlmanacNAVkpNavAlmaf0*>(items[9]) = gANSSSATInfoAlmanacNAVkpNavAlmaf0; }
	void setGANSSSATInfoAlmanacNAVkpNavAlmaf1(const GANSSSATInfoAlmanacNAVkpNavAlmaf1& gANSSSATInfoAlmanacNAVkpNavAlmaf1) { *static_cast<GANSSSATInfoAlmanacNAVkpNavAlmaf1*>(items[10]) = gANSSSATInfoAlmanacNAVkpNavAlmaf1; }
};

typedef SequenceOf<GANSSSATInfoAlmanacNAVkp, CONSTRAINED, 1, maxGANSSSat> GANSSSATInfoAlmanacNAVkpList;

class ALMNAVKeplerianSet : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ALMNAVKeplerianSet(): Sequence(&theInfo) {}

	void setALMNAVKeplerianSetToa(const ALMNAVKeplerianSetToa& aLMNAVKeplerianSetToa) { *static_cast<ALMNAVKeplerianSetToa*>(items[0]) = aLMNAVKeplerianSetToa; }
	void setSatinfoNAVkpList(const GANSSSATInfoAlmanacNAVkpList& satinfoNAVkpList) { *static_cast<GANSSSATInfoAlmanacNAVkpList*>(items[1]) = satinfoNAVkpList; }
};

typedef Integer<CONSTRAINED, 0, 147> ALMReducedKeplerianSetToa;

typedef Integer<CONSTRAINED, 0, 63> GANSSSATInfoAlmanacREDkpSvID;

typedef BitString<CONSTRAINED, 8, 8> GANSSSATInfoAlmanacREDkpRedAlmDeltaA;

typedef BitString<CONSTRAINED, 7, 7> GANSSSATInfoAlmanacREDkpRedAlmOmega0;

typedef BitString<CONSTRAINED, 7, 7> GANSSSATInfoAlmanacREDkpRedAlmPhi0;

typedef BitString<CONSTRAINED, 1, 1> GANSSSATInfoAlmanacREDkpRedAlmL1Health;

typedef BitString<CONSTRAINED, 1, 1> GANSSSATInfoAlmanacREDkpRedAlmL2Health;

typedef BitString<CONSTRAINED, 1, 1> GANSSSATInfoAlmanacREDkpRedAlmL5Health;

class GANSSSATInfoAlmanacREDkp : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	GANSSSATInfoAlmanacREDkp(): Sequence(&theInfo) {}

	void setGANSSSATInfoAlmanacREDkpSvID(const GANSSSATInfoAlmanacREDkpSvID& gANSSSATInfoAlmanacREDkpSvID) { *static_cast<GANSSSATInfoAlmanacREDkpSvID*>(items[0]) = gANSSSATInfoAlmanacREDkpSvID; }
	void setGANSSSATInfoAlmanacREDkpRedAlmDeltaA(const GANSSSATInfoAlmanacREDkpRedAlmDeltaA& gANSSSATInfoAlmanacREDkpRedAlmDeltaA) { *static_cast<GANSSSATInfoAlmanacREDkpRedAlmDeltaA*>(items[1]) = gANSSSATInfoAlmanacREDkpRedAlmDeltaA; }
	void setGANSSSATInfoAlmanacREDkpRedAlmOmega0(const GANSSSATInfoAlmanacREDkpRedAlmOmega0& gANSSSATInfoAlmanacREDkpRedAlmOmega0) { *static_cast<GANSSSATInfoAlmanacREDkpRedAlmOmega0*>(items[2]) = gANSSSATInfoAlmanacREDkpRedAlmOmega0; }
	void setGANSSSATInfoAlmanacREDkpRedAlmPhi0(const GANSSSATInfoAlmanacREDkpRedAlmPhi0& gANSSSATInfoAlmanacREDkpRedAlmPhi0) { *static_cast<GANSSSATInfoAlmanacREDkpRedAlmPhi0*>(items[3]) = gANSSSATInfoAlmanacREDkpRedAlmPhi0; }
	void setGANSSSATInfoAlmanacREDkpRedAlmL1Health(const GANSSSATInfoAlmanacREDkpRedAlmL1Health& gANSSSATInfoAlmanacREDkpRedAlmL1Health) { *static_cast<GANSSSATInfoAlmanacREDkpRedAlmL1Health*>(items[4]) = gANSSSATInfoAlmanacREDkpRedAlmL1Health; }
	void setGANSSSATInfoAlmanacREDkpRedAlmL2Health(const GANSSSATInfoAlmanacREDkpRedAlmL2Health& gANSSSATInfoAlmanacREDkpRedAlmL2Health) { *static_cast<GANSSSATInfoAlmanacREDkpRedAlmL2Health*>(items[5]) = gANSSSATInfoAlmanacREDkpRedAlmL2Health; }
	void setGANSSSATInfoAlmanacREDkpRedAlmL5Health(const GANSSSATInfoAlmanacREDkpRedAlmL5Health& gANSSSATInfoAlmanacREDkpRedAlmL5Health) { *static_cast<GANSSSATInfoAlmanacREDkpRedAlmL5Health*>(items[6]) = gANSSSATInfoAlmanacREDkpRedAlmL5Health; }
};

typedef SequenceOf<GANSSSATInfoAlmanacREDkp, CONSTRAINED, 1, maxGANSSSat> GANSSSATInfoAlmanacREDkpList;

class ALMReducedKeplerianSet : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ALMReducedKeplerianSet(): Sequence(&theInfo) {}

	void setALMReducedKeplerianSetToa(const ALMReducedKeplerianSetToa& aLMReducedKeplerianSetToa) { *static_cast<ALMReducedKeplerianSetToa*>(items[0]) = aLMReducedKeplerianSetToa; }
	void setSatinfoREDkpList(const GANSSSATInfoAlmanacREDkpList& satinfoREDkpList) { *static_cast<GANSSSATInfoAlmanacREDkpList*>(items[1]) = satinfoREDkpList; }
};

typedef Integer<CONSTRAINED, 0, 63> AuxInfoGANSSID1elementSvID;

typedef BitString<CONSTRAINED, 8, 8> AuxInfoGANSSID1elementSignalsAvailable;

class AuxInfoGANSSID1element : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	AuxInfoGANSSID1element(): Sequence(&theInfo) {}

	void setAuxInfoGANSSID1elementSvID(const AuxInfoGANSSID1elementSvID& auxInfoGANSSID1elementSvID) { *static_cast<AuxInfoGANSSID1elementSvID*>(items[0]) = auxInfoGANSSID1elementSvID; }
	void setAuxInfoGANSSID1elementSignalsAvailable(const AuxInfoGANSSID1elementSignalsAvailable& auxInfoGANSSID1elementSignalsAvailable) { *static_cast<AuxInfoGANSSID1elementSignalsAvailable*>(items[1]) = auxInfoGANSSID1elementSignalsAvailable; }
};

typedef SequenceOf<AuxInfoGANSSID1element, CONSTRAINED, 1, maxGANSSSat> AuxInfoGANSSID1;

typedef Integer<CONSTRAINED, 0, 63> AuxInfoGANSSID3elementSvID;

typedef BitString<CONSTRAINED, 8, 8> AuxInfoGANSSID3elementSignalsAvailable;

typedef Integer<CONSTRAINED, -7, 13> AuxInfoGANSSID3elementChannelNumber;

class AuxInfoGANSSID3element : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	AuxInfoGANSSID3element(): Sequence(&theInfo) {}

	void setAuxInfoGANSSID3elementSvID(const AuxInfoGANSSID3elementSvID& auxInfoGANSSID3elementSvID) { *static_cast<AuxInfoGANSSID3elementSvID*>(items[0]) = auxInfoGANSSID3elementSvID; }
	void setAuxInfoGANSSID3elementSignalsAvailable(const AuxInfoGANSSID3elementSignalsAvailable& auxInfoGANSSID3elementSignalsAvailable) { *static_cast<AuxInfoGANSSID3elementSignalsAvailable*>(items[1]) = auxInfoGANSSID3elementSignalsAvailable; }
	void setAuxInfoGANSSID3elementChannelNumber(const AuxInfoGANSSID3elementChannelNumber& auxInfoGANSSID3elementChannelNumber) { *static_cast<AuxInfoGANSSID3elementChannelNumber*>(items[2]) = auxInfoGANSSID3elementChannelNumber; }
};

typedef SequenceOf<AuxInfoGANSSID3element, CONSTRAINED, 1,  maxGANSSSat> AuxInfoGANSSID3;

enum AverageRLCBufferPayloadValues {
	pla0_AverageRLCBufferPayload = 0,
	pla4_AverageRLCBufferPayload = 1,
	pla8_AverageRLCBufferPayload = 2,
	pla16_AverageRLCBufferPayload = 3,
	pla32_AverageRLCBufferPayload = 4,
	pla64_AverageRLCBufferPayload = 5,
	pla128_AverageRLCBufferPayload = 6,
	pla256_AverageRLCBufferPayload = 7,
	pla512_AverageRLCBufferPayload = 8,
	pla1024_AverageRLCBufferPayload = 9,
	pla2k_AverageRLCBufferPayload = 10,
	pla4k_AverageRLCBufferPayload = 11,
	pla8k_AverageRLCBufferPayload = 12,
	pla16k_AverageRLCBufferPayload = 13,
	pla32k_AverageRLCBufferPayload = 14,
	pla64k_AverageRLCBufferPayload = 15,
	pla128k_AverageRLCBufferPayload = 16,
	pla256k_AverageRLCBufferPayload = 17,
	pla512k_AverageRLCBufferPayload = 18,
	pla1024k_AverageRLCBufferPayload = 19,
	spare12_AverageRLCBufferPayload = 20,
	spare11_AverageRLCBufferPayload = 21,
	spare10_AverageRLCBufferPayload = 22,
	spare9_AverageRLCBufferPayload = 23,
	spare8_AverageRLCBufferPayload = 24,
	spare7_AverageRLCBufferPayload = 25,
	spare6_AverageRLCBufferPayload = 26,
	spare5_AverageRLCBufferPayload = 27,
	spare4_AverageRLCBufferPayload = 28,
	spare3_AverageRLCBufferPayload = 29,
	spare2_AverageRLCBufferPayload = 30,
	spare1_AverageRLCBufferPayload = 31,
};
typedef Enumerated<CONSTRAINED, 31> AverageRLCBufferPayload;

typedef Integer<CONSTRAINED, 0, 63> BadSatListItem;

typedef SequenceOf<BadSatListItem, CONSTRAINED, 1, maxSat> BadSatList;

typedef Integer<CONSTRAINED, 0, 63> DLTransportChannelBLER;

class BLERMeasurementResults : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	BLERMeasurementResults(): Sequence(&theInfo) {}

	void setTransportChannelIdentity(const TransportChannelIdentity& transportChannelIdentity) { *static_cast<TransportChannelIdentity*>(items[0]) = transportChannelIdentity; }
	void setDlTransportChannelBLER(const DLTransportChannelBLER& dlTransportChannelBLER) { *static_cast<DLTransportChannelBLER*>(items[1]) = dlTransportChannelBLER; }
};

typedef SequenceOf<BLERMeasurementResults, CONSTRAINED, 1, maxTrCH> BLERMeasurementResultsList;

typedef SequenceOf<TransportChannelIdentity, CONSTRAINED, 1, maxTrCH> BLERTransChIdList;

enum BSICVerificationRequiredValues {
	required_BSICVerificationRequired = 0,
	notRequired_BSICVerificationRequired = 1,
};
typedef Enumerated<CONSTRAINED, 1> BSICVerificationRequired;

typedef Integer<CONSTRAINED, 0, maxCellMeas> BSICReportedVerifiedBSIC;

class BSICReported : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum BSICReportedChoices {
		bSICReportedVerifiedBSIC = 0,
		nonVerifiedBSIC = 1,
	};
	static const Info theInfo;
	BSICReported(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 15> BurstModeParametersBurstStart;

typedef Integer<CONSTRAINED, 10, 25> BurstModeParametersBurstLength;

typedef Integer<CONSTRAINED, 1, 16> BurstModeParametersBurstFreq;

class BurstModeParameters : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	BurstModeParameters(): Sequence(&theInfo) {}

	void setBurstModeParametersBurstStart(const BurstModeParametersBurstStart& burstModeParametersBurstStart) { *static_cast<BurstModeParametersBurstStart*>(items[0]) = burstModeParametersBurstStart; }
	void setBurstModeParametersBurstLength(const BurstModeParametersBurstLength& burstModeParametersBurstLength) { *static_cast<BurstModeParametersBurstLength*>(items[1]) = burstModeParametersBurstLength; }
	void setBurstModeParametersBurstFreq(const BurstModeParametersBurstFreq& burstModeParametersBurstFreq) { *static_cast<BurstModeParametersBurstFreq*>(items[2]) = burstModeParametersBurstFreq; }
};

enum TriggeringCondition2Values {
	activeSetCellsOnly_TriggeringCondition2 = 0,
	monitoredSetCellsOnly_TriggeringCondition2 = 1,
	activeSetAndMonitoredSetCells_TriggeringCondition2 = 2,
	detectedSetCellsOnly_TriggeringCondition2 = 3,
	detectedSetAndMonitoredSetCells_TriggeringCondition2 = 4,
};
typedef Enumerated<CONSTRAINED, 4> TriggeringCondition2;

typedef Integer<CONSTRAINED, 0, 29> ReportingRange;

class ForbiddenAffectCell : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ForbiddenAffectCellChoices {
		fdd = 0,
		tdd = 1,
	};
	static const Info theInfo;
	ForbiddenAffectCell(): Choice(&theInfo) {}
};

typedef SequenceOf<ForbiddenAffectCell, CONSTRAINED, 1, maxCellMeas> ForbiddenAffectCellList;

typedef Integer<CONSTRAINED, 0, 20> W;

enum ReportDeactivationThresholdValues {
	notApplicable_ReportDeactivationThreshold = 0,
	t1_ReportDeactivationThreshold = 1,
	t2_ReportDeactivationThreshold = 2,
	t3_ReportDeactivationThreshold = 3,
	t4_ReportDeactivationThreshold = 4,
	t5_ReportDeactivationThreshold = 5,
	t6_ReportDeactivationThreshold = 6,
	t7_ReportDeactivationThreshold = 7,
};
typedef Enumerated<CONSTRAINED, 7> ReportDeactivationThreshold;

enum ReportingAmountValues {
	ra1_ReportingAmount = 0,
	ra2_ReportingAmount = 1,
	ra4_ReportingAmount = 2,
	ra8_ReportingAmount = 3,
	ra16_ReportingAmount = 4,
	ra32_ReportingAmount = 5,
	ra64_ReportingAmount = 6,
	ra_Infinity_ReportingAmount = 7,
};
typedef Enumerated<CONSTRAINED, 7> ReportingAmount;

enum ReportingIntervalValues {
	noPeriodicalreporting_ReportingInterval = 0,
	ri0_25_ReportingInterval = 1,
	ri0_5_ReportingInterval = 2,
	ri1_ReportingInterval = 3,
	ri2_ReportingInterval = 4,
	ri4_ReportingInterval = 5,
	ri8_ReportingInterval = 6,
	ri16_ReportingInterval = 7,
};
typedef Enumerated<CONSTRAINED, 7> ReportingInterval;

class Event1a : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	Event1a(): Sequence(&theInfo) {}

	void setTriggeringCondition(const TriggeringCondition2& triggeringCondition) { *static_cast<TriggeringCondition2*>(items[0]) = triggeringCondition; }
	void setReportingRange(const ReportingRange& reportingRange) { *static_cast<ReportingRange*>(items[1]) = reportingRange; }
	void setForbiddenAffectCellList(const ForbiddenAffectCellList& forbiddenAffectCellList) { *static_cast<ForbiddenAffectCellList*>(items[2]) = forbiddenAffectCellList; }
	void setW(const W& w) { *static_cast<W*>(items[3]) = w; }
	void setReportDeactivationThreshold(const ReportDeactivationThreshold& reportDeactivationThreshold) { *static_cast<ReportDeactivationThreshold*>(items[4]) = reportDeactivationThreshold; }
	void setReportingAmount(const ReportingAmount& reportingAmount) { *static_cast<ReportingAmount*>(items[5]) = reportingAmount; }
	void setReportingInterval(const ReportingInterval& reportingInterval) { *static_cast<ReportingInterval*>(items[6]) = reportingInterval; }
};

enum TriggeringCondition1Values {
	activeSetCellsOnly_TriggeringCondition1 = 0,
	monitoredSetCellsOnly_TriggeringCondition1 = 1,
	activeSetAndMonitoredSetCells_TriggeringCondition1 = 2,
};
typedef Enumerated<CONSTRAINED, 2> TriggeringCondition1;

class Event1b : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	Event1b(): Sequence(&theInfo) {}

	void setTriggeringCondition(const TriggeringCondition1& triggeringCondition) { *static_cast<TriggeringCondition1*>(items[0]) = triggeringCondition; }
	void setReportingRange(const ReportingRange& reportingRange) { *static_cast<ReportingRange*>(items[1]) = reportingRange; }
	void setForbiddenAffectCellList(const ForbiddenAffectCellList& forbiddenAffectCellList) { *static_cast<ForbiddenAffectCellList*>(items[2]) = forbiddenAffectCellList; }
	void setW(const W& w) { *static_cast<W*>(items[3]) = w; }
};

enum ReplacementActivationThresholdValues {
	notApplicable_ReplacementActivationThreshold = 0,
	t1_ReplacementActivationThreshold = 1,
	t2_ReplacementActivationThreshold = 2,
	t3_ReplacementActivationThreshold = 3,
	t4_ReplacementActivationThreshold = 4,
	t5_ReplacementActivationThreshold = 5,
	t6_ReplacementActivationThreshold = 6,
	t7_ReplacementActivationThreshold = 7,
};
typedef Enumerated<CONSTRAINED, 7> ReplacementActivationThreshold;

class Event1c : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	Event1c(): Sequence(&theInfo) {}

	void setReplacementActivationThreshold(const ReplacementActivationThreshold& replacementActivationThreshold) { *static_cast<ReplacementActivationThreshold*>(items[0]) = replacementActivationThreshold; }
	void setReportingAmount(const ReportingAmount& reportingAmount) { *static_cast<ReportingAmount*>(items[1]) = reportingAmount; }
	void setReportingInterval(const ReportingInterval& reportingInterval) { *static_cast<ReportingInterval*>(items[2]) = reportingInterval; }
};

typedef Null IntraFreqEventE1d;

typedef Integer<CONSTRAINED, -115, 165> ThresholdUsedFrequency;

class Event1e : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	Event1e(): Sequence(&theInfo) {}

	void setTriggeringCondition(const TriggeringCondition2& triggeringCondition) { *static_cast<TriggeringCondition2*>(items[0]) = triggeringCondition; }
	void setThresholdUsedFrequency(const ThresholdUsedFrequency& thresholdUsedFrequency) { *static_cast<ThresholdUsedFrequency*>(items[1]) = thresholdUsedFrequency; }
};

class Event1f : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	Event1f(): Sequence(&theInfo) {}

	void setTriggeringCondition(const TriggeringCondition1& triggeringCondition) { *static_cast<TriggeringCondition1*>(items[0]) = triggeringCondition; }
	void setThresholdUsedFrequency(const ThresholdUsedFrequency& thresholdUsedFrequency) { *static_cast<ThresholdUsedFrequency*>(items[1]) = thresholdUsedFrequency; }
};

typedef Null IntraFreqEventE1g;

class IntraFreqEvent : public Choice {
private:
	static const void *choicesInfo[9];
public:
	enum IntraFreqEventChoices {
		e1a = 0,
		e1b = 1,
		e1c = 2,
		intraFreqEventE1d = 3,
		e1e = 4,
		e1f = 5,
		intraFreqEventE1g = 6,
		e1h = 7,
		e1i = 8,
	};
	static const Info theInfo;
	IntraFreqEvent(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 15> Hysteresis;

enum TimeToTriggerValues {
	ttt0_TimeToTrigger = 0,
	ttt10_TimeToTrigger = 1,
	ttt20_TimeToTrigger = 2,
	ttt40_TimeToTrigger = 3,
	ttt60_TimeToTrigger = 4,
	ttt80_TimeToTrigger = 5,
	ttt100_TimeToTrigger = 6,
	ttt120_TimeToTrigger = 7,
	ttt160_TimeToTrigger = 8,
	ttt200_TimeToTrigger = 9,
	ttt240_TimeToTrigger = 10,
	tt320_TimeToTrigger = 11,
	ttt640_TimeToTrigger = 12,
	ttt1280_TimeToTrigger = 13,
	ttt2560_TimeToTrigger = 14,
	ttt5000_TimeToTrigger = 15,
};
typedef Enumerated<CONSTRAINED, 15> TimeToTrigger;

enum MaxNumberOfReportingCellsType1Values {
	e1_MaxNumberOfReportingCellsType1 = 0,
	e2_MaxNumberOfReportingCellsType1 = 1,
	e3_MaxNumberOfReportingCellsType1 = 2,
	e4_MaxNumberOfReportingCellsType1 = 3,
	e5_MaxNumberOfReportingCellsType1 = 4,
	e6_MaxNumberOfReportingCellsType1 = 5,
};
typedef Enumerated<CONSTRAINED, 5> MaxNumberOfReportingCellsType1;

enum MaxNumberOfReportingCellsType3Values {
	viactCellsPlus1_MaxNumberOfReportingCellsType3 = 0,
	viactCellsPlus2_MaxNumberOfReportingCellsType3 = 1,
	viactCellsPlus3_MaxNumberOfReportingCellsType3 = 2,
	viactCellsPlus4_MaxNumberOfReportingCellsType3 = 3,
	viactCellsPlus5_MaxNumberOfReportingCellsType3 = 4,
	viactCellsPlus6_MaxNumberOfReportingCellsType3 = 5,
};
typedef Enumerated<CONSTRAINED, 5> MaxNumberOfReportingCellsType3;

enum MaxNumberOfReportingCellsType2Values {
	e1_MaxNumberOfReportingCellsType2 = 0,
	e2_MaxNumberOfReportingCellsType2 = 1,
	e3_MaxNumberOfReportingCellsType2 = 2,
	e4_MaxNumberOfReportingCellsType2 = 3,
	e5_MaxNumberOfReportingCellsType2 = 4,
	e6_MaxNumberOfReportingCellsType2 = 5,
	e7_MaxNumberOfReportingCellsType2 = 6,
	e8_MaxNumberOfReportingCellsType2 = 7,
	e9_MaxNumberOfReportingCellsType2 = 8,
	e10_MaxNumberOfReportingCellsType2 = 9,
	e11_MaxNumberOfReportingCellsType2 = 10,
	e12_MaxNumberOfReportingCellsType2 = 11,
};
typedef Enumerated<CONSTRAINED, 11> MaxNumberOfReportingCellsType2;

class ReportingCellStatus : public Choice {
private:
	static const void *choicesInfo[14];
public:
	enum ReportingCellStatusChoices {
		withinActiveSet = 0,
		withinMonitoredSetUsedFreq = 1,
		withinActiveAndOrMonitoredUsedFreq = 2,
		withinDetectedSetUsedFreq = 3,
		withinMonitoredAndOrDetectedUsedFreq = 4,
		allActiveplusMonitoredSet = 5,
		allActivePlusDetectedSet = 6,
		allActivePlusMonitoredAndOrDetectedSet = 7,
		withinVirtualActSet = 8,
		withinMonitoredSetNonUsedFreq = 9,
		withinMonitoredAndOrVirtualActiveSetNonUsedFreq = 10,
		allVirtualActSetplusMonitoredSetNonUsedFreq = 11,
		withinActSetOrVirtualActSetInterRATcells = 12,
		withinActSetAndOrMonitoredUsedFreqOrVirtualActSetAndOrMonitoredNonUsedFreq = 13,
	};
	static const Info theInfo;
	ReportingCellStatus(): Choice(&theInfo) {}
};

class IntraFreqEventCriteria : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	IntraFreqEventCriteria(): Sequence(&theInfo) {}

	void setEvent(const IntraFreqEvent& event) { *static_cast<IntraFreqEvent*>(items[0]) = event; }
	void setHysteresis(const Hysteresis& hysteresis) { *static_cast<Hysteresis*>(items[1]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[2]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[3]) = reportingCellStatus; }
};

typedef SequenceOf<IntraFreqEventCriteria, CONSTRAINED, 1, maxMeasEvent> IntraFreqEventCriteriaList;

class IntraFreqReportingCriteria : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	IntraFreqReportingCriteria(): Sequence(&theInfo) {}

	void setEventCriteriaList(const IntraFreqEventCriteriaList& eventCriteriaList) { *static_cast<IntraFreqEventCriteriaList*>(items[0]) = eventCriteriaList; }
};

enum ReportingIntervalLongValues {
	ril0_ReportingIntervalLong = 0,
	ril0_25_ReportingIntervalLong = 1,
	ril0_5_ReportingIntervalLong = 2,
	ril1_ReportingIntervalLong = 3,
	ril2_ReportingIntervalLong = 4,
	ril3_ReportingIntervalLong = 5,
	ril4_ReportingIntervalLong = 6,
	ril6_ReportingIntervalLong = 7,
	ril8_ReportingIntervalLong = 8,
	ril12_ReportingIntervalLong = 9,
	ril16_ReportingIntervalLong = 10,
	ril20_ReportingIntervalLong = 11,
	ril24_ReportingIntervalLong = 12,
	ril28_ReportingIntervalLong = 13,
	ril32_ReportingIntervalLong = 14,
	ril64_ReportingIntervalLong = 15,
};
typedef Enumerated<CONSTRAINED, 15> ReportingIntervalLong;

class PeriodicalReportingCriteria : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PeriodicalReportingCriteria(): Sequence(&theInfo) {}

	void setReportingAmount(const ReportingAmount& reportingAmount) { *static_cast<ReportingAmount*>(items[0]) = reportingAmount; }
	void setReportingInterval(const ReportingIntervalLong& reportingInterval) { *static_cast<ReportingIntervalLong*>(items[1]) = reportingInterval; }
};

class CellDCHReportCriteria : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CellDCHReportCriteriaChoices {
		intraFreqReportingCriteria = 0,
		periodicalReportingCriteria = 1,
	};
	static const Info theInfo;
	CellDCHReportCriteria(): Choice(&theInfo) {}
};

class ForbiddenAffectCellLCRr4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ForbiddenAffectCellLCRr4(): Sequence(&theInfo) {}

	void setTdd(const PrimaryCCPCHInfoLCRr4& tdd) { *static_cast<PrimaryCCPCHInfoLCRr4*>(items[0]) = tdd; }
};

typedef SequenceOf<ForbiddenAffectCellLCRr4, CONSTRAINED, 1, maxCellMeas> ForbiddenAffectCellListLCRr4;

class Event1aLCRr4 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	Event1aLCRr4(): Sequence(&theInfo) {}

	void setTriggeringCondition(const TriggeringCondition2& triggeringCondition) { *static_cast<TriggeringCondition2*>(items[0]) = triggeringCondition; }
	void setReportingRange(const ReportingRange& reportingRange) { *static_cast<ReportingRange*>(items[1]) = reportingRange; }
	void setForbiddenAffectCellList(const ForbiddenAffectCellListLCRr4& forbiddenAffectCellList) { *static_cast<ForbiddenAffectCellListLCRr4*>(items[2]) = forbiddenAffectCellList; }
	void setW(const W& w) { *static_cast<W*>(items[3]) = w; }
	void setReportDeactivationThreshold(const ReportDeactivationThreshold& reportDeactivationThreshold) { *static_cast<ReportDeactivationThreshold*>(items[4]) = reportDeactivationThreshold; }
	void setReportingAmount(const ReportingAmount& reportingAmount) { *static_cast<ReportingAmount*>(items[5]) = reportingAmount; }
	void setReportingInterval(const ReportingInterval& reportingInterval) { *static_cast<ReportingInterval*>(items[6]) = reportingInterval; }
};

class Event1bLCRr4 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	Event1bLCRr4(): Sequence(&theInfo) {}

	void setTriggeringCondition(const TriggeringCondition1& triggeringCondition) { *static_cast<TriggeringCondition1*>(items[0]) = triggeringCondition; }
	void setReportingRange(const ReportingRange& reportingRange) { *static_cast<ReportingRange*>(items[1]) = reportingRange; }
	void setForbiddenAffectCellList(const ForbiddenAffectCellListLCRr4& forbiddenAffectCellList) { *static_cast<ForbiddenAffectCellListLCRr4*>(items[2]) = forbiddenAffectCellList; }
	void setW(const W& w) { *static_cast<W*>(items[3]) = w; }
};

typedef Null IntraFreqEventLCRr4E1d;

typedef Null IntraFreqEventLCRr4E1g;

class IntraFreqEventLCRr4 : public Choice {
private:
	static const void *choicesInfo[9];
public:
	enum IntraFreqEventLCRr4Choices {
		e1a = 0,
		e1b = 1,
		e1c = 2,
		intraFreqEventLCRr4E1d = 3,
		e1e = 4,
		e1f = 5,
		intraFreqEventLCRr4E1g = 6,
		e1h = 7,
		e1i = 8,
	};
	static const Info theInfo;
	IntraFreqEventLCRr4(): Choice(&theInfo) {}
};

class IntraFreqEventCriteriaLCRr4 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	IntraFreqEventCriteriaLCRr4(): Sequence(&theInfo) {}

	void setEvent(const IntraFreqEventLCRr4& event) { *static_cast<IntraFreqEventLCRr4*>(items[0]) = event; }
	void setHysteresis(const Hysteresis& hysteresis) { *static_cast<Hysteresis*>(items[1]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[2]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[3]) = reportingCellStatus; }
};

typedef SequenceOf<IntraFreqEventCriteriaLCRr4, CONSTRAINED, 1, maxMeasEvent> IntraFreqEventCriteriaListLCRr4;

class IntraFreqReportingCriteriaLCRr4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	IntraFreqReportingCriteriaLCRr4(): Sequence(&theInfo) {}

	void setEventCriteriaList(const IntraFreqEventCriteriaListLCRr4& eventCriteriaList) { *static_cast<IntraFreqEventCriteriaListLCRr4*>(items[0]) = eventCriteriaList; }
};

class CellDCHReportCriteriaLCRr4 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CellDCHReportCriteriaLCRr4Choices {
		intraFreqReportingCriteria = 0,
		periodicalReportingCriteria = 1,
	};
	static const Info theInfo;
	CellDCHReportCriteriaLCRr4(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, maxMeasOccasionPattern_1> CellDCHMeasOccasionPatternLCRPatternIdentifier;

enum CellDCHMeasOccasionPatternLCRstatusFlagValues {
	activate_CellDCHMeasOccasionPatternLCRstatusFlag = 0,
	deactivate_CellDCHMeasOccasionPatternLCRstatusFlag = 1,
};
typedef Enumerated<CONSTRAINED, 1> CellDCHMeasOccasionPatternLCRstatusFlag;

typedef BitString<CONSTRAINED, 5, 5> CellDCHMeasOccasionPatternLCRMeasurementPurpose;

typedef Integer<CONSTRAINED, 1, 9> MeasurementOccasionPatternParameterMeasurementOccasionCoeff;

typedef Integer<CONSTRAINED, 0, 511> MeasurementOccasionPatternParameterMeasurementOccasionOffset;

typedef Integer<CONSTRAINED, 1, 512> MeasurementOccasionPatternParameterMeasurementOccasionLength;

typedef BitString<CONSTRAINED, 7, 7> MeasurementOccasionPatternParameterTimeslotBitmap;

class MeasurementOccasionPatternParameter : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	MeasurementOccasionPatternParameter(): Sequence(&theInfo) {}

	void setMeasurementOccasionPatternParameterMeasurementOccasionCoeff(const MeasurementOccasionPatternParameterMeasurementOccasionCoeff& measurementOccasionPatternParameterMeasurementOccasionCoeff) { *static_cast<MeasurementOccasionPatternParameterMeasurementOccasionCoeff*>(items[0]) = measurementOccasionPatternParameterMeasurementOccasionCoeff; }
	void setMeasurementOccasionPatternParameterMeasurementOccasionOffset(const MeasurementOccasionPatternParameterMeasurementOccasionOffset& measurementOccasionPatternParameterMeasurementOccasionOffset) { *static_cast<MeasurementOccasionPatternParameterMeasurementOccasionOffset*>(items[1]) = measurementOccasionPatternParameterMeasurementOccasionOffset; }
	void setMeasurementOccasionPatternParameterMeasurementOccasionLength(const MeasurementOccasionPatternParameterMeasurementOccasionLength& measurementOccasionPatternParameterMeasurementOccasionLength) { *static_cast<MeasurementOccasionPatternParameterMeasurementOccasionLength*>(items[2]) = measurementOccasionPatternParameterMeasurementOccasionLength; }
	void setMeasurementOccasionPatternParameterTimeslotBitmap(const MeasurementOccasionPatternParameterTimeslotBitmap& measurementOccasionPatternParameterTimeslotBitmap) { *static_cast<MeasurementOccasionPatternParameterTimeslotBitmap*>(items[3]) = measurementOccasionPatternParameterTimeslotBitmap; }
};

class CellDCHMeasOccasionPatternLCR : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellDCHMeasOccasionPatternLCR(): Sequence(&theInfo) {}

	void setCellDCHMeasOccasionPatternLCRPatternIdentifier(const CellDCHMeasOccasionPatternLCRPatternIdentifier& cellDCHMeasOccasionPatternLCRPatternIdentifier) { *static_cast<CellDCHMeasOccasionPatternLCRPatternIdentifier*>(items[0]) = cellDCHMeasOccasionPatternLCRPatternIdentifier; }
	void setCellDCHMeasOccasionPatternLCRstatusFlag(const CellDCHMeasOccasionPatternLCRstatusFlag& cellDCHMeasOccasionPatternLCRstatusFlag) { *static_cast<CellDCHMeasOccasionPatternLCRstatusFlag*>(items[1]) = cellDCHMeasOccasionPatternLCRstatusFlag; }
	void setCellDCHMeasOccasionPatternLCRMeasurementPurpose(const CellDCHMeasOccasionPatternLCRMeasurementPurpose& cellDCHMeasOccasionPatternLCRMeasurementPurpose) { *static_cast<CellDCHMeasOccasionPatternLCRMeasurementPurpose*>(items[2]) = cellDCHMeasOccasionPatternLCRMeasurementPurpose; }
	void setMeasurementOccasionPatternParameter(const MeasurementOccasionPatternParameter& measurementOccasionPatternParameter) { *static_cast<MeasurementOccasionPatternParameter*>(items[3]) = measurementOccasionPatternParameter; }
};

typedef SequenceOf<CellDCHMeasOccasionPatternLCR, CONSTRAINED, 1, maxMeasOccasionPattern> CellDCHMeasOccasionInfoTDD128r9CellDCHMeasOccasionSequenceList;

class CellDCHMeasOccasionInfoTDD128r9 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CellDCHMeasOccasionInfoTDD128r9(): Sequence(&theInfo) {}

	void setCellDCHMeasOccasionInfoTDD128r9CellDCHMeasOccasionSequenceList(const CellDCHMeasOccasionInfoTDD128r9CellDCHMeasOccasionSequenceList& cellDCHMeasOccasionInfoTDD128r9CellDCHMeasOccasionSequenceList) { *static_cast<CellDCHMeasOccasionInfoTDD128r9CellDCHMeasOccasionSequenceList*>(items[0]) = cellDCHMeasOccasionInfoTDD128r9CellDCHMeasOccasionSequenceList; }
};

typedef Integer<CONSTRAINED, -20, 20> CellIndividualOffset;

typedef Integer<CONSTRAINED, 0, 960> ReferenceTimeDifferenceToCellAccuracy40;

typedef Integer<CONSTRAINED, 0, 150> ReferenceTimeDifferenceToCellAccuracy256;

typedef Integer<CONSTRAINED, 0, 15> ReferenceTimeDifferenceToCellAccuracy2560;

class ReferenceTimeDifferenceToCell : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum ReferenceTimeDifferenceToCellChoices {
		referenceTimeDifferenceToCellAccuracy40 = 0,
		referenceTimeDifferenceToCellAccuracy256 = 1,
		referenceTimeDifferenceToCellAccuracy2560 = 2,
	};
	static const Info theInfo;
	ReferenceTimeDifferenceToCell(): Choice(&theInfo) {}
};

typedef Boolean CellInfoModeSpecificInfoFddReadSFNIndicator;

typedef Boolean CellInfoModeSpecificInfoFddTxDiversityIndicator;

class CellInfoModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellInfoModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setPrimaryCPICHTXPower(const PrimaryCPICHTXPower& primaryCPICHTXPower) { *static_cast<PrimaryCPICHTXPower*>(items[1]) = primaryCPICHTXPower; }
	void setCellInfoModeSpecificInfoFddReadSFNIndicator(const CellInfoModeSpecificInfoFddReadSFNIndicator& cellInfoModeSpecificInfoFddReadSFNIndicator) { *static_cast<CellInfoModeSpecificInfoFddReadSFNIndicator*>(items[2]) = cellInfoModeSpecificInfoFddReadSFNIndicator; }
	void setCellInfoModeSpecificInfoFddTxDiversityIndicator(const CellInfoModeSpecificInfoFddTxDiversityIndicator& cellInfoModeSpecificInfoFddTxDiversityIndicator) { *static_cast<CellInfoModeSpecificInfoFddTxDiversityIndicator*>(items[3]) = cellInfoModeSpecificInfoFddTxDiversityIndicator; }
};

class TimeslotInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	TimeslotInfo(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumber& timeslotNumber) { *static_cast<TimeslotNumber*>(items[0]) = timeslotNumber; }
	void setBurstType(const BurstType& burstType) { *static_cast<BurstType*>(items[1]) = burstType; }
};

typedef SequenceOf<TimeslotInfo, CONSTRAINED, 1, maxTS> TimeslotInfoList;

typedef Boolean CellInfoModeSpecificInfoTddReadSFNIndicator;

class CellInfoModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellInfoModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setPrimaryCCPCHInfo(const PrimaryCCPCHInfo& primaryCCPCHInfo) { *static_cast<PrimaryCCPCHInfo*>(items[0]) = primaryCCPCHInfo; }
	void setPrimaryCCPCHTXPower(const PrimaryCCPCHTXPower& primaryCCPCHTXPower) { *static_cast<PrimaryCCPCHTXPower*>(items[1]) = primaryCCPCHTXPower; }
	void setTimeslotInfoList(const TimeslotInfoList& timeslotInfoList) { *static_cast<TimeslotInfoList*>(items[2]) = timeslotInfoList; }
	void setCellInfoModeSpecificInfoTddReadSFNIndicator(const CellInfoModeSpecificInfoTddReadSFNIndicator& cellInfoModeSpecificInfoTddReadSFNIndicator) { *static_cast<CellInfoModeSpecificInfoTddReadSFNIndicator*>(items[3]) = cellInfoModeSpecificInfoTddReadSFNIndicator; }
};

class CellInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CellInfoModeSpecificInfoChoices {
		cellInfoModeSpecificInfoFdd = 0,
		cellInfoModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	CellInfoModeSpecificInfo(): Choice(&theInfo) {}
};

class CellInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CellInfo(): Sequence(&theInfo) {}

	void setCellIndividualOffset(const CellIndividualOffset& cellIndividualOffset) { *static_cast<CellIndividualOffset*>(items[0]) = cellIndividualOffset; }
	void setReferenceTimeDifferenceToCell(const ReferenceTimeDifferenceToCell& referenceTimeDifferenceToCell) { *static_cast<ReferenceTimeDifferenceToCell*>(items[1]) = referenceTimeDifferenceToCell; }
	void setCellInfoModeSpecificInfo(const CellInfoModeSpecificInfo& cellInfoModeSpecificInfo) { *static_cast<CellInfoModeSpecificInfo*>(items[2]) = cellInfoModeSpecificInfo; }
};

typedef Boolean CellInfor4ModeSpecificInfoFddReadSFNIndicator;

typedef Boolean CellInfor4ModeSpecificInfoFddTxDiversityIndicator;

class CellInfor4ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellInfor4ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setPrimaryCPICHTXPower(const PrimaryCPICHTXPower& primaryCPICHTXPower) { *static_cast<PrimaryCPICHTXPower*>(items[1]) = primaryCPICHTXPower; }
	void setCellInfor4ModeSpecificInfoFddReadSFNIndicator(const CellInfor4ModeSpecificInfoFddReadSFNIndicator& cellInfor4ModeSpecificInfoFddReadSFNIndicator) { *static_cast<CellInfor4ModeSpecificInfoFddReadSFNIndicator*>(items[2]) = cellInfor4ModeSpecificInfoFddReadSFNIndicator; }
	void setCellInfor4ModeSpecificInfoFddTxDiversityIndicator(const CellInfor4ModeSpecificInfoFddTxDiversityIndicator& cellInfor4ModeSpecificInfoFddTxDiversityIndicator) { *static_cast<CellInfor4ModeSpecificInfoFddTxDiversityIndicator*>(items[3]) = cellInfor4ModeSpecificInfoFddTxDiversityIndicator; }
};

typedef SequenceOf<TimeslotInfo, CONSTRAINED, 1, maxTS> TimeslotInfoListr4Tdd384;

class TimeslotInfoLCRr4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	TimeslotInfoLCRr4(): Sequence(&theInfo) {}

	void setTimeslotNumber(const TimeslotNumberLCRr4& timeslotNumber) { *static_cast<TimeslotNumberLCRr4*>(items[0]) = timeslotNumber; }
};

typedef SequenceOf<TimeslotInfoLCRr4, CONSTRAINED, 1, maxTS_LCR> TimeslotInfoListr4Tdd128;

class TimeslotInfoListr4 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum TimeslotInfoListr4Choices {
		timeslotInfoListr4Tdd384 = 0,
		timeslotInfoListr4Tdd128 = 1,
	};
	static const Info theInfo;
	TimeslotInfoListr4(): Choice(&theInfo) {}
};

typedef Boolean CellInfor4ModeSpecificInfoTddReadSFNIndicator;

class CellInfor4ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellInfor4ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setPrimaryCCPCHInfo(const PrimaryCCPCHInfor4& primaryCCPCHInfo) { *static_cast<PrimaryCCPCHInfor4*>(items[0]) = primaryCCPCHInfo; }
	void setPrimaryCCPCHTXPower(const PrimaryCCPCHTXPower& primaryCCPCHTXPower) { *static_cast<PrimaryCCPCHTXPower*>(items[1]) = primaryCCPCHTXPower; }
	void setTimeslotInfoList(const TimeslotInfoListr4& timeslotInfoList) { *static_cast<TimeslotInfoListr4*>(items[2]) = timeslotInfoList; }
	void setCellInfor4ModeSpecificInfoTddReadSFNIndicator(const CellInfor4ModeSpecificInfoTddReadSFNIndicator& cellInfor4ModeSpecificInfoTddReadSFNIndicator) { *static_cast<CellInfor4ModeSpecificInfoTddReadSFNIndicator*>(items[3]) = cellInfor4ModeSpecificInfoTddReadSFNIndicator; }
};

class CellInfor4ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CellInfor4ModeSpecificInfoChoices {
		cellInfor4ModeSpecificInfoFdd = 0,
		cellInfor4ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	CellInfor4ModeSpecificInfo(): Choice(&theInfo) {}
};

class CellInfor4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CellInfor4(): Sequence(&theInfo) {}

	void setCellIndividualOffset(const CellIndividualOffset& cellIndividualOffset) { *static_cast<CellIndividualOffset*>(items[0]) = cellIndividualOffset; }
	void setReferenceTimeDifferenceToCell(const ReferenceTimeDifferenceToCell& referenceTimeDifferenceToCell) { *static_cast<ReferenceTimeDifferenceToCell*>(items[1]) = referenceTimeDifferenceToCell; }
	void setCellInfor4ModeSpecificInfo(const CellInfor4ModeSpecificInfo& cellInfor4ModeSpecificInfo) { *static_cast<CellInfor4ModeSpecificInfo*>(items[2]) = cellInfor4ModeSpecificInfo; }
};

typedef Integer<CONSTRAINED, -50, 50> QOffsetSN;

typedef Null PenaltyTimeRSCPNotUsed;

enum TemporaryOffset1Values {
	to3_TemporaryOffset1 = 0,
	to6_TemporaryOffset1 = 1,
	to9_TemporaryOffset1 = 2,
	to12_TemporaryOffset1 = 3,
	to15_TemporaryOffset1 = 4,
	to18_TemporaryOffset1 = 5,
	to21_TemporaryOffset1 = 6,
	infinite_TemporaryOffset1 = 7,
};
typedef Enumerated<CONSTRAINED, 7> TemporaryOffset1;

class PenaltyTimeRSCP : public Choice {
private:
	static const void *choicesInfo[7];
public:
	enum PenaltyTimeRSCPChoices {
		penaltyTimeRSCPNotUsed = 0,
		pt10 = 1,
		pt20 = 2,
		pt30 = 3,
		pt40 = 4,
		pt50 = 5,
		pt60 = 6,
	};
	static const Info theInfo;
	PenaltyTimeRSCP(): Choice(&theInfo) {}
};

class HCSCellReselectInformationRSCP : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	HCSCellReselectInformationRSCP(): Sequence(&theInfo) {}

	void setPenaltyTime(const PenaltyTimeRSCP& penaltyTime) { *static_cast<PenaltyTimeRSCP*>(items[0]) = penaltyTime; }
};

class HCSNeighbouringCellInformationRSCP : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	HCSNeighbouringCellInformationRSCP(): Sequence(&theInfo) {}

	void setHcsPRIO(const HCSPRIO& hcsPRIO) { *static_cast<HCSPRIO*>(items[0]) = hcsPRIO; }
	void setQHCS(const QHCS& qHCS) { *static_cast<QHCS*>(items[1]) = qHCS; }
	void setHcsCellReselectInformation(const HCSCellReselectInformationRSCP& hcsCellReselectInformation) { *static_cast<HCSCellReselectInformationRSCP*>(items[2]) = hcsCellReselectInformation; }
};

class CellSelectReselectInfoMCRSCPModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CellSelectReselectInfoMCRSCPModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setQQualMin(const QQualMin& qQualMin) { *static_cast<QQualMin*>(items[0]) = qQualMin; }
	void setQRxlevMin(const QRxlevMin& qRxlevMin) { *static_cast<QRxlevMin*>(items[1]) = qRxlevMin; }
};

class CellSelectReselectInfoMCRSCPModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CellSelectReselectInfoMCRSCPModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setQRxlevMin(const QRxlevMin& qRxlevMin) { *static_cast<QRxlevMin*>(items[0]) = qRxlevMin; }
};

class CellSelectReselectInfoMCRSCPModeSpecificInfoGsm : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CellSelectReselectInfoMCRSCPModeSpecificInfoGsm(): Sequence(&theInfo) {}

	void setQRxlevMin(const QRxlevMin& qRxlevMin) { *static_cast<QRxlevMin*>(items[0]) = qRxlevMin; }
};

class CellSelectReselectInfoMCRSCPModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum CellSelectReselectInfoMCRSCPModeSpecificInfoChoices {
		cellSelectReselectInfoMCRSCPModeSpecificInfoFdd = 0,
		cellSelectReselectInfoMCRSCPModeSpecificInfoTdd = 1,
		cellSelectReselectInfoMCRSCPModeSpecificInfoGsm = 2,
	};
	static const Info theInfo;
	CellSelectReselectInfoMCRSCPModeSpecificInfo(): Choice(&theInfo) {}
};

class CellSelectReselectInfoMCRSCP : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellSelectReselectInfoMCRSCP(): Sequence(&theInfo) {}

	void setQOffsetSN(const QOffsetSN& qOffsetSN) { *static_cast<QOffsetSN*>(items[0]) = qOffsetSN; }
	void setMaxAllowedULTXPower(const MaxAllowedULTXPower& maxAllowedULTXPower) { *static_cast<MaxAllowedULTXPower*>(items[1]) = maxAllowedULTXPower; }
	void setHcsNeighbouringCellInformationRSCP(const HCSNeighbouringCellInformationRSCP& hcsNeighbouringCellInformationRSCP) { *static_cast<HCSNeighbouringCellInformationRSCP*>(items[2]) = hcsNeighbouringCellInformationRSCP; }
	void setCellSelectReselectInfoMCRSCPModeSpecificInfo(const CellSelectReselectInfoMCRSCPModeSpecificInfo& cellSelectReselectInfoMCRSCPModeSpecificInfo) { *static_cast<CellSelectReselectInfoMCRSCPModeSpecificInfo*>(items[3]) = cellSelectReselectInfoMCRSCPModeSpecificInfo; }
};

class CellInfoLCRr8ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CellInfoLCRr8ext(): Sequence(&theInfo) {}

	void setCellSelectionReselectionInfo(const CellSelectReselectInfoMCRSCP& cellSelectionReselectionInfo) { *static_cast<CellSelectReselectInfoMCRSCP*>(items[0]) = cellSelectionReselectionInfo; }
};

typedef Boolean CellInfor9ModeSpecificInfoFddReadSFNIndicator;

typedef Boolean CellInfor9ModeSpecificInfoFddTxDiversityIndicator;

class CellInfor9ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellInfor9ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setPrimaryCPICHTXPower(const PrimaryCPICHTXPower& primaryCPICHTXPower) { *static_cast<PrimaryCPICHTXPower*>(items[1]) = primaryCPICHTXPower; }
	void setCellInfor9ModeSpecificInfoFddReadSFNIndicator(const CellInfor9ModeSpecificInfoFddReadSFNIndicator& cellInfor9ModeSpecificInfoFddReadSFNIndicator) { *static_cast<CellInfor9ModeSpecificInfoFddReadSFNIndicator*>(items[2]) = cellInfor9ModeSpecificInfoFddReadSFNIndicator; }
	void setCellInfor9ModeSpecificInfoFddTxDiversityIndicator(const CellInfor9ModeSpecificInfoFddTxDiversityIndicator& cellInfor9ModeSpecificInfoFddTxDiversityIndicator) { *static_cast<CellInfor9ModeSpecificInfoFddTxDiversityIndicator*>(items[3]) = cellInfor9ModeSpecificInfoFddTxDiversityIndicator; }
};

typedef Boolean CellInfor9ModeSpecificInfoTddReadSFNIndicator;

class CellInfor9ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellInfor9ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setPrimaryCCPCHInfo(const PrimaryCCPCHInfor4& primaryCCPCHInfo) { *static_cast<PrimaryCCPCHInfor4*>(items[0]) = primaryCCPCHInfo; }
	void setPrimaryCCPCHTXPower(const PrimaryCCPCHTXPower& primaryCCPCHTXPower) { *static_cast<PrimaryCCPCHTXPower*>(items[1]) = primaryCCPCHTXPower; }
	void setTimeslotInfoList(const TimeslotInfoListr4& timeslotInfoList) { *static_cast<TimeslotInfoListr4*>(items[2]) = timeslotInfoList; }
	void setCellInfor9ModeSpecificInfoTddReadSFNIndicator(const CellInfor9ModeSpecificInfoTddReadSFNIndicator& cellInfor9ModeSpecificInfoTddReadSFNIndicator) { *static_cast<CellInfor9ModeSpecificInfoTddReadSFNIndicator*>(items[3]) = cellInfor9ModeSpecificInfoTddReadSFNIndicator; }
};

class CellInfor9ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CellInfor9ModeSpecificInfoChoices {
		cellInfor9ModeSpecificInfoFdd = 0,
		cellInfor9ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	CellInfor9ModeSpecificInfo(): Choice(&theInfo) {}
};

class CellInfor9 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellInfor9(): Sequence(&theInfo) {}

	void setCellIndividualOffset(const CellIndividualOffset& cellIndividualOffset) { *static_cast<CellIndividualOffset*>(items[0]) = cellIndividualOffset; }
	void setReferenceTimeDifferenceToCell(const ReferenceTimeDifferenceToCell& referenceTimeDifferenceToCell) { *static_cast<ReferenceTimeDifferenceToCell*>(items[1]) = referenceTimeDifferenceToCell; }
	void setCellInfor9ModeSpecificInfo(const CellInfor9ModeSpecificInfo& cellInfor9ModeSpecificInfo) { *static_cast<CellInfor9ModeSpecificInfo*>(items[2]) = cellInfor9ModeSpecificInfo; }
	void setCellSelectionReselectionInfo(const CellSelectReselectInfoMCRSCP& cellSelectionReselectionInfo) { *static_cast<CellSelectReselectInfoMCRSCP*>(items[3]) = cellSelectionReselectionInfo; }
};

typedef Boolean CellInfoSIRSCPModeSpecificInfoFddReadSFNIndicator;

typedef Boolean CellInfoSIRSCPModeSpecificInfoFddTxDiversityIndicator;

class CellInfoSIRSCPModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellInfoSIRSCPModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setPrimaryCPICHTXPower(const PrimaryCPICHTXPower& primaryCPICHTXPower) { *static_cast<PrimaryCPICHTXPower*>(items[1]) = primaryCPICHTXPower; }
	void setCellInfoSIRSCPModeSpecificInfoFddReadSFNIndicator(const CellInfoSIRSCPModeSpecificInfoFddReadSFNIndicator& cellInfoSIRSCPModeSpecificInfoFddReadSFNIndicator) { *static_cast<CellInfoSIRSCPModeSpecificInfoFddReadSFNIndicator*>(items[2]) = cellInfoSIRSCPModeSpecificInfoFddReadSFNIndicator; }
	void setCellInfoSIRSCPModeSpecificInfoFddTxDiversityIndicator(const CellInfoSIRSCPModeSpecificInfoFddTxDiversityIndicator& cellInfoSIRSCPModeSpecificInfoFddTxDiversityIndicator) { *static_cast<CellInfoSIRSCPModeSpecificInfoFddTxDiversityIndicator*>(items[3]) = cellInfoSIRSCPModeSpecificInfoFddTxDiversityIndicator; }
};

typedef Boolean CellInfoSIRSCPModeSpecificInfoTddReadSFNIndicator;

class CellInfoSIRSCPModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellInfoSIRSCPModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setPrimaryCCPCHInfo(const PrimaryCCPCHInfo& primaryCCPCHInfo) { *static_cast<PrimaryCCPCHInfo*>(items[0]) = primaryCCPCHInfo; }
	void setPrimaryCCPCHTXPower(const PrimaryCCPCHTXPower& primaryCCPCHTXPower) { *static_cast<PrimaryCCPCHTXPower*>(items[1]) = primaryCCPCHTXPower; }
	void setTimeslotInfoList(const TimeslotInfoList& timeslotInfoList) { *static_cast<TimeslotInfoList*>(items[2]) = timeslotInfoList; }
	void setCellInfoSIRSCPModeSpecificInfoTddReadSFNIndicator(const CellInfoSIRSCPModeSpecificInfoTddReadSFNIndicator& cellInfoSIRSCPModeSpecificInfoTddReadSFNIndicator) { *static_cast<CellInfoSIRSCPModeSpecificInfoTddReadSFNIndicator*>(items[3]) = cellInfoSIRSCPModeSpecificInfoTddReadSFNIndicator; }
};

class CellInfoSIRSCPModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CellInfoSIRSCPModeSpecificInfoChoices {
		cellInfoSIRSCPModeSpecificInfoFdd = 0,
		cellInfoSIRSCPModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	CellInfoSIRSCPModeSpecificInfo(): Choice(&theInfo) {}
};

class CellSelectReselectInfoSIB1112RSCPModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB1112RSCPModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setQQualMin(const QQualMin& qQualMin) { *static_cast<QQualMin*>(items[0]) = qQualMin; }
	void setQRxlevMin(const QRxlevMin& qRxlevMin) { *static_cast<QRxlevMin*>(items[1]) = qRxlevMin; }
};

class CellSelectReselectInfoSIB1112RSCPModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB1112RSCPModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setQRxlevMin(const QRxlevMin& qRxlevMin) { *static_cast<QRxlevMin*>(items[0]) = qRxlevMin; }
};

class CellSelectReselectInfoSIB1112RSCPModeSpecificInfoGsm : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB1112RSCPModeSpecificInfoGsm(): Sequence(&theInfo) {}

	void setQRxlevMin(const QRxlevMin& qRxlevMin) { *static_cast<QRxlevMin*>(items[0]) = qRxlevMin; }
};

class CellSelectReselectInfoSIB1112RSCPModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum CellSelectReselectInfoSIB1112RSCPModeSpecificInfoChoices {
		cellSelectReselectInfoSIB1112RSCPModeSpecificInfoFdd = 0,
		cellSelectReselectInfoSIB1112RSCPModeSpecificInfoTdd = 1,
		cellSelectReselectInfoSIB1112RSCPModeSpecificInfoGsm = 2,
	};
	static const Info theInfo;
	CellSelectReselectInfoSIB1112RSCPModeSpecificInfo(): Choice(&theInfo) {}
};

class CellSelectReselectInfoSIB1112RSCP : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB1112RSCP(): Sequence(&theInfo) {}

	void setQOffsetSN(const QOffsetSN& qOffsetSN) { *static_cast<QOffsetSN*>(items[0]) = qOffsetSN; }
	void setMaxAllowedULTXPower(const MaxAllowedULTXPower& maxAllowedULTXPower) { *static_cast<MaxAllowedULTXPower*>(items[1]) = maxAllowedULTXPower; }
	void setCellSelectReselectInfoSIB1112RSCPModeSpecificInfo(const CellSelectReselectInfoSIB1112RSCPModeSpecificInfo& cellSelectReselectInfoSIB1112RSCPModeSpecificInfo) { *static_cast<CellSelectReselectInfoSIB1112RSCPModeSpecificInfo*>(items[2]) = cellSelectReselectInfoSIB1112RSCPModeSpecificInfo; }
};

class CellInfoSIRSCP : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellInfoSIRSCP(): Sequence(&theInfo) {}

	void setCellIndividualOffset(const CellIndividualOffset& cellIndividualOffset) { *static_cast<CellIndividualOffset*>(items[0]) = cellIndividualOffset; }
	void setReferenceTimeDifferenceToCell(const ReferenceTimeDifferenceToCell& referenceTimeDifferenceToCell) { *static_cast<ReferenceTimeDifferenceToCell*>(items[1]) = referenceTimeDifferenceToCell; }
	void setCellInfoSIRSCPModeSpecificInfo(const CellInfoSIRSCPModeSpecificInfo& cellInfoSIRSCPModeSpecificInfo) { *static_cast<CellInfoSIRSCPModeSpecificInfo*>(items[2]) = cellInfoSIRSCPModeSpecificInfo; }
	void setCellSelectionReselectionInfo(const CellSelectReselectInfoSIB1112RSCP& cellSelectionReselectionInfo) { *static_cast<CellSelectReselectInfoSIB1112RSCP*>(items[3]) = cellSelectionReselectionInfo; }
};

typedef SequenceOf<TimeslotInfoLCRr4, CONSTRAINED, 1, maxTS_LCR> TimeslotInfoListLCRr4;

typedef Boolean CellInfoSIRSCPLCRr4ReadSFNIndicator;

class CellInfoSIRSCPLCRr4 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	CellInfoSIRSCPLCRr4(): Sequence(&theInfo) {}

	void setCellIndividualOffset(const CellIndividualOffset& cellIndividualOffset) { *static_cast<CellIndividualOffset*>(items[0]) = cellIndividualOffset; }
	void setReferenceTimeDifferenceToCell(const ReferenceTimeDifferenceToCell& referenceTimeDifferenceToCell) { *static_cast<ReferenceTimeDifferenceToCell*>(items[1]) = referenceTimeDifferenceToCell; }
	void setPrimaryCCPCHInfo(const PrimaryCCPCHInfoLCRr4& primaryCCPCHInfo) { *static_cast<PrimaryCCPCHInfoLCRr4*>(items[2]) = primaryCCPCHInfo; }
	void setPrimaryCCPCHTXPower(const PrimaryCCPCHTXPower& primaryCCPCHTXPower) { *static_cast<PrimaryCCPCHTXPower*>(items[3]) = primaryCCPCHTXPower; }
	void setTimeslotInfoList(const TimeslotInfoListLCRr4& timeslotInfoList) { *static_cast<TimeslotInfoListLCRr4*>(items[4]) = timeslotInfoList; }
	void setCellInfoSIRSCPLCRr4ReadSFNIndicator(const CellInfoSIRSCPLCRr4ReadSFNIndicator& cellInfoSIRSCPLCRr4ReadSFNIndicator) { *static_cast<CellInfoSIRSCPLCRr4ReadSFNIndicator*>(items[5]) = cellInfoSIRSCPLCRr4ReadSFNIndicator; }
	void setCellSelectionReselectionInfo(const CellSelectReselectInfoSIB1112RSCP& cellSelectionReselectionInfo) { *static_cast<CellSelectReselectInfoSIB1112RSCP*>(items[6]) = cellSelectionReselectionInfo; }
};

typedef Boolean CellInfoSIECN0ModeSpecificInfoFddReadSFNIndicator;

typedef Boolean CellInfoSIECN0ModeSpecificInfoFddTxDiversityIndicator;

class CellInfoSIECN0ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellInfoSIECN0ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setPrimaryCPICHTXPower(const PrimaryCPICHTXPower& primaryCPICHTXPower) { *static_cast<PrimaryCPICHTXPower*>(items[1]) = primaryCPICHTXPower; }
	void setCellInfoSIECN0ModeSpecificInfoFddReadSFNIndicator(const CellInfoSIECN0ModeSpecificInfoFddReadSFNIndicator& cellInfoSIECN0ModeSpecificInfoFddReadSFNIndicator) { *static_cast<CellInfoSIECN0ModeSpecificInfoFddReadSFNIndicator*>(items[2]) = cellInfoSIECN0ModeSpecificInfoFddReadSFNIndicator; }
	void setCellInfoSIECN0ModeSpecificInfoFddTxDiversityIndicator(const CellInfoSIECN0ModeSpecificInfoFddTxDiversityIndicator& cellInfoSIECN0ModeSpecificInfoFddTxDiversityIndicator) { *static_cast<CellInfoSIECN0ModeSpecificInfoFddTxDiversityIndicator*>(items[3]) = cellInfoSIECN0ModeSpecificInfoFddTxDiversityIndicator; }
};

typedef Boolean CellInfoSIECN0ModeSpecificInfoTddReadSFNIndicator;

class CellInfoSIECN0ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellInfoSIECN0ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setPrimaryCCPCHInfo(const PrimaryCCPCHInfo& primaryCCPCHInfo) { *static_cast<PrimaryCCPCHInfo*>(items[0]) = primaryCCPCHInfo; }
	void setPrimaryCCPCHTXPower(const PrimaryCCPCHTXPower& primaryCCPCHTXPower) { *static_cast<PrimaryCCPCHTXPower*>(items[1]) = primaryCCPCHTXPower; }
	void setTimeslotInfoList(const TimeslotInfoList& timeslotInfoList) { *static_cast<TimeslotInfoList*>(items[2]) = timeslotInfoList; }
	void setCellInfoSIECN0ModeSpecificInfoTddReadSFNIndicator(const CellInfoSIECN0ModeSpecificInfoTddReadSFNIndicator& cellInfoSIECN0ModeSpecificInfoTddReadSFNIndicator) { *static_cast<CellInfoSIECN0ModeSpecificInfoTddReadSFNIndicator*>(items[3]) = cellInfoSIECN0ModeSpecificInfoTddReadSFNIndicator; }
};

class CellInfoSIECN0ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CellInfoSIECN0ModeSpecificInfoChoices {
		cellInfoSIECN0ModeSpecificInfoFdd = 0,
		cellInfoSIECN0ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	CellInfoSIECN0ModeSpecificInfo(): Choice(&theInfo) {}
};

class CellSelectReselectInfoSIB1112ECN0ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB1112ECN0ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setQQualMin(const QQualMin& qQualMin) { *static_cast<QQualMin*>(items[0]) = qQualMin; }
	void setQRxlevMin(const QRxlevMin& qRxlevMin) { *static_cast<QRxlevMin*>(items[1]) = qRxlevMin; }
};

class CellSelectReselectInfoSIB1112ECN0ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB1112ECN0ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setQRxlevMin(const QRxlevMin& qRxlevMin) { *static_cast<QRxlevMin*>(items[0]) = qRxlevMin; }
};

class CellSelectReselectInfoSIB1112ECN0ModeSpecificInfoGsm : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB1112ECN0ModeSpecificInfoGsm(): Sequence(&theInfo) {}

	void setQRxlevMin(const QRxlevMin& qRxlevMin) { *static_cast<QRxlevMin*>(items[0]) = qRxlevMin; }
};

class CellSelectReselectInfoSIB1112ECN0ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum CellSelectReselectInfoSIB1112ECN0ModeSpecificInfoChoices {
		cellSelectReselectInfoSIB1112ECN0ModeSpecificInfoFdd = 0,
		cellSelectReselectInfoSIB1112ECN0ModeSpecificInfoTdd = 1,
		cellSelectReselectInfoSIB1112ECN0ModeSpecificInfoGsm = 2,
	};
	static const Info theInfo;
	CellSelectReselectInfoSIB1112ECN0ModeSpecificInfo(): Choice(&theInfo) {}
};

class CellSelectReselectInfoSIB1112ECN0 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB1112ECN0(): Sequence(&theInfo) {}

	void setQOffset1SN(const QOffsetSN& qOffset1SN) { *static_cast<QOffsetSN*>(items[0]) = qOffset1SN; }
	void setQOffset2SN(const QOffsetSN& qOffset2SN) { *static_cast<QOffsetSN*>(items[1]) = qOffset2SN; }
	void setMaxAllowedULTXPower(const MaxAllowedULTXPower& maxAllowedULTXPower) { *static_cast<MaxAllowedULTXPower*>(items[2]) = maxAllowedULTXPower; }
	void setCellSelectReselectInfoSIB1112ECN0ModeSpecificInfo(const CellSelectReselectInfoSIB1112ECN0ModeSpecificInfo& cellSelectReselectInfoSIB1112ECN0ModeSpecificInfo) { *static_cast<CellSelectReselectInfoSIB1112ECN0ModeSpecificInfo*>(items[3]) = cellSelectReselectInfoSIB1112ECN0ModeSpecificInfo; }
};

class CellInfoSIECN0 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellInfoSIECN0(): Sequence(&theInfo) {}

	void setCellIndividualOffset(const CellIndividualOffset& cellIndividualOffset) { *static_cast<CellIndividualOffset*>(items[0]) = cellIndividualOffset; }
	void setReferenceTimeDifferenceToCell(const ReferenceTimeDifferenceToCell& referenceTimeDifferenceToCell) { *static_cast<ReferenceTimeDifferenceToCell*>(items[1]) = referenceTimeDifferenceToCell; }
	void setCellInfoSIECN0ModeSpecificInfo(const CellInfoSIECN0ModeSpecificInfo& cellInfoSIECN0ModeSpecificInfo) { *static_cast<CellInfoSIECN0ModeSpecificInfo*>(items[2]) = cellInfoSIECN0ModeSpecificInfo; }
	void setCellSelectionReselectionInfo(const CellSelectReselectInfoSIB1112ECN0& cellSelectionReselectionInfo) { *static_cast<CellSelectReselectInfoSIB1112ECN0*>(items[3]) = cellSelectionReselectionInfo; }
};

typedef Boolean CellInfoSIECN0LCRr4ReadSFNIndicator;

class CellInfoSIECN0LCRr4 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	CellInfoSIECN0LCRr4(): Sequence(&theInfo) {}

	void setCellIndividualOffset(const CellIndividualOffset& cellIndividualOffset) { *static_cast<CellIndividualOffset*>(items[0]) = cellIndividualOffset; }
	void setReferenceTimeDifferenceToCell(const ReferenceTimeDifferenceToCell& referenceTimeDifferenceToCell) { *static_cast<ReferenceTimeDifferenceToCell*>(items[1]) = referenceTimeDifferenceToCell; }
	void setPrimaryCCPCHInfo(const PrimaryCCPCHInfoLCRr4& primaryCCPCHInfo) { *static_cast<PrimaryCCPCHInfoLCRr4*>(items[2]) = primaryCCPCHInfo; }
	void setPrimaryCCPCHTXPower(const PrimaryCCPCHTXPower& primaryCCPCHTXPower) { *static_cast<PrimaryCCPCHTXPower*>(items[3]) = primaryCCPCHTXPower; }
	void setTimeslotInfoList(const TimeslotInfoListLCRr4& timeslotInfoList) { *static_cast<TimeslotInfoListLCRr4*>(items[4]) = timeslotInfoList; }
	void setCellInfoSIECN0LCRr4ReadSFNIndicator(const CellInfoSIECN0LCRr4ReadSFNIndicator& cellInfoSIECN0LCRr4ReadSFNIndicator) { *static_cast<CellInfoSIECN0LCRr4ReadSFNIndicator*>(items[5]) = cellInfoSIECN0LCRr4ReadSFNIndicator; }
	void setCellSelectionReselectionInfo(const CellSelectReselectInfoSIB1112ECN0& cellSelectionReselectionInfo) { *static_cast<CellSelectReselectInfoSIB1112ECN0*>(items[6]) = cellSelectionReselectionInfo; }
};

typedef Boolean CellInfoSIHCSRSCPModeSpecificInfoFddReadSFNIndicator;

typedef Boolean CellInfoSIHCSRSCPModeSpecificInfoFddTxDiversityIndicator;

class CellInfoSIHCSRSCPModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellInfoSIHCSRSCPModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setPrimaryCPICHTXPower(const PrimaryCPICHTXPower& primaryCPICHTXPower) { *static_cast<PrimaryCPICHTXPower*>(items[1]) = primaryCPICHTXPower; }
	void setCellInfoSIHCSRSCPModeSpecificInfoFddReadSFNIndicator(const CellInfoSIHCSRSCPModeSpecificInfoFddReadSFNIndicator& cellInfoSIHCSRSCPModeSpecificInfoFddReadSFNIndicator) { *static_cast<CellInfoSIHCSRSCPModeSpecificInfoFddReadSFNIndicator*>(items[2]) = cellInfoSIHCSRSCPModeSpecificInfoFddReadSFNIndicator; }
	void setCellInfoSIHCSRSCPModeSpecificInfoFddTxDiversityIndicator(const CellInfoSIHCSRSCPModeSpecificInfoFddTxDiversityIndicator& cellInfoSIHCSRSCPModeSpecificInfoFddTxDiversityIndicator) { *static_cast<CellInfoSIHCSRSCPModeSpecificInfoFddTxDiversityIndicator*>(items[3]) = cellInfoSIHCSRSCPModeSpecificInfoFddTxDiversityIndicator; }
};

typedef Boolean CellInfoSIHCSRSCPModeSpecificInfoTddReadSFNIndicator;

class CellInfoSIHCSRSCPModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellInfoSIHCSRSCPModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setPrimaryCCPCHInfo(const PrimaryCCPCHInfo& primaryCCPCHInfo) { *static_cast<PrimaryCCPCHInfo*>(items[0]) = primaryCCPCHInfo; }
	void setPrimaryCCPCHTXPower(const PrimaryCCPCHTXPower& primaryCCPCHTXPower) { *static_cast<PrimaryCCPCHTXPower*>(items[1]) = primaryCCPCHTXPower; }
	void setTimeslotInfoList(const TimeslotInfoList& timeslotInfoList) { *static_cast<TimeslotInfoList*>(items[2]) = timeslotInfoList; }
	void setCellInfoSIHCSRSCPModeSpecificInfoTddReadSFNIndicator(const CellInfoSIHCSRSCPModeSpecificInfoTddReadSFNIndicator& cellInfoSIHCSRSCPModeSpecificInfoTddReadSFNIndicator) { *static_cast<CellInfoSIHCSRSCPModeSpecificInfoTddReadSFNIndicator*>(items[3]) = cellInfoSIHCSRSCPModeSpecificInfoTddReadSFNIndicator; }
};

class CellInfoSIHCSRSCPModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CellInfoSIHCSRSCPModeSpecificInfoChoices {
		cellInfoSIHCSRSCPModeSpecificInfoFdd = 0,
		cellInfoSIHCSRSCPModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	CellInfoSIHCSRSCPModeSpecificInfo(): Choice(&theInfo) {}
};

class CellSelectReselectInfoSIB1112HCSRSCPModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB1112HCSRSCPModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setQQualMin(const QQualMin& qQualMin) { *static_cast<QQualMin*>(items[0]) = qQualMin; }
	void setQRxlevMin(const QRxlevMin& qRxlevMin) { *static_cast<QRxlevMin*>(items[1]) = qRxlevMin; }
};

class CellSelectReselectInfoSIB1112HCSRSCPModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB1112HCSRSCPModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setQRxlevMin(const QRxlevMin& qRxlevMin) { *static_cast<QRxlevMin*>(items[0]) = qRxlevMin; }
};

class CellSelectReselectInfoSIB1112HCSRSCPModeSpecificInfoGsm : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB1112HCSRSCPModeSpecificInfoGsm(): Sequence(&theInfo) {}

	void setQRxlevMin(const QRxlevMin& qRxlevMin) { *static_cast<QRxlevMin*>(items[0]) = qRxlevMin; }
};

class CellSelectReselectInfoSIB1112HCSRSCPModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum CellSelectReselectInfoSIB1112HCSRSCPModeSpecificInfoChoices {
		cellSelectReselectInfoSIB1112HCSRSCPModeSpecificInfoFdd = 0,
		cellSelectReselectInfoSIB1112HCSRSCPModeSpecificInfoTdd = 1,
		cellSelectReselectInfoSIB1112HCSRSCPModeSpecificInfoGsm = 2,
	};
	static const Info theInfo;
	CellSelectReselectInfoSIB1112HCSRSCPModeSpecificInfo(): Choice(&theInfo) {}
};

class CellSelectReselectInfoSIB1112HCSRSCP : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB1112HCSRSCP(): Sequence(&theInfo) {}

	void setQOffsetSN(const QOffsetSN& qOffsetSN) { *static_cast<QOffsetSN*>(items[0]) = qOffsetSN; }
	void setMaxAllowedULTXPower(const MaxAllowedULTXPower& maxAllowedULTXPower) { *static_cast<MaxAllowedULTXPower*>(items[1]) = maxAllowedULTXPower; }
	void setHcsNeighbouringCellInformationRSCP(const HCSNeighbouringCellInformationRSCP& hcsNeighbouringCellInformationRSCP) { *static_cast<HCSNeighbouringCellInformationRSCP*>(items[2]) = hcsNeighbouringCellInformationRSCP; }
	void setCellSelectReselectInfoSIB1112HCSRSCPModeSpecificInfo(const CellSelectReselectInfoSIB1112HCSRSCPModeSpecificInfo& cellSelectReselectInfoSIB1112HCSRSCPModeSpecificInfo) { *static_cast<CellSelectReselectInfoSIB1112HCSRSCPModeSpecificInfo*>(items[3]) = cellSelectReselectInfoSIB1112HCSRSCPModeSpecificInfo; }
};

class CellInfoSIHCSRSCP : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellInfoSIHCSRSCP(): Sequence(&theInfo) {}

	void setCellIndividualOffset(const CellIndividualOffset& cellIndividualOffset) { *static_cast<CellIndividualOffset*>(items[0]) = cellIndividualOffset; }
	void setReferenceTimeDifferenceToCell(const ReferenceTimeDifferenceToCell& referenceTimeDifferenceToCell) { *static_cast<ReferenceTimeDifferenceToCell*>(items[1]) = referenceTimeDifferenceToCell; }
	void setCellInfoSIHCSRSCPModeSpecificInfo(const CellInfoSIHCSRSCPModeSpecificInfo& cellInfoSIHCSRSCPModeSpecificInfo) { *static_cast<CellInfoSIHCSRSCPModeSpecificInfo*>(items[2]) = cellInfoSIHCSRSCPModeSpecificInfo; }
	void setCellSelectionReselectionInfo(const CellSelectReselectInfoSIB1112HCSRSCP& cellSelectionReselectionInfo) { *static_cast<CellSelectReselectInfoSIB1112HCSRSCP*>(items[3]) = cellSelectionReselectionInfo; }
};

typedef Boolean CellInfoSIHCSRSCPLCRr4ReadSFNIndicator;

class CellInfoSIHCSRSCPLCRr4 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	CellInfoSIHCSRSCPLCRr4(): Sequence(&theInfo) {}

	void setCellIndividualOffset(const CellIndividualOffset& cellIndividualOffset) { *static_cast<CellIndividualOffset*>(items[0]) = cellIndividualOffset; }
	void setReferenceTimeDifferenceToCell(const ReferenceTimeDifferenceToCell& referenceTimeDifferenceToCell) { *static_cast<ReferenceTimeDifferenceToCell*>(items[1]) = referenceTimeDifferenceToCell; }
	void setPrimaryCCPCHInfo(const PrimaryCCPCHInfoLCRr4& primaryCCPCHInfo) { *static_cast<PrimaryCCPCHInfoLCRr4*>(items[2]) = primaryCCPCHInfo; }
	void setPrimaryCCPCHTXPower(const PrimaryCCPCHTXPower& primaryCCPCHTXPower) { *static_cast<PrimaryCCPCHTXPower*>(items[3]) = primaryCCPCHTXPower; }
	void setTimeslotInfoList(const TimeslotInfoListLCRr4& timeslotInfoList) { *static_cast<TimeslotInfoListLCRr4*>(items[4]) = timeslotInfoList; }
	void setCellInfoSIHCSRSCPLCRr4ReadSFNIndicator(const CellInfoSIHCSRSCPLCRr4ReadSFNIndicator& cellInfoSIHCSRSCPLCRr4ReadSFNIndicator) { *static_cast<CellInfoSIHCSRSCPLCRr4ReadSFNIndicator*>(items[5]) = cellInfoSIHCSRSCPLCRr4ReadSFNIndicator; }
	void setCellSelectionReselectionInfo(const CellSelectReselectInfoSIB1112HCSRSCP& cellSelectionReselectionInfo) { *static_cast<CellSelectReselectInfoSIB1112HCSRSCP*>(items[6]) = cellSelectionReselectionInfo; }
};

typedef Boolean CellInfoSIHCSECN0ModeSpecificInfoFddReadSFNIndicator;

typedef Boolean CellInfoSIHCSECN0ModeSpecificInfoFddTxDiversityIndicator;

class CellInfoSIHCSECN0ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellInfoSIHCSECN0ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setPrimaryCPICHTXPower(const PrimaryCPICHTXPower& primaryCPICHTXPower) { *static_cast<PrimaryCPICHTXPower*>(items[1]) = primaryCPICHTXPower; }
	void setCellInfoSIHCSECN0ModeSpecificInfoFddReadSFNIndicator(const CellInfoSIHCSECN0ModeSpecificInfoFddReadSFNIndicator& cellInfoSIHCSECN0ModeSpecificInfoFddReadSFNIndicator) { *static_cast<CellInfoSIHCSECN0ModeSpecificInfoFddReadSFNIndicator*>(items[2]) = cellInfoSIHCSECN0ModeSpecificInfoFddReadSFNIndicator; }
	void setCellInfoSIHCSECN0ModeSpecificInfoFddTxDiversityIndicator(const CellInfoSIHCSECN0ModeSpecificInfoFddTxDiversityIndicator& cellInfoSIHCSECN0ModeSpecificInfoFddTxDiversityIndicator) { *static_cast<CellInfoSIHCSECN0ModeSpecificInfoFddTxDiversityIndicator*>(items[3]) = cellInfoSIHCSECN0ModeSpecificInfoFddTxDiversityIndicator; }
};

typedef Boolean CellInfoSIHCSECN0ModeSpecificInfoTddReadSFNIndicator;

class CellInfoSIHCSECN0ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellInfoSIHCSECN0ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setPrimaryCCPCHInfo(const PrimaryCCPCHInfo& primaryCCPCHInfo) { *static_cast<PrimaryCCPCHInfo*>(items[0]) = primaryCCPCHInfo; }
	void setPrimaryCCPCHTXPower(const PrimaryCCPCHTXPower& primaryCCPCHTXPower) { *static_cast<PrimaryCCPCHTXPower*>(items[1]) = primaryCCPCHTXPower; }
	void setTimeslotInfoList(const TimeslotInfoList& timeslotInfoList) { *static_cast<TimeslotInfoList*>(items[2]) = timeslotInfoList; }
	void setCellInfoSIHCSECN0ModeSpecificInfoTddReadSFNIndicator(const CellInfoSIHCSECN0ModeSpecificInfoTddReadSFNIndicator& cellInfoSIHCSECN0ModeSpecificInfoTddReadSFNIndicator) { *static_cast<CellInfoSIHCSECN0ModeSpecificInfoTddReadSFNIndicator*>(items[3]) = cellInfoSIHCSECN0ModeSpecificInfoTddReadSFNIndicator; }
};

class CellInfoSIHCSECN0ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CellInfoSIHCSECN0ModeSpecificInfoChoices {
		cellInfoSIHCSECN0ModeSpecificInfoFdd = 0,
		cellInfoSIHCSECN0ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	CellInfoSIHCSECN0ModeSpecificInfo(): Choice(&theInfo) {}
};

typedef Null PenaltyTimeECN0NotUsed;

enum TemporaryOffset2Values {
	to2_TemporaryOffset2 = 0,
	to3_TemporaryOffset2 = 1,
	to4_TemporaryOffset2 = 2,
	to6_TemporaryOffset2 = 3,
	to8_TemporaryOffset2 = 4,
	to10_TemporaryOffset2 = 5,
	to12_TemporaryOffset2 = 6,
	infinite_TemporaryOffset2 = 7,
};
typedef Enumerated<CONSTRAINED, 7> TemporaryOffset2;

class TemporaryOffsetList : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	TemporaryOffsetList(): Sequence(&theInfo) {}

	void setTemporaryOffset1(const TemporaryOffset1& temporaryOffset1) { *static_cast<TemporaryOffset1*>(items[0]) = temporaryOffset1; }
	void setTemporaryOffset2(const TemporaryOffset2& temporaryOffset2) { *static_cast<TemporaryOffset2*>(items[1]) = temporaryOffset2; }
};

class PenaltyTimeECN0 : public Choice {
private:
	static const void *choicesInfo[7];
public:
	enum PenaltyTimeECN0Choices {
		penaltyTimeECN0NotUsed = 0,
		pt10 = 1,
		pt20 = 2,
		pt30 = 3,
		pt40 = 4,
		pt50 = 5,
		pt60 = 6,
	};
	static const Info theInfo;
	PenaltyTimeECN0(): Choice(&theInfo) {}
};

class HCSCellReselectInformationECN0 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	HCSCellReselectInformationECN0(): Sequence(&theInfo) {}

	void setPenaltyTime(const PenaltyTimeECN0& penaltyTime) { *static_cast<PenaltyTimeECN0*>(items[0]) = penaltyTime; }
};

class HCSNeighbouringCellInformationECN0 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	HCSNeighbouringCellInformationECN0(): Sequence(&theInfo) {}

	void setHcsPRIO(const HCSPRIO& hcsPRIO) { *static_cast<HCSPRIO*>(items[0]) = hcsPRIO; }
	void setQHCS(const QHCS& qHCS) { *static_cast<QHCS*>(items[1]) = qHCS; }
	void setHcsCellReselectInformation(const HCSCellReselectInformationECN0& hcsCellReselectInformation) { *static_cast<HCSCellReselectInformationECN0*>(items[2]) = hcsCellReselectInformation; }
};

class CellSelectReselectInfoSIB1112HCSECN0ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB1112HCSECN0ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setQQualMin(const QQualMin& qQualMin) { *static_cast<QQualMin*>(items[0]) = qQualMin; }
	void setQRxlevMin(const QRxlevMin& qRxlevMin) { *static_cast<QRxlevMin*>(items[1]) = qRxlevMin; }
};

class CellSelectReselectInfoSIB1112HCSECN0ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB1112HCSECN0ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setQRxlevMin(const QRxlevMin& qRxlevMin) { *static_cast<QRxlevMin*>(items[0]) = qRxlevMin; }
};

class CellSelectReselectInfoSIB1112HCSECN0ModeSpecificInfoGsm : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB1112HCSECN0ModeSpecificInfoGsm(): Sequence(&theInfo) {}

	void setQRxlevMin(const QRxlevMin& qRxlevMin) { *static_cast<QRxlevMin*>(items[0]) = qRxlevMin; }
};

class CellSelectReselectInfoSIB1112HCSECN0ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum CellSelectReselectInfoSIB1112HCSECN0ModeSpecificInfoChoices {
		cellSelectReselectInfoSIB1112HCSECN0ModeSpecificInfoFdd = 0,
		cellSelectReselectInfoSIB1112HCSECN0ModeSpecificInfoTdd = 1,
		cellSelectReselectInfoSIB1112HCSECN0ModeSpecificInfoGsm = 2,
	};
	static const Info theInfo;
	CellSelectReselectInfoSIB1112HCSECN0ModeSpecificInfo(): Choice(&theInfo) {}
};

class CellSelectReselectInfoSIB1112HCSECN0 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB1112HCSECN0(): Sequence(&theInfo) {}

	void setQOffset1SN(const QOffsetSN& qOffset1SN) { *static_cast<QOffsetSN*>(items[0]) = qOffset1SN; }
	void setQOffset2SN(const QOffsetSN& qOffset2SN) { *static_cast<QOffsetSN*>(items[1]) = qOffset2SN; }
	void setMaxAllowedULTXPower(const MaxAllowedULTXPower& maxAllowedULTXPower) { *static_cast<MaxAllowedULTXPower*>(items[2]) = maxAllowedULTXPower; }
	void setHcsNeighbouringCellInformationECN0(const HCSNeighbouringCellInformationECN0& hcsNeighbouringCellInformationECN0) { *static_cast<HCSNeighbouringCellInformationECN0*>(items[3]) = hcsNeighbouringCellInformationECN0; }
	void setCellSelectReselectInfoSIB1112HCSECN0ModeSpecificInfo(const CellSelectReselectInfoSIB1112HCSECN0ModeSpecificInfo& cellSelectReselectInfoSIB1112HCSECN0ModeSpecificInfo) { *static_cast<CellSelectReselectInfoSIB1112HCSECN0ModeSpecificInfo*>(items[4]) = cellSelectReselectInfoSIB1112HCSECN0ModeSpecificInfo; }
};

class CellInfoSIHCSECN0 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellInfoSIHCSECN0(): Sequence(&theInfo) {}

	void setCellIndividualOffset(const CellIndividualOffset& cellIndividualOffset) { *static_cast<CellIndividualOffset*>(items[0]) = cellIndividualOffset; }
	void setReferenceTimeDifferenceToCell(const ReferenceTimeDifferenceToCell& referenceTimeDifferenceToCell) { *static_cast<ReferenceTimeDifferenceToCell*>(items[1]) = referenceTimeDifferenceToCell; }
	void setCellInfoSIHCSECN0ModeSpecificInfo(const CellInfoSIHCSECN0ModeSpecificInfo& cellInfoSIHCSECN0ModeSpecificInfo) { *static_cast<CellInfoSIHCSECN0ModeSpecificInfo*>(items[2]) = cellInfoSIHCSECN0ModeSpecificInfo; }
	void setCellSelectionReselectionInfo(const CellSelectReselectInfoSIB1112HCSECN0& cellSelectionReselectionInfo) { *static_cast<CellSelectReselectInfoSIB1112HCSECN0*>(items[3]) = cellSelectionReselectionInfo; }
};

typedef Boolean CellInfoSIHCSECN0LCRr4ReadSFNIndicator;

class CellInfoSIHCSECN0LCRr4 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	CellInfoSIHCSECN0LCRr4(): Sequence(&theInfo) {}

	void setCellIndividualOffset(const CellIndividualOffset& cellIndividualOffset) { *static_cast<CellIndividualOffset*>(items[0]) = cellIndividualOffset; }
	void setReferenceTimeDifferenceToCell(const ReferenceTimeDifferenceToCell& referenceTimeDifferenceToCell) { *static_cast<ReferenceTimeDifferenceToCell*>(items[1]) = referenceTimeDifferenceToCell; }
	void setPrimaryCCPCHInfo(const PrimaryCCPCHInfoLCRr4& primaryCCPCHInfo) { *static_cast<PrimaryCCPCHInfoLCRr4*>(items[2]) = primaryCCPCHInfo; }
	void setPrimaryCCPCHTXPower(const PrimaryCCPCHTXPower& primaryCCPCHTXPower) { *static_cast<PrimaryCCPCHTXPower*>(items[3]) = primaryCCPCHTXPower; }
	void setTimeslotInfoList(const TimeslotInfoListLCRr4& timeslotInfoList) { *static_cast<TimeslotInfoListLCRr4*>(items[4]) = timeslotInfoList; }
	void setCellInfoSIHCSECN0LCRr4ReadSFNIndicator(const CellInfoSIHCSECN0LCRr4ReadSFNIndicator& cellInfoSIHCSECN0LCRr4ReadSFNIndicator) { *static_cast<CellInfoSIHCSECN0LCRr4ReadSFNIndicator*>(items[5]) = cellInfoSIHCSECN0LCRr4ReadSFNIndicator; }
	void setCellSelectionReselectionInfo(const CellSelectReselectInfoSIB1112HCSECN0& cellSelectionReselectionInfo) { *static_cast<CellSelectReselectInfoSIB1112HCSECN0*>(items[6]) = cellSelectionReselectionInfo; }
};

typedef Integer<CONSTRAINED, 0, 16777215> SFNSFNObsTimeDifference1;

typedef Integer<CONSTRAINED, 0, 65535> SFNSFNObsTimeDifference2;

class SFNSFNObsTimeDifference : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum SFNSFNObsTimeDifferenceChoices {
		type1 = 0,
		type2 = 1,
	};
	static const Info theInfo;
	SFNSFNObsTimeDifference(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 15> CountCSFNFramedifferenceCountCSFNHigh;

typedef Integer<CONSTRAINED, 0, 255> CountCSFNFramedifferenceOff;

class CountCSFNFramedifference : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CountCSFNFramedifference(): Sequence(&theInfo) {}

	void setCountCSFNFramedifferenceCountCSFNHigh(const CountCSFNFramedifferenceCountCSFNHigh& countCSFNFramedifferenceCountCSFNHigh) { *static_cast<CountCSFNFramedifferenceCountCSFNHigh*>(items[0]) = countCSFNFramedifferenceCountCSFNHigh; }
	void setCountCSFNFramedifferenceOff(const CountCSFNFramedifferenceOff& countCSFNFramedifferenceOff) { *static_cast<CountCSFNFramedifferenceOff*>(items[1]) = countCSFNFramedifferenceOff; }
};

typedef Integer<CONSTRAINED, 0, 38399> CellSynchronisationInfoModeSpecificInfoFddTm;

class CellSynchronisationInfoModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CellSynchronisationInfoModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setCountCSFNFramedifference(const CountCSFNFramedifference& countCSFNFramedifference) { *static_cast<CountCSFNFramedifference*>(items[0]) = countCSFNFramedifference; }
	void setCellSynchronisationInfoModeSpecificInfoFddTm(const CellSynchronisationInfoModeSpecificInfoFddTm& cellSynchronisationInfoModeSpecificInfoFddTm) { *static_cast<CellSynchronisationInfoModeSpecificInfoFddTm*>(items[1]) = cellSynchronisationInfoModeSpecificInfoFddTm; }
};

class CellSynchronisationInfoModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CellSynchronisationInfoModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setCountCSFNFramedifference(const CountCSFNFramedifference& countCSFNFramedifference) { *static_cast<CountCSFNFramedifference*>(items[0]) = countCSFNFramedifference; }
};

class CellSynchronisationInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CellSynchronisationInfoModeSpecificInfoChoices {
		cellSynchronisationInfoModeSpecificInfoFdd = 0,
		cellSynchronisationInfoModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	CellSynchronisationInfoModeSpecificInfo(): Choice(&theInfo) {}
};

class CellSynchronisationInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CellSynchronisationInfo(): Sequence(&theInfo) {}

	void setCellSynchronisationInfoModeSpecificInfo(const CellSynchronisationInfoModeSpecificInfo& cellSynchronisationInfoModeSpecificInfo) { *static_cast<CellSynchronisationInfoModeSpecificInfo*>(items[0]) = cellSynchronisationInfoModeSpecificInfo; }
};

typedef Integer<CONSTRAINED, 0, 63> CPICHEcN0;

typedef Integer<CONSTRAINED, 0, 127> CPICHRSCP;

typedef Integer<CONSTRAINED, 46, 173> Pathloss;

class CellMeasuredResultsModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellMeasuredResultsModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setCpichEcN0(const CPICHEcN0& cpichEcN0) { *static_cast<CPICHEcN0*>(items[1]) = cpichEcN0; }
	void setCpichRSCP(const CPICHRSCP& cpichRSCP) { *static_cast<CPICHRSCP*>(items[2]) = cpichRSCP; }
	void setPathloss(const Pathloss& pathloss) { *static_cast<Pathloss*>(items[3]) = pathloss; }
};

typedef Integer<CONSTRAINED, 0, 127> PrimaryCCPCHRSCP;

typedef Integer<CONSTRAINED, 0, 127> TimeslotISCP;

typedef SequenceOf<TimeslotISCP, CONSTRAINED, 1, maxTS> TimeslotISCPList;

class CellMeasuredResultsModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	CellMeasuredResultsModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setCellParametersID(const CellParametersID& cellParametersID) { *static_cast<CellParametersID*>(items[0]) = cellParametersID; }
	void setProposedTGSN(const TGSN& proposedTGSN) { *static_cast<TGSN*>(items[1]) = proposedTGSN; }
	void setPrimaryCCPCHRSCP(const PrimaryCCPCHRSCP& primaryCCPCHRSCP) { *static_cast<PrimaryCCPCHRSCP*>(items[2]) = primaryCCPCHRSCP; }
	void setPathloss(const Pathloss& pathloss) { *static_cast<Pathloss*>(items[3]) = pathloss; }
	void setTimeslotISCPList(const TimeslotISCPList& timeslotISCPList) { *static_cast<TimeslotISCPList*>(items[4]) = timeslotISCPList; }
};

class CellMeasuredResultsModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CellMeasuredResultsModeSpecificInfoChoices {
		cellMeasuredResultsModeSpecificInfoFdd = 0,
		cellMeasuredResultsModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	CellMeasuredResultsModeSpecificInfo(): Choice(&theInfo) {}
};

class CellMeasuredResults : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellMeasuredResults(): Sequence(&theInfo) {}

	void setCellIdentity(const CellIdentity& cellIdentity) { *static_cast<CellIdentity*>(items[0]) = cellIdentity; }
	void setDummy(const SFNSFNObsTimeDifference& dummy) { *static_cast<SFNSFNObsTimeDifference*>(items[1]) = dummy; }
	void setCellSynchronisationInfo(const CellSynchronisationInfo& cellSynchronisationInfo) { *static_cast<CellSynchronisationInfo*>(items[2]) = cellSynchronisationInfo; }
	void setCellMeasuredResultsModeSpecificInfo(const CellMeasuredResultsModeSpecificInfo& cellMeasuredResultsModeSpecificInfo) { *static_cast<CellMeasuredResultsModeSpecificInfo*>(items[3]) = cellMeasuredResultsModeSpecificInfo; }
};

typedef Integer<CONSTRAINED, -5, -1> DeltaRSCP;

class DeltaRSCPPerCell : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DeltaRSCPPerCell(): Sequence(&theInfo) {}

	void setDeltaRSCP(const DeltaRSCP& deltaRSCP) { *static_cast<DeltaRSCP*>(items[0]) = deltaRSCP; }
};

class CellMeasuredResultsr9ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	CellMeasuredResultsr9ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setCpichEcN0(const CPICHEcN0& cpichEcN0) { *static_cast<CPICHEcN0*>(items[1]) = cpichEcN0; }
	void setCpichRSCP(const CPICHRSCP& cpichRSCP) { *static_cast<CPICHRSCP*>(items[2]) = cpichRSCP; }
	void setDeltaRSCPPerCell(const DeltaRSCPPerCell& deltaRSCPPerCell) { *static_cast<DeltaRSCPPerCell*>(items[3]) = deltaRSCPPerCell; }
	void setPathloss(const Pathloss& pathloss) { *static_cast<Pathloss*>(items[4]) = pathloss; }
};

class CellMeasuredResultsr9ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	CellMeasuredResultsr9ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setCellParametersID(const CellParametersID& cellParametersID) { *static_cast<CellParametersID*>(items[0]) = cellParametersID; }
	void setProposedTGSN(const TGSN& proposedTGSN) { *static_cast<TGSN*>(items[1]) = proposedTGSN; }
	void setPrimaryCCPCHRSCP(const PrimaryCCPCHRSCP& primaryCCPCHRSCP) { *static_cast<PrimaryCCPCHRSCP*>(items[2]) = primaryCCPCHRSCP; }
	void setPathloss(const Pathloss& pathloss) { *static_cast<Pathloss*>(items[3]) = pathloss; }
	void setTimeslotISCPList(const TimeslotISCPList& timeslotISCPList) { *static_cast<TimeslotISCPList*>(items[4]) = timeslotISCPList; }
};

class CellMeasuredResultsr9ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CellMeasuredResultsr9ModeSpecificInfoChoices {
		cellMeasuredResultsr9ModeSpecificInfoFdd = 0,
		cellMeasuredResultsr9ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	CellMeasuredResultsr9ModeSpecificInfo(): Choice(&theInfo) {}
};

class CellMeasuredResultsr9 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CellMeasuredResultsr9(): Sequence(&theInfo) {}

	void setCellIdentity(const CellIdentity& cellIdentity) { *static_cast<CellIdentity*>(items[0]) = cellIdentity; }
	void setCellSynchronisationInfo(const CellSynchronisationInfo& cellSynchronisationInfo) { *static_cast<CellSynchronisationInfo*>(items[1]) = cellSynchronisationInfo; }
	void setCellMeasuredResultsr9ModeSpecificInfo(const CellMeasuredResultsr9ModeSpecificInfo& cellMeasuredResultsr9ModeSpecificInfo) { *static_cast<CellMeasuredResultsr9ModeSpecificInfo*>(items[2]) = cellMeasuredResultsr9ModeSpecificInfo; }
};

enum CellMeasuredResultsv920extcsgMemberIndicationValues {
	member_CellMeasuredResultsv920extcsgMemberIndication = 0,
};
typedef Enumerated<CONSTRAINED, 0> CellMeasuredResultsv920extcsgMemberIndication;

class CellMeasuredResultsv920ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CellMeasuredResultsv920ext(): Sequence(&theInfo) {}

	void setCsgIdentity(const CSGIdentity& csgIdentity) { *static_cast<CSGIdentity*>(items[0]) = csgIdentity; }
	void setCellMeasuredResultsv920extcsgMemberIndication(const CellMeasuredResultsv920extcsgMemberIndication& cellMeasuredResultsv920extcsgMemberIndication) { *static_cast<CellMeasuredResultsv920extcsgMemberIndication*>(items[1]) = cellMeasuredResultsv920extcsgMemberIndication; }
};

typedef SequenceOf<PrimaryCPICHInfo, CONSTRAINED, 1, maxCellMeas> CellMeasurementEventResultsFdd;

typedef SequenceOf<PrimaryCCPCHInfo, CONSTRAINED, 1, maxCellMeas> CellMeasurementEventResultsTdd;

class CellMeasurementEventResults : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CellMeasurementEventResultsChoices {
		cellMeasurementEventResultsFdd = 0,
		cellMeasurementEventResultsTdd = 1,
	};
	static const Info theInfo;
	CellMeasurementEventResults(): Choice(&theInfo) {}
};

typedef SequenceOf<PrimaryCPICHInfo, CONSTRAINED, 1,  maxCellMeasOnSecULFreq> CellMeasurementEventResultsOnSecUlFreqFdd;

typedef Null CellMeasurementEventResultsOnSecUlFreqSpare;

class CellMeasurementEventResultsOnSecUlFreq : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CellMeasurementEventResultsOnSecUlFreqChoices {
		cellMeasurementEventResultsOnSecUlFreqFdd = 0,
		cellMeasurementEventResultsOnSecUlFreqSpare = 1,
	};
	static const Info theInfo;
	CellMeasurementEventResultsOnSecUlFreq(): Choice(&theInfo) {}
};

typedef SequenceOf<PrimaryCCPCHInfoLCRr4, CONSTRAINED, 1, maxCellMeas> CellMeasurementEventResultsLCRr4;

enum SFNSFNOTDTypeValues {
	noReport_SFNSFNOTDType = 0,
	type1_SFNSFNOTDType = 1,
	type2_SFNSFNOTDType = 2,
};
typedef Enumerated<CONSTRAINED, 2> SFNSFNOTDType;

typedef Boolean CellReportingQuantitiesCellIdentityreportingIndicator;

typedef Boolean CellReportingQuantitiesCellSynchronisationInfoReportingIndicator;

typedef Boolean CellReportingQuantitiesModeSpecificInfoFddCpichEcN0reportingIndicator;

typedef Boolean CellReportingQuantitiesModeSpecificInfoFddCpichRSCPreportingIndicator;

typedef Boolean CellReportingQuantitiesModeSpecificInfoFddPathlossreportingIndicator;

class CellReportingQuantitiesModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	CellReportingQuantitiesModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setCellReportingQuantitiesModeSpecificInfoFddCpichEcN0reportingIndicator(const CellReportingQuantitiesModeSpecificInfoFddCpichEcN0reportingIndicator& cellReportingQuantitiesModeSpecificInfoFddCpichEcN0reportingIndicator) { *static_cast<CellReportingQuantitiesModeSpecificInfoFddCpichEcN0reportingIndicator*>(items[0]) = cellReportingQuantitiesModeSpecificInfoFddCpichEcN0reportingIndicator; }
	void setCellReportingQuantitiesModeSpecificInfoFddCpichRSCPreportingIndicator(const CellReportingQuantitiesModeSpecificInfoFddCpichRSCPreportingIndicator& cellReportingQuantitiesModeSpecificInfoFddCpichRSCPreportingIndicator) { *static_cast<CellReportingQuantitiesModeSpecificInfoFddCpichRSCPreportingIndicator*>(items[1]) = cellReportingQuantitiesModeSpecificInfoFddCpichRSCPreportingIndicator; }
	void setCellReportingQuantitiesModeSpecificInfoFddPathlossreportingIndicator(const CellReportingQuantitiesModeSpecificInfoFddPathlossreportingIndicator& cellReportingQuantitiesModeSpecificInfoFddPathlossreportingIndicator) { *static_cast<CellReportingQuantitiesModeSpecificInfoFddPathlossreportingIndicator*>(items[2]) = cellReportingQuantitiesModeSpecificInfoFddPathlossreportingIndicator; }
};

typedef Boolean CellReportingQuantitiesModeSpecificInfoTddTimeslotISCPreportingIndicator;

typedef Boolean CellReportingQuantitiesModeSpecificInfoTddProposedTGSNReportingRequired;

typedef Boolean CellReportingQuantitiesModeSpecificInfoTddPrimaryCCPCHRSCPreportingIndicator;

typedef Boolean CellReportingQuantitiesModeSpecificInfoTddPathlossreportingIndicator;

class CellReportingQuantitiesModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellReportingQuantitiesModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setCellReportingQuantitiesModeSpecificInfoTddTimeslotISCPreportingIndicator(const CellReportingQuantitiesModeSpecificInfoTddTimeslotISCPreportingIndicator& cellReportingQuantitiesModeSpecificInfoTddTimeslotISCPreportingIndicator) { *static_cast<CellReportingQuantitiesModeSpecificInfoTddTimeslotISCPreportingIndicator*>(items[0]) = cellReportingQuantitiesModeSpecificInfoTddTimeslotISCPreportingIndicator; }
	void setCellReportingQuantitiesModeSpecificInfoTddProposedTGSNReportingRequired(const CellReportingQuantitiesModeSpecificInfoTddProposedTGSNReportingRequired& cellReportingQuantitiesModeSpecificInfoTddProposedTGSNReportingRequired) { *static_cast<CellReportingQuantitiesModeSpecificInfoTddProposedTGSNReportingRequired*>(items[1]) = cellReportingQuantitiesModeSpecificInfoTddProposedTGSNReportingRequired; }
	void setCellReportingQuantitiesModeSpecificInfoTddPrimaryCCPCHRSCPreportingIndicator(const CellReportingQuantitiesModeSpecificInfoTddPrimaryCCPCHRSCPreportingIndicator& cellReportingQuantitiesModeSpecificInfoTddPrimaryCCPCHRSCPreportingIndicator) { *static_cast<CellReportingQuantitiesModeSpecificInfoTddPrimaryCCPCHRSCPreportingIndicator*>(items[2]) = cellReportingQuantitiesModeSpecificInfoTddPrimaryCCPCHRSCPreportingIndicator; }
	void setCellReportingQuantitiesModeSpecificInfoTddPathlossreportingIndicator(const CellReportingQuantitiesModeSpecificInfoTddPathlossreportingIndicator& cellReportingQuantitiesModeSpecificInfoTddPathlossreportingIndicator) { *static_cast<CellReportingQuantitiesModeSpecificInfoTddPathlossreportingIndicator*>(items[3]) = cellReportingQuantitiesModeSpecificInfoTddPathlossreportingIndicator; }
};

class CellReportingQuantitiesModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CellReportingQuantitiesModeSpecificInfoChoices {
		cellReportingQuantitiesModeSpecificInfoFdd = 0,
		cellReportingQuantitiesModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	CellReportingQuantitiesModeSpecificInfo(): Choice(&theInfo) {}
};

class CellReportingQuantities : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellReportingQuantities(): Sequence(&theInfo) {}

	void setDummy(const SFNSFNOTDType& dummy) { *static_cast<SFNSFNOTDType*>(items[0]) = dummy; }
	void setCellReportingQuantitiesCellIdentityreportingIndicator(const CellReportingQuantitiesCellIdentityreportingIndicator& cellReportingQuantitiesCellIdentityreportingIndicator) { *static_cast<CellReportingQuantitiesCellIdentityreportingIndicator*>(items[1]) = cellReportingQuantitiesCellIdentityreportingIndicator; }
	void setCellReportingQuantitiesCellSynchronisationInfoReportingIndicator(const CellReportingQuantitiesCellSynchronisationInfoReportingIndicator& cellReportingQuantitiesCellSynchronisationInfoReportingIndicator) { *static_cast<CellReportingQuantitiesCellSynchronisationInfoReportingIndicator*>(items[2]) = cellReportingQuantitiesCellSynchronisationInfoReportingIndicator; }
	void setCellReportingQuantitiesModeSpecificInfo(const CellReportingQuantitiesModeSpecificInfo& cellReportingQuantitiesModeSpecificInfo) { *static_cast<CellReportingQuantitiesModeSpecificInfo*>(items[3]) = cellReportingQuantitiesModeSpecificInfo; }
};

class CellSelectReselectInfoSIB1112ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB1112ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setQQualMin(const QQualMin& qQualMin) { *static_cast<QQualMin*>(items[0]) = qQualMin; }
	void setQRxlevMin(const QRxlevMin& qRxlevMin) { *static_cast<QRxlevMin*>(items[1]) = qRxlevMin; }
};

class CellSelectReselectInfoSIB1112ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB1112ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setQRxlevMin(const QRxlevMin& qRxlevMin) { *static_cast<QRxlevMin*>(items[0]) = qRxlevMin; }
};

class CellSelectReselectInfoSIB1112ModeSpecificInfoGsm : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB1112ModeSpecificInfoGsm(): Sequence(&theInfo) {}

	void setQRxlevMin(const QRxlevMin& qRxlevMin) { *static_cast<QRxlevMin*>(items[0]) = qRxlevMin; }
};

class CellSelectReselectInfoSIB1112ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum CellSelectReselectInfoSIB1112ModeSpecificInfoChoices {
		cellSelectReselectInfoSIB1112ModeSpecificInfoFdd = 0,
		cellSelectReselectInfoSIB1112ModeSpecificInfoTdd = 1,
		cellSelectReselectInfoSIB1112ModeSpecificInfoGsm = 2,
	};
	static const Info theInfo;
	CellSelectReselectInfoSIB1112ModeSpecificInfo(): Choice(&theInfo) {}
};

class CellSelectReselectInfoSIB1112 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	CellSelectReselectInfoSIB1112(): Sequence(&theInfo) {}

	void setQOffset1SN(const QOffsetSN& qOffset1SN) { *static_cast<QOffsetSN*>(items[0]) = qOffset1SN; }
	void setQOffset2SN(const QOffsetSN& qOffset2SN) { *static_cast<QOffsetSN*>(items[1]) = qOffset2SN; }
	void setMaxAllowedULTXPower(const MaxAllowedULTXPower& maxAllowedULTXPower) { *static_cast<MaxAllowedULTXPower*>(items[2]) = maxAllowedULTXPower; }
	void setHcsNeighbouringCellInformationRSCP(const HCSNeighbouringCellInformationRSCP& hcsNeighbouringCellInformationRSCP) { *static_cast<HCSNeighbouringCellInformationRSCP*>(items[3]) = hcsNeighbouringCellInformationRSCP; }
	void setCellSelectReselectInfoSIB1112ModeSpecificInfo(const CellSelectReselectInfoSIB1112ModeSpecificInfo& cellSelectReselectInfoSIB1112ModeSpecificInfo) { *static_cast<CellSelectReselectInfoSIB1112ModeSpecificInfo*>(items[4]) = cellSelectReselectInfoSIB1112ModeSpecificInfo; }
};

typedef Integer<CONSTRAINED, -2, -1> DeltaQrxlevmin;

class CellSelectReselectInfov590ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CellSelectReselectInfov590ext(): Sequence(&theInfo) {}

	void setDeltaQrxlevmin(const DeltaQrxlevmin& deltaQrxlevmin) { *static_cast<DeltaQrxlevmin*>(items[0]) = deltaQrxlevmin; }
	void setDeltaQhcs(const DeltaRSCP& deltaQhcs) { *static_cast<DeltaRSCP*>(items[1]) = deltaQhcs; }
};

class CellSelectReselectInfoPCHFACHv5b0ext : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	CellSelectReselectInfoPCHFACHv5b0ext(): Sequence(&theInfo) {}

	void setQHystlSPCH(const QHystSFine& qHystlSPCH) { *static_cast<QHystSFine*>(items[0]) = qHystlSPCH; }
	void setQHystlSFACH(const QHystSFine& qHystlSFACH) { *static_cast<QHystSFine*>(items[1]) = qHystlSFACH; }
	void setQHyst2SPCH(const QHystSFine& qHyst2SPCH) { *static_cast<QHystSFine*>(items[2]) = qHyst2SPCH; }
	void setQHyst2SFACH(const QHystSFine& qHyst2SFACH) { *static_cast<QHystSFine*>(items[3]) = qHyst2SFACH; }
	void setTReselectionSPCH(const TReselectionS& tReselectionSPCH) { *static_cast<TReselectionS*>(items[4]) = tReselectionSPCH; }
	void setTReselectionSFACH(const TReselectionSFine& tReselectionSFACH) { *static_cast<TReselectionSFine*>(items[5]) = tReselectionSFACH; }
};

class CellSelectReselectInfoTreselectionScalingv5c0ext : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	CellSelectReselectInfoTreselectionScalingv5c0ext(): Sequence(&theInfo) {}

	void setNonHCStCRMax(const TCRMax& nonHCStCRMax) { *static_cast<TCRMax*>(items[0]) = nonHCStCRMax; }
	void setSpeedDependentScalingFactor(const SpeedDependentScalingFactor& speedDependentScalingFactor) { *static_cast<SpeedDependentScalingFactor*>(items[1]) = speedDependentScalingFactor; }
	void setInterFrequencyTreselectionScalingFactor(const TreselectionScalingFactor& interFrequencyTreselectionScalingFactor) { *static_cast<TreselectionScalingFactor*>(items[2]) = interFrequencyTreselectionScalingFactor; }
	void setInterRATTreselectionScalingFactor(const TreselectionScalingFactor& interRATTreselectionScalingFactor) { *static_cast<TreselectionScalingFactor*>(items[3]) = interRATTreselectionScalingFactor; }
};

typedef Integer<CONSTRAINED, 0, maxCellMeas_1> InterFreqCellID;

typedef SequenceOf<InterFreqCellID, CONSTRAINED, 1, maxCellMeas> CellsForInterFreqMeasList;

typedef Integer<CONSTRAINED, 0, maxCellMeas_1> InterRATCellID;

typedef SequenceOf<InterRATCellID, CONSTRAINED, 1, maxCellMeas> CellsForInterRATMeasList;

typedef Integer<CONSTRAINED, 0, maxCellMeas_1> IntraFreqCellID;

typedef SequenceOf<IntraFreqCellID, CONSTRAINED, 1, maxCellMeas> CellsForIntraFreqMeasList;

typedef Integer<CONSTRAINED, 0, maxCellMeasOnSecULFreq_1> IntraFreqCellIDOnSecULFreq;

typedef SequenceOf<IntraFreqCellIDOnSecULFreq, CONSTRAINED, 1, maxCellMeasOnSecULFreq> CellsForIntraFreqMeasListOnSecULFreq;

class CellToReport : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CellToReport(): Sequence(&theInfo) {}

	void setBsicReported(const BSICReported& bsicReported) { *static_cast<BSICReported*>(items[0]) = bsicReported; }
};

typedef SequenceOf<CellToReport, CONSTRAINED, 1, maxCellMeas> CellToReportList;

typedef BitString<CONSTRAINED, 11, 11> CNAVclockModelCnavToc;

typedef BitString<CONSTRAINED, 11, 11> CNAVclockModelCnavTop;

typedef BitString<CONSTRAINED, 5, 5> CNAVclockModelCnavURA0;

typedef BitString<CONSTRAINED, 3, 3> CNAVclockModelCnavURA1;

typedef BitString<CONSTRAINED, 3, 3> CNAVclockModelCnavURA2;

typedef BitString<CONSTRAINED, 10, 10> CNAVclockModelCnavAf2;

typedef BitString<CONSTRAINED, 20, 20> CNAVclockModelCnavAf1;

typedef BitString<CONSTRAINED, 26, 26> CNAVclockModelCnavAf0;

typedef BitString<CONSTRAINED, 13, 13> CNAVclockModelCnavTgd;

typedef BitString<CONSTRAINED, 13, 13> CNAVclockModelCnavISCl1cp;

typedef BitString<CONSTRAINED, 13, 13> CNAVclockModelCnavISCl1cd;

typedef BitString<CONSTRAINED, 13, 13> CNAVclockModelCnavISCl1ca;

typedef BitString<CONSTRAINED, 13, 13> CNAVclockModelCnavISCl2c;

typedef BitString<CONSTRAINED, 13, 13> CNAVclockModelCnavISCl5i5;

typedef BitString<CONSTRAINED, 13, 13> CNAVclockModelCnavISCl5q5;

class CNAVclockModel : public Sequence {
private:
	static const void *itemsInfo[15];
	static bool itemsPres[15];
public:
	static const Info theInfo;
	CNAVclockModel(): Sequence(&theInfo) {}

	void setCNAVclockModelCnavToc(const CNAVclockModelCnavToc& cNAVclockModelCnavToc) { *static_cast<CNAVclockModelCnavToc*>(items[0]) = cNAVclockModelCnavToc; }
	void setCNAVclockModelCnavTop(const CNAVclockModelCnavTop& cNAVclockModelCnavTop) { *static_cast<CNAVclockModelCnavTop*>(items[1]) = cNAVclockModelCnavTop; }
	void setCNAVclockModelCnavURA0(const CNAVclockModelCnavURA0& cNAVclockModelCnavURA0) { *static_cast<CNAVclockModelCnavURA0*>(items[2]) = cNAVclockModelCnavURA0; }
	void setCNAVclockModelCnavURA1(const CNAVclockModelCnavURA1& cNAVclockModelCnavURA1) { *static_cast<CNAVclockModelCnavURA1*>(items[3]) = cNAVclockModelCnavURA1; }
	void setCNAVclockModelCnavURA2(const CNAVclockModelCnavURA2& cNAVclockModelCnavURA2) { *static_cast<CNAVclockModelCnavURA2*>(items[4]) = cNAVclockModelCnavURA2; }
	void setCNAVclockModelCnavAf2(const CNAVclockModelCnavAf2& cNAVclockModelCnavAf2) { *static_cast<CNAVclockModelCnavAf2*>(items[5]) = cNAVclockModelCnavAf2; }
	void setCNAVclockModelCnavAf1(const CNAVclockModelCnavAf1& cNAVclockModelCnavAf1) { *static_cast<CNAVclockModelCnavAf1*>(items[6]) = cNAVclockModelCnavAf1; }
	void setCNAVclockModelCnavAf0(const CNAVclockModelCnavAf0& cNAVclockModelCnavAf0) { *static_cast<CNAVclockModelCnavAf0*>(items[7]) = cNAVclockModelCnavAf0; }
	void setCNAVclockModelCnavTgd(const CNAVclockModelCnavTgd& cNAVclockModelCnavTgd) { *static_cast<CNAVclockModelCnavTgd*>(items[8]) = cNAVclockModelCnavTgd; }
	void setCNAVclockModelCnavISCl1cp(const CNAVclockModelCnavISCl1cp& cNAVclockModelCnavISCl1cp) { *static_cast<CNAVclockModelCnavISCl1cp*>(items[9]) = cNAVclockModelCnavISCl1cp; }
	void setCNAVclockModelCnavISCl1cd(const CNAVclockModelCnavISCl1cd& cNAVclockModelCnavISCl1cd) { *static_cast<CNAVclockModelCnavISCl1cd*>(items[10]) = cNAVclockModelCnavISCl1cd; }
	void setCNAVclockModelCnavISCl1ca(const CNAVclockModelCnavISCl1ca& cNAVclockModelCnavISCl1ca) { *static_cast<CNAVclockModelCnavISCl1ca*>(items[11]) = cNAVclockModelCnavISCl1ca; }
	void setCNAVclockModelCnavISCl2c(const CNAVclockModelCnavISCl2c& cNAVclockModelCnavISCl2c) { *static_cast<CNAVclockModelCnavISCl2c*>(items[12]) = cNAVclockModelCnavISCl2c; }
	void setCNAVclockModelCnavISCl5i5(const CNAVclockModelCnavISCl5i5& cNAVclockModelCnavISCl5i5) { *static_cast<CNAVclockModelCnavISCl5i5*>(items[13]) = cNAVclockModelCnavISCl5i5; }
	void setCNAVclockModelCnavISCl5q5(const CNAVclockModelCnavISCl5q5& cNAVclockModelCnavISCl5q5) { *static_cast<CNAVclockModelCnavISCl5q5*>(items[14]) = cNAVclockModelCnavISCl5q5; }
};

typedef Integer<CONSTRAINED, 1, 512> CSGCellInfoModeSpecificInfoFddNumberOfPSCs;

class CSGCellInfoModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CSGCellInfoModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setStartPSC(const PrimaryCPICHInfo& startPSC) { *static_cast<PrimaryCPICHInfo*>(items[0]) = startPSC; }
	void setCSGCellInfoModeSpecificInfoFddNumberOfPSCs(const CSGCellInfoModeSpecificInfoFddNumberOfPSCs& cSGCellInfoModeSpecificInfoFddNumberOfPSCs) { *static_cast<CSGCellInfoModeSpecificInfoFddNumberOfPSCs*>(items[1]) = cSGCellInfoModeSpecificInfoFddNumberOfPSCs; }
};

typedef Null CSGCellInfoModeSpecificInfoTdd;

class CSGCellInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CSGCellInfoModeSpecificInfoChoices {
		cSGCellInfoModeSpecificInfoFdd = 0,
		cSGCellInfoModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	CSGCellInfoModeSpecificInfo(): Choice(&theInfo) {}
};

class CSGCellInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CSGCellInfo(): Sequence(&theInfo) {}

	void setCSGCellInfoModeSpecificInfo(const CSGCellInfoModeSpecificInfo& cSGCellInfoModeSpecificInfo) { *static_cast<CSGCellInfoModeSpecificInfo*>(items[0]) = cSGCellInfoModeSpecificInfo; }
};

typedef SequenceOf<CSGCellInfo, CONSTRAINED, 1, maxMeasCSGRange> CSGCellInfoList;

class CSGInterFreqCellInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CSGInterFreqCellInfo(): Sequence(&theInfo) {}

	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[0]) = frequencyInfo; }
	void setCSGInterFreqCellInfoListperFreq(const CSGCellInfoList& cSGInterFreqCellInfoListperFreq) { *static_cast<CSGCellInfoList*>(items[1]) = cSGInterFreqCellInfoListperFreq; }
};

typedef SequenceOf<CSGInterFreqCellInfo, CONSTRAINED, 1, maxFreq> CSGInterFreqCellInfoList;

typedef CSGCellInfoList CSGIntraFreqCellInfoList;

enum CSGProximityDetectionuTRACSGProximityDetecValues {
	enable_CSGProximityDetectionuTRACSGProximityDetec = 0,
};
typedef Enumerated<CONSTRAINED, 0> CSGProximityDetectionuTRACSGProximityDetec;

enum CSGProximityDetectione_UTRACSGProximityDetecValues {
	enable_CSGProximityDetectione_UTRACSGProximityDetec = 0,
};
typedef Enumerated<CONSTRAINED, 0> CSGProximityDetectione_UTRACSGProximityDetec;

class CSGProximityDetection : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CSGProximityDetection(): Sequence(&theInfo) {}

	void setCSGProximityDetectionuTRACSGProximityDetec(const CSGProximityDetectionuTRACSGProximityDetec& cSGProximityDetectionuTRACSGProximityDetec) { *static_cast<CSGProximityDetectionuTRACSGProximityDetec*>(items[0]) = cSGProximityDetectionuTRACSGProximityDetec; }
	void setCSGProximityDetectione_UTRACSGProximityDetec(const CSGProximityDetectione_UTRACSGProximityDetec& cSGProximityDetectione_UTRACSGProximityDetec) { *static_cast<CSGProximityDetectione_UTRACSGProximityDetec*>(items[1]) = cSGProximityDetectione_UTRACSGProximityDetec; }
};

enum CSGProximityIndicationcSGproximityIndValues {
	entering_CSGProximityIndicationcSGproximityInd = 0,
	leaving_CSGProximityIndicationcSGproximityInd = 1,
};
typedef Enumerated<CONSTRAINED, 1> CSGProximityIndicationcSGproximityInd;

class CSGProximityIndicationRadioAccessTechnologyUTRA : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CSGProximityIndicationRadioAccessTechnologyUTRA(): Sequence(&theInfo) {}

	void setCSGFrequencyInfoUTRA(const FrequencyInfo& cSGFrequencyInfoUTRA) { *static_cast<FrequencyInfo*>(items[0]) = cSGFrequencyInfoUTRA; }
};

class CSGProximityIndicationRadioAccessTechnologyEUTRA : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	CSGProximityIndicationRadioAccessTechnologyEUTRA(): Sequence(&theInfo) {}

	void setCSGFrequencyInfoEUTRA(const EARFCN& cSGFrequencyInfoEUTRA) { *static_cast<EARFCN*>(items[0]) = cSGFrequencyInfoEUTRA; }
};

class CSGProximityIndicationRadioAccessTechnology : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum CSGProximityIndicationRadioAccessTechnologyChoices {
		cSGProximityIndicationRadioAccessTechnologyUTRA = 0,
		cSGProximityIndicationRadioAccessTechnologyEUTRA = 1,
	};
	static const Info theInfo;
	CSGProximityIndicationRadioAccessTechnology(): Choice(&theInfo) {}
};

class CSGProximityIndication : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CSGProximityIndication(): Sequence(&theInfo) {}

	void setCSGProximityIndicationcSGproximityInd(const CSGProximityIndicationcSGproximityInd& cSGProximityIndicationcSGproximityInd) { *static_cast<CSGProximityIndicationcSGproximityInd*>(items[0]) = cSGProximityIndicationcSGproximityInd; }
	void setCSGProximityIndicationRadioAccessTechnology(const CSGProximityIndicationRadioAccessTechnology& cSGProximityIndicationRadioAccessTechnology) { *static_cast<CSGProximityIndicationRadioAccessTechnology*>(items[1]) = cSGProximityIndicationRadioAccessTechnology; }
};

typedef Integer<CONSTRAINED, 0, 7> GANSSSignalId;

typedef BitString<CONSTRAINED, 1, 1024> DataBitAssistanceDatabits;

class DataBitAssistance : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DataBitAssistance(): Sequence(&theInfo) {}

	void setGansssignalid(const GANSSSignalId& gansssignalid) { *static_cast<GANSSSignalId*>(items[0]) = gansssignalid; }
	void setDataBitAssistanceDatabits(const DataBitAssistanceDatabits& dataBitAssistanceDatabits) { *static_cast<DataBitAssistanceDatabits*>(items[1]) = dataBitAssistanceDatabits; }
};

typedef Integer<CONSTRAINED, 0, 63> DataBitAssistanceSatSatID;

typedef SequenceOf<DataBitAssistance, CONSTRAINED, 1, maxSgnType> DataBitAssistanceSgnList;

class DataBitAssistanceSat : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DataBitAssistanceSat(): Sequence(&theInfo) {}

	void setDataBitAssistanceSatSatID(const DataBitAssistanceSatSatID& dataBitAssistanceSatSatID) { *static_cast<DataBitAssistanceSatSatID*>(items[0]) = dataBitAssistanceSatSatID; }
	void setDataBitAssistanceSgnList(const DataBitAssistanceSgnList& dataBitAssistanceSgnList) { *static_cast<DataBitAssistanceSgnList*>(items[1]) = dataBitAssistanceSgnList; }
};

typedef SequenceOf<DataBitAssistanceSat, CONSTRAINED, 1, maxGANSSSat> DataBitAssistanceList;

typedef Integer<CONSTRAINED, -127, 127> DeltaPRC;

typedef Integer<CONSTRAINED, -7, 7> DeltaRRC;

typedef BitString<CONSTRAINED, 11, 11> DeltaUT1B1;

typedef BitString<CONSTRAINED, 10, 10> DeltaUT1B2;

class DeltaUT1 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DeltaUT1(): Sequence(&theInfo) {}

	void setDeltaUT1B1(const DeltaUT1B1& deltaUT1B1) { *static_cast<DeltaUT1B1*>(items[0]) = deltaUT1B1; }
	void setDeltaUT1B2(const DeltaUT1B2& deltaUT1B2) { *static_cast<DeltaUT1B2*>(items[1]) = deltaUT1B2; }
};

enum GANSSStatusHealthValues {
	udre_scale_1dot0_GANSSStatusHealth = 0,
	udre_scale_0dot75_GANSSStatusHealth = 1,
	udre_scale_0dot5_GANSSStatusHealth = 2,
	udre_scale_0dot3_GANSSStatusHealth = 3,
	udre_scale_0dot2_GANSSStatusHealth = 4,
	udre_scale_0dot1_GANSSStatusHealth = 5,
	no_data_GANSSStatusHealth = 6,
	invalid_data_GANSSStatusHealth = 7,
};
typedef Enumerated<CONSTRAINED, 7> GANSSStatusHealth;

typedef Integer<CONSTRAINED, 0, 63> DGANSSSignalInformationSatId;

typedef BitString<CONSTRAINED, 10, 10> DGANSSSignalInformationIodedganss;

enum UDREValues {
	lessThan1_UDRE = 0,
	between1_and_4_UDRE = 1,
	between4_and_8_UDRE = 2,
	over8_UDRE = 3,
};
typedef Enumerated<CONSTRAINED, 3> UDRE;

class DGANSSSignalInformation : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DGANSSSignalInformation(): Sequence(&theInfo) {}

	void setDGANSSSignalInformationSatId(const DGANSSSignalInformationSatId& dGANSSSignalInformationSatId) { *static_cast<DGANSSSignalInformationSatId*>(items[0]) = dGANSSSignalInformationSatId; }
	void setDGANSSSignalInformationIodedganss(const DGANSSSignalInformationIodedganss& dGANSSSignalInformationIodedganss) { *static_cast<DGANSSSignalInformationIodedganss*>(items[1]) = dGANSSSignalInformationIodedganss; }
	void setUdre(const UDRE& udre) { *static_cast<UDRE*>(items[2]) = udre; }
};

typedef SequenceOf<DGANSSSignalInformation, CONSTRAINED, 1, maxGANSSSat> DGANSSSignalInformationList;

class DGANSSInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DGANSSInfo(): Sequence(&theInfo) {}

	void setGanssSignalId(const GANSSSignalId& ganssSignalId) { *static_cast<GANSSSignalId*>(items[0]) = ganssSignalId; }
	void setGanssStatusHealth(const GANSSStatusHealth& ganssStatusHealth) { *static_cast<GANSSStatusHealth*>(items[1]) = ganssStatusHealth; }
	void setDgansssignalInformationList(const DGANSSSignalInformationList& dgansssignalInformationList) { *static_cast<DGANSSSignalInformationList*>(items[2]) = dgansssignalInformationList; }
};

typedef Integer<CONSTRAINED, 0, 63> DGANSSSignalInformationr9SatId;

typedef BitString<CONSTRAINED, 10, 10> DGANSSSignalInformationr9Iodedganss;

enum UDREGrowthRateValues {
	growth_1_5_UDREGrowthRate = 0,
	growth_2_UDREGrowthRate = 1,
	growth_4_UDREGrowthRate = 2,
	growth_6_UDREGrowthRate = 3,
	growth_8_UDREGrowthRate = 4,
	growth_10_UDREGrowthRate = 5,
	growth_12_UDREGrowthRate = 6,
	growth_16_UDREGrowthRate = 7,
};
typedef Enumerated<CONSTRAINED, 7> UDREGrowthRate;

enum UDREValidityTimeValues {
	val_20sec_UDREValidityTime = 0,
	val_40sec_UDREValidityTime = 1,
	val_80sec_UDREValidityTime = 2,
	val_160sec_UDREValidityTime = 3,
	val_320sec_UDREValidityTime = 4,
	val_640sec_UDREValidityTime = 5,
	val_1280sec_UDREValidityTime = 6,
	val_2560sec_UDREValidityTime = 7,
};
typedef Enumerated<CONSTRAINED, 7> UDREValidityTime;

class DGANSSSignalInformationr9 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	DGANSSSignalInformationr9(): Sequence(&theInfo) {}

	void setDGANSSSignalInformationr9SatId(const DGANSSSignalInformationr9SatId& dGANSSSignalInformationr9SatId) { *static_cast<DGANSSSignalInformationr9SatId*>(items[0]) = dGANSSSignalInformationr9SatId; }
	void setDGANSSSignalInformationr9Iodedganss(const DGANSSSignalInformationr9Iodedganss& dGANSSSignalInformationr9Iodedganss) { *static_cast<DGANSSSignalInformationr9Iodedganss*>(items[1]) = dGANSSSignalInformationr9Iodedganss; }
	void setUdre(const UDRE& udre) { *static_cast<UDRE*>(items[2]) = udre; }
	void setUdreGrowthRate(const UDREGrowthRate& udreGrowthRate) { *static_cast<UDREGrowthRate*>(items[3]) = udreGrowthRate; }
	void setUdreValidityTime(const UDREValidityTime& udreValidityTime) { *static_cast<UDREValidityTime*>(items[4]) = udreValidityTime; }
};

typedef SequenceOf<DGANSSSignalInformationr9, CONSTRAINED, 1, maxGANSSSat> DGANSSSignalInformationListr9;

class DGANSSInfor9 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DGANSSInfor9(): Sequence(&theInfo) {}

	void setGanssSignalId(const GANSSSignalId& ganssSignalId) { *static_cast<GANSSSignalId*>(items[0]) = ganssSignalId; }
	void setGanssStatusHealth(const GANSSStatusHealth& ganssStatusHealth) { *static_cast<GANSSStatusHealth*>(items[1]) = ganssStatusHealth; }
	void setDgansssignalInformationList(const DGANSSSignalInformationListr9& dgansssignalInformationList) { *static_cast<DGANSSSignalInformationListr9*>(items[2]) = dgansssignalInformationList; }
};

class DGANSSSignalInformationv920ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DGANSSSignalInformationv920ext(): Sequence(&theInfo) {}

	void setUdreGrowthRate(const UDREGrowthRate& udreGrowthRate) { *static_cast<UDREGrowthRate*>(items[0]) = udreGrowthRate; }
	void setUdreValidityTime(const UDREValidityTime& udreValidityTime) { *static_cast<UDREValidityTime*>(items[1]) = udreValidityTime; }
};

typedef SequenceOf<DGANSSSignalInformationv920ext, CONSTRAINED, 1, maxGANSSSat> DGANSSSignalInformationListv920ext;

class DGANSSInfov920ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DGANSSInfov920ext(): Sequence(&theInfo) {}

	void setDgansssignalInformationList(const DGANSSSignalInformationListv920ext& dgansssignalInformationList) { *static_cast<DGANSSSignalInformationListv920ext*>(items[0]) = dgansssignalInformationList; }
};

typedef SequenceOf<DGANSSInfo, CONSTRAINED, 1, maxSgnType> DGANSSInfoList;

typedef SequenceOf<DGANSSInfor9, CONSTRAINED, 1, maxSgnType> DGANSSInfoListr9;

typedef SequenceOf<DGANSSInfov920ext, CONSTRAINED, 1, maxSgnType> DGANSSInfoListv920ext;

typedef BitString<CONSTRAINED, 8, 8> DGANSSSigIdReq;

typedef Integer<CONSTRAINED, 0, 255> IODE;

typedef Integer<CONSTRAINED, -2047, 2047> PRC;

typedef Integer<CONSTRAINED, -127, 127> RRC;

class DGPSCorrectionSatInfo : public Sequence {
private:
	static const void *itemsInfo[9];
	static bool itemsPres[9];
public:
	static const Info theInfo;
	DGPSCorrectionSatInfo(): Sequence(&theInfo) {}

	void setSatID(const SatID& satID) { *static_cast<SatID*>(items[0]) = satID; }
	void setIode(const IODE& iode) { *static_cast<IODE*>(items[1]) = iode; }
	void setUdre(const UDRE& udre) { *static_cast<UDRE*>(items[2]) = udre; }
	void setPrc(const PRC& prc) { *static_cast<PRC*>(items[3]) = prc; }
	void setRrc(const RRC& rrc) { *static_cast<RRC*>(items[4]) = rrc; }
	void setDummy1(const DeltaPRC& dummy1) { *static_cast<DeltaPRC*>(items[5]) = dummy1; }
	void setDummy2(const DeltaRRC& dummy2) { *static_cast<DeltaRRC*>(items[6]) = dummy2; }
	void setDummy3(const DeltaPRC& dummy3) { *static_cast<DeltaPRC*>(items[7]) = dummy3; }
	void setDummy4(const DeltaRRC& dummy4) { *static_cast<DeltaRRC*>(items[8]) = dummy4; }
};

class DGPSCorrectionSatInfor9 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	DGPSCorrectionSatInfor9(): Sequence(&theInfo) {}

	void setSatID(const SatID& satID) { *static_cast<SatID*>(items[0]) = satID; }
	void setIode(const IODE& iode) { *static_cast<IODE*>(items[1]) = iode; }
	void setUdre(const UDRE& udre) { *static_cast<UDRE*>(items[2]) = udre; }
	void setPrc(const PRC& prc) { *static_cast<PRC*>(items[3]) = prc; }
	void setRrc(const RRC& rrc) { *static_cast<RRC*>(items[4]) = rrc; }
	void setUdreGrowthRate(const UDREGrowthRate& udreGrowthRate) { *static_cast<UDREGrowthRate*>(items[5]) = udreGrowthRate; }
	void setUdreValidityTime(const UDREValidityTime& udreValidityTime) { *static_cast<UDREValidityTime*>(items[6]) = udreValidityTime; }
};

class DGPSCorrectionSatInfov920ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DGPSCorrectionSatInfov920ext(): Sequence(&theInfo) {}

	void setUdreGrowthRate(const UDREGrowthRate& udreGrowthRate) { *static_cast<UDREGrowthRate*>(items[0]) = udreGrowthRate; }
	void setUdreValidityTime(const UDREValidityTime& udreValidityTime) { *static_cast<UDREValidityTime*>(items[1]) = udreValidityTime; }
};

typedef SequenceOf<DGPSCorrectionSatInfo, CONSTRAINED, 1, maxSat> DGPSCorrectionSatInfoList;

typedef SequenceOf<DGPSCorrectionSatInfor9, CONSTRAINED, 1, maxSat> DGPSCorrectionSatInfoListr9;

typedef SequenceOf<DGPSCorrectionSatInfov920ext, CONSTRAINED, 1, maxSat> DGPSCorrectionSatInfoListv920ext;

enum DiffCorrectionStatusValues {
	udre_1_0_DiffCorrectionStatus = 0,
	udre_0_75_DiffCorrectionStatus = 1,
	udre_0_5_DiffCorrectionStatus = 2,
	udre_0_3_DiffCorrectionStatus = 3,
	udre_0_2_DiffCorrectionStatus = 4,
	udre_0_1_DiffCorrectionStatus = 5,
	noData_DiffCorrectionStatus = 6,
	invalidData_DiffCorrectionStatus = 7,
};
typedef Enumerated<CONSTRAINED, 7> DiffCorrectionStatus;

enum EllipsoidPointlatitudeSignValues {
	north_EllipsoidPointlatitudeSign = 0,
	south_EllipsoidPointlatitudeSign = 1,
};
typedef Enumerated<CONSTRAINED, 1> EllipsoidPointlatitudeSign;

typedef Integer<CONSTRAINED, 0, 8388607> EllipsoidPointLatitude;

typedef Integer<CONSTRAINED, -8388608, 8388607> EllipsoidPointLongitude;

class EllipsoidPoint : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	EllipsoidPoint(): Sequence(&theInfo) {}

	void setEllipsoidPointlatitudeSign(const EllipsoidPointlatitudeSign& ellipsoidPointlatitudeSign) { *static_cast<EllipsoidPointlatitudeSign*>(items[0]) = ellipsoidPointlatitudeSign; }
	void setEllipsoidPointLatitude(const EllipsoidPointLatitude& ellipsoidPointLatitude) { *static_cast<EllipsoidPointLatitude*>(items[1]) = ellipsoidPointLatitude; }
	void setEllipsoidPointLongitude(const EllipsoidPointLongitude& ellipsoidPointLongitude) { *static_cast<EllipsoidPointLongitude*>(items[2]) = ellipsoidPointLongitude; }
};

enum EllipsoidPointAltitudelatitudeSignValues {
	north_EllipsoidPointAltitudelatitudeSign = 0,
	south_EllipsoidPointAltitudelatitudeSign = 1,
};
typedef Enumerated<CONSTRAINED, 1> EllipsoidPointAltitudelatitudeSign;

typedef Integer<CONSTRAINED, 0, 8388607> EllipsoidPointAltitudeLatitude;

typedef Integer<CONSTRAINED, -8388608, 8388607> EllipsoidPointAltitudeLongitude;

enum EllipsoidPointAltitudealtitudeDirectionValues {
	height_EllipsoidPointAltitudealtitudeDirection = 0,
	depth_EllipsoidPointAltitudealtitudeDirection = 1,
};
typedef Enumerated<CONSTRAINED, 1> EllipsoidPointAltitudealtitudeDirection;

typedef Integer<CONSTRAINED, 0, 32767> EllipsoidPointAltitudeAltitude;

class EllipsoidPointAltitude : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	EllipsoidPointAltitude(): Sequence(&theInfo) {}

	void setEllipsoidPointAltitudelatitudeSign(const EllipsoidPointAltitudelatitudeSign& ellipsoidPointAltitudelatitudeSign) { *static_cast<EllipsoidPointAltitudelatitudeSign*>(items[0]) = ellipsoidPointAltitudelatitudeSign; }
	void setEllipsoidPointAltitudeLatitude(const EllipsoidPointAltitudeLatitude& ellipsoidPointAltitudeLatitude) { *static_cast<EllipsoidPointAltitudeLatitude*>(items[1]) = ellipsoidPointAltitudeLatitude; }
	void setEllipsoidPointAltitudeLongitude(const EllipsoidPointAltitudeLongitude& ellipsoidPointAltitudeLongitude) { *static_cast<EllipsoidPointAltitudeLongitude*>(items[2]) = ellipsoidPointAltitudeLongitude; }
	void setEllipsoidPointAltitudealtitudeDirection(const EllipsoidPointAltitudealtitudeDirection& ellipsoidPointAltitudealtitudeDirection) { *static_cast<EllipsoidPointAltitudealtitudeDirection*>(items[3]) = ellipsoidPointAltitudealtitudeDirection; }
	void setEllipsoidPointAltitudeAltitude(const EllipsoidPointAltitudeAltitude& ellipsoidPointAltitudeAltitude) { *static_cast<EllipsoidPointAltitudeAltitude*>(items[4]) = ellipsoidPointAltitudeAltitude; }
};

enum EllipsoidPointAltitudeEllipsoidelatitudeSignValues {
	north_EllipsoidPointAltitudeEllipsoidelatitudeSign = 0,
	south_EllipsoidPointAltitudeEllipsoidelatitudeSign = 1,
};
typedef Enumerated<CONSTRAINED, 1> EllipsoidPointAltitudeEllipsoidelatitudeSign;

typedef Integer<CONSTRAINED, 0, 8388607> EllipsoidPointAltitudeEllipsoideLatitude;

typedef Integer<CONSTRAINED, -8388608, 8388607> EllipsoidPointAltitudeEllipsoideLongitude;

enum EllipsoidPointAltitudeEllipsoidealtitudeDirectionValues {
	height_EllipsoidPointAltitudeEllipsoidealtitudeDirection = 0,
	depth_EllipsoidPointAltitudeEllipsoidealtitudeDirection = 1,
};
typedef Enumerated<CONSTRAINED, 1> EllipsoidPointAltitudeEllipsoidealtitudeDirection;

typedef Integer<CONSTRAINED, 0, 32767> EllipsoidPointAltitudeEllipsoideAltitude;

typedef Integer<CONSTRAINED, 0, 127> EllipsoidPointAltitudeEllipsoideUncertaintySemiMajor;

typedef Integer<CONSTRAINED, 0, 127> EllipsoidPointAltitudeEllipsoideUncertaintySemiMinor;

typedef Integer<CONSTRAINED, 0, 89> EllipsoidPointAltitudeEllipsoideOrientationMajorAxis;

typedef Integer<CONSTRAINED, 0, 127> EllipsoidPointAltitudeEllipsoideUncertaintyAltitude;

typedef Integer<CONSTRAINED, 0, 100> EllipsoidPointAltitudeEllipsoideConfidence;

class EllipsoidPointAltitudeEllipsoide : public Sequence {
private:
	static const void *itemsInfo[10];
	static bool itemsPres[10];
public:
	static const Info theInfo;
	EllipsoidPointAltitudeEllipsoide(): Sequence(&theInfo) {}

	void setEllipsoidPointAltitudeEllipsoidelatitudeSign(const EllipsoidPointAltitudeEllipsoidelatitudeSign& ellipsoidPointAltitudeEllipsoidelatitudeSign) { *static_cast<EllipsoidPointAltitudeEllipsoidelatitudeSign*>(items[0]) = ellipsoidPointAltitudeEllipsoidelatitudeSign; }
	void setEllipsoidPointAltitudeEllipsoideLatitude(const EllipsoidPointAltitudeEllipsoideLatitude& ellipsoidPointAltitudeEllipsoideLatitude) { *static_cast<EllipsoidPointAltitudeEllipsoideLatitude*>(items[1]) = ellipsoidPointAltitudeEllipsoideLatitude; }
	void setEllipsoidPointAltitudeEllipsoideLongitude(const EllipsoidPointAltitudeEllipsoideLongitude& ellipsoidPointAltitudeEllipsoideLongitude) { *static_cast<EllipsoidPointAltitudeEllipsoideLongitude*>(items[2]) = ellipsoidPointAltitudeEllipsoideLongitude; }
	void setEllipsoidPointAltitudeEllipsoidealtitudeDirection(const EllipsoidPointAltitudeEllipsoidealtitudeDirection& ellipsoidPointAltitudeEllipsoidealtitudeDirection) { *static_cast<EllipsoidPointAltitudeEllipsoidealtitudeDirection*>(items[3]) = ellipsoidPointAltitudeEllipsoidealtitudeDirection; }
	void setEllipsoidPointAltitudeEllipsoideAltitude(const EllipsoidPointAltitudeEllipsoideAltitude& ellipsoidPointAltitudeEllipsoideAltitude) { *static_cast<EllipsoidPointAltitudeEllipsoideAltitude*>(items[4]) = ellipsoidPointAltitudeEllipsoideAltitude; }
	void setEllipsoidPointAltitudeEllipsoideUncertaintySemiMajor(const EllipsoidPointAltitudeEllipsoideUncertaintySemiMajor& ellipsoidPointAltitudeEllipsoideUncertaintySemiMajor) { *static_cast<EllipsoidPointAltitudeEllipsoideUncertaintySemiMajor*>(items[5]) = ellipsoidPointAltitudeEllipsoideUncertaintySemiMajor; }
	void setEllipsoidPointAltitudeEllipsoideUncertaintySemiMinor(const EllipsoidPointAltitudeEllipsoideUncertaintySemiMinor& ellipsoidPointAltitudeEllipsoideUncertaintySemiMinor) { *static_cast<EllipsoidPointAltitudeEllipsoideUncertaintySemiMinor*>(items[6]) = ellipsoidPointAltitudeEllipsoideUncertaintySemiMinor; }
	void setEllipsoidPointAltitudeEllipsoideOrientationMajorAxis(const EllipsoidPointAltitudeEllipsoideOrientationMajorAxis& ellipsoidPointAltitudeEllipsoideOrientationMajorAxis) { *static_cast<EllipsoidPointAltitudeEllipsoideOrientationMajorAxis*>(items[7]) = ellipsoidPointAltitudeEllipsoideOrientationMajorAxis; }
	void setEllipsoidPointAltitudeEllipsoideUncertaintyAltitude(const EllipsoidPointAltitudeEllipsoideUncertaintyAltitude& ellipsoidPointAltitudeEllipsoideUncertaintyAltitude) { *static_cast<EllipsoidPointAltitudeEllipsoideUncertaintyAltitude*>(items[8]) = ellipsoidPointAltitudeEllipsoideUncertaintyAltitude; }
	void setEllipsoidPointAltitudeEllipsoideConfidence(const EllipsoidPointAltitudeEllipsoideConfidence& ellipsoidPointAltitudeEllipsoideConfidence) { *static_cast<EllipsoidPointAltitudeEllipsoideConfidence*>(items[9]) = ellipsoidPointAltitudeEllipsoideConfidence; }
};

enum EllipsoidPointUncertCirclelatitudeSignValues {
	north_EllipsoidPointUncertCirclelatitudeSign = 0,
	south_EllipsoidPointUncertCirclelatitudeSign = 1,
};
typedef Enumerated<CONSTRAINED, 1> EllipsoidPointUncertCirclelatitudeSign;

typedef Integer<CONSTRAINED, 0, 8388607> EllipsoidPointUncertCircleLatitude;

typedef Integer<CONSTRAINED, -8388608, 8388607> EllipsoidPointUncertCircleLongitude;

typedef Integer<CONSTRAINED, 0, 127> EllipsoidPointUncertCircleUncertaintyCode;

class EllipsoidPointUncertCircle : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	EllipsoidPointUncertCircle(): Sequence(&theInfo) {}

	void setEllipsoidPointUncertCirclelatitudeSign(const EllipsoidPointUncertCirclelatitudeSign& ellipsoidPointUncertCirclelatitudeSign) { *static_cast<EllipsoidPointUncertCirclelatitudeSign*>(items[0]) = ellipsoidPointUncertCirclelatitudeSign; }
	void setEllipsoidPointUncertCircleLatitude(const EllipsoidPointUncertCircleLatitude& ellipsoidPointUncertCircleLatitude) { *static_cast<EllipsoidPointUncertCircleLatitude*>(items[1]) = ellipsoidPointUncertCircleLatitude; }
	void setEllipsoidPointUncertCircleLongitude(const EllipsoidPointUncertCircleLongitude& ellipsoidPointUncertCircleLongitude) { *static_cast<EllipsoidPointUncertCircleLongitude*>(items[2]) = ellipsoidPointUncertCircleLongitude; }
	void setEllipsoidPointUncertCircleUncertaintyCode(const EllipsoidPointUncertCircleUncertaintyCode& ellipsoidPointUncertCircleUncertaintyCode) { *static_cast<EllipsoidPointUncertCircleUncertaintyCode*>(items[3]) = ellipsoidPointUncertCircleUncertaintyCode; }
};

enum EllipsoidPointUncertEllipselatitudeSignValues {
	north_EllipsoidPointUncertEllipselatitudeSign = 0,
	south_EllipsoidPointUncertEllipselatitudeSign = 1,
};
typedef Enumerated<CONSTRAINED, 1> EllipsoidPointUncertEllipselatitudeSign;

typedef Integer<CONSTRAINED, 0, 8388607> EllipsoidPointUncertEllipseLatitude;

typedef Integer<CONSTRAINED, -8388608, 8388607> EllipsoidPointUncertEllipseLongitude;

typedef Integer<CONSTRAINED, 0, 127> EllipsoidPointUncertEllipseUncertaintySemiMajor;

typedef Integer<CONSTRAINED, 0, 127> EllipsoidPointUncertEllipseUncertaintySemiMinor;

typedef Integer<CONSTRAINED, 0, 89> EllipsoidPointUncertEllipseOrientationMajorAxis;

typedef Integer<CONSTRAINED, 0, 100> EllipsoidPointUncertEllipseConfidence;

class EllipsoidPointUncertEllipse : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	EllipsoidPointUncertEllipse(): Sequence(&theInfo) {}

	void setEllipsoidPointUncertEllipselatitudeSign(const EllipsoidPointUncertEllipselatitudeSign& ellipsoidPointUncertEllipselatitudeSign) { *static_cast<EllipsoidPointUncertEllipselatitudeSign*>(items[0]) = ellipsoidPointUncertEllipselatitudeSign; }
	void setEllipsoidPointUncertEllipseLatitude(const EllipsoidPointUncertEllipseLatitude& ellipsoidPointUncertEllipseLatitude) { *static_cast<EllipsoidPointUncertEllipseLatitude*>(items[1]) = ellipsoidPointUncertEllipseLatitude; }
	void setEllipsoidPointUncertEllipseLongitude(const EllipsoidPointUncertEllipseLongitude& ellipsoidPointUncertEllipseLongitude) { *static_cast<EllipsoidPointUncertEllipseLongitude*>(items[2]) = ellipsoidPointUncertEllipseLongitude; }
	void setEllipsoidPointUncertEllipseUncertaintySemiMajor(const EllipsoidPointUncertEllipseUncertaintySemiMajor& ellipsoidPointUncertEllipseUncertaintySemiMajor) { *static_cast<EllipsoidPointUncertEllipseUncertaintySemiMajor*>(items[3]) = ellipsoidPointUncertEllipseUncertaintySemiMajor; }
	void setEllipsoidPointUncertEllipseUncertaintySemiMinor(const EllipsoidPointUncertEllipseUncertaintySemiMinor& ellipsoidPointUncertEllipseUncertaintySemiMinor) { *static_cast<EllipsoidPointUncertEllipseUncertaintySemiMinor*>(items[4]) = ellipsoidPointUncertEllipseUncertaintySemiMinor; }
	void setEllipsoidPointUncertEllipseOrientationMajorAxis(const EllipsoidPointUncertEllipseOrientationMajorAxis& ellipsoidPointUncertEllipseOrientationMajorAxis) { *static_cast<EllipsoidPointUncertEllipseOrientationMajorAxis*>(items[5]) = ellipsoidPointUncertEllipseOrientationMajorAxis; }
	void setEllipsoidPointUncertEllipseConfidence(const EllipsoidPointUncertEllipseConfidence& ellipsoidPointUncertEllipseConfidence) { *static_cast<EllipsoidPointUncertEllipseConfidence*>(items[6]) = ellipsoidPointUncertEllipseConfidence; }
};

enum EnvironmentCharacterisationValues {
	possibleHeavyMultipathNLOS_EnvironmentCharacterisation = 0,
	lightMultipathLOS_EnvironmentCharacterisation = 1,
	notDefined_EnvironmentCharacterisation = 2,
	spare_EnvironmentCharacterisation = 3,
};
typedef Enumerated<CONSTRAINED, 3> EnvironmentCharacterisation;

typedef SequenceOf<EUTRAPhysicalCellIdentity, CONSTRAINED, 1, maxReportedEUTRACellPerFreq> EutraEventResultReportedCells;

class EutraEventResult : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EutraEventResult(): Sequence(&theInfo) {}

	void setEarfcn(const EARFCN& earfcn) { *static_cast<EARFCN*>(items[0]) = earfcn; }
	void setEutraEventResultReportedCells(const EutraEventResultReportedCells& eutraEventResultReportedCells) { *static_cast<EutraEventResultReportedCells*>(items[1]) = eutraEventResultReportedCells; }
};

typedef SequenceOf<EutraEventResult, CONSTRAINED, 1, maxReportedEUTRAFreqs> EutraEventResultList;

enum EventIDInterRATValues {
	e3a_EventIDInterRAT = 0,
	e3b_EventIDInterRAT = 1,
	e3c_EventIDInterRAT = 2,
	e3d_EventIDInterRAT = 3,
};
typedef Enumerated<CONSTRAINED, 3> EventIDInterRAT;

class EUTRAEventResults : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EUTRAEventResults(): Sequence(&theInfo) {}

	void setEventID(const EventIDInterRAT& eventID) { *static_cast<EventIDInterRAT*>(items[0]) = eventID; }
	void setEutraEventResultsList(const EutraEventResultList& eutraEventResultsList) { *static_cast<EutraEventResultList*>(items[1]) = eutraEventResultsList; }
};

enum EUTRAMeasurementBandwidthValues {
	mbw6_EUTRAMeasurementBandwidth = 0,
	mbw15_EUTRAMeasurementBandwidth = 1,
	mbw25_EUTRAMeasurementBandwidth = 2,
	mbw50_EUTRAMeasurementBandwidth = 3,
	mbw75_EUTRAMeasurementBandwidth = 4,
	mbw100_EUTRAMeasurementBandwidth = 5,
};
typedef Enumerated<CONSTRAINED, 5> EUTRAMeasurementBandwidth;

typedef Integer<CONSTRAINED, 0, maxPrio_1> EUTRAFrequencyAndPriorityInfoPriority;

typedef Integer<CONSTRAINED, -70, -22> EUTRAFrequencyAndPriorityInfoQRxLevMinEUTRA;

typedef Integer<CONSTRAINED, 0, 31> EUTRAFrequencyAndPriorityInfoThreshXhigh;

typedef Integer<CONSTRAINED, 0, 31> EUTRAFrequencyAndPriorityInfoThreshXlow;

typedef Boolean EUTRAFrequencyAndPriorityInfoEutraDetection;

class EUTRAFrequencyAndPriorityInfo : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	EUTRAFrequencyAndPriorityInfo(): Sequence(&theInfo) {}

	void setEarfcn(const EARFCN& earfcn) { *static_cast<EARFCN*>(items[0]) = earfcn; }
	void setMeasurementBandwidth(const EUTRAMeasurementBandwidth& measurementBandwidth) { *static_cast<EUTRAMeasurementBandwidth*>(items[1]) = measurementBandwidth; }
	void setEUTRAFrequencyAndPriorityInfoPriority(const EUTRAFrequencyAndPriorityInfoPriority& eUTRAFrequencyAndPriorityInfoPriority) { *static_cast<EUTRAFrequencyAndPriorityInfoPriority*>(items[2]) = eUTRAFrequencyAndPriorityInfoPriority; }
	void setEUTRAFrequencyAndPriorityInfoQRxLevMinEUTRA(const EUTRAFrequencyAndPriorityInfoQRxLevMinEUTRA& eUTRAFrequencyAndPriorityInfoQRxLevMinEUTRA) { *static_cast<EUTRAFrequencyAndPriorityInfoQRxLevMinEUTRA*>(items[3]) = eUTRAFrequencyAndPriorityInfoQRxLevMinEUTRA; }
	void setEUTRAFrequencyAndPriorityInfoThreshXhigh(const EUTRAFrequencyAndPriorityInfoThreshXhigh& eUTRAFrequencyAndPriorityInfoThreshXhigh) { *static_cast<EUTRAFrequencyAndPriorityInfoThreshXhigh*>(items[4]) = eUTRAFrequencyAndPriorityInfoThreshXhigh; }
	void setEUTRAFrequencyAndPriorityInfoThreshXlow(const EUTRAFrequencyAndPriorityInfoThreshXlow& eUTRAFrequencyAndPriorityInfoThreshXlow) { *static_cast<EUTRAFrequencyAndPriorityInfoThreshXlow*>(items[5]) = eUTRAFrequencyAndPriorityInfoThreshXlow; }
	void setEutrablackListedCellList(const EUTRABlacklistedCellPerFreqList& eutrablackListedCellList) { *static_cast<EUTRABlacklistedCellPerFreqList*>(items[6]) = eutrablackListedCellList; }
	void setEUTRAFrequencyAndPriorityInfoEutraDetection(const EUTRAFrequencyAndPriorityInfoEutraDetection& eUTRAFrequencyAndPriorityInfoEutraDetection) { *static_cast<EUTRAFrequencyAndPriorityInfoEutraDetection*>(items[7]) = eUTRAFrequencyAndPriorityInfoEutraDetection; }
};

typedef Integer<CONSTRAINED, -34, -3> EUTRAFrequencyAndPriorityInfov920extQqualMinEUTRA;

typedef Integer<CONSTRAINED, 0, 31> EUTRAFrequencyAndPriorityInfov920extThreshXhigh2;

typedef Integer<CONSTRAINED, 0, 31> EUTRAFrequencyAndPriorityInfov920extThreshXlow2;

class EUTRAFrequencyAndPriorityInfov920ext : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	EUTRAFrequencyAndPriorityInfov920ext(): Sequence(&theInfo) {}

	void setEUTRAFrequencyAndPriorityInfov920extQqualMinEUTRA(const EUTRAFrequencyAndPriorityInfov920extQqualMinEUTRA& eUTRAFrequencyAndPriorityInfov920extQqualMinEUTRA) { *static_cast<EUTRAFrequencyAndPriorityInfov920extQqualMinEUTRA*>(items[0]) = eUTRAFrequencyAndPriorityInfov920extQqualMinEUTRA; }
	void setEUTRAFrequencyAndPriorityInfov920extThreshXhigh2(const EUTRAFrequencyAndPriorityInfov920extThreshXhigh2& eUTRAFrequencyAndPriorityInfov920extThreshXhigh2) { *static_cast<EUTRAFrequencyAndPriorityInfov920extThreshXhigh2*>(items[1]) = eUTRAFrequencyAndPriorityInfov920extThreshXhigh2; }
	void setEUTRAFrequencyAndPriorityInfov920extThreshXlow2(const EUTRAFrequencyAndPriorityInfov920extThreshXlow2& eUTRAFrequencyAndPriorityInfov920extThreshXlow2) { *static_cast<EUTRAFrequencyAndPriorityInfov920extThreshXlow2*>(items[2]) = eUTRAFrequencyAndPriorityInfov920extThreshXlow2; }
};

typedef SequenceOf<EUTRAFrequencyAndPriorityInfo, CONSTRAINED, 1, maxNumEUTRAFreqs> EUTRAFrequencyAndPriorityInfoList;

typedef SequenceOf<EUTRAFrequencyAndPriorityInfov920ext, CONSTRAINED, 1, maxNumEUTRAFreqs> EUTRAFrequencyAndPriorityInfoListv920ext;

typedef Null EUTRAFrequencyRemovalRemoveAllFrequencies;

typedef SequenceOf<EARFCN, CONSTRAINED, 1, maxNumEUTRAFreqs> EUTRAFrequencyRemovalRemoveSomeFrequencies;

typedef Null EUTRAFrequencyRemovalRemoveNoFrequencies;

class EUTRAFrequencyRemoval : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum EUTRAFrequencyRemovalChoices {
		eUTRAFrequencyRemovalRemoveAllFrequencies = 0,
		eUTRAFrequencyRemovalRemoveSomeFrequencies = 1,
		eUTRAFrequencyRemovalRemoveNoFrequencies = 2,
	};
	static const Info theInfo;
	EUTRAFrequencyRemoval(): Choice(&theInfo) {}
};

class EUTRAFrequencyInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	EUTRAFrequencyInfo(): Sequence(&theInfo) {}

	void setEarfcn(const EARFCN& earfcn) { *static_cast<EARFCN*>(items[0]) = earfcn; }
	void setMeasurementBandwidth(const EUTRAMeasurementBandwidth& measurementBandwidth) { *static_cast<EUTRAMeasurementBandwidth*>(items[1]) = measurementBandwidth; }
	void setEutrablackListedCellList(const EUTRABlacklistedCellPerFreqList& eutrablackListedCellList) { *static_cast<EUTRABlacklistedCellPerFreqList*>(items[2]) = eutrablackListedCellList; }
};

typedef SequenceOf<EUTRAFrequencyInfo, CONSTRAINED, 1, maxNumEUTRAFreqs> EUTRAFrequencyInfoList;

class EUTRAFrequencyList : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EUTRAFrequencyList(): Sequence(&theInfo) {}

	void setEutraFrequencyRemoval(const EUTRAFrequencyRemoval& eutraFrequencyRemoval) { *static_cast<EUTRAFrequencyRemoval*>(items[0]) = eutraFrequencyRemoval; }
	void setEutraNewFrequencies(const EUTRAFrequencyInfoList& eutraNewFrequencies) { *static_cast<EUTRAFrequencyInfoList*>(items[1]) = eutraNewFrequencies; }
};

class EUTRASIAcquisition : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EUTRASIAcquisition(): Sequence(&theInfo) {}

	void setEarfcn(const EARFCN& earfcn) { *static_cast<EARFCN*>(items[0]) = earfcn; }
	void setPhysicalCellIdentity(const EUTRAPhysicalCellIdentity& physicalCellIdentity) { *static_cast<EUTRAPhysicalCellIdentity*>(items[1]) = physicalCellIdentity; }
};

class EUTRAFrequencyListr9 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	EUTRAFrequencyListr9(): Sequence(&theInfo) {}

	void setEutraFrequencyRemoval(const EUTRAFrequencyRemoval& eutraFrequencyRemoval) { *static_cast<EUTRAFrequencyRemoval*>(items[0]) = eutraFrequencyRemoval; }
	void setEutraNewFrequencies(const EUTRAFrequencyInfoList& eutraNewFrequencies) { *static_cast<EUTRAFrequencyInfoList*>(items[1]) = eutraNewFrequencies; }
	void setEutraSIAcquisition(const EUTRASIAcquisition& eutraSIAcquisition) { *static_cast<EUTRASIAcquisition*>(items[2]) = eutraSIAcquisition; }
};

typedef Integer<CONSTRAINED, 0, 97> EUTRAMeasuredCellsRSRP;

typedef Integer<CONSTRAINED, 0, 33> EUTRAMeasuredCellsRSRQ;

class EUTRAMeasuredCells : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	EUTRAMeasuredCells(): Sequence(&theInfo) {}

	void setPhysicalCellIdentity(const EUTRAPhysicalCellIdentity& physicalCellIdentity) { *static_cast<EUTRAPhysicalCellIdentity*>(items[0]) = physicalCellIdentity; }
	void setEUTRAMeasuredCellsRSRP(const EUTRAMeasuredCellsRSRP& eUTRAMeasuredCellsRSRP) { *static_cast<EUTRAMeasuredCellsRSRP*>(items[1]) = eUTRAMeasuredCellsRSRP; }
	void setEUTRAMeasuredCellsRSRQ(const EUTRAMeasuredCellsRSRQ& eUTRAMeasuredCellsRSRQ) { *static_cast<EUTRAMeasuredCellsRSRQ*>(items[2]) = eUTRAMeasuredCellsRSRQ; }
};

typedef SequenceOf<EUTRAMeasuredCells, CONSTRAINED, 1, maxReportedEUTRACellPerFreq> EutraMeasuredResultMeasuredEUTRACells;

class EutraMeasuredResult : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	EutraMeasuredResult(): Sequence(&theInfo) {}

	void setEarfcn(const EARFCN& earfcn) { *static_cast<EARFCN*>(items[0]) = earfcn; }
	void setEutraMeasuredResultMeasuredEUTRACells(const EutraMeasuredResultMeasuredEUTRACells& eutraMeasuredResultMeasuredEUTRACells) { *static_cast<EutraMeasuredResultMeasuredEUTRACells*>(items[1]) = eutraMeasuredResultMeasuredEUTRACells; }
};

typedef SequenceOf<EutraMeasuredResult, CONSTRAINED, 1, maxReportedEUTRAFreqs> EutraMeasuredResultList;

class EUTRAMeasuredResults : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	EUTRAMeasuredResults(): Sequence(&theInfo) {}

	void setEutraMeasuredResultList(const EutraMeasuredResultList& eutraMeasuredResultList) { *static_cast<EutraMeasuredResultList*>(items[0]) = eutraMeasuredResultList; }
};

typedef BitString<CONSTRAINED, 28, 28> EUTRASIacquisitionResultsCgiInfoCellIdentity;

typedef BitString<CONSTRAINED, 16, 16> EUTRASIacquisitionResultsCgiInfoTrackingAreaCode;

class EUTRASIacquisitionResultsCgiInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	EUTRASIacquisitionResultsCgiInfo(): Sequence(&theInfo) {}

	void setPlmnIdentity(const PLMNIdentity& plmnIdentity) { *static_cast<PLMNIdentity*>(items[0]) = plmnIdentity; }
	void setEUTRASIacquisitionResultsCgiInfoCellIdentity(const EUTRASIacquisitionResultsCgiInfoCellIdentity& eUTRASIacquisitionResultsCgiInfoCellIdentity) { *static_cast<EUTRASIacquisitionResultsCgiInfoCellIdentity*>(items[1]) = eUTRASIacquisitionResultsCgiInfoCellIdentity; }
	void setEUTRASIacquisitionResultsCgiInfoTrackingAreaCode(const EUTRASIacquisitionResultsCgiInfoTrackingAreaCode& eUTRASIacquisitionResultsCgiInfoTrackingAreaCode) { *static_cast<EUTRASIacquisitionResultsCgiInfoTrackingAreaCode*>(items[2]) = eUTRASIacquisitionResultsCgiInfoTrackingAreaCode; }
};

enum EUTRASIacquisitionResultscsgMemberIndicationValues {
	member_EUTRASIacquisitionResultscsgMemberIndication = 0,
};
typedef Enumerated<CONSTRAINED, 0> EUTRASIacquisitionResultscsgMemberIndication;

class EUTRASIacquisitionResults : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	EUTRASIacquisitionResults(): Sequence(&theInfo) {}

	void setEUTRASIacquisitionResultsCgiInfo(const EUTRASIacquisitionResultsCgiInfo& eUTRASIacquisitionResultsCgiInfo) { *static_cast<EUTRASIacquisitionResultsCgiInfo*>(items[0]) = eUTRASIacquisitionResultsCgiInfo; }
	void setCsgIdentity(const CSGIdentity& csgIdentity) { *static_cast<CSGIdentity*>(items[1]) = csgIdentity; }
	void setEUTRASIacquisitionResultscsgMemberIndication(const EUTRASIacquisitionResultscsgMemberIndication& eUTRASIacquisitionResultscsgMemberIndication) { *static_cast<EUTRASIacquisitionResultscsgMemberIndication*>(items[2]) = eUTRASIacquisitionResultscsgMemberIndication; }
};

class EUTRAMeasuredCellsv920ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	EUTRAMeasuredCellsv920ext(): Sequence(&theInfo) {}

	void setEutraSIacquisitionResults(const EUTRASIacquisitionResults& eutraSIacquisitionResults) { *static_cast<EUTRASIacquisitionResults*>(items[0]) = eutraSIacquisitionResults; }
};

typedef SequenceOf<EUTRAMeasuredCellsv920ext, CONSTRAINED, 1, maxReportedEUTRACellPerFreq> EutraMeasuredResultv920extMeasuredEUTRACellsv920ext;

class EutraMeasuredResultv920ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	EutraMeasuredResultv920ext(): Sequence(&theInfo) {}

	void setEutraMeasuredResultv920extMeasuredEUTRACellsv920ext(const EutraMeasuredResultv920extMeasuredEUTRACellsv920ext& eutraMeasuredResultv920extMeasuredEUTRACellsv920ext) { *static_cast<EutraMeasuredResultv920extMeasuredEUTRACellsv920ext*>(items[0]) = eutraMeasuredResultv920extMeasuredEUTRACellsv920ext; }
};

typedef SequenceOf<EutraMeasuredResultv920ext, CONSTRAINED, 1, maxReportedEUTRAFreqs> EutraMeasuredResultListv920ext;

class EUTRAMeasuredResultsv920ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	EUTRAMeasuredResultsv920ext(): Sequence(&theInfo) {}

	void setEutraMeasuredResultListv920ext(const EutraMeasuredResultListv920ext& eutraMeasuredResultListv920ext) { *static_cast<EutraMeasuredResultListv920ext*>(items[0]) = eutraMeasuredResultListv920ext; }
};

class ForbiddenAffectCellr4 : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ForbiddenAffectCellr4Choices {
		fdd = 0,
		tdd = 1,
	};
	static const Info theInfo;
	ForbiddenAffectCellr4(): Choice(&theInfo) {}
};

typedef SequenceOf<ForbiddenAffectCellr4, CONSTRAINED, 1, maxCellMeas> ForbiddenAffectCellListr4;

class Event1ar4 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	Event1ar4(): Sequence(&theInfo) {}

	void setTriggeringCondition(const TriggeringCondition2& triggeringCondition) { *static_cast<TriggeringCondition2*>(items[0]) = triggeringCondition; }
	void setReportingRange(const ReportingRange& reportingRange) { *static_cast<ReportingRange*>(items[1]) = reportingRange; }
	void setForbiddenAffectCellList(const ForbiddenAffectCellListr4& forbiddenAffectCellList) { *static_cast<ForbiddenAffectCellListr4*>(items[2]) = forbiddenAffectCellList; }
	void setW(const W& w) { *static_cast<W*>(items[3]) = w; }
	void setReportDeactivationThreshold(const ReportDeactivationThreshold& reportDeactivationThreshold) { *static_cast<ReportDeactivationThreshold*>(items[4]) = reportDeactivationThreshold; }
	void setReportingAmount(const ReportingAmount& reportingAmount) { *static_cast<ReportingAmount*>(items[5]) = reportingAmount; }
	void setReportingInterval(const ReportingInterval& reportingInterval) { *static_cast<ReportingInterval*>(items[6]) = reportingInterval; }
};

class ForbiddenAffectCellOnSecULFreq : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ForbiddenAffectCellOnSecULFreq(): Sequence(&theInfo) {}

	void setPrimaryCPICH(const PrimaryCPICHInfo& primaryCPICH) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICH; }
};

typedef SequenceOf<ForbiddenAffectCellOnSecULFreq, CONSTRAINED, 1,  maxCellMeasOnSecULFreq> ForbiddenAffectCellListOnSecULFreq;

class Event1aOnSecUlFreqr9 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	Event1aOnSecUlFreqr9(): Sequence(&theInfo) {}

	void setTriggeringCondition(const TriggeringCondition2& triggeringCondition) { *static_cast<TriggeringCondition2*>(items[0]) = triggeringCondition; }
	void setReportingRange(const ReportingRange& reportingRange) { *static_cast<ReportingRange*>(items[1]) = reportingRange; }
	void setForbiddenAffectCellListOnSecULFreq(const ForbiddenAffectCellListOnSecULFreq& forbiddenAffectCellListOnSecULFreq) { *static_cast<ForbiddenAffectCellListOnSecULFreq*>(items[2]) = forbiddenAffectCellListOnSecULFreq; }
	void setW(const W& w) { *static_cast<W*>(items[3]) = w; }
	void setReportDeactivationThreshold(const ReportDeactivationThreshold& reportDeactivationThreshold) { *static_cast<ReportDeactivationThreshold*>(items[4]) = reportDeactivationThreshold; }
	void setReportingAmount(const ReportingAmount& reportingAmount) { *static_cast<ReportingAmount*>(items[5]) = reportingAmount; }
	void setReportingInterval(const ReportingInterval& reportingInterval) { *static_cast<ReportingInterval*>(items[6]) = reportingInterval; }
};

class Event1br4 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	Event1br4(): Sequence(&theInfo) {}

	void setTriggeringCondition(const TriggeringCondition1& triggeringCondition) { *static_cast<TriggeringCondition1*>(items[0]) = triggeringCondition; }
	void setReportingRange(const ReportingRange& reportingRange) { *static_cast<ReportingRange*>(items[1]) = reportingRange; }
	void setForbiddenAffectCellList(const ForbiddenAffectCellListr4& forbiddenAffectCellList) { *static_cast<ForbiddenAffectCellListr4*>(items[2]) = forbiddenAffectCellList; }
	void setW(const W& w) { *static_cast<W*>(items[3]) = w; }
};

class PeriodicReportingInfo1b : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PeriodicReportingInfo1b(): Sequence(&theInfo) {}

	void setReportingAmount(const ReportingAmount& reportingAmount) { *static_cast<ReportingAmount*>(items[0]) = reportingAmount; }
	void setReportingInterval(const ReportingInterval& reportingInterval) { *static_cast<ReportingInterval*>(items[1]) = reportingInterval; }
};

class Event1br7 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	Event1br7(): Sequence(&theInfo) {}

	void setTriggeringCondition(const TriggeringCondition1& triggeringCondition) { *static_cast<TriggeringCondition1*>(items[0]) = triggeringCondition; }
	void setReportingRange(const ReportingRange& reportingRange) { *static_cast<ReportingRange*>(items[1]) = reportingRange; }
	void setForbiddenAffectCellList(const ForbiddenAffectCellListr4& forbiddenAffectCellList) { *static_cast<ForbiddenAffectCellListr4*>(items[2]) = forbiddenAffectCellList; }
	void setW(const W& w) { *static_cast<W*>(items[3]) = w; }
	void setPeriodicReportingInfo1b(const PeriodicReportingInfo1b& periodicReportingInfo1b) { *static_cast<PeriodicReportingInfo1b*>(items[4]) = periodicReportingInfo1b; }
};

class Event1bOnSecUlFreqr9 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	Event1bOnSecUlFreqr9(): Sequence(&theInfo) {}

	void setTriggeringCondition(const TriggeringCondition1& triggeringCondition) { *static_cast<TriggeringCondition1*>(items[0]) = triggeringCondition; }
	void setReportingRange(const ReportingRange& reportingRange) { *static_cast<ReportingRange*>(items[1]) = reportingRange; }
	void setForbiddenAffectCellListOnSecULFreq(const ForbiddenAffectCellListOnSecULFreq& forbiddenAffectCellListOnSecULFreq) { *static_cast<ForbiddenAffectCellListOnSecULFreq*>(items[2]) = forbiddenAffectCellListOnSecULFreq; }
	void setW(const W& w) { *static_cast<W*>(items[3]) = w; }
	void setPeriodicReportingInfo1b(const PeriodicReportingInfo1b& periodicReportingInfo1b) { *static_cast<PeriodicReportingInfo1b*>(items[4]) = periodicReportingInfo1b; }
};

typedef Boolean Event1dUseCIO;

class Event1d : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	Event1d(): Sequence(&theInfo) {}

	void setTriggeringCondition(const TriggeringCondition2& triggeringCondition) { *static_cast<TriggeringCondition2*>(items[0]) = triggeringCondition; }
	void setEvent1dUseCIO(const Event1dUseCIO& event1dUseCIO) { *static_cast<Event1dUseCIO*>(items[1]) = event1dUseCIO; }
};

typedef Integer<CONSTRAINED, -120, 165> ThresholdUsedFrequencyr6;

class Event1er6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	Event1er6(): Sequence(&theInfo) {}

	void setTriggeringCondition(const TriggeringCondition2& triggeringCondition) { *static_cast<TriggeringCondition2*>(items[0]) = triggeringCondition; }
	void setThresholdUsedFrequency(const ThresholdUsedFrequencyr6& thresholdUsedFrequency) { *static_cast<ThresholdUsedFrequencyr6*>(items[1]) = thresholdUsedFrequency; }
};

class Event1fr6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	Event1fr6(): Sequence(&theInfo) {}

	void setTriggeringCondition(const TriggeringCondition1& triggeringCondition) { *static_cast<TriggeringCondition1*>(items[0]) = triggeringCondition; }
	void setThresholdUsedFrequency(const ThresholdUsedFrequencyr6& thresholdUsedFrequency) { *static_cast<ThresholdUsedFrequencyr6*>(items[1]) = thresholdUsedFrequency; }
};

class Event1jr6 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	Event1jr6(): Sequence(&theInfo) {}

	void setReplacementActivationThreshold(const ReplacementActivationThreshold& replacementActivationThreshold) { *static_cast<ReplacementActivationThreshold*>(items[0]) = replacementActivationThreshold; }
	void setReportingAmount(const ReportingAmount& reportingAmount) { *static_cast<ReportingAmount*>(items[1]) = reportingAmount; }
	void setReportingInterval(const ReportingInterval& reportingInterval) { *static_cast<ReportingInterval*>(items[2]) = reportingInterval; }
};

typedef Integer<CONSTRAINED, -115, 0> Threshold;

typedef Integer<CONSTRAINED, 0, 29> HysteresisInterFreq;

class NonUsedFreqParameter : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	NonUsedFreqParameter(): Sequence(&theInfo) {}

	void setNonUsedFreqThreshold(const Threshold& nonUsedFreqThreshold) { *static_cast<Threshold*>(items[0]) = nonUsedFreqThreshold; }
	void setNonUsedFreqW(const W& nonUsedFreqW) { *static_cast<W*>(items[1]) = nonUsedFreqW; }
};

typedef SequenceOf<NonUsedFreqParameter, CONSTRAINED, 1, maxFreq> NonUsedFreqParameterList;

class Event2a : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	Event2a(): Sequence(&theInfo) {}

	void setDummy(const Threshold& dummy) { *static_cast<Threshold*>(items[0]) = dummy; }
	void setUsedFreqW(const W& usedFreqW) { *static_cast<W*>(items[1]) = usedFreqW; }
	void setHysteresis(const HysteresisInterFreq& hysteresis) { *static_cast<HysteresisInterFreq*>(items[2]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[3]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[4]) = reportingCellStatus; }
	void setNonUsedFreqParameterList(const NonUsedFreqParameterList& nonUsedFreqParameterList) { *static_cast<NonUsedFreqParameterList*>(items[5]) = nonUsedFreqParameterList; }
};

typedef SequenceOf<W, CONSTRAINED, 1, maxFreq> NonUsedFreqWListr6;

class Event2ar6 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	Event2ar6(): Sequence(&theInfo) {}

	void setUsedFreqW(const W& usedFreqW) { *static_cast<W*>(items[0]) = usedFreqW; }
	void setHysteresis(const HysteresisInterFreq& hysteresis) { *static_cast<HysteresisInterFreq*>(items[1]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[2]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[3]) = reportingCellStatus; }
	void setNonUsedFreqParameterList(const NonUsedFreqWListr6& nonUsedFreqParameterList) { *static_cast<NonUsedFreqWListr6*>(items[4]) = nonUsedFreqParameterList; }
};

class Event2b : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	Event2b(): Sequence(&theInfo) {}

	void setUsedFreqThreshold(const Threshold& usedFreqThreshold) { *static_cast<Threshold*>(items[0]) = usedFreqThreshold; }
	void setUsedFreqW(const W& usedFreqW) { *static_cast<W*>(items[1]) = usedFreqW; }
	void setHysteresis(const HysteresisInterFreq& hysteresis) { *static_cast<HysteresisInterFreq*>(items[2]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[3]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[4]) = reportingCellStatus; }
	void setNonUsedFreqParameterList(const NonUsedFreqParameterList& nonUsedFreqParameterList) { *static_cast<NonUsedFreqParameterList*>(items[5]) = nonUsedFreqParameterList; }
};

typedef Integer<CONSTRAINED, -120, 0> Thresholdr6;

class NonUsedFreqParameterr6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	NonUsedFreqParameterr6(): Sequence(&theInfo) {}

	void setNonUsedFreqThreshold(const Thresholdr6& nonUsedFreqThreshold) { *static_cast<Thresholdr6*>(items[0]) = nonUsedFreqThreshold; }
	void setNonUsedFreqW(const W& nonUsedFreqW) { *static_cast<W*>(items[1]) = nonUsedFreqW; }
};

typedef SequenceOf<NonUsedFreqParameterr6, CONSTRAINED, 1, maxFreq> NonUsedFreqParameterListr6;

class Event2br6 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	Event2br6(): Sequence(&theInfo) {}

	void setUsedFreqThreshold(const Thresholdr6& usedFreqThreshold) { *static_cast<Thresholdr6*>(items[0]) = usedFreqThreshold; }
	void setUsedFreqW(const W& usedFreqW) { *static_cast<W*>(items[1]) = usedFreqW; }
	void setHysteresis(const HysteresisInterFreq& hysteresis) { *static_cast<HysteresisInterFreq*>(items[2]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[3]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[4]) = reportingCellStatus; }
	void setNonUsedFreqParameterList(const NonUsedFreqParameterListr6& nonUsedFreqParameterList) { *static_cast<NonUsedFreqParameterListr6*>(items[5]) = nonUsedFreqParameterList; }
};

class Event2c : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	Event2c(): Sequence(&theInfo) {}

	void setHysteresis(const HysteresisInterFreq& hysteresis) { *static_cast<HysteresisInterFreq*>(items[0]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[1]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[2]) = reportingCellStatus; }
	void setNonUsedFreqParameterList(const NonUsedFreqParameterList& nonUsedFreqParameterList) { *static_cast<NonUsedFreqParameterList*>(items[3]) = nonUsedFreqParameterList; }
};

class Event2cr6 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	Event2cr6(): Sequence(&theInfo) {}

	void setHysteresis(const HysteresisInterFreq& hysteresis) { *static_cast<HysteresisInterFreq*>(items[0]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[1]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[2]) = reportingCellStatus; }
	void setNonUsedFreqParameterList(const NonUsedFreqParameterListr6& nonUsedFreqParameterList) { *static_cast<NonUsedFreqParameterListr6*>(items[3]) = nonUsedFreqParameterList; }
};

class Event2d : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	Event2d(): Sequence(&theInfo) {}

	void setUsedFreqThreshold(const Threshold& usedFreqThreshold) { *static_cast<Threshold*>(items[0]) = usedFreqThreshold; }
	void setUsedFreqW(const W& usedFreqW) { *static_cast<W*>(items[1]) = usedFreqW; }
	void setHysteresis(const HysteresisInterFreq& hysteresis) { *static_cast<HysteresisInterFreq*>(items[2]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[3]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[4]) = reportingCellStatus; }
};

class Event2dr6 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	Event2dr6(): Sequence(&theInfo) {}

	void setUsedFreqThreshold(const Thresholdr6& usedFreqThreshold) { *static_cast<Thresholdr6*>(items[0]) = usedFreqThreshold; }
	void setUsedFreqW(const W& usedFreqW) { *static_cast<W*>(items[1]) = usedFreqW; }
	void setHysteresis(const HysteresisInterFreq& hysteresis) { *static_cast<HysteresisInterFreq*>(items[2]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[3]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[4]) = reportingCellStatus; }
};

class Event2e : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	Event2e(): Sequence(&theInfo) {}

	void setHysteresis(const HysteresisInterFreq& hysteresis) { *static_cast<HysteresisInterFreq*>(items[0]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[1]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[2]) = reportingCellStatus; }
	void setNonUsedFreqParameterList(const NonUsedFreqParameterList& nonUsedFreqParameterList) { *static_cast<NonUsedFreqParameterList*>(items[3]) = nonUsedFreqParameterList; }
};

class Event2er6 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	Event2er6(): Sequence(&theInfo) {}

	void setHysteresis(const HysteresisInterFreq& hysteresis) { *static_cast<HysteresisInterFreq*>(items[0]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[1]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[2]) = reportingCellStatus; }
	void setNonUsedFreqParameterList(const NonUsedFreqParameterListr6& nonUsedFreqParameterList) { *static_cast<NonUsedFreqParameterListr6*>(items[3]) = nonUsedFreqParameterList; }
};

class Event2f : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	Event2f(): Sequence(&theInfo) {}

	void setUsedFreqThreshold(const Threshold& usedFreqThreshold) { *static_cast<Threshold*>(items[0]) = usedFreqThreshold; }
	void setUsedFreqW(const W& usedFreqW) { *static_cast<W*>(items[1]) = usedFreqW; }
	void setHysteresis(const HysteresisInterFreq& hysteresis) { *static_cast<HysteresisInterFreq*>(items[2]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[3]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[4]) = reportingCellStatus; }
};

class Event2fr6 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	Event2fr6(): Sequence(&theInfo) {}

	void setUsedFreqThreshold(const Thresholdr6& usedFreqThreshold) { *static_cast<Thresholdr6*>(items[0]) = usedFreqThreshold; }
	void setUsedFreqW(const W& usedFreqW) { *static_cast<W*>(items[1]) = usedFreqW; }
	void setHysteresis(const HysteresisInterFreq& hysteresis) { *static_cast<HysteresisInterFreq*>(items[2]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[3]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[4]) = reportingCellStatus; }
};

class Event3a : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	Event3a(): Sequence(&theInfo) {}

	void setThresholdOwnSystem(const Threshold& thresholdOwnSystem) { *static_cast<Threshold*>(items[0]) = thresholdOwnSystem; }
	void setW(const W& w) { *static_cast<W*>(items[1]) = w; }
	void setThresholdOtherSystem(const Threshold& thresholdOtherSystem) { *static_cast<Threshold*>(items[2]) = thresholdOtherSystem; }
	void setHysteresis(const Hysteresis& hysteresis) { *static_cast<Hysteresis*>(items[3]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[4]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[5]) = reportingCellStatus; }
};

class Event3b : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	Event3b(): Sequence(&theInfo) {}

	void setThresholdOtherSystem(const Threshold& thresholdOtherSystem) { *static_cast<Threshold*>(items[0]) = thresholdOtherSystem; }
	void setHysteresis(const Hysteresis& hysteresis) { *static_cast<Hysteresis*>(items[1]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[2]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[3]) = reportingCellStatus; }
};

class Event3c : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	Event3c(): Sequence(&theInfo) {}

	void setThresholdOtherSystem(const Threshold& thresholdOtherSystem) { *static_cast<Threshold*>(items[0]) = thresholdOtherSystem; }
	void setHysteresis(const Hysteresis& hysteresis) { *static_cast<Hysteresis*>(items[1]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[2]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[3]) = reportingCellStatus; }
};

class Event3d : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	Event3d(): Sequence(&theInfo) {}

	void setHysteresis(const Hysteresis& hysteresis) { *static_cast<Hysteresis*>(items[0]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[1]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[2]) = reportingCellStatus; }
};

enum EventIDInterFreqValues {
	e2a_EventIDInterFreq = 0,
	e2b_EventIDInterFreq = 1,
	e2c_EventIDInterFreq = 2,
	e2d_EventIDInterFreq = 3,
	e2e_EventIDInterFreq = 4,
	e2f_EventIDInterFreq = 5,
	spare2_EventIDInterFreq = 6,
	spare1_EventIDInterFreq = 7,
};
typedef Enumerated<CONSTRAINED, 7> EventIDInterFreq;

enum EventIDIntraFreqValues {
	e1a_EventIDIntraFreq = 0,
	e1b_EventIDIntraFreq = 1,
	e1c_EventIDIntraFreq = 2,
	e1d_EventIDIntraFreq = 3,
	e1e_EventIDIntraFreq = 4,
	e1f_EventIDIntraFreq = 5,
	e1g_EventIDIntraFreq = 6,
	e1h_EventIDIntraFreq = 7,
	e1i_EventIDIntraFreq = 8,
	e1j_EventIDIntraFreq = 9,
	spare6_EventIDIntraFreq = 10,
	spare5_EventIDIntraFreq = 11,
	spare4_EventIDIntraFreq = 12,
	spare3_EventIDIntraFreq = 13,
	spare2_EventIDIntraFreq = 14,
	spare1_EventIDIntraFreq = 15,
};
typedef Enumerated<CONSTRAINED, 15> EventIDIntraFreq;

class IntraFreqEventResults : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IntraFreqEventResults(): Sequence(&theInfo) {}

	void setEventID(const EventIDIntraFreq& eventID) { *static_cast<EventIDIntraFreq*>(items[0]) = eventID; }
	void setCellMeasurementEventResults(const CellMeasurementEventResults& cellMeasurementEventResults) { *static_cast<CellMeasurementEventResults*>(items[1]) = cellMeasurementEventResults; }
};

class InterFreqCell : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterFreqCell(): Sequence(&theInfo) {}

	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[0]) = frequencyInfo; }
	void setNonFreqRelatedEventResults(const CellMeasurementEventResults& nonFreqRelatedEventResults) { *static_cast<CellMeasurementEventResults*>(items[1]) = nonFreqRelatedEventResults; }
};

typedef SequenceOf<InterFreqCell, CONSTRAINED, 1, maxFreq> InterFreqCellList;

class InterFreqEventResults : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterFreqEventResults(): Sequence(&theInfo) {}

	void setEventID(const EventIDInterFreq& eventID) { *static_cast<EventIDInterFreq*>(items[0]) = eventID; }
	void setInterFreqCellList(const InterFreqCellList& interFreqCellList) { *static_cast<InterFreqCellList*>(items[1]) = interFreqCellList; }
};

class InterRATEventResults : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterRATEventResults(): Sequence(&theInfo) {}

	void setEventID(const EventIDInterRAT& eventID) { *static_cast<EventIDInterRAT*>(items[0]) = eventID; }
	void setCellToReportList(const CellToReportList& cellToReportList) { *static_cast<CellToReportList*>(items[1]) = cellToReportList; }
};

typedef Null ULTrCHIdentityRachorcpch;

class ULTrCHIdentity : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum ULTrCHIdentityChoices {
		dch = 0,
		uLTrCHIdentityRachorcpch = 1,
		usch = 2,
	};
	static const Info theInfo;
	ULTrCHIdentity(): Choice(&theInfo) {}
};

enum TrafficVolumeEventTypeValues {
	e4a_TrafficVolumeEventType = 0,
	e4b_TrafficVolumeEventType = 1,
};
typedef Enumerated<CONSTRAINED, 1> TrafficVolumeEventType;

class TrafficVolumeEventResults : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	TrafficVolumeEventResults(): Sequence(&theInfo) {}

	void setUltransportChannelCausingEvent(const ULTrCHIdentity& ultransportChannelCausingEvent) { *static_cast<ULTrCHIdentity*>(items[0]) = ultransportChannelCausingEvent; }
	void setTrafficVolumeEventIdentity(const TrafficVolumeEventType& trafficVolumeEventIdentity) { *static_cast<TrafficVolumeEventType*>(items[1]) = trafficVolumeEventIdentity; }
};

typedef SequenceOf<TransportChannelIdentity, CONSTRAINED, 1, maxTrCH> QualityEventResults;

typedef Null UEInternalEventResultsEvent6a;

typedef Null UEInternalEventResultsEvent6b;

typedef Null UEInternalEventResultsEvent6c;

typedef Null UEInternalEventResultsEvent6d;

typedef Null UEInternalEventResultsEvent6e;

typedef Null UEInternalEventResultsSpare;

class UEInternalEventResults : public Choice {
private:
	static const void *choicesInfo[8];
public:
	enum UEInternalEventResultsChoices {
		uEInternalEventResultsEvent6a = 0,
		uEInternalEventResultsEvent6b = 1,
		uEInternalEventResultsEvent6c = 2,
		uEInternalEventResultsEvent6d = 3,
		uEInternalEventResultsEvent6e = 4,
		event6f = 5,
		event6g = 6,
		uEInternalEventResultsSpare = 7,
	};
	static const Info theInfo;
	UEInternalEventResults(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0,  16383> UTRANGPSReferenceTimeResultUeGPSTimingOfCellMspart;

typedef Integer<CONSTRAINED, 0, 4294967295> UTRANGPSReferenceTimeResultUeGPSTimingOfCellLspart;

class UTRANGPSReferenceTimeResultUeGPSTimingOfCell : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UTRANGPSReferenceTimeResultUeGPSTimingOfCell(): Sequence(&theInfo) {}

	void setUTRANGPSReferenceTimeResultUeGPSTimingOfCellMspart(const UTRANGPSReferenceTimeResultUeGPSTimingOfCellMspart& uTRANGPSReferenceTimeResultUeGPSTimingOfCellMspart) { *static_cast<UTRANGPSReferenceTimeResultUeGPSTimingOfCellMspart*>(items[0]) = uTRANGPSReferenceTimeResultUeGPSTimingOfCellMspart; }
	void setUTRANGPSReferenceTimeResultUeGPSTimingOfCellLspart(const UTRANGPSReferenceTimeResultUeGPSTimingOfCellLspart& uTRANGPSReferenceTimeResultUeGPSTimingOfCellLspart) { *static_cast<UTRANGPSReferenceTimeResultUeGPSTimingOfCellLspart*>(items[1]) = uTRANGPSReferenceTimeResultUeGPSTimingOfCellLspart; }
};

class UTRANGPSReferenceTimeResultModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UTRANGPSReferenceTimeResultModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setReferenceIdentity(const PrimaryCPICHInfo& referenceIdentity) { *static_cast<PrimaryCPICHInfo*>(items[0]) = referenceIdentity; }
};

class UTRANGPSReferenceTimeResultModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UTRANGPSReferenceTimeResultModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setReferenceIdentity(const CellParametersID& referenceIdentity) { *static_cast<CellParametersID*>(items[0]) = referenceIdentity; }
};

class UTRANGPSReferenceTimeResultModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UTRANGPSReferenceTimeResultModeSpecificInfoChoices {
		uTRANGPSReferenceTimeResultModeSpecificInfoFdd = 0,
		uTRANGPSReferenceTimeResultModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	UTRANGPSReferenceTimeResultModeSpecificInfo(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 4095> UTRANGPSReferenceTimeResultSfn;

class UTRANGPSReferenceTimeResult : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UTRANGPSReferenceTimeResult(): Sequence(&theInfo) {}

	void setUTRANGPSReferenceTimeResultUeGPSTimingOfCell(const UTRANGPSReferenceTimeResultUeGPSTimingOfCell& uTRANGPSReferenceTimeResultUeGPSTimingOfCell) { *static_cast<UTRANGPSReferenceTimeResultUeGPSTimingOfCell*>(items[0]) = uTRANGPSReferenceTimeResultUeGPSTimingOfCell; }
	void setUTRANGPSReferenceTimeResultModeSpecificInfo(const UTRANGPSReferenceTimeResultModeSpecificInfo& uTRANGPSReferenceTimeResultModeSpecificInfo) { *static_cast<UTRANGPSReferenceTimeResultModeSpecificInfo*>(items[1]) = uTRANGPSReferenceTimeResultModeSpecificInfo; }
	void setUTRANGPSReferenceTimeResultSfn(const UTRANGPSReferenceTimeResultSfn& uTRANGPSReferenceTimeResultSfn) { *static_cast<UTRANGPSReferenceTimeResultSfn*>(items[2]) = uTRANGPSReferenceTimeResultSfn; }
};

typedef Integer<CONSTRAINED, 0, 604799999> GPSTOW1msec;

typedef Integer<CONSTRAINED, 0, 4095> UEPositioningPositionEstimateInfoReferenceTimeCellTimingSfn;

class UEPositioningPositionEstimateInfoReferenceTimeCellTimingModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningPositionEstimateInfoReferenceTimeCellTimingModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
};

class UEPositioningPositionEstimateInfoReferenceTimeCellTimingModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningPositionEstimateInfoReferenceTimeCellTimingModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setCellAndChannelIdentity(const CellAndChannelIdentity& cellAndChannelIdentity) { *static_cast<CellAndChannelIdentity*>(items[0]) = cellAndChannelIdentity; }
};

class UEPositioningPositionEstimateInfoReferenceTimeCellTimingModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningPositionEstimateInfoReferenceTimeCellTimingModeSpecificInfoChoices {
		uEPositioningPositionEstimateInfoReferenceTimeCellTimingModeSpecificInfoFdd = 0,
		uEPositioningPositionEstimateInfoReferenceTimeCellTimingModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	UEPositioningPositionEstimateInfoReferenceTimeCellTimingModeSpecificInfo(): Choice(&theInfo) {}
};

class UEPositioningPositionEstimateInfoReferenceTimeCellTiming : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningPositionEstimateInfoReferenceTimeCellTiming(): Sequence(&theInfo) {}

	void setUEPositioningPositionEstimateInfoReferenceTimeCellTimingSfn(const UEPositioningPositionEstimateInfoReferenceTimeCellTimingSfn& uEPositioningPositionEstimateInfoReferenceTimeCellTimingSfn) { *static_cast<UEPositioningPositionEstimateInfoReferenceTimeCellTimingSfn*>(items[0]) = uEPositioningPositionEstimateInfoReferenceTimeCellTimingSfn; }
	void setUEPositioningPositionEstimateInfoReferenceTimeCellTimingModeSpecificInfo(const UEPositioningPositionEstimateInfoReferenceTimeCellTimingModeSpecificInfo& uEPositioningPositionEstimateInfoReferenceTimeCellTimingModeSpecificInfo) { *static_cast<UEPositioningPositionEstimateInfoReferenceTimeCellTimingModeSpecificInfo*>(items[1]) = uEPositioningPositionEstimateInfoReferenceTimeCellTimingModeSpecificInfo; }
};

class UEPositioningPositionEstimateInfoReferenceTime : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum UEPositioningPositionEstimateInfoReferenceTimeChoices {
		utranGPSReferenceTimeResult = 0,
		gpsReferenceTimeOnly = 1,
		uEPositioningPositionEstimateInfoReferenceTimeCellTiming = 2,
	};
	static const Info theInfo;
	UEPositioningPositionEstimateInfoReferenceTime(): Choice(&theInfo) {}
};

class PositionEstimate : public Choice {
private:
	static const void *choicesInfo[5];
public:
	enum PositionEstimateChoices {
		ellipsoidPoint = 0,
		ellipsoidPointUncertCircle = 1,
		ellipsoidPointUncertEllipse = 2,
		ellipsoidPointAltitude = 3,
		ellipsoidPointAltitudeEllipse = 4,
	};
	static const Info theInfo;
	PositionEstimate(): Choice(&theInfo) {}
};

class UEPositioningPositionEstimateInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningPositionEstimateInfo(): Sequence(&theInfo) {}

	void setUEPositioningPositionEstimateInfoReferenceTime(const UEPositioningPositionEstimateInfoReferenceTime& uEPositioningPositionEstimateInfoReferenceTime) { *static_cast<UEPositioningPositionEstimateInfoReferenceTime*>(items[0]) = uEPositioningPositionEstimateInfoReferenceTime; }
	void setPositionEstimate(const PositionEstimate& positionEstimate) { *static_cast<PositionEstimate*>(items[1]) = positionEstimate; }
};

typedef Integer<CONSTRAINED, 0, 4095> UEPositioningOTDOAMeasurementSfn;

typedef Integer<CONSTRAINED, 0, 8191> UERXTXTimeDifferenceType2;

typedef BitString<CONSTRAINED, 2, 2> UEPositioningOTDOAQualityStdResolution;

typedef BitString<CONSTRAINED, 3, 3> UEPositioningOTDOAQualityNumberOfOTDOAMeasurements;

typedef BitString<CONSTRAINED, 5, 5> UEPositioningOTDOAQualityStdOfOTDOAMeasurements;

class UEPositioningOTDOAQuality : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UEPositioningOTDOAQuality(): Sequence(&theInfo) {}

	void setUEPositioningOTDOAQualityStdResolution(const UEPositioningOTDOAQualityStdResolution& uEPositioningOTDOAQualityStdResolution) { *static_cast<UEPositioningOTDOAQualityStdResolution*>(items[0]) = uEPositioningOTDOAQualityStdResolution; }
	void setUEPositioningOTDOAQualityNumberOfOTDOAMeasurements(const UEPositioningOTDOAQualityNumberOfOTDOAMeasurements& uEPositioningOTDOAQualityNumberOfOTDOAMeasurements) { *static_cast<UEPositioningOTDOAQualityNumberOfOTDOAMeasurements*>(items[1]) = uEPositioningOTDOAQualityNumberOfOTDOAMeasurements; }
	void setUEPositioningOTDOAQualityStdOfOTDOAMeasurements(const UEPositioningOTDOAQualityStdOfOTDOAMeasurements& uEPositioningOTDOAQualityStdOfOTDOAMeasurements) { *static_cast<UEPositioningOTDOAQualityStdOfOTDOAMeasurements*>(items[2]) = uEPositioningOTDOAQualityStdOfOTDOAMeasurements; }
};

class NeighbourQuality : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	NeighbourQuality(): Sequence(&theInfo) {}

	void setUePositioningOTDOAQuality(const UEPositioningOTDOAQuality& uePositioningOTDOAQuality) { *static_cast<UEPositioningOTDOAQuality*>(items[0]) = uePositioningOTDOAQuality; }
};

class UERXTXTimeDifferenceType2Info : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UERXTXTimeDifferenceType2Info(): Sequence(&theInfo) {}

	void setUeRXTXTimeDifferenceType2(const UERXTXTimeDifferenceType2& ueRXTXTimeDifferenceType2) { *static_cast<UERXTXTimeDifferenceType2*>(items[0]) = ueRXTXTimeDifferenceType2; }
	void setNeighbourQuality(const NeighbourQuality& neighbourQuality) { *static_cast<NeighbourQuality*>(items[1]) = neighbourQuality; }
};

class UEPositioningOTDOAMeasurementModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningOTDOAMeasurementModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setReferenceCellIDentity(const PrimaryCPICHInfo& referenceCellIDentity) { *static_cast<PrimaryCPICHInfo*>(items[0]) = referenceCellIDentity; }
	void setUeRXTXTimeDifferenceType2Info(const UERXTXTimeDifferenceType2Info& ueRXTXTimeDifferenceType2Info) { *static_cast<UERXTXTimeDifferenceType2Info*>(items[1]) = ueRXTXTimeDifferenceType2Info; }
};

class UEPositioningOTDOAMeasurementModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOAMeasurementModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setReferenceCellIdentity(const CellParametersID& referenceCellIdentity) { *static_cast<CellParametersID*>(items[0]) = referenceCellIdentity; }
};

class UEPositioningOTDOAMeasurementModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningOTDOAMeasurementModeSpecificInfoChoices {
		uEPositioningOTDOAMeasurementModeSpecificInfoFdd = 0,
		uEPositioningOTDOAMeasurementModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	UEPositioningOTDOAMeasurementModeSpecificInfo(): Choice(&theInfo) {}
};

class NeighbourModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	NeighbourModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setNeighbourIdentity(const PrimaryCPICHInfo& neighbourIdentity) { *static_cast<PrimaryCPICHInfo*>(items[0]) = neighbourIdentity; }
	void setUERXTXTimeDifferenceType2Info(const UERXTXTimeDifferenceType2Info& uERXTXTimeDifferenceType2Info) { *static_cast<UERXTXTimeDifferenceType2Info*>(items[1]) = uERXTXTimeDifferenceType2Info; }
};

class NeighbourModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	NeighbourModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setNeighbourAndChannelIdentity(const CellAndChannelIdentity& neighbourAndChannelIdentity) { *static_cast<CellAndChannelIdentity*>(items[0]) = neighbourAndChannelIdentity; }
};

class NeighbourModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum NeighbourModeSpecificInfoChoices {
		neighbourModeSpecificInfoFdd = 0,
		neighbourModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	NeighbourModeSpecificInfo(): Choice(&theInfo) {}
};

class Neighbour : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	Neighbour(): Sequence(&theInfo) {}

	void setNeighbourModeSpecificInfo(const NeighbourModeSpecificInfo& neighbourModeSpecificInfo) { *static_cast<NeighbourModeSpecificInfo*>(items[0]) = neighbourModeSpecificInfo; }
	void setNeighbourQuality(const NeighbourQuality& neighbourQuality) { *static_cast<NeighbourQuality*>(items[1]) = neighbourQuality; }
	void setSfnSFNObsTimeDifference2(const SFNSFNObsTimeDifference2& sfnSFNObsTimeDifference2) { *static_cast<SFNSFNObsTimeDifference2*>(items[2]) = sfnSFNObsTimeDifference2; }
};

typedef SequenceOf<Neighbour, CONSTRAINED, 1, maxCellMeas> NeighbourList;

class UEPositioningOTDOAMeasurement : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UEPositioningOTDOAMeasurement(): Sequence(&theInfo) {}

	void setUEPositioningOTDOAMeasurementSfn(const UEPositioningOTDOAMeasurementSfn& uEPositioningOTDOAMeasurementSfn) { *static_cast<UEPositioningOTDOAMeasurementSfn*>(items[0]) = uEPositioningOTDOAMeasurementSfn; }
	void setUEPositioningOTDOAMeasurementModeSpecificInfo(const UEPositioningOTDOAMeasurementModeSpecificInfo& uEPositioningOTDOAMeasurementModeSpecificInfo) { *static_cast<UEPositioningOTDOAMeasurementModeSpecificInfo*>(items[1]) = uEPositioningOTDOAMeasurementModeSpecificInfo; }
	void setNeighbourList(const NeighbourList& neighbourList) { *static_cast<NeighbourList*>(items[2]) = neighbourList; }
};

class UEPositioningGPSMeasurementResultsReferenceTime : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningGPSMeasurementResultsReferenceTimeChoices {
		utranGPSReferenceTimeResult = 0,
		gpsReferenceTimeOnly = 1,
	};
	static const Info theInfo;
	UEPositioningGPSMeasurementResultsReferenceTime(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 63> GPSMeasurementParamSatelliteID;

typedef Integer<CONSTRAINED, 0, 63> GPSMeasurementParamCN0;

typedef Integer<CONSTRAINED, -32768, 32768> GPSMeasurementParamDoppler;

typedef Integer<CONSTRAINED, 0, 1022> GPSMeasurementParamWholeGPSChips;

typedef Integer<CONSTRAINED, 0, 1023> GPSMeasurementParamFractionalGPSChips;

enum MultipathIndicatorValues {
	nm_MultipathIndicator = 0,
	low_MultipathIndicator = 1,
	medium_MultipathIndicator = 2,
	high_MultipathIndicator = 3,
};
typedef Enumerated<CONSTRAINED, 3> MultipathIndicator;

typedef Integer<CONSTRAINED, 0, 63> GPSMeasurementParamPseudorangeRMSError;

class GPSMeasurementParam : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	GPSMeasurementParam(): Sequence(&theInfo) {}

	void setGPSMeasurementParamSatelliteID(const GPSMeasurementParamSatelliteID& gPSMeasurementParamSatelliteID) { *static_cast<GPSMeasurementParamSatelliteID*>(items[0]) = gPSMeasurementParamSatelliteID; }
	void setGPSMeasurementParamCN0(const GPSMeasurementParamCN0& gPSMeasurementParamCN0) { *static_cast<GPSMeasurementParamCN0*>(items[1]) = gPSMeasurementParamCN0; }
	void setGPSMeasurementParamDoppler(const GPSMeasurementParamDoppler& gPSMeasurementParamDoppler) { *static_cast<GPSMeasurementParamDoppler*>(items[2]) = gPSMeasurementParamDoppler; }
	void setGPSMeasurementParamWholeGPSChips(const GPSMeasurementParamWholeGPSChips& gPSMeasurementParamWholeGPSChips) { *static_cast<GPSMeasurementParamWholeGPSChips*>(items[3]) = gPSMeasurementParamWholeGPSChips; }
	void setGPSMeasurementParamFractionalGPSChips(const GPSMeasurementParamFractionalGPSChips& gPSMeasurementParamFractionalGPSChips) { *static_cast<GPSMeasurementParamFractionalGPSChips*>(items[4]) = gPSMeasurementParamFractionalGPSChips; }
	void setMultipathIndicator(const MultipathIndicator& multipathIndicator) { *static_cast<MultipathIndicator*>(items[5]) = multipathIndicator; }
	void setGPSMeasurementParamPseudorangeRMSError(const GPSMeasurementParamPseudorangeRMSError& gPSMeasurementParamPseudorangeRMSError) { *static_cast<GPSMeasurementParamPseudorangeRMSError*>(items[6]) = gPSMeasurementParamPseudorangeRMSError; }
};

typedef SequenceOf<GPSMeasurementParam, CONSTRAINED, 1, maxSat> GPSMeasurementParamList;

class UEPositioningGPSMeasurementResults : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningGPSMeasurementResults(): Sequence(&theInfo) {}

	void setUEPositioningGPSMeasurementResultsReferenceTime(const UEPositioningGPSMeasurementResultsReferenceTime& uEPositioningGPSMeasurementResultsReferenceTime) { *static_cast<UEPositioningGPSMeasurementResultsReferenceTime*>(items[0]) = uEPositioningGPSMeasurementResultsReferenceTime; }
	void setGpsMeasurementParamList(const GPSMeasurementParamList& gpsMeasurementParamList) { *static_cast<GPSMeasurementParamList*>(items[1]) = gpsMeasurementParamList; }
};

typedef Null UEPositioningMeasurementEventResultsAdditionalOrReplacedPosMeasEvent;

class UEPositioningMeasurementEventResults : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum UEPositioningMeasurementEventResultsChoices {
		event7a = 0,
		event7b = 1,
		event7c = 2,
		uEPositioningMeasurementEventResultsAdditionalOrReplacedPosMeasEvent = 3,
	};
	static const Info theInfo;
	UEPositioningMeasurementEventResults(): Choice(&theInfo) {}
};

typedef Null EventResultsSpare;

class EventResults : public Choice {
private:
	static const void *choicesInfo[8];
public:
	enum EventResultsChoices {
		intraFreqEventResults = 0,
		interFreqEventResults = 1,
		interRATEventResults = 2,
		trafficVolumeEventResults = 3,
		qualityEventResults = 4,
		ueInternalEventResults = 5,
		uepositioningMeasurementEventResults = 6,
		eventResultsSpare = 7,
	};
	static const Info theInfo;
	EventResults(): Choice(&theInfo) {}
};

typedef Null UEPositioningPositionEstimateInfov770extReferenceTimeOptionsEarlierthanr7;

typedef Integer<CONSTRAINED, 0, 80> UTRANGANSSReferenceTimeUeGANSSTimingOfCellFramesMsPart;

typedef Integer<CONSTRAINED, 0, 4294967295> UTRANGANSSReferenceTimeUeGANSSTimingOfCellFramesLsPart;

class UTRANGANSSReferenceTimeUeGANSSTimingOfCellFrames : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UTRANGANSSReferenceTimeUeGANSSTimingOfCellFrames(): Sequence(&theInfo) {}

	void setUTRANGANSSReferenceTimeUeGANSSTimingOfCellFramesMsPart(const UTRANGANSSReferenceTimeUeGANSSTimingOfCellFramesMsPart& uTRANGANSSReferenceTimeUeGANSSTimingOfCellFramesMsPart) { *static_cast<UTRANGANSSReferenceTimeUeGANSSTimingOfCellFramesMsPart*>(items[0]) = uTRANGANSSReferenceTimeUeGANSSTimingOfCellFramesMsPart; }
	void setUTRANGANSSReferenceTimeUeGANSSTimingOfCellFramesLsPart(const UTRANGANSSReferenceTimeUeGANSSTimingOfCellFramesLsPart& uTRANGANSSReferenceTimeUeGANSSTimingOfCellFramesLsPart) { *static_cast<UTRANGANSSReferenceTimeUeGANSSTimingOfCellFramesLsPart*>(items[1]) = uTRANGANSSReferenceTimeUeGANSSTimingOfCellFramesLsPart; }
};

typedef Integer<CONSTRAINED, 0, 7> UTRANGANSSReferenceTimeGANSSTimeId;

typedef Integer<CONSTRAINED, 0, 127> UTRANGANSSReferenceTimeGANSSTimeUncertainty;

class UTRANGANSSReferenceTimeModeFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UTRANGANSSReferenceTimeModeFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
};

class UTRANGANSSReferenceTimeModeTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UTRANGANSSReferenceTimeModeTdd(): Sequence(&theInfo) {}

	void setCellParameters(const CellParametersID& cellParameters) { *static_cast<CellParametersID*>(items[0]) = cellParameters; }
};

class UTRANGANSSReferenceTimeMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UTRANGANSSReferenceTimeModeChoices {
		uTRANGANSSReferenceTimeModeFdd = 0,
		uTRANGANSSReferenceTimeModeTdd = 1,
	};
	static const Info theInfo;
	UTRANGANSSReferenceTimeMode(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 4095> UTRANGANSSReferenceTimeReferenceSfn;

class UTRANGANSSReferenceTime : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	UTRANGANSSReferenceTime(): Sequence(&theInfo) {}

	void setUTRANGANSSReferenceTimeUeGANSSTimingOfCellFrames(const UTRANGANSSReferenceTimeUeGANSSTimingOfCellFrames& uTRANGANSSReferenceTimeUeGANSSTimingOfCellFrames) { *static_cast<UTRANGANSSReferenceTimeUeGANSSTimingOfCellFrames*>(items[0]) = uTRANGANSSReferenceTimeUeGANSSTimingOfCellFrames; }
	void setUTRANGANSSReferenceTimeGANSSTimeId(const UTRANGANSSReferenceTimeGANSSTimeId& uTRANGANSSReferenceTimeGANSSTimeId) { *static_cast<UTRANGANSSReferenceTimeGANSSTimeId*>(items[1]) = uTRANGANSSReferenceTimeGANSSTimeId; }
	void setUTRANGANSSReferenceTimeGANSSTimeUncertainty(const UTRANGANSSReferenceTimeGANSSTimeUncertainty& uTRANGANSSReferenceTimeGANSSTimeUncertainty) { *static_cast<UTRANGANSSReferenceTimeGANSSTimeUncertainty*>(items[2]) = uTRANGANSSReferenceTimeGANSSTimeUncertainty; }
	void setUTRANGANSSReferenceTimeMode(const UTRANGANSSReferenceTimeMode& uTRANGANSSReferenceTimeMode) { *static_cast<UTRANGANSSReferenceTimeMode*>(items[3]) = uTRANGANSSReferenceTimeMode; }
	void setUTRANGANSSReferenceTimeReferenceSfn(const UTRANGANSSReferenceTimeReferenceSfn& uTRANGANSSReferenceTimeReferenceSfn) { *static_cast<UTRANGANSSReferenceTimeReferenceSfn*>(items[4]) = uTRANGANSSReferenceTimeReferenceSfn; }
};

typedef Integer<CONSTRAINED, 0, 3599999> GANSSReferenceTimeOnlyGANSStod;

typedef Integer<CONSTRAINED, 0, 7> GANSSReferenceTimeOnlyGANSStimeId;

typedef Integer<CONSTRAINED, 0, 127> GANSSReferenceTimeOnlyGANSStoduncertainty;

class GANSSReferenceTimeOnly : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	GANSSReferenceTimeOnly(): Sequence(&theInfo) {}

	void setGANSSReferenceTimeOnlyGANSStod(const GANSSReferenceTimeOnlyGANSStod& gANSSReferenceTimeOnlyGANSStod) { *static_cast<GANSSReferenceTimeOnlyGANSStod*>(items[0]) = gANSSReferenceTimeOnlyGANSStod; }
	void setGANSSReferenceTimeOnlyGANSStimeId(const GANSSReferenceTimeOnlyGANSStimeId& gANSSReferenceTimeOnlyGANSStimeId) { *static_cast<GANSSReferenceTimeOnlyGANSStimeId*>(items[1]) = gANSSReferenceTimeOnlyGANSStimeId; }
	void setGANSSReferenceTimeOnlyGANSStoduncertainty(const GANSSReferenceTimeOnlyGANSStoduncertainty& gANSSReferenceTimeOnlyGANSStoduncertainty) { *static_cast<GANSSReferenceTimeOnlyGANSStoduncertainty*>(items[2]) = gANSSReferenceTimeOnlyGANSStoduncertainty; }
};

class UEPositioningPositionEstimateInfov770extReferenceTimeOptionsR7ReferenceTime : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningPositionEstimateInfov770extReferenceTimeOptionsR7ReferenceTimeChoices {
		utranGANSSReferenceTimeResult = 0,
		ganssReferenceTimeOnly = 1,
	};
	static const Info theInfo;
	UEPositioningPositionEstimateInfov770extReferenceTimeOptionsR7ReferenceTime(): Choice(&theInfo) {}
};

class UEPositioningPositionEstimateInfov770extReferenceTimeOptionsR7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningPositionEstimateInfov770extReferenceTimeOptionsR7(): Sequence(&theInfo) {}

	void setUEPositioningPositionEstimateInfov770extReferenceTimeOptionsR7ReferenceTime(const UEPositioningPositionEstimateInfov770extReferenceTimeOptionsR7ReferenceTime& uEPositioningPositionEstimateInfov770extReferenceTimeOptionsR7ReferenceTime) { *static_cast<UEPositioningPositionEstimateInfov770extReferenceTimeOptionsR7ReferenceTime*>(items[0]) = uEPositioningPositionEstimateInfov770extReferenceTimeOptionsR7ReferenceTime; }
	void setPositionEstimate(const PositionEstimate& positionEstimate) { *static_cast<PositionEstimate*>(items[1]) = positionEstimate; }
};

class UEPositioningPositionEstimateInfov770extReferenceTimeOptions : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningPositionEstimateInfov770extReferenceTimeOptionsChoices {
		uEPositioningPositionEstimateInfov770extReferenceTimeOptionsEarlierthanr7 = 0,
		uEPositioningPositionEstimateInfov770extReferenceTimeOptionsR7 = 1,
	};
	static const Info theInfo;
	UEPositioningPositionEstimateInfov770extReferenceTimeOptions(): Choice(&theInfo) {}
};

typedef BitString<CONSTRAINED, 16, 16> UEPositioningPositionEstimateInfov770extPositionData;

typedef Integer<CONSTRAINED, 0, 359> HorizontalVelocityBearing;

typedef Integer<CONSTRAINED, 0, 2047> HorizontalVelocityHorizontalSpeed;

class HorizontalVelocity : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	HorizontalVelocity(): Sequence(&theInfo) {}

	void setHorizontalVelocityBearing(const HorizontalVelocityBearing& horizontalVelocityBearing) { *static_cast<HorizontalVelocityBearing*>(items[0]) = horizontalVelocityBearing; }
	void setHorizontalVelocityHorizontalSpeed(const HorizontalVelocityHorizontalSpeed& horizontalVelocityHorizontalSpeed) { *static_cast<HorizontalVelocityHorizontalSpeed*>(items[1]) = horizontalVelocityHorizontalSpeed; }
};

enum HorizontalWithVerticalVelocityverticalSpeedDirectionValues {
	upward_HorizontalWithVerticalVelocityverticalSpeedDirection = 0,
	downward_HorizontalWithVerticalVelocityverticalSpeedDirection = 1,
};
typedef Enumerated<CONSTRAINED, 1> HorizontalWithVerticalVelocityverticalSpeedDirection;

typedef Integer<CONSTRAINED, 0, 359> HorizontalWithVerticalVelocityBearing;

typedef Integer<CONSTRAINED, 0, 2047> HorizontalWithVerticalVelocityHorizontalSpeed;

typedef Integer<CONSTRAINED, 0, 255> HorizontalWithVerticalVelocityVerticalSpeed;

class HorizontalWithVerticalVelocity : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	HorizontalWithVerticalVelocity(): Sequence(&theInfo) {}

	void setHorizontalWithVerticalVelocityverticalSpeedDirection(const HorizontalWithVerticalVelocityverticalSpeedDirection& horizontalWithVerticalVelocityverticalSpeedDirection) { *static_cast<HorizontalWithVerticalVelocityverticalSpeedDirection*>(items[0]) = horizontalWithVerticalVelocityverticalSpeedDirection; }
	void setHorizontalWithVerticalVelocityBearing(const HorizontalWithVerticalVelocityBearing& horizontalWithVerticalVelocityBearing) { *static_cast<HorizontalWithVerticalVelocityBearing*>(items[1]) = horizontalWithVerticalVelocityBearing; }
	void setHorizontalWithVerticalVelocityHorizontalSpeed(const HorizontalWithVerticalVelocityHorizontalSpeed& horizontalWithVerticalVelocityHorizontalSpeed) { *static_cast<HorizontalWithVerticalVelocityHorizontalSpeed*>(items[2]) = horizontalWithVerticalVelocityHorizontalSpeed; }
	void setHorizontalWithVerticalVelocityVerticalSpeed(const HorizontalWithVerticalVelocityVerticalSpeed& horizontalWithVerticalVelocityVerticalSpeed) { *static_cast<HorizontalWithVerticalVelocityVerticalSpeed*>(items[3]) = horizontalWithVerticalVelocityVerticalSpeed; }
};

typedef Integer<CONSTRAINED, 0, 359> HorizontalVelocityWithUncertaintyBearing;

typedef Integer<CONSTRAINED, 0, 2047> HorizontalVelocityWithUncertaintyHorizontalSpeed;

typedef Integer<CONSTRAINED, 0, 255> HorizontalVelocityWithUncertaintyHorizontalSpeedUncertainty;

class HorizontalVelocityWithUncertainty : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	HorizontalVelocityWithUncertainty(): Sequence(&theInfo) {}

	void setHorizontalVelocityWithUncertaintyBearing(const HorizontalVelocityWithUncertaintyBearing& horizontalVelocityWithUncertaintyBearing) { *static_cast<HorizontalVelocityWithUncertaintyBearing*>(items[0]) = horizontalVelocityWithUncertaintyBearing; }
	void setHorizontalVelocityWithUncertaintyHorizontalSpeed(const HorizontalVelocityWithUncertaintyHorizontalSpeed& horizontalVelocityWithUncertaintyHorizontalSpeed) { *static_cast<HorizontalVelocityWithUncertaintyHorizontalSpeed*>(items[1]) = horizontalVelocityWithUncertaintyHorizontalSpeed; }
	void setHorizontalVelocityWithUncertaintyHorizontalSpeedUncertainty(const HorizontalVelocityWithUncertaintyHorizontalSpeedUncertainty& horizontalVelocityWithUncertaintyHorizontalSpeedUncertainty) { *static_cast<HorizontalVelocityWithUncertaintyHorizontalSpeedUncertainty*>(items[2]) = horizontalVelocityWithUncertaintyHorizontalSpeedUncertainty; }
};

enum HorizontalWithVerticalVelocityAndUncertaintyverticalSpeedDirectionValues {
	upward_HorizontalWithVerticalVelocityAndUncertaintyverticalSpeedDirection = 0,
	downward_HorizontalWithVerticalVelocityAndUncertaintyverticalSpeedDirection = 1,
};
typedef Enumerated<CONSTRAINED, 1> HorizontalWithVerticalVelocityAndUncertaintyverticalSpeedDirection;

typedef Integer<CONSTRAINED, 0, 359> HorizontalWithVerticalVelocityAndUncertaintyBearing;

typedef Integer<CONSTRAINED, 0, 2047> HorizontalWithVerticalVelocityAndUncertaintyHorizontalSpeed;

typedef Integer<CONSTRAINED, 0, 255> HorizontalWithVerticalVelocityAndUncertaintyVerticalSpeed;

typedef Integer<CONSTRAINED, 0, 255> HorizontalWithVerticalVelocityAndUncertaintyHorizontalUncertaintySpeed;

typedef Integer<CONSTRAINED, 0, 255> HorizontalWithVerticalVelocityAndUncertaintyVerticalUncertaintySpeed;

class HorizontalWithVerticalVelocityAndUncertainty : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	HorizontalWithVerticalVelocityAndUncertainty(): Sequence(&theInfo) {}

	void setHorizontalWithVerticalVelocityAndUncertaintyverticalSpeedDirection(const HorizontalWithVerticalVelocityAndUncertaintyverticalSpeedDirection& horizontalWithVerticalVelocityAndUncertaintyverticalSpeedDirection) { *static_cast<HorizontalWithVerticalVelocityAndUncertaintyverticalSpeedDirection*>(items[0]) = horizontalWithVerticalVelocityAndUncertaintyverticalSpeedDirection; }
	void setHorizontalWithVerticalVelocityAndUncertaintyBearing(const HorizontalWithVerticalVelocityAndUncertaintyBearing& horizontalWithVerticalVelocityAndUncertaintyBearing) { *static_cast<HorizontalWithVerticalVelocityAndUncertaintyBearing*>(items[1]) = horizontalWithVerticalVelocityAndUncertaintyBearing; }
	void setHorizontalWithVerticalVelocityAndUncertaintyHorizontalSpeed(const HorizontalWithVerticalVelocityAndUncertaintyHorizontalSpeed& horizontalWithVerticalVelocityAndUncertaintyHorizontalSpeed) { *static_cast<HorizontalWithVerticalVelocityAndUncertaintyHorizontalSpeed*>(items[2]) = horizontalWithVerticalVelocityAndUncertaintyHorizontalSpeed; }
	void setHorizontalWithVerticalVelocityAndUncertaintyVerticalSpeed(const HorizontalWithVerticalVelocityAndUncertaintyVerticalSpeed& horizontalWithVerticalVelocityAndUncertaintyVerticalSpeed) { *static_cast<HorizontalWithVerticalVelocityAndUncertaintyVerticalSpeed*>(items[3]) = horizontalWithVerticalVelocityAndUncertaintyVerticalSpeed; }
	void setHorizontalWithVerticalVelocityAndUncertaintyHorizontalUncertaintySpeed(const HorizontalWithVerticalVelocityAndUncertaintyHorizontalUncertaintySpeed& horizontalWithVerticalVelocityAndUncertaintyHorizontalUncertaintySpeed) { *static_cast<HorizontalWithVerticalVelocityAndUncertaintyHorizontalUncertaintySpeed*>(items[4]) = horizontalWithVerticalVelocityAndUncertaintyHorizontalUncertaintySpeed; }
	void setHorizontalWithVerticalVelocityAndUncertaintyVerticalUncertaintySpeed(const HorizontalWithVerticalVelocityAndUncertaintyVerticalUncertaintySpeed& horizontalWithVerticalVelocityAndUncertaintyVerticalUncertaintySpeed) { *static_cast<HorizontalWithVerticalVelocityAndUncertaintyVerticalUncertaintySpeed*>(items[5]) = horizontalWithVerticalVelocityAndUncertaintyVerticalUncertaintySpeed; }
};

class VelocityEstimate : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum VelocityEstimateChoices {
		horizontalVelocity = 0,
		horizontalWithVerticalVelocity = 1,
		horizontalVelocityWithUncertainty = 2,
		horizontalWithVerticalVelocityAndUncertainty = 3,
	};
	static const Info theInfo;
	VelocityEstimate(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 127> UEPositioningGPSReferenceTimeUncertainty;

class UEPositioningPositionEstimateInfov770ext : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UEPositioningPositionEstimateInfov770ext(): Sequence(&theInfo) {}

	void setUEPositioningPositionEstimateInfov770extReferenceTimeOptions(const UEPositioningPositionEstimateInfov770extReferenceTimeOptions& uEPositioningPositionEstimateInfov770extReferenceTimeOptions) { *static_cast<UEPositioningPositionEstimateInfov770extReferenceTimeOptions*>(items[0]) = uEPositioningPositionEstimateInfov770extReferenceTimeOptions; }
	void setUEPositioningPositionEstimateInfov770extPositionData(const UEPositioningPositionEstimateInfov770extPositionData& uEPositioningPositionEstimateInfov770extPositionData) { *static_cast<UEPositioningPositionEstimateInfov770extPositionData*>(items[1]) = uEPositioningPositionEstimateInfov770extPositionData; }
	void setVelocityEstimate(const VelocityEstimate& velocityEstimate) { *static_cast<VelocityEstimate*>(items[2]) = velocityEstimate; }
	void setUePositioningGPSReferenceTimeUncertainty(const UEPositioningGPSReferenceTimeUncertainty& uePositioningGPSReferenceTimeUncertainty) { *static_cast<UEPositioningGPSReferenceTimeUncertainty*>(items[3]) = uePositioningGPSReferenceTimeUncertainty; }
};

class UEPositioningGPSMeasurementResultsv770ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningGPSMeasurementResultsv770ext(): Sequence(&theInfo) {}

	void setUePositioningGPSReferenceTimeUncertainty(const UEPositioningGPSReferenceTimeUncertainty& uePositioningGPSReferenceTimeUncertainty) { *static_cast<UEPositioningGPSReferenceTimeUncertainty*>(items[0]) = uePositioningGPSReferenceTimeUncertainty; }
};

class UEPositioningGANSSMeasuredResultsReferenceTime : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningGANSSMeasuredResultsReferenceTimeChoices {
		utranGANSSReferenceTimeResult = 0,
		ganssReferenceTimeOnly = 1,
	};
	static const Info theInfo;
	UEPositioningGANSSMeasuredResultsReferenceTime(): Choice(&theInfo) {}
};

class GANSSGenericMeasurementInfo : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	GANSSGenericMeasurementInfo(): Sequence(&theInfo) {}

};

class UEPositioningGANSSMeasuredResults : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningGANSSMeasuredResults(): Sequence(&theInfo) {}

	void setUEPositioningGANSSMeasuredResultsReferenceTime(const UEPositioningGANSSMeasuredResultsReferenceTime& uEPositioningGANSSMeasuredResultsReferenceTime) { *static_cast<UEPositioningGANSSMeasuredResultsReferenceTime*>(items[0]) = uEPositioningGANSSMeasuredResultsReferenceTime; }
	void setGanssGenericMeasurementInfo(const GANSSGenericMeasurementInfo& ganssGenericMeasurementInfo) { *static_cast<GANSSGenericMeasurementInfo*>(items[1]) = ganssGenericMeasurementInfo; }
};

typedef Null UEPositioningMeasurementEventResultsv770extSpare;

class UEPositioningMeasurementEventResultsv770ext : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum UEPositioningMeasurementEventResultsv770extChoices {
		event7a = 0,
		event7c = 1,
		event7d = 2,
		uEPositioningMeasurementEventResultsv770extSpare = 3,
	};
	static const Info theInfo;
	UEPositioningMeasurementEventResultsv770ext(): Choice(&theInfo) {}
};

class EventResultsv770ext : public Choice {
private:
	static const void *choicesInfo[1];
public:
	enum EventResultsv770extChoices {
		uepositioningMeasurementEventResults = 0,
	};
	static const Info theInfo;
	EventResultsv770ext(): Choice(&theInfo) {}
};

class GANSSGenericMeasurementInfov860ext : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	GANSSGenericMeasurementInfov860ext(): Sequence(&theInfo) {}

};

class UEPositioningGANSSMeasuredResultsv860ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningGANSSMeasuredResultsv860ext(): Sequence(&theInfo) {}

	void setGanssGenericMeasurementInfo(const GANSSGenericMeasurementInfov860ext& ganssGenericMeasurementInfo) { *static_cast<GANSSGenericMeasurementInfov860ext*>(items[0]) = ganssGenericMeasurementInfo; }
};

class UEPositioningMeasurementEventResultsv860ext : public Choice {
private:
	static const void *choicesInfo[1];
public:
	enum UEPositioningMeasurementEventResultsv860extChoices {
		event7d = 0,
	};
	static const Info theInfo;
	UEPositioningMeasurementEventResultsv860ext(): Choice(&theInfo) {}
};

class EventResultsv860ext : public Choice {
private:
	static const void *choicesInfo[1];
public:
	enum EventResultsv860extChoices {
		uepositioningMeasurementEventResults = 0,
	};
	static const Info theInfo;
	EventResultsv860ext(): Choice(&theInfo) {}
};

class IntraFreqEventResultsOnSecUlFreq : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IntraFreqEventResultsOnSecUlFreq(): Sequence(&theInfo) {}

	void setEventID(const EventIDIntraFreq& eventID) { *static_cast<EventIDIntraFreq*>(items[0]) = eventID; }
	void setCellMeasurementEventResultsOnSecUlFreq(const CellMeasurementEventResultsOnSecUlFreq& cellMeasurementEventResultsOnSecUlFreq) { *static_cast<CellMeasurementEventResultsOnSecUlFreq*>(items[1]) = cellMeasurementEventResultsOnSecUlFreq; }
};

class EventResultsOnSecUlFreq : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	EventResultsOnSecUlFreq(): Sequence(&theInfo) {}

	void setIntraFreqEventResults(const IntraFreqEventResultsOnSecUlFreq& intraFreqEventResults) { *static_cast<IntraFreqEventResultsOnSecUlFreq*>(items[0]) = intraFreqEventResults; }
};

typedef Integer<CONSTRAINED, -42,  21> ExtraDopplerDopplerFirstOrder;

enum ExtraDopplerdopplerUncertaintyValues {
	dopU40_ExtraDopplerdopplerUncertainty = 0,
	dopU20_ExtraDopplerdopplerUncertainty = 1,
	dopU10_ExtraDopplerdopplerUncertainty = 2,
	dopU5_ExtraDopplerdopplerUncertainty = 3,
	dopU2_5_ExtraDopplerdopplerUncertainty = 4,
	spare3_ExtraDopplerdopplerUncertainty = 5,
	spare2_ExtraDopplerdopplerUncertainty = 6,
	spare1_ExtraDopplerdopplerUncertainty = 7,
};
typedef Enumerated<CONSTRAINED, 7> ExtraDopplerdopplerUncertainty;

class ExtraDoppler : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	ExtraDoppler(): Sequence(&theInfo) {}

	void setExtraDopplerDopplerFirstOrder(const ExtraDopplerDopplerFirstOrder& extraDopplerDopplerFirstOrder) { *static_cast<ExtraDopplerDopplerFirstOrder*>(items[0]) = extraDopplerDopplerFirstOrder; }
	void setExtraDopplerdopplerUncertainty(const ExtraDopplerdopplerUncertainty& extraDopplerdopplerUncertainty) { *static_cast<ExtraDopplerdopplerUncertainty*>(items[1]) = extraDopplerdopplerUncertainty; }
};

typedef Integer<CONSTRAINED, 1, 12> FACHMeasurementOccasionInfoFACHmeasoccasioncoeff;

typedef Boolean FACHMeasurementOccasionInfoInterfreqFDDmeasind;

typedef Boolean FACHMeasurementOccasionInfoInterfreqTDDmeasind;

enum RATTypeValues {
	gsm_RATType = 0,
	is2000_RATType = 1,
};
typedef Enumerated<CONSTRAINED, 1> RATType;

typedef SequenceOf<RATType, CONSTRAINED, 1, maxOtherRAT> FACHMeasurementOccasionInfoInterRATmeasind;

class FACHMeasurementOccasionInfo : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	FACHMeasurementOccasionInfo(): Sequence(&theInfo) {}

	void setFACHMeasurementOccasionInfoFACHmeasoccasioncoeff(const FACHMeasurementOccasionInfoFACHmeasoccasioncoeff& fACHMeasurementOccasionInfoFACHmeasoccasioncoeff) { *static_cast<FACHMeasurementOccasionInfoFACHmeasoccasioncoeff*>(items[0]) = fACHMeasurementOccasionInfoFACHmeasoccasioncoeff; }
	void setFACHMeasurementOccasionInfoInterfreqFDDmeasind(const FACHMeasurementOccasionInfoInterfreqFDDmeasind& fACHMeasurementOccasionInfoInterfreqFDDmeasind) { *static_cast<FACHMeasurementOccasionInfoInterfreqFDDmeasind*>(items[1]) = fACHMeasurementOccasionInfoInterfreqFDDmeasind; }
	void setFACHMeasurementOccasionInfoInterfreqTDDmeasind(const FACHMeasurementOccasionInfoInterfreqTDDmeasind& fACHMeasurementOccasionInfoInterfreqTDDmeasind) { *static_cast<FACHMeasurementOccasionInfoInterfreqTDDmeasind*>(items[2]) = fACHMeasurementOccasionInfoInterfreqTDDmeasind; }
	void setFACHMeasurementOccasionInfoInterRATmeasind(const FACHMeasurementOccasionInfoInterRATmeasind& fACHMeasurementOccasionInfoInterRATmeasind) { *static_cast<FACHMeasurementOccasionInfoInterRATmeasind*>(items[3]) = fACHMeasurementOccasionInfoInterRATmeasind; }
};

typedef Boolean FACHMeasurementOccasionInfoLCRr4extInterfreqTDD128measind;

class FACHMeasurementOccasionInfoLCRr4ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	FACHMeasurementOccasionInfoLCRr4ext(): Sequence(&theInfo) {}

	void setFACHMeasurementOccasionInfoLCRr4extInterfreqTDD128measind(const FACHMeasurementOccasionInfoLCRr4extInterfreqTDD128measind& fACHMeasurementOccasionInfoLCRr4extInterfreqTDD128measind) { *static_cast<FACHMeasurementOccasionInfoLCRr4extInterfreqTDD128measind*>(items[0]) = fACHMeasurementOccasionInfoLCRr4extInterfreqTDD128measind; }
};

enum FilterCoefficientValues {
	fc0_FilterCoefficient = 0,
	fc1_FilterCoefficient = 1,
	fc2_FilterCoefficient = 2,
	fc3_FilterCoefficient = 3,
	fc4_FilterCoefficient = 4,
	fc5_FilterCoefficient = 5,
	fc6_FilterCoefficient = 6,
	fc7_FilterCoefficient = 7,
	fc8_FilterCoefficient = 8,
	fc9_FilterCoefficient = 9,
	fc11_FilterCoefficient = 10,
	fc13_FilterCoefficient = 11,
	fc15_FilterCoefficient = 12,
	fc17_FilterCoefficient = 13,
	fc19_FilterCoefficient = 14,
	spare1_FilterCoefficient = 15,
};
typedef Enumerated<CONSTRAINED, 15> FilterCoefficient;

typedef Integer<CONSTRAINED, 0, 15> FineSFNSFN;

enum FreqQualityEstimateQuantityFDDValues {
	cpich_Ec_N0_FreqQualityEstimateQuantityFDD = 0,
	cpich_RSCP_FreqQualityEstimateQuantityFDD = 1,
};
typedef Enumerated<CONSTRAINED, 1> FreqQualityEstimateQuantityFDD;

enum FreqQualityEstimateQuantityTDDValues {
	primaryCCPCH_RSCP_FreqQualityEstimateQuantityTDD = 0,
};
typedef Enumerated<CONSTRAINED, 0> FreqQualityEstimateQuantityTDD;

typedef Integer<CONSTRAINED, 0, 86399> GanssDataBitsGanssTod;

typedef Integer<CONSTRAINED, 0, 15> ReqDataBitAssistanceGanssDataBitInterval;

typedef Integer<CONSTRAINED, 0, 63> GanssSatelliteInfoItem;

typedef SequenceOf<GanssSatelliteInfoItem, CONSTRAINED, 1, maxGANSSSat> ReqDataBitAssistanceGanssSatelliteInfo;

class ReqDataBitAssistance : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ReqDataBitAssistance(): Sequence(&theInfo) {}

	void setGanssSignalID(const DGANSSSigIdReq& ganssSignalID) { *static_cast<DGANSSSigIdReq*>(items[0]) = ganssSignalID; }
	void setReqDataBitAssistanceGanssDataBitInterval(const ReqDataBitAssistanceGanssDataBitInterval& reqDataBitAssistanceGanssDataBitInterval) { *static_cast<ReqDataBitAssistanceGanssDataBitInterval*>(items[1]) = reqDataBitAssistanceGanssDataBitInterval; }
	void setReqDataBitAssistanceGanssSatelliteInfo(const ReqDataBitAssistanceGanssSatelliteInfo& reqDataBitAssistanceGanssSatelliteInfo) { *static_cast<ReqDataBitAssistanceGanssSatelliteInfo*>(items[2]) = reqDataBitAssistanceGanssSatelliteInfo; }
};

class GanssDataBits : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	GanssDataBits(): Sequence(&theInfo) {}

	void setGanssDataBitsGanssTod(const GanssDataBitsGanssTod& ganssDataBitsGanssTod) { *static_cast<GanssDataBitsGanssTod*>(items[0]) = ganssDataBitsGanssTod; }
	void setDataBitAssistance(const ReqDataBitAssistance& dataBitAssistance) { *static_cast<ReqDataBitAssistance*>(items[1]) = dataBitAssistance; }
};

typedef BitString<CONSTRAINED, 56, 56> GANSSDecipheringKeysCurrentDecipheringKey;

typedef BitString<CONSTRAINED, 56, 56> GANSSDecipheringKeysNextDecipheringKey;

class GANSSDecipheringKeys : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	GANSSDecipheringKeys(): Sequence(&theInfo) {}

	void setGANSSDecipheringKeysCurrentDecipheringKey(const GANSSDecipheringKeysCurrentDecipheringKey& gANSSDecipheringKeysCurrentDecipheringKey) { *static_cast<GANSSDecipheringKeysCurrentDecipheringKey*>(items[0]) = gANSSDecipheringKeysCurrentDecipheringKey; }
	void setGANSSDecipheringKeysNextDecipheringKey(const GANSSDecipheringKeysNextDecipheringKey& gANSSDecipheringKeysNextDecipheringKey) { *static_cast<GANSSDecipheringKeysNextDecipheringKey*>(items[1]) = gANSSDecipheringKeysNextDecipheringKey; }
};

typedef Integer<CONSTRAINED, 0, 7> GANSSGenericDataGanssId;

typedef Integer<CONSTRAINED, -8388608, 8388607> UEPositioningGANSSTimeModelGanssta1;

typedef Integer<CONSTRAINED, -64, 63> UEPositioningGANSSTimeModelGanssta2;

enum UEPositioningGANSSTimeModelgnss_to_idValues {
	gps_UEPositioningGANSSTimeModelgnss_to_id = 0,
	galileo_UEPositioningGANSSTimeModelgnss_to_id = 1,
	qzss_UEPositioningGANSSTimeModelgnss_to_id = 2,
	glonass_UEPositioningGANSSTimeModelgnss_to_id = 3,
	spare4_UEPositioningGANSSTimeModelgnss_to_id = 4,
	spare3_UEPositioningGANSSTimeModelgnss_to_id = 5,
	spare2_UEPositioningGANSSTimeModelgnss_to_id = 6,
	spare1_UEPositioningGANSSTimeModelgnss_to_id = 7,
};
typedef Enumerated<CONSTRAINED, 7> UEPositioningGANSSTimeModelgnss_to_id;

typedef Integer<CONSTRAINED, 0, 8191> UEPositioningGANSSTimeModelGansswknumber;

class UEPositioningGANSSTimeModel : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UEPositioningGANSSTimeModel(): Sequence(&theInfo) {}

	void setUEPositioningGANSSTimeModelGanssta1(const UEPositioningGANSSTimeModelGanssta1& uEPositioningGANSSTimeModelGanssta1) { *static_cast<UEPositioningGANSSTimeModelGanssta1*>(items[0]) = uEPositioningGANSSTimeModelGanssta1; }
	void setUEPositioningGANSSTimeModelGanssta2(const UEPositioningGANSSTimeModelGanssta2& uEPositioningGANSSTimeModelGanssta2) { *static_cast<UEPositioningGANSSTimeModelGanssta2*>(items[1]) = uEPositioningGANSSTimeModelGanssta2; }
	void setUEPositioningGANSSTimeModelgnss_to_id(const UEPositioningGANSSTimeModelgnss_to_id& uEPositioningGANSSTimeModelgnss_to_id) { *static_cast<UEPositioningGANSSTimeModelgnss_to_id*>(items[2]) = uEPositioningGANSSTimeModelgnss_to_id; }
	void setUEPositioningGANSSTimeModelGansswknumber(const UEPositioningGANSSTimeModelGansswknumber& uEPositioningGANSSTimeModelGansswknumber) { *static_cast<UEPositioningGANSSTimeModelGansswknumber*>(items[3]) = uEPositioningGANSSTimeModelGansswknumber; }
};

typedef SequenceOf<UEPositioningGANSSTimeModel, CONSTRAINED, 1, maxGANSS_1> GANSSTimeModelsList;

class UEPositioningDGANSSCorrections : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningDGANSSCorrections(): Sequence(&theInfo) {}

	void setDganssInfoList(const DGANSSInfoList& dganssInfoList) { *static_cast<DGANSSInfoList*>(items[0]) = dganssInfoList; }
};

enum UEPositioningGANSSNavigationModelnon_broadcastIndicationValues {
	true_UEPositioningGANSSNavigationModelnon_broadcastIndication = 0,
};
typedef Enumerated<CONSTRAINED, 0> UEPositioningGANSSNavigationModelnon_broadcastIndication;

typedef Integer<CONSTRAINED, 0, 63> GanssSatInfoNavSatId;

typedef BitString<CONSTRAINED, 5, 5> GanssSatInfoNavSvHealth;

typedef BitString<CONSTRAINED, 10, 10> GanssSatInfoNavIod;

typedef BitString<CONSTRAINED, 14, 14> SatelliteclockmodelToc;

typedef BitString<CONSTRAINED, 12, 12> SatelliteclockmodelAf2;

typedef BitString<CONSTRAINED, 18, 18> SatelliteclockmodelAf1;

typedef BitString<CONSTRAINED, 28, 28> SatelliteclockmodelAf0;

typedef BitString<CONSTRAINED, 10, 10> SatelliteclockmodelTgd;

typedef Integer<CONSTRAINED, 0, 1> SatelliteclockmodelModelid;

class Satelliteclockmodel : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	Satelliteclockmodel(): Sequence(&theInfo) {}

	void setSatelliteclockmodelToc(const SatelliteclockmodelToc& satelliteclockmodelToc) { *static_cast<SatelliteclockmodelToc*>(items[0]) = satelliteclockmodelToc; }
	void setSatelliteclockmodelAf2(const SatelliteclockmodelAf2& satelliteclockmodelAf2) { *static_cast<SatelliteclockmodelAf2*>(items[1]) = satelliteclockmodelAf2; }
	void setSatelliteclockmodelAf1(const SatelliteclockmodelAf1& satelliteclockmodelAf1) { *static_cast<SatelliteclockmodelAf1*>(items[2]) = satelliteclockmodelAf1; }
	void setSatelliteclockmodelAf0(const SatelliteclockmodelAf0& satelliteclockmodelAf0) { *static_cast<SatelliteclockmodelAf0*>(items[3]) = satelliteclockmodelAf0; }
	void setSatelliteclockmodelTgd(const SatelliteclockmodelTgd& satelliteclockmodelTgd) { *static_cast<SatelliteclockmodelTgd*>(items[4]) = satelliteclockmodelTgd; }
	void setSatelliteclockmodelModelid(const SatelliteclockmodelModelid& satelliteclockmodelModelid) { *static_cast<SatelliteclockmodelModelid*>(items[5]) = satelliteclockmodelModelid; }
};

typedef SequenceOf<Satelliteclockmodel, CONSTRAINED, 1, maxSatClockModels> SatelliteclockmodelList;

class UEPositioningGANSSClockModel : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningGANSSClockModel(): Sequence(&theInfo) {}

	void setSatelliteclockmodelList(const SatelliteclockmodelList& satelliteclockmodelList) { *static_cast<SatelliteclockmodelList*>(items[0]) = satelliteclockmodelList; }
};

typedef BitString<CONSTRAINED, 14, 14> KeplerianParametersToenav;

typedef BitString<CONSTRAINED, 32, 32> KeplerianParametersGanssomeganav;

typedef BitString<CONSTRAINED, 16, 16> KeplerianParametersDeltannav;

typedef BitString<CONSTRAINED, 32, 32> KeplerianParametersMzeronav;

typedef BitString<CONSTRAINED, 24, 24> KeplerianParametersOmegadotnav;

typedef BitString<CONSTRAINED, 32, 32> KeplerianParametersGanssenav;

typedef BitString<CONSTRAINED, 14, 14> KeplerianParametersIdotnav;

typedef BitString<CONSTRAINED, 32, 32> KeplerianParametersAsqrtnav;

typedef BitString<CONSTRAINED, 32, 32> KeplerianParametersIzeronav;

typedef BitString<CONSTRAINED, 32, 32> KeplerianParametersOmegazeronav;

typedef BitString<CONSTRAINED, 16, 16> KeplerianParametersCrsnav;

typedef BitString<CONSTRAINED, 16, 16> KeplerianParametersCisnav;

typedef BitString<CONSTRAINED, 16, 16> KeplerianParametersCusnav;

typedef BitString<CONSTRAINED, 16, 16> KeplerianParametersCrcnav;

typedef BitString<CONSTRAINED, 16, 16> KeplerianParametersCicnav;

typedef BitString<CONSTRAINED, 16, 16> KeplerianParametersCucnav;

class KeplerianParameters : public Sequence {
private:
	static const void *itemsInfo[16];
	static bool itemsPres[16];
public:
	static const Info theInfo;
	KeplerianParameters(): Sequence(&theInfo) {}

	void setKeplerianParametersToenav(const KeplerianParametersToenav& keplerianParametersToenav) { *static_cast<KeplerianParametersToenav*>(items[0]) = keplerianParametersToenav; }
	void setKeplerianParametersGanssomeganav(const KeplerianParametersGanssomeganav& keplerianParametersGanssomeganav) { *static_cast<KeplerianParametersGanssomeganav*>(items[1]) = keplerianParametersGanssomeganav; }
	void setKeplerianParametersDeltannav(const KeplerianParametersDeltannav& keplerianParametersDeltannav) { *static_cast<KeplerianParametersDeltannav*>(items[2]) = keplerianParametersDeltannav; }
	void setKeplerianParametersMzeronav(const KeplerianParametersMzeronav& keplerianParametersMzeronav) { *static_cast<KeplerianParametersMzeronav*>(items[3]) = keplerianParametersMzeronav; }
	void setKeplerianParametersOmegadotnav(const KeplerianParametersOmegadotnav& keplerianParametersOmegadotnav) { *static_cast<KeplerianParametersOmegadotnav*>(items[4]) = keplerianParametersOmegadotnav; }
	void setKeplerianParametersGanssenav(const KeplerianParametersGanssenav& keplerianParametersGanssenav) { *static_cast<KeplerianParametersGanssenav*>(items[5]) = keplerianParametersGanssenav; }
	void setKeplerianParametersIdotnav(const KeplerianParametersIdotnav& keplerianParametersIdotnav) { *static_cast<KeplerianParametersIdotnav*>(items[6]) = keplerianParametersIdotnav; }
	void setKeplerianParametersAsqrtnav(const KeplerianParametersAsqrtnav& keplerianParametersAsqrtnav) { *static_cast<KeplerianParametersAsqrtnav*>(items[7]) = keplerianParametersAsqrtnav; }
	void setKeplerianParametersIzeronav(const KeplerianParametersIzeronav& keplerianParametersIzeronav) { *static_cast<KeplerianParametersIzeronav*>(items[8]) = keplerianParametersIzeronav; }
	void setKeplerianParametersOmegazeronav(const KeplerianParametersOmegazeronav& keplerianParametersOmegazeronav) { *static_cast<KeplerianParametersOmegazeronav*>(items[9]) = keplerianParametersOmegazeronav; }
	void setKeplerianParametersCrsnav(const KeplerianParametersCrsnav& keplerianParametersCrsnav) { *static_cast<KeplerianParametersCrsnav*>(items[10]) = keplerianParametersCrsnav; }
	void setKeplerianParametersCisnav(const KeplerianParametersCisnav& keplerianParametersCisnav) { *static_cast<KeplerianParametersCisnav*>(items[11]) = keplerianParametersCisnav; }
	void setKeplerianParametersCusnav(const KeplerianParametersCusnav& keplerianParametersCusnav) { *static_cast<KeplerianParametersCusnav*>(items[12]) = keplerianParametersCusnav; }
	void setKeplerianParametersCrcnav(const KeplerianParametersCrcnav& keplerianParametersCrcnav) { *static_cast<KeplerianParametersCrcnav*>(items[13]) = keplerianParametersCrcnav; }
	void setKeplerianParametersCicnav(const KeplerianParametersCicnav& keplerianParametersCicnav) { *static_cast<KeplerianParametersCicnav*>(items[14]) = keplerianParametersCicnav; }
	void setKeplerianParametersCucnav(const KeplerianParametersCucnav& keplerianParametersCucnav) { *static_cast<KeplerianParametersCucnav*>(items[15]) = keplerianParametersCucnav; }
};

class UEPositioningGANSSOrbitModel : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningGANSSOrbitModel(): Sequence(&theInfo) {}

	void setKeplerianParameters(const KeplerianParameters& keplerianParameters) { *static_cast<KeplerianParameters*>(items[0]) = keplerianParameters; }
};

class GanssSatInfoNav : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	GanssSatInfoNav(): Sequence(&theInfo) {}

	void setGanssSatInfoNavSatId(const GanssSatInfoNavSatId& ganssSatInfoNavSatId) { *static_cast<GanssSatInfoNavSatId*>(items[0]) = ganssSatInfoNavSatId; }
	void setGanssSatInfoNavSvHealth(const GanssSatInfoNavSvHealth& ganssSatInfoNavSvHealth) { *static_cast<GanssSatInfoNavSvHealth*>(items[1]) = ganssSatInfoNavSvHealth; }
	void setGanssSatInfoNavIod(const GanssSatInfoNavIod& ganssSatInfoNavIod) { *static_cast<GanssSatInfoNavIod*>(items[2]) = ganssSatInfoNavIod; }
	void setGanssClockModel(const UEPositioningGANSSClockModel& ganssClockModel) { *static_cast<UEPositioningGANSSClockModel*>(items[3]) = ganssClockModel; }
	void setGanssOrbitModel(const UEPositioningGANSSOrbitModel& ganssOrbitModel) { *static_cast<UEPositioningGANSSOrbitModel*>(items[4]) = ganssOrbitModel; }
};

typedef SequenceOf<GanssSatInfoNav, CONSTRAINED, 1, maxGANSSSat> GanssSatInfoNavList;

class UEPositioningGANSSNavigationModel : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningGANSSNavigationModel(): Sequence(&theInfo) {}

	void setUEPositioningGANSSNavigationModelnon_broadcastIndication(const UEPositioningGANSSNavigationModelnon_broadcastIndication& uEPositioningGANSSNavigationModelnon_broadcastIndication) { *static_cast<UEPositioningGANSSNavigationModelnon_broadcastIndication*>(items[0]) = uEPositioningGANSSNavigationModelnon_broadcastIndication; }
	void setGanssSatInfoNavList(const GanssSatInfoNavList& ganssSatInfoNavList) { *static_cast<GanssSatInfoNavList*>(items[1]) = ganssSatInfoNavList; }
};

class UEPositioningGANSSRealTimeIntegrity : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	UEPositioningGANSSRealTimeIntegrity(): Sequence(&theInfo) {}

};

typedef Integer<CONSTRAINED, 0, 59> UEPositioningGANSSDataBitAssistanceGansstod;

class UEPositioningGANSSDataBitAssistance : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningGANSSDataBitAssistance(): Sequence(&theInfo) {}

	void setUEPositioningGANSSDataBitAssistanceGansstod(const UEPositioningGANSSDataBitAssistanceGansstod& uEPositioningGANSSDataBitAssistanceGansstod) { *static_cast<UEPositioningGANSSDataBitAssistanceGansstod*>(items[0]) = uEPositioningGANSSDataBitAssistanceGansstod; }
	void setDataBitAssistanceList(const DataBitAssistanceList& dataBitAssistanceList) { *static_cast<DataBitAssistanceList*>(items[1]) = dataBitAssistanceList; }
};

typedef Integer<CONSTRAINED, 0, 63> GANSSSatelliteInformationGanssSatId;

typedef Integer<CONSTRAINED, 0, 1023> GANSSSatelliteInformationCodePhase;

typedef Integer<CONSTRAINED, 0, 127> GANSSSatelliteInformationIntegerCodePhase;

typedef BitString<CONSTRAINED, 5, 5> GANSSSatelliteInformationCodePhaseSearchWindow;

class GANSSSatelliteInformation : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	GANSSSatelliteInformation(): Sequence(&theInfo) {}

	void setGANSSSatelliteInformationGanssSatId(const GANSSSatelliteInformationGanssSatId& gANSSSatelliteInformationGanssSatId) { *static_cast<GANSSSatelliteInformationGanssSatId*>(items[0]) = gANSSSatelliteInformationGanssSatId; }
	void setExtraDoppler(const ExtraDoppler& extraDoppler) { *static_cast<ExtraDoppler*>(items[1]) = extraDoppler; }
	void setGANSSSatelliteInformationCodePhase(const GANSSSatelliteInformationCodePhase& gANSSSatelliteInformationCodePhase) { *static_cast<GANSSSatelliteInformationCodePhase*>(items[2]) = gANSSSatelliteInformationCodePhase; }
	void setGANSSSatelliteInformationIntegerCodePhase(const GANSSSatelliteInformationIntegerCodePhase& gANSSSatelliteInformationIntegerCodePhase) { *static_cast<GANSSSatelliteInformationIntegerCodePhase*>(items[3]) = gANSSSatelliteInformationIntegerCodePhase; }
	void setGANSSSatelliteInformationCodePhaseSearchWindow(const GANSSSatelliteInformationCodePhaseSearchWindow& gANSSSatelliteInformationCodePhaseSearchWindow) { *static_cast<GANSSSatelliteInformationCodePhaseSearchWindow*>(items[4]) = gANSSSatelliteInformationCodePhaseSearchWindow; }
	void setAzimuthandElevation(const AzimuthAndElevation& azimuthandElevation) { *static_cast<AzimuthAndElevation*>(items[5]) = azimuthandElevation; }
};

typedef SequenceOf<GANSSSatelliteInformation, CONSTRAINED, 1, maxGANSSSat> GANSSSatelliteInformationList;

class UEPositioningGANSSReferenceMeasurementInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningGANSSReferenceMeasurementInfo(): Sequence(&theInfo) {}

	void setGanssSignalId(const GANSSSignalId& ganssSignalId) { *static_cast<GANSSSignalId*>(items[0]) = ganssSignalId; }
	void setSatelliteInformationList(const GANSSSatelliteInformationList& satelliteInformationList) { *static_cast<GANSSSatelliteInformationList*>(items[1]) = satelliteInformationList; }
};

typedef Integer<CONSTRAINED, 0, 255> UEPositioningGANSSAlmanacGansswknumber;

class UEPositioningGANSSAlmanac : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningGANSSAlmanac(): Sequence(&theInfo) {}

	void setUEPositioningGANSSAlmanacGansswknumber(const UEPositioningGANSSAlmanacGansswknumber& uEPositioningGANSSAlmanacGansswknumber) { *static_cast<UEPositioningGANSSAlmanacGansswknumber*>(items[0]) = uEPositioningGANSSAlmanacGansswknumber; }
	void setAlmkeplerianParameters(const ALMkeplerianParameters& almkeplerianParameters) { *static_cast<ALMkeplerianParameters*>(items[1]) = almkeplerianParameters; }
};

typedef BitString<CONSTRAINED, 24, 24> UEPositioningGANSSUTCModelAoneutc;

typedef BitString<CONSTRAINED, 32, 32> UEPositioningGANSSUTCModelAzeroutc;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGANSSUTCModelTotutc;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGANSSUTCModelDeltatlsutc;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGANSSUTCModelWntutc;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGANSSUTCModelWnlsfutc;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGANSSUTCModelDnutc;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGANSSUTCModelDeltatlsfutc;

class UEPositioningGANSSUTCModel : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	UEPositioningGANSSUTCModel(): Sequence(&theInfo) {}

	void setUEPositioningGANSSUTCModelAoneutc(const UEPositioningGANSSUTCModelAoneutc& uEPositioningGANSSUTCModelAoneutc) { *static_cast<UEPositioningGANSSUTCModelAoneutc*>(items[0]) = uEPositioningGANSSUTCModelAoneutc; }
	void setUEPositioningGANSSUTCModelAzeroutc(const UEPositioningGANSSUTCModelAzeroutc& uEPositioningGANSSUTCModelAzeroutc) { *static_cast<UEPositioningGANSSUTCModelAzeroutc*>(items[1]) = uEPositioningGANSSUTCModelAzeroutc; }
	void setUEPositioningGANSSUTCModelTotutc(const UEPositioningGANSSUTCModelTotutc& uEPositioningGANSSUTCModelTotutc) { *static_cast<UEPositioningGANSSUTCModelTotutc*>(items[2]) = uEPositioningGANSSUTCModelTotutc; }
	void setUEPositioningGANSSUTCModelDeltatlsutc(const UEPositioningGANSSUTCModelDeltatlsutc& uEPositioningGANSSUTCModelDeltatlsutc) { *static_cast<UEPositioningGANSSUTCModelDeltatlsutc*>(items[3]) = uEPositioningGANSSUTCModelDeltatlsutc; }
	void setUEPositioningGANSSUTCModelWntutc(const UEPositioningGANSSUTCModelWntutc& uEPositioningGANSSUTCModelWntutc) { *static_cast<UEPositioningGANSSUTCModelWntutc*>(items[4]) = uEPositioningGANSSUTCModelWntutc; }
	void setUEPositioningGANSSUTCModelWnlsfutc(const UEPositioningGANSSUTCModelWnlsfutc& uEPositioningGANSSUTCModelWnlsfutc) { *static_cast<UEPositioningGANSSUTCModelWnlsfutc*>(items[5]) = uEPositioningGANSSUTCModelWnlsfutc; }
	void setUEPositioningGANSSUTCModelDnutc(const UEPositioningGANSSUTCModelDnutc& uEPositioningGANSSUTCModelDnutc) { *static_cast<UEPositioningGANSSUTCModelDnutc*>(items[6]) = uEPositioningGANSSUTCModelDnutc; }
	void setUEPositioningGANSSUTCModelDeltatlsfutc(const UEPositioningGANSSUTCModelDeltatlsfutc& uEPositioningGANSSUTCModelDeltatlsfutc) { *static_cast<UEPositioningGANSSUTCModelDeltatlsfutc*>(items[7]) = uEPositioningGANSSUTCModelDeltatlsfutc; }
};

class GANSSGenericData : public Sequence {
private:
	static const void *itemsInfo[9];
	static bool itemsPres[9];
public:
	static const Info theInfo;
	GANSSGenericData(): Sequence(&theInfo) {}

	void setGANSSGenericDataGanssId(const GANSSGenericDataGanssId& gANSSGenericDataGanssId) { *static_cast<GANSSGenericDataGanssId*>(items[0]) = gANSSGenericDataGanssId; }
	void setGanssTimeModelsList(const GANSSTimeModelsList& ganssTimeModelsList) { *static_cast<GANSSTimeModelsList*>(items[1]) = ganssTimeModelsList; }
	void setUePositioningDGANSSCorrections(const UEPositioningDGANSSCorrections& uePositioningDGANSSCorrections) { *static_cast<UEPositioningDGANSSCorrections*>(items[2]) = uePositioningDGANSSCorrections; }
	void setUePositioningGANSSNavigationModel(const UEPositioningGANSSNavigationModel& uePositioningGANSSNavigationModel) { *static_cast<UEPositioningGANSSNavigationModel*>(items[3]) = uePositioningGANSSNavigationModel; }
	void setUePositioningGANSSRealTimeIntegrity(const UEPositioningGANSSRealTimeIntegrity& uePositioningGANSSRealTimeIntegrity) { *static_cast<UEPositioningGANSSRealTimeIntegrity*>(items[4]) = uePositioningGANSSRealTimeIntegrity; }
	void setUePositioningGANSSDataBitAssistance(const UEPositioningGANSSDataBitAssistance& uePositioningGANSSDataBitAssistance) { *static_cast<UEPositioningGANSSDataBitAssistance*>(items[5]) = uePositioningGANSSDataBitAssistance; }
	void setUePositioningGANSSReferenceMeasurementInfo(const UEPositioningGANSSReferenceMeasurementInfo& uePositioningGANSSReferenceMeasurementInfo) { *static_cast<UEPositioningGANSSReferenceMeasurementInfo*>(items[6]) = uePositioningGANSSReferenceMeasurementInfo; }
	void setUePositioningGANSSAlmanac(const UEPositioningGANSSAlmanac& uePositioningGANSSAlmanac) { *static_cast<UEPositioningGANSSAlmanac*>(items[7]) = uePositioningGANSSAlmanac; }
	void setUePositioningGANSSUTCModel(const UEPositioningGANSSUTCModel& uePositioningGANSSUTCModel) { *static_cast<UEPositioningGANSSUTCModel*>(items[8]) = uePositioningGANSSUTCModel; }
};

enum UEPositioningGANSSSBASIDValues {
	waas_UEPositioningGANSSSBASID = 0,
	egnos_UEPositioningGANSSSBASID = 1,
	msas_UEPositioningGANSSSBASID = 2,
	gagan_UEPositioningGANSSSBASID = 3,
	spare4_UEPositioningGANSSSBASID = 4,
	spare3_UEPositioningGANSSSBASID = 5,
	spare2_UEPositioningGANSSSBASID = 6,
	spare1_UEPositioningGANSSSBASID = 7,
};
typedef Enumerated<CONSTRAINED, 7> UEPositioningGANSSSBASID;

enum UEPositioningGANSSAddNavigationModelsnon_broadcastIndicationValues {
	true_UEPositioningGANSSAddNavigationModelsnon_broadcastIndication = 0,
};
typedef Enumerated<CONSTRAINED, 0> UEPositioningGANSSAddNavigationModelsnon_broadcastIndication;

typedef Integer<CONSTRAINED, 0, 63> GanssSatInfoAddNavSatId;

typedef BitString<CONSTRAINED, 6, 6> GanssSatInfoAddNavSvHealth;

typedef BitString<CONSTRAINED, 11, 11> GanssSatInfoAddNavIod;

typedef BitString<CONSTRAINED, 16, 16> NAVclockModelNavToc;

typedef BitString<CONSTRAINED, 8, 8> NAVclockModelNavaf2;

typedef BitString<CONSTRAINED, 16, 16> NAVclockModelNavaf1;

typedef BitString<CONSTRAINED, 22, 22> NAVclockModelNavaf0;

typedef BitString<CONSTRAINED, 8, 8> NAVclockModelNavTgd;

class NAVclockModel : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	NAVclockModel(): Sequence(&theInfo) {}

	void setNAVclockModelNavToc(const NAVclockModelNavToc& nAVclockModelNavToc) { *static_cast<NAVclockModelNavToc*>(items[0]) = nAVclockModelNavToc; }
	void setNAVclockModelNavaf2(const NAVclockModelNavaf2& nAVclockModelNavaf2) { *static_cast<NAVclockModelNavaf2*>(items[1]) = nAVclockModelNavaf2; }
	void setNAVclockModelNavaf1(const NAVclockModelNavaf1& nAVclockModelNavaf1) { *static_cast<NAVclockModelNavaf1*>(items[2]) = nAVclockModelNavaf1; }
	void setNAVclockModelNavaf0(const NAVclockModelNavaf0& nAVclockModelNavaf0) { *static_cast<NAVclockModelNavaf0*>(items[3]) = nAVclockModelNavaf0; }
	void setNAVclockModelNavTgd(const NAVclockModelNavTgd& nAVclockModelNavTgd) { *static_cast<NAVclockModelNavTgd*>(items[4]) = nAVclockModelNavTgd; }
};

typedef BitString<CONSTRAINED, 22, 22> GLONASSclockModelGloTau;

typedef BitString<CONSTRAINED, 11, 11> GLONASSclockModelGloGamma;

typedef BitString<CONSTRAINED, 5, 5> GLONASSclockModelGloDeltaTau;

class GLONASSclockModel : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	GLONASSclockModel(): Sequence(&theInfo) {}

	void setGLONASSclockModelGloTau(const GLONASSclockModelGloTau& gLONASSclockModelGloTau) { *static_cast<GLONASSclockModelGloTau*>(items[0]) = gLONASSclockModelGloTau; }
	void setGLONASSclockModelGloGamma(const GLONASSclockModelGloGamma& gLONASSclockModelGloGamma) { *static_cast<GLONASSclockModelGloGamma*>(items[1]) = gLONASSclockModelGloGamma; }
	void setGLONASSclockModelGloDeltaTau(const GLONASSclockModelGloDeltaTau& gLONASSclockModelGloDeltaTau) { *static_cast<GLONASSclockModelGloDeltaTau*>(items[2]) = gLONASSclockModelGloDeltaTau; }
};

typedef BitString<CONSTRAINED, 13, 13> SBASclockModelSbasTo;

typedef BitString<CONSTRAINED, 12, 12> SBASclockModelSbasAgfo;

typedef BitString<CONSTRAINED, 8, 8> SBASclockModelSbasAgf1;

class SBASclockModel : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SBASclockModel(): Sequence(&theInfo) {}

	void setSBASclockModelSbasTo(const SBASclockModelSbasTo& sBASclockModelSbasTo) { *static_cast<SBASclockModelSbasTo*>(items[0]) = sBASclockModelSbasTo; }
	void setSBASclockModelSbasAgfo(const SBASclockModelSbasAgfo& sBASclockModelSbasAgfo) { *static_cast<SBASclockModelSbasAgfo*>(items[1]) = sBASclockModelSbasAgfo; }
	void setSBASclockModelSbasAgf1(const SBASclockModelSbasAgf1& sBASclockModelSbasAgf1) { *static_cast<SBASclockModelSbasAgf1*>(items[2]) = sBASclockModelSbasAgf1; }
};

class UEPositioningGANSSAddClockModels : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UEPositioningGANSSAddClockModels(): Sequence(&theInfo) {}

	void setNavClockModel(const NAVclockModel& navClockModel) { *static_cast<NAVclockModel*>(items[0]) = navClockModel; }
	void setCnavClockModel(const CNAVclockModel& cnavClockModel) { *static_cast<CNAVclockModel*>(items[1]) = cnavClockModel; }
	void setGlonassClockModel(const GLONASSclockModel& glonassClockModel) { *static_cast<GLONASSclockModel*>(items[2]) = glonassClockModel; }
	void setSbasClockModel(const SBASclockModel& sbasClockModel) { *static_cast<SBASclockModel*>(items[3]) = sbasClockModel; }
};

typedef BitString<CONSTRAINED, 4, 4> NavModelNAVKeplerianSetNavURA;

typedef BitString<CONSTRAINED, 1, 1> NavModelNAVKeplerianSetNavFitFlag;

typedef BitString<CONSTRAINED, 16, 16> NavModelNAVKeplerianSetNavToe;

typedef BitString<CONSTRAINED, 32, 32> NavModelNAVKeplerianSetNavOmega;

typedef BitString<CONSTRAINED, 16, 16> NavModelNAVKeplerianSetNavDeltaN;

typedef BitString<CONSTRAINED, 32, 32> NavModelNAVKeplerianSetNavM0;

typedef BitString<CONSTRAINED, 24, 24> NavModelNAVKeplerianSetNavOmegaADot;

typedef BitString<CONSTRAINED, 32, 32> NavModelNAVKeplerianSetNavE;

typedef BitString<CONSTRAINED, 14, 14> NavModelNAVKeplerianSetNavIDot;

typedef BitString<CONSTRAINED, 32, 32> NavModelNAVKeplerianSetNavAPowerHalf;

typedef BitString<CONSTRAINED, 32, 32> NavModelNAVKeplerianSetNavI0;

typedef BitString<CONSTRAINED, 32, 32> NavModelNAVKeplerianSetNavOmegaA0;

typedef BitString<CONSTRAINED, 16, 16> NavModelNAVKeplerianSetNavCrs;

typedef BitString<CONSTRAINED, 16, 16> NavModelNAVKeplerianSetNavCis;

typedef BitString<CONSTRAINED, 16, 16> NavModelNAVKeplerianSetNavCus;

typedef BitString<CONSTRAINED, 16, 16> NavModelNAVKeplerianSetNavCrc;

typedef BitString<CONSTRAINED, 16, 16> NavModelNAVKeplerianSetNavCic;

typedef BitString<CONSTRAINED, 16, 16> NavModelNAVKeplerianSetNavCuc;

class NavModelNAVKeplerianSet : public Sequence {
private:
	static const void *itemsInfo[18];
	static bool itemsPres[18];
public:
	static const Info theInfo;
	NavModelNAVKeplerianSet(): Sequence(&theInfo) {}

	void setNavModelNAVKeplerianSetNavURA(const NavModelNAVKeplerianSetNavURA& navModelNAVKeplerianSetNavURA) { *static_cast<NavModelNAVKeplerianSetNavURA*>(items[0]) = navModelNAVKeplerianSetNavURA; }
	void setNavModelNAVKeplerianSetNavFitFlag(const NavModelNAVKeplerianSetNavFitFlag& navModelNAVKeplerianSetNavFitFlag) { *static_cast<NavModelNAVKeplerianSetNavFitFlag*>(items[1]) = navModelNAVKeplerianSetNavFitFlag; }
	void setNavModelNAVKeplerianSetNavToe(const NavModelNAVKeplerianSetNavToe& navModelNAVKeplerianSetNavToe) { *static_cast<NavModelNAVKeplerianSetNavToe*>(items[2]) = navModelNAVKeplerianSetNavToe; }
	void setNavModelNAVKeplerianSetNavOmega(const NavModelNAVKeplerianSetNavOmega& navModelNAVKeplerianSetNavOmega) { *static_cast<NavModelNAVKeplerianSetNavOmega*>(items[3]) = navModelNAVKeplerianSetNavOmega; }
	void setNavModelNAVKeplerianSetNavDeltaN(const NavModelNAVKeplerianSetNavDeltaN& navModelNAVKeplerianSetNavDeltaN) { *static_cast<NavModelNAVKeplerianSetNavDeltaN*>(items[4]) = navModelNAVKeplerianSetNavDeltaN; }
	void setNavModelNAVKeplerianSetNavM0(const NavModelNAVKeplerianSetNavM0& navModelNAVKeplerianSetNavM0) { *static_cast<NavModelNAVKeplerianSetNavM0*>(items[5]) = navModelNAVKeplerianSetNavM0; }
	void setNavModelNAVKeplerianSetNavOmegaADot(const NavModelNAVKeplerianSetNavOmegaADot& navModelNAVKeplerianSetNavOmegaADot) { *static_cast<NavModelNAVKeplerianSetNavOmegaADot*>(items[6]) = navModelNAVKeplerianSetNavOmegaADot; }
	void setNavModelNAVKeplerianSetNavE(const NavModelNAVKeplerianSetNavE& navModelNAVKeplerianSetNavE) { *static_cast<NavModelNAVKeplerianSetNavE*>(items[7]) = navModelNAVKeplerianSetNavE; }
	void setNavModelNAVKeplerianSetNavIDot(const NavModelNAVKeplerianSetNavIDot& navModelNAVKeplerianSetNavIDot) { *static_cast<NavModelNAVKeplerianSetNavIDot*>(items[8]) = navModelNAVKeplerianSetNavIDot; }
	void setNavModelNAVKeplerianSetNavAPowerHalf(const NavModelNAVKeplerianSetNavAPowerHalf& navModelNAVKeplerianSetNavAPowerHalf) { *static_cast<NavModelNAVKeplerianSetNavAPowerHalf*>(items[9]) = navModelNAVKeplerianSetNavAPowerHalf; }
	void setNavModelNAVKeplerianSetNavI0(const NavModelNAVKeplerianSetNavI0& navModelNAVKeplerianSetNavI0) { *static_cast<NavModelNAVKeplerianSetNavI0*>(items[10]) = navModelNAVKeplerianSetNavI0; }
	void setNavModelNAVKeplerianSetNavOmegaA0(const NavModelNAVKeplerianSetNavOmegaA0& navModelNAVKeplerianSetNavOmegaA0) { *static_cast<NavModelNAVKeplerianSetNavOmegaA0*>(items[11]) = navModelNAVKeplerianSetNavOmegaA0; }
	void setNavModelNAVKeplerianSetNavCrs(const NavModelNAVKeplerianSetNavCrs& navModelNAVKeplerianSetNavCrs) { *static_cast<NavModelNAVKeplerianSetNavCrs*>(items[12]) = navModelNAVKeplerianSetNavCrs; }
	void setNavModelNAVKeplerianSetNavCis(const NavModelNAVKeplerianSetNavCis& navModelNAVKeplerianSetNavCis) { *static_cast<NavModelNAVKeplerianSetNavCis*>(items[13]) = navModelNAVKeplerianSetNavCis; }
	void setNavModelNAVKeplerianSetNavCus(const NavModelNAVKeplerianSetNavCus& navModelNAVKeplerianSetNavCus) { *static_cast<NavModelNAVKeplerianSetNavCus*>(items[14]) = navModelNAVKeplerianSetNavCus; }
	void setNavModelNAVKeplerianSetNavCrc(const NavModelNAVKeplerianSetNavCrc& navModelNAVKeplerianSetNavCrc) { *static_cast<NavModelNAVKeplerianSetNavCrc*>(items[15]) = navModelNAVKeplerianSetNavCrc; }
	void setNavModelNAVKeplerianSetNavCic(const NavModelNAVKeplerianSetNavCic& navModelNAVKeplerianSetNavCic) { *static_cast<NavModelNAVKeplerianSetNavCic*>(items[16]) = navModelNAVKeplerianSetNavCic; }
	void setNavModelNAVKeplerianSetNavCuc(const NavModelNAVKeplerianSetNavCuc& navModelNAVKeplerianSetNavCuc) { *static_cast<NavModelNAVKeplerianSetNavCuc*>(items[17]) = navModelNAVKeplerianSetNavCuc; }
};

typedef BitString<CONSTRAINED, 11, 11> NavModelCNAVKeplerianSetCnavTop;

typedef BitString<CONSTRAINED, 5, 5> NavModelCNAVKeplerianSetCnavURAindex;

typedef BitString<CONSTRAINED, 26, 26> NavModelCNAVKeplerianSetCnavDeltaA;

typedef BitString<CONSTRAINED, 25, 25> NavModelCNAVKeplerianSetCnavAdot;

typedef BitString<CONSTRAINED, 17, 17> NavModelCNAVKeplerianSetCnavDeltaNo;

typedef BitString<CONSTRAINED, 23, 23> NavModelCNAVKeplerianSetCnavDeltaNoDot;

typedef BitString<CONSTRAINED, 33, 33> NavModelCNAVKeplerianSetCnavMo;

typedef BitString<CONSTRAINED, 33, 33> NavModelCNAVKeplerianSetCnavE;

typedef BitString<CONSTRAINED, 33, 33> NavModelCNAVKeplerianSetCnavOmega;

typedef BitString<CONSTRAINED, 33, 33> NavModelCNAVKeplerianSetCnavOMEGA0;

typedef BitString<CONSTRAINED, 17, 17> NavModelCNAVKeplerianSetCnavDeltaOmegaDot;

typedef BitString<CONSTRAINED, 33, 33> NavModelCNAVKeplerianSetCnavIo;

typedef BitString<CONSTRAINED, 15, 15> NavModelCNAVKeplerianSetCnavIoDot;

typedef BitString<CONSTRAINED, 16, 16> NavModelCNAVKeplerianSetCnavCis;

typedef BitString<CONSTRAINED, 16, 16> NavModelCNAVKeplerianSetCnavCic;

typedef BitString<CONSTRAINED, 24, 24> NavModelCNAVKeplerianSetCnavCrs;

typedef BitString<CONSTRAINED, 24, 24> NavModelCNAVKeplerianSetCnavCrc;

typedef BitString<CONSTRAINED, 21, 21> NavModelCNAVKeplerianSetCnavCus;

typedef BitString<CONSTRAINED, 21, 21> NavModelCNAVKeplerianSetCnavCuc;

class NavModelCNAVKeplerianSet : public Sequence {
private:
	static const void *itemsInfo[19];
	static bool itemsPres[19];
public:
	static const Info theInfo;
	NavModelCNAVKeplerianSet(): Sequence(&theInfo) {}

	void setNavModelCNAVKeplerianSetCnavTop(const NavModelCNAVKeplerianSetCnavTop& navModelCNAVKeplerianSetCnavTop) { *static_cast<NavModelCNAVKeplerianSetCnavTop*>(items[0]) = navModelCNAVKeplerianSetCnavTop; }
	void setNavModelCNAVKeplerianSetCnavURAindex(const NavModelCNAVKeplerianSetCnavURAindex& navModelCNAVKeplerianSetCnavURAindex) { *static_cast<NavModelCNAVKeplerianSetCnavURAindex*>(items[1]) = navModelCNAVKeplerianSetCnavURAindex; }
	void setNavModelCNAVKeplerianSetCnavDeltaA(const NavModelCNAVKeplerianSetCnavDeltaA& navModelCNAVKeplerianSetCnavDeltaA) { *static_cast<NavModelCNAVKeplerianSetCnavDeltaA*>(items[2]) = navModelCNAVKeplerianSetCnavDeltaA; }
	void setNavModelCNAVKeplerianSetCnavAdot(const NavModelCNAVKeplerianSetCnavAdot& navModelCNAVKeplerianSetCnavAdot) { *static_cast<NavModelCNAVKeplerianSetCnavAdot*>(items[3]) = navModelCNAVKeplerianSetCnavAdot; }
	void setNavModelCNAVKeplerianSetCnavDeltaNo(const NavModelCNAVKeplerianSetCnavDeltaNo& navModelCNAVKeplerianSetCnavDeltaNo) { *static_cast<NavModelCNAVKeplerianSetCnavDeltaNo*>(items[4]) = navModelCNAVKeplerianSetCnavDeltaNo; }
	void setNavModelCNAVKeplerianSetCnavDeltaNoDot(const NavModelCNAVKeplerianSetCnavDeltaNoDot& navModelCNAVKeplerianSetCnavDeltaNoDot) { *static_cast<NavModelCNAVKeplerianSetCnavDeltaNoDot*>(items[5]) = navModelCNAVKeplerianSetCnavDeltaNoDot; }
	void setNavModelCNAVKeplerianSetCnavMo(const NavModelCNAVKeplerianSetCnavMo& navModelCNAVKeplerianSetCnavMo) { *static_cast<NavModelCNAVKeplerianSetCnavMo*>(items[6]) = navModelCNAVKeplerianSetCnavMo; }
	void setNavModelCNAVKeplerianSetCnavE(const NavModelCNAVKeplerianSetCnavE& navModelCNAVKeplerianSetCnavE) { *static_cast<NavModelCNAVKeplerianSetCnavE*>(items[7]) = navModelCNAVKeplerianSetCnavE; }
	void setNavModelCNAVKeplerianSetCnavOmega(const NavModelCNAVKeplerianSetCnavOmega& navModelCNAVKeplerianSetCnavOmega) { *static_cast<NavModelCNAVKeplerianSetCnavOmega*>(items[8]) = navModelCNAVKeplerianSetCnavOmega; }
	void setNavModelCNAVKeplerianSetCnavOMEGA0(const NavModelCNAVKeplerianSetCnavOMEGA0& navModelCNAVKeplerianSetCnavOMEGA0) { *static_cast<NavModelCNAVKeplerianSetCnavOMEGA0*>(items[9]) = navModelCNAVKeplerianSetCnavOMEGA0; }
	void setNavModelCNAVKeplerianSetCnavDeltaOmegaDot(const NavModelCNAVKeplerianSetCnavDeltaOmegaDot& navModelCNAVKeplerianSetCnavDeltaOmegaDot) { *static_cast<NavModelCNAVKeplerianSetCnavDeltaOmegaDot*>(items[10]) = navModelCNAVKeplerianSetCnavDeltaOmegaDot; }
	void setNavModelCNAVKeplerianSetCnavIo(const NavModelCNAVKeplerianSetCnavIo& navModelCNAVKeplerianSetCnavIo) { *static_cast<NavModelCNAVKeplerianSetCnavIo*>(items[11]) = navModelCNAVKeplerianSetCnavIo; }
	void setNavModelCNAVKeplerianSetCnavIoDot(const NavModelCNAVKeplerianSetCnavIoDot& navModelCNAVKeplerianSetCnavIoDot) { *static_cast<NavModelCNAVKeplerianSetCnavIoDot*>(items[12]) = navModelCNAVKeplerianSetCnavIoDot; }
	void setNavModelCNAVKeplerianSetCnavCis(const NavModelCNAVKeplerianSetCnavCis& navModelCNAVKeplerianSetCnavCis) { *static_cast<NavModelCNAVKeplerianSetCnavCis*>(items[13]) = navModelCNAVKeplerianSetCnavCis; }
	void setNavModelCNAVKeplerianSetCnavCic(const NavModelCNAVKeplerianSetCnavCic& navModelCNAVKeplerianSetCnavCic) { *static_cast<NavModelCNAVKeplerianSetCnavCic*>(items[14]) = navModelCNAVKeplerianSetCnavCic; }
	void setNavModelCNAVKeplerianSetCnavCrs(const NavModelCNAVKeplerianSetCnavCrs& navModelCNAVKeplerianSetCnavCrs) { *static_cast<NavModelCNAVKeplerianSetCnavCrs*>(items[15]) = navModelCNAVKeplerianSetCnavCrs; }
	void setNavModelCNAVKeplerianSetCnavCrc(const NavModelCNAVKeplerianSetCnavCrc& navModelCNAVKeplerianSetCnavCrc) { *static_cast<NavModelCNAVKeplerianSetCnavCrc*>(items[16]) = navModelCNAVKeplerianSetCnavCrc; }
	void setNavModelCNAVKeplerianSetCnavCus(const NavModelCNAVKeplerianSetCnavCus& navModelCNAVKeplerianSetCnavCus) { *static_cast<NavModelCNAVKeplerianSetCnavCus*>(items[17]) = navModelCNAVKeplerianSetCnavCus; }
	void setNavModelCNAVKeplerianSetCnavCuc(const NavModelCNAVKeplerianSetCnavCuc& navModelCNAVKeplerianSetCnavCuc) { *static_cast<NavModelCNAVKeplerianSetCnavCuc*>(items[18]) = navModelCNAVKeplerianSetCnavCuc; }
};

typedef BitString<CONSTRAINED, 5, 5> NavModelGLONASSecefGloEn;

typedef BitString<CONSTRAINED, 2, 2> NavModelGLONASSecefGloP1;

typedef BitString<CONSTRAINED, 1, 1> NavModelGLONASSecefGloP2;

typedef BitString<CONSTRAINED, 2, 2> NavModelGLONASSecefGloM;

typedef BitString<CONSTRAINED, 27, 27> NavModelGLONASSecefGloX;

typedef BitString<CONSTRAINED, 24, 24> NavModelGLONASSecefGloXdot;

typedef BitString<CONSTRAINED, 5, 5> NavModelGLONASSecefGloXdotdot;

typedef BitString<CONSTRAINED, 27, 27> NavModelGLONASSecefGloY;

typedef BitString<CONSTRAINED, 24, 24> NavModelGLONASSecefGloYdot;

typedef BitString<CONSTRAINED, 5, 5> NavModelGLONASSecefGloYdotdot;

typedef BitString<CONSTRAINED, 27, 27> NavModelGLONASSecefGloZ;

typedef BitString<CONSTRAINED, 24, 24> NavModelGLONASSecefGloZdot;

typedef BitString<CONSTRAINED, 5, 5> NavModelGLONASSecefGloZdotdot;

class NavModelGLONASSecef : public Sequence {
private:
	static const void *itemsInfo[13];
	static bool itemsPres[13];
public:
	static const Info theInfo;
	NavModelGLONASSecef(): Sequence(&theInfo) {}

	void setNavModelGLONASSecefGloEn(const NavModelGLONASSecefGloEn& navModelGLONASSecefGloEn) { *static_cast<NavModelGLONASSecefGloEn*>(items[0]) = navModelGLONASSecefGloEn; }
	void setNavModelGLONASSecefGloP1(const NavModelGLONASSecefGloP1& navModelGLONASSecefGloP1) { *static_cast<NavModelGLONASSecefGloP1*>(items[1]) = navModelGLONASSecefGloP1; }
	void setNavModelGLONASSecefGloP2(const NavModelGLONASSecefGloP2& navModelGLONASSecefGloP2) { *static_cast<NavModelGLONASSecefGloP2*>(items[2]) = navModelGLONASSecefGloP2; }
	void setNavModelGLONASSecefGloM(const NavModelGLONASSecefGloM& navModelGLONASSecefGloM) { *static_cast<NavModelGLONASSecefGloM*>(items[3]) = navModelGLONASSecefGloM; }
	void setNavModelGLONASSecefGloX(const NavModelGLONASSecefGloX& navModelGLONASSecefGloX) { *static_cast<NavModelGLONASSecefGloX*>(items[4]) = navModelGLONASSecefGloX; }
	void setNavModelGLONASSecefGloXdot(const NavModelGLONASSecefGloXdot& navModelGLONASSecefGloXdot) { *static_cast<NavModelGLONASSecefGloXdot*>(items[5]) = navModelGLONASSecefGloXdot; }
	void setNavModelGLONASSecefGloXdotdot(const NavModelGLONASSecefGloXdotdot& navModelGLONASSecefGloXdotdot) { *static_cast<NavModelGLONASSecefGloXdotdot*>(items[6]) = navModelGLONASSecefGloXdotdot; }
	void setNavModelGLONASSecefGloY(const NavModelGLONASSecefGloY& navModelGLONASSecefGloY) { *static_cast<NavModelGLONASSecefGloY*>(items[7]) = navModelGLONASSecefGloY; }
	void setNavModelGLONASSecefGloYdot(const NavModelGLONASSecefGloYdot& navModelGLONASSecefGloYdot) { *static_cast<NavModelGLONASSecefGloYdot*>(items[8]) = navModelGLONASSecefGloYdot; }
	void setNavModelGLONASSecefGloYdotdot(const NavModelGLONASSecefGloYdotdot& navModelGLONASSecefGloYdotdot) { *static_cast<NavModelGLONASSecefGloYdotdot*>(items[9]) = navModelGLONASSecefGloYdotdot; }
	void setNavModelGLONASSecefGloZ(const NavModelGLONASSecefGloZ& navModelGLONASSecefGloZ) { *static_cast<NavModelGLONASSecefGloZ*>(items[10]) = navModelGLONASSecefGloZ; }
	void setNavModelGLONASSecefGloZdot(const NavModelGLONASSecefGloZdot& navModelGLONASSecefGloZdot) { *static_cast<NavModelGLONASSecefGloZdot*>(items[11]) = navModelGLONASSecefGloZdot; }
	void setNavModelGLONASSecefGloZdotdot(const NavModelGLONASSecefGloZdotdot& navModelGLONASSecefGloZdotdot) { *static_cast<NavModelGLONASSecefGloZdotdot*>(items[12]) = navModelGLONASSecefGloZdotdot; }
};

typedef BitString<CONSTRAINED, 13, 13> NavModelSBASecefSbasTo;

typedef BitString<CONSTRAINED, 4, 4> NavModelSBASecefSbasAccuracy;

typedef BitString<CONSTRAINED, 30, 30> NavModelSBASecefSbasXg;

typedef BitString<CONSTRAINED, 30, 30> NavModelSBASecefSbasYg;

typedef BitString<CONSTRAINED, 25, 25> NavModelSBASecefSbasZg;

typedef BitString<CONSTRAINED, 17, 17> NavModelSBASecefSbasXgDot;

typedef BitString<CONSTRAINED, 17, 17> NavModelSBASecefSbasYgDot;

typedef BitString<CONSTRAINED, 18, 18> NavModelSBASecefSbasZgDot;

typedef BitString<CONSTRAINED, 10, 10> NavModelSBASecefSbasXgDotDot;

typedef BitString<CONSTRAINED, 10, 10> NavModelSBASecefSbagYgDotDot;

typedef BitString<CONSTRAINED, 10, 10> NavModelSBASecefSbasZgDotDot;

class NavModelSBASecef : public Sequence {
private:
	static const void *itemsInfo[11];
	static bool itemsPres[11];
public:
	static const Info theInfo;
	NavModelSBASecef(): Sequence(&theInfo) {}

	void setNavModelSBASecefSbasTo(const NavModelSBASecefSbasTo& navModelSBASecefSbasTo) { *static_cast<NavModelSBASecefSbasTo*>(items[0]) = navModelSBASecefSbasTo; }
	void setNavModelSBASecefSbasAccuracy(const NavModelSBASecefSbasAccuracy& navModelSBASecefSbasAccuracy) { *static_cast<NavModelSBASecefSbasAccuracy*>(items[1]) = navModelSBASecefSbasAccuracy; }
	void setNavModelSBASecefSbasXg(const NavModelSBASecefSbasXg& navModelSBASecefSbasXg) { *static_cast<NavModelSBASecefSbasXg*>(items[2]) = navModelSBASecefSbasXg; }
	void setNavModelSBASecefSbasYg(const NavModelSBASecefSbasYg& navModelSBASecefSbasYg) { *static_cast<NavModelSBASecefSbasYg*>(items[3]) = navModelSBASecefSbasYg; }
	void setNavModelSBASecefSbasZg(const NavModelSBASecefSbasZg& navModelSBASecefSbasZg) { *static_cast<NavModelSBASecefSbasZg*>(items[4]) = navModelSBASecefSbasZg; }
	void setNavModelSBASecefSbasXgDot(const NavModelSBASecefSbasXgDot& navModelSBASecefSbasXgDot) { *static_cast<NavModelSBASecefSbasXgDot*>(items[5]) = navModelSBASecefSbasXgDot; }
	void setNavModelSBASecefSbasYgDot(const NavModelSBASecefSbasYgDot& navModelSBASecefSbasYgDot) { *static_cast<NavModelSBASecefSbasYgDot*>(items[6]) = navModelSBASecefSbasYgDot; }
	void setNavModelSBASecefSbasZgDot(const NavModelSBASecefSbasZgDot& navModelSBASecefSbasZgDot) { *static_cast<NavModelSBASecefSbasZgDot*>(items[7]) = navModelSBASecefSbasZgDot; }
	void setNavModelSBASecefSbasXgDotDot(const NavModelSBASecefSbasXgDotDot& navModelSBASecefSbasXgDotDot) { *static_cast<NavModelSBASecefSbasXgDotDot*>(items[8]) = navModelSBASecefSbasXgDotDot; }
	void setNavModelSBASecefSbagYgDotDot(const NavModelSBASecefSbagYgDotDot& navModelSBASecefSbagYgDotDot) { *static_cast<NavModelSBASecefSbagYgDotDot*>(items[9]) = navModelSBASecefSbagYgDotDot; }
	void setNavModelSBASecefSbasZgDotDot(const NavModelSBASecefSbasZgDotDot& navModelSBASecefSbasZgDotDot) { *static_cast<NavModelSBASecefSbasZgDotDot*>(items[10]) = navModelSBASecefSbasZgDotDot; }
};

class UEPositioningGANSSAddOrbitModels : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UEPositioningGANSSAddOrbitModels(): Sequence(&theInfo) {}

	void setNavKeplerianSet(const NavModelNAVKeplerianSet& navKeplerianSet) { *static_cast<NavModelNAVKeplerianSet*>(items[0]) = navKeplerianSet; }
	void setCnavKeplerianSet(const NavModelCNAVKeplerianSet& cnavKeplerianSet) { *static_cast<NavModelCNAVKeplerianSet*>(items[1]) = cnavKeplerianSet; }
	void setGlonassECEF(const NavModelGLONASSecef& glonassECEF) { *static_cast<NavModelGLONASSecef*>(items[2]) = glonassECEF; }
	void setSbasECEF(const NavModelSBASecef& sbasECEF) { *static_cast<NavModelSBASecef*>(items[3]) = sbasECEF; }
};

class GanssSatInfoAddNav : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	GanssSatInfoAddNav(): Sequence(&theInfo) {}

	void setGanssSatInfoAddNavSatId(const GanssSatInfoAddNavSatId& ganssSatInfoAddNavSatId) { *static_cast<GanssSatInfoAddNavSatId*>(items[0]) = ganssSatInfoAddNavSatId; }
	void setGanssSatInfoAddNavSvHealth(const GanssSatInfoAddNavSvHealth& ganssSatInfoAddNavSvHealth) { *static_cast<GanssSatInfoAddNavSvHealth*>(items[1]) = ganssSatInfoAddNavSvHealth; }
	void setGanssSatInfoAddNavIod(const GanssSatInfoAddNavIod& ganssSatInfoAddNavIod) { *static_cast<GanssSatInfoAddNavIod*>(items[2]) = ganssSatInfoAddNavIod; }
	void setGanssClockModel(const UEPositioningGANSSAddClockModels& ganssClockModel) { *static_cast<UEPositioningGANSSAddClockModels*>(items[3]) = ganssClockModel; }
	void setGanssOrbitModel(const UEPositioningGANSSAddOrbitModels& ganssOrbitModel) { *static_cast<UEPositioningGANSSAddOrbitModels*>(items[4]) = ganssOrbitModel; }
};

typedef SequenceOf<GanssSatInfoAddNav, CONSTRAINED, 1, maxGANSSSat> GanssSatInfoAddNavList;

class UEPositioningGANSSAddNavigationModels : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningGANSSAddNavigationModels(): Sequence(&theInfo) {}

	void setUEPositioningGANSSAddNavigationModelsnon_broadcastIndication(const UEPositioningGANSSAddNavigationModelsnon_broadcastIndication& uEPositioningGANSSAddNavigationModelsnon_broadcastIndication) { *static_cast<UEPositioningGANSSAddNavigationModelsnon_broadcastIndication*>(items[0]) = uEPositioningGANSSAddNavigationModelsnon_broadcastIndication; }
	void setGanssSatInfoNavList(const GanssSatInfoAddNavList& ganssSatInfoNavList) { *static_cast<GanssSatInfoAddNavList*>(items[1]) = ganssSatInfoNavList; }
};

class UEPositioningGANSSAlmanacv860ext : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	UEPositioningGANSSAlmanacv860ext(): Sequence(&theInfo) {}

	void setAlmkeplerianNAVAlmanac(const ALMNAVKeplerianSet& almkeplerianNAVAlmanac) { *static_cast<ALMNAVKeplerianSet*>(items[0]) = almkeplerianNAVAlmanac; }
	void setAlmkeplerianReducedAlmanac(const ALMReducedKeplerianSet& almkeplerianReducedAlmanac) { *static_cast<ALMReducedKeplerianSet*>(items[1]) = almkeplerianReducedAlmanac; }
	void setAlmkeplerianMidiAlmanac(const ALMMidiAlmanacSet& almkeplerianMidiAlmanac) { *static_cast<ALMMidiAlmanacSet*>(items[2]) = almkeplerianMidiAlmanac; }
	void setAlmkeplerianGLONASS(const ALMGlonassAlmanacSet& almkeplerianGLONASS) { *static_cast<ALMGlonassAlmanacSet*>(items[3]) = almkeplerianGLONASS; }
	void setAlmecefSBASAlmanac(const ALMECEFsbasAlmanacSet& almecefSBASAlmanac) { *static_cast<ALMECEFsbasAlmanacSet*>(items[4]) = almecefSBASAlmanac; }
};

typedef BitString<CONSTRAINED, 16, 16> UTCmodelSet1UtcA0;

typedef BitString<CONSTRAINED, 13, 13> UTCmodelSet1UtcA1;

typedef BitString<CONSTRAINED, 7, 7> UTCmodelSet1UtcA2;

typedef BitString<CONSTRAINED, 8, 8> UTCmodelSet1UtcDeltaTls;

typedef BitString<CONSTRAINED, 16, 16> UTCmodelSet1UtcTot;

typedef BitString<CONSTRAINED, 13, 13> UTCmodelSet1UtcWNot;

typedef BitString<CONSTRAINED, 8, 8> UTCmodelSet1UtcWNlsf;

typedef BitString<CONSTRAINED, 4, 4> UTCmodelSet1UtcDN;

typedef BitString<CONSTRAINED, 8, 8> UTCmodelSet1UtcDeltaTlsf;

class UTCmodelSet1 : public Sequence {
private:
	static const void *itemsInfo[9];
	static bool itemsPres[9];
public:
	static const Info theInfo;
	UTCmodelSet1(): Sequence(&theInfo) {}

	void setUTCmodelSet1UtcA0(const UTCmodelSet1UtcA0& uTCmodelSet1UtcA0) { *static_cast<UTCmodelSet1UtcA0*>(items[0]) = uTCmodelSet1UtcA0; }
	void setUTCmodelSet1UtcA1(const UTCmodelSet1UtcA1& uTCmodelSet1UtcA1) { *static_cast<UTCmodelSet1UtcA1*>(items[1]) = uTCmodelSet1UtcA1; }
	void setUTCmodelSet1UtcA2(const UTCmodelSet1UtcA2& uTCmodelSet1UtcA2) { *static_cast<UTCmodelSet1UtcA2*>(items[2]) = uTCmodelSet1UtcA2; }
	void setUTCmodelSet1UtcDeltaTls(const UTCmodelSet1UtcDeltaTls& uTCmodelSet1UtcDeltaTls) { *static_cast<UTCmodelSet1UtcDeltaTls*>(items[3]) = uTCmodelSet1UtcDeltaTls; }
	void setUTCmodelSet1UtcTot(const UTCmodelSet1UtcTot& uTCmodelSet1UtcTot) { *static_cast<UTCmodelSet1UtcTot*>(items[4]) = uTCmodelSet1UtcTot; }
	void setUTCmodelSet1UtcWNot(const UTCmodelSet1UtcWNot& uTCmodelSet1UtcWNot) { *static_cast<UTCmodelSet1UtcWNot*>(items[5]) = uTCmodelSet1UtcWNot; }
	void setUTCmodelSet1UtcWNlsf(const UTCmodelSet1UtcWNlsf& uTCmodelSet1UtcWNlsf) { *static_cast<UTCmodelSet1UtcWNlsf*>(items[6]) = uTCmodelSet1UtcWNlsf; }
	void setUTCmodelSet1UtcDN(const UTCmodelSet1UtcDN& uTCmodelSet1UtcDN) { *static_cast<UTCmodelSet1UtcDN*>(items[7]) = uTCmodelSet1UtcDN; }
	void setUTCmodelSet1UtcDeltaTlsf(const UTCmodelSet1UtcDeltaTlsf& uTCmodelSet1UtcDeltaTlsf) { *static_cast<UTCmodelSet1UtcDeltaTlsf*>(items[8]) = uTCmodelSet1UtcDeltaTlsf; }
};

typedef BitString<CONSTRAINED, 11, 11> UTCmodelSet2NA;

typedef BitString<CONSTRAINED, 32, 32> UTCmodelSet2TauC;

typedef BitString<CONSTRAINED, 2, 2> UTCmodelSet2Kp;

class UTCmodelSet2 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UTCmodelSet2(): Sequence(&theInfo) {}

	void setUTCmodelSet2NA(const UTCmodelSet2NA& uTCmodelSet2NA) { *static_cast<UTCmodelSet2NA*>(items[0]) = uTCmodelSet2NA; }
	void setUTCmodelSet2TauC(const UTCmodelSet2TauC& uTCmodelSet2TauC) { *static_cast<UTCmodelSet2TauC*>(items[1]) = uTCmodelSet2TauC; }
	void setDeltaUT1(const DeltaUT1& deltaUT1) { *static_cast<DeltaUT1*>(items[2]) = deltaUT1; }
	void setUTCmodelSet2Kp(const UTCmodelSet2Kp& uTCmodelSet2Kp) { *static_cast<UTCmodelSet2Kp*>(items[3]) = uTCmodelSet2Kp; }
};

typedef BitString<CONSTRAINED, 24, 24> UTCmodelSet3UtcA1wnt;

typedef BitString<CONSTRAINED, 32, 32> UTCmodelSet3UtcA0wnt;

typedef BitString<CONSTRAINED, 8, 8> UTCmodelSet3UtcTot;

typedef BitString<CONSTRAINED, 8, 8> UTCmodelSet3UtcWNt;

typedef BitString<CONSTRAINED, 8, 8> UTCmodelSet3UtcDeltaTls;

typedef BitString<CONSTRAINED, 8, 8> UTCmodelSet3UtcWNlsf;

typedef BitString<CONSTRAINED, 8, 8> UTCmodelSet3UtcDN;

typedef BitString<CONSTRAINED, 8, 8> UTCmodelSet3UtcDeltaTlsf;

typedef BitString<CONSTRAINED, 3, 3> UTCmodelSet3UtcStandardID;

class UTCmodelSet3 : public Sequence {
private:
	static const void *itemsInfo[9];
	static bool itemsPres[9];
public:
	static const Info theInfo;
	UTCmodelSet3(): Sequence(&theInfo) {}

	void setUTCmodelSet3UtcA1wnt(const UTCmodelSet3UtcA1wnt& uTCmodelSet3UtcA1wnt) { *static_cast<UTCmodelSet3UtcA1wnt*>(items[0]) = uTCmodelSet3UtcA1wnt; }
	void setUTCmodelSet3UtcA0wnt(const UTCmodelSet3UtcA0wnt& uTCmodelSet3UtcA0wnt) { *static_cast<UTCmodelSet3UtcA0wnt*>(items[1]) = uTCmodelSet3UtcA0wnt; }
	void setUTCmodelSet3UtcTot(const UTCmodelSet3UtcTot& uTCmodelSet3UtcTot) { *static_cast<UTCmodelSet3UtcTot*>(items[2]) = uTCmodelSet3UtcTot; }
	void setUTCmodelSet3UtcWNt(const UTCmodelSet3UtcWNt& uTCmodelSet3UtcWNt) { *static_cast<UTCmodelSet3UtcWNt*>(items[3]) = uTCmodelSet3UtcWNt; }
	void setUTCmodelSet3UtcDeltaTls(const UTCmodelSet3UtcDeltaTls& uTCmodelSet3UtcDeltaTls) { *static_cast<UTCmodelSet3UtcDeltaTls*>(items[4]) = uTCmodelSet3UtcDeltaTls; }
	void setUTCmodelSet3UtcWNlsf(const UTCmodelSet3UtcWNlsf& uTCmodelSet3UtcWNlsf) { *static_cast<UTCmodelSet3UtcWNlsf*>(items[5]) = uTCmodelSet3UtcWNlsf; }
	void setUTCmodelSet3UtcDN(const UTCmodelSet3UtcDN& uTCmodelSet3UtcDN) { *static_cast<UTCmodelSet3UtcDN*>(items[6]) = uTCmodelSet3UtcDN; }
	void setUTCmodelSet3UtcDeltaTlsf(const UTCmodelSet3UtcDeltaTlsf& uTCmodelSet3UtcDeltaTlsf) { *static_cast<UTCmodelSet3UtcDeltaTlsf*>(items[7]) = uTCmodelSet3UtcDeltaTlsf; }
	void setUTCmodelSet3UtcStandardID(const UTCmodelSet3UtcStandardID& uTCmodelSet3UtcStandardID) { *static_cast<UTCmodelSet3UtcStandardID*>(items[8]) = uTCmodelSet3UtcStandardID; }
};

class UEPositioningGANSSAddUTCModels : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UEPositioningGANSSAddUTCModels(): Sequence(&theInfo) {}

	void setUtcModel1(const UTCmodelSet1& utcModel1) { *static_cast<UTCmodelSet1*>(items[0]) = utcModel1; }
	void setUtcModel2(const UTCmodelSet2& utcModel2) { *static_cast<UTCmodelSet2*>(items[1]) = utcModel2; }
	void setUtcModel3(const UTCmodelSet3& utcModel3) { *static_cast<UTCmodelSet3*>(items[2]) = utcModel3; }
};

class UEPositioningGANSSAuxiliaryInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningGANSSAuxiliaryInfoChoices {
		ganssID1 = 0,
		ganssID3 = 1,
	};
	static const Info theInfo;
	UEPositioningGANSSAuxiliaryInfo(): Choice(&theInfo) {}
};

class GANSSGenericDatav860ext : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	GANSSGenericDatav860ext(): Sequence(&theInfo) {}

	void setUePositiningGANSSsbasID(const UEPositioningGANSSSBASID& uePositiningGANSSsbasID) { *static_cast<UEPositioningGANSSSBASID*>(items[0]) = uePositiningGANSSsbasID; }
	void setUePositioningGANSSAddNavigationModels(const UEPositioningGANSSAddNavigationModels& uePositioningGANSSAddNavigationModels) { *static_cast<UEPositioningGANSSAddNavigationModels*>(items[1]) = uePositioningGANSSAddNavigationModels; }
	void setUePositioningGANSSAlmanac(const UEPositioningGANSSAlmanacv860ext& uePositioningGANSSAlmanac) { *static_cast<UEPositioningGANSSAlmanacv860ext*>(items[2]) = uePositioningGANSSAlmanac; }
	void setUePositioningGANSSAddUTCModels(const UEPositioningGANSSAddUTCModels& uePositioningGANSSAddUTCModels) { *static_cast<UEPositioningGANSSAddUTCModels*>(items[3]) = uePositioningGANSSAddUTCModels; }
	void setUePositioningGANSSAuxiliaryInfo(const UEPositioningGANSSAuxiliaryInfo& uePositioningGANSSAuxiliaryInfo) { *static_cast<UEPositioningGANSSAuxiliaryInfo*>(items[4]) = uePositioningGANSSAuxiliaryInfo; }
};

typedef Integer<CONSTRAINED, 0, 7> GANSSGenericDatar8GanssId;

typedef Integer<CONSTRAINED, 0, 255> UEPositioningGANSSAlmanacr8Gansswknumber;

class UEPositioningGANSSAlmanacr8 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	UEPositioningGANSSAlmanacr8(): Sequence(&theInfo) {}

	void setUEPositioningGANSSAlmanacr8Gansswknumber(const UEPositioningGANSSAlmanacr8Gansswknumber& uEPositioningGANSSAlmanacr8Gansswknumber) { *static_cast<UEPositioningGANSSAlmanacr8Gansswknumber*>(items[0]) = uEPositioningGANSSAlmanacr8Gansswknumber; }
	void setAlmkeplerianParameters(const ALMkeplerianParameters& almkeplerianParameters) { *static_cast<ALMkeplerianParameters*>(items[1]) = almkeplerianParameters; }
	void setAlmkeplerianNAVAlmanac(const ALMNAVKeplerianSet& almkeplerianNAVAlmanac) { *static_cast<ALMNAVKeplerianSet*>(items[2]) = almkeplerianNAVAlmanac; }
	void setAlmkeplerianReducedAlmanac(const ALMReducedKeplerianSet& almkeplerianReducedAlmanac) { *static_cast<ALMReducedKeplerianSet*>(items[3]) = almkeplerianReducedAlmanac; }
	void setAlmkeplerianMidiAlmanac(const ALMMidiAlmanacSet& almkeplerianMidiAlmanac) { *static_cast<ALMMidiAlmanacSet*>(items[4]) = almkeplerianMidiAlmanac; }
	void setAlmkeplerianGLONASS(const ALMGlonassAlmanacSet& almkeplerianGLONASS) { *static_cast<ALMGlonassAlmanacSet*>(items[5]) = almkeplerianGLONASS; }
	void setAlmecefSBASAlmanac(const ALMECEFsbasAlmanacSet& almecefSBASAlmanac) { *static_cast<ALMECEFsbasAlmanacSet*>(items[6]) = almecefSBASAlmanac; }
};

class GANSSGenericDatar8 : public Sequence {
private:
	static const void *itemsInfo[13];
	static bool itemsPres[13];
public:
	static const Info theInfo;
	GANSSGenericDatar8(): Sequence(&theInfo) {}

	void setGANSSGenericDatar8GanssId(const GANSSGenericDatar8GanssId& gANSSGenericDatar8GanssId) { *static_cast<GANSSGenericDatar8GanssId*>(items[0]) = gANSSGenericDatar8GanssId; }
	void setUePositiningGANSSsbasID(const UEPositioningGANSSSBASID& uePositiningGANSSsbasID) { *static_cast<UEPositioningGANSSSBASID*>(items[1]) = uePositiningGANSSsbasID; }
	void setGanssTimeModelsList(const GANSSTimeModelsList& ganssTimeModelsList) { *static_cast<GANSSTimeModelsList*>(items[2]) = ganssTimeModelsList; }
	void setUePositioningDGANSSCorrections(const UEPositioningDGANSSCorrections& uePositioningDGANSSCorrections) { *static_cast<UEPositioningDGANSSCorrections*>(items[3]) = uePositioningDGANSSCorrections; }
	void setUePositioningGANSSNavigationModel(const UEPositioningGANSSNavigationModel& uePositioningGANSSNavigationModel) { *static_cast<UEPositioningGANSSNavigationModel*>(items[4]) = uePositioningGANSSNavigationModel; }
	void setUePositioningGANSSAddNavigationModels(const UEPositioningGANSSAddNavigationModels& uePositioningGANSSAddNavigationModels) { *static_cast<UEPositioningGANSSAddNavigationModels*>(items[5]) = uePositioningGANSSAddNavigationModels; }
	void setUePositioningGANSSRealTimeIntegrity(const UEPositioningGANSSRealTimeIntegrity& uePositioningGANSSRealTimeIntegrity) { *static_cast<UEPositioningGANSSRealTimeIntegrity*>(items[6]) = uePositioningGANSSRealTimeIntegrity; }
	void setUePositioningGANSSDataBitAssistance(const UEPositioningGANSSDataBitAssistance& uePositioningGANSSDataBitAssistance) { *static_cast<UEPositioningGANSSDataBitAssistance*>(items[7]) = uePositioningGANSSDataBitAssistance; }
	void setUePositioningGANSSReferenceMeasurementInfo(const UEPositioningGANSSReferenceMeasurementInfo& uePositioningGANSSReferenceMeasurementInfo) { *static_cast<UEPositioningGANSSReferenceMeasurementInfo*>(items[8]) = uePositioningGANSSReferenceMeasurementInfo; }
	void setUePositioningGANSSAlmanac(const UEPositioningGANSSAlmanacr8& uePositioningGANSSAlmanac) { *static_cast<UEPositioningGANSSAlmanacr8*>(items[9]) = uePositioningGANSSAlmanac; }
	void setUePositioningGANSSUTCModel(const UEPositioningGANSSUTCModel& uePositioningGANSSUTCModel) { *static_cast<UEPositioningGANSSUTCModel*>(items[10]) = uePositioningGANSSUTCModel; }
	void setUePositioningGANSSAddUTCModels(const UEPositioningGANSSAddUTCModels& uePositioningGANSSAddUTCModels) { *static_cast<UEPositioningGANSSAddUTCModels*>(items[11]) = uePositioningGANSSAddUTCModels; }
	void setUePositioningGANSSAuxiliaryInfo(const UEPositioningGANSSAuxiliaryInfo& uePositioningGANSSAuxiliaryInfo) { *static_cast<UEPositioningGANSSAuxiliaryInfo*>(items[12]) = uePositioningGANSSAuxiliaryInfo; }
};

typedef Integer<CONSTRAINED, 0, 7> GANSSGenericDatar9GanssId;

class UEPositioningDGANSSCorrectionsr9 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningDGANSSCorrectionsr9(): Sequence(&theInfo) {}

	void setDganssInfoList(const DGANSSInfoListr9& dganssInfoList) { *static_cast<DGANSSInfoListr9*>(items[0]) = dganssInfoList; }
};

class GANSSGenericDatar9 : public Sequence {
private:
	static const void *itemsInfo[13];
	static bool itemsPres[13];
public:
	static const Info theInfo;
	GANSSGenericDatar9(): Sequence(&theInfo) {}

	void setGANSSGenericDatar9GanssId(const GANSSGenericDatar9GanssId& gANSSGenericDatar9GanssId) { *static_cast<GANSSGenericDatar9GanssId*>(items[0]) = gANSSGenericDatar9GanssId; }
	void setUePositiningGANSSsbasID(const UEPositioningGANSSSBASID& uePositiningGANSSsbasID) { *static_cast<UEPositioningGANSSSBASID*>(items[1]) = uePositiningGANSSsbasID; }
	void setGanssTimeModelsList(const GANSSTimeModelsList& ganssTimeModelsList) { *static_cast<GANSSTimeModelsList*>(items[2]) = ganssTimeModelsList; }
	void setUePositioningDGANSSCorrections(const UEPositioningDGANSSCorrectionsr9& uePositioningDGANSSCorrections) { *static_cast<UEPositioningDGANSSCorrectionsr9*>(items[3]) = uePositioningDGANSSCorrections; }
	void setUePositioningGANSSNavigationModel(const UEPositioningGANSSNavigationModel& uePositioningGANSSNavigationModel) { *static_cast<UEPositioningGANSSNavigationModel*>(items[4]) = uePositioningGANSSNavigationModel; }
	void setUePositioningGANSSAddNavigationModels(const UEPositioningGANSSAddNavigationModels& uePositioningGANSSAddNavigationModels) { *static_cast<UEPositioningGANSSAddNavigationModels*>(items[5]) = uePositioningGANSSAddNavigationModels; }
	void setUePositioningGANSSRealTimeIntegrity(const UEPositioningGANSSRealTimeIntegrity& uePositioningGANSSRealTimeIntegrity) { *static_cast<UEPositioningGANSSRealTimeIntegrity*>(items[6]) = uePositioningGANSSRealTimeIntegrity; }
	void setUePositioningGANSSDataBitAssistance(const UEPositioningGANSSDataBitAssistance& uePositioningGANSSDataBitAssistance) { *static_cast<UEPositioningGANSSDataBitAssistance*>(items[7]) = uePositioningGANSSDataBitAssistance; }
	void setUePositioningGANSSReferenceMeasurementInfo(const UEPositioningGANSSReferenceMeasurementInfo& uePositioningGANSSReferenceMeasurementInfo) { *static_cast<UEPositioningGANSSReferenceMeasurementInfo*>(items[8]) = uePositioningGANSSReferenceMeasurementInfo; }
	void setUePositioningGANSSAlmanac(const UEPositioningGANSSAlmanacr8& uePositioningGANSSAlmanac) { *static_cast<UEPositioningGANSSAlmanacr8*>(items[9]) = uePositioningGANSSAlmanac; }
	void setUePositioningGANSSUTCModel(const UEPositioningGANSSUTCModel& uePositioningGANSSUTCModel) { *static_cast<UEPositioningGANSSUTCModel*>(items[10]) = uePositioningGANSSUTCModel; }
	void setUePositioningGANSSAddUTCModels(const UEPositioningGANSSAddUTCModels& uePositioningGANSSAddUTCModels) { *static_cast<UEPositioningGANSSAddUTCModels*>(items[11]) = uePositioningGANSSAddUTCModels; }
	void setUePositioningGANSSAuxiliaryInfo(const UEPositioningGANSSAuxiliaryInfo& uePositioningGANSSAuxiliaryInfo) { *static_cast<UEPositioningGANSSAuxiliaryInfo*>(items[12]) = uePositioningGANSSAuxiliaryInfo; }
};

class UEPositioningDGANSSCorrectionsv920ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningDGANSSCorrectionsv920ext(): Sequence(&theInfo) {}

	void setDganssInfoList(const DGANSSInfoListv920ext& dganssInfoList) { *static_cast<DGANSSInfoListv920ext*>(items[0]) = dganssInfoList; }
};

class GANSSGenericDatav920ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	GANSSGenericDatav920ext(): Sequence(&theInfo) {}

	void setUePositioningDGANSSCorrections(const UEPositioningDGANSSCorrectionsv920ext& uePositioningDGANSSCorrections) { *static_cast<UEPositioningDGANSSCorrectionsv920ext*>(items[0]) = uePositioningDGANSSCorrections; }
};

typedef SequenceOf<GANSSGenericData, CONSTRAINED, 1, maxGANSS> GANSSGenericDataList;

typedef SequenceOf<GANSSGenericDatav860ext, CONSTRAINED, 1, maxGANSS> GANSSGenericDataListv860ext;

typedef SequenceOf<GANSSGenericDatar8, CONSTRAINED, 1, maxGANSS> GANSSGenericDataListr8;

typedef SequenceOf<GANSSGenericDatar9, CONSTRAINED, 1, maxGANSS> GANSSGenericDataListr9;

typedef SequenceOf<GANSSGenericDatav920ext, CONSTRAINED, 1, maxGANSS> GANSSGenericDataListv920ext;

class GANSSMeasurementParameters : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	GANSSMeasurementParameters(): Sequence(&theInfo) {}

};

class GANSSMeasurementParametersv860ext : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	GANSSMeasurementParametersv860ext(): Sequence(&theInfo) {}

};

class GANSSMeasurementSignalList : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	GANSSMeasurementSignalList(): Sequence(&theInfo) {}

};

class GANSSMeasurementSignalListv860ext : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	GANSSMeasurementSignalListv860ext(): Sequence(&theInfo) {}

};

typedef Integer<CONSTRAINED, 0, 4095> GanssNavigationModelAdditionalDataGanssWeek;

typedef Integer<CONSTRAINED, 0, 167> GanssNavigationModelAdditionalDataGanssToe;

typedef Integer<CONSTRAINED, 0, 10> GanssNavigationModelAdditionalDataTtoeLimit;

typedef Integer<CONSTRAINED, 0, 63> SatellitesListRelatedDataSatId;

typedef Integer<CONSTRAINED, 0, 1023> SatellitesListRelatedDataIod;

class SatellitesListRelatedData : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SatellitesListRelatedData(): Sequence(&theInfo) {}

	void setSatellitesListRelatedDataSatId(const SatellitesListRelatedDataSatId& satellitesListRelatedDataSatId) { *static_cast<SatellitesListRelatedDataSatId*>(items[0]) = satellitesListRelatedDataSatId; }
	void setSatellitesListRelatedDataIod(const SatellitesListRelatedDataIod& satellitesListRelatedDataIod) { *static_cast<SatellitesListRelatedDataIod*>(items[1]) = satellitesListRelatedDataIod; }
};

typedef SequenceOf<SatellitesListRelatedData, CONSTRAINED, 1, maxGANSSSat> SatellitesListRelatedDataList;

class GanssNavigationModelAdditionalData : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	GanssNavigationModelAdditionalData(): Sequence(&theInfo) {}

	void setGanssNavigationModelAdditionalDataGanssWeek(const GanssNavigationModelAdditionalDataGanssWeek& ganssNavigationModelAdditionalDataGanssWeek) { *static_cast<GanssNavigationModelAdditionalDataGanssWeek*>(items[0]) = ganssNavigationModelAdditionalDataGanssWeek; }
	void setGanssNavigationModelAdditionalDataGanssToe(const GanssNavigationModelAdditionalDataGanssToe& ganssNavigationModelAdditionalDataGanssToe) { *static_cast<GanssNavigationModelAdditionalDataGanssToe*>(items[1]) = ganssNavigationModelAdditionalDataGanssToe; }
	void setGanssNavigationModelAdditionalDataTtoeLimit(const GanssNavigationModelAdditionalDataTtoeLimit& ganssNavigationModelAdditionalDataTtoeLimit) { *static_cast<GanssNavigationModelAdditionalDataTtoeLimit*>(items[2]) = ganssNavigationModelAdditionalDataTtoeLimit; }
	void setSatellitesListRelatedDataList(const SatellitesListRelatedDataList& satellitesListRelatedDataList) { *static_cast<SatellitesListRelatedDataList*>(items[3]) = satellitesListRelatedDataList; }
};

typedef Integer<CONSTRAINED, 0, 7> GanssReqGenericDataGanssId;

typedef Boolean GanssReqGenericDataGanssRealTimeIntegrity;

typedef Boolean GanssReqGenericDataGanssAlmanac;

typedef Boolean GanssReqGenericDataGanssNavigationModel;

typedef BitString<CONSTRAINED, 8, 8> GanssReqGenericDataGanssTimeModelGNSSGNSS;

typedef Boolean GanssReqGenericDataGanssReferenceMeasurementInfo;

typedef Boolean GanssReqGenericDataGanssUTCModel;

class GanssReqGenericData : public Sequence {
private:
	static const void *itemsInfo[10];
	static bool itemsPres[10];
public:
	static const Info theInfo;
	GanssReqGenericData(): Sequence(&theInfo) {}

	void setGanssReqGenericDataGanssId(const GanssReqGenericDataGanssId& ganssReqGenericDataGanssId) { *static_cast<GanssReqGenericDataGanssId*>(items[0]) = ganssReqGenericDataGanssId; }
	void setGanssReqGenericDataGanssRealTimeIntegrity(const GanssReqGenericDataGanssRealTimeIntegrity& ganssReqGenericDataGanssRealTimeIntegrity) { *static_cast<GanssReqGenericDataGanssRealTimeIntegrity*>(items[1]) = ganssReqGenericDataGanssRealTimeIntegrity; }
	void setGanssDifferentialCorrection(const DGANSSSigIdReq& ganssDifferentialCorrection) { *static_cast<DGANSSSigIdReq*>(items[2]) = ganssDifferentialCorrection; }
	void setGanssReqGenericDataGanssAlmanac(const GanssReqGenericDataGanssAlmanac& ganssReqGenericDataGanssAlmanac) { *static_cast<GanssReqGenericDataGanssAlmanac*>(items[3]) = ganssReqGenericDataGanssAlmanac; }
	void setGanssReqGenericDataGanssNavigationModel(const GanssReqGenericDataGanssNavigationModel& ganssReqGenericDataGanssNavigationModel) { *static_cast<GanssReqGenericDataGanssNavigationModel*>(items[4]) = ganssReqGenericDataGanssNavigationModel; }
	void setGanssReqGenericDataGanssTimeModelGNSSGNSS(const GanssReqGenericDataGanssTimeModelGNSSGNSS& ganssReqGenericDataGanssTimeModelGNSSGNSS) { *static_cast<GanssReqGenericDataGanssTimeModelGNSSGNSS*>(items[5]) = ganssReqGenericDataGanssTimeModelGNSSGNSS; }
	void setGanssReqGenericDataGanssReferenceMeasurementInfo(const GanssReqGenericDataGanssReferenceMeasurementInfo& ganssReqGenericDataGanssReferenceMeasurementInfo) { *static_cast<GanssReqGenericDataGanssReferenceMeasurementInfo*>(items[6]) = ganssReqGenericDataGanssReferenceMeasurementInfo; }
	void setGanssDataBits(const GanssDataBits& ganssDataBits) { *static_cast<GanssDataBits*>(items[7]) = ganssDataBits; }
	void setGanssReqGenericDataGanssUTCModel(const GanssReqGenericDataGanssUTCModel& ganssReqGenericDataGanssUTCModel) { *static_cast<GanssReqGenericDataGanssUTCModel*>(items[8]) = ganssReqGenericDataGanssUTCModel; }
	void setGanssNavigationModelAdditionalData(const GanssNavigationModelAdditionalData& ganssNavigationModelAdditionalData) { *static_cast<GanssNavigationModelAdditionalData*>(items[9]) = ganssNavigationModelAdditionalData; }
};

enum GanssReqGenericDatav860extganssAddNavigationModelValues {
	true_GanssReqGenericDatav860extganssAddNavigationModel = 0,
};
typedef Enumerated<CONSTRAINED, 0> GanssReqGenericDatav860extganssAddNavigationModel;

enum GanssReqGenericDatav860extganssAddUTCmodelValues {
	true_GanssReqGenericDatav860extganssAddUTCmodel = 0,
};
typedef Enumerated<CONSTRAINED, 0> GanssReqGenericDatav860extganssAddUTCmodel;

enum GanssReqGenericDatav860extganssAuxInfoValues {
	true_GanssReqGenericDatav860extganssAuxInfo = 0,
};
typedef Enumerated<CONSTRAINED, 0> GanssReqGenericDatav860extganssAuxInfo;

typedef Integer<CONSTRAINED, 0, 7> GanssReqGenericDatav860extGanssAddADchoicesOrbitModelID;

typedef Integer<CONSTRAINED, 0, 7> GanssReqGenericDatav860extGanssAddADchoicesClockModelID;

typedef Integer<CONSTRAINED, 0, 7> GanssReqGenericDatav860extGanssAddADchoicesUtcModelID;

typedef Integer<CONSTRAINED, 0, 7> GanssReqGenericDatav860extGanssAddADchoicesAlmanacModelID;

class GanssReqGenericDatav860extGanssAddADchoices : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	GanssReqGenericDatav860extGanssAddADchoices(): Sequence(&theInfo) {}

	void setGanssReqGenericDatav860extGanssAddADchoicesOrbitModelID(const GanssReqGenericDatav860extGanssAddADchoicesOrbitModelID& ganssReqGenericDatav860extGanssAddADchoicesOrbitModelID) { *static_cast<GanssReqGenericDatav860extGanssAddADchoicesOrbitModelID*>(items[0]) = ganssReqGenericDatav860extGanssAddADchoicesOrbitModelID; }
	void setGanssReqGenericDatav860extGanssAddADchoicesClockModelID(const GanssReqGenericDatav860extGanssAddADchoicesClockModelID& ganssReqGenericDatav860extGanssAddADchoicesClockModelID) { *static_cast<GanssReqGenericDatav860extGanssAddADchoicesClockModelID*>(items[1]) = ganssReqGenericDatav860extGanssAddADchoicesClockModelID; }
	void setGanssReqGenericDatav860extGanssAddADchoicesUtcModelID(const GanssReqGenericDatav860extGanssAddADchoicesUtcModelID& ganssReqGenericDatav860extGanssAddADchoicesUtcModelID) { *static_cast<GanssReqGenericDatav860extGanssAddADchoicesUtcModelID*>(items[2]) = ganssReqGenericDatav860extGanssAddADchoicesUtcModelID; }
	void setGanssReqGenericDatav860extGanssAddADchoicesAlmanacModelID(const GanssReqGenericDatav860extGanssAddADchoicesAlmanacModelID& ganssReqGenericDatav860extGanssAddADchoicesAlmanacModelID) { *static_cast<GanssReqGenericDatav860extGanssAddADchoicesAlmanacModelID*>(items[3]) = ganssReqGenericDatav860extGanssAddADchoicesAlmanacModelID; }
};

class GanssReqGenericDatav860ext : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	GanssReqGenericDatav860ext(): Sequence(&theInfo) {}

	void setSbasId(const UEPositioningGANSSSBASID& sbasId) { *static_cast<UEPositioningGANSSSBASID*>(items[0]) = sbasId; }
	void setGanssReqGenericDatav860extganssAddNavigationModel(const GanssReqGenericDatav860extganssAddNavigationModel& ganssReqGenericDatav860extganssAddNavigationModel) { *static_cast<GanssReqGenericDatav860extganssAddNavigationModel*>(items[1]) = ganssReqGenericDatav860extganssAddNavigationModel; }
	void setGanssReqGenericDatav860extganssAddUTCmodel(const GanssReqGenericDatav860extganssAddUTCmodel& ganssReqGenericDatav860extganssAddUTCmodel) { *static_cast<GanssReqGenericDatav860extganssAddUTCmodel*>(items[2]) = ganssReqGenericDatav860extganssAddUTCmodel; }
	void setGanssReqGenericDatav860extganssAuxInfo(const GanssReqGenericDatav860extganssAuxInfo& ganssReqGenericDatav860extganssAuxInfo) { *static_cast<GanssReqGenericDatav860extganssAuxInfo*>(items[3]) = ganssReqGenericDatav860extganssAuxInfo; }
	void setGanssReqGenericDatav860extGanssAddADchoices(const GanssReqGenericDatav860extGanssAddADchoices& ganssReqGenericDatav860extGanssAddADchoices) { *static_cast<GanssReqGenericDatav860extGanssAddADchoices*>(items[4]) = ganssReqGenericDatav860extGanssAddADchoices; }
};

typedef SequenceOf<GanssReqGenericData, CONSTRAINED, 1, maxGANSS> GanssRequestedGenericAssistanceDataList;

typedef SequenceOf<GanssReqGenericDatav860ext, CONSTRAINED, 1, maxGANSS> GanssRequestedGenericAssistanceDataListv860ext;

typedef Boolean GANSSStormFlagStormflagone;

typedef Boolean GANSSStormFlagStormflagtwo;

typedef Boolean GANSSStormFlagStormflagthree;

typedef Boolean GANSSStormFlagStormflagfour;

typedef Boolean GANSSStormFlagStormflagfive;

class GANSSStormFlag : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	GANSSStormFlag(): Sequence(&theInfo) {}

	void setGANSSStormFlagStormflagone(const GANSSStormFlagStormflagone& gANSSStormFlagStormflagone) { *static_cast<GANSSStormFlagStormflagone*>(items[0]) = gANSSStormFlagStormflagone; }
	void setGANSSStormFlagStormflagtwo(const GANSSStormFlagStormflagtwo& gANSSStormFlagStormflagtwo) { *static_cast<GANSSStormFlagStormflagtwo*>(items[1]) = gANSSStormFlagStormflagtwo; }
	void setGANSSStormFlagStormflagthree(const GANSSStormFlagStormflagthree& gANSSStormFlagStormflagthree) { *static_cast<GANSSStormFlagStormflagthree*>(items[2]) = gANSSStormFlagStormflagthree; }
	void setGANSSStormFlagStormflagfour(const GANSSStormFlagStormflagfour& gANSSStormFlagStormflagfour) { *static_cast<GANSSStormFlagStormflagfour*>(items[3]) = gANSSStormFlagStormflagfour; }
	void setGANSSStormFlagStormflagfive(const GANSSStormFlagStormflagfive& gANSSStormFlagStormflagfive) { *static_cast<GANSSStormFlagStormflagfive*>(items[4]) = gANSSStormFlagStormflagfive; }
};

typedef BitString<CONSTRAINED, 6, 6> GSMCarrierRSSI;

typedef Integer<CONSTRAINED, 46, 173> GSMMeasuredResultsDummy;

typedef Integer<CONSTRAINED, 0, 4095> ObservedTimeDifferenceToGSM;

class GSMMeasuredResults : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	GSMMeasuredResults(): Sequence(&theInfo) {}

	void setGsmCarrierRSSI(const GSMCarrierRSSI& gsmCarrierRSSI) { *static_cast<GSMCarrierRSSI*>(items[0]) = gsmCarrierRSSI; }
	void setGSMMeasuredResultsDummy(const GSMMeasuredResultsDummy& gSMMeasuredResultsDummy) { *static_cast<GSMMeasuredResultsDummy*>(items[1]) = gSMMeasuredResultsDummy; }
	void setBsicReported(const BSICReported& bsicReported) { *static_cast<BSICReported*>(items[2]) = bsicReported; }
	void setDummy2(const ObservedTimeDifferenceToGSM& dummy2) { *static_cast<ObservedTimeDifferenceToGSM*>(items[3]) = dummy2; }
};

typedef SequenceOf<GSMMeasuredResults, CONSTRAINED, 1, maxReportedGSMCells> GSMMeasuredResultsList;

typedef Integer<CONSTRAINED, 0, 604799> GPSTOW1sec;

typedef BitString<CONSTRAINED, 14, 14> GPSTOWAssistTlmMessage;

typedef BitString<CONSTRAINED, 2, 2> GPSTOWAssistTlmReserved;

typedef Boolean GPSTOWAssistAlert;

typedef Boolean GPSTOWAssistAntiSpoof;

class GPSTOWAssist : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	GPSTOWAssist(): Sequence(&theInfo) {}

	void setSatID(const SatID& satID) { *static_cast<SatID*>(items[0]) = satID; }
	void setGPSTOWAssistTlmMessage(const GPSTOWAssistTlmMessage& gPSTOWAssistTlmMessage) { *static_cast<GPSTOWAssistTlmMessage*>(items[1]) = gPSTOWAssistTlmMessage; }
	void setGPSTOWAssistTlmReserved(const GPSTOWAssistTlmReserved& gPSTOWAssistTlmReserved) { *static_cast<GPSTOWAssistTlmReserved*>(items[2]) = gPSTOWAssistTlmReserved; }
	void setGPSTOWAssistAlert(const GPSTOWAssistAlert& gPSTOWAssistAlert) { *static_cast<GPSTOWAssistAlert*>(items[3]) = gPSTOWAssistAlert; }
	void setGPSTOWAssistAntiSpoof(const GPSTOWAssistAntiSpoof& gPSTOWAssistAntiSpoof) { *static_cast<GPSTOWAssistAntiSpoof*>(items[4]) = gPSTOWAssistAntiSpoof; }
};

typedef SequenceOf<GPSTOWAssist, CONSTRAINED, 1, maxSat> GPSTOWAssistList;

typedef Integer<CONSTRAINED, 0, maxCellMeas_1> GSMCellIDGsmCellID;

class GSMCellID : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	GSMCellID(): Sequence(&theInfo) {}

	void setGSMCellIDGsmCellID(const GSMCellIDGsmCellID& gSMCellIDGsmCellID) { *static_cast<GSMCellIDGsmCellID*>(items[0]) = gSMCellIDGsmCellID; }
};

typedef Integer<CONSTRAINED, 0, maxPrio_1> GSMPriorityInfoPriority;

typedef Integer<CONSTRAINED, -58, -13> GSMPriorityInfoQRxLevMinGSM;

typedef Integer<CONSTRAINED, 0, 31> GSMPriorityInfoThreshXhigh;

typedef Integer<CONSTRAINED, 0, 31> GSMPriorityInfoThreshXlow;

class GSMPriorityInfo : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	GSMPriorityInfo(): Sequence(&theInfo) {}

	void setGsmCellGroup(const GSMCellGroup& gsmCellGroup) { *static_cast<GSMCellGroup*>(items[0]) = gsmCellGroup; }
	void setGSMPriorityInfoPriority(const GSMPriorityInfoPriority& gSMPriorityInfoPriority) { *static_cast<GSMPriorityInfoPriority*>(items[1]) = gSMPriorityInfoPriority; }
	void setGSMPriorityInfoQRxLevMinGSM(const GSMPriorityInfoQRxLevMinGSM& gSMPriorityInfoQRxLevMinGSM) { *static_cast<GSMPriorityInfoQRxLevMinGSM*>(items[2]) = gSMPriorityInfoQRxLevMinGSM; }
	void setGSMPriorityInfoThreshXhigh(const GSMPriorityInfoThreshXhigh& gSMPriorityInfoThreshXhigh) { *static_cast<GSMPriorityInfoThreshXhigh*>(items[3]) = gSMPriorityInfoThreshXhigh; }
	void setGSMPriorityInfoThreshXlow(const GSMPriorityInfoThreshXlow& gSMPriorityInfoThreshXlow) { *static_cast<GSMPriorityInfoThreshXlow*>(items[4]) = gSMPriorityInfoThreshXlow; }
};

typedef SequenceOf<GSMPriorityInfo, CONSTRAINED, 1, maxNumGSMCellGroup> GSMPriorityInfoList;

typedef SequenceOf<GSMCellID, CONSTRAINED, 1, maxCellMeas> GSMCellGroupingList;

typedef Integer<CONSTRAINED, 2, 3> IdleIntervalInfoK;

typedef Integer<CONSTRAINED, 0, 7> IdleIntervalInfoOffset;

class IdleIntervalInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IdleIntervalInfo(): Sequence(&theInfo) {}

	void setIdleIntervalInfoK(const IdleIntervalInfoK& idleIntervalInfoK) { *static_cast<IdleIntervalInfoK*>(items[0]) = idleIntervalInfoK; }
	void setIdleIntervalInfoOffset(const IdleIntervalInfoOffset& idleIntervalInfoOffset) { *static_cast<IdleIntervalInfoOffset*>(items[1]) = idleIntervalInfoOffset; }
};

class InterFreqCellLCRr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterFreqCellLCRr4(): Sequence(&theInfo) {}

	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[0]) = frequencyInfo; }
	void setNonFreqRelatedEventResults(const CellMeasurementEventResultsLCRr4& nonFreqRelatedEventResults) { *static_cast<CellMeasurementEventResultsLCRr4*>(items[1]) = nonFreqRelatedEventResults; }
};

typedef Null RemovedInterFreqCellListRemoveAllInterFreqCells;

typedef SequenceOf<InterFreqCellID, CONSTRAINED, 1, maxCellMeas> RemovedInterFreqCellListRemoveSomeInterFreqCells;

typedef Null RemovedInterFreqCellListRemoveNoInterFreqCells;

class RemovedInterFreqCellList : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum RemovedInterFreqCellListChoices {
		removedInterFreqCellListRemoveAllInterFreqCells = 0,
		removedInterFreqCellListRemoveSomeInterFreqCells = 1,
		removedInterFreqCellListRemoveNoInterFreqCells = 2,
	};
	static const Info theInfo;
	RemovedInterFreqCellList(): Choice(&theInfo) {}
};

class NewInterFreqCell : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	NewInterFreqCell(): Sequence(&theInfo) {}

	void setInterFreqCellID(const InterFreqCellID& interFreqCellID) { *static_cast<InterFreqCellID*>(items[0]) = interFreqCellID; }
	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[1]) = frequencyInfo; }
	void setCellInfo(const CellInfo& cellInfo) { *static_cast<CellInfo*>(items[2]) = cellInfo; }
};

typedef SequenceOf<NewInterFreqCell, CONSTRAINED, 1, maxCellMeas> NewInterFreqCellList;

class InterFreqCellInfoList : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	InterFreqCellInfoList(): Sequence(&theInfo) {}

	void setRemovedInterFreqCellList(const RemovedInterFreqCellList& removedInterFreqCellList) { *static_cast<RemovedInterFreqCellList*>(items[0]) = removedInterFreqCellList; }
	void setNewInterFreqCellList(const NewInterFreqCellList& newInterFreqCellList) { *static_cast<NewInterFreqCellList*>(items[1]) = newInterFreqCellList; }
	void setCellsForInterFreqMeasList(const CellsForInterFreqMeasList& cellsForInterFreqMeasList) { *static_cast<CellsForInterFreqMeasList*>(items[2]) = cellsForInterFreqMeasList; }
};

class NewInterFreqCellr4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	NewInterFreqCellr4(): Sequence(&theInfo) {}

	void setInterFreqCellID(const InterFreqCellID& interFreqCellID) { *static_cast<InterFreqCellID*>(items[0]) = interFreqCellID; }
	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[1]) = frequencyInfo; }
	void setCellInfo(const CellInfor4& cellInfo) { *static_cast<CellInfor4*>(items[2]) = cellInfo; }
};

typedef SequenceOf<NewInterFreqCellr4, CONSTRAINED, 1, maxCellMeas> NewInterFreqCellListr4;

class InterFreqCellInfoListr4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	InterFreqCellInfoListr4(): Sequence(&theInfo) {}

	void setRemovedInterFreqCellList(const RemovedInterFreqCellList& removedInterFreqCellList) { *static_cast<RemovedInterFreqCellList*>(items[0]) = removedInterFreqCellList; }
	void setNewInterFreqCellList(const NewInterFreqCellListr4& newInterFreqCellList) { *static_cast<NewInterFreqCellListr4*>(items[1]) = newInterFreqCellList; }
	void setCellsForInterFreqMeasList(const CellsForInterFreqMeasList& cellsForInterFreqMeasList) { *static_cast<CellsForInterFreqMeasList*>(items[2]) = cellsForInterFreqMeasList; }
};

typedef Null NewInterFreqCellr8ModeSpecificInfoNoInfo;

typedef Boolean NewInterFreqCellr8ModeSpecificInfoTdd128IntraSecondaryFreqIndicator;

class NewInterFreqCellr8ModeSpecificInfoTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	NewInterFreqCellr8ModeSpecificInfoTdd128(): Sequence(&theInfo) {}

	void setNewInterFreqCellr8ModeSpecificInfoTdd128IntraSecondaryFreqIndicator(const NewInterFreqCellr8ModeSpecificInfoTdd128IntraSecondaryFreqIndicator& newInterFreqCellr8ModeSpecificInfoTdd128IntraSecondaryFreqIndicator) { *static_cast<NewInterFreqCellr8ModeSpecificInfoTdd128IntraSecondaryFreqIndicator*>(items[0]) = newInterFreqCellr8ModeSpecificInfoTdd128IntraSecondaryFreqIndicator; }
};

class NewInterFreqCellr8ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum NewInterFreqCellr8ModeSpecificInfoChoices {
		newInterFreqCellr8ModeSpecificInfoNoInfo = 0,
		newInterFreqCellr8ModeSpecificInfoTdd128 = 1,
	};
	static const Info theInfo;
	NewInterFreqCellr8ModeSpecificInfo(): Choice(&theInfo) {}
};

class NewInterFreqCellr8 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	NewInterFreqCellr8(): Sequence(&theInfo) {}

	void setInterFreqCellID(const InterFreqCellID& interFreqCellID) { *static_cast<InterFreqCellID*>(items[0]) = interFreqCellID; }
	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[1]) = frequencyInfo; }
	void setCellInfo(const CellInfor4& cellInfo) { *static_cast<CellInfor4*>(items[2]) = cellInfo; }
	void setNewInterFreqCellr8ModeSpecificInfo(const NewInterFreqCellr8ModeSpecificInfo& newInterFreqCellr8ModeSpecificInfo) { *static_cast<NewInterFreqCellr8ModeSpecificInfo*>(items[3]) = newInterFreqCellr8ModeSpecificInfo; }
};

typedef SequenceOf<NewInterFreqCellr8, CONSTRAINED, 1, maxCellMeas> NewInterFreqCellListr8;

class InterFreqCellInfoListr8 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	InterFreqCellInfoListr8(): Sequence(&theInfo) {}

	void setRemovedInterFreqCellList(const RemovedInterFreqCellList& removedInterFreqCellList) { *static_cast<RemovedInterFreqCellList*>(items[0]) = removedInterFreqCellList; }
	void setNewInterFreqCellList(const NewInterFreqCellListr8& newInterFreqCellList) { *static_cast<NewInterFreqCellListr8*>(items[1]) = newInterFreqCellList; }
	void setCellsForInterFreqMeasList(const CellsForInterFreqMeasList& cellsForInterFreqMeasList) { *static_cast<CellsForInterFreqMeasList*>(items[2]) = cellsForInterFreqMeasList; }
};

typedef Null NewInterFreqCellr9ModeSpecificInfoNoInfo;

typedef Boolean NewInterFreqCellr9ModeSpecificInfoTdd128IntraSecondaryFreqIndicator;

class NewInterFreqCellr9ModeSpecificInfoTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	NewInterFreqCellr9ModeSpecificInfoTdd128(): Sequence(&theInfo) {}

	void setNewInterFreqCellr9ModeSpecificInfoTdd128IntraSecondaryFreqIndicator(const NewInterFreqCellr9ModeSpecificInfoTdd128IntraSecondaryFreqIndicator& newInterFreqCellr9ModeSpecificInfoTdd128IntraSecondaryFreqIndicator) { *static_cast<NewInterFreqCellr9ModeSpecificInfoTdd128IntraSecondaryFreqIndicator*>(items[0]) = newInterFreqCellr9ModeSpecificInfoTdd128IntraSecondaryFreqIndicator; }
};

class NewInterFreqCellr9ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum NewInterFreqCellr9ModeSpecificInfoChoices {
		newInterFreqCellr9ModeSpecificInfoNoInfo = 0,
		newInterFreqCellr9ModeSpecificInfoTdd128 = 1,
	};
	static const Info theInfo;
	NewInterFreqCellr9ModeSpecificInfo(): Choice(&theInfo) {}
};

class NewInterFreqCellr9 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	NewInterFreqCellr9(): Sequence(&theInfo) {}

	void setInterFreqCellID(const InterFreqCellID& interFreqCellID) { *static_cast<InterFreqCellID*>(items[0]) = interFreqCellID; }
	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[1]) = frequencyInfo; }
	void setCellInfo(const CellInfor9& cellInfo) { *static_cast<CellInfor9*>(items[2]) = cellInfo; }
	void setNewInterFreqCellr9ModeSpecificInfo(const NewInterFreqCellr9ModeSpecificInfo& newInterFreqCellr9ModeSpecificInfo) { *static_cast<NewInterFreqCellr9ModeSpecificInfo*>(items[3]) = newInterFreqCellr9ModeSpecificInfo; }
};

typedef SequenceOf<NewInterFreqCellr9, CONSTRAINED, 1, maxCellMeas> NewInterFreqCellListr9;

class InterFreqSIAcquisitionModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterFreqSIAcquisitionModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryScramblingCode(const PrimaryCPICHInfo& primaryScramblingCode) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryScramblingCode; }
};

typedef Null InterFreqSIAcquisitionModeSpecificInfoTdd;

class InterFreqSIAcquisitionModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum InterFreqSIAcquisitionModeSpecificInfoChoices {
		interFreqSIAcquisitionModeSpecificInfoFdd = 0,
		interFreqSIAcquisitionModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	InterFreqSIAcquisitionModeSpecificInfo(): Choice(&theInfo) {}
};

class InterFreqSIAcquisition : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterFreqSIAcquisition(): Sequence(&theInfo) {}

	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[0]) = frequencyInfo; }
	void setInterFreqSIAcquisitionModeSpecificInfo(const InterFreqSIAcquisitionModeSpecificInfo& interFreqSIAcquisitionModeSpecificInfo) { *static_cast<InterFreqSIAcquisitionModeSpecificInfo*>(items[1]) = interFreqSIAcquisitionModeSpecificInfo; }
};

class InterFreqCellInfoListr9 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	InterFreqCellInfoListr9(): Sequence(&theInfo) {}

	void setRemovedInterFreqCellList(const RemovedInterFreqCellList& removedInterFreqCellList) { *static_cast<RemovedInterFreqCellList*>(items[0]) = removedInterFreqCellList; }
	void setNewInterFreqCellList(const NewInterFreqCellListr9& newInterFreqCellList) { *static_cast<NewInterFreqCellListr9*>(items[1]) = newInterFreqCellList; }
	void setCellsForInterFreqMeasList(const CellsForInterFreqMeasList& cellsForInterFreqMeasList) { *static_cast<CellsForInterFreqMeasList*>(items[2]) = cellsForInterFreqMeasList; }
	void setCSGInterFreqCellInfoList(const CSGInterFreqCellInfoList& cSGInterFreqCellInfoList) { *static_cast<CSGInterFreqCellInfoList*>(items[3]) = cSGInterFreqCellInfoList; }
	void setInterFreqSIAcquisition(const InterFreqSIAcquisition& interFreqSIAcquisition) { *static_cast<InterFreqSIAcquisition*>(items[4]) = interFreqSIAcquisition; }
};

class NewInterFreqCellSIRSCP : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	NewInterFreqCellSIRSCP(): Sequence(&theInfo) {}

	void setInterFreqCellID(const InterFreqCellID& interFreqCellID) { *static_cast<InterFreqCellID*>(items[0]) = interFreqCellID; }
	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[1]) = frequencyInfo; }
	void setCellInfo(const CellInfoSIRSCP& cellInfo) { *static_cast<CellInfoSIRSCP*>(items[2]) = cellInfo; }
};

typedef SequenceOf<NewInterFreqCellSIRSCP, CONSTRAINED, 1, maxCellMeas> NewInterFreqCellSIListRSCP;

class InterFreqCellInfoSIListRSCP : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterFreqCellInfoSIListRSCP(): Sequence(&theInfo) {}

	void setRemovedInterFreqCellList(const RemovedInterFreqCellList& removedInterFreqCellList) { *static_cast<RemovedInterFreqCellList*>(items[0]) = removedInterFreqCellList; }
	void setNewInterFreqCellList(const NewInterFreqCellSIListRSCP& newInterFreqCellList) { *static_cast<NewInterFreqCellSIListRSCP*>(items[1]) = newInterFreqCellList; }
};

class NewInterFreqCellSIECN0 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	NewInterFreqCellSIECN0(): Sequence(&theInfo) {}

	void setInterFreqCellID(const InterFreqCellID& interFreqCellID) { *static_cast<InterFreqCellID*>(items[0]) = interFreqCellID; }
	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[1]) = frequencyInfo; }
	void setCellInfo(const CellInfoSIECN0& cellInfo) { *static_cast<CellInfoSIECN0*>(items[2]) = cellInfo; }
};

typedef SequenceOf<NewInterFreqCellSIECN0, CONSTRAINED, 1, maxCellMeas> NewInterFreqCellSIListECN0;

class InterFreqCellInfoSIListECN0 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterFreqCellInfoSIListECN0(): Sequence(&theInfo) {}

	void setRemovedInterFreqCellList(const RemovedInterFreqCellList& removedInterFreqCellList) { *static_cast<RemovedInterFreqCellList*>(items[0]) = removedInterFreqCellList; }
	void setNewInterFreqCellList(const NewInterFreqCellSIListECN0& newInterFreqCellList) { *static_cast<NewInterFreqCellSIListECN0*>(items[1]) = newInterFreqCellList; }
};

class NewInterFreqCellSIHCSRSCP : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	NewInterFreqCellSIHCSRSCP(): Sequence(&theInfo) {}

	void setInterFreqCellID(const InterFreqCellID& interFreqCellID) { *static_cast<InterFreqCellID*>(items[0]) = interFreqCellID; }
	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[1]) = frequencyInfo; }
	void setCellInfo(const CellInfoSIHCSRSCP& cellInfo) { *static_cast<CellInfoSIHCSRSCP*>(items[2]) = cellInfo; }
};

typedef SequenceOf<NewInterFreqCellSIHCSRSCP, CONSTRAINED, 1, maxCellMeas> NewInterFreqCellSIListHCSRSCP;

class InterFreqCellInfoSIListHCSRSCP : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterFreqCellInfoSIListHCSRSCP(): Sequence(&theInfo) {}

	void setRemovedInterFreqCellList(const RemovedInterFreqCellList& removedInterFreqCellList) { *static_cast<RemovedInterFreqCellList*>(items[0]) = removedInterFreqCellList; }
	void setNewInterFreqCellList(const NewInterFreqCellSIListHCSRSCP& newInterFreqCellList) { *static_cast<NewInterFreqCellSIListHCSRSCP*>(items[1]) = newInterFreqCellList; }
};

class NewInterFreqCellSIHCSECN0 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	NewInterFreqCellSIHCSECN0(): Sequence(&theInfo) {}

	void setInterFreqCellID(const InterFreqCellID& interFreqCellID) { *static_cast<InterFreqCellID*>(items[0]) = interFreqCellID; }
	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[1]) = frequencyInfo; }
	void setCellInfo(const CellInfoSIHCSECN0& cellInfo) { *static_cast<CellInfoSIHCSECN0*>(items[2]) = cellInfo; }
};

typedef SequenceOf<NewInterFreqCellSIHCSECN0, CONSTRAINED, 1, maxCellMeas> NewInterFreqCellSIListHCSECN0;

class InterFreqCellInfoSIListHCSECN0 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterFreqCellInfoSIListHCSECN0(): Sequence(&theInfo) {}

	void setRemovedInterFreqCellList(const RemovedInterFreqCellList& removedInterFreqCellList) { *static_cast<RemovedInterFreqCellList*>(items[0]) = removedInterFreqCellList; }
	void setNewInterFreqCellList(const NewInterFreqCellSIListHCSECN0& newInterFreqCellList) { *static_cast<NewInterFreqCellSIListHCSECN0*>(items[1]) = newInterFreqCellList; }
};

class NewInterFreqCellSIRSCPLCRr4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	NewInterFreqCellSIRSCPLCRr4(): Sequence(&theInfo) {}

	void setInterFreqCellID(const InterFreqCellID& interFreqCellID) { *static_cast<InterFreqCellID*>(items[0]) = interFreqCellID; }
	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[1]) = frequencyInfo; }
	void setCellInfo(const CellInfoSIRSCPLCRr4& cellInfo) { *static_cast<CellInfoSIRSCPLCRr4*>(items[2]) = cellInfo; }
};

typedef SequenceOf<NewInterFreqCellSIRSCPLCRr4, CONSTRAINED, 1, maxCellMeas> NewInterFreqCellSIListRSCPLCRr4;

class InterFreqCellInfoSIListRSCPLCR : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterFreqCellInfoSIListRSCPLCR(): Sequence(&theInfo) {}

	void setRemovedInterFreqCellList(const RemovedInterFreqCellList& removedInterFreqCellList) { *static_cast<RemovedInterFreqCellList*>(items[0]) = removedInterFreqCellList; }
	void setNewInterFreqCellList(const NewInterFreqCellSIListRSCPLCRr4& newInterFreqCellList) { *static_cast<NewInterFreqCellSIListRSCPLCRr4*>(items[1]) = newInterFreqCellList; }
};

class NewInterFreqCellSIECN0LCRr4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	NewInterFreqCellSIECN0LCRr4(): Sequence(&theInfo) {}

	void setInterFreqCellID(const InterFreqCellID& interFreqCellID) { *static_cast<InterFreqCellID*>(items[0]) = interFreqCellID; }
	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[1]) = frequencyInfo; }
	void setCellInfo(const CellInfoSIECN0LCRr4& cellInfo) { *static_cast<CellInfoSIECN0LCRr4*>(items[2]) = cellInfo; }
};

typedef SequenceOf<NewInterFreqCellSIECN0LCRr4, CONSTRAINED, 1, maxCellMeas> NewInterFreqCellSIListECN0LCRr4;

class InterFreqCellInfoSIListECN0LCR : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterFreqCellInfoSIListECN0LCR(): Sequence(&theInfo) {}

	void setRemovedInterFreqCellList(const RemovedInterFreqCellList& removedInterFreqCellList) { *static_cast<RemovedInterFreqCellList*>(items[0]) = removedInterFreqCellList; }
	void setNewInterFreqCellList(const NewInterFreqCellSIListECN0LCRr4& newInterFreqCellList) { *static_cast<NewInterFreqCellSIListECN0LCRr4*>(items[1]) = newInterFreqCellList; }
};

class NewInterFreqCellSIHCSRSCPLCRr4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	NewInterFreqCellSIHCSRSCPLCRr4(): Sequence(&theInfo) {}

	void setInterFreqCellID(const InterFreqCellID& interFreqCellID) { *static_cast<InterFreqCellID*>(items[0]) = interFreqCellID; }
	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[1]) = frequencyInfo; }
	void setCellInfo(const CellInfoSIHCSRSCPLCRr4& cellInfo) { *static_cast<CellInfoSIHCSRSCPLCRr4*>(items[2]) = cellInfo; }
};

typedef SequenceOf<NewInterFreqCellSIHCSRSCPLCRr4, CONSTRAINED, 1, maxCellMeas> NewInterFreqCellSIListHCSRSCPLCRr4;

class InterFreqCellInfoSIListHCSRSCPLCR : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterFreqCellInfoSIListHCSRSCPLCR(): Sequence(&theInfo) {}

	void setRemovedInterFreqCellList(const RemovedInterFreqCellList& removedInterFreqCellList) { *static_cast<RemovedInterFreqCellList*>(items[0]) = removedInterFreqCellList; }
	void setNewInterFreqCellList(const NewInterFreqCellSIListHCSRSCPLCRr4& newInterFreqCellList) { *static_cast<NewInterFreqCellSIListHCSRSCPLCRr4*>(items[1]) = newInterFreqCellList; }
};

class NewInterFreqCellSIHCSECN0LCRr4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	NewInterFreqCellSIHCSECN0LCRr4(): Sequence(&theInfo) {}

	void setInterFreqCellID(const InterFreqCellID& interFreqCellID) { *static_cast<InterFreqCellID*>(items[0]) = interFreqCellID; }
	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[1]) = frequencyInfo; }
	void setCellInfo(const CellInfoSIHCSECN0LCRr4& cellInfo) { *static_cast<CellInfoSIHCSECN0LCRr4*>(items[2]) = cellInfo; }
};

typedef SequenceOf<NewInterFreqCellSIHCSECN0LCRr4, CONSTRAINED, 1, maxCellMeas> NewInterFreqCellSIListHCSECN0LCRr4;

class InterFreqCellInfoSIListHCSECN0LCR : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterFreqCellInfoSIListHCSECN0LCR(): Sequence(&theInfo) {}

	void setRemovedInterFreqCellList(const RemovedInterFreqCellList& removedInterFreqCellList) { *static_cast<RemovedInterFreqCellList*>(items[0]) = removedInterFreqCellList; }
	void setNewInterFreqCellList(const NewInterFreqCellSIListHCSECN0LCRr4& newInterFreqCellList) { *static_cast<NewInterFreqCellSIListHCSECN0LCRr4*>(items[1]) = newInterFreqCellList; }
};

typedef SequenceOf<InterFreqCellLCRr4, CONSTRAINED, 1, maxFreq> InterFreqCellListLCRr4ext;

typedef SequenceOf<CellMeasuredResults, CONSTRAINED, 1, maxCellMeas> InterFreqCellMeasuredResultsList;

typedef SequenceOf<CellMeasuredResultsv920ext, CONSTRAINED, 1, maxCellMeas> InterFreqCellMeasuredResultsListv920ext;

class InterFreqEvent : public Choice {
private:
	static const void *choicesInfo[6];
public:
	enum InterFreqEventChoices {
		event2a = 0,
		event2b = 1,
		event2c = 2,
		event2d = 3,
		event2e = 4,
		event2f = 5,
	};
	static const Info theInfo;
	InterFreqEvent(): Choice(&theInfo) {}
};

class InterFreqEventr6 : public Choice {
private:
	static const void *choicesInfo[6];
public:
	enum InterFreqEventr6Choices {
		event2a = 0,
		event2b = 1,
		event2c = 2,
		event2d = 3,
		event2e = 4,
		event2f = 5,
	};
	static const Info theInfo;
	InterFreqEventr6(): Choice(&theInfo) {}
};

typedef SequenceOf<InterFreqEvent, CONSTRAINED, 1, maxMeasEvent> InterFreqEventList;

typedef SequenceOf<InterFreqEventr6, CONSTRAINED, 1, maxMeasEvent> InterFreqEventListr6;

typedef SequenceOf<DeltaRSCPPerCell, CONSTRAINED, 1, maxCellMeas> InterFrequencyMeasuredResultsListv590ext;

typedef SequenceOf<DeltaRSCPPerCell, CONSTRAINED, 1, maxFreq> ThreholdNonUsedFrequencydeltaList;

class InterFreqEventCriteriav590ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterFreqEventCriteriav590ext(): Sequence(&theInfo) {}

	void setThreholdUsedFrequencydelta(const DeltaRSCP& threholdUsedFrequencydelta) { *static_cast<DeltaRSCP*>(items[0]) = threholdUsedFrequencydelta; }
	void setThreholdNonUsedFrequencydeltaList(const ThreholdNonUsedFrequencydeltaList& threholdNonUsedFrequencydeltaList) { *static_cast<ThreholdNonUsedFrequencydeltaList*>(items[1]) = threholdNonUsedFrequencydeltaList; }
};

typedef SequenceOf<InterFreqEventCriteriav590ext, CONSTRAINED, 1, maxMeasEvent> InterFreqEventCriteriaListv590ext;

typedef SequenceOf<DeltaRSCP, CONSTRAINED, 1, maxMeasEvent> IntraFreqEventCriteriaListv590ext;

typedef SequenceOf<DeltaRSCPPerCell, CONSTRAINED, 1, maxCellMeas> IntraFrequencyMeasuredResultsListv590ext;

class InterFreqEventResultsLCRr4ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterFreqEventResultsLCRr4ext(): Sequence(&theInfo) {}

	void setEventID(const EventIDInterFreq& eventID) { *static_cast<EventIDInterFreq*>(items[0]) = eventID; }
	void setInterFreqCellList(const InterFreqCellListLCRr4ext& interFreqCellList) { *static_cast<InterFreqCellListLCRr4ext*>(items[1]) = interFreqCellList; }
};

enum IntraFreqMeasQuantityFDDValues {
	cpich_Ec_N0_IntraFreqMeasQuantityFDD = 0,
	cpich_RSCP_IntraFreqMeasQuantityFDD = 1,
	pathloss_IntraFreqMeasQuantityFDD = 2,
	dummy_IntraFreqMeasQuantityFDD = 3,
};
typedef Enumerated<CONSTRAINED, 3> IntraFreqMeasQuantityFDD;

class IntraFreqMeasQuantityModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	IntraFreqMeasQuantityModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setIntraFreqMeasQuantityFDD(const IntraFreqMeasQuantityFDD& intraFreqMeasQuantityFDD) { *static_cast<IntraFreqMeasQuantityFDD*>(items[0]) = intraFreqMeasQuantityFDD; }
};

enum IntraFreqMeasQuantityTDDValues {
	primaryCCPCH_RSCP_IntraFreqMeasQuantityTDD = 0,
	pathloss_IntraFreqMeasQuantityTDD = 1,
	timeslotISCP_IntraFreqMeasQuantityTDD = 2,
	dummy_IntraFreqMeasQuantityTDD = 3,
};
typedef Enumerated<CONSTRAINED, 3> IntraFreqMeasQuantityTDD;

typedef SequenceOf<IntraFreqMeasQuantityTDD, CONSTRAINED, 1, 4> IntraFreqMeasQuantityTDDList;

class IntraFreqMeasQuantityModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	IntraFreqMeasQuantityModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setIntraFreqMeasQuantityTDDList(const IntraFreqMeasQuantityTDDList& intraFreqMeasQuantityTDDList) { *static_cast<IntraFreqMeasQuantityTDDList*>(items[0]) = intraFreqMeasQuantityTDDList; }
};

class IntraFreqMeasQuantityModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum IntraFreqMeasQuantityModeSpecificInfoChoices {
		intraFreqMeasQuantityModeSpecificInfoFdd = 0,
		intraFreqMeasQuantityModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	IntraFreqMeasQuantityModeSpecificInfo(): Choice(&theInfo) {}
};

class IntraFreqMeasQuantity : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IntraFreqMeasQuantity(): Sequence(&theInfo) {}

	void setFilterCoefficient(const FilterCoefficient& filterCoefficient) { *static_cast<FilterCoefficient*>(items[0]) = filterCoefficient; }
	void setIntraFreqMeasQuantityModeSpecificInfo(const IntraFreqMeasQuantityModeSpecificInfo& intraFreqMeasQuantityModeSpecificInfo) { *static_cast<IntraFreqMeasQuantityModeSpecificInfo*>(items[1]) = intraFreqMeasQuantityModeSpecificInfo; }
};

class InterFreqMeasQuantityReportingCriteriaIntraFreqReportingCriteria : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterFreqMeasQuantityReportingCriteriaIntraFreqReportingCriteria(): Sequence(&theInfo) {}

	void setIntraFreqMeasQuantity(const IntraFreqMeasQuantity& intraFreqMeasQuantity) { *static_cast<IntraFreqMeasQuantity*>(items[0]) = intraFreqMeasQuantity; }
};

class InterFreqMeasQuantityReportingCriteriaInterFreqReportingCriteriaModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterFreqMeasQuantityReportingCriteriaInterFreqReportingCriteriaModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setFreqQualityEstimateQuantityFDD(const FreqQualityEstimateQuantityFDD& freqQualityEstimateQuantityFDD) { *static_cast<FreqQualityEstimateQuantityFDD*>(items[0]) = freqQualityEstimateQuantityFDD; }
};

class InterFreqMeasQuantityReportingCriteriaInterFreqReportingCriteriaModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterFreqMeasQuantityReportingCriteriaInterFreqReportingCriteriaModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setFreqQualityEstimateQuantityTDD(const FreqQualityEstimateQuantityTDD& freqQualityEstimateQuantityTDD) { *static_cast<FreqQualityEstimateQuantityTDD*>(items[0]) = freqQualityEstimateQuantityTDD; }
};

class InterFreqMeasQuantityReportingCriteriaInterFreqReportingCriteriaModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum InterFreqMeasQuantityReportingCriteriaInterFreqReportingCriteriaModeSpecificInfoChoices {
		interFreqMeasQuantityReportingCriteriaInterFreqReportingCriteriaModeSpecificInfoFdd = 0,
		interFreqMeasQuantityReportingCriteriaInterFreqReportingCriteriaModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	InterFreqMeasQuantityReportingCriteriaInterFreqReportingCriteriaModeSpecificInfo(): Choice(&theInfo) {}
};

class InterFreqMeasQuantityReportingCriteriaInterFreqReportingCriteria : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterFreqMeasQuantityReportingCriteriaInterFreqReportingCriteria(): Sequence(&theInfo) {}

	void setFilterCoefficient(const FilterCoefficient& filterCoefficient) { *static_cast<FilterCoefficient*>(items[0]) = filterCoefficient; }
	void setInterFreqMeasQuantityReportingCriteriaInterFreqReportingCriteriaModeSpecificInfo(const InterFreqMeasQuantityReportingCriteriaInterFreqReportingCriteriaModeSpecificInfo& interFreqMeasQuantityReportingCriteriaInterFreqReportingCriteriaModeSpecificInfo) { *static_cast<InterFreqMeasQuantityReportingCriteriaInterFreqReportingCriteriaModeSpecificInfo*>(items[1]) = interFreqMeasQuantityReportingCriteriaInterFreqReportingCriteriaModeSpecificInfo; }
};

class InterFreqMeasQuantityReportingCriteria : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum InterFreqMeasQuantityReportingCriteriaChoices {
		interFreqMeasQuantityReportingCriteriaIntraFreqReportingCriteria = 0,
		interFreqMeasQuantityReportingCriteriaInterFreqReportingCriteria = 1,
	};
	static const Info theInfo;
	InterFreqMeasQuantityReportingCriteria(): Choice(&theInfo) {}
};

class InterFreqMeasQuantity : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterFreqMeasQuantity(): Sequence(&theInfo) {}

	void setInterFreqMeasQuantityReportingCriteria(const InterFreqMeasQuantityReportingCriteria& interFreqMeasQuantityReportingCriteria) { *static_cast<InterFreqMeasQuantityReportingCriteria*>(items[0]) = interFreqMeasQuantityReportingCriteria; }
};

typedef Integer<CONSTRAINED, 0, 127> UTRACarrierRSSI;

class InterFreqMeasuredResults : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	InterFreqMeasuredResults(): Sequence(&theInfo) {}

	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[0]) = frequencyInfo; }
	void setUtraCarrierRSSI(const UTRACarrierRSSI& utraCarrierRSSI) { *static_cast<UTRACarrierRSSI*>(items[1]) = utraCarrierRSSI; }
	void setInterFreqCellMeasuredResultsList(const InterFreqCellMeasuredResultsList& interFreqCellMeasuredResultsList) { *static_cast<InterFreqCellMeasuredResultsList*>(items[2]) = interFreqCellMeasuredResultsList; }
};

class InterFreqMeasuredResultsv920ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterFreqMeasuredResultsv920ext(): Sequence(&theInfo) {}

	void setInterFreqCellMeasuredResultsList(const InterFreqCellMeasuredResultsListv920ext& interFreqCellMeasuredResultsList) { *static_cast<InterFreqCellMeasuredResultsListv920ext*>(items[0]) = interFreqCellMeasuredResultsList; }
};

typedef SequenceOf<InterFreqMeasuredResults, CONSTRAINED, 1, maxFreq> InterFreqMeasuredResultsList;

typedef SequenceOf<InterFreqMeasuredResultsv920ext, CONSTRAINED, 1, maxFreq> InterFreqMeasuredResultsListv920ext;

class InterFreqMeasurementSysInfoRSCP : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterFreqMeasurementSysInfoRSCP(): Sequence(&theInfo) {}

	void setInterFreqCellInfoSIList(const InterFreqCellInfoSIListRSCP& interFreqCellInfoSIList) { *static_cast<InterFreqCellInfoSIListRSCP*>(items[0]) = interFreqCellInfoSIList; }
};

class InterFreqMeasurementSysInfoECN0 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterFreqMeasurementSysInfoECN0(): Sequence(&theInfo) {}

	void setInterFreqCellInfoSIList(const InterFreqCellInfoSIListECN0& interFreqCellInfoSIList) { *static_cast<InterFreqCellInfoSIListECN0*>(items[0]) = interFreqCellInfoSIList; }
};

class InterFreqMeasurementSysInfoHCSRSCP : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterFreqMeasurementSysInfoHCSRSCP(): Sequence(&theInfo) {}

	void setInterFreqCellInfoSIList(const InterFreqCellInfoSIListHCSRSCP& interFreqCellInfoSIList) { *static_cast<InterFreqCellInfoSIListHCSRSCP*>(items[0]) = interFreqCellInfoSIList; }
};

class InterFreqMeasurementSysInfoHCSECN0 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterFreqMeasurementSysInfoHCSECN0(): Sequence(&theInfo) {}

	void setInterFreqCellInfoSIList(const InterFreqCellInfoSIListHCSECN0& interFreqCellInfoSIList) { *static_cast<InterFreqCellInfoSIListHCSECN0*>(items[0]) = interFreqCellInfoSIList; }
};

class InterFreqMeasurementSysInfoRSCPLCRr4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterFreqMeasurementSysInfoRSCPLCRr4(): Sequence(&theInfo) {}

	void setInterFreqCellInfoSIList(const InterFreqCellInfoSIListRSCPLCR& interFreqCellInfoSIList) { *static_cast<InterFreqCellInfoSIListRSCPLCR*>(items[0]) = interFreqCellInfoSIList; }
};

class InterFreqMeasurementSysInfoECN0LCRr4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterFreqMeasurementSysInfoECN0LCRr4(): Sequence(&theInfo) {}

	void setInterFreqCellInfoSIList(const InterFreqCellInfoSIListECN0LCR& interFreqCellInfoSIList) { *static_cast<InterFreqCellInfoSIListECN0LCR*>(items[0]) = interFreqCellInfoSIList; }
};

class InterFreqMeasurementSysInfoHCSRSCPLCRr4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterFreqMeasurementSysInfoHCSRSCPLCRr4(): Sequence(&theInfo) {}

	void setInterFreqCellInfoSIList(const InterFreqCellInfoSIListHCSRSCPLCR& interFreqCellInfoSIList) { *static_cast<InterFreqCellInfoSIListHCSRSCPLCR*>(items[0]) = interFreqCellInfoSIList; }
};

class InterFreqMeasurementSysInfoHCSECN0LCRr4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterFreqMeasurementSysInfoHCSECN0LCRr4(): Sequence(&theInfo) {}

	void setInterFreqCellInfoSIList(const InterFreqCellInfoSIListHCSECN0LCR& interFreqCellInfoSIList) { *static_cast<InterFreqCellInfoSIListHCSECN0LCR*>(items[0]) = interFreqCellInfoSIList; }
};

class InterFreqRACHRepCellsList : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	InterFreqRACHRepCellsList(): Sequence(&theInfo) {}

};

enum InterFreqRepQuantityRACHFDDValues {
	cpich_EcN0_InterFreqRepQuantityRACHFDD = 0,
	cpich_RSCP_InterFreqRepQuantityRACHFDD = 1,
};
typedef Enumerated<CONSTRAINED, 1> InterFreqRepQuantityRACHFDD;

class DummyInterFreqRACHReportingInfoModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DummyInterFreqRACHReportingInfoModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setInterFreqRepQuantityRACHFDD(const InterFreqRepQuantityRACHFDD& interFreqRepQuantityRACHFDD) { *static_cast<InterFreqRepQuantityRACHFDD*>(items[0]) = interFreqRepQuantityRACHFDD; }
};

enum InterFreqRepQuantityRACHTDDValues {
	dummy_InterFreqRepQuantityRACHTDD = 0,
	primaryCCPCH_RSCP_InterFreqRepQuantityRACHTDD = 1,
};
typedef Enumerated<CONSTRAINED, 1> InterFreqRepQuantityRACHTDD;

typedef SequenceOf<InterFreqRepQuantityRACHTDD, CONSTRAINED, 1, 2> InterFreqRepQuantityRACHTDDList;

class DummyInterFreqRACHReportingInfoModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DummyInterFreqRACHReportingInfoModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setInterFreqRepQuantityRACHTDDList(const InterFreqRepQuantityRACHTDDList& interFreqRepQuantityRACHTDDList) { *static_cast<InterFreqRepQuantityRACHTDDList*>(items[0]) = interFreqRepQuantityRACHTDDList; }
};

typedef Integer<CONSTRAINED, 1, 8> MaxReportedCellsOnRACHinterFreq;

class DummyInterFreqRACHReportingInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum DummyInterFreqRACHReportingInfoModeSpecificInfoChoices {
		dummyInterFreqRACHReportingInfoModeSpecificInfoFdd = 0,
		dummyInterFreqRACHReportingInfoModeSpecificInfoTdd = 1,
		interFreqRACHReportingThreshold = 2,
		maxReportedCellsOnRACHinterFreq = 3,
	};
	static const Info theInfo;
	DummyInterFreqRACHReportingInfoModeSpecificInfo(): Choice(&theInfo) {}
};

class DummyInterFreqRACHReportingInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DummyInterFreqRACHReportingInfo(): Sequence(&theInfo) {}

	void setDummyInterFreqRACHReportingInfoModeSpecificInfo(const DummyInterFreqRACHReportingInfoModeSpecificInfo& dummyInterFreqRACHReportingInfoModeSpecificInfo) { *static_cast<DummyInterFreqRACHReportingInfoModeSpecificInfo*>(items[0]) = dummyInterFreqRACHReportingInfoModeSpecificInfo; }
};

class InterFreqRACHReportingInfoModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterFreqRACHReportingInfoModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setInterFreqRepQuantityRACHFDD(const InterFreqRepQuantityRACHFDD& interFreqRepQuantityRACHFDD) { *static_cast<InterFreqRepQuantityRACHFDD*>(items[0]) = interFreqRepQuantityRACHFDD; }
};

class InterFreqRACHReportingInfoModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterFreqRACHReportingInfoModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setInterFreqRepQuantityRACHTDDList(const InterFreqRepQuantityRACHTDDList& interFreqRepQuantityRACHTDDList) { *static_cast<InterFreqRepQuantityRACHTDDList*>(items[0]) = interFreqRepQuantityRACHTDDList; }
};

class InterFreqRACHReportingInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum InterFreqRACHReportingInfoModeSpecificInfoChoices {
		interFreqRACHReportingInfoModeSpecificInfoFdd = 0,
		interFreqRACHReportingInfoModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	InterFreqRACHReportingInfoModeSpecificInfo(): Choice(&theInfo) {}
};

class InterFreqRACHReportingInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	InterFreqRACHReportingInfo(): Sequence(&theInfo) {}

	void setInterFreqRACHReportingInfoModeSpecificInfo(const InterFreqRACHReportingInfoModeSpecificInfo& interFreqRACHReportingInfoModeSpecificInfo) { *static_cast<InterFreqRACHReportingInfoModeSpecificInfo*>(items[0]) = interFreqRACHReportingInfoModeSpecificInfo; }
	void setInterFreqRACHReportingThreshold(const Threshold& interFreqRACHReportingThreshold) { *static_cast<Threshold*>(items[1]) = interFreqRACHReportingThreshold; }
	void setMaxReportedCellsOnRACHinterFreq(const MaxReportedCellsOnRACHinterFreq& maxReportedCellsOnRACHinterFreq) { *static_cast<MaxReportedCellsOnRACHinterFreq*>(items[2]) = maxReportedCellsOnRACHinterFreq; }
};

class InterFreqReportingCriteria : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterFreqReportingCriteria(): Sequence(&theInfo) {}

	void setInterFreqEventList(const InterFreqEventList& interFreqEventList) { *static_cast<InterFreqEventList*>(items[0]) = interFreqEventList; }
};

class PeriodicalWithReportingCellStatus : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PeriodicalWithReportingCellStatus(): Sequence(&theInfo) {}

	void setPeriodicalReportingCriteria(const PeriodicalReportingCriteria& periodicalReportingCriteria) { *static_cast<PeriodicalReportingCriteria*>(items[0]) = periodicalReportingCriteria; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[1]) = reportingCellStatus; }
};

class ReportingCellStatusOpt : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ReportingCellStatusOpt(): Sequence(&theInfo) {}

	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[0]) = reportingCellStatus; }
};

class InterFreqReportCriteria : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum InterFreqReportCriteriaChoices {
		intraFreqReportingCriteria = 0,
		interFreqReportingCriteria = 1,
		periodicalReportingCriteria = 2,
		noReporting = 3,
	};
	static const Info theInfo;
	InterFreqReportCriteria(): Choice(&theInfo) {}
};

typedef Null IntraFreqEventr4E1d;

typedef Null IntraFreqEventr4E1g;

class IntraFreqEventr4 : public Choice {
private:
	static const void *choicesInfo[9];
public:
	enum IntraFreqEventr4Choices {
		e1a = 0,
		e1b = 1,
		e1c = 2,
		intraFreqEventr4E1d = 3,
		e1e = 4,
		e1f = 5,
		intraFreqEventr4E1g = 6,
		e1h = 7,
		e1i = 8,
	};
	static const Info theInfo;
	IntraFreqEventr4(): Choice(&theInfo) {}
};

class IntraFreqEventCriteriar4 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	IntraFreqEventCriteriar4(): Sequence(&theInfo) {}

	void setEvent(const IntraFreqEventr4& event) { *static_cast<IntraFreqEventr4*>(items[0]) = event; }
	void setHysteresis(const Hysteresis& hysteresis) { *static_cast<Hysteresis*>(items[1]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[2]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[3]) = reportingCellStatus; }
};

typedef SequenceOf<IntraFreqEventCriteriar4, CONSTRAINED, 1, maxMeasEvent> IntraFreqEventCriteriaListr4;

class IntraFreqReportingCriteriar4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	IntraFreqReportingCriteriar4(): Sequence(&theInfo) {}

	void setEventCriteriaList(const IntraFreqEventCriteriaListr4& eventCriteriaList) { *static_cast<IntraFreqEventCriteriaListr4*>(items[0]) = eventCriteriaList; }
};

class InterFreqReportCriteriar4 : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum InterFreqReportCriteriar4Choices {
		intraFreqReportingCriteria = 0,
		interFreqReportingCriteria = 1,
		periodicalReportingCriteria = 2,
		noReporting = 3,
	};
	static const Info theInfo;
	InterFreqReportCriteriar4(): Choice(&theInfo) {}
};

typedef Null IntraFreqEventr6E1g;

class IntraFreqEventr6 : public Choice {
private:
	static const void *choicesInfo[10];
public:
	enum IntraFreqEventr6Choices {
		e1a = 0,
		e1b = 1,
		e1c = 2,
		e1d = 3,
		e1e = 4,
		e1f = 5,
		intraFreqEventr6E1g = 6,
		e1h = 7,
		e1i = 8,
		e1j = 9,
	};
	static const Info theInfo;
	IntraFreqEventr6(): Choice(&theInfo) {}
};

class IntraFreqEventCriteriar6 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	IntraFreqEventCriteriar6(): Sequence(&theInfo) {}

	void setEvent(const IntraFreqEventr6& event) { *static_cast<IntraFreqEventr6*>(items[0]) = event; }
	void setHysteresis(const Hysteresis& hysteresis) { *static_cast<Hysteresis*>(items[1]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[2]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[3]) = reportingCellStatus; }
};

typedef SequenceOf<IntraFreqEventCriteriar6, CONSTRAINED, 1, maxMeasEvent> IntraFreqEventCriteriaListr6;

class IntraFreqReportingCriteriar6 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	IntraFreqReportingCriteriar6(): Sequence(&theInfo) {}

	void setEventCriteriaList(const IntraFreqEventCriteriaListr6& eventCriteriaList) { *static_cast<IntraFreqEventCriteriaListr6*>(items[0]) = eventCriteriaList; }
};

class InterFreqReportingCriteriar6 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterFreqReportingCriteriar6(): Sequence(&theInfo) {}

	void setInterFreqEventList(const InterFreqEventListr6& interFreqEventList) { *static_cast<InterFreqEventListr6*>(items[0]) = interFreqEventList; }
};

class InterFreqReportCriteriar6 : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum InterFreqReportCriteriar6Choices {
		intraFreqReportingCriteria = 0,
		interFreqReportingCriteria = 1,
		periodicalReportingCriteria = 2,
		noReporting = 3,
	};
	static const Info theInfo;
	InterFreqReportCriteriar6(): Choice(&theInfo) {}
};

typedef Null IntraFreqEventr7E1g;

class IntraFreqEventr7 : public Choice {
private:
	static const void *choicesInfo[10];
public:
	enum IntraFreqEventr7Choices {
		e1a = 0,
		e1b = 1,
		e1c = 2,
		e1d = 3,
		e1e = 4,
		e1f = 5,
		intraFreqEventr7E1g = 6,
		e1h = 7,
		e1i = 8,
		e1j = 9,
	};
	static const Info theInfo;
	IntraFreqEventr7(): Choice(&theInfo) {}
};

class IntraFreqEventCriteriar7 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	IntraFreqEventCriteriar7(): Sequence(&theInfo) {}

	void setEvent(const IntraFreqEventr7& event) { *static_cast<IntraFreqEventr7*>(items[0]) = event; }
	void setHysteresis(const Hysteresis& hysteresis) { *static_cast<Hysteresis*>(items[1]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[2]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[3]) = reportingCellStatus; }
};

typedef SequenceOf<IntraFreqEventCriteriar7, CONSTRAINED, 1, maxMeasEvent> IntraFreqEventCriteriaListr7;

class IntraFreqReportingCriteriar7 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	IntraFreqReportingCriteriar7(): Sequence(&theInfo) {}

	void setEventCriteriaList(const IntraFreqEventCriteriaListr7& eventCriteriaList) { *static_cast<IntraFreqEventCriteriaListr7*>(items[0]) = eventCriteriaList; }
};

class InterFreqReportCriteriar7 : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum InterFreqReportCriteriar7Choices {
		intraFreqReportingCriteria = 0,
		interFreqReportingCriteria = 1,
		periodicalReportingCriteria = 2,
		noReporting = 3,
	};
	static const Info theInfo;
	InterFreqReportCriteriar7(): Choice(&theInfo) {}
};

class IntraFreqEventOnSecULFreq : public Choice {
private:
	static const void *choicesInfo[5];
public:
	enum IntraFreqEventOnSecULFreqChoices {
		e1a = 0,
		e1b = 1,
		e1c = 2,
		e1e = 3,
		e1f = 4,
	};
	static const Info theInfo;
	IntraFreqEventOnSecULFreq(): Choice(&theInfo) {}
};

class IntraFreqEventCriteriaOnSecULFreq : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	IntraFreqEventCriteriaOnSecULFreq(): Sequence(&theInfo) {}

	void setEvent(const IntraFreqEventOnSecULFreq& event) { *static_cast<IntraFreqEventOnSecULFreq*>(items[0]) = event; }
	void setHysteresis(const Hysteresis& hysteresis) { *static_cast<Hysteresis*>(items[1]) = hysteresis; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[2]) = timeToTrigger; }
	void setReportingCellStatus(const ReportingCellStatus& reportingCellStatus) { *static_cast<ReportingCellStatus*>(items[3]) = reportingCellStatus; }
};

typedef SequenceOf<IntraFreqEventCriteriaOnSecULFreq, CONSTRAINED, 1, maxMeasEventOnSecULFreq> IntraFreqEventCriteriaListOnSecULFreqIntraFreqEventCriteria;

class IntraFreqEventCriteriaListOnSecULFreq : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IntraFreqEventCriteriaListOnSecULFreq(): Sequence(&theInfo) {}

	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[0]) = frequencyInfo; }
	void setIntraFreqEventCriteriaListOnSecULFreqIntraFreqEventCriteria(const IntraFreqEventCriteriaListOnSecULFreqIntraFreqEventCriteria& intraFreqEventCriteriaListOnSecULFreqIntraFreqEventCriteria) { *static_cast<IntraFreqEventCriteriaListOnSecULFreqIntraFreqEventCriteria*>(items[1]) = intraFreqEventCriteriaListOnSecULFreqIntraFreqEventCriteria; }
};

class IntraFreqReportingCriteriar9 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IntraFreqReportingCriteriar9(): Sequence(&theInfo) {}

	void setEventCriteriaList(const IntraFreqEventCriteriaListr7& eventCriteriaList) { *static_cast<IntraFreqEventCriteriaListr7*>(items[0]) = eventCriteriaList; }
	void setEventCriteriaListOnSecULFreq(const IntraFreqEventCriteriaListOnSecULFreq& eventCriteriaListOnSecULFreq) { *static_cast<IntraFreqEventCriteriaListOnSecULFreq*>(items[1]) = eventCriteriaListOnSecULFreq; }
};

class InterFreqReportCriteriar9 : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum InterFreqReportCriteriar9Choices {
		intraFreqReportingCriteria = 0,
		interFreqReportingCriteria = 1,
		periodicalReportingCriteria = 2,
		noReporting = 3,
	};
	static const Info theInfo;
	InterFreqReportCriteriar9(): Choice(&theInfo) {}
};

typedef Boolean InterFreqReportingQuantityUtraCarrierRSSI;

typedef Boolean InterFreqReportingQuantityFrequencyQualityEstimate;

class InterFreqReportingQuantity : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	InterFreqReportingQuantity(): Sequence(&theInfo) {}

	void setInterFreqReportingQuantityUtraCarrierRSSI(const InterFreqReportingQuantityUtraCarrierRSSI& interFreqReportingQuantityUtraCarrierRSSI) { *static_cast<InterFreqReportingQuantityUtraCarrierRSSI*>(items[0]) = interFreqReportingQuantityUtraCarrierRSSI; }
	void setInterFreqReportingQuantityFrequencyQualityEstimate(const InterFreqReportingQuantityFrequencyQualityEstimate& interFreqReportingQuantityFrequencyQualityEstimate) { *static_cast<InterFreqReportingQuantityFrequencyQualityEstimate*>(items[1]) = interFreqReportingQuantityFrequencyQualityEstimate; }
	void setNonFreqRelatedQuantities(const CellReportingQuantities& nonFreqRelatedQuantities) { *static_cast<CellReportingQuantities*>(items[2]) = nonFreqRelatedQuantities; }
};

enum MeasurementValidityue_StateValues {
	cell_DCH_MeasurementValidityue_State = 0,
	all_But_Cell_DCH_MeasurementValidityue_State = 1,
	all_States_MeasurementValidityue_State = 2,
};
typedef Enumerated<CONSTRAINED, 2> MeasurementValidityue_State;

class MeasurementValidity : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasurementValidity(): Sequence(&theInfo) {}

	void setMeasurementValidityue_State(const MeasurementValidityue_State& measurementValidityue_State) { *static_cast<MeasurementValidityue_State*>(items[0]) = measurementValidityue_State; }
};

typedef Null UEAutonomousUpdateModeDummy;

typedef Null UEAutonomousUpdateModeOnWithNoReporting;

typedef SequenceOf<PrimaryCPICHInfo, CONSTRAINED, 1, maxRL> RLAdditionInfoList;

class RLInformationLists : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	RLInformationLists(): Sequence(&theInfo) {}

	void setRlAdditionInfoList(const RLAdditionInfoList& rlAdditionInfoList) { *static_cast<RLAdditionInfoList*>(items[0]) = rlAdditionInfoList; }
	void setRLRemovalInformationList(const RLRemovalInformationList& rLRemovalInformationList) { *static_cast<RLRemovalInformationList*>(items[1]) = rLRemovalInformationList; }
};

class UEAutonomousUpdateMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum UEAutonomousUpdateModeChoices {
		uEAutonomousUpdateModeDummy = 0,
		uEAutonomousUpdateModeOnWithNoReporting = 1,
		dummy2 = 2,
	};
	static const Info theInfo;
	UEAutonomousUpdateMode(): Choice(&theInfo) {}
};

class InterFrequencyMeasurement : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	InterFrequencyMeasurement(): Sequence(&theInfo) {}

	void setInterFreqCellInfoList(const InterFreqCellInfoList& interFreqCellInfoList) { *static_cast<InterFreqCellInfoList*>(items[0]) = interFreqCellInfoList; }
	void setInterFreqMeasQuantity(const InterFreqMeasQuantity& interFreqMeasQuantity) { *static_cast<InterFreqMeasQuantity*>(items[1]) = interFreqMeasQuantity; }
	void setInterFreqReportingQuantity(const InterFreqReportingQuantity& interFreqReportingQuantity) { *static_cast<InterFreqReportingQuantity*>(items[2]) = interFreqReportingQuantity; }
	void setMeasurementValidity(const MeasurementValidity& measurementValidity) { *static_cast<MeasurementValidity*>(items[3]) = measurementValidity; }
	void setInterFreqSetUpdate(const UEAutonomousUpdateMode& interFreqSetUpdate) { *static_cast<UEAutonomousUpdateMode*>(items[4]) = interFreqSetUpdate; }
	void setReportCriteria(const InterFreqReportCriteria& reportCriteria) { *static_cast<InterFreqReportCriteria*>(items[5]) = reportCriteria; }
};

class InterFrequencyMeasurementr4 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	InterFrequencyMeasurementr4(): Sequence(&theInfo) {}

	void setInterFreqCellInfoList(const InterFreqCellInfoListr4& interFreqCellInfoList) { *static_cast<InterFreqCellInfoListr4*>(items[0]) = interFreqCellInfoList; }
	void setInterFreqMeasQuantity(const InterFreqMeasQuantity& interFreqMeasQuantity) { *static_cast<InterFreqMeasQuantity*>(items[1]) = interFreqMeasQuantity; }
	void setInterFreqReportingQuantity(const InterFreqReportingQuantity& interFreqReportingQuantity) { *static_cast<InterFreqReportingQuantity*>(items[2]) = interFreqReportingQuantity; }
	void setMeasurementValidity(const MeasurementValidity& measurementValidity) { *static_cast<MeasurementValidity*>(items[3]) = measurementValidity; }
	void setInterFreqSetUpdate(const UEAutonomousUpdateMode& interFreqSetUpdate) { *static_cast<UEAutonomousUpdateMode*>(items[4]) = interFreqSetUpdate; }
	void setReportCriteria(const InterFreqReportCriteriar4& reportCriteria) { *static_cast<InterFreqReportCriteriar4*>(items[5]) = reportCriteria; }
};

class InterFrequencyMeasurementr6 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	InterFrequencyMeasurementr6(): Sequence(&theInfo) {}

	void setInterFreqCellInfoList(const InterFreqCellInfoListr4& interFreqCellInfoList) { *static_cast<InterFreqCellInfoListr4*>(items[0]) = interFreqCellInfoList; }
	void setInterFreqMeasQuantity(const InterFreqMeasQuantity& interFreqMeasQuantity) { *static_cast<InterFreqMeasQuantity*>(items[1]) = interFreqMeasQuantity; }
	void setInterFreqReportingQuantity(const InterFreqReportingQuantity& interFreqReportingQuantity) { *static_cast<InterFreqReportingQuantity*>(items[2]) = interFreqReportingQuantity; }
	void setMeasurementValidity(const MeasurementValidity& measurementValidity) { *static_cast<MeasurementValidity*>(items[3]) = measurementValidity; }
	void setInterFreqSetUpdate(const UEAutonomousUpdateMode& interFreqSetUpdate) { *static_cast<UEAutonomousUpdateMode*>(items[4]) = interFreqSetUpdate; }
	void setReportCriteria(const InterFreqReportCriteriar6& reportCriteria) { *static_cast<InterFreqReportCriteriar6*>(items[5]) = reportCriteria; }
};

class InterFrequencyMeasurementr7 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	InterFrequencyMeasurementr7(): Sequence(&theInfo) {}

	void setInterFreqCellInfoList(const InterFreqCellInfoListr4& interFreqCellInfoList) { *static_cast<InterFreqCellInfoListr4*>(items[0]) = interFreqCellInfoList; }
	void setInterFreqMeasQuantity(const InterFreqMeasQuantity& interFreqMeasQuantity) { *static_cast<InterFreqMeasQuantity*>(items[1]) = interFreqMeasQuantity; }
	void setInterFreqReportingQuantity(const InterFreqReportingQuantity& interFreqReportingQuantity) { *static_cast<InterFreqReportingQuantity*>(items[2]) = interFreqReportingQuantity; }
	void setMeasurementValidity(const MeasurementValidity& measurementValidity) { *static_cast<MeasurementValidity*>(items[3]) = measurementValidity; }
	void setInterFreqSetUpdate(const UEAutonomousUpdateMode& interFreqSetUpdate) { *static_cast<UEAutonomousUpdateMode*>(items[4]) = interFreqSetUpdate; }
	void setReportCriteria(const InterFreqReportCriteriar7& reportCriteria) { *static_cast<InterFreqReportCriteriar7*>(items[5]) = reportCriteria; }
};

typedef Integer<CONSTRAINED, 0, 31> InterFrequencyMeasurementr8AdjacentFrequencyIndex;

class InterFrequencyMeasurementr8 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	InterFrequencyMeasurementr8(): Sequence(&theInfo) {}

	void setInterFreqCellInfoList(const InterFreqCellInfoListr8& interFreqCellInfoList) { *static_cast<InterFreqCellInfoListr8*>(items[0]) = interFreqCellInfoList; }
	void setInterFreqMeasQuantity(const InterFreqMeasQuantity& interFreqMeasQuantity) { *static_cast<InterFreqMeasQuantity*>(items[1]) = interFreqMeasQuantity; }
	void setInterFreqReportingQuantity(const InterFreqReportingQuantity& interFreqReportingQuantity) { *static_cast<InterFreqReportingQuantity*>(items[2]) = interFreqReportingQuantity; }
	void setMeasurementValidity(const MeasurementValidity& measurementValidity) { *static_cast<MeasurementValidity*>(items[3]) = measurementValidity; }
	void setInterFreqSetUpdate(const UEAutonomousUpdateMode& interFreqSetUpdate) { *static_cast<UEAutonomousUpdateMode*>(items[4]) = interFreqSetUpdate; }
	void setInterFrequencyMeasurementr8AdjacentFrequencyIndex(const InterFrequencyMeasurementr8AdjacentFrequencyIndex& interFrequencyMeasurementr8AdjacentFrequencyIndex) { *static_cast<InterFrequencyMeasurementr8AdjacentFrequencyIndex*>(items[5]) = interFrequencyMeasurementr8AdjacentFrequencyIndex; }
	void setReportCriteria(const InterFreqReportCriteriar7& reportCriteria) { *static_cast<InterFreqReportCriteriar7*>(items[6]) = reportCriteria; }
};

typedef Integer<CONSTRAINED, 0, 31> InterFrequencyMeasurementr9AdjacentFrequencyIndex;

typedef Integer<CONSTRAINED, 0, 31> InterFrequencyMeasurementr9InterBandFrequencyIndex;

class InterFrequencyMeasurementr9 : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	InterFrequencyMeasurementr9(): Sequence(&theInfo) {}

	void setInterFreqCellInfoList(const InterFreqCellInfoListr9& interFreqCellInfoList) { *static_cast<InterFreqCellInfoListr9*>(items[0]) = interFreqCellInfoList; }
	void setInterFreqMeasQuantity(const InterFreqMeasQuantity& interFreqMeasQuantity) { *static_cast<InterFreqMeasQuantity*>(items[1]) = interFreqMeasQuantity; }
	void setInterFreqReportingQuantity(const InterFreqReportingQuantity& interFreqReportingQuantity) { *static_cast<InterFreqReportingQuantity*>(items[2]) = interFreqReportingQuantity; }
	void setMeasurementValidity(const MeasurementValidity& measurementValidity) { *static_cast<MeasurementValidity*>(items[3]) = measurementValidity; }
	void setInterFreqSetUpdate(const UEAutonomousUpdateMode& interFreqSetUpdate) { *static_cast<UEAutonomousUpdateMode*>(items[4]) = interFreqSetUpdate; }
	void setInterFrequencyMeasurementr9AdjacentFrequencyIndex(const InterFrequencyMeasurementr9AdjacentFrequencyIndex& interFrequencyMeasurementr9AdjacentFrequencyIndex) { *static_cast<InterFrequencyMeasurementr9AdjacentFrequencyIndex*>(items[5]) = interFrequencyMeasurementr9AdjacentFrequencyIndex; }
	void setInterFrequencyMeasurementr9InterBandFrequencyIndex(const InterFrequencyMeasurementr9InterBandFrequencyIndex& interFrequencyMeasurementr9InterBandFrequencyIndex) { *static_cast<InterFrequencyMeasurementr9InterBandFrequencyIndex*>(items[6]) = interFrequencyMeasurementr9InterBandFrequencyIndex; }
	void setReportCriteria(const InterFreqReportCriteriar9& reportCriteria) { *static_cast<InterFreqReportCriteriar9*>(items[7]) = reportCriteria; }
};

typedef BitString<CONSTRAINED, 3, 3> NCMode;

class InterRATTargetCellDescriptionTechnologySpecificInfoGsm : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	InterRATTargetCellDescriptionTechnologySpecificInfoGsm(): Sequence(&theInfo) {}

	void setBsic(const BSIC& bsic) { *static_cast<BSIC*>(items[0]) = bsic; }
	void setFrequencyband(const FrequencyBand& frequencyband) { *static_cast<FrequencyBand*>(items[1]) = frequencyband; }
	void setBcchARFCN(const BCCHARFCN& bcchARFCN) { *static_cast<BCCHARFCN*>(items[2]) = bcchARFCN; }
	void setNcMode(const NCMode& ncMode) { *static_cast<NCMode*>(items[3]) = ncMode; }
};

typedef Null InterRATTargetCellDescriptionTechnologySpecificInfoIs2000;

typedef Null InterRATTargetCellDescriptionTechnologySpecificInfoSpare2;

typedef Null InterRATTargetCellDescriptionTechnologySpecificInfoSpare1;

class InterRATTargetCellDescriptionTechnologySpecificInfo : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum InterRATTargetCellDescriptionTechnologySpecificInfoChoices {
		interRATTargetCellDescriptionTechnologySpecificInfoGsm = 0,
		interRATTargetCellDescriptionTechnologySpecificInfoIs2000 = 1,
		interRATTargetCellDescriptionTechnologySpecificInfoSpare2 = 2,
		interRATTargetCellDescriptionTechnologySpecificInfoSpare1 = 3,
	};
	static const Info theInfo;
	InterRATTargetCellDescriptionTechnologySpecificInfo(): Choice(&theInfo) {}
};

class InterRATTargetCellDescription : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterRATTargetCellDescription(): Sequence(&theInfo) {}

	void setInterRATTargetCellDescriptionTechnologySpecificInfo(const InterRATTargetCellDescriptionTechnologySpecificInfo& interRATTargetCellDescriptionTechnologySpecificInfo) { *static_cast<InterRATTargetCellDescriptionTechnologySpecificInfo*>(items[0]) = interRATTargetCellDescriptionTechnologySpecificInfo; }
};

typedef Integer<CONSTRAINED, 0, 3> InterRATCellInfoIndication;

typedef Null RemovedInterRATCellListRemoveAllInterRATCells;

typedef SequenceOf<InterRATCellID, CONSTRAINED, 1, maxCellMeas> RemovedInterRATCellListRemoveSomeInterRATCells;

typedef Null RemovedInterRATCellListRemoveNoInterRATCells;

class RemovedInterRATCellList : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum RemovedInterRATCellListChoices {
		removedInterRATCellListRemoveAllInterRATCells = 0,
		removedInterRATCellListRemoveSomeInterRATCells = 1,
		removedInterRATCellListRemoveNoInterRATCells = 2,
	};
	static const Info theInfo;
	RemovedInterRATCellList(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, -50, 50> InterRATCellIndividualOffset;

typedef Null NewInterRATCellTechnologySpecificInfoGsmDummy;

class NewInterRATCellTechnologySpecificInfoGsm : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	NewInterRATCellTechnologySpecificInfoGsm(): Sequence(&theInfo) {}

	void setCellSelectionReselectionInfo(const CellSelectReselectInfoSIB1112& cellSelectionReselectionInfo) { *static_cast<CellSelectReselectInfoSIB1112*>(items[0]) = cellSelectionReselectionInfo; }
	void setInterRATCellIndividualOffset(const InterRATCellIndividualOffset& interRATCellIndividualOffset) { *static_cast<InterRATCellIndividualOffset*>(items[1]) = interRATCellIndividualOffset; }
	void setBsic(const BSIC& bsic) { *static_cast<BSIC*>(items[2]) = bsic; }
	void setFrequencyband(const FrequencyBand& frequencyband) { *static_cast<FrequencyBand*>(items[3]) = frequencyband; }
	void setBcchARFCN(const BCCHARFCN& bcchARFCN) { *static_cast<BCCHARFCN*>(items[4]) = bcchARFCN; }
	void setNewInterRATCellTechnologySpecificInfoGsmDummy(const NewInterRATCellTechnologySpecificInfoGsmDummy& newInterRATCellTechnologySpecificInfoGsmDummy) { *static_cast<NewInterRATCellTechnologySpecificInfoGsmDummy*>(items[5]) = newInterRATCellTechnologySpecificInfoGsmDummy; }
};

enum IS2000SpecificMeasInfoValues {
	frequency_IS2000SpecificMeasInfo = 0,
	timeslot_IS2000SpecificMeasInfo = 1,
	colourcode_IS2000SpecificMeasInfo = 2,
	outputpower_IS2000SpecificMeasInfo = 3,
	pn_Offset_IS2000SpecificMeasInfo = 4,
};
typedef Enumerated<CONSTRAINED, 4> IS2000SpecificMeasInfo;

class NewInterRATCellTechnologySpecificInfoIs2000 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	NewInterRATCellTechnologySpecificInfoIs2000(): Sequence(&theInfo) {}

	void setIs2000SpecificMeasInfo(const IS2000SpecificMeasInfo& is2000SpecificMeasInfo) { *static_cast<IS2000SpecificMeasInfo*>(items[0]) = is2000SpecificMeasInfo; }
};

typedef Null NewInterRATCellTechnologySpecificInfoAbsent;

typedef Null NewInterRATCellTechnologySpecificInfoSpare1;

class NewInterRATCellTechnologySpecificInfo : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum NewInterRATCellTechnologySpecificInfoChoices {
		newInterRATCellTechnologySpecificInfoGsm = 0,
		newInterRATCellTechnologySpecificInfoIs2000 = 1,
		newInterRATCellTechnologySpecificInfoAbsent = 2,
		newInterRATCellTechnologySpecificInfoSpare1 = 3,
	};
	static const Info theInfo;
	NewInterRATCellTechnologySpecificInfo(): Choice(&theInfo) {}
};

class NewInterRATCell : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	NewInterRATCell(): Sequence(&theInfo) {}

	void setInterRATCellID(const InterRATCellID& interRATCellID) { *static_cast<InterRATCellID*>(items[0]) = interRATCellID; }
	void setNewInterRATCellTechnologySpecificInfo(const NewInterRATCellTechnologySpecificInfo& newInterRATCellTechnologySpecificInfo) { *static_cast<NewInterRATCellTechnologySpecificInfo*>(items[1]) = newInterRATCellTechnologySpecificInfo; }
};

typedef SequenceOf<NewInterRATCell, CONSTRAINED, 1, maxCellMeas> NewInterRATCellList;

class InterRATCellInfoList : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	InterRATCellInfoList(): Sequence(&theInfo) {}

	void setRemovedInterRATCellList(const RemovedInterRATCellList& removedInterRATCellList) { *static_cast<RemovedInterRATCellList*>(items[0]) = removedInterRATCellList; }
	void setNewInterRATCellList(const NewInterRATCellList& newInterRATCellList) { *static_cast<NewInterRATCellList*>(items[1]) = newInterRATCellList; }
	void setCellsForInterRATMeasList(const CellsForInterRATMeasList& cellsForInterRATMeasList) { *static_cast<CellsForInterRATMeasList*>(items[2]) = cellsForInterRATMeasList; }
};

typedef Null NewInterRATCellBTechnologySpecificInfoGsmDummy;

class NewInterRATCellBTechnologySpecificInfoGsm : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	NewInterRATCellBTechnologySpecificInfoGsm(): Sequence(&theInfo) {}

	void setCellSelectionReselectionInfo(const CellSelectReselectInfoSIB1112& cellSelectionReselectionInfo) { *static_cast<CellSelectReselectInfoSIB1112*>(items[0]) = cellSelectionReselectionInfo; }
	void setInterRATCellIndividualOffset(const InterRATCellIndividualOffset& interRATCellIndividualOffset) { *static_cast<InterRATCellIndividualOffset*>(items[1]) = interRATCellIndividualOffset; }
	void setBsic(const BSIC& bsic) { *static_cast<BSIC*>(items[2]) = bsic; }
	void setFrequencyband(const FrequencyBand& frequencyband) { *static_cast<FrequencyBand*>(items[3]) = frequencyband; }
	void setBcchARFCN(const BCCHARFCN& bcchARFCN) { *static_cast<BCCHARFCN*>(items[4]) = bcchARFCN; }
	void setNewInterRATCellBTechnologySpecificInfoGsmDummy(const NewInterRATCellBTechnologySpecificInfoGsmDummy& newInterRATCellBTechnologySpecificInfoGsmDummy) { *static_cast<NewInterRATCellBTechnologySpecificInfoGsmDummy*>(items[5]) = newInterRATCellBTechnologySpecificInfoGsmDummy; }
};

class NewInterRATCellBTechnologySpecificInfoIs2000 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	NewInterRATCellBTechnologySpecificInfoIs2000(): Sequence(&theInfo) {}

	void setIs2000SpecificMeasInfo(const IS2000SpecificMeasInfo& is2000SpecificMeasInfo) { *static_cast<IS2000SpecificMeasInfo*>(items[0]) = is2000SpecificMeasInfo; }
};

typedef Null NewInterRATCellBTechnologySpecificInfoAbsent;

typedef Null NewInterRATCellBTechnologySpecificInfoSpare1;

class NewInterRATCellBTechnologySpecificInfo : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum NewInterRATCellBTechnologySpecificInfoChoices {
		newInterRATCellBTechnologySpecificInfoGsm = 0,
		newInterRATCellBTechnologySpecificInfoIs2000 = 1,
		newInterRATCellBTechnologySpecificInfoAbsent = 2,
		newInterRATCellBTechnologySpecificInfoSpare1 = 3,
	};
	static const Info theInfo;
	NewInterRATCellBTechnologySpecificInfo(): Choice(&theInfo) {}
};

class NewInterRATCellB : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	NewInterRATCellB(): Sequence(&theInfo) {}

	void setInterRATCellID(const InterRATCellID& interRATCellID) { *static_cast<InterRATCellID*>(items[0]) = interRATCellID; }
	void setNewInterRATCellBTechnologySpecificInfo(const NewInterRATCellBTechnologySpecificInfo& newInterRATCellBTechnologySpecificInfo) { *static_cast<NewInterRATCellBTechnologySpecificInfo*>(items[1]) = newInterRATCellBTechnologySpecificInfo; }
};

typedef SequenceOf<NewInterRATCellB, CONSTRAINED, 1, maxCellMeas> NewInterRATCellListB;

class InterRATCellInfoListB : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterRATCellInfoListB(): Sequence(&theInfo) {}

	void setRemovedInterRATCellList(const RemovedInterRATCellList& removedInterRATCellList) { *static_cast<RemovedInterRATCellList*>(items[0]) = removedInterRATCellList; }
	void setNewInterRATCellList(const NewInterRATCellListB& newInterRATCellList) { *static_cast<NewInterRATCellListB*>(items[1]) = newInterRATCellList; }
};

class InterRATCellInfoListr4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	InterRATCellInfoListr4(): Sequence(&theInfo) {}

	void setRemovedInterRATCellList(const RemovedInterRATCellList& removedInterRATCellList) { *static_cast<RemovedInterRATCellList*>(items[0]) = removedInterRATCellList; }
	void setNewInterRATCellList(const NewInterRATCellList& newInterRATCellList) { *static_cast<NewInterRATCellList*>(items[1]) = newInterRATCellList; }
	void setCellsForInterRATMeasList(const CellsForInterRATMeasList& cellsForInterRATMeasList) { *static_cast<CellsForInterRATMeasList*>(items[2]) = cellsForInterRATMeasList; }
};

class InterRATCellInfoListr6 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	InterRATCellInfoListr6(): Sequence(&theInfo) {}

	void setRemovedInterRATCellList(const RemovedInterRATCellList& removedInterRATCellList) { *static_cast<RemovedInterRATCellList*>(items[0]) = removedInterRATCellList; }
	void setNewInterRATCellList(const NewInterRATCellList& newInterRATCellList) { *static_cast<NewInterRATCellList*>(items[1]) = newInterRATCellList; }
	void setCellsForInterRATMeasList(const CellsForInterRATMeasList& cellsForInterRATMeasList) { *static_cast<CellsForInterRATMeasList*>(items[2]) = cellsForInterRATMeasList; }
	void setInterRATCellInfoIndicationr6(const InterRATCellInfoIndication& interRATCellInfoIndicationr6) { *static_cast<InterRATCellInfoIndication*>(items[3]) = interRATCellInfoIndicationr6; }
};

class InterRATEvent : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum InterRATEventChoices {
		event3a = 0,
		event3b = 1,
		event3c = 2,
		event3d = 3,
	};
	static const Info theInfo;
	InterRATEvent(): Choice(&theInfo) {}
};

typedef SequenceOf<InterRATEvent, CONSTRAINED, 1, maxMeasEvent> InterRATEventList;

enum MeasurementQuantityGSMValues {
	gsm_CarrierRSSI_MeasurementQuantityGSM = 0,
	dummy_MeasurementQuantityGSM = 1,
};
typedef Enumerated<CONSTRAINED, 1> MeasurementQuantityGSM;

class InterRATMeasQuantityRatSpecificInfoGsm : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	InterRATMeasQuantityRatSpecificInfoGsm(): Sequence(&theInfo) {}

	void setMeasurementQuantity(const MeasurementQuantityGSM& measurementQuantity) { *static_cast<MeasurementQuantityGSM*>(items[0]) = measurementQuantity; }
	void setFilterCoefficient(const FilterCoefficient& filterCoefficient) { *static_cast<FilterCoefficient*>(items[1]) = filterCoefficient; }
	void setBsicVerificationRequired(const BSICVerificationRequired& bsicVerificationRequired) { *static_cast<BSICVerificationRequired*>(items[2]) = bsicVerificationRequired; }
};

typedef Integer<CONSTRAINED, 0, 63> InterRATMeasQuantityRatSpecificInfoIs2000TaddEcIo;

typedef Integer<CONSTRAINED, 0, 15> InterRATMeasQuantityRatSpecificInfoIs2000TcompEcIo;

typedef Integer<CONSTRAINED, 0, 63> InterRATMeasQuantityRatSpecificInfoIs2000SoftSlope;

typedef Integer<CONSTRAINED, 0, 63> InterRATMeasQuantityRatSpecificInfoIs2000AddIntercept;

class InterRATMeasQuantityRatSpecificInfoIs2000 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	InterRATMeasQuantityRatSpecificInfoIs2000(): Sequence(&theInfo) {}

	void setInterRATMeasQuantityRatSpecificInfoIs2000TaddEcIo(const InterRATMeasQuantityRatSpecificInfoIs2000TaddEcIo& interRATMeasQuantityRatSpecificInfoIs2000TaddEcIo) { *static_cast<InterRATMeasQuantityRatSpecificInfoIs2000TaddEcIo*>(items[0]) = interRATMeasQuantityRatSpecificInfoIs2000TaddEcIo; }
	void setInterRATMeasQuantityRatSpecificInfoIs2000TcompEcIo(const InterRATMeasQuantityRatSpecificInfoIs2000TcompEcIo& interRATMeasQuantityRatSpecificInfoIs2000TcompEcIo) { *static_cast<InterRATMeasQuantityRatSpecificInfoIs2000TcompEcIo*>(items[1]) = interRATMeasQuantityRatSpecificInfoIs2000TcompEcIo; }
	void setInterRATMeasQuantityRatSpecificInfoIs2000SoftSlope(const InterRATMeasQuantityRatSpecificInfoIs2000SoftSlope& interRATMeasQuantityRatSpecificInfoIs2000SoftSlope) { *static_cast<InterRATMeasQuantityRatSpecificInfoIs2000SoftSlope*>(items[2]) = interRATMeasQuantityRatSpecificInfoIs2000SoftSlope; }
	void setInterRATMeasQuantityRatSpecificInfoIs2000AddIntercept(const InterRATMeasQuantityRatSpecificInfoIs2000AddIntercept& interRATMeasQuantityRatSpecificInfoIs2000AddIntercept) { *static_cast<InterRATMeasQuantityRatSpecificInfoIs2000AddIntercept*>(items[3]) = interRATMeasQuantityRatSpecificInfoIs2000AddIntercept; }
};

class InterRATMeasQuantityRatSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum InterRATMeasQuantityRatSpecificInfoChoices {
		interRATMeasQuantityRatSpecificInfoGsm = 0,
		interRATMeasQuantityRatSpecificInfoIs2000 = 1,
	};
	static const Info theInfo;
	InterRATMeasQuantityRatSpecificInfo(): Choice(&theInfo) {}
};

class InterRATMeasQuantity : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterRATMeasQuantity(): Sequence(&theInfo) {}

	void setMeasQuantityUTRANQualityEstimate(const IntraFreqMeasQuantity& measQuantityUTRANQualityEstimate) { *static_cast<IntraFreqMeasQuantity*>(items[0]) = measQuantityUTRANQualityEstimate; }
	void setInterRATMeasQuantityRatSpecificInfo(const InterRATMeasQuantityRatSpecificInfo& interRATMeasQuantityRatSpecificInfo) { *static_cast<InterRATMeasQuantityRatSpecificInfo*>(items[1]) = interRATMeasQuantityRatSpecificInfo; }
};

class InterRATMeasQuantityr8RatSpecificInfoGsm : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	InterRATMeasQuantityr8RatSpecificInfoGsm(): Sequence(&theInfo) {}

	void setMeasurementQuantity(const MeasurementQuantityGSM& measurementQuantity) { *static_cast<MeasurementQuantityGSM*>(items[0]) = measurementQuantity; }
	void setFilterCoefficient(const FilterCoefficient& filterCoefficient) { *static_cast<FilterCoefficient*>(items[1]) = filterCoefficient; }
	void setBsicVerificationRequired(const BSICVerificationRequired& bsicVerificationRequired) { *static_cast<BSICVerificationRequired*>(items[2]) = bsicVerificationRequired; }
};

typedef Integer<CONSTRAINED, 0, 63> InterRATMeasQuantityr8RatSpecificInfoIs2000TaddEcIo;

typedef Integer<CONSTRAINED, 0, 15> InterRATMeasQuantityr8RatSpecificInfoIs2000TcompEcIo;

typedef Integer<CONSTRAINED, 0, 63> InterRATMeasQuantityr8RatSpecificInfoIs2000SoftSlope;

typedef Integer<CONSTRAINED, 0, 63> InterRATMeasQuantityr8RatSpecificInfoIs2000AddIntercept;

class InterRATMeasQuantityr8RatSpecificInfoIs2000 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	InterRATMeasQuantityr8RatSpecificInfoIs2000(): Sequence(&theInfo) {}

	void setInterRATMeasQuantityr8RatSpecificInfoIs2000TaddEcIo(const InterRATMeasQuantityr8RatSpecificInfoIs2000TaddEcIo& interRATMeasQuantityr8RatSpecificInfoIs2000TaddEcIo) { *static_cast<InterRATMeasQuantityr8RatSpecificInfoIs2000TaddEcIo*>(items[0]) = interRATMeasQuantityr8RatSpecificInfoIs2000TaddEcIo; }
	void setInterRATMeasQuantityr8RatSpecificInfoIs2000TcompEcIo(const InterRATMeasQuantityr8RatSpecificInfoIs2000TcompEcIo& interRATMeasQuantityr8RatSpecificInfoIs2000TcompEcIo) { *static_cast<InterRATMeasQuantityr8RatSpecificInfoIs2000TcompEcIo*>(items[1]) = interRATMeasQuantityr8RatSpecificInfoIs2000TcompEcIo; }
	void setInterRATMeasQuantityr8RatSpecificInfoIs2000SoftSlope(const InterRATMeasQuantityr8RatSpecificInfoIs2000SoftSlope& interRATMeasQuantityr8RatSpecificInfoIs2000SoftSlope) { *static_cast<InterRATMeasQuantityr8RatSpecificInfoIs2000SoftSlope*>(items[2]) = interRATMeasQuantityr8RatSpecificInfoIs2000SoftSlope; }
	void setInterRATMeasQuantityr8RatSpecificInfoIs2000AddIntercept(const InterRATMeasQuantityr8RatSpecificInfoIs2000AddIntercept& interRATMeasQuantityr8RatSpecificInfoIs2000AddIntercept) { *static_cast<InterRATMeasQuantityr8RatSpecificInfoIs2000AddIntercept*>(items[3]) = interRATMeasQuantityr8RatSpecificInfoIs2000AddIntercept; }
};

enum MeasurementQuantityEUTRAValues {
	rrsp_MeasurementQuantityEUTRA = 0,
	rsrq_MeasurementQuantityEUTRA = 1,
};
typedef Enumerated<CONSTRAINED, 1> MeasurementQuantityEUTRA;

class InterRATMeasQuantityr8RatSpecificInfoEUTRA : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterRATMeasQuantityr8RatSpecificInfoEUTRA(): Sequence(&theInfo) {}

	void setMeasurementQuantity(const MeasurementQuantityEUTRA& measurementQuantity) { *static_cast<MeasurementQuantityEUTRA*>(items[0]) = measurementQuantity; }
	void setFilterCoefficient(const FilterCoefficient& filterCoefficient) { *static_cast<FilterCoefficient*>(items[1]) = filterCoefficient; }
};

class InterRATMeasQuantityr8RatSpecificInfo : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum InterRATMeasQuantityr8RatSpecificInfoChoices {
		interRATMeasQuantityr8RatSpecificInfoGsm = 0,
		interRATMeasQuantityr8RatSpecificInfoIs2000 = 1,
		interRATMeasQuantityr8RatSpecificInfoEUTRA = 2,
	};
	static const Info theInfo;
	InterRATMeasQuantityr8RatSpecificInfo(): Choice(&theInfo) {}
};

class InterRATMeasQuantityr8 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterRATMeasQuantityr8(): Sequence(&theInfo) {}

	void setMeasQuantityUTRANQualityEstimate(const IntraFreqMeasQuantity& measQuantityUTRANQualityEstimate) { *static_cast<IntraFreqMeasQuantity*>(items[0]) = measQuantityUTRANQualityEstimate; }
	void setInterRATMeasQuantityr8RatSpecificInfo(const InterRATMeasQuantityr8RatSpecificInfo& interRATMeasQuantityr8RatSpecificInfo) { *static_cast<InterRATMeasQuantityr8RatSpecificInfo*>(items[1]) = interRATMeasQuantityr8RatSpecificInfo; }
};

typedef Null InterRATMeasuredResultsSpare;

class InterRATMeasuredResults : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum InterRATMeasuredResultsChoices {
		gsm = 0,
		interRATMeasuredResultsSpare = 1,
	};
	static const Info theInfo;
	InterRATMeasuredResults(): Choice(&theInfo) {}
};

typedef SequenceOf<InterRATMeasuredResults, CONSTRAINED, 1, maxOtherRAT_16> InterRATMeasuredResultsList;

typedef Boolean InterRATReportingQuantityUtranEstimatedQuality;

typedef Boolean InterRATReportingQuantityRatSpecificInfoGsmDummy;

typedef Boolean InterRATReportingQuantityRatSpecificInfoGsmDummy2;

typedef Boolean InterRATReportingQuantityRatSpecificInfoGsmGsmCarrierRSSI;

class InterRATReportingQuantityRatSpecificInfoGsm : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	InterRATReportingQuantityRatSpecificInfoGsm(): Sequence(&theInfo) {}

	void setInterRATReportingQuantityRatSpecificInfoGsmDummy(const InterRATReportingQuantityRatSpecificInfoGsmDummy& interRATReportingQuantityRatSpecificInfoGsmDummy) { *static_cast<InterRATReportingQuantityRatSpecificInfoGsmDummy*>(items[0]) = interRATReportingQuantityRatSpecificInfoGsmDummy; }
	void setInterRATReportingQuantityRatSpecificInfoGsmDummy2(const InterRATReportingQuantityRatSpecificInfoGsmDummy2& interRATReportingQuantityRatSpecificInfoGsmDummy2) { *static_cast<InterRATReportingQuantityRatSpecificInfoGsmDummy2*>(items[1]) = interRATReportingQuantityRatSpecificInfoGsmDummy2; }
	void setInterRATReportingQuantityRatSpecificInfoGsmGsmCarrierRSSI(const InterRATReportingQuantityRatSpecificInfoGsmGsmCarrierRSSI& interRATReportingQuantityRatSpecificInfoGsmGsmCarrierRSSI) { *static_cast<InterRATReportingQuantityRatSpecificInfoGsmGsmCarrierRSSI*>(items[2]) = interRATReportingQuantityRatSpecificInfoGsmGsmCarrierRSSI; }
};

class InterRATReportingQuantityRatSpecificInfo : public Choice {
private:
	static const void *choicesInfo[1];
public:
	enum InterRATReportingQuantityRatSpecificInfoChoices {
		interRATReportingQuantityRatSpecificInfoGsm = 0,
	};
	static const Info theInfo;
	InterRATReportingQuantityRatSpecificInfo(): Choice(&theInfo) {}
};

class InterRATReportingQuantity : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterRATReportingQuantity(): Sequence(&theInfo) {}

	void setInterRATReportingQuantityUtranEstimatedQuality(const InterRATReportingQuantityUtranEstimatedQuality& interRATReportingQuantityUtranEstimatedQuality) { *static_cast<InterRATReportingQuantityUtranEstimatedQuality*>(items[0]) = interRATReportingQuantityUtranEstimatedQuality; }
	void setInterRATReportingQuantityRatSpecificInfo(const InterRATReportingQuantityRatSpecificInfo& interRATReportingQuantityRatSpecificInfo) { *static_cast<InterRATReportingQuantityRatSpecificInfo*>(items[1]) = interRATReportingQuantityRatSpecificInfo; }
};

class InterRATReportingCriteria : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterRATReportingCriteria(): Sequence(&theInfo) {}

	void setInterRATEventList(const InterRATEventList& interRATEventList) { *static_cast<InterRATEventList*>(items[0]) = interRATEventList; }
};

class InterRATReportCriteria : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum InterRATReportCriteriaChoices {
		interRATReportingCriteria = 0,
		periodicalReportingCriteria = 1,
		noReporting = 2,
	};
	static const Info theInfo;
	InterRATReportCriteria(): Choice(&theInfo) {}
};

class InterRATMeasurement : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	InterRATMeasurement(): Sequence(&theInfo) {}

	void setInterRATCellInfoList(const InterRATCellInfoList& interRATCellInfoList) { *static_cast<InterRATCellInfoList*>(items[0]) = interRATCellInfoList; }
	void setInterRATMeasQuantity(const InterRATMeasQuantity& interRATMeasQuantity) { *static_cast<InterRATMeasQuantity*>(items[1]) = interRATMeasQuantity; }
	void setInterRATReportingQuantity(const InterRATReportingQuantity& interRATReportingQuantity) { *static_cast<InterRATReportingQuantity*>(items[2]) = interRATReportingQuantity; }
	void setReportCriteria(const InterRATReportCriteria& reportCriteria) { *static_cast<InterRATReportCriteria*>(items[3]) = reportCriteria; }
};

class InterRATMeasurementr4 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	InterRATMeasurementr4(): Sequence(&theInfo) {}

	void setInterRATCellInfoList(const InterRATCellInfoListr4& interRATCellInfoList) { *static_cast<InterRATCellInfoListr4*>(items[0]) = interRATCellInfoList; }
	void setInterRATMeasQuantity(const InterRATMeasQuantity& interRATMeasQuantity) { *static_cast<InterRATMeasQuantity*>(items[1]) = interRATMeasQuantity; }
	void setInterRATReportingQuantity(const InterRATReportingQuantity& interRATReportingQuantity) { *static_cast<InterRATReportingQuantity*>(items[2]) = interRATReportingQuantity; }
	void setReportCriteria(const InterRATReportCriteria& reportCriteria) { *static_cast<InterRATReportCriteria*>(items[3]) = reportCriteria; }
};

class InterRATMeasurementr6 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	InterRATMeasurementr6(): Sequence(&theInfo) {}

	void setInterRATCellInfoList(const InterRATCellInfoListr6& interRATCellInfoList) { *static_cast<InterRATCellInfoListr6*>(items[0]) = interRATCellInfoList; }
	void setInterRATMeasQuantity(const InterRATMeasQuantity& interRATMeasQuantity) { *static_cast<InterRATMeasQuantity*>(items[1]) = interRATMeasQuantity; }
	void setInterRATReportingQuantity(const InterRATReportingQuantity& interRATReportingQuantity) { *static_cast<InterRATReportingQuantity*>(items[2]) = interRATReportingQuantity; }
	void setReportCriteria(const InterRATReportCriteria& reportCriteria) { *static_cast<InterRATReportCriteria*>(items[3]) = reportCriteria; }
};

class InterRATMeasurementr8InterRATMeasurementObjects : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum InterRATMeasurementr8InterRATMeasurementObjectsChoices {
		interRATCellInfoList = 0,
		eutraFrequencyList = 1,
	};
	static const Info theInfo;
	InterRATMeasurementr8InterRATMeasurementObjects(): Choice(&theInfo) {}
};

typedef Boolean InterRATReportingQuantityr8UtranEstimatedQuality;

typedef Boolean InterRATReportingQuantityr8RatSpecificInfoGsmGsmCarrierRSSI;

class InterRATReportingQuantityr8RatSpecificInfoGsm : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterRATReportingQuantityr8RatSpecificInfoGsm(): Sequence(&theInfo) {}

	void setInterRATReportingQuantityr8RatSpecificInfoGsmGsmCarrierRSSI(const InterRATReportingQuantityr8RatSpecificInfoGsmGsmCarrierRSSI& interRATReportingQuantityr8RatSpecificInfoGsmGsmCarrierRSSI) { *static_cast<InterRATReportingQuantityr8RatSpecificInfoGsmGsmCarrierRSSI*>(items[0]) = interRATReportingQuantityr8RatSpecificInfoGsmGsmCarrierRSSI; }
};

enum InterRATReportingQuantityr8RatSpecificInfoEutrareportingQuantityValues {
	measurementQuantity_InterRATReportingQuantityr8RatSpecificInfoEutrareportingQuantity = 0,
	both_InterRATReportingQuantityr8RatSpecificInfoEutrareportingQuantity = 1,
};
typedef Enumerated<CONSTRAINED, 1> InterRATReportingQuantityr8RatSpecificInfoEutrareportingQuantity;

class InterRATReportingQuantityr8RatSpecificInfoEutra : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterRATReportingQuantityr8RatSpecificInfoEutra(): Sequence(&theInfo) {}

	void setInterRATReportingQuantityr8RatSpecificInfoEutrareportingQuantity(const InterRATReportingQuantityr8RatSpecificInfoEutrareportingQuantity& interRATReportingQuantityr8RatSpecificInfoEutrareportingQuantity) { *static_cast<InterRATReportingQuantityr8RatSpecificInfoEutrareportingQuantity*>(items[0]) = interRATReportingQuantityr8RatSpecificInfoEutrareportingQuantity; }
};

class InterRATReportingQuantityr8RatSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum InterRATReportingQuantityr8RatSpecificInfoChoices {
		interRATReportingQuantityr8RatSpecificInfoGsm = 0,
		interRATReportingQuantityr8RatSpecificInfoEutra = 1,
	};
	static const Info theInfo;
	InterRATReportingQuantityr8RatSpecificInfo(): Choice(&theInfo) {}
};

class InterRATReportingQuantityr8 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterRATReportingQuantityr8(): Sequence(&theInfo) {}

	void setInterRATReportingQuantityr8UtranEstimatedQuality(const InterRATReportingQuantityr8UtranEstimatedQuality& interRATReportingQuantityr8UtranEstimatedQuality) { *static_cast<InterRATReportingQuantityr8UtranEstimatedQuality*>(items[0]) = interRATReportingQuantityr8UtranEstimatedQuality; }
	void setInterRATReportingQuantityr8RatSpecificInfo(const InterRATReportingQuantityr8RatSpecificInfo& interRATReportingQuantityr8RatSpecificInfo) { *static_cast<InterRATReportingQuantityr8RatSpecificInfo*>(items[1]) = interRATReportingQuantityr8RatSpecificInfo; }
};

class InterRATMeasurementr8 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	InterRATMeasurementr8(): Sequence(&theInfo) {}

	void setInterRATMeasurementr8InterRATMeasurementObjects(const InterRATMeasurementr8InterRATMeasurementObjects& interRATMeasurementr8InterRATMeasurementObjects) { *static_cast<InterRATMeasurementr8InterRATMeasurementObjects*>(items[0]) = interRATMeasurementr8InterRATMeasurementObjects; }
	void setInterRATMeasQuantity(const InterRATMeasQuantityr8& interRATMeasQuantity) { *static_cast<InterRATMeasQuantityr8*>(items[1]) = interRATMeasQuantity; }
	void setInterRATReportingQuantity(const InterRATReportingQuantityr8& interRATReportingQuantity) { *static_cast<InterRATReportingQuantityr8*>(items[2]) = interRATReportingQuantity; }
	void setReportCriteria(const InterRATReportCriteria& reportCriteria) { *static_cast<InterRATReportCriteria*>(items[3]) = reportCriteria; }
	void setIdleIntervalInfo(const IdleIntervalInfo& idleIntervalInfo) { *static_cast<IdleIntervalInfo*>(items[4]) = idleIntervalInfo; }
};

class InterRATMeasurementr9InterRATMeasurementObjects : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum InterRATMeasurementr9InterRATMeasurementObjectsChoices {
		interRATCellInfoList = 0,
		eutraFrequencyList = 1,
	};
	static const Info theInfo;
	InterRATMeasurementr9InterRATMeasurementObjects(): Choice(&theInfo) {}
};

class InterRATMeasurementr9 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	InterRATMeasurementr9(): Sequence(&theInfo) {}

	void setInterRATMeasurementr9InterRATMeasurementObjects(const InterRATMeasurementr9InterRATMeasurementObjects& interRATMeasurementr9InterRATMeasurementObjects) { *static_cast<InterRATMeasurementr9InterRATMeasurementObjects*>(items[0]) = interRATMeasurementr9InterRATMeasurementObjects; }
	void setInterRATMeasQuantity(const InterRATMeasQuantityr8& interRATMeasQuantity) { *static_cast<InterRATMeasQuantityr8*>(items[1]) = interRATMeasQuantity; }
	void setInterRATReportingQuantity(const InterRATReportingQuantityr8& interRATReportingQuantity) { *static_cast<InterRATReportingQuantityr8*>(items[2]) = interRATReportingQuantity; }
	void setReportCriteria(const InterRATReportCriteria& reportCriteria) { *static_cast<InterRATReportCriteria*>(items[3]) = reportCriteria; }
	void setIdleIntervalInfo(const IdleIntervalInfo& idleIntervalInfo) { *static_cast<IdleIntervalInfo*>(items[4]) = idleIntervalInfo; }
};

class InterRATMeasurementSysInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterRATMeasurementSysInfo(): Sequence(&theInfo) {}

	void setInterRATCellInfoList(const InterRATCellInfoList& interRATCellInfoList) { *static_cast<InterRATCellInfoList*>(items[0]) = interRATCellInfoList; }
};

class InterRATMeasurementSysInfoB : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterRATMeasurementSysInfoB(): Sequence(&theInfo) {}

	void setInterRATCellInfoList(const InterRATCellInfoListB& interRATCellInfoList) { *static_cast<InterRATCellInfoListB*>(items[0]) = interRATCellInfoList; }
};

typedef Null RemovedIntraFreqCellListRemoveAllIntraFreqCells;

typedef SequenceOf<IntraFreqCellID, CONSTRAINED, 1, maxCellMeas> RemovedIntraFreqCellListRemoveSomeIntraFreqCells;

typedef Null RemovedIntraFreqCellListRemoveNoIntraFreqCells;

class RemovedIntraFreqCellList : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum RemovedIntraFreqCellListChoices {
		removedIntraFreqCellListRemoveAllIntraFreqCells = 0,
		removedIntraFreqCellListRemoveSomeIntraFreqCells = 1,
		removedIntraFreqCellListRemoveNoIntraFreqCells = 2,
	};
	static const Info theInfo;
	RemovedIntraFreqCellList(): Choice(&theInfo) {}
};

class NewIntraFreqCell : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	NewIntraFreqCell(): Sequence(&theInfo) {}

	void setIntraFreqCellID(const IntraFreqCellID& intraFreqCellID) { *static_cast<IntraFreqCellID*>(items[0]) = intraFreqCellID; }
	void setCellInfo(const CellInfo& cellInfo) { *static_cast<CellInfo*>(items[1]) = cellInfo; }
};

typedef SequenceOf<NewIntraFreqCell, CONSTRAINED, 1, maxCellMeas> NewIntraFreqCellList;

class IntraFreqCellInfoList : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	IntraFreqCellInfoList(): Sequence(&theInfo) {}

	void setRemovedIntraFreqCellList(const RemovedIntraFreqCellList& removedIntraFreqCellList) { *static_cast<RemovedIntraFreqCellList*>(items[0]) = removedIntraFreqCellList; }
	void setNewIntraFreqCellList(const NewIntraFreqCellList& newIntraFreqCellList) { *static_cast<NewIntraFreqCellList*>(items[1]) = newIntraFreqCellList; }
	void setCellsForIntraFreqMeasList(const CellsForIntraFreqMeasList& cellsForIntraFreqMeasList) { *static_cast<CellsForIntraFreqMeasList*>(items[2]) = cellsForIntraFreqMeasList; }
};

class NewIntraFreqCellr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	NewIntraFreqCellr4(): Sequence(&theInfo) {}

	void setIntraFreqCellID(const IntraFreqCellID& intraFreqCellID) { *static_cast<IntraFreqCellID*>(items[0]) = intraFreqCellID; }
	void setCellInfo(const CellInfor4& cellInfo) { *static_cast<CellInfor4*>(items[1]) = cellInfo; }
};

typedef SequenceOf<NewIntraFreqCellr4, CONSTRAINED, 1, maxCellMeas> NewIntraFreqCellListr4;

class IntraFreqCellInfoListr4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	IntraFreqCellInfoListr4(): Sequence(&theInfo) {}

	void setRemovedIntraFreqCellList(const RemovedIntraFreqCellList& removedIntraFreqCellList) { *static_cast<RemovedIntraFreqCellList*>(items[0]) = removedIntraFreqCellList; }
	void setNewIntraFreqCellList(const NewIntraFreqCellListr4& newIntraFreqCellList) { *static_cast<NewIntraFreqCellListr4*>(items[1]) = newIntraFreqCellList; }
	void setCellsForIntraFreqMeasList(const CellsForIntraFreqMeasList& cellsForIntraFreqMeasList) { *static_cast<CellsForIntraFreqMeasList*>(items[2]) = cellsForIntraFreqMeasList; }
};

typedef Null RemovedIntraFreqCellListOnSecULFreqRemoveAllIntraFreqCells;

typedef SequenceOf<IntraFreqCellIDOnSecULFreq, CONSTRAINED, 1, maxCellMeasOnSecULFreq> RemovedIntraFreqCellListOnSecULFreqRemoveSomeIntraFreqCells;

typedef Null RemovedIntraFreqCellListOnSecULFreqRemoveNoIntraFreqCells;

class RemovedIntraFreqCellListOnSecULFreq : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum RemovedIntraFreqCellListOnSecULFreqChoices {
		removedIntraFreqCellListOnSecULFreqRemoveAllIntraFreqCells = 0,
		removedIntraFreqCellListOnSecULFreqRemoveSomeIntraFreqCells = 1,
		removedIntraFreqCellListOnSecULFreqRemoveNoIntraFreqCells = 2,
	};
	static const Info theInfo;
	RemovedIntraFreqCellListOnSecULFreq(): Choice(&theInfo) {}
};

class NewIntraFreqCellOnSecULFreq : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	NewIntraFreqCellOnSecULFreq(): Sequence(&theInfo) {}

	void setIntraFreqCellIDOnSecULFreq(const IntraFreqCellIDOnSecULFreq& intraFreqCellIDOnSecULFreq) { *static_cast<IntraFreqCellIDOnSecULFreq*>(items[0]) = intraFreqCellIDOnSecULFreq; }
	void setCellInfo(const CellInfor4& cellInfo) { *static_cast<CellInfor4*>(items[1]) = cellInfo; }
};

typedef SequenceOf<NewIntraFreqCellOnSecULFreq, CONSTRAINED, 1, maxCellMeasOnSecULFreq> NewIntraFreqCellListOnSecULFreq;

class IntraFreqCellInfoListInfoOnSecULFreq : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	IntraFreqCellInfoListInfoOnSecULFreq(): Sequence(&theInfo) {}

	void setRemovedIntraFreqCellList(const RemovedIntraFreqCellListOnSecULFreq& removedIntraFreqCellList) { *static_cast<RemovedIntraFreqCellListOnSecULFreq*>(items[0]) = removedIntraFreqCellList; }
	void setNewIntraFreqCellList(const NewIntraFreqCellListOnSecULFreq& newIntraFreqCellList) { *static_cast<NewIntraFreqCellListOnSecULFreq*>(items[1]) = newIntraFreqCellList; }
	void setCellsForIntraFreqMeasList(const CellsForIntraFreqMeasListOnSecULFreq& cellsForIntraFreqMeasList) { *static_cast<CellsForIntraFreqMeasListOnSecULFreq*>(items[2]) = cellsForIntraFreqMeasList; }
};

class IntraFreqCellInfoListOnSecULFreq : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	IntraFreqCellInfoListOnSecULFreq(): Sequence(&theInfo) {}

	void setIntraFreqCellInfoListOnSecULFreq(const IntraFreqCellInfoListInfoOnSecULFreq& intraFreqCellInfoListOnSecULFreq) { *static_cast<IntraFreqCellInfoListInfoOnSecULFreq*>(items[0]) = intraFreqCellInfoListOnSecULFreq; }
};

class NewIntraFreqCellr9 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	NewIntraFreqCellr9(): Sequence(&theInfo) {}

	void setIntraFreqCellID(const IntraFreqCellID& intraFreqCellID) { *static_cast<IntraFreqCellID*>(items[0]) = intraFreqCellID; }
	void setCellInfo(const CellInfor9& cellInfo) { *static_cast<CellInfor9*>(items[1]) = cellInfo; }
};

typedef SequenceOf<NewIntraFreqCellr9, CONSTRAINED, 1, maxCellMeas> NewIntraFreqCellListr9;

typedef SequenceOf<PrimaryCPICHInfo, CONSTRAINED, 1, maxSIrequest> IntraFreqSIAcquisitionInfo;

class IntraFreqSIAcquisitionModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	IntraFreqSIAcquisitionModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setIntraFreqSIAcquisitionInfo(const IntraFreqSIAcquisitionInfo& intraFreqSIAcquisitionInfo) { *static_cast<IntraFreqSIAcquisitionInfo*>(items[0]) = intraFreqSIAcquisitionInfo; }
};

typedef Null IntraFreqSIAcquisitionModeSpecificInfoTdd;

class IntraFreqSIAcquisitionModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum IntraFreqSIAcquisitionModeSpecificInfoChoices {
		intraFreqSIAcquisitionModeSpecificInfoFdd = 0,
		intraFreqSIAcquisitionModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	IntraFreqSIAcquisitionModeSpecificInfo(): Choice(&theInfo) {}
};

class IntraFreqSIAcquisition : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	IntraFreqSIAcquisition(): Sequence(&theInfo) {}

	void setIntraFreqSIAcquisitionModeSpecificInfo(const IntraFreqSIAcquisitionModeSpecificInfo& intraFreqSIAcquisitionModeSpecificInfo) { *static_cast<IntraFreqSIAcquisitionModeSpecificInfo*>(items[0]) = intraFreqSIAcquisitionModeSpecificInfo; }
};

class IntraFreqCellInfoListr9 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	IntraFreqCellInfoListr9(): Sequence(&theInfo) {}

	void setRemovedIntraFreqCellList(const RemovedIntraFreqCellList& removedIntraFreqCellList) { *static_cast<RemovedIntraFreqCellList*>(items[0]) = removedIntraFreqCellList; }
	void setNewIntraFreqCellList(const NewIntraFreqCellListr9& newIntraFreqCellList) { *static_cast<NewIntraFreqCellListr9*>(items[1]) = newIntraFreqCellList; }
	void setCellsForIntraFreqMeasList(const CellsForIntraFreqMeasList& cellsForIntraFreqMeasList) { *static_cast<CellsForIntraFreqMeasList*>(items[2]) = cellsForIntraFreqMeasList; }
	void setCSGIntraFreqCellInfoList(const CSGIntraFreqCellInfoList& cSGIntraFreqCellInfoList) { *static_cast<CSGIntraFreqCellInfoList*>(items[3]) = cSGIntraFreqCellInfoList; }
	void setIntraFreqSIAcquisition(const IntraFreqSIAcquisition& intraFreqSIAcquisition) { *static_cast<IntraFreqSIAcquisition*>(items[4]) = intraFreqSIAcquisition; }
};

class NewIntraFreqCellSIRSCP : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	NewIntraFreqCellSIRSCP(): Sequence(&theInfo) {}

	void setIntraFreqCellID(const IntraFreqCellID& intraFreqCellID) { *static_cast<IntraFreqCellID*>(items[0]) = intraFreqCellID; }
	void setCellInfo(const CellInfoSIRSCP& cellInfo) { *static_cast<CellInfoSIRSCP*>(items[1]) = cellInfo; }
};

typedef SequenceOf<NewIntraFreqCellSIRSCP, CONSTRAINED, 1, maxCellMeas> NewIntraFreqCellSIListRSCP;

class IntraFreqCellInfoSIListRSCP : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IntraFreqCellInfoSIListRSCP(): Sequence(&theInfo) {}

	void setRemovedIntraFreqCellList(const RemovedIntraFreqCellList& removedIntraFreqCellList) { *static_cast<RemovedIntraFreqCellList*>(items[0]) = removedIntraFreqCellList; }
	void setNewIntraFreqCellList(const NewIntraFreqCellSIListRSCP& newIntraFreqCellList) { *static_cast<NewIntraFreqCellSIListRSCP*>(items[1]) = newIntraFreqCellList; }
};

class NewIntraFreqCellSIECN0 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	NewIntraFreqCellSIECN0(): Sequence(&theInfo) {}

	void setIntraFreqCellID(const IntraFreqCellID& intraFreqCellID) { *static_cast<IntraFreqCellID*>(items[0]) = intraFreqCellID; }
	void setCellInfo(const CellInfoSIECN0& cellInfo) { *static_cast<CellInfoSIECN0*>(items[1]) = cellInfo; }
};

typedef SequenceOf<NewIntraFreqCellSIECN0, CONSTRAINED, 1, maxCellMeas> NewIntraFreqCellSIListECN0;

class IntraFreqCellInfoSIListECN0 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IntraFreqCellInfoSIListECN0(): Sequence(&theInfo) {}

	void setRemovedIntraFreqCellList(const RemovedIntraFreqCellList& removedIntraFreqCellList) { *static_cast<RemovedIntraFreqCellList*>(items[0]) = removedIntraFreqCellList; }
	void setNewIntraFreqCellList(const NewIntraFreqCellSIListECN0& newIntraFreqCellList) { *static_cast<NewIntraFreqCellSIListECN0*>(items[1]) = newIntraFreqCellList; }
};

class NewIntraFreqCellSIHCSRSCP : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	NewIntraFreqCellSIHCSRSCP(): Sequence(&theInfo) {}

	void setIntraFreqCellID(const IntraFreqCellID& intraFreqCellID) { *static_cast<IntraFreqCellID*>(items[0]) = intraFreqCellID; }
	void setCellInfo(const CellInfoSIHCSRSCP& cellInfo) { *static_cast<CellInfoSIHCSRSCP*>(items[1]) = cellInfo; }
};

typedef SequenceOf<NewIntraFreqCellSIHCSRSCP, CONSTRAINED, 1, maxCellMeas> NewIntraFreqCellSIListHCSRSCP;

class IntraFreqCellInfoSIListHCSRSCP : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IntraFreqCellInfoSIListHCSRSCP(): Sequence(&theInfo) {}

	void setRemovedIntraFreqCellList(const RemovedIntraFreqCellList& removedIntraFreqCellList) { *static_cast<RemovedIntraFreqCellList*>(items[0]) = removedIntraFreqCellList; }
	void setNewIntraFreqCellList(const NewIntraFreqCellSIListHCSRSCP& newIntraFreqCellList) { *static_cast<NewIntraFreqCellSIListHCSRSCP*>(items[1]) = newIntraFreqCellList; }
};

class NewIntraFreqCellSIHCSECN0 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	NewIntraFreqCellSIHCSECN0(): Sequence(&theInfo) {}

	void setIntraFreqCellID(const IntraFreqCellID& intraFreqCellID) { *static_cast<IntraFreqCellID*>(items[0]) = intraFreqCellID; }
	void setCellInfo(const CellInfoSIHCSECN0& cellInfo) { *static_cast<CellInfoSIHCSECN0*>(items[1]) = cellInfo; }
};

typedef SequenceOf<NewIntraFreqCellSIHCSECN0, CONSTRAINED, 1, maxCellMeas> NewIntraFreqCellSIListHCSECN0;

class IntraFreqCellInfoSIListHCSECN0 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IntraFreqCellInfoSIListHCSECN0(): Sequence(&theInfo) {}

	void setRemovedIntraFreqCellList(const RemovedIntraFreqCellList& removedIntraFreqCellList) { *static_cast<RemovedIntraFreqCellList*>(items[0]) = removedIntraFreqCellList; }
	void setNewIntraFreqCellList(const NewIntraFreqCellSIListHCSECN0& newIntraFreqCellList) { *static_cast<NewIntraFreqCellSIListHCSECN0*>(items[1]) = newIntraFreqCellList; }
};

class NewIntraFreqCellSIRSCPLCRr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	NewIntraFreqCellSIRSCPLCRr4(): Sequence(&theInfo) {}

	void setIntraFreqCellID(const IntraFreqCellID& intraFreqCellID) { *static_cast<IntraFreqCellID*>(items[0]) = intraFreqCellID; }
	void setCellInfo(const CellInfoSIRSCPLCRr4& cellInfo) { *static_cast<CellInfoSIRSCPLCRr4*>(items[1]) = cellInfo; }
};

typedef SequenceOf<NewIntraFreqCellSIRSCPLCRr4, CONSTRAINED, 1, maxCellMeas> NewIntraFreqCellSIListRSCPLCRr4;

class IntraFreqCellInfoSIListRSCPLCRr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IntraFreqCellInfoSIListRSCPLCRr4(): Sequence(&theInfo) {}

	void setRemovedIntraFreqCellList(const RemovedIntraFreqCellList& removedIntraFreqCellList) { *static_cast<RemovedIntraFreqCellList*>(items[0]) = removedIntraFreqCellList; }
	void setNewIntraFreqCellList(const NewIntraFreqCellSIListRSCPLCRr4& newIntraFreqCellList) { *static_cast<NewIntraFreqCellSIListRSCPLCRr4*>(items[1]) = newIntraFreqCellList; }
};

class NewIntraFreqCellSIECN0LCRr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	NewIntraFreqCellSIECN0LCRr4(): Sequence(&theInfo) {}

	void setIntraFreqCellID(const IntraFreqCellID& intraFreqCellID) { *static_cast<IntraFreqCellID*>(items[0]) = intraFreqCellID; }
	void setCellInfo(const CellInfoSIECN0LCRr4& cellInfo) { *static_cast<CellInfoSIECN0LCRr4*>(items[1]) = cellInfo; }
};

typedef SequenceOf<NewIntraFreqCellSIECN0LCRr4, CONSTRAINED, 1, maxCellMeas> NewIntraFreqCellSIListECN0LCRr4;

class IntraFreqCellInfoSIListECN0LCRr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IntraFreqCellInfoSIListECN0LCRr4(): Sequence(&theInfo) {}

	void setRemovedIntraFreqCellList(const RemovedIntraFreqCellList& removedIntraFreqCellList) { *static_cast<RemovedIntraFreqCellList*>(items[0]) = removedIntraFreqCellList; }
	void setNewIntraFreqCellList(const NewIntraFreqCellSIListECN0LCRr4& newIntraFreqCellList) { *static_cast<NewIntraFreqCellSIListECN0LCRr4*>(items[1]) = newIntraFreqCellList; }
};

class NewIntraFreqCellSIHCSRSCPLCRr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	NewIntraFreqCellSIHCSRSCPLCRr4(): Sequence(&theInfo) {}

	void setIntraFreqCellID(const IntraFreqCellID& intraFreqCellID) { *static_cast<IntraFreqCellID*>(items[0]) = intraFreqCellID; }
	void setCellInfo(const CellInfoSIHCSRSCPLCRr4& cellInfo) { *static_cast<CellInfoSIHCSRSCPLCRr4*>(items[1]) = cellInfo; }
};

typedef SequenceOf<NewIntraFreqCellSIHCSRSCPLCRr4, CONSTRAINED, 1, maxCellMeas> NewIntraFreqCellSIListHCSRSCPLCRr4;

class IntraFreqCellInfoSIListHCSRSCPLCRr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IntraFreqCellInfoSIListHCSRSCPLCRr4(): Sequence(&theInfo) {}

	void setRemovedIntraFreqCellList(const RemovedIntraFreqCellList& removedIntraFreqCellList) { *static_cast<RemovedIntraFreqCellList*>(items[0]) = removedIntraFreqCellList; }
	void setNewIntraFreqCellList(const NewIntraFreqCellSIListHCSRSCPLCRr4& newIntraFreqCellList) { *static_cast<NewIntraFreqCellSIListHCSRSCPLCRr4*>(items[1]) = newIntraFreqCellList; }
};

class NewIntraFreqCellSIHCSECN0LCRr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	NewIntraFreqCellSIHCSECN0LCRr4(): Sequence(&theInfo) {}

	void setIntraFreqCellID(const IntraFreqCellID& intraFreqCellID) { *static_cast<IntraFreqCellID*>(items[0]) = intraFreqCellID; }
	void setCellInfo(const CellInfoSIHCSECN0LCRr4& cellInfo) { *static_cast<CellInfoSIHCSECN0LCRr4*>(items[1]) = cellInfo; }
};

typedef SequenceOf<NewIntraFreqCellSIHCSECN0LCRr4, CONSTRAINED, 1, maxCellMeas> NewIntraFreqCellSIListHCSECN0LCRr4;

class IntraFreqCellInfoSIListHCSECN0LCRr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IntraFreqCellInfoSIListHCSECN0LCRr4(): Sequence(&theInfo) {}

	void setRemovedIntraFreqCellList(const RemovedIntraFreqCellList& removedIntraFreqCellList) { *static_cast<RemovedIntraFreqCellList*>(items[0]) = removedIntraFreqCellList; }
	void setNewIntraFreqCellList(const NewIntraFreqCellSIListHCSECN0LCRr4& newIntraFreqCellList) { *static_cast<NewIntraFreqCellSIListHCSECN0LCRr4*>(items[1]) = newIntraFreqCellList; }
};

typedef Boolean IntraFreqEvent1dr5UseCIO;

class IntraFreqEvent1dr5 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IntraFreqEvent1dr5(): Sequence(&theInfo) {}

	void setTriggeringCondition(const TriggeringCondition2& triggeringCondition) { *static_cast<TriggeringCondition2*>(items[0]) = triggeringCondition; }
	void setIntraFreqEvent1dr5UseCIO(const IntraFreqEvent1dr5UseCIO& intraFreqEvent1dr5UseCIO) { *static_cast<IntraFreqEvent1dr5UseCIO*>(items[1]) = intraFreqEvent1dr5UseCIO; }
};

enum IntraFreqMeasQuantityFDDsib3Values {
	cpich_Ec_N0_IntraFreqMeasQuantityFDDsib3 = 0,
	cpich_RSCP_IntraFreqMeasQuantityFDDsib3 = 1,
};
typedef Enumerated<CONSTRAINED, 1> IntraFreqMeasQuantityFDDsib3;

class IntraFreqMeasQuantityTDDsib3List : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	IntraFreqMeasQuantityTDDsib3List(): Sequence(&theInfo) {}

};

typedef SequenceOf<CellMeasuredResults, CONSTRAINED, 1, maxCellMeas> IntraFreqMeasuredResultsList;

typedef SequenceOf<CellMeasuredResultsv920ext, CONSTRAINED, 1, maxCellMeas> IntraFreqMeasuredResultsListv920ext;

enum IntraFreqRepQuantityRACHFDDValues {
	cpich_EcN0_IntraFreqRepQuantityRACHFDD = 0,
	cpich_RSCP_IntraFreqRepQuantityRACHFDD = 1,
	pathloss_IntraFreqRepQuantityRACHFDD = 2,
	noReport_IntraFreqRepQuantityRACHFDD = 3,
};
typedef Enumerated<CONSTRAINED, 3> IntraFreqRepQuantityRACHFDD;

class IntraFreqReportingQuantityForRACHModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	IntraFreqReportingQuantityForRACHModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setIntraFreqRepQuantityRACHFDD(const IntraFreqRepQuantityRACHFDD& intraFreqRepQuantityRACHFDD) { *static_cast<IntraFreqRepQuantityRACHFDD*>(items[0]) = intraFreqRepQuantityRACHFDD; }
};

enum IntraFreqRepQuantityRACHTDDValues {
	timeslotISCP_IntraFreqRepQuantityRACHTDD = 0,
	primaryCCPCH_RSCP_IntraFreqRepQuantityRACHTDD = 1,
	noReport_IntraFreqRepQuantityRACHTDD = 2,
};
typedef Enumerated<CONSTRAINED, 2> IntraFreqRepQuantityRACHTDD;

typedef SequenceOf<IntraFreqRepQuantityRACHTDD, CONSTRAINED, 1, 2> IntraFreqRepQuantityRACHTDDList;

class IntraFreqReportingQuantityForRACHModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	IntraFreqReportingQuantityForRACHModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setIntraFreqRepQuantityRACHTDDList(const IntraFreqRepQuantityRACHTDDList& intraFreqRepQuantityRACHTDDList) { *static_cast<IntraFreqRepQuantityRACHTDDList*>(items[0]) = intraFreqRepQuantityRACHTDDList; }
};

class IntraFreqReportingQuantityForRACHModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum IntraFreqReportingQuantityForRACHModeSpecificInfoChoices {
		intraFreqReportingQuantityForRACHModeSpecificInfoFdd = 0,
		intraFreqReportingQuantityForRACHModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	IntraFreqReportingQuantityForRACHModeSpecificInfo(): Choice(&theInfo) {}
};

class IntraFreqReportingQuantityForRACH : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	IntraFreqReportingQuantityForRACH(): Sequence(&theInfo) {}

	void setSfnSFNOTDType(const SFNSFNOTDType& sfnSFNOTDType) { *static_cast<SFNSFNOTDType*>(items[0]) = sfnSFNOTDType; }
	void setIntraFreqReportingQuantityForRACHModeSpecificInfo(const IntraFreqReportingQuantityForRACHModeSpecificInfo& intraFreqReportingQuantityForRACHModeSpecificInfo) { *static_cast<IntraFreqReportingQuantityForRACHModeSpecificInfo*>(items[1]) = intraFreqReportingQuantityForRACHModeSpecificInfo; }
};

enum MaxReportedCellsOnRACHValues {
	noReport_MaxReportedCellsOnRACH = 0,
	currentCell_MaxReportedCellsOnRACH = 1,
	currentAnd_1_BestNeighbour_MaxReportedCellsOnRACH = 2,
	currentAnd_2_BestNeighbour_MaxReportedCellsOnRACH = 3,
	currentAnd_3_BestNeighbour_MaxReportedCellsOnRACH = 4,
	currentAnd_4_BestNeighbour_MaxReportedCellsOnRACH = 5,
	currentAnd_5_BestNeighbour_MaxReportedCellsOnRACH = 6,
	currentAnd_6_BestNeighbour_MaxReportedCellsOnRACH = 7,
};
typedef Enumerated<CONSTRAINED, 7> MaxReportedCellsOnRACH;

class IntraFreqReportingQuantity : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	IntraFreqReportingQuantity(): Sequence(&theInfo) {}

	void setActiveSetReportingQuantities(const CellReportingQuantities& activeSetReportingQuantities) { *static_cast<CellReportingQuantities*>(items[0]) = activeSetReportingQuantities; }
	void setMonitoredSetReportingQuantities(const CellReportingQuantities& monitoredSetReportingQuantities) { *static_cast<CellReportingQuantities*>(items[1]) = monitoredSetReportingQuantities; }
	void setDetectedSetReportingQuantities(const CellReportingQuantities& detectedSetReportingQuantities) { *static_cast<CellReportingQuantities*>(items[2]) = detectedSetReportingQuantities; }
};

enum TransferModeValues {
	acknowledgedModeRLC_TransferMode = 0,
	unacknowledgedModeRLC_TransferMode = 1,
};
typedef Enumerated<CONSTRAINED, 1> TransferMode;

enum PeriodicalOrEventTriggerValues {
	periodical_PeriodicalOrEventTrigger = 0,
	eventTrigger_PeriodicalOrEventTrigger = 1,
};
typedef Enumerated<CONSTRAINED, 1> PeriodicalOrEventTrigger;

class MeasurementReportingMode : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementReportingMode(): Sequence(&theInfo) {}

	void setMeasurementReportTransferMode(const TransferMode& measurementReportTransferMode) { *static_cast<TransferMode*>(items[0]) = measurementReportTransferMode; }
	void setPeriodicalOrEventTrigger(const PeriodicalOrEventTrigger& periodicalOrEventTrigger) { *static_cast<PeriodicalOrEventTrigger*>(items[1]) = periodicalOrEventTrigger; }
};

class ReportingInfoForCellDCH : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ReportingInfoForCellDCH(): Sequence(&theInfo) {}

	void setIntraFreqReportingQuantity(const IntraFreqReportingQuantity& intraFreqReportingQuantity) { *static_cast<IntraFreqReportingQuantity*>(items[0]) = intraFreqReportingQuantity; }
	void setMeasurementReportingMode(const MeasurementReportingMode& measurementReportingMode) { *static_cast<MeasurementReportingMode*>(items[1]) = measurementReportingMode; }
	void setReportCriteria(const CellDCHReportCriteria& reportCriteria) { *static_cast<CellDCHReportCriteria*>(items[2]) = reportCriteria; }
};

class IntraFreqMeasurementSysInfoRSCP : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	IntraFreqMeasurementSysInfoRSCP(): Sequence(&theInfo) {}

	void setIntraFreqMeasurementID(const MeasurementIdentity& intraFreqMeasurementID) { *static_cast<MeasurementIdentity*>(items[0]) = intraFreqMeasurementID; }
	void setIntraFreqCellInfoSIList(const IntraFreqCellInfoSIListRSCP& intraFreqCellInfoSIList) { *static_cast<IntraFreqCellInfoSIListRSCP*>(items[1]) = intraFreqCellInfoSIList; }
	void setIntraFreqMeasQuantity(const IntraFreqMeasQuantity& intraFreqMeasQuantity) { *static_cast<IntraFreqMeasQuantity*>(items[2]) = intraFreqMeasQuantity; }
	void setIntraFreqReportingQuantityForRACH(const IntraFreqReportingQuantityForRACH& intraFreqReportingQuantityForRACH) { *static_cast<IntraFreqReportingQuantityForRACH*>(items[3]) = intraFreqReportingQuantityForRACH; }
	void setMaxReportedCellsOnRACH(const MaxReportedCellsOnRACH& maxReportedCellsOnRACH) { *static_cast<MaxReportedCellsOnRACH*>(items[4]) = maxReportedCellsOnRACH; }
	void setReportingInfoForCellDCH(const ReportingInfoForCellDCH& reportingInfoForCellDCH) { *static_cast<ReportingInfoForCellDCH*>(items[5]) = reportingInfoForCellDCH; }
};

class IntraFreqMeasurementSysInfoECN0 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	IntraFreqMeasurementSysInfoECN0(): Sequence(&theInfo) {}

	void setIntraFreqMeasurementID(const MeasurementIdentity& intraFreqMeasurementID) { *static_cast<MeasurementIdentity*>(items[0]) = intraFreqMeasurementID; }
	void setIntraFreqCellInfoSIList(const IntraFreqCellInfoSIListECN0& intraFreqCellInfoSIList) { *static_cast<IntraFreqCellInfoSIListECN0*>(items[1]) = intraFreqCellInfoSIList; }
	void setIntraFreqMeasQuantity(const IntraFreqMeasQuantity& intraFreqMeasQuantity) { *static_cast<IntraFreqMeasQuantity*>(items[2]) = intraFreqMeasQuantity; }
	void setIntraFreqReportingQuantityForRACH(const IntraFreqReportingQuantityForRACH& intraFreqReportingQuantityForRACH) { *static_cast<IntraFreqReportingQuantityForRACH*>(items[3]) = intraFreqReportingQuantityForRACH; }
	void setMaxReportedCellsOnRACH(const MaxReportedCellsOnRACH& maxReportedCellsOnRACH) { *static_cast<MaxReportedCellsOnRACH*>(items[4]) = maxReportedCellsOnRACH; }
	void setReportingInfoForCellDCH(const ReportingInfoForCellDCH& reportingInfoForCellDCH) { *static_cast<ReportingInfoForCellDCH*>(items[5]) = reportingInfoForCellDCH; }
};

class IntraFreqMeasurementSysInfoHCSRSCP : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	IntraFreqMeasurementSysInfoHCSRSCP(): Sequence(&theInfo) {}

	void setIntraFreqMeasurementID(const MeasurementIdentity& intraFreqMeasurementID) { *static_cast<MeasurementIdentity*>(items[0]) = intraFreqMeasurementID; }
	void setIntraFreqCellInfoSIList(const IntraFreqCellInfoSIListHCSRSCP& intraFreqCellInfoSIList) { *static_cast<IntraFreqCellInfoSIListHCSRSCP*>(items[1]) = intraFreqCellInfoSIList; }
	void setIntraFreqMeasQuantity(const IntraFreqMeasQuantity& intraFreqMeasQuantity) { *static_cast<IntraFreqMeasQuantity*>(items[2]) = intraFreqMeasQuantity; }
	void setIntraFreqReportingQuantityForRACH(const IntraFreqReportingQuantityForRACH& intraFreqReportingQuantityForRACH) { *static_cast<IntraFreqReportingQuantityForRACH*>(items[3]) = intraFreqReportingQuantityForRACH; }
	void setMaxReportedCellsOnRACH(const MaxReportedCellsOnRACH& maxReportedCellsOnRACH) { *static_cast<MaxReportedCellsOnRACH*>(items[4]) = maxReportedCellsOnRACH; }
	void setReportingInfoForCellDCH(const ReportingInfoForCellDCH& reportingInfoForCellDCH) { *static_cast<ReportingInfoForCellDCH*>(items[5]) = reportingInfoForCellDCH; }
};

class IntraFreqMeasurementSysInfoHCSECN0 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	IntraFreqMeasurementSysInfoHCSECN0(): Sequence(&theInfo) {}

	void setIntraFreqMeasurementID(const MeasurementIdentity& intraFreqMeasurementID) { *static_cast<MeasurementIdentity*>(items[0]) = intraFreqMeasurementID; }
	void setIntraFreqCellInfoSIList(const IntraFreqCellInfoSIListHCSECN0& intraFreqCellInfoSIList) { *static_cast<IntraFreqCellInfoSIListHCSECN0*>(items[1]) = intraFreqCellInfoSIList; }
	void setIntraFreqMeasQuantity(const IntraFreqMeasQuantity& intraFreqMeasQuantity) { *static_cast<IntraFreqMeasQuantity*>(items[2]) = intraFreqMeasQuantity; }
	void setIntraFreqReportingQuantityForRACH(const IntraFreqReportingQuantityForRACH& intraFreqReportingQuantityForRACH) { *static_cast<IntraFreqReportingQuantityForRACH*>(items[3]) = intraFreqReportingQuantityForRACH; }
	void setMaxReportedCellsOnRACH(const MaxReportedCellsOnRACH& maxReportedCellsOnRACH) { *static_cast<MaxReportedCellsOnRACH*>(items[4]) = maxReportedCellsOnRACH; }
	void setReportingInfoForCellDCH(const ReportingInfoForCellDCH& reportingInfoForCellDCH) { *static_cast<ReportingInfoForCellDCH*>(items[5]) = reportingInfoForCellDCH; }
};

class ReportingInfoForCellDCHLCRr4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ReportingInfoForCellDCHLCRr4(): Sequence(&theInfo) {}

	void setIntraFreqReportingQuantity(const IntraFreqReportingQuantity& intraFreqReportingQuantity) { *static_cast<IntraFreqReportingQuantity*>(items[0]) = intraFreqReportingQuantity; }
	void setMeasurementReportingMode(const MeasurementReportingMode& measurementReportingMode) { *static_cast<MeasurementReportingMode*>(items[1]) = measurementReportingMode; }
	void setReportCriteria(const CellDCHReportCriteriaLCRr4& reportCriteria) { *static_cast<CellDCHReportCriteriaLCRr4*>(items[2]) = reportCriteria; }
};

class IntraFreqMeasurementSysInfoRSCPLCRr4 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	IntraFreqMeasurementSysInfoRSCPLCRr4(): Sequence(&theInfo) {}

	void setIntraFreqMeasurementID(const MeasurementIdentity& intraFreqMeasurementID) { *static_cast<MeasurementIdentity*>(items[0]) = intraFreqMeasurementID; }
	void setIntraFreqCellInfoSIList(const IntraFreqCellInfoSIListRSCPLCRr4& intraFreqCellInfoSIList) { *static_cast<IntraFreqCellInfoSIListRSCPLCRr4*>(items[1]) = intraFreqCellInfoSIList; }
	void setIntraFreqMeasQuantity(const IntraFreqMeasQuantity& intraFreqMeasQuantity) { *static_cast<IntraFreqMeasQuantity*>(items[2]) = intraFreqMeasQuantity; }
	void setIntraFreqReportingQuantityForRACH(const IntraFreqReportingQuantityForRACH& intraFreqReportingQuantityForRACH) { *static_cast<IntraFreqReportingQuantityForRACH*>(items[3]) = intraFreqReportingQuantityForRACH; }
	void setMaxReportedCellsOnRACH(const MaxReportedCellsOnRACH& maxReportedCellsOnRACH) { *static_cast<MaxReportedCellsOnRACH*>(items[4]) = maxReportedCellsOnRACH; }
	void setReportingInfoForCellDCH(const ReportingInfoForCellDCHLCRr4& reportingInfoForCellDCH) { *static_cast<ReportingInfoForCellDCHLCRr4*>(items[5]) = reportingInfoForCellDCH; }
};

class IntraFreqMeasurementSysInfoECN0LCRr4 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	IntraFreqMeasurementSysInfoECN0LCRr4(): Sequence(&theInfo) {}

	void setIntraFreqMeasurementID(const MeasurementIdentity& intraFreqMeasurementID) { *static_cast<MeasurementIdentity*>(items[0]) = intraFreqMeasurementID; }
	void setIntraFreqCellInfoSIList(const IntraFreqCellInfoSIListECN0LCRr4& intraFreqCellInfoSIList) { *static_cast<IntraFreqCellInfoSIListECN0LCRr4*>(items[1]) = intraFreqCellInfoSIList; }
	void setIntraFreqMeasQuantity(const IntraFreqMeasQuantity& intraFreqMeasQuantity) { *static_cast<IntraFreqMeasQuantity*>(items[2]) = intraFreqMeasQuantity; }
	void setIntraFreqReportingQuantityForRACH(const IntraFreqReportingQuantityForRACH& intraFreqReportingQuantityForRACH) { *static_cast<IntraFreqReportingQuantityForRACH*>(items[3]) = intraFreqReportingQuantityForRACH; }
	void setMaxReportedCellsOnRACH(const MaxReportedCellsOnRACH& maxReportedCellsOnRACH) { *static_cast<MaxReportedCellsOnRACH*>(items[4]) = maxReportedCellsOnRACH; }
	void setReportingInfoForCellDCH(const ReportingInfoForCellDCHLCRr4& reportingInfoForCellDCH) { *static_cast<ReportingInfoForCellDCHLCRr4*>(items[5]) = reportingInfoForCellDCH; }
};

class IntraFreqMeasurementSysInfoHCSRSCPLCRr4 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	IntraFreqMeasurementSysInfoHCSRSCPLCRr4(): Sequence(&theInfo) {}

	void setIntraFreqMeasurementID(const MeasurementIdentity& intraFreqMeasurementID) { *static_cast<MeasurementIdentity*>(items[0]) = intraFreqMeasurementID; }
	void setIntraFreqCellInfoSIList(const IntraFreqCellInfoSIListHCSRSCPLCRr4& intraFreqCellInfoSIList) { *static_cast<IntraFreqCellInfoSIListHCSRSCPLCRr4*>(items[1]) = intraFreqCellInfoSIList; }
	void setIntraFreqMeasQuantity(const IntraFreqMeasQuantity& intraFreqMeasQuantity) { *static_cast<IntraFreqMeasQuantity*>(items[2]) = intraFreqMeasQuantity; }
	void setIntraFreqReportingQuantityForRACH(const IntraFreqReportingQuantityForRACH& intraFreqReportingQuantityForRACH) { *static_cast<IntraFreqReportingQuantityForRACH*>(items[3]) = intraFreqReportingQuantityForRACH; }
	void setMaxReportedCellsOnRACH(const MaxReportedCellsOnRACH& maxReportedCellsOnRACH) { *static_cast<MaxReportedCellsOnRACH*>(items[4]) = maxReportedCellsOnRACH; }
	void setReportingInfoForCellDCH(const ReportingInfoForCellDCHLCRr4& reportingInfoForCellDCH) { *static_cast<ReportingInfoForCellDCHLCRr4*>(items[5]) = reportingInfoForCellDCH; }
};

class IntraFreqMeasurementSysInfoHCSECN0LCRr4 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	IntraFreqMeasurementSysInfoHCSECN0LCRr4(): Sequence(&theInfo) {}

	void setIntraFreqMeasurementID(const MeasurementIdentity& intraFreqMeasurementID) { *static_cast<MeasurementIdentity*>(items[0]) = intraFreqMeasurementID; }
	void setIntraFreqCellInfoSIList(const IntraFreqCellInfoSIListHCSECN0LCRr4& intraFreqCellInfoSIList) { *static_cast<IntraFreqCellInfoSIListHCSECN0LCRr4*>(items[1]) = intraFreqCellInfoSIList; }
	void setIntraFreqMeasQuantity(const IntraFreqMeasQuantity& intraFreqMeasQuantity) { *static_cast<IntraFreqMeasQuantity*>(items[2]) = intraFreqMeasQuantity; }
	void setIntraFreqReportingQuantityForRACH(const IntraFreqReportingQuantityForRACH& intraFreqReportingQuantityForRACH) { *static_cast<IntraFreqReportingQuantityForRACH*>(items[3]) = intraFreqReportingQuantityForRACH; }
	void setMaxReportedCellsOnRACH(const MaxReportedCellsOnRACH& maxReportedCellsOnRACH) { *static_cast<MaxReportedCellsOnRACH*>(items[4]) = maxReportedCellsOnRACH; }
	void setReportingInfoForCellDCH(const ReportingInfoForCellDCHLCRr4& reportingInfoForCellDCH) { *static_cast<ReportingInfoForCellDCHLCRr4*>(items[5]) = reportingInfoForCellDCH; }
};

class IntraFreqReportCriteria : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum IntraFreqReportCriteriaChoices {
		intraFreqReportingCriteria = 0,
		periodicalReportingCriteria = 1,
		noReporting = 2,
	};
	static const Info theInfo;
	IntraFreqReportCriteria(): Choice(&theInfo) {}
};

class IntraFreqReportCriteriar4 : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum IntraFreqReportCriteriar4Choices {
		intraFreqReportingCriteria = 0,
		periodicalReportingCriteria = 1,
		noReporting = 2,
	};
	static const Info theInfo;
	IntraFreqReportCriteriar4(): Choice(&theInfo) {}
};

class IntraFreqReportCriteriar6 : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum IntraFreqReportCriteriar6Choices {
		intraFreqReportingCriteria = 0,
		periodicalReportingCriteria = 1,
		noReporting = 2,
	};
	static const Info theInfo;
	IntraFreqReportCriteriar6(): Choice(&theInfo) {}
};

class IntraFreqReportCriteriar7 : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum IntraFreqReportCriteriar7Choices {
		intraFreqReportingCriteria = 0,
		periodicalReportingCriteria = 1,
		noReporting = 2,
	};
	static const Info theInfo;
	IntraFreqReportCriteriar7(): Choice(&theInfo) {}
};

class IntraFreqReportCriteriar9 : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum IntraFreqReportCriteriar9Choices {
		intraFreqReportingCriteria = 0,
		periodicalReportingCriteria = 1,
		noReporting = 2,
	};
	static const Info theInfo;
	IntraFreqReportCriteriar9(): Choice(&theInfo) {}
};

class IntraFreqReportingCriteria1br5 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	IntraFreqReportingCriteria1br5(): Sequence(&theInfo) {}

	void setPeriodicReportingInfo1b(const PeriodicReportingInfo1b& periodicReportingInfo1b) { *static_cast<PeriodicReportingInfo1b*>(items[0]) = periodicReportingInfo1b; }
};

class IntraFrequencyMeasurement : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	IntraFrequencyMeasurement(): Sequence(&theInfo) {}

	void setIntraFreqCellInfoList(const IntraFreqCellInfoList& intraFreqCellInfoList) { *static_cast<IntraFreqCellInfoList*>(items[0]) = intraFreqCellInfoList; }
	void setIntraFreqMeasQuantity(const IntraFreqMeasQuantity& intraFreqMeasQuantity) { *static_cast<IntraFreqMeasQuantity*>(items[1]) = intraFreqMeasQuantity; }
	void setIntraFreqReportingQuantity(const IntraFreqReportingQuantity& intraFreqReportingQuantity) { *static_cast<IntraFreqReportingQuantity*>(items[2]) = intraFreqReportingQuantity; }
	void setMeasurementValidity(const MeasurementValidity& measurementValidity) { *static_cast<MeasurementValidity*>(items[3]) = measurementValidity; }
	void setReportCriteria(const IntraFreqReportCriteria& reportCriteria) { *static_cast<IntraFreqReportCriteria*>(items[4]) = reportCriteria; }
};

class IntraFrequencyMeasurementr4 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	IntraFrequencyMeasurementr4(): Sequence(&theInfo) {}

	void setIntraFreqCellInfoList(const IntraFreqCellInfoListr4& intraFreqCellInfoList) { *static_cast<IntraFreqCellInfoListr4*>(items[0]) = intraFreqCellInfoList; }
	void setIntraFreqMeasQuantity(const IntraFreqMeasQuantity& intraFreqMeasQuantity) { *static_cast<IntraFreqMeasQuantity*>(items[1]) = intraFreqMeasQuantity; }
	void setIntraFreqReportingQuantity(const IntraFreqReportingQuantity& intraFreqReportingQuantity) { *static_cast<IntraFreqReportingQuantity*>(items[2]) = intraFreqReportingQuantity; }
	void setMeasurementValidity(const MeasurementValidity& measurementValidity) { *static_cast<MeasurementValidity*>(items[3]) = measurementValidity; }
	void setReportCriteria(const IntraFreqReportCriteriar4& reportCriteria) { *static_cast<IntraFreqReportCriteriar4*>(items[4]) = reportCriteria; }
};

class IntraFrequencyMeasurementr6 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	IntraFrequencyMeasurementr6(): Sequence(&theInfo) {}

	void setIntraFreqCellInfoList(const IntraFreqCellInfoListr4& intraFreqCellInfoList) { *static_cast<IntraFreqCellInfoListr4*>(items[0]) = intraFreqCellInfoList; }
	void setIntraFreqMeasQuantity(const IntraFreqMeasQuantity& intraFreqMeasQuantity) { *static_cast<IntraFreqMeasQuantity*>(items[1]) = intraFreqMeasQuantity; }
	void setIntraFreqReportingQuantity(const IntraFreqReportingQuantity& intraFreqReportingQuantity) { *static_cast<IntraFreqReportingQuantity*>(items[2]) = intraFreqReportingQuantity; }
	void setMeasurementValidity(const MeasurementValidity& measurementValidity) { *static_cast<MeasurementValidity*>(items[3]) = measurementValidity; }
	void setReportCriteria(const IntraFreqReportCriteriar6& reportCriteria) { *static_cast<IntraFreqReportCriteriar6*>(items[4]) = reportCriteria; }
};

class IntraFrequencyMeasurementr7 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	IntraFrequencyMeasurementr7(): Sequence(&theInfo) {}

	void setIntraFreqCellInfoList(const IntraFreqCellInfoListr4& intraFreqCellInfoList) { *static_cast<IntraFreqCellInfoListr4*>(items[0]) = intraFreqCellInfoList; }
	void setIntraFreqMeasQuantity(const IntraFreqMeasQuantity& intraFreqMeasQuantity) { *static_cast<IntraFreqMeasQuantity*>(items[1]) = intraFreqMeasQuantity; }
	void setIntraFreqReportingQuantity(const IntraFreqReportingQuantity& intraFreqReportingQuantity) { *static_cast<IntraFreqReportingQuantity*>(items[2]) = intraFreqReportingQuantity; }
	void setMeasurementValidity(const MeasurementValidity& measurementValidity) { *static_cast<MeasurementValidity*>(items[3]) = measurementValidity; }
	void setReportCriteria(const IntraFreqReportCriteriar7& reportCriteria) { *static_cast<IntraFreqReportCriteriar7*>(items[4]) = reportCriteria; }
};

class IntraFrequencyMeasurementr9 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	IntraFrequencyMeasurementr9(): Sequence(&theInfo) {}

	void setIntraFreqCellInfoList(const IntraFreqCellInfoListr9& intraFreqCellInfoList) { *static_cast<IntraFreqCellInfoListr9*>(items[0]) = intraFreqCellInfoList; }
	void setIntraFreqCellInfoListOnSecULFreq(const IntraFreqCellInfoListOnSecULFreq& intraFreqCellInfoListOnSecULFreq) { *static_cast<IntraFreqCellInfoListOnSecULFreq*>(items[1]) = intraFreqCellInfoListOnSecULFreq; }
	void setIntraFreqMeasQuantity(const IntraFreqMeasQuantity& intraFreqMeasQuantity) { *static_cast<IntraFreqMeasQuantity*>(items[2]) = intraFreqMeasQuantity; }
	void setIntraFreqReportingQuantity(const IntraFreqReportingQuantity& intraFreqReportingQuantity) { *static_cast<IntraFreqReportingQuantity*>(items[3]) = intraFreqReportingQuantity; }
	void setMeasurementValidity(const MeasurementValidity& measurementValidity) { *static_cast<MeasurementValidity*>(items[4]) = measurementValidity; }
	void setReportCriteria(const IntraFreqReportCriteriar9& reportCriteria) { *static_cast<IntraFreqReportCriteriar9*>(items[5]) = reportCriteria; }
};

typedef SequenceOf<CellMeasuredResultsr9, CONSTRAINED, 1, maxCellMeasOnSecULFreq> IntraFrequencyMeasuredResultsListOnSecULFreq;

enum IPLengthValues {
	ipl5_IPLength = 0,
	ipl10_IPLength = 1,
};
typedef Enumerated<CONSTRAINED, 1> IPLength;

typedef Boolean IPPCCPCHr4;

enum IPSpacingValues {
	e5_IPSpacing = 0,
	e7_IPSpacing = 1,
	e10_IPSpacing = 2,
	e15_IPSpacing = 3,
	e20_IPSpacing = 4,
	e30_IPSpacing = 5,
	e40_IPSpacing = 6,
	e50_IPSpacing = 7,
};
typedef Enumerated<CONSTRAINED, 7> IPSpacing;

enum IPSpacingTDDValues {
	e30_IPSpacingTDD = 0,
	e40_IPSpacingTDD = 1,
	e50_IPSpacingTDD = 2,
	e70_IPSpacingTDD = 3,
	e100_IPSpacingTDD = 4,
};
typedef Enumerated<CONSTRAINED, 4> IPSpacingTDD;

enum RLCBuffersPayloadValues {
	pl0_RLCBuffersPayload = 0,
	pl4_RLCBuffersPayload = 1,
	pl8_RLCBuffersPayload = 2,
	pl16_RLCBuffersPayload = 3,
	pl32_RLCBuffersPayload = 4,
	pl64_RLCBuffersPayload = 5,
	pl128_RLCBuffersPayload = 6,
	pl256_RLCBuffersPayload = 7,
	pl512_RLCBuffersPayload = 8,
	pl1024_RLCBuffersPayload = 9,
	pl2k_RLCBuffersPayload = 10,
	pl4k_RLCBuffersPayload = 11,
	pl8k_RLCBuffersPayload = 12,
	pl16k_RLCBuffersPayload = 13,
	pl32k_RLCBuffersPayload = 14,
	pl64k_RLCBuffersPayload = 15,
	pl128k_RLCBuffersPayload = 16,
	pl256k_RLCBuffersPayload = 17,
	pl512k_RLCBuffersPayload = 18,
	pl1024k_RLCBuffersPayload = 19,
	spare12_RLCBuffersPayload = 20,
	spare11_RLCBuffersPayload = 21,
	spare10_RLCBuffersPayload = 22,
	spare9_RLCBuffersPayload = 23,
	spare8_RLCBuffersPayload = 24,
	spare7_RLCBuffersPayload = 25,
	spare6_RLCBuffersPayload = 26,
	spare5_RLCBuffersPayload = 27,
	spare4_RLCBuffersPayload = 28,
	spare3_RLCBuffersPayload = 29,
	spare2_RLCBuffersPayload = 30,
	spare1_RLCBuffersPayload = 31,
};
typedef Enumerated<CONSTRAINED, 31> RLCBuffersPayload;

enum VarianceOfRLCBufferPayloadValues {
	plv0_VarianceOfRLCBufferPayload = 0,
	plv4_VarianceOfRLCBufferPayload = 1,
	plv8_VarianceOfRLCBufferPayload = 2,
	plv16_VarianceOfRLCBufferPayload = 3,
	plv32_VarianceOfRLCBufferPayload = 4,
	plv64_VarianceOfRLCBufferPayload = 5,
	plv128_VarianceOfRLCBufferPayload = 6,
	plv256_VarianceOfRLCBufferPayload = 7,
	plv512_VarianceOfRLCBufferPayload = 8,
	plv1024_VarianceOfRLCBufferPayload = 9,
	plv2k_VarianceOfRLCBufferPayload = 10,
	plv4k_VarianceOfRLCBufferPayload = 11,
	plv8k_VarianceOfRLCBufferPayload = 12,
	plv16k_VarianceOfRLCBufferPayload = 13,
	spare2_VarianceOfRLCBufferPayload = 14,
	spare1_VarianceOfRLCBufferPayload = 15,
};
typedef Enumerated<CONSTRAINED, 15> VarianceOfRLCBufferPayload;

class TrafficVolumeMeasuredResults : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	TrafficVolumeMeasuredResults(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setRlcBuffersPayload(const RLCBuffersPayload& rlcBuffersPayload) { *static_cast<RLCBuffersPayload*>(items[1]) = rlcBuffersPayload; }
	void setAverageRLCBufferPayload(const AverageRLCBufferPayload& averageRLCBufferPayload) { *static_cast<AverageRLCBufferPayload*>(items[2]) = averageRLCBufferPayload; }
	void setVarianceOfRLCBufferPayload(const VarianceOfRLCBufferPayload& varianceOfRLCBufferPayload) { *static_cast<VarianceOfRLCBufferPayload*>(items[3]) = varianceOfRLCBufferPayload; }
};

typedef SequenceOf<TrafficVolumeMeasuredResults, CONSTRAINED, 1, maxRB> TrafficVolumeMeasuredResultsList;

typedef Null QualityMeasuredResultsModeSpecificInfoFdd;

typedef Integer<CONSTRAINED, 0, 63> SIR;

typedef SequenceOf<SIR, CONSTRAINED, 1, maxTS> SIRTimeslotList;

class SIRMeasurementResults : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SIRMeasurementResults(): Sequence(&theInfo) {}

	void setTfcsID(const TFCSIdentityPlain& tfcsID) { *static_cast<TFCSIdentityPlain*>(items[0]) = tfcsID; }
	void setSirTimeslotList(const SIRTimeslotList& sirTimeslotList) { *static_cast<SIRTimeslotList*>(items[1]) = sirTimeslotList; }
};

typedef SequenceOf<SIRMeasurementResults, CONSTRAINED, 1, maxCCTrCH> SIRMeasurementList;

class QualityMeasuredResultsModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	QualityMeasuredResultsModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setSirMeasurementResults(const SIRMeasurementList& sirMeasurementResults) { *static_cast<SIRMeasurementList*>(items[0]) = sirMeasurementResults; }
};

class QualityMeasuredResultsModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum QualityMeasuredResultsModeSpecificInfoChoices {
		qualityMeasuredResultsModeSpecificInfoFdd = 0,
		qualityMeasuredResultsModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	QualityMeasuredResultsModeSpecificInfo(): Choice(&theInfo) {}
};

class QualityMeasuredResults : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	QualityMeasuredResults(): Sequence(&theInfo) {}

	void setBlerMeasurementResultsList(const BLERMeasurementResultsList& blerMeasurementResultsList) { *static_cast<BLERMeasurementResultsList*>(items[0]) = blerMeasurementResultsList; }
	void setQualityMeasuredResultsModeSpecificInfo(const QualityMeasuredResultsModeSpecificInfo& qualityMeasuredResultsModeSpecificInfo) { *static_cast<QualityMeasuredResultsModeSpecificInfo*>(items[1]) = qualityMeasuredResultsModeSpecificInfo; }
};

typedef Integer<CONSTRAINED, 0, 104> UETransmittedPower;

typedef Integer<CONSTRAINED, 768, 1791> UERXTXTimeDifferenceType1;

class UERXTXReportEntry : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UERXTXReportEntry(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setUeRXTXTimeDifferenceType1(const UERXTXTimeDifferenceType1& ueRXTXTimeDifferenceType1) { *static_cast<UERXTXTimeDifferenceType1*>(items[1]) = ueRXTXTimeDifferenceType1; }
};

typedef SequenceOf<UERXTXReportEntry, CONSTRAINED, 1, maxRL> UERXTXReportEntryList;

class UEInternalMeasuredResultsModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEInternalMeasuredResultsModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setUeTransmittedPowerFDD(const UETransmittedPower& ueTransmittedPowerFDD) { *static_cast<UETransmittedPower*>(items[0]) = ueTransmittedPowerFDD; }
	void setUeRXTXReportEntryList(const UERXTXReportEntryList& ueRXTXReportEntryList) { *static_cast<UERXTXReportEntryList*>(items[1]) = ueRXTXReportEntryList; }
};

typedef SequenceOf<UETransmittedPower, CONSTRAINED, 1, maxTS> UETransmittedPowerTDDList;

class UEInternalMeasuredResultsModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEInternalMeasuredResultsModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setUeTransmittedPowerTDDList(const UETransmittedPowerTDDList& ueTransmittedPowerTDDList) { *static_cast<UETransmittedPowerTDDList*>(items[0]) = ueTransmittedPowerTDDList; }
	void setAppliedTA(const ULTimingAdvance& appliedTA) { *static_cast<ULTimingAdvance*>(items[1]) = appliedTA; }
};

class UEInternalMeasuredResultsModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEInternalMeasuredResultsModeSpecificInfoChoices {
		uEInternalMeasuredResultsModeSpecificInfoFdd = 0,
		uEInternalMeasuredResultsModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	UEInternalMeasuredResultsModeSpecificInfo(): Choice(&theInfo) {}
};

class UEInternalMeasuredResults : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEInternalMeasuredResults(): Sequence(&theInfo) {}

	void setUEInternalMeasuredResultsModeSpecificInfo(const UEInternalMeasuredResultsModeSpecificInfo& uEInternalMeasuredResultsModeSpecificInfo) { *static_cast<UEInternalMeasuredResultsModeSpecificInfo*>(items[0]) = uEInternalMeasuredResultsModeSpecificInfo; }
};

enum UEPositioningErrorCauseValues {
	notEnoughOTDOA_Cells_UEPositioningErrorCause = 0,
	notEnoughGPS_Satellites_UEPositioningErrorCause = 1,
	assistanceDataMissing_UEPositioningErrorCause = 2,
	notAccomplishedGPS_TimingOfCellFrames_UEPositioningErrorCause = 3,
	undefinedError_UEPositioningErrorCause = 4,
	requestDeniedByUser_UEPositioningErrorCause = 5,
	notProcessedAndTimeout_UEPositioningErrorCause = 6,
	referenceCellNotServingCell_UEPositioningErrorCause = 7,
};
typedef Enumerated<CONSTRAINED, 7> UEPositioningErrorCause;

typedef Boolean UEPositioningGPSAdditionalAssistanceDataRequestAlmanacRequest;

typedef Boolean UEPositioningGPSAdditionalAssistanceDataRequestUtcModelRequest;

typedef Boolean UEPositioningGPSAdditionalAssistanceDataRequestIonosphericModelRequest;

typedef Boolean UEPositioningGPSAdditionalAssistanceDataRequestNavigationModelRequest;

typedef Boolean UEPositioningGPSAdditionalAssistanceDataRequestDgpsCorrectionsRequest;

typedef Boolean UEPositioningGPSAdditionalAssistanceDataRequestReferenceLocationRequest;

typedef Boolean UEPositioningGPSAdditionalAssistanceDataRequestReferenceTimeRequest;

typedef Boolean UEPositioningGPSAdditionalAssistanceDataRequestAquisitionAssistanceRequest;

typedef Boolean UEPositioningGPSAdditionalAssistanceDataRequestRealTimeIntegrityRequest;

typedef Integer<CONSTRAINED, 0, 1023> UEPositioningGPSNavModelAddDataReqGpsWeek;

typedef Integer<CONSTRAINED, 0, 255> UEPositioningGPSNavModelAddDataReqGpsToe;

typedef Integer<CONSTRAINED, 0, 15> UEPositioningGPSNavModelAddDataReqTToeLimit;

class SatData : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SatData(): Sequence(&theInfo) {}

	void setSatID(const SatID& satID) { *static_cast<SatID*>(items[0]) = satID; }
	void setIode(const IODE& iode) { *static_cast<IODE*>(items[1]) = iode; }
};

typedef SequenceOf<SatData, CONSTRAINED, 0, maxSat> SatDataList;

class UEPositioningGPSNavModelAddDataReq : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UEPositioningGPSNavModelAddDataReq(): Sequence(&theInfo) {}

	void setUEPositioningGPSNavModelAddDataReqGpsWeek(const UEPositioningGPSNavModelAddDataReqGpsWeek& uEPositioningGPSNavModelAddDataReqGpsWeek) { *static_cast<UEPositioningGPSNavModelAddDataReqGpsWeek*>(items[0]) = uEPositioningGPSNavModelAddDataReqGpsWeek; }
	void setUEPositioningGPSNavModelAddDataReqGpsToe(const UEPositioningGPSNavModelAddDataReqGpsToe& uEPositioningGPSNavModelAddDataReqGpsToe) { *static_cast<UEPositioningGPSNavModelAddDataReqGpsToe*>(items[1]) = uEPositioningGPSNavModelAddDataReqGpsToe; }
	void setUEPositioningGPSNavModelAddDataReqTToeLimit(const UEPositioningGPSNavModelAddDataReqTToeLimit& uEPositioningGPSNavModelAddDataReqTToeLimit) { *static_cast<UEPositioningGPSNavModelAddDataReqTToeLimit*>(items[2]) = uEPositioningGPSNavModelAddDataReqTToeLimit; }
	void setSatDataList(const SatDataList& satDataList) { *static_cast<SatDataList*>(items[3]) = satDataList; }
};

class UEPositioningGPSAdditionalAssistanceDataRequest : public Sequence {
private:
	static const void *itemsInfo[10];
	static bool itemsPres[10];
public:
	static const Info theInfo;
	UEPositioningGPSAdditionalAssistanceDataRequest(): Sequence(&theInfo) {}

	void setUEPositioningGPSAdditionalAssistanceDataRequestAlmanacRequest(const UEPositioningGPSAdditionalAssistanceDataRequestAlmanacRequest& uEPositioningGPSAdditionalAssistanceDataRequestAlmanacRequest) { *static_cast<UEPositioningGPSAdditionalAssistanceDataRequestAlmanacRequest*>(items[0]) = uEPositioningGPSAdditionalAssistanceDataRequestAlmanacRequest; }
	void setUEPositioningGPSAdditionalAssistanceDataRequestUtcModelRequest(const UEPositioningGPSAdditionalAssistanceDataRequestUtcModelRequest& uEPositioningGPSAdditionalAssistanceDataRequestUtcModelRequest) { *static_cast<UEPositioningGPSAdditionalAssistanceDataRequestUtcModelRequest*>(items[1]) = uEPositioningGPSAdditionalAssistanceDataRequestUtcModelRequest; }
	void setUEPositioningGPSAdditionalAssistanceDataRequestIonosphericModelRequest(const UEPositioningGPSAdditionalAssistanceDataRequestIonosphericModelRequest& uEPositioningGPSAdditionalAssistanceDataRequestIonosphericModelRequest) { *static_cast<UEPositioningGPSAdditionalAssistanceDataRequestIonosphericModelRequest*>(items[2]) = uEPositioningGPSAdditionalAssistanceDataRequestIonosphericModelRequest; }
	void setUEPositioningGPSAdditionalAssistanceDataRequestNavigationModelRequest(const UEPositioningGPSAdditionalAssistanceDataRequestNavigationModelRequest& uEPositioningGPSAdditionalAssistanceDataRequestNavigationModelRequest) { *static_cast<UEPositioningGPSAdditionalAssistanceDataRequestNavigationModelRequest*>(items[3]) = uEPositioningGPSAdditionalAssistanceDataRequestNavigationModelRequest; }
	void setUEPositioningGPSAdditionalAssistanceDataRequestDgpsCorrectionsRequest(const UEPositioningGPSAdditionalAssistanceDataRequestDgpsCorrectionsRequest& uEPositioningGPSAdditionalAssistanceDataRequestDgpsCorrectionsRequest) { *static_cast<UEPositioningGPSAdditionalAssistanceDataRequestDgpsCorrectionsRequest*>(items[4]) = uEPositioningGPSAdditionalAssistanceDataRequestDgpsCorrectionsRequest; }
	void setUEPositioningGPSAdditionalAssistanceDataRequestReferenceLocationRequest(const UEPositioningGPSAdditionalAssistanceDataRequestReferenceLocationRequest& uEPositioningGPSAdditionalAssistanceDataRequestReferenceLocationRequest) { *static_cast<UEPositioningGPSAdditionalAssistanceDataRequestReferenceLocationRequest*>(items[5]) = uEPositioningGPSAdditionalAssistanceDataRequestReferenceLocationRequest; }
	void setUEPositioningGPSAdditionalAssistanceDataRequestReferenceTimeRequest(const UEPositioningGPSAdditionalAssistanceDataRequestReferenceTimeRequest& uEPositioningGPSAdditionalAssistanceDataRequestReferenceTimeRequest) { *static_cast<UEPositioningGPSAdditionalAssistanceDataRequestReferenceTimeRequest*>(items[6]) = uEPositioningGPSAdditionalAssistanceDataRequestReferenceTimeRequest; }
	void setUEPositioningGPSAdditionalAssistanceDataRequestAquisitionAssistanceRequest(const UEPositioningGPSAdditionalAssistanceDataRequestAquisitionAssistanceRequest& uEPositioningGPSAdditionalAssistanceDataRequestAquisitionAssistanceRequest) { *static_cast<UEPositioningGPSAdditionalAssistanceDataRequestAquisitionAssistanceRequest*>(items[7]) = uEPositioningGPSAdditionalAssistanceDataRequestAquisitionAssistanceRequest; }
	void setUEPositioningGPSAdditionalAssistanceDataRequestRealTimeIntegrityRequest(const UEPositioningGPSAdditionalAssistanceDataRequestRealTimeIntegrityRequest& uEPositioningGPSAdditionalAssistanceDataRequestRealTimeIntegrityRequest) { *static_cast<UEPositioningGPSAdditionalAssistanceDataRequestRealTimeIntegrityRequest*>(items[8]) = uEPositioningGPSAdditionalAssistanceDataRequestRealTimeIntegrityRequest; }
	void setNavModelAddDataRequest(const UEPositioningGPSNavModelAddDataReq& navModelAddDataRequest) { *static_cast<UEPositioningGPSNavModelAddDataReq*>(items[9]) = navModelAddDataRequest; }
};

class UEPositioningError : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningError(): Sequence(&theInfo) {}

	void setErrorReason(const UEPositioningErrorCause& errorReason) { *static_cast<UEPositioningErrorCause*>(items[0]) = errorReason; }
	void setUepositioningGPSadditionalAssistanceDataRequest(const UEPositioningGPSAdditionalAssistanceDataRequest& uepositioningGPSadditionalAssistanceDataRequest) { *static_cast<UEPositioningGPSAdditionalAssistanceDataRequest*>(items[1]) = uepositioningGPSadditionalAssistanceDataRequest; }
};

class UEPositioningMeasuredResults : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UEPositioningMeasuredResults(): Sequence(&theInfo) {}

	void setUepositioningOTDOAMeasurement(const UEPositioningOTDOAMeasurement& uepositioningOTDOAMeasurement) { *static_cast<UEPositioningOTDOAMeasurement*>(items[0]) = uepositioningOTDOAMeasurement; }
	void setUepositioningPositionEstimateInfo(const UEPositioningPositionEstimateInfo& uepositioningPositionEstimateInfo) { *static_cast<UEPositioningPositionEstimateInfo*>(items[1]) = uepositioningPositionEstimateInfo; }
	void setUepositioningGPSMeasurement(const UEPositioningGPSMeasurementResults& uepositioningGPSMeasurement) { *static_cast<UEPositioningGPSMeasurementResults*>(items[2]) = uepositioningGPSMeasurement; }
	void setUepositioningError(const UEPositioningError& uepositioningError) { *static_cast<UEPositioningError*>(items[3]) = uepositioningError; }
};

typedef Null MeasuredResultsSpare;

class MeasuredResults : public Choice {
private:
	static const void *choicesInfo[8];
public:
	enum MeasuredResultsChoices {
		intraFreqMeasuredResultsList = 0,
		interFreqMeasuredResultsList = 1,
		interRATMeasuredResultsList = 2,
		trafficVolumeMeasuredResultsList = 3,
		qualityMeasuredResults = 4,
		ueInternalMeasuredResults = 5,
		uepositioningMeasuredResults = 6,
		measuredResultsSpare = 7,
	};
	static const Info theInfo;
	MeasuredResults(): Choice(&theInfo) {}
};

class MeasuredResultsOnSecUlFreq : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasuredResultsOnSecUlFreq(): Sequence(&theInfo) {}

	void setIntraFreqMeasuredResultsList(const IntraFrequencyMeasuredResultsListOnSecULFreq& intraFreqMeasuredResultsList) { *static_cast<IntraFrequencyMeasuredResultsListOnSecULFreq*>(items[0]) = intraFreqMeasuredResultsList; }
};

class Neighbourv390extModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	Neighbourv390extModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[0]) = frequencyInfo; }
};

typedef Null Neighbourv390extModeSpecificInfoTdd;

class Neighbourv390extModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum Neighbourv390extModeSpecificInfoChoices {
		neighbourv390extModeSpecificInfoFdd = 0,
		neighbourv390extModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	Neighbourv390extModeSpecificInfo(): Choice(&theInfo) {}
};

class Neighbourv390ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	Neighbourv390ext(): Sequence(&theInfo) {}

	void setNeighbourv390extModeSpecificInfo(const Neighbourv390extModeSpecificInfo& neighbourv390extModeSpecificInfo) { *static_cast<Neighbourv390extModeSpecificInfo*>(items[0]) = neighbourv390extModeSpecificInfo; }
};

typedef SequenceOf<Neighbourv390ext, CONSTRAINED, 1, maxCellMeas> NeighbourListv390ext;

class UEPositioningOTDOAMeasurementv390ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOAMeasurementv390ext(): Sequence(&theInfo) {}

	void setNeighbourListv390ext(const NeighbourListv390ext& neighbourListv390ext) { *static_cast<NeighbourListv390ext*>(items[0]) = neighbourListv390ext; }
};

class UEPositioningMeasuredResultsv390ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningMeasuredResultsv390ext(): Sequence(&theInfo) {}

	void setUePositioningOTDOAMeasurementv390ext(const UEPositioningOTDOAMeasurementv390ext& uePositioningOTDOAMeasurementv390ext) { *static_cast<UEPositioningOTDOAMeasurementv390ext*>(items[0]) = uePositioningOTDOAMeasurementv390ext; }
};

class MeasuredResultsv390ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasuredResultsv390ext(): Sequence(&theInfo) {}

	void setUepositioningMeasuredResultsv390ext(const UEPositioningMeasuredResultsv390ext& uepositioningMeasuredResultsv390ext) { *static_cast<UEPositioningMeasuredResultsv390ext*>(items[0]) = uepositioningMeasuredResultsv390ext; }
};

class MeasuredResultsv590ext : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MeasuredResultsv590extChoices {
		intraFrequencyMeasuredResultsList = 0,
		interFrequencyMeasuredResultsList = 1,
	};
	static const Info theInfo;
	MeasuredResultsv590ext(): Choice(&theInfo) {}
};

class UEInternalMeasuredResultsv770extModeSpecificInfoTdd384768 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEInternalMeasuredResultsv770extModeSpecificInfoTdd384768(): Sequence(&theInfo) {}

	void setAppliedTA(const EXTULTimingAdvance& appliedTA) { *static_cast<EXTULTimingAdvance*>(items[0]) = appliedTA; }
};

typedef Integer<CONSTRAINED, 0, 8191> TADVinfoextTADV;

typedef Integer<CONSTRAINED, 0, 4095> TADVinfoextSfn;

class TADVinfoext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	TADVinfoext(): Sequence(&theInfo) {}

	void setTADVinfoextTADV(const TADVinfoextTADV& tADVinfoextTADV) { *static_cast<TADVinfoextTADV*>(items[0]) = tADVinfoextTADV; }
	void setTADVinfoextSfn(const TADVinfoextSfn& tADVinfoextSfn) { *static_cast<TADVinfoextSfn*>(items[1]) = tADVinfoextSfn; }
};

class UEInternalMeasuredResultsv770extModeSpecificInfoTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEInternalMeasuredResultsv770extModeSpecificInfoTdd128(): Sequence(&theInfo) {}

	void setTADVinfo(const TADVinfoext& tADVinfo) { *static_cast<TADVinfoext*>(items[0]) = tADVinfo; }
};

class UEInternalMeasuredResultsv770extModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEInternalMeasuredResultsv770extModeSpecificInfoChoices {
		uEInternalMeasuredResultsv770extModeSpecificInfoTdd384768 = 0,
		uEInternalMeasuredResultsv770extModeSpecificInfoTdd128 = 1,
	};
	static const Info theInfo;
	UEInternalMeasuredResultsv770extModeSpecificInfo(): Choice(&theInfo) {}
};

class UEInternalMeasuredResultsv770ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEInternalMeasuredResultsv770ext(): Sequence(&theInfo) {}

	void setUEInternalMeasuredResultsv770extModeSpecificInfo(const UEInternalMeasuredResultsv770extModeSpecificInfo& uEInternalMeasuredResultsv770extModeSpecificInfo) { *static_cast<UEInternalMeasuredResultsv770extModeSpecificInfo*>(items[0]) = uEInternalMeasuredResultsv770extModeSpecificInfo; }
};

enum UEPositioningErrorCauser7Values {
	notEnoughOTDOA_Cells_UEPositioningErrorCauser7 = 0,
	notEnoughGPS_Satellites_UEPositioningErrorCauser7 = 1,
	assistanceDataMissing_UEPositioningErrorCauser7 = 2,
	notAccomplishedGPS_TimingOfCellFrames_UEPositioningErrorCauser7 = 3,
	undefinedError_UEPositioningErrorCauser7 = 4,
	requestDeniedByUser_UEPositioningErrorCauser7 = 5,
	notProcessedAndTimeout_UEPositioningErrorCauser7 = 6,
	referenceCellNotServingCell_UEPositioningErrorCauser7 = 7,
	notEnoughGANSS_Satellites_UEPositioningErrorCauser7 = 8,
	notAccomplishedGANSS_TimingOfCellFrames_UEPositioningErrorCauser7 = 9,
	spare6_UEPositioningErrorCauser7 = 10,
	spare5_UEPositioningErrorCauser7 = 11,
	spare4_UEPositioningErrorCauser7 = 12,
	spare3_UEPositioningErrorCauser7 = 13,
	spare2_UEPositioningErrorCauser7 = 14,
	spare1_UEPositioningErrorCauser7 = 15,
};
typedef Enumerated<CONSTRAINED, 15> UEPositioningErrorCauser7;

typedef Boolean UEPositioningGANSSAdditionalAssistanceDataRequestGanssReferenceTime;

typedef Boolean UEPositioningGANSSAdditionalAssistanceDataRequestGanssreferenceLocation;

typedef Boolean UEPositioningGANSSAdditionalAssistanceDataRequestGanssIonosphericModel;

class UEPositioningGANSSAdditionalAssistanceDataRequest : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UEPositioningGANSSAdditionalAssistanceDataRequest(): Sequence(&theInfo) {}

	void setUEPositioningGANSSAdditionalAssistanceDataRequestGanssReferenceTime(const UEPositioningGANSSAdditionalAssistanceDataRequestGanssReferenceTime& uEPositioningGANSSAdditionalAssistanceDataRequestGanssReferenceTime) { *static_cast<UEPositioningGANSSAdditionalAssistanceDataRequestGanssReferenceTime*>(items[0]) = uEPositioningGANSSAdditionalAssistanceDataRequestGanssReferenceTime; }
	void setUEPositioningGANSSAdditionalAssistanceDataRequestGanssreferenceLocation(const UEPositioningGANSSAdditionalAssistanceDataRequestGanssreferenceLocation& uEPositioningGANSSAdditionalAssistanceDataRequestGanssreferenceLocation) { *static_cast<UEPositioningGANSSAdditionalAssistanceDataRequestGanssreferenceLocation*>(items[1]) = uEPositioningGANSSAdditionalAssistanceDataRequestGanssreferenceLocation; }
	void setUEPositioningGANSSAdditionalAssistanceDataRequestGanssIonosphericModel(const UEPositioningGANSSAdditionalAssistanceDataRequestGanssIonosphericModel& uEPositioningGANSSAdditionalAssistanceDataRequestGanssIonosphericModel) { *static_cast<UEPositioningGANSSAdditionalAssistanceDataRequestGanssIonosphericModel*>(items[2]) = uEPositioningGANSSAdditionalAssistanceDataRequestGanssIonosphericModel; }
	void setGanssRequestedGenericAssistanceDataList(const GanssRequestedGenericAssistanceDataList& ganssRequestedGenericAssistanceDataList) { *static_cast<GanssRequestedGenericAssistanceDataList*>(items[3]) = ganssRequestedGenericAssistanceDataList; }
};

class UEPositioningErrorr7 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UEPositioningErrorr7(): Sequence(&theInfo) {}

	void setErrorReason(const UEPositioningErrorCauser7& errorReason) { *static_cast<UEPositioningErrorCauser7*>(items[0]) = errorReason; }
	void setUepositioningGPSadditionalAssistanceDataRequest(const UEPositioningGPSAdditionalAssistanceDataRequest& uepositioningGPSadditionalAssistanceDataRequest) { *static_cast<UEPositioningGPSAdditionalAssistanceDataRequest*>(items[1]) = uepositioningGPSadditionalAssistanceDataRequest; }
	void setUepositioningGANSSadditionalAssistanceDataRequest(const UEPositioningGANSSAdditionalAssistanceDataRequest& uepositioningGANSSadditionalAssistanceDataRequest) { *static_cast<UEPositioningGANSSAdditionalAssistanceDataRequest*>(items[2]) = uepositioningGANSSadditionalAssistanceDataRequest; }
};

class UEPositioningMeasuredResultsv770ext : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UEPositioningMeasuredResultsv770ext(): Sequence(&theInfo) {}

	void setUepositioningPositionEstimateInfo(const UEPositioningPositionEstimateInfov770ext& uepositioningPositionEstimateInfo) { *static_cast<UEPositioningPositionEstimateInfov770ext*>(items[0]) = uepositioningPositionEstimateInfo; }
	void setUepositioningGPSMeasurement(const UEPositioningGPSMeasurementResultsv770ext& uepositioningGPSMeasurement) { *static_cast<UEPositioningGPSMeasurementResultsv770ext*>(items[1]) = uepositioningGPSMeasurement; }
	void setUepositioningError(const UEPositioningErrorr7& uepositioningError) { *static_cast<UEPositioningErrorr7*>(items[2]) = uepositioningError; }
	void setUepositioningGanssMeasuredResults(const UEPositioningGANSSMeasuredResults& uepositioningGanssMeasuredResults) { *static_cast<UEPositioningGANSSMeasuredResults*>(items[3]) = uepositioningGanssMeasuredResults; }
};

class MeasuredResultsv770ext : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MeasuredResultsv770extChoices {
		ueInternalMeasuredResults = 0,
		uepositioningMeasuredResults = 1,
	};
	static const Info theInfo;
	MeasuredResultsv770ext(): Choice(&theInfo) {}
};

typedef BitString<CONSTRAINED, 2, 2> UEPositioningGANSSAdditionalAssistanceDataRequestv860extGanssAddIonoModelReq;

enum UEPositioningGANSSAdditionalAssistanceDataRequestv860extganssEOPreqValues {
	true_UEPositioningGANSSAdditionalAssistanceDataRequestv860extganssEOPreq = 0,
};
typedef Enumerated<CONSTRAINED, 0> UEPositioningGANSSAdditionalAssistanceDataRequestv860extganssEOPreq;

class UEPositioningGANSSAdditionalAssistanceDataRequestv860ext : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UEPositioningGANSSAdditionalAssistanceDataRequestv860ext(): Sequence(&theInfo) {}

	void setUEPositioningGANSSAdditionalAssistanceDataRequestv860extGanssAddIonoModelReq(const UEPositioningGANSSAdditionalAssistanceDataRequestv860extGanssAddIonoModelReq& uEPositioningGANSSAdditionalAssistanceDataRequestv860extGanssAddIonoModelReq) { *static_cast<UEPositioningGANSSAdditionalAssistanceDataRequestv860extGanssAddIonoModelReq*>(items[0]) = uEPositioningGANSSAdditionalAssistanceDataRequestv860extGanssAddIonoModelReq; }
	void setUEPositioningGANSSAdditionalAssistanceDataRequestv860extganssEOPreq(const UEPositioningGANSSAdditionalAssistanceDataRequestv860extganssEOPreq& uEPositioningGANSSAdditionalAssistanceDataRequestv860extganssEOPreq) { *static_cast<UEPositioningGANSSAdditionalAssistanceDataRequestv860extganssEOPreq*>(items[1]) = uEPositioningGANSSAdditionalAssistanceDataRequestv860extganssEOPreq; }
	void setGanssRequestedGenericAssistanceDataList(const GanssRequestedGenericAssistanceDataListv860ext& ganssRequestedGenericAssistanceDataList) { *static_cast<GanssRequestedGenericAssistanceDataListv860ext*>(items[2]) = ganssRequestedGenericAssistanceDataList; }
};

class UEPositioningErrorv860ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningErrorv860ext(): Sequence(&theInfo) {}

	void setUepositioningGANSSadditionalAssistanceDataRequest(const UEPositioningGANSSAdditionalAssistanceDataRequestv860ext& uepositioningGANSSadditionalAssistanceDataRequest) { *static_cast<UEPositioningGANSSAdditionalAssistanceDataRequestv860ext*>(items[0]) = uepositioningGANSSadditionalAssistanceDataRequest; }
};

class UEPositioningMeasuredResultsv860ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningMeasuredResultsv860ext(): Sequence(&theInfo) {}

	void setUepositioningError(const UEPositioningErrorv860ext& uepositioningError) { *static_cast<UEPositioningErrorv860ext*>(items[0]) = uepositioningError; }
	void setUepositioningGanssMeasurementResults(const UEPositioningGANSSMeasuredResultsv860ext& uepositioningGanssMeasurementResults) { *static_cast<UEPositioningGANSSMeasuredResultsv860ext*>(items[1]) = uepositioningGanssMeasurementResults; }
};

class MeasuredResultsv860ext : public Choice {
private:
	static const void *choicesInfo[1];
public:
	enum MeasuredResultsv860extChoices {
		uepositioningMeasuredResults = 0,
	};
	static const Info theInfo;
	MeasuredResultsv860ext(): Choice(&theInfo) {}
};

class MeasuredResultsv920ext : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MeasuredResultsv920extChoices {
		intraFreqMeasuredResultsList = 0,
		interFreqMeasuredResultsList = 1,
	};
	static const Info theInfo;
	MeasuredResultsv920ext(): Choice(&theInfo) {}
};

typedef SequenceOf<MeasuredResultsv920ext, CONSTRAINED, 1, maxAdditionalMeas> MeasuredResultsListv920ext;

typedef SequenceOf<MeasuredResultsOnSecUlFreq, CONSTRAINED, 1, maxAdditionalMeas> MeasuredResultsListOnSecUlFreq;

typedef Integer<CONSTRAINED, 0, 2047> TADVinfoTADV;

typedef Integer<CONSTRAINED, 0, 4095> TADVinfoSfn;

class TADVinfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	TADVinfo(): Sequence(&theInfo) {}

	void setTADVinfoTADV(const TADVinfoTADV& tADVinfoTADV) { *static_cast<TADVinfoTADV*>(items[0]) = tADVinfoTADV; }
	void setTADVinfoSfn(const TADVinfoSfn& tADVinfoSfn) { *static_cast<TADVinfoSfn*>(items[1]) = tADVinfoSfn; }
};

class UEInternalMeasuredResultsLCRr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEInternalMeasuredResultsLCRr4(): Sequence(&theInfo) {}

	void setUeTransmittedPowerTDDList(const UETransmittedPowerTDDList& ueTransmittedPowerTDDList) { *static_cast<UETransmittedPowerTDDList*>(items[0]) = ueTransmittedPowerTDDList; }
	void setTADVinfo(const TADVinfo& tADVinfo) { *static_cast<TADVinfo*>(items[1]) = tADVinfo; }
};

typedef Null MeasuredResultsLCRr4Spare;

class MeasuredResultsLCRr4 : public Choice {
private:
	static const void *choicesInfo[8];
public:
	enum MeasuredResultsLCRr4Choices {
		intraFreqMeasuredResultsList = 0,
		interFreqMeasuredResultsList = 1,
		interRATMeasuredResultsList = 2,
		trafficVolumeMeasuredResultsList = 3,
		qualityMeasuredResults = 4,
		ueInternalMeasuredResults = 5,
		uepositioniingMeasuredResults = 6,
		measuredResultsLCRr4Spare = 7,
	};
	static const Info theInfo;
	MeasuredResultsLCRr4(): Choice(&theInfo) {}
};

typedef SequenceOf<MeasuredResults, CONSTRAINED, 1, maxAdditionalMeas> MeasuredResultsList;

typedef SequenceOf<MeasuredResultsLCRr4, CONSTRAINED, 1, maxAdditionalMeas> MeasuredResultsListLCRr4ext;

class MeasuredResultsListv770xet : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	MeasuredResultsListv770xet(): Sequence(&theInfo) {}

};

class MeasuredResultsListv860ext : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	MeasuredResultsListv860ext(): Sequence(&theInfo) {}

};

typedef Null MeasuredResultsOnRACHCurrentCellModeSpecificInfoFddMeasurementQuantitySpare;

class MeasuredResultsOnRACHCurrentCellModeSpecificInfoFddMeasurementQuantity : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum MeasuredResultsOnRACHCurrentCellModeSpecificInfoFddMeasurementQuantityChoices {
		cpichEcN0 = 0,
		cpichRSCP = 1,
		pathloss = 2,
		measuredResultsOnRACHCurrentCellModeSpecificInfoFddMeasurementQuantitySpare = 3,
	};
	static const Info theInfo;
	MeasuredResultsOnRACHCurrentCellModeSpecificInfoFddMeasurementQuantity(): Choice(&theInfo) {}
};

class MeasuredResultsOnRACHCurrentCellModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasuredResultsOnRACHCurrentCellModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setMeasuredResultsOnRACHCurrentCellModeSpecificInfoFddMeasurementQuantity(const MeasuredResultsOnRACHCurrentCellModeSpecificInfoFddMeasurementQuantity& measuredResultsOnRACHCurrentCellModeSpecificInfoFddMeasurementQuantity) { *static_cast<MeasuredResultsOnRACHCurrentCellModeSpecificInfoFddMeasurementQuantity*>(items[0]) = measuredResultsOnRACHCurrentCellModeSpecificInfoFddMeasurementQuantity; }
};

class MeasuredResultsOnRACHCurrentCellModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasuredResultsOnRACHCurrentCellModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setTimeslotISCP(const TimeslotISCPList& timeslotISCP) { *static_cast<TimeslotISCPList*>(items[0]) = timeslotISCP; }
	void setPrimaryCCPCHRSCP(const PrimaryCCPCHRSCP& primaryCCPCHRSCP) { *static_cast<PrimaryCCPCHRSCP*>(items[1]) = primaryCCPCHRSCP; }
};

class MeasuredResultsOnRACHCurrentCellModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MeasuredResultsOnRACHCurrentCellModeSpecificInfoChoices {
		measuredResultsOnRACHCurrentCellModeSpecificInfoFdd = 0,
		measuredResultsOnRACHCurrentCellModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	MeasuredResultsOnRACHCurrentCellModeSpecificInfo(): Choice(&theInfo) {}
};

class MeasuredResultsOnRACHCurrentCell : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasuredResultsOnRACHCurrentCell(): Sequence(&theInfo) {}

	void setMeasuredResultsOnRACHCurrentCellModeSpecificInfo(const MeasuredResultsOnRACHCurrentCellModeSpecificInfo& measuredResultsOnRACHCurrentCellModeSpecificInfo) { *static_cast<MeasuredResultsOnRACHCurrentCellModeSpecificInfo*>(items[0]) = measuredResultsOnRACHCurrentCellModeSpecificInfo; }
};

typedef Null MonitoredCellRACHResultModeSpecificInfoFddMeasurementQuantitySpare;

class MonitoredCellRACHResultModeSpecificInfoFddMeasurementQuantity : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum MonitoredCellRACHResultModeSpecificInfoFddMeasurementQuantityChoices {
		cpichEcN0 = 0,
		cpichRSCP = 1,
		pathloss = 2,
		monitoredCellRACHResultModeSpecificInfoFddMeasurementQuantitySpare = 3,
	};
	static const Info theInfo;
	MonitoredCellRACHResultModeSpecificInfoFddMeasurementQuantity(): Choice(&theInfo) {}
};

class MonitoredCellRACHResultModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MonitoredCellRACHResultModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
	void setMonitoredCellRACHResultModeSpecificInfoFddMeasurementQuantity(const MonitoredCellRACHResultModeSpecificInfoFddMeasurementQuantity& monitoredCellRACHResultModeSpecificInfoFddMeasurementQuantity) { *static_cast<MonitoredCellRACHResultModeSpecificInfoFddMeasurementQuantity*>(items[1]) = monitoredCellRACHResultModeSpecificInfoFddMeasurementQuantity; }
};

class MonitoredCellRACHResultModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MonitoredCellRACHResultModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setCellParametersID(const CellParametersID& cellParametersID) { *static_cast<CellParametersID*>(items[0]) = cellParametersID; }
	void setPrimaryCCPCHRSCP(const PrimaryCCPCHRSCP& primaryCCPCHRSCP) { *static_cast<PrimaryCCPCHRSCP*>(items[1]) = primaryCCPCHRSCP; }
};

class MonitoredCellRACHResultModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MonitoredCellRACHResultModeSpecificInfoChoices {
		monitoredCellRACHResultModeSpecificInfoFdd = 0,
		monitoredCellRACHResultModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	MonitoredCellRACHResultModeSpecificInfo(): Choice(&theInfo) {}
};

class MonitoredCellRACHResult : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MonitoredCellRACHResult(): Sequence(&theInfo) {}

	void setSfnSFNObsTimeDifference(const SFNSFNObsTimeDifference& sfnSFNObsTimeDifference) { *static_cast<SFNSFNObsTimeDifference*>(items[0]) = sfnSFNObsTimeDifference; }
	void setMonitoredCellRACHResultModeSpecificInfo(const MonitoredCellRACHResultModeSpecificInfo& monitoredCellRACHResultModeSpecificInfo) { *static_cast<MonitoredCellRACHResultModeSpecificInfo*>(items[1]) = monitoredCellRACHResultModeSpecificInfo; }
};

typedef SequenceOf<MonitoredCellRACHResult, CONSTRAINED, 1, 8> MonitoredCellRACHList;

class MeasuredResultsOnRACH : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasuredResultsOnRACH(): Sequence(&theInfo) {}

	void setMeasuredResultsOnRACHCurrentCell(const MeasuredResultsOnRACHCurrentCell& measuredResultsOnRACHCurrentCell) { *static_cast<MeasuredResultsOnRACHCurrentCell*>(items[0]) = measuredResultsOnRACHCurrentCell; }
	void setMonitoredCells(const MonitoredCellRACHList& monitoredCells) { *static_cast<MonitoredCellRACHList*>(items[1]) = monitoredCells; }
};

typedef SequenceOf<DeltaRSCPPerCell, CONSTRAINED, 1, 8> MonitoredCellRACHListv7g0ext;

class MeasuredResultsOnRACHv7g0ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasuredResultsOnRACHv7g0ext(): Sequence(&theInfo) {}

	void setCurrentCellDeltaRSCP(const DeltaRSCPPerCell& currentCellDeltaRSCP) { *static_cast<DeltaRSCPPerCell*>(items[0]) = currentCellDeltaRSCP; }
	void setMonitoredCellRACHListv7g0ext(const MonitoredCellRACHListv7g0ext& monitoredCellRACHListv7g0ext) { *static_cast<MonitoredCellRACHListv7g0ext*>(items[1]) = monitoredCellRACHListv7g0ext; }
};

typedef Integer<CONSTRAINED, 0, 1> MeasuredResultsOnRACHinterFreqInterFreqCellIndicationSIB11;

typedef Integer<CONSTRAINED, 0, 1> MeasuredResultsOnRACHinterFreqInterFreqCellIndicationSIB12;

class MeasuredResultsOnRACHinterFreq : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MeasuredResultsOnRACHinterFreq(): Sequence(&theInfo) {}

	void setMeasuredResultsOnRACHinterFreqInterFreqCellIndicationSIB11(const MeasuredResultsOnRACHinterFreqInterFreqCellIndicationSIB11& measuredResultsOnRACHinterFreqInterFreqCellIndicationSIB11) { *static_cast<MeasuredResultsOnRACHinterFreqInterFreqCellIndicationSIB11*>(items[0]) = measuredResultsOnRACHinterFreqInterFreqCellIndicationSIB11; }
	void setMeasuredResultsOnRACHinterFreqInterFreqCellIndicationSIB12(const MeasuredResultsOnRACHinterFreqInterFreqCellIndicationSIB12& measuredResultsOnRACHinterFreqInterFreqCellIndicationSIB12) { *static_cast<MeasuredResultsOnRACHinterFreqInterFreqCellIndicationSIB12*>(items[1]) = measuredResultsOnRACHinterFreqInterFreqCellIndicationSIB12; }
	void setInterFreqRACHRepCellsList(const InterFreqRACHRepCellsList& interFreqRACHRepCellsList) { *static_cast<InterFreqRACHRepCellsList*>(items[2]) = interFreqRACHRepCellsList; }
};

enum UEPositioningMethodTypeValues {
	ue_Assisted_UEPositioningMethodType = 0,
	ue_Based_UEPositioningMethodType = 1,
	ue_BasedPreferred_UEPositioningMethodType = 2,
	ue_AssistedPreferred_UEPositioningMethodType = 3,
};
typedef Enumerated<CONSTRAINED, 3> UEPositioningMethodType;

enum PositioningMethodValues {
	otdoa_PositioningMethod = 0,
	gps_PositioningMethod = 1,
	otdoaOrGPS_PositioningMethod = 2,
	cellID_PositioningMethod = 3,
};
typedef Enumerated<CONSTRAINED, 3> PositioningMethod;

enum UEPositioningResponseTimeValues {
	s1_UEPositioningResponseTime = 0,
	s2_UEPositioningResponseTime = 1,
	s4_UEPositioningResponseTime = 2,
	s8_UEPositioningResponseTime = 3,
	s16_UEPositioningResponseTime = 4,
	s32_UEPositioningResponseTime = 5,
	s64_UEPositioningResponseTime = 6,
	s128_UEPositioningResponseTime = 7,
};
typedef Enumerated<CONSTRAINED, 7> UEPositioningResponseTime;

typedef BitString<CONSTRAINED, 7, 7> UEPositioningAccuracy;

typedef Boolean UEPositioningReportingQuantityGpsTimingOfCellWanted;

typedef Boolean UEPositioningReportingQuantityDummy2;

typedef Boolean UEPositioningReportingQuantityAdditionalAssistanceDataRequest;

class UEPositioningReportingQuantity : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	UEPositioningReportingQuantity(): Sequence(&theInfo) {}

	void setMethodType(const UEPositioningMethodType& methodType) { *static_cast<UEPositioningMethodType*>(items[0]) = methodType; }
	void setPositioningMethod(const PositioningMethod& positioningMethod) { *static_cast<PositioningMethod*>(items[1]) = positioningMethod; }
	void setDummy1(const UEPositioningResponseTime& dummy1) { *static_cast<UEPositioningResponseTime*>(items[2]) = dummy1; }
	void setHorizontalAccuracy(const UEPositioningAccuracy& horizontalAccuracy) { *static_cast<UEPositioningAccuracy*>(items[3]) = horizontalAccuracy; }
	void setUEPositioningReportingQuantityGpsTimingOfCellWanted(const UEPositioningReportingQuantityGpsTimingOfCellWanted& uEPositioningReportingQuantityGpsTimingOfCellWanted) { *static_cast<UEPositioningReportingQuantityGpsTimingOfCellWanted*>(items[4]) = uEPositioningReportingQuantityGpsTimingOfCellWanted; }
	void setUEPositioningReportingQuantityDummy2(const UEPositioningReportingQuantityDummy2& uEPositioningReportingQuantityDummy2) { *static_cast<UEPositioningReportingQuantityDummy2*>(items[5]) = uEPositioningReportingQuantityDummy2; }
	void setUEPositioningReportingQuantityAdditionalAssistanceDataRequest(const UEPositioningReportingQuantityAdditionalAssistanceDataRequest& uEPositioningReportingQuantityAdditionalAssistanceDataRequest) { *static_cast<UEPositioningReportingQuantityAdditionalAssistanceDataRequest*>(items[6]) = uEPositioningReportingQuantityAdditionalAssistanceDataRequest; }
	void setEnvironmentCharacterisation(const EnvironmentCharacterisation& environmentCharacterisation) { *static_cast<EnvironmentCharacterisation*>(items[7]) = environmentCharacterisation; }
};

typedef Boolean UEPositioningEventParamReportFirstFix;

enum UEPositioningMeasurementIntervalValues {
	e5_UEPositioningMeasurementInterval = 0,
	e15_UEPositioningMeasurementInterval = 1,
	e60_UEPositioningMeasurementInterval = 2,
	e300_UEPositioningMeasurementInterval = 3,
	e900_UEPositioningMeasurementInterval = 4,
	e1800_UEPositioningMeasurementInterval = 5,
	e3600_UEPositioningMeasurementInterval = 6,
	e7200_UEPositioningMeasurementInterval = 7,
};
typedef Enumerated<CONSTRAINED, 7> UEPositioningMeasurementInterval;

enum ThresholdPositionChangeValues {
	pc10_ThresholdPositionChange = 0,
	pc20_ThresholdPositionChange = 1,
	pc30_ThresholdPositionChange = 2,
	pc40_ThresholdPositionChange = 3,
	pc50_ThresholdPositionChange = 4,
	pc100_ThresholdPositionChange = 5,
	pc200_ThresholdPositionChange = 6,
	pc300_ThresholdPositionChange = 7,
	pc500_ThresholdPositionChange = 8,
	pc1000_ThresholdPositionChange = 9,
	pc2000_ThresholdPositionChange = 10,
	pc5000_ThresholdPositionChange = 11,
	pc10000_ThresholdPositionChange = 12,
	pc20000_ThresholdPositionChange = 13,
	pc50000_ThresholdPositionChange = 14,
	pc100000_ThresholdPositionChange = 15,
};
typedef Enumerated<CONSTRAINED, 15> ThresholdPositionChange;

enum ThresholdSFNSFNChangeValues {
	c0_25_ThresholdSFNSFNChange = 0,
	c0_5_ThresholdSFNSFNChange = 1,
	c1_ThresholdSFNSFNChange = 2,
	c2_ThresholdSFNSFNChange = 3,
	c3_ThresholdSFNSFNChange = 4,
	c4_ThresholdSFNSFNChange = 5,
	c5_ThresholdSFNSFNChange = 6,
	c10_ThresholdSFNSFNChange = 7,
	c20_ThresholdSFNSFNChange = 8,
	c50_ThresholdSFNSFNChange = 9,
	c100_ThresholdSFNSFNChange = 10,
	c200_ThresholdSFNSFNChange = 11,
	c500_ThresholdSFNSFNChange = 12,
	c1000_ThresholdSFNSFNChange = 13,
	c2000_ThresholdSFNSFNChange = 14,
	c5000_ThresholdSFNSFNChange = 15,
};
typedef Enumerated<CONSTRAINED, 15> ThresholdSFNSFNChange;

enum ThresholdSFNGPSTOWValues {
	ms1_ThresholdSFNGPSTOW = 0,
	ms2_ThresholdSFNGPSTOW = 1,
	ms3_ThresholdSFNGPSTOW = 2,
	ms5_ThresholdSFNGPSTOW = 3,
	ms10_ThresholdSFNGPSTOW = 4,
	ms20_ThresholdSFNGPSTOW = 5,
	ms50_ThresholdSFNGPSTOW = 6,
	ms100_ThresholdSFNGPSTOW = 7,
};
typedef Enumerated<CONSTRAINED, 7> ThresholdSFNGPSTOW;

class UEPositioningEventSpecificInfo : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum UEPositioningEventSpecificInfoChoices {
		e7a = 0,
		e7b = 1,
		e7c = 2,
	};
	static const Info theInfo;
	UEPositioningEventSpecificInfo(): Choice(&theInfo) {}
};

class UEPositioningEventParam : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UEPositioningEventParam(): Sequence(&theInfo) {}

	void setReportingAmount(const ReportingAmount& reportingAmount) { *static_cast<ReportingAmount*>(items[0]) = reportingAmount; }
	void setUEPositioningEventParamReportFirstFix(const UEPositioningEventParamReportFirstFix& uEPositioningEventParamReportFirstFix) { *static_cast<UEPositioningEventParamReportFirstFix*>(items[1]) = uEPositioningEventParamReportFirstFix; }
	void setMeasurementInterval(const UEPositioningMeasurementInterval& measurementInterval) { *static_cast<UEPositioningMeasurementInterval*>(items[2]) = measurementInterval; }
	void setEventSpecificInfo(const UEPositioningEventSpecificInfo& eventSpecificInfo) { *static_cast<UEPositioningEventSpecificInfo*>(items[3]) = eventSpecificInfo; }
};

typedef SequenceOf<UEPositioningEventParam, CONSTRAINED, 1, maxMeasEvent> UEPositioningEventParamList;

typedef Null UEPositioningReportCriteriaNoReporting;

class UEPositioningReportCriteria : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum UEPositioningReportCriteriaChoices {
		uepositioningReportingCriteria = 0,
		periodicalReportingCriteria = 1,
		uEPositioningReportCriteriaNoReporting = 2,
	};
	static const Info theInfo;
	UEPositioningReportCriteria(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 4095> UEPositioningOTDOAReferenceCellInfoSfn;

class UEPositioningOTDOAReferenceCellInfoModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfoModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
};

class UEPositioningOTDOAReferenceCellInfoModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfoModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setCellAndChannelIdentity(const CellAndChannelIdentity& cellAndChannelIdentity) { *static_cast<CellAndChannelIdentity*>(items[0]) = cellAndChannelIdentity; }
};

class UEPositioningOTDOAReferenceCellInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningOTDOAReferenceCellInfoModeSpecificInfoChoices {
		uEPositioningOTDOAReferenceCellInfoModeSpecificInfoFdd = 0,
		uEPositioningOTDOAReferenceCellInfoModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfoModeSpecificInfo(): Choice(&theInfo) {}
};

class UEPositioningOTDOAReferenceCellInfoPositioningModeUeBased : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfoPositioningModeUeBased(): Sequence(&theInfo) {}

};

class UEPositioningOTDOAReferenceCellInfoPositioningModeUeAssisted : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfoPositioningModeUeAssisted(): Sequence(&theInfo) {}

};

class UEPositioningOTDOAReferenceCellInfoPositioningMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningOTDOAReferenceCellInfoPositioningModeChoices {
		uEPositioningOTDOAReferenceCellInfoPositioningModeUeBased = 0,
		uEPositioningOTDOAReferenceCellInfoPositioningModeUeAssisted = 1,
	};
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfoPositioningMode(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 9> UEPositioningIPDLParametersIpOffset;

typedef Integer<CONSTRAINED, 0, 63> UEPositioningIPDLParametersSeed;

class UEPositioningIPDLParameters : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	UEPositioningIPDLParameters(): Sequence(&theInfo) {}

	void setIpSpacing(const IPSpacing& ipSpacing) { *static_cast<IPSpacing*>(items[0]) = ipSpacing; }
	void setIpLength(const IPLength& ipLength) { *static_cast<IPLength*>(items[1]) = ipLength; }
	void setUEPositioningIPDLParametersIpOffset(const UEPositioningIPDLParametersIpOffset& uEPositioningIPDLParametersIpOffset) { *static_cast<UEPositioningIPDLParametersIpOffset*>(items[2]) = uEPositioningIPDLParametersIpOffset; }
	void setUEPositioningIPDLParametersSeed(const UEPositioningIPDLParametersSeed& uEPositioningIPDLParametersSeed) { *static_cast<UEPositioningIPDLParametersSeed*>(items[3]) = uEPositioningIPDLParametersSeed; }
	void setBurstModeParameters(const BurstModeParameters& burstModeParameters) { *static_cast<BurstModeParameters*>(items[4]) = burstModeParameters; }
};

class UEPositioningOTDOAReferenceCellInfo : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfo(): Sequence(&theInfo) {}

	void setUEPositioningOTDOAReferenceCellInfoSfn(const UEPositioningOTDOAReferenceCellInfoSfn& uEPositioningOTDOAReferenceCellInfoSfn) { *static_cast<UEPositioningOTDOAReferenceCellInfoSfn*>(items[0]) = uEPositioningOTDOAReferenceCellInfoSfn; }
	void setUEPositioningOTDOAReferenceCellInfoModeSpecificInfo(const UEPositioningOTDOAReferenceCellInfoModeSpecificInfo& uEPositioningOTDOAReferenceCellInfoModeSpecificInfo) { *static_cast<UEPositioningOTDOAReferenceCellInfoModeSpecificInfo*>(items[1]) = uEPositioningOTDOAReferenceCellInfoModeSpecificInfo; }
	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[2]) = frequencyInfo; }
	void setUEPositioningOTDOAReferenceCellInfoPositioningMode(const UEPositioningOTDOAReferenceCellInfoPositioningMode& uEPositioningOTDOAReferenceCellInfoPositioningMode) { *static_cast<UEPositioningOTDOAReferenceCellInfoPositioningMode*>(items[3]) = uEPositioningOTDOAReferenceCellInfoPositioningMode; }
	void setUepositioningIPDLParemeters(const UEPositioningIPDLParameters& uepositioningIPDLParemeters) { *static_cast<UEPositioningIPDLParameters*>(items[4]) = uepositioningIPDLParemeters; }
};

class UEPositioningOTDOANeighbourCellInfoModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfoModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
};

class UEPositioningOTDOANeighbourCellInfoModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfoModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setCellAndChannelIdentity(const CellAndChannelIdentity& cellAndChannelIdentity) { *static_cast<CellAndChannelIdentity*>(items[0]) = cellAndChannelIdentity; }
};

class UEPositioningOTDOANeighbourCellInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningOTDOANeighbourCellInfoModeSpecificInfoChoices {
		uEPositioningOTDOANeighbourCellInfoModeSpecificInfoFdd = 0,
		uEPositioningOTDOANeighbourCellInfoModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfoModeSpecificInfo(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0 ,  4095> SFNSFNRelTimeDifference1SfnOffset;

typedef Integer<CONSTRAINED, 0,  38399> SFNSFNRelTimeDifference1SfnsfnReltimedifference;

class SFNSFNRelTimeDifference1 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SFNSFNRelTimeDifference1(): Sequence(&theInfo) {}

	void setSFNSFNRelTimeDifference1SfnOffset(const SFNSFNRelTimeDifference1SfnOffset& sFNSFNRelTimeDifference1SfnOffset) { *static_cast<SFNSFNRelTimeDifference1SfnOffset*>(items[0]) = sFNSFNRelTimeDifference1SfnOffset; }
	void setSFNSFNRelTimeDifference1SfnsfnReltimedifference(const SFNSFNRelTimeDifference1SfnsfnReltimedifference& sFNSFNRelTimeDifference1SfnsfnReltimedifference) { *static_cast<SFNSFNRelTimeDifference1SfnsfnReltimedifference*>(items[1]) = sFNSFNRelTimeDifference1SfnsfnReltimedifference; }
};

enum SFNSFNDriftValues {
	sfnsfndrift0_SFNSFNDrift = 0,
	sfnsfndrift1_SFNSFNDrift = 1,
	sfnsfndrift2_SFNSFNDrift = 2,
	sfnsfndrift3_SFNSFNDrift = 3,
	sfnsfndrift4_SFNSFNDrift = 4,
	sfnsfndrift5_SFNSFNDrift = 5,
	sfnsfndrift8_SFNSFNDrift = 6,
	sfnsfndrift10_SFNSFNDrift = 7,
	sfnsfndrift15_SFNSFNDrift = 8,
	sfnsfndrift25_SFNSFNDrift = 9,
	sfnsfndrift35_SFNSFNDrift = 10,
	sfnsfndrift50_SFNSFNDrift = 11,
	sfnsfndrift65_SFNSFNDrift = 12,
	sfnsfndrift80_SFNSFNDrift = 13,
	sfnsfndrift100_SFNSFNDrift = 14,
	sfnsfndrift_1_SFNSFNDrift = 15,
	sfnsfndrift_2_SFNSFNDrift = 16,
	sfnsfndrift_3_SFNSFNDrift = 17,
	sfnsfndrift_4_SFNSFNDrift = 18,
	sfnsfndrift_5_SFNSFNDrift = 19,
	sfnsfndrift_8_SFNSFNDrift = 20,
	sfnsfndrift_10_SFNSFNDrift = 21,
	sfnsfndrift_15_SFNSFNDrift = 22,
	sfnsfndrift_25_SFNSFNDrift = 23,
	sfnsfndrift_35_SFNSFNDrift = 24,
	sfnsfndrift_50_SFNSFNDrift = 25,
	sfnsfndrift_65_SFNSFNDrift = 26,
	sfnsfndrift_80_SFNSFNDrift = 27,
	sfnsfndrift_100_SFNSFNDrift = 28,
};
typedef Enumerated<CONSTRAINED, 28> SFNSFNDrift;

enum OTDOASearchWindowSizeValues {
	c20_OTDOASearchWindowSize = 0,
	c40_OTDOASearchWindowSize = 1,
	c80_OTDOASearchWindowSize = 2,
	c160_OTDOASearchWindowSize = 3,
	c320_OTDOASearchWindowSize = 4,
	c640_OTDOASearchWindowSize = 5,
	c1280_OTDOASearchWindowSize = 6,
	moreThan1280_OTDOASearchWindowSize = 7,
};
typedef Enumerated<CONSTRAINED, 7> OTDOASearchWindowSize;

class UEPositioningOTDOANeighbourCellInfoPositioningModeUeBased : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfoPositioningModeUeBased(): Sequence(&theInfo) {}

};

class UEPositioningOTDOANeighbourCellInfoPositioningModeUeAssisted : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfoPositioningModeUeAssisted(): Sequence(&theInfo) {}

};

class UEPositioningOTDOANeighbourCellInfoPositioningMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningOTDOANeighbourCellInfoPositioningModeChoices {
		uEPositioningOTDOANeighbourCellInfoPositioningModeUeBased = 0,
		uEPositioningOTDOANeighbourCellInfoPositioningModeUeAssisted = 1,
	};
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfoPositioningMode(): Choice(&theInfo) {}
};

class UEPositioningOTDOANeighbourCellInfo : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfo(): Sequence(&theInfo) {}

	void setUEPositioningOTDOANeighbourCellInfoModeSpecificInfo(const UEPositioningOTDOANeighbourCellInfoModeSpecificInfo& uEPositioningOTDOANeighbourCellInfoModeSpecificInfo) { *static_cast<UEPositioningOTDOANeighbourCellInfoModeSpecificInfo*>(items[0]) = uEPositioningOTDOANeighbourCellInfoModeSpecificInfo; }
	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[1]) = frequencyInfo; }
	void setUepositioningIPDLParemeters(const UEPositioningIPDLParameters& uepositioningIPDLParemeters) { *static_cast<UEPositioningIPDLParameters*>(items[2]) = uepositioningIPDLParemeters; }
	void setSfnSFNRelTimeDifference(const SFNSFNRelTimeDifference1& sfnSFNRelTimeDifference) { *static_cast<SFNSFNRelTimeDifference1*>(items[3]) = sfnSFNRelTimeDifference; }
	void setSfnSFNDrift(const SFNSFNDrift& sfnSFNDrift) { *static_cast<SFNSFNDrift*>(items[4]) = sfnSFNDrift; }
	void setSearchWindowSize(const OTDOASearchWindowSize& searchWindowSize) { *static_cast<OTDOASearchWindowSize*>(items[5]) = searchWindowSize; }
	void setUEPositioningOTDOANeighbourCellInfoPositioningMode(const UEPositioningOTDOANeighbourCellInfoPositioningMode& uEPositioningOTDOANeighbourCellInfoPositioningMode) { *static_cast<UEPositioningOTDOANeighbourCellInfoPositioningMode*>(items[6]) = uEPositioningOTDOANeighbourCellInfoPositioningMode; }
};

typedef SequenceOf<UEPositioningOTDOANeighbourCellInfo, CONSTRAINED, 1, maxCellMeas> UEPositioningOTDOANeighbourCellList;

class UEPositioningOTDOAAssistanceData : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningOTDOAAssistanceData(): Sequence(&theInfo) {}

	void setUepositioningOTDOAReferenceCellInfo(const UEPositioningOTDOAReferenceCellInfo& uepositioningOTDOAReferenceCellInfo) { *static_cast<UEPositioningOTDOAReferenceCellInfo*>(items[0]) = uepositioningOTDOAReferenceCellInfo; }
	void setUepositioningOTDOANeighbourCellList(const UEPositioningOTDOANeighbourCellList& uepositioningOTDOANeighbourCellList) { *static_cast<UEPositioningOTDOANeighbourCellList*>(items[1]) = uepositioningOTDOANeighbourCellList; }
};

typedef Integer<CONSTRAINED, 0, 1023> UEPositioningGPSReferenceTimeGpsWeek;

typedef Integer<CONSTRAINED, 0, 1023> UTRANGPSReferenceTimeUtranGPSTimingOfCellMspart;

typedef Integer<CONSTRAINED, 0, 4294967295> UTRANGPSReferenceTimeUtranGPSTimingOfCellLspart;

class UTRANGPSReferenceTimeUtranGPSTimingOfCell : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UTRANGPSReferenceTimeUtranGPSTimingOfCell(): Sequence(&theInfo) {}

	void setUTRANGPSReferenceTimeUtranGPSTimingOfCellMspart(const UTRANGPSReferenceTimeUtranGPSTimingOfCellMspart& uTRANGPSReferenceTimeUtranGPSTimingOfCellMspart) { *static_cast<UTRANGPSReferenceTimeUtranGPSTimingOfCellMspart*>(items[0]) = uTRANGPSReferenceTimeUtranGPSTimingOfCellMspart; }
	void setUTRANGPSReferenceTimeUtranGPSTimingOfCellLspart(const UTRANGPSReferenceTimeUtranGPSTimingOfCellLspart& uTRANGPSReferenceTimeUtranGPSTimingOfCellLspart) { *static_cast<UTRANGPSReferenceTimeUtranGPSTimingOfCellLspart*>(items[1]) = uTRANGPSReferenceTimeUtranGPSTimingOfCellLspart; }
};

class UTRANGPSReferenceTimeModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UTRANGPSReferenceTimeModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setReferenceIdentity(const PrimaryCPICHInfo& referenceIdentity) { *static_cast<PrimaryCPICHInfo*>(items[0]) = referenceIdentity; }
};

class UTRANGPSReferenceTimeModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UTRANGPSReferenceTimeModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setReferenceIdentity(const CellParametersID& referenceIdentity) { *static_cast<CellParametersID*>(items[0]) = referenceIdentity; }
};

class UTRANGPSReferenceTimeModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UTRANGPSReferenceTimeModeSpecificInfoChoices {
		uTRANGPSReferenceTimeModeSpecificInfoFdd = 0,
		uTRANGPSReferenceTimeModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	UTRANGPSReferenceTimeModeSpecificInfo(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 4095> UTRANGPSReferenceTimeSfn;

class UTRANGPSReferenceTime : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UTRANGPSReferenceTime(): Sequence(&theInfo) {}

	void setUTRANGPSReferenceTimeUtranGPSTimingOfCell(const UTRANGPSReferenceTimeUtranGPSTimingOfCell& uTRANGPSReferenceTimeUtranGPSTimingOfCell) { *static_cast<UTRANGPSReferenceTimeUtranGPSTimingOfCell*>(items[0]) = uTRANGPSReferenceTimeUtranGPSTimingOfCell; }
	void setUTRANGPSReferenceTimeModeSpecificInfo(const UTRANGPSReferenceTimeModeSpecificInfo& uTRANGPSReferenceTimeModeSpecificInfo) { *static_cast<UTRANGPSReferenceTimeModeSpecificInfo*>(items[1]) = uTRANGPSReferenceTimeModeSpecificInfo; }
	void setUTRANGPSReferenceTimeSfn(const UTRANGPSReferenceTimeSfn& uTRANGPSReferenceTimeSfn) { *static_cast<UTRANGPSReferenceTimeSfn*>(items[2]) = uTRANGPSReferenceTimeSfn; }
};

enum SFNTOWUncertaintyValues {
	lessThan10_SFNTOWUncertainty = 0,
	moreThan10_SFNTOWUncertainty = 1,
};
typedef Enumerated<CONSTRAINED, 1> SFNTOWUncertainty;

enum UTRANGPSDriftRateValues {
	utran_GPSDrift0_UTRANGPSDriftRate = 0,
	utran_GPSDrift1_UTRANGPSDriftRate = 1,
	utran_GPSDrift2_UTRANGPSDriftRate = 2,
	utran_GPSDrift5_UTRANGPSDriftRate = 3,
	utran_GPSDrift10_UTRANGPSDriftRate = 4,
	utran_GPSDrift15_UTRANGPSDriftRate = 5,
	utran_GPSDrift25_UTRANGPSDriftRate = 6,
	utran_GPSDrift50_UTRANGPSDriftRate = 7,
	utran_GPSDrift_1_UTRANGPSDriftRate = 8,
	utran_GPSDrift_2_UTRANGPSDriftRate = 9,
	utran_GPSDrift_5_UTRANGPSDriftRate = 10,
	utran_GPSDrift_10_UTRANGPSDriftRate = 11,
	utran_GPSDrift_15_UTRANGPSDriftRate = 12,
	utran_GPSDrift_25_UTRANGPSDriftRate = 13,
	utran_GPSDrift_50_UTRANGPSDriftRate = 14,
};
typedef Enumerated<CONSTRAINED, 14> UTRANGPSDriftRate;

class UEPositioningGPSReferenceTime : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	UEPositioningGPSReferenceTime(): Sequence(&theInfo) {}

	void setUEPositioningGPSReferenceTimeGpsWeek(const UEPositioningGPSReferenceTimeGpsWeek& uEPositioningGPSReferenceTimeGpsWeek) { *static_cast<UEPositioningGPSReferenceTimeGpsWeek*>(items[0]) = uEPositioningGPSReferenceTimeGpsWeek; }
	void setGpstow1msec(const GPSTOW1msec& gpstow1msec) { *static_cast<GPSTOW1msec*>(items[1]) = gpstow1msec; }
	void setUtranGPSReferenceTime(const UTRANGPSReferenceTime& utranGPSReferenceTime) { *static_cast<UTRANGPSReferenceTime*>(items[2]) = utranGPSReferenceTime; }
	void setSfntowUncertainty(const SFNTOWUncertainty& sfntowUncertainty) { *static_cast<SFNTOWUncertainty*>(items[3]) = sfntowUncertainty; }
	void setUtranGPSDriftRate(const UTRANGPSDriftRate& utranGPSDriftRate) { *static_cast<UTRANGPSDriftRate*>(items[4]) = utranGPSDriftRate; }
	void setGpsTOWAssistList(const GPSTOWAssistList& gpsTOWAssistList) { *static_cast<GPSTOWAssistList*>(items[5]) = gpsTOWAssistList; }
};

class ReferenceLocation : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ReferenceLocation(): Sequence(&theInfo) {}

	void setEllipsoidPointAltitudeEllipsoide(const EllipsoidPointAltitudeEllipsoide& ellipsoidPointAltitudeEllipsoide) { *static_cast<EllipsoidPointAltitudeEllipsoide*>(items[0]) = ellipsoidPointAltitudeEllipsoide; }
};

class UEPositioningGPSDGPSCorrections : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UEPositioningGPSDGPSCorrections(): Sequence(&theInfo) {}

	void setGpsTOW(const GPSTOW1sec& gpsTOW) { *static_cast<GPSTOW1sec*>(items[0]) = gpsTOW; }
	void setStatusHealth(const DiffCorrectionStatus& statusHealth) { *static_cast<DiffCorrectionStatus*>(items[1]) = statusHealth; }
	void setDgpsCorrectionSatInfoList(const DGPSCorrectionSatInfoList& dgpsCorrectionSatInfoList) { *static_cast<DGPSCorrectionSatInfoList*>(items[2]) = dgpsCorrectionSatInfoList; }
};

enum SatelliteStatusValues {
	ns_NN_U_SatelliteStatus = 0,
	es_SN_SatelliteStatus = 1,
	es_NN_U_SatelliteStatus = 2,
	rev2_SatelliteStatus = 3,
	rev_SatelliteStatus = 4,
};
typedef Enumerated<CONSTRAINED, 4> SatelliteStatus;

typedef BitString<CONSTRAINED, 2, 2> EphemerisParameterCodeOnL2;

typedef BitString<CONSTRAINED, 4, 4> EphemerisParameterUraIndex;

typedef BitString<CONSTRAINED, 6, 6> EphemerisParameterSatHealth;

typedef BitString<CONSTRAINED, 10, 10> EphemerisParameterIodc;

typedef BitString<CONSTRAINED, 1, 1> EphemerisParameterL2Pflag;

typedef BitString<CONSTRAINED, 23, 23> SubFrame1ReservedReserved1;

typedef BitString<CONSTRAINED, 24, 24> SubFrame1ReservedReserved2;

typedef BitString<CONSTRAINED, 24, 24> SubFrame1ReservedReserved3;

typedef BitString<CONSTRAINED, 16, 16> SubFrame1ReservedReserved4;

class SubFrame1Reserved : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SubFrame1Reserved(): Sequence(&theInfo) {}

	void setSubFrame1ReservedReserved1(const SubFrame1ReservedReserved1& subFrame1ReservedReserved1) { *static_cast<SubFrame1ReservedReserved1*>(items[0]) = subFrame1ReservedReserved1; }
	void setSubFrame1ReservedReserved2(const SubFrame1ReservedReserved2& subFrame1ReservedReserved2) { *static_cast<SubFrame1ReservedReserved2*>(items[1]) = subFrame1ReservedReserved2; }
	void setSubFrame1ReservedReserved3(const SubFrame1ReservedReserved3& subFrame1ReservedReserved3) { *static_cast<SubFrame1ReservedReserved3*>(items[2]) = subFrame1ReservedReserved3; }
	void setSubFrame1ReservedReserved4(const SubFrame1ReservedReserved4& subFrame1ReservedReserved4) { *static_cast<SubFrame1ReservedReserved4*>(items[3]) = subFrame1ReservedReserved4; }
};

typedef BitString<CONSTRAINED, 8, 8> EphemerisParameterTGD;

typedef BitString<CONSTRAINED, 16, 16> EphemerisParameterToc;

typedef BitString<CONSTRAINED, 8, 8> EphemerisParameterAf2;

typedef BitString<CONSTRAINED, 16, 16> EphemerisParameterAf1;

typedef BitString<CONSTRAINED, 22, 22> EphemerisParameterAf0;

typedef BitString<CONSTRAINED, 16, 16> EphemerisParameterCrs;

typedef BitString<CONSTRAINED, 16, 16> EphemerisParameterDeltan;

typedef BitString<CONSTRAINED, 32, 32> EphemerisParameterM0;

typedef BitString<CONSTRAINED, 16, 16> EphemerisParameterCuc;

typedef BitString<CONSTRAINED, 32, 32> EphemerisParameterE;

typedef BitString<CONSTRAINED, 16, 16> EphemerisParameterCus;

typedef BitString<CONSTRAINED, 32, 32> EphemerisParameterASqrt;

typedef BitString<CONSTRAINED, 16, 16> EphemerisParameterToe;

typedef BitString<CONSTRAINED, 1, 1> EphemerisParameterFitInterval;

typedef BitString<CONSTRAINED, 5, 5> EphemerisParameterAodo;

typedef BitString<CONSTRAINED, 16, 16> EphemerisParameterCic;

typedef BitString<CONSTRAINED, 32, 32> EphemerisParameterOmega0;

typedef BitString<CONSTRAINED, 16, 16> EphemerisParameterCis;

typedef BitString<CONSTRAINED, 32, 32> EphemerisParameterI0;

typedef BitString<CONSTRAINED, 16, 16> EphemerisParameterCrc;

typedef BitString<CONSTRAINED, 32, 32> EphemerisParameterOmega;

typedef BitString<CONSTRAINED, 24, 24> EphemerisParameterOmegaDot;

typedef BitString<CONSTRAINED, 14, 14> EphemerisParameterIDot;

class EphemerisParameter : public Sequence {
private:
	static const void *itemsInfo[29];
	static bool itemsPres[29];
public:
	static const Info theInfo;
	EphemerisParameter(): Sequence(&theInfo) {}

	void setEphemerisParameterCodeOnL2(const EphemerisParameterCodeOnL2& ephemerisParameterCodeOnL2) { *static_cast<EphemerisParameterCodeOnL2*>(items[0]) = ephemerisParameterCodeOnL2; }
	void setEphemerisParameterUraIndex(const EphemerisParameterUraIndex& ephemerisParameterUraIndex) { *static_cast<EphemerisParameterUraIndex*>(items[1]) = ephemerisParameterUraIndex; }
	void setEphemerisParameterSatHealth(const EphemerisParameterSatHealth& ephemerisParameterSatHealth) { *static_cast<EphemerisParameterSatHealth*>(items[2]) = ephemerisParameterSatHealth; }
	void setEphemerisParameterIodc(const EphemerisParameterIodc& ephemerisParameterIodc) { *static_cast<EphemerisParameterIodc*>(items[3]) = ephemerisParameterIodc; }
	void setEphemerisParameterL2Pflag(const EphemerisParameterL2Pflag& ephemerisParameterL2Pflag) { *static_cast<EphemerisParameterL2Pflag*>(items[4]) = ephemerisParameterL2Pflag; }
	void setSf1Revd(const SubFrame1Reserved& sf1Revd) { *static_cast<SubFrame1Reserved*>(items[5]) = sf1Revd; }
	void setEphemerisParameterTGD(const EphemerisParameterTGD& ephemerisParameterTGD) { *static_cast<EphemerisParameterTGD*>(items[6]) = ephemerisParameterTGD; }
	void setEphemerisParameterToc(const EphemerisParameterToc& ephemerisParameterToc) { *static_cast<EphemerisParameterToc*>(items[7]) = ephemerisParameterToc; }
	void setEphemerisParameterAf2(const EphemerisParameterAf2& ephemerisParameterAf2) { *static_cast<EphemerisParameterAf2*>(items[8]) = ephemerisParameterAf2; }
	void setEphemerisParameterAf1(const EphemerisParameterAf1& ephemerisParameterAf1) { *static_cast<EphemerisParameterAf1*>(items[9]) = ephemerisParameterAf1; }
	void setEphemerisParameterAf0(const EphemerisParameterAf0& ephemerisParameterAf0) { *static_cast<EphemerisParameterAf0*>(items[10]) = ephemerisParameterAf0; }
	void setEphemerisParameterCrs(const EphemerisParameterCrs& ephemerisParameterCrs) { *static_cast<EphemerisParameterCrs*>(items[11]) = ephemerisParameterCrs; }
	void setEphemerisParameterDeltan(const EphemerisParameterDeltan& ephemerisParameterDeltan) { *static_cast<EphemerisParameterDeltan*>(items[12]) = ephemerisParameterDeltan; }
	void setEphemerisParameterM0(const EphemerisParameterM0& ephemerisParameterM0) { *static_cast<EphemerisParameterM0*>(items[13]) = ephemerisParameterM0; }
	void setEphemerisParameterCuc(const EphemerisParameterCuc& ephemerisParameterCuc) { *static_cast<EphemerisParameterCuc*>(items[14]) = ephemerisParameterCuc; }
	void setEphemerisParameterE(const EphemerisParameterE& ephemerisParameterE) { *static_cast<EphemerisParameterE*>(items[15]) = ephemerisParameterE; }
	void setEphemerisParameterCus(const EphemerisParameterCus& ephemerisParameterCus) { *static_cast<EphemerisParameterCus*>(items[16]) = ephemerisParameterCus; }
	void setEphemerisParameterASqrt(const EphemerisParameterASqrt& ephemerisParameterASqrt) { *static_cast<EphemerisParameterASqrt*>(items[17]) = ephemerisParameterASqrt; }
	void setEphemerisParameterToe(const EphemerisParameterToe& ephemerisParameterToe) { *static_cast<EphemerisParameterToe*>(items[18]) = ephemerisParameterToe; }
	void setEphemerisParameterFitInterval(const EphemerisParameterFitInterval& ephemerisParameterFitInterval) { *static_cast<EphemerisParameterFitInterval*>(items[19]) = ephemerisParameterFitInterval; }
	void setEphemerisParameterAodo(const EphemerisParameterAodo& ephemerisParameterAodo) { *static_cast<EphemerisParameterAodo*>(items[20]) = ephemerisParameterAodo; }
	void setEphemerisParameterCic(const EphemerisParameterCic& ephemerisParameterCic) { *static_cast<EphemerisParameterCic*>(items[21]) = ephemerisParameterCic; }
	void setEphemerisParameterOmega0(const EphemerisParameterOmega0& ephemerisParameterOmega0) { *static_cast<EphemerisParameterOmega0*>(items[22]) = ephemerisParameterOmega0; }
	void setEphemerisParameterCis(const EphemerisParameterCis& ephemerisParameterCis) { *static_cast<EphemerisParameterCis*>(items[23]) = ephemerisParameterCis; }
	void setEphemerisParameterI0(const EphemerisParameterI0& ephemerisParameterI0) { *static_cast<EphemerisParameterI0*>(items[24]) = ephemerisParameterI0; }
	void setEphemerisParameterCrc(const EphemerisParameterCrc& ephemerisParameterCrc) { *static_cast<EphemerisParameterCrc*>(items[25]) = ephemerisParameterCrc; }
	void setEphemerisParameterOmega(const EphemerisParameterOmega& ephemerisParameterOmega) { *static_cast<EphemerisParameterOmega*>(items[26]) = ephemerisParameterOmega; }
	void setEphemerisParameterOmegaDot(const EphemerisParameterOmegaDot& ephemerisParameterOmegaDot) { *static_cast<EphemerisParameterOmegaDot*>(items[27]) = ephemerisParameterOmegaDot; }
	void setEphemerisParameterIDot(const EphemerisParameterIDot& ephemerisParameterIDot) { *static_cast<EphemerisParameterIDot*>(items[28]) = ephemerisParameterIDot; }
};

class NavigationModelSatInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	NavigationModelSatInfo(): Sequence(&theInfo) {}

	void setSatID(const SatID& satID) { *static_cast<SatID*>(items[0]) = satID; }
	void setSatelliteStatus(const SatelliteStatus& satelliteStatus) { *static_cast<SatelliteStatus*>(items[1]) = satelliteStatus; }
	void setEphemerisParameter(const EphemerisParameter& ephemerisParameter) { *static_cast<EphemerisParameter*>(items[2]) = ephemerisParameter; }
};

typedef SequenceOf<NavigationModelSatInfo, CONSTRAINED, 1, maxSat> NavigationModelSatInfoList;

class UEPositioningGPSNavigationModel : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningGPSNavigationModel(): Sequence(&theInfo) {}

	void setNavigationModelSatInfoList(const NavigationModelSatInfoList& navigationModelSatInfoList) { *static_cast<NavigationModelSatInfoList*>(items[0]) = navigationModelSatInfoList; }
};

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGPSIonosphericModelAlpha0;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGPSIonosphericModelAlpha1;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGPSIonosphericModelAlpha2;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGPSIonosphericModelAlpha3;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGPSIonosphericModelBeta0;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGPSIonosphericModelBeta1;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGPSIonosphericModelBeta2;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGPSIonosphericModelBeta3;

class UEPositioningGPSIonosphericModel : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	UEPositioningGPSIonosphericModel(): Sequence(&theInfo) {}

	void setUEPositioningGPSIonosphericModelAlpha0(const UEPositioningGPSIonosphericModelAlpha0& uEPositioningGPSIonosphericModelAlpha0) { *static_cast<UEPositioningGPSIonosphericModelAlpha0*>(items[0]) = uEPositioningGPSIonosphericModelAlpha0; }
	void setUEPositioningGPSIonosphericModelAlpha1(const UEPositioningGPSIonosphericModelAlpha1& uEPositioningGPSIonosphericModelAlpha1) { *static_cast<UEPositioningGPSIonosphericModelAlpha1*>(items[1]) = uEPositioningGPSIonosphericModelAlpha1; }
	void setUEPositioningGPSIonosphericModelAlpha2(const UEPositioningGPSIonosphericModelAlpha2& uEPositioningGPSIonosphericModelAlpha2) { *static_cast<UEPositioningGPSIonosphericModelAlpha2*>(items[2]) = uEPositioningGPSIonosphericModelAlpha2; }
	void setUEPositioningGPSIonosphericModelAlpha3(const UEPositioningGPSIonosphericModelAlpha3& uEPositioningGPSIonosphericModelAlpha3) { *static_cast<UEPositioningGPSIonosphericModelAlpha3*>(items[3]) = uEPositioningGPSIonosphericModelAlpha3; }
	void setUEPositioningGPSIonosphericModelBeta0(const UEPositioningGPSIonosphericModelBeta0& uEPositioningGPSIonosphericModelBeta0) { *static_cast<UEPositioningGPSIonosphericModelBeta0*>(items[4]) = uEPositioningGPSIonosphericModelBeta0; }
	void setUEPositioningGPSIonosphericModelBeta1(const UEPositioningGPSIonosphericModelBeta1& uEPositioningGPSIonosphericModelBeta1) { *static_cast<UEPositioningGPSIonosphericModelBeta1*>(items[5]) = uEPositioningGPSIonosphericModelBeta1; }
	void setUEPositioningGPSIonosphericModelBeta2(const UEPositioningGPSIonosphericModelBeta2& uEPositioningGPSIonosphericModelBeta2) { *static_cast<UEPositioningGPSIonosphericModelBeta2*>(items[6]) = uEPositioningGPSIonosphericModelBeta2; }
	void setUEPositioningGPSIonosphericModelBeta3(const UEPositioningGPSIonosphericModelBeta3& uEPositioningGPSIonosphericModelBeta3) { *static_cast<UEPositioningGPSIonosphericModelBeta3*>(items[7]) = uEPositioningGPSIonosphericModelBeta3; }
};

typedef BitString<CONSTRAINED, 24, 24> UEPositioningGPSUTCModelA1;

typedef BitString<CONSTRAINED, 32, 32> UEPositioningGPSUTCModelA0;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGPSUTCModelTot;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGPSUTCModelWnt;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGPSUTCModelDeltatLS;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGPSUTCModelWnlsf;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGPSUTCModelDn;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGPSUTCModelDeltatLSF;

class UEPositioningGPSUTCModel : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	UEPositioningGPSUTCModel(): Sequence(&theInfo) {}

	void setUEPositioningGPSUTCModelA1(const UEPositioningGPSUTCModelA1& uEPositioningGPSUTCModelA1) { *static_cast<UEPositioningGPSUTCModelA1*>(items[0]) = uEPositioningGPSUTCModelA1; }
	void setUEPositioningGPSUTCModelA0(const UEPositioningGPSUTCModelA0& uEPositioningGPSUTCModelA0) { *static_cast<UEPositioningGPSUTCModelA0*>(items[1]) = uEPositioningGPSUTCModelA0; }
	void setUEPositioningGPSUTCModelTot(const UEPositioningGPSUTCModelTot& uEPositioningGPSUTCModelTot) { *static_cast<UEPositioningGPSUTCModelTot*>(items[2]) = uEPositioningGPSUTCModelTot; }
	void setUEPositioningGPSUTCModelWnt(const UEPositioningGPSUTCModelWnt& uEPositioningGPSUTCModelWnt) { *static_cast<UEPositioningGPSUTCModelWnt*>(items[3]) = uEPositioningGPSUTCModelWnt; }
	void setUEPositioningGPSUTCModelDeltatLS(const UEPositioningGPSUTCModelDeltatLS& uEPositioningGPSUTCModelDeltatLS) { *static_cast<UEPositioningGPSUTCModelDeltatLS*>(items[4]) = uEPositioningGPSUTCModelDeltatLS; }
	void setUEPositioningGPSUTCModelWnlsf(const UEPositioningGPSUTCModelWnlsf& uEPositioningGPSUTCModelWnlsf) { *static_cast<UEPositioningGPSUTCModelWnlsf*>(items[5]) = uEPositioningGPSUTCModelWnlsf; }
	void setUEPositioningGPSUTCModelDn(const UEPositioningGPSUTCModelDn& uEPositioningGPSUTCModelDn) { *static_cast<UEPositioningGPSUTCModelDn*>(items[6]) = uEPositioningGPSUTCModelDn; }
	void setUEPositioningGPSUTCModelDeltatLSF(const UEPositioningGPSUTCModelDeltatLSF& uEPositioningGPSUTCModelDeltatLSF) { *static_cast<UEPositioningGPSUTCModelDeltatLSF*>(items[7]) = uEPositioningGPSUTCModelDeltatLSF; }
};

typedef BitString<CONSTRAINED, 8, 8> UEPositioningGPSAlmanacWna;

typedef BitString<CONSTRAINED, 364, 364> UEPositioningGPSAlmanacSvGlobalHealth;

class UEPositioningGPSAlmanac : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UEPositioningGPSAlmanac(): Sequence(&theInfo) {}

	void setUEPositioningGPSAlmanacWna(const UEPositioningGPSAlmanacWna& uEPositioningGPSAlmanacWna) { *static_cast<UEPositioningGPSAlmanacWna*>(items[0]) = uEPositioningGPSAlmanacWna; }
	void setAlmanacSatInfoList(const AlmanacSatInfoList& almanacSatInfoList) { *static_cast<AlmanacSatInfoList*>(items[1]) = almanacSatInfoList; }
	void setUEPositioningGPSAlmanacSvGlobalHealth(const UEPositioningGPSAlmanacSvGlobalHealth& uEPositioningGPSAlmanacSvGlobalHealth) { *static_cast<UEPositioningGPSAlmanacSvGlobalHealth*>(items[2]) = uEPositioningGPSAlmanacSvGlobalHealth; }
};

class UEPositioningGPSAcquisitionAssistance : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UEPositioningGPSAcquisitionAssistance(): Sequence(&theInfo) {}

	void setGpsReferenceTime(const GPSTOW1msec& gpsReferenceTime) { *static_cast<GPSTOW1msec*>(items[0]) = gpsReferenceTime; }
	void setUtranGPSReferenceTime(const UTRANGPSReferenceTime& utranGPSReferenceTime) { *static_cast<UTRANGPSReferenceTime*>(items[1]) = utranGPSReferenceTime; }
	void setSatelliteInformationList(const AcquisitionSatInfoList& satelliteInformationList) { *static_cast<AcquisitionSatInfoList*>(items[2]) = satelliteInformationList; }
};

class UEPositioningGPSReferenceCellInfoModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningGPSReferenceCellInfoModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setReferenceIdentity(const PrimaryCPICHInfo& referenceIdentity) { *static_cast<PrimaryCPICHInfo*>(items[0]) = referenceIdentity; }
};

class UEPositioningGPSReferenceCellInfoModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningGPSReferenceCellInfoModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setReferenceIdentity(const CellParametersID& referenceIdentity) { *static_cast<CellParametersID*>(items[0]) = referenceIdentity; }
};

class UEPositioningGPSReferenceCellInfoModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningGPSReferenceCellInfoModeSpecificInfoChoices {
		uEPositioningGPSReferenceCellInfoModeSpecificInfoFdd = 0,
		uEPositioningGPSReferenceCellInfoModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	UEPositioningGPSReferenceCellInfoModeSpecificInfo(): Choice(&theInfo) {}
};

class UEPositioningGPSReferenceCellInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningGPSReferenceCellInfo(): Sequence(&theInfo) {}

	void setUEPositioningGPSReferenceCellInfoModeSpecificInfo(const UEPositioningGPSReferenceCellInfoModeSpecificInfo& uEPositioningGPSReferenceCellInfoModeSpecificInfo) { *static_cast<UEPositioningGPSReferenceCellInfoModeSpecificInfo*>(items[0]) = uEPositioningGPSReferenceCellInfoModeSpecificInfo; }
};

class UEPositioningGPSAssistanceData : public Sequence {
private:
	static const void *itemsInfo[10];
	static bool itemsPres[10];
public:
	static const Info theInfo;
	UEPositioningGPSAssistanceData(): Sequence(&theInfo) {}

	void setUepositioningGPSReferenceTime(const UEPositioningGPSReferenceTime& uepositioningGPSReferenceTime) { *static_cast<UEPositioningGPSReferenceTime*>(items[0]) = uepositioningGPSReferenceTime; }
	void setUepositioningGPSReferenceLocation(const ReferenceLocation& uepositioningGPSReferenceLocation) { *static_cast<ReferenceLocation*>(items[1]) = uepositioningGPSReferenceLocation; }
	void setUepositioningGPSDGPSCorrections(const UEPositioningGPSDGPSCorrections& uepositioningGPSDGPSCorrections) { *static_cast<UEPositioningGPSDGPSCorrections*>(items[2]) = uepositioningGPSDGPSCorrections; }
	void setUepositioningGPSNavigationModel(const UEPositioningGPSNavigationModel& uepositioningGPSNavigationModel) { *static_cast<UEPositioningGPSNavigationModel*>(items[3]) = uepositioningGPSNavigationModel; }
	void setUepositioningGPSIonosphericModel(const UEPositioningGPSIonosphericModel& uepositioningGPSIonosphericModel) { *static_cast<UEPositioningGPSIonosphericModel*>(items[4]) = uepositioningGPSIonosphericModel; }
	void setUepositioningGPSUTCModel(const UEPositioningGPSUTCModel& uepositioningGPSUTCModel) { *static_cast<UEPositioningGPSUTCModel*>(items[5]) = uepositioningGPSUTCModel; }
	void setUepositioningGPSAlmanac(const UEPositioningGPSAlmanac& uepositioningGPSAlmanac) { *static_cast<UEPositioningGPSAlmanac*>(items[6]) = uepositioningGPSAlmanac; }
	void setUepositioningGPSAcquisitionAssistance(const UEPositioningGPSAcquisitionAssistance& uepositioningGPSAcquisitionAssistance) { *static_cast<UEPositioningGPSAcquisitionAssistance*>(items[7]) = uepositioningGPSAcquisitionAssistance; }
	void setUepositioningGPSRealtimeIntegrity(const BadSatList& uepositioningGPSRealtimeIntegrity) { *static_cast<BadSatList*>(items[8]) = uepositioningGPSRealtimeIntegrity; }
	void setDummy(const UEPositioningGPSReferenceCellInfo& dummy) { *static_cast<UEPositioningGPSReferenceCellInfo*>(items[9]) = dummy; }
};

class UEPositioningMeasurement : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UEPositioningMeasurement(): Sequence(&theInfo) {}

	void setUepositioningReportingQuantity(const UEPositioningReportingQuantity& uepositioningReportingQuantity) { *static_cast<UEPositioningReportingQuantity*>(items[0]) = uepositioningReportingQuantity; }
	void setReportCriteria(const UEPositioningReportCriteria& reportCriteria) { *static_cast<UEPositioningReportCriteria*>(items[1]) = reportCriteria; }
	void setUepositioningOTDOAAssistanceData(const UEPositioningOTDOAAssistanceData& uepositioningOTDOAAssistanceData) { *static_cast<UEPositioningOTDOAAssistanceData*>(items[2]) = uepositioningOTDOAAssistanceData; }
	void setUepositioningGPSAssistanceData(const UEPositioningGPSAssistanceData& uepositioningGPSAssistanceData) { *static_cast<UEPositioningGPSAssistanceData*>(items[3]) = uepositioningGPSAssistanceData; }
};

typedef SequenceOf<ULTrCHIdentity, CONSTRAINED, 1, maxTrCH> TrafficVolumeMeasurementObjectList;

typedef Null TrafficVolumeMeasQuantityRlcBufferPayload;

typedef Integer<CONSTRAINED, 1, 13> TimeInterval;

class TrafficVolumeMeasQuantity : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum TrafficVolumeMeasQuantityChoices {
		trafficVolumeMeasQuantityRlcBufferPayload = 0,
		averageRLCBufferPayload = 1,
		varianceOfRLCBufferPayload = 2,
	};
	static const Info theInfo;
	TrafficVolumeMeasQuantity(): Choice(&theInfo) {}
};

typedef Boolean TrafficVolumeReportingQuantityRlcRBBufferPayload;

typedef Boolean TrafficVolumeReportingQuantityRlcRBBufferPayloadAverage;

typedef Boolean TrafficVolumeReportingQuantityRlcRBBufferPayloadVariance;

class TrafficVolumeReportingQuantity : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	TrafficVolumeReportingQuantity(): Sequence(&theInfo) {}

	void setTrafficVolumeReportingQuantityRlcRBBufferPayload(const TrafficVolumeReportingQuantityRlcRBBufferPayload& trafficVolumeReportingQuantityRlcRBBufferPayload) { *static_cast<TrafficVolumeReportingQuantityRlcRBBufferPayload*>(items[0]) = trafficVolumeReportingQuantityRlcRBBufferPayload; }
	void setTrafficVolumeReportingQuantityRlcRBBufferPayloadAverage(const TrafficVolumeReportingQuantityRlcRBBufferPayloadAverage& trafficVolumeReportingQuantityRlcRBBufferPayloadAverage) { *static_cast<TrafficVolumeReportingQuantityRlcRBBufferPayloadAverage*>(items[1]) = trafficVolumeReportingQuantityRlcRBBufferPayloadAverage; }
	void setTrafficVolumeReportingQuantityRlcRBBufferPayloadVariance(const TrafficVolumeReportingQuantityRlcRBBufferPayloadVariance& trafficVolumeReportingQuantityRlcRBBufferPayloadVariance) { *static_cast<TrafficVolumeReportingQuantityRlcRBBufferPayloadVariance*>(items[2]) = trafficVolumeReportingQuantityRlcRBBufferPayloadVariance; }
};

enum TrafficVolumeThresholdValues {
	th8_TrafficVolumeThreshold = 0,
	th16_TrafficVolumeThreshold = 1,
	th32_TrafficVolumeThreshold = 2,
	th64_TrafficVolumeThreshold = 3,
	th128_TrafficVolumeThreshold = 4,
	th256_TrafficVolumeThreshold = 5,
	th512_TrafficVolumeThreshold = 6,
	th1024_TrafficVolumeThreshold = 7,
	th2k_TrafficVolumeThreshold = 8,
	th3k_TrafficVolumeThreshold = 9,
	th4k_TrafficVolumeThreshold = 10,
	th6k_TrafficVolumeThreshold = 11,
	th8k_TrafficVolumeThreshold = 12,
	th12k_TrafficVolumeThreshold = 13,
	th16k_TrafficVolumeThreshold = 14,
	th24k_TrafficVolumeThreshold = 15,
	th32k_TrafficVolumeThreshold = 16,
	th48k_TrafficVolumeThreshold = 17,
	th64k_TrafficVolumeThreshold = 18,
	th96k_TrafficVolumeThreshold = 19,
	th128k_TrafficVolumeThreshold = 20,
	th192k_TrafficVolumeThreshold = 21,
	th256k_TrafficVolumeThreshold = 22,
	th384k_TrafficVolumeThreshold = 23,
	th512k_TrafficVolumeThreshold = 24,
	th768k_TrafficVolumeThreshold = 25,
};
typedef Enumerated<CONSTRAINED, 25> TrafficVolumeThreshold;

enum PendingTimeAfterTriggerValues {
	ptat0_25_PendingTimeAfterTrigger = 0,
	ptat0_5_PendingTimeAfterTrigger = 1,
	ptat1_PendingTimeAfterTrigger = 2,
	ptat2_PendingTimeAfterTrigger = 3,
	ptat4_PendingTimeAfterTrigger = 4,
	ptat8_PendingTimeAfterTrigger = 5,
	ptat16_PendingTimeAfterTrigger = 6,
};
typedef Enumerated<CONSTRAINED, 6> PendingTimeAfterTrigger;

enum TXInterruptionAfterTriggerValues {
	txiat0_25_TXInterruptionAfterTrigger = 0,
	txiat0_5_TXInterruptionAfterTrigger = 1,
	txiat1_TXInterruptionAfterTrigger = 2,
	txiat2_TXInterruptionAfterTrigger = 3,
	txiat4_TXInterruptionAfterTrigger = 4,
	txiat8_TXInterruptionAfterTrigger = 5,
	txiat16_TXInterruptionAfterTrigger = 6,
};
typedef Enumerated<CONSTRAINED, 6> TXInterruptionAfterTrigger;

class TrafficVolumeEventParam : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	TrafficVolumeEventParam(): Sequence(&theInfo) {}

	void setEventID(const TrafficVolumeEventType& eventID) { *static_cast<TrafficVolumeEventType*>(items[0]) = eventID; }
	void setReportingThreshold(const TrafficVolumeThreshold& reportingThreshold) { *static_cast<TrafficVolumeThreshold*>(items[1]) = reportingThreshold; }
	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[2]) = timeToTrigger; }
	void setPendingTimeAfterTrigger(const PendingTimeAfterTrigger& pendingTimeAfterTrigger) { *static_cast<PendingTimeAfterTrigger*>(items[3]) = pendingTimeAfterTrigger; }
	void setTxInterruptionAfterTrigger(const TXInterruptionAfterTrigger& txInterruptionAfterTrigger) { *static_cast<TXInterruptionAfterTrigger*>(items[4]) = txInterruptionAfterTrigger; }
};

typedef SequenceOf<TrafficVolumeEventParam, CONSTRAINED, 1, maxMeasParEvent> TransChCriteriaEventSpecificParameters;

class TransChCriteria : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	TransChCriteria(): Sequence(&theInfo) {}

	void setUltransportChannelID(const ULTrCHIdentity& ultransportChannelID) { *static_cast<ULTrCHIdentity*>(items[0]) = ultransportChannelID; }
	void setTransChCriteriaEventSpecificParameters(const TransChCriteriaEventSpecificParameters& transChCriteriaEventSpecificParameters) { *static_cast<TransChCriteriaEventSpecificParameters*>(items[1]) = transChCriteriaEventSpecificParameters; }
};

typedef SequenceOf<TransChCriteria, CONSTRAINED, 1, maxTrCH> TransChCriteriaList;

class TrafficVolumeReportingCriteria : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	TrafficVolumeReportingCriteria(): Sequence(&theInfo) {}

	void setTransChCriteriaList(const TransChCriteriaList& transChCriteriaList) { *static_cast<TransChCriteriaList*>(items[0]) = transChCriteriaList; }
};

typedef Null TrafficVolumeReportCriteriaNoReporting;

class TrafficVolumeReportCriteria : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum TrafficVolumeReportCriteriaChoices {
		trafficVolumeReportingCriteria = 0,
		periodicalReportingCriteria = 1,
		trafficVolumeReportCriteriaNoReporting = 2,
	};
	static const Info theInfo;
	TrafficVolumeReportCriteria(): Choice(&theInfo) {}
};

class TrafficVolumeMeasurement : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	TrafficVolumeMeasurement(): Sequence(&theInfo) {}

	void setTrafficVolumeMeasurementObjectList(const TrafficVolumeMeasurementObjectList& trafficVolumeMeasurementObjectList) { *static_cast<TrafficVolumeMeasurementObjectList*>(items[0]) = trafficVolumeMeasurementObjectList; }
	void setTrafficVolumeMeasQuantity(const TrafficVolumeMeasQuantity& trafficVolumeMeasQuantity) { *static_cast<TrafficVolumeMeasQuantity*>(items[1]) = trafficVolumeMeasQuantity; }
	void setTrafficVolumeReportingQuantity(const TrafficVolumeReportingQuantity& trafficVolumeReportingQuantity) { *static_cast<TrafficVolumeReportingQuantity*>(items[2]) = trafficVolumeReportingQuantity; }
	void setMeasurementValidity(const MeasurementValidity& measurementValidity) { *static_cast<MeasurementValidity*>(items[3]) = measurementValidity; }
	void setReportCriteria(const TrafficVolumeReportCriteria& reportCriteria) { *static_cast<TrafficVolumeReportCriteria*>(items[4]) = reportCriteria; }
};

typedef Boolean QualityReportingQuantityDlTransChBLER;

typedef Null QualityReportingQuantityModeSpecificInfoFdd;

typedef TFCSIdentityPlain SIRTFCS;

typedef SequenceOf<SIRTFCS, CONSTRAINED, 1, maxCCTrCH> SIRTFCSList;

class QualityReportingQuantityModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	QualityReportingQuantityModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setSirTFCSList(const SIRTFCSList& sirTFCSList) { *static_cast<SIRTFCSList*>(items[0]) = sirTFCSList; }
};

class QualityReportingQuantityModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum QualityReportingQuantityModeSpecificInfoChoices {
		qualityReportingQuantityModeSpecificInfoFdd = 0,
		qualityReportingQuantityModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	QualityReportingQuantityModeSpecificInfo(): Choice(&theInfo) {}
};

class QualityReportingQuantity : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	QualityReportingQuantity(): Sequence(&theInfo) {}

	void setQualityReportingQuantityDlTransChBLER(const QualityReportingQuantityDlTransChBLER& qualityReportingQuantityDlTransChBLER) { *static_cast<QualityReportingQuantityDlTransChBLER*>(items[0]) = qualityReportingQuantityDlTransChBLER; }
	void setBlerdlTransChIdList(const BLERTransChIdList& blerdlTransChIdList) { *static_cast<BLERTransChIdList*>(items[1]) = blerdlTransChIdList; }
	void setQualityReportingQuantityModeSpecificInfo(const QualityReportingQuantityModeSpecificInfo& qualityReportingQuantityModeSpecificInfo) { *static_cast<QualityReportingQuantityModeSpecificInfo*>(items[2]) = qualityReportingQuantityModeSpecificInfo; }
};

typedef Integer<CONSTRAINED, 1, 512> QualityReportingCriteriaSingleTotalCRC;

typedef Integer<CONSTRAINED, 1, 512> QualityReportingCriteriaSingleBadCRC;

typedef Integer<CONSTRAINED, 1, 512> QualityReportingCriteriaSinglePendingAfterTrigger;

class QualityReportingCriteriaSingle : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	QualityReportingCriteriaSingle(): Sequence(&theInfo) {}

	void setTransportChannelIdentity(const TransportChannelIdentity& transportChannelIdentity) { *static_cast<TransportChannelIdentity*>(items[0]) = transportChannelIdentity; }
	void setQualityReportingCriteriaSingleTotalCRC(const QualityReportingCriteriaSingleTotalCRC& qualityReportingCriteriaSingleTotalCRC) { *static_cast<QualityReportingCriteriaSingleTotalCRC*>(items[1]) = qualityReportingCriteriaSingleTotalCRC; }
	void setQualityReportingCriteriaSingleBadCRC(const QualityReportingCriteriaSingleBadCRC& qualityReportingCriteriaSingleBadCRC) { *static_cast<QualityReportingCriteriaSingleBadCRC*>(items[2]) = qualityReportingCriteriaSingleBadCRC; }
	void setQualityReportingCriteriaSinglePendingAfterTrigger(const QualityReportingCriteriaSinglePendingAfterTrigger& qualityReportingCriteriaSinglePendingAfterTrigger) { *static_cast<QualityReportingCriteriaSinglePendingAfterTrigger*>(items[3]) = qualityReportingCriteriaSinglePendingAfterTrigger; }
};

typedef SequenceOf<QualityReportingCriteriaSingle, CONSTRAINED, 1, maxTrCH> QualityReportingCriteria;

typedef Null QualityReportCriteriaNoReporting;

class QualityReportCriteria : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum QualityReportCriteriaChoices {
		qualityReportingCriteria = 0,
		periodicalReportingCriteria = 1,
		qualityReportCriteriaNoReporting = 2,
	};
	static const Info theInfo;
	QualityReportCriteria(): Choice(&theInfo) {}
};

class QualityMeasurement : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	QualityMeasurement(): Sequence(&theInfo) {}

	void setQualityReportingQuantity(const QualityReportingQuantity& qualityReportingQuantity) { *static_cast<QualityReportingQuantity*>(items[0]) = qualityReportingQuantity; }
	void setReportCriteria(const QualityReportCriteria& reportCriteria) { *static_cast<QualityReportCriteria*>(items[1]) = reportCriteria; }
};

enum UEMeasurementQuantityValues {
	ue_TransmittedPower_UEMeasurementQuantity = 0,
	utra_Carrier_RSSI_UEMeasurementQuantity = 1,
	ue_RX_TX_TimeDifference_UEMeasurementQuantity = 2,
};
typedef Enumerated<CONSTRAINED, 2> UEMeasurementQuantity;

class UEInternalMeasQuantity : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEInternalMeasQuantity(): Sequence(&theInfo) {}

	void setMeasurementQuantity(const UEMeasurementQuantity& measurementQuantity) { *static_cast<UEMeasurementQuantity*>(items[0]) = measurementQuantity; }
	void setFilterCoefficient(const FilterCoefficient& filterCoefficient) { *static_cast<FilterCoefficient*>(items[1]) = filterCoefficient; }
};

typedef Boolean UEInternalReportingQuantityUeTransmittedPower;

typedef Boolean UEInternalReportingQuantityModeSpecificInfoFddUeRXTXTimeDifference;

class UEInternalReportingQuantityModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEInternalReportingQuantityModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setUEInternalReportingQuantityModeSpecificInfoFddUeRXTXTimeDifference(const UEInternalReportingQuantityModeSpecificInfoFddUeRXTXTimeDifference& uEInternalReportingQuantityModeSpecificInfoFddUeRXTXTimeDifference) { *static_cast<UEInternalReportingQuantityModeSpecificInfoFddUeRXTXTimeDifference*>(items[0]) = uEInternalReportingQuantityModeSpecificInfoFddUeRXTXTimeDifference; }
};

typedef Boolean UEInternalReportingQuantityModeSpecificInfoTddAppliedTA;

class UEInternalReportingQuantityModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEInternalReportingQuantityModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setUEInternalReportingQuantityModeSpecificInfoTddAppliedTA(const UEInternalReportingQuantityModeSpecificInfoTddAppliedTA& uEInternalReportingQuantityModeSpecificInfoTddAppliedTA) { *static_cast<UEInternalReportingQuantityModeSpecificInfoTddAppliedTA*>(items[0]) = uEInternalReportingQuantityModeSpecificInfoTddAppliedTA; }
};

class UEInternalReportingQuantityModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEInternalReportingQuantityModeSpecificInfoChoices {
		uEInternalReportingQuantityModeSpecificInfoFdd = 0,
		uEInternalReportingQuantityModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	UEInternalReportingQuantityModeSpecificInfo(): Choice(&theInfo) {}
};

class UEInternalReportingQuantity : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEInternalReportingQuantity(): Sequence(&theInfo) {}

	void setUEInternalReportingQuantityUeTransmittedPower(const UEInternalReportingQuantityUeTransmittedPower& uEInternalReportingQuantityUeTransmittedPower) { *static_cast<UEInternalReportingQuantityUeTransmittedPower*>(items[0]) = uEInternalReportingQuantityUeTransmittedPower; }
	void setUEInternalReportingQuantityModeSpecificInfo(const UEInternalReportingQuantityModeSpecificInfo& uEInternalReportingQuantityModeSpecificInfo) { *static_cast<UEInternalReportingQuantityModeSpecificInfo*>(items[1]) = uEInternalReportingQuantityModeSpecificInfo; }
};

typedef Integer<CONSTRAINED, -50, 33> TransmittedPowerThreshold;

class UE6ABEvent : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UE6ABEvent(): Sequence(&theInfo) {}

	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[0]) = timeToTrigger; }
	void setTransmittedPowerThreshold(const TransmittedPowerThreshold& transmittedPowerThreshold) { *static_cast<TransmittedPowerThreshold*>(items[1]) = transmittedPowerThreshold; }
};

typedef Integer<CONSTRAINED, 768, 1280> UERXTXTimeDifferenceThreshold;

class UE6FGEvent : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UE6FGEvent(): Sequence(&theInfo) {}

	void setTimeToTrigger(const TimeToTrigger& timeToTrigger) { *static_cast<TimeToTrigger*>(items[0]) = timeToTrigger; }
	void setUeRXTXTimeDifferenceThreshold(const UERXTXTimeDifferenceThreshold& ueRXTXTimeDifferenceThreshold) { *static_cast<UERXTXTimeDifferenceThreshold*>(items[1]) = ueRXTXTimeDifferenceThreshold; }
};

class UEInternalEventParam : public Choice {
private:
	static const void *choicesInfo[7];
public:
	enum UEInternalEventParamChoices {
		event6a = 0,
		event6b = 1,
		event6c = 2,
		event6d = 3,
		event6e = 4,
		event6f = 5,
		event6g = 6,
	};
	static const Info theInfo;
	UEInternalEventParam(): Choice(&theInfo) {}
};

typedef SequenceOf<UEInternalEventParam, CONSTRAINED, 1, maxMeasEvent> UEInternalEventParamList;

class UEInternalReportingCriteria : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEInternalReportingCriteria(): Sequence(&theInfo) {}

	void setUeInternalEventParamList(const UEInternalEventParamList& ueInternalEventParamList) { *static_cast<UEInternalEventParamList*>(items[0]) = ueInternalEventParamList; }
};

typedef Null UEInternalReportCriteriaNoReporting;

class UEInternalReportCriteria : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum UEInternalReportCriteriaChoices {
		ueInternalReportingCriteria = 0,
		periodicalReportingCriteria = 1,
		uEInternalReportCriteriaNoReporting = 2,
	};
	static const Info theInfo;
	UEInternalReportCriteria(): Choice(&theInfo) {}
};

class UEInternalMeasurement : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UEInternalMeasurement(): Sequence(&theInfo) {}

	void setUeInternalMeasQuantity(const UEInternalMeasQuantity& ueInternalMeasQuantity) { *static_cast<UEInternalMeasQuantity*>(items[0]) = ueInternalMeasQuantity; }
	void setUeInternalReportingQuantity(const UEInternalReportingQuantity& ueInternalReportingQuantity) { *static_cast<UEInternalReportingQuantity*>(items[1]) = ueInternalReportingQuantity; }
	void setReportCriteria(const UEInternalReportCriteria& reportCriteria) { *static_cast<UEInternalReportCriteria*>(items[2]) = reportCriteria; }
};

class MeasurementType : public Choice {
private:
	static const void *choicesInfo[7];
public:
	enum MeasurementTypeChoices {
		intraFrequencyMeasurement = 0,
		interFrequencyMeasurement = 1,
		interRATMeasurement = 2,
		uepositioningMeasurement = 3,
		trafficVolumeMeasurement = 4,
		qualityMeasurement = 5,
		ueInternalMeasurement = 6,
	};
	static const Info theInfo;
	MeasurementType(): Choice(&theInfo) {}
};

class MeasurementCommandModify : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasurementCommandModify(): Sequence(&theInfo) {}

	void setMeasurementType(const MeasurementType& measurementType) { *static_cast<MeasurementType*>(items[0]) = measurementType; }
};

typedef Null MeasurementCommandRelease;

class MeasurementCommand : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MeasurementCommandChoices {
		setup = 0,
		measurementCommandModify = 1,
		measurementCommandRelease = 2,
	};
	static const Info theInfo;
	MeasurementCommand(): Choice(&theInfo) {}
};

typedef Boolean UEPositioningReportingQuantityr4GpsTimingOfCellWanted;

typedef Boolean UEPositioningReportingQuantityr4AdditionalAssistanceDataReq;

class UEPositioningReportingQuantityr4 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	UEPositioningReportingQuantityr4(): Sequence(&theInfo) {}

	void setMethodType(const UEPositioningMethodType& methodType) { *static_cast<UEPositioningMethodType*>(items[0]) = methodType; }
	void setPositioningMethod(const PositioningMethod& positioningMethod) { *static_cast<PositioningMethod*>(items[1]) = positioningMethod; }
	void setHorizontalAccuracy(const UEPositioningAccuracy& horizontalAccuracy) { *static_cast<UEPositioningAccuracy*>(items[2]) = horizontalAccuracy; }
	void setVerticalAccuracy(const UEPositioningAccuracy& verticalAccuracy) { *static_cast<UEPositioningAccuracy*>(items[3]) = verticalAccuracy; }
	void setUEPositioningReportingQuantityr4GpsTimingOfCellWanted(const UEPositioningReportingQuantityr4GpsTimingOfCellWanted& uEPositioningReportingQuantityr4GpsTimingOfCellWanted) { *static_cast<UEPositioningReportingQuantityr4GpsTimingOfCellWanted*>(items[4]) = uEPositioningReportingQuantityr4GpsTimingOfCellWanted; }
	void setUEPositioningReportingQuantityr4AdditionalAssistanceDataReq(const UEPositioningReportingQuantityr4AdditionalAssistanceDataReq& uEPositioningReportingQuantityr4AdditionalAssistanceDataReq) { *static_cast<UEPositioningReportingQuantityr4AdditionalAssistanceDataReq*>(items[5]) = uEPositioningReportingQuantityr4AdditionalAssistanceDataReq; }
	void setEnvironmentCharacterisation(const EnvironmentCharacterisation& environmentCharacterisation) { *static_cast<EnvironmentCharacterisation*>(items[6]) = environmentCharacterisation; }
};

typedef Integer<CONSTRAINED, 0, 4095> UEPositioningOTDOAReferenceCellInfor4Sfn;

class UEPositioningOTDOAReferenceCellInfor4ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfor4ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
};

class UEPositioningOTDOAReferenceCellInfor4ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfor4ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setCellAndChannelIdentity(const CellAndChannelIdentity& cellAndChannelIdentity) { *static_cast<CellAndChannelIdentity*>(items[0]) = cellAndChannelIdentity; }
};

class UEPositioningOTDOAReferenceCellInfor4ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningOTDOAReferenceCellInfor4ModeSpecificInfoChoices {
		uEPositioningOTDOAReferenceCellInfor4ModeSpecificInfoFdd = 0,
		uEPositioningOTDOAReferenceCellInfor4ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfor4ModeSpecificInfo(): Choice(&theInfo) {}
};

class ReferenceCellPosition : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum ReferenceCellPositionChoices {
		ellipsoidPoint = 0,
		ellipsoidPointWithAltitude = 1,
	};
	static const Info theInfo;
	ReferenceCellPosition(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 32766> UEPositioningOTDOAReferenceCellInfor4PositioningModeUeBasedRoundTripTime;

class UEPositioningOTDOAReferenceCellInfor4PositioningModeUeBased : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfor4PositioningModeUeBased(): Sequence(&theInfo) {}

	void setCellPosition(const ReferenceCellPosition& cellPosition) { *static_cast<ReferenceCellPosition*>(items[0]) = cellPosition; }
	void setUEPositioningOTDOAReferenceCellInfor4PositioningModeUeBasedRoundTripTime(const UEPositioningOTDOAReferenceCellInfor4PositioningModeUeBasedRoundTripTime& uEPositioningOTDOAReferenceCellInfor4PositioningModeUeBasedRoundTripTime) { *static_cast<UEPositioningOTDOAReferenceCellInfor4PositioningModeUeBasedRoundTripTime*>(items[1]) = uEPositioningOTDOAReferenceCellInfor4PositioningModeUeBasedRoundTripTime; }
};

class UEPositioningOTDOAReferenceCellInfor4PositioningModeUeAssisted : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfor4PositioningModeUeAssisted(): Sequence(&theInfo) {}

};

class UEPositioningOTDOAReferenceCellInfor4PositioningMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningOTDOAReferenceCellInfor4PositioningModeChoices {
		uEPositioningOTDOAReferenceCellInfor4PositioningModeUeBased = 0,
		uEPositioningOTDOAReferenceCellInfor4PositioningModeUeAssisted = 1,
	};
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfor4PositioningMode(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 9> UEPositioningIPDLParametersr4ModeSpecificInfoFddIpOffset;

typedef Integer<CONSTRAINED, 0, 63> UEPositioningIPDLParametersr4ModeSpecificInfoFddSeed;

class UEPositioningIPDLParametersr4ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UEPositioningIPDLParametersr4ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setIpSpacing(const IPSpacing& ipSpacing) { *static_cast<IPSpacing*>(items[0]) = ipSpacing; }
	void setIpLength(const IPLength& ipLength) { *static_cast<IPLength*>(items[1]) = ipLength; }
	void setUEPositioningIPDLParametersr4ModeSpecificInfoFddIpOffset(const UEPositioningIPDLParametersr4ModeSpecificInfoFddIpOffset& uEPositioningIPDLParametersr4ModeSpecificInfoFddIpOffset) { *static_cast<UEPositioningIPDLParametersr4ModeSpecificInfoFddIpOffset*>(items[2]) = uEPositioningIPDLParametersr4ModeSpecificInfoFddIpOffset; }
	void setUEPositioningIPDLParametersr4ModeSpecificInfoFddSeed(const UEPositioningIPDLParametersr4ModeSpecificInfoFddSeed& uEPositioningIPDLParametersr4ModeSpecificInfoFddSeed) { *static_cast<UEPositioningIPDLParametersr4ModeSpecificInfoFddSeed*>(items[3]) = uEPositioningIPDLParametersr4ModeSpecificInfoFddSeed; }
};

typedef Integer<CONSTRAINED, 0, 14> UEPositioningIPDLParametersr4ModeSpecificInfoTddIpslot;

typedef Integer<CONSTRAINED, 0, 4095> UEPositioningIPDLParametersr4ModeSpecificInfoTddIpStart;

class UEPositioningIPDLParametersr4ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UEPositioningIPDLParametersr4ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setIpSpacingTDD(const IPSpacingTDD& ipSpacingTDD) { *static_cast<IPSpacingTDD*>(items[0]) = ipSpacingTDD; }
	void setUEPositioningIPDLParametersr4ModeSpecificInfoTddIpslot(const UEPositioningIPDLParametersr4ModeSpecificInfoTddIpslot& uEPositioningIPDLParametersr4ModeSpecificInfoTddIpslot) { *static_cast<UEPositioningIPDLParametersr4ModeSpecificInfoTddIpslot*>(items[1]) = uEPositioningIPDLParametersr4ModeSpecificInfoTddIpslot; }
	void setUEPositioningIPDLParametersr4ModeSpecificInfoTddIpStart(const UEPositioningIPDLParametersr4ModeSpecificInfoTddIpStart& uEPositioningIPDLParametersr4ModeSpecificInfoTddIpStart) { *static_cast<UEPositioningIPDLParametersr4ModeSpecificInfoTddIpStart*>(items[2]) = uEPositioningIPDLParametersr4ModeSpecificInfoTddIpStart; }
	void setIpPCCPCG(const IPPCCPCHr4& ipPCCPCG) { *static_cast<IPPCCPCHr4*>(items[3]) = ipPCCPCG; }
};

class UEPositioningIPDLParametersr4ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningIPDLParametersr4ModeSpecificInfoChoices {
		uEPositioningIPDLParametersr4ModeSpecificInfoFdd = 0,
		uEPositioningIPDLParametersr4ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	UEPositioningIPDLParametersr4ModeSpecificInfo(): Choice(&theInfo) {}
};

class UEPositioningIPDLParametersr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningIPDLParametersr4(): Sequence(&theInfo) {}

	void setUEPositioningIPDLParametersr4ModeSpecificInfo(const UEPositioningIPDLParametersr4ModeSpecificInfo& uEPositioningIPDLParametersr4ModeSpecificInfo) { *static_cast<UEPositioningIPDLParametersr4ModeSpecificInfo*>(items[0]) = uEPositioningIPDLParametersr4ModeSpecificInfo; }
	void setBurstModeParameters(const BurstModeParameters& burstModeParameters) { *static_cast<BurstModeParameters*>(items[1]) = burstModeParameters; }
};

class UEPositioningOTDOAReferenceCellInfor4 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfor4(): Sequence(&theInfo) {}

	void setUEPositioningOTDOAReferenceCellInfor4Sfn(const UEPositioningOTDOAReferenceCellInfor4Sfn& uEPositioningOTDOAReferenceCellInfor4Sfn) { *static_cast<UEPositioningOTDOAReferenceCellInfor4Sfn*>(items[0]) = uEPositioningOTDOAReferenceCellInfor4Sfn; }
	void setUEPositioningOTDOAReferenceCellInfor4ModeSpecificInfo(const UEPositioningOTDOAReferenceCellInfor4ModeSpecificInfo& uEPositioningOTDOAReferenceCellInfor4ModeSpecificInfo) { *static_cast<UEPositioningOTDOAReferenceCellInfor4ModeSpecificInfo*>(items[1]) = uEPositioningOTDOAReferenceCellInfor4ModeSpecificInfo; }
	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[2]) = frequencyInfo; }
	void setUEPositioningOTDOAReferenceCellInfor4PositioningMode(const UEPositioningOTDOAReferenceCellInfor4PositioningMode& uEPositioningOTDOAReferenceCellInfor4PositioningMode) { *static_cast<UEPositioningOTDOAReferenceCellInfor4PositioningMode*>(items[3]) = uEPositioningOTDOAReferenceCellInfor4PositioningMode; }
	void setUepositioningIPDLParemeters(const UEPositioningIPDLParametersr4& uepositioningIPDLParemeters) { *static_cast<UEPositioningIPDLParametersr4*>(items[4]) = uepositioningIPDLParemeters; }
};

class UEPositioningOTDOANeighbourCellInfor4ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfor4ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
};

class UEPositioningOTDOANeighbourCellInfor4ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfor4ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setCellAndChannelIdentity(const CellAndChannelIdentity& cellAndChannelIdentity) { *static_cast<CellAndChannelIdentity*>(items[0]) = cellAndChannelIdentity; }
};

class UEPositioningOTDOANeighbourCellInfor4ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningOTDOANeighbourCellInfor4ModeSpecificInfoChoices {
		uEPositioningOTDOANeighbourCellInfor4ModeSpecificInfoFdd = 0,
		uEPositioningOTDOANeighbourCellInfor4ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfor4ModeSpecificInfo(): Choice(&theInfo) {}
};

enum SFNOffsetValidityValues {
	false_SFNOffsetValidity = 0,
};
typedef Enumerated<CONSTRAINED, 0> SFNOffsetValidity;

typedef Integer<CONSTRAINED, -20000, 20000> UEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRelativeNorth;

typedef Integer<CONSTRAINED, -20000, 20000> UEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRelativeEast;

typedef Integer<CONSTRAINED, -4000, 4000> UEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRelativeAltitude;

typedef Integer<CONSTRAINED, 0,  32766> UEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRoundTripTime;

class UEPositioningOTDOANeighbourCellInfor4PositioningModeUeBased : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfor4PositioningModeUeBased(): Sequence(&theInfo) {}

	void setUEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRelativeNorth(const UEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRelativeNorth& uEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRelativeNorth) { *static_cast<UEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRelativeNorth*>(items[0]) = uEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRelativeNorth; }
	void setUEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRelativeEast(const UEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRelativeEast& uEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRelativeEast) { *static_cast<UEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRelativeEast*>(items[1]) = uEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRelativeEast; }
	void setUEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRelativeAltitude(const UEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRelativeAltitude& uEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRelativeAltitude) { *static_cast<UEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRelativeAltitude*>(items[2]) = uEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRelativeAltitude; }
	void setFineSFNSFN(const FineSFNSFN& fineSFNSFN) { *static_cast<FineSFNSFN*>(items[3]) = fineSFNSFN; }
	void setUEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRoundTripTime(const UEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRoundTripTime& uEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRoundTripTime) { *static_cast<UEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRoundTripTime*>(items[4]) = uEPositioningOTDOANeighbourCellInfor4PositioningModeUeBasedRoundTripTime; }
};

class UEPositioningOTDOANeighbourCellInfor4PositioningModeUeAssisted : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfor4PositioningModeUeAssisted(): Sequence(&theInfo) {}

};

class UEPositioningOTDOANeighbourCellInfor4PositioningMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningOTDOANeighbourCellInfor4PositioningModeChoices {
		uEPositioningOTDOANeighbourCellInfor4PositioningModeUeBased = 0,
		uEPositioningOTDOANeighbourCellInfor4PositioningModeUeAssisted = 1,
	};
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfor4PositioningMode(): Choice(&theInfo) {}
};

class UEPositioningOTDOANeighbourCellInfor4 : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfor4(): Sequence(&theInfo) {}

	void setUEPositioningOTDOANeighbourCellInfor4ModeSpecificInfo(const UEPositioningOTDOANeighbourCellInfor4ModeSpecificInfo& uEPositioningOTDOANeighbourCellInfor4ModeSpecificInfo) { *static_cast<UEPositioningOTDOANeighbourCellInfor4ModeSpecificInfo*>(items[0]) = uEPositioningOTDOANeighbourCellInfor4ModeSpecificInfo; }
	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[1]) = frequencyInfo; }
	void setUepositioningIPDLParemeters(const UEPositioningIPDLParametersr4& uepositioningIPDLParemeters) { *static_cast<UEPositioningIPDLParametersr4*>(items[2]) = uepositioningIPDLParemeters; }
	void setSfnSFNRelTimeDifference(const SFNSFNRelTimeDifference1& sfnSFNRelTimeDifference) { *static_cast<SFNSFNRelTimeDifference1*>(items[3]) = sfnSFNRelTimeDifference; }
	void setSfnOffsetValidity(const SFNOffsetValidity& sfnOffsetValidity) { *static_cast<SFNOffsetValidity*>(items[4]) = sfnOffsetValidity; }
	void setSfnSFNDrift(const SFNSFNDrift& sfnSFNDrift) { *static_cast<SFNSFNDrift*>(items[5]) = sfnSFNDrift; }
	void setSearchWindowSize(const OTDOASearchWindowSize& searchWindowSize) { *static_cast<OTDOASearchWindowSize*>(items[6]) = searchWindowSize; }
	void setUEPositioningOTDOANeighbourCellInfor4PositioningMode(const UEPositioningOTDOANeighbourCellInfor4PositioningMode& uEPositioningOTDOANeighbourCellInfor4PositioningMode) { *static_cast<UEPositioningOTDOANeighbourCellInfor4PositioningMode*>(items[7]) = uEPositioningOTDOANeighbourCellInfor4PositioningMode; }
};

typedef SequenceOf<UEPositioningOTDOANeighbourCellInfor4, CONSTRAINED, 1, maxCellMeas> UEPositioningOTDOANeighbourCellListr4;

class UEPositioningOTDOAAssistanceDatar4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningOTDOAAssistanceDatar4(): Sequence(&theInfo) {}

	void setUepositioningOTDOAReferenceCellInfo(const UEPositioningOTDOAReferenceCellInfor4& uepositioningOTDOAReferenceCellInfo) { *static_cast<UEPositioningOTDOAReferenceCellInfor4*>(items[0]) = uepositioningOTDOAReferenceCellInfo; }
	void setUepositioningOTDOANeighbourCellList(const UEPositioningOTDOANeighbourCellListr4& uepositioningOTDOANeighbourCellList) { *static_cast<UEPositioningOTDOANeighbourCellListr4*>(items[1]) = uepositioningOTDOANeighbourCellList; }
};

class UEPositioningMeasurementr4 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	UEPositioningMeasurementr4(): Sequence(&theInfo) {}

	void setUepositioningReportingQuantity(const UEPositioningReportingQuantityr4& uepositioningReportingQuantity) { *static_cast<UEPositioningReportingQuantityr4*>(items[0]) = uepositioningReportingQuantity; }
	void setMeasurementValidity(const MeasurementValidity& measurementValidity) { *static_cast<MeasurementValidity*>(items[1]) = measurementValidity; }
	void setReportCriteria(const UEPositioningReportCriteria& reportCriteria) { *static_cast<UEPositioningReportCriteria*>(items[2]) = reportCriteria; }
	void setUepositioningOTDOAAssistanceData(const UEPositioningOTDOAAssistanceDatar4& uepositioningOTDOAAssistanceData) { *static_cast<UEPositioningOTDOAAssistanceDatar4*>(items[3]) = uepositioningOTDOAAssistanceData; }
	void setUepositioningGPSAssistanceData(const UEPositioningGPSAssistanceData& uepositioningGPSAssistanceData) { *static_cast<UEPositioningGPSAssistanceData*>(items[4]) = uepositioningGPSAssistanceData; }
};

typedef Boolean UEInternalReportingQuantityr4UeTransmittedPower;

typedef Boolean UEInternalReportingQuantityr4ModeSpecificInfoFddUeRXTXTimeDifference;

class UEInternalReportingQuantityr4ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEInternalReportingQuantityr4ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setUEInternalReportingQuantityr4ModeSpecificInfoFddUeRXTXTimeDifference(const UEInternalReportingQuantityr4ModeSpecificInfoFddUeRXTXTimeDifference& uEInternalReportingQuantityr4ModeSpecificInfoFddUeRXTXTimeDifference) { *static_cast<UEInternalReportingQuantityr4ModeSpecificInfoFddUeRXTXTimeDifference*>(items[0]) = uEInternalReportingQuantityr4ModeSpecificInfoFddUeRXTXTimeDifference; }
};

typedef Boolean UEInternalReportingQuantityr4ModeSpecificInfoTddTddOptionTdd384AppliedTA;

class UEInternalReportingQuantityr4ModeSpecificInfoTddTddOptionTdd384 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEInternalReportingQuantityr4ModeSpecificInfoTddTddOptionTdd384(): Sequence(&theInfo) {}

	void setUEInternalReportingQuantityr4ModeSpecificInfoTddTddOptionTdd384AppliedTA(const UEInternalReportingQuantityr4ModeSpecificInfoTddTddOptionTdd384AppliedTA& uEInternalReportingQuantityr4ModeSpecificInfoTddTddOptionTdd384AppliedTA) { *static_cast<UEInternalReportingQuantityr4ModeSpecificInfoTddTddOptionTdd384AppliedTA*>(items[0]) = uEInternalReportingQuantityr4ModeSpecificInfoTddTddOptionTdd384AppliedTA; }
};

typedef Boolean UEInternalReportingQuantityr4ModeSpecificInfoTddTddOptionTdd128TADVinfo;

class UEInternalReportingQuantityr4ModeSpecificInfoTddTddOptionTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEInternalReportingQuantityr4ModeSpecificInfoTddTddOptionTdd128(): Sequence(&theInfo) {}

	void setUEInternalReportingQuantityr4ModeSpecificInfoTddTddOptionTdd128TADVinfo(const UEInternalReportingQuantityr4ModeSpecificInfoTddTddOptionTdd128TADVinfo& uEInternalReportingQuantityr4ModeSpecificInfoTddTddOptionTdd128TADVinfo) { *static_cast<UEInternalReportingQuantityr4ModeSpecificInfoTddTddOptionTdd128TADVinfo*>(items[0]) = uEInternalReportingQuantityr4ModeSpecificInfoTddTddOptionTdd128TADVinfo; }
};

class UEInternalReportingQuantityr4ModeSpecificInfoTddTddOption : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEInternalReportingQuantityr4ModeSpecificInfoTddTddOptionChoices {
		uEInternalReportingQuantityr4ModeSpecificInfoTddTddOptionTdd384 = 0,
		uEInternalReportingQuantityr4ModeSpecificInfoTddTddOptionTdd128 = 1,
	};
	static const Info theInfo;
	UEInternalReportingQuantityr4ModeSpecificInfoTddTddOption(): Choice(&theInfo) {}
};

class UEInternalReportingQuantityr4ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEInternalReportingQuantityr4ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setUEInternalReportingQuantityr4ModeSpecificInfoTddTddOption(const UEInternalReportingQuantityr4ModeSpecificInfoTddTddOption& uEInternalReportingQuantityr4ModeSpecificInfoTddTddOption) { *static_cast<UEInternalReportingQuantityr4ModeSpecificInfoTddTddOption*>(items[0]) = uEInternalReportingQuantityr4ModeSpecificInfoTddTddOption; }
};

class UEInternalReportingQuantityr4ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEInternalReportingQuantityr4ModeSpecificInfoChoices {
		uEInternalReportingQuantityr4ModeSpecificInfoFdd = 0,
		uEInternalReportingQuantityr4ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	UEInternalReportingQuantityr4ModeSpecificInfo(): Choice(&theInfo) {}
};

class UEInternalReportingQuantityr4 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEInternalReportingQuantityr4(): Sequence(&theInfo) {}

	void setUEInternalReportingQuantityr4UeTransmittedPower(const UEInternalReportingQuantityr4UeTransmittedPower& uEInternalReportingQuantityr4UeTransmittedPower) { *static_cast<UEInternalReportingQuantityr4UeTransmittedPower*>(items[0]) = uEInternalReportingQuantityr4UeTransmittedPower; }
	void setUEInternalReportingQuantityr4ModeSpecificInfo(const UEInternalReportingQuantityr4ModeSpecificInfo& uEInternalReportingQuantityr4ModeSpecificInfo) { *static_cast<UEInternalReportingQuantityr4ModeSpecificInfo*>(items[1]) = uEInternalReportingQuantityr4ModeSpecificInfo; }
};

class UEInternalMeasurementr4 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UEInternalMeasurementr4(): Sequence(&theInfo) {}

	void setUeInternalMeasQuantity(const UEInternalMeasQuantity& ueInternalMeasQuantity) { *static_cast<UEInternalMeasQuantity*>(items[0]) = ueInternalMeasQuantity; }
	void setUeInternalReportingQuantity(const UEInternalReportingQuantityr4& ueInternalReportingQuantity) { *static_cast<UEInternalReportingQuantityr4*>(items[1]) = ueInternalReportingQuantity; }
	void setReportCriteria(const UEInternalReportCriteria& reportCriteria) { *static_cast<UEInternalReportCriteria*>(items[2]) = reportCriteria; }
};

class MeasurementTyper4 : public Choice {
private:
	static const void *choicesInfo[7];
public:
	enum MeasurementTyper4Choices {
		intraFrequencyMeasurement = 0,
		interFrequencyMeasurement = 1,
		interRATMeasurement = 2,
		upMeasurement = 3,
		trafficVolumeMeasurement = 4,
		qualityMeasurement = 5,
		ueInternalMeasurement = 6,
	};
	static const Info theInfo;
	MeasurementTyper4(): Choice(&theInfo) {}
};

class MeasurementCommandr4Modify : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasurementCommandr4Modify(): Sequence(&theInfo) {}

	void setMeasurementType(const MeasurementTyper4& measurementType) { *static_cast<MeasurementTyper4*>(items[0]) = measurementType; }
};

typedef Null MeasurementCommandr4Release;

class MeasurementCommandr4 : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MeasurementCommandr4Choices {
		setup = 0,
		measurementCommandr4Modify = 1,
		measurementCommandr4Release = 2,
	};
	static const Info theInfo;
	MeasurementCommandr4(): Choice(&theInfo) {}
};

class MeasurementTyper6 : public Choice {
private:
	static const void *choicesInfo[7];
public:
	enum MeasurementTyper6Choices {
		intraFrequencyMeasurement = 0,
		interFrequencyMeasurement = 1,
		interRATMeasurement = 2,
		upMeasurement = 3,
		trafficVolumeMeasurement = 4,
		qualityMeasurement = 5,
		ueInternalMeasurement = 6,
	};
	static const Info theInfo;
	MeasurementTyper6(): Choice(&theInfo) {}
};

class MeasurementCommandr6Modify : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasurementCommandr6Modify(): Sequence(&theInfo) {}

	void setMeasurementType(const MeasurementTyper6& measurementType) { *static_cast<MeasurementTyper6*>(items[0]) = measurementType; }
};

typedef Null MeasurementCommandr6Release;

class MeasurementCommandr6 : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MeasurementCommandr6Choices {
		setup = 0,
		measurementCommandr6Modify = 1,
		measurementCommandr6Release = 2,
	};
	static const Info theInfo;
	MeasurementCommandr6(): Choice(&theInfo) {}
};

typedef Boolean UEPositioningReportingQuantityr7GpsTimingOfCellWanted;

typedef Boolean UEPositioningReportingQuantityr7AdditionalAssistanceDataReq;

enum UEPositioningReportingQuantityr7velocityRequestedValues {
	true_UEPositioningReportingQuantityr7velocityRequested = 0,
};
typedef Enumerated<CONSTRAINED, 0> UEPositioningReportingQuantityr7velocityRequested;

typedef BitString<CONSTRAINED, 16, 16> UEPositioningReportingQuantityr7GANSSPositioningMethods;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningReportingQuantityr7GANSSTimingOfCellWanted;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningReportingQuantityr7GANSSCarrierPhaseMeasurementRequested;

class UEPositioningReportingQuantityr7 : public Sequence {
private:
	static const void *itemsInfo[11];
	static bool itemsPres[11];
public:
	static const Info theInfo;
	UEPositioningReportingQuantityr7(): Sequence(&theInfo) {}

	void setMethodType(const UEPositioningMethodType& methodType) { *static_cast<UEPositioningMethodType*>(items[0]) = methodType; }
	void setPositioningMethod(const PositioningMethod& positioningMethod) { *static_cast<PositioningMethod*>(items[1]) = positioningMethod; }
	void setHorizontalAccuracy(const UEPositioningAccuracy& horizontalAccuracy) { *static_cast<UEPositioningAccuracy*>(items[2]) = horizontalAccuracy; }
	void setVerticalAccuracy(const UEPositioningAccuracy& verticalAccuracy) { *static_cast<UEPositioningAccuracy*>(items[3]) = verticalAccuracy; }
	void setUEPositioningReportingQuantityr7GpsTimingOfCellWanted(const UEPositioningReportingQuantityr7GpsTimingOfCellWanted& uEPositioningReportingQuantityr7GpsTimingOfCellWanted) { *static_cast<UEPositioningReportingQuantityr7GpsTimingOfCellWanted*>(items[4]) = uEPositioningReportingQuantityr7GpsTimingOfCellWanted; }
	void setUEPositioningReportingQuantityr7AdditionalAssistanceDataReq(const UEPositioningReportingQuantityr7AdditionalAssistanceDataReq& uEPositioningReportingQuantityr7AdditionalAssistanceDataReq) { *static_cast<UEPositioningReportingQuantityr7AdditionalAssistanceDataReq*>(items[5]) = uEPositioningReportingQuantityr7AdditionalAssistanceDataReq; }
	void setEnvironmentCharacterisation(const EnvironmentCharacterisation& environmentCharacterisation) { *static_cast<EnvironmentCharacterisation*>(items[6]) = environmentCharacterisation; }
	void setUEPositioningReportingQuantityr7velocityRequested(const UEPositioningReportingQuantityr7velocityRequested& uEPositioningReportingQuantityr7velocityRequested) { *static_cast<UEPositioningReportingQuantityr7velocityRequested*>(items[7]) = uEPositioningReportingQuantityr7velocityRequested; }
	void setUEPositioningReportingQuantityr7GANSSPositioningMethods(const UEPositioningReportingQuantityr7GANSSPositioningMethods& uEPositioningReportingQuantityr7GANSSPositioningMethods) { *static_cast<UEPositioningReportingQuantityr7GANSSPositioningMethods*>(items[8]) = uEPositioningReportingQuantityr7GANSSPositioningMethods; }
	void setUEPositioningReportingQuantityr7GANSSTimingOfCellWanted(const UEPositioningReportingQuantityr7GANSSTimingOfCellWanted& uEPositioningReportingQuantityr7GANSSTimingOfCellWanted) { *static_cast<UEPositioningReportingQuantityr7GANSSTimingOfCellWanted*>(items[9]) = uEPositioningReportingQuantityr7GANSSTimingOfCellWanted; }
	void setUEPositioningReportingQuantityr7GANSSCarrierPhaseMeasurementRequested(const UEPositioningReportingQuantityr7GANSSCarrierPhaseMeasurementRequested& uEPositioningReportingQuantityr7GANSSCarrierPhaseMeasurementRequested) { *static_cast<UEPositioningReportingQuantityr7GANSSCarrierPhaseMeasurementRequested*>(items[10]) = uEPositioningReportingQuantityr7GANSSCarrierPhaseMeasurementRequested; }
};

typedef Boolean UEPositioningEventParamr7ReportFirstFix;

enum ThresholdSFNGPSTOWusValues {
	us1_ThresholdSFNGPSTOWus = 0,
	us2_ThresholdSFNGPSTOWus = 1,
	us3_ThresholdSFNGPSTOWus = 2,
	us5_ThresholdSFNGPSTOWus = 3,
	us10_ThresholdSFNGPSTOWus = 4,
	us20_ThresholdSFNGPSTOWus = 5,
	us50_ThresholdSFNGPSTOWus = 6,
	us100_ThresholdSFNGPSTOWus = 7,
};
typedef Enumerated<CONSTRAINED, 7> ThresholdSFNGPSTOWus;

enum ThresholdSFNGANSSTOWValues {
	us1_ThresholdSFNGANSSTOW = 0,
	us2_ThresholdSFNGANSSTOW = 1,
	us3_ThresholdSFNGANSSTOW = 2,
	us5_ThresholdSFNGANSSTOW = 3,
	us10_ThresholdSFNGANSSTOW = 4,
	us20_ThresholdSFNGANSSTOW = 5,
	us50_ThresholdSFNGANSSTOW = 6,
	us100_ThresholdSFNGANSSTOW = 7,
};
typedef Enumerated<CONSTRAINED, 7> ThresholdSFNGANSSTOW;

class UEPositioningEventSpecificInfor7 : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum UEPositioningEventSpecificInfor7Choices {
		e7a = 0,
		e7b = 1,
		e7c = 2,
		e7d = 3,
	};
	static const Info theInfo;
	UEPositioningEventSpecificInfor7(): Choice(&theInfo) {}
};

class UEPositioningEventParamr7 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UEPositioningEventParamr7(): Sequence(&theInfo) {}

	void setReportingAmount(const ReportingAmount& reportingAmount) { *static_cast<ReportingAmount*>(items[0]) = reportingAmount; }
	void setUEPositioningEventParamr7ReportFirstFix(const UEPositioningEventParamr7ReportFirstFix& uEPositioningEventParamr7ReportFirstFix) { *static_cast<UEPositioningEventParamr7ReportFirstFix*>(items[1]) = uEPositioningEventParamr7ReportFirstFix; }
	void setMeasurementInterval(const UEPositioningMeasurementInterval& measurementInterval) { *static_cast<UEPositioningMeasurementInterval*>(items[2]) = measurementInterval; }
	void setEventSpecificInfo(const UEPositioningEventSpecificInfor7& eventSpecificInfo) { *static_cast<UEPositioningEventSpecificInfor7*>(items[3]) = eventSpecificInfo; }
};

typedef SequenceOf<UEPositioningEventParamr7, CONSTRAINED, 1, maxMeasEvent> UEPositioningEventParamListr7;

typedef Null UEPositioningReportCriteriar7NoReporting;

class UEPositioningReportCriteriar7 : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum UEPositioningReportCriteriar7Choices {
		uepositioningReportingCriteria = 0,
		periodicalReportingCriteria = 1,
		uEPositioningReportCriteriar7NoReporting = 2,
	};
	static const Info theInfo;
	UEPositioningReportCriteriar7(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 4095> UEPositioningOTDOAReferenceCellInfor7Sfn;

class UEPositioningOTDOAReferenceCellInfor7ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfor7ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
};

class UEPositioningOTDOAReferenceCellInfor7ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfor7ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setCellAndChannelIdentity(const CellAndChannelIdentity& cellAndChannelIdentity) { *static_cast<CellAndChannelIdentity*>(items[0]) = cellAndChannelIdentity; }
};

class UEPositioningOTDOAReferenceCellInfor7ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningOTDOAReferenceCellInfor7ModeSpecificInfoChoices {
		uEPositioningOTDOAReferenceCellInfor7ModeSpecificInfoFdd = 0,
		uEPositioningOTDOAReferenceCellInfor7ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfor7ModeSpecificInfo(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 32766> UEPositioningOTDOAReferenceCellInfor7PositioningModeUeBasedRoundTripTime;

typedef Integer<CONSTRAINED, 0, 70274> UEPositioningOTDOAReferenceCellInfor7PositioningModeUeBasedRoundTripTimeExtension;

class UEPositioningOTDOAReferenceCellInfor7PositioningModeUeBased : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfor7PositioningModeUeBased(): Sequence(&theInfo) {}

	void setCellPosition(const ReferenceCellPosition& cellPosition) { *static_cast<ReferenceCellPosition*>(items[0]) = cellPosition; }
	void setUEPositioningOTDOAReferenceCellInfor7PositioningModeUeBasedRoundTripTime(const UEPositioningOTDOAReferenceCellInfor7PositioningModeUeBasedRoundTripTime& uEPositioningOTDOAReferenceCellInfor7PositioningModeUeBasedRoundTripTime) { *static_cast<UEPositioningOTDOAReferenceCellInfor7PositioningModeUeBasedRoundTripTime*>(items[1]) = uEPositioningOTDOAReferenceCellInfor7PositioningModeUeBasedRoundTripTime; }
	void setUEPositioningOTDOAReferenceCellInfor7PositioningModeUeBasedRoundTripTimeExtension(const UEPositioningOTDOAReferenceCellInfor7PositioningModeUeBasedRoundTripTimeExtension& uEPositioningOTDOAReferenceCellInfor7PositioningModeUeBasedRoundTripTimeExtension) { *static_cast<UEPositioningOTDOAReferenceCellInfor7PositioningModeUeBasedRoundTripTimeExtension*>(items[2]) = uEPositioningOTDOAReferenceCellInfor7PositioningModeUeBasedRoundTripTimeExtension; }
};

class UEPositioningOTDOAReferenceCellInfor7PositioningModeUeAssisted : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfor7PositioningModeUeAssisted(): Sequence(&theInfo) {}

};

class UEPositioningOTDOAReferenceCellInfor7PositioningMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningOTDOAReferenceCellInfor7PositioningModeChoices {
		uEPositioningOTDOAReferenceCellInfor7PositioningModeUeBased = 0,
		uEPositioningOTDOAReferenceCellInfor7PositioningModeUeAssisted = 1,
	};
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfor7PositioningMode(): Choice(&theInfo) {}
};

class UEPositioningOTDOAReferenceCellInfor7 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfor7(): Sequence(&theInfo) {}

	void setUEPositioningOTDOAReferenceCellInfor7Sfn(const UEPositioningOTDOAReferenceCellInfor7Sfn& uEPositioningOTDOAReferenceCellInfor7Sfn) { *static_cast<UEPositioningOTDOAReferenceCellInfor7Sfn*>(items[0]) = uEPositioningOTDOAReferenceCellInfor7Sfn; }
	void setUEPositioningOTDOAReferenceCellInfor7ModeSpecificInfo(const UEPositioningOTDOAReferenceCellInfor7ModeSpecificInfo& uEPositioningOTDOAReferenceCellInfor7ModeSpecificInfo) { *static_cast<UEPositioningOTDOAReferenceCellInfor7ModeSpecificInfo*>(items[1]) = uEPositioningOTDOAReferenceCellInfor7ModeSpecificInfo; }
	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[2]) = frequencyInfo; }
	void setUEPositioningOTDOAReferenceCellInfor7PositioningMode(const UEPositioningOTDOAReferenceCellInfor7PositioningMode& uEPositioningOTDOAReferenceCellInfor7PositioningMode) { *static_cast<UEPositioningOTDOAReferenceCellInfor7PositioningMode*>(items[3]) = uEPositioningOTDOAReferenceCellInfor7PositioningMode; }
	void setUepositioningIPDLParemeters(const UEPositioningIPDLParametersr4& uepositioningIPDLParemeters) { *static_cast<UEPositioningIPDLParametersr4*>(items[4]) = uepositioningIPDLParemeters; }
};

class UEPositioningOTDOANeighbourCellInfor7ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfor7ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
};

class UEPositioningOTDOANeighbourCellInfor7ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfor7ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setCellAndChannelIdentity(const CellAndChannelIdentity& cellAndChannelIdentity) { *static_cast<CellAndChannelIdentity*>(items[0]) = cellAndChannelIdentity; }
};

class UEPositioningOTDOANeighbourCellInfor7ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningOTDOANeighbourCellInfor7ModeSpecificInfoChoices {
		uEPositioningOTDOANeighbourCellInfor7ModeSpecificInfoFdd = 0,
		uEPositioningOTDOANeighbourCellInfor7ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfor7ModeSpecificInfo(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, -20000, 20000> UEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRelativeNorth;

typedef Integer<CONSTRAINED, -20000, 20000> UEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRelativeEast;

typedef Integer<CONSTRAINED, -4000, 4000> UEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRelativeAltitude;

typedef Integer<CONSTRAINED, 0,  32766> UEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRoundTripTime;

typedef Integer<CONSTRAINED, 0, 70274> UEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRoundTripTimeExtension;

class UEPositioningOTDOANeighbourCellInfor7PositioningModeUeBased : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfor7PositioningModeUeBased(): Sequence(&theInfo) {}

	void setUEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRelativeNorth(const UEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRelativeNorth& uEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRelativeNorth) { *static_cast<UEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRelativeNorth*>(items[0]) = uEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRelativeNorth; }
	void setUEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRelativeEast(const UEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRelativeEast& uEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRelativeEast) { *static_cast<UEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRelativeEast*>(items[1]) = uEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRelativeEast; }
	void setUEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRelativeAltitude(const UEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRelativeAltitude& uEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRelativeAltitude) { *static_cast<UEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRelativeAltitude*>(items[2]) = uEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRelativeAltitude; }
	void setFineSFNSFN(const FineSFNSFN& fineSFNSFN) { *static_cast<FineSFNSFN*>(items[3]) = fineSFNSFN; }
	void setUEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRoundTripTime(const UEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRoundTripTime& uEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRoundTripTime) { *static_cast<UEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRoundTripTime*>(items[4]) = uEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRoundTripTime; }
	void setUEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRoundTripTimeExtension(const UEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRoundTripTimeExtension& uEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRoundTripTimeExtension) { *static_cast<UEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRoundTripTimeExtension*>(items[5]) = uEPositioningOTDOANeighbourCellInfor7PositioningModeUeBasedRoundTripTimeExtension; }
};

class UEPositioningOTDOANeighbourCellInfor7PositioningModeUeAssisted : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfor7PositioningModeUeAssisted(): Sequence(&theInfo) {}

};

class UEPositioningOTDOANeighbourCellInfor7PositioningMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningOTDOANeighbourCellInfor7PositioningModeChoices {
		uEPositioningOTDOANeighbourCellInfor7PositioningModeUeBased = 0,
		uEPositioningOTDOANeighbourCellInfor7PositioningModeUeAssisted = 1,
	};
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfor7PositioningMode(): Choice(&theInfo) {}
};

class UEPositioningOTDOANeighbourCellInfor7 : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfor7(): Sequence(&theInfo) {}

	void setUEPositioningOTDOANeighbourCellInfor7ModeSpecificInfo(const UEPositioningOTDOANeighbourCellInfor7ModeSpecificInfo& uEPositioningOTDOANeighbourCellInfor7ModeSpecificInfo) { *static_cast<UEPositioningOTDOANeighbourCellInfor7ModeSpecificInfo*>(items[0]) = uEPositioningOTDOANeighbourCellInfor7ModeSpecificInfo; }
	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[1]) = frequencyInfo; }
	void setUepositioningIPDLParemeters(const UEPositioningIPDLParametersr4& uepositioningIPDLParemeters) { *static_cast<UEPositioningIPDLParametersr4*>(items[2]) = uepositioningIPDLParemeters; }
	void setSfnSFNRelTimeDifference(const SFNSFNRelTimeDifference1& sfnSFNRelTimeDifference) { *static_cast<SFNSFNRelTimeDifference1*>(items[3]) = sfnSFNRelTimeDifference; }
	void setSfnOffsetValidity(const SFNOffsetValidity& sfnOffsetValidity) { *static_cast<SFNOffsetValidity*>(items[4]) = sfnOffsetValidity; }
	void setSfnSFNDrift(const SFNSFNDrift& sfnSFNDrift) { *static_cast<SFNSFNDrift*>(items[5]) = sfnSFNDrift; }
	void setSearchWindowSize(const OTDOASearchWindowSize& searchWindowSize) { *static_cast<OTDOASearchWindowSize*>(items[6]) = searchWindowSize; }
	void setUEPositioningOTDOANeighbourCellInfor7PositioningMode(const UEPositioningOTDOANeighbourCellInfor7PositioningMode& uEPositioningOTDOANeighbourCellInfor7PositioningMode) { *static_cast<UEPositioningOTDOANeighbourCellInfor7PositioningMode*>(items[7]) = uEPositioningOTDOANeighbourCellInfor7PositioningMode; }
};

typedef SequenceOf<UEPositioningOTDOANeighbourCellInfor7, CONSTRAINED, 1, maxCellMeas> UEPositioningOTDOANeighbourCellListr7;

class UEPositioningOTDOAAssistanceDatar7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningOTDOAAssistanceDatar7(): Sequence(&theInfo) {}

	void setUepositioningOTDOAReferenceCellInfo(const UEPositioningOTDOAReferenceCellInfor7& uepositioningOTDOAReferenceCellInfo) { *static_cast<UEPositioningOTDOAReferenceCellInfor7*>(items[0]) = uepositioningOTDOAReferenceCellInfo; }
	void setUepositioningOTDOANeighbourCellList(const UEPositioningOTDOANeighbourCellListr7& uepositioningOTDOANeighbourCellList) { *static_cast<UEPositioningOTDOANeighbourCellListr7*>(items[1]) = uepositioningOTDOANeighbourCellList; }
};

typedef Integer<CONSTRAINED, 0, 1023> UEPositioningGPSReferenceTimer7GpsWeek;

class UEPositioningGPSReferenceTimer7 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	UEPositioningGPSReferenceTimer7(): Sequence(&theInfo) {}

	void setUEPositioningGPSReferenceTimer7GpsWeek(const UEPositioningGPSReferenceTimer7GpsWeek& uEPositioningGPSReferenceTimer7GpsWeek) { *static_cast<UEPositioningGPSReferenceTimer7GpsWeek*>(items[0]) = uEPositioningGPSReferenceTimer7GpsWeek; }
	void setGpstow1msec(const GPSTOW1msec& gpstow1msec) { *static_cast<GPSTOW1msec*>(items[1]) = gpstow1msec; }
	void setUtranGPSReferenceTime(const UTRANGPSReferenceTime& utranGPSReferenceTime) { *static_cast<UTRANGPSReferenceTime*>(items[2]) = utranGPSReferenceTime; }
	void setUePositioningGPSReferenceTimeUncertainty(const UEPositioningGPSReferenceTimeUncertainty& uePositioningGPSReferenceTimeUncertainty) { *static_cast<UEPositioningGPSReferenceTimeUncertainty*>(items[3]) = uePositioningGPSReferenceTimeUncertainty; }
	void setSfntowUncertainty(const SFNTOWUncertainty& sfntowUncertainty) { *static_cast<SFNTOWUncertainty*>(items[4]) = sfntowUncertainty; }
	void setUtranGPSDriftRate(const UTRANGPSDriftRate& utranGPSDriftRate) { *static_cast<UTRANGPSDriftRate*>(items[5]) = utranGPSDriftRate; }
	void setGpsTOWAssistList(const GPSTOWAssistList& gpsTOWAssistList) { *static_cast<GPSTOWAssistList*>(items[6]) = gpsTOWAssistList; }
};

class UEPositioningGPSAcquisitionAssistancer7 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UEPositioningGPSAcquisitionAssistancer7(): Sequence(&theInfo) {}

	void setGpsReferenceTime(const GPSTOW1msec& gpsReferenceTime) { *static_cast<GPSTOW1msec*>(items[0]) = gpsReferenceTime; }
	void setUtranGPSReferenceTime(const UTRANGPSReferenceTime& utranGPSReferenceTime) { *static_cast<UTRANGPSReferenceTime*>(items[1]) = utranGPSReferenceTime; }
	void setUePositioningGPSReferenceTimeUncertainty(const UEPositioningGPSReferenceTimeUncertainty& uePositioningGPSReferenceTimeUncertainty) { *static_cast<UEPositioningGPSReferenceTimeUncertainty*>(items[2]) = uePositioningGPSReferenceTimeUncertainty; }
	void setSatelliteInformationList(const AcquisitionSatInfoList& satelliteInformationList) { *static_cast<AcquisitionSatInfoList*>(items[3]) = satelliteInformationList; }
};

class UEPositioningGPSAssistanceDatar7 : public Sequence {
private:
	static const void *itemsInfo[9];
	static bool itemsPres[9];
public:
	static const Info theInfo;
	UEPositioningGPSAssistanceDatar7(): Sequence(&theInfo) {}

	void setUepositioningGPSReferenceTime(const UEPositioningGPSReferenceTimer7& uepositioningGPSReferenceTime) { *static_cast<UEPositioningGPSReferenceTimer7*>(items[0]) = uepositioningGPSReferenceTime; }
	void setUepositioningGPSReferenceLocation(const ReferenceLocation& uepositioningGPSReferenceLocation) { *static_cast<ReferenceLocation*>(items[1]) = uepositioningGPSReferenceLocation; }
	void setUepositioningGPSDGPSCorrections(const UEPositioningGPSDGPSCorrections& uepositioningGPSDGPSCorrections) { *static_cast<UEPositioningGPSDGPSCorrections*>(items[2]) = uepositioningGPSDGPSCorrections; }
	void setUepositioningGPSNavigationModel(const UEPositioningGPSNavigationModel& uepositioningGPSNavigationModel) { *static_cast<UEPositioningGPSNavigationModel*>(items[3]) = uepositioningGPSNavigationModel; }
	void setUepositioningGPSIonosphericModel(const UEPositioningGPSIonosphericModel& uepositioningGPSIonosphericModel) { *static_cast<UEPositioningGPSIonosphericModel*>(items[4]) = uepositioningGPSIonosphericModel; }
	void setUepositioningGPSUTCModel(const UEPositioningGPSUTCModel& uepositioningGPSUTCModel) { *static_cast<UEPositioningGPSUTCModel*>(items[5]) = uepositioningGPSUTCModel; }
	void setUepositioningGPSAlmanac(const UEPositioningGPSAlmanac& uepositioningGPSAlmanac) { *static_cast<UEPositioningGPSAlmanac*>(items[6]) = uepositioningGPSAlmanac; }
	void setUepositioningGPSAcquisitionAssistance(const UEPositioningGPSAcquisitionAssistancer7& uepositioningGPSAcquisitionAssistance) { *static_cast<UEPositioningGPSAcquisitionAssistancer7*>(items[7]) = uepositioningGPSAcquisitionAssistance; }
	void setUepositioningGPSRealtimeIntegrity(const BadSatList& uepositioningGPSRealtimeIntegrity) { *static_cast<BadSatList*>(items[8]) = uepositioningGPSRealtimeIntegrity; }
};

typedef Integer<CONSTRAINED, 0, 8191> UEPositioningGANSSReferenceTimeGanssDay;

typedef Integer<CONSTRAINED, 0, 86399> UEPositioningGANSSReferenceTimeGanssTod;

typedef Integer<CONSTRAINED, 0, 127> UEPositioningGANSSReferenceTimeGanssTodUncertainty;

typedef Integer<CONSTRAINED, 0, 7> UEPositioningGANSSReferenceTimeGanssTimeId;

typedef Integer<CONSTRAINED, 0, 3999999> UEPositioningGANSSReferenceTimeUtranganssreferenceTimeTimingOfCellFrames;

class UEPositioningGANSSReferenceTimeUtranganssreferenceTimeModeFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningGANSSReferenceTimeUtranganssreferenceTimeModeFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
};

class UEPositioningGANSSReferenceTimeUtranganssreferenceTimeModeTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningGANSSReferenceTimeUtranganssreferenceTimeModeTdd(): Sequence(&theInfo) {}

	void setCellParameters(const CellParametersID& cellParameters) { *static_cast<CellParametersID*>(items[0]) = cellParameters; }
};

class UEPositioningGANSSReferenceTimeUtranganssreferenceTimeMode : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningGANSSReferenceTimeUtranganssreferenceTimeModeChoices {
		uEPositioningGANSSReferenceTimeUtranganssreferenceTimeModeFdd = 0,
		uEPositioningGANSSReferenceTimeUtranganssreferenceTimeModeTdd = 1,
	};
	static const Info theInfo;
	UEPositioningGANSSReferenceTimeUtranganssreferenceTimeMode(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 4095> UEPositioningGANSSReferenceTimeUtranganssreferenceTimeReferenceSfn;

class UEPositioningGANSSReferenceTimeUtranganssreferenceTime : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UEPositioningGANSSReferenceTimeUtranganssreferenceTime(): Sequence(&theInfo) {}

	void setUEPositioningGANSSReferenceTimeUtranganssreferenceTimeTimingOfCellFrames(const UEPositioningGANSSReferenceTimeUtranganssreferenceTimeTimingOfCellFrames& uEPositioningGANSSReferenceTimeUtranganssreferenceTimeTimingOfCellFrames) { *static_cast<UEPositioningGANSSReferenceTimeUtranganssreferenceTimeTimingOfCellFrames*>(items[0]) = uEPositioningGANSSReferenceTimeUtranganssreferenceTimeTimingOfCellFrames; }
	void setUEPositioningGANSSReferenceTimeUtranganssreferenceTimeMode(const UEPositioningGANSSReferenceTimeUtranganssreferenceTimeMode& uEPositioningGANSSReferenceTimeUtranganssreferenceTimeMode) { *static_cast<UEPositioningGANSSReferenceTimeUtranganssreferenceTimeMode*>(items[1]) = uEPositioningGANSSReferenceTimeUtranganssreferenceTimeMode; }
	void setUEPositioningGANSSReferenceTimeUtranganssreferenceTimeReferenceSfn(const UEPositioningGANSSReferenceTimeUtranganssreferenceTimeReferenceSfn& uEPositioningGANSSReferenceTimeUtranganssreferenceTimeReferenceSfn) { *static_cast<UEPositioningGANSSReferenceTimeUtranganssreferenceTimeReferenceSfn*>(items[2]) = uEPositioningGANSSReferenceTimeUtranganssreferenceTimeReferenceSfn; }
};

enum TutranGanssDriftRateValues {
	ugdr0_TutranGanssDriftRate = 0,
	ugdr1_TutranGanssDriftRate = 1,
	ugdr2_TutranGanssDriftRate = 2,
	ugdr5_TutranGanssDriftRate = 3,
	ugdr10_TutranGanssDriftRate = 4,
	ugdr15_TutranGanssDriftRate = 5,
	ugdr25_TutranGanssDriftRate = 6,
	ugdr50_TutranGanssDriftRate = 7,
	ugdr_1_TutranGanssDriftRate = 8,
	ugdr_2_TutranGanssDriftRate = 9,
	ugdr_5_TutranGanssDriftRate = 10,
	ugdr_10_TutranGanssDriftRate = 11,
	ugdr_15_TutranGanssDriftRate = 12,
	ugdr_25_TutranGanssDriftRate = 13,
	ugdr_50_TutranGanssDriftRate = 14,
	spare_TutranGanssDriftRate = 15,
};
typedef Enumerated<CONSTRAINED, 15> TutranGanssDriftRate;

class UEPositioningGANSSReferenceTime : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	UEPositioningGANSSReferenceTime(): Sequence(&theInfo) {}

	void setUEPositioningGANSSReferenceTimeGanssDay(const UEPositioningGANSSReferenceTimeGanssDay& uEPositioningGANSSReferenceTimeGanssDay) { *static_cast<UEPositioningGANSSReferenceTimeGanssDay*>(items[0]) = uEPositioningGANSSReferenceTimeGanssDay; }
	void setUEPositioningGANSSReferenceTimeGanssTod(const UEPositioningGANSSReferenceTimeGanssTod& uEPositioningGANSSReferenceTimeGanssTod) { *static_cast<UEPositioningGANSSReferenceTimeGanssTod*>(items[1]) = uEPositioningGANSSReferenceTimeGanssTod; }
	void setUEPositioningGANSSReferenceTimeGanssTodUncertainty(const UEPositioningGANSSReferenceTimeGanssTodUncertainty& uEPositioningGANSSReferenceTimeGanssTodUncertainty) { *static_cast<UEPositioningGANSSReferenceTimeGanssTodUncertainty*>(items[2]) = uEPositioningGANSSReferenceTimeGanssTodUncertainty; }
	void setUEPositioningGANSSReferenceTimeGanssTimeId(const UEPositioningGANSSReferenceTimeGanssTimeId& uEPositioningGANSSReferenceTimeGanssTimeId) { *static_cast<UEPositioningGANSSReferenceTimeGanssTimeId*>(items[3]) = uEPositioningGANSSReferenceTimeGanssTimeId; }
	void setUEPositioningGANSSReferenceTimeUtranganssreferenceTime(const UEPositioningGANSSReferenceTimeUtranganssreferenceTime& uEPositioningGANSSReferenceTimeUtranganssreferenceTime) { *static_cast<UEPositioningGANSSReferenceTimeUtranganssreferenceTime*>(items[4]) = uEPositioningGANSSReferenceTimeUtranganssreferenceTime; }
	void setTutranganssdriftRate(const TutranGanssDriftRate& tutranganssdriftRate) { *static_cast<TutranGanssDriftRate*>(items[5]) = tutranganssdriftRate; }
};

class ReferenceLocationGANSS : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	ReferenceLocationGANSS(): Sequence(&theInfo) {}

	void setEllipsoidPointAltitudeEllipsoide(const EllipsoidPointAltitudeEllipsoide& ellipsoidPointAltitudeEllipsoide) { *static_cast<EllipsoidPointAltitudeEllipsoide*>(items[0]) = ellipsoidPointAltitudeEllipsoide; }
};

typedef BitString<CONSTRAINED, 12, 12> UEPositioningGANSSIonosphericModelAlphazeroionos;

typedef BitString<CONSTRAINED, 12, 12> UEPositioningGANSSIonosphericModelAlphaoneionos;

typedef BitString<CONSTRAINED, 12, 12> UEPositioningGANSSIonosphericModelAlphatwoionos;

class UEPositioningGANSSIonosphericModel : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UEPositioningGANSSIonosphericModel(): Sequence(&theInfo) {}

	void setUEPositioningGANSSIonosphericModelAlphazeroionos(const UEPositioningGANSSIonosphericModelAlphazeroionos& uEPositioningGANSSIonosphericModelAlphazeroionos) { *static_cast<UEPositioningGANSSIonosphericModelAlphazeroionos*>(items[0]) = uEPositioningGANSSIonosphericModelAlphazeroionos; }
	void setUEPositioningGANSSIonosphericModelAlphaoneionos(const UEPositioningGANSSIonosphericModelAlphaoneionos& uEPositioningGANSSIonosphericModelAlphaoneionos) { *static_cast<UEPositioningGANSSIonosphericModelAlphaoneionos*>(items[1]) = uEPositioningGANSSIonosphericModelAlphaoneionos; }
	void setUEPositioningGANSSIonosphericModelAlphatwoionos(const UEPositioningGANSSIonosphericModelAlphatwoionos& uEPositioningGANSSIonosphericModelAlphatwoionos) { *static_cast<UEPositioningGANSSIonosphericModelAlphatwoionos*>(items[2]) = uEPositioningGANSSIonosphericModelAlphatwoionos; }
	void setGANSSstormflags(const GANSSStormFlag& gANSSstormflags) { *static_cast<GANSSStormFlag*>(items[3]) = gANSSstormflags; }
};

class UEPositioningGANSSAssistanceData : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UEPositioningGANSSAssistanceData(): Sequence(&theInfo) {}

	void setUepositioningGANSSReferenceTime(const UEPositioningGANSSReferenceTime& uepositioningGANSSReferenceTime) { *static_cast<UEPositioningGANSSReferenceTime*>(items[0]) = uepositioningGANSSReferenceTime; }
	void setUePositioningGanssReferencePosition(const ReferenceLocationGANSS& uePositioningGanssReferencePosition) { *static_cast<ReferenceLocationGANSS*>(items[1]) = uePositioningGanssReferencePosition; }
	void setUePositioningGanssIonosphericModel(const UEPositioningGANSSIonosphericModel& uePositioningGanssIonosphericModel) { *static_cast<UEPositioningGANSSIonosphericModel*>(items[2]) = uePositioningGanssIonosphericModel; }
	void setGanssGenericDataList(const GANSSGenericDataList& ganssGenericDataList) { *static_cast<GANSSGenericDataList*>(items[3]) = ganssGenericDataList; }
};

class UEPositioningMeasurementr7 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	UEPositioningMeasurementr7(): Sequence(&theInfo) {}

	void setUepositioningReportingQuantity(const UEPositioningReportingQuantityr7& uepositioningReportingQuantity) { *static_cast<UEPositioningReportingQuantityr7*>(items[0]) = uepositioningReportingQuantity; }
	void setMeasurementValidity(const MeasurementValidity& measurementValidity) { *static_cast<MeasurementValidity*>(items[1]) = measurementValidity; }
	void setReportCriteria(const UEPositioningReportCriteriar7& reportCriteria) { *static_cast<UEPositioningReportCriteriar7*>(items[2]) = reportCriteria; }
	void setUepositioningOTDOAAssistanceData(const UEPositioningOTDOAAssistanceDatar7& uepositioningOTDOAAssistanceData) { *static_cast<UEPositioningOTDOAAssistanceDatar7*>(items[3]) = uepositioningOTDOAAssistanceData; }
	void setUepositioningGPSAssistanceData(const UEPositioningGPSAssistanceDatar7& uepositioningGPSAssistanceData) { *static_cast<UEPositioningGPSAssistanceDatar7*>(items[4]) = uepositioningGPSAssistanceData; }
	void setUepositioningGANSSAssistanceData(const UEPositioningGANSSAssistanceData& uepositioningGANSSAssistanceData) { *static_cast<UEPositioningGANSSAssistanceData*>(items[5]) = uepositioningGANSSAssistanceData; }
};

class MeasurementTyper7 : public Choice {
private:
	static const void *choicesInfo[7];
public:
	enum MeasurementTyper7Choices {
		intraFrequencyMeasurement = 0,
		interFrequencyMeasurement = 1,
		interRATMeasurement = 2,
		upMeasurement = 3,
		trafficVolumeMeasurement = 4,
		qualityMeasurement = 5,
		ueInternalMeasurement = 6,
	};
	static const Info theInfo;
	MeasurementTyper7(): Choice(&theInfo) {}
};

class MeasurementCommandr7Modify : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasurementCommandr7Modify(): Sequence(&theInfo) {}

	void setMeasurementType(const MeasurementTyper7& measurementType) { *static_cast<MeasurementTyper7*>(items[0]) = measurementType; }
};

typedef Null MeasurementCommandr7Release;

class MeasurementCommandr7 : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MeasurementCommandr7Choices {
		setup = 0,
		measurementCommandr7Modify = 1,
		measurementCommandr7Release = 2,
	};
	static const Info theInfo;
	MeasurementCommandr7(): Choice(&theInfo) {}
};

typedef Boolean UEPositioningReportingQuantityr8GpsTimingOfCellWanted;

typedef Boolean UEPositioningReportingQuantityr8AdditionalAssistanceDataReq;

enum UEPositioningReportingQuantityr8velocityRequestedValues {
	true_UEPositioningReportingQuantityr8velocityRequested = 0,
};
typedef Enumerated<CONSTRAINED, 0> UEPositioningReportingQuantityr8velocityRequested;

typedef BitString<CONSTRAINED, 16, 16> UEPositioningReportingQuantityr8GANSSPositioningMethods;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningReportingQuantityr8GANSSTimingOfCellWanted;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningReportingQuantityr8GANSSCarrierPhaseMeasurementRequested;

typedef BitString<CONSTRAINED, 8, 8> UEPositioningReportingQuantityr8GANSSMultiFreqMeasurementRequested;

class UEPositioningReportingQuantityr8 : public Sequence {
private:
	static const void *itemsInfo[12];
	static bool itemsPres[12];
public:
	static const Info theInfo;
	UEPositioningReportingQuantityr8(): Sequence(&theInfo) {}

	void setMethodType(const UEPositioningMethodType& methodType) { *static_cast<UEPositioningMethodType*>(items[0]) = methodType; }
	void setPositioningMethod(const PositioningMethod& positioningMethod) { *static_cast<PositioningMethod*>(items[1]) = positioningMethod; }
	void setHorizontalAccuracy(const UEPositioningAccuracy& horizontalAccuracy) { *static_cast<UEPositioningAccuracy*>(items[2]) = horizontalAccuracy; }
	void setVerticalAccuracy(const UEPositioningAccuracy& verticalAccuracy) { *static_cast<UEPositioningAccuracy*>(items[3]) = verticalAccuracy; }
	void setUEPositioningReportingQuantityr8GpsTimingOfCellWanted(const UEPositioningReportingQuantityr8GpsTimingOfCellWanted& uEPositioningReportingQuantityr8GpsTimingOfCellWanted) { *static_cast<UEPositioningReportingQuantityr8GpsTimingOfCellWanted*>(items[4]) = uEPositioningReportingQuantityr8GpsTimingOfCellWanted; }
	void setUEPositioningReportingQuantityr8AdditionalAssistanceDataReq(const UEPositioningReportingQuantityr8AdditionalAssistanceDataReq& uEPositioningReportingQuantityr8AdditionalAssistanceDataReq) { *static_cast<UEPositioningReportingQuantityr8AdditionalAssistanceDataReq*>(items[5]) = uEPositioningReportingQuantityr8AdditionalAssistanceDataReq; }
	void setEnvironmentCharacterisation(const EnvironmentCharacterisation& environmentCharacterisation) { *static_cast<EnvironmentCharacterisation*>(items[6]) = environmentCharacterisation; }
	void setUEPositioningReportingQuantityr8velocityRequested(const UEPositioningReportingQuantityr8velocityRequested& uEPositioningReportingQuantityr8velocityRequested) { *static_cast<UEPositioningReportingQuantityr8velocityRequested*>(items[7]) = uEPositioningReportingQuantityr8velocityRequested; }
	void setUEPositioningReportingQuantityr8GANSSPositioningMethods(const UEPositioningReportingQuantityr8GANSSPositioningMethods& uEPositioningReportingQuantityr8GANSSPositioningMethods) { *static_cast<UEPositioningReportingQuantityr8GANSSPositioningMethods*>(items[8]) = uEPositioningReportingQuantityr8GANSSPositioningMethods; }
	void setUEPositioningReportingQuantityr8GANSSTimingOfCellWanted(const UEPositioningReportingQuantityr8GANSSTimingOfCellWanted& uEPositioningReportingQuantityr8GANSSTimingOfCellWanted) { *static_cast<UEPositioningReportingQuantityr8GANSSTimingOfCellWanted*>(items[9]) = uEPositioningReportingQuantityr8GANSSTimingOfCellWanted; }
	void setUEPositioningReportingQuantityr8GANSSCarrierPhaseMeasurementRequested(const UEPositioningReportingQuantityr8GANSSCarrierPhaseMeasurementRequested& uEPositioningReportingQuantityr8GANSSCarrierPhaseMeasurementRequested) { *static_cast<UEPositioningReportingQuantityr8GANSSCarrierPhaseMeasurementRequested*>(items[10]) = uEPositioningReportingQuantityr8GANSSCarrierPhaseMeasurementRequested; }
	void setUEPositioningReportingQuantityr8GANSSMultiFreqMeasurementRequested(const UEPositioningReportingQuantityr8GANSSMultiFreqMeasurementRequested& uEPositioningReportingQuantityr8GANSSMultiFreqMeasurementRequested) { *static_cast<UEPositioningReportingQuantityr8GANSSMultiFreqMeasurementRequested*>(items[11]) = uEPositioningReportingQuantityr8GANSSMultiFreqMeasurementRequested; }
};

typedef BitString<CONSTRAINED, 2, 2> UEPositioningGANSSAddIonoModelDataID;

class UEPositioningGANSSAddIonoModel : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningGANSSAddIonoModel(): Sequence(&theInfo) {}

	void setUEPositioningGANSSAddIonoModelDataID(const UEPositioningGANSSAddIonoModelDataID& uEPositioningGANSSAddIonoModelDataID) { *static_cast<UEPositioningGANSSAddIonoModelDataID*>(items[0]) = uEPositioningGANSSAddIonoModelDataID; }
	void setAlphabetaparameters(const UEPositioningGPSIonosphericModel& alphabetaparameters) { *static_cast<UEPositioningGPSIonosphericModel*>(items[1]) = alphabetaparameters; }
};

typedef BitString<CONSTRAINED, 16, 16> UEPositioningGANSSEarthOrientParaTeop;

typedef BitString<CONSTRAINED, 21, 21> UEPositioningGANSSEarthOrientParaPmX;

typedef BitString<CONSTRAINED, 15, 15> UEPositioningGANSSEarthOrientParaPmXdot;

typedef BitString<CONSTRAINED, 21, 21> UEPositioningGANSSEarthOrientParaPmY;

typedef BitString<CONSTRAINED, 15, 15> UEPositioningGANSSEarthOrientParaPmYdot;

typedef BitString<CONSTRAINED, 31, 31> UEPositioningGANSSEarthOrientParaDeltaUT1;

typedef BitString<CONSTRAINED, 19, 19> UEPositioningGANSSEarthOrientParaDeltaUT1dot;

class UEPositioningGANSSEarthOrientPara : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	UEPositioningGANSSEarthOrientPara(): Sequence(&theInfo) {}

	void setUEPositioningGANSSEarthOrientParaTeop(const UEPositioningGANSSEarthOrientParaTeop& uEPositioningGANSSEarthOrientParaTeop) { *static_cast<UEPositioningGANSSEarthOrientParaTeop*>(items[0]) = uEPositioningGANSSEarthOrientParaTeop; }
	void setUEPositioningGANSSEarthOrientParaPmX(const UEPositioningGANSSEarthOrientParaPmX& uEPositioningGANSSEarthOrientParaPmX) { *static_cast<UEPositioningGANSSEarthOrientParaPmX*>(items[1]) = uEPositioningGANSSEarthOrientParaPmX; }
	void setUEPositioningGANSSEarthOrientParaPmXdot(const UEPositioningGANSSEarthOrientParaPmXdot& uEPositioningGANSSEarthOrientParaPmXdot) { *static_cast<UEPositioningGANSSEarthOrientParaPmXdot*>(items[2]) = uEPositioningGANSSEarthOrientParaPmXdot; }
	void setUEPositioningGANSSEarthOrientParaPmY(const UEPositioningGANSSEarthOrientParaPmY& uEPositioningGANSSEarthOrientParaPmY) { *static_cast<UEPositioningGANSSEarthOrientParaPmY*>(items[3]) = uEPositioningGANSSEarthOrientParaPmY; }
	void setUEPositioningGANSSEarthOrientParaPmYdot(const UEPositioningGANSSEarthOrientParaPmYdot& uEPositioningGANSSEarthOrientParaPmYdot) { *static_cast<UEPositioningGANSSEarthOrientParaPmYdot*>(items[4]) = uEPositioningGANSSEarthOrientParaPmYdot; }
	void setUEPositioningGANSSEarthOrientParaDeltaUT1(const UEPositioningGANSSEarthOrientParaDeltaUT1& uEPositioningGANSSEarthOrientParaDeltaUT1) { *static_cast<UEPositioningGANSSEarthOrientParaDeltaUT1*>(items[5]) = uEPositioningGANSSEarthOrientParaDeltaUT1; }
	void setUEPositioningGANSSEarthOrientParaDeltaUT1dot(const UEPositioningGANSSEarthOrientParaDeltaUT1dot& uEPositioningGANSSEarthOrientParaDeltaUT1dot) { *static_cast<UEPositioningGANSSEarthOrientParaDeltaUT1dot*>(items[6]) = uEPositioningGANSSEarthOrientParaDeltaUT1dot; }
};

class UEPositioningGANSSAssistanceDatar8 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	UEPositioningGANSSAssistanceDatar8(): Sequence(&theInfo) {}

	void setUepositioningGANSSReferenceTime(const UEPositioningGANSSReferenceTime& uepositioningGANSSReferenceTime) { *static_cast<UEPositioningGANSSReferenceTime*>(items[0]) = uepositioningGANSSReferenceTime; }
	void setUePositioningGanssReferencePosition(const ReferenceLocationGANSS& uePositioningGanssReferencePosition) { *static_cast<ReferenceLocationGANSS*>(items[1]) = uePositioningGanssReferencePosition; }
	void setUePositioningGanssIonosphericModel(const UEPositioningGANSSIonosphericModel& uePositioningGanssIonosphericModel) { *static_cast<UEPositioningGANSSIonosphericModel*>(items[2]) = uePositioningGanssIonosphericModel; }
	void setUePositioningGanssAddIonoModel(const UEPositioningGANSSAddIonoModel& uePositioningGanssAddIonoModel) { *static_cast<UEPositioningGANSSAddIonoModel*>(items[3]) = uePositioningGanssAddIonoModel; }
	void setUePositioningGanssEarthOrientationPara(const UEPositioningGANSSEarthOrientPara& uePositioningGanssEarthOrientationPara) { *static_cast<UEPositioningGANSSEarthOrientPara*>(items[4]) = uePositioningGanssEarthOrientationPara; }
	void setGanssGenericDataList(const GANSSGenericDataListr8& ganssGenericDataList) { *static_cast<GANSSGenericDataListr8*>(items[5]) = ganssGenericDataList; }
};

class UEPositioningMeasurementr8 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	UEPositioningMeasurementr8(): Sequence(&theInfo) {}

	void setUepositioningReportingQuantity(const UEPositioningReportingQuantityr8& uepositioningReportingQuantity) { *static_cast<UEPositioningReportingQuantityr8*>(items[0]) = uepositioningReportingQuantity; }
	void setMeasurementValidity(const MeasurementValidity& measurementValidity) { *static_cast<MeasurementValidity*>(items[1]) = measurementValidity; }
	void setReportCriteria(const UEPositioningReportCriteriar7& reportCriteria) { *static_cast<UEPositioningReportCriteriar7*>(items[2]) = reportCriteria; }
	void setUepositioningOTDOAAssistanceData(const UEPositioningOTDOAAssistanceDatar7& uepositioningOTDOAAssistanceData) { *static_cast<UEPositioningOTDOAAssistanceDatar7*>(items[3]) = uepositioningOTDOAAssistanceData; }
	void setUepositioningGPSAssistanceData(const UEPositioningGPSAssistanceDatar7& uepositioningGPSAssistanceData) { *static_cast<UEPositioningGPSAssistanceDatar7*>(items[4]) = uepositioningGPSAssistanceData; }
	void setUepositioningGANSSAssistanceData(const UEPositioningGANSSAssistanceDatar8& uepositioningGANSSAssistanceData) { *static_cast<UEPositioningGANSSAssistanceDatar8*>(items[5]) = uepositioningGANSSAssistanceData; }
};

class MeasurementTyper8 : public Choice {
private:
	static const void *choicesInfo[7];
public:
	enum MeasurementTyper8Choices {
		intraFrequencyMeasurement = 0,
		interFrequencyMeasurement = 1,
		interRATMeasurement = 2,
		upMeasurement = 3,
		trafficVolumeMeasurement = 4,
		qualityMeasurement = 5,
		ueInternalMeasurement = 6,
	};
	static const Info theInfo;
	MeasurementTyper8(): Choice(&theInfo) {}
};

class MeasurementCommandr8Modify : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasurementCommandr8Modify(): Sequence(&theInfo) {}

	void setMeasurementType(const MeasurementTyper8& measurementType) { *static_cast<MeasurementTyper8*>(items[0]) = measurementType; }
};

typedef Null MeasurementCommandr8Release;

class MeasurementCommandr8 : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MeasurementCommandr8Choices {
		setup = 0,
		measurementCommandr8Modify = 1,
		measurementCommandr8Release = 2,
	};
	static const Info theInfo;
	MeasurementCommandr8(): Choice(&theInfo) {}
};

class UEPositioningGPSDGPSCorrectionsr9 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UEPositioningGPSDGPSCorrectionsr9(): Sequence(&theInfo) {}

	void setGpsTOW(const GPSTOW1sec& gpsTOW) { *static_cast<GPSTOW1sec*>(items[0]) = gpsTOW; }
	void setStatusHealth(const DiffCorrectionStatus& statusHealth) { *static_cast<DiffCorrectionStatus*>(items[1]) = statusHealth; }
	void setDgpsCorrectionSatInfoList(const DGPSCorrectionSatInfoListr9& dgpsCorrectionSatInfoList) { *static_cast<DGPSCorrectionSatInfoListr9*>(items[2]) = dgpsCorrectionSatInfoList; }
};

class UEPositioningGPSAssistanceDatar9 : public Sequence {
private:
	static const void *itemsInfo[9];
	static bool itemsPres[9];
public:
	static const Info theInfo;
	UEPositioningGPSAssistanceDatar9(): Sequence(&theInfo) {}

	void setUepositioningGPSReferenceTime(const UEPositioningGPSReferenceTimer7& uepositioningGPSReferenceTime) { *static_cast<UEPositioningGPSReferenceTimer7*>(items[0]) = uepositioningGPSReferenceTime; }
	void setUepositioningGPSReferenceLocation(const ReferenceLocation& uepositioningGPSReferenceLocation) { *static_cast<ReferenceLocation*>(items[1]) = uepositioningGPSReferenceLocation; }
	void setUepositioningGPSDGPSCorrections(const UEPositioningGPSDGPSCorrectionsr9& uepositioningGPSDGPSCorrections) { *static_cast<UEPositioningGPSDGPSCorrectionsr9*>(items[2]) = uepositioningGPSDGPSCorrections; }
	void setUepositioningGPSNavigationModel(const UEPositioningGPSNavigationModel& uepositioningGPSNavigationModel) { *static_cast<UEPositioningGPSNavigationModel*>(items[3]) = uepositioningGPSNavigationModel; }
	void setUepositioningGPSIonosphericModel(const UEPositioningGPSIonosphericModel& uepositioningGPSIonosphericModel) { *static_cast<UEPositioningGPSIonosphericModel*>(items[4]) = uepositioningGPSIonosphericModel; }
	void setUepositioningGPSUTCModel(const UEPositioningGPSUTCModel& uepositioningGPSUTCModel) { *static_cast<UEPositioningGPSUTCModel*>(items[5]) = uepositioningGPSUTCModel; }
	void setUepositioningGPSAlmanac(const UEPositioningGPSAlmanac& uepositioningGPSAlmanac) { *static_cast<UEPositioningGPSAlmanac*>(items[6]) = uepositioningGPSAlmanac; }
	void setUepositioningGPSAcquisitionAssistance(const UEPositioningGPSAcquisitionAssistancer7& uepositioningGPSAcquisitionAssistance) { *static_cast<UEPositioningGPSAcquisitionAssistancer7*>(items[7]) = uepositioningGPSAcquisitionAssistance; }
	void setUepositioningGPSRealtimeIntegrity(const BadSatList& uepositioningGPSRealtimeIntegrity) { *static_cast<BadSatList*>(items[8]) = uepositioningGPSRealtimeIntegrity; }
};

class UEPositioningGANSSAssistanceDatar9 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	UEPositioningGANSSAssistanceDatar9(): Sequence(&theInfo) {}

	void setUepositioningGANSSReferenceTime(const UEPositioningGANSSReferenceTime& uepositioningGANSSReferenceTime) { *static_cast<UEPositioningGANSSReferenceTime*>(items[0]) = uepositioningGANSSReferenceTime; }
	void setUePositioningGanssReferencePosition(const ReferenceLocationGANSS& uePositioningGanssReferencePosition) { *static_cast<ReferenceLocationGANSS*>(items[1]) = uePositioningGanssReferencePosition; }
	void setUePositioningGanssIonosphericModel(const UEPositioningGANSSIonosphericModel& uePositioningGanssIonosphericModel) { *static_cast<UEPositioningGANSSIonosphericModel*>(items[2]) = uePositioningGanssIonosphericModel; }
	void setUePositioningGanssAddIonoModel(const UEPositioningGANSSAddIonoModel& uePositioningGanssAddIonoModel) { *static_cast<UEPositioningGANSSAddIonoModel*>(items[3]) = uePositioningGanssAddIonoModel; }
	void setUePositioningGanssEarthOrientationPara(const UEPositioningGANSSEarthOrientPara& uePositioningGanssEarthOrientationPara) { *static_cast<UEPositioningGANSSEarthOrientPara*>(items[4]) = uePositioningGanssEarthOrientationPara; }
	void setGanssGenericDataList(const GANSSGenericDataListr9& ganssGenericDataList) { *static_cast<GANSSGenericDataListr9*>(items[5]) = ganssGenericDataList; }
};

class UEPositioningMeasurementr9 : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	UEPositioningMeasurementr9(): Sequence(&theInfo) {}

	void setUepositioningReportingQuantity(const UEPositioningReportingQuantityr8& uepositioningReportingQuantity) { *static_cast<UEPositioningReportingQuantityr8*>(items[0]) = uepositioningReportingQuantity; }
	void setMeasurementValidity(const MeasurementValidity& measurementValidity) { *static_cast<MeasurementValidity*>(items[1]) = measurementValidity; }
	void setReportCriteria(const UEPositioningReportCriteriar7& reportCriteria) { *static_cast<UEPositioningReportCriteriar7*>(items[2]) = reportCriteria; }
	void setUepositioningOTDOAAssistanceData(const UEPositioningOTDOAAssistanceDatar7& uepositioningOTDOAAssistanceData) { *static_cast<UEPositioningOTDOAAssistanceDatar7*>(items[3]) = uepositioningOTDOAAssistanceData; }
	void setUepositioningGPSAssistanceData(const UEPositioningGPSAssistanceDatar9& uepositioningGPSAssistanceData) { *static_cast<UEPositioningGPSAssistanceDatar9*>(items[4]) = uepositioningGPSAssistanceData; }
	void setUepositioningGANSSAssistanceData(const UEPositioningGANSSAssistanceDatar9& uepositioningGANSSAssistanceData) { *static_cast<UEPositioningGANSSAssistanceDatar9*>(items[5]) = uepositioningGANSSAssistanceData; }
};

class MeasurementTyper9 : public Choice {
private:
	static const void *choicesInfo[8];
public:
	enum MeasurementTyper9Choices {
		intraFrequencyMeasurement = 0,
		interFrequencyMeasurement = 1,
		interRATMeasurement = 2,
		upMeasurement = 3,
		trafficVolumeMeasurement = 4,
		qualityMeasurement = 5,
		ueInternalMeasurement = 6,
		csgProximityDetection = 7,
	};
	static const Info theInfo;
	MeasurementTyper9(): Choice(&theInfo) {}
};

class MeasurementCommandr9Modify : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasurementCommandr9Modify(): Sequence(&theInfo) {}

	void setMeasurementType(const MeasurementTyper9& measurementType) { *static_cast<MeasurementTyper9*>(items[0]) = measurementType; }
};

typedef Null MeasurementCommandr9Release;

class MeasurementCommandr9 : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MeasurementCommandr9Choices {
		setup = 0,
		measurementCommandr9Modify = 1,
		measurementCommandr9Release = 2,
	};
	static const Info theInfo;
	MeasurementCommandr9(): Choice(&theInfo) {}
};

class MeasurementControlSysInfoUseofHCSHcsnotusedCellSelectQualityMeasureCpichRSCP : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoUseofHCSHcsnotusedCellSelectQualityMeasureCpichRSCP(): Sequence(&theInfo) {}

	void setIntraFreqMeasurementSysInfo(const IntraFreqMeasurementSysInfoRSCP& intraFreqMeasurementSysInfo) { *static_cast<IntraFreqMeasurementSysInfoRSCP*>(items[0]) = intraFreqMeasurementSysInfo; }
	void setInterFreqMeasurementSysInfo(const InterFreqMeasurementSysInfoRSCP& interFreqMeasurementSysInfo) { *static_cast<InterFreqMeasurementSysInfoRSCP*>(items[1]) = interFreqMeasurementSysInfo; }
};

class MeasurementControlSysInfoUseofHCSHcsnotusedCellSelectQualityMeasureCpichEcN0 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoUseofHCSHcsnotusedCellSelectQualityMeasureCpichEcN0(): Sequence(&theInfo) {}

	void setIntraFreqMeasurementSysInfo(const IntraFreqMeasurementSysInfoECN0& intraFreqMeasurementSysInfo) { *static_cast<IntraFreqMeasurementSysInfoECN0*>(items[0]) = intraFreqMeasurementSysInfo; }
	void setInterFreqMeasurementSysInfo(const InterFreqMeasurementSysInfoECN0& interFreqMeasurementSysInfo) { *static_cast<InterFreqMeasurementSysInfoECN0*>(items[1]) = interFreqMeasurementSysInfo; }
};

class MeasurementControlSysInfoUseofHCSHcsnotusedCellSelectQualityMeasure : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MeasurementControlSysInfoUseofHCSHcsnotusedCellSelectQualityMeasureChoices {
		measurementControlSysInfoUseofHCSHcsnotusedCellSelectQualityMeasureCpichRSCP = 0,
		measurementControlSysInfoUseofHCSHcsnotusedCellSelectQualityMeasureCpichEcN0 = 1,
	};
	static const Info theInfo;
	MeasurementControlSysInfoUseofHCSHcsnotusedCellSelectQualityMeasure(): Choice(&theInfo) {}
};

class MeasurementControlSysInfoUseofHCSHcsnotused : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoUseofHCSHcsnotused(): Sequence(&theInfo) {}

	void setMeasurementControlSysInfoUseofHCSHcsnotusedCellSelectQualityMeasure(const MeasurementControlSysInfoUseofHCSHcsnotusedCellSelectQualityMeasure& measurementControlSysInfoUseofHCSHcsnotusedCellSelectQualityMeasure) { *static_cast<MeasurementControlSysInfoUseofHCSHcsnotusedCellSelectQualityMeasure*>(items[0]) = measurementControlSysInfoUseofHCSHcsnotusedCellSelectQualityMeasure; }
	void setInterRATMeasurementSysInfo(const InterRATMeasurementSysInfoB& interRATMeasurementSysInfo) { *static_cast<InterRATMeasurementSysInfoB*>(items[1]) = interRATMeasurementSysInfo; }
};

class MeasurementControlSysInfoUseofHCSHcsusedCellSelectQualityMeasureCpichRSCP : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoUseofHCSHcsusedCellSelectQualityMeasureCpichRSCP(): Sequence(&theInfo) {}

	void setIntraFreqMeasurementSysInfo(const IntraFreqMeasurementSysInfoHCSRSCP& intraFreqMeasurementSysInfo) { *static_cast<IntraFreqMeasurementSysInfoHCSRSCP*>(items[0]) = intraFreqMeasurementSysInfo; }
	void setInterFreqMeasurementSysInfo(const InterFreqMeasurementSysInfoHCSRSCP& interFreqMeasurementSysInfo) { *static_cast<InterFreqMeasurementSysInfoHCSRSCP*>(items[1]) = interFreqMeasurementSysInfo; }
};

class MeasurementControlSysInfoUseofHCSHcsusedCellSelectQualityMeasureCpichEcN0 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoUseofHCSHcsusedCellSelectQualityMeasureCpichEcN0(): Sequence(&theInfo) {}

	void setIntraFreqMeasurementSysInfo(const IntraFreqMeasurementSysInfoHCSECN0& intraFreqMeasurementSysInfo) { *static_cast<IntraFreqMeasurementSysInfoHCSECN0*>(items[0]) = intraFreqMeasurementSysInfo; }
	void setInterFreqMeasurementSysInfo(const InterFreqMeasurementSysInfoHCSECN0& interFreqMeasurementSysInfo) { *static_cast<InterFreqMeasurementSysInfoHCSECN0*>(items[1]) = interFreqMeasurementSysInfo; }
};

class MeasurementControlSysInfoUseofHCSHcsusedCellSelectQualityMeasure : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MeasurementControlSysInfoUseofHCSHcsusedCellSelectQualityMeasureChoices {
		measurementControlSysInfoUseofHCSHcsusedCellSelectQualityMeasureCpichRSCP = 0,
		measurementControlSysInfoUseofHCSHcsusedCellSelectQualityMeasureCpichEcN0 = 1,
	};
	static const Info theInfo;
	MeasurementControlSysInfoUseofHCSHcsusedCellSelectQualityMeasure(): Choice(&theInfo) {}
};

class MeasurementControlSysInfoUseofHCSHcsused : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoUseofHCSHcsused(): Sequence(&theInfo) {}

	void setMeasurementControlSysInfoUseofHCSHcsusedCellSelectQualityMeasure(const MeasurementControlSysInfoUseofHCSHcsusedCellSelectQualityMeasure& measurementControlSysInfoUseofHCSHcsusedCellSelectQualityMeasure) { *static_cast<MeasurementControlSysInfoUseofHCSHcsusedCellSelectQualityMeasure*>(items[0]) = measurementControlSysInfoUseofHCSHcsusedCellSelectQualityMeasure; }
	void setInterRATMeasurementSysInfo(const InterRATMeasurementSysInfo& interRATMeasurementSysInfo) { *static_cast<InterRATMeasurementSysInfo*>(items[1]) = interRATMeasurementSysInfo; }
};

class MeasurementControlSysInfoUseofHCS : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MeasurementControlSysInfoUseofHCSChoices {
		measurementControlSysInfoUseofHCSHcsnotused = 0,
		measurementControlSysInfoUseofHCSHcsused = 1,
	};
	static const Info theInfo;
	MeasurementControlSysInfoUseofHCS(): Choice(&theInfo) {}
};

class TrafficVolumeReportCriteriaSysInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum TrafficVolumeReportCriteriaSysInfoChoices {
		trafficVolumeReportingCriteria = 0,
		periodicalReportingCriteria = 1,
	};
	static const Info theInfo;
	TrafficVolumeReportCriteriaSysInfo(): Choice(&theInfo) {}
};

class TrafficVolumeMeasSysInfo : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	TrafficVolumeMeasSysInfo(): Sequence(&theInfo) {}

	void setTrafficVolumeMeasurementID(const MeasurementIdentity& trafficVolumeMeasurementID) { *static_cast<MeasurementIdentity*>(items[0]) = trafficVolumeMeasurementID; }
	void setTrafficVolumeMeasurementObjectList(const TrafficVolumeMeasurementObjectList& trafficVolumeMeasurementObjectList) { *static_cast<TrafficVolumeMeasurementObjectList*>(items[1]) = trafficVolumeMeasurementObjectList; }
	void setTrafficVolumeMeasQuantity(const TrafficVolumeMeasQuantity& trafficVolumeMeasQuantity) { *static_cast<TrafficVolumeMeasQuantity*>(items[2]) = trafficVolumeMeasQuantity; }
	void setTrafficVolumeReportingQuantity(const TrafficVolumeReportingQuantity& trafficVolumeReportingQuantity) { *static_cast<TrafficVolumeReportingQuantity*>(items[3]) = trafficVolumeReportingQuantity; }
	void setDummy(const TrafficVolumeReportingCriteria& dummy) { *static_cast<TrafficVolumeReportingCriteria*>(items[4]) = dummy; }
	void setMeasurementValidity(const MeasurementValidity& measurementValidity) { *static_cast<MeasurementValidity*>(items[5]) = measurementValidity; }
	void setMeasurementReportingMode(const MeasurementReportingMode& measurementReportingMode) { *static_cast<MeasurementReportingMode*>(items[6]) = measurementReportingMode; }
	void setReportCriteriaSysInf(const TrafficVolumeReportCriteriaSysInfo& reportCriteriaSysInf) { *static_cast<TrafficVolumeReportCriteriaSysInfo*>(items[7]) = reportCriteriaSysInf; }
};

class UEInternalMeasurementSysInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEInternalMeasurementSysInfo(): Sequence(&theInfo) {}

	void setUeInternalMeasurementID(const MeasurementIdentity& ueInternalMeasurementID) { *static_cast<MeasurementIdentity*>(items[0]) = ueInternalMeasurementID; }
	void setUeInternalMeasQuantity(const UEInternalMeasQuantity& ueInternalMeasQuantity) { *static_cast<UEInternalMeasQuantity*>(items[1]) = ueInternalMeasQuantity; }
};

class MeasurementControlSysInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MeasurementControlSysInfo(): Sequence(&theInfo) {}

	void setMeasurementControlSysInfoUseofHCS(const MeasurementControlSysInfoUseofHCS& measurementControlSysInfoUseofHCS) { *static_cast<MeasurementControlSysInfoUseofHCS*>(items[0]) = measurementControlSysInfoUseofHCS; }
	void setTrafficVolumeMeasSysInfo(const TrafficVolumeMeasSysInfo& trafficVolumeMeasSysInfo) { *static_cast<TrafficVolumeMeasSysInfo*>(items[1]) = trafficVolumeMeasSysInfo; }
	void setDummy(const UEInternalMeasurementSysInfo& dummy) { *static_cast<UEInternalMeasurementSysInfo*>(items[2]) = dummy; }
};

class MeasurementControlSysInfoExtensionUseofHCSHcsnotusedCellSelectQualityMeasureCpichRSCP : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoExtensionUseofHCSHcsnotusedCellSelectQualityMeasureCpichRSCP(): Sequence(&theInfo) {}

	void setNewIntraFreqCellList(const NewIntraFreqCellSIListRSCP& newIntraFreqCellList) { *static_cast<NewIntraFreqCellSIListRSCP*>(items[0]) = newIntraFreqCellList; }
	void setNewInterFreqCellList(const NewInterFreqCellSIListRSCP& newInterFreqCellList) { *static_cast<NewInterFreqCellSIListRSCP*>(items[1]) = newInterFreqCellList; }
};

class MeasurementControlSysInfoExtensionUseofHCSHcsnotusedCellSelectQualityMeasureCpichEcN0 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoExtensionUseofHCSHcsnotusedCellSelectQualityMeasureCpichEcN0(): Sequence(&theInfo) {}

	void setNewIntraFreqCellList(const NewIntraFreqCellSIListECN0& newIntraFreqCellList) { *static_cast<NewIntraFreqCellSIListECN0*>(items[0]) = newIntraFreqCellList; }
	void setNewInterFreqCellList(const NewInterFreqCellSIListECN0& newInterFreqCellList) { *static_cast<NewInterFreqCellSIListECN0*>(items[1]) = newInterFreqCellList; }
};

class MeasurementControlSysInfoExtensionUseofHCSHcsnotusedCellSelectQualityMeasure : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MeasurementControlSysInfoExtensionUseofHCSHcsnotusedCellSelectQualityMeasureChoices {
		measurementControlSysInfoExtensionUseofHCSHcsnotusedCellSelectQualityMeasureCpichRSCP = 0,
		measurementControlSysInfoExtensionUseofHCSHcsnotusedCellSelectQualityMeasureCpichEcN0 = 1,
	};
	static const Info theInfo;
	MeasurementControlSysInfoExtensionUseofHCSHcsnotusedCellSelectQualityMeasure(): Choice(&theInfo) {}
};

class MeasurementControlSysInfoExtensionUseofHCSHcsnotused : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoExtensionUseofHCSHcsnotused(): Sequence(&theInfo) {}

	void setMeasurementControlSysInfoExtensionUseofHCSHcsnotusedCellSelectQualityMeasure(const MeasurementControlSysInfoExtensionUseofHCSHcsnotusedCellSelectQualityMeasure& measurementControlSysInfoExtensionUseofHCSHcsnotusedCellSelectQualityMeasure) { *static_cast<MeasurementControlSysInfoExtensionUseofHCSHcsnotusedCellSelectQualityMeasure*>(items[0]) = measurementControlSysInfoExtensionUseofHCSHcsnotusedCellSelectQualityMeasure; }
	void setNewInterRATCellList(const NewInterRATCellList& newInterRATCellList) { *static_cast<NewInterRATCellList*>(items[1]) = newInterRATCellList; }
};

class MeasurementControlSysInfoExtensionUseofHCSHcsusedCellSelectQualityMeasureCpichRSCP : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoExtensionUseofHCSHcsusedCellSelectQualityMeasureCpichRSCP(): Sequence(&theInfo) {}

	void setNewIntraFreqCellList(const NewIntraFreqCellSIListHCSRSCP& newIntraFreqCellList) { *static_cast<NewIntraFreqCellSIListHCSRSCP*>(items[0]) = newIntraFreqCellList; }
	void setNewInterFreqCellList(const NewInterFreqCellSIListHCSRSCP& newInterFreqCellList) { *static_cast<NewInterFreqCellSIListHCSRSCP*>(items[1]) = newInterFreqCellList; }
};

class MeasurementControlSysInfoExtensionUseofHCSHcsusedCellSelectQualityMeasureCpichEcN0 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoExtensionUseofHCSHcsusedCellSelectQualityMeasureCpichEcN0(): Sequence(&theInfo) {}

	void setNewIntraFreqCellList(const NewIntraFreqCellSIListHCSECN0& newIntraFreqCellList) { *static_cast<NewIntraFreqCellSIListHCSECN0*>(items[0]) = newIntraFreqCellList; }
	void setNewInterFreqCellList(const NewInterFreqCellSIListHCSECN0& newInterFreqCellList) { *static_cast<NewInterFreqCellSIListHCSECN0*>(items[1]) = newInterFreqCellList; }
};

class MeasurementControlSysInfoExtensionUseofHCSHcsusedCellSelectQualityMeasure : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MeasurementControlSysInfoExtensionUseofHCSHcsusedCellSelectQualityMeasureChoices {
		measurementControlSysInfoExtensionUseofHCSHcsusedCellSelectQualityMeasureCpichRSCP = 0,
		measurementControlSysInfoExtensionUseofHCSHcsusedCellSelectQualityMeasureCpichEcN0 = 1,
	};
	static const Info theInfo;
	MeasurementControlSysInfoExtensionUseofHCSHcsusedCellSelectQualityMeasure(): Choice(&theInfo) {}
};

class MeasurementControlSysInfoExtensionUseofHCSHcsused : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoExtensionUseofHCSHcsused(): Sequence(&theInfo) {}

	void setMeasurementControlSysInfoExtensionUseofHCSHcsusedCellSelectQualityMeasure(const MeasurementControlSysInfoExtensionUseofHCSHcsusedCellSelectQualityMeasure& measurementControlSysInfoExtensionUseofHCSHcsusedCellSelectQualityMeasure) { *static_cast<MeasurementControlSysInfoExtensionUseofHCSHcsusedCellSelectQualityMeasure*>(items[0]) = measurementControlSysInfoExtensionUseofHCSHcsusedCellSelectQualityMeasure; }
	void setNewInterRATCellList(const NewInterRATCellList& newInterRATCellList) { *static_cast<NewInterRATCellList*>(items[1]) = newInterRATCellList; }
};

class MeasurementControlSysInfoExtensionUseofHCS : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MeasurementControlSysInfoExtensionUseofHCSChoices {
		measurementControlSysInfoExtensionUseofHCSHcsnotused = 0,
		measurementControlSysInfoExtensionUseofHCSHcsused = 1,
	};
	static const Info theInfo;
	MeasurementControlSysInfoExtensionUseofHCS(): Choice(&theInfo) {}
};

class MeasurementControlSysInfoExtension : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasurementControlSysInfoExtension(): Sequence(&theInfo) {}

	void setMeasurementControlSysInfoExtensionUseofHCS(const MeasurementControlSysInfoExtensionUseofHCS& measurementControlSysInfoExtensionUseofHCS) { *static_cast<MeasurementControlSysInfoExtensionUseofHCS*>(items[0]) = measurementControlSysInfoExtensionUseofHCS; }
};

typedef SequenceOf<CellSelectReselectInfov590ext, CONSTRAINED, 1, maxCellMeas> MeasurementControlSysInfoExtensionAddonr5NewIntraFrequencyCellInfoListAddonr5;

typedef SequenceOf<CellSelectReselectInfov590ext, CONSTRAINED, 1, maxCellMeas> MeasurementControlSysInfoExtensionAddonr5NewInterFrequencyCellInfoListAddonr5;

typedef SequenceOf<CellSelectReselectInfov590ext, CONSTRAINED, 1, maxCellMeas> MeasurementControlSysInfoExtensionAddonr5NewInterRATCellInfoListAddonr5;

class MeasurementControlSysInfoExtensionAddonr5 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MeasurementControlSysInfoExtensionAddonr5(): Sequence(&theInfo) {}

	void setMeasurementControlSysInfoExtensionAddonr5NewIntraFrequencyCellInfoListAddonr5(const MeasurementControlSysInfoExtensionAddonr5NewIntraFrequencyCellInfoListAddonr5& measurementControlSysInfoExtensionAddonr5NewIntraFrequencyCellInfoListAddonr5) { *static_cast<MeasurementControlSysInfoExtensionAddonr5NewIntraFrequencyCellInfoListAddonr5*>(items[0]) = measurementControlSysInfoExtensionAddonr5NewIntraFrequencyCellInfoListAddonr5; }
	void setMeasurementControlSysInfoExtensionAddonr5NewInterFrequencyCellInfoListAddonr5(const MeasurementControlSysInfoExtensionAddonr5NewInterFrequencyCellInfoListAddonr5& measurementControlSysInfoExtensionAddonr5NewInterFrequencyCellInfoListAddonr5) { *static_cast<MeasurementControlSysInfoExtensionAddonr5NewInterFrequencyCellInfoListAddonr5*>(items[1]) = measurementControlSysInfoExtensionAddonr5NewInterFrequencyCellInfoListAddonr5; }
	void setMeasurementControlSysInfoExtensionAddonr5NewInterRATCellInfoListAddonr5(const MeasurementControlSysInfoExtensionAddonr5NewInterRATCellInfoListAddonr5& measurementControlSysInfoExtensionAddonr5NewInterRATCellInfoListAddonr5) { *static_cast<MeasurementControlSysInfoExtensionAddonr5NewInterRATCellInfoListAddonr5*>(items[2]) = measurementControlSysInfoExtensionAddonr5NewInterRATCellInfoListAddonr5; }
};

class MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsnotusedCellSelectQualityMeasureCpichRSCP : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsnotusedCellSelectQualityMeasureCpichRSCP(): Sequence(&theInfo) {}

	void setNewIntraFreqCellList(const NewIntraFreqCellSIListRSCPLCRr4& newIntraFreqCellList) { *static_cast<NewIntraFreqCellSIListRSCPLCRr4*>(items[0]) = newIntraFreqCellList; }
	void setNewInterFreqCellList(const NewInterFreqCellSIListRSCPLCRr4& newInterFreqCellList) { *static_cast<NewInterFreqCellSIListRSCPLCRr4*>(items[1]) = newInterFreqCellList; }
};

class MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsnotusedCellSelectQualityMeasureCpichEcN0 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsnotusedCellSelectQualityMeasureCpichEcN0(): Sequence(&theInfo) {}

	void setNewIntraFreqCellList(const NewIntraFreqCellSIListECN0LCRr4& newIntraFreqCellList) { *static_cast<NewIntraFreqCellSIListECN0LCRr4*>(items[0]) = newIntraFreqCellList; }
	void setNewInterFreqCellList(const NewInterFreqCellSIListECN0LCRr4& newInterFreqCellList) { *static_cast<NewInterFreqCellSIListECN0LCRr4*>(items[1]) = newInterFreqCellList; }
};

class MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsnotusedCellSelectQualityMeasure : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsnotusedCellSelectQualityMeasureChoices {
		measurementControlSysInfoExtensionLCRr4UseofHCSHcsnotusedCellSelectQualityMeasureCpichRSCP = 0,
		measurementControlSysInfoExtensionLCRr4UseofHCSHcsnotusedCellSelectQualityMeasureCpichEcN0 = 1,
	};
	static const Info theInfo;
	MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsnotusedCellSelectQualityMeasure(): Choice(&theInfo) {}
};

class MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsnotused : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsnotused(): Sequence(&theInfo) {}

	void setMeasurementControlSysInfoExtensionLCRr4UseofHCSHcsnotusedCellSelectQualityMeasure(const MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsnotusedCellSelectQualityMeasure& measurementControlSysInfoExtensionLCRr4UseofHCSHcsnotusedCellSelectQualityMeasure) { *static_cast<MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsnotusedCellSelectQualityMeasure*>(items[0]) = measurementControlSysInfoExtensionLCRr4UseofHCSHcsnotusedCellSelectQualityMeasure; }
	void setNewInterRATCellList(const NewInterRATCellList& newInterRATCellList) { *static_cast<NewInterRATCellList*>(items[1]) = newInterRATCellList; }
};

class MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsusedCellSelectQualityMeasureCpichRSCP : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsusedCellSelectQualityMeasureCpichRSCP(): Sequence(&theInfo) {}

	void setNewIntraFreqCellList(const NewIntraFreqCellSIListHCSRSCPLCRr4& newIntraFreqCellList) { *static_cast<NewIntraFreqCellSIListHCSRSCPLCRr4*>(items[0]) = newIntraFreqCellList; }
	void setNewInterFreqCellList(const NewInterFreqCellSIListHCSRSCPLCRr4& newInterFreqCellList) { *static_cast<NewInterFreqCellSIListHCSRSCPLCRr4*>(items[1]) = newInterFreqCellList; }
};

class MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsusedCellSelectQualityMeasureCpichEcN0 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsusedCellSelectQualityMeasureCpichEcN0(): Sequence(&theInfo) {}

	void setNewIntraFreqCellList(const NewIntraFreqCellSIListHCSECN0LCRr4& newIntraFreqCellList) { *static_cast<NewIntraFreqCellSIListHCSECN0LCRr4*>(items[0]) = newIntraFreqCellList; }
	void setNewInterFreqCellList(const NewInterFreqCellSIListHCSECN0LCRr4& newInterFreqCellList) { *static_cast<NewInterFreqCellSIListHCSECN0LCRr4*>(items[1]) = newInterFreqCellList; }
};

class MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsusedCellSelectQualityMeasure : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsusedCellSelectQualityMeasureChoices {
		measurementControlSysInfoExtensionLCRr4UseofHCSHcsusedCellSelectQualityMeasureCpichRSCP = 0,
		measurementControlSysInfoExtensionLCRr4UseofHCSHcsusedCellSelectQualityMeasureCpichEcN0 = 1,
	};
	static const Info theInfo;
	MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsusedCellSelectQualityMeasure(): Choice(&theInfo) {}
};

class MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsused : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsused(): Sequence(&theInfo) {}

	void setMeasurementControlSysInfoExtensionLCRr4UseofHCSHcsusedCellSelectQualityMeasure(const MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsusedCellSelectQualityMeasure& measurementControlSysInfoExtensionLCRr4UseofHCSHcsusedCellSelectQualityMeasure) { *static_cast<MeasurementControlSysInfoExtensionLCRr4UseofHCSHcsusedCellSelectQualityMeasure*>(items[0]) = measurementControlSysInfoExtensionLCRr4UseofHCSHcsusedCellSelectQualityMeasure; }
	void setNewInterRATCellList(const NewInterRATCellList& newInterRATCellList) { *static_cast<NewInterRATCellList*>(items[1]) = newInterRATCellList; }
};

class MeasurementControlSysInfoExtensionLCRr4UseofHCS : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MeasurementControlSysInfoExtensionLCRr4UseofHCSChoices {
		measurementControlSysInfoExtensionLCRr4UseofHCSHcsnotused = 0,
		measurementControlSysInfoExtensionLCRr4UseofHCSHcsused = 1,
	};
	static const Info theInfo;
	MeasurementControlSysInfoExtensionLCRr4UseofHCS(): Choice(&theInfo) {}
};

class MeasurementControlSysInfoExtensionLCRr4 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasurementControlSysInfoExtensionLCRr4(): Sequence(&theInfo) {}

	void setMeasurementControlSysInfoExtensionLCRr4UseofHCS(const MeasurementControlSysInfoExtensionLCRr4UseofHCS& measurementControlSysInfoExtensionLCRr4UseofHCS) { *static_cast<MeasurementControlSysInfoExtensionLCRr4UseofHCS*>(items[0]) = measurementControlSysInfoExtensionLCRr4UseofHCS; }
};

class MeasurementControlSysInfoLCRr4extUseofHCSHcsnotusedCellSelectQualityMeasureCpichRSCP : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoLCRr4extUseofHCSHcsnotusedCellSelectQualityMeasureCpichRSCP(): Sequence(&theInfo) {}

	void setIntraFreqMeasurementSysInfo(const IntraFreqMeasurementSysInfoRSCPLCRr4& intraFreqMeasurementSysInfo) { *static_cast<IntraFreqMeasurementSysInfoRSCPLCRr4*>(items[0]) = intraFreqMeasurementSysInfo; }
	void setInterFreqMeasurementSysInfo(const InterFreqMeasurementSysInfoRSCPLCRr4& interFreqMeasurementSysInfo) { *static_cast<InterFreqMeasurementSysInfoRSCPLCRr4*>(items[1]) = interFreqMeasurementSysInfo; }
};

class MeasurementControlSysInfoLCRr4extUseofHCSHcsnotusedCellSelectQualityMeasureCpichEcN0 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoLCRr4extUseofHCSHcsnotusedCellSelectQualityMeasureCpichEcN0(): Sequence(&theInfo) {}

	void setIntraFreqMeasurementSysInfo(const IntraFreqMeasurementSysInfoECN0LCRr4& intraFreqMeasurementSysInfo) { *static_cast<IntraFreqMeasurementSysInfoECN0LCRr4*>(items[0]) = intraFreqMeasurementSysInfo; }
	void setInterFreqMeasurementSysInfo(const InterFreqMeasurementSysInfoECN0LCRr4& interFreqMeasurementSysInfo) { *static_cast<InterFreqMeasurementSysInfoECN0LCRr4*>(items[1]) = interFreqMeasurementSysInfo; }
};

class MeasurementControlSysInfoLCRr4extUseofHCSHcsnotusedCellSelectQualityMeasure : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MeasurementControlSysInfoLCRr4extUseofHCSHcsnotusedCellSelectQualityMeasureChoices {
		measurementControlSysInfoLCRr4extUseofHCSHcsnotusedCellSelectQualityMeasureCpichRSCP = 0,
		measurementControlSysInfoLCRr4extUseofHCSHcsnotusedCellSelectQualityMeasureCpichEcN0 = 1,
	};
	static const Info theInfo;
	MeasurementControlSysInfoLCRr4extUseofHCSHcsnotusedCellSelectQualityMeasure(): Choice(&theInfo) {}
};

class MeasurementControlSysInfoLCRr4extUseofHCSHcsnotused : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasurementControlSysInfoLCRr4extUseofHCSHcsnotused(): Sequence(&theInfo) {}

	void setMeasurementControlSysInfoLCRr4extUseofHCSHcsnotusedCellSelectQualityMeasure(const MeasurementControlSysInfoLCRr4extUseofHCSHcsnotusedCellSelectQualityMeasure& measurementControlSysInfoLCRr4extUseofHCSHcsnotusedCellSelectQualityMeasure) { *static_cast<MeasurementControlSysInfoLCRr4extUseofHCSHcsnotusedCellSelectQualityMeasure*>(items[0]) = measurementControlSysInfoLCRr4extUseofHCSHcsnotusedCellSelectQualityMeasure; }
};

class MeasurementControlSysInfoLCRr4extUseofHCSHcsusedCellSelectQualityMeasureCpichRSCP : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoLCRr4extUseofHCSHcsusedCellSelectQualityMeasureCpichRSCP(): Sequence(&theInfo) {}

	void setIntraFreqMeasurementSysInfo(const IntraFreqMeasurementSysInfoHCSRSCPLCRr4& intraFreqMeasurementSysInfo) { *static_cast<IntraFreqMeasurementSysInfoHCSRSCPLCRr4*>(items[0]) = intraFreqMeasurementSysInfo; }
	void setInterFreqMeasurementSysInfo(const InterFreqMeasurementSysInfoHCSRSCPLCRr4& interFreqMeasurementSysInfo) { *static_cast<InterFreqMeasurementSysInfoHCSRSCPLCRr4*>(items[1]) = interFreqMeasurementSysInfo; }
};

class MeasurementControlSysInfoLCRr4extUseofHCSHcsusedCellSelectQualityMeasureCpichEcN0 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MeasurementControlSysInfoLCRr4extUseofHCSHcsusedCellSelectQualityMeasureCpichEcN0(): Sequence(&theInfo) {}

	void setIntraFreqMeasurementSysInfo(const IntraFreqMeasurementSysInfoHCSECN0LCRr4& intraFreqMeasurementSysInfo) { *static_cast<IntraFreqMeasurementSysInfoHCSECN0LCRr4*>(items[0]) = intraFreqMeasurementSysInfo; }
	void setInterFreqMeasurementSysInfo(const InterFreqMeasurementSysInfoHCSECN0LCRr4& interFreqMeasurementSysInfo) { *static_cast<InterFreqMeasurementSysInfoHCSECN0LCRr4*>(items[1]) = interFreqMeasurementSysInfo; }
};

class MeasurementControlSysInfoLCRr4extUseofHCSHcsusedCellSelectQualityMeasure : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MeasurementControlSysInfoLCRr4extUseofHCSHcsusedCellSelectQualityMeasureChoices {
		measurementControlSysInfoLCRr4extUseofHCSHcsusedCellSelectQualityMeasureCpichRSCP = 0,
		measurementControlSysInfoLCRr4extUseofHCSHcsusedCellSelectQualityMeasureCpichEcN0 = 1,
	};
	static const Info theInfo;
	MeasurementControlSysInfoLCRr4extUseofHCSHcsusedCellSelectQualityMeasure(): Choice(&theInfo) {}
};

class MeasurementControlSysInfoLCRr4extUseofHCSHcsused : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasurementControlSysInfoLCRr4extUseofHCSHcsused(): Sequence(&theInfo) {}

	void setMeasurementControlSysInfoLCRr4extUseofHCSHcsusedCellSelectQualityMeasure(const MeasurementControlSysInfoLCRr4extUseofHCSHcsusedCellSelectQualityMeasure& measurementControlSysInfoLCRr4extUseofHCSHcsusedCellSelectQualityMeasure) { *static_cast<MeasurementControlSysInfoLCRr4extUseofHCSHcsusedCellSelectQualityMeasure*>(items[0]) = measurementControlSysInfoLCRr4extUseofHCSHcsusedCellSelectQualityMeasure; }
};

class MeasurementControlSysInfoLCRr4extUseofHCS : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MeasurementControlSysInfoLCRr4extUseofHCSChoices {
		measurementControlSysInfoLCRr4extUseofHCSHcsnotused = 0,
		measurementControlSysInfoLCRr4extUseofHCSHcsused = 1,
	};
	static const Info theInfo;
	MeasurementControlSysInfoLCRr4extUseofHCS(): Choice(&theInfo) {}
};

class MeasurementControlSysInfoLCRr4ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MeasurementControlSysInfoLCRr4ext(): Sequence(&theInfo) {}

	void setMeasurementControlSysInfoLCRr4extUseofHCS(const MeasurementControlSysInfoLCRr4extUseofHCS& measurementControlSysInfoLCRr4extUseofHCS) { *static_cast<MeasurementControlSysInfoLCRr4extUseofHCS*>(items[0]) = measurementControlSysInfoLCRr4extUseofHCS; }
};

typedef Integer<CONSTRAINED, 17, 32> MeasurementIdentityExt;

class NeighbourTDDr7 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	NeighbourTDDr7(): Sequence(&theInfo) {}

	void setUarfcn(const UARFCN& uarfcn) { *static_cast<UARFCN*>(items[0]) = uarfcn; }
};

typedef SequenceOf<NeighbourTDDr7, CONSTRAINED, 1, maxCellMeas> NeighbourListTDDr7;

typedef Boolean NewInterFreqCellv7b0extIntraSecondaryFreqIndicator;

class NewInterFreqCellv7b0ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	NewInterFreqCellv7b0ext(): Sequence(&theInfo) {}

	void setNewInterFreqCellv7b0extIntraSecondaryFreqIndicator(const NewInterFreqCellv7b0extIntraSecondaryFreqIndicator& newInterFreqCellv7b0extIntraSecondaryFreqIndicator) { *static_cast<NewInterFreqCellv7b0extIntraSecondaryFreqIndicator*>(items[0]) = newInterFreqCellv7b0extIntraSecondaryFreqIndicator; }
};

class NewInterFreqCellLCRv8a0ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	NewInterFreqCellLCRv8a0ext(): Sequence(&theInfo) {}

	void setCellInfoLCRr8(const CellInfoLCRr8ext& cellInfoLCRr8) { *static_cast<CellInfoLCRr8ext*>(items[0]) = cellInfoLCRr8; }
};

typedef SequenceOf<NewInterFreqCellv7b0ext, CONSTRAINED, 1, maxCellMeas> NewInterFreqCellListv7b0ext;

typedef SequenceOf<NewInterFreqCellLCRv8a0ext, CONSTRAINED, 1, maxCellMeas> NewInterFreqCellListLCRv8a0ext;

class NewIntraFreqCellLCRv8a0ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	NewIntraFreqCellLCRv8a0ext(): Sequence(&theInfo) {}

	void setCellInfoLCRr8(const CellInfoLCRr8ext& cellInfoLCRr8) { *static_cast<CellInfoLCRr8ext*>(items[0]) = cellInfoLCRr8; }
};

typedef SequenceOf<NewIntraFreqCellLCRv8a0ext, CONSTRAINED, 1, maxCellMeas> NewIntraFreqCellListLCRv8a0ext;

class PLMNsOfIntraFreqCellsList : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	PLMNsOfIntraFreqCellsList(): Sequence(&theInfo) {}

};

class PLMNsOfInterFreqCellsList : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	PLMNsOfInterFreqCellsList(): Sequence(&theInfo) {}

};

class PLMNsOfInterRATCellsList : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	PLMNsOfInterRATCellsList(): Sequence(&theInfo) {}

};

class PLMNIdentitiesOfNeighbourCells : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	PLMNIdentitiesOfNeighbourCells(): Sequence(&theInfo) {}

	void setPlmnsOfIntraFreqCellsList(const PLMNsOfIntraFreqCellsList& plmnsOfIntraFreqCellsList) { *static_cast<PLMNsOfIntraFreqCellsList*>(items[0]) = plmnsOfIntraFreqCellsList; }
	void setPlmnsOfInterFreqCellsList(const PLMNsOfInterFreqCellsList& plmnsOfInterFreqCellsList) { *static_cast<PLMNsOfInterFreqCellsList*>(items[1]) = plmnsOfInterFreqCellsList; }
	void setPlmnsOfInterRATCellsList(const PLMNsOfInterRATCellsList& plmnsOfInterRATCellsList) { *static_cast<PLMNsOfInterRATCellsList*>(items[2]) = plmnsOfInterRATCellsList; }
};

class MultiplePLMNsOfIntraFreqCellsList : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	MultiplePLMNsOfIntraFreqCellsList(): Sequence(&theInfo) {}

};

class MultiplePLMNsOfInterFreqCellsList : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	MultiplePLMNsOfInterFreqCellsList(): Sequence(&theInfo) {}

};

class PLMNIdentitiesOfNeighbourCellsv860ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	PLMNIdentitiesOfNeighbourCellsv860ext(): Sequence(&theInfo) {}

	void setMultipleplmnsOfIntraFreqCellsList(const MultiplePLMNsOfIntraFreqCellsList& multipleplmnsOfIntraFreqCellsList) { *static_cast<MultiplePLMNsOfIntraFreqCellsList*>(items[0]) = multipleplmnsOfIntraFreqCellsList; }
	void setMultipleplmnsOfInterFreqCellsList(const MultiplePLMNsOfInterFreqCellsList& multipleplmnsOfInterFreqCellsList) { *static_cast<MultiplePLMNsOfInterFreqCellsList*>(items[1]) = multipleplmnsOfInterFreqCellsList; }
};

typedef Integer<CONSTRAINED, 1, 16> QQualMinOffset;

typedef Integer<CONSTRAINED, 1, 8> QRxlevMinOffset;

class TimeslotWithISCP : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	TimeslotWithISCP(): Sequence(&theInfo) {}

	void setTimeslot(const TimeslotNumber& timeslot) { *static_cast<TimeslotNumber*>(items[0]) = timeslot; }
	void setTimeslotISCP(const TimeslotISCP& timeslotISCP) { *static_cast<TimeslotISCP*>(items[1]) = timeslotISCP; }
};

typedef SequenceOf<TimeslotWithISCP, CONSTRAINED, 1, maxTS> TimeslotListWithISCP;

typedef BitString<CONSTRAINED, 1, 1> UEPositioningCipherParametersCipheringKeyFlag;

typedef Integer<CONSTRAINED, 0, 65535> UEPositioningCipherParametersCipheringSerialNumber;

class UEPositioningCipherParameters : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningCipherParameters(): Sequence(&theInfo) {}

	void setUEPositioningCipherParametersCipheringKeyFlag(const UEPositioningCipherParametersCipheringKeyFlag& uEPositioningCipherParametersCipheringKeyFlag) { *static_cast<UEPositioningCipherParametersCipheringKeyFlag*>(items[0]) = uEPositioningCipherParametersCipheringKeyFlag; }
	void setUEPositioningCipherParametersCipheringSerialNumber(const UEPositioningCipherParametersCipheringSerialNumber& uEPositioningCipherParametersCipheringSerialNumber) { *static_cast<UEPositioningCipherParametersCipheringSerialNumber*>(items[1]) = uEPositioningCipherParametersCipheringSerialNumber; }
};

class UEPositioningGANSSAssistanceDatav860ext : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UEPositioningGANSSAssistanceDatav860ext(): Sequence(&theInfo) {}

	void setUePositioningGanssAddIonoModel(const UEPositioningGANSSAddIonoModel& uePositioningGanssAddIonoModel) { *static_cast<UEPositioningGANSSAddIonoModel*>(items[0]) = uePositioningGanssAddIonoModel; }
	void setUePositioningGanssEarthOrientationPara(const UEPositioningGANSSEarthOrientPara& uePositioningGanssEarthOrientationPara) { *static_cast<UEPositioningGANSSEarthOrientPara*>(items[1]) = uePositioningGanssEarthOrientationPara; }
	void setGanssGenericDataList(const GANSSGenericDataListv860ext& ganssGenericDataList) { *static_cast<GANSSGenericDataListv860ext*>(items[2]) = ganssGenericDataList; }
};

class UEPositioningGANSSAssistanceDatav920ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningGANSSAssistanceDatav920ext(): Sequence(&theInfo) {}

	void setGanssGenericDataList(const GANSSGenericDataListv920ext& ganssGenericDataList) { *static_cast<GANSSGenericDataListv920ext*>(items[0]) = ganssGenericDataList; }
};

class UEPositioningGANSSData : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	UEPositioningGANSSData(): Sequence(&theInfo) {}

	void setGanssDataCipheringInfo(const UEPositioningCipherParameters& ganssDataCipheringInfo) { *static_cast<UEPositioningCipherParameters*>(items[0]) = ganssDataCipheringInfo; }
	void setGanssDecipheringKeys(const GANSSDecipheringKeys& ganssDecipheringKeys) { *static_cast<GANSSDecipheringKeys*>(items[1]) = ganssDecipheringKeys; }
	void setUePositioningGanssReferenceTime(const UEPositioningGANSSReferenceTime& uePositioningGanssReferenceTime) { *static_cast<UEPositioningGANSSReferenceTime*>(items[2]) = uePositioningGanssReferenceTime; }
	void setUePositioningGanssReferencePosition(const ReferenceLocationGANSS& uePositioningGanssReferencePosition) { *static_cast<ReferenceLocationGANSS*>(items[3]) = uePositioningGanssReferencePosition; }
	void setUePositioningGanssIonosphericModel(const UEPositioningGANSSIonosphericModel& uePositioningGanssIonosphericModel) { *static_cast<UEPositioningGANSSIonosphericModel*>(items[4]) = uePositioningGanssIonosphericModel; }
	void setGanssGenericDataList(const GANSSGenericDataList& ganssGenericDataList) { *static_cast<GANSSGenericDataList*>(items[5]) = ganssGenericDataList; }
};

typedef SequenceOf<UEPositioningGANSSTimeModel, CONSTRAINED, 1, maxGANSS_1> UEPositioningGANSSTimeModels;

class UEPositioningGPSAcquisitionAssistancev770ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningGPSAcquisitionAssistancev770ext(): Sequence(&theInfo) {}

	void setUePositioningGPSReferenceTimeUncertainty(const UEPositioningGPSReferenceTimeUncertainty& uePositioningGPSReferenceTimeUncertainty) { *static_cast<UEPositioningGPSReferenceTimeUncertainty*>(items[0]) = uePositioningGPSReferenceTimeUncertainty; }
};

class UEPositioningGPSReferenceTimev770ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningGPSReferenceTimev770ext(): Sequence(&theInfo) {}

	void setUePositioningGPSReferenceTimeUncertainty(const UEPositioningGPSReferenceTimeUncertainty& uePositioningGPSReferenceTimeUncertainty) { *static_cast<UEPositioningGPSReferenceTimeUncertainty*>(items[0]) = uePositioningGPSReferenceTimeUncertainty; }
};

class UEPositioningGPSAssistanceDatav770ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningGPSAssistanceDatav770ext(): Sequence(&theInfo) {}

	void setUepositioningGPSReferenceTime(const UEPositioningGPSReferenceTimev770ext& uepositioningGPSReferenceTime) { *static_cast<UEPositioningGPSReferenceTimev770ext*>(items[0]) = uepositioningGPSReferenceTime; }
	void setUepositioningGPSAcquisitionAssistance(const UEPositioningGPSAcquisitionAssistancev770ext& uepositioningGPSAcquisitionAssistance) { *static_cast<UEPositioningGPSAcquisitionAssistancev770ext*>(items[1]) = uepositioningGPSAcquisitionAssistance; }
};

class UEPositioningGPSDGPSCorrectionsv920ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningGPSDGPSCorrectionsv920ext(): Sequence(&theInfo) {}

	void setDgpsCorrectionSatInfoList(const DGPSCorrectionSatInfoListv920ext& dgpsCorrectionSatInfoList) { *static_cast<DGPSCorrectionSatInfoListv920ext*>(items[0]) = dgpsCorrectionSatInfoList; }
};

class UEPositioningGPSAssistanceDatav920ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningGPSAssistanceDatav920ext(): Sequence(&theInfo) {}

	void setUepositioningGPSDGPSCorrections(const UEPositioningGPSDGPSCorrectionsv920ext& uepositioningGPSDGPSCorrections) { *static_cast<UEPositioningGPSDGPSCorrectionsv920ext*>(items[0]) = uepositioningGPSDGPSCorrections; }
};

typedef Integer<CONSTRAINED, 0, 14> UEPositioningIPDLParametersTDDr4extIpslot;

typedef Integer<CONSTRAINED, 0, 4095> UEPositioningIPDLParametersTDDr4extIpStart;

class UEPositioningIPDLParametersTDDr4ext : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	UEPositioningIPDLParametersTDDr4ext(): Sequence(&theInfo) {}

	void setIpSpacing(const IPSpacingTDD& ipSpacing) { *static_cast<IPSpacingTDD*>(items[0]) = ipSpacing; }
	void setUEPositioningIPDLParametersTDDr4extIpslot(const UEPositioningIPDLParametersTDDr4extIpslot& uEPositioningIPDLParametersTDDr4extIpslot) { *static_cast<UEPositioningIPDLParametersTDDr4extIpslot*>(items[1]) = uEPositioningIPDLParametersTDDr4extIpslot; }
	void setUEPositioningIPDLParametersTDDr4extIpStart(const UEPositioningIPDLParametersTDDr4extIpStart& uEPositioningIPDLParametersTDDr4extIpStart) { *static_cast<UEPositioningIPDLParametersTDDr4extIpStart*>(items[2]) = uEPositioningIPDLParametersTDDr4extIpStart; }
	void setIpPCCPCG(const IPPCCPCHr4& ipPCCPCG) { *static_cast<IPPCCPCHr4*>(items[3]) = ipPCCPCG; }
	void setBurstModeParameters(const BurstModeParameters& burstModeParameters) { *static_cast<BurstModeParameters*>(items[4]) = burstModeParameters; }
};

class UEPositioningReportingQuantityv390ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningReportingQuantityv390ext(): Sequence(&theInfo) {}

	void setVerticalAccuracy(const UEPositioningAccuracy& verticalAccuracy) { *static_cast<UEPositioningAccuracy*>(items[0]) = verticalAccuracy; }
};

typedef Integer<CONSTRAINED, 0, 4095> UEPositioningOTDOAReferenceCellInfoUEBSfn;

class UEPositioningOTDOAReferenceCellInfoUEBModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfoUEBModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
};

class UEPositioningOTDOAReferenceCellInfoUEBModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfoUEBModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setCellAndChannelIdentity(const CellAndChannelIdentity& cellAndChannelIdentity) { *static_cast<CellAndChannelIdentity*>(items[0]) = cellAndChannelIdentity; }
};

class UEPositioningOTDOAReferenceCellInfoUEBModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningOTDOAReferenceCellInfoUEBModeSpecificInfoChoices {
		uEPositioningOTDOAReferenceCellInfoUEBModeSpecificInfoFdd = 0,
		uEPositioningOTDOAReferenceCellInfoUEBModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfoUEBModeSpecificInfo(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 32766> UEPositioningOTDOAReferenceCellInfoUEBRoundTripTime;

class UEPositioningOTDOAReferenceCellInfoUEB : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfoUEB(): Sequence(&theInfo) {}

	void setUEPositioningOTDOAReferenceCellInfoUEBSfn(const UEPositioningOTDOAReferenceCellInfoUEBSfn& uEPositioningOTDOAReferenceCellInfoUEBSfn) { *static_cast<UEPositioningOTDOAReferenceCellInfoUEBSfn*>(items[0]) = uEPositioningOTDOAReferenceCellInfoUEBSfn; }
	void setUEPositioningOTDOAReferenceCellInfoUEBModeSpecificInfo(const UEPositioningOTDOAReferenceCellInfoUEBModeSpecificInfo& uEPositioningOTDOAReferenceCellInfoUEBModeSpecificInfo) { *static_cast<UEPositioningOTDOAReferenceCellInfoUEBModeSpecificInfo*>(items[1]) = uEPositioningOTDOAReferenceCellInfoUEBModeSpecificInfo; }
	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[2]) = frequencyInfo; }
	void setCellPosition(const ReferenceCellPosition& cellPosition) { *static_cast<ReferenceCellPosition*>(items[3]) = cellPosition; }
	void setUEPositioningOTDOAReferenceCellInfoUEBRoundTripTime(const UEPositioningOTDOAReferenceCellInfoUEBRoundTripTime& uEPositioningOTDOAReferenceCellInfoUEBRoundTripTime) { *static_cast<UEPositioningOTDOAReferenceCellInfoUEBRoundTripTime*>(items[4]) = uEPositioningOTDOAReferenceCellInfoUEBRoundTripTime; }
	void setUepositioningIPDLParemeters(const UEPositioningIPDLParameters& uepositioningIPDLParemeters) { *static_cast<UEPositioningIPDLParameters*>(items[5]) = uepositioningIPDLParemeters; }
};

class UEPositioningOTDOANeighbourCellInfoUEBModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfoUEBModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setPrimaryCPICHInfo(const PrimaryCPICHInfo& primaryCPICHInfo) { *static_cast<PrimaryCPICHInfo*>(items[0]) = primaryCPICHInfo; }
};

class UEPositioningOTDOANeighbourCellInfoUEBModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfoUEBModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setCellAndChannelIdentity(const CellAndChannelIdentity& cellAndChannelIdentity) { *static_cast<CellAndChannelIdentity*>(items[0]) = cellAndChannelIdentity; }
};

class UEPositioningOTDOANeighbourCellInfoUEBModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum UEPositioningOTDOANeighbourCellInfoUEBModeSpecificInfoChoices {
		uEPositioningOTDOANeighbourCellInfoUEBModeSpecificInfoFdd = 0,
		uEPositioningOTDOANeighbourCellInfoUEBModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfoUEBModeSpecificInfo(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, -20000, 20000> UEPositioningOTDOANeighbourCellInfoUEBRelativeNorth;

typedef Integer<CONSTRAINED, -20000, 20000> UEPositioningOTDOANeighbourCellInfoUEBRelativeEast;

typedef Integer<CONSTRAINED, -4000, 4000> UEPositioningOTDOANeighbourCellInfoUEBRelativeAltitude;

typedef Integer<CONSTRAINED, 0, 32766> UEPositioningOTDOANeighbourCellInfoUEBRoundTripTime;

class UEPositioningOTDOANeighbourCellInfoUEB : public Sequence {
private:
	static const void *itemsInfo[11];
	static bool itemsPres[11];
public:
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfoUEB(): Sequence(&theInfo) {}

	void setUEPositioningOTDOANeighbourCellInfoUEBModeSpecificInfo(const UEPositioningOTDOANeighbourCellInfoUEBModeSpecificInfo& uEPositioningOTDOANeighbourCellInfoUEBModeSpecificInfo) { *static_cast<UEPositioningOTDOANeighbourCellInfoUEBModeSpecificInfo*>(items[0]) = uEPositioningOTDOANeighbourCellInfoUEBModeSpecificInfo; }
	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[1]) = frequencyInfo; }
	void setUepositioningIPDLParemeters(const UEPositioningIPDLParameters& uepositioningIPDLParemeters) { *static_cast<UEPositioningIPDLParameters*>(items[2]) = uepositioningIPDLParemeters; }
	void setSfnSFNRelTimeDifference(const SFNSFNRelTimeDifference1& sfnSFNRelTimeDifference) { *static_cast<SFNSFNRelTimeDifference1*>(items[3]) = sfnSFNRelTimeDifference; }
	void setSfnSFNDrift(const SFNSFNDrift& sfnSFNDrift) { *static_cast<SFNSFNDrift*>(items[4]) = sfnSFNDrift; }
	void setSearchWindowSize(const OTDOASearchWindowSize& searchWindowSize) { *static_cast<OTDOASearchWindowSize*>(items[5]) = searchWindowSize; }
	void setUEPositioningOTDOANeighbourCellInfoUEBRelativeNorth(const UEPositioningOTDOANeighbourCellInfoUEBRelativeNorth& uEPositioningOTDOANeighbourCellInfoUEBRelativeNorth) { *static_cast<UEPositioningOTDOANeighbourCellInfoUEBRelativeNorth*>(items[6]) = uEPositioningOTDOANeighbourCellInfoUEBRelativeNorth; }
	void setUEPositioningOTDOANeighbourCellInfoUEBRelativeEast(const UEPositioningOTDOANeighbourCellInfoUEBRelativeEast& uEPositioningOTDOANeighbourCellInfoUEBRelativeEast) { *static_cast<UEPositioningOTDOANeighbourCellInfoUEBRelativeEast*>(items[7]) = uEPositioningOTDOANeighbourCellInfoUEBRelativeEast; }
	void setUEPositioningOTDOANeighbourCellInfoUEBRelativeAltitude(const UEPositioningOTDOANeighbourCellInfoUEBRelativeAltitude& uEPositioningOTDOANeighbourCellInfoUEBRelativeAltitude) { *static_cast<UEPositioningOTDOANeighbourCellInfoUEBRelativeAltitude*>(items[8]) = uEPositioningOTDOANeighbourCellInfoUEBRelativeAltitude; }
	void setFineSFNSFN(const FineSFNSFN& fineSFNSFN) { *static_cast<FineSFNSFN*>(items[9]) = fineSFNSFN; }
	void setUEPositioningOTDOANeighbourCellInfoUEBRoundTripTime(const UEPositioningOTDOANeighbourCellInfoUEBRoundTripTime& uEPositioningOTDOANeighbourCellInfoUEBRoundTripTime) { *static_cast<UEPositioningOTDOANeighbourCellInfoUEBRoundTripTime*>(items[10]) = uEPositioningOTDOANeighbourCellInfoUEBRoundTripTime; }
};

typedef SequenceOf<UEPositioningOTDOANeighbourCellInfoUEB, CONSTRAINED, 1, maxCellMeas> UEPositioningOTDOANeighbourCellListUEB;

class UEPositioningOTDOAAssistanceDataUEB : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningOTDOAAssistanceDataUEB(): Sequence(&theInfo) {}

	void setUepositioningOTDOAReferenceCellInfoUEB(const UEPositioningOTDOAReferenceCellInfoUEB& uepositioningOTDOAReferenceCellInfoUEB) { *static_cast<UEPositioningOTDOAReferenceCellInfoUEB*>(items[0]) = uepositioningOTDOAReferenceCellInfoUEB; }
	void setUepositioningOTDOANeighbourCellListUEB(const UEPositioningOTDOANeighbourCellListUEB& uepositioningOTDOANeighbourCellListUEB) { *static_cast<UEPositioningOTDOANeighbourCellListUEB*>(items[1]) = uepositioningOTDOANeighbourCellListUEB; }
};

class UEPositioningMeasurementv390ext : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UEPositioningMeasurementv390ext(): Sequence(&theInfo) {}

	void setUepositioningReportingQuantityv390ext(const UEPositioningReportingQuantityv390ext& uepositioningReportingQuantityv390ext) { *static_cast<UEPositioningReportingQuantityv390ext*>(items[0]) = uepositioningReportingQuantityv390ext; }
	void setMeasurementValidity(const MeasurementValidity& measurementValidity) { *static_cast<MeasurementValidity*>(items[1]) = measurementValidity; }
	void setUepositioningOTDOAAssistanceDataUEB(const UEPositioningOTDOAAssistanceDataUEB& uepositioningOTDOAAssistanceDataUEB) { *static_cast<UEPositioningOTDOAAssistanceDataUEB*>(items[2]) = uepositioningOTDOAAssistanceDataUEB; }
};

class UEPositioningMeasurementv920ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningMeasurementv920ext(): Sequence(&theInfo) {}

	void setUepositioningGPSAssistanceData(const UEPositioningGPSAssistanceDatav920ext& uepositioningGPSAssistanceData) { *static_cast<UEPositioningGPSAssistanceDatav920ext*>(items[0]) = uepositioningGPSAssistanceData; }
	void setUepositioningGANSSAssistanceData(const UEPositioningGANSSAssistanceDatav920ext& uepositioningGANSSAssistanceData) { *static_cast<UEPositioningGANSSAssistanceDatav920ext*>(items[1]) = uepositioningGANSSAssistanceData; }
};

typedef SequenceOf<UEPositioningIPDLParametersTDDr4ext, CONSTRAINED, 1, maxCellMeas> UEPositioningIPDLParametersTDDListr4ext;

class UEPositioningOTDOAAssistanceDatar4ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningOTDOAAssistanceDatar4ext(): Sequence(&theInfo) {}

	void setUePositioningIPDLParametersTDDr4ext(const UEPositioningIPDLParametersTDDr4ext& uePositioningIPDLParametersTDDr4ext) { *static_cast<UEPositioningIPDLParametersTDDr4ext*>(items[0]) = uePositioningIPDLParametersTDDr4ext; }
	void setUePositioningIPDLParametersTDDListr4ext(const UEPositioningIPDLParametersTDDListr4ext& uePositioningIPDLParametersTDDListr4ext) { *static_cast<UEPositioningIPDLParametersTDDListr4ext*>(items[1]) = uePositioningIPDLParametersTDDListr4ext; }
};

typedef Integer<CONSTRAINED, 0, 70274> UEPositioningOTDOAReferenceCellInfoUEBextRoundTripTimeExtension;

class UEPositioningOTDOAReferenceCellInfoUEBext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOAReferenceCellInfoUEBext(): Sequence(&theInfo) {}

	void setUEPositioningOTDOAReferenceCellInfoUEBextRoundTripTimeExtension(const UEPositioningOTDOAReferenceCellInfoUEBextRoundTripTimeExtension& uEPositioningOTDOAReferenceCellInfoUEBextRoundTripTimeExtension) { *static_cast<UEPositioningOTDOAReferenceCellInfoUEBextRoundTripTimeExtension*>(items[0]) = uEPositioningOTDOAReferenceCellInfoUEBextRoundTripTimeExtension; }
};

typedef Integer<CONSTRAINED, 0, 70274> UEPositioningOTDOANeighbourCellInfoUEBextRoundTripTimeExtension;

class UEPositioningOTDOANeighbourCellInfoUEBext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOANeighbourCellInfoUEBext(): Sequence(&theInfo) {}

	void setUEPositioningOTDOANeighbourCellInfoUEBextRoundTripTimeExtension(const UEPositioningOTDOANeighbourCellInfoUEBextRoundTripTimeExtension& uEPositioningOTDOANeighbourCellInfoUEBextRoundTripTimeExtension) { *static_cast<UEPositioningOTDOANeighbourCellInfoUEBextRoundTripTimeExtension*>(items[0]) = uEPositioningOTDOANeighbourCellInfoUEBextRoundTripTimeExtension; }
};

typedef SequenceOf<UEPositioningOTDOANeighbourCellInfoUEBext, CONSTRAINED, 1, maxCellMeas> UEPositioningOTDOANeighbourCellListUEBext;

class UEPositioningOTDOAAssistanceDataUEBext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	UEPositioningOTDOAAssistanceDataUEBext(): Sequence(&theInfo) {}

	void setUepositioningOTDOAReferenceCellInfoUEBext(const UEPositioningOTDOAReferenceCellInfoUEBext& uepositioningOTDOAReferenceCellInfoUEBext) { *static_cast<UEPositioningOTDOAReferenceCellInfoUEBext*>(items[0]) = uepositioningOTDOAReferenceCellInfoUEBext; }
	void setUepositioningOTDOANeighbourCellListUEBext(const UEPositioningOTDOANeighbourCellListUEBext& uepositioningOTDOANeighbourCellListUEBext) { *static_cast<UEPositioningOTDOANeighbourCellListUEBext*>(items[1]) = uepositioningOTDOANeighbourCellListUEBext; }
};

class UEPositioningOTDOAMeasuredResultsTDDext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UEPositioningOTDOAMeasuredResultsTDDext(): Sequence(&theInfo) {}

	void setNeighbourList(const NeighbourListTDDr7& neighbourList) { *static_cast<NeighbourListTDDr7*>(items[0]) = neighbourList; }
};

typedef Integer<CONSTRAINED, 0, maxPrio_1> UTRANFDDFrequencyPriority;

typedef Integer<CONSTRAINED, 0, 31> UTRANFDDFrequencyThreshXhigh;

typedef Integer<CONSTRAINED, 0, 31> UTRANFDDFrequencyThreshXlow;

typedef Integer<CONSTRAINED, -24, 0> UTRANFDDFrequencyQQualMinFDD;

typedef Integer<CONSTRAINED, -60, -13> UTRANFDDFrequencyQRxLevMinFDD;

class UTRANFDDFrequency : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	UTRANFDDFrequency(): Sequence(&theInfo) {}

	void setUarfcn(const UARFCN& uarfcn) { *static_cast<UARFCN*>(items[0]) = uarfcn; }
	void setUTRANFDDFrequencyPriority(const UTRANFDDFrequencyPriority& uTRANFDDFrequencyPriority) { *static_cast<UTRANFDDFrequencyPriority*>(items[1]) = uTRANFDDFrequencyPriority; }
	void setUTRANFDDFrequencyThreshXhigh(const UTRANFDDFrequencyThreshXhigh& uTRANFDDFrequencyThreshXhigh) { *static_cast<UTRANFDDFrequencyThreshXhigh*>(items[2]) = uTRANFDDFrequencyThreshXhigh; }
	void setUTRANFDDFrequencyThreshXlow(const UTRANFDDFrequencyThreshXlow& uTRANFDDFrequencyThreshXlow) { *static_cast<UTRANFDDFrequencyThreshXlow*>(items[3]) = uTRANFDDFrequencyThreshXlow; }
	void setUTRANFDDFrequencyQQualMinFDD(const UTRANFDDFrequencyQQualMinFDD& uTRANFDDFrequencyQQualMinFDD) { *static_cast<UTRANFDDFrequencyQQualMinFDD*>(items[4]) = uTRANFDDFrequencyQQualMinFDD; }
	void setUTRANFDDFrequencyQRxLevMinFDD(const UTRANFDDFrequencyQRxLevMinFDD& uTRANFDDFrequencyQRxLevMinFDD) { *static_cast<UTRANFDDFrequencyQRxLevMinFDD*>(items[5]) = uTRANFDDFrequencyQRxLevMinFDD; }
};

typedef SequenceOf<UTRANFDDFrequency, CONSTRAINED, 1, maxNumFDDFreqs> UTRANFDDFrequencyList;

typedef Integer<CONSTRAINED, 0, maxPrio_1> UTRANTDDFrequencyPriority;

typedef Integer<CONSTRAINED, 0, 31> UTRANTDDFrequencyThreshXhigh;

typedef Integer<CONSTRAINED, 0, 31> UTRANTDDFrequencyThreshXlow;

typedef Integer<CONSTRAINED, -60, -13> UTRANTDDFrequencyQRxLevMinTDD;

class UTRANTDDFrequency : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	UTRANTDDFrequency(): Sequence(&theInfo) {}

	void setUarfcn(const UARFCN& uarfcn) { *static_cast<UARFCN*>(items[0]) = uarfcn; }
	void setUTRANTDDFrequencyPriority(const UTRANTDDFrequencyPriority& uTRANTDDFrequencyPriority) { *static_cast<UTRANTDDFrequencyPriority*>(items[1]) = uTRANTDDFrequencyPriority; }
	void setUTRANTDDFrequencyThreshXhigh(const UTRANTDDFrequencyThreshXhigh& uTRANTDDFrequencyThreshXhigh) { *static_cast<UTRANTDDFrequencyThreshXhigh*>(items[2]) = uTRANTDDFrequencyThreshXhigh; }
	void setUTRANTDDFrequencyThreshXlow(const UTRANTDDFrequencyThreshXlow& uTRANTDDFrequencyThreshXlow) { *static_cast<UTRANTDDFrequencyThreshXlow*>(items[3]) = uTRANTDDFrequencyThreshXlow; }
	void setUTRANTDDFrequencyQRxLevMinTDD(const UTRANTDDFrequencyQRxLevMinTDD& uTRANTDDFrequencyQRxLevMinTDD) { *static_cast<UTRANTDDFrequencyQRxLevMinTDD*>(items[4]) = uTRANTDDFrequencyQRxLevMinTDD; }
};

typedef SequenceOf<UTRANTDDFrequency, CONSTRAINED, 1, maxNumTDDFreqs> UTRANTDDFrequencyList;

typedef Integer<CONSTRAINED, 0, maxPrio_1> UTRAPriorityInfoListUtraServingCellPriority;

typedef Integer<CONSTRAINED, 0, 31> UTRAPriorityInfoListUtraServingCellSPrioritySearch1;

typedef Integer<CONSTRAINED, 0, 7> UTRAPriorityInfoListUtraServingCellSPrioritySearch2;

typedef Integer<CONSTRAINED, 0, 31> UTRAPriorityInfoListUtraServingCellThreshServingLow;

class UTRAPriorityInfoListUtraServingCell : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UTRAPriorityInfoListUtraServingCell(): Sequence(&theInfo) {}

	void setUTRAPriorityInfoListUtraServingCellPriority(const UTRAPriorityInfoListUtraServingCellPriority& uTRAPriorityInfoListUtraServingCellPriority) { *static_cast<UTRAPriorityInfoListUtraServingCellPriority*>(items[0]) = uTRAPriorityInfoListUtraServingCellPriority; }
	void setUTRAPriorityInfoListUtraServingCellSPrioritySearch1(const UTRAPriorityInfoListUtraServingCellSPrioritySearch1& uTRAPriorityInfoListUtraServingCellSPrioritySearch1) { *static_cast<UTRAPriorityInfoListUtraServingCellSPrioritySearch1*>(items[1]) = uTRAPriorityInfoListUtraServingCellSPrioritySearch1; }
	void setUTRAPriorityInfoListUtraServingCellSPrioritySearch2(const UTRAPriorityInfoListUtraServingCellSPrioritySearch2& uTRAPriorityInfoListUtraServingCellSPrioritySearch2) { *static_cast<UTRAPriorityInfoListUtraServingCellSPrioritySearch2*>(items[2]) = uTRAPriorityInfoListUtraServingCellSPrioritySearch2; }
	void setUTRAPriorityInfoListUtraServingCellThreshServingLow(const UTRAPriorityInfoListUtraServingCellThreshServingLow& uTRAPriorityInfoListUtraServingCellThreshServingLow) { *static_cast<UTRAPriorityInfoListUtraServingCellThreshServingLow*>(items[3]) = uTRAPriorityInfoListUtraServingCellThreshServingLow; }
};

class UTRAPriorityInfoList : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	UTRAPriorityInfoList(): Sequence(&theInfo) {}

	void setUTRAPriorityInfoListUtraServingCell(const UTRAPriorityInfoListUtraServingCell& uTRAPriorityInfoListUtraServingCell) { *static_cast<UTRAPriorityInfoListUtraServingCell*>(items[0]) = uTRAPriorityInfoListUtraServingCell; }
	void setUtranFDDFrequencyList(const UTRANFDDFrequencyList& utranFDDFrequencyList) { *static_cast<UTRANFDDFrequencyList*>(items[1]) = utranFDDFrequencyList; }
	void setUtranTDDFrequencyList(const UTRANTDDFrequencyList& utranTDDFrequencyList) { *static_cast<UTRANTDDFrequencyList*>(items[2]) = utranTDDFrequencyList; }
};

typedef Integer<CONSTRAINED, 0, 31> UTRAPriorityInfoListv920extThreshServingLow2;

class UTRAPriorityInfoListv920ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	UTRAPriorityInfoListv920ext(): Sequence(&theInfo) {}

	void setUTRAPriorityInfoListv920extThreshServingLow2(const UTRAPriorityInfoListv920extThreshServingLow2& uTRAPriorityInfoListv920extThreshServingLow2) { *static_cast<UTRAPriorityInfoListv920extThreshServingLow2*>(items[0]) = uTRAPriorityInfoListv920extThreshServingLow2; }
};

typedef Integer<CONSTRAINED, 1, 8> MIBValueTag;

typedef Integer<CONSTRAINED, 0, 511> BCCHModificationTime;

class BCCHModificationInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	BCCHModificationInfo(): Sequence(&theInfo) {}

	void setMibValueTag(const MIBValueTag& mibValueTag) { *static_cast<MIBValueTag*>(items[0]) = mibValueTag; }
	void setBcchModificationTime(const BCCHModificationTime& bcchModificationTime) { *static_cast<BCCHModificationTime*>(items[1]) = bcchModificationTime; }
};

typedef Integer<CONSTRAINED, 1, 256> CBSDRXLevel1InformationCtchAllocationPeriod;

typedef Integer<CONSTRAINED, 0, 255> CBSDRXLevel1InformationCbsFrameOffset;

class CBSDRXLevel1Information : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CBSDRXLevel1Information(): Sequence(&theInfo) {}

	void setCBSDRXLevel1InformationCtchAllocationPeriod(const CBSDRXLevel1InformationCtchAllocationPeriod& cBSDRXLevel1InformationCtchAllocationPeriod) { *static_cast<CBSDRXLevel1InformationCtchAllocationPeriod*>(items[0]) = cBSDRXLevel1InformationCtchAllocationPeriod; }
	void setCBSDRXLevel1InformationCbsFrameOffset(const CBSDRXLevel1InformationCbsFrameOffset& cBSDRXLevel1InformationCbsFrameOffset) { *static_cast<CBSDRXLevel1InformationCbsFrameOffset*>(items[1]) = cBSDRXLevel1InformationCbsFrameOffset; }
};

enum CBSDRXLevel1Informationextensionr6Values {
	p8_CBSDRXLevel1Informationextensionr6 = 0,
	p16_CBSDRXLevel1Informationextensionr6 = 1,
	p32_CBSDRXLevel1Informationextensionr6 = 2,
	p64_CBSDRXLevel1Informationextensionr6 = 3,
	p128_CBSDRXLevel1Informationextensionr6 = 4,
	p256_CBSDRXLevel1Informationextensionr6 = 5,
};
typedef Enumerated<CONSTRAINED, 5> CBSDRXLevel1Informationextensionr6;

typedef BitString<CONSTRAINED, 8, 8> CDMA2000MessageMsgType;

typedef BitString<CONSTRAINED, 1, 512> CDMA2000MessagePayload;

class CDMA2000Message : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	CDMA2000Message(): Sequence(&theInfo) {}

	void setCDMA2000MessageMsgType(const CDMA2000MessageMsgType& cDMA2000MessageMsgType) { *static_cast<CDMA2000MessageMsgType*>(items[0]) = cDMA2000MessageMsgType; }
	void setCDMA2000MessagePayload(const CDMA2000MessagePayload& cDMA2000MessagePayload) { *static_cast<CDMA2000MessagePayload*>(items[1]) = cDMA2000MessagePayload; }
};

typedef SequenceOf<CDMA2000Message, CONSTRAINED, 1, maxInterSysMessages> CDMA2000MessageList;

typedef BitString<CONSTRAINED, 5, 5> FrequencyInfoCDMA2000BandClass;

typedef BitString<CONSTRAINED, 11, 11> FrequencyInfoCDMA2000CdmaFreq;

class FrequencyInfoCDMA2000 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	FrequencyInfoCDMA2000(): Sequence(&theInfo) {}

	void setFrequencyInfoCDMA2000BandClass(const FrequencyInfoCDMA2000BandClass& frequencyInfoCDMA2000BandClass) { *static_cast<FrequencyInfoCDMA2000BandClass*>(items[0]) = frequencyInfoCDMA2000BandClass; }
	void setFrequencyInfoCDMA2000CdmaFreq(const FrequencyInfoCDMA2000CdmaFreq& frequencyInfoCDMA2000CdmaFreq) { *static_cast<FrequencyInfoCDMA2000CdmaFreq*>(items[1]) = frequencyInfoCDMA2000CdmaFreq; }
};

typedef SequenceOf<FrequencyInfoCDMA2000, CONSTRAINED, 1, maxNumCDMA2000Freqs> CDMA2000UMTSFrequencyList;

enum DataTransmFrequencydataTransmFreqGranularityValues {
	ms100_DataTransmFrequencydataTransmFreqGranularity = 0,
	ms250_DataTransmFrequencydataTransmFreqGranularity = 1,
	ms500_DataTransmFrequencydataTransmFreqGranularity = 2,
	ms1000_DataTransmFrequencydataTransmFreqGranularity = 3,
	ms2000_DataTransmFrequencydataTransmFreqGranularity = 4,
	ms5000_DataTransmFrequencydataTransmFreqGranularity = 5,
	ms10000_DataTransmFrequencydataTransmFreqGranularity = 6,
	ms60000_DataTransmFrequencydataTransmFreqGranularity = 7,
};
typedef Enumerated<CONSTRAINED, 7> DataTransmFrequencydataTransmFreqGranularity;

typedef Integer<CONSTRAINED, 1, 610> DataTransmFrequencyNumberOfDataTransmOcc;

class DataTransmFrequency : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DataTransmFrequency(): Sequence(&theInfo) {}

	void setDataTransmFrequencydataTransmFreqGranularity(const DataTransmFrequencydataTransmFreqGranularity& dataTransmFrequencydataTransmFreqGranularity) { *static_cast<DataTransmFrequencydataTransmFreqGranularity*>(items[0]) = dataTransmFrequencydataTransmFreqGranularity; }
	void setDataTransmFrequencyNumberOfDataTransmOcc(const DataTransmFrequencyNumberOfDataTransmOcc& dataTransmFrequencyNumberOfDataTransmOcc) { *static_cast<DataTransmFrequencyNumberOfDataTransmOcc*>(items[1]) = dataTransmFrequencyNumberOfDataTransmOcc; }
};

typedef Integer<CONSTRAINED, 1, 120> DataVolumeHistoryDataVolumeMontoringWindow;

typedef Integer<CONSTRAINED, 0, 4294967295> DataVolumePerRBDataVolume;

class DataVolumePerRB : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	DataVolumePerRB(): Sequence(&theInfo) {}

	void setRbIdentity(const RBIdentity& rbIdentity) { *static_cast<RBIdentity*>(items[0]) = rbIdentity; }
	void setDataVolumePerRBDataVolume(const DataVolumePerRBDataVolume& dataVolumePerRBDataVolume) { *static_cast<DataVolumePerRBDataVolume*>(items[1]) = dataVolumePerRBDataVolume; }
};

typedef SequenceOf<DataVolumePerRB, CONSTRAINED, 1, maxRB> DataVolumePerRBList;

class DataVolumeHistory : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	DataVolumeHistory(): Sequence(&theInfo) {}

	void setDataVolumeHistoryDataVolumeMontoringWindow(const DataVolumeHistoryDataVolumeMontoringWindow& dataVolumeHistoryDataVolumeMontoringWindow) { *static_cast<DataVolumeHistoryDataVolumeMontoringWindow*>(items[0]) = dataVolumeHistoryDataVolumeMontoringWindow; }
	void setDataTransmFrequency(const DataTransmFrequency& dataTransmFrequency) { *static_cast<DataTransmFrequency*>(items[1]) = dataTransmFrequency; }
	void setDataVolumePerRB(const DataVolumePerRBList& dataVolumePerRB) { *static_cast<DataVolumePerRBList*>(items[2]) = dataVolumePerRB; }
};

class DeferredMeasurementControlReadingSupportModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DeferredMeasurementControlReadingSupportModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setIntraFreqMeasQuantityFDD(const IntraFreqMeasQuantityFDDsib3& intraFreqMeasQuantityFDD) { *static_cast<IntraFreqMeasQuantityFDDsib3*>(items[0]) = intraFreqMeasQuantityFDD; }
};

class DeferredMeasurementControlReadingSupportModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DeferredMeasurementControlReadingSupportModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setIntraFreqMeasQuantityTDDList(const IntraFreqMeasQuantityTDDsib3List& intraFreqMeasQuantityTDDList) { *static_cast<IntraFreqMeasQuantityTDDsib3List*>(items[0]) = intraFreqMeasQuantityTDDList; }
};

class DeferredMeasurementControlReadingSupportModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum DeferredMeasurementControlReadingSupportModeSpecificInfoChoices {
		deferredMeasurementControlReadingSupportModeSpecificInfoFdd = 0,
		deferredMeasurementControlReadingSupportModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	DeferredMeasurementControlReadingSupportModeSpecificInfo(): Choice(&theInfo) {}
};

class DeferredMeasurementControlReadingSupport : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	DeferredMeasurementControlReadingSupport(): Sequence(&theInfo) {}

	void setDeferredMeasurementControlReadingSupportModeSpecificInfo(const DeferredMeasurementControlReadingSupportModeSpecificInfo& deferredMeasurementControlReadingSupportModeSpecificInfo) { *static_cast<DeferredMeasurementControlReadingSupportModeSpecificInfo*>(items[0]) = deferredMeasurementControlReadingSupportModeSpecificInfo; }
};

typedef OctetString<CONSTRAINED, 1, 2> ETWSInformationWarningType;

typedef OctetString<CONSTRAINED, 2, 2> ETWSInformationMessageIdentifier;

typedef OctetString<CONSTRAINED, 2, 2> ETWSInformationSerialNumber;

class ETWSInformation : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ETWSInformation(): Sequence(&theInfo) {}

	void setETWSInformationWarningType(const ETWSInformationWarningType& eTWSInformationWarningType) { *static_cast<ETWSInformationWarningType*>(items[0]) = eTWSInformationWarningType; }
	void setETWSInformationMessageIdentifier(const ETWSInformationMessageIdentifier& eTWSInformationMessageIdentifier) { *static_cast<ETWSInformationMessageIdentifier*>(items[1]) = eTWSInformationMessageIdentifier; }
	void setETWSInformationSerialNumber(const ETWSInformationSerialNumber& eTWSInformationSerialNumber) { *static_cast<ETWSInformationSerialNumber*>(items[2]) = eTWSInformationSerialNumber; }
};

typedef OctetStringBase ETWSWarningSecurityInfo;

typedef Integer<CONSTRAINED, 1, 8> ExpirationTimeFactor;

typedef Null SIBTypeExtGANSSSystemInfoType151bis;

typedef Null SIBTypeExtGANSSSystemInfoType152bis;

typedef Null SIBTypeExtGANSSSystemInfoType152ter;

typedef Null SIBTypeExtGANSSSystemInfoType153bis;

typedef Null SIBTypeExtGANSSSystemInfoType156;

typedef Null SIBTypeExtGANSSSystemInfoType157;

typedef Null SIBTypeExtGANSSSystemInfoType158;

typedef Null SIBTypeExtGANSSSpare9;

typedef Null SIBTypeExtGANSSSpare8;

typedef Null SIBTypeExtGANSSSpare7;

typedef Null SIBTypeExtGANSSSpare6;

typedef Null SIBTypeExtGANSSSpare5;

typedef Null SIBTypeExtGANSSSpare4;

typedef Null SIBTypeExtGANSSSpare3;

typedef Null SIBTypeExtGANSSSpare2;

typedef Null SIBTypeExtGANSSSpare1;

class SIBTypeExtGANSS : public Choice {
private:
	static const void *choicesInfo[16];
public:
	enum SIBTypeExtGANSSChoices {
		sIBTypeExtGANSSSystemInfoType151bis = 0,
		sIBTypeExtGANSSSystemInfoType152bis = 1,
		sIBTypeExtGANSSSystemInfoType152ter = 2,
		sIBTypeExtGANSSSystemInfoType153bis = 3,
		sIBTypeExtGANSSSystemInfoType156 = 4,
		sIBTypeExtGANSSSystemInfoType157 = 5,
		sIBTypeExtGANSSSystemInfoType158 = 6,
		sIBTypeExtGANSSSpare9 = 7,
		sIBTypeExtGANSSSpare8 = 8,
		sIBTypeExtGANSSSpare7 = 9,
		sIBTypeExtGANSSSpare6 = 10,
		sIBTypeExtGANSSSpare5 = 11,
		sIBTypeExtGANSSSpare4 = 12,
		sIBTypeExtGANSSSpare3 = 13,
		sIBTypeExtGANSSSpare2 = 14,
		sIBTypeExtGANSSSpare1 = 15,
	};
	static const Info theInfo;
	SIBTypeExtGANSS(): Choice(&theInfo) {}
};

typedef Null ValueTagInfoNone;

class ValueTagInfo : public Choice {
private:
	static const void *choicesInfo[4];
public:
	enum ValueTagInfoChoices {
		valueTagInfoNone = 0,
		cellValueTag = 1,
		plmnValueTag = 2,
		sIBOccurrenceIdentityAndValueTag = 3,
	};
	static const Info theInfo;
	ValueTagInfo(): Choice(&theInfo) {}
};

class ExtGANSSSchedulingInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ExtGANSSSchedulingInfo(): Sequence(&theInfo) {}

	void setExtensionGANSSSIBType(const SIBTypeExtGANSS& extensionGANSSSIBType) { *static_cast<SIBTypeExtGANSS*>(items[0]) = extensionGANSSSIBType; }
	void setSchedulingInfo(const SchedulingInformation& schedulingInfo) { *static_cast<SchedulingInformation*>(items[1]) = schedulingInfo; }
	void setValueTagInfo(const ValueTagInfo& valueTagInfo) { *static_cast<ValueTagInfo*>(items[2]) = valueTagInfo; }
};

typedef Integer<CONSTRAINED, 0, 7> ExtGANSSSIBTypeInfoSchedulingInfoGanssID;

typedef SequenceOf<ExtGANSSSchedulingInfo, CONSTRAINED, 1, maxSIB> ExtGANSSSIBTypeInfoSchedulingInfoGanssScheduling;

class ExtGANSSSIBTypeInfoSchedulingInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ExtGANSSSIBTypeInfoSchedulingInfo(): Sequence(&theInfo) {}

	void setExtGANSSSIBTypeInfoSchedulingInfoGanssID(const ExtGANSSSIBTypeInfoSchedulingInfoGanssID& extGANSSSIBTypeInfoSchedulingInfoGanssID) { *static_cast<ExtGANSSSIBTypeInfoSchedulingInfoGanssID*>(items[0]) = extGANSSSIBTypeInfoSchedulingInfoGanssID; }
	void setSbasID(const UEPositioningGANSSSBASID& sbasID) { *static_cast<UEPositioningGANSSSBASID*>(items[1]) = sbasID; }
	void setExtGANSSSIBTypeInfoSchedulingInfoGanssScheduling(const ExtGANSSSIBTypeInfoSchedulingInfoGanssScheduling& extGANSSSIBTypeInfoSchedulingInfoGanssScheduling) { *static_cast<ExtGANSSSIBTypeInfoSchedulingInfoGanssScheduling*>(items[2]) = extGANSSSIBTypeInfoSchedulingInfoGanssScheduling; }
};

typedef SequenceOf<ExtGANSSSIBTypeInfoSchedulingInfo, CONSTRAINED, 1, maxGANSS> ExtGANSSSIBTypeInfoSchedulingInfoList;

typedef Null SIBTypeExtSystemInfoType11bis;

typedef Null SIBTypeExtSystemInfoType15bis;

typedef Null SIBTypeExtSystemInfoType151bis;

typedef Null SIBTypeExtSystemInfoType152bis;

typedef Null SIBTypeExtSystemInfoType153bis;

typedef Null SIBTypeExtSystemInfoType156;

typedef Null SIBTypeExtSystemInfoType157;

typedef Null SIBTypeExtSystemInfoType158;

class SIBTypeExt : public Choice {
private:
	static const void *choicesInfo[8];
public:
	enum SIBTypeExtChoices {
		sIBTypeExtSystemInfoType11bis = 0,
		sIBTypeExtSystemInfoType15bis = 1,
		sIBTypeExtSystemInfoType151bis = 2,
		sIBTypeExtSystemInfoType152bis = 3,
		sIBTypeExtSystemInfoType153bis = 4,
		sIBTypeExtSystemInfoType156 = 5,
		sIBTypeExtSystemInfoType157 = 6,
		sIBTypeExtSystemInfoType158 = 7,
	};
	static const Info theInfo;
	SIBTypeExt(): Choice(&theInfo) {}
};

class ExtSIBTypeInfoSchedulingInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ExtSIBTypeInfoSchedulingInfo(): Sequence(&theInfo) {}

	void setExtensionSIBType(const SIBTypeExt& extensionSIBType) { *static_cast<SIBTypeExt*>(items[0]) = extensionSIBType; }
	void setSchedulingInfo(const SchedulingInformation& schedulingInfo) { *static_cast<SchedulingInformation*>(items[1]) = schedulingInfo; }
	void setValueTagInfo(const ValueTagInfo& valueTagInfo) { *static_cast<ValueTagInfo*>(items[2]) = valueTagInfo; }
};

typedef SequenceOf<ExtSIBTypeInfoSchedulingInfo, CONSTRAINED, 1, maxSIB> ExtSIBTypeInfoSchedulingInfoList;

typedef Null SIBTypeExt2SystemInfoType19;

typedef Null SIBTypeExt2SystemInfoType152ter;

typedef Null SIBTypeExt2SystemInfoType20;

typedef Null SIBTypeExt2Spare5;

typedef Null SIBTypeExt2Spare4;

typedef Null SIBTypeExt2Spare3;

typedef Null SIBTypeExt2Spare2;

typedef Null SIBTypeExt2Spare1;

class SIBTypeExt2 : public Choice {
private:
	static const void *choicesInfo[8];
public:
	enum SIBTypeExt2Choices {
		sIBTypeExt2SystemInfoType19 = 0,
		sIBTypeExt2SystemInfoType152ter = 1,
		sIBTypeExt2SystemInfoType20 = 2,
		sIBTypeExt2Spare5 = 3,
		sIBTypeExt2Spare4 = 4,
		sIBTypeExt2Spare3 = 5,
		sIBTypeExt2Spare2 = 6,
		sIBTypeExt2Spare1 = 7,
	};
	static const Info theInfo;
	SIBTypeExt2(): Choice(&theInfo) {}
};

class ExtSIBTypeInfoSchedulingInfo2 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	ExtSIBTypeInfoSchedulingInfo2(): Sequence(&theInfo) {}

	void setExtensionSIBType2(const SIBTypeExt2& extensionSIBType2) { *static_cast<SIBTypeExt2*>(items[0]) = extensionSIBType2; }
	void setSchedulingInfo(const SchedulingInformation& schedulingInfo) { *static_cast<SchedulingInformation*>(items[1]) = schedulingInfo; }
	void setValueTagInfo(const ValueTagInfo& valueTagInfo) { *static_cast<ValueTagInfo*>(items[2]) = valueTagInfo; }
};

typedef SequenceOf<ExtSIBTypeInfoSchedulingInfo2, CONSTRAINED, 1, maxSIB> ExtSIBTypeInfoSchedulingInfoList2;

typedef SequenceOf<FrequencyInfoFDD, CONSTRAINED, 1, maxNumFDDFreqs> FDDUMTSFrequencyList;

typedef OctetString<CONSTRAINED, 1, 23> GERANSystemInfoBlock;

typedef SequenceOf<GERANSystemInfoBlock, CONSTRAINED, 1, maxGERAN_SI> GERANSystemInformation;

class GSMBARange : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	GSMBARange(): Sequence(&theInfo) {}

	void setGsmLowRangeUARFCN(const UARFCN& gsmLowRangeUARFCN) { *static_cast<UARFCN*>(items[0]) = gsmLowRangeUARFCN; }
	void setGsmUpRangeUARFCN(const UARFCN& gsmUpRangeUARFCN) { *static_cast<UARFCN*>(items[1]) = gsmUpRangeUARFCN; }
};

typedef SequenceOf<GSMBARange, CONSTRAINED, 1, maxNumGSMFreqRanges> GSMBARangeList;

typedef OctetString<CONSTRAINED, 5, 5> GSMClassmark2;

typedef OctetString<CONSTRAINED, 1, 32> GSMClassmark3;

typedef BitString<CONSTRAINED, 1, 512> GSMMessageListItem;

typedef SequenceOf<GSMMessageListItem, CONSTRAINED, 1, maxInterSysMessages> GSMMessageList;

typedef BitString<CONSTRAINED, 7, 7> GsmSecurityCapability;

typedef OctetString<CONSTRAINED, 1, maxHNBNameSize> HNBName;

typedef Null InterRATChangeFailureCauseConfigurationUnacceptable;

typedef Null InterRATChangeFailureCausePhysicalChannelFailure;

typedef Null InterRATChangeFailureCauseUnspecified;

typedef Null InterRATChangeFailureCauseSpare4;

typedef Null InterRATChangeFailureCauseSpare3;

typedef Null InterRATChangeFailureCauseSpare2;

typedef Null InterRATChangeFailureCauseSpare1;

class InterRATChangeFailureCause : public Choice {
private:
	static const void *choicesInfo[8];
public:
	enum InterRATChangeFailureCauseChoices {
		interRATChangeFailureCauseConfigurationUnacceptable = 0,
		interRATChangeFailureCausePhysicalChannelFailure = 1,
		protocolError = 2,
		interRATChangeFailureCauseUnspecified = 3,
		interRATChangeFailureCauseSpare4 = 4,
		interRATChangeFailureCauseSpare3 = 5,
		interRATChangeFailureCauseSpare2 = 6,
		interRATChangeFailureCauseSpare1 = 7,
	};
	static const Info theInfo;
	InterRATChangeFailureCause(): Choice(&theInfo) {}
};

typedef BitString<CONSTRAINED, 1, 32768> GERANIuMessageListItem;

typedef SequenceOf<GERANIuMessageListItem, CONSTRAINED, 1, maxInterSysMessages> GERANIuMessageList;

typedef BitString<CONSTRAINED, 1, 170> GERANIuRadioAccessCapability;

class InterRATUERadioAccessCapabilityGsm : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	InterRATUERadioAccessCapabilityGsm(): Sequence(&theInfo) {}

	void setGsmClassmark2(const GSMClassmark2& gsmClassmark2) { *static_cast<GSMClassmark2*>(items[0]) = gsmClassmark2; }
	void setGsmClassmark3(const GSMClassmark3& gsmClassmark3) { *static_cast<GSMClassmark3*>(items[1]) = gsmClassmark3; }
};

class InterRATUERadioAccessCapabilityCdma2000 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterRATUERadioAccessCapabilityCdma2000(): Sequence(&theInfo) {}

	void setCdma2000MessageList(const CDMA2000MessageList& cdma2000MessageList) { *static_cast<CDMA2000MessageList*>(items[0]) = cdma2000MessageList; }
};

class InterRATUERadioAccessCapability : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum InterRATUERadioAccessCapabilityChoices {
		interRATUERadioAccessCapabilityGsm = 0,
		interRATUERadioAccessCapabilityCdma2000 = 1,
	};
	static const Info theInfo;
	InterRATUERadioAccessCapability(): Choice(&theInfo) {}
};

typedef SequenceOf<InterRATUERadioAccessCapability, CONSTRAINED, 1, maxInterSysMessages> InterRATUERadioAccessCapabilityList;

class InterRATUERadioAccessCapabilityv590ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterRATUERadioAccessCapabilityv590ext(): Sequence(&theInfo) {}

	void setGeranIuRadioAccessCapability(const GERANIuRadioAccessCapability& geranIuRadioAccessCapability) { *static_cast<GERANIuRadioAccessCapability*>(items[0]) = geranIuRadioAccessCapability; }
};

class InterRATUESecurityCapabilityGsm : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	InterRATUESecurityCapabilityGsm(): Sequence(&theInfo) {}

	void setGsmSecurityCapability(const GsmSecurityCapability& gsmSecurityCapability) { *static_cast<GsmSecurityCapability*>(items[0]) = gsmSecurityCapability; }
};

class InterRATUESecurityCapability : public Choice {
private:
	static const void *choicesInfo[1];
public:
	enum InterRATUESecurityCapabilityChoices {
		interRATUESecurityCapabilityGsm = 0,
	};
	static const Info theInfo;
	InterRATUESecurityCapability(): Choice(&theInfo) {}
};

typedef SequenceOf<InterRATUESecurityCapability, CONSTRAINED, 1, maxInterSysMessages> InterRATUESecurityCapList;

typedef Null InterRATHOFailureCauseConfigurationUnacceptable;

typedef Null InterRATHOFailureCausePhysicalChannelFailure;

typedef Null InterRATHOFailureCauseInterRATProtocolError;

typedef Null InterRATHOFailureCauseUnspecified;

typedef Null InterRATHOFailureCauseSpare11;

typedef Null InterRATHOFailureCauseSpare10;

typedef Null InterRATHOFailureCauseSpare9;

typedef Null InterRATHOFailureCauseSpare8;

typedef Null InterRATHOFailureCauseSpare7;

typedef Null InterRATHOFailureCauseSpare6;

typedef Null InterRATHOFailureCauseSpare5;

typedef Null InterRATHOFailureCauseSpare4;

typedef Null InterRATHOFailureCauseSpare3;

typedef Null InterRATHOFailureCauseSpare2;

typedef Null InterRATHOFailureCauseSpare1;

class InterRATHOFailureCause : public Choice {
private:
	static const void *choicesInfo[16];
public:
	enum InterRATHOFailureCauseChoices {
		interRATHOFailureCauseConfigurationUnacceptable = 0,
		interRATHOFailureCausePhysicalChannelFailure = 1,
		protocolError = 2,
		interRATHOFailureCauseInterRATProtocolError = 3,
		interRATHOFailureCauseUnspecified = 4,
		interRATHOFailureCauseSpare11 = 5,
		interRATHOFailureCauseSpare10 = 6,
		interRATHOFailureCauseSpare9 = 7,
		interRATHOFailureCauseSpare8 = 8,
		interRATHOFailureCauseSpare7 = 9,
		interRATHOFailureCauseSpare6 = 10,
		interRATHOFailureCauseSpare5 = 11,
		interRATHOFailureCauseSpare4 = 12,
		interRATHOFailureCauseSpare3 = 13,
		interRATHOFailureCauseSpare2 = 14,
		interRATHOFailureCauseSpare1 = 15,
	};
	static const Info theInfo;
	InterRATHOFailureCause(): Choice(&theInfo) {}
};

typedef Null SIBSbTypeAndTagSysInfoType7;

typedef Null SIBSbTypeAndTagDummy2;

typedef Null SIBSbTypeAndTagDummy3;

typedef Null SIBSbTypeAndTagSysInfoType14;

typedef Null SIBSbTypeAndTagSysInfoType17;

typedef Null SIBSbTypeAndTagSpare2;

typedef Null SIBSbTypeAndTagSpare1;

class SIBSbTypeAndTag : public Choice {
private:
	static const void *choicesInfo[32];
public:
	enum SIBSbTypeAndTagChoices {
		sysInfoType1 = 0,
		sysInfoType2 = 1,
		sysInfoType3 = 2,
		sysInfoType4 = 3,
		sysInfoType5 = 4,
		sysInfoType6 = 5,
		sIBSbTypeAndTagSysInfoType7 = 6,
		dummy = 7,
		sIBSbTypeAndTagDummy2 = 8,
		sIBSbTypeAndTagDummy3 = 9,
		sysInfoType11 = 10,
		sysInfoType12 = 11,
		sysInfoType13 = 12,
		sysInfoType131 = 13,
		sysInfoType132 = 14,
		sysInfoType133 = 15,
		sysInfoType134 = 16,
		sIBSbTypeAndTagSysInfoType14 = 17,
		sysInfoType15 = 18,
		sysInfoType16 = 19,
		sIBSbTypeAndTagSysInfoType17 = 20,
		sysInfoTypeSB1 = 21,
		sysInfoTypeSB2 = 22,
		sysInfoType151 = 23,
		sysInfoType152 = 24,
		sysInfoType153 = 25,
		sysInfoType154 = 26,
		sysInfoType18 = 27,
		sysInfoType155 = 28,
		sysInfoType5bis = 29,
		sIBSbTypeAndTagSpare2 = 30,
		sIBSbTypeAndTagSpare1 = 31,
	};
	static const Info theInfo;
	SIBSbTypeAndTag(): Choice(&theInfo) {}
};

class SchedulingInformationSIBSb : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SchedulingInformationSIBSb(): Sequence(&theInfo) {}

	void setSibSbType(const SIBSbTypeAndTag& sibSbType) { *static_cast<SIBSbTypeAndTag*>(items[0]) = sibSbType; }
	void setScheduling(const SchedulingInformation& scheduling) { *static_cast<SchedulingInformation*>(items[1]) = scheduling; }
};

typedef SequenceOf<SchedulingInformationSIBSb, CONSTRAINED, 1, maxSIB> SIBSbReferenceList;

class MasterInformationBlockv690ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MasterInformationBlockv690ext(): Sequence(&theInfo) {}

	void setMultiplePLMNList(const MultiplePLMNListr6& multiplePLMNList) { *static_cast<MultiplePLMNListr6*>(items[0]) = multiplePLMNList; }
};

class MasterInformationBlockv6b0extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MasterInformationBlockv6b0extIEs(): Sequence(&theInfo) {}

	void setExtSIBTypeInfoSchedulingInfoList(const ExtSIBTypeInfoSchedulingInfoList& extSIBTypeInfoSchedulingInfoList) { *static_cast<ExtSIBTypeInfoSchedulingInfoList*>(items[0]) = extSIBTypeInfoSchedulingInfoList; }
};

enum MasterInformationBlockv860extIEscsg_IndicatorValues {
	true_MasterInformationBlockv860extIEscsg_Indicator = 0,
};
typedef Enumerated<CONSTRAINED, 0> MasterInformationBlockv860extIEscsg_Indicator;

class MasterInformationBlockv860extIEs : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MasterInformationBlockv860extIEs(): Sequence(&theInfo) {}

	void setExtSIBTypeInfoSchedulingInfoList(const ExtSIBTypeInfoSchedulingInfoList2& extSIBTypeInfoSchedulingInfoList) { *static_cast<ExtSIBTypeInfoSchedulingInfoList2*>(items[0]) = extSIBTypeInfoSchedulingInfoList; }
	void setExtGANSSSIBTypeInfoSchedulingInfoList(const ExtGANSSSIBTypeInfoSchedulingInfoList& extGANSSSIBTypeInfoSchedulingInfoList) { *static_cast<ExtGANSSSIBTypeInfoSchedulingInfoList*>(items[1]) = extGANSSSIBTypeInfoSchedulingInfoList; }
	void setMasterInformationBlockv860extIEscsg_Indicator(const MasterInformationBlockv860extIEscsg_Indicator& masterInformationBlockv860extIEscsg_Indicator) { *static_cast<MasterInformationBlockv860extIEscsg_Indicator*>(items[2]) = masterInformationBlockv860extIEscsg_Indicator; }
};

class MasterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	MasterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class MasterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensionsV860NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MasterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensionsV860NonCriticalExtensions(): Sequence(&theInfo) {}

	void setMasterInformationBlockv860ext(const MasterInformationBlockv860extIEs& masterInformationBlockv860ext) { *static_cast<MasterInformationBlockv860extIEs*>(items[0]) = masterInformationBlockv860ext; }
	void setMasterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions(const MasterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions& masterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions) { *static_cast<MasterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = masterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions; }
};

class MasterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MasterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setMasterInformationBlockv6b0ext(const MasterInformationBlockv6b0extIEs& masterInformationBlockv6b0ext) { *static_cast<MasterInformationBlockv6b0extIEs*>(items[0]) = masterInformationBlockv6b0ext; }
	void setMasterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensionsV860NonCriticalExtensions(const MasterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensionsV860NonCriticalExtensions& masterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensionsV860NonCriticalExtensions) { *static_cast<MasterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensionsV860NonCriticalExtensions*>(items[1]) = masterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensionsV860NonCriticalExtensions; }
};

class MasterInformationBlockV690NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MasterInformationBlockV690NonCriticalExtensions(): Sequence(&theInfo) {}

	void setMasterInformationBlockv690ext(const MasterInformationBlockv690ext& masterInformationBlockv690ext) { *static_cast<MasterInformationBlockv690ext*>(items[0]) = masterInformationBlockv690ext; }
	void setMasterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensions(const MasterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensions& masterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensions) { *static_cast<MasterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensions*>(items[1]) = masterInformationBlockV690NonCriticalExtensionsV6b0NonCriticalExtensions; }
};

class MasterInformationBlock : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	MasterInformationBlock(): Sequence(&theInfo) {}

	void setMibValueTag(const MIBValueTag& mibValueTag) { *static_cast<MIBValueTag*>(items[0]) = mibValueTag; }
	void setPlmnType(const PLMNType& plmnType) { *static_cast<PLMNType*>(items[1]) = plmnType; }
	void setSibSbReferenceList(const SIBSbReferenceList& sibSbReferenceList) { *static_cast<SIBSbReferenceList*>(items[2]) = sibSbReferenceList; }
	void setMasterInformationBlockV690NonCriticalExtensions(const MasterInformationBlockV690NonCriticalExtensions& masterInformationBlockV690NonCriticalExtensions) { *static_cast<MasterInformationBlockV690NonCriticalExtensions*>(items[3]) = masterInformationBlockV690NonCriticalExtensions; }
};

typedef SequenceOf<FrequencyInfoTDD, CONSTRAINED, 1, maxNumTDDFreqs> TDDUMTSFrequencyList;

class RplmnInformation : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	RplmnInformation(): Sequence(&theInfo) {}

	void setGsmBARangeList(const GSMBARangeList& gsmBARangeList) { *static_cast<GSMBARangeList*>(items[0]) = gsmBARangeList; }
	void setFddUMTSFrequencyList(const FDDUMTSFrequencyList& fddUMTSFrequencyList) { *static_cast<FDDUMTSFrequencyList*>(items[1]) = fddUMTSFrequencyList; }
	void setTddUMTSFrequencyList(const TDDUMTSFrequencyList& tddUMTSFrequencyList) { *static_cast<TDDUMTSFrequencyList*>(items[2]) = tddUMTSFrequencyList; }
	void setCdma2000UMTSFrequencyList(const CDMA2000UMTSFrequencyList& cdma2000UMTSFrequencyList) { *static_cast<CDMA2000UMTSFrequencyList*>(items[3]) = cdma2000UMTSFrequencyList; }
};

class RplmnInformationr4 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	RplmnInformationr4(): Sequence(&theInfo) {}

	void setGsmBARangeList(const GSMBARangeList& gsmBARangeList) { *static_cast<GSMBARangeList*>(items[0]) = gsmBARangeList; }
	void setFddUMTSFrequencyList(const FDDUMTSFrequencyList& fddUMTSFrequencyList) { *static_cast<FDDUMTSFrequencyList*>(items[1]) = fddUMTSFrequencyList; }
	void setTdd384UMTSFrequencyList(const TDDUMTSFrequencyList& tdd384UMTSFrequencyList) { *static_cast<TDDUMTSFrequencyList*>(items[2]) = tdd384UMTSFrequencyList; }
	void setTdd128UMTSFrequencyList(const TDDUMTSFrequencyList& tdd128UMTSFrequencyList) { *static_cast<TDDUMTSFrequencyList*>(items[3]) = tdd128UMTSFrequencyList; }
	void setCdma2000UMTSFrequencyList(const CDMA2000UMTSFrequencyList& cdma2000UMTSFrequencyList) { *static_cast<CDMA2000UMTSFrequencyList*>(items[4]) = cdma2000UMTSFrequencyList; }
};

typedef Integer<CONSTRAINED, 1, 15> SegmentIndex;

typedef Integer<CONSTRAINED, 0, 2047> SFNPrime;

typedef BitString<CONSTRAINED, 222, 222> SIBDatafixed;

typedef BitString<CONSTRAINED, 1, 214> SIBDatavariable;

typedef SequenceOf<SchedulingInformationSIB, CONSTRAINED, 1, maxSIB> SIBReferenceList;

enum SIBTypeValues {
	masterInformationBlock_SIBType = 0,
	systemInformationBlockType1_SIBType = 1,
	systemInformationBlockType2_SIBType = 2,
	systemInformationBlockType3_SIBType = 3,
	systemInformationBlockType4_SIBType = 4,
	systemInformationBlockType5_SIBType = 5,
	systemInformationBlockType6_SIBType = 6,
	systemInformationBlockType7_SIBType = 7,
	dummy_SIBType = 8,
	dummy2_SIBType = 9,
	dummy3_SIBType = 10,
	systemInformationBlockType11_SIBType = 11,
	systemInformationBlockType12_SIBType = 12,
	systemInformationBlockType13_SIBType = 13,
	systemInformationBlockType13_1_SIBType = 14,
	systemInformationBlockType13_2_SIBType = 15,
	systemInformationBlockType13_3_SIBType = 16,
	systemInformationBlockType13_4_SIBType = 17,
	systemInformationBlockType14_SIBType = 18,
	systemInformationBlockType15_SIBType = 19,
	systemInformationBlockType15_1_SIBType = 20,
	systemInformationBlockType15_2_SIBType = 21,
	systemInformationBlockType15_3_SIBType = 22,
	systemInformationBlockType16_SIBType = 23,
	systemInformationBlockType17_SIBType = 24,
	systemInformationBlockType15_4_SIBType = 25,
	systemInformationBlockType18_SIBType = 26,
	schedulingBlock1_SIBType = 27,
	schedulingBlock2_SIBType = 28,
	systemInformationBlockType15_5_SIBType = 29,
	systemInformationBlockType5bis_SIBType = 30,
	extensionType_SIBType = 31,
};
typedef Enumerated<CONSTRAINED, 31> SIBType;

class SysInfoType1v3a0extIEs : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType1v3a0extIEs(): Sequence(&theInfo) {}

	void setUeConnTimersAndConstantsv3a0ext(const UEConnTimersAndConstantsv3a0ext& ueConnTimersAndConstantsv3a0ext) { *static_cast<UEConnTimersAndConstantsv3a0ext*>(items[0]) = ueConnTimersAndConstantsv3a0ext; }
	void setUeIdleTimersAndConstantsv3a0ext(const UEIdleTimersAndConstantsv3a0ext& ueIdleTimersAndConstantsv3a0ext) { *static_cast<UEIdleTimersAndConstantsv3a0ext*>(items[1]) = ueIdleTimersAndConstantsv3a0ext; }
};

class SysInfoType1v860extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType1v860extIEs(): Sequence(&theInfo) {}

	void setUeConnTimersAndConstants(const UEConnTimersAndConstantsv860ext& ueConnTimersAndConstants) { *static_cast<UEConnTimersAndConstantsv860ext*>(items[0]) = ueConnTimersAndConstants; }
};

class SysInfoType1V3a0NonCriticalExtensionsV860NonCriticalExtentionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType1V3a0NonCriticalExtensionsV860NonCriticalExtentionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType1V3a0NonCriticalExtensionsV860NonCriticalExtentions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType1V3a0NonCriticalExtensionsV860NonCriticalExtentions(): Sequence(&theInfo) {}

	void setSysInfoType1v860ext(const SysInfoType1v860extIEs& sysInfoType1v860ext) { *static_cast<SysInfoType1v860extIEs*>(items[0]) = sysInfoType1v860ext; }
	void setSysInfoType1V3a0NonCriticalExtensionsV860NonCriticalExtentionsNonCriticalExtensions(const SysInfoType1V3a0NonCriticalExtensionsV860NonCriticalExtentionsNonCriticalExtensions& sysInfoType1V3a0NonCriticalExtensionsV860NonCriticalExtentionsNonCriticalExtensions) { *static_cast<SysInfoType1V3a0NonCriticalExtensionsV860NonCriticalExtentionsNonCriticalExtensions*>(items[1]) = sysInfoType1V3a0NonCriticalExtensionsV860NonCriticalExtentionsNonCriticalExtensions; }
};

class SysInfoType1V3a0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType1V3a0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType1v3a0ext(const SysInfoType1v3a0extIEs& sysInfoType1v3a0ext) { *static_cast<SysInfoType1v3a0extIEs*>(items[0]) = sysInfoType1v3a0ext; }
	void setSysInfoType1V3a0NonCriticalExtensionsV860NonCriticalExtentions(const SysInfoType1V3a0NonCriticalExtensionsV860NonCriticalExtentions& sysInfoType1V3a0NonCriticalExtensionsV860NonCriticalExtentions) { *static_cast<SysInfoType1V3a0NonCriticalExtensionsV860NonCriticalExtentions*>(items[1]) = sysInfoType1V3a0NonCriticalExtensionsV860NonCriticalExtentions; }
};

class SysInfoType1 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	SysInfoType1(): Sequence(&theInfo) {}

	void setCnCommonGSMMAPNASSysInfo(const NASSystemInformationGSMMAP& cnCommonGSMMAPNASSysInfo) { *static_cast<NASSystemInformationGSMMAP*>(items[0]) = cnCommonGSMMAPNASSysInfo; }
	void setCnDomainSysInfoList(const CNDomainSysInfoList& cnDomainSysInfoList) { *static_cast<CNDomainSysInfoList*>(items[1]) = cnDomainSysInfoList; }
	void setUeConnTimersAndConstants(const UEConnTimersAndConstants& ueConnTimersAndConstants) { *static_cast<UEConnTimersAndConstants*>(items[2]) = ueConnTimersAndConstants; }
	void setUeIdleTimersAndConstants(const UEIdleTimersAndConstants& ueIdleTimersAndConstants) { *static_cast<UEIdleTimersAndConstants*>(items[3]) = ueIdleTimersAndConstants; }
	void setSysInfoType1V3a0NonCriticalExtensions(const SysInfoType1V3a0NonCriticalExtensions& sysInfoType1V3a0NonCriticalExtensions) { *static_cast<SysInfoType1V3a0NonCriticalExtensions*>(items[4]) = sysInfoType1V3a0NonCriticalExtensions; }
};

class SysInfoType2NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType2NonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType2 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType2(): Sequence(&theInfo) {}

	void setUraIdentityList(const URAIdentityList& uraIdentityList) { *static_cast<URAIdentityList*>(items[0]) = uraIdentityList; }
	void setSysInfoType2NonCriticalExtensions(const SysInfoType2NonCriticalExtensions& sysInfoType2NonCriticalExtensions) { *static_cast<SysInfoType2NonCriticalExtensions*>(items[1]) = sysInfoType2NonCriticalExtensions; }
};

typedef Boolean SysInfoType3Sib4indicator;

class SysInfoType3v4b0extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType3v4b0extIEs(): Sequence(&theInfo) {}

	void setMappingLCR(const MappingLCRr4& mappingLCR) { *static_cast<MappingLCRr4*>(items[0]) = mappingLCR; }
};

class SysInfoType3v590ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType3v590ext(): Sequence(&theInfo) {}

	void setCellSelectReselectInfov590ext(const CellSelectReselectInfov590ext& cellSelectReselectInfov590ext) { *static_cast<CellSelectReselectInfov590ext*>(items[0]) = cellSelectReselectInfov590ext; }
};

class SysInfoType3v5c0extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType3v5c0extIEs(): Sequence(&theInfo) {}

	void setCellSelectReselectInfoTreselectionScalingv5c0ext(const CellSelectReselectInfoTreselectionScalingv5c0ext& cellSelectReselectInfoTreselectionScalingv5c0ext) { *static_cast<CellSelectReselectInfoTreselectionScalingv5c0ext*>(items[0]) = cellSelectReselectInfoTreselectionScalingv5c0ext; }
};

class SysInfoType3v670ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType3v670ext(): Sequence(&theInfo) {}

	void setDomainSpecificAccessRestrictionParametersForPLMNOfMIB(const DomainSpecificAccessRestrictionParamv670ext& domainSpecificAccessRestrictionParametersForPLMNOfMIB) { *static_cast<DomainSpecificAccessRestrictionParamv670ext*>(items[0]) = domainSpecificAccessRestrictionParametersForPLMNOfMIB; }
	void setDomainSpecificAccessRestictionForSharedNetwork(const DomainSpecificAccessRestrictionForSharedNetworkv670ext& domainSpecificAccessRestictionForSharedNetwork) { *static_cast<DomainSpecificAccessRestrictionForSharedNetworkv670ext*>(items[1]) = domainSpecificAccessRestictionForSharedNetwork; }
};

enum MBSFNOnlyServiceValues {
	true_MBSFNOnlyService = 0,
};
typedef Enumerated<CONSTRAINED, 0> MBSFNOnlyService;

class SysInfoType3v770extIEs : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SysInfoType3v770extIEs(): Sequence(&theInfo) {}

	void setDeferredMeasurementControlReadingSupport(const DeferredMeasurementControlReadingSupport& deferredMeasurementControlReadingSupport) { *static_cast<DeferredMeasurementControlReadingSupport*>(items[0]) = deferredMeasurementControlReadingSupport; }
	void setQQualMinOffset(const QQualMinOffset& qQualMinOffset) { *static_cast<QQualMinOffset*>(items[1]) = qQualMinOffset; }
	void setQRxlevMinOffset(const QRxlevMinOffset& qRxlevMinOffset) { *static_cast<QRxlevMinOffset*>(items[2]) = qRxlevMinOffset; }
	void setMbsfnOnlyService(const MBSFNOnlyService& mbsfnOnlyService) { *static_cast<MBSFNOnlyService*>(items[3]) = mbsfnOnlyService; }
};

class SysInfoType3v830extIEs : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType3v830extIEs(): Sequence(&theInfo) {}

	void setPagingPermissionWithAccessControlParametersForPLMNOfMIB(const PagingPermissionWithAccessControlParameters& pagingPermissionWithAccessControlParametersForPLMNOfMIB) { *static_cast<PagingPermissionWithAccessControlParameters*>(items[0]) = pagingPermissionWithAccessControlParametersForPLMNOfMIB; }
	void setPagingPermissionWithAccessControlParametersForSharedNetwork(const PagingPermissionWithAccessControlForSharedNetwork& pagingPermissionWithAccessControlParametersForSharedNetwork) { *static_cast<PagingPermissionWithAccessControlForSharedNetwork*>(items[1]) = pagingPermissionWithAccessControlParametersForSharedNetwork; }
};

class SysInfoType3v860extIEs : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType3v860extIEs(): Sequence(&theInfo) {}

	void setCsgIdentity(const CSGIdentity& csgIdentity) { *static_cast<CSGIdentity*>(items[0]) = csgIdentity; }
	void setCsgPSCSplitInfo(const CSGPSCSplitInfo& csgPSCSplitInfo) { *static_cast<CSGPSCSplitInfo*>(items[1]) = csgPSCSplitInfo; }
};

class SysInfoType3v870extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType3v870extIEs(): Sequence(&theInfo) {}

	void setCellAccessRestriction(const CellAccessRestrictionv870ext& cellAccessRestriction) { *static_cast<CellAccessRestrictionv870ext*>(items[0]) = cellAccessRestriction; }
};

enum SysInfoType3v920extIEsimsEmergencySupportIndicatorValues {
	supported_SysInfoType3v920extIEsimsEmergencySupportIndicator = 0,
};
typedef Enumerated<CONSTRAINED, 0> SysInfoType3v920extIEsimsEmergencySupportIndicator;

class SysInfoType3v920extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType3v920extIEs(): Sequence(&theInfo) {}

	void setSysInfoType3v920extIEsimsEmergencySupportIndicator(const SysInfoType3v920extIEsimsEmergencySupportIndicator& sysInfoType3v920extIEsimsEmergencySupportIndicator) { *static_cast<SysInfoType3v920extIEsimsEmergencySupportIndicator*>(items[0]) = sysInfoType3v920extIEsimsEmergencySupportIndicator; }
};

class SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtensionV900NonCriticalExtensionNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtensionV900NonCriticalExtensionNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtensionV900NonCriticalExtension : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtensionV900NonCriticalExtension(): Sequence(&theInfo) {}

	void setSysInfoType3v920ext(const SysInfoType3v920extIEs& sysInfoType3v920ext) { *static_cast<SysInfoType3v920extIEs*>(items[0]) = sysInfoType3v920ext; }
	void setSysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtensionV900NonCriticalExtensionNonCriticalExtensions(const SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtensionV900NonCriticalExtensionNonCriticalExtensions& sysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtensionV900NonCriticalExtensionNonCriticalExtensions) { *static_cast<SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtensionV900NonCriticalExtensionNonCriticalExtensions*>(items[1]) = sysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtensionV900NonCriticalExtensionNonCriticalExtensions; }
};

class SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtension : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtension(): Sequence(&theInfo) {}

	void setSysInfoType3v870ext(const SysInfoType3v870extIEs& sysInfoType3v870ext) { *static_cast<SysInfoType3v870extIEs*>(items[0]) = sysInfoType3v870ext; }
	void setSysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtensionV900NonCriticalExtension(const SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtensionV900NonCriticalExtension& sysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtensionV900NonCriticalExtension) { *static_cast<SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtensionV900NonCriticalExtension*>(items[1]) = sysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtensionV900NonCriticalExtension; }
};

class SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtension : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtension(): Sequence(&theInfo) {}

	void setSysInfoType3v860ext(const SysInfoType3v860extIEs& sysInfoType3v860ext) { *static_cast<SysInfoType3v860extIEs*>(items[0]) = sysInfoType3v860ext; }
	void setSysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtension(const SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtension& sysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtension) { *static_cast<SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtension*>(items[1]) = sysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtensionV870NonCriticalExtension; }
};

class SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtension : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtension(): Sequence(&theInfo) {}

	void setSysInfoType3v830ext(const SysInfoType3v830extIEs& sysInfoType3v830ext) { *static_cast<SysInfoType3v830extIEs*>(items[0]) = sysInfoType3v830ext; }
	void setSysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtension(const SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtension& sysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtension) { *static_cast<SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtension*>(items[1]) = sysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtensionV860NonCriticalExtension; }
};

class SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtension : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtension(): Sequence(&theInfo) {}

	void setSysInfoType3v770ext(const SysInfoType3v770extIEs& sysInfoType3v770ext) { *static_cast<SysInfoType3v770extIEs*>(items[0]) = sysInfoType3v770ext; }
	void setSysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtension(const SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtension& sysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtension) { *static_cast<SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtension*>(items[1]) = sysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtensionV830NonCriticalExtension; }
};

class SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtension : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtension(): Sequence(&theInfo) {}

	void setSysInfoType3v670ext(const SysInfoType3v670ext& sysInfoType3v670ext) { *static_cast<SysInfoType3v670ext*>(items[0]) = sysInfoType3v670ext; }
	void setSysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtension(const SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtension& sysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtension) { *static_cast<SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtension*>(items[1]) = sysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtensionV770NonCriticalExtension; }
};

class SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtension : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtension(): Sequence(&theInfo) {}

	void setSysInfoType3v5c0ext(const SysInfoType3v5c0extIEs& sysInfoType3v5c0ext) { *static_cast<SysInfoType3v5c0extIEs*>(items[0]) = sysInfoType3v5c0ext; }
	void setSysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtension(const SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtension& sysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtension) { *static_cast<SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtension*>(items[1]) = sysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtensionV670NonCriticalExtension; }
};

class SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtension : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtension(): Sequence(&theInfo) {}

	void setSysInfoType3v590ext(const SysInfoType3v590ext& sysInfoType3v590ext) { *static_cast<SysInfoType3v590ext*>(items[0]) = sysInfoType3v590ext; }
	void setSysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtension(const SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtension& sysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtension) { *static_cast<SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtension*>(items[1]) = sysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtensionV5c0NoncriticalExtension; }
};

class SysInfoType3V4b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType3V4b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType3v4b0ext(const SysInfoType3v4b0extIEs& sysInfoType3v4b0ext) { *static_cast<SysInfoType3v4b0extIEs*>(items[0]) = sysInfoType3v4b0ext; }
	void setSysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtension(const SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtension& sysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtension) { *static_cast<SysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtension*>(items[1]) = sysInfoType3V4b0NonCriticalExtensionsV590NonCriticalExtension; }
};

class SysInfoType3 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	SysInfoType3(): Sequence(&theInfo) {}

	void setSysInfoType3Sib4indicator(const SysInfoType3Sib4indicator& sysInfoType3Sib4indicator) { *static_cast<SysInfoType3Sib4indicator*>(items[0]) = sysInfoType3Sib4indicator; }
	void setCellIdentity(const CellIdentity& cellIdentity) { *static_cast<CellIdentity*>(items[1]) = cellIdentity; }
	void setCellSelectReselectInfo(const CellSelectReselectInfoSIB34& cellSelectReselectInfo) { *static_cast<CellSelectReselectInfoSIB34*>(items[2]) = cellSelectReselectInfo; }
	void setCellAccessRestriction(const CellAccessRestriction& cellAccessRestriction) { *static_cast<CellAccessRestriction*>(items[3]) = cellAccessRestriction; }
	void setSysInfoType3V4b0NonCriticalExtensions(const SysInfoType3V4b0NonCriticalExtensions& sysInfoType3V4b0NonCriticalExtensions) { *static_cast<SysInfoType3V4b0NonCriticalExtensions*>(items[4]) = sysInfoType3V4b0NonCriticalExtensions; }
};

class SysInfoType4v4b0extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType4v4b0extIEs(): Sequence(&theInfo) {}

	void setMappingLCR(const MappingLCRr4& mappingLCR) { *static_cast<MappingLCRr4*>(items[0]) = mappingLCR; }
};

class SysInfoType4v590ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType4v590ext(): Sequence(&theInfo) {}

	void setCellSelectReselectInfov590ext(const CellSelectReselectInfov590ext& cellSelectReselectInfov590ext) { *static_cast<CellSelectReselectInfov590ext*>(items[0]) = cellSelectReselectInfov590ext; }
};

class SysInfoType4v5b0extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType4v5b0extIEs(): Sequence(&theInfo) {}

	void setCellSelectReselectInfoPCHFACHv5b0ext(const CellSelectReselectInfoPCHFACHv5b0ext& cellSelectReselectInfoPCHFACHv5b0ext) { *static_cast<CellSelectReselectInfoPCHFACHv5b0ext*>(items[0]) = cellSelectReselectInfoPCHFACHv5b0ext; }
};

class SysInfoType4v5c0extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType4v5c0extIEs(): Sequence(&theInfo) {}

	void setCellSelectReselectInfoTreselectionScalingv5c0ext(const CellSelectReselectInfoTreselectionScalingv5c0ext& cellSelectReselectInfoTreselectionScalingv5c0ext) { *static_cast<CellSelectReselectInfoTreselectionScalingv5c0ext*>(items[0]) = cellSelectReselectInfoTreselectionScalingv5c0ext; }
};

class SysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtensionV5c0NonCriticalExtensionNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtensionV5c0NonCriticalExtensionNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtensionV5c0NonCriticalExtension : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtensionV5c0NonCriticalExtension(): Sequence(&theInfo) {}

	void setSysInfoType4v5c0ext(const SysInfoType4v5c0extIEs& sysInfoType4v5c0ext) { *static_cast<SysInfoType4v5c0extIEs*>(items[0]) = sysInfoType4v5c0ext; }
	void setSysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtensionV5c0NonCriticalExtensionNonCriticalExtensions(const SysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtensionV5c0NonCriticalExtensionNonCriticalExtensions& sysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtensionV5c0NonCriticalExtensionNonCriticalExtensions) { *static_cast<SysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtensionV5c0NonCriticalExtensionNonCriticalExtensions*>(items[1]) = sysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtensionV5c0NonCriticalExtensionNonCriticalExtensions; }
};

class SysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtension : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtension(): Sequence(&theInfo) {}

	void setSysInfoType4v5b0ext(const SysInfoType4v5b0extIEs& sysInfoType4v5b0ext) { *static_cast<SysInfoType4v5b0extIEs*>(items[0]) = sysInfoType4v5b0ext; }
	void setSysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtensionV5c0NonCriticalExtension(const SysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtensionV5c0NonCriticalExtension& sysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtensionV5c0NonCriticalExtension) { *static_cast<SysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtensionV5c0NonCriticalExtension*>(items[1]) = sysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtensionV5c0NonCriticalExtension; }
};

class SysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtension : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtension(): Sequence(&theInfo) {}

	void setSysInfoType4v590ext(const SysInfoType4v590ext& sysInfoType4v590ext) { *static_cast<SysInfoType4v590ext*>(items[0]) = sysInfoType4v590ext; }
	void setSysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtension(const SysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtension& sysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtension) { *static_cast<SysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtension*>(items[1]) = sysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtensionV5b0NonCriticalExtension; }
};

class SysInfoType4V4b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType4V4b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType4v4b0ext(const SysInfoType4v4b0extIEs& sysInfoType4v4b0ext) { *static_cast<SysInfoType4v4b0extIEs*>(items[0]) = sysInfoType4v4b0ext; }
	void setSysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtension(const SysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtension& sysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtension) { *static_cast<SysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtension*>(items[1]) = sysInfoType4V4b0NonCriticalExtensionsV590NonCriticalExtension; }
};

class SysInfoType4 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SysInfoType4(): Sequence(&theInfo) {}

	void setCellIdentity(const CellIdentity& cellIdentity) { *static_cast<CellIdentity*>(items[0]) = cellIdentity; }
	void setCellSelectReselectInfo(const CellSelectReselectInfoSIB34& cellSelectReselectInfo) { *static_cast<CellSelectReselectInfoSIB34*>(items[1]) = cellSelectReselectInfo; }
	void setCellAccessRestriction(const CellAccessRestriction& cellAccessRestriction) { *static_cast<CellAccessRestriction*>(items[2]) = cellAccessRestriction; }
	void setSysInfoType4V4b0NonCriticalExtensions(const SysInfoType4V4b0NonCriticalExtensions& sysInfoType4V4b0NonCriticalExtensions) { *static_cast<SysInfoType4V4b0NonCriticalExtensions*>(items[3]) = sysInfoType4V4b0NonCriticalExtensions; }
};

typedef Boolean SysInfoType5Sib6indicator;

class SysInfoType5ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType5ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setAichPowerOffset(const AICHPowerOffset& aichPowerOffset) { *static_cast<AICHPowerOffset*>(items[0]) = aichPowerOffset; }
};

class SysInfoType5ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SysInfoType5ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setPuschSysInfoListSFN(const PUSCHSysInfoListSFN& puschSysInfoListSFN) { *static_cast<PUSCHSysInfoListSFN*>(items[0]) = puschSysInfoListSFN; }
	void setPdschSysInfoListSFN(const PDSCHSysInfoListSFN& pdschSysInfoListSFN) { *static_cast<PDSCHSysInfoListSFN*>(items[1]) = pdschSysInfoListSFN; }
	void setOpenLoopPowerControlTDD(const OpenLoopPowerControlTDD& openLoopPowerControlTDD) { *static_cast<OpenLoopPowerControlTDD*>(items[2]) = openLoopPowerControlTDD; }
};

class SysInfoType5ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum SysInfoType5ModeSpecificInfoChoices {
		sysInfoType5ModeSpecificInfoFdd = 0,
		sysInfoType5ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	SysInfoType5ModeSpecificInfo(): Choice(&theInfo) {}
};

class SysInfoType5v4b0extIEsTdd128SpecificInfo : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SysInfoType5v4b0extIEsTdd128SpecificInfo(): Sequence(&theInfo) {}

	void setPuschSysInfoListSFN(const PUSCHSysInfoListSFNLCRr4& puschSysInfoListSFN) { *static_cast<PUSCHSysInfoListSFNLCRr4*>(items[0]) = puschSysInfoListSFN; }
	void setPdschSysInfoListSFN(const PDSCHSysInfoListSFNLCRr4& pdschSysInfoListSFN) { *static_cast<PDSCHSysInfoListSFNLCRr4*>(items[1]) = pdschSysInfoListSFN; }
	void setPCCPCHLCRExtensions(const PrimaryCCPCHInfoLCRr4ext& pCCPCHLCRExtensions) { *static_cast<PrimaryCCPCHInfoLCRr4ext*>(items[2]) = pCCPCHLCRExtensions; }
	void setSCCPCHLCRExtensionsList(const SCCPCHSystemInformationListLCRr4ext& sCCPCHLCRExtensionsList) { *static_cast<SCCPCHSystemInformationListLCRr4ext*>(items[3]) = sCCPCHLCRExtensionsList; }
};

class SysInfoType5v4b0extIEs : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	SysInfoType5v4b0extIEs(): Sequence(&theInfo) {}

	void setPNBSCHAllocationr4(const PNBSCHAllocationr4& pNBSCHAllocationr4) { *static_cast<PNBSCHAllocationr4*>(items[0]) = pNBSCHAllocationr4; }
	void setOpenLoopPowerControlIPDLTDD(const OpenLoopPowerControlIPDLTDDr4& openLoopPowerControlIPDLTDD) { *static_cast<OpenLoopPowerControlIPDLTDDr4*>(items[1]) = openLoopPowerControlIPDLTDD; }
	void setPrachSystemInformationListLCRr4(const PRACHSystemInformationListLCRr4& prachSystemInformationListLCRr4) { *static_cast<PRACHSystemInformationListLCRr4*>(items[2]) = prachSystemInformationListLCRr4; }
	void setSysInfoType5v4b0extIEsTdd128SpecificInfo(const SysInfoType5v4b0extIEsTdd128SpecificInfo& sysInfoType5v4b0extIEsTdd128SpecificInfo) { *static_cast<SysInfoType5v4b0extIEsTdd128SpecificInfo*>(items[3]) = sysInfoType5v4b0extIEsTdd128SpecificInfo; }
	void setFrequencyBandIndicator(const RadioFrequencyBandFDD& frequencyBandIndicator) { *static_cast<RadioFrequencyBandFDD*>(items[4]) = frequencyBandIndicator; }
};

class SysInfoType5v590extIEsHcrr5SpecificInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType5v590extIEsHcrr5SpecificInfo(): Sequence(&theInfo) {}

	void setPuschSysInfoListSFN(const PUSCHSysInfoListSFNHCRr5& puschSysInfoListSFN) { *static_cast<PUSCHSysInfoListSFNHCRr5*>(items[0]) = puschSysInfoListSFN; }
	void setPdschSysInfoListSFN(const PDSCHSysInfoListSFNHCRr5& pdschSysInfoListSFN) { *static_cast<PDSCHSysInfoListSFNHCRr5*>(items[1]) = pdschSysInfoListSFN; }
};

class SysInfoType5v590extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType5v590extIEs(): Sequence(&theInfo) {}

	void setSysInfoType5v590extIEsHcrr5SpecificInfo(const SysInfoType5v590extIEsHcrr5SpecificInfo& sysInfoType5v590extIEsHcrr5SpecificInfo) { *static_cast<SysInfoType5v590extIEsHcrr5SpecificInfo*>(items[0]) = sysInfoType5v590extIEsHcrr5SpecificInfo; }
};

class SysInfoType5v650extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType5v650extIEs(): Sequence(&theInfo) {}

	void setFrequencyBandIndicator2(const RadioFrequencyBandFDD2& frequencyBandIndicator2) { *static_cast<RadioFrequencyBandFDD2*>(items[0]) = frequencyBandIndicator2; }
};

enum SysInfoType5v680extIEshsdpa_CellIndicatorValues {
	hsdpa_CapableCell_SysInfoType5v680extIEshsdpa_CellIndicator = 0,
};
typedef Enumerated<CONSTRAINED, 0> SysInfoType5v680extIEshsdpa_CellIndicator;

class SysInfoType5v680extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType5v680extIEs(): Sequence(&theInfo) {}

	void setSysInfoType5v680extIEshsdpa_CellIndicator(const SysInfoType5v680extIEshsdpa_CellIndicator& sysInfoType5v680extIEshsdpa_CellIndicator) { *static_cast<SysInfoType5v680extIEshsdpa_CellIndicator*>(items[0]) = sysInfoType5v680extIEshsdpa_CellIndicator; }
};

enum SysInfoType5v690extIEsedch_CellIndicatorValues {
	edch_CapableCell_SysInfoType5v690extIEsedch_CellIndicator = 0,
};
typedef Enumerated<CONSTRAINED, 0> SysInfoType5v690extIEsedch_CellIndicator;

class SysInfoType5v690extIEsSccpchSystemInformationMBMS : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum SysInfoType5v690extIEsSccpchSystemInformationMBMSChoices {
		mcchOnSCCPCHusedForNonMBMS = 0,
		mcchOnSCCPCHusedOnlyForMBMS = 1,
	};
	static const Info theInfo;
	SysInfoType5v690extIEsSccpchSystemInformationMBMS(): Choice(&theInfo) {}
};

class SysInfoType5v690extIEs : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SysInfoType5v690extIEs(): Sequence(&theInfo) {}

	void setSysInfoType5v690extIEsedch_CellIndicator(const SysInfoType5v690extIEsedch_CellIndicator& sysInfoType5v690extIEsedch_CellIndicator) { *static_cast<SysInfoType5v690extIEsedch_CellIndicator*>(items[0]) = sysInfoType5v690extIEsedch_CellIndicator; }
	void setSysInfoType5v690extIEsSccpchSystemInformationMBMS(const SysInfoType5v690extIEsSccpchSystemInformationMBMS& sysInfoType5v690extIEsSccpchSystemInformationMBMS) { *static_cast<SysInfoType5v690extIEsSccpchSystemInformationMBMS*>(items[1]) = sysInfoType5v690extIEsSccpchSystemInformationMBMS; }
	void setAdditionalPRACHTFandTFCSCCCHList(const AdditionalPRACHTFandTFCSCCCHList& additionalPRACHTFandTFCSCCCHList) { *static_cast<AdditionalPRACHTFandTFCSCCCHList*>(items[2]) = additionalPRACHTFandTFCSCCCHList; }
	void setCBSDRXLevel1Informationextension(const CBSDRXLevel1Informationextensionr6& cBSDRXLevel1Informationextension) { *static_cast<CBSDRXLevel1Informationextensionr6*>(items[3]) = cBSDRXLevel1Informationextension; }
};

class SysInfoType5v770extIEsModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType5v770extIEsModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setHsdschCommonSystemInformation(const HSDSCHCommonSystemInformation& hsdschCommonSystemInformation) { *static_cast<HSDSCHCommonSystemInformation*>(items[0]) = hsdschCommonSystemInformation; }
	void setHsdschPagingSystemInformation(const HSDSCHPagingSystemInformation& hsdschPagingSystemInformation) { *static_cast<HSDSCHPagingSystemInformation*>(items[1]) = hsdschPagingSystemInformation; }
};

class SysInfoType5v770extIEsModeSpecificInfoTdd768 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SysInfoType5v770extIEsModeSpecificInfoTdd768(): Sequence(&theInfo) {}

	void setPuschSysInfoListSFN(const PUSCHSysInfoListSFNVHCR& puschSysInfoListSFN) { *static_cast<PUSCHSysInfoListSFNVHCR*>(items[0]) = puschSysInfoListSFN; }
	void setPdschSysInfoListSFN(const PDSCHSysInfoListVHCRr7& pdschSysInfoListSFN) { *static_cast<PDSCHSysInfoListVHCRr7*>(items[1]) = pdschSysInfoListSFN; }
	void setPrachSystemInformationList(const PRACHSystemInformationListVHCRr7& prachSystemInformationList) { *static_cast<PRACHSystemInformationListVHCRr7*>(items[2]) = prachSystemInformationList; }
};

class SysInfoType5v770extIEsModeSpecificInfoTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType5v770extIEsModeSpecificInfoTdd128(): Sequence(&theInfo) {}

	void setPrachSystemInformationList(const PRACHSystemInformationListLCRv770ext& prachSystemInformationList) { *static_cast<PRACHSystemInformationListLCRv770ext*>(items[0]) = prachSystemInformationList; }
};

class SysInfoType5v770extIEsModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum SysInfoType5v770extIEsModeSpecificInfoChoices {
		sysInfoType5v770extIEsModeSpecificInfoFdd = 0,
		sysInfoType5v770extIEsModeSpecificInfoTdd768 = 1,
		sysInfoType5v770extIEsModeSpecificInfoTdd128 = 2,
	};
	static const Info theInfo;
	SysInfoType5v770extIEsModeSpecificInfo(): Choice(&theInfo) {}
};

class SysInfoType5v770extIEsSccpchSystemInformationMBMS : public Choice {
private:
	static const void *choicesInfo[1];
public:
	enum SysInfoType5v770extIEsSccpchSystemInformationMBMSChoices {
		mcchOnSCCPCHusedOnlyForMBMS = 0,
	};
	static const Info theInfo;
	SysInfoType5v770extIEsSccpchSystemInformationMBMS(): Choice(&theInfo) {}
};

class SysInfoType5v770extIEs : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SysInfoType5v770extIEs(): Sequence(&theInfo) {}

	void setSysInfoType5v770extIEsModeSpecificInfo(const SysInfoType5v770extIEsModeSpecificInfo& sysInfoType5v770extIEsModeSpecificInfo) { *static_cast<SysInfoType5v770extIEsModeSpecificInfo*>(items[0]) = sysInfoType5v770extIEsModeSpecificInfo; }
	void setSccpchSystemInformationList(const SCCPCHSystemInformationListHCRVHCRr7& sccpchSystemInformationList) { *static_cast<SCCPCHSystemInformationListHCRVHCRr7*>(items[1]) = sccpchSystemInformationList; }
	void setSysInfoType5v770extIEsSccpchSystemInformationMBMS(const SysInfoType5v770extIEsSccpchSystemInformationMBMS& sysInfoType5v770extIEsSccpchSystemInformationMBMS) { *static_cast<SysInfoType5v770extIEsSccpchSystemInformationMBMS*>(items[2]) = sysInfoType5v770extIEsSccpchSystemInformationMBMS; }
	void setTDDMBSFNInformation(const TDDMBSFNInformation& tDDMBSFNInformation) { *static_cast<TDDMBSFNInformation*>(items[3]) = tDDMBSFNInformation; }
};

class SysInfoType5v860extIEsDummy : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType5v860extIEsDummy(): Sequence(&theInfo) {}

};

class SysInfoType5v860extIEsModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType5v860extIEsModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setHsdschDrxCellfachinfo(const HSDSCHDrxCellfachinfo& hsdschDrxCellfachinfo) { *static_cast<HSDSCHDrxCellfachinfo*>(items[0]) = hsdschDrxCellfachinfo; }
};

class SysInfoType5v860extIEsModeSpecificInfoTdd128HsdschCommonSysInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType5v860extIEsModeSpecificInfoTdd128HsdschCommonSysInfo(): Sequence(&theInfo) {}

	void setHsdschCommonSystemInformation(const HSDSCHCommonSystemInformationTDD128& hsdschCommonSystemInformation) { *static_cast<HSDSCHCommonSystemInformationTDD128*>(items[0]) = hsdschCommonSystemInformation; }
	void setHsdschPagingSystemInformation(const HSDSCHPagingSystemInformationTDD128& hsdschPagingSystemInformation) { *static_cast<HSDSCHPagingSystemInformationTDD128*>(items[1]) = hsdschPagingSystemInformation; }
};

class SysInfoType5v860extIEsModeSpecificInfoTdd128 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType5v860extIEsModeSpecificInfoTdd128(): Sequence(&theInfo) {}

	void setSysInfoType5v860extIEsModeSpecificInfoTdd128HsdschCommonSysInfo(const SysInfoType5v860extIEsModeSpecificInfoTdd128HsdschCommonSysInfo& sysInfoType5v860extIEsModeSpecificInfoTdd128HsdschCommonSysInfo) { *static_cast<SysInfoType5v860extIEsModeSpecificInfoTdd128HsdschCommonSysInfo*>(items[0]) = sysInfoType5v860extIEsModeSpecificInfoTdd128HsdschCommonSysInfo; }
	void setHsdschDrxCellfachinfo(const HSDSCHDrxCellfachinfoTDD128& hsdschDrxCellfachinfo) { *static_cast<HSDSCHDrxCellfachinfoTDD128*>(items[1]) = hsdschDrxCellfachinfo; }
};

class SysInfoType5v860extIEsModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum SysInfoType5v860extIEsModeSpecificInfoChoices {
		sysInfoType5v860extIEsModeSpecificInfoFdd = 0,
		sysInfoType5v860extIEsModeSpecificInfoTdd128 = 1,
	};
	static const Info theInfo;
	SysInfoType5v860extIEsModeSpecificInfo(): Choice(&theInfo) {}
};

class SysInfoType5v860extIEs : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType5v860extIEs(): Sequence(&theInfo) {}

	void setSysInfoType5v860extIEsDummy(const SysInfoType5v860extIEsDummy& sysInfoType5v860extIEsDummy) { *static_cast<SysInfoType5v860extIEsDummy*>(items[0]) = sysInfoType5v860extIEsDummy; }
	void setSysInfoType5v860extIEsModeSpecificInfo(const SysInfoType5v860extIEsModeSpecificInfo& sysInfoType5v860extIEsModeSpecificInfo) { *static_cast<SysInfoType5v860extIEsModeSpecificInfo*>(items[1]) = sysInfoType5v860extIEsModeSpecificInfo; }
};

class SysInfoType5v890extIEs : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType5v890extIEs(): Sequence(&theInfo) {}

	void setSecondFrequencyInfo(const FrequencyInfoTDD& secondFrequencyInfo) { *static_cast<FrequencyInfoTDD*>(items[0]) = secondFrequencyInfo; }
	void setCommonEDCHSystemInfo(const CommonEDCHSystemInfo& commonEDCHSystemInfo) { *static_cast<CommonEDCHSystemInfo*>(items[1]) = commonEDCHSystemInfo; }
};

enum SysInfoType5v8b0extIEstresetUsageIndicatorValues {
	true_SysInfoType5v8b0extIEstresetUsageIndicator = 0,
};
typedef Enumerated<CONSTRAINED, 0> SysInfoType5v8b0extIEstresetUsageIndicator;

class SysInfoType5v8b0extIEs : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType5v8b0extIEs(): Sequence(&theInfo) {}

	void setSysInfoType5v8b0extIEstresetUsageIndicator(const SysInfoType5v8b0extIEstresetUsageIndicator& sysInfoType5v8b0extIEstresetUsageIndicator) { *static_cast<SysInfoType5v8b0extIEstresetUsageIndicator*>(items[0]) = sysInfoType5v8b0extIEstresetUsageIndicator; }
	void setUpPCHpositionInfo(const UpPCHpositionLCR& upPCHpositionInfo) { *static_cast<UpPCHpositionLCR*>(items[1]) = upPCHpositionInfo; }
};

class SysInfoType5v8d0extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType5v8d0extIEs(): Sequence(&theInfo) {}

	void setCommonEDCHSystemInfoFDD(const CommonEDCHSystemInfoFDD& commonEDCHSystemInfoFDD) { *static_cast<CommonEDCHSystemInfoFDD*>(items[0]) = commonEDCHSystemInfoFDD; }
};

class SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensionsV8d0NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensionsV8d0NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensionsV8d0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensionsV8d0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType5v8d0ext(const SysInfoType5v8d0extIEs& sysInfoType5v8d0ext) { *static_cast<SysInfoType5v8d0extIEs*>(items[0]) = sysInfoType5v8d0ext; }
	void setSysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensionsV8d0NonCriticalExtensionsNonCriticalExtensions(const SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensionsV8d0NonCriticalExtensionsNonCriticalExtensions& sysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensionsV8d0NonCriticalExtensionsNonCriticalExtensions) { *static_cast<SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensionsV8d0NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = sysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensionsV8d0NonCriticalExtensionsNonCriticalExtensions; }
};

class SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType5v8b0ext(const SysInfoType5v8b0extIEs& sysInfoType5v8b0ext) { *static_cast<SysInfoType5v8b0extIEs*>(items[0]) = sysInfoType5v8b0ext; }
	void setSysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensionsV8d0NonCriticalExtensions(const SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensionsV8d0NonCriticalExtensions& sysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensionsV8d0NonCriticalExtensions) { *static_cast<SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensionsV8d0NonCriticalExtensions*>(items[1]) = sysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensionsV8d0NonCriticalExtensions; }
};

class SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType5v890ext(const SysInfoType5v890extIEs& sysInfoType5v890ext) { *static_cast<SysInfoType5v890extIEs*>(items[0]) = sysInfoType5v890ext; }
	void setSysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensions(const SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensions& sysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensions) { *static_cast<SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensions*>(items[1]) = sysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensionsV8b0NonCriticalExtensions; }
};

class SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType5v860ext(const SysInfoType5v860extIEs& sysInfoType5v860ext) { *static_cast<SysInfoType5v860extIEs*>(items[0]) = sysInfoType5v860ext; }
	void setSysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensions(const SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensions& sysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensions) { *static_cast<SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensions*>(items[1]) = sysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensionsV890NonCriticalExtensions; }
};

class SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType5v770ext(const SysInfoType5v770extIEs& sysInfoType5v770ext) { *static_cast<SysInfoType5v770extIEs*>(items[0]) = sysInfoType5v770ext; }
	void setSysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensions(const SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensions& sysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensions) { *static_cast<SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensions*>(items[1]) = sysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensionsV860NonCriticalExtensions; }
};

class SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType5v690ext(const SysInfoType5v690extIEs& sysInfoType5v690ext) { *static_cast<SysInfoType5v690extIEs*>(items[0]) = sysInfoType5v690ext; }
	void setSysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensions(const SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensions& sysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensions) { *static_cast<SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensions*>(items[1]) = sysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensionsV770NonCriticalExtensions; }
};

class SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType5v680ext(const SysInfoType5v680extIEs& sysInfoType5v680ext) { *static_cast<SysInfoType5v680extIEs*>(items[0]) = sysInfoType5v680ext; }
	void setSysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensions(const SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensions& sysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensions) { *static_cast<SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensions*>(items[1]) = sysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensionsV690NonCriticalExtensions; }
};

class SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType5v650ext(const SysInfoType5v650extIEs& sysInfoType5v650ext) { *static_cast<SysInfoType5v650extIEs*>(items[0]) = sysInfoType5v650ext; }
	void setSysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensions(const SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensions& sysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensions) { *static_cast<SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensions*>(items[1]) = sysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensionsV680NonCriticalExtensions; }
};

class SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType5v590ext(const SysInfoType5v590extIEs& sysInfoType5v590ext) { *static_cast<SysInfoType5v590extIEs*>(items[0]) = sysInfoType5v590ext; }
	void setSysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensions(const SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensions& sysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensions) { *static_cast<SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensions*>(items[1]) = sysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650NonCriticalExtensions; }
};

class SysInfoType5V4b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType5V4b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType5v4b0ext(const SysInfoType5v4b0extIEs& sysInfoType5v4b0ext) { *static_cast<SysInfoType5v4b0extIEs*>(items[0]) = sysInfoType5v4b0ext; }
	void setSysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensions(const SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensions& sysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensions) { *static_cast<SysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensions*>(items[1]) = sysInfoType5V4b0NonCriticalExtensionsV590NonCriticalExtensions; }
};

class SysInfoType5 : public Sequence {
private:
	static const void *itemsInfo[8];
	static bool itemsPres[8];
public:
	static const Info theInfo;
	SysInfoType5(): Sequence(&theInfo) {}

	void setSysInfoType5Sib6indicator(const SysInfoType5Sib6indicator& sysInfoType5Sib6indicator) { *static_cast<SysInfoType5Sib6indicator*>(items[0]) = sysInfoType5Sib6indicator; }
	void setPichPowerOffset(const PICHPowerOffset& pichPowerOffset) { *static_cast<PICHPowerOffset*>(items[1]) = pichPowerOffset; }
	void setSysInfoType5ModeSpecificInfo(const SysInfoType5ModeSpecificInfo& sysInfoType5ModeSpecificInfo) { *static_cast<SysInfoType5ModeSpecificInfo*>(items[2]) = sysInfoType5ModeSpecificInfo; }
	void setPrimaryCCPCHInfo(const PrimaryCCPCHInfo& primaryCCPCHInfo) { *static_cast<PrimaryCCPCHInfo*>(items[3]) = primaryCCPCHInfo; }
	void setPrachSystemInformationList(const PRACHSystemInformationList& prachSystemInformationList) { *static_cast<PRACHSystemInformationList*>(items[4]) = prachSystemInformationList; }
	void setSCCPCHSystemInformationList(const SCCPCHSystemInformationList& sCCPCHSystemInformationList) { *static_cast<SCCPCHSystemInformationList*>(items[5]) = sCCPCHSystemInformationList; }
	void setCbsDRXLevel1Information(const CBSDRXLevel1Information& cbsDRXLevel1Information) { *static_cast<CBSDRXLevel1Information*>(items[6]) = cbsDRXLevel1Information; }
	void setSysInfoType5V4b0NonCriticalExtensions(const SysInfoType5V4b0NonCriticalExtensions& sysInfoType5V4b0NonCriticalExtensions) { *static_cast<SysInfoType5V4b0NonCriticalExtensions*>(items[7]) = sysInfoType5V4b0NonCriticalExtensions; }
};

typedef SysInfoType5 SysInfoType5bis;

class SysInfoType6ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType6ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setAichPowerOffset(const AICHPowerOffset& aichPowerOffset) { *static_cast<AICHPowerOffset*>(items[0]) = aichPowerOffset; }
	void setDummy(const CSICHPowerOffset& dummy) { *static_cast<CSICHPowerOffset*>(items[1]) = dummy; }
};

class SysInfoType6ModeSpecificInfoTdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SysInfoType6ModeSpecificInfoTdd(): Sequence(&theInfo) {}

	void setPuschSysInfoListSFN(const PUSCHSysInfoListSFN& puschSysInfoListSFN) { *static_cast<PUSCHSysInfoListSFN*>(items[0]) = puschSysInfoListSFN; }
	void setPdschSysInfoListSFN(const PDSCHSysInfoListSFN& pdschSysInfoListSFN) { *static_cast<PDSCHSysInfoListSFN*>(items[1]) = pdschSysInfoListSFN; }
	void setOpenLoopPowerControlTDD(const OpenLoopPowerControlTDD& openLoopPowerControlTDD) { *static_cast<OpenLoopPowerControlTDD*>(items[2]) = openLoopPowerControlTDD; }
};

class SysInfoType6ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum SysInfoType6ModeSpecificInfoChoices {
		sysInfoType6ModeSpecificInfoFdd = 0,
		sysInfoType6ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	SysInfoType6ModeSpecificInfo(): Choice(&theInfo) {}
};

class SysInfoType6v4b0extIEsTdd128SpecificInfo : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SysInfoType6v4b0extIEsTdd128SpecificInfo(): Sequence(&theInfo) {}

	void setPuschSysInfoListSFN(const PUSCHSysInfoListSFNLCRr4& puschSysInfoListSFN) { *static_cast<PUSCHSysInfoListSFNLCRr4*>(items[0]) = puschSysInfoListSFN; }
	void setPdschSysInfoListSFN(const PDSCHSysInfoListSFNLCRr4& pdschSysInfoListSFN) { *static_cast<PDSCHSysInfoListSFNLCRr4*>(items[1]) = pdschSysInfoListSFN; }
	void setPCCPCHLCRExtensions(const PrimaryCCPCHInfoLCRr4ext& pCCPCHLCRExtensions) { *static_cast<PrimaryCCPCHInfoLCRr4ext*>(items[2]) = pCCPCHLCRExtensions; }
	void setSCCPCHLCRExtensionsList(const SCCPCHSystemInformationListLCRr4ext& sCCPCHLCRExtensionsList) { *static_cast<SCCPCHSystemInformationListLCRr4ext*>(items[3]) = sCCPCHLCRExtensionsList; }
};

class SysInfoType6v4b0extIEs : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SysInfoType6v4b0extIEs(): Sequence(&theInfo) {}

	void setOpenLoopPowerControlIPDLTDD(const OpenLoopPowerControlIPDLTDDr4& openLoopPowerControlIPDLTDD) { *static_cast<OpenLoopPowerControlIPDLTDDr4*>(items[0]) = openLoopPowerControlIPDLTDD; }
	void setPrachSystemInformationListLCRr4(const PRACHSystemInformationListLCRr4& prachSystemInformationListLCRr4) { *static_cast<PRACHSystemInformationListLCRr4*>(items[1]) = prachSystemInformationListLCRr4; }
	void setSysInfoType6v4b0extIEsTdd128SpecificInfo(const SysInfoType6v4b0extIEsTdd128SpecificInfo& sysInfoType6v4b0extIEsTdd128SpecificInfo) { *static_cast<SysInfoType6v4b0extIEsTdd128SpecificInfo*>(items[2]) = sysInfoType6v4b0extIEsTdd128SpecificInfo; }
	void setFrequencyBandIndicator(const RadioFrequencyBandFDD& frequencyBandIndicator) { *static_cast<RadioFrequencyBandFDD*>(items[3]) = frequencyBandIndicator; }
};

class SysInfoType6v590extIEsHcrr5SpecificInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType6v590extIEsHcrr5SpecificInfo(): Sequence(&theInfo) {}

	void setPuschSysInfoListSFN(const PUSCHSysInfoListSFNHCRr5& puschSysInfoListSFN) { *static_cast<PUSCHSysInfoListSFNHCRr5*>(items[0]) = puschSysInfoListSFN; }
	void setPdschSysInfoListSFN(const PDSCHSysInfoListSFNHCRr5& pdschSysInfoListSFN) { *static_cast<PDSCHSysInfoListSFNHCRr5*>(items[1]) = pdschSysInfoListSFN; }
};

class SysInfoType6v590extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType6v590extIEs(): Sequence(&theInfo) {}

	void setSysInfoType6v590extIEsHcrr5SpecificInfo(const SysInfoType6v590extIEsHcrr5SpecificInfo& sysInfoType6v590extIEsHcrr5SpecificInfo) { *static_cast<SysInfoType6v590extIEsHcrr5SpecificInfo*>(items[0]) = sysInfoType6v590extIEsHcrr5SpecificInfo; }
};

class SysInfoType6v650extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType6v650extIEs(): Sequence(&theInfo) {}

	void setFrequencyBandIndicator2(const RadioFrequencyBandFDD2& frequencyBandIndicator2) { *static_cast<RadioFrequencyBandFDD2*>(items[0]) = frequencyBandIndicator2; }
};

class SysInfoType6v690extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType6v690extIEs(): Sequence(&theInfo) {}

	void setAdditionalPRACHTFandTFCSCCCHList(const AdditionalPRACHTFandTFCSCCCHList& additionalPRACHTFandTFCSCCCHList) { *static_cast<AdditionalPRACHTFandTFCSCCCHList*>(items[0]) = additionalPRACHTFandTFCSCCCHList; }
};

class SysInfoType6v770extIEsTdd768SpecificInfo : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SysInfoType6v770extIEsTdd768SpecificInfo(): Sequence(&theInfo) {}

	void setPuschSysInfoListSFN(const PUSCHSysInfoListSFNVHCR& puschSysInfoListSFN) { *static_cast<PUSCHSysInfoListSFNVHCR*>(items[0]) = puschSysInfoListSFN; }
	void setPdschSysInfoListSFN(const PDSCHSysInfoListVHCRr7& pdschSysInfoListSFN) { *static_cast<PDSCHSysInfoListVHCRr7*>(items[1]) = pdschSysInfoListSFN; }
	void setPrachSystemInformationList(const PRACHSystemInformationListVHCRr7& prachSystemInformationList) { *static_cast<PRACHSystemInformationListVHCRr7*>(items[2]) = prachSystemInformationList; }
};

class SysInfoType6v770extIEs : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType6v770extIEs(): Sequence(&theInfo) {}

	void setSysInfoType6v770extIEsTdd768SpecificInfo(const SysInfoType6v770extIEsTdd768SpecificInfo& sysInfoType6v770extIEsTdd768SpecificInfo) { *static_cast<SysInfoType6v770extIEsTdd768SpecificInfo*>(items[0]) = sysInfoType6v770extIEsTdd768SpecificInfo; }
	void setSccpchSystemInformationList(const SCCPCHSystemInformationListHCRVHCRr7& sccpchSystemInformationList) { *static_cast<SCCPCHSystemInformationListHCRVHCRr7*>(items[1]) = sccpchSystemInformationList; }
};

class SysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensionsV770NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensionsV770NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType6v770ext(const SysInfoType6v770extIEs& sysInfoType6v770ext) { *static_cast<SysInfoType6v770extIEs*>(items[0]) = sysInfoType6v770ext; }
	void setSysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions(const SysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions& sysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions) { *static_cast<SysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = sysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions; }
};

class SysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType6v690ext(const SysInfoType6v690extIEs& sysInfoType6v690ext) { *static_cast<SysInfoType6v690extIEs*>(items[0]) = sysInfoType6v690ext; }
	void setSysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensionsV770NonCriticalExtensions(const SysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensionsV770NonCriticalExtensions& sysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensionsV770NonCriticalExtensions) { *static_cast<SysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensionsV770NonCriticalExtensions*>(items[1]) = sysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensionsV770NonCriticalExtensions; }
};

class SysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType6v650ext(const SysInfoType6v650extIEs& sysInfoType6v650ext) { *static_cast<SysInfoType6v650extIEs*>(items[0]) = sysInfoType6v650ext; }
	void setSysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensions(const SysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensions& sysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensions) { *static_cast<SysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensions*>(items[1]) = sysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensionsV690nonCriticalExtensions; }
};

class SysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType6v590ext(const SysInfoType6v590extIEs& sysInfoType6v590ext) { *static_cast<SysInfoType6v590extIEs*>(items[0]) = sysInfoType6v590ext; }
	void setSysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensions(const SysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensions& sysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensions) { *static_cast<SysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensions*>(items[1]) = sysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensionsV650nonCriticalExtensions; }
};

class SysInfoType6V4b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType6V4b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType6v4b0ext(const SysInfoType6v4b0extIEs& sysInfoType6v4b0ext) { *static_cast<SysInfoType6v4b0extIEs*>(items[0]) = sysInfoType6v4b0ext; }
	void setSysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensions(const SysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensions& sysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensions) { *static_cast<SysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensions*>(items[1]) = sysInfoType6V4b0NonCriticalExtensionsV590NonCriticalExtensions; }
};

class SysInfoType6 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	SysInfoType6(): Sequence(&theInfo) {}

	void setPichPowerOffset(const PICHPowerOffset& pichPowerOffset) { *static_cast<PICHPowerOffset*>(items[0]) = pichPowerOffset; }
	void setSysInfoType6ModeSpecificInfo(const SysInfoType6ModeSpecificInfo& sysInfoType6ModeSpecificInfo) { *static_cast<SysInfoType6ModeSpecificInfo*>(items[1]) = sysInfoType6ModeSpecificInfo; }
	void setPrimaryCCPCHInfo(const PrimaryCCPCHInfo& primaryCCPCHInfo) { *static_cast<PrimaryCCPCHInfo*>(items[2]) = primaryCCPCHInfo; }
	void setPrachSystemInformationList(const PRACHSystemInformationList& prachSystemInformationList) { *static_cast<PRACHSystemInformationList*>(items[3]) = prachSystemInformationList; }
	void setSCCPCHSystemInformationList(const SCCPCHSystemInformationList& sCCPCHSystemInformationList) { *static_cast<SCCPCHSystemInformationList*>(items[4]) = sCCPCHSystemInformationList; }
	void setCbsDRXLevel1Information(const CBSDRXLevel1Information& cbsDRXLevel1Information) { *static_cast<CBSDRXLevel1Information*>(items[5]) = cbsDRXLevel1Information; }
	void setSysInfoType6V4b0NonCriticalExtensions(const SysInfoType6V4b0NonCriticalExtensions& sysInfoType6V4b0NonCriticalExtensions) { *static_cast<SysInfoType6V4b0NonCriticalExtensions*>(items[6]) = sysInfoType6V4b0NonCriticalExtensions; }
};

class SysInfoType7ModeSpecificInfoFdd : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType7ModeSpecificInfoFdd(): Sequence(&theInfo) {}

	void setUlInterference(const ULInterference& ulInterference) { *static_cast<ULInterference*>(items[0]) = ulInterference; }
};

typedef Null SysInfoType7ModeSpecificInfoTdd;

class SysInfoType7ModeSpecificInfo : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum SysInfoType7ModeSpecificInfoChoices {
		sysInfoType7ModeSpecificInfoFdd = 0,
		sysInfoType7ModeSpecificInfoTdd = 1,
	};
	static const Info theInfo;
	SysInfoType7ModeSpecificInfo(): Choice(&theInfo) {}
};

class SysInfoType7NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType7NonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType7 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	SysInfoType7(): Sequence(&theInfo) {}

	void setSysInfoType7ModeSpecificInfo(const SysInfoType7ModeSpecificInfo& sysInfoType7ModeSpecificInfo) { *static_cast<SysInfoType7ModeSpecificInfo*>(items[0]) = sysInfoType7ModeSpecificInfo; }
	void setPrachInformationSIB5List(const DynamicPersistenceLevelList& prachInformationSIB5List) { *static_cast<DynamicPersistenceLevelList*>(items[1]) = prachInformationSIB5List; }
	void setPrachInformationSIB6List(const DynamicPersistenceLevelList& prachInformationSIB6List) { *static_cast<DynamicPersistenceLevelList*>(items[2]) = prachInformationSIB6List; }
	void setExpirationTimeFactor(const ExpirationTimeFactor& expirationTimeFactor) { *static_cast<ExpirationTimeFactor*>(items[3]) = expirationTimeFactor; }
	void setSysInfoType7NonCriticalExtensions(const SysInfoType7NonCriticalExtensions& sysInfoType7NonCriticalExtensions) { *static_cast<SysInfoType7NonCriticalExtensions*>(items[4]) = sysInfoType7NonCriticalExtensions; }
};

class SysInfoType8NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType8NonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType8 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SysInfoType8(): Sequence(&theInfo) {}

	void setDummy1(const CPCHParameters& dummy1) { *static_cast<CPCHParameters*>(items[0]) = dummy1; }
	void setDummy2(const CPCHSetInfoList& dummy2) { *static_cast<CPCHSetInfoList*>(items[1]) = dummy2; }
	void setDummy3(const CSICHPowerOffset& dummy3) { *static_cast<CSICHPowerOffset*>(items[2]) = dummy3; }
	void setSysInfoType8NonCriticalExtensions(const SysInfoType8NonCriticalExtensions& sysInfoType8NonCriticalExtensions) { *static_cast<SysInfoType8NonCriticalExtensions*>(items[3]) = sysInfoType8NonCriticalExtensions; }
};

class SysInfoType9NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType9NonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType9 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType9(): Sequence(&theInfo) {}

	void setDummy(const CPCHPersistenceLevelsList& dummy) { *static_cast<CPCHPersistenceLevelsList*>(items[0]) = dummy; }
	void setSysInfoType9NonCriticalExtensions(const SysInfoType9NonCriticalExtensions& sysInfoType9NonCriticalExtensions) { *static_cast<SysInfoType9NonCriticalExtensions*>(items[1]) = sysInfoType9NonCriticalExtensions; }
};

class SysInfoType10NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType10NonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType10 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType10(): Sequence(&theInfo) {}

	void setDummy(const DRACSysInfoList& dummy) { *static_cast<DRACSysInfoList*>(items[0]) = dummy; }
	void setSysInfoType10NonCriticalExtensions(const SysInfoType10NonCriticalExtensions& sysInfoType10NonCriticalExtensions) { *static_cast<SysInfoType10NonCriticalExtensions*>(items[1]) = sysInfoType10NonCriticalExtensions; }
};

typedef Boolean SysInfoType11Sib12indicator;

class SysInfoType11v4b0extIEs : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType11v4b0extIEs(): Sequence(&theInfo) {}

	void setFachMeasurementOccasionInfoLCRExt(const FACHMeasurementOccasionInfoLCRr4ext& fachMeasurementOccasionInfoLCRExt) { *static_cast<FACHMeasurementOccasionInfoLCRr4ext*>(items[0]) = fachMeasurementOccasionInfoLCRExt; }
	void setMeasurementControlSysInfoLCR(const MeasurementControlSysInfoLCRr4ext& measurementControlSysInfoLCR) { *static_cast<MeasurementControlSysInfoLCRr4ext*>(items[1]) = measurementControlSysInfoLCR; }
};

typedef SequenceOf<CellSelectReselectInfov590ext, CONSTRAINED, 1, maxCellMeas> SysInfoType11v590extIEsNewIntraFrequencyCellInfoListv590ext;

typedef SequenceOf<CellSelectReselectInfov590ext, CONSTRAINED, 1, maxCellMeas> SysInfoType11v590extIEsNewInterFrequencyCellInfoListv590ext;

typedef SequenceOf<CellSelectReselectInfov590ext, CONSTRAINED, 1, maxCellMeas> SysInfoType11v590extIEsNewInterRATCellInfoListv590ext;

class SysInfoType11v590extIEs : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	SysInfoType11v590extIEs(): Sequence(&theInfo) {}

	void setSysInfoType11v590extIEsNewIntraFrequencyCellInfoListv590ext(const SysInfoType11v590extIEsNewIntraFrequencyCellInfoListv590ext& sysInfoType11v590extIEsNewIntraFrequencyCellInfoListv590ext) { *static_cast<SysInfoType11v590extIEsNewIntraFrequencyCellInfoListv590ext*>(items[0]) = sysInfoType11v590extIEsNewIntraFrequencyCellInfoListv590ext; }
	void setSysInfoType11v590extIEsNewInterFrequencyCellInfoListv590ext(const SysInfoType11v590extIEsNewInterFrequencyCellInfoListv590ext& sysInfoType11v590extIEsNewInterFrequencyCellInfoListv590ext) { *static_cast<SysInfoType11v590extIEsNewInterFrequencyCellInfoListv590ext*>(items[1]) = sysInfoType11v590extIEsNewInterFrequencyCellInfoListv590ext; }
	void setSysInfoType11v590extIEsNewInterRATCellInfoListv590ext(const SysInfoType11v590extIEsNewInterRATCellInfoListv590ext& sysInfoType11v590extIEsNewInterRATCellInfoListv590ext) { *static_cast<SysInfoType11v590extIEsNewInterRATCellInfoListv590ext*>(items[2]) = sysInfoType11v590extIEsNewInterRATCellInfoListv590ext; }
	void setIntraFreqEventCriteriaListv590ext(const IntraFreqEventCriteriaListv590ext& intraFreqEventCriteriaListv590ext) { *static_cast<IntraFreqEventCriteriaListv590ext*>(items[3]) = intraFreqEventCriteriaListv590ext; }
	void setIntraFreqReportingCriteria1br5(const IntraFreqReportingCriteria1br5& intraFreqReportingCriteria1br5) { *static_cast<IntraFreqReportingCriteria1br5*>(items[4]) = intraFreqReportingCriteria1br5; }
	void setIntraFreqEvent1dr5(const IntraFreqEvent1dr5& intraFreqEvent1dr5) { *static_cast<IntraFreqEvent1dr5*>(items[5]) = intraFreqEvent1dr5; }
};

class SysInfoType11v690extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType11v690extIEs(): Sequence(&theInfo) {}

	void setDummy(const DummyInterFreqRACHReportingInfo& dummy) { *static_cast<DummyInterFreqRACHReportingInfo*>(items[0]) = dummy; }
};

class SysInfoType11v6b0extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType11v6b0extIEs(): Sequence(&theInfo) {}

	void setInterFreqRACHReportingInfo(const InterFreqRACHReportingInfo& interFreqRACHReportingInfo) { *static_cast<InterFreqRACHReportingInfo*>(items[0]) = interFreqRACHReportingInfo; }
};

class MBSFNFrequency : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBSFNFrequency(): Sequence(&theInfo) {}

	void setFrequencyInfo(const FrequencyInfo& frequencyInfo) { *static_cast<FrequencyInfo*>(items[0]) = frequencyInfo; }
	void setCellParametersID(const CellParametersID& cellParametersID) { *static_cast<CellParametersID*>(items[1]) = cellParametersID; }
};

typedef SequenceOf<MBSFNFrequency, CONSTRAINED, 0, maxMBSFNClusters> MBSFNFrequencyList;

class SysInfoType11v770extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType11v770extIEs(): Sequence(&theInfo) {}

	void setMbsfnFrequencyList(const MBSFNFrequencyList& mbsfnFrequencyList) { *static_cast<MBSFNFrequencyList*>(items[0]) = mbsfnFrequencyList; }
};

class SysInfoType11v7b0extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType11v7b0extIEs(): Sequence(&theInfo) {}

	void setNewInterFreqCellList(const NewInterFreqCellListv7b0ext& newInterFreqCellList) { *static_cast<NewInterFreqCellListv7b0ext*>(items[0]) = newInterFreqCellList; }
};

enum MBSFNFrequencyv860extimb_IndicationValues {
	true_MBSFNFrequencyv860extimb_Indication = 0,
};
typedef Enumerated<CONSTRAINED, 0> MBSFNFrequencyv860extimb_Indication;

class MBSFNFrequencyv860ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MBSFNFrequencyv860ext(): Sequence(&theInfo) {}

	void setMBSFNFrequencyv860extimb_Indication(const MBSFNFrequencyv860extimb_Indication& mBSFNFrequencyv860extimb_Indication) { *static_cast<MBSFNFrequencyv860extimb_Indication*>(items[0]) = mBSFNFrequencyv860extimb_Indication; }
};

typedef SequenceOf<MBSFNFrequencyv860ext, CONSTRAINED, 0, maxMBSFNClusters> MBSFNFrequencyListv860ext;

class SysInfoType11v860extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType11v860extIEs(): Sequence(&theInfo) {}

	void setMbsfnFrequencyList(const MBSFNFrequencyListv860ext& mbsfnFrequencyList) { *static_cast<MBSFNFrequencyListv860ext*>(items[0]) = mbsfnFrequencyList; }
};

class SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensionsV860NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensionsV860NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType11v860ext(const SysInfoType11v860extIEs& sysInfoType11v860ext) { *static_cast<SysInfoType11v860extIEs*>(items[0]) = sysInfoType11v860ext; }
	void setSysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions(const SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions& sysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions) { *static_cast<SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = sysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions; }
};

class SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType11v7b0ext(const SysInfoType11v7b0extIEs& sysInfoType11v7b0ext) { *static_cast<SysInfoType11v7b0extIEs*>(items[0]) = sysInfoType11v7b0ext; }
	void setSysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensionsV860NonCriticalExtensions(const SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensionsV860NonCriticalExtensions& sysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensionsV860NonCriticalExtensions) { *static_cast<SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensionsV860NonCriticalExtensions*>(items[1]) = sysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensionsV860NonCriticalExtensions; }
};

class SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType11v770ext(const SysInfoType11v770extIEs& sysInfoType11v770ext) { *static_cast<SysInfoType11v770extIEs*>(items[0]) = sysInfoType11v770ext; }
	void setSysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensions(const SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensions& sysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensions) { *static_cast<SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensions*>(items[1]) = sysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensionsV7b0NonCriticalExtensions; }
};

class SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType11v6b0ext(const SysInfoType11v6b0extIEs& sysInfoType11v6b0ext) { *static_cast<SysInfoType11v6b0extIEs*>(items[0]) = sysInfoType11v6b0ext; }
	void setSysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensions(const SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensions& sysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensions) { *static_cast<SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensions*>(items[1]) = sysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV770NonCriticalExtensions; }
};

class SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType11v690ext(const SysInfoType11v690extIEs& sysInfoType11v690ext) { *static_cast<SysInfoType11v690extIEs*>(items[0]) = sysInfoType11v690ext; }
	void setSysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensions(const SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensions& sysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensions) { *static_cast<SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensions*>(items[1]) = sysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensions; }
};

class SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtension : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtension(): Sequence(&theInfo) {}

	void setSysInfoType11v590ext(const SysInfoType11v590extIEs& sysInfoType11v590ext) { *static_cast<SysInfoType11v590extIEs*>(items[0]) = sysInfoType11v590ext; }
	void setSysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensions(const SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensions& sysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensions) { *static_cast<SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensions*>(items[1]) = sysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensions; }
};

class SysInfoType11V4b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType11V4b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType11v4b0ext(const SysInfoType11v4b0extIEs& sysInfoType11v4b0ext) { *static_cast<SysInfoType11v4b0extIEs*>(items[0]) = sysInfoType11v4b0ext; }
	void setSysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtension(const SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtension& sysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtension) { *static_cast<SysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtension*>(items[1]) = sysInfoType11V4b0NonCriticalExtensionsV590NonCriticalExtension; }
};

class SysInfoType11 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SysInfoType11(): Sequence(&theInfo) {}

	void setSysInfoType11Sib12indicator(const SysInfoType11Sib12indicator& sysInfoType11Sib12indicator) { *static_cast<SysInfoType11Sib12indicator*>(items[0]) = sysInfoType11Sib12indicator; }
	void setFachMeasurementOccasionInfo(const FACHMeasurementOccasionInfo& fachMeasurementOccasionInfo) { *static_cast<FACHMeasurementOccasionInfo*>(items[1]) = fachMeasurementOccasionInfo; }
	void setMeasurementControlSysInfo(const MeasurementControlSysInfo& measurementControlSysInfo) { *static_cast<MeasurementControlSysInfo*>(items[2]) = measurementControlSysInfo; }
	void setSysInfoType11V4b0NonCriticalExtensions(const SysInfoType11V4b0NonCriticalExtensions& sysInfoType11V4b0NonCriticalExtensions) { *static_cast<SysInfoType11V4b0NonCriticalExtensions*>(items[3]) = sysInfoType11V4b0NonCriticalExtensions; }
};

class SysInfoType11bisv7b0extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType11bisv7b0extIEs(): Sequence(&theInfo) {}

	void setNewInterFreqCellList(const NewInterFreqCellListv7b0ext& newInterFreqCellList) { *static_cast<NewInterFreqCellListv7b0ext*>(items[0]) = newInterFreqCellList; }
};

class SysInfoType11bisv860extIEs : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType11bisv860extIEs(): Sequence(&theInfo) {}

	void setCsgPSCSplitInfo(const CSGPSCSplitInfo& csgPSCSplitInfo) { *static_cast<CSGPSCSplitInfo*>(items[0]) = csgPSCSplitInfo; }
	void setCsgDedicatedFrequencyInfoList(const CSGDedicatedFrequencyInfoList& csgDedicatedFrequencyInfoList) { *static_cast<CSGDedicatedFrequencyInfoList*>(items[1]) = csgDedicatedFrequencyInfoList; }
};

class SysInfoType11bisV7b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType11bisV7b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType11bisV7b0NonCriticalExtensionsV860NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType11bisV7b0NonCriticalExtensionsV860NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType11bisv860ext(const SysInfoType11bisv860extIEs& sysInfoType11bisv860ext) { *static_cast<SysInfoType11bisv860extIEs*>(items[0]) = sysInfoType11bisv860ext; }
	void setSysInfoType11bisV7b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions(const SysInfoType11bisV7b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions& sysInfoType11bisV7b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions) { *static_cast<SysInfoType11bisV7b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = sysInfoType11bisV7b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions; }
};

class SysInfoType11bisV7b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType11bisV7b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType11bisv7b0ext(const SysInfoType11bisv7b0extIEs& sysInfoType11bisv7b0ext) { *static_cast<SysInfoType11bisv7b0extIEs*>(items[0]) = sysInfoType11bisv7b0ext; }
	void setSysInfoType11bisV7b0NonCriticalExtensionsV860NonCriticalExtensions(const SysInfoType11bisV7b0NonCriticalExtensionsV860NonCriticalExtensions& sysInfoType11bisV7b0NonCriticalExtensionsV860NonCriticalExtensions) { *static_cast<SysInfoType11bisV7b0NonCriticalExtensionsV860NonCriticalExtensions*>(items[1]) = sysInfoType11bisV7b0NonCriticalExtensionsV860NonCriticalExtensions; }
};

class SysInfoType11bis : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SysInfoType11bis(): Sequence(&theInfo) {}

	void setMeasurementControlSysInfo(const MeasurementControlSysInfoExtension& measurementControlSysInfo) { *static_cast<MeasurementControlSysInfoExtension*>(items[0]) = measurementControlSysInfo; }
	void setMeasurementControlSysInfoLCR(const MeasurementControlSysInfoExtensionLCRr4& measurementControlSysInfoLCR) { *static_cast<MeasurementControlSysInfoExtensionLCRr4*>(items[1]) = measurementControlSysInfoLCR; }
	void setMeasurementControlSysInfoExtensionAddonr5(const MeasurementControlSysInfoExtensionAddonr5& measurementControlSysInfoExtensionAddonr5) { *static_cast<MeasurementControlSysInfoExtensionAddonr5*>(items[2]) = measurementControlSysInfoExtensionAddonr5; }
	void setSysInfoType11bisV7b0NonCriticalExtensions(const SysInfoType11bisV7b0NonCriticalExtensions& sysInfoType11bisV7b0NonCriticalExtensions) { *static_cast<SysInfoType11bisV7b0NonCriticalExtensions*>(items[3]) = sysInfoType11bisV7b0NonCriticalExtensions; }
};

class SysInfoType12v4b0extIEs : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType12v4b0extIEs(): Sequence(&theInfo) {}

	void setFachMeasurementOccasionInfoLCRExt(const FACHMeasurementOccasionInfoLCRr4ext& fachMeasurementOccasionInfoLCRExt) { *static_cast<FACHMeasurementOccasionInfoLCRr4ext*>(items[0]) = fachMeasurementOccasionInfoLCRExt; }
	void setMeasurementControlSysInfoLCR(const MeasurementControlSysInfoLCRr4ext& measurementControlSysInfoLCR) { *static_cast<MeasurementControlSysInfoLCRr4ext*>(items[1]) = measurementControlSysInfoLCR; }
};

typedef SequenceOf<CellSelectReselectInfov590ext, CONSTRAINED, 1, maxCellMeas> SysInfoType12v590extIEsNewIntraFrequencyCellInfoListv590ext;

typedef SequenceOf<CellSelectReselectInfov590ext, CONSTRAINED, 1, maxCellMeas> SysInfoType12v590extIEsNewInterFrequencyCellInfoListv590ext;

typedef SequenceOf<CellSelectReselectInfov590ext, CONSTRAINED, 1, maxCellMeas> SysInfoType12v590extIEsNewInterRATCellInfoListv590ext;

class SysInfoType12v590extIEs : public Sequence {
private:
	static const void *itemsInfo[6];
	static bool itemsPres[6];
public:
	static const Info theInfo;
	SysInfoType12v590extIEs(): Sequence(&theInfo) {}

	void setSysInfoType12v590extIEsNewIntraFrequencyCellInfoListv590ext(const SysInfoType12v590extIEsNewIntraFrequencyCellInfoListv590ext& sysInfoType12v590extIEsNewIntraFrequencyCellInfoListv590ext) { *static_cast<SysInfoType12v590extIEsNewIntraFrequencyCellInfoListv590ext*>(items[0]) = sysInfoType12v590extIEsNewIntraFrequencyCellInfoListv590ext; }
	void setSysInfoType12v590extIEsNewInterFrequencyCellInfoListv590ext(const SysInfoType12v590extIEsNewInterFrequencyCellInfoListv590ext& sysInfoType12v590extIEsNewInterFrequencyCellInfoListv590ext) { *static_cast<SysInfoType12v590extIEsNewInterFrequencyCellInfoListv590ext*>(items[1]) = sysInfoType12v590extIEsNewInterFrequencyCellInfoListv590ext; }
	void setSysInfoType12v590extIEsNewInterRATCellInfoListv590ext(const SysInfoType12v590extIEsNewInterRATCellInfoListv590ext& sysInfoType12v590extIEsNewInterRATCellInfoListv590ext) { *static_cast<SysInfoType12v590extIEsNewInterRATCellInfoListv590ext*>(items[2]) = sysInfoType12v590extIEsNewInterRATCellInfoListv590ext; }
	void setIntraFreqEventCriteriaListv590ext(const IntraFreqEventCriteriaListv590ext& intraFreqEventCriteriaListv590ext) { *static_cast<IntraFreqEventCriteriaListv590ext*>(items[3]) = intraFreqEventCriteriaListv590ext; }
	void setIntraFreqReportingCriteria1br5(const IntraFreqReportingCriteria1br5& intraFreqReportingCriteria1br5) { *static_cast<IntraFreqReportingCriteria1br5*>(items[4]) = intraFreqReportingCriteria1br5; }
	void setIntraFreqEvent1dr5(const IntraFreqEvent1dr5& intraFreqEvent1dr5) { *static_cast<IntraFreqEvent1dr5*>(items[5]) = intraFreqEvent1dr5; }
};

class SysInfoType12v690extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType12v690extIEs(): Sequence(&theInfo) {}

	void setDummy(const DummyInterFreqRACHReportingInfo& dummy) { *static_cast<DummyInterFreqRACHReportingInfo*>(items[0]) = dummy; }
};

class SysInfoType12v6b0extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType12v6b0extIEs(): Sequence(&theInfo) {}

	void setInterFreqRACHReportingInfo(const InterFreqRACHReportingInfo& interFreqRACHReportingInfo) { *static_cast<InterFreqRACHReportingInfo*>(items[0]) = interFreqRACHReportingInfo; }
};

class SysInfoType12v7b0extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType12v7b0extIEs(): Sequence(&theInfo) {}

	void setNewInterFreqCellList(const NewInterFreqCellListv7b0ext& newInterFreqCellList) { *static_cast<NewInterFreqCellListv7b0ext*>(items[0]) = newInterFreqCellList; }
};

class SysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV7b0NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV7b0NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV7b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV7b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType12v7b0ext(const SysInfoType12v7b0extIEs& sysInfoType12v7b0ext) { *static_cast<SysInfoType12v7b0extIEs*>(items[0]) = sysInfoType12v7b0ext; }
	void setSysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV7b0NonCriticalExtensionsNonCriticalExtensions(const SysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV7b0NonCriticalExtensionsNonCriticalExtensions& sysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV7b0NonCriticalExtensionsNonCriticalExtensions) { *static_cast<SysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV7b0NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = sysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV7b0NonCriticalExtensionsNonCriticalExtensions; }
};

class SysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType12v6b0ext(const SysInfoType12v6b0extIEs& sysInfoType12v6b0ext) { *static_cast<SysInfoType12v6b0extIEs*>(items[0]) = sysInfoType12v6b0ext; }
	void setSysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV7b0NonCriticalExtensions(const SysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV7b0NonCriticalExtensions& sysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV7b0NonCriticalExtensions) { *static_cast<SysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV7b0NonCriticalExtensions*>(items[1]) = sysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensionsV7b0NonCriticalExtensions; }
};

class SysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType12v690ext(const SysInfoType12v690extIEs& sysInfoType12v690ext) { *static_cast<SysInfoType12v690extIEs*>(items[0]) = sysInfoType12v690ext; }
	void setSysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensions(const SysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensions& sysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensions) { *static_cast<SysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensions*>(items[1]) = sysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensionsV6b0NonCriticalExtensions; }
};

class SysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtension : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtension(): Sequence(&theInfo) {}

	void setSysInfoType12v590ext(const SysInfoType12v590extIEs& sysInfoType12v590ext) { *static_cast<SysInfoType12v590extIEs*>(items[0]) = sysInfoType12v590ext; }
	void setSysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensions(const SysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensions& sysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensions) { *static_cast<SysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensions*>(items[1]) = sysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtensionV690NonCriticalExtensions; }
};

class SysInfoType12V4b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType12V4b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType12v4b0ext(const SysInfoType12v4b0extIEs& sysInfoType12v4b0ext) { *static_cast<SysInfoType12v4b0extIEs*>(items[0]) = sysInfoType12v4b0ext; }
	void setSysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtension(const SysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtension& sysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtension) { *static_cast<SysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtension*>(items[1]) = sysInfoType12V4b0NonCriticalExtensionsV590NonCriticalExtension; }
};

class SysInfoType12 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SysInfoType12(): Sequence(&theInfo) {}

	void setFachMeasurementOccasionInfo(const FACHMeasurementOccasionInfo& fachMeasurementOccasionInfo) { *static_cast<FACHMeasurementOccasionInfo*>(items[0]) = fachMeasurementOccasionInfo; }
	void setMeasurementControlSysInfo(const MeasurementControlSysInfo& measurementControlSysInfo) { *static_cast<MeasurementControlSysInfo*>(items[1]) = measurementControlSysInfo; }
	void setSysInfoType12V4b0NonCriticalExtensions(const SysInfoType12V4b0NonCriticalExtensions& sysInfoType12V4b0NonCriticalExtensions) { *static_cast<SysInfoType12V4b0NonCriticalExtensions*>(items[2]) = sysInfoType12V4b0NonCriticalExtensions; }
};

class SysInfoType13v3a0extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType13v3a0extIEs(): Sequence(&theInfo) {}

	void setUeIdleTimersAndConstantsv3a0ext(const UEIdleTimersAndConstantsv3a0ext& ueIdleTimersAndConstantsv3a0ext) { *static_cast<UEIdleTimersAndConstantsv3a0ext*>(items[0]) = ueIdleTimersAndConstantsv3a0ext; }
};

class SysInfoType13v4b0extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType13v4b0extIEs(): Sequence(&theInfo) {}

	void setCapabilityUpdateRequirementr4Ext(const CapabilityUpdateRequirementr4ext& capabilityUpdateRequirementr4Ext) { *static_cast<CapabilityUpdateRequirementr4ext*>(items[0]) = capabilityUpdateRequirementr4Ext; }
};

class SysInfoType13v770extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType13v770extIEs(): Sequence(&theInfo) {}

	void setCapabilityUpdateRequirement(const CapabilityUpdateRequirementv770ext& capabilityUpdateRequirement) { *static_cast<CapabilityUpdateRequirementv770ext*>(items[0]) = capabilityUpdateRequirement; }
};

class SysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsV770NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsV770NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType13v770ext(const SysInfoType13v770extIEs& sysInfoType13v770ext) { *static_cast<SysInfoType13v770extIEs*>(items[0]) = sysInfoType13v770ext; }
	void setSysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions(const SysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions& sysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions) { *static_cast<SysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = sysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions; }
};

class SysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType13v4b0ext(const SysInfoType13v4b0extIEs& sysInfoType13v4b0ext) { *static_cast<SysInfoType13v4b0extIEs*>(items[0]) = sysInfoType13v4b0ext; }
	void setSysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsV770NonCriticalExtensions(const SysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsV770NonCriticalExtensions& sysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsV770NonCriticalExtensions) { *static_cast<SysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsV770NonCriticalExtensions*>(items[1]) = sysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsV770NonCriticalExtensions; }
};

class SysInfoType13V3a0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType13V3a0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType13v3a0ext(const SysInfoType13v3a0extIEs& sysInfoType13v3a0ext) { *static_cast<SysInfoType13v3a0extIEs*>(items[0]) = sysInfoType13v3a0ext; }
	void setSysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensions(const SysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensions& sysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensions) { *static_cast<SysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensions*>(items[1]) = sysInfoType13V3a0NonCriticalExtensionsV4b0NonCriticalExtensions; }
};

class SysInfoType13 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SysInfoType13(): Sequence(&theInfo) {}

	void setCnDomainSysInfoList(const CNDomainSysInfoList& cnDomainSysInfoList) { *static_cast<CNDomainSysInfoList*>(items[0]) = cnDomainSysInfoList; }
	void setUeIdleTimersAndConstants(const UEIdleTimersAndConstants& ueIdleTimersAndConstants) { *static_cast<UEIdleTimersAndConstants*>(items[1]) = ueIdleTimersAndConstants; }
	void setCapabilityUpdateRequirement(const CapabilityUpdateRequirement& capabilityUpdateRequirement) { *static_cast<CapabilityUpdateRequirement*>(items[2]) = capabilityUpdateRequirement; }
	void setSysInfoType13V3a0NonCriticalExtensions(const SysInfoType13V3a0NonCriticalExtensions& sysInfoType13V3a0NonCriticalExtensions) { *static_cast<SysInfoType13V3a0NonCriticalExtensions*>(items[3]) = sysInfoType13V3a0NonCriticalExtensions; }
};

typedef ANSI41NASParameter ANSI41RANDInformation;

class SysInfoType131NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType131NonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType131 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType131(): Sequence(&theInfo) {}

	void setAnsi41RANDInformation(const ANSI41RANDInformation& ansi41RANDInformation) { *static_cast<ANSI41RANDInformation*>(items[0]) = ansi41RANDInformation; }
	void setSysInfoType131NonCriticalExtensions(const SysInfoType131NonCriticalExtensions& sysInfoType131NonCriticalExtensions) { *static_cast<SysInfoType131NonCriticalExtensions*>(items[1]) = sysInfoType131NonCriticalExtensions; }
};

typedef ANSI41NASParameter ANSI41UserZoneIDInformation;

class SysInfoType132NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType132NonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType132 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType132(): Sequence(&theInfo) {}

	void setAnsi41UserZoneIDInformation(const ANSI41UserZoneIDInformation& ansi41UserZoneIDInformation) { *static_cast<ANSI41UserZoneIDInformation*>(items[0]) = ansi41UserZoneIDInformation; }
	void setSysInfoType132NonCriticalExtensions(const SysInfoType132NonCriticalExtensions& sysInfoType132NonCriticalExtensions) { *static_cast<SysInfoType132NonCriticalExtensions*>(items[1]) = sysInfoType132NonCriticalExtensions; }
};

typedef ANSI41NASParameter ANSI41PrivateNeighbourListInfo;

class SysInfoType133NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType133NonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType133 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType133(): Sequence(&theInfo) {}

	void setAnsi41PrivateNeighbourListInfo(const ANSI41PrivateNeighbourListInfo& ansi41PrivateNeighbourListInfo) { *static_cast<ANSI41PrivateNeighbourListInfo*>(items[0]) = ansi41PrivateNeighbourListInfo; }
	void setSysInfoType133NonCriticalExtensions(const SysInfoType133NonCriticalExtensions& sysInfoType133NonCriticalExtensions) { *static_cast<SysInfoType133NonCriticalExtensions*>(items[1]) = sysInfoType133NonCriticalExtensions; }
};

typedef ANSI41NASParameter ANSI41GlobalServiceRedirectInfo;

class SysInfoType134NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType134NonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType134 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType134(): Sequence(&theInfo) {}

	void setAnsi41GlobalServiceRedirectInfo(const ANSI41GlobalServiceRedirectInfo& ansi41GlobalServiceRedirectInfo) { *static_cast<ANSI41GlobalServiceRedirectInfo*>(items[0]) = ansi41GlobalServiceRedirectInfo; }
	void setSysInfoType134NonCriticalExtensions(const SysInfoType134NonCriticalExtensions& sysInfoType134NonCriticalExtensions) { *static_cast<SysInfoType134NonCriticalExtensions*>(items[1]) = sysInfoType134NonCriticalExtensions; }
};

class SysInfoType14NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType14NonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType14 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SysInfoType14(): Sequence(&theInfo) {}

	void setIndividualTSInterferenceList(const IndividualTSInterferenceList& individualTSInterferenceList) { *static_cast<IndividualTSInterferenceList*>(items[0]) = individualTSInterferenceList; }
	void setExpirationTimeFactor(const ExpirationTimeFactor& expirationTimeFactor) { *static_cast<ExpirationTimeFactor*>(items[1]) = expirationTimeFactor; }
	void setSysInfoType14NonCriticalExtensions(const SysInfoType14NonCriticalExtensions& sysInfoType14NonCriticalExtensions) { *static_cast<SysInfoType14NonCriticalExtensions*>(items[2]) = sysInfoType14NonCriticalExtensions; }
};

class SysInfoType15v4b0extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType15v4b0extIEs(): Sequence(&theInfo) {}

	void setUpIpdlParametersTDD(const UEPositioningIPDLParametersTDDr4ext& upIpdlParametersTDD) { *static_cast<UEPositioningIPDLParametersTDDr4ext*>(items[0]) = upIpdlParametersTDD; }
};

class SysInfoType15v770extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType15v770extIEs(): Sequence(&theInfo) {}

	void setUePositioningGPSReferenceTime(const UEPositioningGPSReferenceTimev770ext& uePositioningGPSReferenceTime) { *static_cast<UEPositioningGPSReferenceTimev770ext*>(items[0]) = uePositioningGPSReferenceTime; }
};

class SysInfoType15V4b0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType15V4b0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType15V4b0NonCriticalExtensionsV770NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType15V4b0NonCriticalExtensionsV770NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType15v770ext(const SysInfoType15v770extIEs& sysInfoType15v770ext) { *static_cast<SysInfoType15v770extIEs*>(items[0]) = sysInfoType15v770ext; }
	void setSysInfoType15V4b0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions(const SysInfoType15V4b0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions& sysInfoType15V4b0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions) { *static_cast<SysInfoType15V4b0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = sysInfoType15V4b0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions; }
};

class SysInfoType15V4b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType15V4b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType15v4b0ext(const SysInfoType15v4b0extIEs& sysInfoType15v4b0ext) { *static_cast<SysInfoType15v4b0extIEs*>(items[0]) = sysInfoType15v4b0ext; }
	void setSysInfoType15V4b0NonCriticalExtensionsV770NonCriticalExtensions(const SysInfoType15V4b0NonCriticalExtensionsV770NonCriticalExtensions& sysInfoType15V4b0NonCriticalExtensionsV770NonCriticalExtensions) { *static_cast<SysInfoType15V4b0NonCriticalExtensionsV770NonCriticalExtensions*>(items[1]) = sysInfoType15V4b0NonCriticalExtensionsV770NonCriticalExtensions; }
};

class SysInfoType15 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	SysInfoType15(): Sequence(&theInfo) {}

	void setUepositioningGPSCipherParameters(const UEPositioningCipherParameters& uepositioningGPSCipherParameters) { *static_cast<UEPositioningCipherParameters*>(items[0]) = uepositioningGPSCipherParameters; }
	void setUepositioningGPSReferenceLocation(const ReferenceLocation& uepositioningGPSReferenceLocation) { *static_cast<ReferenceLocation*>(items[1]) = uepositioningGPSReferenceLocation; }
	void setUepositioningGPSReferenceTime(const UEPositioningGPSReferenceTime& uepositioningGPSReferenceTime) { *static_cast<UEPositioningGPSReferenceTime*>(items[2]) = uepositioningGPSReferenceTime; }
	void setUepositioningGPSRealtimeIntegrity(const BadSatList& uepositioningGPSRealtimeIntegrity) { *static_cast<BadSatList*>(items[3]) = uepositioningGPSRealtimeIntegrity; }
	void setSysInfoType15V4b0NonCriticalExtensions(const SysInfoType15V4b0NonCriticalExtensions& sysInfoType15V4b0NonCriticalExtensions) { *static_cast<SysInfoType15V4b0NonCriticalExtensions*>(items[4]) = sysInfoType15V4b0NonCriticalExtensions; }
};

class SysInfoType15bisv860extIEs : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType15bisv860extIEs(): Sequence(&theInfo) {}

	void setUePositioningGANSSAddIonoModel(const UEPositioningGANSSAddIonoModel& uePositioningGANSSAddIonoModel) { *static_cast<UEPositioningGANSSAddIonoModel*>(items[0]) = uePositioningGANSSAddIonoModel; }
	void setUePositioningGANSSEarthOrientationPara(const UEPositioningGANSSEarthOrientPara& uePositioningGANSSEarthOrientationPara) { *static_cast<UEPositioningGANSSEarthOrientPara*>(items[1]) = uePositioningGANSSEarthOrientationPara; }
};

class SysInfoType15bisV860NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType15bisV860NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType15bisV860NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType15bisV860NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType15bisv860ext(const SysInfoType15bisv860extIEs& sysInfoType15bisv860ext) { *static_cast<SysInfoType15bisv860extIEs*>(items[0]) = sysInfoType15bisv860ext; }
	void setSysInfoType15bisV860NonCriticalExtensionsNonCriticalExtensions(const SysInfoType15bisV860NonCriticalExtensionsNonCriticalExtensions& sysInfoType15bisV860NonCriticalExtensionsNonCriticalExtensions) { *static_cast<SysInfoType15bisV860NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = sysInfoType15bisV860NonCriticalExtensionsNonCriticalExtensions; }
};

class SysInfoType15bis : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SysInfoType15bis(): Sequence(&theInfo) {}

	void setUepositioningGANSSReferencePosition(const ReferenceLocationGANSS& uepositioningGANSSReferencePosition) { *static_cast<ReferenceLocationGANSS*>(items[0]) = uepositioningGANSSReferencePosition; }
	void setUepositioningGANSSReferenceTime(const UEPositioningGANSSReferenceTime& uepositioningGANSSReferenceTime) { *static_cast<UEPositioningGANSSReferenceTime*>(items[1]) = uepositioningGANSSReferenceTime; }
	void setUepositioningGANSSIonosphericModel(const UEPositioningGANSSIonosphericModel& uepositioningGANSSIonosphericModel) { *static_cast<UEPositioningGANSSIonosphericModel*>(items[2]) = uepositioningGANSSIonosphericModel; }
	void setSysInfoType15bisV860NonCriticalExtensions(const SysInfoType15bisV860NonCriticalExtensions& sysInfoType15bisV860NonCriticalExtensions) { *static_cast<SysInfoType15bisV860NonCriticalExtensions*>(items[3]) = sysInfoType15bisV860NonCriticalExtensions; }
};

class SysInfoType151v920extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType151v920extIEs(): Sequence(&theInfo) {}

	void setUepositioningGPSDGPSCorrections(const UEPositioningGPSDGPSCorrectionsv920ext& uepositioningGPSDGPSCorrections) { *static_cast<UEPositioningGPSDGPSCorrectionsv920ext*>(items[0]) = uepositioningGPSDGPSCorrections; }
};

class SysInfoType151V920NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType151V920NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType151V920NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType151V920NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType151v920ext(const SysInfoType151v920extIEs& sysInfoType151v920ext) { *static_cast<SysInfoType151v920extIEs*>(items[0]) = sysInfoType151v920ext; }
	void setSysInfoType151V920NonCriticalExtensionsNonCriticalExtensions(const SysInfoType151V920NonCriticalExtensionsNonCriticalExtensions& sysInfoType151V920NonCriticalExtensionsNonCriticalExtensions) { *static_cast<SysInfoType151V920NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = sysInfoType151V920NonCriticalExtensionsNonCriticalExtensions; }
};

class SysInfoType151 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType151(): Sequence(&theInfo) {}

	void setUepositioningGPSDGPSCorrections(const UEPositioningGPSDGPSCorrections& uepositioningGPSDGPSCorrections) { *static_cast<UEPositioningGPSDGPSCorrections*>(items[0]) = uepositioningGPSDGPSCorrections; }
	void setSysInfoType151V920NonCriticalExtensions(const SysInfoType151V920NonCriticalExtensions& sysInfoType151V920NonCriticalExtensions) { *static_cast<SysInfoType151V920NonCriticalExtensions*>(items[1]) = sysInfoType151V920NonCriticalExtensions; }
};

class SysInfoType151bisv920extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType151bisv920extIEs(): Sequence(&theInfo) {}

	void setUepositioningGANSSDGANSSCorrections(const UEPositioningDGANSSCorrectionsv920ext& uepositioningGANSSDGANSSCorrections) { *static_cast<UEPositioningDGANSSCorrectionsv920ext*>(items[0]) = uepositioningGANSSDGANSSCorrections; }
};

class SysInfoType151bisV920NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType151bisV920NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType151bisV920NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType151bisV920NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType151bisv920ext(const SysInfoType151bisv920extIEs& sysInfoType151bisv920ext) { *static_cast<SysInfoType151bisv920extIEs*>(items[0]) = sysInfoType151bisv920ext; }
	void setSysInfoType151bisV920NonCriticalExtensionsNonCriticalExtensions(const SysInfoType151bisV920NonCriticalExtensionsNonCriticalExtensions& sysInfoType151bisV920NonCriticalExtensionsNonCriticalExtensions) { *static_cast<SysInfoType151bisV920NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = sysInfoType151bisV920NonCriticalExtensionsNonCriticalExtensions; }
};

class SysInfoType151bis : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType151bis(): Sequence(&theInfo) {}

	void setUepositioningGANSSDGANSSCorrections(const UEPositioningDGANSSCorrections& uepositioningGANSSDGANSSCorrections) { *static_cast<UEPositioningDGANSSCorrections*>(items[0]) = uepositioningGANSSDGANSSCorrections; }
	void setSysInfoType151bisV920NonCriticalExtensions(const SysInfoType151bisV920NonCriticalExtensions& sysInfoType151bisV920NonCriticalExtensions) { *static_cast<SysInfoType151bisV920NonCriticalExtensions*>(items[1]) = sysInfoType151bisV920NonCriticalExtensions; }
};

class SysInfoType152NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType152NonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType152 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SysInfoType152(): Sequence(&theInfo) {}

	void setTransmissionTOW(const GPSTOW1sec& transmissionTOW) { *static_cast<GPSTOW1sec*>(items[0]) = transmissionTOW; }
	void setSatID(const SatID& satID) { *static_cast<SatID*>(items[1]) = satID; }
	void setEphemerisParameter(const EphemerisParameter& ephemerisParameter) { *static_cast<EphemerisParameter*>(items[2]) = ephemerisParameter; }
	void setSysInfoType152NonCriticalExtensions(const SysInfoType152NonCriticalExtensions& sysInfoType152NonCriticalExtensions) { *static_cast<SysInfoType152NonCriticalExtensions*>(items[3]) = sysInfoType152NonCriticalExtensions; }
};

class SysInfoType152bisNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType152bisNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType152bis : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType152bis(): Sequence(&theInfo) {}

	void setUepositioningGANSSnavigationModel(const UEPositioningGANSSNavigationModel& uepositioningGANSSnavigationModel) { *static_cast<UEPositioningGANSSNavigationModel*>(items[0]) = uepositioningGANSSnavigationModel; }
	void setSysInfoType152bisNonCriticalExtensions(const SysInfoType152bisNonCriticalExtensions& sysInfoType152bisNonCriticalExtensions) { *static_cast<SysInfoType152bisNonCriticalExtensions*>(items[1]) = sysInfoType152bisNonCriticalExtensions; }
};

class SysInfoType152terNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType152terNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType152ter : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType152ter(): Sequence(&theInfo) {}

	void setUepositioningGANSSAddNavigationModels(const UEPositioningGANSSAddNavigationModels& uepositioningGANSSAddNavigationModels) { *static_cast<UEPositioningGANSSAddNavigationModels*>(items[0]) = uepositioningGANSSAddNavigationModels; }
	void setSysInfoType152terNonCriticalExtensions(const SysInfoType152terNonCriticalExtensions& sysInfoType152terNonCriticalExtensions) { *static_cast<SysInfoType152terNonCriticalExtensions*>(items[1]) = sysInfoType152terNonCriticalExtensions; }
};

typedef BitString<CONSTRAINED, 1, 32> SysInfoType153SatMask;

typedef BitString<CONSTRAINED, 8, 8> SysInfoType153LsbTOW;

class SysInfoType153NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType153NonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType153 : public Sequence {
private:
	static const void *itemsInfo[7];
	static bool itemsPres[7];
public:
	static const Info theInfo;
	SysInfoType153(): Sequence(&theInfo) {}

	void setTransmissionTOW(const GPSTOW1sec& transmissionTOW) { *static_cast<GPSTOW1sec*>(items[0]) = transmissionTOW; }
	void setUepositioningGPSAlmanac(const UEPositioningGPSAlmanac& uepositioningGPSAlmanac) { *static_cast<UEPositioningGPSAlmanac*>(items[1]) = uepositioningGPSAlmanac; }
	void setUepositioningGPSIonosphericModel(const UEPositioningGPSIonosphericModel& uepositioningGPSIonosphericModel) { *static_cast<UEPositioningGPSIonosphericModel*>(items[2]) = uepositioningGPSIonosphericModel; }
	void setUepositioningGPSUTCModel(const UEPositioningGPSUTCModel& uepositioningGPSUTCModel) { *static_cast<UEPositioningGPSUTCModel*>(items[3]) = uepositioningGPSUTCModel; }
	void setSysInfoType153SatMask(const SysInfoType153SatMask& sysInfoType153SatMask) { *static_cast<SysInfoType153SatMask*>(items[4]) = sysInfoType153SatMask; }
	void setSysInfoType153LsbTOW(const SysInfoType153LsbTOW& sysInfoType153LsbTOW) { *static_cast<SysInfoType153LsbTOW*>(items[5]) = sysInfoType153LsbTOW; }
	void setSysInfoType153NonCriticalExtensions(const SysInfoType153NonCriticalExtensions& sysInfoType153NonCriticalExtensions) { *static_cast<SysInfoType153NonCriticalExtensions*>(items[6]) = sysInfoType153NonCriticalExtensions; }
};

class SysInfoType153bisv860extIEs : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SysInfoType153bisv860extIEs(): Sequence(&theInfo) {}

	void setUePositioningGANSSAlmanac(const UEPositioningGANSSAlmanacv860ext& uePositioningGANSSAlmanac) { *static_cast<UEPositioningGANSSAlmanacv860ext*>(items[0]) = uePositioningGANSSAlmanac; }
	void setUePositioningGANSSAddUTCModels(const UEPositioningGANSSAddUTCModels& uePositioningGANSSAddUTCModels) { *static_cast<UEPositioningGANSSAddUTCModels*>(items[1]) = uePositioningGANSSAddUTCModels; }
	void setUePositioningGANSSAuxiliaryInfo(const UEPositioningGANSSAuxiliaryInfo& uePositioningGANSSAuxiliaryInfo) { *static_cast<UEPositioningGANSSAuxiliaryInfo*>(items[2]) = uePositioningGANSSAuxiliaryInfo; }
};

class SysInfoType153bisV860NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType153bisV860NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType153bisV860NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType153bisV860NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType153bisv860ext(const SysInfoType153bisv860extIEs& sysInfoType153bisv860ext) { *static_cast<SysInfoType153bisv860extIEs*>(items[0]) = sysInfoType153bisv860ext; }
	void setSysInfoType153bisV860NonCriticalExtensionsNonCriticalExtensions(const SysInfoType153bisV860NonCriticalExtensionsNonCriticalExtensions& sysInfoType153bisV860NonCriticalExtensionsNonCriticalExtensions) { *static_cast<SysInfoType153bisV860NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = sysInfoType153bisV860NonCriticalExtensionsNonCriticalExtensions; }
};

class SysInfoType153bis : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SysInfoType153bis(): Sequence(&theInfo) {}

	void setUepositioningGANSSAlmanac(const UEPositioningGANSSAlmanac& uepositioningGANSSAlmanac) { *static_cast<UEPositioningGANSSAlmanac*>(items[0]) = uepositioningGANSSAlmanac; }
	void setUepositioningGANSSTimeModels(const UEPositioningGANSSTimeModels& uepositioningGANSSTimeModels) { *static_cast<UEPositioningGANSSTimeModels*>(items[1]) = uepositioningGANSSTimeModels; }
	void setUepositioningGANSSUTCModel(const UEPositioningGANSSUTCModel& uepositioningGANSSUTCModel) { *static_cast<UEPositioningGANSSUTCModel*>(items[2]) = uepositioningGANSSUTCModel; }
	void setSysInfoType153bisV860NonCriticalExtensions(const SysInfoType153bisV860NonCriticalExtensions& sysInfoType153bisV860NonCriticalExtensions) { *static_cast<SysInfoType153bisV860NonCriticalExtensions*>(items[3]) = sysInfoType153bisV860NonCriticalExtensions; }
};

class SysInfoType154v3a0ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType154v3a0ext(): Sequence(&theInfo) {}

	void setSfnOffsetValidity(const SFNOffsetValidity& sfnOffsetValidity) { *static_cast<SFNOffsetValidity*>(items[0]) = sfnOffsetValidity; }
};

class SysInfoType154v4b0ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType154v4b0ext(): Sequence(&theInfo) {}

	void setUePositioningOTDOAAssistanceDatar4ext(const UEPositioningOTDOAAssistanceDatar4ext& uePositioningOTDOAAssistanceDatar4ext) { *static_cast<UEPositioningOTDOAAssistanceDatar4ext*>(items[0]) = uePositioningOTDOAAssistanceDatar4ext; }
};

class SysInfoType154V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType154V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType154V3a0NonCriticalExtensionsV4b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType154V3a0NonCriticalExtensionsV4b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType154v4b0ext(const SysInfoType154v4b0ext& sysInfoType154v4b0ext) { *static_cast<SysInfoType154v4b0ext*>(items[0]) = sysInfoType154v4b0ext; }
	void setSysInfoType154V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsNonCriticalExtensions(const SysInfoType154V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsNonCriticalExtensions& sysInfoType154V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsNonCriticalExtensions) { *static_cast<SysInfoType154V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = sysInfoType154V3a0NonCriticalExtensionsV4b0NonCriticalExtensionsNonCriticalExtensions; }
};

class SysInfoType154V3a0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType154V3a0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType154v3a0ext(const SysInfoType154v3a0ext& sysInfoType154v3a0ext) { *static_cast<SysInfoType154v3a0ext*>(items[0]) = sysInfoType154v3a0ext; }
	void setSysInfoType154V3a0NonCriticalExtensionsV4b0NonCriticalExtensions(const SysInfoType154V3a0NonCriticalExtensionsV4b0NonCriticalExtensions& sysInfoType154V3a0NonCriticalExtensionsV4b0NonCriticalExtensions) { *static_cast<SysInfoType154V3a0NonCriticalExtensionsV4b0NonCriticalExtensions*>(items[1]) = sysInfoType154V3a0NonCriticalExtensionsV4b0NonCriticalExtensions; }
};

class SysInfoType154 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SysInfoType154(): Sequence(&theInfo) {}

	void setUepositioningOTDOACipherParameters(const UEPositioningCipherParameters& uepositioningOTDOACipherParameters) { *static_cast<UEPositioningCipherParameters*>(items[0]) = uepositioningOTDOACipherParameters; }
	void setUepositioningOTDOAAssistanceData(const UEPositioningOTDOAAssistanceData& uepositioningOTDOAAssistanceData) { *static_cast<UEPositioningOTDOAAssistanceData*>(items[1]) = uepositioningOTDOAAssistanceData; }
	void setSysInfoType154V3a0NonCriticalExtensions(const SysInfoType154V3a0NonCriticalExtensions& sysInfoType154V3a0NonCriticalExtensions) { *static_cast<SysInfoType154V3a0NonCriticalExtensions*>(items[2]) = sysInfoType154V3a0NonCriticalExtensions; }
};

class SysInfoType155v3a0ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType155v3a0ext(): Sequence(&theInfo) {}

	void setSfnOffsetValidity(const SFNOffsetValidity& sfnOffsetValidity) { *static_cast<SFNOffsetValidity*>(items[0]) = sfnOffsetValidity; }
};

class SysInfoType155v770extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType155v770extIEs(): Sequence(&theInfo) {}

	void setUePositioningOTDOAAssistanceDataUEBext(const UEPositioningOTDOAAssistanceDataUEBext& uePositioningOTDOAAssistanceDataUEBext) { *static_cast<UEPositioningOTDOAAssistanceDataUEBext*>(items[0]) = uePositioningOTDOAAssistanceDataUEBext; }
};

class SysInfoType155V3a0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType155V3a0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType155V3a0NonCriticalExtensionsV770NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType155V3a0NonCriticalExtensionsV770NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType155v770ext(const SysInfoType155v770extIEs& sysInfoType155v770ext) { *static_cast<SysInfoType155v770extIEs*>(items[0]) = sysInfoType155v770ext; }
	void setSysInfoType155V3a0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions(const SysInfoType155V3a0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions& sysInfoType155V3a0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions) { *static_cast<SysInfoType155V3a0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = sysInfoType155V3a0NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions; }
};

class SysInfoType155V3a0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType155V3a0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType155v3a0ext(const SysInfoType155v3a0ext& sysInfoType155v3a0ext) { *static_cast<SysInfoType155v3a0ext*>(items[0]) = sysInfoType155v3a0ext; }
	void setSysInfoType155V3a0NonCriticalExtensionsV770NonCriticalExtensions(const SysInfoType155V3a0NonCriticalExtensionsV770NonCriticalExtensions& sysInfoType155V3a0NonCriticalExtensionsV770NonCriticalExtensions) { *static_cast<SysInfoType155V3a0NonCriticalExtensionsV770NonCriticalExtensions*>(items[1]) = sysInfoType155V3a0NonCriticalExtensionsV770NonCriticalExtensions; }
};

class SysInfoType155 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType155(): Sequence(&theInfo) {}

	void setUepositioningOTDOAAssistanceDataUEB(const UEPositioningOTDOAAssistanceDataUEB& uepositioningOTDOAAssistanceDataUEB) { *static_cast<UEPositioningOTDOAAssistanceDataUEB*>(items[0]) = uepositioningOTDOAAssistanceDataUEB; }
	void setSysInfoType155V3a0NonCriticalExtensions(const SysInfoType155V3a0NonCriticalExtensions& sysInfoType155V3a0NonCriticalExtensions) { *static_cast<SysInfoType155V3a0NonCriticalExtensions*>(items[1]) = sysInfoType155V3a0NonCriticalExtensions; }
};

typedef Integer<CONSTRAINED, 0, 86399> SysInfoType156UepositioningGANSSTOD;

class SysInfoType156NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType156NonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType156 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SysInfoType156(): Sequence(&theInfo) {}

	void setSysInfoType156UepositioningGANSSTOD(const SysInfoType156UepositioningGANSSTOD& sysInfoType156UepositioningGANSSTOD) { *static_cast<SysInfoType156UepositioningGANSSTOD*>(items[0]) = sysInfoType156UepositioningGANSSTOD; }
	void setUepositioningGANSSReferenceMeasurementInformation(const UEPositioningGANSSReferenceMeasurementInfo& uepositioningGANSSReferenceMeasurementInformation) { *static_cast<UEPositioningGANSSReferenceMeasurementInfo*>(items[1]) = uepositioningGANSSReferenceMeasurementInformation; }
	void setSysInfoType156NonCriticalExtensions(const SysInfoType156NonCriticalExtensions& sysInfoType156NonCriticalExtensions) { *static_cast<SysInfoType156NonCriticalExtensions*>(items[2]) = sysInfoType156NonCriticalExtensions; }
};

class SysInfoType157NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType157NonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType157 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType157(): Sequence(&theInfo) {}

	void setUepositioningGANSSDataBitAssistance(const UEPositioningGANSSDataBitAssistance& uepositioningGANSSDataBitAssistance) { *static_cast<UEPositioningGANSSDataBitAssistance*>(items[0]) = uepositioningGANSSDataBitAssistance; }
	void setSysInfoType157NonCriticalExtensions(const SysInfoType157NonCriticalExtensions& sysInfoType157NonCriticalExtensions) { *static_cast<SysInfoType157NonCriticalExtensions*>(items[1]) = sysInfoType157NonCriticalExtensions; }
};

class SysInfoType158NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType158NonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType158 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SysInfoType158(): Sequence(&theInfo) {}

	void setUepositioningGANSSDataCipheringInfo(const UEPositioningCipherParameters& uepositioningGANSSDataCipheringInfo) { *static_cast<UEPositioningCipherParameters*>(items[0]) = uepositioningGANSSDataCipheringInfo; }
	void setUepositioningGANSSrealTimeIntegrity(const UEPositioningGANSSRealTimeIntegrity& uepositioningGANSSrealTimeIntegrity) { *static_cast<UEPositioningGANSSRealTimeIntegrity*>(items[1]) = uepositioningGANSSrealTimeIntegrity; }
	void setSysInfoType158NonCriticalExtensions(const SysInfoType158NonCriticalExtensions& sysInfoType158NonCriticalExtensions) { *static_cast<SysInfoType158NonCriticalExtensions*>(items[2]) = sysInfoType158NonCriticalExtensions; }
};

class SysInfoType16v770extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType16v770extIEs(): Sequence(&theInfo) {}

	void setPreDefinedRadioConfiguration(const PreDefRadioConfigurationv770ext& preDefinedRadioConfiguration) { *static_cast<PreDefRadioConfigurationv770ext*>(items[0]) = preDefinedRadioConfiguration; }
};

class SysInfoType16v920extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType16v920extIEs(): Sequence(&theInfo) {}

	void setPreDefinedRadioConfiguration(const PreDefRadioConfigurationv920ext& preDefinedRadioConfiguration) { *static_cast<PreDefRadioConfigurationv920ext*>(items[0]) = preDefinedRadioConfiguration; }
};

class SysInfoType16V770NonCriticalExtensionsV920NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType16V770NonCriticalExtensionsV920NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType16V770NonCriticalExtensionsV920NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType16V770NonCriticalExtensionsV920NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType16v920ext(const SysInfoType16v920extIEs& sysInfoType16v920ext) { *static_cast<SysInfoType16v920extIEs*>(items[0]) = sysInfoType16v920ext; }
	void setSysInfoType16V770NonCriticalExtensionsV920NonCriticalExtensionsNonCriticalExtensions(const SysInfoType16V770NonCriticalExtensionsV920NonCriticalExtensionsNonCriticalExtensions& sysInfoType16V770NonCriticalExtensionsV920NonCriticalExtensionsNonCriticalExtensions) { *static_cast<SysInfoType16V770NonCriticalExtensionsV920NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = sysInfoType16V770NonCriticalExtensionsV920NonCriticalExtensionsNonCriticalExtensions; }
};

class SysInfoType16V770NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType16V770NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType16v770ext(const SysInfoType16v770extIEs& sysInfoType16v770ext) { *static_cast<SysInfoType16v770extIEs*>(items[0]) = sysInfoType16v770ext; }
	void setSysInfoType16V770NonCriticalExtensionsV920NonCriticalExtensions(const SysInfoType16V770NonCriticalExtensionsV920NonCriticalExtensions& sysInfoType16V770NonCriticalExtensionsV920NonCriticalExtensions) { *static_cast<SysInfoType16V770NonCriticalExtensionsV920NonCriticalExtensions*>(items[1]) = sysInfoType16V770NonCriticalExtensionsV920NonCriticalExtensions; }
};

class SysInfoType16 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType16(): Sequence(&theInfo) {}

	void setPreDefinedRadioConfiguration(const PreDefRadioConfiguration& preDefinedRadioConfiguration) { *static_cast<PreDefRadioConfiguration*>(items[0]) = preDefinedRadioConfiguration; }
	void setSysInfoType16V770NonCriticalExtensions(const SysInfoType16V770NonCriticalExtensions& sysInfoType16V770NonCriticalExtensions) { *static_cast<SysInfoType16V770NonCriticalExtensions*>(items[1]) = sysInfoType16V770NonCriticalExtensions; }
};

class SysInfoType17v4b0extIEsTdd128SpecificInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType17v4b0extIEsTdd128SpecificInfo(): Sequence(&theInfo) {}

	void setPuschSysInfoList(const PUSCHSysInfoListLCRr4& puschSysInfoList) { *static_cast<PUSCHSysInfoListLCRr4*>(items[0]) = puschSysInfoList; }
	void setPdschSysInfoList(const PDSCHSysInfoListLCRr4& pdschSysInfoList) { *static_cast<PDSCHSysInfoListLCRr4*>(items[1]) = pdschSysInfoList; }
};

class SysInfoType17v4b0extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType17v4b0extIEs(): Sequence(&theInfo) {}

	void setSysInfoType17v4b0extIEsTdd128SpecificInfo(const SysInfoType17v4b0extIEsTdd128SpecificInfo& sysInfoType17v4b0extIEsTdd128SpecificInfo) { *static_cast<SysInfoType17v4b0extIEsTdd128SpecificInfo*>(items[0]) = sysInfoType17v4b0extIEsTdd128SpecificInfo; }
};

class SysInfoType17v590extIEsHcrr5SpecificInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType17v590extIEsHcrr5SpecificInfo(): Sequence(&theInfo) {}

	void setPuschSysInfoList(const PUSCHSysInfoListHCRr5& puschSysInfoList) { *static_cast<PUSCHSysInfoListHCRr5*>(items[0]) = puschSysInfoList; }
	void setPdschSysInfoList(const PDSCHSysInfoListHCRr5& pdschSysInfoList) { *static_cast<PDSCHSysInfoListHCRr5*>(items[1]) = pdschSysInfoList; }
};

class SysInfoType17v590extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType17v590extIEs(): Sequence(&theInfo) {}

	void setSysInfoType17v590extIEsHcrr5SpecificInfo(const SysInfoType17v590extIEsHcrr5SpecificInfo& sysInfoType17v590extIEsHcrr5SpecificInfo) { *static_cast<SysInfoType17v590extIEsHcrr5SpecificInfo*>(items[0]) = sysInfoType17v590extIEsHcrr5SpecificInfo; }
};

class SysInfoType17v770extIEsTdd768SpecificInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType17v770extIEsTdd768SpecificInfo(): Sequence(&theInfo) {}

	void setPuschSysInfoListSFN(const PUSCHSysInfoListSFNVHCR& puschSysInfoListSFN) { *static_cast<PUSCHSysInfoListSFNVHCR*>(items[0]) = puschSysInfoListSFN; }
	void setPdschSysInfoListSFN(const PDSCHSysInfoListVHCRr7& pdschSysInfoListSFN) { *static_cast<PDSCHSysInfoListVHCRr7*>(items[1]) = pdschSysInfoListSFN; }
};

class SysInfoType17v770extIEs : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoType17v770extIEs(): Sequence(&theInfo) {}

	void setSysInfoType17v770extIEsTdd768SpecificInfo(const SysInfoType17v770extIEsTdd768SpecificInfo& sysInfoType17v770extIEsTdd768SpecificInfo) { *static_cast<SysInfoType17v770extIEsTdd768SpecificInfo*>(items[0]) = sysInfoType17v770extIEsTdd768SpecificInfo; }
};

class SysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensionsV770NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensionsV770NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType17v770ext(const SysInfoType17v770extIEs& sysInfoType17v770ext) { *static_cast<SysInfoType17v770extIEs*>(items[0]) = sysInfoType17v770ext; }
	void setSysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions(const SysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions& sysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions) { *static_cast<SysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = sysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensionsV770NonCriticalExtensionsNonCriticalExtensions; }
};

class SysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType17v590ext(const SysInfoType17v590extIEs& sysInfoType17v590ext) { *static_cast<SysInfoType17v590extIEs*>(items[0]) = sysInfoType17v590ext; }
	void setSysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensionsV770NonCriticalExtensions(const SysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensionsV770NonCriticalExtensions& sysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensionsV770NonCriticalExtensions) { *static_cast<SysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensionsV770NonCriticalExtensions*>(items[1]) = sysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensionsV770NonCriticalExtensions; }
};

class SysInfoType17V4b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType17V4b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType17v4b0ext(const SysInfoType17v4b0extIEs& sysInfoType17v4b0ext) { *static_cast<SysInfoType17v4b0extIEs*>(items[0]) = sysInfoType17v4b0ext; }
	void setSysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensions(const SysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensions& sysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensions) { *static_cast<SysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensions*>(items[1]) = sysInfoType17V4b0NonCriticalExtensionsV590NonCriticalExtensions; }
};

class SysInfoType17 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SysInfoType17(): Sequence(&theInfo) {}

	void setPuschSysInfoList(const PUSCHSysInfoList& puschSysInfoList) { *static_cast<PUSCHSysInfoList*>(items[0]) = puschSysInfoList; }
	void setPdschSysInfoList(const PDSCHSysInfoList& pdschSysInfoList) { *static_cast<PDSCHSysInfoList*>(items[1]) = pdschSysInfoList; }
	void setSysInfoType17V4b0NonCriticalExtensions(const SysInfoType17V4b0NonCriticalExtensions& sysInfoType17V4b0NonCriticalExtensions) { *static_cast<SysInfoType17V4b0NonCriticalExtensions*>(items[2]) = sysInfoType17V4b0NonCriticalExtensions; }
};

class SysInfoType18v6b0ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType18v6b0ext(): Sequence(&theInfo) {}

	void setIdleModePLMNIdentitiesSIB11bis(const PLMNIdentitiesOfNeighbourCells& idleModePLMNIdentitiesSIB11bis) { *static_cast<PLMNIdentitiesOfNeighbourCells*>(items[0]) = idleModePLMNIdentitiesSIB11bis; }
	void setConnectedModePLMNIdentitiesSIB11bis(const PLMNIdentitiesOfNeighbourCells& connectedModePLMNIdentitiesSIB11bis) { *static_cast<PLMNIdentitiesOfNeighbourCells*>(items[1]) = connectedModePLMNIdentitiesSIB11bis; }
};

class SysInfoType18v860ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType18v860ext(): Sequence(&theInfo) {}

	void setIdleModePLMNIdentities(const PLMNIdentitiesOfNeighbourCellsv860ext& idleModePLMNIdentities) { *static_cast<PLMNIdentitiesOfNeighbourCellsv860ext*>(items[0]) = idleModePLMNIdentities; }
	void setConnectedModePLMNIdentities(const PLMNIdentitiesOfNeighbourCellsv860ext& connectedModePLMNIdentities) { *static_cast<PLMNIdentitiesOfNeighbourCellsv860ext*>(items[1]) = connectedModePLMNIdentities; }
};

class SysInfoType18V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType18V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType18V6b0NonCriticalExtensionsV860NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType18V6b0NonCriticalExtensionsV860NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType18v860ext(const SysInfoType18v860ext& sysInfoType18v860ext) { *static_cast<SysInfoType18v860ext*>(items[0]) = sysInfoType18v860ext; }
	void setSysInfoType18V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions(const SysInfoType18V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions& sysInfoType18V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions) { *static_cast<SysInfoType18V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = sysInfoType18V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions; }
};

class SysInfoType18V6b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType18V6b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType18v6b0ext(const SysInfoType18v6b0ext& sysInfoType18v6b0ext) { *static_cast<SysInfoType18v6b0ext*>(items[0]) = sysInfoType18v6b0ext; }
	void setSysInfoType18V6b0NonCriticalExtensionsV860NonCriticalExtensions(const SysInfoType18V6b0NonCriticalExtensionsV860NonCriticalExtensions& sysInfoType18V6b0NonCriticalExtensionsV860NonCriticalExtensions) { *static_cast<SysInfoType18V6b0NonCriticalExtensionsV860NonCriticalExtensions*>(items[1]) = sysInfoType18V6b0NonCriticalExtensionsV860NonCriticalExtensions; }
};

class SysInfoType18 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	SysInfoType18(): Sequence(&theInfo) {}

	void setIdleModePLMNIdentities(const PLMNIdentitiesOfNeighbourCells& idleModePLMNIdentities) { *static_cast<PLMNIdentitiesOfNeighbourCells*>(items[0]) = idleModePLMNIdentities; }
	void setConnectedModePLMNIdentities(const PLMNIdentitiesOfNeighbourCells& connectedModePLMNIdentities) { *static_cast<PLMNIdentitiesOfNeighbourCells*>(items[1]) = connectedModePLMNIdentities; }
	void setSysInfoType18V6b0NonCriticalExtensions(const SysInfoType18V6b0NonCriticalExtensions& sysInfoType18V6b0NonCriticalExtensions) { *static_cast<SysInfoType18V6b0NonCriticalExtensions*>(items[2]) = sysInfoType18V6b0NonCriticalExtensions; }
};

class SysInfoType19v920ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType19v920ext(): Sequence(&theInfo) {}

	void setUtraPriorityInfoListv920ext(const UTRAPriorityInfoListv920ext& utraPriorityInfoListv920ext) { *static_cast<UTRAPriorityInfoListv920ext*>(items[0]) = utraPriorityInfoListv920ext; }
	void setEutraFrequencyAndPriorityInfoListv920ext(const EUTRAFrequencyAndPriorityInfoListv920ext& eutraFrequencyAndPriorityInfoListv920ext) { *static_cast<EUTRAFrequencyAndPriorityInfoListv920ext*>(items[1]) = eutraFrequencyAndPriorityInfoListv920ext; }
};

class SysInfoType19V920NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType19V920NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType19V920NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType19V920NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoType19v920ext(const SysInfoType19v920ext& sysInfoType19v920ext) { *static_cast<SysInfoType19v920ext*>(items[0]) = sysInfoType19v920ext; }
	void setSysInfoType19V920NonCriticalExtensionsNonCriticalExtensions(const SysInfoType19V920NonCriticalExtensionsNonCriticalExtensions& sysInfoType19V920NonCriticalExtensionsNonCriticalExtensions) { *static_cast<SysInfoType19V920NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = sysInfoType19V920NonCriticalExtensionsNonCriticalExtensions; }
};

class SysInfoType19 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	SysInfoType19(): Sequence(&theInfo) {}

	void setUtraPriorityInfoList(const UTRAPriorityInfoList& utraPriorityInfoList) { *static_cast<UTRAPriorityInfoList*>(items[0]) = utraPriorityInfoList; }
	void setGsmPriorityInfoList(const GSMPriorityInfoList& gsmPriorityInfoList) { *static_cast<GSMPriorityInfoList*>(items[1]) = gsmPriorityInfoList; }
	void setEutraFrequencyAndPriorityInfoList(const EUTRAFrequencyAndPriorityInfoList& eutraFrequencyAndPriorityInfoList) { *static_cast<EUTRAFrequencyAndPriorityInfoList*>(items[2]) = eutraFrequencyAndPriorityInfoList; }
	void setSysInfoType19V920NonCriticalExtensions(const SysInfoType19V920NonCriticalExtensions& sysInfoType19V920NonCriticalExtensions) { *static_cast<SysInfoType19V920NonCriticalExtensions*>(items[3]) = sysInfoType19V920NonCriticalExtensions; }
};

class SysInfoType20NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoType20NonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoType20 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoType20(): Sequence(&theInfo) {}

	void setHNBName(const HNBName& hNBName) { *static_cast<HNBName*>(items[0]) = hNBName; }
	void setSysInfoType20NonCriticalExtensions(const SysInfoType20NonCriticalExtensions& sysInfoType20NonCriticalExtensions) { *static_cast<SysInfoType20NonCriticalExtensions*>(items[1]) = sysInfoType20NonCriticalExtensions; }
};

class SysInfoTypeSB1v6b0ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoTypeSB1v6b0ext(): Sequence(&theInfo) {}

	void setExtSIBTypeInfoSchedulingInfoList(const ExtSIBTypeInfoSchedulingInfoList& extSIBTypeInfoSchedulingInfoList) { *static_cast<ExtSIBTypeInfoSchedulingInfoList*>(items[0]) = extSIBTypeInfoSchedulingInfoList; }
};

class SysInfoTypeSB1v860ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoTypeSB1v860ext(): Sequence(&theInfo) {}

	void setExtSIBTypeInfoSchedulingInfoList(const ExtSIBTypeInfoSchedulingInfoList2& extSIBTypeInfoSchedulingInfoList) { *static_cast<ExtSIBTypeInfoSchedulingInfoList2*>(items[0]) = extSIBTypeInfoSchedulingInfoList; }
	void setExtGANSSSIBTypeInfoSchedulingInfoList(const ExtGANSSSIBTypeInfoSchedulingInfoList& extGANSSSIBTypeInfoSchedulingInfoList) { *static_cast<ExtGANSSSIBTypeInfoSchedulingInfoList*>(items[1]) = extGANSSSIBTypeInfoSchedulingInfoList; }
};

class SysInfoTypeSB1V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoTypeSB1V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoTypeSB1V6b0NonCriticalExtensionsV860NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoTypeSB1V6b0NonCriticalExtensionsV860NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoTypeSB1v860ext(const SysInfoTypeSB1v860ext& sysInfoTypeSB1v860ext) { *static_cast<SysInfoTypeSB1v860ext*>(items[0]) = sysInfoTypeSB1v860ext; }
	void setSysInfoTypeSB1V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions(const SysInfoTypeSB1V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions& sysInfoTypeSB1V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions) { *static_cast<SysInfoTypeSB1V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = sysInfoTypeSB1V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions; }
};

class SysInfoTypeSB1V6b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoTypeSB1V6b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoTypeSB1v6b0ext(const SysInfoTypeSB1v6b0ext& sysInfoTypeSB1v6b0ext) { *static_cast<SysInfoTypeSB1v6b0ext*>(items[0]) = sysInfoTypeSB1v6b0ext; }
	void setSysInfoTypeSB1V6b0NonCriticalExtensionsV860NonCriticalExtensions(const SysInfoTypeSB1V6b0NonCriticalExtensionsV860NonCriticalExtensions& sysInfoTypeSB1V6b0NonCriticalExtensionsV860NonCriticalExtensions) { *static_cast<SysInfoTypeSB1V6b0NonCriticalExtensionsV860NonCriticalExtensions*>(items[1]) = sysInfoTypeSB1V6b0NonCriticalExtensionsV860NonCriticalExtensions; }
};

class SysInfoTypeSB1 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoTypeSB1(): Sequence(&theInfo) {}

	void setSibReferenceList(const SIBReferenceList& sibReferenceList) { *static_cast<SIBReferenceList*>(items[0]) = sibReferenceList; }
	void setSysInfoTypeSB1V6b0NonCriticalExtensions(const SysInfoTypeSB1V6b0NonCriticalExtensions& sysInfoTypeSB1V6b0NonCriticalExtensions) { *static_cast<SysInfoTypeSB1V6b0NonCriticalExtensions*>(items[1]) = sysInfoTypeSB1V6b0NonCriticalExtensions; }
};

class SysInfoTypeSB2v6b0ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	SysInfoTypeSB2v6b0ext(): Sequence(&theInfo) {}

	void setExtSIBTypeInfoSchedulingInfoList(const ExtSIBTypeInfoSchedulingInfoList& extSIBTypeInfoSchedulingInfoList) { *static_cast<ExtSIBTypeInfoSchedulingInfoList*>(items[0]) = extSIBTypeInfoSchedulingInfoList; }
};

class SysInfoTypeSB2v860ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoTypeSB2v860ext(): Sequence(&theInfo) {}

	void setExtSIBTypeInfoSchedulingInfoList(const ExtSIBTypeInfoSchedulingInfoList2& extSIBTypeInfoSchedulingInfoList) { *static_cast<ExtSIBTypeInfoSchedulingInfoList2*>(items[0]) = extSIBTypeInfoSchedulingInfoList; }
	void setExtGANSSSIBTypeInfoSchedulingInfoList(const ExtGANSSSIBTypeInfoSchedulingInfoList& extGANSSSIBTypeInfoSchedulingInfoList) { *static_cast<ExtGANSSSIBTypeInfoSchedulingInfoList*>(items[1]) = extGANSSSIBTypeInfoSchedulingInfoList; }
};

class SysInfoTypeSB2V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	SysInfoTypeSB2V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions(): Sequence(&theInfo) {}

};

class SysInfoTypeSB2V6b0NonCriticalExtensionsV860NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoTypeSB2V6b0NonCriticalExtensionsV860NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoTypeSB2v860ext(const SysInfoTypeSB2v860ext& sysInfoTypeSB2v860ext) { *static_cast<SysInfoTypeSB2v860ext*>(items[0]) = sysInfoTypeSB2v860ext; }
	void setSysInfoTypeSB2V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions(const SysInfoTypeSB2V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions& sysInfoTypeSB2V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions) { *static_cast<SysInfoTypeSB2V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions*>(items[1]) = sysInfoTypeSB2V6b0NonCriticalExtensionsV860NonCriticalExtensionsNonCriticalExtensions; }
};

class SysInfoTypeSB2V6b0NonCriticalExtensions : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoTypeSB2V6b0NonCriticalExtensions(): Sequence(&theInfo) {}

	void setSysInfoTypeSB2v6b0ext(const SysInfoTypeSB2v6b0ext& sysInfoTypeSB2v6b0ext) { *static_cast<SysInfoTypeSB2v6b0ext*>(items[0]) = sysInfoTypeSB2v6b0ext; }
	void setSysInfoTypeSB2V6b0NonCriticalExtensionsV860NonCriticalExtensions(const SysInfoTypeSB2V6b0NonCriticalExtensionsV860NonCriticalExtensions& sysInfoTypeSB2V6b0NonCriticalExtensionsV860NonCriticalExtensions) { *static_cast<SysInfoTypeSB2V6b0NonCriticalExtensionsV860NonCriticalExtensions*>(items[1]) = sysInfoTypeSB2V6b0NonCriticalExtensionsV860NonCriticalExtensions; }
};

class SysInfoTypeSB2 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	SysInfoTypeSB2(): Sequence(&theInfo) {}

	void setSibReferenceList(const SIBReferenceList& sibReferenceList) { *static_cast<SIBReferenceList*>(items[0]) = sibReferenceList; }
	void setSysInfoTypeSB2V6b0NonCriticalExtensions(const SysInfoTypeSB2V6b0NonCriticalExtensions& sysInfoTypeSB2V6b0NonCriticalExtensions) { *static_cast<SysInfoTypeSB2V6b0NonCriticalExtensions*>(items[1]) = sysInfoTypeSB2V6b0NonCriticalExtensions; }
};

typedef Integer<CONSTRAINED, 1, 120> UEHistoryInformationUeInactivityPeriod;

class UEHistoryInformation : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	UEHistoryInformation(): Sequence(&theInfo) {}

	void setUEHistoryInformationUeInactivityPeriod(const UEHistoryInformationUeInactivityPeriod& uEHistoryInformationUeInactivityPeriod) { *static_cast<UEHistoryInformationUeInactivityPeriod*>(items[0]) = uEHistoryInformationUeInactivityPeriod; }
	void setUeMobilityStateIndicator(const HighMobilityDetected& ueMobilityStateIndicator) { *static_cast<HighMobilityDetected*>(items[1]) = ueMobilityStateIndicator; }
	void setUldataVolumeHistory(const DataVolumeHistory& uldataVolumeHistory) { *static_cast<DataVolumeHistory*>(items[2]) = uldataVolumeHistory; }
	void setDldataVolumeHistory(const DataVolumeHistory& dldataVolumeHistory) { *static_cast<DataVolumeHistory*>(items[3]) = dldataVolumeHistory; }
};

enum MBMSAccessProbabilityFactorValues {
	apf0_MBMSAccessProbabilityFactor = 0,
	apf32_MBMSAccessProbabilityFactor = 1,
	apf64_MBMSAccessProbabilityFactor = 2,
	apf96_MBMSAccessProbabilityFactor = 3,
	apf128_MBMSAccessProbabilityFactor = 4,
	apf160_MBMSAccessProbabilityFactor = 5,
	apf192_MBMSAccessProbabilityFactor = 6,
	apf224_MBMSAccessProbabilityFactor = 7,
	apf256_MBMSAccessProbabilityFactor = 8,
	apf288_MBMSAccessProbabilityFactor = 9,
	apf320_MBMSAccessProbabilityFactor = 10,
	apf352_MBMSAccessProbabilityFactor = 11,
	apf384_MBMSAccessProbabilityFactor = 12,
	apf416_MBMSAccessProbabilityFactor = 13,
	apf448_MBMSAccessProbabilityFactor = 14,
	apf480_MBMSAccessProbabilityFactor = 15,
	apf512_MBMSAccessProbabilityFactor = 16,
	apf544_MBMSAccessProbabilityFactor = 17,
	apf576_MBMSAccessProbabilityFactor = 18,
	apf608_MBMSAccessProbabilityFactor = 19,
	apf640_MBMSAccessProbabilityFactor = 20,
	apf672_MBMSAccessProbabilityFactor = 21,
	apf704_MBMSAccessProbabilityFactor = 22,
	apf736_MBMSAccessProbabilityFactor = 23,
	apf768_MBMSAccessProbabilityFactor = 24,
	apf800_MBMSAccessProbabilityFactor = 25,
	apf832_MBMSAccessProbabilityFactor = 26,
	apf864_MBMSAccessProbabilityFactor = 27,
	apf896_MBMSAccessProbabilityFactor = 28,
	apf928_MBMSAccessProbabilityFactor = 29,
	apf960_MBMSAccessProbabilityFactor = 30,
	apf1000_MBMSAccessProbabilityFactor = 31,
};
typedef Enumerated<CONSTRAINED, 31> MBMSAccessProbabilityFactor;

typedef BitString<CONSTRAINED, 12, 12> MBMSCellGroupIdentityr6;

typedef Integer<CONSTRAINED, 1, 32> MBMSCommonCCTrChIdentity;

typedef Integer<CONSTRAINED, 1, 32> MBMSCommonPhyChIdentity;

typedef Integer<CONSTRAINED, 1, 32> MBMSCommonRBIdentity;

class MBMSCommonRBInformationr6 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MBMSCommonRBInformationr6(): Sequence(&theInfo) {}

	void setCommonRBIdentity(const MBMSCommonRBIdentity& commonRBIdentity) { *static_cast<MBMSCommonRBIdentity*>(items[0]) = commonRBIdentity; }
	void setPdcpInfo(const PDCPInfor4& pdcpInfo) { *static_cast<PDCPInfor4*>(items[1]) = pdcpInfo; }
	void setRlcInfo(const RLCInfoMTCHr6& rlcInfo) { *static_cast<RLCInfoMTCHr6*>(items[2]) = rlcInfo; }
};

typedef SequenceOf<MBMSCommonRBInformationr6, CONSTRAINED, 1, maxMBMS_CommonRB> MBMSCommonRBInformationListr6;

typedef Integer<CONSTRAINED, 1, 32> MBMSCommonTrChIdentity;

typedef Boolean MBMSConnectedModeCountingScopeCountingForUraPCH;

typedef Boolean MBMSConnectedModeCountingScopeCountingForCellPCH;

typedef Boolean MBMSConnectedModeCountingScopeCountingForCellFACH;

class MBMSConnectedModeCountingScope : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MBMSConnectedModeCountingScope(): Sequence(&theInfo) {}

	void setMBMSConnectedModeCountingScopeCountingForUraPCH(const MBMSConnectedModeCountingScopeCountingForUraPCH& mBMSConnectedModeCountingScopeCountingForUraPCH) { *static_cast<MBMSConnectedModeCountingScopeCountingForUraPCH*>(items[0]) = mBMSConnectedModeCountingScopeCountingForUraPCH; }
	void setMBMSConnectedModeCountingScopeCountingForCellPCH(const MBMSConnectedModeCountingScopeCountingForCellPCH& mBMSConnectedModeCountingScopeCountingForCellPCH) { *static_cast<MBMSConnectedModeCountingScopeCountingForCellPCH*>(items[1]) = mBMSConnectedModeCountingScopeCountingForCellPCH; }
	void setMBMSConnectedModeCountingScopeCountingForCellFACH(const MBMSConnectedModeCountingScopeCountingForCellFACH& mBMSConnectedModeCountingScopeCountingForCellFACH) { *static_cast<MBMSConnectedModeCountingScopeCountingForCellFACH*>(items[2]) = mBMSConnectedModeCountingScopeCountingForCellFACH; }
};

typedef Integer<CONSTRAINED, 1, maxSCCPCH> MBMSSCCPCHIdentity;

enum MBMSSoftCombTimingOffsetValues {
	ms0_MBMSSoftCombTimingOffset = 0,
	ms10_MBMSSoftCombTimingOffset = 1,
	ms20_MBMSSoftCombTimingOffset = 2,
	ms40_MBMSSoftCombTimingOffset = 3,
};
typedef Enumerated<CONSTRAINED, 3> MBMSSoftCombTimingOffset;

typedef Integer<CONSTRAINED, 1, maxMBMSservUnmodif> MBMSShortTransmissionID;

typedef Integer<CONSTRAINED, 1, 15> MBMSLogicalChIdentity;

class MBMSPTMRBInformationC : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MBMSPTMRBInformationC(): Sequence(&theInfo) {}

	void setRbInformation(const MBMSCommonRBIdentity& rbInformation) { *static_cast<MBMSCommonRBIdentity*>(items[0]) = rbInformation; }
	void setShortTransmissionID(const MBMSShortTransmissionID& shortTransmissionID) { *static_cast<MBMSShortTransmissionID*>(items[1]) = shortTransmissionID; }
	void setLogicalChIdentity(const MBMSLogicalChIdentity& logicalChIdentity) { *static_cast<MBMSLogicalChIdentity*>(items[2]) = logicalChIdentity; }
};

typedef SequenceOf<MBMSPTMRBInformationC, CONSTRAINED, 1, maxRBperTrCh> MBMSPTMRBInformationCList;

class MBMSTrCHInformationCurr : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MBMSTrCHInformationCurr(): Sequence(&theInfo) {}

	void setTranspChInfo(const MBMSCommonTrChIdentity& transpChInfo) { *static_cast<MBMSCommonTrChIdentity*>(items[0]) = transpChInfo; }
	void setRbInformation(const MBMSPTMRBInformationCList& rbInformation) { *static_cast<MBMSPTMRBInformationCList*>(items[1]) = rbInformation; }
	void setMschConfigurationInfo(const MBMSMSCHConfigurationInfor6& mschConfigurationInfo) { *static_cast<MBMSMSCHConfigurationInfor6*>(items[2]) = mschConfigurationInfo; }
};

typedef SequenceOf<MBMSTrCHInformationCurr, CONSTRAINED, 1, maxFACHPCH> MBMSTrCHInformationCurrList;

class MBMSCurrentCellSCCPCHr6 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	MBMSCurrentCellSCCPCHr6(): Sequence(&theInfo) {}

	void setSccpchIdentity(const MBMSSCCPCHIdentity& sccpchIdentity) { *static_cast<MBMSSCCPCHIdentity*>(items[0]) = sccpchIdentity; }
	void setSecondaryCCPCHInfo(const MBMSCommonPhyChIdentity& secondaryCCPCHInfo) { *static_cast<MBMSCommonPhyChIdentity*>(items[1]) = secondaryCCPCHInfo; }
	void setSoftCombTimingOffset(const MBMSSoftCombTimingOffset& softCombTimingOffset) { *static_cast<MBMSSoftCombTimingOffset*>(items[2]) = softCombTimingOffset; }
	void setTranspChInfoCommonForAllTrCh(const MBMSCommonCCTrChIdentity& transpChInfoCommonForAllTrCh) { *static_cast<MBMSCommonCCTrChIdentity*>(items[3]) = transpChInfoCommonForAllTrCh; }
	void setTranspCHInformation(const MBMSTrCHInformationCurrList& transpCHInformation) { *static_cast<MBMSTrCHInformationCurrList*>(items[4]) = transpCHInformation; }
};

typedef SequenceOf<MBMSCurrentCellSCCPCHr6, CONSTRAINED, 1, maxSCCPCH> MBMSCurrentCellSCCPCHListr6;

class MBMSJoinedInformationr6 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MBMSJoinedInformationr6(): Sequence(&theInfo) {}

	void setPTMSI(const PTMSIGSMMAP& pTMSI) { *static_cast<PTMSIGSMMAP*>(items[0]) = pTMSI; }
};

typedef Integer<CONSTRAINED, 0, 7> MBMSL1CombiningSchedule32CycleOffset;

class MBMSL1CombiningSchedule32MtchL1CombiningPeriodList : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	MBMSL1CombiningSchedule32MtchL1CombiningPeriodList(): Sequence(&theInfo) {}

};

class MBMSL1CombiningSchedule32 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSL1CombiningSchedule32(): Sequence(&theInfo) {}

	void setMBMSL1CombiningSchedule32CycleOffset(const MBMSL1CombiningSchedule32CycleOffset& mBMSL1CombiningSchedule32CycleOffset) { *static_cast<MBMSL1CombiningSchedule32CycleOffset*>(items[0]) = mBMSL1CombiningSchedule32CycleOffset; }
	void setMBMSL1CombiningSchedule32MtchL1CombiningPeriodList(const MBMSL1CombiningSchedule32MtchL1CombiningPeriodList& mBMSL1CombiningSchedule32MtchL1CombiningPeriodList) { *static_cast<MBMSL1CombiningSchedule32MtchL1CombiningPeriodList*>(items[1]) = mBMSL1CombiningSchedule32MtchL1CombiningPeriodList; }
};

typedef Integer<CONSTRAINED, 0, 15> MBMSL1CombiningSchedule64CycleOffset;

class MBMSL1CombiningSchedule64MtchL1CombiningPeriodList : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	MBMSL1CombiningSchedule64MtchL1CombiningPeriodList(): Sequence(&theInfo) {}

};

class MBMSL1CombiningSchedule64 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSL1CombiningSchedule64(): Sequence(&theInfo) {}

	void setMBMSL1CombiningSchedule64CycleOffset(const MBMSL1CombiningSchedule64CycleOffset& mBMSL1CombiningSchedule64CycleOffset) { *static_cast<MBMSL1CombiningSchedule64CycleOffset*>(items[0]) = mBMSL1CombiningSchedule64CycleOffset; }
	void setMBMSL1CombiningSchedule64MtchL1CombiningPeriodList(const MBMSL1CombiningSchedule64MtchL1CombiningPeriodList& mBMSL1CombiningSchedule64MtchL1CombiningPeriodList) { *static_cast<MBMSL1CombiningSchedule64MtchL1CombiningPeriodList*>(items[1]) = mBMSL1CombiningSchedule64MtchL1CombiningPeriodList; }
};

typedef Integer<CONSTRAINED, 0, 31> MBMSL1CombiningSchedule128CycleOffset;

class MBMSL1CombiningSchedule128MtchL1CombiningPeriodList : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	MBMSL1CombiningSchedule128MtchL1CombiningPeriodList(): Sequence(&theInfo) {}

};

class MBMSL1CombiningSchedule128 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSL1CombiningSchedule128(): Sequence(&theInfo) {}

	void setMBMSL1CombiningSchedule128CycleOffset(const MBMSL1CombiningSchedule128CycleOffset& mBMSL1CombiningSchedule128CycleOffset) { *static_cast<MBMSL1CombiningSchedule128CycleOffset*>(items[0]) = mBMSL1CombiningSchedule128CycleOffset; }
	void setMBMSL1CombiningSchedule128MtchL1CombiningPeriodList(const MBMSL1CombiningSchedule128MtchL1CombiningPeriodList& mBMSL1CombiningSchedule128MtchL1CombiningPeriodList) { *static_cast<MBMSL1CombiningSchedule128MtchL1CombiningPeriodList*>(items[1]) = mBMSL1CombiningSchedule128MtchL1CombiningPeriodList; }
};

typedef Integer<CONSTRAINED, 0, 63> MBMSL1CombiningSchedule256CycleOffset;

class MBMSL1CombiningSchedule256MtchL1CombiningPeriodList : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	MBMSL1CombiningSchedule256MtchL1CombiningPeriodList(): Sequence(&theInfo) {}

};

class MBMSL1CombiningSchedule256 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSL1CombiningSchedule256(): Sequence(&theInfo) {}

	void setMBMSL1CombiningSchedule256CycleOffset(const MBMSL1CombiningSchedule256CycleOffset& mBMSL1CombiningSchedule256CycleOffset) { *static_cast<MBMSL1CombiningSchedule256CycleOffset*>(items[0]) = mBMSL1CombiningSchedule256CycleOffset; }
	void setMBMSL1CombiningSchedule256MtchL1CombiningPeriodList(const MBMSL1CombiningSchedule256MtchL1CombiningPeriodList& mBMSL1CombiningSchedule256MtchL1CombiningPeriodList) { *static_cast<MBMSL1CombiningSchedule256MtchL1CombiningPeriodList*>(items[1]) = mBMSL1CombiningSchedule256MtchL1CombiningPeriodList; }
};

typedef Integer<CONSTRAINED, 0, 127> MBMSL1CombiningSchedule512CycleOffset;

class MBMSL1CombiningSchedule512MtchL1CombiningPeriodList : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	MBMSL1CombiningSchedule512MtchL1CombiningPeriodList(): Sequence(&theInfo) {}

};

class MBMSL1CombiningSchedule512 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSL1CombiningSchedule512(): Sequence(&theInfo) {}

	void setMBMSL1CombiningSchedule512CycleOffset(const MBMSL1CombiningSchedule512CycleOffset& mBMSL1CombiningSchedule512CycleOffset) { *static_cast<MBMSL1CombiningSchedule512CycleOffset*>(items[0]) = mBMSL1CombiningSchedule512CycleOffset; }
	void setMBMSL1CombiningSchedule512MtchL1CombiningPeriodList(const MBMSL1CombiningSchedule512MtchL1CombiningPeriodList& mBMSL1CombiningSchedule512MtchL1CombiningPeriodList) { *static_cast<MBMSL1CombiningSchedule512MtchL1CombiningPeriodList*>(items[1]) = mBMSL1CombiningSchedule512MtchL1CombiningPeriodList; }
};

typedef Integer<CONSTRAINED, 0, 255> MBMSL1CombiningSchedule1024CycleOffset;

class MBMSL1CombiningSchedule1024MtchL1CombiningPeriodList : public Sequence {
private:
	static const void *itemsInfo[0];
	static bool itemsPres[0];
public:
	static const Info theInfo;
	MBMSL1CombiningSchedule1024MtchL1CombiningPeriodList(): Sequence(&theInfo) {}

};

class MBMSL1CombiningSchedule1024 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSL1CombiningSchedule1024(): Sequence(&theInfo) {}

	void setMBMSL1CombiningSchedule1024CycleOffset(const MBMSL1CombiningSchedule1024CycleOffset& mBMSL1CombiningSchedule1024CycleOffset) { *static_cast<MBMSL1CombiningSchedule1024CycleOffset*>(items[0]) = mBMSL1CombiningSchedule1024CycleOffset; }
	void setMBMSL1CombiningSchedule1024MtchL1CombiningPeriodList(const MBMSL1CombiningSchedule1024MtchL1CombiningPeriodList& mBMSL1CombiningSchedule1024MtchL1CombiningPeriodList) { *static_cast<MBMSL1CombiningSchedule1024MtchL1CombiningPeriodList*>(items[1]) = mBMSL1CombiningSchedule1024MtchL1CombiningPeriodList; }
};

class MBMSL1CombiningSchedule : public Choice {
private:
	static const void *choicesInfo[6];
public:
	enum MBMSL1CombiningScheduleChoices {
		cycleLength32 = 0,
		cycleLength64 = 1,
		cycleLength128 = 2,
		cycleLength256 = 3,
		cycleLength512 = 4,
		cycleLength1024 = 5,
	};
	static const Info theInfo;
	MBMSL1CombiningSchedule(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, 0, 3> MBMSL1CombiningTransmTimeDiff;

class MBMSL23ConfigurationSameAsCurrent : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSL23ConfigurationSameAsCurrent(): Sequence(&theInfo) {}

	void setCurrentCellSCCPCH(const MBMSSCCPCHIdentity& currentCellSCCPCH) { *static_cast<MBMSSCCPCHIdentity*>(items[0]) = currentCellSCCPCH; }
	void setMschConfigurationInfo(const MBMSMSCHConfigurationInfor6& mschConfigurationInfo) { *static_cast<MBMSMSCHConfigurationInfor6*>(items[1]) = mschConfigurationInfo; }
};

typedef Boolean MBMSTrCHInformationNeighbTranspChCombiningStatus;

typedef Boolean MBMSPTMRBInformationNLayer1CombiningStatus;

class MBMSPTMRBInformationN : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MBMSPTMRBInformationN(): Sequence(&theInfo) {}

	void setShortTransmissionID(const MBMSShortTransmissionID& shortTransmissionID) { *static_cast<MBMSShortTransmissionID*>(items[0]) = shortTransmissionID; }
	void setLogicalChIdentity(const MBMSLogicalChIdentity& logicalChIdentity) { *static_cast<MBMSLogicalChIdentity*>(items[1]) = logicalChIdentity; }
	void setMBMSPTMRBInformationNLayer1CombiningStatus(const MBMSPTMRBInformationNLayer1CombiningStatus& mBMSPTMRBInformationNLayer1CombiningStatus) { *static_cast<MBMSPTMRBInformationNLayer1CombiningStatus*>(items[2]) = mBMSPTMRBInformationNLayer1CombiningStatus; }
};

typedef SequenceOf<MBMSPTMRBInformationN, CONSTRAINED, 1, maxRBperTrCh> MBMSPTMRBInformationNList;

class MBMSTrCHInformationNeighb : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	MBMSTrCHInformationNeighb(): Sequence(&theInfo) {}

	void setTranspChInfo(const MBMSCommonTrChIdentity& transpChInfo) { *static_cast<MBMSCommonTrChIdentity*>(items[0]) = transpChInfo; }
	void setMBMSTrCHInformationNeighbTranspChCombiningStatus(const MBMSTrCHInformationNeighbTranspChCombiningStatus& mBMSTrCHInformationNeighbTranspChCombiningStatus) { *static_cast<MBMSTrCHInformationNeighbTranspChCombiningStatus*>(items[1]) = mBMSTrCHInformationNeighbTranspChCombiningStatus; }
	void setRbInformation(const MBMSPTMRBInformationNList& rbInformation) { *static_cast<MBMSPTMRBInformationNList*>(items[2]) = rbInformation; }
	void setMschConfigurationInfo(const MBMSMSCHConfigurationInfor6& mschConfigurationInfo) { *static_cast<MBMSMSCHConfigurationInfor6*>(items[3]) = mschConfigurationInfo; }
};

typedef SequenceOf<MBMSTrCHInformationNeighb, CONSTRAINED, 1, maxFACHPCH> MBMSTrCHInformationNeighbList;

class MBMSL23ConfigurationDifferent : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSL23ConfigurationDifferent(): Sequence(&theInfo) {}

	void setTranspChInfoCommonForAllTrCh(const MBMSCommonCCTrChIdentity& transpChInfoCommonForAllTrCh) { *static_cast<MBMSCommonCCTrChIdentity*>(items[0]) = transpChInfoCommonForAllTrCh; }
	void setTranspCHInformation(const MBMSTrCHInformationNeighbList& transpCHInformation) { *static_cast<MBMSTrCHInformationNeighbList*>(items[1]) = transpCHInformation; }
};

class MBMSL23Configuration : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MBMSL23ConfigurationChoices {
		mBMSL23ConfigurationSameAsCurrent = 0,
		mBMSL23ConfigurationDifferent = 1,
	};
	static const Info theInfo;
	MBMSL23Configuration(): Choice(&theInfo) {}
};

typedef Integer<CONSTRAINED, -10, 5> MBMSMICHPowerOffset;

enum MBMSNICountPerFrameValues {
	ni18_MBMSNICountPerFrame = 0,
	ni36_MBMSNICountPerFrame = 1,
	ni72_MBMSNICountPerFrame = 2,
	ni144_MBMSNICountPerFrame = 3,
};
typedef Enumerated<CONSTRAINED, 3> MBMSNICountPerFrame;

typedef Boolean MBMSMICHConfigurationInfor6ModeFddSttdIndicator;

class MBMSMICHConfigurationInfor6ModeFdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MBMSMICHConfigurationInfor6ModeFdd(): Sequence(&theInfo) {}

	void setChannelisationCode256(const ChannelisationCode256& channelisationCode256) { *static_cast<ChannelisationCode256*>(items[0]) = channelisationCode256; }
	void setNiCountPerFrame(const MBMSNICountPerFrame& niCountPerFrame) { *static_cast<MBMSNICountPerFrame*>(items[1]) = niCountPerFrame; }
	void setMBMSMICHConfigurationInfor6ModeFddSttdIndicator(const MBMSMICHConfigurationInfor6ModeFddSttdIndicator& mBMSMICHConfigurationInfor6ModeFddSttdIndicator) { *static_cast<MBMSMICHConfigurationInfor6ModeFddSttdIndicator*>(items[2]) = mBMSMICHConfigurationInfor6ModeFddSttdIndicator; }
};

enum MBMSMICHNotificationIndLengthValues {
	mn4_MBMSMICHNotificationIndLength = 0,
	mn8_MBMSMICHNotificationIndLength = 1,
	mn16_MBMSMICHNotificationIndLength = 2,
};
typedef Enumerated<CONSTRAINED, 2> MBMSMICHNotificationIndLength;

class MBMSMICHConfigurationInfor6ModeTdd384 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	MBMSMICHConfigurationInfor6ModeTdd384(): Sequence(&theInfo) {}

	void setTimeslot(const TimeslotNumber& timeslot) { *static_cast<TimeslotNumber*>(items[0]) = timeslot; }
	void setMidambleShiftAndBurstType(const MidambleShiftAndBurstType& midambleShiftAndBurstType) { *static_cast<MidambleShiftAndBurstType*>(items[1]) = midambleShiftAndBurstType; }
	void setChannelisationCode(const DLTSChannelisationCode& channelisationCode) { *static_cast<DLTSChannelisationCode*>(items[2]) = channelisationCode; }
	void setRepetitionPeriodLengthOffset(const RepPerLengthOffsetMICH& repetitionPeriodLengthOffset) { *static_cast<RepPerLengthOffsetMICH*>(items[3]) = repetitionPeriodLengthOffset; }
	void setMbmsNotificationIndLength(const MBMSMICHNotificationIndLength& mbmsNotificationIndLength) { *static_cast<MBMSMICHNotificationIndLength*>(items[4]) = mbmsNotificationIndLength; }
};

typedef SequenceOf<DLTSChannelisationCode, CONSTRAINED, 1, 2> MBMSMICHConfigurationInfor6ModeTdd128ChannelisationCodeList;

class MBMSMICHConfigurationInfor6ModeTdd128 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	MBMSMICHConfigurationInfor6ModeTdd128(): Sequence(&theInfo) {}

	void setTimeslot(const TimeslotNumberLCRr4& timeslot) { *static_cast<TimeslotNumberLCRr4*>(items[0]) = timeslot; }
	void setMidambleShiftAndBurstType(const MidambleShiftAndBurstTypeLCRr4& midambleShiftAndBurstType) { *static_cast<MidambleShiftAndBurstTypeLCRr4*>(items[1]) = midambleShiftAndBurstType; }
	void setMBMSMICHConfigurationInfor6ModeTdd128ChannelisationCodeList(const MBMSMICHConfigurationInfor6ModeTdd128ChannelisationCodeList& mBMSMICHConfigurationInfor6ModeTdd128ChannelisationCodeList) { *static_cast<MBMSMICHConfigurationInfor6ModeTdd128ChannelisationCodeList*>(items[2]) = mBMSMICHConfigurationInfor6ModeTdd128ChannelisationCodeList; }
	void setRepetitionPeriodLengthOffset(const RepPerLengthOffsetMICH& repetitionPeriodLengthOffset) { *static_cast<RepPerLengthOffsetMICH*>(items[3]) = repetitionPeriodLengthOffset; }
	void setMbmsNotificationIndLength(const MBMSMICHNotificationIndLength& mbmsNotificationIndLength) { *static_cast<MBMSMICHNotificationIndLength*>(items[4]) = mbmsNotificationIndLength; }
};

class MBMSMICHConfigurationInfor6Mode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MBMSMICHConfigurationInfor6ModeChoices {
		mBMSMICHConfigurationInfor6ModeFdd = 0,
		mBMSMICHConfigurationInfor6ModeTdd384 = 1,
		mBMSMICHConfigurationInfor6ModeTdd128 = 2,
	};
	static const Info theInfo;
	MBMSMICHConfigurationInfor6Mode(): Choice(&theInfo) {}
};

class MBMSMICHConfigurationInfor6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSMICHConfigurationInfor6(): Sequence(&theInfo) {}

	void setMichPowerOffset(const MBMSMICHPowerOffset& michPowerOffset) { *static_cast<MBMSMICHPowerOffset*>(items[0]) = michPowerOffset; }
	void setMBMSMICHConfigurationInfor6Mode(const MBMSMICHConfigurationInfor6Mode& mBMSMICHConfigurationInfor6Mode) { *static_cast<MBMSMICHConfigurationInfor6Mode*>(items[1]) = mBMSMICHConfigurationInfor6Mode; }
};

class MBMSMICHConfigurationInfov770extModeTdd384 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MBMSMICHConfigurationInfov770extModeTdd384(): Sequence(&theInfo) {}

	void setMidambleShiftAndBurstType(const MidambleShiftAndBurstTyper7& midambleShiftAndBurstType) { *static_cast<MidambleShiftAndBurstTyper7*>(items[0]) = midambleShiftAndBurstType; }
};

class MBMSMICHConfigurationInfov770extModeTdd768 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MBMSMICHConfigurationInfov770extModeTdd768(): Sequence(&theInfo) {}

	void setMidambleShiftAndBurstType(const MidambleShiftAndBurstTypeVHCR& midambleShiftAndBurstType) { *static_cast<MidambleShiftAndBurstTypeVHCR*>(items[0]) = midambleShiftAndBurstType; }
};

class MBMSMICHConfigurationInfov770extModeTdd128 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MBMSMICHConfigurationInfov770extModeTdd128(): Sequence(&theInfo) {}

	void setMbsfnSpecialTimeSlot(const TimeSlotLCRext& mbsfnSpecialTimeSlot) { *static_cast<TimeSlotLCRext*>(items[0]) = mbsfnSpecialTimeSlot; }
};

class MBMSMICHConfigurationInfov770extMode : public Choice {
private:
	static const void *choicesInfo[3];
public:
	enum MBMSMICHConfigurationInfov770extModeChoices {
		mBMSMICHConfigurationInfov770extModeTdd384 = 0,
		mBMSMICHConfigurationInfov770extModeTdd768 = 1,
		mBMSMICHConfigurationInfov770extModeTdd128 = 2,
	};
	static const Info theInfo;
	MBMSMICHConfigurationInfov770extMode(): Choice(&theInfo) {}
};

class MBMSMICHConfigurationInfov770ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MBMSMICHConfigurationInfov770ext(): Sequence(&theInfo) {}

	void setMBMSMICHConfigurationInfov770extMode(const MBMSMICHConfigurationInfov770extMode& mBMSMICHConfigurationInfov770extMode) { *static_cast<MBMSMICHConfigurationInfov770extMode*>(items[0]) = mBMSMICHConfigurationInfov770extMode; }
};

enum MBMSNICountPerFrameIMB384Values {
	ni16_MBMSNICountPerFrameIMB384 = 0,
	ni32_MBMSNICountPerFrameIMB384 = 1,
	ni64_MBMSNICountPerFrameIMB384 = 2,
	ni128_MBMSNICountPerFrameIMB384 = 3,
};
typedef Enumerated<CONSTRAINED, 3> MBMSNICountPerFrameIMB384;

class MBMSMICHConfigurationInfov890extModeImb384 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSMICHConfigurationInfov890extModeImb384(): Sequence(&theInfo) {}

	void setChannelisationCode256(const ChannelisationCode256& channelisationCode256) { *static_cast<ChannelisationCode256*>(items[0]) = channelisationCode256; }
	void setNiCountPerFrame(const MBMSNICountPerFrameIMB384& niCountPerFrame) { *static_cast<MBMSNICountPerFrameIMB384*>(items[1]) = niCountPerFrame; }
};

class MBMSMICHConfigurationInfov890extMode : public Choice {
private:
	static const void *choicesInfo[1];
public:
	enum MBMSMICHConfigurationInfov890extModeChoices {
		mBMSMICHConfigurationInfov890extModeImb384 = 0,
	};
	static const Info theInfo;
	MBMSMICHConfigurationInfov890extMode(): Choice(&theInfo) {}
};

class MBMSMICHConfigurationInfov890ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MBMSMICHConfigurationInfov890ext(): Sequence(&theInfo) {}

	void setMBMSMICHConfigurationInfov890extMode(const MBMSMICHConfigurationInfov890extMode& mBMSMICHConfigurationInfov890extMode) { *static_cast<MBMSMICHConfigurationInfov890extMode*>(items[0]) = mBMSMICHConfigurationInfov890extMode; }
};

typedef OctetString<CONSTRAINED, 3, 3> MBMSServiceIdentityr6ServiceIdentity;

typedef Null MBMSServiceIdentityr6PlmnIdentitySameAsMIBPLMNId;

typedef Integer<CONSTRAINED, 1, 5> MBMSServiceIdentityr6PlmnIdentityOtherSameAsMIBMultiPLMNId;

class MBMSServiceIdentityr6PlmnIdentityOther : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MBMSServiceIdentityr6PlmnIdentityOtherChoices {
		mBMSServiceIdentityr6PlmnIdentityOtherSameAsMIBMultiPLMNId = 0,
		explicitPLMNId = 1,
	};
	static const Info theInfo;
	MBMSServiceIdentityr6PlmnIdentityOther(): Choice(&theInfo) {}
};

class MBMSServiceIdentityr6PlmnIdentity : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MBMSServiceIdentityr6PlmnIdentityChoices {
		mBMSServiceIdentityr6PlmnIdentitySameAsMIBPLMNId = 0,
		mBMSServiceIdentityr6PlmnIdentityOther = 1,
	};
	static const Info theInfo;
	MBMSServiceIdentityr6PlmnIdentity(): Choice(&theInfo) {}
};

class MBMSServiceIdentityr6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSServiceIdentityr6(): Sequence(&theInfo) {}

	void setMBMSServiceIdentityr6ServiceIdentity(const MBMSServiceIdentityr6ServiceIdentity& mBMSServiceIdentityr6ServiceIdentity) { *static_cast<MBMSServiceIdentityr6ServiceIdentity*>(items[0]) = mBMSServiceIdentityr6ServiceIdentity; }
	void setMBMSServiceIdentityr6PlmnIdentity(const MBMSServiceIdentityr6PlmnIdentity& mBMSServiceIdentityr6PlmnIdentity) { *static_cast<MBMSServiceIdentityr6PlmnIdentity*>(items[1]) = mBMSServiceIdentityr6PlmnIdentity; }
};

class MBMSTransmissionIdentity : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSTransmissionIdentity(): Sequence(&theInfo) {}

	void setMbmsServiceIdentity(const MBMSServiceIdentityr6& mbmsServiceIdentity) { *static_cast<MBMSServiceIdentityr6*>(items[0]) = mbmsServiceIdentity; }
	void setMbmsSessionIdentity(const MBMSSessionIdentity& mbmsSessionIdentity) { *static_cast<MBMSSessionIdentity*>(items[1]) = mbmsSessionIdentity; }
};

enum MBMSRequiredUEActionModValues {
	none_MBMSRequiredUEActionMod = 0,
	acquireCountingInfo_MBMSRequiredUEActionMod = 1,
	acquireCountingInfoPTM_RBsUnmodified_MBMSRequiredUEActionMod = 2,
	acquirePTM_RBInfo_MBMSRequiredUEActionMod = 3,
	requestPTPRB_MBMSRequiredUEActionMod = 4,
	releasePTM_RB_MBMSRequiredUEActionMod = 5,
};
typedef Enumerated<CONSTRAINED, 5> MBMSRequiredUEActionMod;

typedef Integer<CONSTRAINED, 1, maxMBMS_Freq> MBMSPFLIndex;

typedef FrequencyInfo MBMSPFLInfo;

class MBMSModifedServicer6MbmsPreferredFrequency : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MBMSModifedServicer6MbmsPreferredFrequencyChoices {
		mcch = 0,
		dcch = 1,
	};
	static const Info theInfo;
	MBMSModifedServicer6MbmsPreferredFrequency(): Choice(&theInfo) {}
};

enum MBMSModifedServicer6dummyValues {
	true_MBMSModifedServicer6dummy = 0,
};
typedef Enumerated<CONSTRAINED, 0> MBMSModifedServicer6dummy;

typedef Boolean MBMSModifedServicer6ContinueMCCHReading;

class MBMSModifedServicer6 : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	MBMSModifedServicer6(): Sequence(&theInfo) {}

	void setMbmsTransmissionIdentity(const MBMSTransmissionIdentity& mbmsTransmissionIdentity) { *static_cast<MBMSTransmissionIdentity*>(items[0]) = mbmsTransmissionIdentity; }
	void setMbmsRequiredUEAction(const MBMSRequiredUEActionMod& mbmsRequiredUEAction) { *static_cast<MBMSRequiredUEActionMod*>(items[1]) = mbmsRequiredUEAction; }
	void setMBMSModifedServicer6MbmsPreferredFrequency(const MBMSModifedServicer6MbmsPreferredFrequency& mBMSModifedServicer6MbmsPreferredFrequency) { *static_cast<MBMSModifedServicer6MbmsPreferredFrequency*>(items[2]) = mBMSModifedServicer6MbmsPreferredFrequency; }
	void setMBMSModifedServicer6dummy(const MBMSModifedServicer6dummy& mBMSModifedServicer6dummy) { *static_cast<MBMSModifedServicer6dummy*>(items[3]) = mBMSModifedServicer6dummy; }
	void setMBMSModifedServicer6ContinueMCCHReading(const MBMSModifedServicer6ContinueMCCHReading& mBMSModifedServicer6ContinueMCCHReading) { *static_cast<MBMSModifedServicer6ContinueMCCHReading*>(items[4]) = mBMSModifedServicer6ContinueMCCHReading; }
};

typedef SequenceOf<MBMSModifedServicer6, CONSTRAINED, 1, maxMBMSservModif> MBMSModifedServiceListr6;

typedef Integer<CONSTRAINED, 1, maxMBSFNClusters> MBSFNClusterFrequencyr7;

class MBMSModifiedServicev770ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MBMSModifiedServicev770ext(): Sequence(&theInfo) {}

	void setMbsfnClusterFrequency(const MBSFNClusterFrequencyr7& mbsfnClusterFrequency) { *static_cast<MBSFNClusterFrequencyr7*>(items[0]) = mbsfnClusterFrequency; }
};

enum MBMSPTMRBReleaseCauseLCRr7Values {
	normalRelease_MBMSPTMRBReleaseCauseLCRr7 = 0,
	outOfMBMSServiceCoverageInRAN_MBMSPTMRBReleaseCauseLCRr7 = 1,
	networkAbnormalRelease_MBMSPTMRBReleaseCauseLCRr7 = 2,
	spare5_MBMSPTMRBReleaseCauseLCRr7 = 3,
	spare4_MBMSPTMRBReleaseCauseLCRr7 = 4,
	spare3_MBMSPTMRBReleaseCauseLCRr7 = 5,
	spare2_MBMSPTMRBReleaseCauseLCRr7 = 6,
	spare1_MBMSPTMRBReleaseCauseLCRr7 = 7,
};
typedef Enumerated<CONSTRAINED, 7> MBMSPTMRBReleaseCauseLCRr7;

class MBMSModifiedServiceLCRv7c0ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MBMSModifiedServiceLCRv7c0ext(): Sequence(&theInfo) {}

	void setRbReleaseCause(const MBMSPTMRBReleaseCauseLCRr7& rbReleaseCause) { *static_cast<MBMSPTMRBReleaseCauseLCRr7*>(items[0]) = rbReleaseCause; }
};

typedef SequenceOf<MBMSModifiedServicev770ext, CONSTRAINED, 1, maxMBMSservModif> MBMSModifiedServiceListv770ext;

typedef SequenceOf<MBMSModifiedServiceLCRv7c0ext, CONSTRAINED, 1, maxMBMSservModif> MBMSModifiedServiceListLCRv7c0ext;

enum MBMSSCCPCHPwrOffsetDiffValues {
	mcpo_minus6_MBMSSCCPCHPwrOffsetDiff = 0,
	mcpo_minus3_MBMSSCCPCHPwrOffsetDiff = 1,
	mcpo_plus3_MBMSSCCPCHPwrOffsetDiff = 2,
	mcpo_plus6_MBMSSCCPCHPwrOffsetDiff = 3,
};
typedef Enumerated<CONSTRAINED, 3> MBMSSCCPCHPwrOffsetDiff;

class MBMSNeighbouringCellSCCPCHr6Layer1CombiningFdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MBMSNeighbouringCellSCCPCHr6Layer1CombiningFdd(): Sequence(&theInfo) {}

	void setSoftCombTimingOffset(const MBMSSoftCombTimingOffset& softCombTimingOffset) { *static_cast<MBMSSoftCombTimingOffset*>(items[0]) = softCombTimingOffset; }
	void setMbmsL1CombiningTransmTimeDiff(const MBMSL1CombiningTransmTimeDiff& mbmsL1CombiningTransmTimeDiff) { *static_cast<MBMSL1CombiningTransmTimeDiff*>(items[1]) = mbmsL1CombiningTransmTimeDiff; }
	void setMbmsL1CombiningSchedule(const MBMSL1CombiningSchedule& mbmsL1CombiningSchedule) { *static_cast<MBMSL1CombiningSchedule*>(items[2]) = mbmsL1CombiningSchedule; }
};

typedef Null MBMSNeighbouringCellSCCPCHr6Layer1CombiningTdd;

class MBMSNeighbouringCellSCCPCHr6Layer1Combining : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MBMSNeighbouringCellSCCPCHr6Layer1CombiningChoices {
		mBMSNeighbouringCellSCCPCHr6Layer1CombiningFdd = 0,
		mBMSNeighbouringCellSCCPCHr6Layer1CombiningTdd = 1,
	};
	static const Info theInfo;
	MBMSNeighbouringCellSCCPCHr6Layer1Combining(): Choice(&theInfo) {}
};

class MBMSNeighbouringCellSCCPCHr6 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	MBMSNeighbouringCellSCCPCHr6(): Sequence(&theInfo) {}

	void setSecondaryCCPCHInfo(const MBMSCommonPhyChIdentity& secondaryCCPCHInfo) { *static_cast<MBMSCommonPhyChIdentity*>(items[0]) = secondaryCCPCHInfo; }
	void setSecondaryCCPCHPwrOffsetDiff(const MBMSSCCPCHPwrOffsetDiff& secondaryCCPCHPwrOffsetDiff) { *static_cast<MBMSSCCPCHPwrOffsetDiff*>(items[1]) = secondaryCCPCHPwrOffsetDiff; }
	void setMBMSNeighbouringCellSCCPCHr6Layer1Combining(const MBMSNeighbouringCellSCCPCHr6Layer1Combining& mBMSNeighbouringCellSCCPCHr6Layer1Combining) { *static_cast<MBMSNeighbouringCellSCCPCHr6Layer1Combining*>(items[2]) = mBMSNeighbouringCellSCCPCHr6Layer1Combining; }
	void setMbmsL23Configuration(const MBMSL23Configuration& mbmsL23Configuration) { *static_cast<MBMSL23Configuration*>(items[3]) = mbmsL23Configuration; }
};

class MBMSNeighbouringCellSCCPCHv770extLayer1CombiningFdd : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MBMSNeighbouringCellSCCPCHv770extLayer1CombiningFdd(): Sequence(&theInfo) {}

	void setSoftCombTimingOffset(const MBMSSoftCombTimingOffset& softCombTimingOffset) { *static_cast<MBMSSoftCombTimingOffset*>(items[0]) = softCombTimingOffset; }
	void setMbmsL1CombiningTransmTimeDiff(const MBMSL1CombiningTransmTimeDiff& mbmsL1CombiningTransmTimeDiff) { *static_cast<MBMSL1CombiningTransmTimeDiff*>(items[1]) = mbmsL1CombiningTransmTimeDiff; }
	void setMbmsL1CombiningSchedule(const MBMSL1CombiningSchedule& mbmsL1CombiningSchedule) { *static_cast<MBMSL1CombiningSchedule*>(items[2]) = mbmsL1CombiningSchedule; }
};

typedef Null MBMSNeighbouringCellSCCPCHv770extLayer1CombiningTdd;

class MBMSNeighbouringCellSCCPCHv770extLayer1Combining : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MBMSNeighbouringCellSCCPCHv770extLayer1CombiningChoices {
		mBMSNeighbouringCellSCCPCHv770extLayer1CombiningFdd = 0,
		mBMSNeighbouringCellSCCPCHv770extLayer1CombiningTdd = 1,
	};
	static const Info theInfo;
	MBMSNeighbouringCellSCCPCHv770extLayer1Combining(): Choice(&theInfo) {}
};

class MBMSNeighbouringCellSCCPCHv770ext : public Sequence {
private:
	static const void *itemsInfo[5];
	static bool itemsPres[5];
public:
	static const Info theInfo;
	MBMSNeighbouringCellSCCPCHv770ext(): Sequence(&theInfo) {}

	void setSecondaryCCPCHInfo(const MBMSCommonPhyChIdentity& secondaryCCPCHInfo) { *static_cast<MBMSCommonPhyChIdentity*>(items[0]) = secondaryCCPCHInfo; }
	void setSecondaryCCPCHInfoDiff(const SecondaryCCPCHInfoDiffMBMS& secondaryCCPCHInfoDiff) { *static_cast<SecondaryCCPCHInfoDiffMBMS*>(items[1]) = secondaryCCPCHInfoDiff; }
	void setSecondaryCCPCHPwrOffsetDiff(const MBMSSCCPCHPwrOffsetDiff& secondaryCCPCHPwrOffsetDiff) { *static_cast<MBMSSCCPCHPwrOffsetDiff*>(items[2]) = secondaryCCPCHPwrOffsetDiff; }
	void setMBMSNeighbouringCellSCCPCHv770extLayer1Combining(const MBMSNeighbouringCellSCCPCHv770extLayer1Combining& mBMSNeighbouringCellSCCPCHv770extLayer1Combining) { *static_cast<MBMSNeighbouringCellSCCPCHv770extLayer1Combining*>(items[3]) = mBMSNeighbouringCellSCCPCHv770extLayer1Combining; }
	void setMbmsL23Configuration(const MBMSL23Configuration& mbmsL23Configuration) { *static_cast<MBMSL23Configuration*>(items[4]) = mbmsL23Configuration; }
};

typedef SequenceOf<MBMSNeighbouringCellSCCPCHr6, CONSTRAINED, 1, maxSCCPCH> MBMSNeighbouringCellSCCPCHListr6;

typedef SequenceOf<MBMSNeighbouringCellSCCPCHv770ext, CONSTRAINED, 1, maxSCCPCH> MBMSNeighbouringCellSCCPCHListv770ext;

typedef BitString<CONSTRAINED, 40, 40> MBMSNetworkStandardTimeInformationLCRv890extNetworkStandardTime;

typedef Integer<CONSTRAINED, 0, 4095> MBMSNetworkStandardTimeInformationLCRv890extCorrelativeSFN;

class MBMSNetworkStandardTimeInformationLCRv890ext : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSNetworkStandardTimeInformationLCRv890ext(): Sequence(&theInfo) {}

	void setMBMSNetworkStandardTimeInformationLCRv890extNetworkStandardTime(const MBMSNetworkStandardTimeInformationLCRv890extNetworkStandardTime& mBMSNetworkStandardTimeInformationLCRv890extNetworkStandardTime) { *static_cast<MBMSNetworkStandardTimeInformationLCRv890extNetworkStandardTime*>(items[0]) = mBMSNetworkStandardTimeInformationLCRv890extNetworkStandardTime; }
	void setMBMSNetworkStandardTimeInformationLCRv890extCorrelativeSFN(const MBMSNetworkStandardTimeInformationLCRv890extCorrelativeSFN& mBMSNetworkStandardTimeInformationLCRv890extCorrelativeSFN) { *static_cast<MBMSNetworkStandardTimeInformationLCRv890extCorrelativeSFN*>(items[1]) = mBMSNetworkStandardTimeInformationLCRv890extCorrelativeSFN; }
};

typedef Integer<CONSTRAINED, 0, 32> MBMSNumberOfNeighbourCellsr6;

class MBMSPhyChInformationIMB384 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSPhyChInformationIMB384(): Sequence(&theInfo) {}

	void setMbmsCommonPhyChIdentity(const MBMSCommonPhyChIdentity& mbmsCommonPhyChIdentity) { *static_cast<MBMSCommonPhyChIdentity*>(items[0]) = mbmsCommonPhyChIdentity; }
	void setSecondaryCCPCHInfoMBMS(const SecondaryCCPCHFrameType2Info& secondaryCCPCHInfoMBMS) { *static_cast<SecondaryCCPCHFrameType2Info*>(items[1]) = secondaryCCPCHInfoMBMS; }
};

typedef SequenceOf<MBMSPhyChInformationIMB384, CONSTRAINED, 1, maxMBMS_CommonPhyCh> MBMSPhyChInformationListIMB384;

class MBMSPhyChInformationr6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSPhyChInformationr6(): Sequence(&theInfo) {}

	void setMbmsCommonPhyChIdentity(const MBMSCommonPhyChIdentity& mbmsCommonPhyChIdentity) { *static_cast<MBMSCommonPhyChIdentity*>(items[0]) = mbmsCommonPhyChIdentity; }
	void setSecondaryCCPCHInfoMBMS(const SecondaryCCPCHInfoMBMSr6& secondaryCCPCHInfoMBMS) { *static_cast<SecondaryCCPCHInfoMBMSr6*>(items[1]) = secondaryCCPCHInfoMBMS; }
};

class MBMSPhyChInformationr7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSPhyChInformationr7(): Sequence(&theInfo) {}

	void setMbmsCommonPhyChIdentity(const MBMSCommonPhyChIdentity& mbmsCommonPhyChIdentity) { *static_cast<MBMSCommonPhyChIdentity*>(items[0]) = mbmsCommonPhyChIdentity; }
	void setSecondaryCCPCHInfoMBMS(const SecondaryCCPCHInfoMBMSr7& secondaryCCPCHInfoMBMS) { *static_cast<SecondaryCCPCHInfoMBMSr7*>(items[1]) = secondaryCCPCHInfoMBMS; }
};

typedef SequenceOf<MBMSPhyChInformationr6, CONSTRAINED, 1, maxMBMS_CommonPhyCh> MBMSPhyChInformationListr6;

typedef SequenceOf<MBMSPhyChInformationr7, CONSTRAINED, 1, maxMBMS_CommonPhyCh> MBMSPhyChInformationListr7;

enum MBMSPLServiceRestrictInfor6Values {
	true_MBMSPLServiceRestrictInfor6 = 0,
};
typedef Enumerated<CONSTRAINED, 0> MBMSPLServiceRestrictInfor6;

typedef Integer<CONSTRAINED, 1, maxMBMS_Freq> MBMSPreferredFrequencyInfor6MbmsPreferredFrequency;

enum MBMSQoffsetValues {
	q4_MBMSQoffset = 0,
	q8_MBMSQoffset = 1,
	q12_MBMSQoffset = 2,
	q16_MBMSQoffset = 3,
	q20_MBMSQoffset = 4,
	q30_MBMSQoffset = 5,
	q40_MBMSQoffset = 6,
	qInfinity_MBMSQoffset = 7,
};
typedef Enumerated<CONSTRAINED, 7> MBMSQoffset;

typedef Integer<CONSTRAINED, 0, 7> MBMSPreferredFrequencyInfor6LayerConvergenceInformationMbmsHCSoffset;

class MBMSPreferredFrequencyInfor6LayerConvergenceInformation : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MBMSPreferredFrequencyInfor6LayerConvergenceInformationChoices {
		mbmsQoffset = 0,
		mBMSPreferredFrequencyInfor6LayerConvergenceInformationMbmsHCSoffset = 1,
	};
	static const Info theInfo;
	MBMSPreferredFrequencyInfor6LayerConvergenceInformation(): Choice(&theInfo) {}
};

class MBMSPreferredFrequencyInfor6 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MBMSPreferredFrequencyInfor6(): Sequence(&theInfo) {}

	void setMBMSPreferredFrequencyInfor6MbmsPreferredFrequency(const MBMSPreferredFrequencyInfor6MbmsPreferredFrequency& mBMSPreferredFrequencyInfor6MbmsPreferredFrequency) { *static_cast<MBMSPreferredFrequencyInfor6MbmsPreferredFrequency*>(items[0]) = mBMSPreferredFrequencyInfor6MbmsPreferredFrequency; }
	void setMBMSPreferredFrequencyInfor6LayerConvergenceInformation(const MBMSPreferredFrequencyInfor6LayerConvergenceInformation& mBMSPreferredFrequencyInfor6LayerConvergenceInformation) { *static_cast<MBMSPreferredFrequencyInfor6LayerConvergenceInformation*>(items[1]) = mBMSPreferredFrequencyInfor6LayerConvergenceInformation; }
	void setMbmsPLServiceRestrictInfo(const MBMSPLServiceRestrictInfor6& mbmsPLServiceRestrictInfo) { *static_cast<MBMSPLServiceRestrictInfor6*>(items[2]) = mbmsPLServiceRestrictInfo; }
};

typedef SequenceOf<MBMSPreferredFrequencyInfor6, CONSTRAINED, 1, maxMBMS_Freq> MBMSPreferredFrequencyListr6;

typedef Integer<CONSTRAINED, 0, 2047> MBMSPTMActivationTimer6;

enum MBMSRequiredUEActionUModValues {
	none_MBMSRequiredUEActionUMod = 0,
	acquirePTM_RBInfo_MBMSRequiredUEActionUMod = 1,
	requestPTPRB_MBMSRequiredUEActionUMod = 2,
};
typedef Enumerated<CONSTRAINED, 2> MBMSRequiredUEActionUMod;

typedef Null MBMSSelectedServiceInfoStatusNone;

typedef SequenceOf<MBMSServiceIdentityr6, CONSTRAINED, 1, maxMBMSservSelect> MBMSSelectedServicesListFull;

class MBMSSelectedServiceInfoStatus : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MBMSSelectedServiceInfoStatusChoices {
		mBMSSelectedServiceInfoStatusNone = 0,
		some = 1,
	};
	static const Info theInfo;
	MBMSSelectedServiceInfoStatus(): Choice(&theInfo) {}
};

class MBMSSelectedServiceInfo : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MBMSSelectedServiceInfo(): Sequence(&theInfo) {}

	void setMBMSSelectedServiceInfoStatus(const MBMSSelectedServiceInfoStatus& mBMSSelectedServiceInfoStatus) { *static_cast<MBMSSelectedServiceInfoStatus*>(items[0]) = mBMSSelectedServiceInfoStatus; }
};

typedef SequenceOf<MBMSShortTransmissionID, CONSTRAINED, 1, maxMBMSservSelect> MBMSSelectedServicesListShort;

typedef Integer<CONSTRAINED, 0, 1> MBMSSelectedServicesShortModificationPeriodIdentity;

class MBMSSelectedServicesShort : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSSelectedServicesShort(): Sequence(&theInfo) {}

	void setMbmsSelectedServicesList(const MBMSSelectedServicesListShort& mbmsSelectedServicesList) { *static_cast<MBMSSelectedServicesListShort*>(items[0]) = mbmsSelectedServicesList; }
	void setMBMSSelectedServicesShortModificationPeriodIdentity(const MBMSSelectedServicesShortModificationPeriodIdentity& mBMSSelectedServicesShortModificationPeriodIdentity) { *static_cast<MBMSSelectedServicesShortModificationPeriodIdentity*>(items[1]) = mBMSSelectedServicesShortModificationPeriodIdentity; }
};

class MBMSServiceAccessInfor6 : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	MBMSServiceAccessInfor6(): Sequence(&theInfo) {}

	void setShortTransmissionID(const MBMSShortTransmissionID& shortTransmissionID) { *static_cast<MBMSShortTransmissionID*>(items[0]) = shortTransmissionID; }
	void setAccessprobabilityFactorIdle(const MBMSAccessProbabilityFactor& accessprobabilityFactorIdle) { *static_cast<MBMSAccessProbabilityFactor*>(items[1]) = accessprobabilityFactorIdle; }
	void setAccessprobabilityFactorConnected(const MBMSAccessProbabilityFactor& accessprobabilityFactorConnected) { *static_cast<MBMSAccessProbabilityFactor*>(items[2]) = accessprobabilityFactorConnected; }
	void setMbmsConnectedModeCountingScope(const MBMSConnectedModeCountingScope& mbmsConnectedModeCountingScope) { *static_cast<MBMSConnectedModeCountingScope*>(items[3]) = mbmsConnectedModeCountingScope; }
};

typedef SequenceOf<MBMSServiceAccessInfor6, CONSTRAINED, 1, maxMBMSservCount> MBMSServiceAccessInfoListr6;

typedef Integer<CONSTRAINED, 0, 255> MBMSServiceTransmInfoStart;

typedef Integer<CONSTRAINED, 1, 256> MBMSServiceTransmInfoDuration;

class MBMSServiceTransmInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSServiceTransmInfo(): Sequence(&theInfo) {}

	void setMBMSServiceTransmInfoStart(const MBMSServiceTransmInfoStart& mBMSServiceTransmInfoStart) { *static_cast<MBMSServiceTransmInfoStart*>(items[0]) = mBMSServiceTransmInfoStart; }
	void setMBMSServiceTransmInfoDuration(const MBMSServiceTransmInfoDuration& mBMSServiceTransmInfoDuration) { *static_cast<MBMSServiceTransmInfoDuration*>(items[1]) = mBMSServiceTransmInfoDuration; }
};

typedef SequenceOf<MBMSServiceTransmInfo, CONSTRAINED, 1, maxMBMSTransmis> MBMSServiceTransmInfoList;

typedef Integer<CONSTRAINED, 0, 31> MBMSServiceSchedulingInfor6NextSchedulingperiod;

class MBMSServiceSchedulingInfor6 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MBMSServiceSchedulingInfor6(): Sequence(&theInfo) {}

	void setMbmsTransmissionIdentity(const MBMSTransmissionIdentity& mbmsTransmissionIdentity) { *static_cast<MBMSTransmissionIdentity*>(items[0]) = mbmsTransmissionIdentity; }
	void setMbmsServiceTransmInfoList(const MBMSServiceTransmInfoList& mbmsServiceTransmInfoList) { *static_cast<MBMSServiceTransmInfoList*>(items[1]) = mbmsServiceTransmInfoList; }
	void setMBMSServiceSchedulingInfor6NextSchedulingperiod(const MBMSServiceSchedulingInfor6NextSchedulingperiod& mBMSServiceSchedulingInfor6NextSchedulingperiod) { *static_cast<MBMSServiceSchedulingInfor6NextSchedulingperiod*>(items[2]) = mBMSServiceSchedulingInfor6NextSchedulingperiod; }
};

typedef SequenceOf<MBMSServiceSchedulingInfor6, CONSTRAINED, 1, maxMBMSservSched> MBMSServiceSchedulingInfoListr6;

typedef Integer<CONSTRAINED, 1, maxFACHPCH> MBMSTrCHInformationSIB5TranspChIdentity;

class MBMSTrCHInformationSIB5 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MBMSTrCHInformationSIB5(): Sequence(&theInfo) {}

	void setMBMSTrCHInformationSIB5TranspChIdentity(const MBMSTrCHInformationSIB5TranspChIdentity& mBMSTrCHInformationSIB5TranspChIdentity) { *static_cast<MBMSTrCHInformationSIB5TranspChIdentity*>(items[0]) = mBMSTrCHInformationSIB5TranspChIdentity; }
	void setRbInformation(const MBMSPTMRBInformationCList& rbInformation) { *static_cast<MBMSPTMRBInformationCList*>(items[1]) = rbInformation; }
	void setMschConfigurationInfo(const MBMSMSCHConfigurationInfor6& mschConfigurationInfo) { *static_cast<MBMSMSCHConfigurationInfor6*>(items[2]) = mschConfigurationInfo; }
};

typedef SequenceOf<MBMSTrCHInformationSIB5, CONSTRAINED, 1, maxFACHPCH> MBMSTrCHInformationSIB5List;

class MBMSSIBType5SCCPCHr6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSSIBType5SCCPCHr6(): Sequence(&theInfo) {}

	void setSccpchIdentity(const MBMSSCCPCHIdentity& sccpchIdentity) { *static_cast<MBMSSCCPCHIdentity*>(items[0]) = sccpchIdentity; }
	void setTranspCHInformation(const MBMSTrCHInformationSIB5List& transpCHInformation) { *static_cast<MBMSTrCHInformationSIB5List*>(items[1]) = transpCHInformation; }
};

typedef SequenceOf<MBMSSIBType5SCCPCHr6, CONSTRAINED, 1, maxSCCPCH> MBMSSIBType5SCCPCHListr6;

class MBMSTimersAndCountersr6 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MBMSTimersAndCountersr6(): Sequence(&theInfo) {}

	void setT318(const T318& t318) { *static_cast<T318*>(items[0]) = t318; }
};

class MBMSTranspChInfoForCCTrChr6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSTranspChInfoForCCTrChr6(): Sequence(&theInfo) {}

	void setCommonCCTrChIdentity(const MBMSCommonCCTrChIdentity& commonCCTrChIdentity) { *static_cast<MBMSCommonCCTrChIdentity*>(items[0]) = commonCCTrChIdentity; }
	void setTransportFormatCombinationSet(const TFCS& transportFormatCombinationSet) { *static_cast<TFCS*>(items[1]) = transportFormatCombinationSet; }
};

typedef SequenceOf<MBMSTranspChInfoForCCTrChr6, CONSTRAINED, 1, maxMBMS_CommonCCTrCh> MBMSTranspChInfoForEachCCTrChr6;

class MBMSTranspChInfoForTrChr6 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBMSTranspChInfoForTrChr6(): Sequence(&theInfo) {}

	void setCommonTrChIdentity(const MBMSCommonTrChIdentity& commonTrChIdentity) { *static_cast<MBMSCommonTrChIdentity*>(items[0]) = commonTrChIdentity; }
	void setTransportFormatSet(const TransportFormatSet& transportFormatSet) { *static_cast<TransportFormatSet*>(items[1]) = transportFormatSet; }
};

typedef SequenceOf<MBMSTranspChInfoForTrChr6, CONSTRAINED, 1, maxMBMS_CommonTrCh> MBMSTranspChInfoForEachTrChr6;

class MBMSUnmodifiedServicer6 : public Sequence {
private:
	static const void *itemsInfo[3];
	static bool itemsPres[3];
public:
	static const Info theInfo;
	MBMSUnmodifiedServicer6(): Sequence(&theInfo) {}

	void setMbmsTransmissionIdentity(const MBMSTransmissionIdentity& mbmsTransmissionIdentity) { *static_cast<MBMSTransmissionIdentity*>(items[0]) = mbmsTransmissionIdentity; }
	void setMbmsRequiredUEAction(const MBMSRequiredUEActionUMod& mbmsRequiredUEAction) { *static_cast<MBMSRequiredUEActionUMod*>(items[1]) = mbmsRequiredUEAction; }
	void setMbmsPreferredFrequency(const MBMSPFLIndex& mbmsPreferredFrequency) { *static_cast<MBMSPFLIndex*>(items[2]) = mbmsPreferredFrequency; }
};

typedef SequenceOf<MBMSUnmodifiedServicer6, CONSTRAINED, 1, maxMBMSservUnmodif> MBMSUnmodifiedServiceListr6;

class MBMSUnmodifiedServicev770ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MBMSUnmodifiedServicev770ext(): Sequence(&theInfo) {}

	void setMbsfnClusterFrequency(const MBSFNClusterFrequencyr7& mbsfnClusterFrequency) { *static_cast<MBSFNClusterFrequencyr7*>(items[0]) = mbsfnClusterFrequency; }
};

typedef SequenceOf<MBMSUnmodifiedServicev770ext, CONSTRAINED, 1, maxMBMSservUnmodif> MBMSUnmodifiedServiceListv770ext;

enum MBSFNservicesNotNotifiedr7notificationOfAllMBSFNServicesInTheBandValues {
	true_MBSFNservicesNotNotifiedr7notificationOfAllMBSFNServicesInTheBand = 0,
};
typedef Enumerated<CONSTRAINED, 0> MBSFNservicesNotNotifiedr7notificationOfAllMBSFNServicesInTheBand;

class MBSFNservicesNotNotifiedr7 : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MBSFNservicesNotNotifiedr7(): Sequence(&theInfo) {}

	void setMBSFNservicesNotNotifiedr7notificationOfAllMBSFNServicesInTheBand(const MBSFNservicesNotNotifiedr7notificationOfAllMBSFNServicesInTheBand& mBSFNservicesNotNotifiedr7notificationOfAllMBSFNServicesInTheBand) { *static_cast<MBSFNservicesNotNotifiedr7notificationOfAllMBSFNServicesInTheBand*>(items[0]) = mBSFNservicesNotNotifiedr7notificationOfAllMBSFNServicesInTheBand; }
};

typedef Null MBSFNInterFrequencyNeighbourr7MbsfnServicesNotificationMbsfnServicesNotified;

class MBSFNInterFrequencyNeighbourr7MbsfnServicesNotification : public Choice {
private:
	static const void *choicesInfo[2];
public:
	enum MBSFNInterFrequencyNeighbourr7MbsfnServicesNotificationChoices {
		mBSFNInterFrequencyNeighbourr7MbsfnServicesNotificationMbsfnServicesNotified = 0,
		mbsfnServicesNotNotified = 1,
	};
	static const Info theInfo;
	MBSFNInterFrequencyNeighbourr7MbsfnServicesNotification(): Choice(&theInfo) {}
};

class MBSFNInterFrequencyNeighbourr7 : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBSFNInterFrequencyNeighbourr7(): Sequence(&theInfo) {}

	void setMbsfnFrequency(const FrequencyInfo& mbsfnFrequency) { *static_cast<FrequencyInfo*>(items[0]) = mbsfnFrequency; }
	void setMBSFNInterFrequencyNeighbourr7MbsfnServicesNotification(const MBSFNInterFrequencyNeighbourr7MbsfnServicesNotification& mBSFNInterFrequencyNeighbourr7MbsfnServicesNotification) { *static_cast<MBSFNInterFrequencyNeighbourr7MbsfnServicesNotification*>(items[1]) = mBSFNInterFrequencyNeighbourr7MbsfnServicesNotification; }
};

enum MBSFNInterFrequencyNeighbourv860extimb_IndicationValues {
	true_MBSFNInterFrequencyNeighbourv860extimb_Indication = 0,
};
typedef Enumerated<CONSTRAINED, 0> MBSFNInterFrequencyNeighbourv860extimb_Indication;

class MBSFNInterFrequencyNeighbourv860ext : public Sequence {
private:
	static const void *itemsInfo[1];
	static bool itemsPres[1];
public:
	static const Info theInfo;
	MBSFNInterFrequencyNeighbourv860ext(): Sequence(&theInfo) {}

	void setMBSFNInterFrequencyNeighbourv860extimb_Indication(const MBSFNInterFrequencyNeighbourv860extimb_Indication& mBSFNInterFrequencyNeighbourv860extimb_Indication) { *static_cast<MBSFNInterFrequencyNeighbourv860extimb_Indication*>(items[0]) = mBSFNInterFrequencyNeighbourv860extimb_Indication; }
};

typedef SequenceOf<MBSFNInterFrequencyNeighbourr7, CONSTRAINED, 1, maxMBSFNClusters> MBSFNInterFrequencyNeighbourListr7;

typedef SequenceOf<MBSFNInterFrequencyNeighbourv860ext, CONSTRAINED, 1, maxMBSFNClusters> MBSFNInterFrequencyNeighbourListv860ext;

class MBSFNTDDTimeSlotInfo : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBSFNTDDTimeSlotInfo(): Sequence(&theInfo) {}

	void setTimeSlotNumber(const TimeslotNumberLCRr4& timeSlotNumber) { *static_cast<TimeslotNumberLCRr4*>(items[0]) = timeSlotNumber; }
	void setCellParametersID(const CellParametersID& cellParametersID) { *static_cast<CellParametersID*>(items[1]) = cellParametersID; }
};

typedef SequenceOf<MBSFNTDDTimeSlotInfo, CONSTRAINED, 1, maxTS> MBSFNTDDInformation;

typedef Integer<CONSTRAINED, 1, maxMBSFNClusters> MBSFNTDDTimeSlotInfoLCRFrequencyIndex;

class MBSFNTDDTimeSlotInfoLCR : public Sequence {
private:
	static const void *itemsInfo[2];
	static bool itemsPres[2];
public:
	static const Info theInfo;
	MBSFNTDDTimeSlotInfoLCR(): Sequence(&theInfo) {}

	void setMBSFNTDDTimeSlotInfoLCRFrequencyIndex(const MBSFNTDDTimeSlotInfoLCRFrequencyIndex& mBSFNTDDTimeSlotInfoLCRFrequencyIndex) { *static_cast<MBSFNTDDTimeSlotInfoLCRFrequencyIndex*>(items[0]) = mBSFNTDDTimeSlotInfoLCRFrequencyIndex; }
	void setTimeSlotList(const MBSFNTDDInformation& timeSlotList) { *static_cast<MBSFNTDDInformation*>(items[1]) = timeSlotList; }
};

typedef SequenceOf<MBSFNTDDTimeSlotInfoLCR, CONSTRAINED, 1, maxMBSFNClusters> MBSFNTDDInformationLCR;

typedef Integer<CONSTRAINED, 2, 9> MBSFNTDMInfoTDMPeriod;

typedef Integer<CONSTRAINED, 0, 8> MBSFNTDMInfoTDMOffset;

typedef Integer<CONSTRAINED, 1, 8> MBSFNTDMInfoTDMLength;

class MBSFNTDMInfo : public Sequence {
private:
	static const void *itemsInfo[4];
	static bool itemsPres[4];
public:
	static const Info theInfo;
	MBSFNTDMInfo(): Sequence(&theInfo) {}

	void setShortTransmissionID(const MBMSShortTransmissionID& shortTransmissionID) { *static_cast<MBMSShortTransmissionID*>(items[0]) = shortTransmissionID; }
	void setMBSFNTDMInfoTDMPeriod(const MBSFNTDMInfoTDMPeriod& mBSFNTDMInfoTDMPeriod) { *static_cast<MBSFNTDMInfoTDMPeriod*>(items[1]) = mBSFNTDMInfoTDMPeriod; }
	void setMBSFNTDMInfoTDMOffset(const MBSFNTDMInfoTDMOffset& mBSFNTDMInfoTDMOffset) { *static_cast<MBSFNTDMInfoTDMOffset*>(items[2]) = mBSFNTDMInfoTDMOffset; }
	void setMBSFNTDMInfoTDMLength(const MBSFNTDMInfoTDMLength& mBSFNTDMInfoTDMLength) { *static_cast<MBSFNTDMInfoTDMLength*>(items[3]) = mBSFNTDMInfoTDMLength; }
};

typedef SequenceOf<MBSFNTDMInfo, CONSTRAINED, 1, maxMBMSservUnmodif> MBSFNTDMInfoList;

}

#endif /* RRCINFORMATIONELEMENTS_H_ */