windows-server-2003/net/tapi/skywalker/h323/asn/h4503pp.c

#include <windows.h>
#include "h4503pp.h"

#pragma warning ( disable: 4133 )

ASN1module_t H4503PP_Module = NULL;

static int ASN1CALL ASN1Enc_TransportAddress_ipSourceRoute_routing(ASN1encoding_t enc, TransportAddress_ipSourceRoute_routing *val);
static int ASN1CALL ASN1Enc_TransportAddress_ipSourceRoute_route(ASN1encoding_t enc, PTransportAddress_ipSourceRoute_route *val);
static int ASN1CALL ASN1Enc_TransportAddress_ip6Address(ASN1encoding_t enc, TransportAddress_ip6Address *val);
static int ASN1CALL ASN1Enc_TransportAddress_ipxAddress(ASN1encoding_t enc, TransportAddress_ipxAddress *val);
static int ASN1CALL ASN1Enc_TransportAddress_ipSourceRoute(ASN1encoding_t enc, TransportAddress_ipSourceRoute *val);
static int ASN1CALL ASN1Enc_TransportAddress_ipAddress(ASN1encoding_t enc, TransportAddress_ipAddress *val);
static int ASN1CALL ASN1Enc_Reject_problem(ASN1encoding_t enc, Reject_problem *val);
static int ASN1CALL ASN1Enc_EntityType(ASN1encoding_t enc, EntityType *val);
static int ASN1CALL ASN1Enc_InterpretationApdu(ASN1encoding_t enc, InterpretationApdu *val);
static int ASN1CALL ASN1Enc_ServiceApdus(ASN1encoding_t enc, ServiceApdus *val);
static int ASN1CALL ASN1Enc_Reject(ASN1encoding_t enc, Reject *val);
static int ASN1CALL ASN1Enc_EXTENSION(ASN1encoding_t enc, EXTENSION *val);
static int ASN1CALL ASN1Enc_GroupIndicationOnRes(ASN1encoding_t enc, GroupIndicationOnRes *val);
static int ASN1CALL ASN1Enc_GroupIndicationOffRes(ASN1encoding_t enc, GroupIndicationOffRes *val);
static int ASN1CALL ASN1Enc_PickupRes(ASN1encoding_t enc, PickupRes *val);
static int ASN1CALL ASN1Enc_PickExeRes(ASN1encoding_t enc, PickExeRes *val);
static int ASN1CALL ASN1Enc_UserSpecifiedSubaddress(ASN1encoding_t enc, UserSpecifiedSubaddress *val);
static int ASN1CALL ASN1Enc_CODE(ASN1encoding_t enc, CODE *val);
static int ASN1CALL ASN1Enc_H221NonStandard(ASN1encoding_t enc, H221NonStandard *val);
static int ASN1CALL ASN1Enc_H225NonStandardIdentifier(ASN1encoding_t enc, H225NonStandardIdentifier *val);
static int ASN1CALL ASN1Enc_PublicTypeOfNumber(ASN1encoding_t enc, PublicTypeOfNumber *val);
static int ASN1CALL ASN1Enc_PrivateTypeOfNumber(ASN1encoding_t enc, PrivateTypeOfNumber *val);
static int ASN1CALL ASN1Enc_CallIdentifier(ASN1encoding_t enc, CallIdentifier *val);
static int ASN1CALL ASN1Enc_ReturnResult_result(ASN1encoding_t enc, ReturnResult_result *val);
static int ASN1CALL ASN1Enc_Invoke(ASN1encoding_t enc, Invoke *val);
static int ASN1CALL ASN1Enc_ReturnResult(ASN1encoding_t enc, ReturnResult *val);
static int ASN1CALL ASN1Enc_ReturnError(ASN1encoding_t enc, ReturnError *val);
static int ASN1CALL ASN1Enc_ExtensionSeq(ASN1encoding_t enc, PExtensionSeq *val);
static int ASN1CALL ASN1Enc_PickrequRes(ASN1encoding_t enc, PickrequRes *val);
static int ASN1CALL ASN1Enc_PartySubaddress(ASN1encoding_t enc, PartySubaddress *val);
static int ASN1CALL ASN1Enc_H225NonStandardParameter(ASN1encoding_t enc, H225NonStandardParameter *val);
static int ASN1CALL ASN1Enc_PublicPartyNumber(ASN1encoding_t enc, PublicPartyNumber *val);
static int ASN1CALL ASN1Enc_PrivatePartyNumber(ASN1encoding_t enc, PrivatePartyNumber *val);
static int ASN1CALL ASN1Enc_TransportAddress(ASN1encoding_t enc, TransportAddress *val);
static int ASN1CALL ASN1Enc_CTActiveArg_argumentExtension(ASN1encoding_t enc, CTActiveArg_argumentExtension *val);
static int ASN1CALL ASN1Enc_CTCompleteArg_argumentExtension(ASN1encoding_t enc, CTCompleteArg_argumentExtension *val);
static int ASN1CALL ASN1Enc_SubaddressTransferArg_argumentExtension(ASN1encoding_t enc, SubaddressTransferArg_argumentExtension *val);
static int ASN1CALL ASN1Enc_CTUpdateArg_argumentExtension(ASN1encoding_t enc, CTUpdateArg_argumentExtension *val);
static int ASN1CALL ASN1Enc_CTIdentifyRes_resultExtension(ASN1encoding_t enc, CTIdentifyRes_resultExtension *val);
static int ASN1CALL ASN1Enc_CTSetupArg_argumentExtension(ASN1encoding_t enc, CTSetupArg_argumentExtension *val);
static int ASN1CALL ASN1Enc_CTInitiateArg_argumentExtension(ASN1encoding_t enc, CTInitiateArg_argumentExtension *val);
static int ASN1CALL ASN1Enc_IntResult_extension(ASN1encoding_t enc, IntResult_extension *val);
static int ASN1CALL ASN1Enc_DivertingLegInformation4Argument_extension(ASN1encoding_t enc, DivertingLegInformation4Argument_extension *val);
static int ASN1CALL ASN1Enc_DivertingLegInformation3Argument_extension(ASN1encoding_t enc, DivertingLegInformation3Argument_extension *val);
static int ASN1CALL ASN1Enc_DivertingLegInformation2Argument_extension(ASN1encoding_t enc, DivertingLegInformation2Argument_extension *val);
static int ASN1CALL ASN1Enc_DivertingLegInformation1Argument_extension(ASN1encoding_t enc, DivertingLegInformation1Argument_extension *val);
static int ASN1CALL ASN1Enc_CallReroutingArgument_extension(ASN1encoding_t enc, CallReroutingArgument_extension *val);
static int ASN1CALL ASN1Enc_CheckRestrictionArgument_extension(ASN1encoding_t enc, CheckRestrictionArgument_extension *val);
static int ASN1CALL ASN1Enc_InterrogateDiversionQArgument_extension(ASN1encoding_t enc, InterrogateDiversionQArgument_extension *val);
static int ASN1CALL ASN1Enc_DeactivateDiversionQArgument_extension(ASN1encoding_t enc, DeactivateDiversionQArgument_extension *val);
static int ASN1CALL ASN1Enc_ActivateDiversionQArgument_extension(ASN1encoding_t enc, ActivateDiversionQArgument_extension *val);
static int ASN1CALL ASN1Enc_H4503ROS(ASN1encoding_t enc, H4503ROS *val);
static int ASN1CALL ASN1Enc_DummyArg(ASN1encoding_t enc, DummyArg *val);
static int ASN1CALL ASN1Enc_DummyRes(ASN1encoding_t enc, DummyRes *val);
static int ASN1CALL ASN1Enc_SubaddressTransferArg(ASN1encoding_t enc, SubaddressTransferArg *val);
static int ASN1CALL ASN1Enc_MixedExtension(ASN1encoding_t enc, MixedExtension *val);
static int ASN1CALL ASN1Enc_PartyNumber(ASN1encoding_t enc, PartyNumber *val);
static int ASN1CALL ASN1Enc_CpickupNotifyArg_extensionArg(ASN1encoding_t enc, PCpickupNotifyArg_extensionArg *val);
static int ASN1CALL ASN1Enc_CpNotifyArg_extensionArg(ASN1encoding_t enc, PCpNotifyArg_extensionArg *val);
static int ASN1CALL ASN1Enc_PickExeRes_extensionRes(ASN1encoding_t enc, PPickExeRes_extensionRes *val);
static int ASN1CALL ASN1Enc_PickExeArg_extensionArg(ASN1encoding_t enc, PPickExeArg_extensionArg *val);
static int ASN1CALL ASN1Enc_PickupRes_extensionRes(ASN1encoding_t enc, PPickupRes_extensionRes *val);
static int ASN1CALL ASN1Enc_PickupArg_extensionArg(ASN1encoding_t enc, PPickupArg_extensionArg *val);
static int ASN1CALL ASN1Enc_PickrequRes_extensionRes(ASN1encoding_t enc, PPickrequRes_extensionRes *val);
static int ASN1CALL ASN1Enc_PickrequArg_extensionArg(ASN1encoding_t enc, PPickrequArg_extensionArg *val);
static int ASN1CALL ASN1Enc_GroupIndicationOffRes_extensionRes(ASN1encoding_t enc, PGroupIndicationOffRes_extensionRes *val);
static int ASN1CALL ASN1Enc_GroupIndicationOffArg_extensionArg(ASN1encoding_t enc, PGroupIndicationOffArg_extensionArg *val);
static int ASN1CALL ASN1Enc_GroupIndicationOnRes_extensionRes(ASN1encoding_t enc, PGroupIndicationOnRes_extensionRes *val);
static int ASN1CALL ASN1Enc_GroupIndicationOnArg_extensionArg(ASN1encoding_t enc, PGroupIndicationOnArg_extensionArg *val);
static int ASN1CALL ASN1Enc_CpSetupRes_extensionRes(ASN1encoding_t enc, PCpSetupRes_extensionRes *val);
static int ASN1CALL ASN1Enc_CpSetupArg_extensionArg(ASN1encoding_t enc, PCpSetupArg_extensionArg *val);
static int ASN1CALL ASN1Enc_CpRequestRes_extensionRes(ASN1encoding_t enc, PCpRequestRes_extensionRes *val);
static int ASN1CALL ASN1Enc_CpRequestArg_extensionArg(ASN1encoding_t enc, PCpRequestArg_extensionArg *val);
static int ASN1CALL ASN1Enc_ServiceApdus_rosApdus(ASN1encoding_t enc, PServiceApdus_rosApdus *val);
static int ASN1CALL ASN1Enc_AliasAddress(ASN1encoding_t enc, AliasAddress *val);
static int ASN1CALL ASN1Enc_EndpointAddress_destinationAddress(ASN1encoding_t enc, PEndpointAddress_destinationAddress *val);
static int ASN1CALL ASN1Enc_AddressInformation(ASN1encoding_t enc, AddressInformation *val);
static int ASN1CALL ASN1Enc_EndpointAddress(ASN1encoding_t enc, EndpointAddress *val);
static int ASN1CALL ASN1Enc_NetworkFacilityExtension(ASN1encoding_t enc, NetworkFacilityExtension *val);
static int ASN1CALL ASN1Enc_ActivateDiversionQArgument(ASN1encoding_t enc, ActivateDiversionQArgument *val);
static int ASN1CALL ASN1Enc_DeactivateDiversionQArgument(ASN1encoding_t enc, DeactivateDiversionQArgument *val);
static int ASN1CALL ASN1Enc_InterrogateDiversionQArgument(ASN1encoding_t enc, InterrogateDiversionQArgument *val);
static int ASN1CALL ASN1Enc_CheckRestrictionArgument(ASN1encoding_t enc, CheckRestrictionArgument *val);
static int ASN1CALL ASN1Enc_CallReroutingArgument(ASN1encoding_t enc, CallReroutingArgument *val);
static int ASN1CALL ASN1Enc_DivertingLegInformation1Argument(ASN1encoding_t enc, DivertingLegInformation1Argument *val);
static int ASN1CALL ASN1Enc_DivertingLegInformation2Argument(ASN1encoding_t enc, DivertingLegInformation2Argument *val);
static int ASN1CALL ASN1Enc_DivertingLegInformation3Argument(ASN1encoding_t enc, DivertingLegInformation3Argument *val);
static int ASN1CALL ASN1Enc_DivertingLegInformation4Argument(ASN1encoding_t enc, DivertingLegInformation4Argument *val);
static int ASN1CALL ASN1Enc_IntResult(ASN1encoding_t enc, IntResult *val);
static int ASN1CALL ASN1Enc_CTInitiateArg(ASN1encoding_t enc, CTInitiateArg *val);
static int ASN1CALL ASN1Enc_CTSetupArg(ASN1encoding_t enc, CTSetupArg *val);
static int ASN1CALL ASN1Enc_CTIdentifyRes(ASN1encoding_t enc, CTIdentifyRes *val);
static int ASN1CALL ASN1Enc_CTUpdateArg(ASN1encoding_t enc, CTUpdateArg *val);
static int ASN1CALL ASN1Enc_CTCompleteArg(ASN1encoding_t enc, CTCompleteArg *val);
static int ASN1CALL ASN1Enc_CTActiveArg(ASN1encoding_t enc, CTActiveArg *val);
static int ASN1CALL ASN1Enc_CpRequestArg(ASN1encoding_t enc, CpRequestArg *val);
static int ASN1CALL ASN1Enc_CpRequestRes(ASN1encoding_t enc, CpRequestRes *val);
static int ASN1CALL ASN1Enc_CpSetupArg(ASN1encoding_t enc, CpSetupArg *val);
static int ASN1CALL ASN1Enc_CpSetupRes(ASN1encoding_t enc, CpSetupRes *val);
static int ASN1CALL ASN1Enc_GroupIndicationOnArg(ASN1encoding_t enc, GroupIndicationOnArg *val);
static int ASN1CALL ASN1Enc_GroupIndicationOffArg(ASN1encoding_t enc, GroupIndicationOffArg *val);
static int ASN1CALL ASN1Enc_PickrequArg(ASN1encoding_t enc, PickrequArg *val);
static int ASN1CALL ASN1Enc_PickupArg(ASN1encoding_t enc, PickupArg *val);
static int ASN1CALL ASN1Enc_PickExeArg(ASN1encoding_t enc, PickExeArg *val);
static int ASN1CALL ASN1Enc_CpNotifyArg(ASN1encoding_t enc, CpNotifyArg *val);
static int ASN1CALL ASN1Enc_CpickupNotifyArg(ASN1encoding_t enc, CpickupNotifyArg *val);
static int ASN1CALL ASN1Enc_H4501SupplementaryService(ASN1encoding_t enc, H4501SupplementaryService *val);
static int ASN1CALL ASN1Enc_IntResultList(ASN1encoding_t enc, IntResultList *val);
static int ASN1CALL ASN1Dec_TransportAddress_ipSourceRoute_routing(ASN1decoding_t dec, TransportAddress_ipSourceRoute_routing *val);
static int ASN1CALL ASN1Dec_TransportAddress_ipSourceRoute_route(ASN1decoding_t dec, PTransportAddress_ipSourceRoute_route *val);
static int ASN1CALL ASN1Dec_TransportAddress_ip6Address(ASN1decoding_t dec, TransportAddress_ip6Address *val);
static int ASN1CALL ASN1Dec_TransportAddress_ipxAddress(ASN1decoding_t dec, TransportAddress_ipxAddress *val);
static int ASN1CALL ASN1Dec_TransportAddress_ipSourceRoute(ASN1decoding_t dec, TransportAddress_ipSourceRoute *val);
static int ASN1CALL ASN1Dec_TransportAddress_ipAddress(ASN1decoding_t dec, TransportAddress_ipAddress *val);
static int ASN1CALL ASN1Dec_Reject_problem(ASN1decoding_t dec, Reject_problem *val);
static int ASN1CALL ASN1Dec_EntityType(ASN1decoding_t dec, EntityType *val);
static int ASN1CALL ASN1Dec_InterpretationApdu(ASN1decoding_t dec, InterpretationApdu *val);
static int ASN1CALL ASN1Dec_ServiceApdus(ASN1decoding_t dec, ServiceApdus *val);
static int ASN1CALL ASN1Dec_Reject(ASN1decoding_t dec, Reject *val);
static int ASN1CALL ASN1Dec_EXTENSION(ASN1decoding_t dec, EXTENSION *val);
static int ASN1CALL ASN1Dec_GroupIndicationOnRes(ASN1decoding_t dec, GroupIndicationOnRes *val);
static int ASN1CALL ASN1Dec_GroupIndicationOffRes(ASN1decoding_t dec, GroupIndicationOffRes *val);
static int ASN1CALL ASN1Dec_PickupRes(ASN1decoding_t dec, PickupRes *val);
static int ASN1CALL ASN1Dec_PickExeRes(ASN1decoding_t dec, PickExeRes *val);
static int ASN1CALL ASN1Dec_UserSpecifiedSubaddress(ASN1decoding_t dec, UserSpecifiedSubaddress *val);
static int ASN1CALL ASN1Dec_CODE(ASN1decoding_t dec, CODE *val);
static int ASN1CALL ASN1Dec_H221NonStandard(ASN1decoding_t dec, H221NonStandard *val);
static int ASN1CALL ASN1Dec_H225NonStandardIdentifier(ASN1decoding_t dec, H225NonStandardIdentifier *val);
static int ASN1CALL ASN1Dec_PublicTypeOfNumber(ASN1decoding_t dec, PublicTypeOfNumber *val);
static int ASN1CALL ASN1Dec_PrivateTypeOfNumber(ASN1decoding_t dec, PrivateTypeOfNumber *val);
static int ASN1CALL ASN1Dec_CallIdentifier(ASN1decoding_t dec, CallIdentifier *val);
static int ASN1CALL ASN1Dec_ReturnResult_result(ASN1decoding_t dec, ReturnResult_result *val);
static int ASN1CALL ASN1Dec_Invoke(ASN1decoding_t dec, Invoke *val);
static int ASN1CALL ASN1Dec_ReturnResult(ASN1decoding_t dec, ReturnResult *val);
static int ASN1CALL ASN1Dec_ReturnError(ASN1decoding_t dec, ReturnError *val);
static int ASN1CALL ASN1Dec_ExtensionSeq(ASN1decoding_t dec, PExtensionSeq *val);
static int ASN1CALL ASN1Dec_PickrequRes(ASN1decoding_t dec, PickrequRes *val);
static int ASN1CALL ASN1Dec_PartySubaddress(ASN1decoding_t dec, PartySubaddress *val);
static int ASN1CALL ASN1Dec_H225NonStandardParameter(ASN1decoding_t dec, H225NonStandardParameter *val);
static int ASN1CALL ASN1Dec_PublicPartyNumber(ASN1decoding_t dec, PublicPartyNumber *val);
static int ASN1CALL ASN1Dec_PrivatePartyNumber(ASN1decoding_t dec, PrivatePartyNumber *val);
static int ASN1CALL ASN1Dec_TransportAddress(ASN1decoding_t dec, TransportAddress *val);
static int ASN1CALL ASN1Dec_CTActiveArg_argumentExtension(ASN1decoding_t dec, CTActiveArg_argumentExtension *val);
static int ASN1CALL ASN1Dec_CTCompleteArg_argumentExtension(ASN1decoding_t dec, CTCompleteArg_argumentExtension *val);
static int ASN1CALL ASN1Dec_SubaddressTransferArg_argumentExtension(ASN1decoding_t dec, SubaddressTransferArg_argumentExtension *val);
static int ASN1CALL ASN1Dec_CTUpdateArg_argumentExtension(ASN1decoding_t dec, CTUpdateArg_argumentExtension *val);
static int ASN1CALL ASN1Dec_CTIdentifyRes_resultExtension(ASN1decoding_t dec, CTIdentifyRes_resultExtension *val);
static int ASN1CALL ASN1Dec_CTSetupArg_argumentExtension(ASN1decoding_t dec, CTSetupArg_argumentExtension *val);
static int ASN1CALL ASN1Dec_CTInitiateArg_argumentExtension(ASN1decoding_t dec, CTInitiateArg_argumentExtension *val);
static int ASN1CALL ASN1Dec_IntResult_extension(ASN1decoding_t dec, IntResult_extension *val);
static int ASN1CALL ASN1Dec_DivertingLegInformation4Argument_extension(ASN1decoding_t dec, DivertingLegInformation4Argument_extension *val);
static int ASN1CALL ASN1Dec_DivertingLegInformation3Argument_extension(ASN1decoding_t dec, DivertingLegInformation3Argument_extension *val);
static int ASN1CALL ASN1Dec_DivertingLegInformation2Argument_extension(ASN1decoding_t dec, DivertingLegInformation2Argument_extension *val);
static int ASN1CALL ASN1Dec_DivertingLegInformation1Argument_extension(ASN1decoding_t dec, DivertingLegInformation1Argument_extension *val);
static int ASN1CALL ASN1Dec_CallReroutingArgument_extension(ASN1decoding_t dec, CallReroutingArgument_extension *val);
static int ASN1CALL ASN1Dec_CheckRestrictionArgument_extension(ASN1decoding_t dec, CheckRestrictionArgument_extension *val);
static int ASN1CALL ASN1Dec_InterrogateDiversionQArgument_extension(ASN1decoding_t dec, InterrogateDiversionQArgument_extension *val);
static int ASN1CALL ASN1Dec_DeactivateDiversionQArgument_extension(ASN1decoding_t dec, DeactivateDiversionQArgument_extension *val);
static int ASN1CALL ASN1Dec_ActivateDiversionQArgument_extension(ASN1decoding_t dec, ActivateDiversionQArgument_extension *val);
static int ASN1CALL ASN1Dec_H4503ROS(ASN1decoding_t dec, H4503ROS *val);
static int ASN1CALL ASN1Dec_DummyArg(ASN1decoding_t dec, DummyArg *val);
static int ASN1CALL ASN1Dec_DummyRes(ASN1decoding_t dec, DummyRes *val);
static int ASN1CALL ASN1Dec_SubaddressTransferArg(ASN1decoding_t dec, SubaddressTransferArg *val);
static int ASN1CALL ASN1Dec_MixedExtension(ASN1decoding_t dec, MixedExtension *val);
static int ASN1CALL ASN1Dec_PartyNumber(ASN1decoding_t dec, PartyNumber *val);
static int ASN1CALL ASN1Dec_CpickupNotifyArg_extensionArg(ASN1decoding_t dec, PCpickupNotifyArg_extensionArg *val);
static int ASN1CALL ASN1Dec_CpNotifyArg_extensionArg(ASN1decoding_t dec, PCpNotifyArg_extensionArg *val);
static int ASN1CALL ASN1Dec_PickExeRes_extensionRes(ASN1decoding_t dec, PPickExeRes_extensionRes *val);
static int ASN1CALL ASN1Dec_PickExeArg_extensionArg(ASN1decoding_t dec, PPickExeArg_extensionArg *val);
static int ASN1CALL ASN1Dec_PickupRes_extensionRes(ASN1decoding_t dec, PPickupRes_extensionRes *val);
static int ASN1CALL ASN1Dec_PickupArg_extensionArg(ASN1decoding_t dec, PPickupArg_extensionArg *val);
static int ASN1CALL ASN1Dec_PickrequRes_extensionRes(ASN1decoding_t dec, PPickrequRes_extensionRes *val);
static int ASN1CALL ASN1Dec_PickrequArg_extensionArg(ASN1decoding_t dec, PPickrequArg_extensionArg *val);
static int ASN1CALL ASN1Dec_GroupIndicationOffRes_extensionRes(ASN1decoding_t dec, PGroupIndicationOffRes_extensionRes *val);
static int ASN1CALL ASN1Dec_GroupIndicationOffArg_extensionArg(ASN1decoding_t dec, PGroupIndicationOffArg_extensionArg *val);
static int ASN1CALL ASN1Dec_GroupIndicationOnRes_extensionRes(ASN1decoding_t dec, PGroupIndicationOnRes_extensionRes *val);
static int ASN1CALL ASN1Dec_GroupIndicationOnArg_extensionArg(ASN1decoding_t dec, PGroupIndicationOnArg_extensionArg *val);
static int ASN1CALL ASN1Dec_CpSetupRes_extensionRes(ASN1decoding_t dec, PCpSetupRes_extensionRes *val);
static int ASN1CALL ASN1Dec_CpSetupArg_extensionArg(ASN1decoding_t dec, PCpSetupArg_extensionArg *val);
static int ASN1CALL ASN1Dec_CpRequestRes_extensionRes(ASN1decoding_t dec, PCpRequestRes_extensionRes *val);
static int ASN1CALL ASN1Dec_CpRequestArg_extensionArg(ASN1decoding_t dec, PCpRequestArg_extensionArg *val);
static int ASN1CALL ASN1Dec_ServiceApdus_rosApdus(ASN1decoding_t dec, PServiceApdus_rosApdus *val);
static int ASN1CALL ASN1Dec_AliasAddress(ASN1decoding_t dec, AliasAddress *val);
static int ASN1CALL ASN1Dec_EndpointAddress_destinationAddress(ASN1decoding_t dec, PEndpointAddress_destinationAddress *val);
static int ASN1CALL ASN1Dec_AddressInformation(ASN1decoding_t dec, AddressInformation *val);
static int ASN1CALL ASN1Dec_EndpointAddress(ASN1decoding_t dec, EndpointAddress *val);
static int ASN1CALL ASN1Dec_NetworkFacilityExtension(ASN1decoding_t dec, NetworkFacilityExtension *val);
static int ASN1CALL ASN1Dec_ActivateDiversionQArgument(ASN1decoding_t dec, ActivateDiversionQArgument *val);
static int ASN1CALL ASN1Dec_DeactivateDiversionQArgument(ASN1decoding_t dec, DeactivateDiversionQArgument *val);
static int ASN1CALL ASN1Dec_InterrogateDiversionQArgument(ASN1decoding_t dec, InterrogateDiversionQArgument *val);
static int ASN1CALL ASN1Dec_CheckRestrictionArgument(ASN1decoding_t dec, CheckRestrictionArgument *val);
static int ASN1CALL ASN1Dec_CallReroutingArgument(ASN1decoding_t dec, CallReroutingArgument *val);
static int ASN1CALL ASN1Dec_DivertingLegInformation1Argument(ASN1decoding_t dec, DivertingLegInformation1Argument *val);
static int ASN1CALL ASN1Dec_DivertingLegInformation2Argument(ASN1decoding_t dec, DivertingLegInformation2Argument *val);
static int ASN1CALL ASN1Dec_DivertingLegInformation3Argument(ASN1decoding_t dec, DivertingLegInformation3Argument *val);
static int ASN1CALL ASN1Dec_DivertingLegInformation4Argument(ASN1decoding_t dec, DivertingLegInformation4Argument *val);
static int ASN1CALL ASN1Dec_IntResult(ASN1decoding_t dec, IntResult *val);
static int ASN1CALL ASN1Dec_CTInitiateArg(ASN1decoding_t dec, CTInitiateArg *val);
static int ASN1CALL ASN1Dec_CTSetupArg(ASN1decoding_t dec, CTSetupArg *val);
static int ASN1CALL ASN1Dec_CTIdentifyRes(ASN1decoding_t dec, CTIdentifyRes *val);
static int ASN1CALL ASN1Dec_CTUpdateArg(ASN1decoding_t dec, CTUpdateArg *val);
static int ASN1CALL ASN1Dec_CTCompleteArg(ASN1decoding_t dec, CTCompleteArg *val);
static int ASN1CALL ASN1Dec_CTActiveArg(ASN1decoding_t dec, CTActiveArg *val);
static int ASN1CALL ASN1Dec_CpRequestArg(ASN1decoding_t dec, CpRequestArg *val);
static int ASN1CALL ASN1Dec_CpRequestRes(ASN1decoding_t dec, CpRequestRes *val);
static int ASN1CALL ASN1Dec_CpSetupArg(ASN1decoding_t dec, CpSetupArg *val);
static int ASN1CALL ASN1Dec_CpSetupRes(ASN1decoding_t dec, CpSetupRes *val);
static int ASN1CALL ASN1Dec_GroupIndicationOnArg(ASN1decoding_t dec, GroupIndicationOnArg *val);
static int ASN1CALL ASN1Dec_GroupIndicationOffArg(ASN1decoding_t dec, GroupIndicationOffArg *val);
static int ASN1CALL ASN1Dec_PickrequArg(ASN1decoding_t dec, PickrequArg *val);
static int ASN1CALL ASN1Dec_PickupArg(ASN1decoding_t dec, PickupArg *val);
static int ASN1CALL ASN1Dec_PickExeArg(ASN1decoding_t dec, PickExeArg *val);
static int ASN1CALL ASN1Dec_CpNotifyArg(ASN1decoding_t dec, CpNotifyArg *val);
static int ASN1CALL ASN1Dec_CpickupNotifyArg(ASN1decoding_t dec, CpickupNotifyArg *val);
static int ASN1CALL ASN1Dec_H4501SupplementaryService(ASN1decoding_t dec, H4501SupplementaryService *val);
static int ASN1CALL ASN1Dec_IntResultList(ASN1decoding_t dec, IntResultList *val);
static void ASN1CALL ASN1Free_TransportAddress_ipSourceRoute_route(PTransportAddress_ipSourceRoute_route *val);
static void ASN1CALL ASN1Free_TransportAddress_ip6Address(TransportAddress_ip6Address *val);
static void ASN1CALL ASN1Free_TransportAddress_ipxAddress(TransportAddress_ipxAddress *val);
static void ASN1CALL ASN1Free_TransportAddress_ipSourceRoute(TransportAddress_ipSourceRoute *val);
static void ASN1CALL ASN1Free_TransportAddress_ipAddress(TransportAddress_ipAddress *val);
static void ASN1CALL ASN1Free_ServiceApdus(ServiceApdus *val);
static void ASN1CALL ASN1Free_EXTENSION(EXTENSION *val);
static void ASN1CALL ASN1Free_GroupIndicationOnRes(GroupIndicationOnRes *val);
static void ASN1CALL ASN1Free_GroupIndicationOffRes(GroupIndicationOffRes *val);
static void ASN1CALL ASN1Free_PickupRes(PickupRes *val);
static void ASN1CALL ASN1Free_PickExeRes(PickExeRes *val);
static void ASN1CALL ASN1Free_UserSpecifiedSubaddress(UserSpecifiedSubaddress *val);
static void ASN1CALL ASN1Free_CODE(CODE *val);
static void ASN1CALL ASN1Free_H225NonStandardIdentifier(H225NonStandardIdentifier *val);
static void ASN1CALL ASN1Free_CallIdentifier(CallIdentifier *val);
static void ASN1CALL ASN1Free_ReturnResult_result(ReturnResult_result *val);
static void ASN1CALL ASN1Free_Invoke(Invoke *val);
static void ASN1CALL ASN1Free_ReturnResult(ReturnResult *val);
static void ASN1CALL ASN1Free_ReturnError(ReturnError *val);
static void ASN1CALL ASN1Free_ExtensionSeq(PExtensionSeq *val);
static void ASN1CALL ASN1Free_PickrequRes(PickrequRes *val);
static void ASN1CALL ASN1Free_PartySubaddress(PartySubaddress *val);
static void ASN1CALL ASN1Free_H225NonStandardParameter(H225NonStandardParameter *val);
static void ASN1CALL ASN1Free_PublicPartyNumber(PublicPartyNumber *val);
static void ASN1CALL ASN1Free_PrivatePartyNumber(PrivatePartyNumber *val);
static void ASN1CALL ASN1Free_TransportAddress(TransportAddress *val);
static void ASN1CALL ASN1Free_CTActiveArg_argumentExtension(CTActiveArg_argumentExtension *val);
static void ASN1CALL ASN1Free_CTCompleteArg_argumentExtension(CTCompleteArg_argumentExtension *val);
static void ASN1CALL ASN1Free_SubaddressTransferArg_argumentExtension(SubaddressTransferArg_argumentExtension *val);
static void ASN1CALL ASN1Free_CTUpdateArg_argumentExtension(CTUpdateArg_argumentExtension *val);
static void ASN1CALL ASN1Free_CTIdentifyRes_resultExtension(CTIdentifyRes_resultExtension *val);
static void ASN1CALL ASN1Free_CTSetupArg_argumentExtension(CTSetupArg_argumentExtension *val);
static void ASN1CALL ASN1Free_CTInitiateArg_argumentExtension(CTInitiateArg_argumentExtension *val);
static void ASN1CALL ASN1Free_IntResult_extension(IntResult_extension *val);
static void ASN1CALL ASN1Free_DivertingLegInformation4Argument_extension(DivertingLegInformation4Argument_extension *val);
static void ASN1CALL ASN1Free_DivertingLegInformation3Argument_extension(DivertingLegInformation3Argument_extension *val);
static void ASN1CALL ASN1Free_DivertingLegInformation2Argument_extension(DivertingLegInformation2Argument_extension *val);
static void ASN1CALL ASN1Free_DivertingLegInformation1Argument_extension(DivertingLegInformation1Argument_extension *val);
static void ASN1CALL ASN1Free_CallReroutingArgument_extension(CallReroutingArgument_extension *val);
static void ASN1CALL ASN1Free_CheckRestrictionArgument_extension(CheckRestrictionArgument_extension *val);
static void ASN1CALL ASN1Free_InterrogateDiversionQArgument_extension(InterrogateDiversionQArgument_extension *val);
static void ASN1CALL ASN1Free_DeactivateDiversionQArgument_extension(DeactivateDiversionQArgument_extension *val);
static void ASN1CALL ASN1Free_ActivateDiversionQArgument_extension(ActivateDiversionQArgument_extension *val);
static void ASN1CALL ASN1Free_H4503ROS(H4503ROS *val);
static void ASN1CALL ASN1Free_DummyArg(DummyArg *val);
static void ASN1CALL ASN1Free_DummyRes(DummyRes *val);
static void ASN1CALL ASN1Free_SubaddressTransferArg(SubaddressTransferArg *val);
static void ASN1CALL ASN1Free_MixedExtension(MixedExtension *val);
static void ASN1CALL ASN1Free_PartyNumber(PartyNumber *val);
static void ASN1CALL ASN1Free_CpickupNotifyArg_extensionArg(PCpickupNotifyArg_extensionArg *val);
static void ASN1CALL ASN1Free_CpNotifyArg_extensionArg(PCpNotifyArg_extensionArg *val);
static void ASN1CALL ASN1Free_PickExeRes_extensionRes(PPickExeRes_extensionRes *val);
static void ASN1CALL ASN1Free_PickExeArg_extensionArg(PPickExeArg_extensionArg *val);
static void ASN1CALL ASN1Free_PickupRes_extensionRes(PPickupRes_extensionRes *val);
static void ASN1CALL ASN1Free_PickupArg_extensionArg(PPickupArg_extensionArg *val);
static void ASN1CALL ASN1Free_PickrequRes_extensionRes(PPickrequRes_extensionRes *val);
static void ASN1CALL ASN1Free_PickrequArg_extensionArg(PPickrequArg_extensionArg *val);
static void ASN1CALL ASN1Free_GroupIndicationOffRes_extensionRes(PGroupIndicationOffRes_extensionRes *val);
static void ASN1CALL ASN1Free_GroupIndicationOffArg_extensionArg(PGroupIndicationOffArg_extensionArg *val);
static void ASN1CALL ASN1Free_GroupIndicationOnRes_extensionRes(PGroupIndicationOnRes_extensionRes *val);
static void ASN1CALL ASN1Free_GroupIndicationOnArg_extensionArg(PGroupIndicationOnArg_extensionArg *val);
static void ASN1CALL ASN1Free_CpSetupRes_extensionRes(PCpSetupRes_extensionRes *val);
static void ASN1CALL ASN1Free_CpSetupArg_extensionArg(PCpSetupArg_extensionArg *val);
static void ASN1CALL ASN1Free_CpRequestRes_extensionRes(PCpRequestRes_extensionRes *val);
static void ASN1CALL ASN1Free_CpRequestArg_extensionArg(PCpRequestArg_extensionArg *val);
static void ASN1CALL ASN1Free_ServiceApdus_rosApdus(PServiceApdus_rosApdus *val);
static void ASN1CALL ASN1Free_AliasAddress(AliasAddress *val);
static void ASN1CALL ASN1Free_EndpointAddress_destinationAddress(PEndpointAddress_destinationAddress *val);
static void ASN1CALL ASN1Free_AddressInformation(AddressInformation *val);
static void ASN1CALL ASN1Free_EndpointAddress(EndpointAddress *val);
static void ASN1CALL ASN1Free_NetworkFacilityExtension(NetworkFacilityExtension *val);
static void ASN1CALL ASN1Free_ActivateDiversionQArgument(ActivateDiversionQArgument *val);
static void ASN1CALL ASN1Free_DeactivateDiversionQArgument(DeactivateDiversionQArgument *val);
static void ASN1CALL ASN1Free_InterrogateDiversionQArgument(InterrogateDiversionQArgument *val);
static void ASN1CALL ASN1Free_CheckRestrictionArgument(CheckRestrictionArgument *val);
static void ASN1CALL ASN1Free_CallReroutingArgument(CallReroutingArgument *val);
static void ASN1CALL ASN1Free_DivertingLegInformation1Argument(DivertingLegInformation1Argument *val);
static void ASN1CALL ASN1Free_DivertingLegInformation2Argument(DivertingLegInformation2Argument *val);
static void ASN1CALL ASN1Free_DivertingLegInformation3Argument(DivertingLegInformation3Argument *val);
static void ASN1CALL ASN1Free_DivertingLegInformation4Argument(DivertingLegInformation4Argument *val);
static void ASN1CALL ASN1Free_IntResult(IntResult *val);
static void ASN1CALL ASN1Free_CTInitiateArg(CTInitiateArg *val);
static void ASN1CALL ASN1Free_CTSetupArg(CTSetupArg *val);
static void ASN1CALL ASN1Free_CTIdentifyRes(CTIdentifyRes *val);
static void ASN1CALL ASN1Free_CTUpdateArg(CTUpdateArg *val);
static void ASN1CALL ASN1Free_CTCompleteArg(CTCompleteArg *val);
static void ASN1CALL ASN1Free_CTActiveArg(CTActiveArg *val);
static void ASN1CALL ASN1Free_CpRequestArg(CpRequestArg *val);
static void ASN1CALL ASN1Free_CpRequestRes(CpRequestRes *val);
static void ASN1CALL ASN1Free_CpSetupArg(CpSetupArg *val);
static void ASN1CALL ASN1Free_CpSetupRes(CpSetupRes *val);
static void ASN1CALL ASN1Free_GroupIndicationOnArg(GroupIndicationOnArg *val);
static void ASN1CALL ASN1Free_GroupIndicationOffArg(GroupIndicationOffArg *val);
static void ASN1CALL ASN1Free_PickrequArg(PickrequArg *val);
static void ASN1CALL ASN1Free_PickupArg(PickupArg *val);
static void ASN1CALL ASN1Free_PickExeArg(PickExeArg *val);
static void ASN1CALL ASN1Free_CpNotifyArg(CpNotifyArg *val);
static void ASN1CALL ASN1Free_CpickupNotifyArg(CpickupNotifyArg *val);
static void ASN1CALL ASN1Free_H4501SupplementaryService(H4501SupplementaryService *val);
static void ASN1CALL ASN1Free_IntResultList(IntResultList *val);

typedef ASN1PerEncFun_t ASN1EncFun_t;
static const ASN1EncFun_t encfntab[36] = {
    (ASN1EncFun_t) ASN1Enc_GroupIndicationOnRes,
    (ASN1EncFun_t) ASN1Enc_GroupIndicationOffRes,
    (ASN1EncFun_t) ASN1Enc_PickupRes,
    (ASN1EncFun_t) ASN1Enc_PickExeRes,
    (ASN1EncFun_t) ASN1Enc_PickrequRes,
    (ASN1EncFun_t) ASN1Enc_DummyArg,
    (ASN1EncFun_t) ASN1Enc_DummyRes,
    (ASN1EncFun_t) ASN1Enc_SubaddressTransferArg,
    (ASN1EncFun_t) ASN1Enc_ActivateDiversionQArgument,
    (ASN1EncFun_t) ASN1Enc_DeactivateDiversionQArgument,
    (ASN1EncFun_t) ASN1Enc_InterrogateDiversionQArgument,
    (ASN1EncFun_t) ASN1Enc_CheckRestrictionArgument,
    (ASN1EncFun_t) ASN1Enc_CallReroutingArgument,
    (ASN1EncFun_t) ASN1Enc_DivertingLegInformation1Argument,
    (ASN1EncFun_t) ASN1Enc_DivertingLegInformation2Argument,
    (ASN1EncFun_t) ASN1Enc_DivertingLegInformation3Argument,
    (ASN1EncFun_t) ASN1Enc_DivertingLegInformation4Argument,
    (ASN1EncFun_t) ASN1Enc_CTInitiateArg,
    (ASN1EncFun_t) ASN1Enc_CTSetupArg,
    (ASN1EncFun_t) ASN1Enc_CTIdentifyRes,
    (ASN1EncFun_t) ASN1Enc_CTUpdateArg,
    (ASN1EncFun_t) ASN1Enc_CTCompleteArg,
    (ASN1EncFun_t) ASN1Enc_CTActiveArg,
    (ASN1EncFun_t) ASN1Enc_CpRequestArg,
    (ASN1EncFun_t) ASN1Enc_CpRequestRes,
    (ASN1EncFun_t) ASN1Enc_CpSetupArg,
    (ASN1EncFun_t) ASN1Enc_CpSetupRes,
    (ASN1EncFun_t) ASN1Enc_GroupIndicationOnArg,
    (ASN1EncFun_t) ASN1Enc_GroupIndicationOffArg,
    (ASN1EncFun_t) ASN1Enc_PickrequArg,
    (ASN1EncFun_t) ASN1Enc_PickupArg,
    (ASN1EncFun_t) ASN1Enc_PickExeArg,
    (ASN1EncFun_t) ASN1Enc_CpNotifyArg,
    (ASN1EncFun_t) ASN1Enc_CpickupNotifyArg,
    (ASN1EncFun_t) ASN1Enc_H4501SupplementaryService,
    (ASN1EncFun_t) ASN1Enc_IntResultList,
};
typedef ASN1PerDecFun_t ASN1DecFun_t;
static const ASN1DecFun_t decfntab[36] = {
    (ASN1DecFun_t) ASN1Dec_GroupIndicationOnRes,
    (ASN1DecFun_t) ASN1Dec_GroupIndicationOffRes,
    (ASN1DecFun_t) ASN1Dec_PickupRes,
    (ASN1DecFun_t) ASN1Dec_PickExeRes,
    (ASN1DecFun_t) ASN1Dec_PickrequRes,
    (ASN1DecFun_t) ASN1Dec_DummyArg,
    (ASN1DecFun_t) ASN1Dec_DummyRes,
    (ASN1DecFun_t) ASN1Dec_SubaddressTransferArg,
    (ASN1DecFun_t) ASN1Dec_ActivateDiversionQArgument,
    (ASN1DecFun_t) ASN1Dec_DeactivateDiversionQArgument,
    (ASN1DecFun_t) ASN1Dec_InterrogateDiversionQArgument,
    (ASN1DecFun_t) ASN1Dec_CheckRestrictionArgument,
    (ASN1DecFun_t) ASN1Dec_CallReroutingArgument,
    (ASN1DecFun_t) ASN1Dec_DivertingLegInformation1Argument,
    (ASN1DecFun_t) ASN1Dec_DivertingLegInformation2Argument,
    (ASN1DecFun_t) ASN1Dec_DivertingLegInformation3Argument,
    (ASN1DecFun_t) ASN1Dec_DivertingLegInformation4Argument,
    (ASN1DecFun_t) ASN1Dec_CTInitiateArg,
    (ASN1DecFun_t) ASN1Dec_CTSetupArg,
    (ASN1DecFun_t) ASN1Dec_CTIdentifyRes,
    (ASN1DecFun_t) ASN1Dec_CTUpdateArg,
    (ASN1DecFun_t) ASN1Dec_CTCompleteArg,
    (ASN1DecFun_t) ASN1Dec_CTActiveArg,
    (ASN1DecFun_t) ASN1Dec_CpRequestArg,
    (ASN1DecFun_t) ASN1Dec_CpRequestRes,
    (ASN1DecFun_t) ASN1Dec_CpSetupArg,
    (ASN1DecFun_t) ASN1Dec_CpSetupRes,
    (ASN1DecFun_t) ASN1Dec_GroupIndicationOnArg,
    (ASN1DecFun_t) ASN1Dec_GroupIndicationOffArg,
    (ASN1DecFun_t) ASN1Dec_PickrequArg,
    (ASN1DecFun_t) ASN1Dec_PickupArg,
    (ASN1DecFun_t) ASN1Dec_PickExeArg,
    (ASN1DecFun_t) ASN1Dec_CpNotifyArg,
    (ASN1DecFun_t) ASN1Dec_CpickupNotifyArg,
    (ASN1DecFun_t) ASN1Dec_H4501SupplementaryService,
    (ASN1DecFun_t) ASN1Dec_IntResultList,
};
static const ASN1FreeFun_t freefntab[36] = {
    (ASN1FreeFun_t) ASN1Free_GroupIndicationOnRes,
    (ASN1FreeFun_t) ASN1Free_GroupIndicationOffRes,
    (ASN1FreeFun_t) ASN1Free_PickupRes,
    (ASN1FreeFun_t) ASN1Free_PickExeRes,
    (ASN1FreeFun_t) ASN1Free_PickrequRes,
    (ASN1FreeFun_t) ASN1Free_DummyArg,
    (ASN1FreeFun_t) ASN1Free_DummyRes,
    (ASN1FreeFun_t) ASN1Free_SubaddressTransferArg,
    (ASN1FreeFun_t) ASN1Free_ActivateDiversionQArgument,
    (ASN1FreeFun_t) ASN1Free_DeactivateDiversionQArgument,
    (ASN1FreeFun_t) ASN1Free_InterrogateDiversionQArgument,
    (ASN1FreeFun_t) ASN1Free_CheckRestrictionArgument,
    (ASN1FreeFun_t) ASN1Free_CallReroutingArgument,
    (ASN1FreeFun_t) ASN1Free_DivertingLegInformation1Argument,
    (ASN1FreeFun_t) ASN1Free_DivertingLegInformation2Argument,
    (ASN1FreeFun_t) ASN1Free_DivertingLegInformation3Argument,
    (ASN1FreeFun_t) ASN1Free_DivertingLegInformation4Argument,
    (ASN1FreeFun_t) ASN1Free_CTInitiateArg,
    (ASN1FreeFun_t) ASN1Free_CTSetupArg,
    (ASN1FreeFun_t) ASN1Free_CTIdentifyRes,
    (ASN1FreeFun_t) ASN1Free_CTUpdateArg,
    (ASN1FreeFun_t) ASN1Free_CTCompleteArg,
    (ASN1FreeFun_t) ASN1Free_CTActiveArg,
    (ASN1FreeFun_t) ASN1Free_CpRequestArg,
    (ASN1FreeFun_t) ASN1Free_CpRequestRes,
    (ASN1FreeFun_t) ASN1Free_CpSetupArg,
    (ASN1FreeFun_t) ASN1Free_CpSetupRes,
    (ASN1FreeFun_t) ASN1Free_GroupIndicationOnArg,
    (ASN1FreeFun_t) ASN1Free_GroupIndicationOffArg,
    (ASN1FreeFun_t) ASN1Free_PickrequArg,
    (ASN1FreeFun_t) ASN1Free_PickupArg,
    (ASN1FreeFun_t) ASN1Free_PickExeArg,
    (ASN1FreeFun_t) ASN1Free_CpNotifyArg,
    (ASN1FreeFun_t) ASN1Free_CpickupNotifyArg,
    (ASN1FreeFun_t) ASN1Free_H4501SupplementaryService,
    (ASN1FreeFun_t) ASN1Free_IntResultList,
};
static const ULONG sizetab[36] = {
    SIZE_H4503PP_Module_PDU_0,
    SIZE_H4503PP_Module_PDU_1,
    SIZE_H4503PP_Module_PDU_2,
    SIZE_H4503PP_Module_PDU_3,
    SIZE_H4503PP_Module_PDU_4,
    SIZE_H4503PP_Module_PDU_5,
    SIZE_H4503PP_Module_PDU_6,
    SIZE_H4503PP_Module_PDU_7,
    SIZE_H4503PP_Module_PDU_8,
    SIZE_H4503PP_Module_PDU_9,
    SIZE_H4503PP_Module_PDU_10,
    SIZE_H4503PP_Module_PDU_11,
    SIZE_H4503PP_Module_PDU_12,
    SIZE_H4503PP_Module_PDU_13,
    SIZE_H4503PP_Module_PDU_14,
    SIZE_H4503PP_Module_PDU_15,
    SIZE_H4503PP_Module_PDU_16,
    SIZE_H4503PP_Module_PDU_17,
    SIZE_H4503PP_Module_PDU_18,
    SIZE_H4503PP_Module_PDU_19,
    SIZE_H4503PP_Module_PDU_20,
    SIZE_H4503PP_Module_PDU_21,
    SIZE_H4503PP_Module_PDU_22,
    SIZE_H4503PP_Module_PDU_23,
    SIZE_H4503PP_Module_PDU_24,
    SIZE_H4503PP_Module_PDU_25,
    SIZE_H4503PP_Module_PDU_26,
    SIZE_H4503PP_Module_PDU_27,
    SIZE_H4503PP_Module_PDU_28,
    SIZE_H4503PP_Module_PDU_29,
    SIZE_H4503PP_Module_PDU_30,
    SIZE_H4503PP_Module_PDU_31,
    SIZE_H4503PP_Module_PDU_32,
    SIZE_H4503PP_Module_PDU_33,
    SIZE_H4503PP_Module_PDU_34,
    SIZE_H4503PP_Module_PDU_35,
};

/* forward declarations of values: */
/* definitions of value components: */
/* definitions of values: */
CallStatus CTCompleteArg_callStatus_default = 0;
ASN1bool_t IntResult_remoteEnabled_default = 0;
BasicService InterrogateDiversionQArgument_basicService_default = 0;

void ASN1CALL H4503PP_Module_Startup(void)
{
    H4503PP_Module = ASN1_CreateModule(0x10000, ASN1_PER_RULE_ALIGNED, ASN1FLAGS_NONE, 36, (const ASN1GenericFun_t *) encfntab, (const ASN1GenericFun_t *) decfntab, freefntab, sizetab, 0x30353468);
}

void ASN1CALL H4503PP_Module_Cleanup(void)
{
    ASN1_CloseModule(H4503PP_Module);
    H4503PP_Module = NULL;
}

static int ASN1CALL ASN1Enc_TransportAddress_ipSourceRoute_routing(ASN1encoding_t enc, TransportAddress_ipSourceRoute_routing *val)
{
    if (!ASN1PEREncSimpleChoiceEx(enc, (val)->choice, 1))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_TransportAddress_ipSourceRoute_routing(ASN1decoding_t dec, TransportAddress_ipSourceRoute_routing *val)
{
    if (!ASN1PERDecSimpleChoiceEx(dec, &(val)->choice, 1))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Enc_TransportAddress_ipSourceRoute_route(ASN1encoding_t enc, PTransportAddress_ipSourceRoute_route *val)
{
    return ASN1PEREncSeqOf_NoSize(enc, (ASN1iterator_t **) val, (ASN1iterator_encfn) ASN1Enc_TransportAddress_ipSourceRoute_route_ElmFn);
}

static int ASN1CALL ASN1Enc_TransportAddress_ipSourceRoute_route_ElmFn(ASN1encoding_t enc, PTransportAddress_ipSourceRoute_route val)
{
    if (!ASN1PEREncOctetString_FixedSize(enc, (ASN1octetstring2_t *) &val->value, 4))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_TransportAddress_ipSourceRoute_route(ASN1decoding_t dec, PTransportAddress_ipSourceRoute_route *val)
{
    return ASN1PERDecSeqOf_NoSize(dec, (ASN1iterator_t **) val, (ASN1iterator_decfn) ASN1Dec_TransportAddress_ipSourceRoute_route_ElmFn, sizeof(**val));
}

static int ASN1CALL ASN1Dec_TransportAddress_ipSourceRoute_route_ElmFn(ASN1decoding_t dec, PTransportAddress_ipSourceRoute_route val)
{
    if (!ASN1PERDecOctetString_FixedSize(dec, (ASN1octetstring2_t *) &val->value, 4))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_TransportAddress_ipSourceRoute_route(PTransportAddress_ipSourceRoute_route *val)
{
    if (val) {
    ASN1PERFreeSeqOf((ASN1iterator_t **) val, (ASN1iterator_freefn) ASN1Free_TransportAddress_ipSourceRoute_route_ElmFn);
    }
}

static void ASN1CALL ASN1Free_TransportAddress_ipSourceRoute_route_ElmFn(PTransportAddress_ipSourceRoute_route val)
{
    if (val) {
    }
}

static int ASN1CALL ASN1Enc_TransportAddress_ip6Address(ASN1encoding_t enc, TransportAddress_ip6Address *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncOctetString_FixedSize(enc, (ASN1octetstring2_t *) &(val)->ip, 16))
    return 0;
    if (!ASN1PEREncUnsignedShort(enc, (val)->port))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_TransportAddress_ip6Address(ASN1decoding_t dec, TransportAddress_ip6Address *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecOctetString_FixedSize(dec, (ASN1octetstring2_t *) &(val)->ip, 16))
    return 0;
    if (!ASN1PERDecUnsignedShort(dec, &(val)->port))
    return 0;
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_TransportAddress_ip6Address(TransportAddress_ip6Address *val)
{
    if (val) {
    }
}

static int ASN1CALL ASN1Enc_TransportAddress_ipxAddress(ASN1encoding_t enc, TransportAddress_ipxAddress *val)
{
    if (!ASN1PEREncOctetString_FixedSize(enc, (ASN1octetstring2_t *) &(val)->node, 6))
    return 0;
    if (!ASN1PEREncOctetString_FixedSize(enc, (ASN1octetstring2_t *) &(val)->netnum, 4))
    return 0;
    if (!ASN1PEREncOctetString_FixedSize(enc, (ASN1octetstring2_t *) &(val)->port, 2))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_TransportAddress_ipxAddress(ASN1decoding_t dec, TransportAddress_ipxAddress *val)
{
    if (!ASN1PERDecOctetString_FixedSize(dec, (ASN1octetstring2_t *) &(val)->node, 6))
    return 0;
    if (!ASN1PERDecOctetString_FixedSize(dec, (ASN1octetstring2_t *) &(val)->netnum, 4))
    return 0;
    if (!ASN1PERDecOctetString_FixedSize(dec, (ASN1octetstring2_t *) &(val)->port, 2))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_TransportAddress_ipxAddress(TransportAddress_ipxAddress *val)
{
    if (val) {
    }
}

static int ASN1CALL ASN1Enc_TransportAddress_ipSourceRoute(ASN1encoding_t enc, TransportAddress_ipSourceRoute *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncOctetString_FixedSize(enc, (ASN1octetstring2_t *) &(val)->ip, 4))
    return 0;
    if (!ASN1PEREncUnsignedShort(enc, (val)->port))
    return 0;
    if (!ASN1Enc_TransportAddress_ipSourceRoute_route(enc, &(val)->route))
    return 0;
    if (!ASN1Enc_TransportAddress_ipSourceRoute_routing(enc, &(val)->routing))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_TransportAddress_ipSourceRoute(ASN1decoding_t dec, TransportAddress_ipSourceRoute *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecOctetString_FixedSize(dec, (ASN1octetstring2_t *) &(val)->ip, 4))
    return 0;
    if (!ASN1PERDecUnsignedShort(dec, &(val)->port))
    return 0;
    if (!ASN1Dec_TransportAddress_ipSourceRoute_route(dec, &(val)->route))
    return 0;
    if (!ASN1Dec_TransportAddress_ipSourceRoute_routing(dec, &(val)->routing))
    return 0;
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_TransportAddress_ipSourceRoute(TransportAddress_ipSourceRoute *val)
{
    if (val) {
    ASN1Free_TransportAddress_ipSourceRoute_route(&(val)->route);
    }
}

static int ASN1CALL ASN1Enc_TransportAddress_ipAddress(ASN1encoding_t enc, TransportAddress_ipAddress *val)
{
    if (!ASN1PEREncOctetString_FixedSize(enc, (ASN1octetstring2_t *) &(val)->ip, 4))
    return 0;
    if (!ASN1PEREncUnsignedShort(enc, (val)->port))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_TransportAddress_ipAddress(ASN1decoding_t dec, TransportAddress_ipAddress *val)
{
    if (!ASN1PERDecOctetString_FixedSize(dec, (ASN1octetstring2_t *) &(val)->ip, 4))
    return 0;
    if (!ASN1PERDecUnsignedShort(dec, &(val)->port))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_TransportAddress_ipAddress(TransportAddress_ipAddress *val)
{
    if (val) {
    }
}

static int ASN1CALL ASN1Enc_Reject_problem(ASN1encoding_t enc, Reject_problem *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 2))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1PEREncInteger(enc, (val)->u.general))
        return 0;
    break;
    case 2:
    if (!ASN1PEREncInteger(enc, (val)->u.invoke))
        return 0;
    break;
    case 3:
    if (!ASN1PEREncInteger(enc, (val)->u.returnResult))
        return 0;
    break;
    case 4:
    if (!ASN1PEREncInteger(enc, (val)->u.returnError))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_Reject_problem(ASN1decoding_t dec, Reject_problem *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 2))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1PERDecInteger(dec, &(val)->u.general))
        return 0;
    break;
    case 2:
    if (!ASN1PERDecInteger(dec, &(val)->u.invoke))
        return 0;
    break;
    case 3:
    if (!ASN1PERDecInteger(dec, &(val)->u.returnResult))
        return 0;
    break;
    case 4:
    if (!ASN1PERDecInteger(dec, &(val)->u.returnError))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Enc_EntityType(ASN1encoding_t enc, EntityType *val)
{
    if (!ASN1PEREncSimpleChoiceEx(enc, (val)->choice, 1))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_EntityType(ASN1decoding_t dec, EntityType *val)
{
    if (!ASN1PERDecSimpleChoiceEx(dec, &(val)->choice, 1))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Enc_InterpretationApdu(ASN1encoding_t enc, InterpretationApdu *val)
{
    if (!ASN1PEREncSimpleChoiceEx(enc, (val)->choice, 2))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_InterpretationApdu(ASN1decoding_t dec, InterpretationApdu *val)
{
    if (!ASN1PERDecSimpleChoiceEx(dec, &(val)->choice, 2))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Enc_ServiceApdus(ASN1encoding_t enc, ServiceApdus *val)
{
    if (!ASN1PEREncSimpleChoiceEx(enc, (val)->choice, 0))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ServiceApdus_rosApdus(enc, &(val)->u.rosApdus))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_ServiceApdus(ASN1decoding_t dec, ServiceApdus *val)
{
    if (!ASN1PERDecSimpleChoiceEx(dec, &(val)->choice, 0))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ServiceApdus_rosApdus(dec, &(val)->u.rosApdus))
        return 0;
    break;
    case 0:
    /* extension case */
    if (!ASN1PERDecSkipFragmented(dec, 8))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_ServiceApdus(ServiceApdus *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ServiceApdus_rosApdus(&(val)->u.rosApdus);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_Reject(ASN1encoding_t enc, Reject *val)
{
    if (!ASN1PEREncInteger(enc, (val)->invokeId))
    return 0;
    if (!ASN1Enc_Reject_problem(enc, &(val)->problem))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_Reject(ASN1decoding_t dec, Reject *val)
{
    if (!ASN1PERDecInteger(dec, &(val)->invokeId))
    return 0;
    if (!ASN1Dec_Reject_problem(dec, &(val)->problem))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Enc_EXTENSION(ASN1encoding_t enc, EXTENSION *val)
{
    if (!ASN1PEREncBits(enc, 1, (val)->o))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PEREncUnsignedShort(enc, (val)->argumentType - 1))
        return 0;
    }
    if (!ASN1PEREncObjectIdentifier(enc, &(val)->extensionID))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_EXTENSION(ASN1decoding_t dec, EXTENSION *val)
{
    if (!ASN1PERDecExtension(dec, 1, (val)->o))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PERDecUnsignedShort(dec, &(val)->argumentType))
        return 0;
    (val)->argumentType += 1;
    }
    if (!ASN1PERDecObjectIdentifier(dec, &(val)->extensionID))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_EXTENSION(EXTENSION *val)
{
    if (val) {
    ASN1objectidentifier_free(&(val)->extensionID);
    }
}

static int ASN1CALL ASN1Enc_GroupIndicationOnRes(ASN1encoding_t enc, GroupIndicationOnRes *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 1, (val)->o))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_GroupIndicationOnRes_extensionRes(enc, &(val)->extensionRes))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_GroupIndicationOnRes(ASN1decoding_t dec, GroupIndicationOnRes *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 1, (val)->o))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_GroupIndicationOnRes_extensionRes(dec, &(val)->extensionRes))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_GroupIndicationOnRes(GroupIndicationOnRes *val)
{
    if (val) {
    if ((val)->o[0] & 0x80) {
        ASN1Free_GroupIndicationOnRes_extensionRes(&(val)->extensionRes);
    }
    }
}

static int ASN1CALL ASN1Enc_GroupIndicationOffRes(ASN1encoding_t enc, GroupIndicationOffRes *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 1, (val)->o))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_GroupIndicationOffRes_extensionRes(enc, &(val)->extensionRes))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_GroupIndicationOffRes(ASN1decoding_t dec, GroupIndicationOffRes *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 1, (val)->o))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_GroupIndicationOffRes_extensionRes(dec, &(val)->extensionRes))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_GroupIndicationOffRes(GroupIndicationOffRes *val)
{
    if (val) {
    if ((val)->o[0] & 0x80) {
        ASN1Free_GroupIndicationOffRes_extensionRes(&(val)->extensionRes);
    }
    }
}

static int ASN1CALL ASN1Enc_PickupRes(ASN1encoding_t enc, PickupRes *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 1, (val)->o))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_PickupRes_extensionRes(enc, &(val)->extensionRes))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_PickupRes(ASN1decoding_t dec, PickupRes *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 1, (val)->o))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_PickupRes_extensionRes(dec, &(val)->extensionRes))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_PickupRes(PickupRes *val)
{
    if (val) {
    if ((val)->o[0] & 0x80) {
        ASN1Free_PickupRes_extensionRes(&(val)->extensionRes);
    }
    }
}

static int ASN1CALL ASN1Enc_PickExeRes(ASN1encoding_t enc, PickExeRes *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 1, (val)->o))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_PickExeRes_extensionRes(enc, &(val)->extensionRes))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_PickExeRes(ASN1decoding_t dec, PickExeRes *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 1, (val)->o))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_PickExeRes_extensionRes(dec, &(val)->extensionRes))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_PickExeRes(PickExeRes *val)
{
    if (val) {
    if ((val)->o[0] & 0x80) {
        ASN1Free_PickExeRes_extensionRes(&(val)->extensionRes);
    }
    }
}

static int ASN1CALL ASN1Enc_UserSpecifiedSubaddress(ASN1encoding_t enc, UserSpecifiedSubaddress *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 1, (val)->o))
    return 0;
    if (!ASN1PEREncOctetString_VarSize(enc, (ASN1octetstring2_t *) &(val)->subaddressInformation, 1, 20, 5))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PEREncBoolean(enc, (val)->oddCountIndicator))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_UserSpecifiedSubaddress(ASN1decoding_t dec, UserSpecifiedSubaddress *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 1, (val)->o))
    return 0;
    if (!ASN1PERDecOctetString_VarSize(dec, (ASN1octetstring2_t *) &(val)->subaddressInformation, 1, 20, 5))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PERDecBoolean(dec, &(val)->oddCountIndicator))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_UserSpecifiedSubaddress(UserSpecifiedSubaddress *val)
{
    if (val) {
    }
}

static int ASN1CALL ASN1Enc_CODE(ASN1encoding_t enc, CODE *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1PEREncInteger(enc, (val)->u.local))
        return 0;
    break;
    case 2:
    if (!ASN1PEREncObjectIdentifier(enc, &(val)->u.global))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CODE(ASN1decoding_t dec, CODE *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1PERDecInteger(dec, &(val)->u.local))
        return 0;
    break;
    case 2:
    if (!ASN1PERDecObjectIdentifier(dec, &(val)->u.global))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CODE(CODE *val)
{
    if (val) {
    switch ((val)->choice) {
    case 2:
        ASN1objectidentifier_free(&(val)->u.global);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_H221NonStandard(ASN1encoding_t enc, H221NonStandard *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncBitVal(enc, 8, (val)->t35CountryCode))
    return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncBitVal(enc, 8, (val)->t35Extension))
    return 0;
    if (!ASN1PEREncUnsignedShort(enc, (val)->manufacturerCode))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_H221NonStandard(ASN1decoding_t dec, H221NonStandard *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    ASN1PERDecAlignment(dec);
    if (!ASN1PERDecU16Val(dec, 8, &(val)->t35CountryCode))
    return 0;
    ASN1PERDecAlignment(dec);
    if (!ASN1PERDecU16Val(dec, 8, &(val)->t35Extension))
    return 0;
    if (!ASN1PERDecUnsignedShort(dec, &(val)->manufacturerCode))
    return 0;
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Enc_H225NonStandardIdentifier(ASN1encoding_t enc, H225NonStandardIdentifier *val)
{
    if (!ASN1PEREncSimpleChoiceEx(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1PEREncObjectIdentifier(enc, &(val)->u.object))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H221NonStandard(enc, &(val)->u.h221NonStandard))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_H225NonStandardIdentifier(ASN1decoding_t dec, H225NonStandardIdentifier *val)
{
    if (!ASN1PERDecSimpleChoiceEx(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1PERDecObjectIdentifier(dec, &(val)->u.object))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H221NonStandard(dec, &(val)->u.h221NonStandard))
        return 0;
    break;
    case 0:
    /* extension case */
    if (!ASN1PERDecSkipFragmented(dec, 8))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_H225NonStandardIdentifier(H225NonStandardIdentifier *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1objectidentifier_free(&(val)->u.object);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_PublicTypeOfNumber(ASN1encoding_t enc, PublicTypeOfNumber *val)
{
    if (!ASN1PEREncSimpleChoiceEx(enc, (val)->choice, 3))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_PublicTypeOfNumber(ASN1decoding_t dec, PublicTypeOfNumber *val)
{
    if (!ASN1PERDecSimpleChoiceEx(dec, &(val)->choice, 3))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Enc_PrivateTypeOfNumber(ASN1encoding_t enc, PrivateTypeOfNumber *val)
{
    if (!ASN1PEREncSimpleChoiceEx(enc, (val)->choice, 3))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_PrivateTypeOfNumber(ASN1decoding_t dec, PrivateTypeOfNumber *val)
{
    if (!ASN1PERDecSimpleChoiceEx(dec, &(val)->choice, 3))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Enc_CallIdentifier(ASN1encoding_t enc, CallIdentifier *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncOctetString_FixedSize(enc, (ASN1octetstring2_t *) &(val)->guid, 16))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_CallIdentifier(ASN1decoding_t dec, CallIdentifier *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecOctetString_FixedSize(dec, (ASN1octetstring2_t *) &(val)->guid, 16))
    return 0;
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CallIdentifier(CallIdentifier *val)
{
    if (val) {
    }
}

static int ASN1CALL ASN1Enc_ReturnResult_result(ASN1encoding_t enc, ReturnResult_result *val)
{
    if (!ASN1Enc_CODE(enc, &(val)->opcode))
    return 0;
    if (!ASN1PEREncOctetString_NoSize(enc, &(val)->result))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_ReturnResult_result(ASN1decoding_t dec, ReturnResult_result *val)
{
    if (!ASN1Dec_CODE(dec, &(val)->opcode))
    return 0;
    if (!ASN1PERDecOctetString_NoSize(dec, &(val)->result))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_ReturnResult_result(ReturnResult_result *val)
{
    if (val) {
    ASN1Free_CODE(&(val)->opcode);
    ASN1octetstring_free(&(val)->result);
    }
}

static int ASN1CALL ASN1Enc_Invoke(ASN1encoding_t enc, Invoke *val)
{
    if (!ASN1PEREncBits(enc, 2, (val)->o))
    return 0;
    if (!ASN1PEREncUnsignedShort(enc, (val)->invokeId))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PEREncInteger(enc, (val)->linkedId))
        return 0;
    }
    if (!ASN1Enc_CODE(enc, &(val)->opcode))
    return 0;
    if ((val)->o[0] & 0x40) {
    if (!ASN1PEREncOctetString_NoSize(enc, &(val)->argument))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_Invoke(ASN1decoding_t dec, Invoke *val)
{
    if (!ASN1PERDecExtension(dec, 2, (val)->o))
    return 0;
    if (!ASN1PERDecUnsignedShort(dec, &(val)->invokeId))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PERDecInteger(dec, &(val)->linkedId))
        return 0;
    }
    if (!ASN1Dec_CODE(dec, &(val)->opcode))
    return 0;
    if ((val)->o[0] & 0x40) {
    if (!ASN1PERDecOctetString_NoSize(dec, &(val)->argument))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_Invoke(Invoke *val)
{
    if (val) {
    ASN1Free_CODE(&(val)->opcode);
    if ((val)->o[0] & 0x40) {
        ASN1octetstring_free(&(val)->argument);
    }
    }
}

static int ASN1CALL ASN1Enc_ReturnResult(ASN1encoding_t enc, ReturnResult *val)
{
    if (!ASN1PEREncBits(enc, 1, (val)->o))
    return 0;
    if (!ASN1PEREncInteger(enc, (val)->invokeId))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_ReturnResult_result(enc, &(val)->result))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_ReturnResult(ASN1decoding_t dec, ReturnResult *val)
{
    if (!ASN1PERDecExtension(dec, 1, (val)->o))
    return 0;
    if (!ASN1PERDecInteger(dec, &(val)->invokeId))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_ReturnResult_result(dec, &(val)->result))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_ReturnResult(ReturnResult *val)
{
    if (val) {
    if ((val)->o[0] & 0x80) {
        ASN1Free_ReturnResult_result(&(val)->result);
    }
    }
}

static int ASN1CALL ASN1Enc_ReturnError(ASN1encoding_t enc, ReturnError *val)
{
    if (!ASN1PEREncBits(enc, 1, (val)->o))
    return 0;
    if (!ASN1PEREncInteger(enc, (val)->invokeId))
    return 0;
    if (!ASN1Enc_CODE(enc, &(val)->errcode))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PEREncOctetString_NoSize(enc, &(val)->parameter))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_ReturnError(ASN1decoding_t dec, ReturnError *val)
{
    if (!ASN1PERDecExtension(dec, 1, (val)->o))
    return 0;
    if (!ASN1PERDecInteger(dec, &(val)->invokeId))
    return 0;
    if (!ASN1Dec_CODE(dec, &(val)->errcode))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PERDecOctetString_NoSize(dec, &(val)->parameter))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_ReturnError(ReturnError *val)
{
    if (val) {
    ASN1Free_CODE(&(val)->errcode);
    if ((val)->o[0] & 0x80) {
        ASN1octetstring_free(&(val)->parameter);
    }
    }
}

static int ASN1CALL ASN1Enc_ExtensionSeq(ASN1encoding_t enc, PExtensionSeq *val)
{
    return ASN1PEREncSeqOf_NoSize(enc, (ASN1iterator_t **) val, (ASN1iterator_encfn) ASN1Enc_ExtensionSeq_ElmFn);
}

static int ASN1CALL ASN1Enc_ExtensionSeq_ElmFn(ASN1encoding_t enc, PExtensionSeq val)
{
    if (!ASN1Enc_EXTENSION(enc, &val->value))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_ExtensionSeq(ASN1decoding_t dec, PExtensionSeq *val)
{
    return ASN1PERDecSeqOf_NoSize(dec, (ASN1iterator_t **) val, (ASN1iterator_decfn) ASN1Dec_ExtensionSeq_ElmFn, sizeof(**val));
}

static int ASN1CALL ASN1Dec_ExtensionSeq_ElmFn(ASN1decoding_t dec, PExtensionSeq val)
{
    if (!ASN1Dec_EXTENSION(dec, &val->value))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_ExtensionSeq(PExtensionSeq *val)
{
    if (val) {
    ASN1PERFreeSeqOf((ASN1iterator_t **) val, (ASN1iterator_freefn) ASN1Free_ExtensionSeq_ElmFn);
    }
}

static void ASN1CALL ASN1Free_ExtensionSeq_ElmFn(PExtensionSeq val)
{
    if (val) {
    ASN1Free_EXTENSION(&val->value);
    }
}

static int ASN1CALL ASN1Enc_PickrequRes(ASN1encoding_t enc, PickrequRes *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 1, (val)->o))
    return 0;
    if (!ASN1Enc_CallIdentifier(enc, &(val)->callPickupId))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_PickrequRes_extensionRes(enc, &(val)->extensionRes))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_PickrequRes(ASN1decoding_t dec, PickrequRes *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 1, (val)->o))
    return 0;
    if (!ASN1Dec_CallIdentifier(dec, &(val)->callPickupId))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_PickrequRes_extensionRes(dec, &(val)->extensionRes))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_PickrequRes(PickrequRes *val)
{
    if (val) {
    ASN1Free_CallIdentifier(&(val)->callPickupId);
    if ((val)->o[0] & 0x80) {
        ASN1Free_PickrequRes_extensionRes(&(val)->extensionRes);
    }
    }
}

static int ASN1CALL ASN1Enc_PartySubaddress(ASN1encoding_t enc, PartySubaddress *val)
{
    if (!ASN1PEREncSimpleChoiceEx(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_UserSpecifiedSubaddress(enc, &(val)->u.userSpecifiedSubaddress))
        return 0;
    break;
    case 2:
    if (!ASN1PEREncOctetString_VarSize(enc, (ASN1octetstring2_t *) &(val)->u.nsapSubaddress, 1, 20, 5))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_PartySubaddress(ASN1decoding_t dec, PartySubaddress *val)
{
    if (!ASN1PERDecSimpleChoiceEx(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_UserSpecifiedSubaddress(dec, &(val)->u.userSpecifiedSubaddress))
        return 0;
    break;
    case 2:
    if (!ASN1PERDecOctetString_VarSize(dec, (ASN1octetstring2_t *) &(val)->u.nsapSubaddress, 1, 20, 5))
        return 0;
    break;
    case 0:
    /* extension case */
    if (!ASN1PERDecSkipFragmented(dec, 8))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_PartySubaddress(PartySubaddress *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_UserSpecifiedSubaddress(&(val)->u.userSpecifiedSubaddress);
        break;
    case 2:
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_H225NonStandardParameter(ASN1encoding_t enc, H225NonStandardParameter *val)
{
    if (!ASN1Enc_H225NonStandardIdentifier(enc, &(val)->nonStandardIdentifier))
    return 0;
    if (!ASN1PEREncOctetString_NoSize(enc, &(val)->data))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_H225NonStandardParameter(ASN1decoding_t dec, H225NonStandardParameter *val)
{
    if (!ASN1Dec_H225NonStandardIdentifier(dec, &(val)->nonStandardIdentifier))
    return 0;
    if (!ASN1PERDecOctetString_NoSize(dec, &(val)->data))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_H225NonStandardParameter(H225NonStandardParameter *val)
{
    if (val) {
    ASN1Free_H225NonStandardIdentifier(&(val)->nonStandardIdentifier);
    ASN1octetstring_free(&(val)->data);
    }
}

static ASN1stringtableentry_t PublicPartyNumber_publicNumberDigits_StringTableEntries[] = {
    { 35, 35, 0 }, { 42, 42, 1 }, { 44, 44, 2 }, 
    { 48, 57, 3 }, 
};

static ASN1stringtable_t PublicPartyNumber_publicNumberDigits_StringTable = {
    4, PublicPartyNumber_publicNumberDigits_StringTableEntries
};

static int ASN1CALL ASN1Enc_PublicPartyNumber(ASN1encoding_t enc, PublicPartyNumber *val)
{
    ASN1uint32_t t;
    if (!ASN1Enc_PublicTypeOfNumber(enc, &(val)->publicTypeOfNumber))
    return 0;
    t = lstrlenA((val)->publicNumberDigits);
    if (!ASN1PEREncBitVal(enc, 7, t - 1))
    return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncTableCharString(enc, t, (val)->publicNumberDigits, 4, &PublicPartyNumber_publicNumberDigits_StringTable))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_PublicPartyNumber(ASN1decoding_t dec, PublicPartyNumber *val)
{
    ASN1uint32_t l;
    if (!ASN1Dec_PublicTypeOfNumber(dec, &(val)->publicTypeOfNumber))
    return 0;
    if (!ASN1PERDecU32Val(dec, 7, &l))
    return 0;
    l += 1;
    ASN1PERDecAlignment(dec);

    //NikhilB: Fix for the overflow bug 03/02/27
    if ( l >= sizeof((val)->publicNumberDigits) ) {
        ASN1DecSetError(dec, ASN1_ERR_LARGE);
        return 0; 
    }

    if (!ASN1PERDecZeroTableCharStringNoAlloc(dec, l, (val)->publicNumberDigits, 4, &PublicPartyNumber_publicNumberDigits_StringTable))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_PublicPartyNumber(PublicPartyNumber *val)
{
    if (val) {
    }
}

static ASN1stringtableentry_t PrivatePartyNumber_privateNumberDigits_StringTableEntries[] = {
    { 35, 35, 0 }, { 42, 42, 1 }, { 44, 44, 2 }, 
    { 48, 57, 3 }, 
};

static ASN1stringtable_t PrivatePartyNumber_privateNumberDigits_StringTable = {
    4, PrivatePartyNumber_privateNumberDigits_StringTableEntries
};

static int ASN1CALL ASN1Enc_PrivatePartyNumber(ASN1encoding_t enc, PrivatePartyNumber *val)
{
    ASN1uint32_t t;
    if (!ASN1Enc_PrivateTypeOfNumber(enc, &(val)->privateTypeOfNumber))
    return 0;
    t = lstrlenA((val)->privateNumberDigits);
    if (!ASN1PEREncBitVal(enc, 7, t - 1))
    return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncTableCharString(enc, t, (val)->privateNumberDigits, 4, &PrivatePartyNumber_privateNumberDigits_StringTable))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_PrivatePartyNumber(ASN1decoding_t dec, PrivatePartyNumber *val)
{
    ASN1uint32_t l;
    if (!ASN1Dec_PrivateTypeOfNumber(dec, &(val)->privateTypeOfNumber))
    return 0;
    if (!ASN1PERDecU32Val(dec, 7, &l))
    return 0;
    l += 1;
    ASN1PERDecAlignment(dec);

    //NikhilB: Fix for the overflow bug 03/02/27
    if ( l >= sizeof((val)->privateNumberDigits) ) {
        ASN1DecSetError(dec, ASN1_ERR_LARGE);
        return 0; 
    }

    if (!ASN1PERDecZeroTableCharStringNoAlloc(dec, l, (val)->privateNumberDigits, 4, &PrivatePartyNumber_privateNumberDigits_StringTable))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_PrivatePartyNumber(PrivatePartyNumber *val)
{
    if (val) {
    }
}

static int ASN1CALL ASN1Enc_TransportAddress(ASN1encoding_t enc, TransportAddress *val)
{
    if (!ASN1PEREncSimpleChoiceEx(enc, (val)->choice, 3))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_TransportAddress_ipAddress(enc, &(val)->u.ipAddress))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_TransportAddress_ipSourceRoute(enc, &(val)->u.ipSourceRoute))
        return 0;
    break;
    case 3:
    if (!ASN1Enc_TransportAddress_ipxAddress(enc, &(val)->u.ipxAddress))
        return 0;
    break;
    case 4:
    if (!ASN1Enc_TransportAddress_ip6Address(enc, &(val)->u.ip6Address))
        return 0;
    break;
    case 5:
    if (!ASN1PEREncOctetString_FixedSize(enc, (ASN1octetstring2_t *) &(val)->u.netBios, 16))
        return 0;
    break;
    case 6:
    if (!ASN1PEREncOctetString_VarSize(enc, (ASN1octetstring2_t *) &(val)->u.nsap, 1, 20, 5))
        return 0;
    break;
    case 7:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardAddress))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_TransportAddress(ASN1decoding_t dec, TransportAddress *val)
{
    if (!ASN1PERDecSimpleChoiceEx(dec, &(val)->choice, 3))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_TransportAddress_ipAddress(dec, &(val)->u.ipAddress))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_TransportAddress_ipSourceRoute(dec, &(val)->u.ipSourceRoute))
        return 0;
    break;
    case 3:
    if (!ASN1Dec_TransportAddress_ipxAddress(dec, &(val)->u.ipxAddress))
        return 0;
    break;
    case 4:
    if (!ASN1Dec_TransportAddress_ip6Address(dec, &(val)->u.ip6Address))
        return 0;
    break;
    case 5:
    if (!ASN1PERDecOctetString_FixedSize(dec, (ASN1octetstring2_t *) &(val)->u.netBios, 16))
        return 0;
    break;
    case 6:
    if (!ASN1PERDecOctetString_VarSize(dec, (ASN1octetstring2_t *) &(val)->u.nsap, 1, 20, 5))
        return 0;
    break;
    case 7:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardAddress))
        return 0;
    break;
    case 0:
    /* extension case */
    if (!ASN1PERDecSkipFragmented(dec, 8))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_TransportAddress(TransportAddress *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_TransportAddress_ipAddress(&(val)->u.ipAddress);
        break;
    case 2:
        ASN1Free_TransportAddress_ipSourceRoute(&(val)->u.ipSourceRoute);
        break;
    case 3:
        ASN1Free_TransportAddress_ipxAddress(&(val)->u.ipxAddress);
        break;
    case 4:
        ASN1Free_TransportAddress_ip6Address(&(val)->u.ip6Address);
        break;
    case 5:
        break;
    case 6:
        break;
    case 7:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardAddress);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_CTActiveArg_argumentExtension(ASN1encoding_t enc, CTActiveArg_argumentExtension *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ExtensionSeq(enc, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CTActiveArg_argumentExtension(ASN1decoding_t dec, CTActiveArg_argumentExtension *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ExtensionSeq(dec, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CTActiveArg_argumentExtension(CTActiveArg_argumentExtension *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ExtensionSeq(&(val)->u.extensionSeq);
        break;
    case 2:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardData);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_CTCompleteArg_argumentExtension(ASN1encoding_t enc, CTCompleteArg_argumentExtension *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ExtensionSeq(enc, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CTCompleteArg_argumentExtension(ASN1decoding_t dec, CTCompleteArg_argumentExtension *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ExtensionSeq(dec, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CTCompleteArg_argumentExtension(CTCompleteArg_argumentExtension *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ExtensionSeq(&(val)->u.extensionSeq);
        break;
    case 2:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardData);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_SubaddressTransferArg_argumentExtension(ASN1encoding_t enc, SubaddressTransferArg_argumentExtension *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ExtensionSeq(enc, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_SubaddressTransferArg_argumentExtension(ASN1decoding_t dec, SubaddressTransferArg_argumentExtension *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ExtensionSeq(dec, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_SubaddressTransferArg_argumentExtension(SubaddressTransferArg_argumentExtension *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ExtensionSeq(&(val)->u.extensionSeq);
        break;
    case 2:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardData);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_CTUpdateArg_argumentExtension(ASN1encoding_t enc, CTUpdateArg_argumentExtension *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ExtensionSeq(enc, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CTUpdateArg_argumentExtension(ASN1decoding_t dec, CTUpdateArg_argumentExtension *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ExtensionSeq(dec, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CTUpdateArg_argumentExtension(CTUpdateArg_argumentExtension *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ExtensionSeq(&(val)->u.extensionSeq);
        break;
    case 2:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardData);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_CTIdentifyRes_resultExtension(ASN1encoding_t enc, CTIdentifyRes_resultExtension *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ExtensionSeq(enc, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CTIdentifyRes_resultExtension(ASN1decoding_t dec, CTIdentifyRes_resultExtension *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ExtensionSeq(dec, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CTIdentifyRes_resultExtension(CTIdentifyRes_resultExtension *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ExtensionSeq(&(val)->u.extensionSeq);
        break;
    case 2:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardData);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_CTSetupArg_argumentExtension(ASN1encoding_t enc, CTSetupArg_argumentExtension *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ExtensionSeq(enc, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CTSetupArg_argumentExtension(ASN1decoding_t dec, CTSetupArg_argumentExtension *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ExtensionSeq(dec, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CTSetupArg_argumentExtension(CTSetupArg_argumentExtension *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ExtensionSeq(&(val)->u.extensionSeq);
        break;
    case 2:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardData);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_CTInitiateArg_argumentExtension(ASN1encoding_t enc, CTInitiateArg_argumentExtension *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ExtensionSeq(enc, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CTInitiateArg_argumentExtension(ASN1decoding_t dec, CTInitiateArg_argumentExtension *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ExtensionSeq(dec, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CTInitiateArg_argumentExtension(CTInitiateArg_argumentExtension *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ExtensionSeq(&(val)->u.extensionSeq);
        break;
    case 2:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardData);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_IntResult_extension(ASN1encoding_t enc, IntResult_extension *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ExtensionSeq(enc, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_IntResult_extension(ASN1decoding_t dec, IntResult_extension *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ExtensionSeq(dec, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_IntResult_extension(IntResult_extension *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ExtensionSeq(&(val)->u.extensionSeq);
        break;
    case 2:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardData);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_DivertingLegInformation4Argument_extension(ASN1encoding_t enc, DivertingLegInformation4Argument_extension *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ExtensionSeq(enc, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_DivertingLegInformation4Argument_extension(ASN1decoding_t dec, DivertingLegInformation4Argument_extension *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ExtensionSeq(dec, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_DivertingLegInformation4Argument_extension(DivertingLegInformation4Argument_extension *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ExtensionSeq(&(val)->u.extensionSeq);
        break;
    case 2:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardData);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_DivertingLegInformation3Argument_extension(ASN1encoding_t enc, DivertingLegInformation3Argument_extension *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ExtensionSeq(enc, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_DivertingLegInformation3Argument_extension(ASN1decoding_t dec, DivertingLegInformation3Argument_extension *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ExtensionSeq(dec, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_DivertingLegInformation3Argument_extension(DivertingLegInformation3Argument_extension *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ExtensionSeq(&(val)->u.extensionSeq);
        break;
    case 2:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardData);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_DivertingLegInformation2Argument_extension(ASN1encoding_t enc, DivertingLegInformation2Argument_extension *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ExtensionSeq(enc, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_DivertingLegInformation2Argument_extension(ASN1decoding_t dec, DivertingLegInformation2Argument_extension *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ExtensionSeq(dec, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_DivertingLegInformation2Argument_extension(DivertingLegInformation2Argument_extension *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ExtensionSeq(&(val)->u.extensionSeq);
        break;
    case 2:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardData);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_DivertingLegInformation1Argument_extension(ASN1encoding_t enc, DivertingLegInformation1Argument_extension *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ExtensionSeq(enc, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_DivertingLegInformation1Argument_extension(ASN1decoding_t dec, DivertingLegInformation1Argument_extension *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ExtensionSeq(dec, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_DivertingLegInformation1Argument_extension(DivertingLegInformation1Argument_extension *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ExtensionSeq(&(val)->u.extensionSeq);
        break;
    case 2:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardData);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_CallReroutingArgument_extension(ASN1encoding_t enc, CallReroutingArgument_extension *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ExtensionSeq(enc, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CallReroutingArgument_extension(ASN1decoding_t dec, CallReroutingArgument_extension *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ExtensionSeq(dec, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CallReroutingArgument_extension(CallReroutingArgument_extension *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ExtensionSeq(&(val)->u.extensionSeq);
        break;
    case 2:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardData);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_CheckRestrictionArgument_extension(ASN1encoding_t enc, CheckRestrictionArgument_extension *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ExtensionSeq(enc, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CheckRestrictionArgument_extension(ASN1decoding_t dec, CheckRestrictionArgument_extension *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ExtensionSeq(dec, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CheckRestrictionArgument_extension(CheckRestrictionArgument_extension *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ExtensionSeq(&(val)->u.extensionSeq);
        break;
    case 2:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardData);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_InterrogateDiversionQArgument_extension(ASN1encoding_t enc, InterrogateDiversionQArgument_extension *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ExtensionSeq(enc, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_InterrogateDiversionQArgument_extension(ASN1decoding_t dec, InterrogateDiversionQArgument_extension *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ExtensionSeq(dec, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_InterrogateDiversionQArgument_extension(InterrogateDiversionQArgument_extension *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ExtensionSeq(&(val)->u.extensionSeq);
        break;
    case 2:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardData);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_DeactivateDiversionQArgument_extension(ASN1encoding_t enc, DeactivateDiversionQArgument_extension *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ExtensionSeq(enc, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_DeactivateDiversionQArgument_extension(ASN1decoding_t dec, DeactivateDiversionQArgument_extension *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ExtensionSeq(dec, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_DeactivateDiversionQArgument_extension(DeactivateDiversionQArgument_extension *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ExtensionSeq(&(val)->u.extensionSeq);
        break;
    case 2:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardData);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_ActivateDiversionQArgument_extension(ASN1encoding_t enc, ActivateDiversionQArgument_extension *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ExtensionSeq(enc, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_ActivateDiversionQArgument_extension(ASN1decoding_t dec, ActivateDiversionQArgument_extension *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ExtensionSeq(dec, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_ActivateDiversionQArgument_extension(ActivateDiversionQArgument_extension *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ExtensionSeq(&(val)->u.extensionSeq);
        break;
    case 2:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardData);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_H4503ROS(ASN1encoding_t enc, H4503ROS *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 2))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_Invoke(enc, &(val)->u.invoke))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_ReturnResult(enc, &(val)->u.returnResult))
        return 0;
    break;
    case 3:
    if (!ASN1Enc_ReturnError(enc, &(val)->u.returnError))
        return 0;
    break;
    case 4:
    if (!ASN1Enc_Reject(enc, &(val)->u.reject))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_H4503ROS(ASN1decoding_t dec, H4503ROS *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 2))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_Invoke(dec, &(val)->u.invoke))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_ReturnResult(dec, &(val)->u.returnResult))
        return 0;
    break;
    case 3:
    if (!ASN1Dec_ReturnError(dec, &(val)->u.returnError))
        return 0;
    break;
    case 4:
    if (!ASN1Dec_Reject(dec, &(val)->u.reject))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_H4503ROS(H4503ROS *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_Invoke(&(val)->u.invoke);
        break;
    case 2:
        ASN1Free_ReturnResult(&(val)->u.returnResult);
        break;
    case 3:
        ASN1Free_ReturnError(&(val)->u.returnError);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_DummyArg(ASN1encoding_t enc, DummyArg *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ExtensionSeq(enc, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_DummyArg(ASN1decoding_t dec, DummyArg *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ExtensionSeq(dec, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_DummyArg(DummyArg *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ExtensionSeq(&(val)->u.extensionSeq);
        break;
    case 2:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardData);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_DummyRes(ASN1encoding_t enc, DummyRes *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ExtensionSeq(enc, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_DummyRes(ASN1decoding_t dec, DummyRes *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ExtensionSeq(dec, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_DummyRes(DummyRes *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ExtensionSeq(&(val)->u.extensionSeq);
        break;
    case 2:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardData);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_SubaddressTransferArg(ASN1encoding_t enc, SubaddressTransferArg *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 1, (val)->o))
    return 0;
    if (!ASN1Enc_PartySubaddress(enc, &(val)->redirectionSubaddress))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_SubaddressTransferArg_argumentExtension(enc, &(val)->argumentExtension))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_SubaddressTransferArg(ASN1decoding_t dec, SubaddressTransferArg *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 1, (val)->o))
    return 0;
    if (!ASN1Dec_PartySubaddress(dec, &(val)->redirectionSubaddress))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_SubaddressTransferArg_argumentExtension(dec, &(val)->argumentExtension))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_SubaddressTransferArg(SubaddressTransferArg *val)
{
    if (val) {
    ASN1Free_PartySubaddress(&(val)->redirectionSubaddress);
    if ((val)->o[0] & 0x80) {
        ASN1Free_SubaddressTransferArg_argumentExtension(&(val)->argumentExtension);
    }
    }
}

static int ASN1CALL ASN1Enc_MixedExtension(ASN1encoding_t enc, MixedExtension *val)
{
    if (!ASN1PEREncSimpleChoice(enc, (val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_ExtensionSeq(enc, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Enc_H225NonStandardParameter(enc, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_MixedExtension(ASN1decoding_t dec, MixedExtension *val)
{
    if (!ASN1PERDecSimpleChoice(dec, &(val)->choice, 1))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_ExtensionSeq(dec, &(val)->u.extensionSeq))
        return 0;
    break;
    case 2:
    if (!ASN1Dec_H225NonStandardParameter(dec, &(val)->u.nonStandardData))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_MixedExtension(MixedExtension *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_ExtensionSeq(&(val)->u.extensionSeq);
        break;
    case 2:
        ASN1Free_H225NonStandardParameter(&(val)->u.nonStandardData);
        break;
    }
    }
}

static ASN1stringtableentry_t PartyNumber_dataPartyNumber_StringTableEntries[] = {
    { 35, 35, 0 }, { 42, 42, 1 }, { 44, 44, 2 }, 
    { 48, 57, 3 }, 
};

static ASN1stringtable_t PartyNumber_dataPartyNumber_StringTable = {
    4, PartyNumber_dataPartyNumber_StringTableEntries
};

static ASN1stringtableentry_t PartyNumber_telexPartyNumber_StringTableEntries[] = {
    { 35, 35, 0 }, { 42, 42, 1 }, { 44, 44, 2 }, 
    { 48, 57, 3 }, 
};

static ASN1stringtable_t PartyNumber_telexPartyNumber_StringTable = {
    4, PartyNumber_telexPartyNumber_StringTableEntries
};

static ASN1stringtableentry_t PartyNumber_nationalStandardPartyNumber_StringTableEntries[] = {
    { 35, 35, 0 }, { 42, 42, 1 }, { 44, 44, 2 }, 
    { 48, 57, 3 }, 
};

static ASN1stringtable_t PartyNumber_nationalStandardPartyNumber_StringTable = {
    4, PartyNumber_nationalStandardPartyNumber_StringTableEntries
};

static int ASN1CALL ASN1Enc_PartyNumber(ASN1encoding_t enc, PartyNumber *val)
{
    ASN1uint32_t t;
    if (!ASN1PEREncSimpleChoiceEx(enc, (val)->choice, 3))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Enc_PublicPartyNumber(enc, &(val)->u.publicNumber))
        return 0;
    break;
    case 2:
    t = lstrlenA((val)->u.dataPartyNumber);
    if (!ASN1PEREncBitVal(enc, 7, t - 1))
        return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncTableCharString(enc, t, (val)->u.dataPartyNumber, 4, &PartyNumber_dataPartyNumber_StringTable))
        return 0;
    break;
    case 3:
    t = lstrlenA((val)->u.telexPartyNumber);
    if (!ASN1PEREncBitVal(enc, 7, t - 1))
        return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncTableCharString(enc, t, (val)->u.telexPartyNumber, 4, &PartyNumber_telexPartyNumber_StringTable))
        return 0;
    break;
    case 4:
    if (!ASN1Enc_PrivatePartyNumber(enc, &(val)->u.privateNumber))
        return 0;
    break;
    case 5:
    t = lstrlenA((val)->u.nationalStandardPartyNumber);
    if (!ASN1PEREncBitVal(enc, 7, t - 1))
        return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncTableCharString(enc, t, (val)->u.nationalStandardPartyNumber, 4, &PartyNumber_nationalStandardPartyNumber_StringTable))
        return 0;
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_PartyNumber(ASN1decoding_t dec, PartyNumber *val)
{
    ASN1uint32_t l;
    if (!ASN1PERDecSimpleChoiceEx(dec, &(val)->choice, 3))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1Dec_PublicPartyNumber(dec, &(val)->u.publicNumber))
        return 0;
    break;
    case 2:
    if (!ASN1PERDecU32Val(dec, 7, &l))
        return 0;
    l += 1;
    ASN1PERDecAlignment(dec);

    //NikhilB: Fix for the overflow bug 03/02/27
    if ( l >= sizeof((val)->u.dataPartyNumber) ) {
        ASN1DecSetError(dec, ASN1_ERR_LARGE);
        return 0; 
    }

    if (!ASN1PERDecZeroTableCharStringNoAlloc(dec, l, (val)->u.dataPartyNumber, 4, &PartyNumber_dataPartyNumber_StringTable))
        return 0;
    break;
    case 3:
    if (!ASN1PERDecU32Val(dec, 7, &l))
        return 0;
    l += 1;
    ASN1PERDecAlignment(dec);

    //NikhilB: Fix for the overflow bug 03/02/27
    if ( l >= sizeof((val)->u.telexPartyNumber) ) {
        ASN1DecSetError(dec, ASN1_ERR_LARGE);
        return 0; 
    }

    if (!ASN1PERDecZeroTableCharStringNoAlloc(dec, l, (val)->u.telexPartyNumber, 4, &PartyNumber_telexPartyNumber_StringTable))
        return 0;
    break;
    case 4:
    if (!ASN1Dec_PrivatePartyNumber(dec, &(val)->u.privateNumber))
        return 0;
    break;
    case 5:
    if (!ASN1PERDecU32Val(dec, 7, &l))
        return 0;
    l += 1;
    ASN1PERDecAlignment(dec);

    //NikhilB: Fix for the overflow bug 03/02/27
    if ( l >= sizeof((val)->u.nationalStandardPartyNumber) ) {
        ASN1DecSetError(dec, ASN1_ERR_LARGE);
        return 0; 
    }

    if (!ASN1PERDecZeroTableCharStringNoAlloc(dec, l, (val)->u.nationalStandardPartyNumber, 4, &PartyNumber_nationalStandardPartyNumber_StringTable))
        return 0;
    break;
    case 0:
    /* extension case */
    if (!ASN1PERDecSkipFragmented(dec, 8))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_PartyNumber(PartyNumber *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        ASN1Free_PublicPartyNumber(&(val)->u.publicNumber);
        break;
    case 2:
        break;
    case 3:
        break;
    case 4:
        ASN1Free_PrivatePartyNumber(&(val)->u.privateNumber);
        break;
    case 5:
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_CpickupNotifyArg_extensionArg(ASN1encoding_t enc, PCpickupNotifyArg_extensionArg *val)
{
    return ASN1PEREncSeqOf_NoSize(enc, (ASN1iterator_t **) val, (ASN1iterator_encfn) ASN1Enc_CpickupNotifyArg_extensionArg_ElmFn);
}

static int ASN1CALL ASN1Enc_CpickupNotifyArg_extensionArg_ElmFn(ASN1encoding_t enc, PCpickupNotifyArg_extensionArg val)
{
    if (!ASN1Enc_MixedExtension(enc, &val->value))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_CpickupNotifyArg_extensionArg(ASN1decoding_t dec, PCpickupNotifyArg_extensionArg *val)
{
    return ASN1PERDecSeqOf_NoSize(dec, (ASN1iterator_t **) val, (ASN1iterator_decfn) ASN1Dec_CpickupNotifyArg_extensionArg_ElmFn, sizeof(**val));
}

static int ASN1CALL ASN1Dec_CpickupNotifyArg_extensionArg_ElmFn(ASN1decoding_t dec, PCpickupNotifyArg_extensionArg val)
{
    if (!ASN1Dec_MixedExtension(dec, &val->value))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_CpickupNotifyArg_extensionArg(PCpickupNotifyArg_extensionArg *val)
{
    if (val) {
    ASN1PERFreeSeqOf((ASN1iterator_t **) val, (ASN1iterator_freefn) ASN1Free_CpickupNotifyArg_extensionArg_ElmFn);
    }
}

static void ASN1CALL ASN1Free_CpickupNotifyArg_extensionArg_ElmFn(PCpickupNotifyArg_extensionArg val)
{
    if (val) {
    ASN1Free_MixedExtension(&val->value);
    }
}

static int ASN1CALL ASN1Enc_CpNotifyArg_extensionArg(ASN1encoding_t enc, PCpNotifyArg_extensionArg *val)
{
    return ASN1PEREncSeqOf_NoSize(enc, (ASN1iterator_t **) val, (ASN1iterator_encfn) ASN1Enc_CpNotifyArg_extensionArg_ElmFn);
}

static int ASN1CALL ASN1Enc_CpNotifyArg_extensionArg_ElmFn(ASN1encoding_t enc, PCpNotifyArg_extensionArg val)
{
    if (!ASN1Enc_MixedExtension(enc, &val->value))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_CpNotifyArg_extensionArg(ASN1decoding_t dec, PCpNotifyArg_extensionArg *val)
{
    return ASN1PERDecSeqOf_NoSize(dec, (ASN1iterator_t **) val, (ASN1iterator_decfn) ASN1Dec_CpNotifyArg_extensionArg_ElmFn, sizeof(**val));
}

static int ASN1CALL ASN1Dec_CpNotifyArg_extensionArg_ElmFn(ASN1decoding_t dec, PCpNotifyArg_extensionArg val)
{
    if (!ASN1Dec_MixedExtension(dec, &val->value))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_CpNotifyArg_extensionArg(PCpNotifyArg_extensionArg *val)
{
    if (val) {
    ASN1PERFreeSeqOf((ASN1iterator_t **) val, (ASN1iterator_freefn) ASN1Free_CpNotifyArg_extensionArg_ElmFn);
    }
}

static void ASN1CALL ASN1Free_CpNotifyArg_extensionArg_ElmFn(PCpNotifyArg_extensionArg val)
{
    if (val) {
    ASN1Free_MixedExtension(&val->value);
    }
}

static int ASN1CALL ASN1Enc_PickExeRes_extensionRes(ASN1encoding_t enc, PPickExeRes_extensionRes *val)
{
    return ASN1PEREncSeqOf_NoSize(enc, (ASN1iterator_t **) val, (ASN1iterator_encfn) ASN1Enc_PickExeRes_extensionRes_ElmFn);
}

static int ASN1CALL ASN1Enc_PickExeRes_extensionRes_ElmFn(ASN1encoding_t enc, PPickExeRes_extensionRes val)
{
    if (!ASN1Enc_MixedExtension(enc, &val->value))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_PickExeRes_extensionRes(ASN1decoding_t dec, PPickExeRes_extensionRes *val)
{
    return ASN1PERDecSeqOf_NoSize(dec, (ASN1iterator_t **) val, (ASN1iterator_decfn) ASN1Dec_PickExeRes_extensionRes_ElmFn, sizeof(**val));
}

static int ASN1CALL ASN1Dec_PickExeRes_extensionRes_ElmFn(ASN1decoding_t dec, PPickExeRes_extensionRes val)
{
    if (!ASN1Dec_MixedExtension(dec, &val->value))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_PickExeRes_extensionRes(PPickExeRes_extensionRes *val)
{
    if (val) {
    ASN1PERFreeSeqOf((ASN1iterator_t **) val, (ASN1iterator_freefn) ASN1Free_PickExeRes_extensionRes_ElmFn);
    }
}

static void ASN1CALL ASN1Free_PickExeRes_extensionRes_ElmFn(PPickExeRes_extensionRes val)
{
    if (val) {
    ASN1Free_MixedExtension(&val->value);
    }
}

static int ASN1CALL ASN1Enc_PickExeArg_extensionArg(ASN1encoding_t enc, PPickExeArg_extensionArg *val)
{
    return ASN1PEREncSeqOf_NoSize(enc, (ASN1iterator_t **) val, (ASN1iterator_encfn) ASN1Enc_PickExeArg_extensionArg_ElmFn);
}

static int ASN1CALL ASN1Enc_PickExeArg_extensionArg_ElmFn(ASN1encoding_t enc, PPickExeArg_extensionArg val)
{
    if (!ASN1Enc_MixedExtension(enc, &val->value))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_PickExeArg_extensionArg(ASN1decoding_t dec, PPickExeArg_extensionArg *val)
{
    return ASN1PERDecSeqOf_NoSize(dec, (ASN1iterator_t **) val, (ASN1iterator_decfn) ASN1Dec_PickExeArg_extensionArg_ElmFn, sizeof(**val));
}

static int ASN1CALL ASN1Dec_PickExeArg_extensionArg_ElmFn(ASN1decoding_t dec, PPickExeArg_extensionArg val)
{
    if (!ASN1Dec_MixedExtension(dec, &val->value))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_PickExeArg_extensionArg(PPickExeArg_extensionArg *val)
{
    if (val) {
    ASN1PERFreeSeqOf((ASN1iterator_t **) val, (ASN1iterator_freefn) ASN1Free_PickExeArg_extensionArg_ElmFn);
    }
}

static void ASN1CALL ASN1Free_PickExeArg_extensionArg_ElmFn(PPickExeArg_extensionArg val)
{
    if (val) {
    ASN1Free_MixedExtension(&val->value);
    }
}

static int ASN1CALL ASN1Enc_PickupRes_extensionRes(ASN1encoding_t enc, PPickupRes_extensionRes *val)
{
    return ASN1PEREncSeqOf_NoSize(enc, (ASN1iterator_t **) val, (ASN1iterator_encfn) ASN1Enc_PickupRes_extensionRes_ElmFn);
}

static int ASN1CALL ASN1Enc_PickupRes_extensionRes_ElmFn(ASN1encoding_t enc, PPickupRes_extensionRes val)
{
    if (!ASN1Enc_MixedExtension(enc, &val->value))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_PickupRes_extensionRes(ASN1decoding_t dec, PPickupRes_extensionRes *val)
{
    return ASN1PERDecSeqOf_NoSize(dec, (ASN1iterator_t **) val, (ASN1iterator_decfn) ASN1Dec_PickupRes_extensionRes_ElmFn, sizeof(**val));
}

static int ASN1CALL ASN1Dec_PickupRes_extensionRes_ElmFn(ASN1decoding_t dec, PPickupRes_extensionRes val)
{
    if (!ASN1Dec_MixedExtension(dec, &val->value))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_PickupRes_extensionRes(PPickupRes_extensionRes *val)
{
    if (val) {
    ASN1PERFreeSeqOf((ASN1iterator_t **) val, (ASN1iterator_freefn) ASN1Free_PickupRes_extensionRes_ElmFn);
    }
}

static void ASN1CALL ASN1Free_PickupRes_extensionRes_ElmFn(PPickupRes_extensionRes val)
{
    if (val) {
    ASN1Free_MixedExtension(&val->value);
    }
}

static int ASN1CALL ASN1Enc_PickupArg_extensionArg(ASN1encoding_t enc, PPickupArg_extensionArg *val)
{
    return ASN1PEREncSeqOf_NoSize(enc, (ASN1iterator_t **) val, (ASN1iterator_encfn) ASN1Enc_PickupArg_extensionArg_ElmFn);
}

static int ASN1CALL ASN1Enc_PickupArg_extensionArg_ElmFn(ASN1encoding_t enc, PPickupArg_extensionArg val)
{
    if (!ASN1Enc_MixedExtension(enc, &val->value))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_PickupArg_extensionArg(ASN1decoding_t dec, PPickupArg_extensionArg *val)
{
    return ASN1PERDecSeqOf_NoSize(dec, (ASN1iterator_t **) val, (ASN1iterator_decfn) ASN1Dec_PickupArg_extensionArg_ElmFn, sizeof(**val));
}

static int ASN1CALL ASN1Dec_PickupArg_extensionArg_ElmFn(ASN1decoding_t dec, PPickupArg_extensionArg val)
{
    if (!ASN1Dec_MixedExtension(dec, &val->value))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_PickupArg_extensionArg(PPickupArg_extensionArg *val)
{
    if (val) {
    ASN1PERFreeSeqOf((ASN1iterator_t **) val, (ASN1iterator_freefn) ASN1Free_PickupArg_extensionArg_ElmFn);
    }
}

static void ASN1CALL ASN1Free_PickupArg_extensionArg_ElmFn(PPickupArg_extensionArg val)
{
    if (val) {
    ASN1Free_MixedExtension(&val->value);
    }
}

static int ASN1CALL ASN1Enc_PickrequRes_extensionRes(ASN1encoding_t enc, PPickrequRes_extensionRes *val)
{
    return ASN1PEREncSeqOf_NoSize(enc, (ASN1iterator_t **) val, (ASN1iterator_encfn) ASN1Enc_PickrequRes_extensionRes_ElmFn);
}

static int ASN1CALL ASN1Enc_PickrequRes_extensionRes_ElmFn(ASN1encoding_t enc, PPickrequRes_extensionRes val)
{
    if (!ASN1Enc_MixedExtension(enc, &val->value))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_PickrequRes_extensionRes(ASN1decoding_t dec, PPickrequRes_extensionRes *val)
{
    return ASN1PERDecSeqOf_NoSize(dec, (ASN1iterator_t **) val, (ASN1iterator_decfn) ASN1Dec_PickrequRes_extensionRes_ElmFn, sizeof(**val));
}

static int ASN1CALL ASN1Dec_PickrequRes_extensionRes_ElmFn(ASN1decoding_t dec, PPickrequRes_extensionRes val)
{
    if (!ASN1Dec_MixedExtension(dec, &val->value))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_PickrequRes_extensionRes(PPickrequRes_extensionRes *val)
{
    if (val) {
    ASN1PERFreeSeqOf((ASN1iterator_t **) val, (ASN1iterator_freefn) ASN1Free_PickrequRes_extensionRes_ElmFn);
    }
}

static void ASN1CALL ASN1Free_PickrequRes_extensionRes_ElmFn(PPickrequRes_extensionRes val)
{
    if (val) {
    ASN1Free_MixedExtension(&val->value);
    }
}

static int ASN1CALL ASN1Enc_PickrequArg_extensionArg(ASN1encoding_t enc, PPickrequArg_extensionArg *val)
{
    return ASN1PEREncSeqOf_NoSize(enc, (ASN1iterator_t **) val, (ASN1iterator_encfn) ASN1Enc_PickrequArg_extensionArg_ElmFn);
}

static int ASN1CALL ASN1Enc_PickrequArg_extensionArg_ElmFn(ASN1encoding_t enc, PPickrequArg_extensionArg val)
{
    if (!ASN1Enc_MixedExtension(enc, &val->value))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_PickrequArg_extensionArg(ASN1decoding_t dec, PPickrequArg_extensionArg *val)
{
    return ASN1PERDecSeqOf_NoSize(dec, (ASN1iterator_t **) val, (ASN1iterator_decfn) ASN1Dec_PickrequArg_extensionArg_ElmFn, sizeof(**val));
}

static int ASN1CALL ASN1Dec_PickrequArg_extensionArg_ElmFn(ASN1decoding_t dec, PPickrequArg_extensionArg val)
{
    if (!ASN1Dec_MixedExtension(dec, &val->value))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_PickrequArg_extensionArg(PPickrequArg_extensionArg *val)
{
    if (val) {
    ASN1PERFreeSeqOf((ASN1iterator_t **) val, (ASN1iterator_freefn) ASN1Free_PickrequArg_extensionArg_ElmFn);
    }
}

static void ASN1CALL ASN1Free_PickrequArg_extensionArg_ElmFn(PPickrequArg_extensionArg val)
{
    if (val) {
    ASN1Free_MixedExtension(&val->value);
    }
}

static int ASN1CALL ASN1Enc_GroupIndicationOffRes_extensionRes(ASN1encoding_t enc, PGroupIndicationOffRes_extensionRes *val)
{
    return ASN1PEREncSeqOf_NoSize(enc, (ASN1iterator_t **) val, (ASN1iterator_encfn) ASN1Enc_GroupIndicationOffRes_extensionRes_ElmFn);
}

static int ASN1CALL ASN1Enc_GroupIndicationOffRes_extensionRes_ElmFn(ASN1encoding_t enc, PGroupIndicationOffRes_extensionRes val)
{
    if (!ASN1Enc_MixedExtension(enc, &val->value))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_GroupIndicationOffRes_extensionRes(ASN1decoding_t dec, PGroupIndicationOffRes_extensionRes *val)
{
    return ASN1PERDecSeqOf_NoSize(dec, (ASN1iterator_t **) val, (ASN1iterator_decfn) ASN1Dec_GroupIndicationOffRes_extensionRes_ElmFn, sizeof(**val));
}

static int ASN1CALL ASN1Dec_GroupIndicationOffRes_extensionRes_ElmFn(ASN1decoding_t dec, PGroupIndicationOffRes_extensionRes val)
{
    if (!ASN1Dec_MixedExtension(dec, &val->value))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_GroupIndicationOffRes_extensionRes(PGroupIndicationOffRes_extensionRes *val)
{
    if (val) {
    ASN1PERFreeSeqOf((ASN1iterator_t **) val, (ASN1iterator_freefn) ASN1Free_GroupIndicationOffRes_extensionRes_ElmFn);
    }
}

static void ASN1CALL ASN1Free_GroupIndicationOffRes_extensionRes_ElmFn(PGroupIndicationOffRes_extensionRes val)
{
    if (val) {
    ASN1Free_MixedExtension(&val->value);
    }
}

static int ASN1CALL ASN1Enc_GroupIndicationOffArg_extensionArg(ASN1encoding_t enc, PGroupIndicationOffArg_extensionArg *val)
{
    return ASN1PEREncSeqOf_NoSize(enc, (ASN1iterator_t **) val, (ASN1iterator_encfn) ASN1Enc_GroupIndicationOffArg_extensionArg_ElmFn);
}

static int ASN1CALL ASN1Enc_GroupIndicationOffArg_extensionArg_ElmFn(ASN1encoding_t enc, PGroupIndicationOffArg_extensionArg val)
{
    if (!ASN1Enc_MixedExtension(enc, &val->value))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_GroupIndicationOffArg_extensionArg(ASN1decoding_t dec, PGroupIndicationOffArg_extensionArg *val)
{
    return ASN1PERDecSeqOf_NoSize(dec, (ASN1iterator_t **) val, (ASN1iterator_decfn) ASN1Dec_GroupIndicationOffArg_extensionArg_ElmFn, sizeof(**val));
}

static int ASN1CALL ASN1Dec_GroupIndicationOffArg_extensionArg_ElmFn(ASN1decoding_t dec, PGroupIndicationOffArg_extensionArg val)
{
    if (!ASN1Dec_MixedExtension(dec, &val->value))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_GroupIndicationOffArg_extensionArg(PGroupIndicationOffArg_extensionArg *val)
{
    if (val) {
    ASN1PERFreeSeqOf((ASN1iterator_t **) val, (ASN1iterator_freefn) ASN1Free_GroupIndicationOffArg_extensionArg_ElmFn);
    }
}

static void ASN1CALL ASN1Free_GroupIndicationOffArg_extensionArg_ElmFn(PGroupIndicationOffArg_extensionArg val)
{
    if (val) {
    ASN1Free_MixedExtension(&val->value);
    }
}

static int ASN1CALL ASN1Enc_GroupIndicationOnRes_extensionRes(ASN1encoding_t enc, PGroupIndicationOnRes_extensionRes *val)
{
    return ASN1PEREncSeqOf_NoSize(enc, (ASN1iterator_t **) val, (ASN1iterator_encfn) ASN1Enc_GroupIndicationOnRes_extensionRes_ElmFn);
}

static int ASN1CALL ASN1Enc_GroupIndicationOnRes_extensionRes_ElmFn(ASN1encoding_t enc, PGroupIndicationOnRes_extensionRes val)
{
    if (!ASN1Enc_MixedExtension(enc, &val->value))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_GroupIndicationOnRes_extensionRes(ASN1decoding_t dec, PGroupIndicationOnRes_extensionRes *val)
{
    return ASN1PERDecSeqOf_NoSize(dec, (ASN1iterator_t **) val, (ASN1iterator_decfn) ASN1Dec_GroupIndicationOnRes_extensionRes_ElmFn, sizeof(**val));
}

static int ASN1CALL ASN1Dec_GroupIndicationOnRes_extensionRes_ElmFn(ASN1decoding_t dec, PGroupIndicationOnRes_extensionRes val)
{
    if (!ASN1Dec_MixedExtension(dec, &val->value))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_GroupIndicationOnRes_extensionRes(PGroupIndicationOnRes_extensionRes *val)
{
    if (val) {
    ASN1PERFreeSeqOf((ASN1iterator_t **) val, (ASN1iterator_freefn) ASN1Free_GroupIndicationOnRes_extensionRes_ElmFn);
    }
}

static void ASN1CALL ASN1Free_GroupIndicationOnRes_extensionRes_ElmFn(PGroupIndicationOnRes_extensionRes val)
{
    if (val) {
    ASN1Free_MixedExtension(&val->value);
    }
}

static int ASN1CALL ASN1Enc_GroupIndicationOnArg_extensionArg(ASN1encoding_t enc, PGroupIndicationOnArg_extensionArg *val)
{
    return ASN1PEREncSeqOf_NoSize(enc, (ASN1iterator_t **) val, (ASN1iterator_encfn) ASN1Enc_GroupIndicationOnArg_extensionArg_ElmFn);
}

static int ASN1CALL ASN1Enc_GroupIndicationOnArg_extensionArg_ElmFn(ASN1encoding_t enc, PGroupIndicationOnArg_extensionArg val)
{
    if (!ASN1Enc_MixedExtension(enc, &val->value))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_GroupIndicationOnArg_extensionArg(ASN1decoding_t dec, PGroupIndicationOnArg_extensionArg *val)
{
    return ASN1PERDecSeqOf_NoSize(dec, (ASN1iterator_t **) val, (ASN1iterator_decfn) ASN1Dec_GroupIndicationOnArg_extensionArg_ElmFn, sizeof(**val));
}

static int ASN1CALL ASN1Dec_GroupIndicationOnArg_extensionArg_ElmFn(ASN1decoding_t dec, PGroupIndicationOnArg_extensionArg val)
{
    if (!ASN1Dec_MixedExtension(dec, &val->value))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_GroupIndicationOnArg_extensionArg(PGroupIndicationOnArg_extensionArg *val)
{
    if (val) {
    ASN1PERFreeSeqOf((ASN1iterator_t **) val, (ASN1iterator_freefn) ASN1Free_GroupIndicationOnArg_extensionArg_ElmFn);
    }
}

static void ASN1CALL ASN1Free_GroupIndicationOnArg_extensionArg_ElmFn(PGroupIndicationOnArg_extensionArg val)
{
    if (val) {
    ASN1Free_MixedExtension(&val->value);
    }
}

static int ASN1CALL ASN1Enc_CpSetupRes_extensionRes(ASN1encoding_t enc, PCpSetupRes_extensionRes *val)
{
    return ASN1PEREncSeqOf_NoSize(enc, (ASN1iterator_t **) val, (ASN1iterator_encfn) ASN1Enc_CpSetupRes_extensionRes_ElmFn);
}

static int ASN1CALL ASN1Enc_CpSetupRes_extensionRes_ElmFn(ASN1encoding_t enc, PCpSetupRes_extensionRes val)
{
    if (!ASN1Enc_MixedExtension(enc, &val->value))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_CpSetupRes_extensionRes(ASN1decoding_t dec, PCpSetupRes_extensionRes *val)
{
    return ASN1PERDecSeqOf_NoSize(dec, (ASN1iterator_t **) val, (ASN1iterator_decfn) ASN1Dec_CpSetupRes_extensionRes_ElmFn, sizeof(**val));
}

static int ASN1CALL ASN1Dec_CpSetupRes_extensionRes_ElmFn(ASN1decoding_t dec, PCpSetupRes_extensionRes val)
{
    if (!ASN1Dec_MixedExtension(dec, &val->value))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_CpSetupRes_extensionRes(PCpSetupRes_extensionRes *val)
{
    if (val) {
    ASN1PERFreeSeqOf((ASN1iterator_t **) val, (ASN1iterator_freefn) ASN1Free_CpSetupRes_extensionRes_ElmFn);
    }
}

static void ASN1CALL ASN1Free_CpSetupRes_extensionRes_ElmFn(PCpSetupRes_extensionRes val)
{
    if (val) {
    ASN1Free_MixedExtension(&val->value);
    }
}

static int ASN1CALL ASN1Enc_CpSetupArg_extensionArg(ASN1encoding_t enc, PCpSetupArg_extensionArg *val)
{
    return ASN1PEREncSeqOf_NoSize(enc, (ASN1iterator_t **) val, (ASN1iterator_encfn) ASN1Enc_CpSetupArg_extensionArg_ElmFn);
}

static int ASN1CALL ASN1Enc_CpSetupArg_extensionArg_ElmFn(ASN1encoding_t enc, PCpSetupArg_extensionArg val)
{
    if (!ASN1Enc_MixedExtension(enc, &val->value))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_CpSetupArg_extensionArg(ASN1decoding_t dec, PCpSetupArg_extensionArg *val)
{
    return ASN1PERDecSeqOf_NoSize(dec, (ASN1iterator_t **) val, (ASN1iterator_decfn) ASN1Dec_CpSetupArg_extensionArg_ElmFn, sizeof(**val));
}

static int ASN1CALL ASN1Dec_CpSetupArg_extensionArg_ElmFn(ASN1decoding_t dec, PCpSetupArg_extensionArg val)
{
    if (!ASN1Dec_MixedExtension(dec, &val->value))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_CpSetupArg_extensionArg(PCpSetupArg_extensionArg *val)
{
    if (val) {
    ASN1PERFreeSeqOf((ASN1iterator_t **) val, (ASN1iterator_freefn) ASN1Free_CpSetupArg_extensionArg_ElmFn);
    }
}

static void ASN1CALL ASN1Free_CpSetupArg_extensionArg_ElmFn(PCpSetupArg_extensionArg val)
{
    if (val) {
    ASN1Free_MixedExtension(&val->value);
    }
}

static int ASN1CALL ASN1Enc_CpRequestRes_extensionRes(ASN1encoding_t enc, PCpRequestRes_extensionRes *val)
{
    return ASN1PEREncSeqOf_NoSize(enc, (ASN1iterator_t **) val, (ASN1iterator_encfn) ASN1Enc_CpRequestRes_extensionRes_ElmFn);
}

static int ASN1CALL ASN1Enc_CpRequestRes_extensionRes_ElmFn(ASN1encoding_t enc, PCpRequestRes_extensionRes val)
{
    if (!ASN1Enc_MixedExtension(enc, &val->value))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_CpRequestRes_extensionRes(ASN1decoding_t dec, PCpRequestRes_extensionRes *val)
{
    return ASN1PERDecSeqOf_NoSize(dec, (ASN1iterator_t **) val, (ASN1iterator_decfn) ASN1Dec_CpRequestRes_extensionRes_ElmFn, sizeof(**val));
}

static int ASN1CALL ASN1Dec_CpRequestRes_extensionRes_ElmFn(ASN1decoding_t dec, PCpRequestRes_extensionRes val)
{
    if (!ASN1Dec_MixedExtension(dec, &val->value))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_CpRequestRes_extensionRes(PCpRequestRes_extensionRes *val)
{
    if (val) {
    ASN1PERFreeSeqOf((ASN1iterator_t **) val, (ASN1iterator_freefn) ASN1Free_CpRequestRes_extensionRes_ElmFn);
    }
}

static void ASN1CALL ASN1Free_CpRequestRes_extensionRes_ElmFn(PCpRequestRes_extensionRes val)
{
    if (val) {
    ASN1Free_MixedExtension(&val->value);
    }
}

static int ASN1CALL ASN1Enc_CpRequestArg_extensionArg(ASN1encoding_t enc, PCpRequestArg_extensionArg *val)
{
    return ASN1PEREncSeqOf_NoSize(enc, (ASN1iterator_t **) val, (ASN1iterator_encfn) ASN1Enc_CpRequestArg_extensionArg_ElmFn);
}

static int ASN1CALL ASN1Enc_CpRequestArg_extensionArg_ElmFn(ASN1encoding_t enc, PCpRequestArg_extensionArg val)
{
    if (!ASN1Enc_MixedExtension(enc, &val->value))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_CpRequestArg_extensionArg(ASN1decoding_t dec, PCpRequestArg_extensionArg *val)
{
    return ASN1PERDecSeqOf_NoSize(dec, (ASN1iterator_t **) val, (ASN1iterator_decfn) ASN1Dec_CpRequestArg_extensionArg_ElmFn, sizeof(**val));
}

static int ASN1CALL ASN1Dec_CpRequestArg_extensionArg_ElmFn(ASN1decoding_t dec, PCpRequestArg_extensionArg val)
{
    if (!ASN1Dec_MixedExtension(dec, &val->value))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_CpRequestArg_extensionArg(PCpRequestArg_extensionArg *val)
{
    if (val) {
    ASN1PERFreeSeqOf((ASN1iterator_t **) val, (ASN1iterator_freefn) ASN1Free_CpRequestArg_extensionArg_ElmFn);
    }
}

static void ASN1CALL ASN1Free_CpRequestArg_extensionArg_ElmFn(PCpRequestArg_extensionArg val)
{
    if (val) {
    ASN1Free_MixedExtension(&val->value);
    }
}

static int ASN1CALL ASN1Enc_ServiceApdus_rosApdus(ASN1encoding_t enc, PServiceApdus_rosApdus *val)
{
    return ASN1PEREncSeqOf_NoSize(enc, (ASN1iterator_t **) val, (ASN1iterator_encfn) ASN1Enc_ServiceApdus_rosApdus_ElmFn);
}

static int ASN1CALL ASN1Enc_ServiceApdus_rosApdus_ElmFn(ASN1encoding_t enc, PServiceApdus_rosApdus val)
{
    if (!ASN1Enc_H4503ROS(enc, &val->value))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_ServiceApdus_rosApdus(ASN1decoding_t dec, PServiceApdus_rosApdus *val)
{
    return ASN1PERDecSeqOf_NoSize(dec, (ASN1iterator_t **) val, (ASN1iterator_decfn) ASN1Dec_ServiceApdus_rosApdus_ElmFn, sizeof(**val));
}

static int ASN1CALL ASN1Dec_ServiceApdus_rosApdus_ElmFn(ASN1decoding_t dec, PServiceApdus_rosApdus val)
{
    if (!ASN1Dec_H4503ROS(dec, &val->value))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_ServiceApdus_rosApdus(PServiceApdus_rosApdus *val)
{
    if (val) {
    ASN1PERFreeSeqOf((ASN1iterator_t **) val, (ASN1iterator_freefn) ASN1Free_ServiceApdus_rosApdus_ElmFn);
    }
}

static void ASN1CALL ASN1Free_ServiceApdus_rosApdus_ElmFn(PServiceApdus_rosApdus val)
{
    if (val) {
    ASN1Free_H4503ROS(&val->value);
    }
}

static ASN1stringtableentry_t AliasAddress_e164_StringTableEntries[] = {
    { 35, 35, 0 }, { 42, 42, 1 }, { 44, 44, 2 }, 
    { 48, 57, 3 }, 
};

static ASN1stringtable_t AliasAddress_e164_StringTable = {
    4, AliasAddress_e164_StringTableEntries
};

static int ASN1CALL ASN1Enc_AliasAddress(ASN1encoding_t enc, AliasAddress *val)
{
    ASN1uint32_t t;
    ASN1encoding_t ee;
    if (!ASN1PEREncComplexChoice(enc, (val)->choice, 1, 2))
    return 0;
    switch ((val)->choice) {
    case 1:
    t = lstrlenA((val)->u.e164);
    if (!ASN1PEREncBitVal(enc, 7, t - 1))
        return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncTableCharString(enc, t, (val)->u.e164, 4, &AliasAddress_e164_StringTable))
        return 0;
    break;
    case 2:
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncBitVal(enc, 8, ((val)->u.h323_ID).length - 1))
        return 0;
    if (!ASN1PEREncChar16String(enc, ((val)->u.h323_ID).length, ((val)->u.h323_ID).value, 16))
        return 0;
    break;
    case 3:
    if (ASN1_CreateEncoder(enc->module, &ee, NULL, 0, enc) < 0)
        return 0;
    t = lstrlenA((val)->u.url_ID);
    ASN1PEREncAlignment(ee);
    if (!ASN1PEREncBitVal(ee, 16, t - 1))
        return 0;
    if (!ASN1PEREncCharString(ee, t, (val)->u.url_ID, 8))
        return 0;
    if (!ASN1PEREncFlushFragmentedToParent(ee))
        return 0;
    ASN1_CloseEncoder2(ee);
    break;
    case 4:
    if (ASN1_CreateEncoder(enc->module, &ee, NULL, 0, enc) < 0)
        return 0;
    if (!ASN1Enc_TransportAddress(ee, &(val)->u.transportID))
        return 0;
    if (!ASN1PEREncFlushFragmentedToParent(ee))
        return 0;
    ASN1_CloseEncoder2(ee);
    break;
    case 5:
    if (ASN1_CreateEncoder(enc->module, &ee, NULL, 0, enc) < 0)
        return 0;
    t = lstrlenA((val)->u.email_ID);
    ASN1PEREncAlignment(ee);
    if (!ASN1PEREncBitVal(ee, 16, t - 1))
        return 0;
    if (!ASN1PEREncCharString(ee, t, (val)->u.email_ID, 8))
        return 0;
    if (!ASN1PEREncFlushFragmentedToParent(ee))
        return 0;
    ASN1_CloseEncoder2(ee);
    break;
    case 6:
    if (ASN1_CreateEncoder(enc->module, &ee, NULL, 0, enc) < 0)
        return 0;
    if (!ASN1Enc_PartyNumber(ee, &(val)->u.partyNumber))
        return 0;
    if (!ASN1PEREncFlushFragmentedToParent(ee))
        return 0;
    ASN1_CloseEncoder2(ee);
    break;
    default:
    /* impossible */
    ASN1EncSetError(enc, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_AliasAddress(ASN1decoding_t dec, AliasAddress *val)
{
    ASN1uint32_t l;
    ASN1decoding_t dd;
    ASN1octet_t *db;
    ASN1uint32_t ds;
    if (!ASN1PERDecComplexChoice(dec, &(val)->choice, 1, 2))
    return 0;
    switch ((val)->choice) {
    case 1:
    if (!ASN1PERDecU32Val(dec, 7, &l))
        return 0;
    l += 1;
    ASN1PERDecAlignment(dec);

    //NikhilB: Fix for the overflow bug 03/02/27
    if ( l >= sizeof((val)->u.e164) ) {
        ASN1DecSetError(dec, ASN1_ERR_LARGE);
        return 0; 
    }

    if (!ASN1PERDecZeroTableCharStringNoAlloc(dec, l, (val)->u.e164, 4, &AliasAddress_e164_StringTable))
        return 0;
    break;
    case 2:
    ASN1PERDecAlignment(dec);
    if (!ASN1PERDecU32Val(dec, 8, &((val)->u.h323_ID).length))
        return 0;
    ((val)->u.h323_ID).length += 1;
    if (!ASN1PERDecChar16String(dec, ((val)->u.h323_ID).length, &((val)->u.h323_ID).value, 16))
        return 0;
    break;
    case 3:
    if (!ASN1PERDecFragmented(dec, &ds, &db, 8))
        return 0;
    if (ASN1_CreateDecoderEx(dec->module, &dd, db, ds, dec, ASN1DECODE_AUTOFREEBUFFER) < 0)
        return 0;
    ASN1PERDecAlignment(dd);
    if (!ASN1PERDecU32Val(dd, 16, &l))
        return 0;
    l += 1;

    //NikhilB: Fix for the overflow bug 03/02/26
    if (l >= sizeof((val)->u.url_ID)) { 
        ASN1DecSetError(dd, ASN1_ERR_LARGE);
        return 0; 
    }

    if (!ASN1PERDecZeroCharStringNoAlloc(dd, l, (val)->u.url_ID, 8))
        return 0;
    ASN1_CloseDecoder(dd);
    break;
    case 4:
    if (!ASN1PERDecFragmented(dec, &ds, &db, 8))
        return 0;
    if (ASN1_CreateDecoderEx(dec->module, &dd, db, ds, dec, ASN1DECODE_AUTOFREEBUFFER) < 0)
        return 0;
    if (!ASN1Dec_TransportAddress(dd, &(val)->u.transportID))
        return 0;
    ASN1_CloseDecoder(dd);
    break;
    case 5:
    if (!ASN1PERDecFragmented(dec, &ds, &db, 8))
        return 0;
    if (ASN1_CreateDecoderEx(dec->module, &dd, db, ds, dec, ASN1DECODE_AUTOFREEBUFFER) < 0)
        return 0;
    ASN1PERDecAlignment(dd);
    if (!ASN1PERDecU32Val(dd, 16, &l))
        return 0;
    l += 1;

    //NikhilB: Fix for the overflow bug 03/02/26
    if (l >= sizeof((val)->u.email_ID)) { 
        ASN1DecSetError(dd, ASN1_ERR_LARGE);
        return 0; 
    }

    if (!ASN1PERDecZeroCharStringNoAlloc(dd, l, (val)->u.email_ID, 8))
        return 0;
    ASN1_CloseDecoder(dd);
    break;
    case 6:
    if (!ASN1PERDecFragmented(dec, &ds, &db, 8))
        return 0;
    if (ASN1_CreateDecoderEx(dec->module, &dd, db, ds, dec, ASN1DECODE_AUTOFREEBUFFER) < 0)
        return 0;
    if (!ASN1Dec_PartyNumber(dd, &(val)->u.partyNumber))
        return 0;
    ASN1_CloseDecoder(dd);
    break;
    case 0:
    /* extension case */
    if (!ASN1PERDecSkipFragmented(dec, 8))
        return 0;
    break;
    default:
    /* impossible */
    ASN1DecSetError(dec, ASN1_ERR_CHOICE);
    return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_AliasAddress(AliasAddress *val)
{
    if (val) {
    switch ((val)->choice) {
    case 1:
        break;
    case 2:
        ASN1char16string_free(&(val)->u.h323_ID);
        break;
    case 3:
        break;
    case 4:
        ASN1Free_TransportAddress(&(val)->u.transportID);
        break;
    case 5:
        break;
    case 6:
        ASN1Free_PartyNumber(&(val)->u.partyNumber);
        break;
    }
    }
}

static int ASN1CALL ASN1Enc_EndpointAddress_destinationAddress(ASN1encoding_t enc, PEndpointAddress_destinationAddress *val)
{
    return ASN1PEREncSeqOf_NoSize(enc, (ASN1iterator_t **) val, (ASN1iterator_encfn) ASN1Enc_EndpointAddress_destinationAddress_ElmFn);
}

static int ASN1CALL ASN1Enc_EndpointAddress_destinationAddress_ElmFn(ASN1encoding_t enc, PEndpointAddress_destinationAddress val)
{
    if (!ASN1Enc_AliasAddress(enc, &val->value))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_EndpointAddress_destinationAddress(ASN1decoding_t dec, PEndpointAddress_destinationAddress *val)
{
    return ASN1PERDecSeqOf_NoSize(dec, (ASN1iterator_t **) val, (ASN1iterator_decfn) ASN1Dec_EndpointAddress_destinationAddress_ElmFn, sizeof(**val));
}

static int ASN1CALL ASN1Dec_EndpointAddress_destinationAddress_ElmFn(ASN1decoding_t dec, PEndpointAddress_destinationAddress val)
{
    if (!ASN1Dec_AliasAddress(dec, &val->value))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_EndpointAddress_destinationAddress(PEndpointAddress_destinationAddress *val)
{
    if (val) {
    ASN1PERFreeSeqOf((ASN1iterator_t **) val, (ASN1iterator_freefn) ASN1Free_EndpointAddress_destinationAddress_ElmFn);
    }
}

static void ASN1CALL ASN1Free_EndpointAddress_destinationAddress_ElmFn(PEndpointAddress_destinationAddress val)
{
    if (val) {
    ASN1Free_AliasAddress(&val->value);
    }
}

static int ASN1CALL ASN1Enc_AddressInformation(ASN1encoding_t enc, AddressInformation *val)
{
    if (!ASN1Enc_AliasAddress(enc, val))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_AddressInformation(ASN1decoding_t dec, AddressInformation *val)
{
    if (!ASN1Dec_AliasAddress(dec, val))
    return 0;
    return 1;
}

static void ASN1CALL ASN1Free_AddressInformation(AddressInformation *val)
{
    if (val) {
    ASN1Free_AliasAddress(val);
    }
}

static int ASN1CALL ASN1Enc_EndpointAddress(ASN1encoding_t enc, EndpointAddress *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 1, (val)->o))
    return 0;
    if (!ASN1Enc_EndpointAddress_destinationAddress(enc, &(val)->destinationAddress))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_AliasAddress(enc, &(val)->remoteExtensionAddress))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_EndpointAddress(ASN1decoding_t dec, EndpointAddress *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 1, (val)->o))
    return 0;
    if (!ASN1Dec_EndpointAddress_destinationAddress(dec, &(val)->destinationAddress))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_AliasAddress(dec, &(val)->remoteExtensionAddress))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_EndpointAddress(EndpointAddress *val)
{
    if (val) {
    ASN1Free_EndpointAddress_destinationAddress(&(val)->destinationAddress);
    if ((val)->o[0] & 0x80) {
        ASN1Free_AliasAddress(&(val)->remoteExtensionAddress);
    }
    }
}

static int ASN1CALL ASN1Enc_NetworkFacilityExtension(ASN1encoding_t enc, NetworkFacilityExtension *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 2, (val)->o))
    return 0;
    if (!ASN1Enc_EntityType(enc, &(val)->sourceEntity))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_AddressInformation(enc, &(val)->sourceEntityAddress))
        return 0;
    }
    if (!ASN1Enc_EntityType(enc, &(val)->destinationEntity))
    return 0;
    if ((val)->o[0] & 0x40) {
    if (!ASN1Enc_AddressInformation(enc, &(val)->destinationEntityAddress))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_NetworkFacilityExtension(ASN1decoding_t dec, NetworkFacilityExtension *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 2, (val)->o))
    return 0;
    if (!ASN1Dec_EntityType(dec, &(val)->sourceEntity))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_AddressInformation(dec, &(val)->sourceEntityAddress))
        return 0;
    }
    if (!ASN1Dec_EntityType(dec, &(val)->destinationEntity))
    return 0;
    if ((val)->o[0] & 0x40) {
    if (!ASN1Dec_AddressInformation(dec, &(val)->destinationEntityAddress))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_NetworkFacilityExtension(NetworkFacilityExtension *val)
{
    if (val) {
    if ((val)->o[0] & 0x80) {
        ASN1Free_AddressInformation(&(val)->sourceEntityAddress);
    }
    if ((val)->o[0] & 0x40) {
        ASN1Free_AddressInformation(&(val)->destinationEntityAddress);
    }
    }
}

static int ASN1CALL ASN1Enc_ActivateDiversionQArgument(ASN1encoding_t enc, ActivateDiversionQArgument *val)
{
    ASN1uint32_t u;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 1, (val)->o))
    return 0;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBitVal(enc, 2, (val)->procedure))
    return 0;
    switch ((val)->basicService) {
    case 0:
    u = 0;
    break;
    case 1:
    u = 1;
    break;
    case 2:
    u = 2;
    break;
    case 3:
    u = 3;
    break;
    case 32:
    u = 4;
    break;
    case 33:
    u = 5;
    break;
    case 34:
    u = 6;
    break;
    case 35:
    u = 7;
    break;
    case 36:
    u = 8;
    break;
    }
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBitVal(enc, 4, u))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->divertedToAddress))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->servedUserNr))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->activatingUserNr))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_ActivateDiversionQArgument_extension(enc, &(val)->extension))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_ActivateDiversionQArgument(ASN1decoding_t dec, ActivateDiversionQArgument *val)
{
    ASN1uint32_t y;
    ASN1uint32_t x;
    ASN1uint32_t u;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 1, (val)->o))
    return 0;
    if (!ASN1PERDecExtensionBit(dec, &x))
    return 0;
    if (!x) {
    if (!ASN1PERDecU32Val(dec, 2, &(val)->procedure))
        return 0;
    } else {
    if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    if (!ASN1PERDecExtensionBit(dec, &x))
    return 0;
    if (!x) {
    if (!ASN1PERDecU32Val(dec, 4, &u))
        return 0;
    switch (u) {
    case 0:
        (val)->basicService = 0;
        break;
    case 1:
        (val)->basicService = 1;
        break;
    case 2:
        (val)->basicService = 2;
        break;
    case 3:
        (val)->basicService = 3;
        break;
    case 4:
        (val)->basicService = 32;
        break;
    case 5:
        (val)->basicService = 33;
        break;
    case 6:
        (val)->basicService = 34;
        break;
    case 7:
        (val)->basicService = 35;
        break;
    case 8:
        (val)->basicService = 36;
        break;
    }
    } else {
    if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    if (!ASN1Dec_EndpointAddress(dec, &(val)->divertedToAddress))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->servedUserNr))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->activatingUserNr))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_ActivateDiversionQArgument_extension(dec, &(val)->extension))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_ActivateDiversionQArgument(ActivateDiversionQArgument *val)
{
    if (val) {
    ASN1Free_EndpointAddress(&(val)->divertedToAddress);
    ASN1Free_EndpointAddress(&(val)->servedUserNr);
    ASN1Free_EndpointAddress(&(val)->activatingUserNr);
    if ((val)->o[0] & 0x80) {
        ASN1Free_ActivateDiversionQArgument_extension(&(val)->extension);
    }
    }
}

static int ASN1CALL ASN1Enc_DeactivateDiversionQArgument(ASN1encoding_t enc, DeactivateDiversionQArgument *val)
{
    ASN1uint32_t u;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 1, (val)->o))
    return 0;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBitVal(enc, 2, (val)->procedure))
    return 0;
    switch ((val)->basicService) {
    case 0:
    u = 0;
    break;
    case 1:
    u = 1;
    break;
    case 2:
    u = 2;
    break;
    case 3:
    u = 3;
    break;
    case 32:
    u = 4;
    break;
    case 33:
    u = 5;
    break;
    case 34:
    u = 6;
    break;
    case 35:
    u = 7;
    break;
    case 36:
    u = 8;
    break;
    }
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBitVal(enc, 4, u))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->servedUserNr))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->deactivatingUserNr))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_DeactivateDiversionQArgument_extension(enc, &(val)->extension))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_DeactivateDiversionQArgument(ASN1decoding_t dec, DeactivateDiversionQArgument *val)
{
    ASN1uint32_t y;
    ASN1uint32_t x;
    ASN1uint32_t u;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 1, (val)->o))
    return 0;
    if (!ASN1PERDecExtensionBit(dec, &x))
    return 0;
    if (!x) {
    if (!ASN1PERDecU32Val(dec, 2, &(val)->procedure))
        return 0;
    } else {
    if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    if (!ASN1PERDecExtensionBit(dec, &x))
    return 0;
    if (!x) {
    if (!ASN1PERDecU32Val(dec, 4, &u))
        return 0;
    switch (u) {
    case 0:
        (val)->basicService = 0;
        break;
    case 1:
        (val)->basicService = 1;
        break;
    case 2:
        (val)->basicService = 2;
        break;
    case 3:
        (val)->basicService = 3;
        break;
    case 4:
        (val)->basicService = 32;
        break;
    case 5:
        (val)->basicService = 33;
        break;
    case 6:
        (val)->basicService = 34;
        break;
    case 7:
        (val)->basicService = 35;
        break;
    case 8:
        (val)->basicService = 36;
        break;
    }
    } else {
    if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    if (!ASN1Dec_EndpointAddress(dec, &(val)->servedUserNr))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->deactivatingUserNr))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_DeactivateDiversionQArgument_extension(dec, &(val)->extension))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_DeactivateDiversionQArgument(DeactivateDiversionQArgument *val)
{
    if (val) {
    ASN1Free_EndpointAddress(&(val)->servedUserNr);
    ASN1Free_EndpointAddress(&(val)->deactivatingUserNr);
    if ((val)->o[0] & 0x80) {
        ASN1Free_DeactivateDiversionQArgument_extension(&(val)->extension);
    }
    }
}

static int ASN1CALL ASN1Enc_InterrogateDiversionQArgument(ASN1encoding_t enc, InterrogateDiversionQArgument *val)
{
    ASN1octet_t o[1];
    ASN1uint32_t u;
    CopyMemory(o, (val)->o, 1);
    if ((val)->basicService == 0)
    o[0] &= ~0x80;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 2, o))
    return 0;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBitVal(enc, 2, (val)->procedure))
    return 0;
    if (o[0] & 0x80) {
    switch ((val)->basicService) {
    case 0:
        u = 0;
        break;
    case 1:
        u = 1;
        break;
    case 2:
        u = 2;
        break;
    case 3:
        u = 3;
        break;
    case 32:
        u = 4;
        break;
    case 33:
        u = 5;
        break;
    case 34:
        u = 6;
        break;
    case 35:
        u = 7;
        break;
    case 36:
        u = 8;
        break;
    }
    if (!ASN1PEREncExtensionBitClear(enc))
        return 0;
    if (!ASN1PEREncBitVal(enc, 4, u))
        return 0;
    }
    if (!ASN1Enc_EndpointAddress(enc, &(val)->servedUserNr))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->interrogatingUserNr))
    return 0;
    if (o[0] & 0x40) {
    if (!ASN1Enc_InterrogateDiversionQArgument_extension(enc, &(val)->extension))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_InterrogateDiversionQArgument(ASN1decoding_t dec, InterrogateDiversionQArgument *val)
{
    ASN1uint32_t y;
    ASN1uint32_t x;
    ASN1uint32_t u;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 2, (val)->o))
    return 0;
    if (!ASN1PERDecExtensionBit(dec, &x))
    return 0;
    if (!x) {
    if (!ASN1PERDecU32Val(dec, 2, &(val)->procedure))
        return 0;
    } else {
    if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    if ((val)->o[0] & 0x80) {
    if (!ASN1PERDecExtensionBit(dec, &x))
        return 0;
    if (!x) {
        if (!ASN1PERDecU32Val(dec, 4, &u))
        return 0;
        switch (u) {
        case 0:
        (val)->basicService = 0;
        break;
        case 1:
        (val)->basicService = 1;
        break;
        case 2:
        (val)->basicService = 2;
        break;
        case 3:
        (val)->basicService = 3;
        break;
        case 4:
        (val)->basicService = 32;
        break;
        case 5:
        (val)->basicService = 33;
        break;
        case 6:
        (val)->basicService = 34;
        break;
        case 7:
        (val)->basicService = 35;
        break;
        case 8:
        (val)->basicService = 36;
        break;
        }
    } else {
        if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    }
    if (!ASN1Dec_EndpointAddress(dec, &(val)->servedUserNr))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->interrogatingUserNr))
    return 0;
    if ((val)->o[0] & 0x40) {
    if (!ASN1Dec_InterrogateDiversionQArgument_extension(dec, &(val)->extension))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    if (!((val)->o[0] & 0x80))
    (val)->basicService = 0;
    return 1;
}

static void ASN1CALL ASN1Free_InterrogateDiversionQArgument(InterrogateDiversionQArgument *val)
{
    if (val) {
    ASN1Free_EndpointAddress(&(val)->servedUserNr);
    ASN1Free_EndpointAddress(&(val)->interrogatingUserNr);
    if ((val)->o[0] & 0x40) {
        ASN1Free_InterrogateDiversionQArgument_extension(&(val)->extension);
    }
    }
}

static int ASN1CALL ASN1Enc_CheckRestrictionArgument(ASN1encoding_t enc, CheckRestrictionArgument *val)
{
    ASN1uint32_t u;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 1, (val)->o))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->servedUserNr))
    return 0;
    switch ((val)->basicService) {
    case 0:
    u = 0;
    break;
    case 1:
    u = 1;
    break;
    case 2:
    u = 2;
    break;
    case 3:
    u = 3;
    break;
    case 32:
    u = 4;
    break;
    case 33:
    u = 5;
    break;
    case 34:
    u = 6;
    break;
    case 35:
    u = 7;
    break;
    case 36:
    u = 8;
    break;
    }
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBitVal(enc, 4, u))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->divertedToNr))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_CheckRestrictionArgument_extension(enc, &(val)->extension))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CheckRestrictionArgument(ASN1decoding_t dec, CheckRestrictionArgument *val)
{
    ASN1uint32_t y;
    ASN1uint32_t x;
    ASN1uint32_t u;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 1, (val)->o))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->servedUserNr))
    return 0;
    if (!ASN1PERDecExtensionBit(dec, &x))
    return 0;
    if (!x) {
    if (!ASN1PERDecU32Val(dec, 4, &u))
        return 0;
    switch (u) {
    case 0:
        (val)->basicService = 0;
        break;
    case 1:
        (val)->basicService = 1;
        break;
    case 2:
        (val)->basicService = 2;
        break;
    case 3:
        (val)->basicService = 3;
        break;
    case 4:
        (val)->basicService = 32;
        break;
    case 5:
        (val)->basicService = 33;
        break;
    case 6:
        (val)->basicService = 34;
        break;
    case 7:
        (val)->basicService = 35;
        break;
    case 8:
        (val)->basicService = 36;
        break;
    }
    } else {
    if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    if (!ASN1Dec_EndpointAddress(dec, &(val)->divertedToNr))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_CheckRestrictionArgument_extension(dec, &(val)->extension))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CheckRestrictionArgument(CheckRestrictionArgument *val)
{
    if (val) {
    ASN1Free_EndpointAddress(&(val)->servedUserNr);
    ASN1Free_EndpointAddress(&(val)->divertedToNr);
    if ((val)->o[0] & 0x80) {
        ASN1Free_CheckRestrictionArgument_extension(&(val)->extension);
    }
    }
}

static int ASN1CALL ASN1Enc_CallReroutingArgument(ASN1encoding_t enc, CallReroutingArgument *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 7, (val)->o))
    return 0;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBitVal(enc, 2, (val)->reroutingReason))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PEREncExtensionBitClear(enc))
        return 0;
    if (!ASN1PEREncBitVal(enc, 2, (val)->originalReroutingReason))
        return 0;
    }
    if (!ASN1Enc_EndpointAddress(enc, &(val)->calledAddress))
    return 0;
    if (!ASN1PEREncBitVal(enc, 4, (val)->diversionCounter - 1))
    return 0;
    if (!ASN1PEREncOctetString_NoSize(enc, &(val)->h225InfoElement))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->lastReroutingNr))
    return 0;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBitVal(enc, 2, (val)->subscriptionOption))
    return 0;
    if ((val)->o[0] & 0x40) {
    if (!ASN1Enc_PartySubaddress(enc, &(val)->callingPartySubaddress))
        return 0;
    }
    if (!ASN1Enc_EndpointAddress(enc, &(val)->callingNumber))
    return 0;
    if ((val)->o[0] & 0x20) {
    if (!ASN1PEREncBitVal(enc, 7, ((val)->callingInfo).length - 1))
        return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncChar16String(enc, ((val)->callingInfo).length, ((val)->callingInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x10) {
    if (!ASN1Enc_EndpointAddress(enc, &(val)->originalCalledNr))
        return 0;
    }
    if ((val)->o[0] & 0x8) {
    if (!ASN1PEREncBitVal(enc, 7, ((val)->redirectingInfo).length - 1))
        return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncChar16String(enc, ((val)->redirectingInfo).length, ((val)->redirectingInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x4) {
    if (!ASN1PEREncBitVal(enc, 7, ((val)->originalCalledInfo).length - 1))
        return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncChar16String(enc, ((val)->originalCalledInfo).length, ((val)->originalCalledInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x2) {
    if (!ASN1Enc_CallReroutingArgument_extension(enc, &(val)->extension))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CallReroutingArgument(ASN1decoding_t dec, CallReroutingArgument *val)
{
    ASN1uint32_t y;
    ASN1uint32_t x;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 7, (val)->o))
    return 0;
    if (!ASN1PERDecExtensionBit(dec, &x))
    return 0;
    if (!x) {
    if (!ASN1PERDecU32Val(dec, 2, &(val)->reroutingReason))
        return 0;
    } else {
    if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    if ((val)->o[0] & 0x80) {
    if (!ASN1PERDecExtensionBit(dec, &x))
        return 0;
    if (!x) {
        if (!ASN1PERDecU32Val(dec, 2, &(val)->originalReroutingReason))
        return 0;
    } else {
        if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    }
    if (!ASN1Dec_EndpointAddress(dec, &(val)->calledAddress))
    return 0;
    if (!ASN1PERDecU16Val(dec, 4, &(val)->diversionCounter))
    return 0;
    (val)->diversionCounter += 1;
    if (!ASN1PERDecOctetString_NoSize(dec, &(val)->h225InfoElement))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->lastReroutingNr))
    return 0;
    if (!ASN1PERDecExtensionBit(dec, &x))
    return 0;
    if (!x) {
    if (!ASN1PERDecU32Val(dec, 2, &(val)->subscriptionOption))
        return 0;
    } else {
    if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Dec_PartySubaddress(dec, &(val)->callingPartySubaddress))
        return 0;
    }
    if (!ASN1Dec_EndpointAddress(dec, &(val)->callingNumber))
    return 0;
    if ((val)->o[0] & 0x20) {
    if (!ASN1PERDecU32Val(dec, 7, &((val)->callingInfo).length))
        return 0;
    ((val)->callingInfo).length += 1;
    ASN1PERDecAlignment(dec);
    if (!ASN1PERDecChar16String(dec, ((val)->callingInfo).length, &((val)->callingInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x10) {
    if (!ASN1Dec_EndpointAddress(dec, &(val)->originalCalledNr))
        return 0;
    }
    if ((val)->o[0] & 0x8) {
    if (!ASN1PERDecU32Val(dec, 7, &((val)->redirectingInfo).length))
        return 0;
    ((val)->redirectingInfo).length += 1;
    ASN1PERDecAlignment(dec);
    if (!ASN1PERDecChar16String(dec, ((val)->redirectingInfo).length, &((val)->redirectingInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x4) {
    if (!ASN1PERDecU32Val(dec, 7, &((val)->originalCalledInfo).length))
        return 0;
    ((val)->originalCalledInfo).length += 1;
    ASN1PERDecAlignment(dec);
    if (!ASN1PERDecChar16String(dec, ((val)->originalCalledInfo).length, &((val)->originalCalledInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x2) {
    if (!ASN1Dec_CallReroutingArgument_extension(dec, &(val)->extension))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CallReroutingArgument(CallReroutingArgument *val)
{
    if (val) {
    ASN1Free_EndpointAddress(&(val)->calledAddress);
    ASN1octetstring_free(&(val)->h225InfoElement);
    ASN1Free_EndpointAddress(&(val)->lastReroutingNr);
    if ((val)->o[0] & 0x40) {
        ASN1Free_PartySubaddress(&(val)->callingPartySubaddress);
    }
    ASN1Free_EndpointAddress(&(val)->callingNumber);
    if ((val)->o[0] & 0x20) {
        ASN1char16string_free(&(val)->callingInfo);
    }
    if ((val)->o[0] & 0x10) {
        ASN1Free_EndpointAddress(&(val)->originalCalledNr);
    }
    if ((val)->o[0] & 0x8) {
        ASN1char16string_free(&(val)->redirectingInfo);
    }
    if ((val)->o[0] & 0x4) {
        ASN1char16string_free(&(val)->originalCalledInfo);
    }
    if ((val)->o[0] & 0x2) {
        ASN1Free_CallReroutingArgument_extension(&(val)->extension);
    }
    }
}

static int ASN1CALL ASN1Enc_DivertingLegInformation1Argument(ASN1encoding_t enc, DivertingLegInformation1Argument *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 4, (val)->o))
    return 0;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBitVal(enc, 2, (val)->diversionReason))
    return 0;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBitVal(enc, 2, (val)->subscriptionOption))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->nominatedNr))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PEREncBitVal(enc, 7, ((val)->nominatedInfo).length - 1))
        return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncChar16String(enc, ((val)->nominatedInfo).length, ((val)->nominatedInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Enc_EndpointAddress(enc, &(val)->redirectingNr))
        return 0;
    }
    if ((val)->o[0] & 0x20) {
    if (!ASN1PEREncBitVal(enc, 7, ((val)->redirectingInfo).length - 1))
        return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncChar16String(enc, ((val)->redirectingInfo).length, ((val)->redirectingInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x10) {
    if (!ASN1Enc_DivertingLegInformation1Argument_extension(enc, &(val)->extension))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_DivertingLegInformation1Argument(ASN1decoding_t dec, DivertingLegInformation1Argument *val)
{
    ASN1uint32_t y;
    ASN1uint32_t x;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 4, (val)->o))
    return 0;
    if (!ASN1PERDecExtensionBit(dec, &x))
    return 0;
    if (!x) {
    if (!ASN1PERDecU32Val(dec, 2, &(val)->diversionReason))
        return 0;
    } else {
    if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    if (!ASN1PERDecExtensionBit(dec, &x))
    return 0;
    if (!x) {
    if (!ASN1PERDecU32Val(dec, 2, &(val)->subscriptionOption))
        return 0;
    } else {
    if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    if (!ASN1Dec_EndpointAddress(dec, &(val)->nominatedNr))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PERDecU32Val(dec, 7, &((val)->nominatedInfo).length))
        return 0;
    ((val)->nominatedInfo).length += 1;
    ASN1PERDecAlignment(dec);
    if (!ASN1PERDecChar16String(dec, ((val)->nominatedInfo).length, &((val)->nominatedInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Dec_EndpointAddress(dec, &(val)->redirectingNr))
        return 0;
    }
    if ((val)->o[0] & 0x20) {
    if (!ASN1PERDecU32Val(dec, 7, &((val)->redirectingInfo).length))
        return 0;
    ((val)->redirectingInfo).length += 1;
    ASN1PERDecAlignment(dec);
    if (!ASN1PERDecChar16String(dec, ((val)->redirectingInfo).length, &((val)->redirectingInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x10) {
    if (!ASN1Dec_DivertingLegInformation1Argument_extension(dec, &(val)->extension))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_DivertingLegInformation1Argument(DivertingLegInformation1Argument *val)
{
    if (val) {
    ASN1Free_EndpointAddress(&(val)->nominatedNr);
    if ((val)->o[0] & 0x80) {
        ASN1char16string_free(&(val)->nominatedInfo);
    }
    if ((val)->o[0] & 0x40) {
        ASN1Free_EndpointAddress(&(val)->redirectingNr);
    }
    if ((val)->o[0] & 0x20) {
        ASN1char16string_free(&(val)->redirectingInfo);
    }
    if ((val)->o[0] & 0x10) {
        ASN1Free_DivertingLegInformation1Argument_extension(&(val)->extension);
    }
    }
}

static int ASN1CALL ASN1Enc_DivertingLegInformation2Argument(ASN1encoding_t enc, DivertingLegInformation2Argument *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 6, (val)->o))
    return 0;
    if (!ASN1PEREncBitVal(enc, 4, (val)->diversionCounter - 1))
    return 0;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBitVal(enc, 2, (val)->diversionReason))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PEREncExtensionBitClear(enc))
        return 0;
    if (!ASN1PEREncBitVal(enc, 2, (val)->originalDiversionReason))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Enc_EndpointAddress(enc, &(val)->divertingNr))
        return 0;
    }
    if ((val)->o[0] & 0x20) {
    if (!ASN1Enc_EndpointAddress(enc, &(val)->originalCalledNr))
        return 0;
    }
    if ((val)->o[0] & 0x10) {
    if (!ASN1PEREncBitVal(enc, 7, ((val)->redirectingInfo).length - 1))
        return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncChar16String(enc, ((val)->redirectingInfo).length, ((val)->redirectingInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x8) {
    if (!ASN1PEREncBitVal(enc, 7, ((val)->originalCalledInfo).length - 1))
        return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncChar16String(enc, ((val)->originalCalledInfo).length, ((val)->originalCalledInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x4) {
    if (!ASN1Enc_DivertingLegInformation2Argument_extension(enc, &(val)->extension))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_DivertingLegInformation2Argument(ASN1decoding_t dec, DivertingLegInformation2Argument *val)
{
    ASN1uint32_t y;
    ASN1uint32_t x;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 6, (val)->o))
    return 0;
    if (!ASN1PERDecU16Val(dec, 4, &(val)->diversionCounter))
    return 0;
    (val)->diversionCounter += 1;
    if (!ASN1PERDecExtensionBit(dec, &x))
    return 0;
    if (!x) {
    if (!ASN1PERDecU32Val(dec, 2, &(val)->diversionReason))
        return 0;
    } else {
    if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    if ((val)->o[0] & 0x80) {
    if (!ASN1PERDecExtensionBit(dec, &x))
        return 0;
    if (!x) {
        if (!ASN1PERDecU32Val(dec, 2, &(val)->originalDiversionReason))
        return 0;
    } else {
        if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Dec_EndpointAddress(dec, &(val)->divertingNr))
        return 0;
    }
    if ((val)->o[0] & 0x20) {
    if (!ASN1Dec_EndpointAddress(dec, &(val)->originalCalledNr))
        return 0;
    }
    if ((val)->o[0] & 0x10) {
    if (!ASN1PERDecU32Val(dec, 7, &((val)->redirectingInfo).length))
        return 0;
    ((val)->redirectingInfo).length += 1;
    ASN1PERDecAlignment(dec);
    if (!ASN1PERDecChar16String(dec, ((val)->redirectingInfo).length, &((val)->redirectingInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x8) {
    if (!ASN1PERDecU32Val(dec, 7, &((val)->originalCalledInfo).length))
        return 0;
    ((val)->originalCalledInfo).length += 1;
    ASN1PERDecAlignment(dec);
    if (!ASN1PERDecChar16String(dec, ((val)->originalCalledInfo).length, &((val)->originalCalledInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x4) {
    if (!ASN1Dec_DivertingLegInformation2Argument_extension(dec, &(val)->extension))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_DivertingLegInformation2Argument(DivertingLegInformation2Argument *val)
{
    if (val) {
    if ((val)->o[0] & 0x40) {
        ASN1Free_EndpointAddress(&(val)->divertingNr);
    }
    if ((val)->o[0] & 0x20) {
        ASN1Free_EndpointAddress(&(val)->originalCalledNr);
    }
    if ((val)->o[0] & 0x10) {
        ASN1char16string_free(&(val)->redirectingInfo);
    }
    if ((val)->o[0] & 0x8) {
        ASN1char16string_free(&(val)->originalCalledInfo);
    }
    if ((val)->o[0] & 0x4) {
        ASN1Free_DivertingLegInformation2Argument_extension(&(val)->extension);
    }
    }
}

static int ASN1CALL ASN1Enc_DivertingLegInformation3Argument(ASN1encoding_t enc, DivertingLegInformation3Argument *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 3, (val)->o))
    return 0;
    if (!ASN1PEREncBoolean(enc, (val)->presentationAllowedIndicator))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_EndpointAddress(enc, &(val)->redirectionNr))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1PEREncBitVal(enc, 7, ((val)->redirectionInfo).length - 1))
        return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncChar16String(enc, ((val)->redirectionInfo).length, ((val)->redirectionInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x20) {
    if (!ASN1Enc_DivertingLegInformation3Argument_extension(enc, &(val)->extension))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_DivertingLegInformation3Argument(ASN1decoding_t dec, DivertingLegInformation3Argument *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 3, (val)->o))
    return 0;
    if (!ASN1PERDecBoolean(dec, &(val)->presentationAllowedIndicator))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_EndpointAddress(dec, &(val)->redirectionNr))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1PERDecU32Val(dec, 7, &((val)->redirectionInfo).length))
        return 0;
    ((val)->redirectionInfo).length += 1;
    ASN1PERDecAlignment(dec);
    if (!ASN1PERDecChar16String(dec, ((val)->redirectionInfo).length, &((val)->redirectionInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x20) {
    if (!ASN1Dec_DivertingLegInformation3Argument_extension(dec, &(val)->extension))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_DivertingLegInformation3Argument(DivertingLegInformation3Argument *val)
{
    if (val) {
    if ((val)->o[0] & 0x80) {
        ASN1Free_EndpointAddress(&(val)->redirectionNr);
    }
    if ((val)->o[0] & 0x40) {
        ASN1char16string_free(&(val)->redirectionInfo);
    }
    if ((val)->o[0] & 0x20) {
        ASN1Free_DivertingLegInformation3Argument_extension(&(val)->extension);
    }
    }
}

static int ASN1CALL ASN1Enc_DivertingLegInformation4Argument(ASN1encoding_t enc, DivertingLegInformation4Argument *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 3, (val)->o))
    return 0;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBitVal(enc, 2, (val)->diversionReason))
    return 0;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBitVal(enc, 2, (val)->subscriptionOption))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->callingNr))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PEREncBitVal(enc, 7, ((val)->callingInfo).length - 1))
        return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncChar16String(enc, ((val)->callingInfo).length, ((val)->callingInfo).value, 16))
        return 0;
    }
    if (!ASN1Enc_EndpointAddress(enc, &(val)->nominatedNr))
    return 0;
    if ((val)->o[0] & 0x40) {
    if (!ASN1PEREncBitVal(enc, 7, ((val)->nominatedInfo).length - 1))
        return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncChar16String(enc, ((val)->nominatedInfo).length, ((val)->nominatedInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x20) {
    if (!ASN1Enc_DivertingLegInformation4Argument_extension(enc, &(val)->extension))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_DivertingLegInformation4Argument(ASN1decoding_t dec, DivertingLegInformation4Argument *val)
{
    ASN1uint32_t y;
    ASN1uint32_t x;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 3, (val)->o))
    return 0;
    if (!ASN1PERDecExtensionBit(dec, &x))
    return 0;
    if (!x) {
    if (!ASN1PERDecU32Val(dec, 2, &(val)->diversionReason))
        return 0;
    } else {
    if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    if (!ASN1PERDecExtensionBit(dec, &x))
    return 0;
    if (!x) {
    if (!ASN1PERDecU32Val(dec, 2, &(val)->subscriptionOption))
        return 0;
    } else {
    if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    if (!ASN1Dec_EndpointAddress(dec, &(val)->callingNr))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PERDecU32Val(dec, 7, &((val)->callingInfo).length))
        return 0;
    ((val)->callingInfo).length += 1;
    ASN1PERDecAlignment(dec);
    if (!ASN1PERDecChar16String(dec, ((val)->callingInfo).length, &((val)->callingInfo).value, 16))
        return 0;
    }
    if (!ASN1Dec_EndpointAddress(dec, &(val)->nominatedNr))
    return 0;
    if ((val)->o[0] & 0x40) {
    if (!ASN1PERDecU32Val(dec, 7, &((val)->nominatedInfo).length))
        return 0;
    ((val)->nominatedInfo).length += 1;
    ASN1PERDecAlignment(dec);
    if (!ASN1PERDecChar16String(dec, ((val)->nominatedInfo).length, &((val)->nominatedInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x20) {
    if (!ASN1Dec_DivertingLegInformation4Argument_extension(dec, &(val)->extension))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_DivertingLegInformation4Argument(DivertingLegInformation4Argument *val)
{
    if (val) {
    ASN1Free_EndpointAddress(&(val)->callingNr);
    if ((val)->o[0] & 0x80) {
        ASN1char16string_free(&(val)->callingInfo);
    }
    ASN1Free_EndpointAddress(&(val)->nominatedNr);
    if ((val)->o[0] & 0x40) {
        ASN1char16string_free(&(val)->nominatedInfo);
    }
    if ((val)->o[0] & 0x20) {
        ASN1Free_DivertingLegInformation4Argument_extension(&(val)->extension);
    }
    }
}

static int ASN1CALL ASN1Enc_IntResult(ASN1encoding_t enc, IntResult *val)
{
    ASN1octet_t o[1];
    ASN1uint32_t u;
    CopyMemory(o, (val)->o, 1);
    if (!(val)->remoteEnabled)
    o[0] &= ~0x80;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 2, o))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->servedUserNr))
    return 0;
    switch ((val)->basicService) {
    case 0:
    u = 0;
    break;
    case 1:
    u = 1;
    break;
    case 2:
    u = 2;
    break;
    case 3:
    u = 3;
    break;
    case 32:
    u = 4;
    break;
    case 33:
    u = 5;
    break;
    case 34:
    u = 6;
    break;
    case 35:
    u = 7;
    break;
    case 36:
    u = 8;
    break;
    }
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBitVal(enc, 4, u))
    return 0;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBitVal(enc, 2, (val)->procedure))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->divertedToAddress))
    return 0;
    if (o[0] & 0x80) {
    if (!ASN1PEREncBoolean(enc, (val)->remoteEnabled))
        return 0;
    }
    if (o[0] & 0x40) {
    if (!ASN1Enc_IntResult_extension(enc, &(val)->extension))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_IntResult(ASN1decoding_t dec, IntResult *val)
{
    ASN1uint32_t y;
    ASN1uint32_t x;
    ASN1uint32_t u;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 2, (val)->o))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->servedUserNr))
    return 0;
    if (!ASN1PERDecExtensionBit(dec, &x))
    return 0;
    if (!x) {
    if (!ASN1PERDecU32Val(dec, 4, &u))
        return 0;
    switch (u) {
    case 0:
        (val)->basicService = 0;
        break;
    case 1:
        (val)->basicService = 1;
        break;
    case 2:
        (val)->basicService = 2;
        break;
    case 3:
        (val)->basicService = 3;
        break;
    case 4:
        (val)->basicService = 32;
        break;
    case 5:
        (val)->basicService = 33;
        break;
    case 6:
        (val)->basicService = 34;
        break;
    case 7:
        (val)->basicService = 35;
        break;
    case 8:
        (val)->basicService = 36;
        break;
    }
    } else {
    if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    if (!ASN1PERDecExtensionBit(dec, &x))
    return 0;
    if (!x) {
    if (!ASN1PERDecU32Val(dec, 2, &(val)->procedure))
        return 0;
    } else {
    if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    if (!ASN1Dec_EndpointAddress(dec, &(val)->divertedToAddress))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PERDecBoolean(dec, &(val)->remoteEnabled))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Dec_IntResult_extension(dec, &(val)->extension))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    if (!((val)->o[0] & 0x80))
    (val)->remoteEnabled = 0;
    return 1;
}

static void ASN1CALL ASN1Free_IntResult(IntResult *val)
{
    if (val) {
    ASN1Free_EndpointAddress(&(val)->servedUserNr);
    ASN1Free_EndpointAddress(&(val)->divertedToAddress);
    if ((val)->o[0] & 0x40) {
        ASN1Free_IntResult_extension(&(val)->extension);
    }
    }
}

static ASN1stringtableentry_t CTInitiateArg_callIdentity_StringTableEntries[] = {
    { 32, 32, 0 }, { 48, 57, 1 }, 
};

static ASN1stringtable_t CTInitiateArg_callIdentity_StringTable = {
    2, CTInitiateArg_callIdentity_StringTableEntries
};

static int ASN1CALL ASN1Enc_CTInitiateArg(ASN1encoding_t enc, CTInitiateArg *val)
{
    ASN1uint32_t t;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 1, (val)->o))
    return 0;
    t = lstrlenA((val)->callIdentity);
    if (!ASN1PEREncBitVal(enc, 3, t))
    return 0;
    //nik
    if (t!=0) ASN1PEREncAlignment(enc);
    if (!ASN1PEREncTableCharString(enc, t, (val)->callIdentity, 4, &CTInitiateArg_callIdentity_StringTable))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->reroutingNumber))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_CTInitiateArg_argumentExtension(enc, &(val)->argumentExtension))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CTInitiateArg(ASN1decoding_t dec, CTInitiateArg *val)
{
    ASN1uint32_t y;
    ASN1uint32_t l;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 1, (val)->o))
    return 0;
    if (!ASN1PERDecU32Val(dec, 3, &l))
    return 0;
    //nik
    if (l!=0) ASN1PERDecAlignment(dec);

    //NikhilB: Fix for the overflow bug 03/02/27
    if ( l >= sizeof((val)->callIdentity) ) {
        ASN1DecSetError(dec, ASN1_ERR_LARGE);
        return 0; 
    }

    if (!ASN1PERDecZeroTableCharStringNoAlloc(dec, l, (val)->callIdentity, 4, &CTInitiateArg_callIdentity_StringTable))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->reroutingNumber))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_CTInitiateArg_argumentExtension(dec, &(val)->argumentExtension))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CTInitiateArg(CTInitiateArg *val)
{
    if (val) {
    ASN1Free_EndpointAddress(&(val)->reroutingNumber);
    if ((val)->o[0] & 0x80) {
        ASN1Free_CTInitiateArg_argumentExtension(&(val)->argumentExtension);
    }
    }
}

static ASN1stringtableentry_t CTSetupArg_callIdentity_StringTableEntries[] = {
    { 32, 32, 0 }, { 48, 57, 1 }, 
};

static ASN1stringtable_t CTSetupArg_callIdentity_StringTable = {
    2, CTSetupArg_callIdentity_StringTableEntries
};

static int ASN1CALL ASN1Enc_CTSetupArg(ASN1encoding_t enc, CTSetupArg *val)
{
    ASN1uint32_t t;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 2, (val)->o))
    return 0;
    t = lstrlenA((val)->callIdentity);
    if (!ASN1PEREncBitVal(enc, 3, t))
    return 0;
    //nik
    if (t!=0) ASN1PEREncAlignment(enc);
    if (!ASN1PEREncTableCharString(enc, t, (val)->callIdentity, 4, &CTSetupArg_callIdentity_StringTable))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_EndpointAddress(enc, &(val)->transferringNumber))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Enc_CTSetupArg_argumentExtension(enc, &(val)->argumentExtension))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CTSetupArg(ASN1decoding_t dec, CTSetupArg *val)
{
    ASN1uint32_t y;
    ASN1uint32_t l;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 2, (val)->o))
    return 0;
    if (!ASN1PERDecU32Val(dec, 3, &l))
    return 0;
    //nik
    if (l!=0) ASN1PERDecAlignment(dec);

    //NikhilB: Fix for the overflow bug 03/02/27
    if ( l >= sizeof((val)->callIdentity) ) {
        ASN1DecSetError(dec, ASN1_ERR_LARGE);
        return 0; 
    }

    if (!ASN1PERDecZeroTableCharStringNoAlloc(dec, l, (val)->callIdentity, 4, &CTSetupArg_callIdentity_StringTable))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_EndpointAddress(dec, &(val)->transferringNumber))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Dec_CTSetupArg_argumentExtension(dec, &(val)->argumentExtension))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CTSetupArg(CTSetupArg *val)
{
    if (val) {
    if ((val)->o[0] & 0x80) {
        ASN1Free_EndpointAddress(&(val)->transferringNumber);
    }
    if ((val)->o[0] & 0x40) {
        ASN1Free_CTSetupArg_argumentExtension(&(val)->argumentExtension);
    }
    }
}

static ASN1stringtableentry_t CTIdentifyRes_callIdentity_StringTableEntries[] = {
    { 32, 32, 0 }, { 48, 57, 1 }, 
};

static ASN1stringtable_t CTIdentifyRes_callIdentity_StringTable = {
    2, CTIdentifyRes_callIdentity_StringTableEntries
};

static int ASN1CALL ASN1Enc_CTIdentifyRes(ASN1encoding_t enc, CTIdentifyRes *val)
{
    ASN1uint32_t t;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 1, (val)->o))
    return 0;
    t = lstrlenA((val)->callIdentity);
    if (!ASN1PEREncBitVal(enc, 3, t))
    return 0;
    //nik
    if (t!=0) ASN1PEREncAlignment(enc);
    if (!ASN1PEREncTableCharString(enc, t, (val)->callIdentity, 4, &CTIdentifyRes_callIdentity_StringTable))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->reroutingNumber))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_CTIdentifyRes_resultExtension(enc, &(val)->resultExtension))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CTIdentifyRes(ASN1decoding_t dec, CTIdentifyRes *val)
{
    ASN1uint32_t y;
    ASN1uint32_t l;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 1, (val)->o))
    return 0;
    if (!ASN1PERDecU32Val(dec, 3, &l))
    return 0;
    //nik
    if (l!=0) ASN1PERDecAlignment(dec);

    //NikhilB: Fix for the overflow bug 03/02/27
    if ( l >= sizeof((val)->callIdentity) ) {
        ASN1DecSetError(dec, ASN1_ERR_LARGE);
        return 0; 
    }

    if (!ASN1PERDecZeroTableCharStringNoAlloc(dec, l, (val)->callIdentity, 4, &CTIdentifyRes_callIdentity_StringTable))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->reroutingNumber))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_CTIdentifyRes_resultExtension(dec, &(val)->resultExtension))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CTIdentifyRes(CTIdentifyRes *val)
{
    if (val) {
    ASN1Free_EndpointAddress(&(val)->reroutingNumber);
    if ((val)->o[0] & 0x80) {
        ASN1Free_CTIdentifyRes_resultExtension(&(val)->resultExtension);
    }
    }
}

static int ASN1CALL ASN1Enc_CTUpdateArg(ASN1encoding_t enc, CTUpdateArg *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 3, (val)->o))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->redirectionNumber))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PEREncBitVal(enc, 7, ((val)->redirectionInfo).length - 1))
        return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncChar16String(enc, ((val)->redirectionInfo).length, ((val)->redirectionInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1PEREncOctetString_NoSize(enc, &(val)->basicCallInfoElements))
        return 0;
    }
    if ((val)->o[0] & 0x20) {
    if (!ASN1Enc_CTUpdateArg_argumentExtension(enc, &(val)->argumentExtension))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CTUpdateArg(ASN1decoding_t dec, CTUpdateArg *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 3, (val)->o))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->redirectionNumber))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PERDecU32Val(dec, 7, &((val)->redirectionInfo).length))
        return 0;
    ((val)->redirectionInfo).length += 1;
    ASN1PERDecAlignment(dec);
    if (!ASN1PERDecChar16String(dec, ((val)->redirectionInfo).length, &((val)->redirectionInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1PERDecOctetString_NoSize(dec, &(val)->basicCallInfoElements))
        return 0;
    }
    if ((val)->o[0] & 0x20) {
    if (!ASN1Dec_CTUpdateArg_argumentExtension(dec, &(val)->argumentExtension))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CTUpdateArg(CTUpdateArg *val)
{
    if (val) {
    ASN1Free_EndpointAddress(&(val)->redirectionNumber);
    if ((val)->o[0] & 0x80) {
        ASN1char16string_free(&(val)->redirectionInfo);
    }
    if ((val)->o[0] & 0x40) {
        ASN1octetstring_free(&(val)->basicCallInfoElements);
    }
    if ((val)->o[0] & 0x20) {
        ASN1Free_CTUpdateArg_argumentExtension(&(val)->argumentExtension);
    }
    }
}

static int ASN1CALL ASN1Enc_CTCompleteArg(ASN1encoding_t enc, CTCompleteArg *val)
{
    ASN1octet_t o[1];
    CopyMemory(o, (val)->o, 1);
    if ((val)->callStatus == 0)
    o[0] &= ~0x20;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 4, o))
    return 0;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBitVal(enc, 1, (val)->endDesignation))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->redirectionNumber))
    return 0;
    if (o[0] & 0x80) {
    if (!ASN1PEREncOctetString_NoSize(enc, &(val)->basicCallInfoElements))
        return 0;
    }
    if (o[0] & 0x40) {
    if (!ASN1PEREncBitVal(enc, 7, ((val)->redirectionInfo).length - 1))
        return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncChar16String(enc, ((val)->redirectionInfo).length, ((val)->redirectionInfo).value, 16))
        return 0;
    }
    if (o[0] & 0x20) {
    if (!ASN1PEREncExtensionBitClear(enc))
        return 0;
    if (!ASN1PEREncBitVal(enc, 1, (val)->callStatus))
        return 0;
    }
    if (o[0] & 0x10) {
    if (!ASN1Enc_CTCompleteArg_argumentExtension(enc, &(val)->argumentExtension))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CTCompleteArg(ASN1decoding_t dec, CTCompleteArg *val)
{
    ASN1uint32_t y;
    ASN1uint32_t x;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 4, (val)->o))
    return 0;
    if (!ASN1PERDecExtensionBit(dec, &x))
    return 0;
    if (!x) {
    if (!ASN1PERDecU32Val(dec, 1, &(val)->endDesignation))
        return 0;
    } else {
    if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    if (!ASN1Dec_EndpointAddress(dec, &(val)->redirectionNumber))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PERDecOctetString_NoSize(dec, &(val)->basicCallInfoElements))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1PERDecU32Val(dec, 7, &((val)->redirectionInfo).length))
        return 0;
    ((val)->redirectionInfo).length += 1;
    ASN1PERDecAlignment(dec);
    if (!ASN1PERDecChar16String(dec, ((val)->redirectionInfo).length, &((val)->redirectionInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x20) {
    if (!ASN1PERDecExtensionBit(dec, &x))
        return 0;
    if (!x) {
        if (!ASN1PERDecU32Val(dec, 1, &(val)->callStatus))
        return 0;
    } else {
        if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    }
    if ((val)->o[0] & 0x10) {
    if (!ASN1Dec_CTCompleteArg_argumentExtension(dec, &(val)->argumentExtension))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    if (!((val)->o[0] & 0x20))
    (val)->callStatus = 0;
    return 1;
}

static void ASN1CALL ASN1Free_CTCompleteArg(CTCompleteArg *val)
{
    if (val) {
    ASN1Free_EndpointAddress(&(val)->redirectionNumber);
    if ((val)->o[0] & 0x80) {
        ASN1octetstring_free(&(val)->basicCallInfoElements);
    }
    if ((val)->o[0] & 0x40) {
        ASN1char16string_free(&(val)->redirectionInfo);
    }
    if ((val)->o[0] & 0x10) {
        ASN1Free_CTCompleteArg_argumentExtension(&(val)->argumentExtension);
    }
    }
}

static int ASN1CALL ASN1Enc_CTActiveArg(ASN1encoding_t enc, CTActiveArg *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 3, (val)->o))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->connectedAddress))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PEREncOctetString_NoSize(enc, &(val)->basicCallInfoElements))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1PEREncBitVal(enc, 7, ((val)->connectedInfo).length - 1))
        return 0;
    ASN1PEREncAlignment(enc);
    if (!ASN1PEREncChar16String(enc, ((val)->connectedInfo).length, ((val)->connectedInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x20) {
    if (!ASN1Enc_CTActiveArg_argumentExtension(enc, &(val)->argumentExtension))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CTActiveArg(ASN1decoding_t dec, CTActiveArg *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 3, (val)->o))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->connectedAddress))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PERDecOctetString_NoSize(dec, &(val)->basicCallInfoElements))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1PERDecU32Val(dec, 7, &((val)->connectedInfo).length))
        return 0;
    ((val)->connectedInfo).length += 1;
    ASN1PERDecAlignment(dec);
    if (!ASN1PERDecChar16String(dec, ((val)->connectedInfo).length, &((val)->connectedInfo).value, 16))
        return 0;
    }
    if ((val)->o[0] & 0x20) {
    if (!ASN1Dec_CTActiveArg_argumentExtension(dec, &(val)->argumentExtension))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CTActiveArg(CTActiveArg *val)
{
    if (val) {
    ASN1Free_EndpointAddress(&(val)->connectedAddress);
    if ((val)->o[0] & 0x80) {
        ASN1octetstring_free(&(val)->basicCallInfoElements);
    }
    if ((val)->o[0] & 0x40) {
        ASN1char16string_free(&(val)->connectedInfo);
    }
    if ((val)->o[0] & 0x20) {
        ASN1Free_CTActiveArg_argumentExtension(&(val)->argumentExtension);
    }
    }
}

static int ASN1CALL ASN1Enc_CpRequestArg(ASN1encoding_t enc, CpRequestArg *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 2, (val)->o))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->parkingNumber))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->parkedNumber))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->parkedToNumber))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PEREncUnsignedShort(enc, (val)->parkedToPosition))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Enc_CpRequestArg_extensionArg(enc, &(val)->extensionArg))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CpRequestArg(ASN1decoding_t dec, CpRequestArg *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 2, (val)->o))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->parkingNumber))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->parkedNumber))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->parkedToNumber))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PERDecUnsignedShort(dec, &(val)->parkedToPosition))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Dec_CpRequestArg_extensionArg(dec, &(val)->extensionArg))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CpRequestArg(CpRequestArg *val)
{
    if (val) {
    ASN1Free_EndpointAddress(&(val)->parkingNumber);
    ASN1Free_EndpointAddress(&(val)->parkedNumber);
    ASN1Free_EndpointAddress(&(val)->parkedToNumber);
    if ((val)->o[0] & 0x40) {
        ASN1Free_CpRequestArg_extensionArg(&(val)->extensionArg);
    }
    }
}

static int ASN1CALL ASN1Enc_CpRequestRes(ASN1encoding_t enc, CpRequestRes *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 2, (val)->o))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->parkedToNumber))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PEREncUnsignedShort(enc, (val)->parkedToPosition))
        return 0;
    }
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBitVal(enc, 2, (val)->parkCondition))
    return 0;
    if ((val)->o[0] & 0x40) {
    if (!ASN1Enc_CpRequestRes_extensionRes(enc, &(val)->extensionRes))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CpRequestRes(ASN1decoding_t dec, CpRequestRes *val)
{
    ASN1uint32_t y;
    ASN1uint32_t x;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 2, (val)->o))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->parkedToNumber))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PERDecUnsignedShort(dec, &(val)->parkedToPosition))
        return 0;
    }
    if (!ASN1PERDecExtensionBit(dec, &x))
    return 0;
    if (!x) {
    if (!ASN1PERDecU32Val(dec, 2, &(val)->parkCondition))
        return 0;
    } else {
    if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Dec_CpRequestRes_extensionRes(dec, &(val)->extensionRes))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CpRequestRes(CpRequestRes *val)
{
    if (val) {
    ASN1Free_EndpointAddress(&(val)->parkedToNumber);
    if ((val)->o[0] & 0x40) {
        ASN1Free_CpRequestRes_extensionRes(&(val)->extensionRes);
    }
    }
}

static int ASN1CALL ASN1Enc_CpSetupArg(ASN1encoding_t enc, CpSetupArg *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 2, (val)->o))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->parkingNumber))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->parkedNumber))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->parkedToNumber))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PEREncUnsignedShort(enc, (val)->parkedToPosition))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Enc_CpSetupArg_extensionArg(enc, &(val)->extensionArg))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CpSetupArg(ASN1decoding_t dec, CpSetupArg *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 2, (val)->o))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->parkingNumber))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->parkedNumber))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->parkedToNumber))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PERDecUnsignedShort(dec, &(val)->parkedToPosition))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Dec_CpSetupArg_extensionArg(dec, &(val)->extensionArg))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CpSetupArg(CpSetupArg *val)
{
    if (val) {
    ASN1Free_EndpointAddress(&(val)->parkingNumber);
    ASN1Free_EndpointAddress(&(val)->parkedNumber);
    ASN1Free_EndpointAddress(&(val)->parkedToNumber);
    if ((val)->o[0] & 0x40) {
        ASN1Free_CpSetupArg_extensionArg(&(val)->extensionArg);
    }
    }
}

static int ASN1CALL ASN1Enc_CpSetupRes(ASN1encoding_t enc, CpSetupRes *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 2, (val)->o))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->parkedToNumber))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PEREncUnsignedShort(enc, (val)->parkedToPosition))
        return 0;
    }
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBitVal(enc, 2, (val)->parkCondition))
    return 0;
    if ((val)->o[0] & 0x40) {
    if (!ASN1Enc_CpSetupRes_extensionRes(enc, &(val)->extensionRes))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CpSetupRes(ASN1decoding_t dec, CpSetupRes *val)
{
    ASN1uint32_t y;
    ASN1uint32_t x;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 2, (val)->o))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->parkedToNumber))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PERDecUnsignedShort(dec, &(val)->parkedToPosition))
        return 0;
    }
    if (!ASN1PERDecExtensionBit(dec, &x))
    return 0;
    if (!x) {
    if (!ASN1PERDecU32Val(dec, 2, &(val)->parkCondition))
        return 0;
    } else {
    if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Dec_CpSetupRes_extensionRes(dec, &(val)->extensionRes))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CpSetupRes(CpSetupRes *val)
{
    if (val) {
    ASN1Free_EndpointAddress(&(val)->parkedToNumber);
    if ((val)->o[0] & 0x40) {
        ASN1Free_CpSetupRes_extensionRes(&(val)->extensionRes);
    }
    }
}

static int ASN1CALL ASN1Enc_GroupIndicationOnArg(ASN1encoding_t enc, GroupIndicationOnArg *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 2, (val)->o))
    return 0;
    if (!ASN1Enc_CallIdentifier(enc, &(val)->callPickupId))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->groupMemberUserNr))
    return 0;
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBitVal(enc, 1, (val)->retrieveCallType))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->partyToRetrieve))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->retrieveAddress))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PEREncUnsignedShort(enc, (val)->parkPosition))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Enc_GroupIndicationOnArg_extensionArg(enc, &(val)->extensionArg))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_GroupIndicationOnArg(ASN1decoding_t dec, GroupIndicationOnArg *val)
{
    ASN1uint32_t y;
    ASN1uint32_t x;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 2, (val)->o))
    return 0;
    if (!ASN1Dec_CallIdentifier(dec, &(val)->callPickupId))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->groupMemberUserNr))
    return 0;
    if (!ASN1PERDecExtensionBit(dec, &x))
    return 0;
    if (!x) {
    if (!ASN1PERDecU32Val(dec, 1, &(val)->retrieveCallType))
        return 0;
    } else {
    if (!ASN1PERDecSkipNormallySmall(dec))
        return 0;
    }
    if (!ASN1Dec_EndpointAddress(dec, &(val)->partyToRetrieve))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->retrieveAddress))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1PERDecUnsignedShort(dec, &(val)->parkPosition))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Dec_GroupIndicationOnArg_extensionArg(dec, &(val)->extensionArg))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_GroupIndicationOnArg(GroupIndicationOnArg *val)
{
    if (val) {
    ASN1Free_CallIdentifier(&(val)->callPickupId);
    ASN1Free_EndpointAddress(&(val)->groupMemberUserNr);
    ASN1Free_EndpointAddress(&(val)->partyToRetrieve);
    ASN1Free_EndpointAddress(&(val)->retrieveAddress);
    if ((val)->o[0] & 0x40) {
        ASN1Free_GroupIndicationOnArg_extensionArg(&(val)->extensionArg);
    }
    }
}

static int ASN1CALL ASN1Enc_GroupIndicationOffArg(ASN1encoding_t enc, GroupIndicationOffArg *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 1, (val)->o))
    return 0;
    if (!ASN1Enc_CallIdentifier(enc, &(val)->callPickupId))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->groupMemberUserNr))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_GroupIndicationOffArg_extensionArg(enc, &(val)->extensionArg))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_GroupIndicationOffArg(ASN1decoding_t dec, GroupIndicationOffArg *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 1, (val)->o))
    return 0;
    if (!ASN1Dec_CallIdentifier(dec, &(val)->callPickupId))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->groupMemberUserNr))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_GroupIndicationOffArg_extensionArg(dec, &(val)->extensionArg))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_GroupIndicationOffArg(GroupIndicationOffArg *val)
{
    if (val) {
    ASN1Free_CallIdentifier(&(val)->callPickupId);
    ASN1Free_EndpointAddress(&(val)->groupMemberUserNr);
    if ((val)->o[0] & 0x80) {
        ASN1Free_GroupIndicationOffArg_extensionArg(&(val)->extensionArg);
    }
    }
}

static int ASN1CALL ASN1Enc_PickrequArg(ASN1encoding_t enc, PickrequArg *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 4, (val)->o))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->picking_upNumber))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_CallIdentifier(enc, &(val)->callPickupId))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Enc_EndpointAddress(enc, &(val)->partyToRetrieve))
        return 0;
    }
    if (!ASN1Enc_EndpointAddress(enc, &(val)->retrieveAddress))
    return 0;
    if ((val)->o[0] & 0x20) {
    if (!ASN1PEREncUnsignedShort(enc, (val)->parkPosition))
        return 0;
    }
    if ((val)->o[0] & 0x10) {
    if (!ASN1Enc_PickrequArg_extensionArg(enc, &(val)->extensionArg))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_PickrequArg(ASN1decoding_t dec, PickrequArg *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 4, (val)->o))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->picking_upNumber))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_CallIdentifier(dec, &(val)->callPickupId))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Dec_EndpointAddress(dec, &(val)->partyToRetrieve))
        return 0;
    }
    if (!ASN1Dec_EndpointAddress(dec, &(val)->retrieveAddress))
    return 0;
    if ((val)->o[0] & 0x20) {
    if (!ASN1PERDecUnsignedShort(dec, &(val)->parkPosition))
        return 0;
    }
    if ((val)->o[0] & 0x10) {
    if (!ASN1Dec_PickrequArg_extensionArg(dec, &(val)->extensionArg))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_PickrequArg(PickrequArg *val)
{
    if (val) {
    ASN1Free_EndpointAddress(&(val)->picking_upNumber);
    if ((val)->o[0] & 0x80) {
        ASN1Free_CallIdentifier(&(val)->callPickupId);
    }
    if ((val)->o[0] & 0x40) {
        ASN1Free_EndpointAddress(&(val)->partyToRetrieve);
    }
    ASN1Free_EndpointAddress(&(val)->retrieveAddress);
    if ((val)->o[0] & 0x10) {
        ASN1Free_PickrequArg_extensionArg(&(val)->extensionArg);
    }
    }
}

static int ASN1CALL ASN1Enc_PickupArg(ASN1encoding_t enc, PickupArg *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 1, (val)->o))
    return 0;
    if (!ASN1Enc_CallIdentifier(enc, &(val)->callPickupId))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->picking_upNumber))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_PickupArg_extensionArg(enc, &(val)->extensionArg))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_PickupArg(ASN1decoding_t dec, PickupArg *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 1, (val)->o))
    return 0;
    if (!ASN1Dec_CallIdentifier(dec, &(val)->callPickupId))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->picking_upNumber))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_PickupArg_extensionArg(dec, &(val)->extensionArg))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_PickupArg(PickupArg *val)
{
    if (val) {
    ASN1Free_CallIdentifier(&(val)->callPickupId);
    ASN1Free_EndpointAddress(&(val)->picking_upNumber);
    if ((val)->o[0] & 0x80) {
        ASN1Free_PickupArg_extensionArg(&(val)->extensionArg);
    }
    }
}

static int ASN1CALL ASN1Enc_PickExeArg(ASN1encoding_t enc, PickExeArg *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 1, (val)->o))
    return 0;
    if (!ASN1Enc_CallIdentifier(enc, &(val)->callPickupId))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->picking_upNumber))
    return 0;
    if (!ASN1Enc_EndpointAddress(enc, &(val)->partyToRetrieve))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_PickExeArg_extensionArg(enc, &(val)->extensionArg))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_PickExeArg(ASN1decoding_t dec, PickExeArg *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 1, (val)->o))
    return 0;
    if (!ASN1Dec_CallIdentifier(dec, &(val)->callPickupId))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->picking_upNumber))
    return 0;
    if (!ASN1Dec_EndpointAddress(dec, &(val)->partyToRetrieve))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_PickExeArg_extensionArg(dec, &(val)->extensionArg))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_PickExeArg(PickExeArg *val)
{
    if (val) {
    ASN1Free_CallIdentifier(&(val)->callPickupId);
    ASN1Free_EndpointAddress(&(val)->picking_upNumber);
    ASN1Free_EndpointAddress(&(val)->partyToRetrieve);
    if ((val)->o[0] & 0x80) {
        ASN1Free_PickExeArg_extensionArg(&(val)->extensionArg);
    }
    }
}

static int ASN1CALL ASN1Enc_CpNotifyArg(ASN1encoding_t enc, CpNotifyArg *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 2, (val)->o))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_EndpointAddress(enc, &(val)->parkingNumber))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Enc_CpNotifyArg_extensionArg(enc, &(val)->extensionArg))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CpNotifyArg(ASN1decoding_t dec, CpNotifyArg *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 2, (val)->o))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_EndpointAddress(dec, &(val)->parkingNumber))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Dec_CpNotifyArg_extensionArg(dec, &(val)->extensionArg))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CpNotifyArg(CpNotifyArg *val)
{
    if (val) {
    if ((val)->o[0] & 0x80) {
        ASN1Free_EndpointAddress(&(val)->parkingNumber);
    }
    if ((val)->o[0] & 0x40) {
        ASN1Free_CpNotifyArg_extensionArg(&(val)->extensionArg);
    }
    }
}

static int ASN1CALL ASN1Enc_CpickupNotifyArg(ASN1encoding_t enc, CpickupNotifyArg *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 2, (val)->o))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_EndpointAddress(enc, &(val)->picking_upNumber))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Enc_CpickupNotifyArg_extensionArg(enc, &(val)->extensionArg))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_CpickupNotifyArg(ASN1decoding_t dec, CpickupNotifyArg *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 2, (val)->o))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_EndpointAddress(dec, &(val)->picking_upNumber))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Dec_CpickupNotifyArg_extensionArg(dec, &(val)->extensionArg))
        return 0;
    }
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_CpickupNotifyArg(CpickupNotifyArg *val)
{
    if (val) {
    if ((val)->o[0] & 0x80) {
        ASN1Free_EndpointAddress(&(val)->picking_upNumber);
    }
    if ((val)->o[0] & 0x40) {
        ASN1Free_CpickupNotifyArg_extensionArg(&(val)->extensionArg);
    }
    }
}

static int ASN1CALL ASN1Enc_H4501SupplementaryService(ASN1encoding_t enc, H4501SupplementaryService *val)
{
    if (!ASN1PEREncExtensionBitClear(enc))
    return 0;
    if (!ASN1PEREncBits(enc, 2, (val)->o))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Enc_NetworkFacilityExtension(enc, &(val)->networkFacilityExtension))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Enc_InterpretationApdu(enc, &(val)->interpretationApdu))
        return 0;
    }
    if (!ASN1Enc_ServiceApdus(enc, &(val)->serviceApdu))
    return 0;
    return 1;
}

static int ASN1CALL ASN1Dec_H4501SupplementaryService(ASN1decoding_t dec, H4501SupplementaryService *val)
{
    ASN1uint32_t y;
    if (!ASN1PERDecExtensionBit(dec, &y))
    return 0;
    if (!ASN1PERDecExtension(dec, 2, (val)->o))
    return 0;
    if ((val)->o[0] & 0x80) {
    if (!ASN1Dec_NetworkFacilityExtension(dec, &(val)->networkFacilityExtension))
        return 0;
    }
    if ((val)->o[0] & 0x40) {
    if (!ASN1Dec_InterpretationApdu(dec, &(val)->interpretationApdu))
        return 0;
    }
    if (!ASN1Dec_ServiceApdus(dec, &(val)->serviceApdu))
    return 0;
    if (y) {
    if (!ASN1PERDecSkipNormallySmallExtensionFragmented(dec))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_H4501SupplementaryService(H4501SupplementaryService *val)
{
    if (val) {
    if ((val)->o[0] & 0x80) {
        ASN1Free_NetworkFacilityExtension(&(val)->networkFacilityExtension);
    }
    ASN1Free_ServiceApdus(&(val)->serviceApdu);
    }
}

static int ASN1CALL ASN1Enc_IntResultList(ASN1encoding_t enc, IntResultList *val)
{
    ASN1uint32_t i;
    if (!ASN1PEREncBitVal(enc, 5, (val)->count))
    return 0;
    for (i = 0; i < (val)->count; i++) {
    if (!ASN1Enc_IntResult(enc, &((val)->value)[i]))
        return 0;
    }
    return 1;
}

static int ASN1CALL ASN1Dec_IntResultList(ASN1decoding_t dec, IntResultList *val)
{
    ASN1uint32_t i;
    if (!ASN1PERDecU32Val(dec, 5, &(val)->count))
    return 0;
    for (i = 0; i < (val)->count; i++) {
    if (!ASN1Dec_IntResult(dec, &((val)->value)[i]))
        return 0;
    }
    return 1;
}

static void ASN1CALL ASN1Free_IntResultList(IntResultList *val)
{
    ASN1uint32_t i;
    if (val) {
    for (i = 0; i < (val)->count; i++) {
        ASN1Free_IntResult(&(val)->value[i]);
    }
    }
}