/*
 * Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
 * Copyright (c) 2011, 2012 Open Networking Foundation
 * Copyright 2013, Big Switch Networks, Inc. This library was generated by the LoxiGen Compiler.
 * Copyright 2018, Red Hat, Inc.
 */
// Automatically generated by LOXI from template module.go
// Do not modify

package of11

import (
	"bytes"
	"encoding/binary"
	"fmt"
	"net"

	"github.com/opencord/goloxi"
)

type OxmId struct {
	TypeLen uint32
}

type IOxmId interface {
	goloxi.Serializable
	GetTypeLen() uint32
	GetOXMName() string
}

func (self *OxmId) GetTypeLen() uint32 {
	return self.TypeLen
}

func (self *OxmId) SetTypeLen(v uint32) {
	self.TypeLen = v
}

func (self *OxmId) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint32(uint32(self.TypeLen))

	return nil
}

func DecodeOxmId(decoder *goloxi.Decoder) (IOxmId, error) {
	_oxmid := &OxmId{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmId packet too short: %d < 4", decoder.Length())
	}
	_oxmid.TypeLen = uint32(decoder.ReadUint32())

	switch _oxmid.TypeLen {
	case 126465:
		return DecodeOxmIdConnTrackingNwProto(_oxmid, decoder)
	case 7682:
		return DecodeOxmIdArpOp(_oxmid, decoder)
	case 2147500550:
		return DecodeOxmIdIpv6NdTll(_oxmid, decoder)
	case 84484:
		return DecodeOxmIdConjId(_oxmid, decoder)
	case 105976:
		return DecodeOxmIdTunMetadata38Masked(_oxmid, decoder)
	case 74246:
		return DecodeOxmIdArpSha(_oxmid, decoder)
	case 7169:
		return DecodeOxmIdIcmpCode(_oxmid, decoder)
	case 73736:
		return DecodeOxmIdTunId(_oxmid, decoder)
	case 2147484424:
		return DecodeOxmIdInPhyPortMasked(_oxmid, decoder)
	case 70408:
		return DecodeOxmIdReg9Masked(_oxmid, decoder)
	case 129026:
		return DecodeOxmIdConnTrackingTpSrc(_oxmid, decoder)
	case 127492:
		return DecodeOxmIdConnTrackingNwDst(_oxmid, decoder)
	case 2147484680:
		return DecodeOxmIdMetadata(_oxmid, decoder)
	case 128528:
		return DecodeOxmIdConnTrackingIpv6Dst(_oxmid, decoder)
	case 94332:
		return DecodeOxmIdTunMetadata16(_oxmid, decoder)
	case 129538:
		return DecodeOxmIdConnTrackingTpDst(_oxmid, decoder)
	case 108536:
		return DecodeOxmIdTunMetadata43Masked(_oxmid, decoder)
	case 106488:
		return DecodeOxmIdTunMetadata39Masked(_oxmid, decoder)
	case 112764:
		return DecodeOxmIdTunMetadata52(_oxmid, decoder)
	case 8708:
		return DecodeOxmIdArpTpa(_oxmid, decoder)
	case 2147498754:
		return DecodeOxmIdIcmpv6TypeMasked(_oxmid, decoder)
	case 89080:
		return DecodeOxmIdTunMetadata5Masked(_oxmid, decoder)
	case 94844:
		return DecodeOxmIdTunMetadata17(_oxmid, decoder)
	case 74758:
		return DecodeOxmIdArpTha(_oxmid, decoder)
	case 99964:
		return DecodeOxmIdTunMetadata27(_oxmid, decoder)
	case 67336:
		return DecodeOxmIdReg3Masked(_oxmid, decoder)
	case 115192:
		return DecodeOxmIdTunMetadata56Masked(_oxmid, decoder)
	case 71172:
		return DecodeOxmIdReg11(_oxmid, decoder)
	case 79364:
		return DecodeOxmIdIpv6Label(_oxmid, decoder)
	case 73480:
		return DecodeOxmIdReg15Masked(_oxmid, decoder)
	case 120068:
		return DecodeOxmIdConnTrackingZoneMasked(_oxmid, decoder)
	case 107512:
		return DecodeOxmIdTunMetadata41Masked(_oxmid, decoder)
	case 116348:
		return DecodeOxmIdTunMetadata59(_oxmid, decoder)
	case 89592:
		return DecodeOxmIdTunMetadata6Masked(_oxmid, decoder)
	case 110204:
		return DecodeOxmIdTunMetadata47(_oxmid, decoder)
	case 77830:
		return DecodeOxmIdNdSll(_oxmid, decoder)
	case 117372:
		return DecodeOxmIdTunMetadata61(_oxmid, decoder)
	case 2147489796:
		return DecodeOxmIdIpv4Dst(_oxmid, decoder)
	case 2147497988:
		return DecodeOxmIdIpv6Flabel(_oxmid, decoder)
	case 103928:
		return DecodeOxmIdTunMetadata34Masked(_oxmid, decoder)
	case 95868:
		return DecodeOxmIdTunMetadata19(_oxmid, decoder)
	case 2:
		return DecodeOxmIdInPort(_oxmid, decoder)
	case 74507:
		return DecodeOxmIdArpShaMasked(_oxmid, decoder)
	case 96892:
		return DecodeOxmIdTunMetadata21(_oxmid, decoder)
	case 108024:
		return DecodeOxmIdTunMetadata42Masked(_oxmid, decoder)
	case 129284:
		return DecodeOxmIdConnTrackingTpSrcMasked(_oxmid, decoder)
	case 112120:
		return DecodeOxmIdTunMetadata50Masked(_oxmid, decoder)
	case 2147484944:
		return DecodeOxmIdMetadataMasked(_oxmid, decoder)
	case 2147500812:
		return DecodeOxmIdIpv6NdTllMasked(_oxmid, decoder)
	case 78342:
		return DecodeOxmIdNdTll(_oxmid, decoder)
	case 2147486468:
		return DecodeOxmIdEthTypeMasked(_oxmid, decoder)
	case 96380:
		return DecodeOxmIdTunMetadata20(_oxmid, decoder)
	case 113276:
		return DecodeOxmIdTunMetadata53(_oxmid, decoder)
	case 92152:
		return DecodeOxmIdTunMetadata11Masked(_oxmid, decoder)
	case 129796:
		return DecodeOxmIdConnTrackingTpDstMasked(_oxmid, decoder)
	case 103548:
		return DecodeOxmIdTunMetadata34(_oxmid, decoder)
	case 120324:
		return DecodeOxmIdConnTrackingMark(_oxmid, decoder)
	case 118776:
		return DecodeOxmIdTunMetadata63Masked(_oxmid, decoder)
	case 90748:
		return DecodeOxmIdTunMetadata9(_oxmid, decoder)
	case 128016:
		return DecodeOxmIdConnTrackingIpv6Src(_oxmid, decoder)
	case 82946:
		return DecodeOxmIdTcpFlags(_oxmid, decoder)
	case 80897:
		return DecodeOxmIdMplsTtl(_oxmid, decoder)
	case 92664:
		return DecodeOxmIdTunMetadata12Masked(_oxmid, decoder)
	case 123408:
		return DecodeOxmIdXxreg2(_oxmid, decoder)
	case 2147499266:
		return DecodeOxmIdIcmpv6CodeMasked(_oxmid, decoder)
	case 2147489544:
		return DecodeOxmIdIpv4SrcMasked(_oxmid, decoder)
	case 2147487490:
		return DecodeOxmIdVlanPcpMasked(_oxmid, decoder)
	case 81412:
		return DecodeOxmIdTunSrc(_oxmid, decoder)
	case 5122:
		return DecodeOxmIdTcpDst(_oxmid, decoder)
	case 97404:
		return DecodeOxmIdTunMetadata22(_oxmid, decoder)
	case 1538:
		return DecodeOxmIdEthType(_oxmid, decoder)
	case 2561:
		return DecodeOxmIdNwTos(_oxmid, decoder)
	case 93176:
		return DecodeOxmIdTunMetadata13Masked(_oxmid, decoder)
	case 67848:
		return DecodeOxmIdReg4Masked(_oxmid, decoder)
	case 115704:
		return DecodeOxmIdTunMetadata57Masked(_oxmid, decoder)
	case 86140:
		return DecodeOxmIdTunMetadata0(_oxmid, decoder)
	case 65540:
		return DecodeOxmIdReg0(_oxmid, decoder)
	case 2147500038:
		return DecodeOxmIdIpv6NdSll(_oxmid, decoder)
	case 97916:
		return DecodeOxmIdTunMetadata23(_oxmid, decoder)
	case 2050:
		return DecodeOxmIdVlanTci(_oxmid, decoder)
	case 3073:
		return DecodeOxmIdNwProto(_oxmid, decoder)
	case 93688:
		return DecodeOxmIdTunMetadata14Masked(_oxmid, decoder)
	case 116860:
		return DecodeOxmIdTunMetadata60(_oxmid, decoder)
	case 2147487233:
		return DecodeOxmIdVlanPcp(_oxmid, decoder)
	case 2147484164:
		return DecodeOxmIdInPhyPort(_oxmid, decoder)
	case 2147486980:
		return DecodeOxmIdVlanVidMasked(_oxmid, decoder)
	case 113144:
		return DecodeOxmIdTunMetadata52Masked(_oxmid, decoder)
	case 82436:
		return DecodeOxmIdPktMark(_oxmid, decoder)
	case 121120:
		return DecodeOxmIdConnTrackingLabelMasked(_oxmid, decoder)
	case 98428:
		return DecodeOxmIdTunMetadata24(_oxmid, decoder)
	case 85505:
		return DecodeOxmIdTunGbpFlags(_oxmid, decoder)
	case 94200:
		return DecodeOxmIdTunMetadata15Masked(_oxmid, decoder)
	case 112632:
		return DecodeOxmIdTunMetadata51Masked(_oxmid, decoder)
	case 5378:
		return DecodeOxmIdTcpDstMasked(_oxmid, decoder)
	case 2147486722:
		return DecodeOxmIdVlanVid(_oxmid, decoder)
	case 66564:
		return DecodeOxmIdReg2(_oxmid, decoder)
	case 121632:
		return DecodeOxmIdTunIpv6SrcMasked(_oxmid, decoder)
	case 103416:
		return DecodeOxmIdTunMetadata33Masked(_oxmid, decoder)
	case 98940:
		return DecodeOxmIdTunMetadata25(_oxmid, decoder)
	case 84994:
		return DecodeOxmIdTunGbpId(_oxmid, decoder)
	case 2147487745:
		return DecodeOxmIdIpDscp(_oxmid, decoder)
	case 94712:
		return DecodeOxmIdTunMetadata16Masked(_oxmid, decoder)
	case 120848:
		return DecodeOxmIdConnTrackingLabel(_oxmid, decoder)
	case 109692:
		return DecodeOxmIdTunMetadata46(_oxmid, decoder)
	case 69896:
		return DecodeOxmIdReg8Masked(_oxmid, decoder)
	case 104060:
		return DecodeOxmIdTunMetadata35(_oxmid, decoder)
	case 71432:
		return DecodeOxmIdReg11Masked(_oxmid, decoder)
	case 110584:
		return DecodeOxmIdTunMetadata47Masked(_oxmid, decoder)
	case 79624:
		return DecodeOxmIdIpv6LabelMasked(_oxmid, decoder)
	case 122144:
		return DecodeOxmIdTunIpv6DstMasked(_oxmid, decoder)
	case 99452:
		return DecodeOxmIdTunMetadata26(_oxmid, decoder)
	case 109560:
		return DecodeOxmIdTunMetadata45Masked(_oxmid, decoder)
	case 95224:
		return DecodeOxmIdTunMetadata17Masked(_oxmid, decoder)
	case 121360:
		return DecodeOxmIdTunIpv6Src(_oxmid, decoder)
	case 85762:
		return DecodeOxmIdTunGbpFlagsMasked(_oxmid, decoder)
	case 2147490056:
		return DecodeOxmIdIpv4DstMasked(_oxmid, decoder)
	case 83972:
		return DecodeOxmIdRecircId(_oxmid, decoder)
	case 122656:
		return DecodeOxmIdXxreg0Masked(_oxmid, decoder)
	case 128800:
		return DecodeOxmIdConnTrackingIpv6DstMasked(_oxmid, decoder)
	case 118786:
		return DecodeOxmIdTunFlags(_oxmid, decoder)
	case 2147488769:
		return DecodeOxmIdIpProto(_oxmid, decoder)
	case 95736:
		return DecodeOxmIdTunMetadata18Masked(_oxmid, decoder)
	case 121872:
		return DecodeOxmIdTunIpv6Dst(_oxmid, decoder)
	case 81924:
		return DecodeOxmIdTunDst(_oxmid, decoder)
	case 68360:
		return DecodeOxmIdReg5Masked(_oxmid, decoder)
	case 518:
		return DecodeOxmIdEthDst(_oxmid, decoder)
	case 116216:
		return DecodeOxmIdTunMetadata58Masked(_oxmid, decoder)
	case 114300:
		return DecodeOxmIdTunMetadata55(_oxmid, decoder)
	case 68100:
		return DecodeOxmIdReg5(_oxmid, decoder)
	case 123168:
		return DecodeOxmIdXxreg1Masked(_oxmid, decoder)
	case 100476:
		return DecodeOxmIdTunMetadata28(_oxmid, decoder)
	case 4610:
		return DecodeOxmIdTcpSrc(_oxmid, decoder)
	case 123680:
		return DecodeOxmIdXxreg2Masked(_oxmid, decoder)
	case 96248:
		return DecodeOxmIdTunMetadata19Masked(_oxmid, decoder)
	case 122384:
		return DecodeOxmIdXxreg0(_oxmid, decoder)
	case 78091:
		return DecodeOxmIdNdSllMasked(_oxmid, decoder)
	case 1030:
		return DecodeOxmIdEthSrc(_oxmid, decoder)
	case 68612:
		return DecodeOxmIdReg6(_oxmid, decoder)
	case 107644:
		return DecodeOxmIdTunMetadata42(_oxmid, decoder)
	case 100988:
		return DecodeOxmIdTunMetadata29(_oxmid, decoder)
	case 119810:
		return DecodeOxmIdConnTrackingZone(_oxmid, decoder)
	case 96760:
		return DecodeOxmIdTunMetadata20Masked(_oxmid, decoder)
	case 85252:
		return DecodeOxmIdTunGbpIdMasked(_oxmid, decoder)
	case 78603:
		return DecodeOxmIdNdTllMasked(_oxmid, decoder)
	case 86652:
		return DecodeOxmIdTunMetadata1(_oxmid, decoder)
	case 69124:
		return DecodeOxmIdReg7(_oxmid, decoder)
	case 88188:
		return DecodeOxmIdTunMetadata4(_oxmid, decoder)
	case 3588:
		return DecodeOxmIdIpSrc(_oxmid, decoder)
	case 124192:
		return DecodeOxmIdXxreg3Masked(_oxmid, decoder)
	case 101500:
		return DecodeOxmIdTunMetadata30(_oxmid, decoder)
	case 5634:
		return DecodeOxmIdUdpSrc(_oxmid, decoder)
	case 127240:
		return DecodeOxmIdConnTrackingNwSrcMasked(_oxmid, decoder)
	case 6657:
		return DecodeOxmIdIcmpType(_oxmid, decoder)
	case 97272:
		return DecodeOxmIdTunMetadata21Masked(_oxmid, decoder)
	case 81672:
		return DecodeOxmIdTunSrcMasked(_oxmid, decoder)
	case 122896:
		return DecodeOxmIdXxreg1(_oxmid, decoder)
	case 2147489026:
		return DecodeOxmIdIpProtoMasked(_oxmid, decoder)
	case 2147483912:
		return DecodeOxmIdInPortMasked(_oxmid, decoder)
	case 4100:
		return DecodeOxmIdIpDst(_oxmid, decoder)
	case 65800:
		return DecodeOxmIdReg0Masked(_oxmid, decoder)
	case 75552:
		return DecodeOxmIdIpv6SrcMasked(_oxmid, decoder)
	case 102012:
		return DecodeOxmIdTunMetadata31(_oxmid, decoder)
	case 79106:
		return DecodeOxmIdIpFragMasked(_oxmid, decoder)
	case 2147501826:
		return DecodeOxmIdMplsTcMasked(_oxmid, decoder)
	case 8452:
		return DecodeOxmIdArpSpaMasked(_oxmid, decoder)
	case 97784:
		return DecodeOxmIdTunMetadata22Masked(_oxmid, decoder)
	case 1286:
		return DecodeOxmIdEthSrcMasked(_oxmid, decoder)
	case 66052:
		return DecodeOxmIdReg1(_oxmid, decoder)
	case 8968:
		return DecodeOxmIdArpTpaMasked(_oxmid, decoder)
	case 2147488514:
		return DecodeOxmIdIpEcnMasked(_oxmid, decoder)
	case 75019:
		return DecodeOxmIdArpThaMasked(_oxmid, decoder)
	case 2147500300:
		return DecodeOxmIdIpv6NdSllMasked(_oxmid, decoder)
	case 66312:
		return DecodeOxmIdReg1Masked(_oxmid, decoder)
	case 74000:
		return DecodeOxmIdTunIdMasked(_oxmid, decoder)
	case 102524:
		return DecodeOxmIdTunMetadata32(_oxmid, decoder)
	case 111228:
		return DecodeOxmIdTunMetadata49(_oxmid, decoder)
	case 88568:
		return DecodeOxmIdTunMetadata4Masked(_oxmid, decoder)
	case 2147499536:
		return DecodeOxmIdIpv6NdTarget(_oxmid, decoder)
	case 98296:
		return DecodeOxmIdTunMetadata23Masked(_oxmid, decoder)
	case 75280:
		return DecodeOxmIdIpv6Src(_oxmid, decoder)
	case 68872:
		return DecodeOxmIdReg6Masked(_oxmid, decoder)
	case 116728:
		return DecodeOxmIdTunMetadata59Masked(_oxmid, decoder)
	case 110072:
		return DecodeOxmIdTunMetadata46Masked(_oxmid, decoder)
	case 70660:
		return DecodeOxmIdReg10(_oxmid, decoder)
	case 76064:
		return DecodeOxmIdIpv6DstMasked(_oxmid, decoder)
	case 103036:
		return DecodeOxmIdTunMetadata33(_oxmid, decoder)
	case 107000:
		return DecodeOxmIdTunMetadata40Masked(_oxmid, decoder)
	case 110716:
		return DecodeOxmIdTunMetadata48(_oxmid, decoder)
	case 98808:
		return DecodeOxmIdTunMetadata24Masked(_oxmid, decoder)
	case 75792:
		return DecodeOxmIdIpv6Dst(_oxmid, decoder)
	case 2147501060:
		return DecodeOxmIdMplsLabel(_oxmid, decoder)
	case 73220:
		return DecodeOxmIdReg15(_oxmid, decoder)
	case 117884:
		return DecodeOxmIdTunMetadata62(_oxmid, decoder)
	case 83720:
		return DecodeOxmIdDpHashMasked(_oxmid, decoder)
	case 108156:
		return DecodeOxmIdTunMetadata43(_oxmid, decoder)
	case 87164:
		return DecodeOxmIdTunMetadata2(_oxmid, decoder)
	case 99320:
		return DecodeOxmIdTunMetadata25Masked(_oxmid, decoder)
	case 5892:
		return DecodeOxmIdUdpSrcMasked(_oxmid, decoder)
	case 113656:
		return DecodeOxmIdTunMetadata53Masked(_oxmid, decoder)
	case 69636:
		return DecodeOxmIdReg8(_oxmid, decoder)
	case 88700:
		return DecodeOxmIdTunMetadata5(_oxmid, decoder)
	case 113788:
		return DecodeOxmIdTunMetadata54(_oxmid, decoder)
	case 71684:
		return DecodeOxmIdReg12(_oxmid, decoder)
	case 77600:
		return DecodeOxmIdNdTargetMasked(_oxmid, decoder)
	case 87676:
		return DecodeOxmIdTunMetadata3(_oxmid, decoder)
	case 127752:
		return DecodeOxmIdConnTrackingNwDstMasked(_oxmid, decoder)
	case 99832:
		return DecodeOxmIdTunMetadata26Masked(_oxmid, decoder)
	case 114812:
		return DecodeOxmIdTunMetadata56(_oxmid, decoder)
	case 82184:
		return DecodeOxmIdTunDstMasked(_oxmid, decoder)
	case 90236:
		return DecodeOxmIdTunMetadata8(_oxmid, decoder)
	case 72196:
		return DecodeOxmIdReg13(_oxmid, decoder)
	case 104572:
		return DecodeOxmIdTunMetadata36(_oxmid, decoder)
	case 2147492354:
		return DecodeOxmIdSctpSrc(_oxmid, decoder)
	case 95356:
		return DecodeOxmIdTunMetadata18(_oxmid, decoder)
	case 2147493377:
		return DecodeOxmIdIcmpv4Type(_oxmid, decoder)
	case 100344:
		return DecodeOxmIdTunMetadata27Masked(_oxmid, decoder)
	case 77328:
		return DecodeOxmIdNdTarget(_oxmid, decoder)
	case 2147488257:
		return DecodeOxmIdIpEcn(_oxmid, decoder)
	case 118264:
		return DecodeOxmIdTunMetadata62Masked(_oxmid, decoder)
	case 90616:
		return DecodeOxmIdTunMetadata8Masked(_oxmid, decoder)
	case 72708:
		return DecodeOxmIdReg14(_oxmid, decoder)
	case 114680:
		return DecodeOxmIdTunMetadata55Masked(_oxmid, decoder)
	case 105084:
		return DecodeOxmIdTunMetadata37(_oxmid, decoder)
	case 91128:
		return DecodeOxmIdTunMetadata9Masked(_oxmid, decoder)
	case 111740:
		return DecodeOxmIdTunMetadata50(_oxmid, decoder)
	case 2147493889:
		return DecodeOxmIdIcmpv4Code(_oxmid, decoder)
	case 100856:
		return DecodeOxmIdTunMetadata28Masked(_oxmid, decoder)
	case 2308:
		return DecodeOxmIdVlanTciMasked(_oxmid, decoder)
	case 2147501320:
		return DecodeOxmIdMplsLabelMasked(_oxmid, decoder)
	case 779:
		return DecodeOxmIdEthDstMasked(_oxmid, decoder)
	case 2147493124:
		return DecodeOxmIdSctpDstMasked(_oxmid, decoder)
	case 69384:
		return DecodeOxmIdReg7Masked(_oxmid, decoder)
	case 117240:
		return DecodeOxmIdTunMetadata60Masked(_oxmid, decoder)
	case 3848:
		return DecodeOxmIdIpSrcMasked(_oxmid, decoder)
	case 128288:
		return DecodeOxmIdConnTrackingIpv6SrcMasked(_oxmid, decoder)
	case 92284:
		return DecodeOxmIdTunMetadata12(_oxmid, decoder)
	case 105596:
		return DecodeOxmIdTunMetadata38(_oxmid, decoder)
	case 4868:
		return DecodeOxmIdTcpSrcMasked(_oxmid, decoder)
	case 76289:
		return DecodeOxmIdIcmpv6Type(_oxmid, decoder)
	case 101368:
		return DecodeOxmIdTunMetadata29Masked(_oxmid, decoder)
	case 88056:
		return DecodeOxmIdTunMetadata3Masked(_oxmid, decoder)
	case 118396:
		return DecodeOxmIdTunMetadata63(_oxmid, decoder)
	case 2147493634:
		return DecodeOxmIdIcmpv4TypeMasked(_oxmid, decoder)
	case 4360:
		return DecodeOxmIdIpDstMasked(_oxmid, decoder)
	case 8196:
		return DecodeOxmIdArpSpa(_oxmid, decoder)
	case 108668:
		return DecodeOxmIdTunMetadata44(_oxmid, decoder)
	case 106108:
		return DecodeOxmIdTunMetadata39(_oxmid, decoder)
	case 76801:
		return DecodeOxmIdIcmpv6Code(_oxmid, decoder)
	case 101880:
		return DecodeOxmIdTunMetadata30Masked(_oxmid, decoder)
	case 114168:
		return DecodeOxmIdTunMetadata54Masked(_oxmid, decoder)
	case 2147494146:
		return DecodeOxmIdIcmpv4CodeMasked(_oxmid, decoder)
	case 70148:
		return DecodeOxmIdReg9(_oxmid, decoder)
	case 89212:
		return DecodeOxmIdTunMetadata6(_oxmid, decoder)
	case 119560:
		return DecodeOxmIdConnTrackingStateMasked(_oxmid, decoder)
	case 83204:
		return DecodeOxmIdTcpFlagsMasked(_oxmid, decoder)
	case 106620:
		return DecodeOxmIdTunMetadata40(_oxmid, decoder)
	case 6146:
		return DecodeOxmIdUdpDst(_oxmid, decoder)
	case 119044:
		return DecodeOxmIdTunFlagsMasked(_oxmid, decoder)
	case 102392:
		return DecodeOxmIdTunMetadata31Masked(_oxmid, decoder)
	case 115324:
		return DecodeOxmIdTunMetadata57(_oxmid, decoder)
	case 82696:
		return DecodeOxmIdPktMarkMasked(_oxmid, decoder)
	case 123920:
		return DecodeOxmIdXxreg3(_oxmid, decoder)
	case 70920:
		return DecodeOxmIdReg10Masked(_oxmid, decoder)
	case 107132:
		return DecodeOxmIdTunMetadata41(_oxmid, decoder)
	case 102904:
		return DecodeOxmIdTunMetadata32Masked(_oxmid, decoder)
	case 111096:
		return DecodeOxmIdTunMetadata48Masked(_oxmid, decoder)
	case 67076:
		return DecodeOxmIdReg3(_oxmid, decoder)
	case 120584:
		return DecodeOxmIdConnTrackingMarkMasked(_oxmid, decoder)
	case 91260:
		return DecodeOxmIdTunMetadata10(_oxmid, decoder)
	case 112252:
		return DecodeOxmIdTunMetadata51(_oxmid, decoder)
	case 87032:
		return DecodeOxmIdTunMetadata1Masked(_oxmid, decoder)
	case 2147501569:
		return DecodeOxmIdMplsTc(_oxmid, decoder)
	case 83460:
		return DecodeOxmIdDpHash(_oxmid, decoder)
	case 126722:
		return DecodeOxmIdConnTrackingNwProtoMasked(_oxmid, decoder)
	case 119300:
		return DecodeOxmIdConnTrackingState(_oxmid, decoder)
	case 117752:
		return DecodeOxmIdTunMetadata61Masked(_oxmid, decoder)
	case 71944:
		return DecodeOxmIdReg12Masked(_oxmid, decoder)
	case 2147499808:
		return DecodeOxmIdIpv6NdTargetMasked(_oxmid, decoder)
	case 91772:
		return DecodeOxmIdTunMetadata11(_oxmid, decoder)
	case 78849:
		return DecodeOxmIdIpFrag(_oxmid, decoder)
	case 87544:
		return DecodeOxmIdTunMetadata2Masked(_oxmid, decoder)
	case 90104:
		return DecodeOxmIdTunMetadata7Masked(_oxmid, decoder)
	case 72456:
		return DecodeOxmIdReg13Masked(_oxmid, decoder)
	case 109180:
		return DecodeOxmIdTunMetadata45(_oxmid, decoder)
	case 91640:
		return DecodeOxmIdTunMetadata10Masked(_oxmid, decoder)
	case 2147498248:
		return DecodeOxmIdIpv6FlabelMasked(_oxmid, decoder)
	case 2147492612:
		return DecodeOxmIdSctpSrcMasked(_oxmid, decoder)
	case 104440:
		return DecodeOxmIdTunMetadata35Masked(_oxmid, decoder)
	case 2147494660:
		return DecodeOxmIdArpOpMasked(_oxmid, decoder)
	case 66824:
		return DecodeOxmIdReg2Masked(_oxmid, decoder)
	case 109048:
		return DecodeOxmIdTunMetadata44Masked(_oxmid, decoder)
	case 2147492866:
		return DecodeOxmIdSctpDst(_oxmid, decoder)
	case 89724:
		return DecodeOxmIdTunMetadata7(_oxmid, decoder)
	case 72968:
		return DecodeOxmIdReg14Masked(_oxmid, decoder)
	case 92796:
		return DecodeOxmIdTunMetadata13(_oxmid, decoder)
	case 79873:
		return DecodeOxmIdNwEcn(_oxmid, decoder)
	case 104952:
		return DecodeOxmIdTunMetadata36Masked(_oxmid, decoder)
	case 115836:
		return DecodeOxmIdTunMetadata58(_oxmid, decoder)
	case 93820:
		return DecodeOxmIdTunMetadata15(_oxmid, decoder)
	case 2147489284:
		return DecodeOxmIdIpv4Src(_oxmid, decoder)
	case 93308:
		return DecodeOxmIdTunMetadata14(_oxmid, decoder)
	case 80385:
		return DecodeOxmIdNwTtl(_oxmid, decoder)
	case 105464:
		return DecodeOxmIdTunMetadata37Masked(_oxmid, decoder)
	case 111608:
		return DecodeOxmIdTunMetadata49Masked(_oxmid, decoder)
	case 2147488002:
		return DecodeOxmIdIpDscpMasked(_oxmid, decoder)
	case 86520:
		return DecodeOxmIdTunMetadata0Masked(_oxmid, decoder)
	case 67588:
		return DecodeOxmIdReg4(_oxmid, decoder)
	case 6404:
		return DecodeOxmIdUdpDstMasked(_oxmid, decoder)
	case 126980:
		return DecodeOxmIdConnTrackingNwSrc(_oxmid, decoder)
	default:
		return _oxmid, nil
	}
}

func NewOxmId(_type_len uint32) *OxmId {
	obj := &OxmId{}
	obj.TypeLen = _type_len
	return obj
}
func (self *OxmId) GetOXMName() string {
	return ""
}

func (self *OxmId) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type ActionNxBundleLoadSlave struct {
	Port Port
}

type IActionNxBundleLoadSlave interface {
	goloxi.Serializable
	GetPort() Port
}

func (self *ActionNxBundleLoadSlave) GetPort() Port {
	return self.Port
}

func (self *ActionNxBundleLoadSlave) SetPort(v Port) {
	self.Port = v
}

func (self *ActionNxBundleLoadSlave) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint32(uint32(self.Port))

	return nil
}

func DecodeActionNxBundleLoadSlave(decoder *goloxi.Decoder) (*ActionNxBundleLoadSlave, error) {
	_actionnxbundleloadslave := &ActionNxBundleLoadSlave{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("ActionNxBundleLoadSlave packet too short: %d < 4", decoder.Length())
	}
	_actionnxbundleloadslave.Port = Port(decoder.ReadUint32())
	return _actionnxbundleloadslave, nil
}

func NewActionNxBundleLoadSlave() *ActionNxBundleLoadSlave {
	obj := &ActionNxBundleLoadSlave{}
	return obj
}

type ActionNxController2Property struct {
	Type NxActionController2PropType
}

type IActionNxController2Property interface {
	goloxi.Serializable
	GetType() NxActionController2PropType
}

func (self *ActionNxController2Property) GetType() NxActionController2PropType {
	return self.Type
}

func (self *ActionNxController2Property) SetType(v NxActionController2PropType) {
	self.Type = v
}

func (self *ActionNxController2Property) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Type))

	return nil
}

func DecodeActionNxController2Property(decoder *goloxi.Decoder) (IActionNxController2Property, error) {
	_actionnxcontroller2property := &ActionNxController2Property{}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("ActionNxController2Property packet too short: %d < 2", decoder.Length())
	}
	_actionnxcontroller2property.Type = NxActionController2PropType(decoder.ReadUint16())

	switch _actionnxcontroller2property.Type {
	case 0:
		return DecodeActionNxController2PropertyMaxLen(_actionnxcontroller2property, decoder)
	case 1:
		return DecodeActionNxController2PropertyControllerId(_actionnxcontroller2property, decoder)
	case 2:
		return DecodeActionNxController2PropertyReason(_actionnxcontroller2property, decoder)
	case 3:
		return DecodeActionNxController2PropertyUserdata(_actionnxcontroller2property, decoder)
	case 4:
		return DecodeActionNxController2PropertyPause(_actionnxcontroller2property, decoder)
	case 5:
		return DecodeActionNxController2PropertyMeterId(_actionnxcontroller2property, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'ActionNxController2Property'", _actionnxcontroller2property.Type)
	}
}

func NewActionNxController2Property(_type NxActionController2PropType) *ActionNxController2Property {
	obj := &ActionNxController2Property{}
	obj.Type = _type
	return obj
}

type ActionNxController2PropertyControllerId struct {
	*ActionNxController2Property
	ControllerId uint16
}

type IActionNxController2PropertyControllerId interface {
	IActionNxController2Property
	GetControllerId() uint16
}

func (self *ActionNxController2PropertyControllerId) GetControllerId() uint16 {
	return self.ControllerId
}

func (self *ActionNxController2PropertyControllerId) SetControllerId(v uint16) {
	self.ControllerId = v
}

func (self *ActionNxController2PropertyControllerId) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.ControllerId))
	length := len(encoder.Bytes()) - startIndex
	alignedLength := ((length + 7) / 8 * 8)

	encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))

	return nil
}

func DecodeActionNxController2PropertyControllerId(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyControllerId, error) {
	_actionnxcontroller2propertycontrollerid := &ActionNxController2PropertyControllerId{ActionNxController2Property: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("ActionNxController2PropertyControllerId packet too short: %d < 2", decoder.Length())
	}
	defer decoder.SkipAlign()

	_actionnxcontroller2propertycontrollerid.ControllerId = uint16(decoder.ReadUint16())
	return _actionnxcontroller2propertycontrollerid, nil
}

func NewActionNxController2PropertyControllerId() *ActionNxController2PropertyControllerId {
	obj := &ActionNxController2PropertyControllerId{
		ActionNxController2Property: NewActionNxController2Property(1),
	}
	return obj
}

type ActionNxController2PropertyMaxLen struct {
	*ActionNxController2Property
	MaxLen uint16
}

type IActionNxController2PropertyMaxLen interface {
	IActionNxController2Property
	GetMaxLen() uint16
}

func (self *ActionNxController2PropertyMaxLen) GetMaxLen() uint16 {
	return self.MaxLen
}

func (self *ActionNxController2PropertyMaxLen) SetMaxLen(v uint16) {
	self.MaxLen = v
}

func (self *ActionNxController2PropertyMaxLen) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.MaxLen))
	length := len(encoder.Bytes()) - startIndex
	alignedLength := ((length + 7) / 8 * 8)

	encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))

	return nil
}

func DecodeActionNxController2PropertyMaxLen(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyMaxLen, error) {
	_actionnxcontroller2propertymaxlen := &ActionNxController2PropertyMaxLen{ActionNxController2Property: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("ActionNxController2PropertyMaxLen packet too short: %d < 2", decoder.Length())
	}
	defer decoder.SkipAlign()

	_actionnxcontroller2propertymaxlen.MaxLen = uint16(decoder.ReadUint16())
	return _actionnxcontroller2propertymaxlen, nil
}

func NewActionNxController2PropertyMaxLen() *ActionNxController2PropertyMaxLen {
	obj := &ActionNxController2PropertyMaxLen{
		ActionNxController2Property: NewActionNxController2Property(0),
	}
	return obj
}

type ActionNxController2PropertyMeterId struct {
	*ActionNxController2Property
	MeterId uint32
}

type IActionNxController2PropertyMeterId interface {
	IActionNxController2Property
	GetMeterId() uint32
}

func (self *ActionNxController2PropertyMeterId) GetMeterId() uint32 {
	return self.MeterId
}

func (self *ActionNxController2PropertyMeterId) SetMeterId(v uint32) {
	self.MeterId = v
}

func (self *ActionNxController2PropertyMeterId) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.MeterId))
	length := len(encoder.Bytes()) - startIndex
	alignedLength := ((length + 7) / 8 * 8)

	encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))

	return nil
}

func DecodeActionNxController2PropertyMeterId(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyMeterId, error) {
	_actionnxcontroller2propertymeterid := &ActionNxController2PropertyMeterId{ActionNxController2Property: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("ActionNxController2PropertyMeterId packet too short: %d < 4", decoder.Length())
	}
	defer decoder.SkipAlign()

	_actionnxcontroller2propertymeterid.MeterId = uint32(decoder.ReadUint32())
	return _actionnxcontroller2propertymeterid, nil
}

func NewActionNxController2PropertyMeterId() *ActionNxController2PropertyMeterId {
	obj := &ActionNxController2PropertyMeterId{
		ActionNxController2Property: NewActionNxController2Property(5),
	}
	return obj
}

type ActionNxController2PropertyPause struct {
	*ActionNxController2Property
}

type IActionNxController2PropertyPause interface {
	IActionNxController2Property
}

func (self *ActionNxController2PropertyPause) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex
	alignedLength := ((length + 7) / 8 * 8)

	encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))

	return nil
}

func DecodeActionNxController2PropertyPause(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyPause, error) {
	_actionnxcontroller2propertypause := &ActionNxController2PropertyPause{ActionNxController2Property: parent}
	defer decoder.SkipAlign()

	return _actionnxcontroller2propertypause, nil
}

func NewActionNxController2PropertyPause() *ActionNxController2PropertyPause {
	obj := &ActionNxController2PropertyPause{
		ActionNxController2Property: NewActionNxController2Property(4),
	}
	return obj
}

type ActionNxController2PropertyReason struct {
	*ActionNxController2Property
	Reason PacketInReason
}

type IActionNxController2PropertyReason interface {
	IActionNxController2Property
	GetReason() PacketInReason
}

func (self *ActionNxController2PropertyReason) GetReason() PacketInReason {
	return self.Reason
}

func (self *ActionNxController2PropertyReason) SetReason(v PacketInReason) {
	self.Reason = v
}

func (self *ActionNxController2PropertyReason) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Reason))
	length := len(encoder.Bytes()) - startIndex
	alignedLength := ((length + 7) / 8 * 8)

	encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))

	return nil
}

func DecodeActionNxController2PropertyReason(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyReason, error) {
	_actionnxcontroller2propertyreason := &ActionNxController2PropertyReason{ActionNxController2Property: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("ActionNxController2PropertyReason packet too short: %d < 1", decoder.Length())
	}
	defer decoder.SkipAlign()

	_actionnxcontroller2propertyreason.Reason = PacketInReason(decoder.ReadByte())
	return _actionnxcontroller2propertyreason, nil
}

func NewActionNxController2PropertyReason() *ActionNxController2PropertyReason {
	obj := &ActionNxController2PropertyReason{
		ActionNxController2Property: NewActionNxController2Property(2),
	}
	return obj
}

type ActionNxController2PropertyUserdata struct {
	*ActionNxController2Property
	Length   uint16
	Userdata []byte
}

type IActionNxController2PropertyUserdata interface {
	IActionNxController2Property
	GetLength() uint16
	GetUserdata() []byte
}

func (self *ActionNxController2PropertyUserdata) GetLength() uint16 {
	return self.Length
}

func (self *ActionNxController2PropertyUserdata) SetLength(v uint16) {
	self.Length = v
}

func (self *ActionNxController2PropertyUserdata) GetUserdata() []byte {
	return self.Userdata
}

func (self *ActionNxController2PropertyUserdata) SetUserdata(v []byte) {
	self.Userdata = v
}

func (self *ActionNxController2PropertyUserdata) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Length))
	encoder.Write(self.Userdata)
	length := len(encoder.Bytes()) - startIndex
	alignedLength := ((length + 7) / 8 * 8)

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))

	return nil
}

func DecodeActionNxController2PropertyUserdata(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyUserdata, error) {
	_actionnxcontroller2propertyuserdata := &ActionNxController2PropertyUserdata{ActionNxController2Property: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("ActionNxController2PropertyUserdata packet too short: %d < 2", decoder.Length())
	}
	defer decoder.SkipAlign()

	_actionnxcontroller2propertyuserdata.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(((_actionnxcontroller2propertyuserdata.Length)+7)/8*8), 2+2)
	_actionnxcontroller2propertyuserdata.Userdata = decoder.Read(int(decoder.Length()))
	return _actionnxcontroller2propertyuserdata, nil
}

func NewActionNxController2PropertyUserdata() *ActionNxController2PropertyUserdata {
	obj := &ActionNxController2PropertyUserdata{
		ActionNxController2Property: NewActionNxController2Property(3),
	}
	return obj
}

type BsnInterface struct {
	HwAddr      net.HardwareAddr
	Name        string
	Ipv4Addr    net.IP
	Ipv4Netmask net.IP
}

type IBsnInterface interface {
	goloxi.Serializable
	GetHwAddr() net.HardwareAddr
	GetName() string
	GetIpv4Addr() net.IP
	GetIpv4Netmask() net.IP
}

func (self *BsnInterface) GetHwAddr() net.HardwareAddr {
	return self.HwAddr
}

func (self *BsnInterface) SetHwAddr(v net.HardwareAddr) {
	self.HwAddr = v
}

func (self *BsnInterface) GetName() string {
	return self.Name
}

func (self *BsnInterface) SetName(v string) {
	self.Name = v
}

func (self *BsnInterface) GetIpv4Addr() net.IP {
	return self.Ipv4Addr
}

func (self *BsnInterface) SetIpv4Addr(v net.IP) {
	self.Ipv4Addr = v
}

func (self *BsnInterface) GetIpv4Netmask() net.IP {
	return self.Ipv4Netmask
}

func (self *BsnInterface) SetIpv4Netmask(v net.IP) {
	self.Ipv4Netmask = v
}

func (self *BsnInterface) Serialize(encoder *goloxi.Encoder) error {

	encoder.Write(self.HwAddr)
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	encoder.Write([]byte(self.Name))
	encoder.Write(self.Ipv4Addr.To4())
	encoder.Write(self.Ipv4Netmask.To4())

	return nil
}

func DecodeBsnInterface(decoder *goloxi.Decoder) (*BsnInterface, error) {
	_bsninterface := &BsnInterface{}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("BsnInterface packet too short: %d < 32", decoder.Length())
	}
	_bsninterface.HwAddr = net.HardwareAddr(decoder.Read(6))
	decoder.Skip(2)
	_bsninterface.Name = string(bytes.Trim(decoder.Read(16), "\x00"))
	_bsninterface.Ipv4Addr = net.IP(decoder.Read(4))
	_bsninterface.Ipv4Netmask = net.IP(decoder.Read(4))
	return _bsninterface, nil
}

func NewBsnInterface() *BsnInterface {
	obj := &BsnInterface{}
	return obj
}

type BsnVport struct {
	Type   uint16
	Length uint16
}

type IBsnVport interface {
	goloxi.Serializable
	GetType() uint16
	GetLength() uint16
}

func (self *BsnVport) GetType() uint16 {
	return self.Type
}

func (self *BsnVport) SetType(v uint16) {
	self.Type = v
}

func (self *BsnVport) GetLength() uint16 {
	return self.Length
}

func (self *BsnVport) SetLength(v uint16) {
	self.Length = v
}

func (self *BsnVport) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Length))

	return nil
}
func (self *BsnVport) Decode(decoder *goloxi.Decoder) error {
	if decoder.Length() < 4 {
		return fmt.Errorf("BsnVport packet too short: %d < 4", decoder.Length())
	}

	self.Type = uint16(decoder.ReadUint16())
	self.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(self.Length), 2+2)

	return nil
}

func NewBsnVport(_type uint16) *BsnVport {
	obj := &BsnVport{}
	obj.Type = _type
	return obj
}

type BsnVportL2Gre struct {
	*BsnVport
	Flags          BsnVportL2GreFlags
	PortNo         Port
	LoopbackPortNo Port
	LocalMac       net.HardwareAddr
	NhMac          net.HardwareAddr
	SrcIp          net.IP
	DstIp          net.IP
	Dscp           uint8
	Ttl            uint8
	Vpn            uint32
	RateLimit      uint32
	IfName         string
}

type IBsnVportL2Gre interface {
	IBsnVport
	GetFlags() BsnVportL2GreFlags
	GetPortNo() Port
	GetLoopbackPortNo() Port
	GetLocalMac() net.HardwareAddr
	GetNhMac() net.HardwareAddr
	GetSrcIp() net.IP
	GetDstIp() net.IP
	GetDscp() uint8
	GetTtl() uint8
	GetVpn() uint32
	GetRateLimit() uint32
	GetIfName() string
}

func (self *BsnVportL2Gre) GetFlags() BsnVportL2GreFlags {
	return self.Flags
}

func (self *BsnVportL2Gre) SetFlags(v BsnVportL2GreFlags) {
	self.Flags = v
}

func (self *BsnVportL2Gre) GetPortNo() Port {
	return self.PortNo
}

func (self *BsnVportL2Gre) SetPortNo(v Port) {
	self.PortNo = v
}

func (self *BsnVportL2Gre) GetLoopbackPortNo() Port {
	return self.LoopbackPortNo
}

func (self *BsnVportL2Gre) SetLoopbackPortNo(v Port) {
	self.LoopbackPortNo = v
}

func (self *BsnVportL2Gre) GetLocalMac() net.HardwareAddr {
	return self.LocalMac
}

func (self *BsnVportL2Gre) SetLocalMac(v net.HardwareAddr) {
	self.LocalMac = v
}

func (self *BsnVportL2Gre) GetNhMac() net.HardwareAddr {
	return self.NhMac
}

func (self *BsnVportL2Gre) SetNhMac(v net.HardwareAddr) {
	self.NhMac = v
}

func (self *BsnVportL2Gre) GetSrcIp() net.IP {
	return self.SrcIp
}

func (self *BsnVportL2Gre) SetSrcIp(v net.IP) {
	self.SrcIp = v
}

func (self *BsnVportL2Gre) GetDstIp() net.IP {
	return self.DstIp
}

func (self *BsnVportL2Gre) SetDstIp(v net.IP) {
	self.DstIp = v
}

func (self *BsnVportL2Gre) GetDscp() uint8 {
	return self.Dscp
}

func (self *BsnVportL2Gre) SetDscp(v uint8) {
	self.Dscp = v
}

func (self *BsnVportL2Gre) GetTtl() uint8 {
	return self.Ttl
}

func (self *BsnVportL2Gre) SetTtl(v uint8) {
	self.Ttl = v
}

func (self *BsnVportL2Gre) GetVpn() uint32 {
	return self.Vpn
}

func (self *BsnVportL2Gre) SetVpn(v uint32) {
	self.Vpn = v
}

func (self *BsnVportL2Gre) GetRateLimit() uint32 {
	return self.RateLimit
}

func (self *BsnVportL2Gre) SetRateLimit(v uint32) {
	self.RateLimit = v
}

func (self *BsnVportL2Gre) GetIfName() string {
	return self.IfName
}

func (self *BsnVportL2Gre) SetIfName(v string) {
	self.IfName = v
}

func (self *BsnVportL2Gre) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnVport.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Flags))
	self.PortNo.Serialize(encoder)
	self.LoopbackPortNo.Serialize(encoder)
	encoder.Write(self.LocalMac)
	encoder.Write(self.NhMac)
	encoder.Write(self.SrcIp.To4())
	encoder.Write(self.DstIp.To4())
	encoder.PutUint8(uint8(self.Dscp))
	encoder.PutUint8(uint8(self.Ttl))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	encoder.PutUint32(uint32(self.Vpn))
	encoder.PutUint32(uint32(self.RateLimit))
	encoder.Write([]byte(self.IfName))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnVportL2Gre(parent *BsnVport, decoder *goloxi.Decoder) (*BsnVportL2Gre, error) {
	_bsnvportl2gre := &BsnVportL2Gre{BsnVport: parent}
	if decoder.Length() < 60 {
		return nil, fmt.Errorf("BsnVportL2Gre packet too short: %d < 60", decoder.Length())
	}
	_bsnvportl2gre.Flags = BsnVportL2GreFlags(decoder.ReadUint32())
	_bsnvportl2gre.PortNo.Decode(decoder)
	_bsnvportl2gre.LoopbackPortNo.Decode(decoder)
	_bsnvportl2gre.LocalMac = net.HardwareAddr(decoder.Read(6))
	_bsnvportl2gre.NhMac = net.HardwareAddr(decoder.Read(6))
	_bsnvportl2gre.SrcIp = net.IP(decoder.Read(4))
	_bsnvportl2gre.DstIp = net.IP(decoder.Read(4))
	_bsnvportl2gre.Dscp = uint8(decoder.ReadByte())
	_bsnvportl2gre.Ttl = uint8(decoder.ReadByte())
	decoder.Skip(2)
	_bsnvportl2gre.Vpn = uint32(decoder.ReadUint32())
	_bsnvportl2gre.RateLimit = uint32(decoder.ReadUint32())
	_bsnvportl2gre.IfName = string(bytes.Trim(decoder.Read(16), "\x00"))
	return _bsnvportl2gre, nil
}

func NewBsnVportL2Gre() *BsnVportL2Gre {
	obj := &BsnVportL2Gre{
		BsnVport: NewBsnVport(1),
	}
	return obj
}

type BsnVportQInQ struct {
	*BsnVport
	PortNo        uint32
	IngressTpid   uint16
	IngressVlanId uint16
	EgressTpid    uint16
	EgressVlanId  uint16
	IfName        string
}

type IBsnVportQInQ interface {
	IBsnVport
	GetPortNo() uint32
	GetIngressTpid() uint16
	GetIngressVlanId() uint16
	GetEgressTpid() uint16
	GetEgressVlanId() uint16
	GetIfName() string
}

func (self *BsnVportQInQ) GetPortNo() uint32 {
	return self.PortNo
}

func (self *BsnVportQInQ) SetPortNo(v uint32) {
	self.PortNo = v
}

func (self *BsnVportQInQ) GetIngressTpid() uint16 {
	return self.IngressTpid
}

func (self *BsnVportQInQ) SetIngressTpid(v uint16) {
	self.IngressTpid = v
}

func (self *BsnVportQInQ) GetIngressVlanId() uint16 {
	return self.IngressVlanId
}

func (self *BsnVportQInQ) SetIngressVlanId(v uint16) {
	self.IngressVlanId = v
}

func (self *BsnVportQInQ) GetEgressTpid() uint16 {
	return self.EgressTpid
}

func (self *BsnVportQInQ) SetEgressTpid(v uint16) {
	self.EgressTpid = v
}

func (self *BsnVportQInQ) GetEgressVlanId() uint16 {
	return self.EgressVlanId
}

func (self *BsnVportQInQ) SetEgressVlanId(v uint16) {
	self.EgressVlanId = v
}

func (self *BsnVportQInQ) GetIfName() string {
	return self.IfName
}

func (self *BsnVportQInQ) SetIfName(v string) {
	self.IfName = v
}

func (self *BsnVportQInQ) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnVport.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.PortNo))
	encoder.PutUint16(uint16(self.IngressTpid))
	encoder.PutUint16(uint16(self.IngressVlanId))
	encoder.PutUint16(uint16(self.EgressTpid))
	encoder.PutUint16(uint16(self.EgressVlanId))
	encoder.Write([]byte(self.IfName))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnVportQInQ(parent *BsnVport, decoder *goloxi.Decoder) (*BsnVportQInQ, error) {
	_bsnvportqinq := &BsnVportQInQ{BsnVport: parent}
	if decoder.Length() < 28 {
		return nil, fmt.Errorf("BsnVportQInQ packet too short: %d < 28", decoder.Length())
	}
	_bsnvportqinq.PortNo = uint32(decoder.ReadUint32())
	_bsnvportqinq.IngressTpid = uint16(decoder.ReadUint16())
	_bsnvportqinq.IngressVlanId = uint16(decoder.ReadUint16())
	_bsnvportqinq.EgressTpid = uint16(decoder.ReadUint16())
	_bsnvportqinq.EgressVlanId = uint16(decoder.ReadUint16())
	_bsnvportqinq.IfName = string(bytes.Trim(decoder.Read(16), "\x00"))
	return _bsnvportqinq, nil
}

func NewBsnVportQInQ() *BsnVportQInQ {
	obj := &BsnVportQInQ{
		BsnVport: NewBsnVport(0),
	}
	return obj
}

type Bucket struct {
	Len        uint16
	Weight     uint16
	WatchPort  Port
	WatchGroup uint32
	Actions    []goloxi.IAction
}

type IBucket interface {
	goloxi.Serializable
	GetLen() uint16
	GetWeight() uint16
	GetWatchPort() Port
	GetWatchGroup() uint32
	GetActions() []goloxi.IAction
}

func (self *Bucket) GetLen() uint16 {
	return self.Len
}

func (self *Bucket) SetLen(v uint16) {
	self.Len = v
}

func (self *Bucket) GetWeight() uint16 {
	return self.Weight
}

func (self *Bucket) SetWeight(v uint16) {
	self.Weight = v
}

func (self *Bucket) GetWatchPort() Port {
	return self.WatchPort
}

func (self *Bucket) SetWatchPort(v Port) {
	self.WatchPort = v
}

func (self *Bucket) GetWatchGroup() uint32 {
	return self.WatchGroup
}

func (self *Bucket) SetWatchGroup(v uint32) {
	self.WatchGroup = v
}

func (self *Bucket) GetActions() []goloxi.IAction {
	return self.Actions
}

func (self *Bucket) SetActions(v []goloxi.IAction) {
	self.Actions = v
}

func (self *Bucket) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Len))
	encoder.PutUint16(uint16(self.Weight))
	self.WatchPort.Serialize(encoder)
	encoder.PutUint32(uint32(self.WatchGroup))
	encoder.Write(bytes.Repeat([]byte{0}, 4))
	for _, obj := range self.Actions {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))

	return nil
}

func DecodeBucket(decoder *goloxi.Decoder) (*Bucket, error) {
	_bucket := &Bucket{}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("Bucket packet too short: %d < 16", decoder.Length())
	}
	_bucket.Len = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_bucket.Len), 2+0)
	_bucket.Weight = uint16(decoder.ReadUint16())
	_bucket.WatchPort.Decode(decoder)
	_bucket.WatchGroup = uint32(decoder.ReadUint32())
	decoder.Skip(4)

	for decoder.Length() >= 8 {
		item, err := DecodeAction(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bucket.Actions = append(_bucket.Actions, item)
		}
	}
	return _bucket, nil
}

func NewBucket() *Bucket {
	obj := &Bucket{}
	return obj
}

type BucketCounter struct {
	PacketCount uint64
	ByteCount   uint64
}

type IBucketCounter interface {
	goloxi.Serializable
	GetPacketCount() uint64
	GetByteCount() uint64
}

func (self *BucketCounter) GetPacketCount() uint64 {
	return self.PacketCount
}

func (self *BucketCounter) SetPacketCount(v uint64) {
	self.PacketCount = v
}

func (self *BucketCounter) GetByteCount() uint64 {
	return self.ByteCount
}

func (self *BucketCounter) SetByteCount(v uint64) {
	self.ByteCount = v
}

func (self *BucketCounter) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint64(uint64(self.PacketCount))
	encoder.PutUint64(uint64(self.ByteCount))

	return nil
}

func DecodeBucketCounter(decoder *goloxi.Decoder) (*BucketCounter, error) {
	_bucketcounter := &BucketCounter{}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("BucketCounter packet too short: %d < 16", decoder.Length())
	}
	_bucketcounter.PacketCount = uint64(decoder.ReadUint64())
	_bucketcounter.ByteCount = uint64(decoder.ReadUint64())
	return _bucketcounter, nil
}

func NewBucketCounter() *BucketCounter {
	obj := &BucketCounter{}
	return obj
}

type EdPropHeader struct {
	PropClass uint16
}

type IEdPropHeader interface {
	goloxi.Serializable
	GetPropClass() uint16
}

func (self *EdPropHeader) GetPropClass() uint16 {
	return self.PropClass
}

func (self *EdPropHeader) SetPropClass(v uint16) {
	self.PropClass = v
}

func (self *EdPropHeader) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.PropClass))

	return nil
}

func DecodeEdPropHeader(decoder *goloxi.Decoder) (IEdPropHeader, error) {
	_edpropheader := &EdPropHeader{}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("EdPropHeader packet too short: %d < 2", decoder.Length())
	}
	_edpropheader.PropClass = uint16(decoder.ReadUint16())

	switch _edpropheader.PropClass {
	case 4:
		return DecodeEdPropNsh(_edpropheader, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'EdPropHeader'", _edpropheader.PropClass)
	}
}

func NewEdPropHeader(_prop_class uint16) *EdPropHeader {
	obj := &EdPropHeader{}
	obj.PropClass = _prop_class
	return obj
}

type EdPropNsh struct {
	*EdPropHeader
	Type uint8
	Len  uint8
}

type IEdPropNsh interface {
	IEdPropHeader
	GetType() uint8
	GetLen() uint8
}

func (self *EdPropNsh) GetType() uint8 {
	return self.Type
}

func (self *EdPropNsh) SetType(v uint8) {
	self.Type = v
}

func (self *EdPropNsh) GetLen() uint8 {
	return self.Len
}

func (self *EdPropNsh) SetLen(v uint8) {
	self.Len = v
}

func (self *EdPropNsh) Serialize(encoder *goloxi.Encoder) error {
	if err := self.EdPropHeader.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Type))
	encoder.PutUint8(uint8(self.Len))

	return nil
}

func DecodeEdPropNsh(parent *EdPropHeader, decoder *goloxi.Decoder) (IEdPropNsh, error) {
	_edpropnsh := &EdPropNsh{EdPropHeader: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("EdPropNsh packet too short: %d < 2", decoder.Length())
	}
	defer decoder.SkipAlign()

	_edpropnsh.Type = uint8(decoder.ReadByte())
	_edpropnsh.Len = uint8(decoder.ReadByte())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(((_edpropnsh.Len)+7)/8*8), 1+3)

	switch _edpropnsh.Type {
	case 1:
		return DecodeEdPropNshMdType(_edpropnsh, decoder)
	case 2:
		return DecodeEdPropNshTlv(_edpropnsh, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'EdPropNsh'", _edpropnsh.Type)
	}
}

func NewEdPropNsh(_type uint8) *EdPropNsh {
	obj := &EdPropNsh{
		EdPropHeader: NewEdPropHeader(4),
	}
	obj.Type = _type
	return obj
}

type EdPropNshMdType struct {
	*EdPropNsh
	MdType uint8
}

type IEdPropNshMdType interface {
	IEdPropNsh
	GetMdType() uint8
}

func (self *EdPropNshMdType) GetMdType() uint8 {
	return self.MdType
}

func (self *EdPropNshMdType) SetMdType(v uint8) {
	self.MdType = v
}

func (self *EdPropNshMdType) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.EdPropNsh.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.MdType))
	encoder.Write(bytes.Repeat([]byte{0}, 3))
	length := len(encoder.Bytes()) - startIndex

	encoder.Bytes()[startIndex+3] = uint8(length)

	return nil
}

func DecodeEdPropNshMdType(parent *EdPropNsh, decoder *goloxi.Decoder) (*EdPropNshMdType, error) {
	_edpropnshmdtype := &EdPropNshMdType{EdPropNsh: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("EdPropNshMdType packet too short: %d < 4", decoder.Length())
	}
	_edpropnshmdtype.MdType = uint8(decoder.ReadByte())
	decoder.Skip(3)
	return _edpropnshmdtype, nil
}

func NewEdPropNshMdType() *EdPropNshMdType {
	obj := &EdPropNshMdType{
		EdPropNsh: NewEdPropNsh(1),
	}
	return obj
}

type EdPropNshTlv struct {
	*EdPropNsh
	TlvClass uint16
	TlvType  uint8
	TlvLen   uint8
	Value    []byte
}

type IEdPropNshTlv interface {
	IEdPropNsh
	GetTlvClass() uint16
	GetTlvType() uint8
	GetTlvLen() uint8
	GetValue() []byte
}

func (self *EdPropNshTlv) GetTlvClass() uint16 {
	return self.TlvClass
}

func (self *EdPropNshTlv) SetTlvClass(v uint16) {
	self.TlvClass = v
}

func (self *EdPropNshTlv) GetTlvType() uint8 {
	return self.TlvType
}

func (self *EdPropNshTlv) SetTlvType(v uint8) {
	self.TlvType = v
}

func (self *EdPropNshTlv) GetTlvLen() uint8 {
	return self.TlvLen
}

func (self *EdPropNshTlv) SetTlvLen(v uint8) {
	self.TlvLen = v
}

func (self *EdPropNshTlv) GetValue() []byte {
	return self.Value
}

func (self *EdPropNshTlv) SetValue(v []byte) {
	self.Value = v
}

func (self *EdPropNshTlv) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.EdPropNsh.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.TlvClass))
	encoder.PutUint8(uint8(self.TlvType))
	encoder.PutUint8(uint8(self.TlvLen))
	encoder.Write(self.Value)
	length := len(encoder.Bytes()) - startIndex

	encoder.Bytes()[startIndex+3] = uint8(length)

	return nil
}

func DecodeEdPropNshTlv(parent *EdPropNsh, decoder *goloxi.Decoder) (*EdPropNshTlv, error) {
	_edpropnshtlv := &EdPropNshTlv{EdPropNsh: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("EdPropNshTlv packet too short: %d < 4", decoder.Length())
	}
	_edpropnshtlv.TlvClass = uint16(decoder.ReadUint16())
	_edpropnshtlv.TlvType = uint8(decoder.ReadByte())
	_edpropnshtlv.TlvLen = uint8(decoder.ReadByte())
	_edpropnshtlv.Value = decoder.SliceDecoder(int(_edpropnshtlv.TlvLen), 0).Read(int(_edpropnshtlv.TlvLen))
	return _edpropnshtlv, nil
}

func NewEdPropNshTlv() *EdPropNshTlv {
	obj := &EdPropNshTlv{
		EdPropNsh: NewEdPropNsh(2),
	}
	return obj
}

type FlowModSpec struct {
	SrcDst uint8
	NBits  uint8
}

type IFlowModSpec interface {
	goloxi.Serializable
	GetSrcDst() uint8
	GetNBits() uint8
}

func (self *FlowModSpec) GetSrcDst() uint8 {
	return self.SrcDst
}

func (self *FlowModSpec) SetSrcDst(v uint8) {
	self.SrcDst = v
}

func (self *FlowModSpec) GetNBits() uint8 {
	return self.NBits
}

func (self *FlowModSpec) SetNBits(v uint8) {
	self.NBits = v
}

func (self *FlowModSpec) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint8(uint8(self.SrcDst))
	encoder.PutUint8(uint8(self.NBits))

	return nil
}

func DecodeFlowModSpec(decoder *goloxi.Decoder) (IFlowModSpec, error) {
	_flowmodspec := &FlowModSpec{}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("FlowModSpec packet too short: %d < 2", decoder.Length())
	}
	_flowmodspec.SrcDst = uint8(decoder.ReadByte())
	_flowmodspec.NBits = uint8(decoder.ReadByte())
	if _flowmodspec.SrcDst == 0 && _flowmodspec.NBits == 0 {
		return nil, nil
	}

	switch _flowmodspec.SrcDst {
	case 0:
		return DecodeFlowModSpecSrc0Dst0(_flowmodspec, decoder)
	case 8:
		return DecodeFlowModSpecSrc0Dst1(_flowmodspec, decoder)
	case 40:
		return DecodeFlowModSpecSrc1Dst1(_flowmodspec, decoder)
	case 16:
		return DecodeFlowModSpecSrc0Dst2(_flowmodspec, decoder)
	case 32:
		return DecodeFlowModSpecSrc1Dst0(_flowmodspec, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'FlowModSpec'", _flowmodspec.SrcDst)
	}
}

func NewFlowModSpec(_src_dst uint8) *FlowModSpec {
	obj := &FlowModSpec{}
	obj.SrcDst = _src_dst
	return obj
}

type FlowModSpecSrc0Dst0 struct {
	*FlowModSpec
	Src    goloxi.IOxmId
	SrcOfs uint16
	Dst    goloxi.IOxmId
	DstOfs uint16
}

type IFlowModSpecSrc0Dst0 interface {
	IFlowModSpec
	GetSrc() goloxi.IOxmId
	GetSrcOfs() uint16
	GetDst() goloxi.IOxmId
	GetDstOfs() uint16
}

func (self *FlowModSpecSrc0Dst0) GetSrc() goloxi.IOxmId {
	return self.Src
}

func (self *FlowModSpecSrc0Dst0) SetSrc(v goloxi.IOxmId) {
	self.Src = v
}

func (self *FlowModSpecSrc0Dst0) GetSrcOfs() uint16 {
	return self.SrcOfs
}

func (self *FlowModSpecSrc0Dst0) SetSrcOfs(v uint16) {
	self.SrcOfs = v
}

func (self *FlowModSpecSrc0Dst0) GetDst() goloxi.IOxmId {
	return self.Dst
}

func (self *FlowModSpecSrc0Dst0) SetDst(v goloxi.IOxmId) {
	self.Dst = v
}

func (self *FlowModSpecSrc0Dst0) GetDstOfs() uint16 {
	return self.DstOfs
}

func (self *FlowModSpecSrc0Dst0) SetDstOfs(v uint16) {
	self.DstOfs = v
}

func (self *FlowModSpecSrc0Dst0) Serialize(encoder *goloxi.Encoder) error {
	if err := self.FlowModSpec.Serialize(encoder); err != nil {
		return err
	}

	self.Src.Serialize(encoder)
	encoder.PutUint16(uint16(self.SrcOfs))
	self.Dst.Serialize(encoder)
	encoder.PutUint16(uint16(self.DstOfs))

	return nil
}

func DecodeFlowModSpecSrc0Dst0(parent *FlowModSpec, decoder *goloxi.Decoder) (IFlowModSpecSrc0Dst0, error) {
	_flowmodspecsrc0dst0 := &FlowModSpecSrc0Dst0{FlowModSpec: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("FlowModSpecSrc0Dst0 packet too short: %d < 12", decoder.Length())
	}
	if obj, err := DecodeOxmId(decoder); err != nil {
		return nil, err
	} else {
		_flowmodspecsrc0dst0.Src = obj
	}

	_flowmodspecsrc0dst0.SrcOfs = uint16(decoder.ReadUint16())
	if obj, err := DecodeOxmId(decoder); err != nil {
		return nil, err
	} else {
		_flowmodspecsrc0dst0.Dst = obj
	}

	_flowmodspecsrc0dst0.DstOfs = uint16(decoder.ReadUint16())
	return _flowmodspecsrc0dst0, nil
}

func NewFlowModSpecSrc0Dst0(_n_bits uint8) *FlowModSpecSrc0Dst0 {
	obj := &FlowModSpecSrc0Dst0{
		FlowModSpec: NewFlowModSpec(0),
	}
	obj.NBits = _n_bits
	return obj
}

type FlowModSpecSrc0Dst1 struct {
	*FlowModSpec
	Src    goloxi.IOxmId
	SrcOfs uint16
	Dst    goloxi.IOxmId
	DstOfs uint16
}

type IFlowModSpecSrc0Dst1 interface {
	IFlowModSpec
	GetSrc() goloxi.IOxmId
	GetSrcOfs() uint16
	GetDst() goloxi.IOxmId
	GetDstOfs() uint16
}

func (self *FlowModSpecSrc0Dst1) GetSrc() goloxi.IOxmId {
	return self.Src
}

func (self *FlowModSpecSrc0Dst1) SetSrc(v goloxi.IOxmId) {
	self.Src = v
}

func (self *FlowModSpecSrc0Dst1) GetSrcOfs() uint16 {
	return self.SrcOfs
}

func (self *FlowModSpecSrc0Dst1) SetSrcOfs(v uint16) {
	self.SrcOfs = v
}

func (self *FlowModSpecSrc0Dst1) GetDst() goloxi.IOxmId {
	return self.Dst
}

func (self *FlowModSpecSrc0Dst1) SetDst(v goloxi.IOxmId) {
	self.Dst = v
}

func (self *FlowModSpecSrc0Dst1) GetDstOfs() uint16 {
	return self.DstOfs
}

func (self *FlowModSpecSrc0Dst1) SetDstOfs(v uint16) {
	self.DstOfs = v
}

func (self *FlowModSpecSrc0Dst1) Serialize(encoder *goloxi.Encoder) error {
	if err := self.FlowModSpec.Serialize(encoder); err != nil {
		return err
	}

	self.Src.Serialize(encoder)
	encoder.PutUint16(uint16(self.SrcOfs))
	self.Dst.Serialize(encoder)
	encoder.PutUint16(uint16(self.DstOfs))

	return nil
}

func DecodeFlowModSpecSrc0Dst1(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc0Dst1, error) {
	_flowmodspecsrc0dst1 := &FlowModSpecSrc0Dst1{FlowModSpec: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("FlowModSpecSrc0Dst1 packet too short: %d < 12", decoder.Length())
	}
	if obj, err := DecodeOxmId(decoder); err != nil {
		return nil, err
	} else {
		_flowmodspecsrc0dst1.Src = obj
	}

	_flowmodspecsrc0dst1.SrcOfs = uint16(decoder.ReadUint16())
	if obj, err := DecodeOxmId(decoder); err != nil {
		return nil, err
	} else {
		_flowmodspecsrc0dst1.Dst = obj
	}

	_flowmodspecsrc0dst1.DstOfs = uint16(decoder.ReadUint16())
	return _flowmodspecsrc0dst1, nil
}

func NewFlowModSpecSrc0Dst1() *FlowModSpecSrc0Dst1 {
	obj := &FlowModSpecSrc0Dst1{
		FlowModSpec: NewFlowModSpec(8),
	}
	return obj
}

type FlowModSpecSrc0Dst2 struct {
	*FlowModSpec
	Src    goloxi.IOxmId
	SrcOfs uint16
}

type IFlowModSpecSrc0Dst2 interface {
	IFlowModSpec
	GetSrc() goloxi.IOxmId
	GetSrcOfs() uint16
}

func (self *FlowModSpecSrc0Dst2) GetSrc() goloxi.IOxmId {
	return self.Src
}

func (self *FlowModSpecSrc0Dst2) SetSrc(v goloxi.IOxmId) {
	self.Src = v
}

func (self *FlowModSpecSrc0Dst2) GetSrcOfs() uint16 {
	return self.SrcOfs
}

func (self *FlowModSpecSrc0Dst2) SetSrcOfs(v uint16) {
	self.SrcOfs = v
}

func (self *FlowModSpecSrc0Dst2) Serialize(encoder *goloxi.Encoder) error {
	if err := self.FlowModSpec.Serialize(encoder); err != nil {
		return err
	}

	self.Src.Serialize(encoder)
	encoder.PutUint16(uint16(self.SrcOfs))

	return nil
}

func DecodeFlowModSpecSrc0Dst2(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc0Dst2, error) {
	_flowmodspecsrc0dst2 := &FlowModSpecSrc0Dst2{FlowModSpec: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("FlowModSpecSrc0Dst2 packet too short: %d < 6", decoder.Length())
	}
	if obj, err := DecodeOxmId(decoder); err != nil {
		return nil, err
	} else {
		_flowmodspecsrc0dst2.Src = obj
	}

	_flowmodspecsrc0dst2.SrcOfs = uint16(decoder.ReadUint16())
	return _flowmodspecsrc0dst2, nil
}

func NewFlowModSpecSrc0Dst2() *FlowModSpecSrc0Dst2 {
	obj := &FlowModSpecSrc0Dst2{
		FlowModSpec: NewFlowModSpec(16),
	}
	return obj
}

type FlowModSpecSrc1Dst0 struct {
	*FlowModSpec
	Src    []byte
	Dst    goloxi.IOxmId
	DstOfs uint16
}

type IFlowModSpecSrc1Dst0 interface {
	IFlowModSpec
	GetSrc() []byte
	GetDst() goloxi.IOxmId
	GetDstOfs() uint16
}

func (self *FlowModSpecSrc1Dst0) GetSrc() []byte {
	return self.Src
}

func (self *FlowModSpecSrc1Dst0) SetSrc(v []byte) {
	self.Src = v
}

func (self *FlowModSpecSrc1Dst0) GetDst() goloxi.IOxmId {
	return self.Dst
}

func (self *FlowModSpecSrc1Dst0) SetDst(v goloxi.IOxmId) {
	self.Dst = v
}

func (self *FlowModSpecSrc1Dst0) GetDstOfs() uint16 {
	return self.DstOfs
}

func (self *FlowModSpecSrc1Dst0) SetDstOfs(v uint16) {
	self.DstOfs = v
}

func (self *FlowModSpecSrc1Dst0) Serialize(encoder *goloxi.Encoder) error {
	if err := self.FlowModSpec.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Src)
	self.Dst.Serialize(encoder)
	encoder.PutUint16(uint16(self.DstOfs))

	return nil
}

func DecodeFlowModSpecSrc1Dst0(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc1Dst0, error) {
	_flowmodspecsrc1dst0 := &FlowModSpecSrc1Dst0{FlowModSpec: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("FlowModSpecSrc1Dst0 packet too short: %d < 6", decoder.Length())
	}
	_flowmodspecsrc1dst0.Src = decoder.SliceDecoder(int((_flowmodspecsrc1dst0.NBits+15)/16*2), 0).Read(int(_flowmodspecsrc1dst0.NBits))
	if obj, err := DecodeOxmId(decoder); err != nil {
		return nil, err
	} else {
		_flowmodspecsrc1dst0.Dst = obj
	}

	_flowmodspecsrc1dst0.DstOfs = uint16(decoder.ReadUint16())
	return _flowmodspecsrc1dst0, nil
}

func NewFlowModSpecSrc1Dst0() *FlowModSpecSrc1Dst0 {
	obj := &FlowModSpecSrc1Dst0{
		FlowModSpec: NewFlowModSpec(32),
	}
	return obj
}

type FlowModSpecSrc1Dst1 struct {
	*FlowModSpec
	Src    []byte
	Dst    goloxi.IOxmId
	DstOfs uint16
}

type IFlowModSpecSrc1Dst1 interface {
	IFlowModSpec
	GetSrc() []byte
	GetDst() goloxi.IOxmId
	GetDstOfs() uint16
}

func (self *FlowModSpecSrc1Dst1) GetSrc() []byte {
	return self.Src
}

func (self *FlowModSpecSrc1Dst1) SetSrc(v []byte) {
	self.Src = v
}

func (self *FlowModSpecSrc1Dst1) GetDst() goloxi.IOxmId {
	return self.Dst
}

func (self *FlowModSpecSrc1Dst1) SetDst(v goloxi.IOxmId) {
	self.Dst = v
}

func (self *FlowModSpecSrc1Dst1) GetDstOfs() uint16 {
	return self.DstOfs
}

func (self *FlowModSpecSrc1Dst1) SetDstOfs(v uint16) {
	self.DstOfs = v
}

func (self *FlowModSpecSrc1Dst1) Serialize(encoder *goloxi.Encoder) error {
	if err := self.FlowModSpec.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Src)
	self.Dst.Serialize(encoder)
	encoder.PutUint16(uint16(self.DstOfs))

	return nil
}

func DecodeFlowModSpecSrc1Dst1(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc1Dst1, error) {
	_flowmodspecsrc1dst1 := &FlowModSpecSrc1Dst1{FlowModSpec: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("FlowModSpecSrc1Dst1 packet too short: %d < 6", decoder.Length())
	}
	_flowmodspecsrc1dst1.Src = decoder.SliceDecoder(int((_flowmodspecsrc1dst1.NBits+15)/16*2), 0).Read(int(_flowmodspecsrc1dst1.NBits))
	if obj, err := DecodeOxmId(decoder); err != nil {
		return nil, err
	} else {
		_flowmodspecsrc1dst1.Dst = obj
	}

	_flowmodspecsrc1dst1.DstOfs = uint16(decoder.ReadUint16())
	return _flowmodspecsrc1dst1, nil
}

func NewFlowModSpecSrc1Dst1() *FlowModSpecSrc1Dst1 {
	obj := &FlowModSpecSrc1Dst1{
		FlowModSpec: NewFlowModSpec(40),
	}
	return obj
}

type FlowStatsEntry struct {
	Length       uint16
	TableId      uint8
	DurationSec  uint32
	DurationNsec uint32
	Priority     uint16
	IdleTimeout  uint16
	HardTimeout  uint16
	Cookie       uint64
	PacketCount  uint64
	ByteCount    uint64
	Match        Match
	Instructions []IInstruction
}

type IFlowStatsEntry interface {
	goloxi.Serializable
	GetLength() uint16
	GetTableId() uint8
	GetDurationSec() uint32
	GetDurationNsec() uint32
	GetPriority() uint16
	GetIdleTimeout() uint16
	GetHardTimeout() uint16
	GetCookie() uint64
	GetPacketCount() uint64
	GetByteCount() uint64
	GetMatch() Match
	GetInstructions() []IInstruction
}

func (self *FlowStatsEntry) GetLength() uint16 {
	return self.Length
}

func (self *FlowStatsEntry) SetLength(v uint16) {
	self.Length = v
}

func (self *FlowStatsEntry) GetTableId() uint8 {
	return self.TableId
}

func (self *FlowStatsEntry) SetTableId(v uint8) {
	self.TableId = v
}

func (self *FlowStatsEntry) GetDurationSec() uint32 {
	return self.DurationSec
}

func (self *FlowStatsEntry) SetDurationSec(v uint32) {
	self.DurationSec = v
}

func (self *FlowStatsEntry) GetDurationNsec() uint32 {
	return self.DurationNsec
}

func (self *FlowStatsEntry) SetDurationNsec(v uint32) {
	self.DurationNsec = v
}

func (self *FlowStatsEntry) GetPriority() uint16 {
	return self.Priority
}

func (self *FlowStatsEntry) SetPriority(v uint16) {
	self.Priority = v
}

func (self *FlowStatsEntry) GetIdleTimeout() uint16 {
	return self.IdleTimeout
}

func (self *FlowStatsEntry) SetIdleTimeout(v uint16) {
	self.IdleTimeout = v
}

func (self *FlowStatsEntry) GetHardTimeout() uint16 {
	return self.HardTimeout
}

func (self *FlowStatsEntry) SetHardTimeout(v uint16) {
	self.HardTimeout = v
}

func (self *FlowStatsEntry) GetCookie() uint64 {
	return self.Cookie
}

func (self *FlowStatsEntry) SetCookie(v uint64) {
	self.Cookie = v
}

func (self *FlowStatsEntry) GetPacketCount() uint64 {
	return self.PacketCount
}

func (self *FlowStatsEntry) SetPacketCount(v uint64) {
	self.PacketCount = v
}

func (self *FlowStatsEntry) GetByteCount() uint64 {
	return self.ByteCount
}

func (self *FlowStatsEntry) SetByteCount(v uint64) {
	self.ByteCount = v
}

func (self *FlowStatsEntry) GetMatch() Match {
	return self.Match
}

func (self *FlowStatsEntry) SetMatch(v Match) {
	self.Match = v
}

func (self *FlowStatsEntry) GetInstructions() []IInstruction {
	return self.Instructions
}

func (self *FlowStatsEntry) SetInstructions(v []IInstruction) {
	self.Instructions = v
}

func (self *FlowStatsEntry) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Length))
	encoder.PutUint8(uint8(self.TableId))
	encoder.Write(bytes.Repeat([]byte{0}, 1))
	encoder.PutUint32(uint32(self.DurationSec))
	encoder.PutUint32(uint32(self.DurationNsec))
	encoder.PutUint16(uint16(self.Priority))
	encoder.PutUint16(uint16(self.IdleTimeout))
	encoder.PutUint16(uint16(self.HardTimeout))
	encoder.Write(bytes.Repeat([]byte{0}, 6))
	encoder.PutUint64(uint64(self.Cookie))
	encoder.PutUint64(uint64(self.PacketCount))
	encoder.PutUint64(uint64(self.ByteCount))
	if err := self.Match.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.Instructions {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))

	return nil
}

func DecodeFlowStatsEntry(decoder *goloxi.Decoder) (*FlowStatsEntry, error) {
	_flowstatsentry := &FlowStatsEntry{}
	if decoder.Length() < 136 {
		return nil, fmt.Errorf("FlowStatsEntry packet too short: %d < 136", decoder.Length())
	}
	_flowstatsentry.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_flowstatsentry.Length), 2+0)
	_flowstatsentry.TableId = uint8(decoder.ReadByte())
	decoder.Skip(1)
	_flowstatsentry.DurationSec = uint32(decoder.ReadUint32())
	_flowstatsentry.DurationNsec = uint32(decoder.ReadUint32())
	_flowstatsentry.Priority = uint16(decoder.ReadUint16())
	_flowstatsentry.IdleTimeout = uint16(decoder.ReadUint16())
	_flowstatsentry.HardTimeout = uint16(decoder.ReadUint16())
	decoder.Skip(6)
	_flowstatsentry.Cookie = uint64(decoder.ReadUint64())
	_flowstatsentry.PacketCount = uint64(decoder.ReadUint64())
	_flowstatsentry.ByteCount = uint64(decoder.ReadUint64())
	if err := _flowstatsentry.Match.Decode(decoder); err != nil {
		return nil, err
	}

	for decoder.Length() >= 8 {
		item, err := DecodeInstruction(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_flowstatsentry.Instructions = append(_flowstatsentry.Instructions, item)
		}
	}
	return _flowstatsentry, nil
}

func NewFlowStatsEntry() *FlowStatsEntry {
	obj := &FlowStatsEntry{}
	return obj
}

type GroupDescStatsEntry struct {
	Length    uint16
	GroupType GroupType
	GroupId   uint32
	Buckets   []*Bucket
}

type IGroupDescStatsEntry interface {
	goloxi.Serializable
	GetLength() uint16
	GetGroupType() GroupType
	GetGroupId() uint32
	GetBuckets() []*Bucket
}

func (self *GroupDescStatsEntry) GetLength() uint16 {
	return self.Length
}

func (self *GroupDescStatsEntry) SetLength(v uint16) {
	self.Length = v
}

func (self *GroupDescStatsEntry) GetGroupType() GroupType {
	return self.GroupType
}

func (self *GroupDescStatsEntry) SetGroupType(v GroupType) {
	self.GroupType = v
}

func (self *GroupDescStatsEntry) GetGroupId() uint32 {
	return self.GroupId
}

func (self *GroupDescStatsEntry) SetGroupId(v uint32) {
	self.GroupId = v
}

func (self *GroupDescStatsEntry) GetBuckets() []*Bucket {
	return self.Buckets
}

func (self *GroupDescStatsEntry) SetBuckets(v []*Bucket) {
	self.Buckets = v
}

func (self *GroupDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Length))
	encoder.PutUint8(uint8(self.GroupType))
	encoder.Write(bytes.Repeat([]byte{0}, 1))
	encoder.PutUint32(uint32(self.GroupId))
	for _, obj := range self.Buckets {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))

	return nil
}

func DecodeGroupDescStatsEntry(decoder *goloxi.Decoder) (*GroupDescStatsEntry, error) {
	_groupdescstatsentry := &GroupDescStatsEntry{}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("GroupDescStatsEntry packet too short: %d < 8", decoder.Length())
	}
	_groupdescstatsentry.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_groupdescstatsentry.Length), 2+0)
	_groupdescstatsentry.GroupType = GroupType(decoder.ReadByte())
	decoder.Skip(1)
	_groupdescstatsentry.GroupId = uint32(decoder.ReadUint32())

	for decoder.Length() >= 16 {
		item, err := DecodeBucket(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_groupdescstatsentry.Buckets = append(_groupdescstatsentry.Buckets, item)
		}
	}
	return _groupdescstatsentry, nil
}

func NewGroupDescStatsEntry() *GroupDescStatsEntry {
	obj := &GroupDescStatsEntry{}
	return obj
}

type GroupStatsEntry struct {
	Length      uint16
	GroupId     uint32
	RefCount    uint32
	PacketCount uint64
	ByteCount   uint64
	BucketStats []*BucketCounter
}

type IGroupStatsEntry interface {
	goloxi.Serializable
	GetLength() uint16
	GetGroupId() uint32
	GetRefCount() uint32
	GetPacketCount() uint64
	GetByteCount() uint64
	GetBucketStats() []*BucketCounter
}

func (self *GroupStatsEntry) GetLength() uint16 {
	return self.Length
}

func (self *GroupStatsEntry) SetLength(v uint16) {
	self.Length = v
}

func (self *GroupStatsEntry) GetGroupId() uint32 {
	return self.GroupId
}

func (self *GroupStatsEntry) SetGroupId(v uint32) {
	self.GroupId = v
}

func (self *GroupStatsEntry) GetRefCount() uint32 {
	return self.RefCount
}

func (self *GroupStatsEntry) SetRefCount(v uint32) {
	self.RefCount = v
}

func (self *GroupStatsEntry) GetPacketCount() uint64 {
	return self.PacketCount
}

func (self *GroupStatsEntry) SetPacketCount(v uint64) {
	self.PacketCount = v
}

func (self *GroupStatsEntry) GetByteCount() uint64 {
	return self.ByteCount
}

func (self *GroupStatsEntry) SetByteCount(v uint64) {
	self.ByteCount = v
}

func (self *GroupStatsEntry) GetBucketStats() []*BucketCounter {
	return self.BucketStats
}

func (self *GroupStatsEntry) SetBucketStats(v []*BucketCounter) {
	self.BucketStats = v
}

func (self *GroupStatsEntry) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Length))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	encoder.PutUint32(uint32(self.GroupId))
	encoder.PutUint32(uint32(self.RefCount))
	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint64(uint64(self.PacketCount))
	encoder.PutUint64(uint64(self.ByteCount))
	for _, obj := range self.BucketStats {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))

	return nil
}

func DecodeGroupStatsEntry(decoder *goloxi.Decoder) (*GroupStatsEntry, error) {
	_groupstatsentry := &GroupStatsEntry{}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("GroupStatsEntry packet too short: %d < 32", decoder.Length())
	}
	_groupstatsentry.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_groupstatsentry.Length), 2+0)
	decoder.Skip(2)
	_groupstatsentry.GroupId = uint32(decoder.ReadUint32())
	_groupstatsentry.RefCount = uint32(decoder.ReadUint32())
	decoder.Skip(4)
	_groupstatsentry.PacketCount = uint64(decoder.ReadUint64())
	_groupstatsentry.ByteCount = uint64(decoder.ReadUint64())

	for decoder.Length() >= 16 {
		item, err := DecodeBucketCounter(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_groupstatsentry.BucketStats = append(_groupstatsentry.BucketStats, item)
		}
	}
	return _groupstatsentry, nil
}

func NewGroupStatsEntry() *GroupStatsEntry {
	obj := &GroupStatsEntry{}
	return obj
}

type InstructionId struct {
	Type uint16
	Len  uint16
}

type IInstructionId interface {
	goloxi.Serializable
	GetType() uint16
	GetLen() uint16
}

func (self *InstructionId) GetType() uint16 {
	return self.Type
}

func (self *InstructionId) SetType(v uint16) {
	self.Type = v
}

func (self *InstructionId) GetLen() uint16 {
	return self.Len
}

func (self *InstructionId) SetLen(v uint16) {
	self.Len = v
}

func (self *InstructionId) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Len))

	return nil
}

func DecodeInstructionId(decoder *goloxi.Decoder) (IInstructionId, error) {
	_instructionid := &InstructionId{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("InstructionId packet too short: %d < 4", decoder.Length())
	}
	_instructionid.Type = uint16(decoder.ReadUint16())
	_instructionid.Len = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_instructionid.Len), 2+2)

	switch _instructionid.Type {
	case 1:
		return DecodeInstructionIdGotoTable(_instructionid, decoder)
	case 2:
		return DecodeInstructionIdWriteMetadata(_instructionid, decoder)
	case 3:
		return DecodeInstructionIdWriteActions(_instructionid, decoder)
	case 4:
		return DecodeInstructionIdApplyActions(_instructionid, decoder)
	case 5:
		return DecodeInstructionIdClearActions(_instructionid, decoder)
	case 65535:
		return DecodeInstructionIdExperimenter(_instructionid, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'InstructionId'", _instructionid.Type)
	}
}

func NewInstructionId(_type uint16) *InstructionId {
	obj := &InstructionId{}
	obj.Type = _type
	return obj
}

type InstructionIdApplyActions struct {
	*InstructionId
}

type IInstructionIdApplyActions interface {
	IInstructionId
}

func (self *InstructionIdApplyActions) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionId.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdApplyActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdApplyActions, error) {
	_instructionidapplyactions := &InstructionIdApplyActions{InstructionId: parent}
	return _instructionidapplyactions, nil
}

func NewInstructionIdApplyActions() *InstructionIdApplyActions {
	obj := &InstructionIdApplyActions{
		InstructionId: NewInstructionId(4),
	}
	return obj
}

type InstructionIdClearActions struct {
	*InstructionId
}

type IInstructionIdClearActions interface {
	IInstructionId
}

func (self *InstructionIdClearActions) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionId.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdClearActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdClearActions, error) {
	_instructionidclearactions := &InstructionIdClearActions{InstructionId: parent}
	return _instructionidclearactions, nil
}

func NewInstructionIdClearActions() *InstructionIdClearActions {
	obj := &InstructionIdClearActions{
		InstructionId: NewInstructionId(5),
	}
	return obj
}

type InstructionIdExperimenter struct {
	*InstructionId
	Experimenter uint32
}

type IInstructionIdExperimenter interface {
	IInstructionId
	GetExperimenter() uint32
}

func (self *InstructionIdExperimenter) GetExperimenter() uint32 {
	return self.Experimenter
}

func (self *InstructionIdExperimenter) SetExperimenter(v uint32) {
	self.Experimenter = v
}

func (self *InstructionIdExperimenter) Serialize(encoder *goloxi.Encoder) error {
	if err := self.InstructionId.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Experimenter))

	return nil
}

func DecodeInstructionIdExperimenter(parent *InstructionId, decoder *goloxi.Decoder) (IInstructionIdExperimenter, error) {
	_instructionidexperimenter := &InstructionIdExperimenter{InstructionId: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("InstructionIdExperimenter packet too short: %d < 4", decoder.Length())
	}
	_instructionidexperimenter.Experimenter = uint32(decoder.ReadUint32())
	return _instructionidexperimenter, nil
}

func NewInstructionIdExperimenter(_experimenter uint32) *InstructionIdExperimenter {
	obj := &InstructionIdExperimenter{
		InstructionId: NewInstructionId(65535),
	}
	obj.Experimenter = _experimenter
	return obj
}

type InstructionIdGotoTable struct {
	*InstructionId
}

type IInstructionIdGotoTable interface {
	IInstructionId
}

func (self *InstructionIdGotoTable) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionId.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdGotoTable(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdGotoTable, error) {
	_instructionidgototable := &InstructionIdGotoTable{InstructionId: parent}
	return _instructionidgototable, nil
}

func NewInstructionIdGotoTable() *InstructionIdGotoTable {
	obj := &InstructionIdGotoTable{
		InstructionId: NewInstructionId(1),
	}
	return obj
}

type InstructionIdWriteActions struct {
	*InstructionId
}

type IInstructionIdWriteActions interface {
	IInstructionId
}

func (self *InstructionIdWriteActions) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionId.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdWriteActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdWriteActions, error) {
	_instructionidwriteactions := &InstructionIdWriteActions{InstructionId: parent}
	return _instructionidwriteactions, nil
}

func NewInstructionIdWriteActions() *InstructionIdWriteActions {
	obj := &InstructionIdWriteActions{
		InstructionId: NewInstructionId(3),
	}
	return obj
}

type InstructionIdWriteMetadata struct {
	*InstructionId
}

type IInstructionIdWriteMetadata interface {
	IInstructionId
}

func (self *InstructionIdWriteMetadata) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionId.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdWriteMetadata(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdWriteMetadata, error) {
	_instructionidwritemetadata := &InstructionIdWriteMetadata{InstructionId: parent}
	return _instructionidwritemetadata, nil
}

func NewInstructionIdWriteMetadata() *InstructionIdWriteMetadata {
	obj := &InstructionIdWriteMetadata{
		InstructionId: NewInstructionId(2),
	}
	return obj
}

type MatchV2 struct {
	Type         uint16
	Length       uint16
	InPort       Port
	Wildcards    WcBmap
	EthSrc       net.HardwareAddr
	EthSrcMask   net.HardwareAddr
	EthDst       net.HardwareAddr
	EthDstMask   net.HardwareAddr
	VlanVid      uint16
	VlanPcp      uint8
	EthType      uint16
	IpDscp       uint8
	IpProto      uint8
	Ipv4Src      net.IP
	Ipv4SrcMask  net.IP
	Ipv4Dst      net.IP
	Ipv4DstMask  net.IP
	TcpSrc       uint16
	TcpDst       uint16
	MplsLabel    uint32
	MplsTc       uint8
	Metadata     uint64
	MetadataMask uint64
}

type IMatchV2 interface {
	goloxi.Serializable
	GetType() uint16
	GetLength() uint16
	GetInPort() Port
	GetWildcards() WcBmap
	GetEthSrc() net.HardwareAddr
	GetEthSrcMask() net.HardwareAddr
	GetEthDst() net.HardwareAddr
	GetEthDstMask() net.HardwareAddr
	GetVlanVid() uint16
	GetVlanPcp() uint8
	GetEthType() uint16
	GetIpDscp() uint8
	GetIpProto() uint8
	GetIpv4Src() net.IP
	GetIpv4SrcMask() net.IP
	GetIpv4Dst() net.IP
	GetIpv4DstMask() net.IP
	GetTcpSrc() uint16
	GetTcpDst() uint16
	GetMplsLabel() uint32
	GetMplsTc() uint8
	GetMetadata() uint64
	GetMetadataMask() uint64
}

func (self *MatchV2) GetType() uint16 {
	return self.Type
}

func (self *MatchV2) SetType(v uint16) {
	self.Type = v
}

func (self *MatchV2) GetLength() uint16 {
	return self.Length
}

func (self *MatchV2) SetLength(v uint16) {
	self.Length = v
}

func (self *MatchV2) GetInPort() Port {
	return self.InPort
}

func (self *MatchV2) SetInPort(v Port) {
	self.InPort = v
}

func (self *MatchV2) GetWildcards() WcBmap {
	return self.Wildcards
}

func (self *MatchV2) SetWildcards(v WcBmap) {
	self.Wildcards = v
}

func (self *MatchV2) GetEthSrc() net.HardwareAddr {
	return self.EthSrc
}

func (self *MatchV2) SetEthSrc(v net.HardwareAddr) {
	self.EthSrc = v
}

func (self *MatchV2) GetEthSrcMask() net.HardwareAddr {
	return self.EthSrcMask
}

func (self *MatchV2) SetEthSrcMask(v net.HardwareAddr) {
	self.EthSrcMask = v
}

func (self *MatchV2) GetEthDst() net.HardwareAddr {
	return self.EthDst
}

func (self *MatchV2) SetEthDst(v net.HardwareAddr) {
	self.EthDst = v
}

func (self *MatchV2) GetEthDstMask() net.HardwareAddr {
	return self.EthDstMask
}

func (self *MatchV2) SetEthDstMask(v net.HardwareAddr) {
	self.EthDstMask = v
}

func (self *MatchV2) GetVlanVid() uint16 {
	return self.VlanVid
}

func (self *MatchV2) SetVlanVid(v uint16) {
	self.VlanVid = v
}

func (self *MatchV2) GetVlanPcp() uint8 {
	return self.VlanPcp
}

func (self *MatchV2) SetVlanPcp(v uint8) {
	self.VlanPcp = v
}

func (self *MatchV2) GetEthType() uint16 {
	return self.EthType
}

func (self *MatchV2) SetEthType(v uint16) {
	self.EthType = v
}

func (self *MatchV2) GetIpDscp() uint8 {
	return self.IpDscp
}

func (self *MatchV2) SetIpDscp(v uint8) {
	self.IpDscp = v
}

func (self *MatchV2) GetIpProto() uint8 {
	return self.IpProto
}

func (self *MatchV2) SetIpProto(v uint8) {
	self.IpProto = v
}

func (self *MatchV2) GetIpv4Src() net.IP {
	return self.Ipv4Src
}

func (self *MatchV2) SetIpv4Src(v net.IP) {
	self.Ipv4Src = v
}

func (self *MatchV2) GetIpv4SrcMask() net.IP {
	return self.Ipv4SrcMask
}

func (self *MatchV2) SetIpv4SrcMask(v net.IP) {
	self.Ipv4SrcMask = v
}

func (self *MatchV2) GetIpv4Dst() net.IP {
	return self.Ipv4Dst
}

func (self *MatchV2) SetIpv4Dst(v net.IP) {
	self.Ipv4Dst = v
}

func (self *MatchV2) GetIpv4DstMask() net.IP {
	return self.Ipv4DstMask
}

func (self *MatchV2) SetIpv4DstMask(v net.IP) {
	self.Ipv4DstMask = v
}

func (self *MatchV2) GetTcpSrc() uint16 {
	return self.TcpSrc
}

func (self *MatchV2) SetTcpSrc(v uint16) {
	self.TcpSrc = v
}

func (self *MatchV2) GetTcpDst() uint16 {
	return self.TcpDst
}

func (self *MatchV2) SetTcpDst(v uint16) {
	self.TcpDst = v
}

func (self *MatchV2) GetMplsLabel() uint32 {
	return self.MplsLabel
}

func (self *MatchV2) SetMplsLabel(v uint32) {
	self.MplsLabel = v
}

func (self *MatchV2) GetMplsTc() uint8 {
	return self.MplsTc
}

func (self *MatchV2) SetMplsTc(v uint8) {
	self.MplsTc = v
}

func (self *MatchV2) GetMetadata() uint64 {
	return self.Metadata
}

func (self *MatchV2) SetMetadata(v uint64) {
	self.Metadata = v
}

func (self *MatchV2) GetMetadataMask() uint64 {
	return self.MetadataMask
}

func (self *MatchV2) SetMetadataMask(v uint64) {
	self.MetadataMask = v
}

func (self *MatchV2) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Length))
	self.InPort.Serialize(encoder)
	self.Wildcards.Serialize(encoder)
	encoder.Write(self.EthSrc)
	encoder.Write(self.EthSrcMask)
	encoder.Write(self.EthDst)
	encoder.Write(self.EthDstMask)
	encoder.PutUint16(uint16(self.VlanVid))
	encoder.PutUint8(uint8(self.VlanPcp))
	encoder.Write(bytes.Repeat([]byte{0}, 1))
	encoder.PutUint16(uint16(self.EthType))
	encoder.PutUint8(uint8(self.IpDscp))
	encoder.PutUint8(uint8(self.IpProto))
	encoder.Write(self.Ipv4Src.To4())
	encoder.Write(self.Ipv4SrcMask.To4())
	encoder.Write(self.Ipv4Dst.To4())
	encoder.Write(self.Ipv4DstMask.To4())
	encoder.PutUint16(uint16(self.TcpSrc))
	encoder.PutUint16(uint16(self.TcpDst))
	encoder.PutUint32(uint32(self.MplsLabel))
	encoder.PutUint8(uint8(self.MplsTc))
	encoder.Write(bytes.Repeat([]byte{0}, 3))
	encoder.PutUint64(uint64(self.Metadata))
	encoder.PutUint64(uint64(self.MetadataMask))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}
func (self *MatchV2) Decode(decoder *goloxi.Decoder) error {
	if decoder.Length() < 88 {
		return fmt.Errorf("MatchV2 packet too short: %d < 88", decoder.Length())
	}

	self.Type = uint16(decoder.ReadUint16())
	self.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(self.Length), 2+2)
	self.InPort.Decode(decoder)
	self.Wildcards.Decode(decoder)
	self.EthSrc = net.HardwareAddr(decoder.Read(6))
	self.EthSrcMask = net.HardwareAddr(decoder.Read(6))
	self.EthDst = net.HardwareAddr(decoder.Read(6))
	self.EthDstMask = net.HardwareAddr(decoder.Read(6))
	self.VlanVid = uint16(decoder.ReadUint16())
	self.VlanPcp = uint8(decoder.ReadByte())
	decoder.Skip(1)
	self.EthType = uint16(decoder.ReadUint16())
	self.IpDscp = uint8(decoder.ReadByte())
	self.IpProto = uint8(decoder.ReadByte())
	self.Ipv4Src = net.IP(decoder.Read(4))
	self.Ipv4SrcMask = net.IP(decoder.Read(4))
	self.Ipv4Dst = net.IP(decoder.Read(4))
	self.Ipv4DstMask = net.IP(decoder.Read(4))
	self.TcpSrc = uint16(decoder.ReadUint16())
	self.TcpDst = uint16(decoder.ReadUint16())
	self.MplsLabel = uint32(decoder.ReadUint32())
	self.MplsTc = uint8(decoder.ReadByte())
	decoder.Skip(3)
	self.Metadata = uint64(decoder.ReadUint64())
	self.MetadataMask = uint64(decoder.ReadUint64())

	return nil
}

func NewMatchV2() *MatchV2 {
	obj := &MatchV2{}
	return obj
}

type NiciraMatch struct {
	NxmEntries []goloxi.IOxm
}

type INiciraMatch interface {
	goloxi.Serializable
	GetNxmEntries() []goloxi.IOxm
}

func (self *NiciraMatch) GetNxmEntries() []goloxi.IOxm {
	return self.NxmEntries
}

func (self *NiciraMatch) SetNxmEntries(v []goloxi.IOxm) {
	self.NxmEntries = v
}

func (self *NiciraMatch) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	for _, obj := range self.NxmEntries {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex
	alignedLength := ((length + 7) / 8 * 8)

	encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))

	return nil
}
func (self *NiciraMatch) Decode(decoder *goloxi.Decoder) error {

	defer decoder.SkipAlign()

	for decoder.Length() >= 4 {
		item, err := DecodeOxm(decoder)
		if err != nil {
			return err
		}
		if item != nil {
			self.NxmEntries = append(self.NxmEntries, item)
		}
	}

	return nil
}

func NewNiciraMatch() *NiciraMatch {
	obj := &NiciraMatch{}
	return obj
}

type NiciraFlowStats struct {
	Length       uint16
	TableId      uint8
	DurationSec  uint32
	DurationNsec uint32
	Priority     uint16
	IdleTimeout  uint16
	HardTimeout  uint16
	MatchLen     uint16
	IdleAge      uint16
	HardAge      uint16
	Cookie       uint64
	PacketCount  uint64
	ByteCount    uint64
	Match        NiciraMatch
	Actions      []goloxi.IAction
}

type INiciraFlowStats interface {
	goloxi.Serializable
	GetLength() uint16
	GetTableId() uint8
	GetDurationSec() uint32
	GetDurationNsec() uint32
	GetPriority() uint16
	GetIdleTimeout() uint16
	GetHardTimeout() uint16
	GetMatchLen() uint16
	GetIdleAge() uint16
	GetHardAge() uint16
	GetCookie() uint64
	GetPacketCount() uint64
	GetByteCount() uint64
	GetMatch() NiciraMatch
	GetActions() []goloxi.IAction
}

func (self *NiciraFlowStats) GetLength() uint16 {
	return self.Length
}

func (self *NiciraFlowStats) SetLength(v uint16) {
	self.Length = v
}

func (self *NiciraFlowStats) GetTableId() uint8 {
	return self.TableId
}

func (self *NiciraFlowStats) SetTableId(v uint8) {
	self.TableId = v
}

func (self *NiciraFlowStats) GetDurationSec() uint32 {
	return self.DurationSec
}

func (self *NiciraFlowStats) SetDurationSec(v uint32) {
	self.DurationSec = v
}

func (self *NiciraFlowStats) GetDurationNsec() uint32 {
	return self.DurationNsec
}

func (self *NiciraFlowStats) SetDurationNsec(v uint32) {
	self.DurationNsec = v
}

func (self *NiciraFlowStats) GetPriority() uint16 {
	return self.Priority
}

func (self *NiciraFlowStats) SetPriority(v uint16) {
	self.Priority = v
}

func (self *NiciraFlowStats) GetIdleTimeout() uint16 {
	return self.IdleTimeout
}

func (self *NiciraFlowStats) SetIdleTimeout(v uint16) {
	self.IdleTimeout = v
}

func (self *NiciraFlowStats) GetHardTimeout() uint16 {
	return self.HardTimeout
}

func (self *NiciraFlowStats) SetHardTimeout(v uint16) {
	self.HardTimeout = v
}

func (self *NiciraFlowStats) GetMatchLen() uint16 {
	return self.MatchLen
}

func (self *NiciraFlowStats) SetMatchLen(v uint16) {
	self.MatchLen = v
}

func (self *NiciraFlowStats) GetIdleAge() uint16 {
	return self.IdleAge
}

func (self *NiciraFlowStats) SetIdleAge(v uint16) {
	self.IdleAge = v
}

func (self *NiciraFlowStats) GetHardAge() uint16 {
	return self.HardAge
}

func (self *NiciraFlowStats) SetHardAge(v uint16) {
	self.HardAge = v
}

func (self *NiciraFlowStats) GetCookie() uint64 {
	return self.Cookie
}

func (self *NiciraFlowStats) SetCookie(v uint64) {
	self.Cookie = v
}

func (self *NiciraFlowStats) GetPacketCount() uint64 {
	return self.PacketCount
}

func (self *NiciraFlowStats) SetPacketCount(v uint64) {
	self.PacketCount = v
}

func (self *NiciraFlowStats) GetByteCount() uint64 {
	return self.ByteCount
}

func (self *NiciraFlowStats) SetByteCount(v uint64) {
	self.ByteCount = v
}

func (self *NiciraFlowStats) GetMatch() NiciraMatch {
	return self.Match
}

func (self *NiciraFlowStats) SetMatch(v NiciraMatch) {
	self.Match = v
}

func (self *NiciraFlowStats) GetActions() []goloxi.IAction {
	return self.Actions
}

func (self *NiciraFlowStats) SetActions(v []goloxi.IAction) {
	self.Actions = v
}

func (self *NiciraFlowStats) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Length))
	encoder.PutUint8(uint8(self.TableId))
	encoder.Write(bytes.Repeat([]byte{0}, 1))
	encoder.PutUint32(uint32(self.DurationSec))
	encoder.PutUint32(uint32(self.DurationNsec))
	encoder.PutUint16(uint16(self.Priority))
	encoder.PutUint16(uint16(self.IdleTimeout))
	encoder.PutUint16(uint16(self.HardTimeout))
	encoder.PutUint16(uint16(self.MatchLen))
	encoder.PutUint16(uint16(self.IdleAge))
	encoder.PutUint16(uint16(self.HardAge))
	encoder.PutUint64(uint64(self.Cookie))
	encoder.PutUint64(uint64(self.PacketCount))
	encoder.PutUint64(uint64(self.ByteCount))
	if err := self.Match.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.Actions {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))

	return nil
}

func DecodeNiciraFlowStats(decoder *goloxi.Decoder) (*NiciraFlowStats, error) {
	_niciraflowstats := &NiciraFlowStats{}
	if decoder.Length() < 48 {
		return nil, fmt.Errorf("NiciraFlowStats packet too short: %d < 48", decoder.Length())
	}
	_niciraflowstats.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_niciraflowstats.Length), 2+0)
	_niciraflowstats.TableId = uint8(decoder.ReadByte())
	decoder.Skip(1)
	_niciraflowstats.DurationSec = uint32(decoder.ReadUint32())
	_niciraflowstats.DurationNsec = uint32(decoder.ReadUint32())
	_niciraflowstats.Priority = uint16(decoder.ReadUint16())
	_niciraflowstats.IdleTimeout = uint16(decoder.ReadUint16())
	_niciraflowstats.HardTimeout = uint16(decoder.ReadUint16())
	_niciraflowstats.MatchLen = uint16(decoder.ReadUint16())
	_niciraflowstats.IdleAge = uint16(decoder.ReadUint16())
	_niciraflowstats.HardAge = uint16(decoder.ReadUint16())
	_niciraflowstats.Cookie = uint64(decoder.ReadUint64())
	_niciraflowstats.PacketCount = uint64(decoder.ReadUint64())
	_niciraflowstats.ByteCount = uint64(decoder.ReadUint64())
	if err := _niciraflowstats.Match.Decode(decoder.SliceDecoder(int(_niciraflowstats.MatchLen), 0)); err != nil {
		return nil, err
	}

	decoder.SkipAlign()

	for decoder.Length() >= 8 {
		item, err := DecodeAction(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_niciraflowstats.Actions = append(_niciraflowstats.Actions, item)
		}
	}
	return _niciraflowstats, nil
}

func NewNiciraFlowStats() *NiciraFlowStats {
	obj := &NiciraFlowStats{}
	return obj
}

type NiciraFlowUpdateEvent struct {
	Length uint16
	Event  uint16
}

type INiciraFlowUpdateEvent interface {
	goloxi.Serializable
	GetLength() uint16
	GetEvent() uint16
}

func (self *NiciraFlowUpdateEvent) GetLength() uint16 {
	return self.Length
}

func (self *NiciraFlowUpdateEvent) SetLength(v uint16) {
	self.Length = v
}

func (self *NiciraFlowUpdateEvent) GetEvent() uint16 {
	return self.Event
}

func (self *NiciraFlowUpdateEvent) SetEvent(v uint16) {
	self.Event = v
}

func (self *NiciraFlowUpdateEvent) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Length))
	encoder.PutUint16(uint16(self.Event))

	return nil
}

func DecodeNiciraFlowUpdateEvent(decoder *goloxi.Decoder) (INiciraFlowUpdateEvent, error) {
	_niciraflowupdateevent := &NiciraFlowUpdateEvent{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NiciraFlowUpdateEvent packet too short: %d < 4", decoder.Length())
	}
	_niciraflowupdateevent.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_niciraflowupdateevent.Length), 2+0)
	_niciraflowupdateevent.Event = uint16(decoder.ReadUint16())

	switch _niciraflowupdateevent.Event {
	case 0:
		return DecodeNiciraFlowUpdateFullAdd(_niciraflowupdateevent, decoder)
	case 1:
		return DecodeNiciraFlowUpdateFullDeleted(_niciraflowupdateevent, decoder)
	case 2:
		return DecodeNiciraFlowUpdateFullModified(_niciraflowupdateevent, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'NiciraFlowUpdateEvent'", _niciraflowupdateevent.Event)
	}
}

func NewNiciraFlowUpdateEvent(_event uint16) *NiciraFlowUpdateEvent {
	obj := &NiciraFlowUpdateEvent{}
	obj.Event = _event
	return obj
}

type NiciraFlowUpdateFullAdd struct {
	*NiciraFlowUpdateEvent
	Reason      uint16
	Priority    uint16
	IdleTimeout uint16
	HardTimeout uint16
	MatchLen    uint16
	TableId     uint8
	Cookie      uint64
	Match       NiciraMatch
	Actions     []goloxi.IAction
}

type INiciraFlowUpdateFullAdd interface {
	INiciraFlowUpdateEvent
	GetReason() uint16
	GetPriority() uint16
	GetIdleTimeout() uint16
	GetHardTimeout() uint16
	GetMatchLen() uint16
	GetTableId() uint8
	GetCookie() uint64
	GetMatch() NiciraMatch
	GetActions() []goloxi.IAction
}

func (self *NiciraFlowUpdateFullAdd) GetReason() uint16 {
	return self.Reason
}

func (self *NiciraFlowUpdateFullAdd) SetReason(v uint16) {
	self.Reason = v
}

func (self *NiciraFlowUpdateFullAdd) GetPriority() uint16 {
	return self.Priority
}

func (self *NiciraFlowUpdateFullAdd) SetPriority(v uint16) {
	self.Priority = v
}

func (self *NiciraFlowUpdateFullAdd) GetIdleTimeout() uint16 {
	return self.IdleTimeout
}

func (self *NiciraFlowUpdateFullAdd) SetIdleTimeout(v uint16) {
	self.IdleTimeout = v
}

func (self *NiciraFlowUpdateFullAdd) GetHardTimeout() uint16 {
	return self.HardTimeout
}

func (self *NiciraFlowUpdateFullAdd) SetHardTimeout(v uint16) {
	self.HardTimeout = v
}

func (self *NiciraFlowUpdateFullAdd) GetMatchLen() uint16 {
	return self.MatchLen
}

func (self *NiciraFlowUpdateFullAdd) SetMatchLen(v uint16) {
	self.MatchLen = v
}

func (self *NiciraFlowUpdateFullAdd) GetTableId() uint8 {
	return self.TableId
}

func (self *NiciraFlowUpdateFullAdd) SetTableId(v uint8) {
	self.TableId = v
}

func (self *NiciraFlowUpdateFullAdd) GetCookie() uint64 {
	return self.Cookie
}

func (self *NiciraFlowUpdateFullAdd) SetCookie(v uint64) {
	self.Cookie = v
}

func (self *NiciraFlowUpdateFullAdd) GetMatch() NiciraMatch {
	return self.Match
}

func (self *NiciraFlowUpdateFullAdd) SetMatch(v NiciraMatch) {
	self.Match = v
}

func (self *NiciraFlowUpdateFullAdd) GetActions() []goloxi.IAction {
	return self.Actions
}

func (self *NiciraFlowUpdateFullAdd) SetActions(v []goloxi.IAction) {
	self.Actions = v
}

func (self *NiciraFlowUpdateFullAdd) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Reason))
	encoder.PutUint16(uint16(self.Priority))
	encoder.PutUint16(uint16(self.IdleTimeout))
	encoder.PutUint16(uint16(self.HardTimeout))
	encoder.PutUint16(uint16(self.MatchLen))
	encoder.PutUint8(uint8(self.TableId))
	encoder.Write(bytes.Repeat([]byte{0}, 1))
	encoder.PutUint64(uint64(self.Cookie))
	if err := self.Match.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.Actions {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))

	return nil
}

func DecodeNiciraFlowUpdateFullAdd(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullAdd, error) {
	_niciraflowupdatefulladd := &NiciraFlowUpdateFullAdd{NiciraFlowUpdateEvent: parent}
	if decoder.Length() < 20 {
		return nil, fmt.Errorf("NiciraFlowUpdateFullAdd packet too short: %d < 20", decoder.Length())
	}
	_niciraflowupdatefulladd.Reason = uint16(decoder.ReadUint16())
	_niciraflowupdatefulladd.Priority = uint16(decoder.ReadUint16())
	_niciraflowupdatefulladd.IdleTimeout = uint16(decoder.ReadUint16())
	_niciraflowupdatefulladd.HardTimeout = uint16(decoder.ReadUint16())
	_niciraflowupdatefulladd.MatchLen = uint16(decoder.ReadUint16())
	_niciraflowupdatefulladd.TableId = uint8(decoder.ReadByte())
	decoder.Skip(1)
	_niciraflowupdatefulladd.Cookie = uint64(decoder.ReadUint64())
	if err := _niciraflowupdatefulladd.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefulladd.MatchLen), 0)); err != nil {
		return nil, err
	}

	decoder.SkipAlign()

	for decoder.Length() >= 8 {
		item, err := DecodeAction(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_niciraflowupdatefulladd.Actions = append(_niciraflowupdatefulladd.Actions, item)
		}
	}
	return _niciraflowupdatefulladd, nil
}

func NewNiciraFlowUpdateFullAdd() *NiciraFlowUpdateFullAdd {
	obj := &NiciraFlowUpdateFullAdd{
		NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(0),
	}
	return obj
}

type NiciraFlowUpdateFullDeleted struct {
	*NiciraFlowUpdateEvent
	Reason      uint16
	Priority    uint16
	IdleTimeout uint16
	HardTimeout uint16
	MatchLen    uint16
	TableId     uint8
	Cookie      uint64
	Match       NiciraMatch
	Actions     []goloxi.IAction
}

type INiciraFlowUpdateFullDeleted interface {
	INiciraFlowUpdateEvent
	GetReason() uint16
	GetPriority() uint16
	GetIdleTimeout() uint16
	GetHardTimeout() uint16
	GetMatchLen() uint16
	GetTableId() uint8
	GetCookie() uint64
	GetMatch() NiciraMatch
	GetActions() []goloxi.IAction
}

func (self *NiciraFlowUpdateFullDeleted) GetReason() uint16 {
	return self.Reason
}

func (self *NiciraFlowUpdateFullDeleted) SetReason(v uint16) {
	self.Reason = v
}

func (self *NiciraFlowUpdateFullDeleted) GetPriority() uint16 {
	return self.Priority
}

func (self *NiciraFlowUpdateFullDeleted) SetPriority(v uint16) {
	self.Priority = v
}

func (self *NiciraFlowUpdateFullDeleted) GetIdleTimeout() uint16 {
	return self.IdleTimeout
}

func (self *NiciraFlowUpdateFullDeleted) SetIdleTimeout(v uint16) {
	self.IdleTimeout = v
}

func (self *NiciraFlowUpdateFullDeleted) GetHardTimeout() uint16 {
	return self.HardTimeout
}

func (self *NiciraFlowUpdateFullDeleted) SetHardTimeout(v uint16) {
	self.HardTimeout = v
}

func (self *NiciraFlowUpdateFullDeleted) GetMatchLen() uint16 {
	return self.MatchLen
}

func (self *NiciraFlowUpdateFullDeleted) SetMatchLen(v uint16) {
	self.MatchLen = v
}

func (self *NiciraFlowUpdateFullDeleted) GetTableId() uint8 {
	return self.TableId
}

func (self *NiciraFlowUpdateFullDeleted) SetTableId(v uint8) {
	self.TableId = v
}

func (self *NiciraFlowUpdateFullDeleted) GetCookie() uint64 {
	return self.Cookie
}

func (self *NiciraFlowUpdateFullDeleted) SetCookie(v uint64) {
	self.Cookie = v
}

func (self *NiciraFlowUpdateFullDeleted) GetMatch() NiciraMatch {
	return self.Match
}

func (self *NiciraFlowUpdateFullDeleted) SetMatch(v NiciraMatch) {
	self.Match = v
}

func (self *NiciraFlowUpdateFullDeleted) GetActions() []goloxi.IAction {
	return self.Actions
}

func (self *NiciraFlowUpdateFullDeleted) SetActions(v []goloxi.IAction) {
	self.Actions = v
}

func (self *NiciraFlowUpdateFullDeleted) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Reason))
	encoder.PutUint16(uint16(self.Priority))
	encoder.PutUint16(uint16(self.IdleTimeout))
	encoder.PutUint16(uint16(self.HardTimeout))
	encoder.PutUint16(uint16(self.MatchLen))
	encoder.PutUint8(uint8(self.TableId))
	encoder.Write(bytes.Repeat([]byte{0}, 1))
	encoder.PutUint64(uint64(self.Cookie))
	if err := self.Match.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.Actions {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))

	return nil
}

func DecodeNiciraFlowUpdateFullDeleted(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullDeleted, error) {
	_niciraflowupdatefulldeleted := &NiciraFlowUpdateFullDeleted{NiciraFlowUpdateEvent: parent}
	if decoder.Length() < 20 {
		return nil, fmt.Errorf("NiciraFlowUpdateFullDeleted packet too short: %d < 20", decoder.Length())
	}
	_niciraflowupdatefulldeleted.Reason = uint16(decoder.ReadUint16())
	_niciraflowupdatefulldeleted.Priority = uint16(decoder.ReadUint16())
	_niciraflowupdatefulldeleted.IdleTimeout = uint16(decoder.ReadUint16())
	_niciraflowupdatefulldeleted.HardTimeout = uint16(decoder.ReadUint16())
	_niciraflowupdatefulldeleted.MatchLen = uint16(decoder.ReadUint16())
	_niciraflowupdatefulldeleted.TableId = uint8(decoder.ReadByte())
	decoder.Skip(1)
	_niciraflowupdatefulldeleted.Cookie = uint64(decoder.ReadUint64())
	if err := _niciraflowupdatefulldeleted.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefulldeleted.MatchLen), 0)); err != nil {
		return nil, err
	}

	decoder.SkipAlign()

	for decoder.Length() >= 8 {
		item, err := DecodeAction(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_niciraflowupdatefulldeleted.Actions = append(_niciraflowupdatefulldeleted.Actions, item)
		}
	}
	return _niciraflowupdatefulldeleted, nil
}

func NewNiciraFlowUpdateFullDeleted() *NiciraFlowUpdateFullDeleted {
	obj := &NiciraFlowUpdateFullDeleted{
		NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(1),
	}
	return obj
}

type NiciraFlowUpdateFullModified struct {
	*NiciraFlowUpdateEvent
	Reason      uint16
	Priority    uint16
	IdleTimeout uint16
	HardTimeout uint16
	MatchLen    uint16
	TableId     uint8
	Cookie      uint64
	Match       NiciraMatch
	Actions     []goloxi.IAction
}

type INiciraFlowUpdateFullModified interface {
	INiciraFlowUpdateEvent
	GetReason() uint16
	GetPriority() uint16
	GetIdleTimeout() uint16
	GetHardTimeout() uint16
	GetMatchLen() uint16
	GetTableId() uint8
	GetCookie() uint64
	GetMatch() NiciraMatch
	GetActions() []goloxi.IAction
}

func (self *NiciraFlowUpdateFullModified) GetReason() uint16 {
	return self.Reason
}

func (self *NiciraFlowUpdateFullModified) SetReason(v uint16) {
	self.Reason = v
}

func (self *NiciraFlowUpdateFullModified) GetPriority() uint16 {
	return self.Priority
}

func (self *NiciraFlowUpdateFullModified) SetPriority(v uint16) {
	self.Priority = v
}

func (self *NiciraFlowUpdateFullModified) GetIdleTimeout() uint16 {
	return self.IdleTimeout
}

func (self *NiciraFlowUpdateFullModified) SetIdleTimeout(v uint16) {
	self.IdleTimeout = v
}

func (self *NiciraFlowUpdateFullModified) GetHardTimeout() uint16 {
	return self.HardTimeout
}

func (self *NiciraFlowUpdateFullModified) SetHardTimeout(v uint16) {
	self.HardTimeout = v
}

func (self *NiciraFlowUpdateFullModified) GetMatchLen() uint16 {
	return self.MatchLen
}

func (self *NiciraFlowUpdateFullModified) SetMatchLen(v uint16) {
	self.MatchLen = v
}

func (self *NiciraFlowUpdateFullModified) GetTableId() uint8 {
	return self.TableId
}

func (self *NiciraFlowUpdateFullModified) SetTableId(v uint8) {
	self.TableId = v
}

func (self *NiciraFlowUpdateFullModified) GetCookie() uint64 {
	return self.Cookie
}

func (self *NiciraFlowUpdateFullModified) SetCookie(v uint64) {
	self.Cookie = v
}

func (self *NiciraFlowUpdateFullModified) GetMatch() NiciraMatch {
	return self.Match
}

func (self *NiciraFlowUpdateFullModified) SetMatch(v NiciraMatch) {
	self.Match = v
}

func (self *NiciraFlowUpdateFullModified) GetActions() []goloxi.IAction {
	return self.Actions
}

func (self *NiciraFlowUpdateFullModified) SetActions(v []goloxi.IAction) {
	self.Actions = v
}

func (self *NiciraFlowUpdateFullModified) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Reason))
	encoder.PutUint16(uint16(self.Priority))
	encoder.PutUint16(uint16(self.IdleTimeout))
	encoder.PutUint16(uint16(self.HardTimeout))
	encoder.PutUint16(uint16(self.MatchLen))
	encoder.PutUint8(uint8(self.TableId))
	encoder.Write(bytes.Repeat([]byte{0}, 1))
	encoder.PutUint64(uint64(self.Cookie))
	if err := self.Match.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.Actions {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))

	return nil
}

func DecodeNiciraFlowUpdateFullModified(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullModified, error) {
	_niciraflowupdatefullmodified := &NiciraFlowUpdateFullModified{NiciraFlowUpdateEvent: parent}
	if decoder.Length() < 20 {
		return nil, fmt.Errorf("NiciraFlowUpdateFullModified packet too short: %d < 20", decoder.Length())
	}
	_niciraflowupdatefullmodified.Reason = uint16(decoder.ReadUint16())
	_niciraflowupdatefullmodified.Priority = uint16(decoder.ReadUint16())
	_niciraflowupdatefullmodified.IdleTimeout = uint16(decoder.ReadUint16())
	_niciraflowupdatefullmodified.HardTimeout = uint16(decoder.ReadUint16())
	_niciraflowupdatefullmodified.MatchLen = uint16(decoder.ReadUint16())
	_niciraflowupdatefullmodified.TableId = uint8(decoder.ReadByte())
	decoder.Skip(1)
	_niciraflowupdatefullmodified.Cookie = uint64(decoder.ReadUint64())
	if err := _niciraflowupdatefullmodified.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefullmodified.MatchLen), 0)); err != nil {
		return nil, err
	}

	decoder.SkipAlign()

	for decoder.Length() >= 8 {
		item, err := DecodeAction(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_niciraflowupdatefullmodified.Actions = append(_niciraflowupdatefullmodified.Actions, item)
		}
	}
	return _niciraflowupdatefullmodified, nil
}

func NewNiciraFlowUpdateFullModified() *NiciraFlowUpdateFullModified {
	obj := &NiciraFlowUpdateFullModified{
		NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(2),
	}
	return obj
}

type OxmIdArpOp struct {
	*OxmId
}

type IOxmIdArpOp interface {
	IOxmId
}

func (self *OxmIdArpOp) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdArpOp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpOp, error) {
	_oxmidarpop := &OxmIdArpOp{OxmId: parent}
	return _oxmidarpop, nil
}

func NewOxmIdArpOp() *OxmIdArpOp {
	obj := &OxmIdArpOp{
		OxmId: NewOxmId(7682),
	}
	return obj
}
func (self *OxmIdArpOp) GetOXMName() string {
	return "arp_op"
}

func (self *OxmIdArpOp) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdArpSha struct {
	*OxmId
}

type IOxmIdArpSha interface {
	IOxmId
}

func (self *OxmIdArpSha) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdArpSha(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSha, error) {
	_oxmidarpsha := &OxmIdArpSha{OxmId: parent}
	return _oxmidarpsha, nil
}

func NewOxmIdArpSha() *OxmIdArpSha {
	obj := &OxmIdArpSha{
		OxmId: NewOxmId(74246),
	}
	return obj
}
func (self *OxmIdArpSha) GetOXMName() string {
	return "arp_sha"
}

func (self *OxmIdArpSha) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdArpShaMasked struct {
	*OxmId
}

type IOxmIdArpShaMasked interface {
	IOxmId
}

func (self *OxmIdArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdArpShaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpShaMasked, error) {
	_oxmidarpshamasked := &OxmIdArpShaMasked{OxmId: parent}
	return _oxmidarpshamasked, nil
}

func NewOxmIdArpShaMasked() *OxmIdArpShaMasked {
	obj := &OxmIdArpShaMasked{
		OxmId: NewOxmId(74507),
	}
	return obj
}
func (self *OxmIdArpShaMasked) GetOXMName() string {
	return "arp_sha_masked"
}

func (self *OxmIdArpShaMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdArpSpa struct {
	*OxmId
}

type IOxmIdArpSpa interface {
	IOxmId
}

func (self *OxmIdArpSpa) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdArpSpa(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSpa, error) {
	_oxmidarpspa := &OxmIdArpSpa{OxmId: parent}
	return _oxmidarpspa, nil
}

func NewOxmIdArpSpa() *OxmIdArpSpa {
	obj := &OxmIdArpSpa{
		OxmId: NewOxmId(8196),
	}
	return obj
}
func (self *OxmIdArpSpa) GetOXMName() string {
	return "arp_spa"
}

func (self *OxmIdArpSpa) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdArpSpaMasked struct {
	*OxmId
}

type IOxmIdArpSpaMasked interface {
	IOxmId
}

func (self *OxmIdArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdArpSpaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSpaMasked, error) {
	_oxmidarpspamasked := &OxmIdArpSpaMasked{OxmId: parent}
	return _oxmidarpspamasked, nil
}

func NewOxmIdArpSpaMasked() *OxmIdArpSpaMasked {
	obj := &OxmIdArpSpaMasked{
		OxmId: NewOxmId(8452),
	}
	return obj
}
func (self *OxmIdArpSpaMasked) GetOXMName() string {
	return "arp_spa_masked"
}

func (self *OxmIdArpSpaMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdArpTha struct {
	*OxmId
}

type IOxmIdArpTha interface {
	IOxmId
}

func (self *OxmIdArpTha) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdArpTha(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTha, error) {
	_oxmidarptha := &OxmIdArpTha{OxmId: parent}
	return _oxmidarptha, nil
}

func NewOxmIdArpTha() *OxmIdArpTha {
	obj := &OxmIdArpTha{
		OxmId: NewOxmId(74758),
	}
	return obj
}
func (self *OxmIdArpTha) GetOXMName() string {
	return "arp_tha"
}

func (self *OxmIdArpTha) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdArpThaMasked struct {
	*OxmId
}

type IOxmIdArpThaMasked interface {
	IOxmId
}

func (self *OxmIdArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdArpThaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpThaMasked, error) {
	_oxmidarpthamasked := &OxmIdArpThaMasked{OxmId: parent}
	return _oxmidarpthamasked, nil
}

func NewOxmIdArpThaMasked() *OxmIdArpThaMasked {
	obj := &OxmIdArpThaMasked{
		OxmId: NewOxmId(75019),
	}
	return obj
}
func (self *OxmIdArpThaMasked) GetOXMName() string {
	return "arp_tha_masked"
}

func (self *OxmIdArpThaMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdArpTpa struct {
	*OxmId
}

type IOxmIdArpTpa interface {
	IOxmId
}

func (self *OxmIdArpTpa) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdArpTpa(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTpa, error) {
	_oxmidarptpa := &OxmIdArpTpa{OxmId: parent}
	return _oxmidarptpa, nil
}

func NewOxmIdArpTpa() *OxmIdArpTpa {
	obj := &OxmIdArpTpa{
		OxmId: NewOxmId(8708),
	}
	return obj
}
func (self *OxmIdArpTpa) GetOXMName() string {
	return "arp_tpa"
}

func (self *OxmIdArpTpa) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdArpTpaMasked struct {
	*OxmId
}

type IOxmIdArpTpaMasked interface {
	IOxmId
}

func (self *OxmIdArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdArpTpaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTpaMasked, error) {
	_oxmidarptpamasked := &OxmIdArpTpaMasked{OxmId: parent}
	return _oxmidarptpamasked, nil
}

func NewOxmIdArpTpaMasked() *OxmIdArpTpaMasked {
	obj := &OxmIdArpTpaMasked{
		OxmId: NewOxmId(8968),
	}
	return obj
}
func (self *OxmIdArpTpaMasked) GetOXMName() string {
	return "arp_tpa_masked"
}

func (self *OxmIdArpTpaMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConjId struct {
	*OxmId
}

type IOxmIdConjId interface {
	IOxmId
}

func (self *OxmIdConjId) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConjId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConjId, error) {
	_oxmidconjid := &OxmIdConjId{OxmId: parent}
	return _oxmidconjid, nil
}

func NewOxmIdConjId() *OxmIdConjId {
	obj := &OxmIdConjId{
		OxmId: NewOxmId(84484),
	}
	return obj
}
func (self *OxmIdConjId) GetOXMName() string {
	return "conj_id"
}

func (self *OxmIdConjId) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdCtIpv6Dst struct {
	*OxmId
}

type IOxmIdCtIpv6Dst interface {
	IOxmId
}

func (self *OxmIdCtIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdCtIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6Dst, error) {
	_oxmidctipv6dst := &OxmIdCtIpv6Dst{OxmId: parent}
	return _oxmidctipv6dst, nil
}

func NewOxmIdCtIpv6Dst() *OxmIdCtIpv6Dst {
	obj := &OxmIdCtIpv6Dst{
		OxmId: NewOxmId(128528),
	}
	return obj
}
func (self *OxmIdCtIpv6Dst) GetOXMName() string {
	return "ct_ipv6_dst"
}

func (self *OxmIdCtIpv6Dst) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdCtIpv6DstMasked struct {
	*OxmId
}

type IOxmIdCtIpv6DstMasked interface {
	IOxmId
}

func (self *OxmIdCtIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdCtIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6DstMasked, error) {
	_oxmidctipv6dstmasked := &OxmIdCtIpv6DstMasked{OxmId: parent}
	return _oxmidctipv6dstmasked, nil
}

func NewOxmIdCtIpv6DstMasked() *OxmIdCtIpv6DstMasked {
	obj := &OxmIdCtIpv6DstMasked{
		OxmId: NewOxmId(128800),
	}
	return obj
}
func (self *OxmIdCtIpv6DstMasked) GetOXMName() string {
	return "ct_ipv6_dst_masked"
}

func (self *OxmIdCtIpv6DstMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdCtIpv6Src struct {
	*OxmId
}

type IOxmIdCtIpv6Src interface {
	IOxmId
}

func (self *OxmIdCtIpv6Src) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdCtIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6Src, error) {
	_oxmidctipv6src := &OxmIdCtIpv6Src{OxmId: parent}
	return _oxmidctipv6src, nil
}

func NewOxmIdCtIpv6Src() *OxmIdCtIpv6Src {
	obj := &OxmIdCtIpv6Src{
		OxmId: NewOxmId(128016),
	}
	return obj
}
func (self *OxmIdCtIpv6Src) GetOXMName() string {
	return "ct_ipv6_src"
}

func (self *OxmIdCtIpv6Src) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdCtIpv6SrcMasked struct {
	*OxmId
}

type IOxmIdCtIpv6SrcMasked interface {
	IOxmId
}

func (self *OxmIdCtIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdCtIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6SrcMasked, error) {
	_oxmidctipv6srcmasked := &OxmIdCtIpv6SrcMasked{OxmId: parent}
	return _oxmidctipv6srcmasked, nil
}

func NewOxmIdCtIpv6SrcMasked() *OxmIdCtIpv6SrcMasked {
	obj := &OxmIdCtIpv6SrcMasked{
		OxmId: NewOxmId(128288),
	}
	return obj
}
func (self *OxmIdCtIpv6SrcMasked) GetOXMName() string {
	return "ct_ipv6_src_masked"
}

func (self *OxmIdCtIpv6SrcMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdCtLabel struct {
	*OxmId
}

type IOxmIdCtLabel interface {
	IOxmId
}

func (self *OxmIdCtLabel) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdCtLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtLabel, error) {
	_oxmidctlabel := &OxmIdCtLabel{OxmId: parent}
	return _oxmidctlabel, nil
}

func NewOxmIdCtLabel() *OxmIdCtLabel {
	obj := &OxmIdCtLabel{
		OxmId: NewOxmId(120848),
	}
	return obj
}
func (self *OxmIdCtLabel) GetOXMName() string {
	return "ct_label"
}

func (self *OxmIdCtLabel) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdCtLabelMasked struct {
	*OxmId
}

type IOxmIdCtLabelMasked interface {
	IOxmId
}

func (self *OxmIdCtLabelMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdCtLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtLabelMasked, error) {
	_oxmidctlabelmasked := &OxmIdCtLabelMasked{OxmId: parent}
	return _oxmidctlabelmasked, nil
}

func NewOxmIdCtLabelMasked() *OxmIdCtLabelMasked {
	obj := &OxmIdCtLabelMasked{
		OxmId: NewOxmId(121120),
	}
	return obj
}
func (self *OxmIdCtLabelMasked) GetOXMName() string {
	return "ct_label_masked"
}

func (self *OxmIdCtLabelMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdCtMark struct {
	*OxmId
}

type IOxmIdCtMark interface {
	IOxmId
}

func (self *OxmIdCtMark) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdCtMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtMark, error) {
	_oxmidctmark := &OxmIdCtMark{OxmId: parent}
	return _oxmidctmark, nil
}

func NewOxmIdCtMark() *OxmIdCtMark {
	obj := &OxmIdCtMark{
		OxmId: NewOxmId(120324),
	}
	return obj
}
func (self *OxmIdCtMark) GetOXMName() string {
	return "ct_mark"
}

func (self *OxmIdCtMark) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdCtMarkMasked struct {
	*OxmId
}

type IOxmIdCtMarkMasked interface {
	IOxmId
}

func (self *OxmIdCtMarkMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdCtMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtMarkMasked, error) {
	_oxmidctmarkmasked := &OxmIdCtMarkMasked{OxmId: parent}
	return _oxmidctmarkmasked, nil
}

func NewOxmIdCtMarkMasked() *OxmIdCtMarkMasked {
	obj := &OxmIdCtMarkMasked{
		OxmId: NewOxmId(120584),
	}
	return obj
}
func (self *OxmIdCtMarkMasked) GetOXMName() string {
	return "ct_mark_masked"
}

func (self *OxmIdCtMarkMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdCtNwDst struct {
	*OxmId
}

type IOxmIdCtNwDst interface {
	IOxmId
}

func (self *OxmIdCtNwDst) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdCtNwDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwDst, error) {
	_oxmidctnwdst := &OxmIdCtNwDst{OxmId: parent}
	return _oxmidctnwdst, nil
}

func NewOxmIdCtNwDst() *OxmIdCtNwDst {
	obj := &OxmIdCtNwDst{
		OxmId: NewOxmId(127492),
	}
	return obj
}
func (self *OxmIdCtNwDst) GetOXMName() string {
	return "ct_nw_dst"
}

func (self *OxmIdCtNwDst) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdCtNwDstMasked struct {
	*OxmId
}

type IOxmIdCtNwDstMasked interface {
	IOxmId
}

func (self *OxmIdCtNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdCtNwDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwDstMasked, error) {
	_oxmidctnwdstmasked := &OxmIdCtNwDstMasked{OxmId: parent}
	return _oxmidctnwdstmasked, nil
}

func NewOxmIdCtNwDstMasked() *OxmIdCtNwDstMasked {
	obj := &OxmIdCtNwDstMasked{
		OxmId: NewOxmId(127752),
	}
	return obj
}
func (self *OxmIdCtNwDstMasked) GetOXMName() string {
	return "ct_nw_dst_masked"
}

func (self *OxmIdCtNwDstMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdCtNwProto struct {
	*OxmId
}

type IOxmIdCtNwProto interface {
	IOxmId
}

func (self *OxmIdCtNwProto) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdCtNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwProto, error) {
	_oxmidctnwproto := &OxmIdCtNwProto{OxmId: parent}
	return _oxmidctnwproto, nil
}

func NewOxmIdCtNwProto() *OxmIdCtNwProto {
	obj := &OxmIdCtNwProto{
		OxmId: NewOxmId(126465),
	}
	return obj
}
func (self *OxmIdCtNwProto) GetOXMName() string {
	return "ct_nw_proto"
}

func (self *OxmIdCtNwProto) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdCtNwSrc struct {
	*OxmId
}

type IOxmIdCtNwSrc interface {
	IOxmId
}

func (self *OxmIdCtNwSrc) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdCtNwSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwSrc, error) {
	_oxmidctnwsrc := &OxmIdCtNwSrc{OxmId: parent}
	return _oxmidctnwsrc, nil
}

func NewOxmIdCtNwSrc() *OxmIdCtNwSrc {
	obj := &OxmIdCtNwSrc{
		OxmId: NewOxmId(126980),
	}
	return obj
}
func (self *OxmIdCtNwSrc) GetOXMName() string {
	return "ct_nw_src"
}

func (self *OxmIdCtNwSrc) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdCtNwSrcMasked struct {
	*OxmId
}

type IOxmIdCtNwSrcMasked interface {
	IOxmId
}

func (self *OxmIdCtNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdCtNwSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwSrcMasked, error) {
	_oxmidctnwsrcmasked := &OxmIdCtNwSrcMasked{OxmId: parent}
	return _oxmidctnwsrcmasked, nil
}

func NewOxmIdCtNwSrcMasked() *OxmIdCtNwSrcMasked {
	obj := &OxmIdCtNwSrcMasked{
		OxmId: NewOxmId(127240),
	}
	return obj
}
func (self *OxmIdCtNwSrcMasked) GetOXMName() string {
	return "ct_nw_src_masked"
}

func (self *OxmIdCtNwSrcMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdCtState struct {
	*OxmId
}

type IOxmIdCtState interface {
	IOxmId
}

func (self *OxmIdCtState) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdCtState(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtState, error) {
	_oxmidctstate := &OxmIdCtState{OxmId: parent}
	return _oxmidctstate, nil
}

func NewOxmIdCtState() *OxmIdCtState {
	obj := &OxmIdCtState{
		OxmId: NewOxmId(119300),
	}
	return obj
}
func (self *OxmIdCtState) GetOXMName() string {
	return "ct_state"
}

func (self *OxmIdCtState) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdCtStateMasked struct {
	*OxmId
}

type IOxmIdCtStateMasked interface {
	IOxmId
}

func (self *OxmIdCtStateMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdCtStateMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtStateMasked, error) {
	_oxmidctstatemasked := &OxmIdCtStateMasked{OxmId: parent}
	return _oxmidctstatemasked, nil
}

func NewOxmIdCtStateMasked() *OxmIdCtStateMasked {
	obj := &OxmIdCtStateMasked{
		OxmId: NewOxmId(119560),
	}
	return obj
}
func (self *OxmIdCtStateMasked) GetOXMName() string {
	return "ct_state_masked"
}

func (self *OxmIdCtStateMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdCtTpDst struct {
	*OxmId
}

type IOxmIdCtTpDst interface {
	IOxmId
}

func (self *OxmIdCtTpDst) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdCtTpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpDst, error) {
	_oxmidcttpdst := &OxmIdCtTpDst{OxmId: parent}
	return _oxmidcttpdst, nil
}

func NewOxmIdCtTpDst() *OxmIdCtTpDst {
	obj := &OxmIdCtTpDst{
		OxmId: NewOxmId(129538),
	}
	return obj
}
func (self *OxmIdCtTpDst) GetOXMName() string {
	return "ct_tp_dst"
}

func (self *OxmIdCtTpDst) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdCtTpDstMasked struct {
	*OxmId
}

type IOxmIdCtTpDstMasked interface {
	IOxmId
}

func (self *OxmIdCtTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdCtTpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpDstMasked, error) {
	_oxmidcttpdstmasked := &OxmIdCtTpDstMasked{OxmId: parent}
	return _oxmidcttpdstmasked, nil
}

func NewOxmIdCtTpDstMasked() *OxmIdCtTpDstMasked {
	obj := &OxmIdCtTpDstMasked{
		OxmId: NewOxmId(129796),
	}
	return obj
}
func (self *OxmIdCtTpDstMasked) GetOXMName() string {
	return "ct_tp_dst_masked"
}

func (self *OxmIdCtTpDstMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdCtTpSrc struct {
	*OxmId
}

type IOxmIdCtTpSrc interface {
	IOxmId
}

func (self *OxmIdCtTpSrc) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdCtTpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpSrc, error) {
	_oxmidcttpsrc := &OxmIdCtTpSrc{OxmId: parent}
	return _oxmidcttpsrc, nil
}

func NewOxmIdCtTpSrc() *OxmIdCtTpSrc {
	obj := &OxmIdCtTpSrc{
		OxmId: NewOxmId(129026),
	}
	return obj
}
func (self *OxmIdCtTpSrc) GetOXMName() string {
	return "ct_tp_src"
}

func (self *OxmIdCtTpSrc) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdCtTpSrcMasked struct {
	*OxmId
}

type IOxmIdCtTpSrcMasked interface {
	IOxmId
}

func (self *OxmIdCtTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdCtTpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpSrcMasked, error) {
	_oxmidcttpsrcmasked := &OxmIdCtTpSrcMasked{OxmId: parent}
	return _oxmidcttpsrcmasked, nil
}

func NewOxmIdCtTpSrcMasked() *OxmIdCtTpSrcMasked {
	obj := &OxmIdCtTpSrcMasked{
		OxmId: NewOxmId(129284),
	}
	return obj
}
func (self *OxmIdCtTpSrcMasked) GetOXMName() string {
	return "ct_tp_src_masked"
}

func (self *OxmIdCtTpSrcMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdCtZone struct {
	*OxmId
}

type IOxmIdCtZone interface {
	IOxmId
}

func (self *OxmIdCtZone) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdCtZone(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtZone, error) {
	_oxmidctzone := &OxmIdCtZone{OxmId: parent}
	return _oxmidctzone, nil
}

func NewOxmIdCtZone() *OxmIdCtZone {
	obj := &OxmIdCtZone{
		OxmId: NewOxmId(119810),
	}
	return obj
}
func (self *OxmIdCtZone) GetOXMName() string {
	return "ct_zone"
}

func (self *OxmIdCtZone) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdDpHash struct {
	*OxmId
}

type IOxmIdDpHash interface {
	IOxmId
}

func (self *OxmIdDpHash) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdDpHash(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdDpHash, error) {
	_oxmiddphash := &OxmIdDpHash{OxmId: parent}
	return _oxmiddphash, nil
}

func NewOxmIdDpHash() *OxmIdDpHash {
	obj := &OxmIdDpHash{
		OxmId: NewOxmId(83460),
	}
	return obj
}
func (self *OxmIdDpHash) GetOXMName() string {
	return "dp_hash"
}

func (self *OxmIdDpHash) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdDpHashMasked struct {
	*OxmId
}

type IOxmIdDpHashMasked interface {
	IOxmId
}

func (self *OxmIdDpHashMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdDpHashMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdDpHashMasked, error) {
	_oxmiddphashmasked := &OxmIdDpHashMasked{OxmId: parent}
	return _oxmiddphashmasked, nil
}

func NewOxmIdDpHashMasked() *OxmIdDpHashMasked {
	obj := &OxmIdDpHashMasked{
		OxmId: NewOxmId(83720),
	}
	return obj
}
func (self *OxmIdDpHashMasked) GetOXMName() string {
	return "dp_hash_masked"
}

func (self *OxmIdDpHashMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdEthDst struct {
	*OxmId
}

type IOxmIdEthDst interface {
	IOxmId
}

func (self *OxmIdEthDst) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdEthDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthDst, error) {
	_oxmidethdst := &OxmIdEthDst{OxmId: parent}
	return _oxmidethdst, nil
}

func NewOxmIdEthDst() *OxmIdEthDst {
	obj := &OxmIdEthDst{
		OxmId: NewOxmId(518),
	}
	return obj
}
func (self *OxmIdEthDst) GetOXMName() string {
	return "eth_dst"
}

func (self *OxmIdEthDst) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdEthDstMasked struct {
	*OxmId
}

type IOxmIdEthDstMasked interface {
	IOxmId
}

func (self *OxmIdEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdEthDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthDstMasked, error) {
	_oxmidethdstmasked := &OxmIdEthDstMasked{OxmId: parent}
	return _oxmidethdstmasked, nil
}

func NewOxmIdEthDstMasked() *OxmIdEthDstMasked {
	obj := &OxmIdEthDstMasked{
		OxmId: NewOxmId(779),
	}
	return obj
}
func (self *OxmIdEthDstMasked) GetOXMName() string {
	return "eth_dst_masked"
}

func (self *OxmIdEthDstMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdEthSrc struct {
	*OxmId
}

type IOxmIdEthSrc interface {
	IOxmId
}

func (self *OxmIdEthSrc) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdEthSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthSrc, error) {
	_oxmidethsrc := &OxmIdEthSrc{OxmId: parent}
	return _oxmidethsrc, nil
}

func NewOxmIdEthSrc() *OxmIdEthSrc {
	obj := &OxmIdEthSrc{
		OxmId: NewOxmId(1030),
	}
	return obj
}
func (self *OxmIdEthSrc) GetOXMName() string {
	return "eth_src"
}

func (self *OxmIdEthSrc) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdEthSrcMasked struct {
	*OxmId
}

type IOxmIdEthSrcMasked interface {
	IOxmId
}

func (self *OxmIdEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdEthSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthSrcMasked, error) {
	_oxmidethsrcmasked := &OxmIdEthSrcMasked{OxmId: parent}
	return _oxmidethsrcmasked, nil
}

func NewOxmIdEthSrcMasked() *OxmIdEthSrcMasked {
	obj := &OxmIdEthSrcMasked{
		OxmId: NewOxmId(1286),
	}
	return obj
}
func (self *OxmIdEthSrcMasked) GetOXMName() string {
	return "eth_src_masked"
}

func (self *OxmIdEthSrcMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdEthType struct {
	*OxmId
}

type IOxmIdEthType interface {
	IOxmId
}

func (self *OxmIdEthType) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdEthType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthType, error) {
	_oxmidethtype := &OxmIdEthType{OxmId: parent}
	return _oxmidethtype, nil
}

func NewOxmIdEthType() *OxmIdEthType {
	obj := &OxmIdEthType{
		OxmId: NewOxmId(1538),
	}
	return obj
}
func (self *OxmIdEthType) GetOXMName() string {
	return "eth_type"
}

func (self *OxmIdEthType) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIcmpCode struct {
	*OxmId
}

type IOxmIdIcmpCode interface {
	IOxmId
}

func (self *OxmIdIcmpCode) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIcmpCode(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpCode, error) {
	_oxmidicmpcode := &OxmIdIcmpCode{OxmId: parent}
	return _oxmidicmpcode, nil
}

func NewOxmIdIcmpCode() *OxmIdIcmpCode {
	obj := &OxmIdIcmpCode{
		OxmId: NewOxmId(7169),
	}
	return obj
}
func (self *OxmIdIcmpCode) GetOXMName() string {
	return "icmp_code"
}

func (self *OxmIdIcmpCode) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIcmpType struct {
	*OxmId
}

type IOxmIdIcmpType interface {
	IOxmId
}

func (self *OxmIdIcmpType) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIcmpType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpType, error) {
	_oxmidicmptype := &OxmIdIcmpType{OxmId: parent}
	return _oxmidicmptype, nil
}

func NewOxmIdIcmpType() *OxmIdIcmpType {
	obj := &OxmIdIcmpType{
		OxmId: NewOxmId(6657),
	}
	return obj
}
func (self *OxmIdIcmpType) GetOXMName() string {
	return "icmp_type"
}

func (self *OxmIdIcmpType) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIcmpv6Code struct {
	*OxmId
}

type IOxmIdIcmpv6Code interface {
	IOxmId
}

func (self *OxmIdIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIcmpv6Code(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6Code, error) {
	_oxmidicmpv6code := &OxmIdIcmpv6Code{OxmId: parent}
	return _oxmidicmpv6code, nil
}

func NewOxmIdIcmpv6Code() *OxmIdIcmpv6Code {
	obj := &OxmIdIcmpv6Code{
		OxmId: NewOxmId(76801),
	}
	return obj
}
func (self *OxmIdIcmpv6Code) GetOXMName() string {
	return "icmpv6_code"
}

func (self *OxmIdIcmpv6Code) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIcmpv6Type struct {
	*OxmId
}

type IOxmIdIcmpv6Type interface {
	IOxmId
}

func (self *OxmIdIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIcmpv6Type(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6Type, error) {
	_oxmidicmpv6type := &OxmIdIcmpv6Type{OxmId: parent}
	return _oxmidicmpv6type, nil
}

func NewOxmIdIcmpv6Type() *OxmIdIcmpv6Type {
	obj := &OxmIdIcmpv6Type{
		OxmId: NewOxmId(76289),
	}
	return obj
}
func (self *OxmIdIcmpv6Type) GetOXMName() string {
	return "icmpv6_type"
}

func (self *OxmIdIcmpv6Type) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdInPort struct {
	*OxmId
}

type IOxmIdInPort interface {
	IOxmId
}

func (self *OxmIdInPort) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdInPort(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPort, error) {
	_oxmidinport := &OxmIdInPort{OxmId: parent}
	return _oxmidinport, nil
}

func NewOxmIdInPort() *OxmIdInPort {
	obj := &OxmIdInPort{
		OxmId: NewOxmId(2),
	}
	return obj
}
func (self *OxmIdInPort) GetOXMName() string {
	return "in_port"
}

func (self *OxmIdInPort) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpDst struct {
	*OxmId
}

type IOxmIdIpDst interface {
	IOxmId
}

func (self *OxmIdIpDst) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDst, error) {
	_oxmidipdst := &OxmIdIpDst{OxmId: parent}
	return _oxmidipdst, nil
}

func NewOxmIdIpDst() *OxmIdIpDst {
	obj := &OxmIdIpDst{
		OxmId: NewOxmId(4100),
	}
	return obj
}
func (self *OxmIdIpDst) GetOXMName() string {
	return "ip_dst"
}

func (self *OxmIdIpDst) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpDstMasked struct {
	*OxmId
}

type IOxmIdIpDstMasked interface {
	IOxmId
}

func (self *OxmIdIpDstMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDstMasked, error) {
	_oxmidipdstmasked := &OxmIdIpDstMasked{OxmId: parent}
	return _oxmidipdstmasked, nil
}

func NewOxmIdIpDstMasked() *OxmIdIpDstMasked {
	obj := &OxmIdIpDstMasked{
		OxmId: NewOxmId(4360),
	}
	return obj
}
func (self *OxmIdIpDstMasked) GetOXMName() string {
	return "ip_dst_masked"
}

func (self *OxmIdIpDstMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpFrag struct {
	*OxmId
}

type IOxmIdIpFrag interface {
	IOxmId
}

func (self *OxmIdIpFrag) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpFrag(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpFrag, error) {
	_oxmidipfrag := &OxmIdIpFrag{OxmId: parent}
	return _oxmidipfrag, nil
}

func NewOxmIdIpFrag() *OxmIdIpFrag {
	obj := &OxmIdIpFrag{
		OxmId: NewOxmId(78849),
	}
	return obj
}
func (self *OxmIdIpFrag) GetOXMName() string {
	return "ip_frag"
}

func (self *OxmIdIpFrag) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpFragMasked struct {
	*OxmId
}

type IOxmIdIpFragMasked interface {
	IOxmId
}

func (self *OxmIdIpFragMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpFragMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpFragMasked, error) {
	_oxmidipfragmasked := &OxmIdIpFragMasked{OxmId: parent}
	return _oxmidipfragmasked, nil
}

func NewOxmIdIpFragMasked() *OxmIdIpFragMasked {
	obj := &OxmIdIpFragMasked{
		OxmId: NewOxmId(79106),
	}
	return obj
}
func (self *OxmIdIpFragMasked) GetOXMName() string {
	return "ip_frag_masked"
}

func (self *OxmIdIpFragMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpSrc struct {
	*OxmId
}

type IOxmIdIpSrc interface {
	IOxmId
}

func (self *OxmIdIpSrc) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpSrc, error) {
	_oxmidipsrc := &OxmIdIpSrc{OxmId: parent}
	return _oxmidipsrc, nil
}

func NewOxmIdIpSrc() *OxmIdIpSrc {
	obj := &OxmIdIpSrc{
		OxmId: NewOxmId(3588),
	}
	return obj
}
func (self *OxmIdIpSrc) GetOXMName() string {
	return "ip_src"
}

func (self *OxmIdIpSrc) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpSrcMasked struct {
	*OxmId
}

type IOxmIdIpSrcMasked interface {
	IOxmId
}

func (self *OxmIdIpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpSrcMasked, error) {
	_oxmidipsrcmasked := &OxmIdIpSrcMasked{OxmId: parent}
	return _oxmidipsrcmasked, nil
}

func NewOxmIdIpSrcMasked() *OxmIdIpSrcMasked {
	obj := &OxmIdIpSrcMasked{
		OxmId: NewOxmId(3848),
	}
	return obj
}
func (self *OxmIdIpSrcMasked) GetOXMName() string {
	return "ip_src_masked"
}

func (self *OxmIdIpSrcMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpv6Dst struct {
	*OxmId
}

type IOxmIdIpv6Dst interface {
	IOxmId
}

func (self *OxmIdIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Dst, error) {
	_oxmidipv6dst := &OxmIdIpv6Dst{OxmId: parent}
	return _oxmidipv6dst, nil
}

func NewOxmIdIpv6Dst() *OxmIdIpv6Dst {
	obj := &OxmIdIpv6Dst{
		OxmId: NewOxmId(75792),
	}
	return obj
}
func (self *OxmIdIpv6Dst) GetOXMName() string {
	return "ipv6_dst"
}

func (self *OxmIdIpv6Dst) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpv6DstMasked struct {
	*OxmId
}

type IOxmIdIpv6DstMasked interface {
	IOxmId
}

func (self *OxmIdIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6DstMasked, error) {
	_oxmidipv6dstmasked := &OxmIdIpv6DstMasked{OxmId: parent}
	return _oxmidipv6dstmasked, nil
}

func NewOxmIdIpv6DstMasked() *OxmIdIpv6DstMasked {
	obj := &OxmIdIpv6DstMasked{
		OxmId: NewOxmId(76064),
	}
	return obj
}
func (self *OxmIdIpv6DstMasked) GetOXMName() string {
	return "ipv6_dst_masked"
}

func (self *OxmIdIpv6DstMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpv6Label struct {
	*OxmId
}

type IOxmIdIpv6Label interface {
	IOxmId
}

func (self *OxmIdIpv6Label) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpv6Label(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Label, error) {
	_oxmidipv6label := &OxmIdIpv6Label{OxmId: parent}
	return _oxmidipv6label, nil
}

func NewOxmIdIpv6Label() *OxmIdIpv6Label {
	obj := &OxmIdIpv6Label{
		OxmId: NewOxmId(79364),
	}
	return obj
}
func (self *OxmIdIpv6Label) GetOXMName() string {
	return "ipv6_label"
}

func (self *OxmIdIpv6Label) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpv6LabelMasked struct {
	*OxmId
}

type IOxmIdIpv6LabelMasked interface {
	IOxmId
}

func (self *OxmIdIpv6LabelMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpv6LabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6LabelMasked, error) {
	_oxmidipv6labelmasked := &OxmIdIpv6LabelMasked{OxmId: parent}
	return _oxmidipv6labelmasked, nil
}

func NewOxmIdIpv6LabelMasked() *OxmIdIpv6LabelMasked {
	obj := &OxmIdIpv6LabelMasked{
		OxmId: NewOxmId(79624),
	}
	return obj
}
func (self *OxmIdIpv6LabelMasked) GetOXMName() string {
	return "ipv6_label_masked"
}

func (self *OxmIdIpv6LabelMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpv6Src struct {
	*OxmId
}

type IOxmIdIpv6Src interface {
	IOxmId
}

func (self *OxmIdIpv6Src) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Src, error) {
	_oxmidipv6src := &OxmIdIpv6Src{OxmId: parent}
	return _oxmidipv6src, nil
}

func NewOxmIdIpv6Src() *OxmIdIpv6Src {
	obj := &OxmIdIpv6Src{
		OxmId: NewOxmId(75280),
	}
	return obj
}
func (self *OxmIdIpv6Src) GetOXMName() string {
	return "ipv6_src"
}

func (self *OxmIdIpv6Src) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpv6SrcMasked struct {
	*OxmId
}

type IOxmIdIpv6SrcMasked interface {
	IOxmId
}

func (self *OxmIdIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6SrcMasked, error) {
	_oxmidipv6srcmasked := &OxmIdIpv6SrcMasked{OxmId: parent}
	return _oxmidipv6srcmasked, nil
}

func NewOxmIdIpv6SrcMasked() *OxmIdIpv6SrcMasked {
	obj := &OxmIdIpv6SrcMasked{
		OxmId: NewOxmId(75552),
	}
	return obj
}
func (self *OxmIdIpv6SrcMasked) GetOXMName() string {
	return "ipv6_src_masked"
}

func (self *OxmIdIpv6SrcMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdMplsTtl struct {
	*OxmId
}

type IOxmIdMplsTtl interface {
	IOxmId
}

func (self *OxmIdMplsTtl) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdMplsTtl(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTtl, error) {
	_oxmidmplsttl := &OxmIdMplsTtl{OxmId: parent}
	return _oxmidmplsttl, nil
}

func NewOxmIdMplsTtl() *OxmIdMplsTtl {
	obj := &OxmIdMplsTtl{
		OxmId: NewOxmId(80897),
	}
	return obj
}
func (self *OxmIdMplsTtl) GetOXMName() string {
	return "mpls_ttl"
}

func (self *OxmIdMplsTtl) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdNdSll struct {
	*OxmId
}

type IOxmIdNdSll interface {
	IOxmId
}

func (self *OxmIdNdSll) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdNdSll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdSll, error) {
	_oxmidndsll := &OxmIdNdSll{OxmId: parent}
	return _oxmidndsll, nil
}

func NewOxmIdNdSll() *OxmIdNdSll {
	obj := &OxmIdNdSll{
		OxmId: NewOxmId(77830),
	}
	return obj
}
func (self *OxmIdNdSll) GetOXMName() string {
	return "nd_sll"
}

func (self *OxmIdNdSll) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdNdSllMasked struct {
	*OxmId
}

type IOxmIdNdSllMasked interface {
	IOxmId
}

func (self *OxmIdNdSllMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdNdSllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdSllMasked, error) {
	_oxmidndsllmasked := &OxmIdNdSllMasked{OxmId: parent}
	return _oxmidndsllmasked, nil
}

func NewOxmIdNdSllMasked() *OxmIdNdSllMasked {
	obj := &OxmIdNdSllMasked{
		OxmId: NewOxmId(78091),
	}
	return obj
}
func (self *OxmIdNdSllMasked) GetOXMName() string {
	return "nd_sll_masked"
}

func (self *OxmIdNdSllMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdNdTarget struct {
	*OxmId
}

type IOxmIdNdTarget interface {
	IOxmId
}

func (self *OxmIdNdTarget) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdNdTarget(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTarget, error) {
	_oxmidndtarget := &OxmIdNdTarget{OxmId: parent}
	return _oxmidndtarget, nil
}

func NewOxmIdNdTarget() *OxmIdNdTarget {
	obj := &OxmIdNdTarget{
		OxmId: NewOxmId(77328),
	}
	return obj
}
func (self *OxmIdNdTarget) GetOXMName() string {
	return "nd_target"
}

func (self *OxmIdNdTarget) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdNdTargetMasked struct {
	*OxmId
}

type IOxmIdNdTargetMasked interface {
	IOxmId
}

func (self *OxmIdNdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdNdTargetMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTargetMasked, error) {
	_oxmidndtargetmasked := &OxmIdNdTargetMasked{OxmId: parent}
	return _oxmidndtargetmasked, nil
}

func NewOxmIdNdTargetMasked() *OxmIdNdTargetMasked {
	obj := &OxmIdNdTargetMasked{
		OxmId: NewOxmId(77600),
	}
	return obj
}
func (self *OxmIdNdTargetMasked) GetOXMName() string {
	return "nd_target_masked"
}

func (self *OxmIdNdTargetMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdNdTll struct {
	*OxmId
}

type IOxmIdNdTll interface {
	IOxmId
}

func (self *OxmIdNdTll) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdNdTll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTll, error) {
	_oxmidndtll := &OxmIdNdTll{OxmId: parent}
	return _oxmidndtll, nil
}

func NewOxmIdNdTll() *OxmIdNdTll {
	obj := &OxmIdNdTll{
		OxmId: NewOxmId(78342),
	}
	return obj
}
func (self *OxmIdNdTll) GetOXMName() string {
	return "nd_tll"
}

func (self *OxmIdNdTll) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdNdTllMasked struct {
	*OxmId
}

type IOxmIdNdTllMasked interface {
	IOxmId
}

func (self *OxmIdNdTllMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdNdTllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTllMasked, error) {
	_oxmidndtllmasked := &OxmIdNdTllMasked{OxmId: parent}
	return _oxmidndtllmasked, nil
}

func NewOxmIdNdTllMasked() *OxmIdNdTllMasked {
	obj := &OxmIdNdTllMasked{
		OxmId: NewOxmId(78603),
	}
	return obj
}
func (self *OxmIdNdTllMasked) GetOXMName() string {
	return "nd_tll_masked"
}

func (self *OxmIdNdTllMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdNwEcn struct {
	*OxmId
}

type IOxmIdNwEcn interface {
	IOxmId
}

func (self *OxmIdNwEcn) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdNwEcn(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwEcn, error) {
	_oxmidnwecn := &OxmIdNwEcn{OxmId: parent}
	return _oxmidnwecn, nil
}

func NewOxmIdNwEcn() *OxmIdNwEcn {
	obj := &OxmIdNwEcn{
		OxmId: NewOxmId(79873),
	}
	return obj
}
func (self *OxmIdNwEcn) GetOXMName() string {
	return "nw_ecn"
}

func (self *OxmIdNwEcn) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdNwProto struct {
	*OxmId
}

type IOxmIdNwProto interface {
	IOxmId
}

func (self *OxmIdNwProto) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwProto, error) {
	_oxmidnwproto := &OxmIdNwProto{OxmId: parent}
	return _oxmidnwproto, nil
}

func NewOxmIdNwProto() *OxmIdNwProto {
	obj := &OxmIdNwProto{
		OxmId: NewOxmId(3073),
	}
	return obj
}
func (self *OxmIdNwProto) GetOXMName() string {
	return "nw_proto"
}

func (self *OxmIdNwProto) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdNwTos struct {
	*OxmId
}

type IOxmIdNwTos interface {
	IOxmId
}

func (self *OxmIdNwTos) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdNwTos(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwTos, error) {
	_oxmidnwtos := &OxmIdNwTos{OxmId: parent}
	return _oxmidnwtos, nil
}

func NewOxmIdNwTos() *OxmIdNwTos {
	obj := &OxmIdNwTos{
		OxmId: NewOxmId(2561),
	}
	return obj
}
func (self *OxmIdNwTos) GetOXMName() string {
	return "nw_tos"
}

func (self *OxmIdNwTos) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdNwTtl struct {
	*OxmId
}

type IOxmIdNwTtl interface {
	IOxmId
}

func (self *OxmIdNwTtl) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdNwTtl(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwTtl, error) {
	_oxmidnwttl := &OxmIdNwTtl{OxmId: parent}
	return _oxmidnwttl, nil
}

func NewOxmIdNwTtl() *OxmIdNwTtl {
	obj := &OxmIdNwTtl{
		OxmId: NewOxmId(80385),
	}
	return obj
}
func (self *OxmIdNwTtl) GetOXMName() string {
	return "nw_ttl"
}

func (self *OxmIdNwTtl) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdPktMark struct {
	*OxmId
}

type IOxmIdPktMark interface {
	IOxmId
}

func (self *OxmIdPktMark) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdPktMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPktMark, error) {
	_oxmidpktmark := &OxmIdPktMark{OxmId: parent}
	return _oxmidpktmark, nil
}

func NewOxmIdPktMark() *OxmIdPktMark {
	obj := &OxmIdPktMark{
		OxmId: NewOxmId(82436),
	}
	return obj
}
func (self *OxmIdPktMark) GetOXMName() string {
	return "pkt_mark"
}

func (self *OxmIdPktMark) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdPktMarkMasked struct {
	*OxmId
}

type IOxmIdPktMarkMasked interface {
	IOxmId
}

func (self *OxmIdPktMarkMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdPktMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPktMarkMasked, error) {
	_oxmidpktmarkmasked := &OxmIdPktMarkMasked{OxmId: parent}
	return _oxmidpktmarkmasked, nil
}

func NewOxmIdPktMarkMasked() *OxmIdPktMarkMasked {
	obj := &OxmIdPktMarkMasked{
		OxmId: NewOxmId(82696),
	}
	return obj
}
func (self *OxmIdPktMarkMasked) GetOXMName() string {
	return "pkt_mark_masked"
}

func (self *OxmIdPktMarkMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdRecircId struct {
	*OxmId
}

type IOxmIdRecircId interface {
	IOxmId
}

func (self *OxmIdRecircId) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdRecircId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdRecircId, error) {
	_oxmidrecircid := &OxmIdRecircId{OxmId: parent}
	return _oxmidrecircid, nil
}

func NewOxmIdRecircId() *OxmIdRecircId {
	obj := &OxmIdRecircId{
		OxmId: NewOxmId(83972),
	}
	return obj
}
func (self *OxmIdRecircId) GetOXMName() string {
	return "recirc_id"
}

func (self *OxmIdRecircId) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg0 struct {
	*OxmId
}

type IOxmIdReg0 interface {
	IOxmId
}

func (self *OxmIdReg0) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg0, error) {
	_oxmidreg0 := &OxmIdReg0{OxmId: parent}
	return _oxmidreg0, nil
}

func NewOxmIdReg0() *OxmIdReg0 {
	obj := &OxmIdReg0{
		OxmId: NewOxmId(65540),
	}
	return obj
}
func (self *OxmIdReg0) GetOXMName() string {
	return "reg0"
}

func (self *OxmIdReg0) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg0Masked struct {
	*OxmId
}

type IOxmIdReg0Masked interface {
	IOxmId
}

func (self *OxmIdReg0Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg0Masked, error) {
	_oxmidreg0masked := &OxmIdReg0Masked{OxmId: parent}
	return _oxmidreg0masked, nil
}

func NewOxmIdReg0Masked() *OxmIdReg0Masked {
	obj := &OxmIdReg0Masked{
		OxmId: NewOxmId(65800),
	}
	return obj
}
func (self *OxmIdReg0Masked) GetOXMName() string {
	return "reg0_masked"
}

func (self *OxmIdReg0Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg1 struct {
	*OxmId
}

type IOxmIdReg1 interface {
	IOxmId
}

func (self *OxmIdReg1) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg1, error) {
	_oxmidreg1 := &OxmIdReg1{OxmId: parent}
	return _oxmidreg1, nil
}

func NewOxmIdReg1() *OxmIdReg1 {
	obj := &OxmIdReg1{
		OxmId: NewOxmId(66052),
	}
	return obj
}
func (self *OxmIdReg1) GetOXMName() string {
	return "reg1"
}

func (self *OxmIdReg1) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg10 struct {
	*OxmId
}

type IOxmIdReg10 interface {
	IOxmId
}

func (self *OxmIdReg10) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg10(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg10, error) {
	_oxmidreg10 := &OxmIdReg10{OxmId: parent}
	return _oxmidreg10, nil
}

func NewOxmIdReg10() *OxmIdReg10 {
	obj := &OxmIdReg10{
		OxmId: NewOxmId(70660),
	}
	return obj
}
func (self *OxmIdReg10) GetOXMName() string {
	return "reg10"
}

func (self *OxmIdReg10) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg10Masked struct {
	*OxmId
}

type IOxmIdReg10Masked interface {
	IOxmId
}

func (self *OxmIdReg10Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg10Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg10Masked, error) {
	_oxmidreg10masked := &OxmIdReg10Masked{OxmId: parent}
	return _oxmidreg10masked, nil
}

func NewOxmIdReg10Masked() *OxmIdReg10Masked {
	obj := &OxmIdReg10Masked{
		OxmId: NewOxmId(70920),
	}
	return obj
}
func (self *OxmIdReg10Masked) GetOXMName() string {
	return "reg10_masked"
}

func (self *OxmIdReg10Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg11 struct {
	*OxmId
}

type IOxmIdReg11 interface {
	IOxmId
}

func (self *OxmIdReg11) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg11(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg11, error) {
	_oxmidreg11 := &OxmIdReg11{OxmId: parent}
	return _oxmidreg11, nil
}

func NewOxmIdReg11() *OxmIdReg11 {
	obj := &OxmIdReg11{
		OxmId: NewOxmId(71172),
	}
	return obj
}
func (self *OxmIdReg11) GetOXMName() string {
	return "reg11"
}

func (self *OxmIdReg11) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg11Masked struct {
	*OxmId
}

type IOxmIdReg11Masked interface {
	IOxmId
}

func (self *OxmIdReg11Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg11Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg11Masked, error) {
	_oxmidreg11masked := &OxmIdReg11Masked{OxmId: parent}
	return _oxmidreg11masked, nil
}

func NewOxmIdReg11Masked() *OxmIdReg11Masked {
	obj := &OxmIdReg11Masked{
		OxmId: NewOxmId(71432),
	}
	return obj
}
func (self *OxmIdReg11Masked) GetOXMName() string {
	return "reg11_masked"
}

func (self *OxmIdReg11Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg12 struct {
	*OxmId
}

type IOxmIdReg12 interface {
	IOxmId
}

func (self *OxmIdReg12) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg12(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg12, error) {
	_oxmidreg12 := &OxmIdReg12{OxmId: parent}
	return _oxmidreg12, nil
}

func NewOxmIdReg12() *OxmIdReg12 {
	obj := &OxmIdReg12{
		OxmId: NewOxmId(71684),
	}
	return obj
}
func (self *OxmIdReg12) GetOXMName() string {
	return "reg12"
}

func (self *OxmIdReg12) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg12Masked struct {
	*OxmId
}

type IOxmIdReg12Masked interface {
	IOxmId
}

func (self *OxmIdReg12Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg12Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg12Masked, error) {
	_oxmidreg12masked := &OxmIdReg12Masked{OxmId: parent}
	return _oxmidreg12masked, nil
}

func NewOxmIdReg12Masked() *OxmIdReg12Masked {
	obj := &OxmIdReg12Masked{
		OxmId: NewOxmId(71944),
	}
	return obj
}
func (self *OxmIdReg12Masked) GetOXMName() string {
	return "reg12_masked"
}

func (self *OxmIdReg12Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg13 struct {
	*OxmId
}

type IOxmIdReg13 interface {
	IOxmId
}

func (self *OxmIdReg13) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg13(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg13, error) {
	_oxmidreg13 := &OxmIdReg13{OxmId: parent}
	return _oxmidreg13, nil
}

func NewOxmIdReg13() *OxmIdReg13 {
	obj := &OxmIdReg13{
		OxmId: NewOxmId(72196),
	}
	return obj
}
func (self *OxmIdReg13) GetOXMName() string {
	return "reg13"
}

func (self *OxmIdReg13) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg13Masked struct {
	*OxmId
}

type IOxmIdReg13Masked interface {
	IOxmId
}

func (self *OxmIdReg13Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg13Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg13Masked, error) {
	_oxmidreg13masked := &OxmIdReg13Masked{OxmId: parent}
	return _oxmidreg13masked, nil
}

func NewOxmIdReg13Masked() *OxmIdReg13Masked {
	obj := &OxmIdReg13Masked{
		OxmId: NewOxmId(72456),
	}
	return obj
}
func (self *OxmIdReg13Masked) GetOXMName() string {
	return "reg13_masked"
}

func (self *OxmIdReg13Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg14 struct {
	*OxmId
}

type IOxmIdReg14 interface {
	IOxmId
}

func (self *OxmIdReg14) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg14(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg14, error) {
	_oxmidreg14 := &OxmIdReg14{OxmId: parent}
	return _oxmidreg14, nil
}

func NewOxmIdReg14() *OxmIdReg14 {
	obj := &OxmIdReg14{
		OxmId: NewOxmId(72708),
	}
	return obj
}
func (self *OxmIdReg14) GetOXMName() string {
	return "reg14"
}

func (self *OxmIdReg14) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg14Masked struct {
	*OxmId
}

type IOxmIdReg14Masked interface {
	IOxmId
}

func (self *OxmIdReg14Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg14Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg14Masked, error) {
	_oxmidreg14masked := &OxmIdReg14Masked{OxmId: parent}
	return _oxmidreg14masked, nil
}

func NewOxmIdReg14Masked() *OxmIdReg14Masked {
	obj := &OxmIdReg14Masked{
		OxmId: NewOxmId(72968),
	}
	return obj
}
func (self *OxmIdReg14Masked) GetOXMName() string {
	return "reg14_masked"
}

func (self *OxmIdReg14Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg15 struct {
	*OxmId
}

type IOxmIdReg15 interface {
	IOxmId
}

func (self *OxmIdReg15) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg15(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg15, error) {
	_oxmidreg15 := &OxmIdReg15{OxmId: parent}
	return _oxmidreg15, nil
}

func NewOxmIdReg15() *OxmIdReg15 {
	obj := &OxmIdReg15{
		OxmId: NewOxmId(73220),
	}
	return obj
}
func (self *OxmIdReg15) GetOXMName() string {
	return "reg15"
}

func (self *OxmIdReg15) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg15Masked struct {
	*OxmId
}

type IOxmIdReg15Masked interface {
	IOxmId
}

func (self *OxmIdReg15Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg15Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg15Masked, error) {
	_oxmidreg15masked := &OxmIdReg15Masked{OxmId: parent}
	return _oxmidreg15masked, nil
}

func NewOxmIdReg15Masked() *OxmIdReg15Masked {
	obj := &OxmIdReg15Masked{
		OxmId: NewOxmId(73480),
	}
	return obj
}
func (self *OxmIdReg15Masked) GetOXMName() string {
	return "reg15_masked"
}

func (self *OxmIdReg15Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg1Masked struct {
	*OxmId
}

type IOxmIdReg1Masked interface {
	IOxmId
}

func (self *OxmIdReg1Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg1Masked, error) {
	_oxmidreg1masked := &OxmIdReg1Masked{OxmId: parent}
	return _oxmidreg1masked, nil
}

func NewOxmIdReg1Masked() *OxmIdReg1Masked {
	obj := &OxmIdReg1Masked{
		OxmId: NewOxmId(66312),
	}
	return obj
}
func (self *OxmIdReg1Masked) GetOXMName() string {
	return "reg1_masked"
}

func (self *OxmIdReg1Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg2 struct {
	*OxmId
}

type IOxmIdReg2 interface {
	IOxmId
}

func (self *OxmIdReg2) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg2, error) {
	_oxmidreg2 := &OxmIdReg2{OxmId: parent}
	return _oxmidreg2, nil
}

func NewOxmIdReg2() *OxmIdReg2 {
	obj := &OxmIdReg2{
		OxmId: NewOxmId(66564),
	}
	return obj
}
func (self *OxmIdReg2) GetOXMName() string {
	return "reg2"
}

func (self *OxmIdReg2) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg2Masked struct {
	*OxmId
}

type IOxmIdReg2Masked interface {
	IOxmId
}

func (self *OxmIdReg2Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg2Masked, error) {
	_oxmidreg2masked := &OxmIdReg2Masked{OxmId: parent}
	return _oxmidreg2masked, nil
}

func NewOxmIdReg2Masked() *OxmIdReg2Masked {
	obj := &OxmIdReg2Masked{
		OxmId: NewOxmId(66824),
	}
	return obj
}
func (self *OxmIdReg2Masked) GetOXMName() string {
	return "reg2_masked"
}

func (self *OxmIdReg2Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg3 struct {
	*OxmId
}

type IOxmIdReg3 interface {
	IOxmId
}

func (self *OxmIdReg3) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg3, error) {
	_oxmidreg3 := &OxmIdReg3{OxmId: parent}
	return _oxmidreg3, nil
}

func NewOxmIdReg3() *OxmIdReg3 {
	obj := &OxmIdReg3{
		OxmId: NewOxmId(67076),
	}
	return obj
}
func (self *OxmIdReg3) GetOXMName() string {
	return "reg3"
}

func (self *OxmIdReg3) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg3Masked struct {
	*OxmId
}

type IOxmIdReg3Masked interface {
	IOxmId
}

func (self *OxmIdReg3Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg3Masked, error) {
	_oxmidreg3masked := &OxmIdReg3Masked{OxmId: parent}
	return _oxmidreg3masked, nil
}

func NewOxmIdReg3Masked() *OxmIdReg3Masked {
	obj := &OxmIdReg3Masked{
		OxmId: NewOxmId(67336),
	}
	return obj
}
func (self *OxmIdReg3Masked) GetOXMName() string {
	return "reg3_masked"
}

func (self *OxmIdReg3Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg4 struct {
	*OxmId
}

type IOxmIdReg4 interface {
	IOxmId
}

func (self *OxmIdReg4) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg4, error) {
	_oxmidreg4 := &OxmIdReg4{OxmId: parent}
	return _oxmidreg4, nil
}

func NewOxmIdReg4() *OxmIdReg4 {
	obj := &OxmIdReg4{
		OxmId: NewOxmId(67588),
	}
	return obj
}
func (self *OxmIdReg4) GetOXMName() string {
	return "reg4"
}

func (self *OxmIdReg4) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg4Masked struct {
	*OxmId
}

type IOxmIdReg4Masked interface {
	IOxmId
}

func (self *OxmIdReg4Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg4Masked, error) {
	_oxmidreg4masked := &OxmIdReg4Masked{OxmId: parent}
	return _oxmidreg4masked, nil
}

func NewOxmIdReg4Masked() *OxmIdReg4Masked {
	obj := &OxmIdReg4Masked{
		OxmId: NewOxmId(67848),
	}
	return obj
}
func (self *OxmIdReg4Masked) GetOXMName() string {
	return "reg4_masked"
}

func (self *OxmIdReg4Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg5 struct {
	*OxmId
}

type IOxmIdReg5 interface {
	IOxmId
}

func (self *OxmIdReg5) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg5, error) {
	_oxmidreg5 := &OxmIdReg5{OxmId: parent}
	return _oxmidreg5, nil
}

func NewOxmIdReg5() *OxmIdReg5 {
	obj := &OxmIdReg5{
		OxmId: NewOxmId(68100),
	}
	return obj
}
func (self *OxmIdReg5) GetOXMName() string {
	return "reg5"
}

func (self *OxmIdReg5) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg5Masked struct {
	*OxmId
}

type IOxmIdReg5Masked interface {
	IOxmId
}

func (self *OxmIdReg5Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg5Masked, error) {
	_oxmidreg5masked := &OxmIdReg5Masked{OxmId: parent}
	return _oxmidreg5masked, nil
}

func NewOxmIdReg5Masked() *OxmIdReg5Masked {
	obj := &OxmIdReg5Masked{
		OxmId: NewOxmId(68360),
	}
	return obj
}
func (self *OxmIdReg5Masked) GetOXMName() string {
	return "reg5_masked"
}

func (self *OxmIdReg5Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg6 struct {
	*OxmId
}

type IOxmIdReg6 interface {
	IOxmId
}

func (self *OxmIdReg6) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg6, error) {
	_oxmidreg6 := &OxmIdReg6{OxmId: parent}
	return _oxmidreg6, nil
}

func NewOxmIdReg6() *OxmIdReg6 {
	obj := &OxmIdReg6{
		OxmId: NewOxmId(68612),
	}
	return obj
}
func (self *OxmIdReg6) GetOXMName() string {
	return "reg6"
}

func (self *OxmIdReg6) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg6Masked struct {
	*OxmId
}

type IOxmIdReg6Masked interface {
	IOxmId
}

func (self *OxmIdReg6Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg6Masked, error) {
	_oxmidreg6masked := &OxmIdReg6Masked{OxmId: parent}
	return _oxmidreg6masked, nil
}

func NewOxmIdReg6Masked() *OxmIdReg6Masked {
	obj := &OxmIdReg6Masked{
		OxmId: NewOxmId(68872),
	}
	return obj
}
func (self *OxmIdReg6Masked) GetOXMName() string {
	return "reg6_masked"
}

func (self *OxmIdReg6Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg7 struct {
	*OxmId
}

type IOxmIdReg7 interface {
	IOxmId
}

func (self *OxmIdReg7) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg7, error) {
	_oxmidreg7 := &OxmIdReg7{OxmId: parent}
	return _oxmidreg7, nil
}

func NewOxmIdReg7() *OxmIdReg7 {
	obj := &OxmIdReg7{
		OxmId: NewOxmId(69124),
	}
	return obj
}
func (self *OxmIdReg7) GetOXMName() string {
	return "reg7"
}

func (self *OxmIdReg7) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg7Masked struct {
	*OxmId
}

type IOxmIdReg7Masked interface {
	IOxmId
}

func (self *OxmIdReg7Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg7Masked, error) {
	_oxmidreg7masked := &OxmIdReg7Masked{OxmId: parent}
	return _oxmidreg7masked, nil
}

func NewOxmIdReg7Masked() *OxmIdReg7Masked {
	obj := &OxmIdReg7Masked{
		OxmId: NewOxmId(69384),
	}
	return obj
}
func (self *OxmIdReg7Masked) GetOXMName() string {
	return "reg7_masked"
}

func (self *OxmIdReg7Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg8 struct {
	*OxmId
}

type IOxmIdReg8 interface {
	IOxmId
}

func (self *OxmIdReg8) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg8(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg8, error) {
	_oxmidreg8 := &OxmIdReg8{OxmId: parent}
	return _oxmidreg8, nil
}

func NewOxmIdReg8() *OxmIdReg8 {
	obj := &OxmIdReg8{
		OxmId: NewOxmId(69636),
	}
	return obj
}
func (self *OxmIdReg8) GetOXMName() string {
	return "reg8"
}

func (self *OxmIdReg8) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg8Masked struct {
	*OxmId
}

type IOxmIdReg8Masked interface {
	IOxmId
}

func (self *OxmIdReg8Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg8Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg8Masked, error) {
	_oxmidreg8masked := &OxmIdReg8Masked{OxmId: parent}
	return _oxmidreg8masked, nil
}

func NewOxmIdReg8Masked() *OxmIdReg8Masked {
	obj := &OxmIdReg8Masked{
		OxmId: NewOxmId(69896),
	}
	return obj
}
func (self *OxmIdReg8Masked) GetOXMName() string {
	return "reg8_masked"
}

func (self *OxmIdReg8Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg9 struct {
	*OxmId
}

type IOxmIdReg9 interface {
	IOxmId
}

func (self *OxmIdReg9) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg9(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg9, error) {
	_oxmidreg9 := &OxmIdReg9{OxmId: parent}
	return _oxmidreg9, nil
}

func NewOxmIdReg9() *OxmIdReg9 {
	obj := &OxmIdReg9{
		OxmId: NewOxmId(70148),
	}
	return obj
}
func (self *OxmIdReg9) GetOXMName() string {
	return "reg9"
}

func (self *OxmIdReg9) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdReg9Masked struct {
	*OxmId
}

type IOxmIdReg9Masked interface {
	IOxmId
}

func (self *OxmIdReg9Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdReg9Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg9Masked, error) {
	_oxmidreg9masked := &OxmIdReg9Masked{OxmId: parent}
	return _oxmidreg9masked, nil
}

func NewOxmIdReg9Masked() *OxmIdReg9Masked {
	obj := &OxmIdReg9Masked{
		OxmId: NewOxmId(70408),
	}
	return obj
}
func (self *OxmIdReg9Masked) GetOXMName() string {
	return "reg9_masked"
}

func (self *OxmIdReg9Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTcpDst struct {
	*OxmId
}

type IOxmIdTcpDst interface {
	IOxmId
}

func (self *OxmIdTcpDst) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTcpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpDst, error) {
	_oxmidtcpdst := &OxmIdTcpDst{OxmId: parent}
	return _oxmidtcpdst, nil
}

func NewOxmIdTcpDst() *OxmIdTcpDst {
	obj := &OxmIdTcpDst{
		OxmId: NewOxmId(5122),
	}
	return obj
}
func (self *OxmIdTcpDst) GetOXMName() string {
	return "tcp_dst"
}

func (self *OxmIdTcpDst) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTcpDstMasked struct {
	*OxmId
}

type IOxmIdTcpDstMasked interface {
	IOxmId
}

func (self *OxmIdTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTcpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpDstMasked, error) {
	_oxmidtcpdstmasked := &OxmIdTcpDstMasked{OxmId: parent}
	return _oxmidtcpdstmasked, nil
}

func NewOxmIdTcpDstMasked() *OxmIdTcpDstMasked {
	obj := &OxmIdTcpDstMasked{
		OxmId: NewOxmId(5378),
	}
	return obj
}
func (self *OxmIdTcpDstMasked) GetOXMName() string {
	return "tcp_dst_masked"
}

func (self *OxmIdTcpDstMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTcpFlags struct {
	*OxmId
}

type IOxmIdTcpFlags interface {
	IOxmId
}

func (self *OxmIdTcpFlags) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpFlags, error) {
	_oxmidtcpflags := &OxmIdTcpFlags{OxmId: parent}
	return _oxmidtcpflags, nil
}

func NewOxmIdTcpFlags() *OxmIdTcpFlags {
	obj := &OxmIdTcpFlags{
		OxmId: NewOxmId(82946),
	}
	return obj
}
func (self *OxmIdTcpFlags) GetOXMName() string {
	return "tcp_flags"
}

func (self *OxmIdTcpFlags) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTcpFlagsMasked struct {
	*OxmId
}

type IOxmIdTcpFlagsMasked interface {
	IOxmId
}

func (self *OxmIdTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpFlagsMasked, error) {
	_oxmidtcpflagsmasked := &OxmIdTcpFlagsMasked{OxmId: parent}
	return _oxmidtcpflagsmasked, nil
}

func NewOxmIdTcpFlagsMasked() *OxmIdTcpFlagsMasked {
	obj := &OxmIdTcpFlagsMasked{
		OxmId: NewOxmId(83204),
	}
	return obj
}
func (self *OxmIdTcpFlagsMasked) GetOXMName() string {
	return "tcp_flags_masked"
}

func (self *OxmIdTcpFlagsMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTcpSrc struct {
	*OxmId
}

type IOxmIdTcpSrc interface {
	IOxmId
}

func (self *OxmIdTcpSrc) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTcpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpSrc, error) {
	_oxmidtcpsrc := &OxmIdTcpSrc{OxmId: parent}
	return _oxmidtcpsrc, nil
}

func NewOxmIdTcpSrc() *OxmIdTcpSrc {
	obj := &OxmIdTcpSrc{
		OxmId: NewOxmId(4610),
	}
	return obj
}
func (self *OxmIdTcpSrc) GetOXMName() string {
	return "tcp_src"
}

func (self *OxmIdTcpSrc) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTcpSrcMasked struct {
	*OxmId
}

type IOxmIdTcpSrcMasked interface {
	IOxmId
}

func (self *OxmIdTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTcpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpSrcMasked, error) {
	_oxmidtcpsrcmasked := &OxmIdTcpSrcMasked{OxmId: parent}
	return _oxmidtcpsrcmasked, nil
}

func NewOxmIdTcpSrcMasked() *OxmIdTcpSrcMasked {
	obj := &OxmIdTcpSrcMasked{
		OxmId: NewOxmId(4868),
	}
	return obj
}
func (self *OxmIdTcpSrcMasked) GetOXMName() string {
	return "tcp_src_masked"
}

func (self *OxmIdTcpSrcMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunDst struct {
	*OxmId
}

type IOxmIdTunDst interface {
	IOxmId
}

func (self *OxmIdTunDst) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunDst, error) {
	_oxmidtundst := &OxmIdTunDst{OxmId: parent}
	return _oxmidtundst, nil
}

func NewOxmIdTunDst() *OxmIdTunDst {
	obj := &OxmIdTunDst{
		OxmId: NewOxmId(81924),
	}
	return obj
}
func (self *OxmIdTunDst) GetOXMName() string {
	return "tun_dst"
}

func (self *OxmIdTunDst) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunDstMasked struct {
	*OxmId
}

type IOxmIdTunDstMasked interface {
	IOxmId
}

func (self *OxmIdTunDstMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunDstMasked, error) {
	_oxmidtundstmasked := &OxmIdTunDstMasked{OxmId: parent}
	return _oxmidtundstmasked, nil
}

func NewOxmIdTunDstMasked() *OxmIdTunDstMasked {
	obj := &OxmIdTunDstMasked{
		OxmId: NewOxmId(82184),
	}
	return obj
}
func (self *OxmIdTunDstMasked) GetOXMName() string {
	return "tun_dst_masked"
}

func (self *OxmIdTunDstMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunFlags struct {
	*OxmId
}

type IOxmIdTunFlags interface {
	IOxmId
}

func (self *OxmIdTunFlags) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunFlags, error) {
	_oxmidtunflags := &OxmIdTunFlags{OxmId: parent}
	return _oxmidtunflags, nil
}

func NewOxmIdTunFlags() *OxmIdTunFlags {
	obj := &OxmIdTunFlags{
		OxmId: NewOxmId(118786),
	}
	return obj
}
func (self *OxmIdTunFlags) GetOXMName() string {
	return "tun_flags"
}

func (self *OxmIdTunFlags) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunFlagsMasked struct {
	*OxmId
}

type IOxmIdTunFlagsMasked interface {
	IOxmId
}

func (self *OxmIdTunFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunFlagsMasked, error) {
	_oxmidtunflagsmasked := &OxmIdTunFlagsMasked{OxmId: parent}
	return _oxmidtunflagsmasked, nil
}

func NewOxmIdTunFlagsMasked() *OxmIdTunFlagsMasked {
	obj := &OxmIdTunFlagsMasked{
		OxmId: NewOxmId(119044),
	}
	return obj
}
func (self *OxmIdTunFlagsMasked) GetOXMName() string {
	return "tun_flags_masked"
}

func (self *OxmIdTunFlagsMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunGbpFlags struct {
	*OxmId
}

type IOxmIdTunGbpFlags interface {
	IOxmId
}

func (self *OxmIdTunGbpFlags) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunGbpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpFlags, error) {
	_oxmidtungbpflags := &OxmIdTunGbpFlags{OxmId: parent}
	return _oxmidtungbpflags, nil
}

func NewOxmIdTunGbpFlags() *OxmIdTunGbpFlags {
	obj := &OxmIdTunGbpFlags{
		OxmId: NewOxmId(85505),
	}
	return obj
}
func (self *OxmIdTunGbpFlags) GetOXMName() string {
	return "tun_gbp_flags"
}

func (self *OxmIdTunGbpFlags) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunGbpFlagsMasked struct {
	*OxmId
}

type IOxmIdTunGbpFlagsMasked interface {
	IOxmId
}

func (self *OxmIdTunGbpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunGbpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpFlagsMasked, error) {
	_oxmidtungbpflagsmasked := &OxmIdTunGbpFlagsMasked{OxmId: parent}
	return _oxmidtungbpflagsmasked, nil
}

func NewOxmIdTunGbpFlagsMasked() *OxmIdTunGbpFlagsMasked {
	obj := &OxmIdTunGbpFlagsMasked{
		OxmId: NewOxmId(85762),
	}
	return obj
}
func (self *OxmIdTunGbpFlagsMasked) GetOXMName() string {
	return "tun_gbp_flags_masked"
}

func (self *OxmIdTunGbpFlagsMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunGbpId struct {
	*OxmId
}

type IOxmIdTunGbpId interface {
	IOxmId
}

func (self *OxmIdTunGbpId) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunGbpId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpId, error) {
	_oxmidtungbpid := &OxmIdTunGbpId{OxmId: parent}
	return _oxmidtungbpid, nil
}

func NewOxmIdTunGbpId() *OxmIdTunGbpId {
	obj := &OxmIdTunGbpId{
		OxmId: NewOxmId(84994),
	}
	return obj
}
func (self *OxmIdTunGbpId) GetOXMName() string {
	return "tun_gbp_id"
}

func (self *OxmIdTunGbpId) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunGbpIdMasked struct {
	*OxmId
}

type IOxmIdTunGbpIdMasked interface {
	IOxmId
}

func (self *OxmIdTunGbpIdMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunGbpIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpIdMasked, error) {
	_oxmidtungbpidmasked := &OxmIdTunGbpIdMasked{OxmId: parent}
	return _oxmidtungbpidmasked, nil
}

func NewOxmIdTunGbpIdMasked() *OxmIdTunGbpIdMasked {
	obj := &OxmIdTunGbpIdMasked{
		OxmId: NewOxmId(85252),
	}
	return obj
}
func (self *OxmIdTunGbpIdMasked) GetOXMName() string {
	return "tun_gbp_id_masked"
}

func (self *OxmIdTunGbpIdMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunId struct {
	*OxmId
}

type IOxmIdTunId interface {
	IOxmId
}

func (self *OxmIdTunId) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunId, error) {
	_oxmidtunid := &OxmIdTunId{OxmId: parent}
	return _oxmidtunid, nil
}

func NewOxmIdTunId() *OxmIdTunId {
	obj := &OxmIdTunId{
		OxmId: NewOxmId(73736),
	}
	return obj
}
func (self *OxmIdTunId) GetOXMName() string {
	return "tun_id"
}

func (self *OxmIdTunId) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunIdMasked struct {
	*OxmId
}

type IOxmIdTunIdMasked interface {
	IOxmId
}

func (self *OxmIdTunIdMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIdMasked, error) {
	_oxmidtunidmasked := &OxmIdTunIdMasked{OxmId: parent}
	return _oxmidtunidmasked, nil
}

func NewOxmIdTunIdMasked() *OxmIdTunIdMasked {
	obj := &OxmIdTunIdMasked{
		OxmId: NewOxmId(74000),
	}
	return obj
}
func (self *OxmIdTunIdMasked) GetOXMName() string {
	return "tun_id_masked"
}

func (self *OxmIdTunIdMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunIpv6Dst struct {
	*OxmId
}

type IOxmIdTunIpv6Dst interface {
	IOxmId
}

func (self *OxmIdTunIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6Dst, error) {
	_oxmidtunipv6dst := &OxmIdTunIpv6Dst{OxmId: parent}
	return _oxmidtunipv6dst, nil
}

func NewOxmIdTunIpv6Dst() *OxmIdTunIpv6Dst {
	obj := &OxmIdTunIpv6Dst{
		OxmId: NewOxmId(121872),
	}
	return obj
}
func (self *OxmIdTunIpv6Dst) GetOXMName() string {
	return "tun_ipv6_dst"
}

func (self *OxmIdTunIpv6Dst) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunIpv6DstMasked struct {
	*OxmId
}

type IOxmIdTunIpv6DstMasked interface {
	IOxmId
}

func (self *OxmIdTunIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6DstMasked, error) {
	_oxmidtunipv6dstmasked := &OxmIdTunIpv6DstMasked{OxmId: parent}
	return _oxmidtunipv6dstmasked, nil
}

func NewOxmIdTunIpv6DstMasked() *OxmIdTunIpv6DstMasked {
	obj := &OxmIdTunIpv6DstMasked{
		OxmId: NewOxmId(122144),
	}
	return obj
}
func (self *OxmIdTunIpv6DstMasked) GetOXMName() string {
	return "tun_ipv6_dst_masked"
}

func (self *OxmIdTunIpv6DstMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunIpv6Src struct {
	*OxmId
}

type IOxmIdTunIpv6Src interface {
	IOxmId
}

func (self *OxmIdTunIpv6Src) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6Src, error) {
	_oxmidtunipv6src := &OxmIdTunIpv6Src{OxmId: parent}
	return _oxmidtunipv6src, nil
}

func NewOxmIdTunIpv6Src() *OxmIdTunIpv6Src {
	obj := &OxmIdTunIpv6Src{
		OxmId: NewOxmId(121360),
	}
	return obj
}
func (self *OxmIdTunIpv6Src) GetOXMName() string {
	return "tun_ipv6_src"
}

func (self *OxmIdTunIpv6Src) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunIpv6SrcMasked struct {
	*OxmId
}

type IOxmIdTunIpv6SrcMasked interface {
	IOxmId
}

func (self *OxmIdTunIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6SrcMasked, error) {
	_oxmidtunipv6srcmasked := &OxmIdTunIpv6SrcMasked{OxmId: parent}
	return _oxmidtunipv6srcmasked, nil
}

func NewOxmIdTunIpv6SrcMasked() *OxmIdTunIpv6SrcMasked {
	obj := &OxmIdTunIpv6SrcMasked{
		OxmId: NewOxmId(121632),
	}
	return obj
}
func (self *OxmIdTunIpv6SrcMasked) GetOXMName() string {
	return "tun_ipv6_src_masked"
}

func (self *OxmIdTunIpv6SrcMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata0 struct {
	*OxmId
}

type IOxmIdTunMetadata0 interface {
	IOxmId
}

func (self *OxmIdTunMetadata0) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata0, error) {
	_oxmidtunmetadata0 := &OxmIdTunMetadata0{OxmId: parent}
	return _oxmidtunmetadata0, nil
}

func NewOxmIdTunMetadata0() *OxmIdTunMetadata0 {
	obj := &OxmIdTunMetadata0{
		OxmId: NewOxmId(86140),
	}
	return obj
}
func (self *OxmIdTunMetadata0) GetOXMName() string {
	return "tun_metadata0"
}

func (self *OxmIdTunMetadata0) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata0Masked struct {
	*OxmId
}

type IOxmIdTunMetadata0Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata0Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata0Masked, error) {
	_oxmidtunmetadata0masked := &OxmIdTunMetadata0Masked{OxmId: parent}
	return _oxmidtunmetadata0masked, nil
}

func NewOxmIdTunMetadata0Masked() *OxmIdTunMetadata0Masked {
	obj := &OxmIdTunMetadata0Masked{
		OxmId: NewOxmId(86520),
	}
	return obj
}
func (self *OxmIdTunMetadata0Masked) GetOXMName() string {
	return "tun_metadata0_masked"
}

func (self *OxmIdTunMetadata0Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata1 struct {
	*OxmId
}

type IOxmIdTunMetadata1 interface {
	IOxmId
}

func (self *OxmIdTunMetadata1) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata1, error) {
	_oxmidtunmetadata1 := &OxmIdTunMetadata1{OxmId: parent}
	return _oxmidtunmetadata1, nil
}

func NewOxmIdTunMetadata1() *OxmIdTunMetadata1 {
	obj := &OxmIdTunMetadata1{
		OxmId: NewOxmId(86652),
	}
	return obj
}
func (self *OxmIdTunMetadata1) GetOXMName() string {
	return "tun_metadata1"
}

func (self *OxmIdTunMetadata1) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata10 struct {
	*OxmId
}

type IOxmIdTunMetadata10 interface {
	IOxmId
}

func (self *OxmIdTunMetadata10) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata10(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata10, error) {
	_oxmidtunmetadata10 := &OxmIdTunMetadata10{OxmId: parent}
	return _oxmidtunmetadata10, nil
}

func NewOxmIdTunMetadata10() *OxmIdTunMetadata10 {
	obj := &OxmIdTunMetadata10{
		OxmId: NewOxmId(91260),
	}
	return obj
}
func (self *OxmIdTunMetadata10) GetOXMName() string {
	return "tun_metadata10"
}

func (self *OxmIdTunMetadata10) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata10Masked struct {
	*OxmId
}

type IOxmIdTunMetadata10Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata10Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata10Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata10Masked, error) {
	_oxmidtunmetadata10masked := &OxmIdTunMetadata10Masked{OxmId: parent}
	return _oxmidtunmetadata10masked, nil
}

func NewOxmIdTunMetadata10Masked() *OxmIdTunMetadata10Masked {
	obj := &OxmIdTunMetadata10Masked{
		OxmId: NewOxmId(91640),
	}
	return obj
}
func (self *OxmIdTunMetadata10Masked) GetOXMName() string {
	return "tun_metadata10_masked"
}

func (self *OxmIdTunMetadata10Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata11 struct {
	*OxmId
}

type IOxmIdTunMetadata11 interface {
	IOxmId
}

func (self *OxmIdTunMetadata11) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata11(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata11, error) {
	_oxmidtunmetadata11 := &OxmIdTunMetadata11{OxmId: parent}
	return _oxmidtunmetadata11, nil
}

func NewOxmIdTunMetadata11() *OxmIdTunMetadata11 {
	obj := &OxmIdTunMetadata11{
		OxmId: NewOxmId(91772),
	}
	return obj
}
func (self *OxmIdTunMetadata11) GetOXMName() string {
	return "tun_metadata11"
}

func (self *OxmIdTunMetadata11) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata11Masked struct {
	*OxmId
}

type IOxmIdTunMetadata11Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata11Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata11Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata11Masked, error) {
	_oxmidtunmetadata11masked := &OxmIdTunMetadata11Masked{OxmId: parent}
	return _oxmidtunmetadata11masked, nil
}

func NewOxmIdTunMetadata11Masked() *OxmIdTunMetadata11Masked {
	obj := &OxmIdTunMetadata11Masked{
		OxmId: NewOxmId(92152),
	}
	return obj
}
func (self *OxmIdTunMetadata11Masked) GetOXMName() string {
	return "tun_metadata11_masked"
}

func (self *OxmIdTunMetadata11Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata12 struct {
	*OxmId
}

type IOxmIdTunMetadata12 interface {
	IOxmId
}

func (self *OxmIdTunMetadata12) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata12(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata12, error) {
	_oxmidtunmetadata12 := &OxmIdTunMetadata12{OxmId: parent}
	return _oxmidtunmetadata12, nil
}

func NewOxmIdTunMetadata12() *OxmIdTunMetadata12 {
	obj := &OxmIdTunMetadata12{
		OxmId: NewOxmId(92284),
	}
	return obj
}
func (self *OxmIdTunMetadata12) GetOXMName() string {
	return "tun_metadata12"
}

func (self *OxmIdTunMetadata12) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata12Masked struct {
	*OxmId
}

type IOxmIdTunMetadata12Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata12Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata12Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata12Masked, error) {
	_oxmidtunmetadata12masked := &OxmIdTunMetadata12Masked{OxmId: parent}
	return _oxmidtunmetadata12masked, nil
}

func NewOxmIdTunMetadata12Masked() *OxmIdTunMetadata12Masked {
	obj := &OxmIdTunMetadata12Masked{
		OxmId: NewOxmId(92664),
	}
	return obj
}
func (self *OxmIdTunMetadata12Masked) GetOXMName() string {
	return "tun_metadata12_masked"
}

func (self *OxmIdTunMetadata12Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata13 struct {
	*OxmId
}

type IOxmIdTunMetadata13 interface {
	IOxmId
}

func (self *OxmIdTunMetadata13) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata13(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata13, error) {
	_oxmidtunmetadata13 := &OxmIdTunMetadata13{OxmId: parent}
	return _oxmidtunmetadata13, nil
}

func NewOxmIdTunMetadata13() *OxmIdTunMetadata13 {
	obj := &OxmIdTunMetadata13{
		OxmId: NewOxmId(92796),
	}
	return obj
}
func (self *OxmIdTunMetadata13) GetOXMName() string {
	return "tun_metadata13"
}

func (self *OxmIdTunMetadata13) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata13Masked struct {
	*OxmId
}

type IOxmIdTunMetadata13Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata13Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata13Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata13Masked, error) {
	_oxmidtunmetadata13masked := &OxmIdTunMetadata13Masked{OxmId: parent}
	return _oxmidtunmetadata13masked, nil
}

func NewOxmIdTunMetadata13Masked() *OxmIdTunMetadata13Masked {
	obj := &OxmIdTunMetadata13Masked{
		OxmId: NewOxmId(93176),
	}
	return obj
}
func (self *OxmIdTunMetadata13Masked) GetOXMName() string {
	return "tun_metadata13_masked"
}

func (self *OxmIdTunMetadata13Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata14 struct {
	*OxmId
}

type IOxmIdTunMetadata14 interface {
	IOxmId
}

func (self *OxmIdTunMetadata14) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata14(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata14, error) {
	_oxmidtunmetadata14 := &OxmIdTunMetadata14{OxmId: parent}
	return _oxmidtunmetadata14, nil
}

func NewOxmIdTunMetadata14() *OxmIdTunMetadata14 {
	obj := &OxmIdTunMetadata14{
		OxmId: NewOxmId(93308),
	}
	return obj
}
func (self *OxmIdTunMetadata14) GetOXMName() string {
	return "tun_metadata14"
}

func (self *OxmIdTunMetadata14) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata14Masked struct {
	*OxmId
}

type IOxmIdTunMetadata14Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata14Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata14Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata14Masked, error) {
	_oxmidtunmetadata14masked := &OxmIdTunMetadata14Masked{OxmId: parent}
	return _oxmidtunmetadata14masked, nil
}

func NewOxmIdTunMetadata14Masked() *OxmIdTunMetadata14Masked {
	obj := &OxmIdTunMetadata14Masked{
		OxmId: NewOxmId(93688),
	}
	return obj
}
func (self *OxmIdTunMetadata14Masked) GetOXMName() string {
	return "tun_metadata14_masked"
}

func (self *OxmIdTunMetadata14Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata15 struct {
	*OxmId
}

type IOxmIdTunMetadata15 interface {
	IOxmId
}

func (self *OxmIdTunMetadata15) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata15(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata15, error) {
	_oxmidtunmetadata15 := &OxmIdTunMetadata15{OxmId: parent}
	return _oxmidtunmetadata15, nil
}

func NewOxmIdTunMetadata15() *OxmIdTunMetadata15 {
	obj := &OxmIdTunMetadata15{
		OxmId: NewOxmId(93820),
	}
	return obj
}
func (self *OxmIdTunMetadata15) GetOXMName() string {
	return "tun_metadata15"
}

func (self *OxmIdTunMetadata15) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata15Masked struct {
	*OxmId
}

type IOxmIdTunMetadata15Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata15Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata15Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata15Masked, error) {
	_oxmidtunmetadata15masked := &OxmIdTunMetadata15Masked{OxmId: parent}
	return _oxmidtunmetadata15masked, nil
}

func NewOxmIdTunMetadata15Masked() *OxmIdTunMetadata15Masked {
	obj := &OxmIdTunMetadata15Masked{
		OxmId: NewOxmId(94200),
	}
	return obj
}
func (self *OxmIdTunMetadata15Masked) GetOXMName() string {
	return "tun_metadata15_masked"
}

func (self *OxmIdTunMetadata15Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata16 struct {
	*OxmId
}

type IOxmIdTunMetadata16 interface {
	IOxmId
}

func (self *OxmIdTunMetadata16) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata16(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata16, error) {
	_oxmidtunmetadata16 := &OxmIdTunMetadata16{OxmId: parent}
	return _oxmidtunmetadata16, nil
}

func NewOxmIdTunMetadata16() *OxmIdTunMetadata16 {
	obj := &OxmIdTunMetadata16{
		OxmId: NewOxmId(94332),
	}
	return obj
}
func (self *OxmIdTunMetadata16) GetOXMName() string {
	return "tun_metadata16"
}

func (self *OxmIdTunMetadata16) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata16Masked struct {
	*OxmId
}

type IOxmIdTunMetadata16Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata16Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata16Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata16Masked, error) {
	_oxmidtunmetadata16masked := &OxmIdTunMetadata16Masked{OxmId: parent}
	return _oxmidtunmetadata16masked, nil
}

func NewOxmIdTunMetadata16Masked() *OxmIdTunMetadata16Masked {
	obj := &OxmIdTunMetadata16Masked{
		OxmId: NewOxmId(94712),
	}
	return obj
}
func (self *OxmIdTunMetadata16Masked) GetOXMName() string {
	return "tun_metadata16_masked"
}

func (self *OxmIdTunMetadata16Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata17 struct {
	*OxmId
}

type IOxmIdTunMetadata17 interface {
	IOxmId
}

func (self *OxmIdTunMetadata17) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata17(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata17, error) {
	_oxmidtunmetadata17 := &OxmIdTunMetadata17{OxmId: parent}
	return _oxmidtunmetadata17, nil
}

func NewOxmIdTunMetadata17() *OxmIdTunMetadata17 {
	obj := &OxmIdTunMetadata17{
		OxmId: NewOxmId(94844),
	}
	return obj
}
func (self *OxmIdTunMetadata17) GetOXMName() string {
	return "tun_metadata17"
}

func (self *OxmIdTunMetadata17) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata17Masked struct {
	*OxmId
}

type IOxmIdTunMetadata17Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata17Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata17Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata17Masked, error) {
	_oxmidtunmetadata17masked := &OxmIdTunMetadata17Masked{OxmId: parent}
	return _oxmidtunmetadata17masked, nil
}

func NewOxmIdTunMetadata17Masked() *OxmIdTunMetadata17Masked {
	obj := &OxmIdTunMetadata17Masked{
		OxmId: NewOxmId(95224),
	}
	return obj
}
func (self *OxmIdTunMetadata17Masked) GetOXMName() string {
	return "tun_metadata17_masked"
}

func (self *OxmIdTunMetadata17Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata18 struct {
	*OxmId
}

type IOxmIdTunMetadata18 interface {
	IOxmId
}

func (self *OxmIdTunMetadata18) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata18(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata18, error) {
	_oxmidtunmetadata18 := &OxmIdTunMetadata18{OxmId: parent}
	return _oxmidtunmetadata18, nil
}

func NewOxmIdTunMetadata18() *OxmIdTunMetadata18 {
	obj := &OxmIdTunMetadata18{
		OxmId: NewOxmId(95356),
	}
	return obj
}
func (self *OxmIdTunMetadata18) GetOXMName() string {
	return "tun_metadata18"
}

func (self *OxmIdTunMetadata18) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata18Masked struct {
	*OxmId
}

type IOxmIdTunMetadata18Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata18Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata18Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata18Masked, error) {
	_oxmidtunmetadata18masked := &OxmIdTunMetadata18Masked{OxmId: parent}
	return _oxmidtunmetadata18masked, nil
}

func NewOxmIdTunMetadata18Masked() *OxmIdTunMetadata18Masked {
	obj := &OxmIdTunMetadata18Masked{
		OxmId: NewOxmId(95736),
	}
	return obj
}
func (self *OxmIdTunMetadata18Masked) GetOXMName() string {
	return "tun_metadata18_masked"
}

func (self *OxmIdTunMetadata18Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata19 struct {
	*OxmId
}

type IOxmIdTunMetadata19 interface {
	IOxmId
}

func (self *OxmIdTunMetadata19) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata19(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata19, error) {
	_oxmidtunmetadata19 := &OxmIdTunMetadata19{OxmId: parent}
	return _oxmidtunmetadata19, nil
}

func NewOxmIdTunMetadata19() *OxmIdTunMetadata19 {
	obj := &OxmIdTunMetadata19{
		OxmId: NewOxmId(95868),
	}
	return obj
}
func (self *OxmIdTunMetadata19) GetOXMName() string {
	return "tun_metadata19"
}

func (self *OxmIdTunMetadata19) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata19Masked struct {
	*OxmId
}

type IOxmIdTunMetadata19Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata19Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata19Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata19Masked, error) {
	_oxmidtunmetadata19masked := &OxmIdTunMetadata19Masked{OxmId: parent}
	return _oxmidtunmetadata19masked, nil
}

func NewOxmIdTunMetadata19Masked() *OxmIdTunMetadata19Masked {
	obj := &OxmIdTunMetadata19Masked{
		OxmId: NewOxmId(96248),
	}
	return obj
}
func (self *OxmIdTunMetadata19Masked) GetOXMName() string {
	return "tun_metadata19_masked"
}

func (self *OxmIdTunMetadata19Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata1Masked struct {
	*OxmId
}

type IOxmIdTunMetadata1Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata1Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata1Masked, error) {
	_oxmidtunmetadata1masked := &OxmIdTunMetadata1Masked{OxmId: parent}
	return _oxmidtunmetadata1masked, nil
}

func NewOxmIdTunMetadata1Masked() *OxmIdTunMetadata1Masked {
	obj := &OxmIdTunMetadata1Masked{
		OxmId: NewOxmId(87032),
	}
	return obj
}
func (self *OxmIdTunMetadata1Masked) GetOXMName() string {
	return "tun_metadata1_masked"
}

func (self *OxmIdTunMetadata1Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata2 struct {
	*OxmId
}

type IOxmIdTunMetadata2 interface {
	IOxmId
}

func (self *OxmIdTunMetadata2) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata2, error) {
	_oxmidtunmetadata2 := &OxmIdTunMetadata2{OxmId: parent}
	return _oxmidtunmetadata2, nil
}

func NewOxmIdTunMetadata2() *OxmIdTunMetadata2 {
	obj := &OxmIdTunMetadata2{
		OxmId: NewOxmId(87164),
	}
	return obj
}
func (self *OxmIdTunMetadata2) GetOXMName() string {
	return "tun_metadata2"
}

func (self *OxmIdTunMetadata2) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata20 struct {
	*OxmId
}

type IOxmIdTunMetadata20 interface {
	IOxmId
}

func (self *OxmIdTunMetadata20) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata20(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata20, error) {
	_oxmidtunmetadata20 := &OxmIdTunMetadata20{OxmId: parent}
	return _oxmidtunmetadata20, nil
}

func NewOxmIdTunMetadata20() *OxmIdTunMetadata20 {
	obj := &OxmIdTunMetadata20{
		OxmId: NewOxmId(96380),
	}
	return obj
}
func (self *OxmIdTunMetadata20) GetOXMName() string {
	return "tun_metadata20"
}

func (self *OxmIdTunMetadata20) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata20Masked struct {
	*OxmId
}

type IOxmIdTunMetadata20Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata20Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata20Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata20Masked, error) {
	_oxmidtunmetadata20masked := &OxmIdTunMetadata20Masked{OxmId: parent}
	return _oxmidtunmetadata20masked, nil
}

func NewOxmIdTunMetadata20Masked() *OxmIdTunMetadata20Masked {
	obj := &OxmIdTunMetadata20Masked{
		OxmId: NewOxmId(96760),
	}
	return obj
}
func (self *OxmIdTunMetadata20Masked) GetOXMName() string {
	return "tun_metadata20_masked"
}

func (self *OxmIdTunMetadata20Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata21 struct {
	*OxmId
}

type IOxmIdTunMetadata21 interface {
	IOxmId
}

func (self *OxmIdTunMetadata21) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata21(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata21, error) {
	_oxmidtunmetadata21 := &OxmIdTunMetadata21{OxmId: parent}
	return _oxmidtunmetadata21, nil
}

func NewOxmIdTunMetadata21() *OxmIdTunMetadata21 {
	obj := &OxmIdTunMetadata21{
		OxmId: NewOxmId(96892),
	}
	return obj
}
func (self *OxmIdTunMetadata21) GetOXMName() string {
	return "tun_metadata21"
}

func (self *OxmIdTunMetadata21) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata21Masked struct {
	*OxmId
}

type IOxmIdTunMetadata21Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata21Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata21Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata21Masked, error) {
	_oxmidtunmetadata21masked := &OxmIdTunMetadata21Masked{OxmId: parent}
	return _oxmidtunmetadata21masked, nil
}

func NewOxmIdTunMetadata21Masked() *OxmIdTunMetadata21Masked {
	obj := &OxmIdTunMetadata21Masked{
		OxmId: NewOxmId(97272),
	}
	return obj
}
func (self *OxmIdTunMetadata21Masked) GetOXMName() string {
	return "tun_metadata21_masked"
}

func (self *OxmIdTunMetadata21Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata22 struct {
	*OxmId
}

type IOxmIdTunMetadata22 interface {
	IOxmId
}

func (self *OxmIdTunMetadata22) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata22(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata22, error) {
	_oxmidtunmetadata22 := &OxmIdTunMetadata22{OxmId: parent}
	return _oxmidtunmetadata22, nil
}

func NewOxmIdTunMetadata22() *OxmIdTunMetadata22 {
	obj := &OxmIdTunMetadata22{
		OxmId: NewOxmId(97404),
	}
	return obj
}
func (self *OxmIdTunMetadata22) GetOXMName() string {
	return "tun_metadata22"
}

func (self *OxmIdTunMetadata22) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata22Masked struct {
	*OxmId
}

type IOxmIdTunMetadata22Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata22Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata22Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata22Masked, error) {
	_oxmidtunmetadata22masked := &OxmIdTunMetadata22Masked{OxmId: parent}
	return _oxmidtunmetadata22masked, nil
}

func NewOxmIdTunMetadata22Masked() *OxmIdTunMetadata22Masked {
	obj := &OxmIdTunMetadata22Masked{
		OxmId: NewOxmId(97784),
	}
	return obj
}
func (self *OxmIdTunMetadata22Masked) GetOXMName() string {
	return "tun_metadata22_masked"
}

func (self *OxmIdTunMetadata22Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata23 struct {
	*OxmId
}

type IOxmIdTunMetadata23 interface {
	IOxmId
}

func (self *OxmIdTunMetadata23) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata23(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata23, error) {
	_oxmidtunmetadata23 := &OxmIdTunMetadata23{OxmId: parent}
	return _oxmidtunmetadata23, nil
}

func NewOxmIdTunMetadata23() *OxmIdTunMetadata23 {
	obj := &OxmIdTunMetadata23{
		OxmId: NewOxmId(97916),
	}
	return obj
}
func (self *OxmIdTunMetadata23) GetOXMName() string {
	return "tun_metadata23"
}

func (self *OxmIdTunMetadata23) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata23Masked struct {
	*OxmId
}

type IOxmIdTunMetadata23Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata23Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata23Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata23Masked, error) {
	_oxmidtunmetadata23masked := &OxmIdTunMetadata23Masked{OxmId: parent}
	return _oxmidtunmetadata23masked, nil
}

func NewOxmIdTunMetadata23Masked() *OxmIdTunMetadata23Masked {
	obj := &OxmIdTunMetadata23Masked{
		OxmId: NewOxmId(98296),
	}
	return obj
}
func (self *OxmIdTunMetadata23Masked) GetOXMName() string {
	return "tun_metadata23_masked"
}

func (self *OxmIdTunMetadata23Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata24 struct {
	*OxmId
}

type IOxmIdTunMetadata24 interface {
	IOxmId
}

func (self *OxmIdTunMetadata24) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata24(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata24, error) {
	_oxmidtunmetadata24 := &OxmIdTunMetadata24{OxmId: parent}
	return _oxmidtunmetadata24, nil
}

func NewOxmIdTunMetadata24() *OxmIdTunMetadata24 {
	obj := &OxmIdTunMetadata24{
		OxmId: NewOxmId(98428),
	}
	return obj
}
func (self *OxmIdTunMetadata24) GetOXMName() string {
	return "tun_metadata24"
}

func (self *OxmIdTunMetadata24) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata24Masked struct {
	*OxmId
}

type IOxmIdTunMetadata24Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata24Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata24Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata24Masked, error) {
	_oxmidtunmetadata24masked := &OxmIdTunMetadata24Masked{OxmId: parent}
	return _oxmidtunmetadata24masked, nil
}

func NewOxmIdTunMetadata24Masked() *OxmIdTunMetadata24Masked {
	obj := &OxmIdTunMetadata24Masked{
		OxmId: NewOxmId(98808),
	}
	return obj
}
func (self *OxmIdTunMetadata24Masked) GetOXMName() string {
	return "tun_metadata24_masked"
}

func (self *OxmIdTunMetadata24Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata25 struct {
	*OxmId
}

type IOxmIdTunMetadata25 interface {
	IOxmId
}

func (self *OxmIdTunMetadata25) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata25(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata25, error) {
	_oxmidtunmetadata25 := &OxmIdTunMetadata25{OxmId: parent}
	return _oxmidtunmetadata25, nil
}

func NewOxmIdTunMetadata25() *OxmIdTunMetadata25 {
	obj := &OxmIdTunMetadata25{
		OxmId: NewOxmId(98940),
	}
	return obj
}
func (self *OxmIdTunMetadata25) GetOXMName() string {
	return "tun_metadata25"
}

func (self *OxmIdTunMetadata25) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata25Masked struct {
	*OxmId
}

type IOxmIdTunMetadata25Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata25Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata25Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata25Masked, error) {
	_oxmidtunmetadata25masked := &OxmIdTunMetadata25Masked{OxmId: parent}
	return _oxmidtunmetadata25masked, nil
}

func NewOxmIdTunMetadata25Masked() *OxmIdTunMetadata25Masked {
	obj := &OxmIdTunMetadata25Masked{
		OxmId: NewOxmId(99320),
	}
	return obj
}
func (self *OxmIdTunMetadata25Masked) GetOXMName() string {
	return "tun_metadata25_masked"
}

func (self *OxmIdTunMetadata25Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata26 struct {
	*OxmId
}

type IOxmIdTunMetadata26 interface {
	IOxmId
}

func (self *OxmIdTunMetadata26) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata26(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata26, error) {
	_oxmidtunmetadata26 := &OxmIdTunMetadata26{OxmId: parent}
	return _oxmidtunmetadata26, nil
}

func NewOxmIdTunMetadata26() *OxmIdTunMetadata26 {
	obj := &OxmIdTunMetadata26{
		OxmId: NewOxmId(99452),
	}
	return obj
}
func (self *OxmIdTunMetadata26) GetOXMName() string {
	return "tun_metadata26"
}

func (self *OxmIdTunMetadata26) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata26Masked struct {
	*OxmId
}

type IOxmIdTunMetadata26Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata26Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata26Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata26Masked, error) {
	_oxmidtunmetadata26masked := &OxmIdTunMetadata26Masked{OxmId: parent}
	return _oxmidtunmetadata26masked, nil
}

func NewOxmIdTunMetadata26Masked() *OxmIdTunMetadata26Masked {
	obj := &OxmIdTunMetadata26Masked{
		OxmId: NewOxmId(99832),
	}
	return obj
}
func (self *OxmIdTunMetadata26Masked) GetOXMName() string {
	return "tun_metadata26_masked"
}

func (self *OxmIdTunMetadata26Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata27 struct {
	*OxmId
}

type IOxmIdTunMetadata27 interface {
	IOxmId
}

func (self *OxmIdTunMetadata27) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata27(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata27, error) {
	_oxmidtunmetadata27 := &OxmIdTunMetadata27{OxmId: parent}
	return _oxmidtunmetadata27, nil
}

func NewOxmIdTunMetadata27() *OxmIdTunMetadata27 {
	obj := &OxmIdTunMetadata27{
		OxmId: NewOxmId(99964),
	}
	return obj
}
func (self *OxmIdTunMetadata27) GetOXMName() string {
	return "tun_metadata27"
}

func (self *OxmIdTunMetadata27) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata27Masked struct {
	*OxmId
}

type IOxmIdTunMetadata27Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata27Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata27Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata27Masked, error) {
	_oxmidtunmetadata27masked := &OxmIdTunMetadata27Masked{OxmId: parent}
	return _oxmidtunmetadata27masked, nil
}

func NewOxmIdTunMetadata27Masked() *OxmIdTunMetadata27Masked {
	obj := &OxmIdTunMetadata27Masked{
		OxmId: NewOxmId(100344),
	}
	return obj
}
func (self *OxmIdTunMetadata27Masked) GetOXMName() string {
	return "tun_metadata27_masked"
}

func (self *OxmIdTunMetadata27Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata28 struct {
	*OxmId
}

type IOxmIdTunMetadata28 interface {
	IOxmId
}

func (self *OxmIdTunMetadata28) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata28(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata28, error) {
	_oxmidtunmetadata28 := &OxmIdTunMetadata28{OxmId: parent}
	return _oxmidtunmetadata28, nil
}

func NewOxmIdTunMetadata28() *OxmIdTunMetadata28 {
	obj := &OxmIdTunMetadata28{
		OxmId: NewOxmId(100476),
	}
	return obj
}
func (self *OxmIdTunMetadata28) GetOXMName() string {
	return "tun_metadata28"
}

func (self *OxmIdTunMetadata28) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata28Masked struct {
	*OxmId
}

type IOxmIdTunMetadata28Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata28Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata28Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata28Masked, error) {
	_oxmidtunmetadata28masked := &OxmIdTunMetadata28Masked{OxmId: parent}
	return _oxmidtunmetadata28masked, nil
}

func NewOxmIdTunMetadata28Masked() *OxmIdTunMetadata28Masked {
	obj := &OxmIdTunMetadata28Masked{
		OxmId: NewOxmId(100856),
	}
	return obj
}
func (self *OxmIdTunMetadata28Masked) GetOXMName() string {
	return "tun_metadata28_masked"
}

func (self *OxmIdTunMetadata28Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata29 struct {
	*OxmId
}

type IOxmIdTunMetadata29 interface {
	IOxmId
}

func (self *OxmIdTunMetadata29) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata29(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata29, error) {
	_oxmidtunmetadata29 := &OxmIdTunMetadata29{OxmId: parent}
	return _oxmidtunmetadata29, nil
}

func NewOxmIdTunMetadata29() *OxmIdTunMetadata29 {
	obj := &OxmIdTunMetadata29{
		OxmId: NewOxmId(100988),
	}
	return obj
}
func (self *OxmIdTunMetadata29) GetOXMName() string {
	return "tun_metadata29"
}

func (self *OxmIdTunMetadata29) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata29Masked struct {
	*OxmId
}

type IOxmIdTunMetadata29Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata29Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata29Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata29Masked, error) {
	_oxmidtunmetadata29masked := &OxmIdTunMetadata29Masked{OxmId: parent}
	return _oxmidtunmetadata29masked, nil
}

func NewOxmIdTunMetadata29Masked() *OxmIdTunMetadata29Masked {
	obj := &OxmIdTunMetadata29Masked{
		OxmId: NewOxmId(101368),
	}
	return obj
}
func (self *OxmIdTunMetadata29Masked) GetOXMName() string {
	return "tun_metadata29_masked"
}

func (self *OxmIdTunMetadata29Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata2Masked struct {
	*OxmId
}

type IOxmIdTunMetadata2Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata2Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata2Masked, error) {
	_oxmidtunmetadata2masked := &OxmIdTunMetadata2Masked{OxmId: parent}
	return _oxmidtunmetadata2masked, nil
}

func NewOxmIdTunMetadata2Masked() *OxmIdTunMetadata2Masked {
	obj := &OxmIdTunMetadata2Masked{
		OxmId: NewOxmId(87544),
	}
	return obj
}
func (self *OxmIdTunMetadata2Masked) GetOXMName() string {
	return "tun_metadata2_masked"
}

func (self *OxmIdTunMetadata2Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata3 struct {
	*OxmId
}

type IOxmIdTunMetadata3 interface {
	IOxmId
}

func (self *OxmIdTunMetadata3) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata3, error) {
	_oxmidtunmetadata3 := &OxmIdTunMetadata3{OxmId: parent}
	return _oxmidtunmetadata3, nil
}

func NewOxmIdTunMetadata3() *OxmIdTunMetadata3 {
	obj := &OxmIdTunMetadata3{
		OxmId: NewOxmId(87676),
	}
	return obj
}
func (self *OxmIdTunMetadata3) GetOXMName() string {
	return "tun_metadata3"
}

func (self *OxmIdTunMetadata3) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata30 struct {
	*OxmId
}

type IOxmIdTunMetadata30 interface {
	IOxmId
}

func (self *OxmIdTunMetadata30) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata30(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata30, error) {
	_oxmidtunmetadata30 := &OxmIdTunMetadata30{OxmId: parent}
	return _oxmidtunmetadata30, nil
}

func NewOxmIdTunMetadata30() *OxmIdTunMetadata30 {
	obj := &OxmIdTunMetadata30{
		OxmId: NewOxmId(101500),
	}
	return obj
}
func (self *OxmIdTunMetadata30) GetOXMName() string {
	return "tun_metadata30"
}

func (self *OxmIdTunMetadata30) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata30Masked struct {
	*OxmId
}

type IOxmIdTunMetadata30Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata30Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata30Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata30Masked, error) {
	_oxmidtunmetadata30masked := &OxmIdTunMetadata30Masked{OxmId: parent}
	return _oxmidtunmetadata30masked, nil
}

func NewOxmIdTunMetadata30Masked() *OxmIdTunMetadata30Masked {
	obj := &OxmIdTunMetadata30Masked{
		OxmId: NewOxmId(101880),
	}
	return obj
}
func (self *OxmIdTunMetadata30Masked) GetOXMName() string {
	return "tun_metadata30_masked"
}

func (self *OxmIdTunMetadata30Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata31 struct {
	*OxmId
}

type IOxmIdTunMetadata31 interface {
	IOxmId
}

func (self *OxmIdTunMetadata31) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata31(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata31, error) {
	_oxmidtunmetadata31 := &OxmIdTunMetadata31{OxmId: parent}
	return _oxmidtunmetadata31, nil
}

func NewOxmIdTunMetadata31() *OxmIdTunMetadata31 {
	obj := &OxmIdTunMetadata31{
		OxmId: NewOxmId(102012),
	}
	return obj
}
func (self *OxmIdTunMetadata31) GetOXMName() string {
	return "tun_metadata31"
}

func (self *OxmIdTunMetadata31) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata31Masked struct {
	*OxmId
}

type IOxmIdTunMetadata31Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata31Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata31Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata31Masked, error) {
	_oxmidtunmetadata31masked := &OxmIdTunMetadata31Masked{OxmId: parent}
	return _oxmidtunmetadata31masked, nil
}

func NewOxmIdTunMetadata31Masked() *OxmIdTunMetadata31Masked {
	obj := &OxmIdTunMetadata31Masked{
		OxmId: NewOxmId(102392),
	}
	return obj
}
func (self *OxmIdTunMetadata31Masked) GetOXMName() string {
	return "tun_metadata31_masked"
}

func (self *OxmIdTunMetadata31Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata32 struct {
	*OxmId
}

type IOxmIdTunMetadata32 interface {
	IOxmId
}

func (self *OxmIdTunMetadata32) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata32(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata32, error) {
	_oxmidtunmetadata32 := &OxmIdTunMetadata32{OxmId: parent}
	return _oxmidtunmetadata32, nil
}

func NewOxmIdTunMetadata32() *OxmIdTunMetadata32 {
	obj := &OxmIdTunMetadata32{
		OxmId: NewOxmId(102524),
	}
	return obj
}
func (self *OxmIdTunMetadata32) GetOXMName() string {
	return "tun_metadata32"
}

func (self *OxmIdTunMetadata32) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata32Masked struct {
	*OxmId
}

type IOxmIdTunMetadata32Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata32Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata32Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata32Masked, error) {
	_oxmidtunmetadata32masked := &OxmIdTunMetadata32Masked{OxmId: parent}
	return _oxmidtunmetadata32masked, nil
}

func NewOxmIdTunMetadata32Masked() *OxmIdTunMetadata32Masked {
	obj := &OxmIdTunMetadata32Masked{
		OxmId: NewOxmId(102904),
	}
	return obj
}
func (self *OxmIdTunMetadata32Masked) GetOXMName() string {
	return "tun_metadata32_masked"
}

func (self *OxmIdTunMetadata32Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata33 struct {
	*OxmId
}

type IOxmIdTunMetadata33 interface {
	IOxmId
}

func (self *OxmIdTunMetadata33) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata33(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata33, error) {
	_oxmidtunmetadata33 := &OxmIdTunMetadata33{OxmId: parent}
	return _oxmidtunmetadata33, nil
}

func NewOxmIdTunMetadata33() *OxmIdTunMetadata33 {
	obj := &OxmIdTunMetadata33{
		OxmId: NewOxmId(103036),
	}
	return obj
}
func (self *OxmIdTunMetadata33) GetOXMName() string {
	return "tun_metadata33"
}

func (self *OxmIdTunMetadata33) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata33Masked struct {
	*OxmId
}

type IOxmIdTunMetadata33Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata33Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata33Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata33Masked, error) {
	_oxmidtunmetadata33masked := &OxmIdTunMetadata33Masked{OxmId: parent}
	return _oxmidtunmetadata33masked, nil
}

func NewOxmIdTunMetadata33Masked() *OxmIdTunMetadata33Masked {
	obj := &OxmIdTunMetadata33Masked{
		OxmId: NewOxmId(103416),
	}
	return obj
}
func (self *OxmIdTunMetadata33Masked) GetOXMName() string {
	return "tun_metadata33_masked"
}

func (self *OxmIdTunMetadata33Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata34 struct {
	*OxmId
}

type IOxmIdTunMetadata34 interface {
	IOxmId
}

func (self *OxmIdTunMetadata34) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata34(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata34, error) {
	_oxmidtunmetadata34 := &OxmIdTunMetadata34{OxmId: parent}
	return _oxmidtunmetadata34, nil
}

func NewOxmIdTunMetadata34() *OxmIdTunMetadata34 {
	obj := &OxmIdTunMetadata34{
		OxmId: NewOxmId(103548),
	}
	return obj
}
func (self *OxmIdTunMetadata34) GetOXMName() string {
	return "tun_metadata34"
}

func (self *OxmIdTunMetadata34) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata34Masked struct {
	*OxmId
}

type IOxmIdTunMetadata34Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata34Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata34Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata34Masked, error) {
	_oxmidtunmetadata34masked := &OxmIdTunMetadata34Masked{OxmId: parent}
	return _oxmidtunmetadata34masked, nil
}

func NewOxmIdTunMetadata34Masked() *OxmIdTunMetadata34Masked {
	obj := &OxmIdTunMetadata34Masked{
		OxmId: NewOxmId(103928),
	}
	return obj
}
func (self *OxmIdTunMetadata34Masked) GetOXMName() string {
	return "tun_metadata34_masked"
}

func (self *OxmIdTunMetadata34Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata35 struct {
	*OxmId
}

type IOxmIdTunMetadata35 interface {
	IOxmId
}

func (self *OxmIdTunMetadata35) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata35(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata35, error) {
	_oxmidtunmetadata35 := &OxmIdTunMetadata35{OxmId: parent}
	return _oxmidtunmetadata35, nil
}

func NewOxmIdTunMetadata35() *OxmIdTunMetadata35 {
	obj := &OxmIdTunMetadata35{
		OxmId: NewOxmId(104060),
	}
	return obj
}
func (self *OxmIdTunMetadata35) GetOXMName() string {
	return "tun_metadata35"
}

func (self *OxmIdTunMetadata35) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata35Masked struct {
	*OxmId
}

type IOxmIdTunMetadata35Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata35Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata35Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata35Masked, error) {
	_oxmidtunmetadata35masked := &OxmIdTunMetadata35Masked{OxmId: parent}
	return _oxmidtunmetadata35masked, nil
}

func NewOxmIdTunMetadata35Masked() *OxmIdTunMetadata35Masked {
	obj := &OxmIdTunMetadata35Masked{
		OxmId: NewOxmId(104440),
	}
	return obj
}
func (self *OxmIdTunMetadata35Masked) GetOXMName() string {
	return "tun_metadata35_masked"
}

func (self *OxmIdTunMetadata35Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata36 struct {
	*OxmId
}

type IOxmIdTunMetadata36 interface {
	IOxmId
}

func (self *OxmIdTunMetadata36) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata36(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata36, error) {
	_oxmidtunmetadata36 := &OxmIdTunMetadata36{OxmId: parent}
	return _oxmidtunmetadata36, nil
}

func NewOxmIdTunMetadata36() *OxmIdTunMetadata36 {
	obj := &OxmIdTunMetadata36{
		OxmId: NewOxmId(104572),
	}
	return obj
}
func (self *OxmIdTunMetadata36) GetOXMName() string {
	return "tun_metadata36"
}

func (self *OxmIdTunMetadata36) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata36Masked struct {
	*OxmId
}

type IOxmIdTunMetadata36Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata36Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata36Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata36Masked, error) {
	_oxmidtunmetadata36masked := &OxmIdTunMetadata36Masked{OxmId: parent}
	return _oxmidtunmetadata36masked, nil
}

func NewOxmIdTunMetadata36Masked() *OxmIdTunMetadata36Masked {
	obj := &OxmIdTunMetadata36Masked{
		OxmId: NewOxmId(104952),
	}
	return obj
}
func (self *OxmIdTunMetadata36Masked) GetOXMName() string {
	return "tun_metadata36_masked"
}

func (self *OxmIdTunMetadata36Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata37 struct {
	*OxmId
}

type IOxmIdTunMetadata37 interface {
	IOxmId
}

func (self *OxmIdTunMetadata37) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata37(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata37, error) {
	_oxmidtunmetadata37 := &OxmIdTunMetadata37{OxmId: parent}
	return _oxmidtunmetadata37, nil
}

func NewOxmIdTunMetadata37() *OxmIdTunMetadata37 {
	obj := &OxmIdTunMetadata37{
		OxmId: NewOxmId(105084),
	}
	return obj
}
func (self *OxmIdTunMetadata37) GetOXMName() string {
	return "tun_metadata37"
}

func (self *OxmIdTunMetadata37) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata37Masked struct {
	*OxmId
}

type IOxmIdTunMetadata37Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata37Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata37Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata37Masked, error) {
	_oxmidtunmetadata37masked := &OxmIdTunMetadata37Masked{OxmId: parent}
	return _oxmidtunmetadata37masked, nil
}

func NewOxmIdTunMetadata37Masked() *OxmIdTunMetadata37Masked {
	obj := &OxmIdTunMetadata37Masked{
		OxmId: NewOxmId(105464),
	}
	return obj
}
func (self *OxmIdTunMetadata37Masked) GetOXMName() string {
	return "tun_metadata37_masked"
}

func (self *OxmIdTunMetadata37Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata38 struct {
	*OxmId
}

type IOxmIdTunMetadata38 interface {
	IOxmId
}

func (self *OxmIdTunMetadata38) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata38(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata38, error) {
	_oxmidtunmetadata38 := &OxmIdTunMetadata38{OxmId: parent}
	return _oxmidtunmetadata38, nil
}

func NewOxmIdTunMetadata38() *OxmIdTunMetadata38 {
	obj := &OxmIdTunMetadata38{
		OxmId: NewOxmId(105596),
	}
	return obj
}
func (self *OxmIdTunMetadata38) GetOXMName() string {
	return "tun_metadata38"
}

func (self *OxmIdTunMetadata38) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata38Masked struct {
	*OxmId
}

type IOxmIdTunMetadata38Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata38Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata38Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata38Masked, error) {
	_oxmidtunmetadata38masked := &OxmIdTunMetadata38Masked{OxmId: parent}
	return _oxmidtunmetadata38masked, nil
}

func NewOxmIdTunMetadata38Masked() *OxmIdTunMetadata38Masked {
	obj := &OxmIdTunMetadata38Masked{
		OxmId: NewOxmId(105976),
	}
	return obj
}
func (self *OxmIdTunMetadata38Masked) GetOXMName() string {
	return "tun_metadata38_masked"
}

func (self *OxmIdTunMetadata38Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata39 struct {
	*OxmId
}

type IOxmIdTunMetadata39 interface {
	IOxmId
}

func (self *OxmIdTunMetadata39) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata39(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata39, error) {
	_oxmidtunmetadata39 := &OxmIdTunMetadata39{OxmId: parent}
	return _oxmidtunmetadata39, nil
}

func NewOxmIdTunMetadata39() *OxmIdTunMetadata39 {
	obj := &OxmIdTunMetadata39{
		OxmId: NewOxmId(106108),
	}
	return obj
}
func (self *OxmIdTunMetadata39) GetOXMName() string {
	return "tun_metadata39"
}

func (self *OxmIdTunMetadata39) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata39Masked struct {
	*OxmId
}

type IOxmIdTunMetadata39Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata39Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata39Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata39Masked, error) {
	_oxmidtunmetadata39masked := &OxmIdTunMetadata39Masked{OxmId: parent}
	return _oxmidtunmetadata39masked, nil
}

func NewOxmIdTunMetadata39Masked() *OxmIdTunMetadata39Masked {
	obj := &OxmIdTunMetadata39Masked{
		OxmId: NewOxmId(106488),
	}
	return obj
}
func (self *OxmIdTunMetadata39Masked) GetOXMName() string {
	return "tun_metadata39_masked"
}

func (self *OxmIdTunMetadata39Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata3Masked struct {
	*OxmId
}

type IOxmIdTunMetadata3Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata3Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata3Masked, error) {
	_oxmidtunmetadata3masked := &OxmIdTunMetadata3Masked{OxmId: parent}
	return _oxmidtunmetadata3masked, nil
}

func NewOxmIdTunMetadata3Masked() *OxmIdTunMetadata3Masked {
	obj := &OxmIdTunMetadata3Masked{
		OxmId: NewOxmId(88056),
	}
	return obj
}
func (self *OxmIdTunMetadata3Masked) GetOXMName() string {
	return "tun_metadata3_masked"
}

func (self *OxmIdTunMetadata3Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata4 struct {
	*OxmId
}

type IOxmIdTunMetadata4 interface {
	IOxmId
}

func (self *OxmIdTunMetadata4) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata4, error) {
	_oxmidtunmetadata4 := &OxmIdTunMetadata4{OxmId: parent}
	return _oxmidtunmetadata4, nil
}

func NewOxmIdTunMetadata4() *OxmIdTunMetadata4 {
	obj := &OxmIdTunMetadata4{
		OxmId: NewOxmId(88188),
	}
	return obj
}
func (self *OxmIdTunMetadata4) GetOXMName() string {
	return "tun_metadata4"
}

func (self *OxmIdTunMetadata4) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata40 struct {
	*OxmId
}

type IOxmIdTunMetadata40 interface {
	IOxmId
}

func (self *OxmIdTunMetadata40) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata40(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata40, error) {
	_oxmidtunmetadata40 := &OxmIdTunMetadata40{OxmId: parent}
	return _oxmidtunmetadata40, nil
}

func NewOxmIdTunMetadata40() *OxmIdTunMetadata40 {
	obj := &OxmIdTunMetadata40{
		OxmId: NewOxmId(106620),
	}
	return obj
}
func (self *OxmIdTunMetadata40) GetOXMName() string {
	return "tun_metadata40"
}

func (self *OxmIdTunMetadata40) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata40Masked struct {
	*OxmId
}

type IOxmIdTunMetadata40Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata40Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata40Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata40Masked, error) {
	_oxmidtunmetadata40masked := &OxmIdTunMetadata40Masked{OxmId: parent}
	return _oxmidtunmetadata40masked, nil
}

func NewOxmIdTunMetadata40Masked() *OxmIdTunMetadata40Masked {
	obj := &OxmIdTunMetadata40Masked{
		OxmId: NewOxmId(107000),
	}
	return obj
}
func (self *OxmIdTunMetadata40Masked) GetOXMName() string {
	return "tun_metadata40_masked"
}

func (self *OxmIdTunMetadata40Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata41 struct {
	*OxmId
}

type IOxmIdTunMetadata41 interface {
	IOxmId
}

func (self *OxmIdTunMetadata41) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata41(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata41, error) {
	_oxmidtunmetadata41 := &OxmIdTunMetadata41{OxmId: parent}
	return _oxmidtunmetadata41, nil
}

func NewOxmIdTunMetadata41() *OxmIdTunMetadata41 {
	obj := &OxmIdTunMetadata41{
		OxmId: NewOxmId(107132),
	}
	return obj
}
func (self *OxmIdTunMetadata41) GetOXMName() string {
	return "tun_metadata41"
}

func (self *OxmIdTunMetadata41) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata41Masked struct {
	*OxmId
}

type IOxmIdTunMetadata41Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata41Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata41Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata41Masked, error) {
	_oxmidtunmetadata41masked := &OxmIdTunMetadata41Masked{OxmId: parent}
	return _oxmidtunmetadata41masked, nil
}

func NewOxmIdTunMetadata41Masked() *OxmIdTunMetadata41Masked {
	obj := &OxmIdTunMetadata41Masked{
		OxmId: NewOxmId(107512),
	}
	return obj
}
func (self *OxmIdTunMetadata41Masked) GetOXMName() string {
	return "tun_metadata41_masked"
}

func (self *OxmIdTunMetadata41Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata42 struct {
	*OxmId
}

type IOxmIdTunMetadata42 interface {
	IOxmId
}

func (self *OxmIdTunMetadata42) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata42(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata42, error) {
	_oxmidtunmetadata42 := &OxmIdTunMetadata42{OxmId: parent}
	return _oxmidtunmetadata42, nil
}

func NewOxmIdTunMetadata42() *OxmIdTunMetadata42 {
	obj := &OxmIdTunMetadata42{
		OxmId: NewOxmId(107644),
	}
	return obj
}
func (self *OxmIdTunMetadata42) GetOXMName() string {
	return "tun_metadata42"
}

func (self *OxmIdTunMetadata42) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata42Masked struct {
	*OxmId
}

type IOxmIdTunMetadata42Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata42Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata42Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata42Masked, error) {
	_oxmidtunmetadata42masked := &OxmIdTunMetadata42Masked{OxmId: parent}
	return _oxmidtunmetadata42masked, nil
}

func NewOxmIdTunMetadata42Masked() *OxmIdTunMetadata42Masked {
	obj := &OxmIdTunMetadata42Masked{
		OxmId: NewOxmId(108024),
	}
	return obj
}
func (self *OxmIdTunMetadata42Masked) GetOXMName() string {
	return "tun_metadata42_masked"
}

func (self *OxmIdTunMetadata42Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata43 struct {
	*OxmId
}

type IOxmIdTunMetadata43 interface {
	IOxmId
}

func (self *OxmIdTunMetadata43) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata43(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata43, error) {
	_oxmidtunmetadata43 := &OxmIdTunMetadata43{OxmId: parent}
	return _oxmidtunmetadata43, nil
}

func NewOxmIdTunMetadata43() *OxmIdTunMetadata43 {
	obj := &OxmIdTunMetadata43{
		OxmId: NewOxmId(108156),
	}
	return obj
}
func (self *OxmIdTunMetadata43) GetOXMName() string {
	return "tun_metadata43"
}

func (self *OxmIdTunMetadata43) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata43Masked struct {
	*OxmId
}

type IOxmIdTunMetadata43Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata43Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata43Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata43Masked, error) {
	_oxmidtunmetadata43masked := &OxmIdTunMetadata43Masked{OxmId: parent}
	return _oxmidtunmetadata43masked, nil
}

func NewOxmIdTunMetadata43Masked() *OxmIdTunMetadata43Masked {
	obj := &OxmIdTunMetadata43Masked{
		OxmId: NewOxmId(108536),
	}
	return obj
}
func (self *OxmIdTunMetadata43Masked) GetOXMName() string {
	return "tun_metadata43_masked"
}

func (self *OxmIdTunMetadata43Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata44 struct {
	*OxmId
}

type IOxmIdTunMetadata44 interface {
	IOxmId
}

func (self *OxmIdTunMetadata44) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata44(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata44, error) {
	_oxmidtunmetadata44 := &OxmIdTunMetadata44{OxmId: parent}
	return _oxmidtunmetadata44, nil
}

func NewOxmIdTunMetadata44() *OxmIdTunMetadata44 {
	obj := &OxmIdTunMetadata44{
		OxmId: NewOxmId(108668),
	}
	return obj
}
func (self *OxmIdTunMetadata44) GetOXMName() string {
	return "tun_metadata44"
}

func (self *OxmIdTunMetadata44) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata44Masked struct {
	*OxmId
}

type IOxmIdTunMetadata44Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata44Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata44Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata44Masked, error) {
	_oxmidtunmetadata44masked := &OxmIdTunMetadata44Masked{OxmId: parent}
	return _oxmidtunmetadata44masked, nil
}

func NewOxmIdTunMetadata44Masked() *OxmIdTunMetadata44Masked {
	obj := &OxmIdTunMetadata44Masked{
		OxmId: NewOxmId(109048),
	}
	return obj
}
func (self *OxmIdTunMetadata44Masked) GetOXMName() string {
	return "tun_metadata44_masked"
}

func (self *OxmIdTunMetadata44Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata45 struct {
	*OxmId
}

type IOxmIdTunMetadata45 interface {
	IOxmId
}

func (self *OxmIdTunMetadata45) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata45(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata45, error) {
	_oxmidtunmetadata45 := &OxmIdTunMetadata45{OxmId: parent}
	return _oxmidtunmetadata45, nil
}

func NewOxmIdTunMetadata45() *OxmIdTunMetadata45 {
	obj := &OxmIdTunMetadata45{
		OxmId: NewOxmId(109180),
	}
	return obj
}
func (self *OxmIdTunMetadata45) GetOXMName() string {
	return "tun_metadata45"
}

func (self *OxmIdTunMetadata45) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata45Masked struct {
	*OxmId
}

type IOxmIdTunMetadata45Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata45Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata45Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata45Masked, error) {
	_oxmidtunmetadata45masked := &OxmIdTunMetadata45Masked{OxmId: parent}
	return _oxmidtunmetadata45masked, nil
}

func NewOxmIdTunMetadata45Masked() *OxmIdTunMetadata45Masked {
	obj := &OxmIdTunMetadata45Masked{
		OxmId: NewOxmId(109560),
	}
	return obj
}
func (self *OxmIdTunMetadata45Masked) GetOXMName() string {
	return "tun_metadata45_masked"
}

func (self *OxmIdTunMetadata45Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata46 struct {
	*OxmId
}

type IOxmIdTunMetadata46 interface {
	IOxmId
}

func (self *OxmIdTunMetadata46) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata46(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata46, error) {
	_oxmidtunmetadata46 := &OxmIdTunMetadata46{OxmId: parent}
	return _oxmidtunmetadata46, nil
}

func NewOxmIdTunMetadata46() *OxmIdTunMetadata46 {
	obj := &OxmIdTunMetadata46{
		OxmId: NewOxmId(109692),
	}
	return obj
}
func (self *OxmIdTunMetadata46) GetOXMName() string {
	return "tun_metadata46"
}

func (self *OxmIdTunMetadata46) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata46Masked struct {
	*OxmId
}

type IOxmIdTunMetadata46Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata46Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata46Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata46Masked, error) {
	_oxmidtunmetadata46masked := &OxmIdTunMetadata46Masked{OxmId: parent}
	return _oxmidtunmetadata46masked, nil
}

func NewOxmIdTunMetadata46Masked() *OxmIdTunMetadata46Masked {
	obj := &OxmIdTunMetadata46Masked{
		OxmId: NewOxmId(110072),
	}
	return obj
}
func (self *OxmIdTunMetadata46Masked) GetOXMName() string {
	return "tun_metadata46_masked"
}

func (self *OxmIdTunMetadata46Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata47 struct {
	*OxmId
}

type IOxmIdTunMetadata47 interface {
	IOxmId
}

func (self *OxmIdTunMetadata47) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata47(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata47, error) {
	_oxmidtunmetadata47 := &OxmIdTunMetadata47{OxmId: parent}
	return _oxmidtunmetadata47, nil
}

func NewOxmIdTunMetadata47() *OxmIdTunMetadata47 {
	obj := &OxmIdTunMetadata47{
		OxmId: NewOxmId(110204),
	}
	return obj
}
func (self *OxmIdTunMetadata47) GetOXMName() string {
	return "tun_metadata47"
}

func (self *OxmIdTunMetadata47) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata47Masked struct {
	*OxmId
}

type IOxmIdTunMetadata47Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata47Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata47Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata47Masked, error) {
	_oxmidtunmetadata47masked := &OxmIdTunMetadata47Masked{OxmId: parent}
	return _oxmidtunmetadata47masked, nil
}

func NewOxmIdTunMetadata47Masked() *OxmIdTunMetadata47Masked {
	obj := &OxmIdTunMetadata47Masked{
		OxmId: NewOxmId(110584),
	}
	return obj
}
func (self *OxmIdTunMetadata47Masked) GetOXMName() string {
	return "tun_metadata47_masked"
}

func (self *OxmIdTunMetadata47Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata48 struct {
	*OxmId
}

type IOxmIdTunMetadata48 interface {
	IOxmId
}

func (self *OxmIdTunMetadata48) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata48(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata48, error) {
	_oxmidtunmetadata48 := &OxmIdTunMetadata48{OxmId: parent}
	return _oxmidtunmetadata48, nil
}

func NewOxmIdTunMetadata48() *OxmIdTunMetadata48 {
	obj := &OxmIdTunMetadata48{
		OxmId: NewOxmId(110716),
	}
	return obj
}
func (self *OxmIdTunMetadata48) GetOXMName() string {
	return "tun_metadata48"
}

func (self *OxmIdTunMetadata48) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata48Masked struct {
	*OxmId
}

type IOxmIdTunMetadata48Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata48Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata48Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata48Masked, error) {
	_oxmidtunmetadata48masked := &OxmIdTunMetadata48Masked{OxmId: parent}
	return _oxmidtunmetadata48masked, nil
}

func NewOxmIdTunMetadata48Masked() *OxmIdTunMetadata48Masked {
	obj := &OxmIdTunMetadata48Masked{
		OxmId: NewOxmId(111096),
	}
	return obj
}
func (self *OxmIdTunMetadata48Masked) GetOXMName() string {
	return "tun_metadata48_masked"
}

func (self *OxmIdTunMetadata48Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata49 struct {
	*OxmId
}

type IOxmIdTunMetadata49 interface {
	IOxmId
}

func (self *OxmIdTunMetadata49) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata49(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata49, error) {
	_oxmidtunmetadata49 := &OxmIdTunMetadata49{OxmId: parent}
	return _oxmidtunmetadata49, nil
}

func NewOxmIdTunMetadata49() *OxmIdTunMetadata49 {
	obj := &OxmIdTunMetadata49{
		OxmId: NewOxmId(111228),
	}
	return obj
}
func (self *OxmIdTunMetadata49) GetOXMName() string {
	return "tun_metadata49"
}

func (self *OxmIdTunMetadata49) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata49Masked struct {
	*OxmId
}

type IOxmIdTunMetadata49Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata49Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata49Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata49Masked, error) {
	_oxmidtunmetadata49masked := &OxmIdTunMetadata49Masked{OxmId: parent}
	return _oxmidtunmetadata49masked, nil
}

func NewOxmIdTunMetadata49Masked() *OxmIdTunMetadata49Masked {
	obj := &OxmIdTunMetadata49Masked{
		OxmId: NewOxmId(111608),
	}
	return obj
}
func (self *OxmIdTunMetadata49Masked) GetOXMName() string {
	return "tun_metadata49_masked"
}

func (self *OxmIdTunMetadata49Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata4Masked struct {
	*OxmId
}

type IOxmIdTunMetadata4Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata4Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata4Masked, error) {
	_oxmidtunmetadata4masked := &OxmIdTunMetadata4Masked{OxmId: parent}
	return _oxmidtunmetadata4masked, nil
}

func NewOxmIdTunMetadata4Masked() *OxmIdTunMetadata4Masked {
	obj := &OxmIdTunMetadata4Masked{
		OxmId: NewOxmId(88568),
	}
	return obj
}
func (self *OxmIdTunMetadata4Masked) GetOXMName() string {
	return "tun_metadata4_masked"
}

func (self *OxmIdTunMetadata4Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata5 struct {
	*OxmId
}

type IOxmIdTunMetadata5 interface {
	IOxmId
}

func (self *OxmIdTunMetadata5) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata5, error) {
	_oxmidtunmetadata5 := &OxmIdTunMetadata5{OxmId: parent}
	return _oxmidtunmetadata5, nil
}

func NewOxmIdTunMetadata5() *OxmIdTunMetadata5 {
	obj := &OxmIdTunMetadata5{
		OxmId: NewOxmId(88700),
	}
	return obj
}
func (self *OxmIdTunMetadata5) GetOXMName() string {
	return "tun_metadata5"
}

func (self *OxmIdTunMetadata5) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata50 struct {
	*OxmId
}

type IOxmIdTunMetadata50 interface {
	IOxmId
}

func (self *OxmIdTunMetadata50) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata50(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata50, error) {
	_oxmidtunmetadata50 := &OxmIdTunMetadata50{OxmId: parent}
	return _oxmidtunmetadata50, nil
}

func NewOxmIdTunMetadata50() *OxmIdTunMetadata50 {
	obj := &OxmIdTunMetadata50{
		OxmId: NewOxmId(111740),
	}
	return obj
}
func (self *OxmIdTunMetadata50) GetOXMName() string {
	return "tun_metadata50"
}

func (self *OxmIdTunMetadata50) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata50Masked struct {
	*OxmId
}

type IOxmIdTunMetadata50Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata50Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata50Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata50Masked, error) {
	_oxmidtunmetadata50masked := &OxmIdTunMetadata50Masked{OxmId: parent}
	return _oxmidtunmetadata50masked, nil
}

func NewOxmIdTunMetadata50Masked() *OxmIdTunMetadata50Masked {
	obj := &OxmIdTunMetadata50Masked{
		OxmId: NewOxmId(112120),
	}
	return obj
}
func (self *OxmIdTunMetadata50Masked) GetOXMName() string {
	return "tun_metadata50_masked"
}

func (self *OxmIdTunMetadata50Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata51 struct {
	*OxmId
}

type IOxmIdTunMetadata51 interface {
	IOxmId
}

func (self *OxmIdTunMetadata51) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata51(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata51, error) {
	_oxmidtunmetadata51 := &OxmIdTunMetadata51{OxmId: parent}
	return _oxmidtunmetadata51, nil
}

func NewOxmIdTunMetadata51() *OxmIdTunMetadata51 {
	obj := &OxmIdTunMetadata51{
		OxmId: NewOxmId(112252),
	}
	return obj
}
func (self *OxmIdTunMetadata51) GetOXMName() string {
	return "tun_metadata51"
}

func (self *OxmIdTunMetadata51) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata51Masked struct {
	*OxmId
}

type IOxmIdTunMetadata51Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata51Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata51Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata51Masked, error) {
	_oxmidtunmetadata51masked := &OxmIdTunMetadata51Masked{OxmId: parent}
	return _oxmidtunmetadata51masked, nil
}

func NewOxmIdTunMetadata51Masked() *OxmIdTunMetadata51Masked {
	obj := &OxmIdTunMetadata51Masked{
		OxmId: NewOxmId(112632),
	}
	return obj
}
func (self *OxmIdTunMetadata51Masked) GetOXMName() string {
	return "tun_metadata51_masked"
}

func (self *OxmIdTunMetadata51Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata52 struct {
	*OxmId
}

type IOxmIdTunMetadata52 interface {
	IOxmId
}

func (self *OxmIdTunMetadata52) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata52(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata52, error) {
	_oxmidtunmetadata52 := &OxmIdTunMetadata52{OxmId: parent}
	return _oxmidtunmetadata52, nil
}

func NewOxmIdTunMetadata52() *OxmIdTunMetadata52 {
	obj := &OxmIdTunMetadata52{
		OxmId: NewOxmId(112764),
	}
	return obj
}
func (self *OxmIdTunMetadata52) GetOXMName() string {
	return "tun_metadata52"
}

func (self *OxmIdTunMetadata52) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata52Masked struct {
	*OxmId
}

type IOxmIdTunMetadata52Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata52Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata52Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata52Masked, error) {
	_oxmidtunmetadata52masked := &OxmIdTunMetadata52Masked{OxmId: parent}
	return _oxmidtunmetadata52masked, nil
}

func NewOxmIdTunMetadata52Masked() *OxmIdTunMetadata52Masked {
	obj := &OxmIdTunMetadata52Masked{
		OxmId: NewOxmId(113144),
	}
	return obj
}
func (self *OxmIdTunMetadata52Masked) GetOXMName() string {
	return "tun_metadata52_masked"
}

func (self *OxmIdTunMetadata52Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata53 struct {
	*OxmId
}

type IOxmIdTunMetadata53 interface {
	IOxmId
}

func (self *OxmIdTunMetadata53) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata53(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata53, error) {
	_oxmidtunmetadata53 := &OxmIdTunMetadata53{OxmId: parent}
	return _oxmidtunmetadata53, nil
}

func NewOxmIdTunMetadata53() *OxmIdTunMetadata53 {
	obj := &OxmIdTunMetadata53{
		OxmId: NewOxmId(113276),
	}
	return obj
}
func (self *OxmIdTunMetadata53) GetOXMName() string {
	return "tun_metadata53"
}

func (self *OxmIdTunMetadata53) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata53Masked struct {
	*OxmId
}

type IOxmIdTunMetadata53Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata53Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata53Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata53Masked, error) {
	_oxmidtunmetadata53masked := &OxmIdTunMetadata53Masked{OxmId: parent}
	return _oxmidtunmetadata53masked, nil
}

func NewOxmIdTunMetadata53Masked() *OxmIdTunMetadata53Masked {
	obj := &OxmIdTunMetadata53Masked{
		OxmId: NewOxmId(113656),
	}
	return obj
}
func (self *OxmIdTunMetadata53Masked) GetOXMName() string {
	return "tun_metadata53_masked"
}

func (self *OxmIdTunMetadata53Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata54 struct {
	*OxmId
}

type IOxmIdTunMetadata54 interface {
	IOxmId
}

func (self *OxmIdTunMetadata54) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata54(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata54, error) {
	_oxmidtunmetadata54 := &OxmIdTunMetadata54{OxmId: parent}
	return _oxmidtunmetadata54, nil
}

func NewOxmIdTunMetadata54() *OxmIdTunMetadata54 {
	obj := &OxmIdTunMetadata54{
		OxmId: NewOxmId(113788),
	}
	return obj
}
func (self *OxmIdTunMetadata54) GetOXMName() string {
	return "tun_metadata54"
}

func (self *OxmIdTunMetadata54) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata54Masked struct {
	*OxmId
}

type IOxmIdTunMetadata54Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata54Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata54Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata54Masked, error) {
	_oxmidtunmetadata54masked := &OxmIdTunMetadata54Masked{OxmId: parent}
	return _oxmidtunmetadata54masked, nil
}

func NewOxmIdTunMetadata54Masked() *OxmIdTunMetadata54Masked {
	obj := &OxmIdTunMetadata54Masked{
		OxmId: NewOxmId(114168),
	}
	return obj
}
func (self *OxmIdTunMetadata54Masked) GetOXMName() string {
	return "tun_metadata54_masked"
}

func (self *OxmIdTunMetadata54Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata55 struct {
	*OxmId
}

type IOxmIdTunMetadata55 interface {
	IOxmId
}

func (self *OxmIdTunMetadata55) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata55(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata55, error) {
	_oxmidtunmetadata55 := &OxmIdTunMetadata55{OxmId: parent}
	return _oxmidtunmetadata55, nil
}

func NewOxmIdTunMetadata55() *OxmIdTunMetadata55 {
	obj := &OxmIdTunMetadata55{
		OxmId: NewOxmId(114300),
	}
	return obj
}
func (self *OxmIdTunMetadata55) GetOXMName() string {
	return "tun_metadata55"
}

func (self *OxmIdTunMetadata55) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata55Masked struct {
	*OxmId
}

type IOxmIdTunMetadata55Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata55Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata55Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata55Masked, error) {
	_oxmidtunmetadata55masked := &OxmIdTunMetadata55Masked{OxmId: parent}
	return _oxmidtunmetadata55masked, nil
}

func NewOxmIdTunMetadata55Masked() *OxmIdTunMetadata55Masked {
	obj := &OxmIdTunMetadata55Masked{
		OxmId: NewOxmId(114680),
	}
	return obj
}
func (self *OxmIdTunMetadata55Masked) GetOXMName() string {
	return "tun_metadata55_masked"
}

func (self *OxmIdTunMetadata55Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata56 struct {
	*OxmId
}

type IOxmIdTunMetadata56 interface {
	IOxmId
}

func (self *OxmIdTunMetadata56) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata56(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata56, error) {
	_oxmidtunmetadata56 := &OxmIdTunMetadata56{OxmId: parent}
	return _oxmidtunmetadata56, nil
}

func NewOxmIdTunMetadata56() *OxmIdTunMetadata56 {
	obj := &OxmIdTunMetadata56{
		OxmId: NewOxmId(114812),
	}
	return obj
}
func (self *OxmIdTunMetadata56) GetOXMName() string {
	return "tun_metadata56"
}

func (self *OxmIdTunMetadata56) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata56Masked struct {
	*OxmId
}

type IOxmIdTunMetadata56Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata56Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata56Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata56Masked, error) {
	_oxmidtunmetadata56masked := &OxmIdTunMetadata56Masked{OxmId: parent}
	return _oxmidtunmetadata56masked, nil
}

func NewOxmIdTunMetadata56Masked() *OxmIdTunMetadata56Masked {
	obj := &OxmIdTunMetadata56Masked{
		OxmId: NewOxmId(115192),
	}
	return obj
}
func (self *OxmIdTunMetadata56Masked) GetOXMName() string {
	return "tun_metadata56_masked"
}

func (self *OxmIdTunMetadata56Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata57 struct {
	*OxmId
}

type IOxmIdTunMetadata57 interface {
	IOxmId
}

func (self *OxmIdTunMetadata57) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata57(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata57, error) {
	_oxmidtunmetadata57 := &OxmIdTunMetadata57{OxmId: parent}
	return _oxmidtunmetadata57, nil
}

func NewOxmIdTunMetadata57() *OxmIdTunMetadata57 {
	obj := &OxmIdTunMetadata57{
		OxmId: NewOxmId(115324),
	}
	return obj
}
func (self *OxmIdTunMetadata57) GetOXMName() string {
	return "tun_metadata57"
}

func (self *OxmIdTunMetadata57) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata57Masked struct {
	*OxmId
}

type IOxmIdTunMetadata57Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata57Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata57Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata57Masked, error) {
	_oxmidtunmetadata57masked := &OxmIdTunMetadata57Masked{OxmId: parent}
	return _oxmidtunmetadata57masked, nil
}

func NewOxmIdTunMetadata57Masked() *OxmIdTunMetadata57Masked {
	obj := &OxmIdTunMetadata57Masked{
		OxmId: NewOxmId(115704),
	}
	return obj
}
func (self *OxmIdTunMetadata57Masked) GetOXMName() string {
	return "tun_metadata57_masked"
}

func (self *OxmIdTunMetadata57Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata58 struct {
	*OxmId
}

type IOxmIdTunMetadata58 interface {
	IOxmId
}

func (self *OxmIdTunMetadata58) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata58(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata58, error) {
	_oxmidtunmetadata58 := &OxmIdTunMetadata58{OxmId: parent}
	return _oxmidtunmetadata58, nil
}

func NewOxmIdTunMetadata58() *OxmIdTunMetadata58 {
	obj := &OxmIdTunMetadata58{
		OxmId: NewOxmId(115836),
	}
	return obj
}
func (self *OxmIdTunMetadata58) GetOXMName() string {
	return "tun_metadata58"
}

func (self *OxmIdTunMetadata58) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata58Masked struct {
	*OxmId
}

type IOxmIdTunMetadata58Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata58Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata58Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata58Masked, error) {
	_oxmidtunmetadata58masked := &OxmIdTunMetadata58Masked{OxmId: parent}
	return _oxmidtunmetadata58masked, nil
}

func NewOxmIdTunMetadata58Masked() *OxmIdTunMetadata58Masked {
	obj := &OxmIdTunMetadata58Masked{
		OxmId: NewOxmId(116216),
	}
	return obj
}
func (self *OxmIdTunMetadata58Masked) GetOXMName() string {
	return "tun_metadata58_masked"
}

func (self *OxmIdTunMetadata58Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata59 struct {
	*OxmId
}

type IOxmIdTunMetadata59 interface {
	IOxmId
}

func (self *OxmIdTunMetadata59) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata59(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata59, error) {
	_oxmidtunmetadata59 := &OxmIdTunMetadata59{OxmId: parent}
	return _oxmidtunmetadata59, nil
}

func NewOxmIdTunMetadata59() *OxmIdTunMetadata59 {
	obj := &OxmIdTunMetadata59{
		OxmId: NewOxmId(116348),
	}
	return obj
}
func (self *OxmIdTunMetadata59) GetOXMName() string {
	return "tun_metadata59"
}

func (self *OxmIdTunMetadata59) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata59Masked struct {
	*OxmId
}

type IOxmIdTunMetadata59Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata59Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata59Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata59Masked, error) {
	_oxmidtunmetadata59masked := &OxmIdTunMetadata59Masked{OxmId: parent}
	return _oxmidtunmetadata59masked, nil
}

func NewOxmIdTunMetadata59Masked() *OxmIdTunMetadata59Masked {
	obj := &OxmIdTunMetadata59Masked{
		OxmId: NewOxmId(116728),
	}
	return obj
}
func (self *OxmIdTunMetadata59Masked) GetOXMName() string {
	return "tun_metadata59_masked"
}

func (self *OxmIdTunMetadata59Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata5Masked struct {
	*OxmId
}

type IOxmIdTunMetadata5Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata5Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata5Masked, error) {
	_oxmidtunmetadata5masked := &OxmIdTunMetadata5Masked{OxmId: parent}
	return _oxmidtunmetadata5masked, nil
}

func NewOxmIdTunMetadata5Masked() *OxmIdTunMetadata5Masked {
	obj := &OxmIdTunMetadata5Masked{
		OxmId: NewOxmId(89080),
	}
	return obj
}
func (self *OxmIdTunMetadata5Masked) GetOXMName() string {
	return "tun_metadata5_masked"
}

func (self *OxmIdTunMetadata5Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata6 struct {
	*OxmId
}

type IOxmIdTunMetadata6 interface {
	IOxmId
}

func (self *OxmIdTunMetadata6) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata6, error) {
	_oxmidtunmetadata6 := &OxmIdTunMetadata6{OxmId: parent}
	return _oxmidtunmetadata6, nil
}

func NewOxmIdTunMetadata6() *OxmIdTunMetadata6 {
	obj := &OxmIdTunMetadata6{
		OxmId: NewOxmId(89212),
	}
	return obj
}
func (self *OxmIdTunMetadata6) GetOXMName() string {
	return "tun_metadata6"
}

func (self *OxmIdTunMetadata6) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata60 struct {
	*OxmId
}

type IOxmIdTunMetadata60 interface {
	IOxmId
}

func (self *OxmIdTunMetadata60) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata60(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata60, error) {
	_oxmidtunmetadata60 := &OxmIdTunMetadata60{OxmId: parent}
	return _oxmidtunmetadata60, nil
}

func NewOxmIdTunMetadata60() *OxmIdTunMetadata60 {
	obj := &OxmIdTunMetadata60{
		OxmId: NewOxmId(116860),
	}
	return obj
}
func (self *OxmIdTunMetadata60) GetOXMName() string {
	return "tun_metadata60"
}

func (self *OxmIdTunMetadata60) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata60Masked struct {
	*OxmId
}

type IOxmIdTunMetadata60Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata60Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata60Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata60Masked, error) {
	_oxmidtunmetadata60masked := &OxmIdTunMetadata60Masked{OxmId: parent}
	return _oxmidtunmetadata60masked, nil
}

func NewOxmIdTunMetadata60Masked() *OxmIdTunMetadata60Masked {
	obj := &OxmIdTunMetadata60Masked{
		OxmId: NewOxmId(117240),
	}
	return obj
}
func (self *OxmIdTunMetadata60Masked) GetOXMName() string {
	return "tun_metadata60_masked"
}

func (self *OxmIdTunMetadata60Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata61 struct {
	*OxmId
}

type IOxmIdTunMetadata61 interface {
	IOxmId
}

func (self *OxmIdTunMetadata61) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata61(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata61, error) {
	_oxmidtunmetadata61 := &OxmIdTunMetadata61{OxmId: parent}
	return _oxmidtunmetadata61, nil
}

func NewOxmIdTunMetadata61() *OxmIdTunMetadata61 {
	obj := &OxmIdTunMetadata61{
		OxmId: NewOxmId(117372),
	}
	return obj
}
func (self *OxmIdTunMetadata61) GetOXMName() string {
	return "tun_metadata61"
}

func (self *OxmIdTunMetadata61) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata61Masked struct {
	*OxmId
}

type IOxmIdTunMetadata61Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata61Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata61Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata61Masked, error) {
	_oxmidtunmetadata61masked := &OxmIdTunMetadata61Masked{OxmId: parent}
	return _oxmidtunmetadata61masked, nil
}

func NewOxmIdTunMetadata61Masked() *OxmIdTunMetadata61Masked {
	obj := &OxmIdTunMetadata61Masked{
		OxmId: NewOxmId(117752),
	}
	return obj
}
func (self *OxmIdTunMetadata61Masked) GetOXMName() string {
	return "tun_metadata61_masked"
}

func (self *OxmIdTunMetadata61Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata62 struct {
	*OxmId
}

type IOxmIdTunMetadata62 interface {
	IOxmId
}

func (self *OxmIdTunMetadata62) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata62(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata62, error) {
	_oxmidtunmetadata62 := &OxmIdTunMetadata62{OxmId: parent}
	return _oxmidtunmetadata62, nil
}

func NewOxmIdTunMetadata62() *OxmIdTunMetadata62 {
	obj := &OxmIdTunMetadata62{
		OxmId: NewOxmId(117884),
	}
	return obj
}
func (self *OxmIdTunMetadata62) GetOXMName() string {
	return "tun_metadata62"
}

func (self *OxmIdTunMetadata62) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata62Masked struct {
	*OxmId
}

type IOxmIdTunMetadata62Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata62Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata62Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata62Masked, error) {
	_oxmidtunmetadata62masked := &OxmIdTunMetadata62Masked{OxmId: parent}
	return _oxmidtunmetadata62masked, nil
}

func NewOxmIdTunMetadata62Masked() *OxmIdTunMetadata62Masked {
	obj := &OxmIdTunMetadata62Masked{
		OxmId: NewOxmId(118264),
	}
	return obj
}
func (self *OxmIdTunMetadata62Masked) GetOXMName() string {
	return "tun_metadata62_masked"
}

func (self *OxmIdTunMetadata62Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata63 struct {
	*OxmId
}

type IOxmIdTunMetadata63 interface {
	IOxmId
}

func (self *OxmIdTunMetadata63) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata63(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata63, error) {
	_oxmidtunmetadata63 := &OxmIdTunMetadata63{OxmId: parent}
	return _oxmidtunmetadata63, nil
}

func NewOxmIdTunMetadata63() *OxmIdTunMetadata63 {
	obj := &OxmIdTunMetadata63{
		OxmId: NewOxmId(118396),
	}
	return obj
}
func (self *OxmIdTunMetadata63) GetOXMName() string {
	return "tun_metadata63"
}

func (self *OxmIdTunMetadata63) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata63Masked struct {
	*OxmId
}

type IOxmIdTunMetadata63Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata63Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata63Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata63Masked, error) {
	_oxmidtunmetadata63masked := &OxmIdTunMetadata63Masked{OxmId: parent}
	return _oxmidtunmetadata63masked, nil
}

func NewOxmIdTunMetadata63Masked() *OxmIdTunMetadata63Masked {
	obj := &OxmIdTunMetadata63Masked{
		OxmId: NewOxmId(118776),
	}
	return obj
}
func (self *OxmIdTunMetadata63Masked) GetOXMName() string {
	return "tun_metadata63_masked"
}

func (self *OxmIdTunMetadata63Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata6Masked struct {
	*OxmId
}

type IOxmIdTunMetadata6Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata6Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata6Masked, error) {
	_oxmidtunmetadata6masked := &OxmIdTunMetadata6Masked{OxmId: parent}
	return _oxmidtunmetadata6masked, nil
}

func NewOxmIdTunMetadata6Masked() *OxmIdTunMetadata6Masked {
	obj := &OxmIdTunMetadata6Masked{
		OxmId: NewOxmId(89592),
	}
	return obj
}
func (self *OxmIdTunMetadata6Masked) GetOXMName() string {
	return "tun_metadata6_masked"
}

func (self *OxmIdTunMetadata6Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata7 struct {
	*OxmId
}

type IOxmIdTunMetadata7 interface {
	IOxmId
}

func (self *OxmIdTunMetadata7) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata7, error) {
	_oxmidtunmetadata7 := &OxmIdTunMetadata7{OxmId: parent}
	return _oxmidtunmetadata7, nil
}

func NewOxmIdTunMetadata7() *OxmIdTunMetadata7 {
	obj := &OxmIdTunMetadata7{
		OxmId: NewOxmId(89724),
	}
	return obj
}
func (self *OxmIdTunMetadata7) GetOXMName() string {
	return "tun_metadata7"
}

func (self *OxmIdTunMetadata7) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata7Masked struct {
	*OxmId
}

type IOxmIdTunMetadata7Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata7Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata7Masked, error) {
	_oxmidtunmetadata7masked := &OxmIdTunMetadata7Masked{OxmId: parent}
	return _oxmidtunmetadata7masked, nil
}

func NewOxmIdTunMetadata7Masked() *OxmIdTunMetadata7Masked {
	obj := &OxmIdTunMetadata7Masked{
		OxmId: NewOxmId(90104),
	}
	return obj
}
func (self *OxmIdTunMetadata7Masked) GetOXMName() string {
	return "tun_metadata7_masked"
}

func (self *OxmIdTunMetadata7Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata8 struct {
	*OxmId
}

type IOxmIdTunMetadata8 interface {
	IOxmId
}

func (self *OxmIdTunMetadata8) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata8(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata8, error) {
	_oxmidtunmetadata8 := &OxmIdTunMetadata8{OxmId: parent}
	return _oxmidtunmetadata8, nil
}

func NewOxmIdTunMetadata8() *OxmIdTunMetadata8 {
	obj := &OxmIdTunMetadata8{
		OxmId: NewOxmId(90236),
	}
	return obj
}
func (self *OxmIdTunMetadata8) GetOXMName() string {
	return "tun_metadata8"
}

func (self *OxmIdTunMetadata8) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata8Masked struct {
	*OxmId
}

type IOxmIdTunMetadata8Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata8Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata8Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata8Masked, error) {
	_oxmidtunmetadata8masked := &OxmIdTunMetadata8Masked{OxmId: parent}
	return _oxmidtunmetadata8masked, nil
}

func NewOxmIdTunMetadata8Masked() *OxmIdTunMetadata8Masked {
	obj := &OxmIdTunMetadata8Masked{
		OxmId: NewOxmId(90616),
	}
	return obj
}
func (self *OxmIdTunMetadata8Masked) GetOXMName() string {
	return "tun_metadata8_masked"
}

func (self *OxmIdTunMetadata8Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata9 struct {
	*OxmId
}

type IOxmIdTunMetadata9 interface {
	IOxmId
}

func (self *OxmIdTunMetadata9) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata9(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata9, error) {
	_oxmidtunmetadata9 := &OxmIdTunMetadata9{OxmId: parent}
	return _oxmidtunmetadata9, nil
}

func NewOxmIdTunMetadata9() *OxmIdTunMetadata9 {
	obj := &OxmIdTunMetadata9{
		OxmId: NewOxmId(90748),
	}
	return obj
}
func (self *OxmIdTunMetadata9) GetOXMName() string {
	return "tun_metadata9"
}

func (self *OxmIdTunMetadata9) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunMetadata9Masked struct {
	*OxmId
}

type IOxmIdTunMetadata9Masked interface {
	IOxmId
}

func (self *OxmIdTunMetadata9Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunMetadata9Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata9Masked, error) {
	_oxmidtunmetadata9masked := &OxmIdTunMetadata9Masked{OxmId: parent}
	return _oxmidtunmetadata9masked, nil
}

func NewOxmIdTunMetadata9Masked() *OxmIdTunMetadata9Masked {
	obj := &OxmIdTunMetadata9Masked{
		OxmId: NewOxmId(91128),
	}
	return obj
}
func (self *OxmIdTunMetadata9Masked) GetOXMName() string {
	return "tun_metadata9_masked"
}

func (self *OxmIdTunMetadata9Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunSrc struct {
	*OxmId
}

type IOxmIdTunSrc interface {
	IOxmId
}

func (self *OxmIdTunSrc) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunSrc, error) {
	_oxmidtunsrc := &OxmIdTunSrc{OxmId: parent}
	return _oxmidtunsrc, nil
}

func NewOxmIdTunSrc() *OxmIdTunSrc {
	obj := &OxmIdTunSrc{
		OxmId: NewOxmId(81412),
	}
	return obj
}
func (self *OxmIdTunSrc) GetOXMName() string {
	return "tun_src"
}

func (self *OxmIdTunSrc) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunSrcMasked struct {
	*OxmId
}

type IOxmIdTunSrcMasked interface {
	IOxmId
}

func (self *OxmIdTunSrcMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunSrcMasked, error) {
	_oxmidtunsrcmasked := &OxmIdTunSrcMasked{OxmId: parent}
	return _oxmidtunsrcmasked, nil
}

func NewOxmIdTunSrcMasked() *OxmIdTunSrcMasked {
	obj := &OxmIdTunSrcMasked{
		OxmId: NewOxmId(81672),
	}
	return obj
}
func (self *OxmIdTunSrcMasked) GetOXMName() string {
	return "tun_src_masked"
}

func (self *OxmIdTunSrcMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdUdpDst struct {
	*OxmId
}

type IOxmIdUdpDst interface {
	IOxmId
}

func (self *OxmIdUdpDst) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdUdpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpDst, error) {
	_oxmidudpdst := &OxmIdUdpDst{OxmId: parent}
	return _oxmidudpdst, nil
}

func NewOxmIdUdpDst() *OxmIdUdpDst {
	obj := &OxmIdUdpDst{
		OxmId: NewOxmId(6146),
	}
	return obj
}
func (self *OxmIdUdpDst) GetOXMName() string {
	return "udp_dst"
}

func (self *OxmIdUdpDst) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdUdpDstMasked struct {
	*OxmId
}

type IOxmIdUdpDstMasked interface {
	IOxmId
}

func (self *OxmIdUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdUdpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpDstMasked, error) {
	_oxmidudpdstmasked := &OxmIdUdpDstMasked{OxmId: parent}
	return _oxmidudpdstmasked, nil
}

func NewOxmIdUdpDstMasked() *OxmIdUdpDstMasked {
	obj := &OxmIdUdpDstMasked{
		OxmId: NewOxmId(6404),
	}
	return obj
}
func (self *OxmIdUdpDstMasked) GetOXMName() string {
	return "udp_dst_masked"
}

func (self *OxmIdUdpDstMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdUdpSrc struct {
	*OxmId
}

type IOxmIdUdpSrc interface {
	IOxmId
}

func (self *OxmIdUdpSrc) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdUdpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpSrc, error) {
	_oxmidudpsrc := &OxmIdUdpSrc{OxmId: parent}
	return _oxmidudpsrc, nil
}

func NewOxmIdUdpSrc() *OxmIdUdpSrc {
	obj := &OxmIdUdpSrc{
		OxmId: NewOxmId(5634),
	}
	return obj
}
func (self *OxmIdUdpSrc) GetOXMName() string {
	return "udp_src"
}

func (self *OxmIdUdpSrc) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdUdpSrcMasked struct {
	*OxmId
}

type IOxmIdUdpSrcMasked interface {
	IOxmId
}

func (self *OxmIdUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdUdpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpSrcMasked, error) {
	_oxmidudpsrcmasked := &OxmIdUdpSrcMasked{OxmId: parent}
	return _oxmidudpsrcmasked, nil
}

func NewOxmIdUdpSrcMasked() *OxmIdUdpSrcMasked {
	obj := &OxmIdUdpSrcMasked{
		OxmId: NewOxmId(5892),
	}
	return obj
}
func (self *OxmIdUdpSrcMasked) GetOXMName() string {
	return "udp_src_masked"
}

func (self *OxmIdUdpSrcMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdVlanTci struct {
	*OxmId
}

type IOxmIdVlanTci interface {
	IOxmId
}

func (self *OxmIdVlanTci) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdVlanTci(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanTci, error) {
	_oxmidvlantci := &OxmIdVlanTci{OxmId: parent}
	return _oxmidvlantci, nil
}

func NewOxmIdVlanTci() *OxmIdVlanTci {
	obj := &OxmIdVlanTci{
		OxmId: NewOxmId(2050),
	}
	return obj
}
func (self *OxmIdVlanTci) GetOXMName() string {
	return "vlan_tci"
}

func (self *OxmIdVlanTci) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdVlanTciMasked struct {
	*OxmId
}

type IOxmIdVlanTciMasked interface {
	IOxmId
}

func (self *OxmIdVlanTciMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdVlanTciMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanTciMasked, error) {
	_oxmidvlantcimasked := &OxmIdVlanTciMasked{OxmId: parent}
	return _oxmidvlantcimasked, nil
}

func NewOxmIdVlanTciMasked() *OxmIdVlanTciMasked {
	obj := &OxmIdVlanTciMasked{
		OxmId: NewOxmId(2308),
	}
	return obj
}
func (self *OxmIdVlanTciMasked) GetOXMName() string {
	return "vlan_tci_masked"
}

func (self *OxmIdVlanTciMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdXxreg0 struct {
	*OxmId
}

type IOxmIdXxreg0 interface {
	IOxmId
}

func (self *OxmIdXxreg0) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdXxreg0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg0, error) {
	_oxmidxxreg0 := &OxmIdXxreg0{OxmId: parent}
	return _oxmidxxreg0, nil
}

func NewOxmIdXxreg0() *OxmIdXxreg0 {
	obj := &OxmIdXxreg0{
		OxmId: NewOxmId(122384),
	}
	return obj
}
func (self *OxmIdXxreg0) GetOXMName() string {
	return "xxreg0"
}

func (self *OxmIdXxreg0) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdXxreg0Masked struct {
	*OxmId
}

type IOxmIdXxreg0Masked interface {
	IOxmId
}

func (self *OxmIdXxreg0Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdXxreg0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg0Masked, error) {
	_oxmidxxreg0masked := &OxmIdXxreg0Masked{OxmId: parent}
	return _oxmidxxreg0masked, nil
}

func NewOxmIdXxreg0Masked() *OxmIdXxreg0Masked {
	obj := &OxmIdXxreg0Masked{
		OxmId: NewOxmId(122656),
	}
	return obj
}
func (self *OxmIdXxreg0Masked) GetOXMName() string {
	return "xxreg0_masked"
}

func (self *OxmIdXxreg0Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdXxreg1 struct {
	*OxmId
}

type IOxmIdXxreg1 interface {
	IOxmId
}

func (self *OxmIdXxreg1) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdXxreg1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg1, error) {
	_oxmidxxreg1 := &OxmIdXxreg1{OxmId: parent}
	return _oxmidxxreg1, nil
}

func NewOxmIdXxreg1() *OxmIdXxreg1 {
	obj := &OxmIdXxreg1{
		OxmId: NewOxmId(122896),
	}
	return obj
}
func (self *OxmIdXxreg1) GetOXMName() string {
	return "xxreg1"
}

func (self *OxmIdXxreg1) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdXxreg1Masked struct {
	*OxmId
}

type IOxmIdXxreg1Masked interface {
	IOxmId
}

func (self *OxmIdXxreg1Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdXxreg1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg1Masked, error) {
	_oxmidxxreg1masked := &OxmIdXxreg1Masked{OxmId: parent}
	return _oxmidxxreg1masked, nil
}

func NewOxmIdXxreg1Masked() *OxmIdXxreg1Masked {
	obj := &OxmIdXxreg1Masked{
		OxmId: NewOxmId(123168),
	}
	return obj
}
func (self *OxmIdXxreg1Masked) GetOXMName() string {
	return "xxreg1_masked"
}

func (self *OxmIdXxreg1Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdXxreg2 struct {
	*OxmId
}

type IOxmIdXxreg2 interface {
	IOxmId
}

func (self *OxmIdXxreg2) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdXxreg2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg2, error) {
	_oxmidxxreg2 := &OxmIdXxreg2{OxmId: parent}
	return _oxmidxxreg2, nil
}

func NewOxmIdXxreg2() *OxmIdXxreg2 {
	obj := &OxmIdXxreg2{
		OxmId: NewOxmId(123408),
	}
	return obj
}
func (self *OxmIdXxreg2) GetOXMName() string {
	return "xxreg2"
}

func (self *OxmIdXxreg2) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdXxreg2Masked struct {
	*OxmId
}

type IOxmIdXxreg2Masked interface {
	IOxmId
}

func (self *OxmIdXxreg2Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdXxreg2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg2Masked, error) {
	_oxmidxxreg2masked := &OxmIdXxreg2Masked{OxmId: parent}
	return _oxmidxxreg2masked, nil
}

func NewOxmIdXxreg2Masked() *OxmIdXxreg2Masked {
	obj := &OxmIdXxreg2Masked{
		OxmId: NewOxmId(123680),
	}
	return obj
}
func (self *OxmIdXxreg2Masked) GetOXMName() string {
	return "xxreg2_masked"
}

func (self *OxmIdXxreg2Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdXxreg3 struct {
	*OxmId
}

type IOxmIdXxreg3 interface {
	IOxmId
}

func (self *OxmIdXxreg3) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdXxreg3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg3, error) {
	_oxmidxxreg3 := &OxmIdXxreg3{OxmId: parent}
	return _oxmidxxreg3, nil
}

func NewOxmIdXxreg3() *OxmIdXxreg3 {
	obj := &OxmIdXxreg3{
		OxmId: NewOxmId(123920),
	}
	return obj
}
func (self *OxmIdXxreg3) GetOXMName() string {
	return "xxreg3"
}

func (self *OxmIdXxreg3) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdXxreg3Masked struct {
	*OxmId
}

type IOxmIdXxreg3Masked interface {
	IOxmId
}

func (self *OxmIdXxreg3Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdXxreg3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg3Masked, error) {
	_oxmidxxreg3masked := &OxmIdXxreg3Masked{OxmId: parent}
	return _oxmidxxreg3masked, nil
}

func NewOxmIdXxreg3Masked() *OxmIdXxreg3Masked {
	obj := &OxmIdXxreg3Masked{
		OxmId: NewOxmId(124192),
	}
	return obj
}
func (self *OxmIdXxreg3Masked) GetOXMName() string {
	return "xxreg3_masked"
}

func (self *OxmIdXxreg3Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdArpOpMasked struct {
	*OxmId
}

type IOxmIdArpOpMasked interface {
	IOxmId
}

func (self *OxmIdArpOpMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdArpOpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpOpMasked, error) {
	_oxmidarpopmasked := &OxmIdArpOpMasked{OxmId: parent}
	return _oxmidarpopmasked, nil
}

func NewOxmIdArpOpMasked() *OxmIdArpOpMasked {
	obj := &OxmIdArpOpMasked{
		OxmId: NewOxmId(2147494660),
	}
	return obj
}
func (self *OxmIdArpOpMasked) GetOXMName() string {
	return "arp_op_masked"
}

func (self *OxmIdArpOpMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingIpv6Dst struct {
	*OxmId
}

type IOxmIdConnTrackingIpv6Dst interface {
	IOxmId
}

func (self *OxmIdConnTrackingIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6Dst, error) {
	_oxmidconntrackingipv6dst := &OxmIdConnTrackingIpv6Dst{OxmId: parent}
	return _oxmidconntrackingipv6dst, nil
}

func NewOxmIdConnTrackingIpv6Dst() *OxmIdConnTrackingIpv6Dst {
	obj := &OxmIdConnTrackingIpv6Dst{
		OxmId: NewOxmId(128528),
	}
	return obj
}
func (self *OxmIdConnTrackingIpv6Dst) GetOXMName() string {
	return "conn_tracking_ipv6_dst"
}

func (self *OxmIdConnTrackingIpv6Dst) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingIpv6DstMasked struct {
	*OxmId
}

type IOxmIdConnTrackingIpv6DstMasked interface {
	IOxmId
}

func (self *OxmIdConnTrackingIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6DstMasked, error) {
	_oxmidconntrackingipv6dstmasked := &OxmIdConnTrackingIpv6DstMasked{OxmId: parent}
	return _oxmidconntrackingipv6dstmasked, nil
}

func NewOxmIdConnTrackingIpv6DstMasked() *OxmIdConnTrackingIpv6DstMasked {
	obj := &OxmIdConnTrackingIpv6DstMasked{
		OxmId: NewOxmId(128800),
	}
	return obj
}
func (self *OxmIdConnTrackingIpv6DstMasked) GetOXMName() string {
	return "conn_tracking_ipv6_dst_masked"
}

func (self *OxmIdConnTrackingIpv6DstMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingIpv6Src struct {
	*OxmId
}

type IOxmIdConnTrackingIpv6Src interface {
	IOxmId
}

func (self *OxmIdConnTrackingIpv6Src) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6Src, error) {
	_oxmidconntrackingipv6src := &OxmIdConnTrackingIpv6Src{OxmId: parent}
	return _oxmidconntrackingipv6src, nil
}

func NewOxmIdConnTrackingIpv6Src() *OxmIdConnTrackingIpv6Src {
	obj := &OxmIdConnTrackingIpv6Src{
		OxmId: NewOxmId(128016),
	}
	return obj
}
func (self *OxmIdConnTrackingIpv6Src) GetOXMName() string {
	return "conn_tracking_ipv6_src"
}

func (self *OxmIdConnTrackingIpv6Src) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingIpv6SrcMasked struct {
	*OxmId
}

type IOxmIdConnTrackingIpv6SrcMasked interface {
	IOxmId
}

func (self *OxmIdConnTrackingIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6SrcMasked, error) {
	_oxmidconntrackingipv6srcmasked := &OxmIdConnTrackingIpv6SrcMasked{OxmId: parent}
	return _oxmidconntrackingipv6srcmasked, nil
}

func NewOxmIdConnTrackingIpv6SrcMasked() *OxmIdConnTrackingIpv6SrcMasked {
	obj := &OxmIdConnTrackingIpv6SrcMasked{
		OxmId: NewOxmId(128288),
	}
	return obj
}
func (self *OxmIdConnTrackingIpv6SrcMasked) GetOXMName() string {
	return "conn_tracking_ipv6_src_masked"
}

func (self *OxmIdConnTrackingIpv6SrcMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingLabel struct {
	*OxmId
}

type IOxmIdConnTrackingLabel interface {
	IOxmId
}

func (self *OxmIdConnTrackingLabel) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingLabel, error) {
	_oxmidconntrackinglabel := &OxmIdConnTrackingLabel{OxmId: parent}
	return _oxmidconntrackinglabel, nil
}

func NewOxmIdConnTrackingLabel() *OxmIdConnTrackingLabel {
	obj := &OxmIdConnTrackingLabel{
		OxmId: NewOxmId(120848),
	}
	return obj
}
func (self *OxmIdConnTrackingLabel) GetOXMName() string {
	return "conn_tracking_label"
}

func (self *OxmIdConnTrackingLabel) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingLabelMasked struct {
	*OxmId
}

type IOxmIdConnTrackingLabelMasked interface {
	IOxmId
}

func (self *OxmIdConnTrackingLabelMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingLabelMasked, error) {
	_oxmidconntrackinglabelmasked := &OxmIdConnTrackingLabelMasked{OxmId: parent}
	return _oxmidconntrackinglabelmasked, nil
}

func NewOxmIdConnTrackingLabelMasked() *OxmIdConnTrackingLabelMasked {
	obj := &OxmIdConnTrackingLabelMasked{
		OxmId: NewOxmId(121120),
	}
	return obj
}
func (self *OxmIdConnTrackingLabelMasked) GetOXMName() string {
	return "conn_tracking_label_masked"
}

func (self *OxmIdConnTrackingLabelMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingMark struct {
	*OxmId
}

type IOxmIdConnTrackingMark interface {
	IOxmId
}

func (self *OxmIdConnTrackingMark) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingMark, error) {
	_oxmidconntrackingmark := &OxmIdConnTrackingMark{OxmId: parent}
	return _oxmidconntrackingmark, nil
}

func NewOxmIdConnTrackingMark() *OxmIdConnTrackingMark {
	obj := &OxmIdConnTrackingMark{
		OxmId: NewOxmId(120324),
	}
	return obj
}
func (self *OxmIdConnTrackingMark) GetOXMName() string {
	return "conn_tracking_mark"
}

func (self *OxmIdConnTrackingMark) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingMarkMasked struct {
	*OxmId
}

type IOxmIdConnTrackingMarkMasked interface {
	IOxmId
}

func (self *OxmIdConnTrackingMarkMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingMarkMasked, error) {
	_oxmidconntrackingmarkmasked := &OxmIdConnTrackingMarkMasked{OxmId: parent}
	return _oxmidconntrackingmarkmasked, nil
}

func NewOxmIdConnTrackingMarkMasked() *OxmIdConnTrackingMarkMasked {
	obj := &OxmIdConnTrackingMarkMasked{
		OxmId: NewOxmId(120584),
	}
	return obj
}
func (self *OxmIdConnTrackingMarkMasked) GetOXMName() string {
	return "conn_tracking_mark_masked"
}

func (self *OxmIdConnTrackingMarkMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingNwDst struct {
	*OxmId
}

type IOxmIdConnTrackingNwDst interface {
	IOxmId
}

func (self *OxmIdConnTrackingNwDst) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingNwDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwDst, error) {
	_oxmidconntrackingnwdst := &OxmIdConnTrackingNwDst{OxmId: parent}
	return _oxmidconntrackingnwdst, nil
}

func NewOxmIdConnTrackingNwDst() *OxmIdConnTrackingNwDst {
	obj := &OxmIdConnTrackingNwDst{
		OxmId: NewOxmId(127492),
	}
	return obj
}
func (self *OxmIdConnTrackingNwDst) GetOXMName() string {
	return "conn_tracking_nw_dst"
}

func (self *OxmIdConnTrackingNwDst) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingNwDstMasked struct {
	*OxmId
}

type IOxmIdConnTrackingNwDstMasked interface {
	IOxmId
}

func (self *OxmIdConnTrackingNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingNwDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwDstMasked, error) {
	_oxmidconntrackingnwdstmasked := &OxmIdConnTrackingNwDstMasked{OxmId: parent}
	return _oxmidconntrackingnwdstmasked, nil
}

func NewOxmIdConnTrackingNwDstMasked() *OxmIdConnTrackingNwDstMasked {
	obj := &OxmIdConnTrackingNwDstMasked{
		OxmId: NewOxmId(127752),
	}
	return obj
}
func (self *OxmIdConnTrackingNwDstMasked) GetOXMName() string {
	return "conn_tracking_nw_dst_masked"
}

func (self *OxmIdConnTrackingNwDstMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingNwProto struct {
	*OxmId
}

type IOxmIdConnTrackingNwProto interface {
	IOxmId
}

func (self *OxmIdConnTrackingNwProto) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwProto, error) {
	_oxmidconntrackingnwproto := &OxmIdConnTrackingNwProto{OxmId: parent}
	return _oxmidconntrackingnwproto, nil
}

func NewOxmIdConnTrackingNwProto() *OxmIdConnTrackingNwProto {
	obj := &OxmIdConnTrackingNwProto{
		OxmId: NewOxmId(126465),
	}
	return obj
}
func (self *OxmIdConnTrackingNwProto) GetOXMName() string {
	return "conn_tracking_nw_proto"
}

func (self *OxmIdConnTrackingNwProto) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingNwProtoMasked struct {
	*OxmId
}

type IOxmIdConnTrackingNwProtoMasked interface {
	IOxmId
}

func (self *OxmIdConnTrackingNwProtoMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingNwProtoMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwProtoMasked, error) {
	_oxmidconntrackingnwprotomasked := &OxmIdConnTrackingNwProtoMasked{OxmId: parent}
	return _oxmidconntrackingnwprotomasked, nil
}

func NewOxmIdConnTrackingNwProtoMasked() *OxmIdConnTrackingNwProtoMasked {
	obj := &OxmIdConnTrackingNwProtoMasked{
		OxmId: NewOxmId(126722),
	}
	return obj
}
func (self *OxmIdConnTrackingNwProtoMasked) GetOXMName() string {
	return "conn_tracking_nw_proto_masked"
}

func (self *OxmIdConnTrackingNwProtoMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingNwSrc struct {
	*OxmId
}

type IOxmIdConnTrackingNwSrc interface {
	IOxmId
}

func (self *OxmIdConnTrackingNwSrc) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingNwSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwSrc, error) {
	_oxmidconntrackingnwsrc := &OxmIdConnTrackingNwSrc{OxmId: parent}
	return _oxmidconntrackingnwsrc, nil
}

func NewOxmIdConnTrackingNwSrc() *OxmIdConnTrackingNwSrc {
	obj := &OxmIdConnTrackingNwSrc{
		OxmId: NewOxmId(126980),
	}
	return obj
}
func (self *OxmIdConnTrackingNwSrc) GetOXMName() string {
	return "conn_tracking_nw_src"
}

func (self *OxmIdConnTrackingNwSrc) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingNwSrcMasked struct {
	*OxmId
}

type IOxmIdConnTrackingNwSrcMasked interface {
	IOxmId
}

func (self *OxmIdConnTrackingNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingNwSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwSrcMasked, error) {
	_oxmidconntrackingnwsrcmasked := &OxmIdConnTrackingNwSrcMasked{OxmId: parent}
	return _oxmidconntrackingnwsrcmasked, nil
}

func NewOxmIdConnTrackingNwSrcMasked() *OxmIdConnTrackingNwSrcMasked {
	obj := &OxmIdConnTrackingNwSrcMasked{
		OxmId: NewOxmId(127240),
	}
	return obj
}
func (self *OxmIdConnTrackingNwSrcMasked) GetOXMName() string {
	return "conn_tracking_nw_src_masked"
}

func (self *OxmIdConnTrackingNwSrcMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingState struct {
	*OxmId
}

type IOxmIdConnTrackingState interface {
	IOxmId
}

func (self *OxmIdConnTrackingState) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingState(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingState, error) {
	_oxmidconntrackingstate := &OxmIdConnTrackingState{OxmId: parent}
	return _oxmidconntrackingstate, nil
}

func NewOxmIdConnTrackingState() *OxmIdConnTrackingState {
	obj := &OxmIdConnTrackingState{
		OxmId: NewOxmId(119300),
	}
	return obj
}
func (self *OxmIdConnTrackingState) GetOXMName() string {
	return "conn_tracking_state"
}

func (self *OxmIdConnTrackingState) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingStateMasked struct {
	*OxmId
}

type IOxmIdConnTrackingStateMasked interface {
	IOxmId
}

func (self *OxmIdConnTrackingStateMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingStateMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingStateMasked, error) {
	_oxmidconntrackingstatemasked := &OxmIdConnTrackingStateMasked{OxmId: parent}
	return _oxmidconntrackingstatemasked, nil
}

func NewOxmIdConnTrackingStateMasked() *OxmIdConnTrackingStateMasked {
	obj := &OxmIdConnTrackingStateMasked{
		OxmId: NewOxmId(119560),
	}
	return obj
}
func (self *OxmIdConnTrackingStateMasked) GetOXMName() string {
	return "conn_tracking_state_masked"
}

func (self *OxmIdConnTrackingStateMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingTpDst struct {
	*OxmId
}

type IOxmIdConnTrackingTpDst interface {
	IOxmId
}

func (self *OxmIdConnTrackingTpDst) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingTpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpDst, error) {
	_oxmidconntrackingtpdst := &OxmIdConnTrackingTpDst{OxmId: parent}
	return _oxmidconntrackingtpdst, nil
}

func NewOxmIdConnTrackingTpDst() *OxmIdConnTrackingTpDst {
	obj := &OxmIdConnTrackingTpDst{
		OxmId: NewOxmId(129538),
	}
	return obj
}
func (self *OxmIdConnTrackingTpDst) GetOXMName() string {
	return "conn_tracking_tp_dst"
}

func (self *OxmIdConnTrackingTpDst) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingTpDstMasked struct {
	*OxmId
}

type IOxmIdConnTrackingTpDstMasked interface {
	IOxmId
}

func (self *OxmIdConnTrackingTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingTpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpDstMasked, error) {
	_oxmidconntrackingtpdstmasked := &OxmIdConnTrackingTpDstMasked{OxmId: parent}
	return _oxmidconntrackingtpdstmasked, nil
}

func NewOxmIdConnTrackingTpDstMasked() *OxmIdConnTrackingTpDstMasked {
	obj := &OxmIdConnTrackingTpDstMasked{
		OxmId: NewOxmId(129796),
	}
	return obj
}
func (self *OxmIdConnTrackingTpDstMasked) GetOXMName() string {
	return "conn_tracking_tp_dst_masked"
}

func (self *OxmIdConnTrackingTpDstMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingTpSrc struct {
	*OxmId
}

type IOxmIdConnTrackingTpSrc interface {
	IOxmId
}

func (self *OxmIdConnTrackingTpSrc) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingTpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpSrc, error) {
	_oxmidconntrackingtpsrc := &OxmIdConnTrackingTpSrc{OxmId: parent}
	return _oxmidconntrackingtpsrc, nil
}

func NewOxmIdConnTrackingTpSrc() *OxmIdConnTrackingTpSrc {
	obj := &OxmIdConnTrackingTpSrc{
		OxmId: NewOxmId(129026),
	}
	return obj
}
func (self *OxmIdConnTrackingTpSrc) GetOXMName() string {
	return "conn_tracking_tp_src"
}

func (self *OxmIdConnTrackingTpSrc) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingTpSrcMasked struct {
	*OxmId
}

type IOxmIdConnTrackingTpSrcMasked interface {
	IOxmId
}

func (self *OxmIdConnTrackingTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingTpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpSrcMasked, error) {
	_oxmidconntrackingtpsrcmasked := &OxmIdConnTrackingTpSrcMasked{OxmId: parent}
	return _oxmidconntrackingtpsrcmasked, nil
}

func NewOxmIdConnTrackingTpSrcMasked() *OxmIdConnTrackingTpSrcMasked {
	obj := &OxmIdConnTrackingTpSrcMasked{
		OxmId: NewOxmId(129284),
	}
	return obj
}
func (self *OxmIdConnTrackingTpSrcMasked) GetOXMName() string {
	return "conn_tracking_tp_src_masked"
}

func (self *OxmIdConnTrackingTpSrcMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingZone struct {
	*OxmId
}

type IOxmIdConnTrackingZone interface {
	IOxmId
}

func (self *OxmIdConnTrackingZone) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingZone(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingZone, error) {
	_oxmidconntrackingzone := &OxmIdConnTrackingZone{OxmId: parent}
	return _oxmidconntrackingzone, nil
}

func NewOxmIdConnTrackingZone() *OxmIdConnTrackingZone {
	obj := &OxmIdConnTrackingZone{
		OxmId: NewOxmId(119810),
	}
	return obj
}
func (self *OxmIdConnTrackingZone) GetOXMName() string {
	return "conn_tracking_zone"
}

func (self *OxmIdConnTrackingZone) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdConnTrackingZoneMasked struct {
	*OxmId
}

type IOxmIdConnTrackingZoneMasked interface {
	IOxmId
}

func (self *OxmIdConnTrackingZoneMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdConnTrackingZoneMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingZoneMasked, error) {
	_oxmidconntrackingzonemasked := &OxmIdConnTrackingZoneMasked{OxmId: parent}
	return _oxmidconntrackingzonemasked, nil
}

func NewOxmIdConnTrackingZoneMasked() *OxmIdConnTrackingZoneMasked {
	obj := &OxmIdConnTrackingZoneMasked{
		OxmId: NewOxmId(120068),
	}
	return obj
}
func (self *OxmIdConnTrackingZoneMasked) GetOXMName() string {
	return "conn_tracking_zone_masked"
}

func (self *OxmIdConnTrackingZoneMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdEthTypeMasked struct {
	*OxmId
}

type IOxmIdEthTypeMasked interface {
	IOxmId
}

func (self *OxmIdEthTypeMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdEthTypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthTypeMasked, error) {
	_oxmidethtypemasked := &OxmIdEthTypeMasked{OxmId: parent}
	return _oxmidethtypemasked, nil
}

func NewOxmIdEthTypeMasked() *OxmIdEthTypeMasked {
	obj := &OxmIdEthTypeMasked{
		OxmId: NewOxmId(2147486468),
	}
	return obj
}
func (self *OxmIdEthTypeMasked) GetOXMName() string {
	return "eth_type_masked"
}

func (self *OxmIdEthTypeMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIcmpv4Code struct {
	*OxmId
}

type IOxmIdIcmpv4Code interface {
	IOxmId
}

func (self *OxmIdIcmpv4Code) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIcmpv4Code(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4Code, error) {
	_oxmidicmpv4code := &OxmIdIcmpv4Code{OxmId: parent}
	return _oxmidicmpv4code, nil
}

func NewOxmIdIcmpv4Code() *OxmIdIcmpv4Code {
	obj := &OxmIdIcmpv4Code{
		OxmId: NewOxmId(2147493889),
	}
	return obj
}
func (self *OxmIdIcmpv4Code) GetOXMName() string {
	return "icmpv4_code"
}

func (self *OxmIdIcmpv4Code) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIcmpv4CodeMasked struct {
	*OxmId
}

type IOxmIdIcmpv4CodeMasked interface {
	IOxmId
}

func (self *OxmIdIcmpv4CodeMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIcmpv4CodeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4CodeMasked, error) {
	_oxmidicmpv4codemasked := &OxmIdIcmpv4CodeMasked{OxmId: parent}
	return _oxmidicmpv4codemasked, nil
}

func NewOxmIdIcmpv4CodeMasked() *OxmIdIcmpv4CodeMasked {
	obj := &OxmIdIcmpv4CodeMasked{
		OxmId: NewOxmId(2147494146),
	}
	return obj
}
func (self *OxmIdIcmpv4CodeMasked) GetOXMName() string {
	return "icmpv4_code_masked"
}

func (self *OxmIdIcmpv4CodeMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIcmpv4Type struct {
	*OxmId
}

type IOxmIdIcmpv4Type interface {
	IOxmId
}

func (self *OxmIdIcmpv4Type) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIcmpv4Type(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4Type, error) {
	_oxmidicmpv4type := &OxmIdIcmpv4Type{OxmId: parent}
	return _oxmidicmpv4type, nil
}

func NewOxmIdIcmpv4Type() *OxmIdIcmpv4Type {
	obj := &OxmIdIcmpv4Type{
		OxmId: NewOxmId(2147493377),
	}
	return obj
}
func (self *OxmIdIcmpv4Type) GetOXMName() string {
	return "icmpv4_type"
}

func (self *OxmIdIcmpv4Type) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIcmpv4TypeMasked struct {
	*OxmId
}

type IOxmIdIcmpv4TypeMasked interface {
	IOxmId
}

func (self *OxmIdIcmpv4TypeMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIcmpv4TypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4TypeMasked, error) {
	_oxmidicmpv4typemasked := &OxmIdIcmpv4TypeMasked{OxmId: parent}
	return _oxmidicmpv4typemasked, nil
}

func NewOxmIdIcmpv4TypeMasked() *OxmIdIcmpv4TypeMasked {
	obj := &OxmIdIcmpv4TypeMasked{
		OxmId: NewOxmId(2147493634),
	}
	return obj
}
func (self *OxmIdIcmpv4TypeMasked) GetOXMName() string {
	return "icmpv4_type_masked"
}

func (self *OxmIdIcmpv4TypeMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIcmpv6CodeMasked struct {
	*OxmId
}

type IOxmIdIcmpv6CodeMasked interface {
	IOxmId
}

func (self *OxmIdIcmpv6CodeMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIcmpv6CodeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6CodeMasked, error) {
	_oxmidicmpv6codemasked := &OxmIdIcmpv6CodeMasked{OxmId: parent}
	return _oxmidicmpv6codemasked, nil
}

func NewOxmIdIcmpv6CodeMasked() *OxmIdIcmpv6CodeMasked {
	obj := &OxmIdIcmpv6CodeMasked{
		OxmId: NewOxmId(2147499266),
	}
	return obj
}
func (self *OxmIdIcmpv6CodeMasked) GetOXMName() string {
	return "icmpv6_code_masked"
}

func (self *OxmIdIcmpv6CodeMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIcmpv6TypeMasked struct {
	*OxmId
}

type IOxmIdIcmpv6TypeMasked interface {
	IOxmId
}

func (self *OxmIdIcmpv6TypeMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIcmpv6TypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6TypeMasked, error) {
	_oxmidicmpv6typemasked := &OxmIdIcmpv6TypeMasked{OxmId: parent}
	return _oxmidicmpv6typemasked, nil
}

func NewOxmIdIcmpv6TypeMasked() *OxmIdIcmpv6TypeMasked {
	obj := &OxmIdIcmpv6TypeMasked{
		OxmId: NewOxmId(2147498754),
	}
	return obj
}
func (self *OxmIdIcmpv6TypeMasked) GetOXMName() string {
	return "icmpv6_type_masked"
}

func (self *OxmIdIcmpv6TypeMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdInPhyPort struct {
	*OxmId
}

type IOxmIdInPhyPort interface {
	IOxmId
}

func (self *OxmIdInPhyPort) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdInPhyPort(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPhyPort, error) {
	_oxmidinphyport := &OxmIdInPhyPort{OxmId: parent}
	return _oxmidinphyport, nil
}

func NewOxmIdInPhyPort() *OxmIdInPhyPort {
	obj := &OxmIdInPhyPort{
		OxmId: NewOxmId(2147484164),
	}
	return obj
}
func (self *OxmIdInPhyPort) GetOXMName() string {
	return "in_phy_port"
}

func (self *OxmIdInPhyPort) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdInPhyPortMasked struct {
	*OxmId
}

type IOxmIdInPhyPortMasked interface {
	IOxmId
}

func (self *OxmIdInPhyPortMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdInPhyPortMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPhyPortMasked, error) {
	_oxmidinphyportmasked := &OxmIdInPhyPortMasked{OxmId: parent}
	return _oxmidinphyportmasked, nil
}

func NewOxmIdInPhyPortMasked() *OxmIdInPhyPortMasked {
	obj := &OxmIdInPhyPortMasked{
		OxmId: NewOxmId(2147484424),
	}
	return obj
}
func (self *OxmIdInPhyPortMasked) GetOXMName() string {
	return "in_phy_port_masked"
}

func (self *OxmIdInPhyPortMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdInPortMasked struct {
	*OxmId
}

type IOxmIdInPortMasked interface {
	IOxmId
}

func (self *OxmIdInPortMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdInPortMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPortMasked, error) {
	_oxmidinportmasked := &OxmIdInPortMasked{OxmId: parent}
	return _oxmidinportmasked, nil
}

func NewOxmIdInPortMasked() *OxmIdInPortMasked {
	obj := &OxmIdInPortMasked{
		OxmId: NewOxmId(2147483912),
	}
	return obj
}
func (self *OxmIdInPortMasked) GetOXMName() string {
	return "in_port_masked"
}

func (self *OxmIdInPortMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpDscp struct {
	*OxmId
}

type IOxmIdIpDscp interface {
	IOxmId
}

func (self *OxmIdIpDscp) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpDscp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDscp, error) {
	_oxmidipdscp := &OxmIdIpDscp{OxmId: parent}
	return _oxmidipdscp, nil
}

func NewOxmIdIpDscp() *OxmIdIpDscp {
	obj := &OxmIdIpDscp{
		OxmId: NewOxmId(2147487745),
	}
	return obj
}
func (self *OxmIdIpDscp) GetOXMName() string {
	return "ip_dscp"
}

func (self *OxmIdIpDscp) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpDscpMasked struct {
	*OxmId
}

type IOxmIdIpDscpMasked interface {
	IOxmId
}

func (self *OxmIdIpDscpMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpDscpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDscpMasked, error) {
	_oxmidipdscpmasked := &OxmIdIpDscpMasked{OxmId: parent}
	return _oxmidipdscpmasked, nil
}

func NewOxmIdIpDscpMasked() *OxmIdIpDscpMasked {
	obj := &OxmIdIpDscpMasked{
		OxmId: NewOxmId(2147488002),
	}
	return obj
}
func (self *OxmIdIpDscpMasked) GetOXMName() string {
	return "ip_dscp_masked"
}

func (self *OxmIdIpDscpMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpEcn struct {
	*OxmId
}

type IOxmIdIpEcn interface {
	IOxmId
}

func (self *OxmIdIpEcn) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpEcn(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpEcn, error) {
	_oxmidipecn := &OxmIdIpEcn{OxmId: parent}
	return _oxmidipecn, nil
}

func NewOxmIdIpEcn() *OxmIdIpEcn {
	obj := &OxmIdIpEcn{
		OxmId: NewOxmId(2147488257),
	}
	return obj
}
func (self *OxmIdIpEcn) GetOXMName() string {
	return "ip_ecn"
}

func (self *OxmIdIpEcn) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpEcnMasked struct {
	*OxmId
}

type IOxmIdIpEcnMasked interface {
	IOxmId
}

func (self *OxmIdIpEcnMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpEcnMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpEcnMasked, error) {
	_oxmidipecnmasked := &OxmIdIpEcnMasked{OxmId: parent}
	return _oxmidipecnmasked, nil
}

func NewOxmIdIpEcnMasked() *OxmIdIpEcnMasked {
	obj := &OxmIdIpEcnMasked{
		OxmId: NewOxmId(2147488514),
	}
	return obj
}
func (self *OxmIdIpEcnMasked) GetOXMName() string {
	return "ip_ecn_masked"
}

func (self *OxmIdIpEcnMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpProto struct {
	*OxmId
}

type IOxmIdIpProto interface {
	IOxmId
}

func (self *OxmIdIpProto) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpProto, error) {
	_oxmidipproto := &OxmIdIpProto{OxmId: parent}
	return _oxmidipproto, nil
}

func NewOxmIdIpProto() *OxmIdIpProto {
	obj := &OxmIdIpProto{
		OxmId: NewOxmId(2147488769),
	}
	return obj
}
func (self *OxmIdIpProto) GetOXMName() string {
	return "ip_proto"
}

func (self *OxmIdIpProto) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpProtoMasked struct {
	*OxmId
}

type IOxmIdIpProtoMasked interface {
	IOxmId
}

func (self *OxmIdIpProtoMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpProtoMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpProtoMasked, error) {
	_oxmidipprotomasked := &OxmIdIpProtoMasked{OxmId: parent}
	return _oxmidipprotomasked, nil
}

func NewOxmIdIpProtoMasked() *OxmIdIpProtoMasked {
	obj := &OxmIdIpProtoMasked{
		OxmId: NewOxmId(2147489026),
	}
	return obj
}
func (self *OxmIdIpProtoMasked) GetOXMName() string {
	return "ip_proto_masked"
}

func (self *OxmIdIpProtoMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpv4Dst struct {
	*OxmId
}

type IOxmIdIpv4Dst interface {
	IOxmId
}

func (self *OxmIdIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpv4Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4Dst, error) {
	_oxmidipv4dst := &OxmIdIpv4Dst{OxmId: parent}
	return _oxmidipv4dst, nil
}

func NewOxmIdIpv4Dst() *OxmIdIpv4Dst {
	obj := &OxmIdIpv4Dst{
		OxmId: NewOxmId(2147489796),
	}
	return obj
}
func (self *OxmIdIpv4Dst) GetOXMName() string {
	return "ipv4_dst"
}

func (self *OxmIdIpv4Dst) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpv4DstMasked struct {
	*OxmId
}

type IOxmIdIpv4DstMasked interface {
	IOxmId
}

func (self *OxmIdIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpv4DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4DstMasked, error) {
	_oxmidipv4dstmasked := &OxmIdIpv4DstMasked{OxmId: parent}
	return _oxmidipv4dstmasked, nil
}

func NewOxmIdIpv4DstMasked() *OxmIdIpv4DstMasked {
	obj := &OxmIdIpv4DstMasked{
		OxmId: NewOxmId(2147490056),
	}
	return obj
}
func (self *OxmIdIpv4DstMasked) GetOXMName() string {
	return "ipv4_dst_masked"
}

func (self *OxmIdIpv4DstMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpv4Src struct {
	*OxmId
}

type IOxmIdIpv4Src interface {
	IOxmId
}

func (self *OxmIdIpv4Src) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpv4Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4Src, error) {
	_oxmidipv4src := &OxmIdIpv4Src{OxmId: parent}
	return _oxmidipv4src, nil
}

func NewOxmIdIpv4Src() *OxmIdIpv4Src {
	obj := &OxmIdIpv4Src{
		OxmId: NewOxmId(2147489284),
	}
	return obj
}
func (self *OxmIdIpv4Src) GetOXMName() string {
	return "ipv4_src"
}

func (self *OxmIdIpv4Src) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpv4SrcMasked struct {
	*OxmId
}

type IOxmIdIpv4SrcMasked interface {
	IOxmId
}

func (self *OxmIdIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpv4SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4SrcMasked, error) {
	_oxmidipv4srcmasked := &OxmIdIpv4SrcMasked{OxmId: parent}
	return _oxmidipv4srcmasked, nil
}

func NewOxmIdIpv4SrcMasked() *OxmIdIpv4SrcMasked {
	obj := &OxmIdIpv4SrcMasked{
		OxmId: NewOxmId(2147489544),
	}
	return obj
}
func (self *OxmIdIpv4SrcMasked) GetOXMName() string {
	return "ipv4_src_masked"
}

func (self *OxmIdIpv4SrcMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpv6Flabel struct {
	*OxmId
}

type IOxmIdIpv6Flabel interface {
	IOxmId
}

func (self *OxmIdIpv6Flabel) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpv6Flabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Flabel, error) {
	_oxmidipv6flabel := &OxmIdIpv6Flabel{OxmId: parent}
	return _oxmidipv6flabel, nil
}

func NewOxmIdIpv6Flabel() *OxmIdIpv6Flabel {
	obj := &OxmIdIpv6Flabel{
		OxmId: NewOxmId(2147497988),
	}
	return obj
}
func (self *OxmIdIpv6Flabel) GetOXMName() string {
	return "ipv6_flabel"
}

func (self *OxmIdIpv6Flabel) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpv6FlabelMasked struct {
	*OxmId
}

type IOxmIdIpv6FlabelMasked interface {
	IOxmId
}

func (self *OxmIdIpv6FlabelMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpv6FlabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6FlabelMasked, error) {
	_oxmidipv6flabelmasked := &OxmIdIpv6FlabelMasked{OxmId: parent}
	return _oxmidipv6flabelmasked, nil
}

func NewOxmIdIpv6FlabelMasked() *OxmIdIpv6FlabelMasked {
	obj := &OxmIdIpv6FlabelMasked{
		OxmId: NewOxmId(2147498248),
	}
	return obj
}
func (self *OxmIdIpv6FlabelMasked) GetOXMName() string {
	return "ipv6_flabel_masked"
}

func (self *OxmIdIpv6FlabelMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpv6NdSll struct {
	*OxmId
}

type IOxmIdIpv6NdSll interface {
	IOxmId
}

func (self *OxmIdIpv6NdSll) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpv6NdSll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdSll, error) {
	_oxmidipv6ndsll := &OxmIdIpv6NdSll{OxmId: parent}
	return _oxmidipv6ndsll, nil
}

func NewOxmIdIpv6NdSll() *OxmIdIpv6NdSll {
	obj := &OxmIdIpv6NdSll{
		OxmId: NewOxmId(2147500038),
	}
	return obj
}
func (self *OxmIdIpv6NdSll) GetOXMName() string {
	return "ipv6_nd_sll"
}

func (self *OxmIdIpv6NdSll) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpv6NdSllMasked struct {
	*OxmId
}

type IOxmIdIpv6NdSllMasked interface {
	IOxmId
}

func (self *OxmIdIpv6NdSllMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpv6NdSllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdSllMasked, error) {
	_oxmidipv6ndsllmasked := &OxmIdIpv6NdSllMasked{OxmId: parent}
	return _oxmidipv6ndsllmasked, nil
}

func NewOxmIdIpv6NdSllMasked() *OxmIdIpv6NdSllMasked {
	obj := &OxmIdIpv6NdSllMasked{
		OxmId: NewOxmId(2147500300),
	}
	return obj
}
func (self *OxmIdIpv6NdSllMasked) GetOXMName() string {
	return "ipv6_nd_sll_masked"
}

func (self *OxmIdIpv6NdSllMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpv6NdTarget struct {
	*OxmId
}

type IOxmIdIpv6NdTarget interface {
	IOxmId
}

func (self *OxmIdIpv6NdTarget) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpv6NdTarget(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTarget, error) {
	_oxmidipv6ndtarget := &OxmIdIpv6NdTarget{OxmId: parent}
	return _oxmidipv6ndtarget, nil
}

func NewOxmIdIpv6NdTarget() *OxmIdIpv6NdTarget {
	obj := &OxmIdIpv6NdTarget{
		OxmId: NewOxmId(2147499536),
	}
	return obj
}
func (self *OxmIdIpv6NdTarget) GetOXMName() string {
	return "ipv6_nd_target"
}

func (self *OxmIdIpv6NdTarget) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpv6NdTargetMasked struct {
	*OxmId
}

type IOxmIdIpv6NdTargetMasked interface {
	IOxmId
}

func (self *OxmIdIpv6NdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpv6NdTargetMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTargetMasked, error) {
	_oxmidipv6ndtargetmasked := &OxmIdIpv6NdTargetMasked{OxmId: parent}
	return _oxmidipv6ndtargetmasked, nil
}

func NewOxmIdIpv6NdTargetMasked() *OxmIdIpv6NdTargetMasked {
	obj := &OxmIdIpv6NdTargetMasked{
		OxmId: NewOxmId(2147499808),
	}
	return obj
}
func (self *OxmIdIpv6NdTargetMasked) GetOXMName() string {
	return "ipv6_nd_target_masked"
}

func (self *OxmIdIpv6NdTargetMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpv6NdTll struct {
	*OxmId
}

type IOxmIdIpv6NdTll interface {
	IOxmId
}

func (self *OxmIdIpv6NdTll) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpv6NdTll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTll, error) {
	_oxmidipv6ndtll := &OxmIdIpv6NdTll{OxmId: parent}
	return _oxmidipv6ndtll, nil
}

func NewOxmIdIpv6NdTll() *OxmIdIpv6NdTll {
	obj := &OxmIdIpv6NdTll{
		OxmId: NewOxmId(2147500550),
	}
	return obj
}
func (self *OxmIdIpv6NdTll) GetOXMName() string {
	return "ipv6_nd_tll"
}

func (self *OxmIdIpv6NdTll) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpv6NdTllMasked struct {
	*OxmId
}

type IOxmIdIpv6NdTllMasked interface {
	IOxmId
}

func (self *OxmIdIpv6NdTllMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpv6NdTllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTllMasked, error) {
	_oxmidipv6ndtllmasked := &OxmIdIpv6NdTllMasked{OxmId: parent}
	return _oxmidipv6ndtllmasked, nil
}

func NewOxmIdIpv6NdTllMasked() *OxmIdIpv6NdTllMasked {
	obj := &OxmIdIpv6NdTllMasked{
		OxmId: NewOxmId(2147500812),
	}
	return obj
}
func (self *OxmIdIpv6NdTllMasked) GetOXMName() string {
	return "ipv6_nd_tll_masked"
}

func (self *OxmIdIpv6NdTllMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdMetadata struct {
	*OxmId
}

type IOxmIdMetadata interface {
	IOxmId
}

func (self *OxmIdMetadata) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdMetadata(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMetadata, error) {
	_oxmidmetadata := &OxmIdMetadata{OxmId: parent}
	return _oxmidmetadata, nil
}

func NewOxmIdMetadata() *OxmIdMetadata {
	obj := &OxmIdMetadata{
		OxmId: NewOxmId(2147484680),
	}
	return obj
}
func (self *OxmIdMetadata) GetOXMName() string {
	return "metadata"
}

func (self *OxmIdMetadata) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdMetadataMasked struct {
	*OxmId
}

type IOxmIdMetadataMasked interface {
	IOxmId
}

func (self *OxmIdMetadataMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdMetadataMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMetadataMasked, error) {
	_oxmidmetadatamasked := &OxmIdMetadataMasked{OxmId: parent}
	return _oxmidmetadatamasked, nil
}

func NewOxmIdMetadataMasked() *OxmIdMetadataMasked {
	obj := &OxmIdMetadataMasked{
		OxmId: NewOxmId(2147484944),
	}
	return obj
}
func (self *OxmIdMetadataMasked) GetOXMName() string {
	return "metadata_masked"
}

func (self *OxmIdMetadataMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdMplsLabel struct {
	*OxmId
}

type IOxmIdMplsLabel interface {
	IOxmId
}

func (self *OxmIdMplsLabel) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdMplsLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsLabel, error) {
	_oxmidmplslabel := &OxmIdMplsLabel{OxmId: parent}
	return _oxmidmplslabel, nil
}

func NewOxmIdMplsLabel() *OxmIdMplsLabel {
	obj := &OxmIdMplsLabel{
		OxmId: NewOxmId(2147501060),
	}
	return obj
}
func (self *OxmIdMplsLabel) GetOXMName() string {
	return "mpls_label"
}

func (self *OxmIdMplsLabel) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdMplsLabelMasked struct {
	*OxmId
}

type IOxmIdMplsLabelMasked interface {
	IOxmId
}

func (self *OxmIdMplsLabelMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdMplsLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsLabelMasked, error) {
	_oxmidmplslabelmasked := &OxmIdMplsLabelMasked{OxmId: parent}
	return _oxmidmplslabelmasked, nil
}

func NewOxmIdMplsLabelMasked() *OxmIdMplsLabelMasked {
	obj := &OxmIdMplsLabelMasked{
		OxmId: NewOxmId(2147501320),
	}
	return obj
}
func (self *OxmIdMplsLabelMasked) GetOXMName() string {
	return "mpls_label_masked"
}

func (self *OxmIdMplsLabelMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdMplsTc struct {
	*OxmId
}

type IOxmIdMplsTc interface {
	IOxmId
}

func (self *OxmIdMplsTc) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdMplsTc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTc, error) {
	_oxmidmplstc := &OxmIdMplsTc{OxmId: parent}
	return _oxmidmplstc, nil
}

func NewOxmIdMplsTc() *OxmIdMplsTc {
	obj := &OxmIdMplsTc{
		OxmId: NewOxmId(2147501569),
	}
	return obj
}
func (self *OxmIdMplsTc) GetOXMName() string {
	return "mpls_tc"
}

func (self *OxmIdMplsTc) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdMplsTcMasked struct {
	*OxmId
}

type IOxmIdMplsTcMasked interface {
	IOxmId
}

func (self *OxmIdMplsTcMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdMplsTcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTcMasked, error) {
	_oxmidmplstcmasked := &OxmIdMplsTcMasked{OxmId: parent}
	return _oxmidmplstcmasked, nil
}

func NewOxmIdMplsTcMasked() *OxmIdMplsTcMasked {
	obj := &OxmIdMplsTcMasked{
		OxmId: NewOxmId(2147501826),
	}
	return obj
}
func (self *OxmIdMplsTcMasked) GetOXMName() string {
	return "mpls_tc_masked"
}

func (self *OxmIdMplsTcMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdSctpDst struct {
	*OxmId
}

type IOxmIdSctpDst interface {
	IOxmId
}

func (self *OxmIdSctpDst) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdSctpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpDst, error) {
	_oxmidsctpdst := &OxmIdSctpDst{OxmId: parent}
	return _oxmidsctpdst, nil
}

func NewOxmIdSctpDst() *OxmIdSctpDst {
	obj := &OxmIdSctpDst{
		OxmId: NewOxmId(2147492866),
	}
	return obj
}
func (self *OxmIdSctpDst) GetOXMName() string {
	return "sctp_dst"
}

func (self *OxmIdSctpDst) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdSctpDstMasked struct {
	*OxmId
}

type IOxmIdSctpDstMasked interface {
	IOxmId
}

func (self *OxmIdSctpDstMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdSctpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpDstMasked, error) {
	_oxmidsctpdstmasked := &OxmIdSctpDstMasked{OxmId: parent}
	return _oxmidsctpdstmasked, nil
}

func NewOxmIdSctpDstMasked() *OxmIdSctpDstMasked {
	obj := &OxmIdSctpDstMasked{
		OxmId: NewOxmId(2147493124),
	}
	return obj
}
func (self *OxmIdSctpDstMasked) GetOXMName() string {
	return "sctp_dst_masked"
}

func (self *OxmIdSctpDstMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdSctpSrc struct {
	*OxmId
}

type IOxmIdSctpSrc interface {
	IOxmId
}

func (self *OxmIdSctpSrc) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdSctpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpSrc, error) {
	_oxmidsctpsrc := &OxmIdSctpSrc{OxmId: parent}
	return _oxmidsctpsrc, nil
}

func NewOxmIdSctpSrc() *OxmIdSctpSrc {
	obj := &OxmIdSctpSrc{
		OxmId: NewOxmId(2147492354),
	}
	return obj
}
func (self *OxmIdSctpSrc) GetOXMName() string {
	return "sctp_src"
}

func (self *OxmIdSctpSrc) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdSctpSrcMasked struct {
	*OxmId
}

type IOxmIdSctpSrcMasked interface {
	IOxmId
}

func (self *OxmIdSctpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdSctpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpSrcMasked, error) {
	_oxmidsctpsrcmasked := &OxmIdSctpSrcMasked{OxmId: parent}
	return _oxmidsctpsrcmasked, nil
}

func NewOxmIdSctpSrcMasked() *OxmIdSctpSrcMasked {
	obj := &OxmIdSctpSrcMasked{
		OxmId: NewOxmId(2147492612),
	}
	return obj
}
func (self *OxmIdSctpSrcMasked) GetOXMName() string {
	return "sctp_src_masked"
}

func (self *OxmIdSctpSrcMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdVlanPcp struct {
	*OxmId
}

type IOxmIdVlanPcp interface {
	IOxmId
}

func (self *OxmIdVlanPcp) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdVlanPcp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanPcp, error) {
	_oxmidvlanpcp := &OxmIdVlanPcp{OxmId: parent}
	return _oxmidvlanpcp, nil
}

func NewOxmIdVlanPcp() *OxmIdVlanPcp {
	obj := &OxmIdVlanPcp{
		OxmId: NewOxmId(2147487233),
	}
	return obj
}
func (self *OxmIdVlanPcp) GetOXMName() string {
	return "vlan_pcp"
}

func (self *OxmIdVlanPcp) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdVlanPcpMasked struct {
	*OxmId
}

type IOxmIdVlanPcpMasked interface {
	IOxmId
}

func (self *OxmIdVlanPcpMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdVlanPcpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanPcpMasked, error) {
	_oxmidvlanpcpmasked := &OxmIdVlanPcpMasked{OxmId: parent}
	return _oxmidvlanpcpmasked, nil
}

func NewOxmIdVlanPcpMasked() *OxmIdVlanPcpMasked {
	obj := &OxmIdVlanPcpMasked{
		OxmId: NewOxmId(2147487490),
	}
	return obj
}
func (self *OxmIdVlanPcpMasked) GetOXMName() string {
	return "vlan_pcp_masked"
}

func (self *OxmIdVlanPcpMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdVlanVid struct {
	*OxmId
}

type IOxmIdVlanVid interface {
	IOxmId
}

func (self *OxmIdVlanVid) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdVlanVid(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanVid, error) {
	_oxmidvlanvid := &OxmIdVlanVid{OxmId: parent}
	return _oxmidvlanvid, nil
}

func NewOxmIdVlanVid() *OxmIdVlanVid {
	obj := &OxmIdVlanVid{
		OxmId: NewOxmId(2147486722),
	}
	return obj
}
func (self *OxmIdVlanVid) GetOXMName() string {
	return "vlan_vid"
}

func (self *OxmIdVlanVid) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdVlanVidMasked struct {
	*OxmId
}

type IOxmIdVlanVidMasked interface {
	IOxmId
}

func (self *OxmIdVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdVlanVidMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanVidMasked, error) {
	_oxmidvlanvidmasked := &OxmIdVlanVidMasked{OxmId: parent}
	return _oxmidvlanvidmasked, nil
}

func NewOxmIdVlanVidMasked() *OxmIdVlanVidMasked {
	obj := &OxmIdVlanVidMasked{
		OxmId: NewOxmId(2147486980),
	}
	return obj
}
func (self *OxmIdVlanVidMasked) GetOXMName() string {
	return "vlan_vid_masked"
}

func (self *OxmIdVlanVidMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type PacketQueue struct {
	QueueId    uint32
	Len        uint16
	Properties []IQueueProp
}

type IPacketQueue interface {
	goloxi.Serializable
	GetQueueId() uint32
	GetLen() uint16
	GetProperties() []IQueueProp
}

func (self *PacketQueue) GetQueueId() uint32 {
	return self.QueueId
}

func (self *PacketQueue) SetQueueId(v uint32) {
	self.QueueId = v
}

func (self *PacketQueue) GetLen() uint16 {
	return self.Len
}

func (self *PacketQueue) SetLen(v uint16) {
	self.Len = v
}

func (self *PacketQueue) GetProperties() []IQueueProp {
	return self.Properties
}

func (self *PacketQueue) SetProperties(v []IQueueProp) {
	self.Properties = v
}

func (self *PacketQueue) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint32(uint32(self.QueueId))
	encoder.PutUint16(uint16(self.Len))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	for _, obj := range self.Properties {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+4:startIndex+6], uint16(length))

	return nil
}

func DecodePacketQueue(decoder *goloxi.Decoder) (*PacketQueue, error) {
	_packetqueue := &PacketQueue{}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("PacketQueue packet too short: %d < 8", decoder.Length())
	}
	_packetqueue.QueueId = uint32(decoder.ReadUint32())
	_packetqueue.Len = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_packetqueue.Len), 2+4)
	decoder.Skip(2)

	for decoder.Length() >= 8 {
		item, err := DecodeQueueProp(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_packetqueue.Properties = append(_packetqueue.Properties, item)
		}
	}
	return _packetqueue, nil
}

func NewPacketQueue() *PacketQueue {
	obj := &PacketQueue{}
	return obj
}

type PortDesc struct {
	PortNo     Port
	HwAddr     net.HardwareAddr
	Name       string
	Config     PortConfig
	State      PortState
	Curr       PortFeatures
	Advertised PortFeatures
	Supported  PortFeatures
	Peer       PortFeatures
	CurrSpeed  uint32
	MaxSpeed   uint32
}

type IPortDesc interface {
	goloxi.Serializable
	GetPortNo() Port
	GetHwAddr() net.HardwareAddr
	GetName() string
	GetConfig() PortConfig
	GetState() PortState
	GetCurr() PortFeatures
	GetAdvertised() PortFeatures
	GetSupported() PortFeatures
	GetPeer() PortFeatures
	GetCurrSpeed() uint32
	GetMaxSpeed() uint32
}

func (self *PortDesc) GetPortNo() Port {
	return self.PortNo
}

func (self *PortDesc) SetPortNo(v Port) {
	self.PortNo = v
}

func (self *PortDesc) GetHwAddr() net.HardwareAddr {
	return self.HwAddr
}

func (self *PortDesc) SetHwAddr(v net.HardwareAddr) {
	self.HwAddr = v
}

func (self *PortDesc) GetName() string {
	return self.Name
}

func (self *PortDesc) SetName(v string) {
	self.Name = v
}

func (self *PortDesc) GetConfig() PortConfig {
	return self.Config
}

func (self *PortDesc) SetConfig(v PortConfig) {
	self.Config = v
}

func (self *PortDesc) GetState() PortState {
	return self.State
}

func (self *PortDesc) SetState(v PortState) {
	self.State = v
}

func (self *PortDesc) GetCurr() PortFeatures {
	return self.Curr
}

func (self *PortDesc) SetCurr(v PortFeatures) {
	self.Curr = v
}

func (self *PortDesc) GetAdvertised() PortFeatures {
	return self.Advertised
}

func (self *PortDesc) SetAdvertised(v PortFeatures) {
	self.Advertised = v
}

func (self *PortDesc) GetSupported() PortFeatures {
	return self.Supported
}

func (self *PortDesc) SetSupported(v PortFeatures) {
	self.Supported = v
}

func (self *PortDesc) GetPeer() PortFeatures {
	return self.Peer
}

func (self *PortDesc) SetPeer(v PortFeatures) {
	self.Peer = v
}

func (self *PortDesc) GetCurrSpeed() uint32 {
	return self.CurrSpeed
}

func (self *PortDesc) SetCurrSpeed(v uint32) {
	self.CurrSpeed = v
}

func (self *PortDesc) GetMaxSpeed() uint32 {
	return self.MaxSpeed
}

func (self *PortDesc) SetMaxSpeed(v uint32) {
	self.MaxSpeed = v
}

func (self *PortDesc) Serialize(encoder *goloxi.Encoder) error {

	self.PortNo.Serialize(encoder)
	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.Write(self.HwAddr)
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	encoder.Write([]byte(self.Name))
	encoder.PutUint32(uint32(self.Config))
	encoder.PutUint32(uint32(self.State))
	encoder.PutUint32(uint32(self.Curr))
	encoder.PutUint32(uint32(self.Advertised))
	encoder.PutUint32(uint32(self.Supported))
	encoder.PutUint32(uint32(self.Peer))
	encoder.PutUint32(uint32(self.CurrSpeed))
	encoder.PutUint32(uint32(self.MaxSpeed))

	return nil
}
func (self *PortDesc) Decode(decoder *goloxi.Decoder) error {
	if decoder.Length() < 64 {
		return fmt.Errorf("PortDesc packet too short: %d < 64", decoder.Length())
	}

	self.PortNo.Decode(decoder)
	decoder.Skip(4)
	self.HwAddr = net.HardwareAddr(decoder.Read(6))
	decoder.Skip(2)
	self.Name = string(bytes.Trim(decoder.Read(16), "\x00"))
	self.Config = PortConfig(decoder.ReadUint32())
	self.State = PortState(decoder.ReadUint32())
	self.Curr = PortFeatures(decoder.ReadUint32())
	self.Advertised = PortFeatures(decoder.ReadUint32())
	self.Supported = PortFeatures(decoder.ReadUint32())
	self.Peer = PortFeatures(decoder.ReadUint32())
	self.CurrSpeed = uint32(decoder.ReadUint32())
	self.MaxSpeed = uint32(decoder.ReadUint32())

	return nil
}

func NewPortDesc() *PortDesc {
	obj := &PortDesc{}
	return obj
}

type PortStatsEntry struct {
	PortNo     Port
	RxPackets  uint64
	TxPackets  uint64
	RxBytes    uint64
	TxBytes    uint64
	RxDropped  uint64
	TxDropped  uint64
	RxErrors   uint64
	TxErrors   uint64
	RxFrameErr uint64
	RxOverErr  uint64
	RxCrcErr   uint64
	Collisions uint64
}

type IPortStatsEntry interface {
	goloxi.Serializable
	GetPortNo() Port
	GetRxPackets() uint64
	GetTxPackets() uint64
	GetRxBytes() uint64
	GetTxBytes() uint64
	GetRxDropped() uint64
	GetTxDropped() uint64
	GetRxErrors() uint64
	GetTxErrors() uint64
	GetRxFrameErr() uint64
	GetRxOverErr() uint64
	GetRxCrcErr() uint64
	GetCollisions() uint64
}

func (self *PortStatsEntry) GetPortNo() Port {
	return self.PortNo
}

func (self *PortStatsEntry) SetPortNo(v Port) {
	self.PortNo = v
}

func (self *PortStatsEntry) GetRxPackets() uint64 {
	return self.RxPackets
}

func (self *PortStatsEntry) SetRxPackets(v uint64) {
	self.RxPackets = v
}

func (self *PortStatsEntry) GetTxPackets() uint64 {
	return self.TxPackets
}

func (self *PortStatsEntry) SetTxPackets(v uint64) {
	self.TxPackets = v
}

func (self *PortStatsEntry) GetRxBytes() uint64 {
	return self.RxBytes
}

func (self *PortStatsEntry) SetRxBytes(v uint64) {
	self.RxBytes = v
}

func (self *PortStatsEntry) GetTxBytes() uint64 {
	return self.TxBytes
}

func (self *PortStatsEntry) SetTxBytes(v uint64) {
	self.TxBytes = v
}

func (self *PortStatsEntry) GetRxDropped() uint64 {
	return self.RxDropped
}

func (self *PortStatsEntry) SetRxDropped(v uint64) {
	self.RxDropped = v
}

func (self *PortStatsEntry) GetTxDropped() uint64 {
	return self.TxDropped
}

func (self *PortStatsEntry) SetTxDropped(v uint64) {
	self.TxDropped = v
}

func (self *PortStatsEntry) GetRxErrors() uint64 {
	return self.RxErrors
}

func (self *PortStatsEntry) SetRxErrors(v uint64) {
	self.RxErrors = v
}

func (self *PortStatsEntry) GetTxErrors() uint64 {
	return self.TxErrors
}

func (self *PortStatsEntry) SetTxErrors(v uint64) {
	self.TxErrors = v
}

func (self *PortStatsEntry) GetRxFrameErr() uint64 {
	return self.RxFrameErr
}

func (self *PortStatsEntry) SetRxFrameErr(v uint64) {
	self.RxFrameErr = v
}

func (self *PortStatsEntry) GetRxOverErr() uint64 {
	return self.RxOverErr
}

func (self *PortStatsEntry) SetRxOverErr(v uint64) {
	self.RxOverErr = v
}

func (self *PortStatsEntry) GetRxCrcErr() uint64 {
	return self.RxCrcErr
}

func (self *PortStatsEntry) SetRxCrcErr(v uint64) {
	self.RxCrcErr = v
}

func (self *PortStatsEntry) GetCollisions() uint64 {
	return self.Collisions
}

func (self *PortStatsEntry) SetCollisions(v uint64) {
	self.Collisions = v
}

func (self *PortStatsEntry) Serialize(encoder *goloxi.Encoder) error {

	self.PortNo.Serialize(encoder)
	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint64(uint64(self.RxPackets))
	encoder.PutUint64(uint64(self.TxPackets))
	encoder.PutUint64(uint64(self.RxBytes))
	encoder.PutUint64(uint64(self.TxBytes))
	encoder.PutUint64(uint64(self.RxDropped))
	encoder.PutUint64(uint64(self.TxDropped))
	encoder.PutUint64(uint64(self.RxErrors))
	encoder.PutUint64(uint64(self.TxErrors))
	encoder.PutUint64(uint64(self.RxFrameErr))
	encoder.PutUint64(uint64(self.RxOverErr))
	encoder.PutUint64(uint64(self.RxCrcErr))
	encoder.PutUint64(uint64(self.Collisions))

	return nil
}

func DecodePortStatsEntry(decoder *goloxi.Decoder) (*PortStatsEntry, error) {
	_portstatsentry := &PortStatsEntry{}
	if decoder.Length() < 104 {
		return nil, fmt.Errorf("PortStatsEntry packet too short: %d < 104", decoder.Length())
	}
	_portstatsentry.PortNo.Decode(decoder)
	decoder.Skip(4)
	_portstatsentry.RxPackets = uint64(decoder.ReadUint64())
	_portstatsentry.TxPackets = uint64(decoder.ReadUint64())
	_portstatsentry.RxBytes = uint64(decoder.ReadUint64())
	_portstatsentry.TxBytes = uint64(decoder.ReadUint64())
	_portstatsentry.RxDropped = uint64(decoder.ReadUint64())
	_portstatsentry.TxDropped = uint64(decoder.ReadUint64())
	_portstatsentry.RxErrors = uint64(decoder.ReadUint64())
	_portstatsentry.TxErrors = uint64(decoder.ReadUint64())
	_portstatsentry.RxFrameErr = uint64(decoder.ReadUint64())
	_portstatsentry.RxOverErr = uint64(decoder.ReadUint64())
	_portstatsentry.RxCrcErr = uint64(decoder.ReadUint64())
	_portstatsentry.Collisions = uint64(decoder.ReadUint64())
	return _portstatsentry, nil
}

func NewPortStatsEntry() *PortStatsEntry {
	obj := &PortStatsEntry{}
	return obj
}

type QueueProp struct {
	Type uint16
	Len  uint16
}

type IQueueProp interface {
	goloxi.Serializable
	GetType() uint16
	GetLen() uint16
}

func (self *QueueProp) GetType() uint16 {
	return self.Type
}

func (self *QueueProp) SetType(v uint16) {
	self.Type = v
}

func (self *QueueProp) GetLen() uint16 {
	return self.Len
}

func (self *QueueProp) SetLen(v uint16) {
	self.Len = v
}

func (self *QueueProp) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Len))

	return nil
}

func DecodeQueueProp(decoder *goloxi.Decoder) (IQueueProp, error) {
	_queueprop := &QueueProp{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("QueueProp packet too short: %d < 4", decoder.Length())
	}
	_queueprop.Type = uint16(decoder.ReadUint16())
	_queueprop.Len = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_queueprop.Len), 2+2)

	switch _queueprop.Type {
	case 1:
		return DecodeQueuePropMinRate(_queueprop, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'QueueProp'", _queueprop.Type)
	}
}

func NewQueueProp(_type uint16) *QueueProp {
	obj := &QueueProp{}
	obj.Type = _type
	return obj
}

type QueuePropMinRate struct {
	*QueueProp
	Rate uint16
}

type IQueuePropMinRate interface {
	IQueueProp
	GetRate() uint16
}

func (self *QueuePropMinRate) GetRate() uint16 {
	return self.Rate
}

func (self *QueuePropMinRate) SetRate(v uint16) {
	self.Rate = v
}

func (self *QueuePropMinRate) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.QueueProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint16(uint16(self.Rate))
	encoder.Write(bytes.Repeat([]byte{0}, 6))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeQueuePropMinRate(parent *QueueProp, decoder *goloxi.Decoder) (*QueuePropMinRate, error) {
	_queuepropminrate := &QueuePropMinRate{QueueProp: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("QueuePropMinRate packet too short: %d < 12", decoder.Length())
	}
	decoder.Skip(4)
	_queuepropminrate.Rate = uint16(decoder.ReadUint16())
	decoder.Skip(6)
	return _queuepropminrate, nil
}

func NewQueuePropMinRate() *QueuePropMinRate {
	obj := &QueuePropMinRate{
		QueueProp: NewQueueProp(1),
	}
	return obj
}

type QueueStatsEntry struct {
	PortNo    Port
	QueueId   uint32
	TxBytes   uint64
	TxPackets uint64
	TxErrors  uint64
}

type IQueueStatsEntry interface {
	goloxi.Serializable
	GetPortNo() Port
	GetQueueId() uint32
	GetTxBytes() uint64
	GetTxPackets() uint64
	GetTxErrors() uint64
}

func (self *QueueStatsEntry) GetPortNo() Port {
	return self.PortNo
}

func (self *QueueStatsEntry) SetPortNo(v Port) {
	self.PortNo = v
}

func (self *QueueStatsEntry) GetQueueId() uint32 {
	return self.QueueId
}

func (self *QueueStatsEntry) SetQueueId(v uint32) {
	self.QueueId = v
}

func (self *QueueStatsEntry) GetTxBytes() uint64 {
	return self.TxBytes
}

func (self *QueueStatsEntry) SetTxBytes(v uint64) {
	self.TxBytes = v
}

func (self *QueueStatsEntry) GetTxPackets() uint64 {
	return self.TxPackets
}

func (self *QueueStatsEntry) SetTxPackets(v uint64) {
	self.TxPackets = v
}

func (self *QueueStatsEntry) GetTxErrors() uint64 {
	return self.TxErrors
}

func (self *QueueStatsEntry) SetTxErrors(v uint64) {
	self.TxErrors = v
}

func (self *QueueStatsEntry) Serialize(encoder *goloxi.Encoder) error {

	self.PortNo.Serialize(encoder)
	encoder.PutUint32(uint32(self.QueueId))
	encoder.PutUint64(uint64(self.TxBytes))
	encoder.PutUint64(uint64(self.TxPackets))
	encoder.PutUint64(uint64(self.TxErrors))

	return nil
}

func DecodeQueueStatsEntry(decoder *goloxi.Decoder) (*QueueStatsEntry, error) {
	_queuestatsentry := &QueueStatsEntry{}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("QueueStatsEntry packet too short: %d < 32", decoder.Length())
	}
	_queuestatsentry.PortNo.Decode(decoder)
	_queuestatsentry.QueueId = uint32(decoder.ReadUint32())
	_queuestatsentry.TxBytes = uint64(decoder.ReadUint64())
	_queuestatsentry.TxPackets = uint64(decoder.ReadUint64())
	_queuestatsentry.TxErrors = uint64(decoder.ReadUint64())
	return _queuestatsentry, nil
}

func NewQueueStatsEntry() *QueueStatsEntry {
	obj := &QueueStatsEntry{}
	return obj
}

type TableStatsEntry struct {
	TableId      uint8
	Name         string
	Wildcards    WcBmap
	Match        MatchBmap
	Instructions uint32
	WriteActions uint32
	ApplyActions uint32
	Config       uint32
	MaxEntries   uint32
	ActiveCount  uint32
	LookupCount  uint64
	MatchedCount uint64
}

type ITableStatsEntry interface {
	goloxi.Serializable
	GetTableId() uint8
	GetName() string
	GetWildcards() WcBmap
	GetMatch() MatchBmap
	GetInstructions() uint32
	GetWriteActions() uint32
	GetApplyActions() uint32
	GetConfig() uint32
	GetMaxEntries() uint32
	GetActiveCount() uint32
	GetLookupCount() uint64
	GetMatchedCount() uint64
}

func (self *TableStatsEntry) GetTableId() uint8 {
	return self.TableId
}

func (self *TableStatsEntry) SetTableId(v uint8) {
	self.TableId = v
}

func (self *TableStatsEntry) GetName() string {
	return self.Name
}

func (self *TableStatsEntry) SetName(v string) {
	self.Name = v
}

func (self *TableStatsEntry) GetWildcards() WcBmap {
	return self.Wildcards
}

func (self *TableStatsEntry) SetWildcards(v WcBmap) {
	self.Wildcards = v
}

func (self *TableStatsEntry) GetMatch() MatchBmap {
	return self.Match
}

func (self *TableStatsEntry) SetMatch(v MatchBmap) {
	self.Match = v
}

func (self *TableStatsEntry) GetInstructions() uint32 {
	return self.Instructions
}

func (self *TableStatsEntry) SetInstructions(v uint32) {
	self.Instructions = v
}

func (self *TableStatsEntry) GetWriteActions() uint32 {
	return self.WriteActions
}

func (self *TableStatsEntry) SetWriteActions(v uint32) {
	self.WriteActions = v
}

func (self *TableStatsEntry) GetApplyActions() uint32 {
	return self.ApplyActions
}

func (self *TableStatsEntry) SetApplyActions(v uint32) {
	self.ApplyActions = v
}

func (self *TableStatsEntry) GetConfig() uint32 {
	return self.Config
}

func (self *TableStatsEntry) SetConfig(v uint32) {
	self.Config = v
}

func (self *TableStatsEntry) GetMaxEntries() uint32 {
	return self.MaxEntries
}

func (self *TableStatsEntry) SetMaxEntries(v uint32) {
	self.MaxEntries = v
}

func (self *TableStatsEntry) GetActiveCount() uint32 {
	return self.ActiveCount
}

func (self *TableStatsEntry) SetActiveCount(v uint32) {
	self.ActiveCount = v
}

func (self *TableStatsEntry) GetLookupCount() uint64 {
	return self.LookupCount
}

func (self *TableStatsEntry) SetLookupCount(v uint64) {
	self.LookupCount = v
}

func (self *TableStatsEntry) GetMatchedCount() uint64 {
	return self.MatchedCount
}

func (self *TableStatsEntry) SetMatchedCount(v uint64) {
	self.MatchedCount = v
}

func (self *TableStatsEntry) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint8(uint8(self.TableId))
	encoder.Write(bytes.Repeat([]byte{0}, 7))
	encoder.Write([]byte(self.Name))
	self.Wildcards.Serialize(encoder)
	self.Match.Serialize(encoder)
	encoder.PutUint32(uint32(self.Instructions))
	encoder.PutUint32(uint32(self.WriteActions))
	encoder.PutUint32(uint32(self.ApplyActions))
	encoder.PutUint32(uint32(self.Config))
	encoder.PutUint32(uint32(self.MaxEntries))
	encoder.PutUint32(uint32(self.ActiveCount))
	encoder.PutUint64(uint64(self.LookupCount))
	encoder.PutUint64(uint64(self.MatchedCount))

	return nil
}

func DecodeTableStatsEntry(decoder *goloxi.Decoder) (*TableStatsEntry, error) {
	_tablestatsentry := &TableStatsEntry{}
	if decoder.Length() < 88 {
		return nil, fmt.Errorf("TableStatsEntry packet too short: %d < 88", decoder.Length())
	}
	_tablestatsentry.TableId = uint8(decoder.ReadByte())
	decoder.Skip(7)
	_tablestatsentry.Name = string(bytes.Trim(decoder.Read(32), "\x00"))
	_tablestatsentry.Wildcards.Decode(decoder)
	_tablestatsentry.Match.Decode(decoder)
	_tablestatsentry.Instructions = uint32(decoder.ReadUint32())
	_tablestatsentry.WriteActions = uint32(decoder.ReadUint32())
	_tablestatsentry.ApplyActions = uint32(decoder.ReadUint32())
	_tablestatsentry.Config = uint32(decoder.ReadUint32())
	_tablestatsentry.MaxEntries = uint32(decoder.ReadUint32())
	_tablestatsentry.ActiveCount = uint32(decoder.ReadUint32())
	_tablestatsentry.LookupCount = uint64(decoder.ReadUint64())
	_tablestatsentry.MatchedCount = uint64(decoder.ReadUint64())
	return _tablestatsentry, nil
}

func NewTableStatsEntry() *TableStatsEntry {
	obj := &TableStatsEntry{}
	return obj
}