/*
 * 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 of12

import (
	"fmt"
	"net"

	"github.com/opencord/goloxi"
)

type Oxm struct {
	TypeLen uint32
}

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

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

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

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

	encoder.PutUint32(uint32(self.TypeLen))

	return nil
}

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

	switch _oxm.TypeLen {
	case 110204:
		return DecodeNxmTunMetadata47(_oxm, decoder)
	case 129026:
		return DecodeOxmConnTrackingTpSrc(_oxm, decoder)
	case 2147483652:
		return DecodeOxmInPort(_oxm, decoder)
	case 77830:
		return DecodeNxmNdSll(_oxm, decoder)
	case 2147499009:
		return DecodeOxmIcmpv6Code(_oxm, decoder)
	case 73736:
		return DecodeNxmTunId(_oxm, decoder)
	case 2:
		return DecodeNxmInPort(_oxm, decoder)
	case 120848:
		return DecodeOxmConnTrackingLabel(_oxm, decoder)
	case 199684:
		return DecodeOxmBsnL3DstClassId(_oxm, decoder)
	case 111228:
		return DecodeNxmTunMetadata49(_oxm, decoder)
	case 1030:
		return DecodeNxmEthSrc(_oxm, decoder)
	case 112252:
		return DecodeNxmTunMetadata51(_oxm, decoder)
	case 108024:
		return DecodeNxmTunMetadata42Masked(_oxm, decoder)
	case 2147495176:
		return DecodeOxmArpSpaMasked(_oxm, decoder)
	case 113276:
		return DecodeNxmTunMetadata53(_oxm, decoder)
	case 109048:
		return DecodeNxmTunMetadata44Masked(_oxm, decoder)
	case 94332:
		return DecodeNxmTunMetadata16(_oxm, decoder)
	case 65540:
		return DecodeNxmReg0(_oxm, decoder)
	case 114300:
		return DecodeNxmTunMetadata55(_oxm, decoder)
	case 2050:
		return DecodeNxmVlanTci(_oxm, decoder)
	case 3073:
		return DecodeNxmNwProto(_oxm, decoder)
	case 110072:
		return DecodeNxmTunMetadata46Masked(_oxm, decoder)
	case 66564:
		return DecodeNxmReg2(_oxm, decoder)
	case 115324:
		return DecodeNxmTunMetadata57(_oxm, decoder)
	case 2147486722:
		return DecodeOxmVlanVid(_oxm, decoder)
	case 2147487745:
		return DecodeOxmIpDscp(_oxm, decoder)
	case 111096:
		return DecodeNxmTunMetadata48Masked(_oxm, decoder)
	case 83204:
		return DecodeNxmTcpFlagsMasked(_oxm, decoder)
	case 3588:
		return DecodeNxmIpSrc(_oxm, decoder)
	case 198660:
		return DecodeOxmBsnL3InterfaceClassId(_oxm, decoder)
	case 2147488769:
		return DecodeOxmIpProto(_oxm, decoder)
	case 112120:
		return DecodeNxmTunMetadata50Masked(_oxm, decoder)
	case 121872:
		return DecodeNxmTunIpv6Dst(_oxm, decoder)
	case 199172:
		return DecodeOxmBsnL3SrcClassId(_oxm, decoder)
	case 68612:
		return DecodeNxmReg6(_oxm, decoder)
	case 117372:
		return DecodeNxmTunMetadata61(_oxm, decoder)
	case 5122:
		return DecodeNxmTcpDst(_oxm, decoder)
	case 113144:
		return DecodeNxmTunMetadata52Masked(_oxm, decoder)
	case 122896:
		return DecodeNxmXxreg1(_oxm, decoder)
	case 124192:
		return DecodeNxmXxreg3Masked(_oxm, decoder)
	case 81672:
		return DecodeOxmTunnelIpv4SrcMasked(_oxm, decoder)
	case 2147485702:
		return DecodeOxmEthSrc(_oxm, decoder)
	case 4100:
		return DecodeNxmIpDst(_oxm, decoder)
	case 118396:
		return DecodeNxmTunMetadata63(_oxm, decoder)
	case 2147494146:
		return DecodeOxmIcmpv4CodeMasked(_oxm, decoder)
	case 129284:
		return DecodeOxmConnTrackingTpSrcMasked(_oxm, decoder)
	case 114168:
		return DecodeNxmTunMetadata54Masked(_oxm, decoder)
	case 123920:
		return DecodeNxmXxreg3(_oxm, decoder)
	case 200968:
		return DecodeOxmBsnUdf0Masked(_oxm, decoder)
	case 78091:
		return DecodeNxmNdSllMasked(_oxm, decoder)
	case 2147496204:
		return DecodeOxmArpShaMasked(_oxm, decoder)
	case 74000:
		return DecodeNxmTunIdMasked(_oxm, decoder)
	case 86140:
		return DecodeNxmTunMetadata0(_oxm, decoder)
	case 70660:
		return DecodeNxmReg10(_oxm, decoder)
	case 121120:
		return DecodeOxmConnTrackingLabelMasked(_oxm, decoder)
	case 107000:
		return DecodeNxmTunMetadata40Masked(_oxm, decoder)
	case 3848:
		return DecodeNxmIpSrcMasked(_oxm, decoder)
	case 87164:
		return DecodeNxmTunMetadata2(_oxm, decoder)
	case 202756:
		return DecodeOxmBsnUdf4(_oxm, decoder)
	case 204802:
		return DecodeOxmBsnTcpFlags(_oxm, decoder)
	case 205825:
		return DecodeOxmBsnL2CacheHit(_oxm, decoder)
	case 116216:
		return DecodeNxmTunMetadata58Masked(_oxm, decoder)
	case 199432:
		return DecodeOxmBsnL3SrcClassIdMasked(_oxm, decoder)
	case 88188:
		return DecodeNxmTunMetadata4(_oxm, decoder)
	case 72708:
		return DecodeNxmReg14(_oxm, decoder)
	case 2147492866:
		return DecodeOxmSctpDst(_oxm, decoder)
	case 2147493889:
		return DecodeOxmIcmpv4Code(_oxm, decoder)
	case 117240:
		return DecodeNxmTunMetadata60Masked(_oxm, decoder)
	case 200196:
		return DecodeOxmBsnEgrPortGroupId(_oxm, decoder)
	case 128288:
		return DecodeOxmConnTrackingIpv6SrcMasked(_oxm, decoder)
	case 89212:
		return DecodeNxmTunMetadata6(_oxm, decoder)
	case 2147500300:
		return DecodeOxmIpv6NdSllMasked(_oxm, decoder)
	case 8196:
		return DecodeNxmArpSpa(_oxm, decoder)
	case 76801:
		return DecodeNxmIcmpv6Code(_oxm, decoder)
	case 118264:
		return DecodeNxmTunMetadata62Masked(_oxm, decoder)
	case 70148:
		return DecodeNxmReg9(_oxm, decoder)
	case 119560:
		return DecodeOxmConnTrackingStateMasked(_oxm, decoder)
	case 90236:
		return DecodeNxmTunMetadata8(_oxm, decoder)
	case 119044:
		return DecodeNxmTunFlagsMasked(_oxm, decoder)
	case 82696:
		return DecodeNxmPktMarkMasked(_oxm, decoder)
	case 4294923528:
		return DecodeOxmOvsTcpFlagsMasked(_oxm, decoder)
	case 120584:
		return DecodeOxmConnTrackingMarkMasked(_oxm, decoder)
	case 91260:
		return DecodeNxmTunMetadata10(_oxm, decoder)
	case 87032:
		return DecodeNxmTunMetadata1Masked(_oxm, decoder)
	case 126722:
		return DecodeOxmConnTrackingNwProtoMasked(_oxm, decoder)
	case 206852:
		return DecodeOxmBsnIngressPortGroupId(_oxm, decoder)
	case 209921:
		return DecodeOxmBsnIpFragmentation(_oxm, decoder)
	case 196896:
		return DecodeOxmBsnInPorts128Masked(_oxm, decoder)
	case 92284:
		return DecodeNxmTunMetadata12(_oxm, decoder)
	case 88056:
		return DecodeNxmTunMetadata3Masked(_oxm, decoder)
	case 2147494916:
		return DecodeOxmArpSpa(_oxm, decoder)
	case 79873:
		return DecodeNxmNwEcn(_oxm, decoder)
	case 196624:
		return DecodeOxmBsnInPorts128(_oxm, decoder)
	case 200456:
		return DecodeOxmBsnEgrPortGroupIdMasked(_oxm, decoder)
	case 2147489284:
		return DecodeOxmIpv4Src(_oxm, decoder)
	case 93308:
		return DecodeNxmTunMetadata14(_oxm, decoder)
	case 115192:
		return DecodeNxmTunMetadata56Masked(_oxm, decoder)
	case 2147498497:
		return DecodeOxmIcmpv6Type(_oxm, decoder)
	case 129538:
		return DecodeOxmConnTrackingTpDst(_oxm, decoder)
	case 2147500550:
		return DecodeOxmIpv6NdTll(_oxm, decoder)
	case 84484:
		return DecodeNxmConjId(_oxm, decoder)
	case 74246:
		return DecodeNxmArpSha(_oxm, decoder)
	case 198402:
		return DecodeOxmBsnGlobalVrfAllowedMasked(_oxm, decoder)
	case 123408:
		return DecodeNxmXxreg2(_oxm, decoder)
	case 90104:
		return DecodeNxmTunMetadata7Masked(_oxm, decoder)
	case 129796:
		return DecodeOxmConnTrackingTpDstMasked(_oxm, decoder)
	case 70408:
		return DecodeNxmReg9Masked(_oxm, decoder)
	case 91128:
		return DecodeNxmTunMetadata9Masked(_oxm, decoder)
	case 83720:
		return DecodeNxmDpHashMasked(_oxm, decoder)
	case 2147495942:
		return DecodeOxmArpSha(_oxm, decoder)
	case 2147497988:
		return DecodeOxmIpv6Flabel(_oxm, decoder)
	case 78603:
		return DecodeNxmNdTllMasked(_oxm, decoder)
	case 2147500812:
		return DecodeOxmIpv6NdTllMasked(_oxm, decoder)
	case 96380:
		return DecodeNxmTunMetadata20(_oxm, decoder)
	case 92152:
		return DecodeNxmTunMetadata11Masked(_oxm, decoder)
	case 80897:
		return DecodeNxmMplsTtl(_oxm, decoder)
	case 2147489544:
		return DecodeOxmIpv4SrcMasked(_oxm, decoder)
	case 97404:
		return DecodeNxmTunMetadata22(_oxm, decoder)
	case 93176:
		return DecodeNxmTunMetadata13Masked(_oxm, decoder)
	case 94844:
		return DecodeNxmTunMetadata17(_oxm, decoder)
	case 81924:
		return DecodeOxmTunnelIpv4Dst(_oxm, decoder)
	case 127752:
		return DecodeOxmConnTrackingNwDstMasked(_oxm, decoder)
	case 98428:
		return DecodeNxmTunMetadata24(_oxm, decoder)
	case 94200:
		return DecodeNxmTunMetadata15Masked(_oxm, decoder)
	case 2147489026:
		return DecodeOxmIpProtoMasked(_oxm, decoder)
	case 2147501060:
		return DecodeOxmMplsLabel(_oxm, decoder)
	case 84994:
		return DecodeNxmTunGbpId(_oxm, decoder)
	case 99452:
		return DecodeNxmTunMetadata26(_oxm, decoder)
	case 95224:
		return DecodeNxmTunMetadata17Masked(_oxm, decoder)
	case 2147500038:
		return DecodeOxmIpv6NdSll(_oxm, decoder)
	case 83972:
		return DecodeNxmRecircId(_oxm, decoder)
	case 128800:
		return DecodeOxmConnTrackingIpv6DstMasked(_oxm, decoder)
	case 72196:
		return DecodeNxmReg13(_oxm, decoder)
	case 100476:
		return DecodeNxmTunMetadata28(_oxm, decoder)
	case 96248:
		return DecodeNxmTunMetadata19Masked(_oxm, decoder)
	case 2147488514:
		return DecodeOxmIpEcnMasked(_oxm, decoder)
	case 112764:
		return DecodeNxmTunMetadata52(_oxm, decoder)
	case 101500:
		return DecodeNxmTunMetadata30(_oxm, decoder)
	case 97272:
		return DecodeNxmTunMetadata21Masked(_oxm, decoder)
	case 2147498754:
		return DecodeOxmIcmpv6TypeMasked(_oxm, decoder)
	case 2147486468:
		return DecodeOxmEthTypeMasked(_oxm, decoder)
	case 2147484424:
		return DecodeOxmInPhyPortMasked(_oxm, decoder)
	case 74507:
		return DecodeNxmArpShaMasked(_oxm, decoder)
	case 2147496716:
		return DecodeOxmArpThaMasked(_oxm, decoder)
	case 197384:
		return DecodeOxmBsnLagIdMasked(_oxm, decoder)
	case 76064:
		return DecodeNxmIpv6DstMasked(_oxm, decoder)
	case 102524:
		return DecodeNxmTunMetadata32(_oxm, decoder)
	case 98296:
		return DecodeNxmTunMetadata23Masked(_oxm, decoder)
	case 4868:
		return DecodeNxmTcpSrcMasked(_oxm, decoder)
	case 121632:
		return DecodeNxmTunIpv6SrcMasked(_oxm, decoder)
	case 75792:
		return DecodeNxmIpv6Dst(_oxm, decoder)
	case 202504:
		return DecodeOxmBsnUdf3Masked(_oxm, decoder)
	case 120324:
		return DecodeOxmConnTrackingMark(_oxm, decoder)
	case 99320:
		return DecodeNxmTunMetadata25Masked(_oxm, decoder)
	case 65800:
		return DecodeNxmReg0Masked(_oxm, decoder)
	case 66824:
		return DecodeNxmReg2Masked(_oxm, decoder)
	case 72456:
		return DecodeNxmReg13Masked(_oxm, decoder)
	case 68360:
		return DecodeNxmReg5Masked(_oxm, decoder)
	case 104572:
		return DecodeNxmTunMetadata36(_oxm, decoder)
	case 95356:
		return DecodeNxmTunMetadata18(_oxm, decoder)
	case 100344:
		return DecodeNxmTunMetadata27Masked(_oxm, decoder)
	case 2147490564:
		return DecodeOxmTcpSrcMasked(_oxm, decoder)
	case 4294923270:
		return DecodeOxmOvsTcpFlags(_oxm, decoder)
	case 779:
		return DecodeNxmEthDstMasked(_oxm, decoder)
	case 69384:
		return DecodeNxmReg7Masked(_oxm, decoder)
	case 2147497248:
		return DecodeOxmIpv6SrcMasked(_oxm, decoder)
	case 105596:
		return DecodeNxmTunMetadata38(_oxm, decoder)
	case 101368:
		return DecodeNxmTunMetadata29Masked(_oxm, decoder)
	case 2147491588:
		return DecodeOxmUdpSrcMasked(_oxm, decoder)
	case 108668:
		return DecodeNxmTunMetadata44(_oxm, decoder)
	case 2147496976:
		return DecodeOxmIpv6Src(_oxm, decoder)
	case 201480:
		return DecodeOxmBsnUdf1Masked(_oxm, decoder)
	case 106620:
		return DecodeNxmTunMetadata40(_oxm, decoder)
	case 102392:
		return DecodeNxmTunMetadata31Masked(_oxm, decoder)
	case 2147492612:
		return DecodeOxmSctpSrcMasked(_oxm, decoder)
	case 73480:
		return DecodeNxmReg15Masked(_oxm, decoder)
	case 204292:
		return DecodeOxmBsnUdf7(_oxm, decoder)
	case 71432:
		return DecodeNxmReg11Masked(_oxm, decoder)
	case 107644:
		return DecodeNxmTunMetadata42(_oxm, decoder)
	case 103416:
		return DecodeNxmTunMetadata33Masked(_oxm, decoder)
	case 2147498248:
		return DecodeOxmIpv6FlabelMasked(_oxm, decoder)
	case 203528:
		return DecodeOxmBsnUdf5Masked(_oxm, decoder)
	case 89592:
		return DecodeNxmTunMetadata6Masked(_oxm, decoder)
	case 104440:
		return DecodeNxmTunMetadata35Masked(_oxm, decoder)
	case 2147494660:
		return DecodeOxmArpOpMasked(_oxm, decoder)
	case 197636:
		return DecodeOxmBsnVrf(_oxm, decoder)
	case 204552:
		return DecodeOxmBsnUdf7Masked(_oxm, decoder)
	case 109692:
		return DecodeNxmTunMetadata46(_oxm, decoder)
	case 105464:
		return DecodeNxmTunMetadata37Masked(_oxm, decoder)
	case 89080:
		return DecodeNxmTunMetadata5Masked(_oxm, decoder)
	case 67588:
		return DecodeNxmReg4(_oxm, decoder)
	case 7169:
		return DecodeNxmIcmpCode(_oxm, decoder)
	case 82946:
		return DecodeNxmTcpFlags(_oxm, decoder)
	case 203780:
		return DecodeOxmBsnUdf6(_oxm, decoder)
	case 74758:
		return DecodeNxmArpTha(_oxm, decoder)
	case 198145:
		return DecodeOxmBsnGlobalVrfAllowed(_oxm, decoder)
	case 2147484680:
		return DecodeOxmMetadata(_oxm, decoder)
	case 1538:
		return DecodeNxmEthType(_oxm, decoder)
	case 8968:
		return DecodeNxmArpTpaMasked(_oxm, decoder)
	case 128016:
		return DecodeOxmConnTrackingIpv6Src(_oxm, decoder)
	case 110716:
		return DecodeNxmTunMetadata48(_oxm, decoder)
	case 127492:
		return DecodeOxmConnTrackingNwDst(_oxm, decoder)
	case 78342:
		return DecodeNxmNdTll(_oxm, decoder)
	case 111740:
		return DecodeNxmTunMetadata50(_oxm, decoder)
	case 107512:
		return DecodeNxmTunMetadata41Masked(_oxm, decoder)
	case 121360:
		return DecodeNxmTunIpv6Src(_oxm, decoder)
	case 2147495688:
		return DecodeOxmArpTpaMasked(_oxm, decoder)
	case 113788:
		return DecodeNxmTunMetadata54(_oxm, decoder)
	case 2561:
		return DecodeNxmNwTos(_oxm, decoder)
	case 109560:
		return DecodeNxmTunMetadata45Masked(_oxm, decoder)
	case 2147501826:
		return DecodeOxmMplsTcMasked(_oxm, decoder)
	case 103548:
		return DecodeNxmTunMetadata34(_oxm, decoder)
	case 2147484164:
		return DecodeOxmInPhyPort(_oxm, decoder)
	case 205316:
		return DecodeOxmBsnVlanXlatePortGroupId(_oxm, decoder)
	case 114812:
		return DecodeNxmTunMetadata56(_oxm, decoder)
	case 2147486210:
		return DecodeOxmEthType(_oxm, decoder)
	case 2147487233:
		return DecodeOxmVlanPcp(_oxm, decoder)
	case 110584:
		return DecodeNxmTunMetadata47Masked(_oxm, decoder)
	case 79624:
		return DecodeNxmIpv6LabelMasked(_oxm, decoder)
	case 115836:
		return DecodeNxmTunMetadata58(_oxm, decoder)
	case 2147488257:
		return DecodeOxmIpEcn(_oxm, decoder)
	case 111608:
		return DecodeNxmTunMetadata49Masked(_oxm, decoder)
	case 85762:
		return DecodeNxmTunGbpFlagsMasked(_oxm, decoder)
	case 518:
		return DecodeNxmEthDst(_oxm, decoder)
	case 68100:
		return DecodeNxmReg5(_oxm, decoder)
	case 116860:
		return DecodeNxmTunMetadata60(_oxm, decoder)
	case 4610:
		return DecodeNxmTcpSrc(_oxm, decoder)
	case 112632:
		return DecodeNxmTunMetadata51Masked(_oxm, decoder)
	case 122384:
		return DecodeNxmXxreg0(_oxm, decoder)
	case 123680:
		return DecodeNxmXxreg2Masked(_oxm, decoder)
	case 69124:
		return DecodeNxmReg7(_oxm, decoder)
	case 117884:
		return DecodeNxmTunMetadata62(_oxm, decoder)
	case 5634:
		return DecodeNxmUdpSrc(_oxm, decoder)
	case 6657:
		return DecodeNxmIcmpType(_oxm, decoder)
	case 113656:
		return DecodeNxmTunMetadata53Masked(_oxm, decoder)
	case 198920:
		return DecodeOxmBsnL3InterfaceClassIdMasked(_oxm, decoder)
	case 210178:
		return DecodeOxmBsnIpFragmentationMasked(_oxm, decoder)
	case 120068:
		return DecodeOxmConnTrackingZoneMasked(_oxm, decoder)
	case 1286:
		return DecodeNxmEthSrcMasked(_oxm, decoder)
	case 204040:
		return DecodeOxmBsnUdf6Masked(_oxm, decoder)
	case 75019:
		return DecodeNxmArpThaMasked(_oxm, decoder)
	case 201220:
		return DecodeOxmBsnUdf1(_oxm, decoder)
	case 205576:
		return DecodeOxmBsnVlanXlatePortGroupIdMasked(_oxm, decoder)
	case 2147484944:
		return DecodeOxmMetadataMasked(_oxm, decoder)
	case 6146:
		return DecodeNxmUdpDst(_oxm, decoder)
	case 2147490306:
		return DecodeOxmTcpSrc(_oxm, decoder)
	case 114680:
		return DecodeNxmTunMetadata55Masked(_oxm, decoder)
	case 122144:
		return DecodeNxmTunIpv6DstMasked(_oxm, decoder)
	case 86652:
		return DecodeNxmTunMetadata1(_oxm, decoder)
	case 202244:
		return DecodeOxmBsnUdf3(_oxm, decoder)
	case 2147491330:
		return DecodeOxmUdpSrc(_oxm, decoder)
	case 115704:
		return DecodeNxmTunMetadata57Masked(_oxm, decoder)
	case 69636:
		return DecodeNxmReg8(_oxm, decoder)
	case 87676:
		return DecodeNxmTunMetadata3(_oxm, decoder)
	case 82184:
		return DecodeOxmTunnelIpv4DstMasked(_oxm, decoder)
	case 203268:
		return DecodeOxmBsnUdf5(_oxm, decoder)
	case 2147492354:
		return DecodeOxmSctpSrc(_oxm, decoder)
	case 2147493377:
		return DecodeOxmIcmpv4Type(_oxm, decoder)
	case 116728:
		return DecodeNxmTunMetadata59Masked(_oxm, decoder)
	case 88700:
		return DecodeNxmTunMetadata5(_oxm, decoder)
	case 73220:
		return DecodeNxmReg15(_oxm, decoder)
	case 76289:
		return DecodeNxmIcmpv6Type(_oxm, decoder)
	case 117752:
		return DecodeNxmTunMetadata61Masked(_oxm, decoder)
	case 4360:
		return DecodeNxmIpDstMasked(_oxm, decoder)
	case 89724:
		return DecodeNxmTunMetadata7(_oxm, decoder)
	case 8708:
		return DecodeNxmArpTpa(_oxm, decoder)
	case 2147494402:
		return DecodeOxmArpOp(_oxm, decoder)
	case 118776:
		return DecodeNxmTunMetadata63Masked(_oxm, decoder)
	case 199944:
		return DecodeOxmBsnL3DstClassIdMasked(_oxm, decoder)
	case 90748:
		return DecodeNxmTunMetadata9(_oxm, decoder)
	case 86520:
		return DecodeNxmTunMetadata0Masked(_oxm, decoder)
	case 2147487490:
		return DecodeOxmVlanPcpMasked(_oxm, decoder)
	case 2147492100:
		return DecodeOxmUdpDstMasked(_oxm, decoder)
	case 2147501320:
		return DecodeOxmMplsLabelMasked(_oxm, decoder)
	case 197124:
		return DecodeOxmBsnLagId(_oxm, decoder)
	case 78849:
		return DecodeNxmIpFrag(_oxm, decoder)
	case 2147490818:
		return DecodeOxmTcpDst(_oxm, decoder)
	case 200708:
		return DecodeOxmBsnUdf0(_oxm, decoder)
	case 91772:
		return DecodeNxmTunMetadata11(_oxm, decoder)
	case 87544:
		return DecodeNxmTunMetadata2Masked(_oxm, decoder)
	case 92796:
		return DecodeNxmTunMetadata13(_oxm, decoder)
	case 88568:
		return DecodeNxmTunMetadata4Masked(_oxm, decoder)
	case 2147495428:
		return DecodeOxmArpTpa(_oxm, decoder)
	case 80385:
		return DecodeNxmNwTtl(_oxm, decoder)
	case 105976:
		return DecodeNxmTunMetadata38Masked(_oxm, decoder)
	case 126465:
		return DecodeOxmConnTrackingNwProto(_oxm, decoder)
	case 7682:
		return DecodeNxmArpOp(_oxm, decoder)
	case 71172:
		return DecodeNxmReg11(_oxm, decoder)
	case 2147485190:
		return DecodeOxmEthDst(_oxm, decoder)
	case 2147499266:
		return DecodeOxmIcmpv6CodeMasked(_oxm, decoder)
	case 128528:
		return DecodeOxmConnTrackingIpv6Dst(_oxm, decoder)
	case 85252:
		return DecodeNxmTunGbpIdMasked(_oxm, decoder)
	case 90616:
		return DecodeNxmTunMetadata8Masked(_oxm, decoder)
	case 79364:
		return DecodeNxmIpv6Label(_oxm, decoder)
	case 207112:
		return DecodeOxmBsnIngressPortGroupIdMasked(_oxm, decoder)
	case 2147489796:
		return DecodeOxmIpv4Dst(_oxm, decoder)
	case 206400:
		return DecodeOxmBsnInPorts512(_oxm, decoder)
	case 95868:
		return DecodeNxmTunMetadata19(_oxm, decoder)
	case 91640:
		return DecodeNxmTunMetadata10Masked(_oxm, decoder)
	case 2147485964:
		return DecodeOxmEthSrcMasked(_oxm, decoder)
	case 2147496454:
		return DecodeOxmArpTha(_oxm, decoder)
	case 2147491842:
		return DecodeOxmUdpDst(_oxm, decoder)
	case 2147501569:
		return DecodeOxmMplsTc(_oxm, decoder)
	case 70920:
		return DecodeNxmReg10Masked(_oxm, decoder)
	case 96892:
		return DecodeNxmTunMetadata21(_oxm, decoder)
	case 92664:
		return DecodeNxmTunMetadata12Masked(_oxm, decoder)
	case 205060:
		return DecodeOxmBsnTcpFlagsMasked(_oxm, decoder)
	case 81412:
		return DecodeOxmTunnelIpv4Src(_oxm, decoder)
	case 99964:
		return DecodeNxmTunMetadata27(_oxm, decoder)
	case 71684:
		return DecodeNxmReg12(_oxm, decoder)
	case 127240:
		return DecodeOxmConnTrackingNwSrcMasked(_oxm, decoder)
	case 97916:
		return DecodeNxmTunMetadata23(_oxm, decoder)
	case 93688:
		return DecodeNxmTunMetadata14Masked(_oxm, decoder)
	case 82436:
		return DecodeNxmPktMark(_oxm, decoder)
	case 85505:
		return DecodeNxmTunGbpFlags(_oxm, decoder)
	case 98940:
		return DecodeNxmTunMetadata25(_oxm, decoder)
	case 94712:
		return DecodeNxmTunMetadata16Masked(_oxm, decoder)
	case 83460:
		return DecodeNxmDpHash(_oxm, decoder)
	case 2147490056:
		return DecodeOxmIpv4DstMasked(_oxm, decoder)
	case 123168:
		return DecodeNxmXxreg1Masked(_oxm, decoder)
	case 118786:
		return DecodeNxmTunFlags(_oxm, decoder)
	case 95736:
		return DecodeNxmTunMetadata18Masked(_oxm, decoder)
	case 2308:
		return DecodeNxmVlanTciMasked(_oxm, decoder)
	case 2147488002:
		return DecodeOxmIpDscpMasked(_oxm, decoder)
	case 100988:
		return DecodeNxmTunMetadata29(_oxm, decoder)
	case 119810:
		return DecodeOxmConnTrackingZone(_oxm, decoder)
	case 96760:
		return DecodeNxmTunMetadata20Masked(_oxm, decoder)
	case 2147486980:
		return DecodeOxmVlanVidMasked(_oxm, decoder)
	case 116348:
		return DecodeNxmTunMetadata59(_oxm, decoder)
	case 5378:
		return DecodeNxmTcpDstMasked(_oxm, decoder)
	case 71944:
		return DecodeNxmReg12Masked(_oxm, decoder)
	case 2147483912:
		return DecodeOxmInPortMasked(_oxm, decoder)
	case 75552:
		return DecodeNxmIpv6SrcMasked(_oxm, decoder)
	case 102012:
		return DecodeNxmTunMetadata31(_oxm, decoder)
	case 2147493634:
		return DecodeOxmIcmpv4TypeMasked(_oxm, decoder)
	case 5892:
		return DecodeNxmUdpSrcMasked(_oxm, decoder)
	case 97784:
		return DecodeNxmTunMetadata22Masked(_oxm, decoder)
	case 66052:
		return DecodeNxmReg1(_oxm, decoder)
	case 67336:
		return DecodeNxmReg3Masked(_oxm, decoder)
	case 2147485452:
		return DecodeOxmEthDstMasked(_oxm, decoder)
	case 75280:
		return DecodeNxmIpv6Src(_oxm, decoder)
	case 197896:
		return DecodeOxmBsnVrfMasked(_oxm, decoder)
	case 122656:
		return DecodeNxmXxreg0Masked(_oxm, decoder)
	case 103036:
		return DecodeNxmTunMetadata33(_oxm, decoder)
	case 98808:
		return DecodeNxmTunMetadata24Masked(_oxm, decoder)
	case 67848:
		return DecodeNxmReg4Masked(_oxm, decoder)
	case 77600:
		return DecodeNxmNdTargetMasked(_oxm, decoder)
	case 104060:
		return DecodeNxmTunMetadata35(_oxm, decoder)
	case 99832:
		return DecodeNxmTunMetadata26Masked(_oxm, decoder)
	case 6404:
		return DecodeNxmUdpDstMasked(_oxm, decoder)
	case 77328:
		return DecodeNxmNdTarget(_oxm, decoder)
	case 68872:
		return DecodeNxmReg6Masked(_oxm, decoder)
	case 105084:
		return DecodeNxmTunMetadata37(_oxm, decoder)
	case 100856:
		return DecodeNxmTunMetadata28Masked(_oxm, decoder)
	case 2147491076:
		return DecodeOxmTcpDstMasked(_oxm, decoder)
	case 206082:
		return DecodeOxmBsnL2CacheHitMasked(_oxm, decoder)
	case 69896:
		return DecodeNxmReg8Masked(_oxm, decoder)
	case 2147497760:
		return DecodeOxmIpv6DstMasked(_oxm, decoder)
	case 206720:
		return DecodeOxmBsnInPorts512Masked(_oxm, decoder)
	case 106108:
		return DecodeNxmTunMetadata39(_oxm, decoder)
	case 101880:
		return DecodeNxmTunMetadata30Masked(_oxm, decoder)
	case 8452:
		return DecodeNxmArpSpaMasked(_oxm, decoder)
	case 66312:
		return DecodeNxmReg1Masked(_oxm, decoder)
	case 2147497488:
		return DecodeOxmIpv6Dst(_oxm, decoder)
	case 201992:
		return DecodeOxmBsnUdf2Masked(_oxm, decoder)
	case 107132:
		return DecodeNxmTunMetadata41(_oxm, decoder)
	case 102904:
		return DecodeNxmTunMetadata32Masked(_oxm, decoder)
	case 2147493124:
		return DecodeOxmSctpDstMasked(_oxm, decoder)
	case 67076:
		return DecodeNxmReg3(_oxm, decoder)
	case 119300:
		return DecodeOxmConnTrackingState(_oxm, decoder)
	case 203016:
		return DecodeOxmBsnUdf4Masked(_oxm, decoder)
	case 2147499808:
		return DecodeOxmIpv6NdTargetMasked(_oxm, decoder)
	case 108156:
		return DecodeNxmTunMetadata43(_oxm, decoder)
	case 103928:
		return DecodeNxmTunMetadata34Masked(_oxm, decoder)
	case 106488:
		return DecodeNxmTunMetadata39Masked(_oxm, decoder)
	case 201732:
		return DecodeOxmBsnUdf2(_oxm, decoder)
	case 2147499536:
		return DecodeOxmIpv6NdTarget(_oxm, decoder)
	case 72968:
		return DecodeNxmReg14Masked(_oxm, decoder)
	case 109180:
		return DecodeNxmTunMetadata45(_oxm, decoder)
	case 104952:
		return DecodeNxmTunMetadata36Masked(_oxm, decoder)
	case 93820:
		return DecodeNxmTunMetadata15(_oxm, decoder)
	case 79106:
		return DecodeNxmIpFragMasked(_oxm, decoder)
	case 108536:
		return DecodeNxmTunMetadata43Masked(_oxm, decoder)
	case 126980:
		return DecodeOxmConnTrackingNwSrc(_oxm, decoder)
	default:
		return nil, nil
	}
}

func NewOxm(_type_len uint32) *Oxm {
	obj := &Oxm{}
	obj.TypeLen = _type_len
	return obj
}

type NxmArpOp struct {
	*Oxm
	Value uint16
}

type INxmArpOp interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *NxmArpOp) GetValue() uint16 {
	return self.Value
}

func (self *NxmArpOp) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeNxmArpOp(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpOp, error) {
	_nxmarpop := &NxmArpOp{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("NxmArpOp packet too short: %d < 2", decoder.Length())
	}
	_nxmarpop.Value = uint16(decoder.ReadUint16())
	return _nxmarpop, nil
}

func NewNxmArpOp() *NxmArpOp {
	obj := &NxmArpOp{
		Oxm: NewOxm(7682),
	}
	return obj
}
func (self *NxmArpOp) GetOXMName() string {
	return "arp_op"
}

func (self *NxmArpOp) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmArpOp) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmArpSha struct {
	*Oxm
	Value net.HardwareAddr
}

type INxmArpSha interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
}

func (self *NxmArpSha) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *NxmArpSha) SetValue(v net.HardwareAddr) {
	self.Value = v
}

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmArpSha(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSha, error) {
	_nxmarpsha := &NxmArpSha{Oxm: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("NxmArpSha packet too short: %d < 6", decoder.Length())
	}
	_nxmarpsha.Value = net.HardwareAddr(decoder.Read(6))
	return _nxmarpsha, nil
}

func NewNxmArpSha() *NxmArpSha {
	obj := &NxmArpSha{
		Oxm: NewOxm(74246),
	}
	return obj
}
func (self *NxmArpSha) GetOXMName() string {
	return "arp_sha"
}

func (self *NxmArpSha) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmArpSha) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmArpShaMasked struct {
	*Oxm
	Value     net.HardwareAddr
	ValueMask net.HardwareAddr
}

type INxmArpShaMasked interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
	GetValueMask() net.HardwareAddr
}

func (self *NxmArpShaMasked) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *NxmArpShaMasked) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *NxmArpShaMasked) GetValueMask() net.HardwareAddr {
	return self.ValueMask
}

func (self *NxmArpShaMasked) SetValueMask(v net.HardwareAddr) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmArpShaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpShaMasked, error) {
	_nxmarpshamasked := &NxmArpShaMasked{Oxm: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("NxmArpShaMasked packet too short: %d < 12", decoder.Length())
	}
	_nxmarpshamasked.Value = net.HardwareAddr(decoder.Read(6))
	_nxmarpshamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
	return _nxmarpshamasked, nil
}

func NewNxmArpShaMasked() *NxmArpShaMasked {
	obj := &NxmArpShaMasked{
		Oxm: NewOxm(74507),
	}
	return obj
}
func (self *NxmArpShaMasked) GetOXMName() string {
	return "arp_sha_masked"
}

func (self *NxmArpShaMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmArpShaMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmArpShaMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmArpSpa struct {
	*Oxm
	Value net.IP
}

type INxmArpSpa interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *NxmArpSpa) GetValue() net.IP {
	return self.Value
}

func (self *NxmArpSpa) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To4())

	return nil
}

func DecodeNxmArpSpa(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSpa, error) {
	_nxmarpspa := &NxmArpSpa{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmArpSpa packet too short: %d < 4", decoder.Length())
	}
	_nxmarpspa.Value = net.IP(decoder.Read(4))
	return _nxmarpspa, nil
}

func NewNxmArpSpa() *NxmArpSpa {
	obj := &NxmArpSpa{
		Oxm: NewOxm(8196),
	}
	return obj
}
func (self *NxmArpSpa) GetOXMName() string {
	return "arp_spa"
}

func (self *NxmArpSpa) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmArpSpa) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmArpSpaMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type INxmArpSpaMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *NxmArpSpaMasked) GetValue() net.IP {
	return self.Value
}

func (self *NxmArpSpaMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *NxmArpSpaMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *NxmArpSpaMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To4())
	encoder.Write(self.ValueMask.To4())

	return nil
}

func DecodeNxmArpSpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSpaMasked, error) {
	_nxmarpspamasked := &NxmArpSpaMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmArpSpaMasked packet too short: %d < 8", decoder.Length())
	}
	_nxmarpspamasked.Value = net.IP(decoder.Read(4))
	_nxmarpspamasked.ValueMask = net.IP(decoder.Read(4))
	return _nxmarpspamasked, nil
}

func NewNxmArpSpaMasked() *NxmArpSpaMasked {
	obj := &NxmArpSpaMasked{
		Oxm: NewOxm(8452),
	}
	return obj
}
func (self *NxmArpSpaMasked) GetOXMName() string {
	return "arp_spa_masked"
}

func (self *NxmArpSpaMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmArpSpaMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmArpSpaMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmArpTha struct {
	*Oxm
	Value net.HardwareAddr
}

type INxmArpTha interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
}

func (self *NxmArpTha) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *NxmArpTha) SetValue(v net.HardwareAddr) {
	self.Value = v
}

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmArpTha(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTha, error) {
	_nxmarptha := &NxmArpTha{Oxm: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("NxmArpTha packet too short: %d < 6", decoder.Length())
	}
	_nxmarptha.Value = net.HardwareAddr(decoder.Read(6))
	return _nxmarptha, nil
}

func NewNxmArpTha() *NxmArpTha {
	obj := &NxmArpTha{
		Oxm: NewOxm(74758),
	}
	return obj
}
func (self *NxmArpTha) GetOXMName() string {
	return "arp_tha"
}

func (self *NxmArpTha) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmArpTha) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmArpThaMasked struct {
	*Oxm
	Value     net.HardwareAddr
	ValueMask net.HardwareAddr
}

type INxmArpThaMasked interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
	GetValueMask() net.HardwareAddr
}

func (self *NxmArpThaMasked) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *NxmArpThaMasked) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *NxmArpThaMasked) GetValueMask() net.HardwareAddr {
	return self.ValueMask
}

func (self *NxmArpThaMasked) SetValueMask(v net.HardwareAddr) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmArpThaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpThaMasked, error) {
	_nxmarpthamasked := &NxmArpThaMasked{Oxm: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("NxmArpThaMasked packet too short: %d < 12", decoder.Length())
	}
	_nxmarpthamasked.Value = net.HardwareAddr(decoder.Read(6))
	_nxmarpthamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
	return _nxmarpthamasked, nil
}

func NewNxmArpThaMasked() *NxmArpThaMasked {
	obj := &NxmArpThaMasked{
		Oxm: NewOxm(75019),
	}
	return obj
}
func (self *NxmArpThaMasked) GetOXMName() string {
	return "arp_tha_masked"
}

func (self *NxmArpThaMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmArpThaMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmArpThaMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmArpTpa struct {
	*Oxm
	Value net.IP
}

type INxmArpTpa interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *NxmArpTpa) GetValue() net.IP {
	return self.Value
}

func (self *NxmArpTpa) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To4())

	return nil
}

func DecodeNxmArpTpa(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTpa, error) {
	_nxmarptpa := &NxmArpTpa{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmArpTpa packet too short: %d < 4", decoder.Length())
	}
	_nxmarptpa.Value = net.IP(decoder.Read(4))
	return _nxmarptpa, nil
}

func NewNxmArpTpa() *NxmArpTpa {
	obj := &NxmArpTpa{
		Oxm: NewOxm(8708),
	}
	return obj
}
func (self *NxmArpTpa) GetOXMName() string {
	return "arp_tpa"
}

func (self *NxmArpTpa) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmArpTpa) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmArpTpaMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type INxmArpTpaMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *NxmArpTpaMasked) GetValue() net.IP {
	return self.Value
}

func (self *NxmArpTpaMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *NxmArpTpaMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *NxmArpTpaMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To4())
	encoder.Write(self.ValueMask.To4())

	return nil
}

func DecodeNxmArpTpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTpaMasked, error) {
	_nxmarptpamasked := &NxmArpTpaMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmArpTpaMasked packet too short: %d < 8", decoder.Length())
	}
	_nxmarptpamasked.Value = net.IP(decoder.Read(4))
	_nxmarptpamasked.ValueMask = net.IP(decoder.Read(4))
	return _nxmarptpamasked, nil
}

func NewNxmArpTpaMasked() *NxmArpTpaMasked {
	obj := &NxmArpTpaMasked{
		Oxm: NewOxm(8968),
	}
	return obj
}
func (self *NxmArpTpaMasked) GetOXMName() string {
	return "arp_tpa_masked"
}

func (self *NxmArpTpaMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmArpTpaMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmArpTpaMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmConjId struct {
	*Oxm
	Value uint32
}

type INxmConjId interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmConjId) GetValue() uint32 {
	return self.Value
}

func (self *NxmConjId) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmConjId(parent *Oxm, decoder *goloxi.Decoder) (*NxmConjId, error) {
	_nxmconjid := &NxmConjId{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmConjId packet too short: %d < 4", decoder.Length())
	}
	_nxmconjid.Value = uint32(decoder.ReadUint32())
	return _nxmconjid, nil
}

func NewNxmConjId() *NxmConjId {
	obj := &NxmConjId{
		Oxm: NewOxm(84484),
	}
	return obj
}
func (self *NxmConjId) GetOXMName() string {
	return "conj_id"
}

func (self *NxmConjId) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmConjId) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmCtIpv6Dst struct {
	*Oxm
	Value net.IP
}

type INxmCtIpv6Dst interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *NxmCtIpv6Dst) GetValue() net.IP {
	return self.Value
}

func (self *NxmCtIpv6Dst) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To16())

	return nil
}

func DecodeNxmCtIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6Dst, error) {
	_nxmctipv6dst := &NxmCtIpv6Dst{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("NxmCtIpv6Dst packet too short: %d < 16", decoder.Length())
	}
	_nxmctipv6dst.Value = net.IP(decoder.Read(16))
	return _nxmctipv6dst, nil
}

func NewNxmCtIpv6Dst() *NxmCtIpv6Dst {
	obj := &NxmCtIpv6Dst{
		Oxm: NewOxm(128528),
	}
	return obj
}
func (self *NxmCtIpv6Dst) GetOXMName() string {
	return "ct_ipv6_dst"
}

func (self *NxmCtIpv6Dst) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmCtIpv6Dst) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmCtIpv6DstMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type INxmCtIpv6DstMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *NxmCtIpv6DstMasked) GetValue() net.IP {
	return self.Value
}

func (self *NxmCtIpv6DstMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *NxmCtIpv6DstMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *NxmCtIpv6DstMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To16())
	encoder.Write(self.ValueMask.To16())

	return nil
}

func DecodeNxmCtIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6DstMasked, error) {
	_nxmctipv6dstmasked := &NxmCtIpv6DstMasked{Oxm: parent}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("NxmCtIpv6DstMasked packet too short: %d < 32", decoder.Length())
	}
	_nxmctipv6dstmasked.Value = net.IP(decoder.Read(16))
	_nxmctipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
	return _nxmctipv6dstmasked, nil
}

func NewNxmCtIpv6DstMasked() *NxmCtIpv6DstMasked {
	obj := &NxmCtIpv6DstMasked{
		Oxm: NewOxm(128800),
	}
	return obj
}
func (self *NxmCtIpv6DstMasked) GetOXMName() string {
	return "ct_ipv6_dst_masked"
}

func (self *NxmCtIpv6DstMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmCtIpv6DstMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmCtIpv6DstMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmCtIpv6Src struct {
	*Oxm
	Value net.IP
}

type INxmCtIpv6Src interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *NxmCtIpv6Src) GetValue() net.IP {
	return self.Value
}

func (self *NxmCtIpv6Src) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To16())

	return nil
}

func DecodeNxmCtIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6Src, error) {
	_nxmctipv6src := &NxmCtIpv6Src{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("NxmCtIpv6Src packet too short: %d < 16", decoder.Length())
	}
	_nxmctipv6src.Value = net.IP(decoder.Read(16))
	return _nxmctipv6src, nil
}

func NewNxmCtIpv6Src() *NxmCtIpv6Src {
	obj := &NxmCtIpv6Src{
		Oxm: NewOxm(128016),
	}
	return obj
}
func (self *NxmCtIpv6Src) GetOXMName() string {
	return "ct_ipv6_src"
}

func (self *NxmCtIpv6Src) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmCtIpv6Src) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmCtIpv6SrcMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type INxmCtIpv6SrcMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *NxmCtIpv6SrcMasked) GetValue() net.IP {
	return self.Value
}

func (self *NxmCtIpv6SrcMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *NxmCtIpv6SrcMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *NxmCtIpv6SrcMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To16())
	encoder.Write(self.ValueMask.To16())

	return nil
}

func DecodeNxmCtIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6SrcMasked, error) {
	_nxmctipv6srcmasked := &NxmCtIpv6SrcMasked{Oxm: parent}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("NxmCtIpv6SrcMasked packet too short: %d < 32", decoder.Length())
	}
	_nxmctipv6srcmasked.Value = net.IP(decoder.Read(16))
	_nxmctipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
	return _nxmctipv6srcmasked, nil
}

func NewNxmCtIpv6SrcMasked() *NxmCtIpv6SrcMasked {
	obj := &NxmCtIpv6SrcMasked{
		Oxm: NewOxm(128288),
	}
	return obj
}
func (self *NxmCtIpv6SrcMasked) GetOXMName() string {
	return "ct_ipv6_src_masked"
}

func (self *NxmCtIpv6SrcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmCtIpv6SrcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmCtIpv6SrcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmCtLabel struct {
	*Oxm
	Value uint128
}

type INxmCtLabel interface {
	goloxi.IOxm
	GetValue() uint128
}

func (self *NxmCtLabel) GetValue() uint128 {
	return self.Value
}

func (self *NxmCtLabel) SetValue(v uint128) {
	self.Value = v
}

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

	encoder.PutUint128(uint128(self.Value))

	return nil
}

func DecodeNxmCtLabel(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtLabel, error) {
	_nxmctlabel := &NxmCtLabel{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("NxmCtLabel packet too short: %d < 16", decoder.Length())
	}
	_nxmctlabel.Value = uint128(decoder.ReadUint128())
	return _nxmctlabel, nil
}

func NewNxmCtLabel() *NxmCtLabel {
	obj := &NxmCtLabel{
		Oxm: NewOxm(120848),
	}
	return obj
}
func (self *NxmCtLabel) GetOXMName() string {
	return "ct_label"
}

func (self *NxmCtLabel) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmCtLabel) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmCtLabelMasked struct {
	*Oxm
	Value     uint128
	ValueMask uint128
}

type INxmCtLabelMasked interface {
	goloxi.IOxm
	GetValue() uint128
	GetValueMask() uint128
}

func (self *NxmCtLabelMasked) GetValue() uint128 {
	return self.Value
}

func (self *NxmCtLabelMasked) SetValue(v uint128) {
	self.Value = v
}

func (self *NxmCtLabelMasked) GetValueMask() uint128 {
	return self.ValueMask
}

func (self *NxmCtLabelMasked) SetValueMask(v uint128) {
	self.ValueMask = v
}

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

	encoder.PutUint128(uint128(self.Value))
	encoder.PutUint128(uint128(self.ValueMask))

	return nil
}

func DecodeNxmCtLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtLabelMasked, error) {
	_nxmctlabelmasked := &NxmCtLabelMasked{Oxm: parent}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("NxmCtLabelMasked packet too short: %d < 32", decoder.Length())
	}
	_nxmctlabelmasked.Value = uint128(decoder.ReadUint128())
	_nxmctlabelmasked.ValueMask = uint128(decoder.ReadUint128())
	return _nxmctlabelmasked, nil
}

func NewNxmCtLabelMasked() *NxmCtLabelMasked {
	obj := &NxmCtLabelMasked{
		Oxm: NewOxm(121120),
	}
	return obj
}
func (self *NxmCtLabelMasked) GetOXMName() string {
	return "ct_label_masked"
}

func (self *NxmCtLabelMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmCtLabelMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmCtLabelMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmCtMark struct {
	*Oxm
	Value uint32
}

type INxmCtMark interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmCtMark) GetValue() uint32 {
	return self.Value
}

func (self *NxmCtMark) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmCtMark(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtMark, error) {
	_nxmctmark := &NxmCtMark{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmCtMark packet too short: %d < 4", decoder.Length())
	}
	_nxmctmark.Value = uint32(decoder.ReadUint32())
	return _nxmctmark, nil
}

func NewNxmCtMark() *NxmCtMark {
	obj := &NxmCtMark{
		Oxm: NewOxm(120324),
	}
	return obj
}
func (self *NxmCtMark) GetOXMName() string {
	return "ct_mark"
}

func (self *NxmCtMark) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmCtMark) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmCtMarkMasked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type INxmCtMarkMasked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *NxmCtMarkMasked) GetValue() uint32 {
	return self.Value
}

func (self *NxmCtMarkMasked) SetValue(v uint32) {
	self.Value = v
}

func (self *NxmCtMarkMasked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *NxmCtMarkMasked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeNxmCtMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtMarkMasked, error) {
	_nxmctmarkmasked := &NxmCtMarkMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmCtMarkMasked packet too short: %d < 8", decoder.Length())
	}
	_nxmctmarkmasked.Value = uint32(decoder.ReadUint32())
	_nxmctmarkmasked.ValueMask = uint32(decoder.ReadUint32())
	return _nxmctmarkmasked, nil
}

func NewNxmCtMarkMasked() *NxmCtMarkMasked {
	obj := &NxmCtMarkMasked{
		Oxm: NewOxm(120584),
	}
	return obj
}
func (self *NxmCtMarkMasked) GetOXMName() string {
	return "ct_mark_masked"
}

func (self *NxmCtMarkMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmCtMarkMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmCtMarkMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmCtNwDst struct {
	*Oxm
	Value net.IP
}

type INxmCtNwDst interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *NxmCtNwDst) GetValue() net.IP {
	return self.Value
}

func (self *NxmCtNwDst) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To4())

	return nil
}

func DecodeNxmCtNwDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwDst, error) {
	_nxmctnwdst := &NxmCtNwDst{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmCtNwDst packet too short: %d < 4", decoder.Length())
	}
	_nxmctnwdst.Value = net.IP(decoder.Read(4))
	return _nxmctnwdst, nil
}

func NewNxmCtNwDst() *NxmCtNwDst {
	obj := &NxmCtNwDst{
		Oxm: NewOxm(127492),
	}
	return obj
}
func (self *NxmCtNwDst) GetOXMName() string {
	return "ct_nw_dst"
}

func (self *NxmCtNwDst) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmCtNwDst) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmCtNwDstMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type INxmCtNwDstMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *NxmCtNwDstMasked) GetValue() net.IP {
	return self.Value
}

func (self *NxmCtNwDstMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *NxmCtNwDstMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *NxmCtNwDstMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To4())
	encoder.Write(self.ValueMask.To4())

	return nil
}

func DecodeNxmCtNwDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwDstMasked, error) {
	_nxmctnwdstmasked := &NxmCtNwDstMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmCtNwDstMasked packet too short: %d < 8", decoder.Length())
	}
	_nxmctnwdstmasked.Value = net.IP(decoder.Read(4))
	_nxmctnwdstmasked.ValueMask = net.IP(decoder.Read(4))
	return _nxmctnwdstmasked, nil
}

func NewNxmCtNwDstMasked() *NxmCtNwDstMasked {
	obj := &NxmCtNwDstMasked{
		Oxm: NewOxm(127752),
	}
	return obj
}
func (self *NxmCtNwDstMasked) GetOXMName() string {
	return "ct_nw_dst_masked"
}

func (self *NxmCtNwDstMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmCtNwDstMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmCtNwDstMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmCtNwProto struct {
	*Oxm
	Value uint8
}

type INxmCtNwProto interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *NxmCtNwProto) GetValue() uint8 {
	return self.Value
}

func (self *NxmCtNwProto) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeNxmCtNwProto(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwProto, error) {
	_nxmctnwproto := &NxmCtNwProto{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("NxmCtNwProto packet too short: %d < 1", decoder.Length())
	}
	_nxmctnwproto.Value = uint8(decoder.ReadByte())
	return _nxmctnwproto, nil
}

func NewNxmCtNwProto() *NxmCtNwProto {
	obj := &NxmCtNwProto{
		Oxm: NewOxm(126465),
	}
	return obj
}
func (self *NxmCtNwProto) GetOXMName() string {
	return "ct_nw_proto"
}

func (self *NxmCtNwProto) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmCtNwProto) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmCtNwSrc struct {
	*Oxm
	Value net.IP
}

type INxmCtNwSrc interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *NxmCtNwSrc) GetValue() net.IP {
	return self.Value
}

func (self *NxmCtNwSrc) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To4())

	return nil
}

func DecodeNxmCtNwSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwSrc, error) {
	_nxmctnwsrc := &NxmCtNwSrc{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmCtNwSrc packet too short: %d < 4", decoder.Length())
	}
	_nxmctnwsrc.Value = net.IP(decoder.Read(4))
	return _nxmctnwsrc, nil
}

func NewNxmCtNwSrc() *NxmCtNwSrc {
	obj := &NxmCtNwSrc{
		Oxm: NewOxm(126980),
	}
	return obj
}
func (self *NxmCtNwSrc) GetOXMName() string {
	return "ct_nw_src"
}

func (self *NxmCtNwSrc) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmCtNwSrc) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmCtNwSrcMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type INxmCtNwSrcMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *NxmCtNwSrcMasked) GetValue() net.IP {
	return self.Value
}

func (self *NxmCtNwSrcMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *NxmCtNwSrcMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *NxmCtNwSrcMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To4())
	encoder.Write(self.ValueMask.To4())

	return nil
}

func DecodeNxmCtNwSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwSrcMasked, error) {
	_nxmctnwsrcmasked := &NxmCtNwSrcMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmCtNwSrcMasked packet too short: %d < 8", decoder.Length())
	}
	_nxmctnwsrcmasked.Value = net.IP(decoder.Read(4))
	_nxmctnwsrcmasked.ValueMask = net.IP(decoder.Read(4))
	return _nxmctnwsrcmasked, nil
}

func NewNxmCtNwSrcMasked() *NxmCtNwSrcMasked {
	obj := &NxmCtNwSrcMasked{
		Oxm: NewOxm(127240),
	}
	return obj
}
func (self *NxmCtNwSrcMasked) GetOXMName() string {
	return "ct_nw_src_masked"
}

func (self *NxmCtNwSrcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmCtNwSrcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmCtNwSrcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmCtState struct {
	*Oxm
	Value []byte
}

type INxmCtState interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmCtState(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtState, error) {
	_nxmctstate := &NxmCtState{Oxm: parent}
	_nxmctstate.Value = decoder.Read(int(_nxmctstate.TypeLen & 0xFF))
	return _nxmctstate, nil
}

func NewNxmCtState() *NxmCtState {
	obj := &NxmCtState{
		Oxm: NewOxm(119300),
	}
	return obj
}
func (self *NxmCtState) GetOXMName() string {
	return "ct_state"
}

func (self *NxmCtState) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmCtState) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmCtStateMasked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmCtStateMasked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmCtStateMasked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmCtStateMasked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmCtStateMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtStateMasked, error) {
	_nxmctstatemasked := &NxmCtStateMasked{Oxm: parent}
	_nxmctstatemasked.Value = decoder.Read(int(_nxmctstatemasked.TypeLen & 0xFF))
	_nxmctstatemasked.ValueMask = decoder.Read(int(_nxmctstatemasked.TypeLen & 0xFF))
	return _nxmctstatemasked, nil
}

func NewNxmCtStateMasked() *NxmCtStateMasked {
	obj := &NxmCtStateMasked{
		Oxm: NewOxm(119560),
	}
	return obj
}
func (self *NxmCtStateMasked) GetOXMName() string {
	return "ct_state_masked"
}

func (self *NxmCtStateMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmCtStateMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmCtStateMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmCtTpDst struct {
	*Oxm
	Value uint16
}

type INxmCtTpDst interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *NxmCtTpDst) GetValue() uint16 {
	return self.Value
}

func (self *NxmCtTpDst) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeNxmCtTpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpDst, error) {
	_nxmcttpdst := &NxmCtTpDst{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("NxmCtTpDst packet too short: %d < 2", decoder.Length())
	}
	_nxmcttpdst.Value = uint16(decoder.ReadUint16())
	return _nxmcttpdst, nil
}

func NewNxmCtTpDst() *NxmCtTpDst {
	obj := &NxmCtTpDst{
		Oxm: NewOxm(129538),
	}
	return obj
}
func (self *NxmCtTpDst) GetOXMName() string {
	return "ct_tp_dst"
}

func (self *NxmCtTpDst) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmCtTpDst) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmCtTpDstMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type INxmCtTpDstMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *NxmCtTpDstMasked) GetValue() uint16 {
	return self.Value
}

func (self *NxmCtTpDstMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *NxmCtTpDstMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *NxmCtTpDstMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeNxmCtTpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpDstMasked, error) {
	_nxmcttpdstmasked := &NxmCtTpDstMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmCtTpDstMasked packet too short: %d < 4", decoder.Length())
	}
	_nxmcttpdstmasked.Value = uint16(decoder.ReadUint16())
	_nxmcttpdstmasked.ValueMask = uint16(decoder.ReadUint16())
	return _nxmcttpdstmasked, nil
}

func NewNxmCtTpDstMasked() *NxmCtTpDstMasked {
	obj := &NxmCtTpDstMasked{
		Oxm: NewOxm(129796),
	}
	return obj
}
func (self *NxmCtTpDstMasked) GetOXMName() string {
	return "ct_tp_dst_masked"
}

func (self *NxmCtTpDstMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmCtTpDstMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmCtTpDstMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmCtTpSrc struct {
	*Oxm
	Value uint16
}

type INxmCtTpSrc interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *NxmCtTpSrc) GetValue() uint16 {
	return self.Value
}

func (self *NxmCtTpSrc) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeNxmCtTpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpSrc, error) {
	_nxmcttpsrc := &NxmCtTpSrc{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("NxmCtTpSrc packet too short: %d < 2", decoder.Length())
	}
	_nxmcttpsrc.Value = uint16(decoder.ReadUint16())
	return _nxmcttpsrc, nil
}

func NewNxmCtTpSrc() *NxmCtTpSrc {
	obj := &NxmCtTpSrc{
		Oxm: NewOxm(129026),
	}
	return obj
}
func (self *NxmCtTpSrc) GetOXMName() string {
	return "ct_tp_src"
}

func (self *NxmCtTpSrc) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmCtTpSrc) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmCtTpSrcMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type INxmCtTpSrcMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *NxmCtTpSrcMasked) GetValue() uint16 {
	return self.Value
}

func (self *NxmCtTpSrcMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *NxmCtTpSrcMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *NxmCtTpSrcMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeNxmCtTpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpSrcMasked, error) {
	_nxmcttpsrcmasked := &NxmCtTpSrcMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmCtTpSrcMasked packet too short: %d < 4", decoder.Length())
	}
	_nxmcttpsrcmasked.Value = uint16(decoder.ReadUint16())
	_nxmcttpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
	return _nxmcttpsrcmasked, nil
}

func NewNxmCtTpSrcMasked() *NxmCtTpSrcMasked {
	obj := &NxmCtTpSrcMasked{
		Oxm: NewOxm(129284),
	}
	return obj
}
func (self *NxmCtTpSrcMasked) GetOXMName() string {
	return "ct_tp_src_masked"
}

func (self *NxmCtTpSrcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmCtTpSrcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmCtTpSrcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmCtZone struct {
	*Oxm
	Value uint16
}

type INxmCtZone interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *NxmCtZone) GetValue() uint16 {
	return self.Value
}

func (self *NxmCtZone) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeNxmCtZone(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtZone, error) {
	_nxmctzone := &NxmCtZone{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("NxmCtZone packet too short: %d < 2", decoder.Length())
	}
	_nxmctzone.Value = uint16(decoder.ReadUint16())
	return _nxmctzone, nil
}

func NewNxmCtZone() *NxmCtZone {
	obj := &NxmCtZone{
		Oxm: NewOxm(119810),
	}
	return obj
}
func (self *NxmCtZone) GetOXMName() string {
	return "ct_zone"
}

func (self *NxmCtZone) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmCtZone) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmDpHash struct {
	*Oxm
	Value uint32
}

type INxmDpHash interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmDpHash) GetValue() uint32 {
	return self.Value
}

func (self *NxmDpHash) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmDpHash(parent *Oxm, decoder *goloxi.Decoder) (*NxmDpHash, error) {
	_nxmdphash := &NxmDpHash{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmDpHash packet too short: %d < 4", decoder.Length())
	}
	_nxmdphash.Value = uint32(decoder.ReadUint32())
	return _nxmdphash, nil
}

func NewNxmDpHash() *NxmDpHash {
	obj := &NxmDpHash{
		Oxm: NewOxm(83460),
	}
	return obj
}
func (self *NxmDpHash) GetOXMName() string {
	return "dp_hash"
}

func (self *NxmDpHash) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmDpHash) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmDpHashMasked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type INxmDpHashMasked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *NxmDpHashMasked) GetValue() uint32 {
	return self.Value
}

func (self *NxmDpHashMasked) SetValue(v uint32) {
	self.Value = v
}

func (self *NxmDpHashMasked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *NxmDpHashMasked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeNxmDpHashMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmDpHashMasked, error) {
	_nxmdphashmasked := &NxmDpHashMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmDpHashMasked packet too short: %d < 8", decoder.Length())
	}
	_nxmdphashmasked.Value = uint32(decoder.ReadUint32())
	_nxmdphashmasked.ValueMask = uint32(decoder.ReadUint32())
	return _nxmdphashmasked, nil
}

func NewNxmDpHashMasked() *NxmDpHashMasked {
	obj := &NxmDpHashMasked{
		Oxm: NewOxm(83720),
	}
	return obj
}
func (self *NxmDpHashMasked) GetOXMName() string {
	return "dp_hash_masked"
}

func (self *NxmDpHashMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmDpHashMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmDpHashMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmEthDst struct {
	*Oxm
	Value net.HardwareAddr
}

type INxmEthDst interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
}

func (self *NxmEthDst) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *NxmEthDst) SetValue(v net.HardwareAddr) {
	self.Value = v
}

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmEthDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthDst, error) {
	_nxmethdst := &NxmEthDst{Oxm: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("NxmEthDst packet too short: %d < 6", decoder.Length())
	}
	_nxmethdst.Value = net.HardwareAddr(decoder.Read(6))
	return _nxmethdst, nil
}

func NewNxmEthDst() *NxmEthDst {
	obj := &NxmEthDst{
		Oxm: NewOxm(518),
	}
	return obj
}
func (self *NxmEthDst) GetOXMName() string {
	return "eth_dst"
}

func (self *NxmEthDst) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmEthDst) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmEthDstMasked struct {
	*Oxm
	Value     net.HardwareAddr
	ValueMask net.HardwareAddr
}

type INxmEthDstMasked interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
	GetValueMask() net.HardwareAddr
}

func (self *NxmEthDstMasked) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *NxmEthDstMasked) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *NxmEthDstMasked) GetValueMask() net.HardwareAddr {
	return self.ValueMask
}

func (self *NxmEthDstMasked) SetValueMask(v net.HardwareAddr) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmEthDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthDstMasked, error) {
	_nxmethdstmasked := &NxmEthDstMasked{Oxm: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("NxmEthDstMasked packet too short: %d < 12", decoder.Length())
	}
	_nxmethdstmasked.Value = net.HardwareAddr(decoder.Read(6))
	_nxmethdstmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
	return _nxmethdstmasked, nil
}

func NewNxmEthDstMasked() *NxmEthDstMasked {
	obj := &NxmEthDstMasked{
		Oxm: NewOxm(779),
	}
	return obj
}
func (self *NxmEthDstMasked) GetOXMName() string {
	return "eth_dst_masked"
}

func (self *NxmEthDstMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmEthDstMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmEthDstMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmEthSrc struct {
	*Oxm
	Value net.HardwareAddr
}

type INxmEthSrc interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
}

func (self *NxmEthSrc) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *NxmEthSrc) SetValue(v net.HardwareAddr) {
	self.Value = v
}

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmEthSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthSrc, error) {
	_nxmethsrc := &NxmEthSrc{Oxm: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("NxmEthSrc packet too short: %d < 6", decoder.Length())
	}
	_nxmethsrc.Value = net.HardwareAddr(decoder.Read(6))
	return _nxmethsrc, nil
}

func NewNxmEthSrc() *NxmEthSrc {
	obj := &NxmEthSrc{
		Oxm: NewOxm(1030),
	}
	return obj
}
func (self *NxmEthSrc) GetOXMName() string {
	return "eth_src"
}

func (self *NxmEthSrc) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmEthSrc) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmEthSrcMasked struct {
	*Oxm
	Value     net.HardwareAddr
	ValueMask net.HardwareAddr
}

type INxmEthSrcMasked interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
	GetValueMask() net.HardwareAddr
}

func (self *NxmEthSrcMasked) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *NxmEthSrcMasked) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *NxmEthSrcMasked) GetValueMask() net.HardwareAddr {
	return self.ValueMask
}

func (self *NxmEthSrcMasked) SetValueMask(v net.HardwareAddr) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmEthSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthSrcMasked, error) {
	_nxmethsrcmasked := &NxmEthSrcMasked{Oxm: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("NxmEthSrcMasked packet too short: %d < 12", decoder.Length())
	}
	_nxmethsrcmasked.Value = net.HardwareAddr(decoder.Read(6))
	_nxmethsrcmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
	return _nxmethsrcmasked, nil
}

func NewNxmEthSrcMasked() *NxmEthSrcMasked {
	obj := &NxmEthSrcMasked{
		Oxm: NewOxm(1286),
	}
	return obj
}
func (self *NxmEthSrcMasked) GetOXMName() string {
	return "eth_src_masked"
}

func (self *NxmEthSrcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmEthSrcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmEthSrcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmEthType struct {
	*Oxm
	Value uint16
}

type INxmEthType interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *NxmEthType) GetValue() uint16 {
	return self.Value
}

func (self *NxmEthType) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeNxmEthType(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthType, error) {
	_nxmethtype := &NxmEthType{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("NxmEthType packet too short: %d < 2", decoder.Length())
	}
	_nxmethtype.Value = uint16(decoder.ReadUint16())
	return _nxmethtype, nil
}

func NewNxmEthType() *NxmEthType {
	obj := &NxmEthType{
		Oxm: NewOxm(1538),
	}
	return obj
}
func (self *NxmEthType) GetOXMName() string {
	return "eth_type"
}

func (self *NxmEthType) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmEthType) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmIcmpCode struct {
	*Oxm
	Value uint8
}

type INxmIcmpCode interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *NxmIcmpCode) GetValue() uint8 {
	return self.Value
}

func (self *NxmIcmpCode) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeNxmIcmpCode(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpCode, error) {
	_nxmicmpcode := &NxmIcmpCode{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("NxmIcmpCode packet too short: %d < 1", decoder.Length())
	}
	_nxmicmpcode.Value = uint8(decoder.ReadByte())
	return _nxmicmpcode, nil
}

func NewNxmIcmpCode() *NxmIcmpCode {
	obj := &NxmIcmpCode{
		Oxm: NewOxm(7169),
	}
	return obj
}
func (self *NxmIcmpCode) GetOXMName() string {
	return "icmp_code"
}

func (self *NxmIcmpCode) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmIcmpCode) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmIcmpType struct {
	*Oxm
	Value uint8
}

type INxmIcmpType interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *NxmIcmpType) GetValue() uint8 {
	return self.Value
}

func (self *NxmIcmpType) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeNxmIcmpType(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpType, error) {
	_nxmicmptype := &NxmIcmpType{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("NxmIcmpType packet too short: %d < 1", decoder.Length())
	}
	_nxmicmptype.Value = uint8(decoder.ReadByte())
	return _nxmicmptype, nil
}

func NewNxmIcmpType() *NxmIcmpType {
	obj := &NxmIcmpType{
		Oxm: NewOxm(6657),
	}
	return obj
}
func (self *NxmIcmpType) GetOXMName() string {
	return "icmp_type"
}

func (self *NxmIcmpType) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmIcmpType) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmIcmpv6Code struct {
	*Oxm
	Value uint8
}

type INxmIcmpv6Code interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *NxmIcmpv6Code) GetValue() uint8 {
	return self.Value
}

func (self *NxmIcmpv6Code) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeNxmIcmpv6Code(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpv6Code, error) {
	_nxmicmpv6code := &NxmIcmpv6Code{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("NxmIcmpv6Code packet too short: %d < 1", decoder.Length())
	}
	_nxmicmpv6code.Value = uint8(decoder.ReadByte())
	return _nxmicmpv6code, nil
}

func NewNxmIcmpv6Code() *NxmIcmpv6Code {
	obj := &NxmIcmpv6Code{
		Oxm: NewOxm(76801),
	}
	return obj
}
func (self *NxmIcmpv6Code) GetOXMName() string {
	return "icmpv6_code"
}

func (self *NxmIcmpv6Code) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmIcmpv6Code) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmIcmpv6Type struct {
	*Oxm
	Value uint8
}

type INxmIcmpv6Type interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *NxmIcmpv6Type) GetValue() uint8 {
	return self.Value
}

func (self *NxmIcmpv6Type) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeNxmIcmpv6Type(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpv6Type, error) {
	_nxmicmpv6type := &NxmIcmpv6Type{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("NxmIcmpv6Type packet too short: %d < 1", decoder.Length())
	}
	_nxmicmpv6type.Value = uint8(decoder.ReadByte())
	return _nxmicmpv6type, nil
}

func NewNxmIcmpv6Type() *NxmIcmpv6Type {
	obj := &NxmIcmpv6Type{
		Oxm: NewOxm(76289),
	}
	return obj
}
func (self *NxmIcmpv6Type) GetOXMName() string {
	return "icmpv6_type"
}

func (self *NxmIcmpv6Type) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmIcmpv6Type) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmInPort struct {
	*Oxm
	Value Port
}

type INxmInPort interface {
	goloxi.IOxm
	GetValue() Port
}

func (self *NxmInPort) GetValue() Port {
	return self.Value
}

func (self *NxmInPort) SetValue(v Port) {
	self.Value = v
}

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

	self.Value.Serialize(encoder)

	return nil
}

func DecodeNxmInPort(parent *Oxm, decoder *goloxi.Decoder) (*NxmInPort, error) {
	_nxminport := &NxmInPort{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmInPort packet too short: %d < 4", decoder.Length())
	}
	_nxminport.Value.Decode(decoder)
	return _nxminport, nil
}

func NewNxmInPort() *NxmInPort {
	obj := &NxmInPort{
		Oxm: NewOxm(2),
	}
	return obj
}
func (self *NxmInPort) GetOXMName() string {
	return "in_port"
}

func (self *NxmInPort) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmInPort) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmIpDst struct {
	*Oxm
	Value net.IP
}

type INxmIpDst interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *NxmIpDst) GetValue() net.IP {
	return self.Value
}

func (self *NxmIpDst) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To4())

	return nil
}

func DecodeNxmIpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpDst, error) {
	_nxmipdst := &NxmIpDst{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmIpDst packet too short: %d < 4", decoder.Length())
	}
	_nxmipdst.Value = net.IP(decoder.Read(4))
	return _nxmipdst, nil
}

func NewNxmIpDst() *NxmIpDst {
	obj := &NxmIpDst{
		Oxm: NewOxm(4100),
	}
	return obj
}
func (self *NxmIpDst) GetOXMName() string {
	return "ip_dst"
}

func (self *NxmIpDst) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmIpDst) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmIpDstMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type INxmIpDstMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *NxmIpDstMasked) GetValue() net.IP {
	return self.Value
}

func (self *NxmIpDstMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *NxmIpDstMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *NxmIpDstMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To4())
	encoder.Write(self.ValueMask.To4())

	return nil
}

func DecodeNxmIpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpDstMasked, error) {
	_nxmipdstmasked := &NxmIpDstMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmIpDstMasked packet too short: %d < 8", decoder.Length())
	}
	_nxmipdstmasked.Value = net.IP(decoder.Read(4))
	_nxmipdstmasked.ValueMask = net.IP(decoder.Read(4))
	return _nxmipdstmasked, nil
}

func NewNxmIpDstMasked() *NxmIpDstMasked {
	obj := &NxmIpDstMasked{
		Oxm: NewOxm(4360),
	}
	return obj
}
func (self *NxmIpDstMasked) GetOXMName() string {
	return "ip_dst_masked"
}

func (self *NxmIpDstMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmIpDstMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmIpDstMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmIpFrag struct {
	*Oxm
	Value []byte
}

type INxmIpFrag interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmIpFrag(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpFrag, error) {
	_nxmipfrag := &NxmIpFrag{Oxm: parent}
	_nxmipfrag.Value = decoder.Read(int(_nxmipfrag.TypeLen & 0xFF))
	return _nxmipfrag, nil
}

func NewNxmIpFrag() *NxmIpFrag {
	obj := &NxmIpFrag{
		Oxm: NewOxm(78849),
	}
	return obj
}
func (self *NxmIpFrag) GetOXMName() string {
	return "ip_frag"
}

func (self *NxmIpFrag) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmIpFrag) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmIpFragMasked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmIpFragMasked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmIpFragMasked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmIpFragMasked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmIpFragMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpFragMasked, error) {
	_nxmipfragmasked := &NxmIpFragMasked{Oxm: parent}
	_nxmipfragmasked.Value = decoder.Read(int(_nxmipfragmasked.TypeLen & 0xFF))
	_nxmipfragmasked.ValueMask = decoder.Read(int(_nxmipfragmasked.TypeLen & 0xFF))
	return _nxmipfragmasked, nil
}

func NewNxmIpFragMasked() *NxmIpFragMasked {
	obj := &NxmIpFragMasked{
		Oxm: NewOxm(79106),
	}
	return obj
}
func (self *NxmIpFragMasked) GetOXMName() string {
	return "ip_frag_masked"
}

func (self *NxmIpFragMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmIpFragMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmIpFragMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmIpSrc struct {
	*Oxm
	Value net.IP
}

type INxmIpSrc interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *NxmIpSrc) GetValue() net.IP {
	return self.Value
}

func (self *NxmIpSrc) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To4())

	return nil
}

func DecodeNxmIpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpSrc, error) {
	_nxmipsrc := &NxmIpSrc{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmIpSrc packet too short: %d < 4", decoder.Length())
	}
	_nxmipsrc.Value = net.IP(decoder.Read(4))
	return _nxmipsrc, nil
}

func NewNxmIpSrc() *NxmIpSrc {
	obj := &NxmIpSrc{
		Oxm: NewOxm(3588),
	}
	return obj
}
func (self *NxmIpSrc) GetOXMName() string {
	return "ip_src"
}

func (self *NxmIpSrc) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmIpSrc) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmIpSrcMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type INxmIpSrcMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *NxmIpSrcMasked) GetValue() net.IP {
	return self.Value
}

func (self *NxmIpSrcMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *NxmIpSrcMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *NxmIpSrcMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To4())
	encoder.Write(self.ValueMask.To4())

	return nil
}

func DecodeNxmIpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpSrcMasked, error) {
	_nxmipsrcmasked := &NxmIpSrcMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmIpSrcMasked packet too short: %d < 8", decoder.Length())
	}
	_nxmipsrcmasked.Value = net.IP(decoder.Read(4))
	_nxmipsrcmasked.ValueMask = net.IP(decoder.Read(4))
	return _nxmipsrcmasked, nil
}

func NewNxmIpSrcMasked() *NxmIpSrcMasked {
	obj := &NxmIpSrcMasked{
		Oxm: NewOxm(3848),
	}
	return obj
}
func (self *NxmIpSrcMasked) GetOXMName() string {
	return "ip_src_masked"
}

func (self *NxmIpSrcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmIpSrcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmIpSrcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmIpv6Dst struct {
	*Oxm
	Value net.IP
}

type INxmIpv6Dst interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *NxmIpv6Dst) GetValue() net.IP {
	return self.Value
}

func (self *NxmIpv6Dst) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To16())

	return nil
}

func DecodeNxmIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Dst, error) {
	_nxmipv6dst := &NxmIpv6Dst{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("NxmIpv6Dst packet too short: %d < 16", decoder.Length())
	}
	_nxmipv6dst.Value = net.IP(decoder.Read(16))
	return _nxmipv6dst, nil
}

func NewNxmIpv6Dst() *NxmIpv6Dst {
	obj := &NxmIpv6Dst{
		Oxm: NewOxm(75792),
	}
	return obj
}
func (self *NxmIpv6Dst) GetOXMName() string {
	return "ipv6_dst"
}

func (self *NxmIpv6Dst) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmIpv6Dst) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmIpv6DstMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type INxmIpv6DstMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *NxmIpv6DstMasked) GetValue() net.IP {
	return self.Value
}

func (self *NxmIpv6DstMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *NxmIpv6DstMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *NxmIpv6DstMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To16())
	encoder.Write(self.ValueMask.To16())

	return nil
}

func DecodeNxmIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6DstMasked, error) {
	_nxmipv6dstmasked := &NxmIpv6DstMasked{Oxm: parent}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("NxmIpv6DstMasked packet too short: %d < 32", decoder.Length())
	}
	_nxmipv6dstmasked.Value = net.IP(decoder.Read(16))
	_nxmipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
	return _nxmipv6dstmasked, nil
}

func NewNxmIpv6DstMasked() *NxmIpv6DstMasked {
	obj := &NxmIpv6DstMasked{
		Oxm: NewOxm(76064),
	}
	return obj
}
func (self *NxmIpv6DstMasked) GetOXMName() string {
	return "ipv6_dst_masked"
}

func (self *NxmIpv6DstMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmIpv6DstMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmIpv6DstMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmIpv6Label struct {
	*Oxm
	Value uint32
}

type INxmIpv6Label interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmIpv6Label) GetValue() uint32 {
	return self.Value
}

func (self *NxmIpv6Label) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmIpv6Label(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Label, error) {
	_nxmipv6label := &NxmIpv6Label{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmIpv6Label packet too short: %d < 4", decoder.Length())
	}
	_nxmipv6label.Value = uint32(decoder.ReadUint32())
	return _nxmipv6label, nil
}

func NewNxmIpv6Label() *NxmIpv6Label {
	obj := &NxmIpv6Label{
		Oxm: NewOxm(79364),
	}
	return obj
}
func (self *NxmIpv6Label) GetOXMName() string {
	return "ipv6_label"
}

func (self *NxmIpv6Label) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmIpv6Label) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmIpv6LabelMasked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type INxmIpv6LabelMasked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *NxmIpv6LabelMasked) GetValue() uint32 {
	return self.Value
}

func (self *NxmIpv6LabelMasked) SetValue(v uint32) {
	self.Value = v
}

func (self *NxmIpv6LabelMasked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *NxmIpv6LabelMasked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeNxmIpv6LabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6LabelMasked, error) {
	_nxmipv6labelmasked := &NxmIpv6LabelMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmIpv6LabelMasked packet too short: %d < 8", decoder.Length())
	}
	_nxmipv6labelmasked.Value = uint32(decoder.ReadUint32())
	_nxmipv6labelmasked.ValueMask = uint32(decoder.ReadUint32())
	return _nxmipv6labelmasked, nil
}

func NewNxmIpv6LabelMasked() *NxmIpv6LabelMasked {
	obj := &NxmIpv6LabelMasked{
		Oxm: NewOxm(79624),
	}
	return obj
}
func (self *NxmIpv6LabelMasked) GetOXMName() string {
	return "ipv6_label_masked"
}

func (self *NxmIpv6LabelMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmIpv6LabelMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmIpv6LabelMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmIpv6Src struct {
	*Oxm
	Value net.IP
}

type INxmIpv6Src interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *NxmIpv6Src) GetValue() net.IP {
	return self.Value
}

func (self *NxmIpv6Src) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To16())

	return nil
}

func DecodeNxmIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Src, error) {
	_nxmipv6src := &NxmIpv6Src{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("NxmIpv6Src packet too short: %d < 16", decoder.Length())
	}
	_nxmipv6src.Value = net.IP(decoder.Read(16))
	return _nxmipv6src, nil
}

func NewNxmIpv6Src() *NxmIpv6Src {
	obj := &NxmIpv6Src{
		Oxm: NewOxm(75280),
	}
	return obj
}
func (self *NxmIpv6Src) GetOXMName() string {
	return "ipv6_src"
}

func (self *NxmIpv6Src) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmIpv6Src) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmIpv6SrcMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type INxmIpv6SrcMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *NxmIpv6SrcMasked) GetValue() net.IP {
	return self.Value
}

func (self *NxmIpv6SrcMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *NxmIpv6SrcMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *NxmIpv6SrcMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To16())
	encoder.Write(self.ValueMask.To16())

	return nil
}

func DecodeNxmIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6SrcMasked, error) {
	_nxmipv6srcmasked := &NxmIpv6SrcMasked{Oxm: parent}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("NxmIpv6SrcMasked packet too short: %d < 32", decoder.Length())
	}
	_nxmipv6srcmasked.Value = net.IP(decoder.Read(16))
	_nxmipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
	return _nxmipv6srcmasked, nil
}

func NewNxmIpv6SrcMasked() *NxmIpv6SrcMasked {
	obj := &NxmIpv6SrcMasked{
		Oxm: NewOxm(75552),
	}
	return obj
}
func (self *NxmIpv6SrcMasked) GetOXMName() string {
	return "ipv6_src_masked"
}

func (self *NxmIpv6SrcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmIpv6SrcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmIpv6SrcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmMplsTtl struct {
	*Oxm
	Value uint8
}

type INxmMplsTtl interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *NxmMplsTtl) GetValue() uint8 {
	return self.Value
}

func (self *NxmMplsTtl) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeNxmMplsTtl(parent *Oxm, decoder *goloxi.Decoder) (*NxmMplsTtl, error) {
	_nxmmplsttl := &NxmMplsTtl{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("NxmMplsTtl packet too short: %d < 1", decoder.Length())
	}
	_nxmmplsttl.Value = uint8(decoder.ReadByte())
	return _nxmmplsttl, nil
}

func NewNxmMplsTtl() *NxmMplsTtl {
	obj := &NxmMplsTtl{
		Oxm: NewOxm(80897),
	}
	return obj
}
func (self *NxmMplsTtl) GetOXMName() string {
	return "mpls_ttl"
}

func (self *NxmMplsTtl) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmMplsTtl) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmNdSll struct {
	*Oxm
	Value net.HardwareAddr
}

type INxmNdSll interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
}

func (self *NxmNdSll) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *NxmNdSll) SetValue(v net.HardwareAddr) {
	self.Value = v
}

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmNdSll(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdSll, error) {
	_nxmndsll := &NxmNdSll{Oxm: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("NxmNdSll packet too short: %d < 6", decoder.Length())
	}
	_nxmndsll.Value = net.HardwareAddr(decoder.Read(6))
	return _nxmndsll, nil
}

func NewNxmNdSll() *NxmNdSll {
	obj := &NxmNdSll{
		Oxm: NewOxm(77830),
	}
	return obj
}
func (self *NxmNdSll) GetOXMName() string {
	return "nd_sll"
}

func (self *NxmNdSll) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmNdSll) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmNdSllMasked struct {
	*Oxm
	Value     net.HardwareAddr
	ValueMask net.HardwareAddr
}

type INxmNdSllMasked interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
	GetValueMask() net.HardwareAddr
}

func (self *NxmNdSllMasked) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *NxmNdSllMasked) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *NxmNdSllMasked) GetValueMask() net.HardwareAddr {
	return self.ValueMask
}

func (self *NxmNdSllMasked) SetValueMask(v net.HardwareAddr) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmNdSllMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdSllMasked, error) {
	_nxmndsllmasked := &NxmNdSllMasked{Oxm: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("NxmNdSllMasked packet too short: %d < 12", decoder.Length())
	}
	_nxmndsllmasked.Value = net.HardwareAddr(decoder.Read(6))
	_nxmndsllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
	return _nxmndsllmasked, nil
}

func NewNxmNdSllMasked() *NxmNdSllMasked {
	obj := &NxmNdSllMasked{
		Oxm: NewOxm(78091),
	}
	return obj
}
func (self *NxmNdSllMasked) GetOXMName() string {
	return "nd_sll_masked"
}

func (self *NxmNdSllMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmNdSllMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmNdSllMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmNdTarget struct {
	*Oxm
	Value net.IP
}

type INxmNdTarget interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *NxmNdTarget) GetValue() net.IP {
	return self.Value
}

func (self *NxmNdTarget) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To16())

	return nil
}

func DecodeNxmNdTarget(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTarget, error) {
	_nxmndtarget := &NxmNdTarget{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("NxmNdTarget packet too short: %d < 16", decoder.Length())
	}
	_nxmndtarget.Value = net.IP(decoder.Read(16))
	return _nxmndtarget, nil
}

func NewNxmNdTarget() *NxmNdTarget {
	obj := &NxmNdTarget{
		Oxm: NewOxm(77328),
	}
	return obj
}
func (self *NxmNdTarget) GetOXMName() string {
	return "nd_target"
}

func (self *NxmNdTarget) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmNdTarget) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmNdTargetMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type INxmNdTargetMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *NxmNdTargetMasked) GetValue() net.IP {
	return self.Value
}

func (self *NxmNdTargetMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *NxmNdTargetMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *NxmNdTargetMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To16())
	encoder.Write(self.ValueMask.To16())

	return nil
}

func DecodeNxmNdTargetMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTargetMasked, error) {
	_nxmndtargetmasked := &NxmNdTargetMasked{Oxm: parent}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("NxmNdTargetMasked packet too short: %d < 32", decoder.Length())
	}
	_nxmndtargetmasked.Value = net.IP(decoder.Read(16))
	_nxmndtargetmasked.ValueMask = net.IP(decoder.Read(16))
	return _nxmndtargetmasked, nil
}

func NewNxmNdTargetMasked() *NxmNdTargetMasked {
	obj := &NxmNdTargetMasked{
		Oxm: NewOxm(77600),
	}
	return obj
}
func (self *NxmNdTargetMasked) GetOXMName() string {
	return "nd_target_masked"
}

func (self *NxmNdTargetMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmNdTargetMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmNdTargetMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmNdTll struct {
	*Oxm
	Value net.HardwareAddr
}

type INxmNdTll interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
}

func (self *NxmNdTll) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *NxmNdTll) SetValue(v net.HardwareAddr) {
	self.Value = v
}

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmNdTll(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTll, error) {
	_nxmndtll := &NxmNdTll{Oxm: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("NxmNdTll packet too short: %d < 6", decoder.Length())
	}
	_nxmndtll.Value = net.HardwareAddr(decoder.Read(6))
	return _nxmndtll, nil
}

func NewNxmNdTll() *NxmNdTll {
	obj := &NxmNdTll{
		Oxm: NewOxm(78342),
	}
	return obj
}
func (self *NxmNdTll) GetOXMName() string {
	return "nd_tll"
}

func (self *NxmNdTll) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmNdTll) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmNdTllMasked struct {
	*Oxm
	Value     net.HardwareAddr
	ValueMask net.HardwareAddr
}

type INxmNdTllMasked interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
	GetValueMask() net.HardwareAddr
}

func (self *NxmNdTllMasked) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *NxmNdTllMasked) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *NxmNdTllMasked) GetValueMask() net.HardwareAddr {
	return self.ValueMask
}

func (self *NxmNdTllMasked) SetValueMask(v net.HardwareAddr) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmNdTllMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTllMasked, error) {
	_nxmndtllmasked := &NxmNdTllMasked{Oxm: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("NxmNdTllMasked packet too short: %d < 12", decoder.Length())
	}
	_nxmndtllmasked.Value = net.HardwareAddr(decoder.Read(6))
	_nxmndtllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
	return _nxmndtllmasked, nil
}

func NewNxmNdTllMasked() *NxmNdTllMasked {
	obj := &NxmNdTllMasked{
		Oxm: NewOxm(78603),
	}
	return obj
}
func (self *NxmNdTllMasked) GetOXMName() string {
	return "nd_tll_masked"
}

func (self *NxmNdTllMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmNdTllMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmNdTllMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmNwEcn struct {
	*Oxm
	Value uint8
}

type INxmNwEcn interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *NxmNwEcn) GetValue() uint8 {
	return self.Value
}

func (self *NxmNwEcn) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeNxmNwEcn(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwEcn, error) {
	_nxmnwecn := &NxmNwEcn{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("NxmNwEcn packet too short: %d < 1", decoder.Length())
	}
	_nxmnwecn.Value = uint8(decoder.ReadByte())
	return _nxmnwecn, nil
}

func NewNxmNwEcn() *NxmNwEcn {
	obj := &NxmNwEcn{
		Oxm: NewOxm(79873),
	}
	return obj
}
func (self *NxmNwEcn) GetOXMName() string {
	return "nw_ecn"
}

func (self *NxmNwEcn) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmNwEcn) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmNwProto struct {
	*Oxm
	Value uint8
}

type INxmNwProto interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *NxmNwProto) GetValue() uint8 {
	return self.Value
}

func (self *NxmNwProto) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeNxmNwProto(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwProto, error) {
	_nxmnwproto := &NxmNwProto{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("NxmNwProto packet too short: %d < 1", decoder.Length())
	}
	_nxmnwproto.Value = uint8(decoder.ReadByte())
	return _nxmnwproto, nil
}

func NewNxmNwProto() *NxmNwProto {
	obj := &NxmNwProto{
		Oxm: NewOxm(3073),
	}
	return obj
}
func (self *NxmNwProto) GetOXMName() string {
	return "nw_proto"
}

func (self *NxmNwProto) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmNwProto) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmNwTos struct {
	*Oxm
	Value uint8
}

type INxmNwTos interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *NxmNwTos) GetValue() uint8 {
	return self.Value
}

func (self *NxmNwTos) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeNxmNwTos(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwTos, error) {
	_nxmnwtos := &NxmNwTos{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("NxmNwTos packet too short: %d < 1", decoder.Length())
	}
	_nxmnwtos.Value = uint8(decoder.ReadByte())
	return _nxmnwtos, nil
}

func NewNxmNwTos() *NxmNwTos {
	obj := &NxmNwTos{
		Oxm: NewOxm(2561),
	}
	return obj
}
func (self *NxmNwTos) GetOXMName() string {
	return "nw_tos"
}

func (self *NxmNwTos) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmNwTos) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmNwTtl struct {
	*Oxm
	Value uint8
}

type INxmNwTtl interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *NxmNwTtl) GetValue() uint8 {
	return self.Value
}

func (self *NxmNwTtl) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeNxmNwTtl(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwTtl, error) {
	_nxmnwttl := &NxmNwTtl{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("NxmNwTtl packet too short: %d < 1", decoder.Length())
	}
	_nxmnwttl.Value = uint8(decoder.ReadByte())
	return _nxmnwttl, nil
}

func NewNxmNwTtl() *NxmNwTtl {
	obj := &NxmNwTtl{
		Oxm: NewOxm(80385),
	}
	return obj
}
func (self *NxmNwTtl) GetOXMName() string {
	return "nw_ttl"
}

func (self *NxmNwTtl) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmNwTtl) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmPktMark struct {
	*Oxm
	Value uint32
}

type INxmPktMark interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmPktMark) GetValue() uint32 {
	return self.Value
}

func (self *NxmPktMark) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmPktMark(parent *Oxm, decoder *goloxi.Decoder) (*NxmPktMark, error) {
	_nxmpktmark := &NxmPktMark{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmPktMark packet too short: %d < 4", decoder.Length())
	}
	_nxmpktmark.Value = uint32(decoder.ReadUint32())
	return _nxmpktmark, nil
}

func NewNxmPktMark() *NxmPktMark {
	obj := &NxmPktMark{
		Oxm: NewOxm(82436),
	}
	return obj
}
func (self *NxmPktMark) GetOXMName() string {
	return "pkt_mark"
}

func (self *NxmPktMark) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmPktMark) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmPktMarkMasked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type INxmPktMarkMasked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *NxmPktMarkMasked) GetValue() uint32 {
	return self.Value
}

func (self *NxmPktMarkMasked) SetValue(v uint32) {
	self.Value = v
}

func (self *NxmPktMarkMasked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *NxmPktMarkMasked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeNxmPktMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmPktMarkMasked, error) {
	_nxmpktmarkmasked := &NxmPktMarkMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmPktMarkMasked packet too short: %d < 8", decoder.Length())
	}
	_nxmpktmarkmasked.Value = uint32(decoder.ReadUint32())
	_nxmpktmarkmasked.ValueMask = uint32(decoder.ReadUint32())
	return _nxmpktmarkmasked, nil
}

func NewNxmPktMarkMasked() *NxmPktMarkMasked {
	obj := &NxmPktMarkMasked{
		Oxm: NewOxm(82696),
	}
	return obj
}
func (self *NxmPktMarkMasked) GetOXMName() string {
	return "pkt_mark_masked"
}

func (self *NxmPktMarkMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmPktMarkMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmPktMarkMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmRecircId struct {
	*Oxm
	Value uint32
}

type INxmRecircId interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmRecircId) GetValue() uint32 {
	return self.Value
}

func (self *NxmRecircId) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmRecircId(parent *Oxm, decoder *goloxi.Decoder) (*NxmRecircId, error) {
	_nxmrecircid := &NxmRecircId{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmRecircId packet too short: %d < 4", decoder.Length())
	}
	_nxmrecircid.Value = uint32(decoder.ReadUint32())
	return _nxmrecircid, nil
}

func NewNxmRecircId() *NxmRecircId {
	obj := &NxmRecircId{
		Oxm: NewOxm(83972),
	}
	return obj
}
func (self *NxmRecircId) GetOXMName() string {
	return "recirc_id"
}

func (self *NxmRecircId) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmRecircId) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmReg0 struct {
	*Oxm
	Value uint32
}

type INxmReg0 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmReg0) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg0) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmReg0(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg0, error) {
	_nxmreg0 := &NxmReg0{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmReg0 packet too short: %d < 4", decoder.Length())
	}
	_nxmreg0.Value = uint32(decoder.ReadUint32())
	return _nxmreg0, nil
}

func NewNxmReg0() *NxmReg0 {
	obj := &NxmReg0{
		Oxm: NewOxm(65540),
	}
	return obj
}
func (self *NxmReg0) GetOXMName() string {
	return "reg0"
}

func (self *NxmReg0) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg0) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmReg0Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type INxmReg0Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *NxmReg0Masked) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg0Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *NxmReg0Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *NxmReg0Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeNxmReg0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg0Masked, error) {
	_nxmreg0masked := &NxmReg0Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmReg0Masked packet too short: %d < 8", decoder.Length())
	}
	_nxmreg0masked.Value = uint32(decoder.ReadUint32())
	_nxmreg0masked.ValueMask = uint32(decoder.ReadUint32())
	return _nxmreg0masked, nil
}

func NewNxmReg0Masked() *NxmReg0Masked {
	obj := &NxmReg0Masked{
		Oxm: NewOxm(65800),
	}
	return obj
}
func (self *NxmReg0Masked) GetOXMName() string {
	return "reg0_masked"
}

func (self *NxmReg0Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg0Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmReg0Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmReg1 struct {
	*Oxm
	Value uint32
}

type INxmReg1 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmReg1) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg1) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmReg1(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg1, error) {
	_nxmreg1 := &NxmReg1{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmReg1 packet too short: %d < 4", decoder.Length())
	}
	_nxmreg1.Value = uint32(decoder.ReadUint32())
	return _nxmreg1, nil
}

func NewNxmReg1() *NxmReg1 {
	obj := &NxmReg1{
		Oxm: NewOxm(66052),
	}
	return obj
}
func (self *NxmReg1) GetOXMName() string {
	return "reg1"
}

func (self *NxmReg1) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg1) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmReg10 struct {
	*Oxm
	Value uint32
}

type INxmReg10 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmReg10) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg10) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmReg10(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg10, error) {
	_nxmreg10 := &NxmReg10{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmReg10 packet too short: %d < 4", decoder.Length())
	}
	_nxmreg10.Value = uint32(decoder.ReadUint32())
	return _nxmreg10, nil
}

func NewNxmReg10() *NxmReg10 {
	obj := &NxmReg10{
		Oxm: NewOxm(70660),
	}
	return obj
}
func (self *NxmReg10) GetOXMName() string {
	return "reg10"
}

func (self *NxmReg10) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg10) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmReg10Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type INxmReg10Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *NxmReg10Masked) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg10Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *NxmReg10Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *NxmReg10Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeNxmReg10Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg10Masked, error) {
	_nxmreg10masked := &NxmReg10Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmReg10Masked packet too short: %d < 8", decoder.Length())
	}
	_nxmreg10masked.Value = uint32(decoder.ReadUint32())
	_nxmreg10masked.ValueMask = uint32(decoder.ReadUint32())
	return _nxmreg10masked, nil
}

func NewNxmReg10Masked() *NxmReg10Masked {
	obj := &NxmReg10Masked{
		Oxm: NewOxm(70920),
	}
	return obj
}
func (self *NxmReg10Masked) GetOXMName() string {
	return "reg10_masked"
}

func (self *NxmReg10Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg10Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmReg10Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmReg11 struct {
	*Oxm
	Value uint32
}

type INxmReg11 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmReg11) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg11) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmReg11(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg11, error) {
	_nxmreg11 := &NxmReg11{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmReg11 packet too short: %d < 4", decoder.Length())
	}
	_nxmreg11.Value = uint32(decoder.ReadUint32())
	return _nxmreg11, nil
}

func NewNxmReg11() *NxmReg11 {
	obj := &NxmReg11{
		Oxm: NewOxm(71172),
	}
	return obj
}
func (self *NxmReg11) GetOXMName() string {
	return "reg11"
}

func (self *NxmReg11) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg11) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmReg11Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type INxmReg11Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *NxmReg11Masked) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg11Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *NxmReg11Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *NxmReg11Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeNxmReg11Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg11Masked, error) {
	_nxmreg11masked := &NxmReg11Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmReg11Masked packet too short: %d < 8", decoder.Length())
	}
	_nxmreg11masked.Value = uint32(decoder.ReadUint32())
	_nxmreg11masked.ValueMask = uint32(decoder.ReadUint32())
	return _nxmreg11masked, nil
}

func NewNxmReg11Masked() *NxmReg11Masked {
	obj := &NxmReg11Masked{
		Oxm: NewOxm(71432),
	}
	return obj
}
func (self *NxmReg11Masked) GetOXMName() string {
	return "reg11_masked"
}

func (self *NxmReg11Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg11Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmReg11Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmReg12 struct {
	*Oxm
	Value uint32
}

type INxmReg12 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmReg12) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg12) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmReg12(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg12, error) {
	_nxmreg12 := &NxmReg12{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmReg12 packet too short: %d < 4", decoder.Length())
	}
	_nxmreg12.Value = uint32(decoder.ReadUint32())
	return _nxmreg12, nil
}

func NewNxmReg12() *NxmReg12 {
	obj := &NxmReg12{
		Oxm: NewOxm(71684),
	}
	return obj
}
func (self *NxmReg12) GetOXMName() string {
	return "reg12"
}

func (self *NxmReg12) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg12) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmReg12Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type INxmReg12Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *NxmReg12Masked) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg12Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *NxmReg12Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *NxmReg12Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeNxmReg12Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg12Masked, error) {
	_nxmreg12masked := &NxmReg12Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmReg12Masked packet too short: %d < 8", decoder.Length())
	}
	_nxmreg12masked.Value = uint32(decoder.ReadUint32())
	_nxmreg12masked.ValueMask = uint32(decoder.ReadUint32())
	return _nxmreg12masked, nil
}

func NewNxmReg12Masked() *NxmReg12Masked {
	obj := &NxmReg12Masked{
		Oxm: NewOxm(71944),
	}
	return obj
}
func (self *NxmReg12Masked) GetOXMName() string {
	return "reg12_masked"
}

func (self *NxmReg12Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg12Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmReg12Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmReg13 struct {
	*Oxm
	Value uint32
}

type INxmReg13 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmReg13) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg13) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmReg13(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg13, error) {
	_nxmreg13 := &NxmReg13{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmReg13 packet too short: %d < 4", decoder.Length())
	}
	_nxmreg13.Value = uint32(decoder.ReadUint32())
	return _nxmreg13, nil
}

func NewNxmReg13() *NxmReg13 {
	obj := &NxmReg13{
		Oxm: NewOxm(72196),
	}
	return obj
}
func (self *NxmReg13) GetOXMName() string {
	return "reg13"
}

func (self *NxmReg13) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg13) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmReg13Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type INxmReg13Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *NxmReg13Masked) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg13Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *NxmReg13Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *NxmReg13Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeNxmReg13Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg13Masked, error) {
	_nxmreg13masked := &NxmReg13Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmReg13Masked packet too short: %d < 8", decoder.Length())
	}
	_nxmreg13masked.Value = uint32(decoder.ReadUint32())
	_nxmreg13masked.ValueMask = uint32(decoder.ReadUint32())
	return _nxmreg13masked, nil
}

func NewNxmReg13Masked() *NxmReg13Masked {
	obj := &NxmReg13Masked{
		Oxm: NewOxm(72456),
	}
	return obj
}
func (self *NxmReg13Masked) GetOXMName() string {
	return "reg13_masked"
}

func (self *NxmReg13Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg13Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmReg13Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmReg14 struct {
	*Oxm
	Value uint32
}

type INxmReg14 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmReg14) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg14) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmReg14(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg14, error) {
	_nxmreg14 := &NxmReg14{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmReg14 packet too short: %d < 4", decoder.Length())
	}
	_nxmreg14.Value = uint32(decoder.ReadUint32())
	return _nxmreg14, nil
}

func NewNxmReg14() *NxmReg14 {
	obj := &NxmReg14{
		Oxm: NewOxm(72708),
	}
	return obj
}
func (self *NxmReg14) GetOXMName() string {
	return "reg14"
}

func (self *NxmReg14) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg14) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmReg14Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type INxmReg14Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *NxmReg14Masked) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg14Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *NxmReg14Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *NxmReg14Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeNxmReg14Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg14Masked, error) {
	_nxmreg14masked := &NxmReg14Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmReg14Masked packet too short: %d < 8", decoder.Length())
	}
	_nxmreg14masked.Value = uint32(decoder.ReadUint32())
	_nxmreg14masked.ValueMask = uint32(decoder.ReadUint32())
	return _nxmreg14masked, nil
}

func NewNxmReg14Masked() *NxmReg14Masked {
	obj := &NxmReg14Masked{
		Oxm: NewOxm(72968),
	}
	return obj
}
func (self *NxmReg14Masked) GetOXMName() string {
	return "reg14_masked"
}

func (self *NxmReg14Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg14Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmReg14Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmReg15 struct {
	*Oxm
	Value uint32
}

type INxmReg15 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmReg15) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg15) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmReg15(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg15, error) {
	_nxmreg15 := &NxmReg15{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmReg15 packet too short: %d < 4", decoder.Length())
	}
	_nxmreg15.Value = uint32(decoder.ReadUint32())
	return _nxmreg15, nil
}

func NewNxmReg15() *NxmReg15 {
	obj := &NxmReg15{
		Oxm: NewOxm(73220),
	}
	return obj
}
func (self *NxmReg15) GetOXMName() string {
	return "reg15"
}

func (self *NxmReg15) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg15) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmReg15Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type INxmReg15Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *NxmReg15Masked) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg15Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *NxmReg15Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *NxmReg15Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeNxmReg15Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg15Masked, error) {
	_nxmreg15masked := &NxmReg15Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmReg15Masked packet too short: %d < 8", decoder.Length())
	}
	_nxmreg15masked.Value = uint32(decoder.ReadUint32())
	_nxmreg15masked.ValueMask = uint32(decoder.ReadUint32())
	return _nxmreg15masked, nil
}

func NewNxmReg15Masked() *NxmReg15Masked {
	obj := &NxmReg15Masked{
		Oxm: NewOxm(73480),
	}
	return obj
}
func (self *NxmReg15Masked) GetOXMName() string {
	return "reg15_masked"
}

func (self *NxmReg15Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg15Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmReg15Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmReg1Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type INxmReg1Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *NxmReg1Masked) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg1Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *NxmReg1Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *NxmReg1Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeNxmReg1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg1Masked, error) {
	_nxmreg1masked := &NxmReg1Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmReg1Masked packet too short: %d < 8", decoder.Length())
	}
	_nxmreg1masked.Value = uint32(decoder.ReadUint32())
	_nxmreg1masked.ValueMask = uint32(decoder.ReadUint32())
	return _nxmreg1masked, nil
}

func NewNxmReg1Masked() *NxmReg1Masked {
	obj := &NxmReg1Masked{
		Oxm: NewOxm(66312),
	}
	return obj
}
func (self *NxmReg1Masked) GetOXMName() string {
	return "reg1_masked"
}

func (self *NxmReg1Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg1Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmReg1Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmReg2 struct {
	*Oxm
	Value uint32
}

type INxmReg2 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmReg2) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg2) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmReg2(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg2, error) {
	_nxmreg2 := &NxmReg2{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmReg2 packet too short: %d < 4", decoder.Length())
	}
	_nxmreg2.Value = uint32(decoder.ReadUint32())
	return _nxmreg2, nil
}

func NewNxmReg2() *NxmReg2 {
	obj := &NxmReg2{
		Oxm: NewOxm(66564),
	}
	return obj
}
func (self *NxmReg2) GetOXMName() string {
	return "reg2"
}

func (self *NxmReg2) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg2) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmReg2Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type INxmReg2Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *NxmReg2Masked) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg2Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *NxmReg2Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *NxmReg2Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeNxmReg2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg2Masked, error) {
	_nxmreg2masked := &NxmReg2Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmReg2Masked packet too short: %d < 8", decoder.Length())
	}
	_nxmreg2masked.Value = uint32(decoder.ReadUint32())
	_nxmreg2masked.ValueMask = uint32(decoder.ReadUint32())
	return _nxmreg2masked, nil
}

func NewNxmReg2Masked() *NxmReg2Masked {
	obj := &NxmReg2Masked{
		Oxm: NewOxm(66824),
	}
	return obj
}
func (self *NxmReg2Masked) GetOXMName() string {
	return "reg2_masked"
}

func (self *NxmReg2Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg2Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmReg2Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmReg3 struct {
	*Oxm
	Value uint32
}

type INxmReg3 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmReg3) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg3) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmReg3(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg3, error) {
	_nxmreg3 := &NxmReg3{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmReg3 packet too short: %d < 4", decoder.Length())
	}
	_nxmreg3.Value = uint32(decoder.ReadUint32())
	return _nxmreg3, nil
}

func NewNxmReg3() *NxmReg3 {
	obj := &NxmReg3{
		Oxm: NewOxm(67076),
	}
	return obj
}
func (self *NxmReg3) GetOXMName() string {
	return "reg3"
}

func (self *NxmReg3) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg3) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmReg3Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type INxmReg3Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *NxmReg3Masked) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg3Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *NxmReg3Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *NxmReg3Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeNxmReg3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg3Masked, error) {
	_nxmreg3masked := &NxmReg3Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmReg3Masked packet too short: %d < 8", decoder.Length())
	}
	_nxmreg3masked.Value = uint32(decoder.ReadUint32())
	_nxmreg3masked.ValueMask = uint32(decoder.ReadUint32())
	return _nxmreg3masked, nil
}

func NewNxmReg3Masked() *NxmReg3Masked {
	obj := &NxmReg3Masked{
		Oxm: NewOxm(67336),
	}
	return obj
}
func (self *NxmReg3Masked) GetOXMName() string {
	return "reg3_masked"
}

func (self *NxmReg3Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg3Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmReg3Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmReg4 struct {
	*Oxm
	Value uint32
}

type INxmReg4 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmReg4) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg4) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmReg4(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg4, error) {
	_nxmreg4 := &NxmReg4{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmReg4 packet too short: %d < 4", decoder.Length())
	}
	_nxmreg4.Value = uint32(decoder.ReadUint32())
	return _nxmreg4, nil
}

func NewNxmReg4() *NxmReg4 {
	obj := &NxmReg4{
		Oxm: NewOxm(67588),
	}
	return obj
}
func (self *NxmReg4) GetOXMName() string {
	return "reg4"
}

func (self *NxmReg4) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg4) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmReg4Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type INxmReg4Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *NxmReg4Masked) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg4Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *NxmReg4Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *NxmReg4Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeNxmReg4Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg4Masked, error) {
	_nxmreg4masked := &NxmReg4Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmReg4Masked packet too short: %d < 8", decoder.Length())
	}
	_nxmreg4masked.Value = uint32(decoder.ReadUint32())
	_nxmreg4masked.ValueMask = uint32(decoder.ReadUint32())
	return _nxmreg4masked, nil
}

func NewNxmReg4Masked() *NxmReg4Masked {
	obj := &NxmReg4Masked{
		Oxm: NewOxm(67848),
	}
	return obj
}
func (self *NxmReg4Masked) GetOXMName() string {
	return "reg4_masked"
}

func (self *NxmReg4Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg4Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmReg4Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmReg5 struct {
	*Oxm
	Value uint32
}

type INxmReg5 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmReg5) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg5) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmReg5(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg5, error) {
	_nxmreg5 := &NxmReg5{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmReg5 packet too short: %d < 4", decoder.Length())
	}
	_nxmreg5.Value = uint32(decoder.ReadUint32())
	return _nxmreg5, nil
}

func NewNxmReg5() *NxmReg5 {
	obj := &NxmReg5{
		Oxm: NewOxm(68100),
	}
	return obj
}
func (self *NxmReg5) GetOXMName() string {
	return "reg5"
}

func (self *NxmReg5) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg5) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmReg5Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type INxmReg5Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *NxmReg5Masked) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg5Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *NxmReg5Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *NxmReg5Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeNxmReg5Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg5Masked, error) {
	_nxmreg5masked := &NxmReg5Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmReg5Masked packet too short: %d < 8", decoder.Length())
	}
	_nxmreg5masked.Value = uint32(decoder.ReadUint32())
	_nxmreg5masked.ValueMask = uint32(decoder.ReadUint32())
	return _nxmreg5masked, nil
}

func NewNxmReg5Masked() *NxmReg5Masked {
	obj := &NxmReg5Masked{
		Oxm: NewOxm(68360),
	}
	return obj
}
func (self *NxmReg5Masked) GetOXMName() string {
	return "reg5_masked"
}

func (self *NxmReg5Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg5Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmReg5Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmReg6 struct {
	*Oxm
	Value uint32
}

type INxmReg6 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmReg6) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg6) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmReg6(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg6, error) {
	_nxmreg6 := &NxmReg6{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmReg6 packet too short: %d < 4", decoder.Length())
	}
	_nxmreg6.Value = uint32(decoder.ReadUint32())
	return _nxmreg6, nil
}

func NewNxmReg6() *NxmReg6 {
	obj := &NxmReg6{
		Oxm: NewOxm(68612),
	}
	return obj
}
func (self *NxmReg6) GetOXMName() string {
	return "reg6"
}

func (self *NxmReg6) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg6) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmReg6Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type INxmReg6Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *NxmReg6Masked) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg6Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *NxmReg6Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *NxmReg6Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeNxmReg6Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg6Masked, error) {
	_nxmreg6masked := &NxmReg6Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmReg6Masked packet too short: %d < 8", decoder.Length())
	}
	_nxmreg6masked.Value = uint32(decoder.ReadUint32())
	_nxmreg6masked.ValueMask = uint32(decoder.ReadUint32())
	return _nxmreg6masked, nil
}

func NewNxmReg6Masked() *NxmReg6Masked {
	obj := &NxmReg6Masked{
		Oxm: NewOxm(68872),
	}
	return obj
}
func (self *NxmReg6Masked) GetOXMName() string {
	return "reg6_masked"
}

func (self *NxmReg6Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg6Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmReg6Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmReg7 struct {
	*Oxm
	Value uint32
}

type INxmReg7 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmReg7) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg7) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmReg7(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg7, error) {
	_nxmreg7 := &NxmReg7{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmReg7 packet too short: %d < 4", decoder.Length())
	}
	_nxmreg7.Value = uint32(decoder.ReadUint32())
	return _nxmreg7, nil
}

func NewNxmReg7() *NxmReg7 {
	obj := &NxmReg7{
		Oxm: NewOxm(69124),
	}
	return obj
}
func (self *NxmReg7) GetOXMName() string {
	return "reg7"
}

func (self *NxmReg7) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg7) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmReg7Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type INxmReg7Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *NxmReg7Masked) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg7Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *NxmReg7Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *NxmReg7Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeNxmReg7Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg7Masked, error) {
	_nxmreg7masked := &NxmReg7Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmReg7Masked packet too short: %d < 8", decoder.Length())
	}
	_nxmreg7masked.Value = uint32(decoder.ReadUint32())
	_nxmreg7masked.ValueMask = uint32(decoder.ReadUint32())
	return _nxmreg7masked, nil
}

func NewNxmReg7Masked() *NxmReg7Masked {
	obj := &NxmReg7Masked{
		Oxm: NewOxm(69384),
	}
	return obj
}
func (self *NxmReg7Masked) GetOXMName() string {
	return "reg7_masked"
}

func (self *NxmReg7Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg7Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmReg7Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmReg8 struct {
	*Oxm
	Value uint32
}

type INxmReg8 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmReg8) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg8) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmReg8(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg8, error) {
	_nxmreg8 := &NxmReg8{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmReg8 packet too short: %d < 4", decoder.Length())
	}
	_nxmreg8.Value = uint32(decoder.ReadUint32())
	return _nxmreg8, nil
}

func NewNxmReg8() *NxmReg8 {
	obj := &NxmReg8{
		Oxm: NewOxm(69636),
	}
	return obj
}
func (self *NxmReg8) GetOXMName() string {
	return "reg8"
}

func (self *NxmReg8) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg8) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmReg8Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type INxmReg8Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *NxmReg8Masked) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg8Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *NxmReg8Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *NxmReg8Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeNxmReg8Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg8Masked, error) {
	_nxmreg8masked := &NxmReg8Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmReg8Masked packet too short: %d < 8", decoder.Length())
	}
	_nxmreg8masked.Value = uint32(decoder.ReadUint32())
	_nxmreg8masked.ValueMask = uint32(decoder.ReadUint32())
	return _nxmreg8masked, nil
}

func NewNxmReg8Masked() *NxmReg8Masked {
	obj := &NxmReg8Masked{
		Oxm: NewOxm(69896),
	}
	return obj
}
func (self *NxmReg8Masked) GetOXMName() string {
	return "reg8_masked"
}

func (self *NxmReg8Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg8Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmReg8Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmReg9 struct {
	*Oxm
	Value uint32
}

type INxmReg9 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *NxmReg9) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg9) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeNxmReg9(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg9, error) {
	_nxmreg9 := &NxmReg9{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmReg9 packet too short: %d < 4", decoder.Length())
	}
	_nxmreg9.Value = uint32(decoder.ReadUint32())
	return _nxmreg9, nil
}

func NewNxmReg9() *NxmReg9 {
	obj := &NxmReg9{
		Oxm: NewOxm(70148),
	}
	return obj
}
func (self *NxmReg9) GetOXMName() string {
	return "reg9"
}

func (self *NxmReg9) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg9) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmReg9Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type INxmReg9Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *NxmReg9Masked) GetValue() uint32 {
	return self.Value
}

func (self *NxmReg9Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *NxmReg9Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *NxmReg9Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeNxmReg9Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg9Masked, error) {
	_nxmreg9masked := &NxmReg9Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmReg9Masked packet too short: %d < 8", decoder.Length())
	}
	_nxmreg9masked.Value = uint32(decoder.ReadUint32())
	_nxmreg9masked.ValueMask = uint32(decoder.ReadUint32())
	return _nxmreg9masked, nil
}

func NewNxmReg9Masked() *NxmReg9Masked {
	obj := &NxmReg9Masked{
		Oxm: NewOxm(70408),
	}
	return obj
}
func (self *NxmReg9Masked) GetOXMName() string {
	return "reg9_masked"
}

func (self *NxmReg9Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmReg9Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmReg9Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTcpDst struct {
	*Oxm
	Value uint16
}

type INxmTcpDst interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *NxmTcpDst) GetValue() uint16 {
	return self.Value
}

func (self *NxmTcpDst) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeNxmTcpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpDst, error) {
	_nxmtcpdst := &NxmTcpDst{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("NxmTcpDst packet too short: %d < 2", decoder.Length())
	}
	_nxmtcpdst.Value = uint16(decoder.ReadUint16())
	return _nxmtcpdst, nil
}

func NewNxmTcpDst() *NxmTcpDst {
	obj := &NxmTcpDst{
		Oxm: NewOxm(5122),
	}
	return obj
}
func (self *NxmTcpDst) GetOXMName() string {
	return "tcp_dst"
}

func (self *NxmTcpDst) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTcpDst) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTcpDstMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type INxmTcpDstMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *NxmTcpDstMasked) GetValue() uint16 {
	return self.Value
}

func (self *NxmTcpDstMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *NxmTcpDstMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *NxmTcpDstMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeNxmTcpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpDstMasked, error) {
	_nxmtcpdstmasked := &NxmTcpDstMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmTcpDstMasked packet too short: %d < 4", decoder.Length())
	}
	_nxmtcpdstmasked.Value = uint16(decoder.ReadUint16())
	_nxmtcpdstmasked.ValueMask = uint16(decoder.ReadUint16())
	return _nxmtcpdstmasked, nil
}

func NewNxmTcpDstMasked() *NxmTcpDstMasked {
	obj := &NxmTcpDstMasked{
		Oxm: NewOxm(5378),
	}
	return obj
}
func (self *NxmTcpDstMasked) GetOXMName() string {
	return "tcp_dst_masked"
}

func (self *NxmTcpDstMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTcpDstMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTcpDstMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTcpFlags struct {
	*Oxm
	Value TcpFlags
}

type INxmTcpFlags interface {
	goloxi.IOxm
	GetValue() TcpFlags
}

func (self *NxmTcpFlags) GetValue() TcpFlags {
	return self.Value
}

func (self *NxmTcpFlags) SetValue(v TcpFlags) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeNxmTcpFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpFlags, error) {
	_nxmtcpflags := &NxmTcpFlags{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("NxmTcpFlags packet too short: %d < 2", decoder.Length())
	}
	_nxmtcpflags.Value = TcpFlags(decoder.ReadUint16())
	return _nxmtcpflags, nil
}

func NewNxmTcpFlags() *NxmTcpFlags {
	obj := &NxmTcpFlags{
		Oxm: NewOxm(82946),
	}
	return obj
}
func (self *NxmTcpFlags) GetOXMName() string {
	return "tcp_flags"
}

func (self *NxmTcpFlags) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTcpFlags) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTcpFlagsMasked struct {
	*Oxm
	Value     TcpFlags
	ValueMask uint16
}

type INxmTcpFlagsMasked interface {
	goloxi.IOxm
	GetValue() TcpFlags
	GetValueMask() uint16
}

func (self *NxmTcpFlagsMasked) GetValue() TcpFlags {
	return self.Value
}

func (self *NxmTcpFlagsMasked) SetValue(v TcpFlags) {
	self.Value = v
}

func (self *NxmTcpFlagsMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *NxmTcpFlagsMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeNxmTcpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpFlagsMasked, error) {
	_nxmtcpflagsmasked := &NxmTcpFlagsMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmTcpFlagsMasked packet too short: %d < 4", decoder.Length())
	}
	_nxmtcpflagsmasked.Value = TcpFlags(decoder.ReadUint16())
	_nxmtcpflagsmasked.ValueMask = uint16(decoder.ReadUint16())
	return _nxmtcpflagsmasked, nil
}

func NewNxmTcpFlagsMasked() *NxmTcpFlagsMasked {
	obj := &NxmTcpFlagsMasked{
		Oxm: NewOxm(83204),
	}
	return obj
}
func (self *NxmTcpFlagsMasked) GetOXMName() string {
	return "tcp_flags_masked"
}

func (self *NxmTcpFlagsMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTcpFlagsMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTcpFlagsMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTcpSrc struct {
	*Oxm
	Value uint16
}

type INxmTcpSrc interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *NxmTcpSrc) GetValue() uint16 {
	return self.Value
}

func (self *NxmTcpSrc) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeNxmTcpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpSrc, error) {
	_nxmtcpsrc := &NxmTcpSrc{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("NxmTcpSrc packet too short: %d < 2", decoder.Length())
	}
	_nxmtcpsrc.Value = uint16(decoder.ReadUint16())
	return _nxmtcpsrc, nil
}

func NewNxmTcpSrc() *NxmTcpSrc {
	obj := &NxmTcpSrc{
		Oxm: NewOxm(4610),
	}
	return obj
}
func (self *NxmTcpSrc) GetOXMName() string {
	return "tcp_src"
}

func (self *NxmTcpSrc) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTcpSrc) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTcpSrcMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type INxmTcpSrcMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *NxmTcpSrcMasked) GetValue() uint16 {
	return self.Value
}

func (self *NxmTcpSrcMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *NxmTcpSrcMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *NxmTcpSrcMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeNxmTcpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpSrcMasked, error) {
	_nxmtcpsrcmasked := &NxmTcpSrcMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmTcpSrcMasked packet too short: %d < 4", decoder.Length())
	}
	_nxmtcpsrcmasked.Value = uint16(decoder.ReadUint16())
	_nxmtcpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
	return _nxmtcpsrcmasked, nil
}

func NewNxmTcpSrcMasked() *NxmTcpSrcMasked {
	obj := &NxmTcpSrcMasked{
		Oxm: NewOxm(4868),
	}
	return obj
}
func (self *NxmTcpSrcMasked) GetOXMName() string {
	return "tcp_src_masked"
}

func (self *NxmTcpSrcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTcpSrcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTcpSrcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunDst struct {
	*Oxm
	Value net.IP
}

type INxmTunDst interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *NxmTunDst) GetValue() net.IP {
	return self.Value
}

func (self *NxmTunDst) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To4())

	return nil
}

func DecodeNxmTunDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunDst, error) {
	_nxmtundst := &NxmTunDst{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmTunDst packet too short: %d < 4", decoder.Length())
	}
	_nxmtundst.Value = net.IP(decoder.Read(4))
	return _nxmtundst, nil
}

func NewNxmTunDst() *NxmTunDst {
	obj := &NxmTunDst{
		Oxm: NewOxm(81924),
	}
	return obj
}
func (self *NxmTunDst) GetOXMName() string {
	return "tun_dst"
}

func (self *NxmTunDst) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunDst) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunDstMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type INxmTunDstMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *NxmTunDstMasked) GetValue() net.IP {
	return self.Value
}

func (self *NxmTunDstMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *NxmTunDstMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *NxmTunDstMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To4())
	encoder.Write(self.ValueMask.To4())

	return nil
}

func DecodeNxmTunDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunDstMasked, error) {
	_nxmtundstmasked := &NxmTunDstMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmTunDstMasked packet too short: %d < 8", decoder.Length())
	}
	_nxmtundstmasked.Value = net.IP(decoder.Read(4))
	_nxmtundstmasked.ValueMask = net.IP(decoder.Read(4))
	return _nxmtundstmasked, nil
}

func NewNxmTunDstMasked() *NxmTunDstMasked {
	obj := &NxmTunDstMasked{
		Oxm: NewOxm(82184),
	}
	return obj
}
func (self *NxmTunDstMasked) GetOXMName() string {
	return "tun_dst_masked"
}

func (self *NxmTunDstMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunDstMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunDstMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunFlags struct {
	*Oxm
	Value uint16
}

type INxmTunFlags interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *NxmTunFlags) GetValue() uint16 {
	return self.Value
}

func (self *NxmTunFlags) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeNxmTunFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunFlags, error) {
	_nxmtunflags := &NxmTunFlags{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("NxmTunFlags packet too short: %d < 2", decoder.Length())
	}
	_nxmtunflags.Value = uint16(decoder.ReadUint16())
	return _nxmtunflags, nil
}

func NewNxmTunFlags() *NxmTunFlags {
	obj := &NxmTunFlags{
		Oxm: NewOxm(118786),
	}
	return obj
}
func (self *NxmTunFlags) GetOXMName() string {
	return "tun_flags"
}

func (self *NxmTunFlags) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunFlags) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunFlagsMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type INxmTunFlagsMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *NxmTunFlagsMasked) GetValue() uint16 {
	return self.Value
}

func (self *NxmTunFlagsMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *NxmTunFlagsMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *NxmTunFlagsMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeNxmTunFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunFlagsMasked, error) {
	_nxmtunflagsmasked := &NxmTunFlagsMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmTunFlagsMasked packet too short: %d < 4", decoder.Length())
	}
	_nxmtunflagsmasked.Value = uint16(decoder.ReadUint16())
	_nxmtunflagsmasked.ValueMask = uint16(decoder.ReadUint16())
	return _nxmtunflagsmasked, nil
}

func NewNxmTunFlagsMasked() *NxmTunFlagsMasked {
	obj := &NxmTunFlagsMasked{
		Oxm: NewOxm(119044),
	}
	return obj
}
func (self *NxmTunFlagsMasked) GetOXMName() string {
	return "tun_flags_masked"
}

func (self *NxmTunFlagsMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunFlagsMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunFlagsMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunGbpFlags struct {
	*Oxm
	Value uint8
}

type INxmTunGbpFlags interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *NxmTunGbpFlags) GetValue() uint8 {
	return self.Value
}

func (self *NxmTunGbpFlags) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeNxmTunGbpFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpFlags, error) {
	_nxmtungbpflags := &NxmTunGbpFlags{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("NxmTunGbpFlags packet too short: %d < 1", decoder.Length())
	}
	_nxmtungbpflags.Value = uint8(decoder.ReadByte())
	return _nxmtungbpflags, nil
}

func NewNxmTunGbpFlags() *NxmTunGbpFlags {
	obj := &NxmTunGbpFlags{
		Oxm: NewOxm(85505),
	}
	return obj
}
func (self *NxmTunGbpFlags) GetOXMName() string {
	return "tun_gbp_flags"
}

func (self *NxmTunGbpFlags) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunGbpFlags) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunGbpFlagsMasked struct {
	*Oxm
	Value     uint8
	ValueMask uint8
}

type INxmTunGbpFlagsMasked interface {
	goloxi.IOxm
	GetValue() uint8
	GetValueMask() uint8
}

func (self *NxmTunGbpFlagsMasked) GetValue() uint8 {
	return self.Value
}

func (self *NxmTunGbpFlagsMasked) SetValue(v uint8) {
	self.Value = v
}

func (self *NxmTunGbpFlagsMasked) GetValueMask() uint8 {
	return self.ValueMask
}

func (self *NxmTunGbpFlagsMasked) SetValueMask(v uint8) {
	self.ValueMask = v
}

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

	encoder.PutUint8(uint8(self.Value))
	encoder.PutUint8(uint8(self.ValueMask))

	return nil
}

func DecodeNxmTunGbpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpFlagsMasked, error) {
	_nxmtungbpflagsmasked := &NxmTunGbpFlagsMasked{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("NxmTunGbpFlagsMasked packet too short: %d < 2", decoder.Length())
	}
	_nxmtungbpflagsmasked.Value = uint8(decoder.ReadByte())
	_nxmtungbpflagsmasked.ValueMask = uint8(decoder.ReadByte())
	return _nxmtungbpflagsmasked, nil
}

func NewNxmTunGbpFlagsMasked() *NxmTunGbpFlagsMasked {
	obj := &NxmTunGbpFlagsMasked{
		Oxm: NewOxm(85762),
	}
	return obj
}
func (self *NxmTunGbpFlagsMasked) GetOXMName() string {
	return "tun_gbp_flags_masked"
}

func (self *NxmTunGbpFlagsMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunGbpFlagsMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunGbpFlagsMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunGbpId struct {
	*Oxm
	Value uint16
}

type INxmTunGbpId interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *NxmTunGbpId) GetValue() uint16 {
	return self.Value
}

func (self *NxmTunGbpId) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeNxmTunGbpId(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpId, error) {
	_nxmtungbpid := &NxmTunGbpId{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("NxmTunGbpId packet too short: %d < 2", decoder.Length())
	}
	_nxmtungbpid.Value = uint16(decoder.ReadUint16())
	return _nxmtungbpid, nil
}

func NewNxmTunGbpId() *NxmTunGbpId {
	obj := &NxmTunGbpId{
		Oxm: NewOxm(84994),
	}
	return obj
}
func (self *NxmTunGbpId) GetOXMName() string {
	return "tun_gbp_id"
}

func (self *NxmTunGbpId) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunGbpId) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunGbpIdMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type INxmTunGbpIdMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *NxmTunGbpIdMasked) GetValue() uint16 {
	return self.Value
}

func (self *NxmTunGbpIdMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *NxmTunGbpIdMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *NxmTunGbpIdMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeNxmTunGbpIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpIdMasked, error) {
	_nxmtungbpidmasked := &NxmTunGbpIdMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmTunGbpIdMasked packet too short: %d < 4", decoder.Length())
	}
	_nxmtungbpidmasked.Value = uint16(decoder.ReadUint16())
	_nxmtungbpidmasked.ValueMask = uint16(decoder.ReadUint16())
	return _nxmtungbpidmasked, nil
}

func NewNxmTunGbpIdMasked() *NxmTunGbpIdMasked {
	obj := &NxmTunGbpIdMasked{
		Oxm: NewOxm(85252),
	}
	return obj
}
func (self *NxmTunGbpIdMasked) GetOXMName() string {
	return "tun_gbp_id_masked"
}

func (self *NxmTunGbpIdMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunGbpIdMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunGbpIdMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunId struct {
	*Oxm
	Value uint64
}

type INxmTunId interface {
	goloxi.IOxm
	GetValue() uint64
}

func (self *NxmTunId) GetValue() uint64 {
	return self.Value
}

func (self *NxmTunId) SetValue(v uint64) {
	self.Value = v
}

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

	encoder.PutUint64(uint64(self.Value))

	return nil
}

func DecodeNxmTunId(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunId, error) {
	_nxmtunid := &NxmTunId{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmTunId packet too short: %d < 8", decoder.Length())
	}
	_nxmtunid.Value = uint64(decoder.ReadUint64())
	return _nxmtunid, nil
}

func NewNxmTunId() *NxmTunId {
	obj := &NxmTunId{
		Oxm: NewOxm(73736),
	}
	return obj
}
func (self *NxmTunId) GetOXMName() string {
	return "tun_id"
}

func (self *NxmTunId) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunId) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunIdMasked struct {
	*Oxm
	Value     uint64
	ValueMask uint64
}

type INxmTunIdMasked interface {
	goloxi.IOxm
	GetValue() uint64
	GetValueMask() uint64
}

func (self *NxmTunIdMasked) GetValue() uint64 {
	return self.Value
}

func (self *NxmTunIdMasked) SetValue(v uint64) {
	self.Value = v
}

func (self *NxmTunIdMasked) GetValueMask() uint64 {
	return self.ValueMask
}

func (self *NxmTunIdMasked) SetValueMask(v uint64) {
	self.ValueMask = v
}

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

	encoder.PutUint64(uint64(self.Value))
	encoder.PutUint64(uint64(self.ValueMask))

	return nil
}

func DecodeNxmTunIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIdMasked, error) {
	_nxmtunidmasked := &NxmTunIdMasked{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("NxmTunIdMasked packet too short: %d < 16", decoder.Length())
	}
	_nxmtunidmasked.Value = uint64(decoder.ReadUint64())
	_nxmtunidmasked.ValueMask = uint64(decoder.ReadUint64())
	return _nxmtunidmasked, nil
}

func NewNxmTunIdMasked() *NxmTunIdMasked {
	obj := &NxmTunIdMasked{
		Oxm: NewOxm(74000),
	}
	return obj
}
func (self *NxmTunIdMasked) GetOXMName() string {
	return "tun_id_masked"
}

func (self *NxmTunIdMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunIdMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunIdMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunIpv6Dst struct {
	*Oxm
	Value net.IP
}

type INxmTunIpv6Dst interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *NxmTunIpv6Dst) GetValue() net.IP {
	return self.Value
}

func (self *NxmTunIpv6Dst) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To16())

	return nil
}

func DecodeNxmTunIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6Dst, error) {
	_nxmtunipv6dst := &NxmTunIpv6Dst{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("NxmTunIpv6Dst packet too short: %d < 16", decoder.Length())
	}
	_nxmtunipv6dst.Value = net.IP(decoder.Read(16))
	return _nxmtunipv6dst, nil
}

func NewNxmTunIpv6Dst() *NxmTunIpv6Dst {
	obj := &NxmTunIpv6Dst{
		Oxm: NewOxm(121872),
	}
	return obj
}
func (self *NxmTunIpv6Dst) GetOXMName() string {
	return "tun_ipv6_dst"
}

func (self *NxmTunIpv6Dst) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunIpv6Dst) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunIpv6DstMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type INxmTunIpv6DstMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *NxmTunIpv6DstMasked) GetValue() net.IP {
	return self.Value
}

func (self *NxmTunIpv6DstMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *NxmTunIpv6DstMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *NxmTunIpv6DstMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To16())
	encoder.Write(self.ValueMask.To16())

	return nil
}

func DecodeNxmTunIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6DstMasked, error) {
	_nxmtunipv6dstmasked := &NxmTunIpv6DstMasked{Oxm: parent}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("NxmTunIpv6DstMasked packet too short: %d < 32", decoder.Length())
	}
	_nxmtunipv6dstmasked.Value = net.IP(decoder.Read(16))
	_nxmtunipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
	return _nxmtunipv6dstmasked, nil
}

func NewNxmTunIpv6DstMasked() *NxmTunIpv6DstMasked {
	obj := &NxmTunIpv6DstMasked{
		Oxm: NewOxm(122144),
	}
	return obj
}
func (self *NxmTunIpv6DstMasked) GetOXMName() string {
	return "tun_ipv6_dst_masked"
}

func (self *NxmTunIpv6DstMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunIpv6DstMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunIpv6DstMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunIpv6Src struct {
	*Oxm
	Value net.IP
}

type INxmTunIpv6Src interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *NxmTunIpv6Src) GetValue() net.IP {
	return self.Value
}

func (self *NxmTunIpv6Src) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To16())

	return nil
}

func DecodeNxmTunIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6Src, error) {
	_nxmtunipv6src := &NxmTunIpv6Src{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("NxmTunIpv6Src packet too short: %d < 16", decoder.Length())
	}
	_nxmtunipv6src.Value = net.IP(decoder.Read(16))
	return _nxmtunipv6src, nil
}

func NewNxmTunIpv6Src() *NxmTunIpv6Src {
	obj := &NxmTunIpv6Src{
		Oxm: NewOxm(121360),
	}
	return obj
}
func (self *NxmTunIpv6Src) GetOXMName() string {
	return "tun_ipv6_src"
}

func (self *NxmTunIpv6Src) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunIpv6Src) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunIpv6SrcMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type INxmTunIpv6SrcMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *NxmTunIpv6SrcMasked) GetValue() net.IP {
	return self.Value
}

func (self *NxmTunIpv6SrcMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *NxmTunIpv6SrcMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *NxmTunIpv6SrcMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To16())
	encoder.Write(self.ValueMask.To16())

	return nil
}

func DecodeNxmTunIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6SrcMasked, error) {
	_nxmtunipv6srcmasked := &NxmTunIpv6SrcMasked{Oxm: parent}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("NxmTunIpv6SrcMasked packet too short: %d < 32", decoder.Length())
	}
	_nxmtunipv6srcmasked.Value = net.IP(decoder.Read(16))
	_nxmtunipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
	return _nxmtunipv6srcmasked, nil
}

func NewNxmTunIpv6SrcMasked() *NxmTunIpv6SrcMasked {
	obj := &NxmTunIpv6SrcMasked{
		Oxm: NewOxm(121632),
	}
	return obj
}
func (self *NxmTunIpv6SrcMasked) GetOXMName() string {
	return "tun_ipv6_src_masked"
}

func (self *NxmTunIpv6SrcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunIpv6SrcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunIpv6SrcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata0 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata0 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata0(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata0, error) {
	_nxmtunmetadata0 := &NxmTunMetadata0{Oxm: parent}
	_nxmtunmetadata0.Value = decoder.Read(int(_nxmtunmetadata0.TypeLen & 0xFF))
	return _nxmtunmetadata0, nil
}

func NewNxmTunMetadata0() *NxmTunMetadata0 {
	obj := &NxmTunMetadata0{
		Oxm: NewOxm(86140),
	}
	return obj
}
func (self *NxmTunMetadata0) GetOXMName() string {
	return "tun_metadata0"
}

func (self *NxmTunMetadata0) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata0) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata0Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata0Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata0Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata0Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata0Masked, error) {
	_nxmtunmetadata0masked := &NxmTunMetadata0Masked{Oxm: parent}
	_nxmtunmetadata0masked.Value = decoder.Read(int(_nxmtunmetadata0masked.TypeLen & 0xFF))
	_nxmtunmetadata0masked.ValueMask = decoder.Read(int(_nxmtunmetadata0masked.TypeLen & 0xFF))
	return _nxmtunmetadata0masked, nil
}

func NewNxmTunMetadata0Masked() *NxmTunMetadata0Masked {
	obj := &NxmTunMetadata0Masked{
		Oxm: NewOxm(86520),
	}
	return obj
}
func (self *NxmTunMetadata0Masked) GetOXMName() string {
	return "tun_metadata0_masked"
}

func (self *NxmTunMetadata0Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata0Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata0Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata1 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata1 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata1(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata1, error) {
	_nxmtunmetadata1 := &NxmTunMetadata1{Oxm: parent}
	_nxmtunmetadata1.Value = decoder.Read(int(_nxmtunmetadata1.TypeLen & 0xFF))
	return _nxmtunmetadata1, nil
}

func NewNxmTunMetadata1() *NxmTunMetadata1 {
	obj := &NxmTunMetadata1{
		Oxm: NewOxm(86652),
	}
	return obj
}
func (self *NxmTunMetadata1) GetOXMName() string {
	return "tun_metadata1"
}

func (self *NxmTunMetadata1) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata1) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata10 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata10 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata10(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata10, error) {
	_nxmtunmetadata10 := &NxmTunMetadata10{Oxm: parent}
	_nxmtunmetadata10.Value = decoder.Read(int(_nxmtunmetadata10.TypeLen & 0xFF))
	return _nxmtunmetadata10, nil
}

func NewNxmTunMetadata10() *NxmTunMetadata10 {
	obj := &NxmTunMetadata10{
		Oxm: NewOxm(91260),
	}
	return obj
}
func (self *NxmTunMetadata10) GetOXMName() string {
	return "tun_metadata10"
}

func (self *NxmTunMetadata10) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata10) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata10Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata10Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata10Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata10Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata10Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata10Masked, error) {
	_nxmtunmetadata10masked := &NxmTunMetadata10Masked{Oxm: parent}
	_nxmtunmetadata10masked.Value = decoder.Read(int(_nxmtunmetadata10masked.TypeLen & 0xFF))
	_nxmtunmetadata10masked.ValueMask = decoder.Read(int(_nxmtunmetadata10masked.TypeLen & 0xFF))
	return _nxmtunmetadata10masked, nil
}

func NewNxmTunMetadata10Masked() *NxmTunMetadata10Masked {
	obj := &NxmTunMetadata10Masked{
		Oxm: NewOxm(91640),
	}
	return obj
}
func (self *NxmTunMetadata10Masked) GetOXMName() string {
	return "tun_metadata10_masked"
}

func (self *NxmTunMetadata10Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata10Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata10Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata11 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata11 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata11(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata11, error) {
	_nxmtunmetadata11 := &NxmTunMetadata11{Oxm: parent}
	_nxmtunmetadata11.Value = decoder.Read(int(_nxmtunmetadata11.TypeLen & 0xFF))
	return _nxmtunmetadata11, nil
}

func NewNxmTunMetadata11() *NxmTunMetadata11 {
	obj := &NxmTunMetadata11{
		Oxm: NewOxm(91772),
	}
	return obj
}
func (self *NxmTunMetadata11) GetOXMName() string {
	return "tun_metadata11"
}

func (self *NxmTunMetadata11) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata11) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata11Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata11Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata11Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata11Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata11Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata11Masked, error) {
	_nxmtunmetadata11masked := &NxmTunMetadata11Masked{Oxm: parent}
	_nxmtunmetadata11masked.Value = decoder.Read(int(_nxmtunmetadata11masked.TypeLen & 0xFF))
	_nxmtunmetadata11masked.ValueMask = decoder.Read(int(_nxmtunmetadata11masked.TypeLen & 0xFF))
	return _nxmtunmetadata11masked, nil
}

func NewNxmTunMetadata11Masked() *NxmTunMetadata11Masked {
	obj := &NxmTunMetadata11Masked{
		Oxm: NewOxm(92152),
	}
	return obj
}
func (self *NxmTunMetadata11Masked) GetOXMName() string {
	return "tun_metadata11_masked"
}

func (self *NxmTunMetadata11Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata11Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata11Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata12 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata12 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata12(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata12, error) {
	_nxmtunmetadata12 := &NxmTunMetadata12{Oxm: parent}
	_nxmtunmetadata12.Value = decoder.Read(int(_nxmtunmetadata12.TypeLen & 0xFF))
	return _nxmtunmetadata12, nil
}

func NewNxmTunMetadata12() *NxmTunMetadata12 {
	obj := &NxmTunMetadata12{
		Oxm: NewOxm(92284),
	}
	return obj
}
func (self *NxmTunMetadata12) GetOXMName() string {
	return "tun_metadata12"
}

func (self *NxmTunMetadata12) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata12) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata12Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata12Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata12Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata12Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata12Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata12Masked, error) {
	_nxmtunmetadata12masked := &NxmTunMetadata12Masked{Oxm: parent}
	_nxmtunmetadata12masked.Value = decoder.Read(int(_nxmtunmetadata12masked.TypeLen & 0xFF))
	_nxmtunmetadata12masked.ValueMask = decoder.Read(int(_nxmtunmetadata12masked.TypeLen & 0xFF))
	return _nxmtunmetadata12masked, nil
}

func NewNxmTunMetadata12Masked() *NxmTunMetadata12Masked {
	obj := &NxmTunMetadata12Masked{
		Oxm: NewOxm(92664),
	}
	return obj
}
func (self *NxmTunMetadata12Masked) GetOXMName() string {
	return "tun_metadata12_masked"
}

func (self *NxmTunMetadata12Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata12Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata12Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata13 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata13 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata13(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata13, error) {
	_nxmtunmetadata13 := &NxmTunMetadata13{Oxm: parent}
	_nxmtunmetadata13.Value = decoder.Read(int(_nxmtunmetadata13.TypeLen & 0xFF))
	return _nxmtunmetadata13, nil
}

func NewNxmTunMetadata13() *NxmTunMetadata13 {
	obj := &NxmTunMetadata13{
		Oxm: NewOxm(92796),
	}
	return obj
}
func (self *NxmTunMetadata13) GetOXMName() string {
	return "tun_metadata13"
}

func (self *NxmTunMetadata13) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata13) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata13Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata13Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata13Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata13Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata13Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata13Masked, error) {
	_nxmtunmetadata13masked := &NxmTunMetadata13Masked{Oxm: parent}
	_nxmtunmetadata13masked.Value = decoder.Read(int(_nxmtunmetadata13masked.TypeLen & 0xFF))
	_nxmtunmetadata13masked.ValueMask = decoder.Read(int(_nxmtunmetadata13masked.TypeLen & 0xFF))
	return _nxmtunmetadata13masked, nil
}

func NewNxmTunMetadata13Masked() *NxmTunMetadata13Masked {
	obj := &NxmTunMetadata13Masked{
		Oxm: NewOxm(93176),
	}
	return obj
}
func (self *NxmTunMetadata13Masked) GetOXMName() string {
	return "tun_metadata13_masked"
}

func (self *NxmTunMetadata13Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata13Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata13Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata14 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata14 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata14(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata14, error) {
	_nxmtunmetadata14 := &NxmTunMetadata14{Oxm: parent}
	_nxmtunmetadata14.Value = decoder.Read(int(_nxmtunmetadata14.TypeLen & 0xFF))
	return _nxmtunmetadata14, nil
}

func NewNxmTunMetadata14() *NxmTunMetadata14 {
	obj := &NxmTunMetadata14{
		Oxm: NewOxm(93308),
	}
	return obj
}
func (self *NxmTunMetadata14) GetOXMName() string {
	return "tun_metadata14"
}

func (self *NxmTunMetadata14) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata14) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata14Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata14Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata14Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata14Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata14Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata14Masked, error) {
	_nxmtunmetadata14masked := &NxmTunMetadata14Masked{Oxm: parent}
	_nxmtunmetadata14masked.Value = decoder.Read(int(_nxmtunmetadata14masked.TypeLen & 0xFF))
	_nxmtunmetadata14masked.ValueMask = decoder.Read(int(_nxmtunmetadata14masked.TypeLen & 0xFF))
	return _nxmtunmetadata14masked, nil
}

func NewNxmTunMetadata14Masked() *NxmTunMetadata14Masked {
	obj := &NxmTunMetadata14Masked{
		Oxm: NewOxm(93688),
	}
	return obj
}
func (self *NxmTunMetadata14Masked) GetOXMName() string {
	return "tun_metadata14_masked"
}

func (self *NxmTunMetadata14Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata14Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata14Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata15 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata15 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata15(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata15, error) {
	_nxmtunmetadata15 := &NxmTunMetadata15{Oxm: parent}
	_nxmtunmetadata15.Value = decoder.Read(int(_nxmtunmetadata15.TypeLen & 0xFF))
	return _nxmtunmetadata15, nil
}

func NewNxmTunMetadata15() *NxmTunMetadata15 {
	obj := &NxmTunMetadata15{
		Oxm: NewOxm(93820),
	}
	return obj
}
func (self *NxmTunMetadata15) GetOXMName() string {
	return "tun_metadata15"
}

func (self *NxmTunMetadata15) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata15) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata15Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata15Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata15Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata15Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata15Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata15Masked, error) {
	_nxmtunmetadata15masked := &NxmTunMetadata15Masked{Oxm: parent}
	_nxmtunmetadata15masked.Value = decoder.Read(int(_nxmtunmetadata15masked.TypeLen & 0xFF))
	_nxmtunmetadata15masked.ValueMask = decoder.Read(int(_nxmtunmetadata15masked.TypeLen & 0xFF))
	return _nxmtunmetadata15masked, nil
}

func NewNxmTunMetadata15Masked() *NxmTunMetadata15Masked {
	obj := &NxmTunMetadata15Masked{
		Oxm: NewOxm(94200),
	}
	return obj
}
func (self *NxmTunMetadata15Masked) GetOXMName() string {
	return "tun_metadata15_masked"
}

func (self *NxmTunMetadata15Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata15Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata15Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata16 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata16 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata16(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata16, error) {
	_nxmtunmetadata16 := &NxmTunMetadata16{Oxm: parent}
	_nxmtunmetadata16.Value = decoder.Read(int(_nxmtunmetadata16.TypeLen & 0xFF))
	return _nxmtunmetadata16, nil
}

func NewNxmTunMetadata16() *NxmTunMetadata16 {
	obj := &NxmTunMetadata16{
		Oxm: NewOxm(94332),
	}
	return obj
}
func (self *NxmTunMetadata16) GetOXMName() string {
	return "tun_metadata16"
}

func (self *NxmTunMetadata16) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata16) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata16Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata16Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata16Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata16Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata16Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata16Masked, error) {
	_nxmtunmetadata16masked := &NxmTunMetadata16Masked{Oxm: parent}
	_nxmtunmetadata16masked.Value = decoder.Read(int(_nxmtunmetadata16masked.TypeLen & 0xFF))
	_nxmtunmetadata16masked.ValueMask = decoder.Read(int(_nxmtunmetadata16masked.TypeLen & 0xFF))
	return _nxmtunmetadata16masked, nil
}

func NewNxmTunMetadata16Masked() *NxmTunMetadata16Masked {
	obj := &NxmTunMetadata16Masked{
		Oxm: NewOxm(94712),
	}
	return obj
}
func (self *NxmTunMetadata16Masked) GetOXMName() string {
	return "tun_metadata16_masked"
}

func (self *NxmTunMetadata16Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata16Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata16Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata17 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata17 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata17(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata17, error) {
	_nxmtunmetadata17 := &NxmTunMetadata17{Oxm: parent}
	_nxmtunmetadata17.Value = decoder.Read(int(_nxmtunmetadata17.TypeLen & 0xFF))
	return _nxmtunmetadata17, nil
}

func NewNxmTunMetadata17() *NxmTunMetadata17 {
	obj := &NxmTunMetadata17{
		Oxm: NewOxm(94844),
	}
	return obj
}
func (self *NxmTunMetadata17) GetOXMName() string {
	return "tun_metadata17"
}

func (self *NxmTunMetadata17) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata17) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata17Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata17Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata17Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata17Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata17Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata17Masked, error) {
	_nxmtunmetadata17masked := &NxmTunMetadata17Masked{Oxm: parent}
	_nxmtunmetadata17masked.Value = decoder.Read(int(_nxmtunmetadata17masked.TypeLen & 0xFF))
	_nxmtunmetadata17masked.ValueMask = decoder.Read(int(_nxmtunmetadata17masked.TypeLen & 0xFF))
	return _nxmtunmetadata17masked, nil
}

func NewNxmTunMetadata17Masked() *NxmTunMetadata17Masked {
	obj := &NxmTunMetadata17Masked{
		Oxm: NewOxm(95224),
	}
	return obj
}
func (self *NxmTunMetadata17Masked) GetOXMName() string {
	return "tun_metadata17_masked"
}

func (self *NxmTunMetadata17Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata17Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata17Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata18 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata18 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata18(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata18, error) {
	_nxmtunmetadata18 := &NxmTunMetadata18{Oxm: parent}
	_nxmtunmetadata18.Value = decoder.Read(int(_nxmtunmetadata18.TypeLen & 0xFF))
	return _nxmtunmetadata18, nil
}

func NewNxmTunMetadata18() *NxmTunMetadata18 {
	obj := &NxmTunMetadata18{
		Oxm: NewOxm(95356),
	}
	return obj
}
func (self *NxmTunMetadata18) GetOXMName() string {
	return "tun_metadata18"
}

func (self *NxmTunMetadata18) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata18) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata18Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata18Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata18Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata18Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata18Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata18Masked, error) {
	_nxmtunmetadata18masked := &NxmTunMetadata18Masked{Oxm: parent}
	_nxmtunmetadata18masked.Value = decoder.Read(int(_nxmtunmetadata18masked.TypeLen & 0xFF))
	_nxmtunmetadata18masked.ValueMask = decoder.Read(int(_nxmtunmetadata18masked.TypeLen & 0xFF))
	return _nxmtunmetadata18masked, nil
}

func NewNxmTunMetadata18Masked() *NxmTunMetadata18Masked {
	obj := &NxmTunMetadata18Masked{
		Oxm: NewOxm(95736),
	}
	return obj
}
func (self *NxmTunMetadata18Masked) GetOXMName() string {
	return "tun_metadata18_masked"
}

func (self *NxmTunMetadata18Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata18Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata18Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata19 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata19 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata19(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata19, error) {
	_nxmtunmetadata19 := &NxmTunMetadata19{Oxm: parent}
	_nxmtunmetadata19.Value = decoder.Read(int(_nxmtunmetadata19.TypeLen & 0xFF))
	return _nxmtunmetadata19, nil
}

func NewNxmTunMetadata19() *NxmTunMetadata19 {
	obj := &NxmTunMetadata19{
		Oxm: NewOxm(95868),
	}
	return obj
}
func (self *NxmTunMetadata19) GetOXMName() string {
	return "tun_metadata19"
}

func (self *NxmTunMetadata19) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata19) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata19Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata19Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata19Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata19Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata19Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata19Masked, error) {
	_nxmtunmetadata19masked := &NxmTunMetadata19Masked{Oxm: parent}
	_nxmtunmetadata19masked.Value = decoder.Read(int(_nxmtunmetadata19masked.TypeLen & 0xFF))
	_nxmtunmetadata19masked.ValueMask = decoder.Read(int(_nxmtunmetadata19masked.TypeLen & 0xFF))
	return _nxmtunmetadata19masked, nil
}

func NewNxmTunMetadata19Masked() *NxmTunMetadata19Masked {
	obj := &NxmTunMetadata19Masked{
		Oxm: NewOxm(96248),
	}
	return obj
}
func (self *NxmTunMetadata19Masked) GetOXMName() string {
	return "tun_metadata19_masked"
}

func (self *NxmTunMetadata19Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata19Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata19Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata1Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata1Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata1Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata1Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata1Masked, error) {
	_nxmtunmetadata1masked := &NxmTunMetadata1Masked{Oxm: parent}
	_nxmtunmetadata1masked.Value = decoder.Read(int(_nxmtunmetadata1masked.TypeLen & 0xFF))
	_nxmtunmetadata1masked.ValueMask = decoder.Read(int(_nxmtunmetadata1masked.TypeLen & 0xFF))
	return _nxmtunmetadata1masked, nil
}

func NewNxmTunMetadata1Masked() *NxmTunMetadata1Masked {
	obj := &NxmTunMetadata1Masked{
		Oxm: NewOxm(87032),
	}
	return obj
}
func (self *NxmTunMetadata1Masked) GetOXMName() string {
	return "tun_metadata1_masked"
}

func (self *NxmTunMetadata1Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata1Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata1Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata2 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata2 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata2(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata2, error) {
	_nxmtunmetadata2 := &NxmTunMetadata2{Oxm: parent}
	_nxmtunmetadata2.Value = decoder.Read(int(_nxmtunmetadata2.TypeLen & 0xFF))
	return _nxmtunmetadata2, nil
}

func NewNxmTunMetadata2() *NxmTunMetadata2 {
	obj := &NxmTunMetadata2{
		Oxm: NewOxm(87164),
	}
	return obj
}
func (self *NxmTunMetadata2) GetOXMName() string {
	return "tun_metadata2"
}

func (self *NxmTunMetadata2) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata2) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata20 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata20 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata20(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata20, error) {
	_nxmtunmetadata20 := &NxmTunMetadata20{Oxm: parent}
	_nxmtunmetadata20.Value = decoder.Read(int(_nxmtunmetadata20.TypeLen & 0xFF))
	return _nxmtunmetadata20, nil
}

func NewNxmTunMetadata20() *NxmTunMetadata20 {
	obj := &NxmTunMetadata20{
		Oxm: NewOxm(96380),
	}
	return obj
}
func (self *NxmTunMetadata20) GetOXMName() string {
	return "tun_metadata20"
}

func (self *NxmTunMetadata20) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata20) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata20Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata20Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata20Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata20Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata20Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata20Masked, error) {
	_nxmtunmetadata20masked := &NxmTunMetadata20Masked{Oxm: parent}
	_nxmtunmetadata20masked.Value = decoder.Read(int(_nxmtunmetadata20masked.TypeLen & 0xFF))
	_nxmtunmetadata20masked.ValueMask = decoder.Read(int(_nxmtunmetadata20masked.TypeLen & 0xFF))
	return _nxmtunmetadata20masked, nil
}

func NewNxmTunMetadata20Masked() *NxmTunMetadata20Masked {
	obj := &NxmTunMetadata20Masked{
		Oxm: NewOxm(96760),
	}
	return obj
}
func (self *NxmTunMetadata20Masked) GetOXMName() string {
	return "tun_metadata20_masked"
}

func (self *NxmTunMetadata20Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata20Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata20Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata21 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata21 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata21(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata21, error) {
	_nxmtunmetadata21 := &NxmTunMetadata21{Oxm: parent}
	_nxmtunmetadata21.Value = decoder.Read(int(_nxmtunmetadata21.TypeLen & 0xFF))
	return _nxmtunmetadata21, nil
}

func NewNxmTunMetadata21() *NxmTunMetadata21 {
	obj := &NxmTunMetadata21{
		Oxm: NewOxm(96892),
	}
	return obj
}
func (self *NxmTunMetadata21) GetOXMName() string {
	return "tun_metadata21"
}

func (self *NxmTunMetadata21) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata21) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata21Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata21Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata21Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata21Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata21Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata21Masked, error) {
	_nxmtunmetadata21masked := &NxmTunMetadata21Masked{Oxm: parent}
	_nxmtunmetadata21masked.Value = decoder.Read(int(_nxmtunmetadata21masked.TypeLen & 0xFF))
	_nxmtunmetadata21masked.ValueMask = decoder.Read(int(_nxmtunmetadata21masked.TypeLen & 0xFF))
	return _nxmtunmetadata21masked, nil
}

func NewNxmTunMetadata21Masked() *NxmTunMetadata21Masked {
	obj := &NxmTunMetadata21Masked{
		Oxm: NewOxm(97272),
	}
	return obj
}
func (self *NxmTunMetadata21Masked) GetOXMName() string {
	return "tun_metadata21_masked"
}

func (self *NxmTunMetadata21Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata21Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata21Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata22 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata22 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata22(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata22, error) {
	_nxmtunmetadata22 := &NxmTunMetadata22{Oxm: parent}
	_nxmtunmetadata22.Value = decoder.Read(int(_nxmtunmetadata22.TypeLen & 0xFF))
	return _nxmtunmetadata22, nil
}

func NewNxmTunMetadata22() *NxmTunMetadata22 {
	obj := &NxmTunMetadata22{
		Oxm: NewOxm(97404),
	}
	return obj
}
func (self *NxmTunMetadata22) GetOXMName() string {
	return "tun_metadata22"
}

func (self *NxmTunMetadata22) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata22) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata22Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata22Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata22Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata22Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata22Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata22Masked, error) {
	_nxmtunmetadata22masked := &NxmTunMetadata22Masked{Oxm: parent}
	_nxmtunmetadata22masked.Value = decoder.Read(int(_nxmtunmetadata22masked.TypeLen & 0xFF))
	_nxmtunmetadata22masked.ValueMask = decoder.Read(int(_nxmtunmetadata22masked.TypeLen & 0xFF))
	return _nxmtunmetadata22masked, nil
}

func NewNxmTunMetadata22Masked() *NxmTunMetadata22Masked {
	obj := &NxmTunMetadata22Masked{
		Oxm: NewOxm(97784),
	}
	return obj
}
func (self *NxmTunMetadata22Masked) GetOXMName() string {
	return "tun_metadata22_masked"
}

func (self *NxmTunMetadata22Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata22Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata22Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata23 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata23 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata23(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata23, error) {
	_nxmtunmetadata23 := &NxmTunMetadata23{Oxm: parent}
	_nxmtunmetadata23.Value = decoder.Read(int(_nxmtunmetadata23.TypeLen & 0xFF))
	return _nxmtunmetadata23, nil
}

func NewNxmTunMetadata23() *NxmTunMetadata23 {
	obj := &NxmTunMetadata23{
		Oxm: NewOxm(97916),
	}
	return obj
}
func (self *NxmTunMetadata23) GetOXMName() string {
	return "tun_metadata23"
}

func (self *NxmTunMetadata23) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata23) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata23Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata23Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata23Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata23Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata23Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata23Masked, error) {
	_nxmtunmetadata23masked := &NxmTunMetadata23Masked{Oxm: parent}
	_nxmtunmetadata23masked.Value = decoder.Read(int(_nxmtunmetadata23masked.TypeLen & 0xFF))
	_nxmtunmetadata23masked.ValueMask = decoder.Read(int(_nxmtunmetadata23masked.TypeLen & 0xFF))
	return _nxmtunmetadata23masked, nil
}

func NewNxmTunMetadata23Masked() *NxmTunMetadata23Masked {
	obj := &NxmTunMetadata23Masked{
		Oxm: NewOxm(98296),
	}
	return obj
}
func (self *NxmTunMetadata23Masked) GetOXMName() string {
	return "tun_metadata23_masked"
}

func (self *NxmTunMetadata23Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata23Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata23Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata24 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata24 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata24(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata24, error) {
	_nxmtunmetadata24 := &NxmTunMetadata24{Oxm: parent}
	_nxmtunmetadata24.Value = decoder.Read(int(_nxmtunmetadata24.TypeLen & 0xFF))
	return _nxmtunmetadata24, nil
}

func NewNxmTunMetadata24() *NxmTunMetadata24 {
	obj := &NxmTunMetadata24{
		Oxm: NewOxm(98428),
	}
	return obj
}
func (self *NxmTunMetadata24) GetOXMName() string {
	return "tun_metadata24"
}

func (self *NxmTunMetadata24) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata24) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata24Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata24Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata24Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata24Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata24Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata24Masked, error) {
	_nxmtunmetadata24masked := &NxmTunMetadata24Masked{Oxm: parent}
	_nxmtunmetadata24masked.Value = decoder.Read(int(_nxmtunmetadata24masked.TypeLen & 0xFF))
	_nxmtunmetadata24masked.ValueMask = decoder.Read(int(_nxmtunmetadata24masked.TypeLen & 0xFF))
	return _nxmtunmetadata24masked, nil
}

func NewNxmTunMetadata24Masked() *NxmTunMetadata24Masked {
	obj := &NxmTunMetadata24Masked{
		Oxm: NewOxm(98808),
	}
	return obj
}
func (self *NxmTunMetadata24Masked) GetOXMName() string {
	return "tun_metadata24_masked"
}

func (self *NxmTunMetadata24Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata24Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata24Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata25 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata25 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata25(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata25, error) {
	_nxmtunmetadata25 := &NxmTunMetadata25{Oxm: parent}
	_nxmtunmetadata25.Value = decoder.Read(int(_nxmtunmetadata25.TypeLen & 0xFF))
	return _nxmtunmetadata25, nil
}

func NewNxmTunMetadata25() *NxmTunMetadata25 {
	obj := &NxmTunMetadata25{
		Oxm: NewOxm(98940),
	}
	return obj
}
func (self *NxmTunMetadata25) GetOXMName() string {
	return "tun_metadata25"
}

func (self *NxmTunMetadata25) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata25) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata25Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata25Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata25Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata25Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata25Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata25Masked, error) {
	_nxmtunmetadata25masked := &NxmTunMetadata25Masked{Oxm: parent}
	_nxmtunmetadata25masked.Value = decoder.Read(int(_nxmtunmetadata25masked.TypeLen & 0xFF))
	_nxmtunmetadata25masked.ValueMask = decoder.Read(int(_nxmtunmetadata25masked.TypeLen & 0xFF))
	return _nxmtunmetadata25masked, nil
}

func NewNxmTunMetadata25Masked() *NxmTunMetadata25Masked {
	obj := &NxmTunMetadata25Masked{
		Oxm: NewOxm(99320),
	}
	return obj
}
func (self *NxmTunMetadata25Masked) GetOXMName() string {
	return "tun_metadata25_masked"
}

func (self *NxmTunMetadata25Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata25Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata25Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata26 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata26 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata26(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata26, error) {
	_nxmtunmetadata26 := &NxmTunMetadata26{Oxm: parent}
	_nxmtunmetadata26.Value = decoder.Read(int(_nxmtunmetadata26.TypeLen & 0xFF))
	return _nxmtunmetadata26, nil
}

func NewNxmTunMetadata26() *NxmTunMetadata26 {
	obj := &NxmTunMetadata26{
		Oxm: NewOxm(99452),
	}
	return obj
}
func (self *NxmTunMetadata26) GetOXMName() string {
	return "tun_metadata26"
}

func (self *NxmTunMetadata26) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata26) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata26Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata26Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata26Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata26Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata26Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata26Masked, error) {
	_nxmtunmetadata26masked := &NxmTunMetadata26Masked{Oxm: parent}
	_nxmtunmetadata26masked.Value = decoder.Read(int(_nxmtunmetadata26masked.TypeLen & 0xFF))
	_nxmtunmetadata26masked.ValueMask = decoder.Read(int(_nxmtunmetadata26masked.TypeLen & 0xFF))
	return _nxmtunmetadata26masked, nil
}

func NewNxmTunMetadata26Masked() *NxmTunMetadata26Masked {
	obj := &NxmTunMetadata26Masked{
		Oxm: NewOxm(99832),
	}
	return obj
}
func (self *NxmTunMetadata26Masked) GetOXMName() string {
	return "tun_metadata26_masked"
}

func (self *NxmTunMetadata26Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata26Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata26Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata27 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata27 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata27(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata27, error) {
	_nxmtunmetadata27 := &NxmTunMetadata27{Oxm: parent}
	_nxmtunmetadata27.Value = decoder.Read(int(_nxmtunmetadata27.TypeLen & 0xFF))
	return _nxmtunmetadata27, nil
}

func NewNxmTunMetadata27() *NxmTunMetadata27 {
	obj := &NxmTunMetadata27{
		Oxm: NewOxm(99964),
	}
	return obj
}
func (self *NxmTunMetadata27) GetOXMName() string {
	return "tun_metadata27"
}

func (self *NxmTunMetadata27) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata27) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata27Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata27Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata27Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata27Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata27Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata27Masked, error) {
	_nxmtunmetadata27masked := &NxmTunMetadata27Masked{Oxm: parent}
	_nxmtunmetadata27masked.Value = decoder.Read(int(_nxmtunmetadata27masked.TypeLen & 0xFF))
	_nxmtunmetadata27masked.ValueMask = decoder.Read(int(_nxmtunmetadata27masked.TypeLen & 0xFF))
	return _nxmtunmetadata27masked, nil
}

func NewNxmTunMetadata27Masked() *NxmTunMetadata27Masked {
	obj := &NxmTunMetadata27Masked{
		Oxm: NewOxm(100344),
	}
	return obj
}
func (self *NxmTunMetadata27Masked) GetOXMName() string {
	return "tun_metadata27_masked"
}

func (self *NxmTunMetadata27Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata27Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata27Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata28 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata28 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata28(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata28, error) {
	_nxmtunmetadata28 := &NxmTunMetadata28{Oxm: parent}
	_nxmtunmetadata28.Value = decoder.Read(int(_nxmtunmetadata28.TypeLen & 0xFF))
	return _nxmtunmetadata28, nil
}

func NewNxmTunMetadata28() *NxmTunMetadata28 {
	obj := &NxmTunMetadata28{
		Oxm: NewOxm(100476),
	}
	return obj
}
func (self *NxmTunMetadata28) GetOXMName() string {
	return "tun_metadata28"
}

func (self *NxmTunMetadata28) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata28) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata28Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata28Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata28Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata28Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata28Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata28Masked, error) {
	_nxmtunmetadata28masked := &NxmTunMetadata28Masked{Oxm: parent}
	_nxmtunmetadata28masked.Value = decoder.Read(int(_nxmtunmetadata28masked.TypeLen & 0xFF))
	_nxmtunmetadata28masked.ValueMask = decoder.Read(int(_nxmtunmetadata28masked.TypeLen & 0xFF))
	return _nxmtunmetadata28masked, nil
}

func NewNxmTunMetadata28Masked() *NxmTunMetadata28Masked {
	obj := &NxmTunMetadata28Masked{
		Oxm: NewOxm(100856),
	}
	return obj
}
func (self *NxmTunMetadata28Masked) GetOXMName() string {
	return "tun_metadata28_masked"
}

func (self *NxmTunMetadata28Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata28Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata28Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata29 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata29 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata29(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata29, error) {
	_nxmtunmetadata29 := &NxmTunMetadata29{Oxm: parent}
	_nxmtunmetadata29.Value = decoder.Read(int(_nxmtunmetadata29.TypeLen & 0xFF))
	return _nxmtunmetadata29, nil
}

func NewNxmTunMetadata29() *NxmTunMetadata29 {
	obj := &NxmTunMetadata29{
		Oxm: NewOxm(100988),
	}
	return obj
}
func (self *NxmTunMetadata29) GetOXMName() string {
	return "tun_metadata29"
}

func (self *NxmTunMetadata29) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata29) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata29Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata29Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata29Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata29Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata29Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata29Masked, error) {
	_nxmtunmetadata29masked := &NxmTunMetadata29Masked{Oxm: parent}
	_nxmtunmetadata29masked.Value = decoder.Read(int(_nxmtunmetadata29masked.TypeLen & 0xFF))
	_nxmtunmetadata29masked.ValueMask = decoder.Read(int(_nxmtunmetadata29masked.TypeLen & 0xFF))
	return _nxmtunmetadata29masked, nil
}

func NewNxmTunMetadata29Masked() *NxmTunMetadata29Masked {
	obj := &NxmTunMetadata29Masked{
		Oxm: NewOxm(101368),
	}
	return obj
}
func (self *NxmTunMetadata29Masked) GetOXMName() string {
	return "tun_metadata29_masked"
}

func (self *NxmTunMetadata29Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata29Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata29Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata2Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata2Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata2Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata2Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata2Masked, error) {
	_nxmtunmetadata2masked := &NxmTunMetadata2Masked{Oxm: parent}
	_nxmtunmetadata2masked.Value = decoder.Read(int(_nxmtunmetadata2masked.TypeLen & 0xFF))
	_nxmtunmetadata2masked.ValueMask = decoder.Read(int(_nxmtunmetadata2masked.TypeLen & 0xFF))
	return _nxmtunmetadata2masked, nil
}

func NewNxmTunMetadata2Masked() *NxmTunMetadata2Masked {
	obj := &NxmTunMetadata2Masked{
		Oxm: NewOxm(87544),
	}
	return obj
}
func (self *NxmTunMetadata2Masked) GetOXMName() string {
	return "tun_metadata2_masked"
}

func (self *NxmTunMetadata2Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata2Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata2Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata3 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata3 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata3(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata3, error) {
	_nxmtunmetadata3 := &NxmTunMetadata3{Oxm: parent}
	_nxmtunmetadata3.Value = decoder.Read(int(_nxmtunmetadata3.TypeLen & 0xFF))
	return _nxmtunmetadata3, nil
}

func NewNxmTunMetadata3() *NxmTunMetadata3 {
	obj := &NxmTunMetadata3{
		Oxm: NewOxm(87676),
	}
	return obj
}
func (self *NxmTunMetadata3) GetOXMName() string {
	return "tun_metadata3"
}

func (self *NxmTunMetadata3) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata3) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata30 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata30 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata30(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata30, error) {
	_nxmtunmetadata30 := &NxmTunMetadata30{Oxm: parent}
	_nxmtunmetadata30.Value = decoder.Read(int(_nxmtunmetadata30.TypeLen & 0xFF))
	return _nxmtunmetadata30, nil
}

func NewNxmTunMetadata30() *NxmTunMetadata30 {
	obj := &NxmTunMetadata30{
		Oxm: NewOxm(101500),
	}
	return obj
}
func (self *NxmTunMetadata30) GetOXMName() string {
	return "tun_metadata30"
}

func (self *NxmTunMetadata30) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata30) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata30Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata30Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata30Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata30Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata30Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata30Masked, error) {
	_nxmtunmetadata30masked := &NxmTunMetadata30Masked{Oxm: parent}
	_nxmtunmetadata30masked.Value = decoder.Read(int(_nxmtunmetadata30masked.TypeLen & 0xFF))
	_nxmtunmetadata30masked.ValueMask = decoder.Read(int(_nxmtunmetadata30masked.TypeLen & 0xFF))
	return _nxmtunmetadata30masked, nil
}

func NewNxmTunMetadata30Masked() *NxmTunMetadata30Masked {
	obj := &NxmTunMetadata30Masked{
		Oxm: NewOxm(101880),
	}
	return obj
}
func (self *NxmTunMetadata30Masked) GetOXMName() string {
	return "tun_metadata30_masked"
}

func (self *NxmTunMetadata30Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata30Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata30Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata31 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata31 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata31(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata31, error) {
	_nxmtunmetadata31 := &NxmTunMetadata31{Oxm: parent}
	_nxmtunmetadata31.Value = decoder.Read(int(_nxmtunmetadata31.TypeLen & 0xFF))
	return _nxmtunmetadata31, nil
}

func NewNxmTunMetadata31() *NxmTunMetadata31 {
	obj := &NxmTunMetadata31{
		Oxm: NewOxm(102012),
	}
	return obj
}
func (self *NxmTunMetadata31) GetOXMName() string {
	return "tun_metadata31"
}

func (self *NxmTunMetadata31) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata31) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata31Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata31Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata31Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata31Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata31Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata31Masked, error) {
	_nxmtunmetadata31masked := &NxmTunMetadata31Masked{Oxm: parent}
	_nxmtunmetadata31masked.Value = decoder.Read(int(_nxmtunmetadata31masked.TypeLen & 0xFF))
	_nxmtunmetadata31masked.ValueMask = decoder.Read(int(_nxmtunmetadata31masked.TypeLen & 0xFF))
	return _nxmtunmetadata31masked, nil
}

func NewNxmTunMetadata31Masked() *NxmTunMetadata31Masked {
	obj := &NxmTunMetadata31Masked{
		Oxm: NewOxm(102392),
	}
	return obj
}
func (self *NxmTunMetadata31Masked) GetOXMName() string {
	return "tun_metadata31_masked"
}

func (self *NxmTunMetadata31Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata31Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata31Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata32 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata32 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata32(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata32, error) {
	_nxmtunmetadata32 := &NxmTunMetadata32{Oxm: parent}
	_nxmtunmetadata32.Value = decoder.Read(int(_nxmtunmetadata32.TypeLen & 0xFF))
	return _nxmtunmetadata32, nil
}

func NewNxmTunMetadata32() *NxmTunMetadata32 {
	obj := &NxmTunMetadata32{
		Oxm: NewOxm(102524),
	}
	return obj
}
func (self *NxmTunMetadata32) GetOXMName() string {
	return "tun_metadata32"
}

func (self *NxmTunMetadata32) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata32) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata32Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata32Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata32Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata32Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata32Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata32Masked, error) {
	_nxmtunmetadata32masked := &NxmTunMetadata32Masked{Oxm: parent}
	_nxmtunmetadata32masked.Value = decoder.Read(int(_nxmtunmetadata32masked.TypeLen & 0xFF))
	_nxmtunmetadata32masked.ValueMask = decoder.Read(int(_nxmtunmetadata32masked.TypeLen & 0xFF))
	return _nxmtunmetadata32masked, nil
}

func NewNxmTunMetadata32Masked() *NxmTunMetadata32Masked {
	obj := &NxmTunMetadata32Masked{
		Oxm: NewOxm(102904),
	}
	return obj
}
func (self *NxmTunMetadata32Masked) GetOXMName() string {
	return "tun_metadata32_masked"
}

func (self *NxmTunMetadata32Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata32Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata32Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata33 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata33 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata33(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata33, error) {
	_nxmtunmetadata33 := &NxmTunMetadata33{Oxm: parent}
	_nxmtunmetadata33.Value = decoder.Read(int(_nxmtunmetadata33.TypeLen & 0xFF))
	return _nxmtunmetadata33, nil
}

func NewNxmTunMetadata33() *NxmTunMetadata33 {
	obj := &NxmTunMetadata33{
		Oxm: NewOxm(103036),
	}
	return obj
}
func (self *NxmTunMetadata33) GetOXMName() string {
	return "tun_metadata33"
}

func (self *NxmTunMetadata33) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata33) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata33Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata33Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata33Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata33Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata33Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata33Masked, error) {
	_nxmtunmetadata33masked := &NxmTunMetadata33Masked{Oxm: parent}
	_nxmtunmetadata33masked.Value = decoder.Read(int(_nxmtunmetadata33masked.TypeLen & 0xFF))
	_nxmtunmetadata33masked.ValueMask = decoder.Read(int(_nxmtunmetadata33masked.TypeLen & 0xFF))
	return _nxmtunmetadata33masked, nil
}

func NewNxmTunMetadata33Masked() *NxmTunMetadata33Masked {
	obj := &NxmTunMetadata33Masked{
		Oxm: NewOxm(103416),
	}
	return obj
}
func (self *NxmTunMetadata33Masked) GetOXMName() string {
	return "tun_metadata33_masked"
}

func (self *NxmTunMetadata33Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata33Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata33Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata34 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata34 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata34(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata34, error) {
	_nxmtunmetadata34 := &NxmTunMetadata34{Oxm: parent}
	_nxmtunmetadata34.Value = decoder.Read(int(_nxmtunmetadata34.TypeLen & 0xFF))
	return _nxmtunmetadata34, nil
}

func NewNxmTunMetadata34() *NxmTunMetadata34 {
	obj := &NxmTunMetadata34{
		Oxm: NewOxm(103548),
	}
	return obj
}
func (self *NxmTunMetadata34) GetOXMName() string {
	return "tun_metadata34"
}

func (self *NxmTunMetadata34) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata34) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata34Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata34Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata34Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata34Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata34Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata34Masked, error) {
	_nxmtunmetadata34masked := &NxmTunMetadata34Masked{Oxm: parent}
	_nxmtunmetadata34masked.Value = decoder.Read(int(_nxmtunmetadata34masked.TypeLen & 0xFF))
	_nxmtunmetadata34masked.ValueMask = decoder.Read(int(_nxmtunmetadata34masked.TypeLen & 0xFF))
	return _nxmtunmetadata34masked, nil
}

func NewNxmTunMetadata34Masked() *NxmTunMetadata34Masked {
	obj := &NxmTunMetadata34Masked{
		Oxm: NewOxm(103928),
	}
	return obj
}
func (self *NxmTunMetadata34Masked) GetOXMName() string {
	return "tun_metadata34_masked"
}

func (self *NxmTunMetadata34Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata34Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata34Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata35 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata35 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata35(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata35, error) {
	_nxmtunmetadata35 := &NxmTunMetadata35{Oxm: parent}
	_nxmtunmetadata35.Value = decoder.Read(int(_nxmtunmetadata35.TypeLen & 0xFF))
	return _nxmtunmetadata35, nil
}

func NewNxmTunMetadata35() *NxmTunMetadata35 {
	obj := &NxmTunMetadata35{
		Oxm: NewOxm(104060),
	}
	return obj
}
func (self *NxmTunMetadata35) GetOXMName() string {
	return "tun_metadata35"
}

func (self *NxmTunMetadata35) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata35) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata35Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata35Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata35Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata35Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata35Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata35Masked, error) {
	_nxmtunmetadata35masked := &NxmTunMetadata35Masked{Oxm: parent}
	_nxmtunmetadata35masked.Value = decoder.Read(int(_nxmtunmetadata35masked.TypeLen & 0xFF))
	_nxmtunmetadata35masked.ValueMask = decoder.Read(int(_nxmtunmetadata35masked.TypeLen & 0xFF))
	return _nxmtunmetadata35masked, nil
}

func NewNxmTunMetadata35Masked() *NxmTunMetadata35Masked {
	obj := &NxmTunMetadata35Masked{
		Oxm: NewOxm(104440),
	}
	return obj
}
func (self *NxmTunMetadata35Masked) GetOXMName() string {
	return "tun_metadata35_masked"
}

func (self *NxmTunMetadata35Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata35Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata35Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata36 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata36 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata36(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata36, error) {
	_nxmtunmetadata36 := &NxmTunMetadata36{Oxm: parent}
	_nxmtunmetadata36.Value = decoder.Read(int(_nxmtunmetadata36.TypeLen & 0xFF))
	return _nxmtunmetadata36, nil
}

func NewNxmTunMetadata36() *NxmTunMetadata36 {
	obj := &NxmTunMetadata36{
		Oxm: NewOxm(104572),
	}
	return obj
}
func (self *NxmTunMetadata36) GetOXMName() string {
	return "tun_metadata36"
}

func (self *NxmTunMetadata36) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata36) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata36Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata36Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata36Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata36Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata36Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata36Masked, error) {
	_nxmtunmetadata36masked := &NxmTunMetadata36Masked{Oxm: parent}
	_nxmtunmetadata36masked.Value = decoder.Read(int(_nxmtunmetadata36masked.TypeLen & 0xFF))
	_nxmtunmetadata36masked.ValueMask = decoder.Read(int(_nxmtunmetadata36masked.TypeLen & 0xFF))
	return _nxmtunmetadata36masked, nil
}

func NewNxmTunMetadata36Masked() *NxmTunMetadata36Masked {
	obj := &NxmTunMetadata36Masked{
		Oxm: NewOxm(104952),
	}
	return obj
}
func (self *NxmTunMetadata36Masked) GetOXMName() string {
	return "tun_metadata36_masked"
}

func (self *NxmTunMetadata36Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata36Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata36Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata37 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata37 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata37(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata37, error) {
	_nxmtunmetadata37 := &NxmTunMetadata37{Oxm: parent}
	_nxmtunmetadata37.Value = decoder.Read(int(_nxmtunmetadata37.TypeLen & 0xFF))
	return _nxmtunmetadata37, nil
}

func NewNxmTunMetadata37() *NxmTunMetadata37 {
	obj := &NxmTunMetadata37{
		Oxm: NewOxm(105084),
	}
	return obj
}
func (self *NxmTunMetadata37) GetOXMName() string {
	return "tun_metadata37"
}

func (self *NxmTunMetadata37) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata37) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata37Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata37Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata37Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata37Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata37Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata37Masked, error) {
	_nxmtunmetadata37masked := &NxmTunMetadata37Masked{Oxm: parent}
	_nxmtunmetadata37masked.Value = decoder.Read(int(_nxmtunmetadata37masked.TypeLen & 0xFF))
	_nxmtunmetadata37masked.ValueMask = decoder.Read(int(_nxmtunmetadata37masked.TypeLen & 0xFF))
	return _nxmtunmetadata37masked, nil
}

func NewNxmTunMetadata37Masked() *NxmTunMetadata37Masked {
	obj := &NxmTunMetadata37Masked{
		Oxm: NewOxm(105464),
	}
	return obj
}
func (self *NxmTunMetadata37Masked) GetOXMName() string {
	return "tun_metadata37_masked"
}

func (self *NxmTunMetadata37Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata37Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata37Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata38 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata38 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata38(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata38, error) {
	_nxmtunmetadata38 := &NxmTunMetadata38{Oxm: parent}
	_nxmtunmetadata38.Value = decoder.Read(int(_nxmtunmetadata38.TypeLen & 0xFF))
	return _nxmtunmetadata38, nil
}

func NewNxmTunMetadata38() *NxmTunMetadata38 {
	obj := &NxmTunMetadata38{
		Oxm: NewOxm(105596),
	}
	return obj
}
func (self *NxmTunMetadata38) GetOXMName() string {
	return "tun_metadata38"
}

func (self *NxmTunMetadata38) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata38) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata38Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata38Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata38Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata38Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata38Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata38Masked, error) {
	_nxmtunmetadata38masked := &NxmTunMetadata38Masked{Oxm: parent}
	_nxmtunmetadata38masked.Value = decoder.Read(int(_nxmtunmetadata38masked.TypeLen & 0xFF))
	_nxmtunmetadata38masked.ValueMask = decoder.Read(int(_nxmtunmetadata38masked.TypeLen & 0xFF))
	return _nxmtunmetadata38masked, nil
}

func NewNxmTunMetadata38Masked() *NxmTunMetadata38Masked {
	obj := &NxmTunMetadata38Masked{
		Oxm: NewOxm(105976),
	}
	return obj
}
func (self *NxmTunMetadata38Masked) GetOXMName() string {
	return "tun_metadata38_masked"
}

func (self *NxmTunMetadata38Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata38Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata38Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata39 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata39 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata39(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata39, error) {
	_nxmtunmetadata39 := &NxmTunMetadata39{Oxm: parent}
	_nxmtunmetadata39.Value = decoder.Read(int(_nxmtunmetadata39.TypeLen & 0xFF))
	return _nxmtunmetadata39, nil
}

func NewNxmTunMetadata39() *NxmTunMetadata39 {
	obj := &NxmTunMetadata39{
		Oxm: NewOxm(106108),
	}
	return obj
}
func (self *NxmTunMetadata39) GetOXMName() string {
	return "tun_metadata39"
}

func (self *NxmTunMetadata39) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata39) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata39Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata39Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata39Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata39Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata39Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata39Masked, error) {
	_nxmtunmetadata39masked := &NxmTunMetadata39Masked{Oxm: parent}
	_nxmtunmetadata39masked.Value = decoder.Read(int(_nxmtunmetadata39masked.TypeLen & 0xFF))
	_nxmtunmetadata39masked.ValueMask = decoder.Read(int(_nxmtunmetadata39masked.TypeLen & 0xFF))
	return _nxmtunmetadata39masked, nil
}

func NewNxmTunMetadata39Masked() *NxmTunMetadata39Masked {
	obj := &NxmTunMetadata39Masked{
		Oxm: NewOxm(106488),
	}
	return obj
}
func (self *NxmTunMetadata39Masked) GetOXMName() string {
	return "tun_metadata39_masked"
}

func (self *NxmTunMetadata39Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata39Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata39Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata3Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata3Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata3Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata3Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata3Masked, error) {
	_nxmtunmetadata3masked := &NxmTunMetadata3Masked{Oxm: parent}
	_nxmtunmetadata3masked.Value = decoder.Read(int(_nxmtunmetadata3masked.TypeLen & 0xFF))
	_nxmtunmetadata3masked.ValueMask = decoder.Read(int(_nxmtunmetadata3masked.TypeLen & 0xFF))
	return _nxmtunmetadata3masked, nil
}

func NewNxmTunMetadata3Masked() *NxmTunMetadata3Masked {
	obj := &NxmTunMetadata3Masked{
		Oxm: NewOxm(88056),
	}
	return obj
}
func (self *NxmTunMetadata3Masked) GetOXMName() string {
	return "tun_metadata3_masked"
}

func (self *NxmTunMetadata3Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata3Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata3Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata4 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata4 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata4(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata4, error) {
	_nxmtunmetadata4 := &NxmTunMetadata4{Oxm: parent}
	_nxmtunmetadata4.Value = decoder.Read(int(_nxmtunmetadata4.TypeLen & 0xFF))
	return _nxmtunmetadata4, nil
}

func NewNxmTunMetadata4() *NxmTunMetadata4 {
	obj := &NxmTunMetadata4{
		Oxm: NewOxm(88188),
	}
	return obj
}
func (self *NxmTunMetadata4) GetOXMName() string {
	return "tun_metadata4"
}

func (self *NxmTunMetadata4) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata4) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata40 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata40 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata40(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata40, error) {
	_nxmtunmetadata40 := &NxmTunMetadata40{Oxm: parent}
	_nxmtunmetadata40.Value = decoder.Read(int(_nxmtunmetadata40.TypeLen & 0xFF))
	return _nxmtunmetadata40, nil
}

func NewNxmTunMetadata40() *NxmTunMetadata40 {
	obj := &NxmTunMetadata40{
		Oxm: NewOxm(106620),
	}
	return obj
}
func (self *NxmTunMetadata40) GetOXMName() string {
	return "tun_metadata40"
}

func (self *NxmTunMetadata40) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata40) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata40Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata40Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata40Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata40Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata40Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata40Masked, error) {
	_nxmtunmetadata40masked := &NxmTunMetadata40Masked{Oxm: parent}
	_nxmtunmetadata40masked.Value = decoder.Read(int(_nxmtunmetadata40masked.TypeLen & 0xFF))
	_nxmtunmetadata40masked.ValueMask = decoder.Read(int(_nxmtunmetadata40masked.TypeLen & 0xFF))
	return _nxmtunmetadata40masked, nil
}

func NewNxmTunMetadata40Masked() *NxmTunMetadata40Masked {
	obj := &NxmTunMetadata40Masked{
		Oxm: NewOxm(107000),
	}
	return obj
}
func (self *NxmTunMetadata40Masked) GetOXMName() string {
	return "tun_metadata40_masked"
}

func (self *NxmTunMetadata40Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata40Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata40Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata41 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata41 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata41(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata41, error) {
	_nxmtunmetadata41 := &NxmTunMetadata41{Oxm: parent}
	_nxmtunmetadata41.Value = decoder.Read(int(_nxmtunmetadata41.TypeLen & 0xFF))
	return _nxmtunmetadata41, nil
}

func NewNxmTunMetadata41() *NxmTunMetadata41 {
	obj := &NxmTunMetadata41{
		Oxm: NewOxm(107132),
	}
	return obj
}
func (self *NxmTunMetadata41) GetOXMName() string {
	return "tun_metadata41"
}

func (self *NxmTunMetadata41) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata41) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata41Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata41Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata41Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata41Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata41Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata41Masked, error) {
	_nxmtunmetadata41masked := &NxmTunMetadata41Masked{Oxm: parent}
	_nxmtunmetadata41masked.Value = decoder.Read(int(_nxmtunmetadata41masked.TypeLen & 0xFF))
	_nxmtunmetadata41masked.ValueMask = decoder.Read(int(_nxmtunmetadata41masked.TypeLen & 0xFF))
	return _nxmtunmetadata41masked, nil
}

func NewNxmTunMetadata41Masked() *NxmTunMetadata41Masked {
	obj := &NxmTunMetadata41Masked{
		Oxm: NewOxm(107512),
	}
	return obj
}
func (self *NxmTunMetadata41Masked) GetOXMName() string {
	return "tun_metadata41_masked"
}

func (self *NxmTunMetadata41Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata41Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata41Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata42 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata42 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata42(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata42, error) {
	_nxmtunmetadata42 := &NxmTunMetadata42{Oxm: parent}
	_nxmtunmetadata42.Value = decoder.Read(int(_nxmtunmetadata42.TypeLen & 0xFF))
	return _nxmtunmetadata42, nil
}

func NewNxmTunMetadata42() *NxmTunMetadata42 {
	obj := &NxmTunMetadata42{
		Oxm: NewOxm(107644),
	}
	return obj
}
func (self *NxmTunMetadata42) GetOXMName() string {
	return "tun_metadata42"
}

func (self *NxmTunMetadata42) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata42) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata42Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata42Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata42Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata42Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata42Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata42Masked, error) {
	_nxmtunmetadata42masked := &NxmTunMetadata42Masked{Oxm: parent}
	_nxmtunmetadata42masked.Value = decoder.Read(int(_nxmtunmetadata42masked.TypeLen & 0xFF))
	_nxmtunmetadata42masked.ValueMask = decoder.Read(int(_nxmtunmetadata42masked.TypeLen & 0xFF))
	return _nxmtunmetadata42masked, nil
}

func NewNxmTunMetadata42Masked() *NxmTunMetadata42Masked {
	obj := &NxmTunMetadata42Masked{
		Oxm: NewOxm(108024),
	}
	return obj
}
func (self *NxmTunMetadata42Masked) GetOXMName() string {
	return "tun_metadata42_masked"
}

func (self *NxmTunMetadata42Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata42Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata42Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata43 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata43 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata43(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata43, error) {
	_nxmtunmetadata43 := &NxmTunMetadata43{Oxm: parent}
	_nxmtunmetadata43.Value = decoder.Read(int(_nxmtunmetadata43.TypeLen & 0xFF))
	return _nxmtunmetadata43, nil
}

func NewNxmTunMetadata43() *NxmTunMetadata43 {
	obj := &NxmTunMetadata43{
		Oxm: NewOxm(108156),
	}
	return obj
}
func (self *NxmTunMetadata43) GetOXMName() string {
	return "tun_metadata43"
}

func (self *NxmTunMetadata43) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata43) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata43Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata43Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata43Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata43Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata43Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata43Masked, error) {
	_nxmtunmetadata43masked := &NxmTunMetadata43Masked{Oxm: parent}
	_nxmtunmetadata43masked.Value = decoder.Read(int(_nxmtunmetadata43masked.TypeLen & 0xFF))
	_nxmtunmetadata43masked.ValueMask = decoder.Read(int(_nxmtunmetadata43masked.TypeLen & 0xFF))
	return _nxmtunmetadata43masked, nil
}

func NewNxmTunMetadata43Masked() *NxmTunMetadata43Masked {
	obj := &NxmTunMetadata43Masked{
		Oxm: NewOxm(108536),
	}
	return obj
}
func (self *NxmTunMetadata43Masked) GetOXMName() string {
	return "tun_metadata43_masked"
}

func (self *NxmTunMetadata43Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata43Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata43Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata44 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata44 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata44(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata44, error) {
	_nxmtunmetadata44 := &NxmTunMetadata44{Oxm: parent}
	_nxmtunmetadata44.Value = decoder.Read(int(_nxmtunmetadata44.TypeLen & 0xFF))
	return _nxmtunmetadata44, nil
}

func NewNxmTunMetadata44() *NxmTunMetadata44 {
	obj := &NxmTunMetadata44{
		Oxm: NewOxm(108668),
	}
	return obj
}
func (self *NxmTunMetadata44) GetOXMName() string {
	return "tun_metadata44"
}

func (self *NxmTunMetadata44) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata44) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata44Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata44Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata44Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata44Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata44Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata44Masked, error) {
	_nxmtunmetadata44masked := &NxmTunMetadata44Masked{Oxm: parent}
	_nxmtunmetadata44masked.Value = decoder.Read(int(_nxmtunmetadata44masked.TypeLen & 0xFF))
	_nxmtunmetadata44masked.ValueMask = decoder.Read(int(_nxmtunmetadata44masked.TypeLen & 0xFF))
	return _nxmtunmetadata44masked, nil
}

func NewNxmTunMetadata44Masked() *NxmTunMetadata44Masked {
	obj := &NxmTunMetadata44Masked{
		Oxm: NewOxm(109048),
	}
	return obj
}
func (self *NxmTunMetadata44Masked) GetOXMName() string {
	return "tun_metadata44_masked"
}

func (self *NxmTunMetadata44Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata44Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata44Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata45 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata45 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata45(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata45, error) {
	_nxmtunmetadata45 := &NxmTunMetadata45{Oxm: parent}
	_nxmtunmetadata45.Value = decoder.Read(int(_nxmtunmetadata45.TypeLen & 0xFF))
	return _nxmtunmetadata45, nil
}

func NewNxmTunMetadata45() *NxmTunMetadata45 {
	obj := &NxmTunMetadata45{
		Oxm: NewOxm(109180),
	}
	return obj
}
func (self *NxmTunMetadata45) GetOXMName() string {
	return "tun_metadata45"
}

func (self *NxmTunMetadata45) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata45) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata45Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata45Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata45Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata45Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata45Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata45Masked, error) {
	_nxmtunmetadata45masked := &NxmTunMetadata45Masked{Oxm: parent}
	_nxmtunmetadata45masked.Value = decoder.Read(int(_nxmtunmetadata45masked.TypeLen & 0xFF))
	_nxmtunmetadata45masked.ValueMask = decoder.Read(int(_nxmtunmetadata45masked.TypeLen & 0xFF))
	return _nxmtunmetadata45masked, nil
}

func NewNxmTunMetadata45Masked() *NxmTunMetadata45Masked {
	obj := &NxmTunMetadata45Masked{
		Oxm: NewOxm(109560),
	}
	return obj
}
func (self *NxmTunMetadata45Masked) GetOXMName() string {
	return "tun_metadata45_masked"
}

func (self *NxmTunMetadata45Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata45Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata45Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata46 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata46 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata46(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata46, error) {
	_nxmtunmetadata46 := &NxmTunMetadata46{Oxm: parent}
	_nxmtunmetadata46.Value = decoder.Read(int(_nxmtunmetadata46.TypeLen & 0xFF))
	return _nxmtunmetadata46, nil
}

func NewNxmTunMetadata46() *NxmTunMetadata46 {
	obj := &NxmTunMetadata46{
		Oxm: NewOxm(109692),
	}
	return obj
}
func (self *NxmTunMetadata46) GetOXMName() string {
	return "tun_metadata46"
}

func (self *NxmTunMetadata46) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata46) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata46Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata46Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata46Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata46Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata46Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata46Masked, error) {
	_nxmtunmetadata46masked := &NxmTunMetadata46Masked{Oxm: parent}
	_nxmtunmetadata46masked.Value = decoder.Read(int(_nxmtunmetadata46masked.TypeLen & 0xFF))
	_nxmtunmetadata46masked.ValueMask = decoder.Read(int(_nxmtunmetadata46masked.TypeLen & 0xFF))
	return _nxmtunmetadata46masked, nil
}

func NewNxmTunMetadata46Masked() *NxmTunMetadata46Masked {
	obj := &NxmTunMetadata46Masked{
		Oxm: NewOxm(110072),
	}
	return obj
}
func (self *NxmTunMetadata46Masked) GetOXMName() string {
	return "tun_metadata46_masked"
}

func (self *NxmTunMetadata46Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata46Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata46Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata47 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata47 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata47(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata47, error) {
	_nxmtunmetadata47 := &NxmTunMetadata47{Oxm: parent}
	_nxmtunmetadata47.Value = decoder.Read(int(_nxmtunmetadata47.TypeLen & 0xFF))
	return _nxmtunmetadata47, nil
}

func NewNxmTunMetadata47() *NxmTunMetadata47 {
	obj := &NxmTunMetadata47{
		Oxm: NewOxm(110204),
	}
	return obj
}
func (self *NxmTunMetadata47) GetOXMName() string {
	return "tun_metadata47"
}

func (self *NxmTunMetadata47) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata47) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata47Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata47Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata47Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata47Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata47Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata47Masked, error) {
	_nxmtunmetadata47masked := &NxmTunMetadata47Masked{Oxm: parent}
	_nxmtunmetadata47masked.Value = decoder.Read(int(_nxmtunmetadata47masked.TypeLen & 0xFF))
	_nxmtunmetadata47masked.ValueMask = decoder.Read(int(_nxmtunmetadata47masked.TypeLen & 0xFF))
	return _nxmtunmetadata47masked, nil
}

func NewNxmTunMetadata47Masked() *NxmTunMetadata47Masked {
	obj := &NxmTunMetadata47Masked{
		Oxm: NewOxm(110584),
	}
	return obj
}
func (self *NxmTunMetadata47Masked) GetOXMName() string {
	return "tun_metadata47_masked"
}

func (self *NxmTunMetadata47Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata47Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata47Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata48 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata48 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata48(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata48, error) {
	_nxmtunmetadata48 := &NxmTunMetadata48{Oxm: parent}
	_nxmtunmetadata48.Value = decoder.Read(int(_nxmtunmetadata48.TypeLen & 0xFF))
	return _nxmtunmetadata48, nil
}

func NewNxmTunMetadata48() *NxmTunMetadata48 {
	obj := &NxmTunMetadata48{
		Oxm: NewOxm(110716),
	}
	return obj
}
func (self *NxmTunMetadata48) GetOXMName() string {
	return "tun_metadata48"
}

func (self *NxmTunMetadata48) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata48) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata48Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata48Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata48Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata48Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata48Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata48Masked, error) {
	_nxmtunmetadata48masked := &NxmTunMetadata48Masked{Oxm: parent}
	_nxmtunmetadata48masked.Value = decoder.Read(int(_nxmtunmetadata48masked.TypeLen & 0xFF))
	_nxmtunmetadata48masked.ValueMask = decoder.Read(int(_nxmtunmetadata48masked.TypeLen & 0xFF))
	return _nxmtunmetadata48masked, nil
}

func NewNxmTunMetadata48Masked() *NxmTunMetadata48Masked {
	obj := &NxmTunMetadata48Masked{
		Oxm: NewOxm(111096),
	}
	return obj
}
func (self *NxmTunMetadata48Masked) GetOXMName() string {
	return "tun_metadata48_masked"
}

func (self *NxmTunMetadata48Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata48Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata48Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata49 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata49 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata49(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata49, error) {
	_nxmtunmetadata49 := &NxmTunMetadata49{Oxm: parent}
	_nxmtunmetadata49.Value = decoder.Read(int(_nxmtunmetadata49.TypeLen & 0xFF))
	return _nxmtunmetadata49, nil
}

func NewNxmTunMetadata49() *NxmTunMetadata49 {
	obj := &NxmTunMetadata49{
		Oxm: NewOxm(111228),
	}
	return obj
}
func (self *NxmTunMetadata49) GetOXMName() string {
	return "tun_metadata49"
}

func (self *NxmTunMetadata49) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata49) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata49Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata49Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata49Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata49Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata49Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata49Masked, error) {
	_nxmtunmetadata49masked := &NxmTunMetadata49Masked{Oxm: parent}
	_nxmtunmetadata49masked.Value = decoder.Read(int(_nxmtunmetadata49masked.TypeLen & 0xFF))
	_nxmtunmetadata49masked.ValueMask = decoder.Read(int(_nxmtunmetadata49masked.TypeLen & 0xFF))
	return _nxmtunmetadata49masked, nil
}

func NewNxmTunMetadata49Masked() *NxmTunMetadata49Masked {
	obj := &NxmTunMetadata49Masked{
		Oxm: NewOxm(111608),
	}
	return obj
}
func (self *NxmTunMetadata49Masked) GetOXMName() string {
	return "tun_metadata49_masked"
}

func (self *NxmTunMetadata49Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata49Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata49Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata4Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata4Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata4Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata4Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata4Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata4Masked, error) {
	_nxmtunmetadata4masked := &NxmTunMetadata4Masked{Oxm: parent}
	_nxmtunmetadata4masked.Value = decoder.Read(int(_nxmtunmetadata4masked.TypeLen & 0xFF))
	_nxmtunmetadata4masked.ValueMask = decoder.Read(int(_nxmtunmetadata4masked.TypeLen & 0xFF))
	return _nxmtunmetadata4masked, nil
}

func NewNxmTunMetadata4Masked() *NxmTunMetadata4Masked {
	obj := &NxmTunMetadata4Masked{
		Oxm: NewOxm(88568),
	}
	return obj
}
func (self *NxmTunMetadata4Masked) GetOXMName() string {
	return "tun_metadata4_masked"
}

func (self *NxmTunMetadata4Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata4Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata4Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata5 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata5 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata5(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata5, error) {
	_nxmtunmetadata5 := &NxmTunMetadata5{Oxm: parent}
	_nxmtunmetadata5.Value = decoder.Read(int(_nxmtunmetadata5.TypeLen & 0xFF))
	return _nxmtunmetadata5, nil
}

func NewNxmTunMetadata5() *NxmTunMetadata5 {
	obj := &NxmTunMetadata5{
		Oxm: NewOxm(88700),
	}
	return obj
}
func (self *NxmTunMetadata5) GetOXMName() string {
	return "tun_metadata5"
}

func (self *NxmTunMetadata5) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata5) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata50 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata50 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata50(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata50, error) {
	_nxmtunmetadata50 := &NxmTunMetadata50{Oxm: parent}
	_nxmtunmetadata50.Value = decoder.Read(int(_nxmtunmetadata50.TypeLen & 0xFF))
	return _nxmtunmetadata50, nil
}

func NewNxmTunMetadata50() *NxmTunMetadata50 {
	obj := &NxmTunMetadata50{
		Oxm: NewOxm(111740),
	}
	return obj
}
func (self *NxmTunMetadata50) GetOXMName() string {
	return "tun_metadata50"
}

func (self *NxmTunMetadata50) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata50) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata50Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata50Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata50Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata50Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata50Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata50Masked, error) {
	_nxmtunmetadata50masked := &NxmTunMetadata50Masked{Oxm: parent}
	_nxmtunmetadata50masked.Value = decoder.Read(int(_nxmtunmetadata50masked.TypeLen & 0xFF))
	_nxmtunmetadata50masked.ValueMask = decoder.Read(int(_nxmtunmetadata50masked.TypeLen & 0xFF))
	return _nxmtunmetadata50masked, nil
}

func NewNxmTunMetadata50Masked() *NxmTunMetadata50Masked {
	obj := &NxmTunMetadata50Masked{
		Oxm: NewOxm(112120),
	}
	return obj
}
func (self *NxmTunMetadata50Masked) GetOXMName() string {
	return "tun_metadata50_masked"
}

func (self *NxmTunMetadata50Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata50Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata50Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata51 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata51 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata51(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata51, error) {
	_nxmtunmetadata51 := &NxmTunMetadata51{Oxm: parent}
	_nxmtunmetadata51.Value = decoder.Read(int(_nxmtunmetadata51.TypeLen & 0xFF))
	return _nxmtunmetadata51, nil
}

func NewNxmTunMetadata51() *NxmTunMetadata51 {
	obj := &NxmTunMetadata51{
		Oxm: NewOxm(112252),
	}
	return obj
}
func (self *NxmTunMetadata51) GetOXMName() string {
	return "tun_metadata51"
}

func (self *NxmTunMetadata51) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata51) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata51Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata51Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata51Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata51Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata51Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata51Masked, error) {
	_nxmtunmetadata51masked := &NxmTunMetadata51Masked{Oxm: parent}
	_nxmtunmetadata51masked.Value = decoder.Read(int(_nxmtunmetadata51masked.TypeLen & 0xFF))
	_nxmtunmetadata51masked.ValueMask = decoder.Read(int(_nxmtunmetadata51masked.TypeLen & 0xFF))
	return _nxmtunmetadata51masked, nil
}

func NewNxmTunMetadata51Masked() *NxmTunMetadata51Masked {
	obj := &NxmTunMetadata51Masked{
		Oxm: NewOxm(112632),
	}
	return obj
}
func (self *NxmTunMetadata51Masked) GetOXMName() string {
	return "tun_metadata51_masked"
}

func (self *NxmTunMetadata51Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata51Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata51Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata52 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata52 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata52(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata52, error) {
	_nxmtunmetadata52 := &NxmTunMetadata52{Oxm: parent}
	_nxmtunmetadata52.Value = decoder.Read(int(_nxmtunmetadata52.TypeLen & 0xFF))
	return _nxmtunmetadata52, nil
}

func NewNxmTunMetadata52() *NxmTunMetadata52 {
	obj := &NxmTunMetadata52{
		Oxm: NewOxm(112764),
	}
	return obj
}
func (self *NxmTunMetadata52) GetOXMName() string {
	return "tun_metadata52"
}

func (self *NxmTunMetadata52) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata52) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata52Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata52Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata52Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata52Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata52Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata52Masked, error) {
	_nxmtunmetadata52masked := &NxmTunMetadata52Masked{Oxm: parent}
	_nxmtunmetadata52masked.Value = decoder.Read(int(_nxmtunmetadata52masked.TypeLen & 0xFF))
	_nxmtunmetadata52masked.ValueMask = decoder.Read(int(_nxmtunmetadata52masked.TypeLen & 0xFF))
	return _nxmtunmetadata52masked, nil
}

func NewNxmTunMetadata52Masked() *NxmTunMetadata52Masked {
	obj := &NxmTunMetadata52Masked{
		Oxm: NewOxm(113144),
	}
	return obj
}
func (self *NxmTunMetadata52Masked) GetOXMName() string {
	return "tun_metadata52_masked"
}

func (self *NxmTunMetadata52Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata52Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata52Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata53 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata53 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata53(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata53, error) {
	_nxmtunmetadata53 := &NxmTunMetadata53{Oxm: parent}
	_nxmtunmetadata53.Value = decoder.Read(int(_nxmtunmetadata53.TypeLen & 0xFF))
	return _nxmtunmetadata53, nil
}

func NewNxmTunMetadata53() *NxmTunMetadata53 {
	obj := &NxmTunMetadata53{
		Oxm: NewOxm(113276),
	}
	return obj
}
func (self *NxmTunMetadata53) GetOXMName() string {
	return "tun_metadata53"
}

func (self *NxmTunMetadata53) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata53) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata53Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata53Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata53Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata53Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata53Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata53Masked, error) {
	_nxmtunmetadata53masked := &NxmTunMetadata53Masked{Oxm: parent}
	_nxmtunmetadata53masked.Value = decoder.Read(int(_nxmtunmetadata53masked.TypeLen & 0xFF))
	_nxmtunmetadata53masked.ValueMask = decoder.Read(int(_nxmtunmetadata53masked.TypeLen & 0xFF))
	return _nxmtunmetadata53masked, nil
}

func NewNxmTunMetadata53Masked() *NxmTunMetadata53Masked {
	obj := &NxmTunMetadata53Masked{
		Oxm: NewOxm(113656),
	}
	return obj
}
func (self *NxmTunMetadata53Masked) GetOXMName() string {
	return "tun_metadata53_masked"
}

func (self *NxmTunMetadata53Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata53Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata53Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata54 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata54 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata54(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata54, error) {
	_nxmtunmetadata54 := &NxmTunMetadata54{Oxm: parent}
	_nxmtunmetadata54.Value = decoder.Read(int(_nxmtunmetadata54.TypeLen & 0xFF))
	return _nxmtunmetadata54, nil
}

func NewNxmTunMetadata54() *NxmTunMetadata54 {
	obj := &NxmTunMetadata54{
		Oxm: NewOxm(113788),
	}
	return obj
}
func (self *NxmTunMetadata54) GetOXMName() string {
	return "tun_metadata54"
}

func (self *NxmTunMetadata54) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata54) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata54Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata54Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata54Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata54Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata54Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata54Masked, error) {
	_nxmtunmetadata54masked := &NxmTunMetadata54Masked{Oxm: parent}
	_nxmtunmetadata54masked.Value = decoder.Read(int(_nxmtunmetadata54masked.TypeLen & 0xFF))
	_nxmtunmetadata54masked.ValueMask = decoder.Read(int(_nxmtunmetadata54masked.TypeLen & 0xFF))
	return _nxmtunmetadata54masked, nil
}

func NewNxmTunMetadata54Masked() *NxmTunMetadata54Masked {
	obj := &NxmTunMetadata54Masked{
		Oxm: NewOxm(114168),
	}
	return obj
}
func (self *NxmTunMetadata54Masked) GetOXMName() string {
	return "tun_metadata54_masked"
}

func (self *NxmTunMetadata54Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata54Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata54Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata55 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata55 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata55(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata55, error) {
	_nxmtunmetadata55 := &NxmTunMetadata55{Oxm: parent}
	_nxmtunmetadata55.Value = decoder.Read(int(_nxmtunmetadata55.TypeLen & 0xFF))
	return _nxmtunmetadata55, nil
}

func NewNxmTunMetadata55() *NxmTunMetadata55 {
	obj := &NxmTunMetadata55{
		Oxm: NewOxm(114300),
	}
	return obj
}
func (self *NxmTunMetadata55) GetOXMName() string {
	return "tun_metadata55"
}

func (self *NxmTunMetadata55) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata55) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata55Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata55Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata55Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata55Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata55Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata55Masked, error) {
	_nxmtunmetadata55masked := &NxmTunMetadata55Masked{Oxm: parent}
	_nxmtunmetadata55masked.Value = decoder.Read(int(_nxmtunmetadata55masked.TypeLen & 0xFF))
	_nxmtunmetadata55masked.ValueMask = decoder.Read(int(_nxmtunmetadata55masked.TypeLen & 0xFF))
	return _nxmtunmetadata55masked, nil
}

func NewNxmTunMetadata55Masked() *NxmTunMetadata55Masked {
	obj := &NxmTunMetadata55Masked{
		Oxm: NewOxm(114680),
	}
	return obj
}
func (self *NxmTunMetadata55Masked) GetOXMName() string {
	return "tun_metadata55_masked"
}

func (self *NxmTunMetadata55Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata55Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata55Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata56 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata56 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata56(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata56, error) {
	_nxmtunmetadata56 := &NxmTunMetadata56{Oxm: parent}
	_nxmtunmetadata56.Value = decoder.Read(int(_nxmtunmetadata56.TypeLen & 0xFF))
	return _nxmtunmetadata56, nil
}

func NewNxmTunMetadata56() *NxmTunMetadata56 {
	obj := &NxmTunMetadata56{
		Oxm: NewOxm(114812),
	}
	return obj
}
func (self *NxmTunMetadata56) GetOXMName() string {
	return "tun_metadata56"
}

func (self *NxmTunMetadata56) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata56) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata56Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata56Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata56Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata56Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata56Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata56Masked, error) {
	_nxmtunmetadata56masked := &NxmTunMetadata56Masked{Oxm: parent}
	_nxmtunmetadata56masked.Value = decoder.Read(int(_nxmtunmetadata56masked.TypeLen & 0xFF))
	_nxmtunmetadata56masked.ValueMask = decoder.Read(int(_nxmtunmetadata56masked.TypeLen & 0xFF))
	return _nxmtunmetadata56masked, nil
}

func NewNxmTunMetadata56Masked() *NxmTunMetadata56Masked {
	obj := &NxmTunMetadata56Masked{
		Oxm: NewOxm(115192),
	}
	return obj
}
func (self *NxmTunMetadata56Masked) GetOXMName() string {
	return "tun_metadata56_masked"
}

func (self *NxmTunMetadata56Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata56Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata56Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata57 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata57 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata57(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata57, error) {
	_nxmtunmetadata57 := &NxmTunMetadata57{Oxm: parent}
	_nxmtunmetadata57.Value = decoder.Read(int(_nxmtunmetadata57.TypeLen & 0xFF))
	return _nxmtunmetadata57, nil
}

func NewNxmTunMetadata57() *NxmTunMetadata57 {
	obj := &NxmTunMetadata57{
		Oxm: NewOxm(115324),
	}
	return obj
}
func (self *NxmTunMetadata57) GetOXMName() string {
	return "tun_metadata57"
}

func (self *NxmTunMetadata57) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata57) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata57Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata57Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata57Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata57Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata57Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata57Masked, error) {
	_nxmtunmetadata57masked := &NxmTunMetadata57Masked{Oxm: parent}
	_nxmtunmetadata57masked.Value = decoder.Read(int(_nxmtunmetadata57masked.TypeLen & 0xFF))
	_nxmtunmetadata57masked.ValueMask = decoder.Read(int(_nxmtunmetadata57masked.TypeLen & 0xFF))
	return _nxmtunmetadata57masked, nil
}

func NewNxmTunMetadata57Masked() *NxmTunMetadata57Masked {
	obj := &NxmTunMetadata57Masked{
		Oxm: NewOxm(115704),
	}
	return obj
}
func (self *NxmTunMetadata57Masked) GetOXMName() string {
	return "tun_metadata57_masked"
}

func (self *NxmTunMetadata57Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata57Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata57Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata58 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata58 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata58(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata58, error) {
	_nxmtunmetadata58 := &NxmTunMetadata58{Oxm: parent}
	_nxmtunmetadata58.Value = decoder.Read(int(_nxmtunmetadata58.TypeLen & 0xFF))
	return _nxmtunmetadata58, nil
}

func NewNxmTunMetadata58() *NxmTunMetadata58 {
	obj := &NxmTunMetadata58{
		Oxm: NewOxm(115836),
	}
	return obj
}
func (self *NxmTunMetadata58) GetOXMName() string {
	return "tun_metadata58"
}

func (self *NxmTunMetadata58) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata58) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata58Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata58Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata58Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata58Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata58Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata58Masked, error) {
	_nxmtunmetadata58masked := &NxmTunMetadata58Masked{Oxm: parent}
	_nxmtunmetadata58masked.Value = decoder.Read(int(_nxmtunmetadata58masked.TypeLen & 0xFF))
	_nxmtunmetadata58masked.ValueMask = decoder.Read(int(_nxmtunmetadata58masked.TypeLen & 0xFF))
	return _nxmtunmetadata58masked, nil
}

func NewNxmTunMetadata58Masked() *NxmTunMetadata58Masked {
	obj := &NxmTunMetadata58Masked{
		Oxm: NewOxm(116216),
	}
	return obj
}
func (self *NxmTunMetadata58Masked) GetOXMName() string {
	return "tun_metadata58_masked"
}

func (self *NxmTunMetadata58Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata58Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata58Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata59 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata59 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata59(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata59, error) {
	_nxmtunmetadata59 := &NxmTunMetadata59{Oxm: parent}
	_nxmtunmetadata59.Value = decoder.Read(int(_nxmtunmetadata59.TypeLen & 0xFF))
	return _nxmtunmetadata59, nil
}

func NewNxmTunMetadata59() *NxmTunMetadata59 {
	obj := &NxmTunMetadata59{
		Oxm: NewOxm(116348),
	}
	return obj
}
func (self *NxmTunMetadata59) GetOXMName() string {
	return "tun_metadata59"
}

func (self *NxmTunMetadata59) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata59) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata59Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata59Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata59Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata59Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata59Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata59Masked, error) {
	_nxmtunmetadata59masked := &NxmTunMetadata59Masked{Oxm: parent}
	_nxmtunmetadata59masked.Value = decoder.Read(int(_nxmtunmetadata59masked.TypeLen & 0xFF))
	_nxmtunmetadata59masked.ValueMask = decoder.Read(int(_nxmtunmetadata59masked.TypeLen & 0xFF))
	return _nxmtunmetadata59masked, nil
}

func NewNxmTunMetadata59Masked() *NxmTunMetadata59Masked {
	obj := &NxmTunMetadata59Masked{
		Oxm: NewOxm(116728),
	}
	return obj
}
func (self *NxmTunMetadata59Masked) GetOXMName() string {
	return "tun_metadata59_masked"
}

func (self *NxmTunMetadata59Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata59Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata59Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata5Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata5Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata5Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata5Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata5Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata5Masked, error) {
	_nxmtunmetadata5masked := &NxmTunMetadata5Masked{Oxm: parent}
	_nxmtunmetadata5masked.Value = decoder.Read(int(_nxmtunmetadata5masked.TypeLen & 0xFF))
	_nxmtunmetadata5masked.ValueMask = decoder.Read(int(_nxmtunmetadata5masked.TypeLen & 0xFF))
	return _nxmtunmetadata5masked, nil
}

func NewNxmTunMetadata5Masked() *NxmTunMetadata5Masked {
	obj := &NxmTunMetadata5Masked{
		Oxm: NewOxm(89080),
	}
	return obj
}
func (self *NxmTunMetadata5Masked) GetOXMName() string {
	return "tun_metadata5_masked"
}

func (self *NxmTunMetadata5Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata5Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata5Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata6 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata6 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata6(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata6, error) {
	_nxmtunmetadata6 := &NxmTunMetadata6{Oxm: parent}
	_nxmtunmetadata6.Value = decoder.Read(int(_nxmtunmetadata6.TypeLen & 0xFF))
	return _nxmtunmetadata6, nil
}

func NewNxmTunMetadata6() *NxmTunMetadata6 {
	obj := &NxmTunMetadata6{
		Oxm: NewOxm(89212),
	}
	return obj
}
func (self *NxmTunMetadata6) GetOXMName() string {
	return "tun_metadata6"
}

func (self *NxmTunMetadata6) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata6) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata60 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata60 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata60(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata60, error) {
	_nxmtunmetadata60 := &NxmTunMetadata60{Oxm: parent}
	_nxmtunmetadata60.Value = decoder.Read(int(_nxmtunmetadata60.TypeLen & 0xFF))
	return _nxmtunmetadata60, nil
}

func NewNxmTunMetadata60() *NxmTunMetadata60 {
	obj := &NxmTunMetadata60{
		Oxm: NewOxm(116860),
	}
	return obj
}
func (self *NxmTunMetadata60) GetOXMName() string {
	return "tun_metadata60"
}

func (self *NxmTunMetadata60) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata60) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata60Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata60Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata60Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata60Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata60Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata60Masked, error) {
	_nxmtunmetadata60masked := &NxmTunMetadata60Masked{Oxm: parent}
	_nxmtunmetadata60masked.Value = decoder.Read(int(_nxmtunmetadata60masked.TypeLen & 0xFF))
	_nxmtunmetadata60masked.ValueMask = decoder.Read(int(_nxmtunmetadata60masked.TypeLen & 0xFF))
	return _nxmtunmetadata60masked, nil
}

func NewNxmTunMetadata60Masked() *NxmTunMetadata60Masked {
	obj := &NxmTunMetadata60Masked{
		Oxm: NewOxm(117240),
	}
	return obj
}
func (self *NxmTunMetadata60Masked) GetOXMName() string {
	return "tun_metadata60_masked"
}

func (self *NxmTunMetadata60Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata60Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata60Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata61 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata61 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata61(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata61, error) {
	_nxmtunmetadata61 := &NxmTunMetadata61{Oxm: parent}
	_nxmtunmetadata61.Value = decoder.Read(int(_nxmtunmetadata61.TypeLen & 0xFF))
	return _nxmtunmetadata61, nil
}

func NewNxmTunMetadata61() *NxmTunMetadata61 {
	obj := &NxmTunMetadata61{
		Oxm: NewOxm(117372),
	}
	return obj
}
func (self *NxmTunMetadata61) GetOXMName() string {
	return "tun_metadata61"
}

func (self *NxmTunMetadata61) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata61) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata61Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata61Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata61Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata61Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata61Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata61Masked, error) {
	_nxmtunmetadata61masked := &NxmTunMetadata61Masked{Oxm: parent}
	_nxmtunmetadata61masked.Value = decoder.Read(int(_nxmtunmetadata61masked.TypeLen & 0xFF))
	_nxmtunmetadata61masked.ValueMask = decoder.Read(int(_nxmtunmetadata61masked.TypeLen & 0xFF))
	return _nxmtunmetadata61masked, nil
}

func NewNxmTunMetadata61Masked() *NxmTunMetadata61Masked {
	obj := &NxmTunMetadata61Masked{
		Oxm: NewOxm(117752),
	}
	return obj
}
func (self *NxmTunMetadata61Masked) GetOXMName() string {
	return "tun_metadata61_masked"
}

func (self *NxmTunMetadata61Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata61Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata61Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata62 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata62 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata62(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata62, error) {
	_nxmtunmetadata62 := &NxmTunMetadata62{Oxm: parent}
	_nxmtunmetadata62.Value = decoder.Read(int(_nxmtunmetadata62.TypeLen & 0xFF))
	return _nxmtunmetadata62, nil
}

func NewNxmTunMetadata62() *NxmTunMetadata62 {
	obj := &NxmTunMetadata62{
		Oxm: NewOxm(117884),
	}
	return obj
}
func (self *NxmTunMetadata62) GetOXMName() string {
	return "tun_metadata62"
}

func (self *NxmTunMetadata62) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata62) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata62Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata62Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata62Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata62Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata62Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata62Masked, error) {
	_nxmtunmetadata62masked := &NxmTunMetadata62Masked{Oxm: parent}
	_nxmtunmetadata62masked.Value = decoder.Read(int(_nxmtunmetadata62masked.TypeLen & 0xFF))
	_nxmtunmetadata62masked.ValueMask = decoder.Read(int(_nxmtunmetadata62masked.TypeLen & 0xFF))
	return _nxmtunmetadata62masked, nil
}

func NewNxmTunMetadata62Masked() *NxmTunMetadata62Masked {
	obj := &NxmTunMetadata62Masked{
		Oxm: NewOxm(118264),
	}
	return obj
}
func (self *NxmTunMetadata62Masked) GetOXMName() string {
	return "tun_metadata62_masked"
}

func (self *NxmTunMetadata62Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata62Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata62Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata63 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata63 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata63(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata63, error) {
	_nxmtunmetadata63 := &NxmTunMetadata63{Oxm: parent}
	_nxmtunmetadata63.Value = decoder.Read(int(_nxmtunmetadata63.TypeLen & 0xFF))
	return _nxmtunmetadata63, nil
}

func NewNxmTunMetadata63() *NxmTunMetadata63 {
	obj := &NxmTunMetadata63{
		Oxm: NewOxm(118396),
	}
	return obj
}
func (self *NxmTunMetadata63) GetOXMName() string {
	return "tun_metadata63"
}

func (self *NxmTunMetadata63) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata63) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata63Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata63Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata63Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata63Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata63Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata63Masked, error) {
	_nxmtunmetadata63masked := &NxmTunMetadata63Masked{Oxm: parent}
	_nxmtunmetadata63masked.Value = decoder.Read(int(_nxmtunmetadata63masked.TypeLen & 0xFF))
	_nxmtunmetadata63masked.ValueMask = decoder.Read(int(_nxmtunmetadata63masked.TypeLen & 0xFF))
	return _nxmtunmetadata63masked, nil
}

func NewNxmTunMetadata63Masked() *NxmTunMetadata63Masked {
	obj := &NxmTunMetadata63Masked{
		Oxm: NewOxm(118776),
	}
	return obj
}
func (self *NxmTunMetadata63Masked) GetOXMName() string {
	return "tun_metadata63_masked"
}

func (self *NxmTunMetadata63Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata63Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata63Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata6Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata6Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata6Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata6Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata6Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata6Masked, error) {
	_nxmtunmetadata6masked := &NxmTunMetadata6Masked{Oxm: parent}
	_nxmtunmetadata6masked.Value = decoder.Read(int(_nxmtunmetadata6masked.TypeLen & 0xFF))
	_nxmtunmetadata6masked.ValueMask = decoder.Read(int(_nxmtunmetadata6masked.TypeLen & 0xFF))
	return _nxmtunmetadata6masked, nil
}

func NewNxmTunMetadata6Masked() *NxmTunMetadata6Masked {
	obj := &NxmTunMetadata6Masked{
		Oxm: NewOxm(89592),
	}
	return obj
}
func (self *NxmTunMetadata6Masked) GetOXMName() string {
	return "tun_metadata6_masked"
}

func (self *NxmTunMetadata6Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata6Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata6Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata7 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata7 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata7(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata7, error) {
	_nxmtunmetadata7 := &NxmTunMetadata7{Oxm: parent}
	_nxmtunmetadata7.Value = decoder.Read(int(_nxmtunmetadata7.TypeLen & 0xFF))
	return _nxmtunmetadata7, nil
}

func NewNxmTunMetadata7() *NxmTunMetadata7 {
	obj := &NxmTunMetadata7{
		Oxm: NewOxm(89724),
	}
	return obj
}
func (self *NxmTunMetadata7) GetOXMName() string {
	return "tun_metadata7"
}

func (self *NxmTunMetadata7) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata7) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata7Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata7Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata7Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata7Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata7Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata7Masked, error) {
	_nxmtunmetadata7masked := &NxmTunMetadata7Masked{Oxm: parent}
	_nxmtunmetadata7masked.Value = decoder.Read(int(_nxmtunmetadata7masked.TypeLen & 0xFF))
	_nxmtunmetadata7masked.ValueMask = decoder.Read(int(_nxmtunmetadata7masked.TypeLen & 0xFF))
	return _nxmtunmetadata7masked, nil
}

func NewNxmTunMetadata7Masked() *NxmTunMetadata7Masked {
	obj := &NxmTunMetadata7Masked{
		Oxm: NewOxm(90104),
	}
	return obj
}
func (self *NxmTunMetadata7Masked) GetOXMName() string {
	return "tun_metadata7_masked"
}

func (self *NxmTunMetadata7Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata7Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata7Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata8 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata8 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata8(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata8, error) {
	_nxmtunmetadata8 := &NxmTunMetadata8{Oxm: parent}
	_nxmtunmetadata8.Value = decoder.Read(int(_nxmtunmetadata8.TypeLen & 0xFF))
	return _nxmtunmetadata8, nil
}

func NewNxmTunMetadata8() *NxmTunMetadata8 {
	obj := &NxmTunMetadata8{
		Oxm: NewOxm(90236),
	}
	return obj
}
func (self *NxmTunMetadata8) GetOXMName() string {
	return "tun_metadata8"
}

func (self *NxmTunMetadata8) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata8) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata8Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata8Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata8Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata8Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata8Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata8Masked, error) {
	_nxmtunmetadata8masked := &NxmTunMetadata8Masked{Oxm: parent}
	_nxmtunmetadata8masked.Value = decoder.Read(int(_nxmtunmetadata8masked.TypeLen & 0xFF))
	_nxmtunmetadata8masked.ValueMask = decoder.Read(int(_nxmtunmetadata8masked.TypeLen & 0xFF))
	return _nxmtunmetadata8masked, nil
}

func NewNxmTunMetadata8Masked() *NxmTunMetadata8Masked {
	obj := &NxmTunMetadata8Masked{
		Oxm: NewOxm(90616),
	}
	return obj
}
func (self *NxmTunMetadata8Masked) GetOXMName() string {
	return "tun_metadata8_masked"
}

func (self *NxmTunMetadata8Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata8Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata8Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunMetadata9 struct {
	*Oxm
	Value []byte
}

type INxmTunMetadata9 interface {
	goloxi.IOxm
	GetValue() []byte
}

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

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

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

	encoder.Write(self.Value)

	return nil
}

func DecodeNxmTunMetadata9(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata9, error) {
	_nxmtunmetadata9 := &NxmTunMetadata9{Oxm: parent}
	_nxmtunmetadata9.Value = decoder.Read(int(_nxmtunmetadata9.TypeLen & 0xFF))
	return _nxmtunmetadata9, nil
}

func NewNxmTunMetadata9() *NxmTunMetadata9 {
	obj := &NxmTunMetadata9{
		Oxm: NewOxm(90748),
	}
	return obj
}
func (self *NxmTunMetadata9) GetOXMName() string {
	return "tun_metadata9"
}

func (self *NxmTunMetadata9) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata9) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunMetadata9Masked struct {
	*Oxm
	Value     []byte
	ValueMask []byte
}

type INxmTunMetadata9Masked interface {
	goloxi.IOxm
	GetValue() []byte
	GetValueMask() []byte
}

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

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

func (self *NxmTunMetadata9Masked) GetValueMask() []byte {
	return self.ValueMask
}

func (self *NxmTunMetadata9Masked) SetValueMask(v []byte) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeNxmTunMetadata9Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata9Masked, error) {
	_nxmtunmetadata9masked := &NxmTunMetadata9Masked{Oxm: parent}
	_nxmtunmetadata9masked.Value = decoder.Read(int(_nxmtunmetadata9masked.TypeLen & 0xFF))
	_nxmtunmetadata9masked.ValueMask = decoder.Read(int(_nxmtunmetadata9masked.TypeLen & 0xFF))
	return _nxmtunmetadata9masked, nil
}

func NewNxmTunMetadata9Masked() *NxmTunMetadata9Masked {
	obj := &NxmTunMetadata9Masked{
		Oxm: NewOxm(91128),
	}
	return obj
}
func (self *NxmTunMetadata9Masked) GetOXMName() string {
	return "tun_metadata9_masked"
}

func (self *NxmTunMetadata9Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunMetadata9Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunMetadata9Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmTunSrc struct {
	*Oxm
	Value net.IP
}

type INxmTunSrc interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *NxmTunSrc) GetValue() net.IP {
	return self.Value
}

func (self *NxmTunSrc) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To4())

	return nil
}

func DecodeNxmTunSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunSrc, error) {
	_nxmtunsrc := &NxmTunSrc{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmTunSrc packet too short: %d < 4", decoder.Length())
	}
	_nxmtunsrc.Value = net.IP(decoder.Read(4))
	return _nxmtunsrc, nil
}

func NewNxmTunSrc() *NxmTunSrc {
	obj := &NxmTunSrc{
		Oxm: NewOxm(81412),
	}
	return obj
}
func (self *NxmTunSrc) GetOXMName() string {
	return "tun_src"
}

func (self *NxmTunSrc) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunSrc) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmTunSrcMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type INxmTunSrcMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *NxmTunSrcMasked) GetValue() net.IP {
	return self.Value
}

func (self *NxmTunSrcMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *NxmTunSrcMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *NxmTunSrcMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To4())
	encoder.Write(self.ValueMask.To4())

	return nil
}

func DecodeNxmTunSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunSrcMasked, error) {
	_nxmtunsrcmasked := &NxmTunSrcMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("NxmTunSrcMasked packet too short: %d < 8", decoder.Length())
	}
	_nxmtunsrcmasked.Value = net.IP(decoder.Read(4))
	_nxmtunsrcmasked.ValueMask = net.IP(decoder.Read(4))
	return _nxmtunsrcmasked, nil
}

func NewNxmTunSrcMasked() *NxmTunSrcMasked {
	obj := &NxmTunSrcMasked{
		Oxm: NewOxm(81672),
	}
	return obj
}
func (self *NxmTunSrcMasked) GetOXMName() string {
	return "tun_src_masked"
}

func (self *NxmTunSrcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmTunSrcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmTunSrcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmUdpDst struct {
	*Oxm
	Value uint16
}

type INxmUdpDst interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *NxmUdpDst) GetValue() uint16 {
	return self.Value
}

func (self *NxmUdpDst) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeNxmUdpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpDst, error) {
	_nxmudpdst := &NxmUdpDst{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("NxmUdpDst packet too short: %d < 2", decoder.Length())
	}
	_nxmudpdst.Value = uint16(decoder.ReadUint16())
	return _nxmudpdst, nil
}

func NewNxmUdpDst() *NxmUdpDst {
	obj := &NxmUdpDst{
		Oxm: NewOxm(6146),
	}
	return obj
}
func (self *NxmUdpDst) GetOXMName() string {
	return "udp_dst"
}

func (self *NxmUdpDst) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmUdpDst) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmUdpDstMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type INxmUdpDstMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *NxmUdpDstMasked) GetValue() uint16 {
	return self.Value
}

func (self *NxmUdpDstMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *NxmUdpDstMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *NxmUdpDstMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeNxmUdpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpDstMasked, error) {
	_nxmudpdstmasked := &NxmUdpDstMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmUdpDstMasked packet too short: %d < 4", decoder.Length())
	}
	_nxmudpdstmasked.Value = uint16(decoder.ReadUint16())
	_nxmudpdstmasked.ValueMask = uint16(decoder.ReadUint16())
	return _nxmudpdstmasked, nil
}

func NewNxmUdpDstMasked() *NxmUdpDstMasked {
	obj := &NxmUdpDstMasked{
		Oxm: NewOxm(6404),
	}
	return obj
}
func (self *NxmUdpDstMasked) GetOXMName() string {
	return "udp_dst_masked"
}

func (self *NxmUdpDstMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmUdpDstMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmUdpDstMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmUdpSrc struct {
	*Oxm
	Value uint16
}

type INxmUdpSrc interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *NxmUdpSrc) GetValue() uint16 {
	return self.Value
}

func (self *NxmUdpSrc) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeNxmUdpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpSrc, error) {
	_nxmudpsrc := &NxmUdpSrc{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("NxmUdpSrc packet too short: %d < 2", decoder.Length())
	}
	_nxmudpsrc.Value = uint16(decoder.ReadUint16())
	return _nxmudpsrc, nil
}

func NewNxmUdpSrc() *NxmUdpSrc {
	obj := &NxmUdpSrc{
		Oxm: NewOxm(5634),
	}
	return obj
}
func (self *NxmUdpSrc) GetOXMName() string {
	return "udp_src"
}

func (self *NxmUdpSrc) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmUdpSrc) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmUdpSrcMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type INxmUdpSrcMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *NxmUdpSrcMasked) GetValue() uint16 {
	return self.Value
}

func (self *NxmUdpSrcMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *NxmUdpSrcMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *NxmUdpSrcMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeNxmUdpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpSrcMasked, error) {
	_nxmudpsrcmasked := &NxmUdpSrcMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmUdpSrcMasked packet too short: %d < 4", decoder.Length())
	}
	_nxmudpsrcmasked.Value = uint16(decoder.ReadUint16())
	_nxmudpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
	return _nxmudpsrcmasked, nil
}

func NewNxmUdpSrcMasked() *NxmUdpSrcMasked {
	obj := &NxmUdpSrcMasked{
		Oxm: NewOxm(5892),
	}
	return obj
}
func (self *NxmUdpSrcMasked) GetOXMName() string {
	return "udp_src_masked"
}

func (self *NxmUdpSrcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmUdpSrcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmUdpSrcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmVlanTci struct {
	*Oxm
	Value uint16
}

type INxmVlanTci interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *NxmVlanTci) GetValue() uint16 {
	return self.Value
}

func (self *NxmVlanTci) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeNxmVlanTci(parent *Oxm, decoder *goloxi.Decoder) (*NxmVlanTci, error) {
	_nxmvlantci := &NxmVlanTci{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("NxmVlanTci packet too short: %d < 2", decoder.Length())
	}
	_nxmvlantci.Value = uint16(decoder.ReadUint16())
	return _nxmvlantci, nil
}

func NewNxmVlanTci() *NxmVlanTci {
	obj := &NxmVlanTci{
		Oxm: NewOxm(2050),
	}
	return obj
}
func (self *NxmVlanTci) GetOXMName() string {
	return "vlan_tci"
}

func (self *NxmVlanTci) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmVlanTci) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmVlanTciMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type INxmVlanTciMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *NxmVlanTciMasked) GetValue() uint16 {
	return self.Value
}

func (self *NxmVlanTciMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *NxmVlanTciMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *NxmVlanTciMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeNxmVlanTciMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmVlanTciMasked, error) {
	_nxmvlantcimasked := &NxmVlanTciMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NxmVlanTciMasked packet too short: %d < 4", decoder.Length())
	}
	_nxmvlantcimasked.Value = uint16(decoder.ReadUint16())
	_nxmvlantcimasked.ValueMask = uint16(decoder.ReadUint16())
	return _nxmvlantcimasked, nil
}

func NewNxmVlanTciMasked() *NxmVlanTciMasked {
	obj := &NxmVlanTciMasked{
		Oxm: NewOxm(2308),
	}
	return obj
}
func (self *NxmVlanTciMasked) GetOXMName() string {
	return "vlan_tci_masked"
}

func (self *NxmVlanTciMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmVlanTciMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmVlanTciMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmXxreg0 struct {
	*Oxm
	Value uint128
}

type INxmXxreg0 interface {
	goloxi.IOxm
	GetValue() uint128
}

func (self *NxmXxreg0) GetValue() uint128 {
	return self.Value
}

func (self *NxmXxreg0) SetValue(v uint128) {
	self.Value = v
}

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

	encoder.PutUint128(uint128(self.Value))

	return nil
}

func DecodeNxmXxreg0(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg0, error) {
	_nxmxxreg0 := &NxmXxreg0{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("NxmXxreg0 packet too short: %d < 16", decoder.Length())
	}
	_nxmxxreg0.Value = uint128(decoder.ReadUint128())
	return _nxmxxreg0, nil
}

func NewNxmXxreg0() *NxmXxreg0 {
	obj := &NxmXxreg0{
		Oxm: NewOxm(122384),
	}
	return obj
}
func (self *NxmXxreg0) GetOXMName() string {
	return "xxreg0"
}

func (self *NxmXxreg0) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmXxreg0) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmXxreg0Masked struct {
	*Oxm
	Value     uint128
	ValueMask uint128
}

type INxmXxreg0Masked interface {
	goloxi.IOxm
	GetValue() uint128
	GetValueMask() uint128
}

func (self *NxmXxreg0Masked) GetValue() uint128 {
	return self.Value
}

func (self *NxmXxreg0Masked) SetValue(v uint128) {
	self.Value = v
}

func (self *NxmXxreg0Masked) GetValueMask() uint128 {
	return self.ValueMask
}

func (self *NxmXxreg0Masked) SetValueMask(v uint128) {
	self.ValueMask = v
}

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

	encoder.PutUint128(uint128(self.Value))
	encoder.PutUint128(uint128(self.ValueMask))

	return nil
}

func DecodeNxmXxreg0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg0Masked, error) {
	_nxmxxreg0masked := &NxmXxreg0Masked{Oxm: parent}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("NxmXxreg0Masked packet too short: %d < 32", decoder.Length())
	}
	_nxmxxreg0masked.Value = uint128(decoder.ReadUint128())
	_nxmxxreg0masked.ValueMask = uint128(decoder.ReadUint128())
	return _nxmxxreg0masked, nil
}

func NewNxmXxreg0Masked() *NxmXxreg0Masked {
	obj := &NxmXxreg0Masked{
		Oxm: NewOxm(122656),
	}
	return obj
}
func (self *NxmXxreg0Masked) GetOXMName() string {
	return "xxreg0_masked"
}

func (self *NxmXxreg0Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmXxreg0Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmXxreg0Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmXxreg1 struct {
	*Oxm
	Value uint128
}

type INxmXxreg1 interface {
	goloxi.IOxm
	GetValue() uint128
}

func (self *NxmXxreg1) GetValue() uint128 {
	return self.Value
}

func (self *NxmXxreg1) SetValue(v uint128) {
	self.Value = v
}

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

	encoder.PutUint128(uint128(self.Value))

	return nil
}

func DecodeNxmXxreg1(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg1, error) {
	_nxmxxreg1 := &NxmXxreg1{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("NxmXxreg1 packet too short: %d < 16", decoder.Length())
	}
	_nxmxxreg1.Value = uint128(decoder.ReadUint128())
	return _nxmxxreg1, nil
}

func NewNxmXxreg1() *NxmXxreg1 {
	obj := &NxmXxreg1{
		Oxm: NewOxm(122896),
	}
	return obj
}
func (self *NxmXxreg1) GetOXMName() string {
	return "xxreg1"
}

func (self *NxmXxreg1) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmXxreg1) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmXxreg1Masked struct {
	*Oxm
	Value     uint128
	ValueMask uint128
}

type INxmXxreg1Masked interface {
	goloxi.IOxm
	GetValue() uint128
	GetValueMask() uint128
}

func (self *NxmXxreg1Masked) GetValue() uint128 {
	return self.Value
}

func (self *NxmXxreg1Masked) SetValue(v uint128) {
	self.Value = v
}

func (self *NxmXxreg1Masked) GetValueMask() uint128 {
	return self.ValueMask
}

func (self *NxmXxreg1Masked) SetValueMask(v uint128) {
	self.ValueMask = v
}

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

	encoder.PutUint128(uint128(self.Value))
	encoder.PutUint128(uint128(self.ValueMask))

	return nil
}

func DecodeNxmXxreg1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg1Masked, error) {
	_nxmxxreg1masked := &NxmXxreg1Masked{Oxm: parent}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("NxmXxreg1Masked packet too short: %d < 32", decoder.Length())
	}
	_nxmxxreg1masked.Value = uint128(decoder.ReadUint128())
	_nxmxxreg1masked.ValueMask = uint128(decoder.ReadUint128())
	return _nxmxxreg1masked, nil
}

func NewNxmXxreg1Masked() *NxmXxreg1Masked {
	obj := &NxmXxreg1Masked{
		Oxm: NewOxm(123168),
	}
	return obj
}
func (self *NxmXxreg1Masked) GetOXMName() string {
	return "xxreg1_masked"
}

func (self *NxmXxreg1Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmXxreg1Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmXxreg1Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmXxreg2 struct {
	*Oxm
	Value uint128
}

type INxmXxreg2 interface {
	goloxi.IOxm
	GetValue() uint128
}

func (self *NxmXxreg2) GetValue() uint128 {
	return self.Value
}

func (self *NxmXxreg2) SetValue(v uint128) {
	self.Value = v
}

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

	encoder.PutUint128(uint128(self.Value))

	return nil
}

func DecodeNxmXxreg2(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg2, error) {
	_nxmxxreg2 := &NxmXxreg2{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("NxmXxreg2 packet too short: %d < 16", decoder.Length())
	}
	_nxmxxreg2.Value = uint128(decoder.ReadUint128())
	return _nxmxxreg2, nil
}

func NewNxmXxreg2() *NxmXxreg2 {
	obj := &NxmXxreg2{
		Oxm: NewOxm(123408),
	}
	return obj
}
func (self *NxmXxreg2) GetOXMName() string {
	return "xxreg2"
}

func (self *NxmXxreg2) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmXxreg2) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmXxreg2Masked struct {
	*Oxm
	Value     uint128
	ValueMask uint128
}

type INxmXxreg2Masked interface {
	goloxi.IOxm
	GetValue() uint128
	GetValueMask() uint128
}

func (self *NxmXxreg2Masked) GetValue() uint128 {
	return self.Value
}

func (self *NxmXxreg2Masked) SetValue(v uint128) {
	self.Value = v
}

func (self *NxmXxreg2Masked) GetValueMask() uint128 {
	return self.ValueMask
}

func (self *NxmXxreg2Masked) SetValueMask(v uint128) {
	self.ValueMask = v
}

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

	encoder.PutUint128(uint128(self.Value))
	encoder.PutUint128(uint128(self.ValueMask))

	return nil
}

func DecodeNxmXxreg2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg2Masked, error) {
	_nxmxxreg2masked := &NxmXxreg2Masked{Oxm: parent}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("NxmXxreg2Masked packet too short: %d < 32", decoder.Length())
	}
	_nxmxxreg2masked.Value = uint128(decoder.ReadUint128())
	_nxmxxreg2masked.ValueMask = uint128(decoder.ReadUint128())
	return _nxmxxreg2masked, nil
}

func NewNxmXxreg2Masked() *NxmXxreg2Masked {
	obj := &NxmXxreg2Masked{
		Oxm: NewOxm(123680),
	}
	return obj
}
func (self *NxmXxreg2Masked) GetOXMName() string {
	return "xxreg2_masked"
}

func (self *NxmXxreg2Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmXxreg2Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmXxreg2Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type NxmXxreg3 struct {
	*Oxm
	Value uint128
}

type INxmXxreg3 interface {
	goloxi.IOxm
	GetValue() uint128
}

func (self *NxmXxreg3) GetValue() uint128 {
	return self.Value
}

func (self *NxmXxreg3) SetValue(v uint128) {
	self.Value = v
}

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

	encoder.PutUint128(uint128(self.Value))

	return nil
}

func DecodeNxmXxreg3(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg3, error) {
	_nxmxxreg3 := &NxmXxreg3{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("NxmXxreg3 packet too short: %d < 16", decoder.Length())
	}
	_nxmxxreg3.Value = uint128(decoder.ReadUint128())
	return _nxmxxreg3, nil
}

func NewNxmXxreg3() *NxmXxreg3 {
	obj := &NxmXxreg3{
		Oxm: NewOxm(123920),
	}
	return obj
}
func (self *NxmXxreg3) GetOXMName() string {
	return "xxreg3"
}

func (self *NxmXxreg3) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmXxreg3) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type NxmXxreg3Masked struct {
	*Oxm
	Value     uint128
	ValueMask uint128
}

type INxmXxreg3Masked interface {
	goloxi.IOxm
	GetValue() uint128
	GetValueMask() uint128
}

func (self *NxmXxreg3Masked) GetValue() uint128 {
	return self.Value
}

func (self *NxmXxreg3Masked) SetValue(v uint128) {
	self.Value = v
}

func (self *NxmXxreg3Masked) GetValueMask() uint128 {
	return self.ValueMask
}

func (self *NxmXxreg3Masked) SetValueMask(v uint128) {
	self.ValueMask = v
}

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

	encoder.PutUint128(uint128(self.Value))
	encoder.PutUint128(uint128(self.ValueMask))

	return nil
}

func DecodeNxmXxreg3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg3Masked, error) {
	_nxmxxreg3masked := &NxmXxreg3Masked{Oxm: parent}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("NxmXxreg3Masked packet too short: %d < 32", decoder.Length())
	}
	_nxmxxreg3masked.Value = uint128(decoder.ReadUint128())
	_nxmxxreg3masked.ValueMask = uint128(decoder.ReadUint128())
	return _nxmxxreg3masked, nil
}

func NewNxmXxreg3Masked() *NxmXxreg3Masked {
	obj := &NxmXxreg3Masked{
		Oxm: NewOxm(124192),
	}
	return obj
}
func (self *NxmXxreg3Masked) GetOXMName() string {
	return "xxreg3_masked"
}

func (self *NxmXxreg3Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *NxmXxreg3Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *NxmXxreg3Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmArpOp struct {
	*Oxm
	Value uint16
}

type IOxmArpOp interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *OxmArpOp) GetValue() uint16 {
	return self.Value
}

func (self *OxmArpOp) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeOxmArpOp(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpOp, error) {
	_oxmarpop := &OxmArpOp{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmArpOp packet too short: %d < 2", decoder.Length())
	}
	_oxmarpop.Value = uint16(decoder.ReadUint16())
	return _oxmarpop, nil
}

func NewOxmArpOp() *OxmArpOp {
	obj := &OxmArpOp{
		Oxm: NewOxm(2147494402),
	}
	return obj
}
func (self *OxmArpOp) GetOXMName() string {
	return "arp_op"
}

func (self *OxmArpOp) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmArpOp) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmArpOpMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type IOxmArpOpMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *OxmArpOpMasked) GetValue() uint16 {
	return self.Value
}

func (self *OxmArpOpMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *OxmArpOpMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *OxmArpOpMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeOxmArpOpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpOpMasked, error) {
	_oxmarpopmasked := &OxmArpOpMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmArpOpMasked packet too short: %d < 4", decoder.Length())
	}
	_oxmarpopmasked.Value = uint16(decoder.ReadUint16())
	_oxmarpopmasked.ValueMask = uint16(decoder.ReadUint16())
	return _oxmarpopmasked, nil
}

func NewOxmArpOpMasked() *OxmArpOpMasked {
	obj := &OxmArpOpMasked{
		Oxm: NewOxm(2147494660),
	}
	return obj
}
func (self *OxmArpOpMasked) GetOXMName() string {
	return "arp_op_masked"
}

func (self *OxmArpOpMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmArpOpMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmArpOpMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmArpSha struct {
	*Oxm
	Value net.HardwareAddr
}

type IOxmArpSha interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
}

func (self *OxmArpSha) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *OxmArpSha) SetValue(v net.HardwareAddr) {
	self.Value = v
}

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

	encoder.Write(self.Value)

	return nil
}

func DecodeOxmArpSha(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSha, error) {
	_oxmarpsha := &OxmArpSha{Oxm: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("OxmArpSha packet too short: %d < 6", decoder.Length())
	}
	_oxmarpsha.Value = net.HardwareAddr(decoder.Read(6))
	return _oxmarpsha, nil
}

func NewOxmArpSha() *OxmArpSha {
	obj := &OxmArpSha{
		Oxm: NewOxm(2147495942),
	}
	return obj
}
func (self *OxmArpSha) GetOXMName() string {
	return "arp_sha"
}

func (self *OxmArpSha) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmArpSha) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmArpShaMasked struct {
	*Oxm
	Value     net.HardwareAddr
	ValueMask net.HardwareAddr
}

type IOxmArpShaMasked interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
	GetValueMask() net.HardwareAddr
}

func (self *OxmArpShaMasked) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *OxmArpShaMasked) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *OxmArpShaMasked) GetValueMask() net.HardwareAddr {
	return self.ValueMask
}

func (self *OxmArpShaMasked) SetValueMask(v net.HardwareAddr) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeOxmArpShaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpShaMasked, error) {
	_oxmarpshamasked := &OxmArpShaMasked{Oxm: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("OxmArpShaMasked packet too short: %d < 12", decoder.Length())
	}
	_oxmarpshamasked.Value = net.HardwareAddr(decoder.Read(6))
	_oxmarpshamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
	return _oxmarpshamasked, nil
}

func NewOxmArpShaMasked() *OxmArpShaMasked {
	obj := &OxmArpShaMasked{
		Oxm: NewOxm(2147496204),
	}
	return obj
}
func (self *OxmArpShaMasked) GetOXMName() string {
	return "arp_sha_masked"
}

func (self *OxmArpShaMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmArpShaMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmArpShaMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmArpSpa struct {
	*Oxm
	Value uint32
}

type IOxmArpSpa interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmArpSpa) GetValue() uint32 {
	return self.Value
}

func (self *OxmArpSpa) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmArpSpa(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSpa, error) {
	_oxmarpspa := &OxmArpSpa{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmArpSpa packet too short: %d < 4", decoder.Length())
	}
	_oxmarpspa.Value = uint32(decoder.ReadUint32())
	return _oxmarpspa, nil
}

func NewOxmArpSpa() *OxmArpSpa {
	obj := &OxmArpSpa{
		Oxm: NewOxm(2147494916),
	}
	return obj
}
func (self *OxmArpSpa) GetOXMName() string {
	return "arp_spa"
}

func (self *OxmArpSpa) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmArpSpa) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmArpSpaMasked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmArpSpaMasked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmArpSpaMasked) GetValue() uint32 {
	return self.Value
}

func (self *OxmArpSpaMasked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmArpSpaMasked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmArpSpaMasked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmArpSpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSpaMasked, error) {
	_oxmarpspamasked := &OxmArpSpaMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmArpSpaMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmarpspamasked.Value = uint32(decoder.ReadUint32())
	_oxmarpspamasked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmarpspamasked, nil
}

func NewOxmArpSpaMasked() *OxmArpSpaMasked {
	obj := &OxmArpSpaMasked{
		Oxm: NewOxm(2147495176),
	}
	return obj
}
func (self *OxmArpSpaMasked) GetOXMName() string {
	return "arp_spa_masked"
}

func (self *OxmArpSpaMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmArpSpaMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmArpSpaMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmArpTha struct {
	*Oxm
	Value net.HardwareAddr
}

type IOxmArpTha interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
}

func (self *OxmArpTha) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *OxmArpTha) SetValue(v net.HardwareAddr) {
	self.Value = v
}

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

	encoder.Write(self.Value)

	return nil
}

func DecodeOxmArpTha(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTha, error) {
	_oxmarptha := &OxmArpTha{Oxm: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("OxmArpTha packet too short: %d < 6", decoder.Length())
	}
	_oxmarptha.Value = net.HardwareAddr(decoder.Read(6))
	return _oxmarptha, nil
}

func NewOxmArpTha() *OxmArpTha {
	obj := &OxmArpTha{
		Oxm: NewOxm(2147496454),
	}
	return obj
}
func (self *OxmArpTha) GetOXMName() string {
	return "arp_tha"
}

func (self *OxmArpTha) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmArpTha) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmArpThaMasked struct {
	*Oxm
	Value     net.HardwareAddr
	ValueMask net.HardwareAddr
}

type IOxmArpThaMasked interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
	GetValueMask() net.HardwareAddr
}

func (self *OxmArpThaMasked) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *OxmArpThaMasked) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *OxmArpThaMasked) GetValueMask() net.HardwareAddr {
	return self.ValueMask
}

func (self *OxmArpThaMasked) SetValueMask(v net.HardwareAddr) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeOxmArpThaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpThaMasked, error) {
	_oxmarpthamasked := &OxmArpThaMasked{Oxm: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("OxmArpThaMasked packet too short: %d < 12", decoder.Length())
	}
	_oxmarpthamasked.Value = net.HardwareAddr(decoder.Read(6))
	_oxmarpthamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
	return _oxmarpthamasked, nil
}

func NewOxmArpThaMasked() *OxmArpThaMasked {
	obj := &OxmArpThaMasked{
		Oxm: NewOxm(2147496716),
	}
	return obj
}
func (self *OxmArpThaMasked) GetOXMName() string {
	return "arp_tha_masked"
}

func (self *OxmArpThaMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmArpThaMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmArpThaMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmArpTpa struct {
	*Oxm
	Value uint32
}

type IOxmArpTpa interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmArpTpa) GetValue() uint32 {
	return self.Value
}

func (self *OxmArpTpa) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmArpTpa(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTpa, error) {
	_oxmarptpa := &OxmArpTpa{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmArpTpa packet too short: %d < 4", decoder.Length())
	}
	_oxmarptpa.Value = uint32(decoder.ReadUint32())
	return _oxmarptpa, nil
}

func NewOxmArpTpa() *OxmArpTpa {
	obj := &OxmArpTpa{
		Oxm: NewOxm(2147495428),
	}
	return obj
}
func (self *OxmArpTpa) GetOXMName() string {
	return "arp_tpa"
}

func (self *OxmArpTpa) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmArpTpa) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmArpTpaMasked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmArpTpaMasked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmArpTpaMasked) GetValue() uint32 {
	return self.Value
}

func (self *OxmArpTpaMasked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmArpTpaMasked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmArpTpaMasked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmArpTpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTpaMasked, error) {
	_oxmarptpamasked := &OxmArpTpaMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmArpTpaMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmarptpamasked.Value = uint32(decoder.ReadUint32())
	_oxmarptpamasked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmarptpamasked, nil
}

func NewOxmArpTpaMasked() *OxmArpTpaMasked {
	obj := &OxmArpTpaMasked{
		Oxm: NewOxm(2147495688),
	}
	return obj
}
func (self *OxmArpTpaMasked) GetOXMName() string {
	return "arp_tpa_masked"
}

func (self *OxmArpTpaMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmArpTpaMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmArpTpaMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnEgrPortGroupId struct {
	*Oxm
	Value uint32
}

type IOxmBsnEgrPortGroupId interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmBsnEgrPortGroupId) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnEgrPortGroupId) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmBsnEgrPortGroupId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnEgrPortGroupId, error) {
	_oxmbsnegrportgroupid := &OxmBsnEgrPortGroupId{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmBsnEgrPortGroupId packet too short: %d < 4", decoder.Length())
	}
	_oxmbsnegrportgroupid.Value = uint32(decoder.ReadUint32())
	return _oxmbsnegrportgroupid, nil
}

func NewOxmBsnEgrPortGroupId() *OxmBsnEgrPortGroupId {
	obj := &OxmBsnEgrPortGroupId{
		Oxm: NewOxm(200196),
	}
	return obj
}
func (self *OxmBsnEgrPortGroupId) GetOXMName() string {
	return "bsn_egr_port_group_id"
}

func (self *OxmBsnEgrPortGroupId) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnEgrPortGroupId) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnEgrPortGroupIdMasked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmBsnEgrPortGroupIdMasked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmBsnEgrPortGroupIdMasked) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnEgrPortGroupIdMasked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmBsnEgrPortGroupIdMasked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmBsnEgrPortGroupIdMasked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmBsnEgrPortGroupIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnEgrPortGroupIdMasked, error) {
	_oxmbsnegrportgroupidmasked := &OxmBsnEgrPortGroupIdMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmBsnEgrPortGroupIdMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmbsnegrportgroupidmasked.Value = uint32(decoder.ReadUint32())
	_oxmbsnegrportgroupidmasked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmbsnegrportgroupidmasked, nil
}

func NewOxmBsnEgrPortGroupIdMasked() *OxmBsnEgrPortGroupIdMasked {
	obj := &OxmBsnEgrPortGroupIdMasked{
		Oxm: NewOxm(200456),
	}
	return obj
}
func (self *OxmBsnEgrPortGroupIdMasked) GetOXMName() string {
	return "bsn_egr_port_group_id_masked"
}

func (self *OxmBsnEgrPortGroupIdMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnEgrPortGroupIdMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnEgrPortGroupIdMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnGlobalVrfAllowed struct {
	*Oxm
	Value uint8
}

type IOxmBsnGlobalVrfAllowed interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *OxmBsnGlobalVrfAllowed) GetValue() uint8 {
	return self.Value
}

func (self *OxmBsnGlobalVrfAllowed) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeOxmBsnGlobalVrfAllowed(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnGlobalVrfAllowed, error) {
	_oxmbsnglobalvrfallowed := &OxmBsnGlobalVrfAllowed{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("OxmBsnGlobalVrfAllowed packet too short: %d < 1", decoder.Length())
	}
	_oxmbsnglobalvrfallowed.Value = uint8(decoder.ReadByte())
	return _oxmbsnglobalvrfallowed, nil
}

func NewOxmBsnGlobalVrfAllowed() *OxmBsnGlobalVrfAllowed {
	obj := &OxmBsnGlobalVrfAllowed{
		Oxm: NewOxm(198145),
	}
	return obj
}
func (self *OxmBsnGlobalVrfAllowed) GetOXMName() string {
	return "bsn_global_vrf_allowed"
}

func (self *OxmBsnGlobalVrfAllowed) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnGlobalVrfAllowed) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnGlobalVrfAllowedMasked struct {
	*Oxm
	Value     uint8
	ValueMask uint8
}

type IOxmBsnGlobalVrfAllowedMasked interface {
	goloxi.IOxm
	GetValue() uint8
	GetValueMask() uint8
}

func (self *OxmBsnGlobalVrfAllowedMasked) GetValue() uint8 {
	return self.Value
}

func (self *OxmBsnGlobalVrfAllowedMasked) SetValue(v uint8) {
	self.Value = v
}

func (self *OxmBsnGlobalVrfAllowedMasked) GetValueMask() uint8 {
	return self.ValueMask
}

func (self *OxmBsnGlobalVrfAllowedMasked) SetValueMask(v uint8) {
	self.ValueMask = v
}

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

	encoder.PutUint8(uint8(self.Value))
	encoder.PutUint8(uint8(self.ValueMask))

	return nil
}

func DecodeOxmBsnGlobalVrfAllowedMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnGlobalVrfAllowedMasked, error) {
	_oxmbsnglobalvrfallowedmasked := &OxmBsnGlobalVrfAllowedMasked{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmBsnGlobalVrfAllowedMasked packet too short: %d < 2", decoder.Length())
	}
	_oxmbsnglobalvrfallowedmasked.Value = uint8(decoder.ReadByte())
	_oxmbsnglobalvrfallowedmasked.ValueMask = uint8(decoder.ReadByte())
	return _oxmbsnglobalvrfallowedmasked, nil
}

func NewOxmBsnGlobalVrfAllowedMasked() *OxmBsnGlobalVrfAllowedMasked {
	obj := &OxmBsnGlobalVrfAllowedMasked{
		Oxm: NewOxm(198402),
	}
	return obj
}
func (self *OxmBsnGlobalVrfAllowedMasked) GetOXMName() string {
	return "bsn_global_vrf_allowed_masked"
}

func (self *OxmBsnGlobalVrfAllowedMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnGlobalVrfAllowedMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnGlobalVrfAllowedMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnInPorts128 struct {
	*Oxm
	Value Bitmap128
}

type IOxmBsnInPorts128 interface {
	goloxi.IOxm
	GetValue() Bitmap128
}

func (self *OxmBsnInPorts128) GetValue() Bitmap128 {
	return self.Value
}

func (self *OxmBsnInPorts128) SetValue(v Bitmap128) {
	self.Value = v
}

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

	self.Value.Serialize(encoder)

	return nil
}

func DecodeOxmBsnInPorts128(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInPorts128, error) {
	_oxmbsninports128 := &OxmBsnInPorts128{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("OxmBsnInPorts128 packet too short: %d < 16", decoder.Length())
	}
	_oxmbsninports128.Value.Decode(decoder)
	return _oxmbsninports128, nil
}

func NewOxmBsnInPorts128() *OxmBsnInPorts128 {
	obj := &OxmBsnInPorts128{
		Oxm: NewOxm(196624),
	}
	return obj
}
func (self *OxmBsnInPorts128) GetOXMName() string {
	return "bsn_in_ports_128"
}

func (self *OxmBsnInPorts128) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnInPorts128) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnInPorts128Masked struct {
	*Oxm
	Value     Bitmap128
	ValueMask Bitmap128
}

type IOxmBsnInPorts128Masked interface {
	goloxi.IOxm
	GetValue() Bitmap128
	GetValueMask() Bitmap128
}

func (self *OxmBsnInPorts128Masked) GetValue() Bitmap128 {
	return self.Value
}

func (self *OxmBsnInPorts128Masked) SetValue(v Bitmap128) {
	self.Value = v
}

func (self *OxmBsnInPorts128Masked) GetValueMask() Bitmap128 {
	return self.ValueMask
}

func (self *OxmBsnInPorts128Masked) SetValueMask(v Bitmap128) {
	self.ValueMask = v
}

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

	self.Value.Serialize(encoder)
	self.ValueMask.Serialize(encoder)

	return nil
}

func DecodeOxmBsnInPorts128Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInPorts128Masked, error) {
	_oxmbsninports128masked := &OxmBsnInPorts128Masked{Oxm: parent}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("OxmBsnInPorts128Masked packet too short: %d < 32", decoder.Length())
	}
	_oxmbsninports128masked.Value.Decode(decoder)
	_oxmbsninports128masked.ValueMask.Decode(decoder)
	return _oxmbsninports128masked, nil
}

func NewOxmBsnInPorts128Masked() *OxmBsnInPorts128Masked {
	obj := &OxmBsnInPorts128Masked{
		Oxm: NewOxm(196896),
	}
	return obj
}
func (self *OxmBsnInPorts128Masked) GetOXMName() string {
	return "bsn_in_ports_128_masked"
}

func (self *OxmBsnInPorts128Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnInPorts128Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnInPorts128Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnInPorts512 struct {
	*Oxm
	Value Bitmap512
}

type IOxmBsnInPorts512 interface {
	goloxi.IOxm
	GetValue() Bitmap512
}

func (self *OxmBsnInPorts512) GetValue() Bitmap512 {
	return self.Value
}

func (self *OxmBsnInPorts512) SetValue(v Bitmap512) {
	self.Value = v
}

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

	self.Value.Serialize(encoder)

	return nil
}

func DecodeOxmBsnInPorts512(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInPorts512, error) {
	_oxmbsninports512 := &OxmBsnInPorts512{Oxm: parent}
	if decoder.Length() < 64 {
		return nil, fmt.Errorf("OxmBsnInPorts512 packet too short: %d < 64", decoder.Length())
	}
	_oxmbsninports512.Value.Decode(decoder)
	return _oxmbsninports512, nil
}

func NewOxmBsnInPorts512() *OxmBsnInPorts512 {
	obj := &OxmBsnInPorts512{
		Oxm: NewOxm(206400),
	}
	return obj
}
func (self *OxmBsnInPorts512) GetOXMName() string {
	return "bsn_in_ports_512"
}

func (self *OxmBsnInPorts512) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnInPorts512) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnInPorts512Masked struct {
	*Oxm
	Value     Bitmap512
	ValueMask Bitmap512
}

type IOxmBsnInPorts512Masked interface {
	goloxi.IOxm
	GetValue() Bitmap512
	GetValueMask() Bitmap512
}

func (self *OxmBsnInPorts512Masked) GetValue() Bitmap512 {
	return self.Value
}

func (self *OxmBsnInPorts512Masked) SetValue(v Bitmap512) {
	self.Value = v
}

func (self *OxmBsnInPorts512Masked) GetValueMask() Bitmap512 {
	return self.ValueMask
}

func (self *OxmBsnInPorts512Masked) SetValueMask(v Bitmap512) {
	self.ValueMask = v
}

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

	self.Value.Serialize(encoder)
	self.ValueMask.Serialize(encoder)

	return nil
}

func DecodeOxmBsnInPorts512Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInPorts512Masked, error) {
	_oxmbsninports512masked := &OxmBsnInPorts512Masked{Oxm: parent}
	if decoder.Length() < 128 {
		return nil, fmt.Errorf("OxmBsnInPorts512Masked packet too short: %d < 128", decoder.Length())
	}
	_oxmbsninports512masked.Value.Decode(decoder)
	_oxmbsninports512masked.ValueMask.Decode(decoder)
	return _oxmbsninports512masked, nil
}

func NewOxmBsnInPorts512Masked() *OxmBsnInPorts512Masked {
	obj := &OxmBsnInPorts512Masked{
		Oxm: NewOxm(206720),
	}
	return obj
}
func (self *OxmBsnInPorts512Masked) GetOXMName() string {
	return "bsn_in_ports_512_masked"
}

func (self *OxmBsnInPorts512Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnInPorts512Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnInPorts512Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnIngressPortGroupId struct {
	*Oxm
	Value uint32
}

type IOxmBsnIngressPortGroupId interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmBsnIngressPortGroupId) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnIngressPortGroupId) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmBsnIngressPortGroupId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIngressPortGroupId, error) {
	_oxmbsningressportgroupid := &OxmBsnIngressPortGroupId{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmBsnIngressPortGroupId packet too short: %d < 4", decoder.Length())
	}
	_oxmbsningressportgroupid.Value = uint32(decoder.ReadUint32())
	return _oxmbsningressportgroupid, nil
}

func NewOxmBsnIngressPortGroupId() *OxmBsnIngressPortGroupId {
	obj := &OxmBsnIngressPortGroupId{
		Oxm: NewOxm(206852),
	}
	return obj
}
func (self *OxmBsnIngressPortGroupId) GetOXMName() string {
	return "bsn_ingress_port_group_id"
}

func (self *OxmBsnIngressPortGroupId) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnIngressPortGroupId) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnIngressPortGroupIdMasked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmBsnIngressPortGroupIdMasked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmBsnIngressPortGroupIdMasked) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnIngressPortGroupIdMasked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmBsnIngressPortGroupIdMasked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmBsnIngressPortGroupIdMasked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmBsnIngressPortGroupIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIngressPortGroupIdMasked, error) {
	_oxmbsningressportgroupidmasked := &OxmBsnIngressPortGroupIdMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmBsnIngressPortGroupIdMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmbsningressportgroupidmasked.Value = uint32(decoder.ReadUint32())
	_oxmbsningressportgroupidmasked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmbsningressportgroupidmasked, nil
}

func NewOxmBsnIngressPortGroupIdMasked() *OxmBsnIngressPortGroupIdMasked {
	obj := &OxmBsnIngressPortGroupIdMasked{
		Oxm: NewOxm(207112),
	}
	return obj
}
func (self *OxmBsnIngressPortGroupIdMasked) GetOXMName() string {
	return "bsn_ingress_port_group_id_masked"
}

func (self *OxmBsnIngressPortGroupIdMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnIngressPortGroupIdMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnIngressPortGroupIdMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnIpFragmentation struct {
	*Oxm
	Value uint8
}

type IOxmBsnIpFragmentation interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *OxmBsnIpFragmentation) GetValue() uint8 {
	return self.Value
}

func (self *OxmBsnIpFragmentation) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeOxmBsnIpFragmentation(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIpFragmentation, error) {
	_oxmbsnipfragmentation := &OxmBsnIpFragmentation{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("OxmBsnIpFragmentation packet too short: %d < 1", decoder.Length())
	}
	_oxmbsnipfragmentation.Value = uint8(decoder.ReadByte())
	return _oxmbsnipfragmentation, nil
}

func NewOxmBsnIpFragmentation() *OxmBsnIpFragmentation {
	obj := &OxmBsnIpFragmentation{
		Oxm: NewOxm(209921),
	}
	return obj
}
func (self *OxmBsnIpFragmentation) GetOXMName() string {
	return "bsn_ip_fragmentation"
}

func (self *OxmBsnIpFragmentation) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnIpFragmentation) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnIpFragmentationMasked struct {
	*Oxm
	Value     uint8
	ValueMask uint8
}

type IOxmBsnIpFragmentationMasked interface {
	goloxi.IOxm
	GetValue() uint8
	GetValueMask() uint8
}

func (self *OxmBsnIpFragmentationMasked) GetValue() uint8 {
	return self.Value
}

func (self *OxmBsnIpFragmentationMasked) SetValue(v uint8) {
	self.Value = v
}

func (self *OxmBsnIpFragmentationMasked) GetValueMask() uint8 {
	return self.ValueMask
}

func (self *OxmBsnIpFragmentationMasked) SetValueMask(v uint8) {
	self.ValueMask = v
}

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

	encoder.PutUint8(uint8(self.Value))
	encoder.PutUint8(uint8(self.ValueMask))

	return nil
}

func DecodeOxmBsnIpFragmentationMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIpFragmentationMasked, error) {
	_oxmbsnipfragmentationmasked := &OxmBsnIpFragmentationMasked{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmBsnIpFragmentationMasked packet too short: %d < 2", decoder.Length())
	}
	_oxmbsnipfragmentationmasked.Value = uint8(decoder.ReadByte())
	_oxmbsnipfragmentationmasked.ValueMask = uint8(decoder.ReadByte())
	return _oxmbsnipfragmentationmasked, nil
}

func NewOxmBsnIpFragmentationMasked() *OxmBsnIpFragmentationMasked {
	obj := &OxmBsnIpFragmentationMasked{
		Oxm: NewOxm(210178),
	}
	return obj
}
func (self *OxmBsnIpFragmentationMasked) GetOXMName() string {
	return "bsn_ip_fragmentation_masked"
}

func (self *OxmBsnIpFragmentationMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnIpFragmentationMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnIpFragmentationMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnL2CacheHit struct {
	*Oxm
	Value uint8
}

type IOxmBsnL2CacheHit interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *OxmBsnL2CacheHit) GetValue() uint8 {
	return self.Value
}

func (self *OxmBsnL2CacheHit) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeOxmBsnL2CacheHit(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL2CacheHit, error) {
	_oxmbsnl2cachehit := &OxmBsnL2CacheHit{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("OxmBsnL2CacheHit packet too short: %d < 1", decoder.Length())
	}
	_oxmbsnl2cachehit.Value = uint8(decoder.ReadByte())
	return _oxmbsnl2cachehit, nil
}

func NewOxmBsnL2CacheHit() *OxmBsnL2CacheHit {
	obj := &OxmBsnL2CacheHit{
		Oxm: NewOxm(205825),
	}
	return obj
}
func (self *OxmBsnL2CacheHit) GetOXMName() string {
	return "bsn_l2_cache_hit"
}

func (self *OxmBsnL2CacheHit) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnL2CacheHit) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnL2CacheHitMasked struct {
	*Oxm
	Value     uint8
	ValueMask uint8
}

type IOxmBsnL2CacheHitMasked interface {
	goloxi.IOxm
	GetValue() uint8
	GetValueMask() uint8
}

func (self *OxmBsnL2CacheHitMasked) GetValue() uint8 {
	return self.Value
}

func (self *OxmBsnL2CacheHitMasked) SetValue(v uint8) {
	self.Value = v
}

func (self *OxmBsnL2CacheHitMasked) GetValueMask() uint8 {
	return self.ValueMask
}

func (self *OxmBsnL2CacheHitMasked) SetValueMask(v uint8) {
	self.ValueMask = v
}

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

	encoder.PutUint8(uint8(self.Value))
	encoder.PutUint8(uint8(self.ValueMask))

	return nil
}

func DecodeOxmBsnL2CacheHitMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL2CacheHitMasked, error) {
	_oxmbsnl2cachehitmasked := &OxmBsnL2CacheHitMasked{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmBsnL2CacheHitMasked packet too short: %d < 2", decoder.Length())
	}
	_oxmbsnl2cachehitmasked.Value = uint8(decoder.ReadByte())
	_oxmbsnl2cachehitmasked.ValueMask = uint8(decoder.ReadByte())
	return _oxmbsnl2cachehitmasked, nil
}

func NewOxmBsnL2CacheHitMasked() *OxmBsnL2CacheHitMasked {
	obj := &OxmBsnL2CacheHitMasked{
		Oxm: NewOxm(206082),
	}
	return obj
}
func (self *OxmBsnL2CacheHitMasked) GetOXMName() string {
	return "bsn_l2_cache_hit_masked"
}

func (self *OxmBsnL2CacheHitMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnL2CacheHitMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnL2CacheHitMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnL3DstClassId struct {
	*Oxm
	Value uint32
}

type IOxmBsnL3DstClassId interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmBsnL3DstClassId) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnL3DstClassId) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmBsnL3DstClassId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3DstClassId, error) {
	_oxmbsnl3dstclassid := &OxmBsnL3DstClassId{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmBsnL3DstClassId packet too short: %d < 4", decoder.Length())
	}
	_oxmbsnl3dstclassid.Value = uint32(decoder.ReadUint32())
	return _oxmbsnl3dstclassid, nil
}

func NewOxmBsnL3DstClassId() *OxmBsnL3DstClassId {
	obj := &OxmBsnL3DstClassId{
		Oxm: NewOxm(199684),
	}
	return obj
}
func (self *OxmBsnL3DstClassId) GetOXMName() string {
	return "bsn_l3_dst_class_id"
}

func (self *OxmBsnL3DstClassId) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnL3DstClassId) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnL3DstClassIdMasked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmBsnL3DstClassIdMasked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmBsnL3DstClassIdMasked) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnL3DstClassIdMasked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmBsnL3DstClassIdMasked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmBsnL3DstClassIdMasked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmBsnL3DstClassIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3DstClassIdMasked, error) {
	_oxmbsnl3dstclassidmasked := &OxmBsnL3DstClassIdMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmBsnL3DstClassIdMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmbsnl3dstclassidmasked.Value = uint32(decoder.ReadUint32())
	_oxmbsnl3dstclassidmasked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmbsnl3dstclassidmasked, nil
}

func NewOxmBsnL3DstClassIdMasked() *OxmBsnL3DstClassIdMasked {
	obj := &OxmBsnL3DstClassIdMasked{
		Oxm: NewOxm(199944),
	}
	return obj
}
func (self *OxmBsnL3DstClassIdMasked) GetOXMName() string {
	return "bsn_l3_dst_class_id_masked"
}

func (self *OxmBsnL3DstClassIdMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnL3DstClassIdMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnL3DstClassIdMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnL3InterfaceClassId struct {
	*Oxm
	Value uint32
}

type IOxmBsnL3InterfaceClassId interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmBsnL3InterfaceClassId) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnL3InterfaceClassId) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmBsnL3InterfaceClassId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3InterfaceClassId, error) {
	_oxmbsnl3interfaceclassid := &OxmBsnL3InterfaceClassId{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmBsnL3InterfaceClassId packet too short: %d < 4", decoder.Length())
	}
	_oxmbsnl3interfaceclassid.Value = uint32(decoder.ReadUint32())
	return _oxmbsnl3interfaceclassid, nil
}

func NewOxmBsnL3InterfaceClassId() *OxmBsnL3InterfaceClassId {
	obj := &OxmBsnL3InterfaceClassId{
		Oxm: NewOxm(198660),
	}
	return obj
}
func (self *OxmBsnL3InterfaceClassId) GetOXMName() string {
	return "bsn_l3_interface_class_id"
}

func (self *OxmBsnL3InterfaceClassId) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnL3InterfaceClassId) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnL3InterfaceClassIdMasked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmBsnL3InterfaceClassIdMasked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmBsnL3InterfaceClassIdMasked) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnL3InterfaceClassIdMasked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmBsnL3InterfaceClassIdMasked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmBsnL3InterfaceClassIdMasked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmBsnL3InterfaceClassIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3InterfaceClassIdMasked, error) {
	_oxmbsnl3interfaceclassidmasked := &OxmBsnL3InterfaceClassIdMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmBsnL3InterfaceClassIdMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmbsnl3interfaceclassidmasked.Value = uint32(decoder.ReadUint32())
	_oxmbsnl3interfaceclassidmasked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmbsnl3interfaceclassidmasked, nil
}

func NewOxmBsnL3InterfaceClassIdMasked() *OxmBsnL3InterfaceClassIdMasked {
	obj := &OxmBsnL3InterfaceClassIdMasked{
		Oxm: NewOxm(198920),
	}
	return obj
}
func (self *OxmBsnL3InterfaceClassIdMasked) GetOXMName() string {
	return "bsn_l3_interface_class_id_masked"
}

func (self *OxmBsnL3InterfaceClassIdMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnL3InterfaceClassIdMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnL3InterfaceClassIdMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnL3SrcClassId struct {
	*Oxm
	Value uint32
}

type IOxmBsnL3SrcClassId interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmBsnL3SrcClassId) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnL3SrcClassId) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmBsnL3SrcClassId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3SrcClassId, error) {
	_oxmbsnl3srcclassid := &OxmBsnL3SrcClassId{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmBsnL3SrcClassId packet too short: %d < 4", decoder.Length())
	}
	_oxmbsnl3srcclassid.Value = uint32(decoder.ReadUint32())
	return _oxmbsnl3srcclassid, nil
}

func NewOxmBsnL3SrcClassId() *OxmBsnL3SrcClassId {
	obj := &OxmBsnL3SrcClassId{
		Oxm: NewOxm(199172),
	}
	return obj
}
func (self *OxmBsnL3SrcClassId) GetOXMName() string {
	return "bsn_l3_src_class_id"
}

func (self *OxmBsnL3SrcClassId) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnL3SrcClassId) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnL3SrcClassIdMasked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmBsnL3SrcClassIdMasked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmBsnL3SrcClassIdMasked) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnL3SrcClassIdMasked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmBsnL3SrcClassIdMasked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmBsnL3SrcClassIdMasked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmBsnL3SrcClassIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3SrcClassIdMasked, error) {
	_oxmbsnl3srcclassidmasked := &OxmBsnL3SrcClassIdMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmBsnL3SrcClassIdMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmbsnl3srcclassidmasked.Value = uint32(decoder.ReadUint32())
	_oxmbsnl3srcclassidmasked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmbsnl3srcclassidmasked, nil
}

func NewOxmBsnL3SrcClassIdMasked() *OxmBsnL3SrcClassIdMasked {
	obj := &OxmBsnL3SrcClassIdMasked{
		Oxm: NewOxm(199432),
	}
	return obj
}
func (self *OxmBsnL3SrcClassIdMasked) GetOXMName() string {
	return "bsn_l3_src_class_id_masked"
}

func (self *OxmBsnL3SrcClassIdMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnL3SrcClassIdMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnL3SrcClassIdMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnLagId struct {
	*Oxm
	Value uint32
}

type IOxmBsnLagId interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmBsnLagId) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnLagId) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmBsnLagId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnLagId, error) {
	_oxmbsnlagid := &OxmBsnLagId{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmBsnLagId packet too short: %d < 4", decoder.Length())
	}
	_oxmbsnlagid.Value = uint32(decoder.ReadUint32())
	return _oxmbsnlagid, nil
}

func NewOxmBsnLagId() *OxmBsnLagId {
	obj := &OxmBsnLagId{
		Oxm: NewOxm(197124),
	}
	return obj
}
func (self *OxmBsnLagId) GetOXMName() string {
	return "bsn_lag_id"
}

func (self *OxmBsnLagId) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnLagId) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnLagIdMasked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmBsnLagIdMasked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmBsnLagIdMasked) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnLagIdMasked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmBsnLagIdMasked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmBsnLagIdMasked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmBsnLagIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnLagIdMasked, error) {
	_oxmbsnlagidmasked := &OxmBsnLagIdMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmBsnLagIdMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmbsnlagidmasked.Value = uint32(decoder.ReadUint32())
	_oxmbsnlagidmasked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmbsnlagidmasked, nil
}

func NewOxmBsnLagIdMasked() *OxmBsnLagIdMasked {
	obj := &OxmBsnLagIdMasked{
		Oxm: NewOxm(197384),
	}
	return obj
}
func (self *OxmBsnLagIdMasked) GetOXMName() string {
	return "bsn_lag_id_masked"
}

func (self *OxmBsnLagIdMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnLagIdMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnLagIdMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnTcpFlags struct {
	*Oxm
	Value uint16
}

type IOxmBsnTcpFlags interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *OxmBsnTcpFlags) GetValue() uint16 {
	return self.Value
}

func (self *OxmBsnTcpFlags) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeOxmBsnTcpFlags(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnTcpFlags, error) {
	_oxmbsntcpflags := &OxmBsnTcpFlags{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmBsnTcpFlags packet too short: %d < 2", decoder.Length())
	}
	_oxmbsntcpflags.Value = uint16(decoder.ReadUint16())
	return _oxmbsntcpflags, nil
}

func NewOxmBsnTcpFlags() *OxmBsnTcpFlags {
	obj := &OxmBsnTcpFlags{
		Oxm: NewOxm(204802),
	}
	return obj
}
func (self *OxmBsnTcpFlags) GetOXMName() string {
	return "bsn_tcp_flags"
}

func (self *OxmBsnTcpFlags) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnTcpFlags) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnTcpFlagsMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type IOxmBsnTcpFlagsMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *OxmBsnTcpFlagsMasked) GetValue() uint16 {
	return self.Value
}

func (self *OxmBsnTcpFlagsMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *OxmBsnTcpFlagsMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *OxmBsnTcpFlagsMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeOxmBsnTcpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnTcpFlagsMasked, error) {
	_oxmbsntcpflagsmasked := &OxmBsnTcpFlagsMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmBsnTcpFlagsMasked packet too short: %d < 4", decoder.Length())
	}
	_oxmbsntcpflagsmasked.Value = uint16(decoder.ReadUint16())
	_oxmbsntcpflagsmasked.ValueMask = uint16(decoder.ReadUint16())
	return _oxmbsntcpflagsmasked, nil
}

func NewOxmBsnTcpFlagsMasked() *OxmBsnTcpFlagsMasked {
	obj := &OxmBsnTcpFlagsMasked{
		Oxm: NewOxm(205060),
	}
	return obj
}
func (self *OxmBsnTcpFlagsMasked) GetOXMName() string {
	return "bsn_tcp_flags_masked"
}

func (self *OxmBsnTcpFlagsMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnTcpFlagsMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnTcpFlagsMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnUdf0 struct {
	*Oxm
	Value uint32
}

type IOxmBsnUdf0 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmBsnUdf0) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnUdf0) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmBsnUdf0(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf0, error) {
	_oxmbsnudf0 := &OxmBsnUdf0{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmBsnUdf0 packet too short: %d < 4", decoder.Length())
	}
	_oxmbsnudf0.Value = uint32(decoder.ReadUint32())
	return _oxmbsnudf0, nil
}

func NewOxmBsnUdf0() *OxmBsnUdf0 {
	obj := &OxmBsnUdf0{
		Oxm: NewOxm(200708),
	}
	return obj
}
func (self *OxmBsnUdf0) GetOXMName() string {
	return "bsn_udf0"
}

func (self *OxmBsnUdf0) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnUdf0) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnUdf0Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmBsnUdf0Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmBsnUdf0Masked) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnUdf0Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmBsnUdf0Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmBsnUdf0Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmBsnUdf0Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf0Masked, error) {
	_oxmbsnudf0masked := &OxmBsnUdf0Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmBsnUdf0Masked packet too short: %d < 8", decoder.Length())
	}
	_oxmbsnudf0masked.Value = uint32(decoder.ReadUint32())
	_oxmbsnudf0masked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmbsnudf0masked, nil
}

func NewOxmBsnUdf0Masked() *OxmBsnUdf0Masked {
	obj := &OxmBsnUdf0Masked{
		Oxm: NewOxm(200968),
	}
	return obj
}
func (self *OxmBsnUdf0Masked) GetOXMName() string {
	return "bsn_udf0_masked"
}

func (self *OxmBsnUdf0Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnUdf0Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnUdf0Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnUdf1 struct {
	*Oxm
	Value uint32
}

type IOxmBsnUdf1 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmBsnUdf1) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnUdf1) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmBsnUdf1(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf1, error) {
	_oxmbsnudf1 := &OxmBsnUdf1{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmBsnUdf1 packet too short: %d < 4", decoder.Length())
	}
	_oxmbsnudf1.Value = uint32(decoder.ReadUint32())
	return _oxmbsnudf1, nil
}

func NewOxmBsnUdf1() *OxmBsnUdf1 {
	obj := &OxmBsnUdf1{
		Oxm: NewOxm(201220),
	}
	return obj
}
func (self *OxmBsnUdf1) GetOXMName() string {
	return "bsn_udf1"
}

func (self *OxmBsnUdf1) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnUdf1) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnUdf1Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmBsnUdf1Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmBsnUdf1Masked) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnUdf1Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmBsnUdf1Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmBsnUdf1Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmBsnUdf1Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf1Masked, error) {
	_oxmbsnudf1masked := &OxmBsnUdf1Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmBsnUdf1Masked packet too short: %d < 8", decoder.Length())
	}
	_oxmbsnudf1masked.Value = uint32(decoder.ReadUint32())
	_oxmbsnudf1masked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmbsnudf1masked, nil
}

func NewOxmBsnUdf1Masked() *OxmBsnUdf1Masked {
	obj := &OxmBsnUdf1Masked{
		Oxm: NewOxm(201480),
	}
	return obj
}
func (self *OxmBsnUdf1Masked) GetOXMName() string {
	return "bsn_udf1_masked"
}

func (self *OxmBsnUdf1Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnUdf1Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnUdf1Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnUdf2 struct {
	*Oxm
	Value uint32
}

type IOxmBsnUdf2 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmBsnUdf2) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnUdf2) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmBsnUdf2(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf2, error) {
	_oxmbsnudf2 := &OxmBsnUdf2{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmBsnUdf2 packet too short: %d < 4", decoder.Length())
	}
	_oxmbsnudf2.Value = uint32(decoder.ReadUint32())
	return _oxmbsnudf2, nil
}

func NewOxmBsnUdf2() *OxmBsnUdf2 {
	obj := &OxmBsnUdf2{
		Oxm: NewOxm(201732),
	}
	return obj
}
func (self *OxmBsnUdf2) GetOXMName() string {
	return "bsn_udf2"
}

func (self *OxmBsnUdf2) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnUdf2) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnUdf2Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmBsnUdf2Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmBsnUdf2Masked) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnUdf2Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmBsnUdf2Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmBsnUdf2Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmBsnUdf2Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf2Masked, error) {
	_oxmbsnudf2masked := &OxmBsnUdf2Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmBsnUdf2Masked packet too short: %d < 8", decoder.Length())
	}
	_oxmbsnudf2masked.Value = uint32(decoder.ReadUint32())
	_oxmbsnudf2masked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmbsnudf2masked, nil
}

func NewOxmBsnUdf2Masked() *OxmBsnUdf2Masked {
	obj := &OxmBsnUdf2Masked{
		Oxm: NewOxm(201992),
	}
	return obj
}
func (self *OxmBsnUdf2Masked) GetOXMName() string {
	return "bsn_udf2_masked"
}

func (self *OxmBsnUdf2Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnUdf2Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnUdf2Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnUdf3 struct {
	*Oxm
	Value uint32
}

type IOxmBsnUdf3 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmBsnUdf3) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnUdf3) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmBsnUdf3(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf3, error) {
	_oxmbsnudf3 := &OxmBsnUdf3{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmBsnUdf3 packet too short: %d < 4", decoder.Length())
	}
	_oxmbsnudf3.Value = uint32(decoder.ReadUint32())
	return _oxmbsnudf3, nil
}

func NewOxmBsnUdf3() *OxmBsnUdf3 {
	obj := &OxmBsnUdf3{
		Oxm: NewOxm(202244),
	}
	return obj
}
func (self *OxmBsnUdf3) GetOXMName() string {
	return "bsn_udf3"
}

func (self *OxmBsnUdf3) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnUdf3) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnUdf3Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmBsnUdf3Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmBsnUdf3Masked) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnUdf3Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmBsnUdf3Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmBsnUdf3Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmBsnUdf3Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf3Masked, error) {
	_oxmbsnudf3masked := &OxmBsnUdf3Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmBsnUdf3Masked packet too short: %d < 8", decoder.Length())
	}
	_oxmbsnudf3masked.Value = uint32(decoder.ReadUint32())
	_oxmbsnudf3masked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmbsnudf3masked, nil
}

func NewOxmBsnUdf3Masked() *OxmBsnUdf3Masked {
	obj := &OxmBsnUdf3Masked{
		Oxm: NewOxm(202504),
	}
	return obj
}
func (self *OxmBsnUdf3Masked) GetOXMName() string {
	return "bsn_udf3_masked"
}

func (self *OxmBsnUdf3Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnUdf3Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnUdf3Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnUdf4 struct {
	*Oxm
	Value uint32
}

type IOxmBsnUdf4 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmBsnUdf4) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnUdf4) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmBsnUdf4(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf4, error) {
	_oxmbsnudf4 := &OxmBsnUdf4{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmBsnUdf4 packet too short: %d < 4", decoder.Length())
	}
	_oxmbsnudf4.Value = uint32(decoder.ReadUint32())
	return _oxmbsnudf4, nil
}

func NewOxmBsnUdf4() *OxmBsnUdf4 {
	obj := &OxmBsnUdf4{
		Oxm: NewOxm(202756),
	}
	return obj
}
func (self *OxmBsnUdf4) GetOXMName() string {
	return "bsn_udf4"
}

func (self *OxmBsnUdf4) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnUdf4) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnUdf4Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmBsnUdf4Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmBsnUdf4Masked) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnUdf4Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmBsnUdf4Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmBsnUdf4Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmBsnUdf4Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf4Masked, error) {
	_oxmbsnudf4masked := &OxmBsnUdf4Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmBsnUdf4Masked packet too short: %d < 8", decoder.Length())
	}
	_oxmbsnudf4masked.Value = uint32(decoder.ReadUint32())
	_oxmbsnudf4masked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmbsnudf4masked, nil
}

func NewOxmBsnUdf4Masked() *OxmBsnUdf4Masked {
	obj := &OxmBsnUdf4Masked{
		Oxm: NewOxm(203016),
	}
	return obj
}
func (self *OxmBsnUdf4Masked) GetOXMName() string {
	return "bsn_udf4_masked"
}

func (self *OxmBsnUdf4Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnUdf4Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnUdf4Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnUdf5 struct {
	*Oxm
	Value uint32
}

type IOxmBsnUdf5 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmBsnUdf5) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnUdf5) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmBsnUdf5(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf5, error) {
	_oxmbsnudf5 := &OxmBsnUdf5{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmBsnUdf5 packet too short: %d < 4", decoder.Length())
	}
	_oxmbsnudf5.Value = uint32(decoder.ReadUint32())
	return _oxmbsnudf5, nil
}

func NewOxmBsnUdf5() *OxmBsnUdf5 {
	obj := &OxmBsnUdf5{
		Oxm: NewOxm(203268),
	}
	return obj
}
func (self *OxmBsnUdf5) GetOXMName() string {
	return "bsn_udf5"
}

func (self *OxmBsnUdf5) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnUdf5) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnUdf5Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmBsnUdf5Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmBsnUdf5Masked) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnUdf5Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmBsnUdf5Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmBsnUdf5Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmBsnUdf5Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf5Masked, error) {
	_oxmbsnudf5masked := &OxmBsnUdf5Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmBsnUdf5Masked packet too short: %d < 8", decoder.Length())
	}
	_oxmbsnudf5masked.Value = uint32(decoder.ReadUint32())
	_oxmbsnudf5masked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmbsnudf5masked, nil
}

func NewOxmBsnUdf5Masked() *OxmBsnUdf5Masked {
	obj := &OxmBsnUdf5Masked{
		Oxm: NewOxm(203528),
	}
	return obj
}
func (self *OxmBsnUdf5Masked) GetOXMName() string {
	return "bsn_udf5_masked"
}

func (self *OxmBsnUdf5Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnUdf5Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnUdf5Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnUdf6 struct {
	*Oxm
	Value uint32
}

type IOxmBsnUdf6 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmBsnUdf6) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnUdf6) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmBsnUdf6(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf6, error) {
	_oxmbsnudf6 := &OxmBsnUdf6{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmBsnUdf6 packet too short: %d < 4", decoder.Length())
	}
	_oxmbsnudf6.Value = uint32(decoder.ReadUint32())
	return _oxmbsnudf6, nil
}

func NewOxmBsnUdf6() *OxmBsnUdf6 {
	obj := &OxmBsnUdf6{
		Oxm: NewOxm(203780),
	}
	return obj
}
func (self *OxmBsnUdf6) GetOXMName() string {
	return "bsn_udf6"
}

func (self *OxmBsnUdf6) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnUdf6) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnUdf6Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmBsnUdf6Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmBsnUdf6Masked) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnUdf6Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmBsnUdf6Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmBsnUdf6Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmBsnUdf6Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf6Masked, error) {
	_oxmbsnudf6masked := &OxmBsnUdf6Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmBsnUdf6Masked packet too short: %d < 8", decoder.Length())
	}
	_oxmbsnudf6masked.Value = uint32(decoder.ReadUint32())
	_oxmbsnudf6masked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmbsnudf6masked, nil
}

func NewOxmBsnUdf6Masked() *OxmBsnUdf6Masked {
	obj := &OxmBsnUdf6Masked{
		Oxm: NewOxm(204040),
	}
	return obj
}
func (self *OxmBsnUdf6Masked) GetOXMName() string {
	return "bsn_udf6_masked"
}

func (self *OxmBsnUdf6Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnUdf6Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnUdf6Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnUdf7 struct {
	*Oxm
	Value uint32
}

type IOxmBsnUdf7 interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmBsnUdf7) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnUdf7) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmBsnUdf7(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf7, error) {
	_oxmbsnudf7 := &OxmBsnUdf7{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmBsnUdf7 packet too short: %d < 4", decoder.Length())
	}
	_oxmbsnudf7.Value = uint32(decoder.ReadUint32())
	return _oxmbsnudf7, nil
}

func NewOxmBsnUdf7() *OxmBsnUdf7 {
	obj := &OxmBsnUdf7{
		Oxm: NewOxm(204292),
	}
	return obj
}
func (self *OxmBsnUdf7) GetOXMName() string {
	return "bsn_udf7"
}

func (self *OxmBsnUdf7) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnUdf7) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnUdf7Masked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmBsnUdf7Masked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmBsnUdf7Masked) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnUdf7Masked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmBsnUdf7Masked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmBsnUdf7Masked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmBsnUdf7Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf7Masked, error) {
	_oxmbsnudf7masked := &OxmBsnUdf7Masked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmBsnUdf7Masked packet too short: %d < 8", decoder.Length())
	}
	_oxmbsnudf7masked.Value = uint32(decoder.ReadUint32())
	_oxmbsnudf7masked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmbsnudf7masked, nil
}

func NewOxmBsnUdf7Masked() *OxmBsnUdf7Masked {
	obj := &OxmBsnUdf7Masked{
		Oxm: NewOxm(204552),
	}
	return obj
}
func (self *OxmBsnUdf7Masked) GetOXMName() string {
	return "bsn_udf7_masked"
}

func (self *OxmBsnUdf7Masked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnUdf7Masked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnUdf7Masked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnVlanXlatePortGroupId struct {
	*Oxm
	Value uint32
}

type IOxmBsnVlanXlatePortGroupId interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmBsnVlanXlatePortGroupId) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnVlanXlatePortGroupId) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmBsnVlanXlatePortGroupId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVlanXlatePortGroupId, error) {
	_oxmbsnvlanxlateportgroupid := &OxmBsnVlanXlatePortGroupId{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmBsnVlanXlatePortGroupId packet too short: %d < 4", decoder.Length())
	}
	_oxmbsnvlanxlateportgroupid.Value = uint32(decoder.ReadUint32())
	return _oxmbsnvlanxlateportgroupid, nil
}

func NewOxmBsnVlanXlatePortGroupId() *OxmBsnVlanXlatePortGroupId {
	obj := &OxmBsnVlanXlatePortGroupId{
		Oxm: NewOxm(205316),
	}
	return obj
}
func (self *OxmBsnVlanXlatePortGroupId) GetOXMName() string {
	return "bsn_vlan_xlate_port_group_id"
}

func (self *OxmBsnVlanXlatePortGroupId) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnVlanXlatePortGroupId) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnVlanXlatePortGroupIdMasked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmBsnVlanXlatePortGroupIdMasked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmBsnVlanXlatePortGroupIdMasked) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnVlanXlatePortGroupIdMasked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmBsnVlanXlatePortGroupIdMasked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmBsnVlanXlatePortGroupIdMasked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmBsnVlanXlatePortGroupIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVlanXlatePortGroupIdMasked, error) {
	_oxmbsnvlanxlateportgroupidmasked := &OxmBsnVlanXlatePortGroupIdMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmBsnVlanXlatePortGroupIdMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmbsnvlanxlateportgroupidmasked.Value = uint32(decoder.ReadUint32())
	_oxmbsnvlanxlateportgroupidmasked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmbsnvlanxlateportgroupidmasked, nil
}

func NewOxmBsnVlanXlatePortGroupIdMasked() *OxmBsnVlanXlatePortGroupIdMasked {
	obj := &OxmBsnVlanXlatePortGroupIdMasked{
		Oxm: NewOxm(205576),
	}
	return obj
}
func (self *OxmBsnVlanXlatePortGroupIdMasked) GetOXMName() string {
	return "bsn_vlan_xlate_port_group_id_masked"
}

func (self *OxmBsnVlanXlatePortGroupIdMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnVlanXlatePortGroupIdMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnVlanXlatePortGroupIdMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmBsnVrf struct {
	*Oxm
	Value uint32
}

type IOxmBsnVrf interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmBsnVrf) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnVrf) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmBsnVrf(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVrf, error) {
	_oxmbsnvrf := &OxmBsnVrf{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmBsnVrf packet too short: %d < 4", decoder.Length())
	}
	_oxmbsnvrf.Value = uint32(decoder.ReadUint32())
	return _oxmbsnvrf, nil
}

func NewOxmBsnVrf() *OxmBsnVrf {
	obj := &OxmBsnVrf{
		Oxm: NewOxm(197636),
	}
	return obj
}
func (self *OxmBsnVrf) GetOXMName() string {
	return "bsn_vrf"
}

func (self *OxmBsnVrf) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnVrf) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmBsnVrfMasked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmBsnVrfMasked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmBsnVrfMasked) GetValue() uint32 {
	return self.Value
}

func (self *OxmBsnVrfMasked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmBsnVrfMasked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmBsnVrfMasked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmBsnVrfMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVrfMasked, error) {
	_oxmbsnvrfmasked := &OxmBsnVrfMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmBsnVrfMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmbsnvrfmasked.Value = uint32(decoder.ReadUint32())
	_oxmbsnvrfmasked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmbsnvrfmasked, nil
}

func NewOxmBsnVrfMasked() *OxmBsnVrfMasked {
	obj := &OxmBsnVrfMasked{
		Oxm: NewOxm(197896),
	}
	return obj
}
func (self *OxmBsnVrfMasked) GetOXMName() string {
	return "bsn_vrf_masked"
}

func (self *OxmBsnVrfMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmBsnVrfMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmBsnVrfMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmConnTrackingIpv6Dst struct {
	*Oxm
	Value net.IP
}

type IOxmConnTrackingIpv6Dst interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *OxmConnTrackingIpv6Dst) GetValue() net.IP {
	return self.Value
}

func (self *OxmConnTrackingIpv6Dst) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To16())

	return nil
}

func DecodeOxmConnTrackingIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6Dst, error) {
	_oxmconntrackingipv6dst := &OxmConnTrackingIpv6Dst{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("OxmConnTrackingIpv6Dst packet too short: %d < 16", decoder.Length())
	}
	_oxmconntrackingipv6dst.Value = net.IP(decoder.Read(16))
	return _oxmconntrackingipv6dst, nil
}

func NewOxmConnTrackingIpv6Dst() *OxmConnTrackingIpv6Dst {
	obj := &OxmConnTrackingIpv6Dst{
		Oxm: NewOxm(128528),
	}
	return obj
}
func (self *OxmConnTrackingIpv6Dst) GetOXMName() string {
	return "conn_tracking_ipv6_dst"
}

func (self *OxmConnTrackingIpv6Dst) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingIpv6Dst) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmConnTrackingIpv6DstMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type IOxmConnTrackingIpv6DstMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *OxmConnTrackingIpv6DstMasked) GetValue() net.IP {
	return self.Value
}

func (self *OxmConnTrackingIpv6DstMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *OxmConnTrackingIpv6DstMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *OxmConnTrackingIpv6DstMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To16())
	encoder.Write(self.ValueMask.To16())

	return nil
}

func DecodeOxmConnTrackingIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6DstMasked, error) {
	_oxmconntrackingipv6dstmasked := &OxmConnTrackingIpv6DstMasked{Oxm: parent}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("OxmConnTrackingIpv6DstMasked packet too short: %d < 32", decoder.Length())
	}
	_oxmconntrackingipv6dstmasked.Value = net.IP(decoder.Read(16))
	_oxmconntrackingipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
	return _oxmconntrackingipv6dstmasked, nil
}

func NewOxmConnTrackingIpv6DstMasked() *OxmConnTrackingIpv6DstMasked {
	obj := &OxmConnTrackingIpv6DstMasked{
		Oxm: NewOxm(128800),
	}
	return obj
}
func (self *OxmConnTrackingIpv6DstMasked) GetOXMName() string {
	return "conn_tracking_ipv6_dst_masked"
}

func (self *OxmConnTrackingIpv6DstMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingIpv6DstMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmConnTrackingIpv6DstMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmConnTrackingIpv6Src struct {
	*Oxm
	Value net.IP
}

type IOxmConnTrackingIpv6Src interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *OxmConnTrackingIpv6Src) GetValue() net.IP {
	return self.Value
}

func (self *OxmConnTrackingIpv6Src) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To16())

	return nil
}

func DecodeOxmConnTrackingIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6Src, error) {
	_oxmconntrackingipv6src := &OxmConnTrackingIpv6Src{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("OxmConnTrackingIpv6Src packet too short: %d < 16", decoder.Length())
	}
	_oxmconntrackingipv6src.Value = net.IP(decoder.Read(16))
	return _oxmconntrackingipv6src, nil
}

func NewOxmConnTrackingIpv6Src() *OxmConnTrackingIpv6Src {
	obj := &OxmConnTrackingIpv6Src{
		Oxm: NewOxm(128016),
	}
	return obj
}
func (self *OxmConnTrackingIpv6Src) GetOXMName() string {
	return "conn_tracking_ipv6_src"
}

func (self *OxmConnTrackingIpv6Src) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingIpv6Src) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmConnTrackingIpv6SrcMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type IOxmConnTrackingIpv6SrcMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *OxmConnTrackingIpv6SrcMasked) GetValue() net.IP {
	return self.Value
}

func (self *OxmConnTrackingIpv6SrcMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *OxmConnTrackingIpv6SrcMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *OxmConnTrackingIpv6SrcMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To16())
	encoder.Write(self.ValueMask.To16())

	return nil
}

func DecodeOxmConnTrackingIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6SrcMasked, error) {
	_oxmconntrackingipv6srcmasked := &OxmConnTrackingIpv6SrcMasked{Oxm: parent}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("OxmConnTrackingIpv6SrcMasked packet too short: %d < 32", decoder.Length())
	}
	_oxmconntrackingipv6srcmasked.Value = net.IP(decoder.Read(16))
	_oxmconntrackingipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
	return _oxmconntrackingipv6srcmasked, nil
}

func NewOxmConnTrackingIpv6SrcMasked() *OxmConnTrackingIpv6SrcMasked {
	obj := &OxmConnTrackingIpv6SrcMasked{
		Oxm: NewOxm(128288),
	}
	return obj
}
func (self *OxmConnTrackingIpv6SrcMasked) GetOXMName() string {
	return "conn_tracking_ipv6_src_masked"
}

func (self *OxmConnTrackingIpv6SrcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingIpv6SrcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmConnTrackingIpv6SrcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmConnTrackingLabel struct {
	*Oxm
	Value uint128
}

type IOxmConnTrackingLabel interface {
	goloxi.IOxm
	GetValue() uint128
}

func (self *OxmConnTrackingLabel) GetValue() uint128 {
	return self.Value
}

func (self *OxmConnTrackingLabel) SetValue(v uint128) {
	self.Value = v
}

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

	encoder.PutUint128(uint128(self.Value))

	return nil
}

func DecodeOxmConnTrackingLabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingLabel, error) {
	_oxmconntrackinglabel := &OxmConnTrackingLabel{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("OxmConnTrackingLabel packet too short: %d < 16", decoder.Length())
	}
	_oxmconntrackinglabel.Value = uint128(decoder.ReadUint128())
	return _oxmconntrackinglabel, nil
}

func NewOxmConnTrackingLabel() *OxmConnTrackingLabel {
	obj := &OxmConnTrackingLabel{
		Oxm: NewOxm(120848),
	}
	return obj
}
func (self *OxmConnTrackingLabel) GetOXMName() string {
	return "conn_tracking_label"
}

func (self *OxmConnTrackingLabel) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingLabel) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmConnTrackingLabelMasked struct {
	*Oxm
	Value     uint128
	ValueMask uint128
}

type IOxmConnTrackingLabelMasked interface {
	goloxi.IOxm
	GetValue() uint128
	GetValueMask() uint128
}

func (self *OxmConnTrackingLabelMasked) GetValue() uint128 {
	return self.Value
}

func (self *OxmConnTrackingLabelMasked) SetValue(v uint128) {
	self.Value = v
}

func (self *OxmConnTrackingLabelMasked) GetValueMask() uint128 {
	return self.ValueMask
}

func (self *OxmConnTrackingLabelMasked) SetValueMask(v uint128) {
	self.ValueMask = v
}

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

	encoder.PutUint128(uint128(self.Value))
	encoder.PutUint128(uint128(self.ValueMask))

	return nil
}

func DecodeOxmConnTrackingLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingLabelMasked, error) {
	_oxmconntrackinglabelmasked := &OxmConnTrackingLabelMasked{Oxm: parent}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("OxmConnTrackingLabelMasked packet too short: %d < 32", decoder.Length())
	}
	_oxmconntrackinglabelmasked.Value = uint128(decoder.ReadUint128())
	_oxmconntrackinglabelmasked.ValueMask = uint128(decoder.ReadUint128())
	return _oxmconntrackinglabelmasked, nil
}

func NewOxmConnTrackingLabelMasked() *OxmConnTrackingLabelMasked {
	obj := &OxmConnTrackingLabelMasked{
		Oxm: NewOxm(121120),
	}
	return obj
}
func (self *OxmConnTrackingLabelMasked) GetOXMName() string {
	return "conn_tracking_label_masked"
}

func (self *OxmConnTrackingLabelMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingLabelMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmConnTrackingLabelMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmConnTrackingMark struct {
	*Oxm
	Value uint32
}

type IOxmConnTrackingMark interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmConnTrackingMark) GetValue() uint32 {
	return self.Value
}

func (self *OxmConnTrackingMark) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmConnTrackingMark(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingMark, error) {
	_oxmconntrackingmark := &OxmConnTrackingMark{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmConnTrackingMark packet too short: %d < 4", decoder.Length())
	}
	_oxmconntrackingmark.Value = uint32(decoder.ReadUint32())
	return _oxmconntrackingmark, nil
}

func NewOxmConnTrackingMark() *OxmConnTrackingMark {
	obj := &OxmConnTrackingMark{
		Oxm: NewOxm(120324),
	}
	return obj
}
func (self *OxmConnTrackingMark) GetOXMName() string {
	return "conn_tracking_mark"
}

func (self *OxmConnTrackingMark) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingMark) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmConnTrackingMarkMasked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmConnTrackingMarkMasked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmConnTrackingMarkMasked) GetValue() uint32 {
	return self.Value
}

func (self *OxmConnTrackingMarkMasked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmConnTrackingMarkMasked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmConnTrackingMarkMasked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmConnTrackingMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingMarkMasked, error) {
	_oxmconntrackingmarkmasked := &OxmConnTrackingMarkMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmConnTrackingMarkMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmconntrackingmarkmasked.Value = uint32(decoder.ReadUint32())
	_oxmconntrackingmarkmasked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmconntrackingmarkmasked, nil
}

func NewOxmConnTrackingMarkMasked() *OxmConnTrackingMarkMasked {
	obj := &OxmConnTrackingMarkMasked{
		Oxm: NewOxm(120584),
	}
	return obj
}
func (self *OxmConnTrackingMarkMasked) GetOXMName() string {
	return "conn_tracking_mark_masked"
}

func (self *OxmConnTrackingMarkMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingMarkMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmConnTrackingMarkMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmConnTrackingNwDst struct {
	*Oxm
	Value uint32
}

type IOxmConnTrackingNwDst interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmConnTrackingNwDst) GetValue() uint32 {
	return self.Value
}

func (self *OxmConnTrackingNwDst) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmConnTrackingNwDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwDst, error) {
	_oxmconntrackingnwdst := &OxmConnTrackingNwDst{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmConnTrackingNwDst packet too short: %d < 4", decoder.Length())
	}
	_oxmconntrackingnwdst.Value = uint32(decoder.ReadUint32())
	return _oxmconntrackingnwdst, nil
}

func NewOxmConnTrackingNwDst() *OxmConnTrackingNwDst {
	obj := &OxmConnTrackingNwDst{
		Oxm: NewOxm(127492),
	}
	return obj
}
func (self *OxmConnTrackingNwDst) GetOXMName() string {
	return "conn_tracking_nw_dst"
}

func (self *OxmConnTrackingNwDst) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingNwDst) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmConnTrackingNwDstMasked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmConnTrackingNwDstMasked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmConnTrackingNwDstMasked) GetValue() uint32 {
	return self.Value
}

func (self *OxmConnTrackingNwDstMasked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmConnTrackingNwDstMasked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmConnTrackingNwDstMasked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmConnTrackingNwDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwDstMasked, error) {
	_oxmconntrackingnwdstmasked := &OxmConnTrackingNwDstMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmConnTrackingNwDstMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmconntrackingnwdstmasked.Value = uint32(decoder.ReadUint32())
	_oxmconntrackingnwdstmasked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmconntrackingnwdstmasked, nil
}

func NewOxmConnTrackingNwDstMasked() *OxmConnTrackingNwDstMasked {
	obj := &OxmConnTrackingNwDstMasked{
		Oxm: NewOxm(127752),
	}
	return obj
}
func (self *OxmConnTrackingNwDstMasked) GetOXMName() string {
	return "conn_tracking_nw_dst_masked"
}

func (self *OxmConnTrackingNwDstMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingNwDstMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmConnTrackingNwDstMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmConnTrackingNwProto struct {
	*Oxm
	Value uint8
}

type IOxmConnTrackingNwProto interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *OxmConnTrackingNwProto) GetValue() uint8 {
	return self.Value
}

func (self *OxmConnTrackingNwProto) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeOxmConnTrackingNwProto(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwProto, error) {
	_oxmconntrackingnwproto := &OxmConnTrackingNwProto{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("OxmConnTrackingNwProto packet too short: %d < 1", decoder.Length())
	}
	_oxmconntrackingnwproto.Value = uint8(decoder.ReadByte())
	return _oxmconntrackingnwproto, nil
}

func NewOxmConnTrackingNwProto() *OxmConnTrackingNwProto {
	obj := &OxmConnTrackingNwProto{
		Oxm: NewOxm(126465),
	}
	return obj
}
func (self *OxmConnTrackingNwProto) GetOXMName() string {
	return "conn_tracking_nw_proto"
}

func (self *OxmConnTrackingNwProto) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingNwProto) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmConnTrackingNwProtoMasked struct {
	*Oxm
	Value     uint8
	ValueMask uint8
}

type IOxmConnTrackingNwProtoMasked interface {
	goloxi.IOxm
	GetValue() uint8
	GetValueMask() uint8
}

func (self *OxmConnTrackingNwProtoMasked) GetValue() uint8 {
	return self.Value
}

func (self *OxmConnTrackingNwProtoMasked) SetValue(v uint8) {
	self.Value = v
}

func (self *OxmConnTrackingNwProtoMasked) GetValueMask() uint8 {
	return self.ValueMask
}

func (self *OxmConnTrackingNwProtoMasked) SetValueMask(v uint8) {
	self.ValueMask = v
}

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

	encoder.PutUint8(uint8(self.Value))
	encoder.PutUint8(uint8(self.ValueMask))

	return nil
}

func DecodeOxmConnTrackingNwProtoMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwProtoMasked, error) {
	_oxmconntrackingnwprotomasked := &OxmConnTrackingNwProtoMasked{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmConnTrackingNwProtoMasked packet too short: %d < 2", decoder.Length())
	}
	_oxmconntrackingnwprotomasked.Value = uint8(decoder.ReadByte())
	_oxmconntrackingnwprotomasked.ValueMask = uint8(decoder.ReadByte())
	return _oxmconntrackingnwprotomasked, nil
}

func NewOxmConnTrackingNwProtoMasked() *OxmConnTrackingNwProtoMasked {
	obj := &OxmConnTrackingNwProtoMasked{
		Oxm: NewOxm(126722),
	}
	return obj
}
func (self *OxmConnTrackingNwProtoMasked) GetOXMName() string {
	return "conn_tracking_nw_proto_masked"
}

func (self *OxmConnTrackingNwProtoMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingNwProtoMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmConnTrackingNwProtoMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmConnTrackingNwSrc struct {
	*Oxm
	Value uint32
}

type IOxmConnTrackingNwSrc interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmConnTrackingNwSrc) GetValue() uint32 {
	return self.Value
}

func (self *OxmConnTrackingNwSrc) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmConnTrackingNwSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwSrc, error) {
	_oxmconntrackingnwsrc := &OxmConnTrackingNwSrc{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmConnTrackingNwSrc packet too short: %d < 4", decoder.Length())
	}
	_oxmconntrackingnwsrc.Value = uint32(decoder.ReadUint32())
	return _oxmconntrackingnwsrc, nil
}

func NewOxmConnTrackingNwSrc() *OxmConnTrackingNwSrc {
	obj := &OxmConnTrackingNwSrc{
		Oxm: NewOxm(126980),
	}
	return obj
}
func (self *OxmConnTrackingNwSrc) GetOXMName() string {
	return "conn_tracking_nw_src"
}

func (self *OxmConnTrackingNwSrc) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingNwSrc) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmConnTrackingNwSrcMasked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmConnTrackingNwSrcMasked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmConnTrackingNwSrcMasked) GetValue() uint32 {
	return self.Value
}

func (self *OxmConnTrackingNwSrcMasked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmConnTrackingNwSrcMasked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmConnTrackingNwSrcMasked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmConnTrackingNwSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwSrcMasked, error) {
	_oxmconntrackingnwsrcmasked := &OxmConnTrackingNwSrcMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmConnTrackingNwSrcMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmconntrackingnwsrcmasked.Value = uint32(decoder.ReadUint32())
	_oxmconntrackingnwsrcmasked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmconntrackingnwsrcmasked, nil
}

func NewOxmConnTrackingNwSrcMasked() *OxmConnTrackingNwSrcMasked {
	obj := &OxmConnTrackingNwSrcMasked{
		Oxm: NewOxm(127240),
	}
	return obj
}
func (self *OxmConnTrackingNwSrcMasked) GetOXMName() string {
	return "conn_tracking_nw_src_masked"
}

func (self *OxmConnTrackingNwSrcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingNwSrcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmConnTrackingNwSrcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmConnTrackingState struct {
	*Oxm
	Value CsStates
}

type IOxmConnTrackingState interface {
	goloxi.IOxm
	GetValue() CsStates
}

func (self *OxmConnTrackingState) GetValue() CsStates {
	return self.Value
}

func (self *OxmConnTrackingState) SetValue(v CsStates) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmConnTrackingState(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingState, error) {
	_oxmconntrackingstate := &OxmConnTrackingState{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmConnTrackingState packet too short: %d < 4", decoder.Length())
	}
	_oxmconntrackingstate.Value = CsStates(decoder.ReadUint32())
	return _oxmconntrackingstate, nil
}

func NewOxmConnTrackingState() *OxmConnTrackingState {
	obj := &OxmConnTrackingState{
		Oxm: NewOxm(119300),
	}
	return obj
}
func (self *OxmConnTrackingState) GetOXMName() string {
	return "conn_tracking_state"
}

func (self *OxmConnTrackingState) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingState) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmConnTrackingStateMasked struct {
	*Oxm
	Value     CsStates
	ValueMask CsStates
}

type IOxmConnTrackingStateMasked interface {
	goloxi.IOxm
	GetValue() CsStates
	GetValueMask() CsStates
}

func (self *OxmConnTrackingStateMasked) GetValue() CsStates {
	return self.Value
}

func (self *OxmConnTrackingStateMasked) SetValue(v CsStates) {
	self.Value = v
}

func (self *OxmConnTrackingStateMasked) GetValueMask() CsStates {
	return self.ValueMask
}

func (self *OxmConnTrackingStateMasked) SetValueMask(v CsStates) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmConnTrackingStateMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingStateMasked, error) {
	_oxmconntrackingstatemasked := &OxmConnTrackingStateMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmConnTrackingStateMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmconntrackingstatemasked.Value = CsStates(decoder.ReadUint32())
	_oxmconntrackingstatemasked.ValueMask = CsStates(decoder.ReadUint32())
	return _oxmconntrackingstatemasked, nil
}

func NewOxmConnTrackingStateMasked() *OxmConnTrackingStateMasked {
	obj := &OxmConnTrackingStateMasked{
		Oxm: NewOxm(119560),
	}
	return obj
}
func (self *OxmConnTrackingStateMasked) GetOXMName() string {
	return "conn_tracking_state_masked"
}

func (self *OxmConnTrackingStateMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingStateMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmConnTrackingStateMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmConnTrackingTpDst struct {
	*Oxm
	Value uint16
}

type IOxmConnTrackingTpDst interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *OxmConnTrackingTpDst) GetValue() uint16 {
	return self.Value
}

func (self *OxmConnTrackingTpDst) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeOxmConnTrackingTpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpDst, error) {
	_oxmconntrackingtpdst := &OxmConnTrackingTpDst{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmConnTrackingTpDst packet too short: %d < 2", decoder.Length())
	}
	_oxmconntrackingtpdst.Value = uint16(decoder.ReadUint16())
	return _oxmconntrackingtpdst, nil
}

func NewOxmConnTrackingTpDst() *OxmConnTrackingTpDst {
	obj := &OxmConnTrackingTpDst{
		Oxm: NewOxm(129538),
	}
	return obj
}
func (self *OxmConnTrackingTpDst) GetOXMName() string {
	return "conn_tracking_tp_dst"
}

func (self *OxmConnTrackingTpDst) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingTpDst) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmConnTrackingTpDstMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type IOxmConnTrackingTpDstMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *OxmConnTrackingTpDstMasked) GetValue() uint16 {
	return self.Value
}

func (self *OxmConnTrackingTpDstMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *OxmConnTrackingTpDstMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *OxmConnTrackingTpDstMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeOxmConnTrackingTpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpDstMasked, error) {
	_oxmconntrackingtpdstmasked := &OxmConnTrackingTpDstMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmConnTrackingTpDstMasked packet too short: %d < 4", decoder.Length())
	}
	_oxmconntrackingtpdstmasked.Value = uint16(decoder.ReadUint16())
	_oxmconntrackingtpdstmasked.ValueMask = uint16(decoder.ReadUint16())
	return _oxmconntrackingtpdstmasked, nil
}

func NewOxmConnTrackingTpDstMasked() *OxmConnTrackingTpDstMasked {
	obj := &OxmConnTrackingTpDstMasked{
		Oxm: NewOxm(129796),
	}
	return obj
}
func (self *OxmConnTrackingTpDstMasked) GetOXMName() string {
	return "conn_tracking_tp_dst_masked"
}

func (self *OxmConnTrackingTpDstMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingTpDstMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmConnTrackingTpDstMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmConnTrackingTpSrc struct {
	*Oxm
	Value uint16
}

type IOxmConnTrackingTpSrc interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *OxmConnTrackingTpSrc) GetValue() uint16 {
	return self.Value
}

func (self *OxmConnTrackingTpSrc) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeOxmConnTrackingTpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpSrc, error) {
	_oxmconntrackingtpsrc := &OxmConnTrackingTpSrc{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmConnTrackingTpSrc packet too short: %d < 2", decoder.Length())
	}
	_oxmconntrackingtpsrc.Value = uint16(decoder.ReadUint16())
	return _oxmconntrackingtpsrc, nil
}

func NewOxmConnTrackingTpSrc() *OxmConnTrackingTpSrc {
	obj := &OxmConnTrackingTpSrc{
		Oxm: NewOxm(129026),
	}
	return obj
}
func (self *OxmConnTrackingTpSrc) GetOXMName() string {
	return "conn_tracking_tp_src"
}

func (self *OxmConnTrackingTpSrc) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingTpSrc) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmConnTrackingTpSrcMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type IOxmConnTrackingTpSrcMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *OxmConnTrackingTpSrcMasked) GetValue() uint16 {
	return self.Value
}

func (self *OxmConnTrackingTpSrcMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *OxmConnTrackingTpSrcMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *OxmConnTrackingTpSrcMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeOxmConnTrackingTpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpSrcMasked, error) {
	_oxmconntrackingtpsrcmasked := &OxmConnTrackingTpSrcMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmConnTrackingTpSrcMasked packet too short: %d < 4", decoder.Length())
	}
	_oxmconntrackingtpsrcmasked.Value = uint16(decoder.ReadUint16())
	_oxmconntrackingtpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
	return _oxmconntrackingtpsrcmasked, nil
}

func NewOxmConnTrackingTpSrcMasked() *OxmConnTrackingTpSrcMasked {
	obj := &OxmConnTrackingTpSrcMasked{
		Oxm: NewOxm(129284),
	}
	return obj
}
func (self *OxmConnTrackingTpSrcMasked) GetOXMName() string {
	return "conn_tracking_tp_src_masked"
}

func (self *OxmConnTrackingTpSrcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingTpSrcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmConnTrackingTpSrcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmConnTrackingZone struct {
	*Oxm
	Value uint16
}

type IOxmConnTrackingZone interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *OxmConnTrackingZone) GetValue() uint16 {
	return self.Value
}

func (self *OxmConnTrackingZone) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeOxmConnTrackingZone(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingZone, error) {
	_oxmconntrackingzone := &OxmConnTrackingZone{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmConnTrackingZone packet too short: %d < 2", decoder.Length())
	}
	_oxmconntrackingzone.Value = uint16(decoder.ReadUint16())
	return _oxmconntrackingzone, nil
}

func NewOxmConnTrackingZone() *OxmConnTrackingZone {
	obj := &OxmConnTrackingZone{
		Oxm: NewOxm(119810),
	}
	return obj
}
func (self *OxmConnTrackingZone) GetOXMName() string {
	return "conn_tracking_zone"
}

func (self *OxmConnTrackingZone) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingZone) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmConnTrackingZoneMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type IOxmConnTrackingZoneMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *OxmConnTrackingZoneMasked) GetValue() uint16 {
	return self.Value
}

func (self *OxmConnTrackingZoneMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *OxmConnTrackingZoneMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *OxmConnTrackingZoneMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeOxmConnTrackingZoneMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingZoneMasked, error) {
	_oxmconntrackingzonemasked := &OxmConnTrackingZoneMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmConnTrackingZoneMasked packet too short: %d < 4", decoder.Length())
	}
	_oxmconntrackingzonemasked.Value = uint16(decoder.ReadUint16())
	_oxmconntrackingzonemasked.ValueMask = uint16(decoder.ReadUint16())
	return _oxmconntrackingzonemasked, nil
}

func NewOxmConnTrackingZoneMasked() *OxmConnTrackingZoneMasked {
	obj := &OxmConnTrackingZoneMasked{
		Oxm: NewOxm(120068),
	}
	return obj
}
func (self *OxmConnTrackingZoneMasked) GetOXMName() string {
	return "conn_tracking_zone_masked"
}

func (self *OxmConnTrackingZoneMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmConnTrackingZoneMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmConnTrackingZoneMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmEthDst struct {
	*Oxm
	Value net.HardwareAddr
}

type IOxmEthDst interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
}

func (self *OxmEthDst) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *OxmEthDst) SetValue(v net.HardwareAddr) {
	self.Value = v
}

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

	encoder.Write(self.Value)

	return nil
}

func DecodeOxmEthDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthDst, error) {
	_oxmethdst := &OxmEthDst{Oxm: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("OxmEthDst packet too short: %d < 6", decoder.Length())
	}
	_oxmethdst.Value = net.HardwareAddr(decoder.Read(6))
	return _oxmethdst, nil
}

func NewOxmEthDst() *OxmEthDst {
	obj := &OxmEthDst{
		Oxm: NewOxm(2147485190),
	}
	return obj
}
func (self *OxmEthDst) GetOXMName() string {
	return "eth_dst"
}

func (self *OxmEthDst) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmEthDst) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmEthDstMasked struct {
	*Oxm
	Value     net.HardwareAddr
	ValueMask net.HardwareAddr
}

type IOxmEthDstMasked interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
	GetValueMask() net.HardwareAddr
}

func (self *OxmEthDstMasked) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *OxmEthDstMasked) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *OxmEthDstMasked) GetValueMask() net.HardwareAddr {
	return self.ValueMask
}

func (self *OxmEthDstMasked) SetValueMask(v net.HardwareAddr) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeOxmEthDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthDstMasked, error) {
	_oxmethdstmasked := &OxmEthDstMasked{Oxm: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("OxmEthDstMasked packet too short: %d < 12", decoder.Length())
	}
	_oxmethdstmasked.Value = net.HardwareAddr(decoder.Read(6))
	_oxmethdstmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
	return _oxmethdstmasked, nil
}

func NewOxmEthDstMasked() *OxmEthDstMasked {
	obj := &OxmEthDstMasked{
		Oxm: NewOxm(2147485452),
	}
	return obj
}
func (self *OxmEthDstMasked) GetOXMName() string {
	return "eth_dst_masked"
}

func (self *OxmEthDstMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmEthDstMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmEthDstMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmEthSrc struct {
	*Oxm
	Value net.HardwareAddr
}

type IOxmEthSrc interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
}

func (self *OxmEthSrc) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *OxmEthSrc) SetValue(v net.HardwareAddr) {
	self.Value = v
}

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

	encoder.Write(self.Value)

	return nil
}

func DecodeOxmEthSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthSrc, error) {
	_oxmethsrc := &OxmEthSrc{Oxm: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("OxmEthSrc packet too short: %d < 6", decoder.Length())
	}
	_oxmethsrc.Value = net.HardwareAddr(decoder.Read(6))
	return _oxmethsrc, nil
}

func NewOxmEthSrc() *OxmEthSrc {
	obj := &OxmEthSrc{
		Oxm: NewOxm(2147485702),
	}
	return obj
}
func (self *OxmEthSrc) GetOXMName() string {
	return "eth_src"
}

func (self *OxmEthSrc) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmEthSrc) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmEthSrcMasked struct {
	*Oxm
	Value     net.HardwareAddr
	ValueMask net.HardwareAddr
}

type IOxmEthSrcMasked interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
	GetValueMask() net.HardwareAddr
}

func (self *OxmEthSrcMasked) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *OxmEthSrcMasked) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *OxmEthSrcMasked) GetValueMask() net.HardwareAddr {
	return self.ValueMask
}

func (self *OxmEthSrcMasked) SetValueMask(v net.HardwareAddr) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeOxmEthSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthSrcMasked, error) {
	_oxmethsrcmasked := &OxmEthSrcMasked{Oxm: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("OxmEthSrcMasked packet too short: %d < 12", decoder.Length())
	}
	_oxmethsrcmasked.Value = net.HardwareAddr(decoder.Read(6))
	_oxmethsrcmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
	return _oxmethsrcmasked, nil
}

func NewOxmEthSrcMasked() *OxmEthSrcMasked {
	obj := &OxmEthSrcMasked{
		Oxm: NewOxm(2147485964),
	}
	return obj
}
func (self *OxmEthSrcMasked) GetOXMName() string {
	return "eth_src_masked"
}

func (self *OxmEthSrcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmEthSrcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmEthSrcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmEthType struct {
	*Oxm
	Value EthernetType
}

type IOxmEthType interface {
	goloxi.IOxm
	GetValue() EthernetType
}

func (self *OxmEthType) GetValue() EthernetType {
	return self.Value
}

func (self *OxmEthType) SetValue(v EthernetType) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeOxmEthType(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthType, error) {
	_oxmethtype := &OxmEthType{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmEthType packet too short: %d < 2", decoder.Length())
	}
	_oxmethtype.Value = EthernetType(decoder.ReadUint16())
	return _oxmethtype, nil
}

func NewOxmEthType() *OxmEthType {
	obj := &OxmEthType{
		Oxm: NewOxm(2147486210),
	}
	return obj
}
func (self *OxmEthType) GetOXMName() string {
	return "eth_type"
}

func (self *OxmEthType) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmEthType) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmEthTypeMasked struct {
	*Oxm
	Value     EthernetType
	ValueMask uint16
}

type IOxmEthTypeMasked interface {
	goloxi.IOxm
	GetValue() EthernetType
	GetValueMask() uint16
}

func (self *OxmEthTypeMasked) GetValue() EthernetType {
	return self.Value
}

func (self *OxmEthTypeMasked) SetValue(v EthernetType) {
	self.Value = v
}

func (self *OxmEthTypeMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *OxmEthTypeMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeOxmEthTypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthTypeMasked, error) {
	_oxmethtypemasked := &OxmEthTypeMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmEthTypeMasked packet too short: %d < 4", decoder.Length())
	}
	_oxmethtypemasked.Value = EthernetType(decoder.ReadUint16())
	_oxmethtypemasked.ValueMask = uint16(decoder.ReadUint16())
	return _oxmethtypemasked, nil
}

func NewOxmEthTypeMasked() *OxmEthTypeMasked {
	obj := &OxmEthTypeMasked{
		Oxm: NewOxm(2147486468),
	}
	return obj
}
func (self *OxmEthTypeMasked) GetOXMName() string {
	return "eth_type_masked"
}

func (self *OxmEthTypeMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmEthTypeMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmEthTypeMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmIcmpv4Code struct {
	*Oxm
	Value uint8
}

type IOxmIcmpv4Code interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *OxmIcmpv4Code) GetValue() uint8 {
	return self.Value
}

func (self *OxmIcmpv4Code) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeOxmIcmpv4Code(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4Code, error) {
	_oxmicmpv4code := &OxmIcmpv4Code{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("OxmIcmpv4Code packet too short: %d < 1", decoder.Length())
	}
	_oxmicmpv4code.Value = uint8(decoder.ReadByte())
	return _oxmicmpv4code, nil
}

func NewOxmIcmpv4Code() *OxmIcmpv4Code {
	obj := &OxmIcmpv4Code{
		Oxm: NewOxm(2147493889),
	}
	return obj
}
func (self *OxmIcmpv4Code) GetOXMName() string {
	return "icmpv4_code"
}

func (self *OxmIcmpv4Code) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIcmpv4Code) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmIcmpv4CodeMasked struct {
	*Oxm
	Value     uint8
	ValueMask uint8
}

type IOxmIcmpv4CodeMasked interface {
	goloxi.IOxm
	GetValue() uint8
	GetValueMask() uint8
}

func (self *OxmIcmpv4CodeMasked) GetValue() uint8 {
	return self.Value
}

func (self *OxmIcmpv4CodeMasked) SetValue(v uint8) {
	self.Value = v
}

func (self *OxmIcmpv4CodeMasked) GetValueMask() uint8 {
	return self.ValueMask
}

func (self *OxmIcmpv4CodeMasked) SetValueMask(v uint8) {
	self.ValueMask = v
}

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

	encoder.PutUint8(uint8(self.Value))
	encoder.PutUint8(uint8(self.ValueMask))

	return nil
}

func DecodeOxmIcmpv4CodeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4CodeMasked, error) {
	_oxmicmpv4codemasked := &OxmIcmpv4CodeMasked{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmIcmpv4CodeMasked packet too short: %d < 2", decoder.Length())
	}
	_oxmicmpv4codemasked.Value = uint8(decoder.ReadByte())
	_oxmicmpv4codemasked.ValueMask = uint8(decoder.ReadByte())
	return _oxmicmpv4codemasked, nil
}

func NewOxmIcmpv4CodeMasked() *OxmIcmpv4CodeMasked {
	obj := &OxmIcmpv4CodeMasked{
		Oxm: NewOxm(2147494146),
	}
	return obj
}
func (self *OxmIcmpv4CodeMasked) GetOXMName() string {
	return "icmpv4_code_masked"
}

func (self *OxmIcmpv4CodeMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIcmpv4CodeMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmIcmpv4CodeMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmIcmpv4Type struct {
	*Oxm
	Value IcmpType
}

type IOxmIcmpv4Type interface {
	goloxi.IOxm
	GetValue() IcmpType
}

func (self *OxmIcmpv4Type) GetValue() IcmpType {
	return self.Value
}

func (self *OxmIcmpv4Type) SetValue(v IcmpType) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeOxmIcmpv4Type(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4Type, error) {
	_oxmicmpv4type := &OxmIcmpv4Type{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("OxmIcmpv4Type packet too short: %d < 1", decoder.Length())
	}
	_oxmicmpv4type.Value = IcmpType(decoder.ReadByte())
	return _oxmicmpv4type, nil
}

func NewOxmIcmpv4Type() *OxmIcmpv4Type {
	obj := &OxmIcmpv4Type{
		Oxm: NewOxm(2147493377),
	}
	return obj
}
func (self *OxmIcmpv4Type) GetOXMName() string {
	return "icmpv4_type"
}

func (self *OxmIcmpv4Type) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIcmpv4Type) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmIcmpv4TypeMasked struct {
	*Oxm
	Value     IcmpType
	ValueMask uint8
}

type IOxmIcmpv4TypeMasked interface {
	goloxi.IOxm
	GetValue() IcmpType
	GetValueMask() uint8
}

func (self *OxmIcmpv4TypeMasked) GetValue() IcmpType {
	return self.Value
}

func (self *OxmIcmpv4TypeMasked) SetValue(v IcmpType) {
	self.Value = v
}

func (self *OxmIcmpv4TypeMasked) GetValueMask() uint8 {
	return self.ValueMask
}

func (self *OxmIcmpv4TypeMasked) SetValueMask(v uint8) {
	self.ValueMask = v
}

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

	encoder.PutUint8(uint8(self.Value))
	encoder.PutUint8(uint8(self.ValueMask))

	return nil
}

func DecodeOxmIcmpv4TypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4TypeMasked, error) {
	_oxmicmpv4typemasked := &OxmIcmpv4TypeMasked{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmIcmpv4TypeMasked packet too short: %d < 2", decoder.Length())
	}
	_oxmicmpv4typemasked.Value = IcmpType(decoder.ReadByte())
	_oxmicmpv4typemasked.ValueMask = uint8(decoder.ReadByte())
	return _oxmicmpv4typemasked, nil
}

func NewOxmIcmpv4TypeMasked() *OxmIcmpv4TypeMasked {
	obj := &OxmIcmpv4TypeMasked{
		Oxm: NewOxm(2147493634),
	}
	return obj
}
func (self *OxmIcmpv4TypeMasked) GetOXMName() string {
	return "icmpv4_type_masked"
}

func (self *OxmIcmpv4TypeMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIcmpv4TypeMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmIcmpv4TypeMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmIcmpv6Code struct {
	*Oxm
	Value uint8
}

type IOxmIcmpv6Code interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *OxmIcmpv6Code) GetValue() uint8 {
	return self.Value
}

func (self *OxmIcmpv6Code) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeOxmIcmpv6Code(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6Code, error) {
	_oxmicmpv6code := &OxmIcmpv6Code{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("OxmIcmpv6Code packet too short: %d < 1", decoder.Length())
	}
	_oxmicmpv6code.Value = uint8(decoder.ReadByte())
	return _oxmicmpv6code, nil
}

func NewOxmIcmpv6Code() *OxmIcmpv6Code {
	obj := &OxmIcmpv6Code{
		Oxm: NewOxm(2147499009),
	}
	return obj
}
func (self *OxmIcmpv6Code) GetOXMName() string {
	return "icmpv6_code"
}

func (self *OxmIcmpv6Code) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIcmpv6Code) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmIcmpv6CodeMasked struct {
	*Oxm
	Value     uint8
	ValueMask uint8
}

type IOxmIcmpv6CodeMasked interface {
	goloxi.IOxm
	GetValue() uint8
	GetValueMask() uint8
}

func (self *OxmIcmpv6CodeMasked) GetValue() uint8 {
	return self.Value
}

func (self *OxmIcmpv6CodeMasked) SetValue(v uint8) {
	self.Value = v
}

func (self *OxmIcmpv6CodeMasked) GetValueMask() uint8 {
	return self.ValueMask
}

func (self *OxmIcmpv6CodeMasked) SetValueMask(v uint8) {
	self.ValueMask = v
}

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

	encoder.PutUint8(uint8(self.Value))
	encoder.PutUint8(uint8(self.ValueMask))

	return nil
}

func DecodeOxmIcmpv6CodeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6CodeMasked, error) {
	_oxmicmpv6codemasked := &OxmIcmpv6CodeMasked{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmIcmpv6CodeMasked packet too short: %d < 2", decoder.Length())
	}
	_oxmicmpv6codemasked.Value = uint8(decoder.ReadByte())
	_oxmicmpv6codemasked.ValueMask = uint8(decoder.ReadByte())
	return _oxmicmpv6codemasked, nil
}

func NewOxmIcmpv6CodeMasked() *OxmIcmpv6CodeMasked {
	obj := &OxmIcmpv6CodeMasked{
		Oxm: NewOxm(2147499266),
	}
	return obj
}
func (self *OxmIcmpv6CodeMasked) GetOXMName() string {
	return "icmpv6_code_masked"
}

func (self *OxmIcmpv6CodeMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIcmpv6CodeMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmIcmpv6CodeMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmIcmpv6Type struct {
	*Oxm
	Value Icmpv6Type
}

type IOxmIcmpv6Type interface {
	goloxi.IOxm
	GetValue() Icmpv6Type
}

func (self *OxmIcmpv6Type) GetValue() Icmpv6Type {
	return self.Value
}

func (self *OxmIcmpv6Type) SetValue(v Icmpv6Type) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeOxmIcmpv6Type(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6Type, error) {
	_oxmicmpv6type := &OxmIcmpv6Type{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("OxmIcmpv6Type packet too short: %d < 1", decoder.Length())
	}
	_oxmicmpv6type.Value = Icmpv6Type(decoder.ReadByte())
	return _oxmicmpv6type, nil
}

func NewOxmIcmpv6Type() *OxmIcmpv6Type {
	obj := &OxmIcmpv6Type{
		Oxm: NewOxm(2147498497),
	}
	return obj
}
func (self *OxmIcmpv6Type) GetOXMName() string {
	return "icmpv6_type"
}

func (self *OxmIcmpv6Type) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIcmpv6Type) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmIcmpv6TypeMasked struct {
	*Oxm
	Value     Icmpv6Type
	ValueMask uint8
}

type IOxmIcmpv6TypeMasked interface {
	goloxi.IOxm
	GetValue() Icmpv6Type
	GetValueMask() uint8
}

func (self *OxmIcmpv6TypeMasked) GetValue() Icmpv6Type {
	return self.Value
}

func (self *OxmIcmpv6TypeMasked) SetValue(v Icmpv6Type) {
	self.Value = v
}

func (self *OxmIcmpv6TypeMasked) GetValueMask() uint8 {
	return self.ValueMask
}

func (self *OxmIcmpv6TypeMasked) SetValueMask(v uint8) {
	self.ValueMask = v
}

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

	encoder.PutUint8(uint8(self.Value))
	encoder.PutUint8(uint8(self.ValueMask))

	return nil
}

func DecodeOxmIcmpv6TypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6TypeMasked, error) {
	_oxmicmpv6typemasked := &OxmIcmpv6TypeMasked{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmIcmpv6TypeMasked packet too short: %d < 2", decoder.Length())
	}
	_oxmicmpv6typemasked.Value = Icmpv6Type(decoder.ReadByte())
	_oxmicmpv6typemasked.ValueMask = uint8(decoder.ReadByte())
	return _oxmicmpv6typemasked, nil
}

func NewOxmIcmpv6TypeMasked() *OxmIcmpv6TypeMasked {
	obj := &OxmIcmpv6TypeMasked{
		Oxm: NewOxm(2147498754),
	}
	return obj
}
func (self *OxmIcmpv6TypeMasked) GetOXMName() string {
	return "icmpv6_type_masked"
}

func (self *OxmIcmpv6TypeMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIcmpv6TypeMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmIcmpv6TypeMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmInPhyPort struct {
	*Oxm
	Value Port
}

type IOxmInPhyPort interface {
	goloxi.IOxm
	GetValue() Port
}

func (self *OxmInPhyPort) GetValue() Port {
	return self.Value
}

func (self *OxmInPhyPort) SetValue(v Port) {
	self.Value = v
}

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

	self.Value.Serialize(encoder)

	return nil
}

func DecodeOxmInPhyPort(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPhyPort, error) {
	_oxminphyport := &OxmInPhyPort{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmInPhyPort packet too short: %d < 4", decoder.Length())
	}
	_oxminphyport.Value.Decode(decoder)
	return _oxminphyport, nil
}

func NewOxmInPhyPort() *OxmInPhyPort {
	obj := &OxmInPhyPort{
		Oxm: NewOxm(2147484164),
	}
	return obj
}
func (self *OxmInPhyPort) GetOXMName() string {
	return "in_phy_port"
}

func (self *OxmInPhyPort) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmInPhyPort) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmInPhyPortMasked struct {
	*Oxm
	Value     Port
	ValueMask Port
}

type IOxmInPhyPortMasked interface {
	goloxi.IOxm
	GetValue() Port
	GetValueMask() Port
}

func (self *OxmInPhyPortMasked) GetValue() Port {
	return self.Value
}

func (self *OxmInPhyPortMasked) SetValue(v Port) {
	self.Value = v
}

func (self *OxmInPhyPortMasked) GetValueMask() Port {
	return self.ValueMask
}

func (self *OxmInPhyPortMasked) SetValueMask(v Port) {
	self.ValueMask = v
}

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

	self.Value.Serialize(encoder)
	self.ValueMask.Serialize(encoder)

	return nil
}

func DecodeOxmInPhyPortMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPhyPortMasked, error) {
	_oxminphyportmasked := &OxmInPhyPortMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmInPhyPortMasked packet too short: %d < 8", decoder.Length())
	}
	_oxminphyportmasked.Value.Decode(decoder)
	_oxminphyportmasked.ValueMask.Decode(decoder)
	return _oxminphyportmasked, nil
}

func NewOxmInPhyPortMasked() *OxmInPhyPortMasked {
	obj := &OxmInPhyPortMasked{
		Oxm: NewOxm(2147484424),
	}
	return obj
}
func (self *OxmInPhyPortMasked) GetOXMName() string {
	return "in_phy_port_masked"
}

func (self *OxmInPhyPortMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmInPhyPortMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmInPhyPortMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmInPort struct {
	*Oxm
	Value Port
}

type IOxmInPort interface {
	goloxi.IOxm
	GetValue() Port
}

func (self *OxmInPort) GetValue() Port {
	return self.Value
}

func (self *OxmInPort) SetValue(v Port) {
	self.Value = v
}

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

	self.Value.Serialize(encoder)

	return nil
}

func DecodeOxmInPort(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPort, error) {
	_oxminport := &OxmInPort{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmInPort packet too short: %d < 4", decoder.Length())
	}
	_oxminport.Value.Decode(decoder)
	return _oxminport, nil
}

func NewOxmInPort() *OxmInPort {
	obj := &OxmInPort{
		Oxm: NewOxm(2147483652),
	}
	return obj
}
func (self *OxmInPort) GetOXMName() string {
	return "in_port"
}

func (self *OxmInPort) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmInPort) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmInPortMasked struct {
	*Oxm
	Value     Port
	ValueMask Port
}

type IOxmInPortMasked interface {
	goloxi.IOxm
	GetValue() Port
	GetValueMask() Port
}

func (self *OxmInPortMasked) GetValue() Port {
	return self.Value
}

func (self *OxmInPortMasked) SetValue(v Port) {
	self.Value = v
}

func (self *OxmInPortMasked) GetValueMask() Port {
	return self.ValueMask
}

func (self *OxmInPortMasked) SetValueMask(v Port) {
	self.ValueMask = v
}

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

	self.Value.Serialize(encoder)
	self.ValueMask.Serialize(encoder)

	return nil
}

func DecodeOxmInPortMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPortMasked, error) {
	_oxminportmasked := &OxmInPortMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmInPortMasked packet too short: %d < 8", decoder.Length())
	}
	_oxminportmasked.Value.Decode(decoder)
	_oxminportmasked.ValueMask.Decode(decoder)
	return _oxminportmasked, nil
}

func NewOxmInPortMasked() *OxmInPortMasked {
	obj := &OxmInPortMasked{
		Oxm: NewOxm(2147483912),
	}
	return obj
}
func (self *OxmInPortMasked) GetOXMName() string {
	return "in_port_masked"
}

func (self *OxmInPortMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmInPortMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmInPortMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmIpDscp struct {
	*Oxm
	Value uint8
}

type IOxmIpDscp interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *OxmIpDscp) GetValue() uint8 {
	return self.Value
}

func (self *OxmIpDscp) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeOxmIpDscp(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpDscp, error) {
	_oxmipdscp := &OxmIpDscp{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("OxmIpDscp packet too short: %d < 1", decoder.Length())
	}
	_oxmipdscp.Value = uint8(decoder.ReadByte())
	return _oxmipdscp, nil
}

func NewOxmIpDscp() *OxmIpDscp {
	obj := &OxmIpDscp{
		Oxm: NewOxm(2147487745),
	}
	return obj
}
func (self *OxmIpDscp) GetOXMName() string {
	return "ip_dscp"
}

func (self *OxmIpDscp) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpDscp) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmIpDscpMasked struct {
	*Oxm
	Value     uint8
	ValueMask uint8
}

type IOxmIpDscpMasked interface {
	goloxi.IOxm
	GetValue() uint8
	GetValueMask() uint8
}

func (self *OxmIpDscpMasked) GetValue() uint8 {
	return self.Value
}

func (self *OxmIpDscpMasked) SetValue(v uint8) {
	self.Value = v
}

func (self *OxmIpDscpMasked) GetValueMask() uint8 {
	return self.ValueMask
}

func (self *OxmIpDscpMasked) SetValueMask(v uint8) {
	self.ValueMask = v
}

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

	encoder.PutUint8(uint8(self.Value))
	encoder.PutUint8(uint8(self.ValueMask))

	return nil
}

func DecodeOxmIpDscpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpDscpMasked, error) {
	_oxmipdscpmasked := &OxmIpDscpMasked{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmIpDscpMasked packet too short: %d < 2", decoder.Length())
	}
	_oxmipdscpmasked.Value = uint8(decoder.ReadByte())
	_oxmipdscpmasked.ValueMask = uint8(decoder.ReadByte())
	return _oxmipdscpmasked, nil
}

func NewOxmIpDscpMasked() *OxmIpDscpMasked {
	obj := &OxmIpDscpMasked{
		Oxm: NewOxm(2147488002),
	}
	return obj
}
func (self *OxmIpDscpMasked) GetOXMName() string {
	return "ip_dscp_masked"
}

func (self *OxmIpDscpMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpDscpMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmIpDscpMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmIpEcn struct {
	*Oxm
	Value uint8
}

type IOxmIpEcn interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *OxmIpEcn) GetValue() uint8 {
	return self.Value
}

func (self *OxmIpEcn) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeOxmIpEcn(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpEcn, error) {
	_oxmipecn := &OxmIpEcn{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("OxmIpEcn packet too short: %d < 1", decoder.Length())
	}
	_oxmipecn.Value = uint8(decoder.ReadByte())
	return _oxmipecn, nil
}

func NewOxmIpEcn() *OxmIpEcn {
	obj := &OxmIpEcn{
		Oxm: NewOxm(2147488257),
	}
	return obj
}
func (self *OxmIpEcn) GetOXMName() string {
	return "ip_ecn"
}

func (self *OxmIpEcn) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpEcn) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmIpEcnMasked struct {
	*Oxm
	Value     uint8
	ValueMask uint8
}

type IOxmIpEcnMasked interface {
	goloxi.IOxm
	GetValue() uint8
	GetValueMask() uint8
}

func (self *OxmIpEcnMasked) GetValue() uint8 {
	return self.Value
}

func (self *OxmIpEcnMasked) SetValue(v uint8) {
	self.Value = v
}

func (self *OxmIpEcnMasked) GetValueMask() uint8 {
	return self.ValueMask
}

func (self *OxmIpEcnMasked) SetValueMask(v uint8) {
	self.ValueMask = v
}

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

	encoder.PutUint8(uint8(self.Value))
	encoder.PutUint8(uint8(self.ValueMask))

	return nil
}

func DecodeOxmIpEcnMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpEcnMasked, error) {
	_oxmipecnmasked := &OxmIpEcnMasked{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmIpEcnMasked packet too short: %d < 2", decoder.Length())
	}
	_oxmipecnmasked.Value = uint8(decoder.ReadByte())
	_oxmipecnmasked.ValueMask = uint8(decoder.ReadByte())
	return _oxmipecnmasked, nil
}

func NewOxmIpEcnMasked() *OxmIpEcnMasked {
	obj := &OxmIpEcnMasked{
		Oxm: NewOxm(2147488514),
	}
	return obj
}
func (self *OxmIpEcnMasked) GetOXMName() string {
	return "ip_ecn_masked"
}

func (self *OxmIpEcnMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpEcnMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmIpEcnMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmIpProto struct {
	*Oxm
	Value IpPrototype
}

type IOxmIpProto interface {
	goloxi.IOxm
	GetValue() IpPrototype
}

func (self *OxmIpProto) GetValue() IpPrototype {
	return self.Value
}

func (self *OxmIpProto) SetValue(v IpPrototype) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeOxmIpProto(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpProto, error) {
	_oxmipproto := &OxmIpProto{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("OxmIpProto packet too short: %d < 1", decoder.Length())
	}
	_oxmipproto.Value = IpPrototype(decoder.ReadByte())
	return _oxmipproto, nil
}

func NewOxmIpProto() *OxmIpProto {
	obj := &OxmIpProto{
		Oxm: NewOxm(2147488769),
	}
	return obj
}
func (self *OxmIpProto) GetOXMName() string {
	return "ip_proto"
}

func (self *OxmIpProto) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpProto) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmIpProtoMasked struct {
	*Oxm
	Value     IpPrototype
	ValueMask uint8
}

type IOxmIpProtoMasked interface {
	goloxi.IOxm
	GetValue() IpPrototype
	GetValueMask() uint8
}

func (self *OxmIpProtoMasked) GetValue() IpPrototype {
	return self.Value
}

func (self *OxmIpProtoMasked) SetValue(v IpPrototype) {
	self.Value = v
}

func (self *OxmIpProtoMasked) GetValueMask() uint8 {
	return self.ValueMask
}

func (self *OxmIpProtoMasked) SetValueMask(v uint8) {
	self.ValueMask = v
}

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

	encoder.PutUint8(uint8(self.Value))
	encoder.PutUint8(uint8(self.ValueMask))

	return nil
}

func DecodeOxmIpProtoMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpProtoMasked, error) {
	_oxmipprotomasked := &OxmIpProtoMasked{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmIpProtoMasked packet too short: %d < 2", decoder.Length())
	}
	_oxmipprotomasked.Value = IpPrototype(decoder.ReadByte())
	_oxmipprotomasked.ValueMask = uint8(decoder.ReadByte())
	return _oxmipprotomasked, nil
}

func NewOxmIpProtoMasked() *OxmIpProtoMasked {
	obj := &OxmIpProtoMasked{
		Oxm: NewOxm(2147489026),
	}
	return obj
}
func (self *OxmIpProtoMasked) GetOXMName() string {
	return "ip_proto_masked"
}

func (self *OxmIpProtoMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpProtoMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmIpProtoMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmIpv4Dst struct {
	*Oxm
	Value net.IP
}

type IOxmIpv4Dst interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *OxmIpv4Dst) GetValue() net.IP {
	return self.Value
}

func (self *OxmIpv4Dst) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To4())

	return nil
}

func DecodeOxmIpv4Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4Dst, error) {
	_oxmipv4dst := &OxmIpv4Dst{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmIpv4Dst packet too short: %d < 4", decoder.Length())
	}
	_oxmipv4dst.Value = net.IP(decoder.Read(4))
	return _oxmipv4dst, nil
}

func NewOxmIpv4Dst() *OxmIpv4Dst {
	obj := &OxmIpv4Dst{
		Oxm: NewOxm(2147489796),
	}
	return obj
}
func (self *OxmIpv4Dst) GetOXMName() string {
	return "ipv4_dst"
}

func (self *OxmIpv4Dst) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpv4Dst) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmIpv4DstMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type IOxmIpv4DstMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *OxmIpv4DstMasked) GetValue() net.IP {
	return self.Value
}

func (self *OxmIpv4DstMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *OxmIpv4DstMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *OxmIpv4DstMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To4())
	encoder.Write(self.ValueMask.To4())

	return nil
}

func DecodeOxmIpv4DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4DstMasked, error) {
	_oxmipv4dstmasked := &OxmIpv4DstMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmIpv4DstMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmipv4dstmasked.Value = net.IP(decoder.Read(4))
	_oxmipv4dstmasked.ValueMask = net.IP(decoder.Read(4))
	return _oxmipv4dstmasked, nil
}

func NewOxmIpv4DstMasked() *OxmIpv4DstMasked {
	obj := &OxmIpv4DstMasked{
		Oxm: NewOxm(2147490056),
	}
	return obj
}
func (self *OxmIpv4DstMasked) GetOXMName() string {
	return "ipv4_dst_masked"
}

func (self *OxmIpv4DstMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpv4DstMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmIpv4DstMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmIpv4Src struct {
	*Oxm
	Value net.IP
}

type IOxmIpv4Src interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *OxmIpv4Src) GetValue() net.IP {
	return self.Value
}

func (self *OxmIpv4Src) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To4())

	return nil
}

func DecodeOxmIpv4Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4Src, error) {
	_oxmipv4src := &OxmIpv4Src{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmIpv4Src packet too short: %d < 4", decoder.Length())
	}
	_oxmipv4src.Value = net.IP(decoder.Read(4))
	return _oxmipv4src, nil
}

func NewOxmIpv4Src() *OxmIpv4Src {
	obj := &OxmIpv4Src{
		Oxm: NewOxm(2147489284),
	}
	return obj
}
func (self *OxmIpv4Src) GetOXMName() string {
	return "ipv4_src"
}

func (self *OxmIpv4Src) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpv4Src) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmIpv4SrcMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type IOxmIpv4SrcMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *OxmIpv4SrcMasked) GetValue() net.IP {
	return self.Value
}

func (self *OxmIpv4SrcMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *OxmIpv4SrcMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *OxmIpv4SrcMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To4())
	encoder.Write(self.ValueMask.To4())

	return nil
}

func DecodeOxmIpv4SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4SrcMasked, error) {
	_oxmipv4srcmasked := &OxmIpv4SrcMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmIpv4SrcMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmipv4srcmasked.Value = net.IP(decoder.Read(4))
	_oxmipv4srcmasked.ValueMask = net.IP(decoder.Read(4))
	return _oxmipv4srcmasked, nil
}

func NewOxmIpv4SrcMasked() *OxmIpv4SrcMasked {
	obj := &OxmIpv4SrcMasked{
		Oxm: NewOxm(2147489544),
	}
	return obj
}
func (self *OxmIpv4SrcMasked) GetOXMName() string {
	return "ipv4_src_masked"
}

func (self *OxmIpv4SrcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpv4SrcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmIpv4SrcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmIpv6Dst struct {
	*Oxm
	Value net.IP
}

type IOxmIpv6Dst interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *OxmIpv6Dst) GetValue() net.IP {
	return self.Value
}

func (self *OxmIpv6Dst) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To16())

	return nil
}

func DecodeOxmIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Dst, error) {
	_oxmipv6dst := &OxmIpv6Dst{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("OxmIpv6Dst packet too short: %d < 16", decoder.Length())
	}
	_oxmipv6dst.Value = net.IP(decoder.Read(16))
	return _oxmipv6dst, nil
}

func NewOxmIpv6Dst() *OxmIpv6Dst {
	obj := &OxmIpv6Dst{
		Oxm: NewOxm(2147497488),
	}
	return obj
}
func (self *OxmIpv6Dst) GetOXMName() string {
	return "ipv6_dst"
}

func (self *OxmIpv6Dst) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpv6Dst) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmIpv6DstMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type IOxmIpv6DstMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *OxmIpv6DstMasked) GetValue() net.IP {
	return self.Value
}

func (self *OxmIpv6DstMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *OxmIpv6DstMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *OxmIpv6DstMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To16())
	encoder.Write(self.ValueMask.To16())

	return nil
}

func DecodeOxmIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6DstMasked, error) {
	_oxmipv6dstmasked := &OxmIpv6DstMasked{Oxm: parent}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("OxmIpv6DstMasked packet too short: %d < 32", decoder.Length())
	}
	_oxmipv6dstmasked.Value = net.IP(decoder.Read(16))
	_oxmipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
	return _oxmipv6dstmasked, nil
}

func NewOxmIpv6DstMasked() *OxmIpv6DstMasked {
	obj := &OxmIpv6DstMasked{
		Oxm: NewOxm(2147497760),
	}
	return obj
}
func (self *OxmIpv6DstMasked) GetOXMName() string {
	return "ipv6_dst_masked"
}

func (self *OxmIpv6DstMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpv6DstMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmIpv6DstMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmIpv6Flabel struct {
	*Oxm
	Value uint32
}

type IOxmIpv6Flabel interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmIpv6Flabel) GetValue() uint32 {
	return self.Value
}

func (self *OxmIpv6Flabel) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmIpv6Flabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Flabel, error) {
	_oxmipv6flabel := &OxmIpv6Flabel{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmIpv6Flabel packet too short: %d < 4", decoder.Length())
	}
	_oxmipv6flabel.Value = uint32(decoder.ReadUint32())
	return _oxmipv6flabel, nil
}

func NewOxmIpv6Flabel() *OxmIpv6Flabel {
	obj := &OxmIpv6Flabel{
		Oxm: NewOxm(2147497988),
	}
	return obj
}
func (self *OxmIpv6Flabel) GetOXMName() string {
	return "ipv6_flabel"
}

func (self *OxmIpv6Flabel) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpv6Flabel) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmIpv6FlabelMasked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmIpv6FlabelMasked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmIpv6FlabelMasked) GetValue() uint32 {
	return self.Value
}

func (self *OxmIpv6FlabelMasked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmIpv6FlabelMasked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmIpv6FlabelMasked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmIpv6FlabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6FlabelMasked, error) {
	_oxmipv6flabelmasked := &OxmIpv6FlabelMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmIpv6FlabelMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmipv6flabelmasked.Value = uint32(decoder.ReadUint32())
	_oxmipv6flabelmasked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmipv6flabelmasked, nil
}

func NewOxmIpv6FlabelMasked() *OxmIpv6FlabelMasked {
	obj := &OxmIpv6FlabelMasked{
		Oxm: NewOxm(2147498248),
	}
	return obj
}
func (self *OxmIpv6FlabelMasked) GetOXMName() string {
	return "ipv6_flabel_masked"
}

func (self *OxmIpv6FlabelMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpv6FlabelMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmIpv6FlabelMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmIpv6NdSll struct {
	*Oxm
	Value net.HardwareAddr
}

type IOxmIpv6NdSll interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
}

func (self *OxmIpv6NdSll) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *OxmIpv6NdSll) SetValue(v net.HardwareAddr) {
	self.Value = v
}

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

	encoder.Write(self.Value)

	return nil
}

func DecodeOxmIpv6NdSll(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdSll, error) {
	_oxmipv6ndsll := &OxmIpv6NdSll{Oxm: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("OxmIpv6NdSll packet too short: %d < 6", decoder.Length())
	}
	_oxmipv6ndsll.Value = net.HardwareAddr(decoder.Read(6))
	return _oxmipv6ndsll, nil
}

func NewOxmIpv6NdSll() *OxmIpv6NdSll {
	obj := &OxmIpv6NdSll{
		Oxm: NewOxm(2147500038),
	}
	return obj
}
func (self *OxmIpv6NdSll) GetOXMName() string {
	return "ipv6_nd_sll"
}

func (self *OxmIpv6NdSll) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpv6NdSll) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmIpv6NdSllMasked struct {
	*Oxm
	Value     net.HardwareAddr
	ValueMask net.HardwareAddr
}

type IOxmIpv6NdSllMasked interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
	GetValueMask() net.HardwareAddr
}

func (self *OxmIpv6NdSllMasked) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *OxmIpv6NdSllMasked) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *OxmIpv6NdSllMasked) GetValueMask() net.HardwareAddr {
	return self.ValueMask
}

func (self *OxmIpv6NdSllMasked) SetValueMask(v net.HardwareAddr) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeOxmIpv6NdSllMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdSllMasked, error) {
	_oxmipv6ndsllmasked := &OxmIpv6NdSllMasked{Oxm: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("OxmIpv6NdSllMasked packet too short: %d < 12", decoder.Length())
	}
	_oxmipv6ndsllmasked.Value = net.HardwareAddr(decoder.Read(6))
	_oxmipv6ndsllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
	return _oxmipv6ndsllmasked, nil
}

func NewOxmIpv6NdSllMasked() *OxmIpv6NdSllMasked {
	obj := &OxmIpv6NdSllMasked{
		Oxm: NewOxm(2147500300),
	}
	return obj
}
func (self *OxmIpv6NdSllMasked) GetOXMName() string {
	return "ipv6_nd_sll_masked"
}

func (self *OxmIpv6NdSllMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpv6NdSllMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmIpv6NdSllMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmIpv6NdTarget struct {
	*Oxm
	Value net.IP
}

type IOxmIpv6NdTarget interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *OxmIpv6NdTarget) GetValue() net.IP {
	return self.Value
}

func (self *OxmIpv6NdTarget) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To16())

	return nil
}

func DecodeOxmIpv6NdTarget(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTarget, error) {
	_oxmipv6ndtarget := &OxmIpv6NdTarget{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("OxmIpv6NdTarget packet too short: %d < 16", decoder.Length())
	}
	_oxmipv6ndtarget.Value = net.IP(decoder.Read(16))
	return _oxmipv6ndtarget, nil
}

func NewOxmIpv6NdTarget() *OxmIpv6NdTarget {
	obj := &OxmIpv6NdTarget{
		Oxm: NewOxm(2147499536),
	}
	return obj
}
func (self *OxmIpv6NdTarget) GetOXMName() string {
	return "ipv6_nd_target"
}

func (self *OxmIpv6NdTarget) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpv6NdTarget) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmIpv6NdTargetMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type IOxmIpv6NdTargetMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *OxmIpv6NdTargetMasked) GetValue() net.IP {
	return self.Value
}

func (self *OxmIpv6NdTargetMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *OxmIpv6NdTargetMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *OxmIpv6NdTargetMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To16())
	encoder.Write(self.ValueMask.To16())

	return nil
}

func DecodeOxmIpv6NdTargetMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTargetMasked, error) {
	_oxmipv6ndtargetmasked := &OxmIpv6NdTargetMasked{Oxm: parent}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("OxmIpv6NdTargetMasked packet too short: %d < 32", decoder.Length())
	}
	_oxmipv6ndtargetmasked.Value = net.IP(decoder.Read(16))
	_oxmipv6ndtargetmasked.ValueMask = net.IP(decoder.Read(16))
	return _oxmipv6ndtargetmasked, nil
}

func NewOxmIpv6NdTargetMasked() *OxmIpv6NdTargetMasked {
	obj := &OxmIpv6NdTargetMasked{
		Oxm: NewOxm(2147499808),
	}
	return obj
}
func (self *OxmIpv6NdTargetMasked) GetOXMName() string {
	return "ipv6_nd_target_masked"
}

func (self *OxmIpv6NdTargetMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpv6NdTargetMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmIpv6NdTargetMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmIpv6NdTll struct {
	*Oxm
	Value net.HardwareAddr
}

type IOxmIpv6NdTll interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
}

func (self *OxmIpv6NdTll) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *OxmIpv6NdTll) SetValue(v net.HardwareAddr) {
	self.Value = v
}

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

	encoder.Write(self.Value)

	return nil
}

func DecodeOxmIpv6NdTll(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTll, error) {
	_oxmipv6ndtll := &OxmIpv6NdTll{Oxm: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("OxmIpv6NdTll packet too short: %d < 6", decoder.Length())
	}
	_oxmipv6ndtll.Value = net.HardwareAddr(decoder.Read(6))
	return _oxmipv6ndtll, nil
}

func NewOxmIpv6NdTll() *OxmIpv6NdTll {
	obj := &OxmIpv6NdTll{
		Oxm: NewOxm(2147500550),
	}
	return obj
}
func (self *OxmIpv6NdTll) GetOXMName() string {
	return "ipv6_nd_tll"
}

func (self *OxmIpv6NdTll) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpv6NdTll) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmIpv6NdTllMasked struct {
	*Oxm
	Value     net.HardwareAddr
	ValueMask net.HardwareAddr
}

type IOxmIpv6NdTllMasked interface {
	goloxi.IOxm
	GetValue() net.HardwareAddr
	GetValueMask() net.HardwareAddr
}

func (self *OxmIpv6NdTllMasked) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *OxmIpv6NdTllMasked) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *OxmIpv6NdTllMasked) GetValueMask() net.HardwareAddr {
	return self.ValueMask
}

func (self *OxmIpv6NdTllMasked) SetValueMask(v net.HardwareAddr) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value)
	encoder.Write(self.ValueMask)

	return nil
}

func DecodeOxmIpv6NdTllMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTllMasked, error) {
	_oxmipv6ndtllmasked := &OxmIpv6NdTllMasked{Oxm: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("OxmIpv6NdTllMasked packet too short: %d < 12", decoder.Length())
	}
	_oxmipv6ndtllmasked.Value = net.HardwareAddr(decoder.Read(6))
	_oxmipv6ndtllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
	return _oxmipv6ndtllmasked, nil
}

func NewOxmIpv6NdTllMasked() *OxmIpv6NdTllMasked {
	obj := &OxmIpv6NdTllMasked{
		Oxm: NewOxm(2147500812),
	}
	return obj
}
func (self *OxmIpv6NdTllMasked) GetOXMName() string {
	return "ipv6_nd_tll_masked"
}

func (self *OxmIpv6NdTllMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpv6NdTllMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmIpv6NdTllMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmIpv6Src struct {
	*Oxm
	Value net.IP
}

type IOxmIpv6Src interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *OxmIpv6Src) GetValue() net.IP {
	return self.Value
}

func (self *OxmIpv6Src) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To16())

	return nil
}

func DecodeOxmIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Src, error) {
	_oxmipv6src := &OxmIpv6Src{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("OxmIpv6Src packet too short: %d < 16", decoder.Length())
	}
	_oxmipv6src.Value = net.IP(decoder.Read(16))
	return _oxmipv6src, nil
}

func NewOxmIpv6Src() *OxmIpv6Src {
	obj := &OxmIpv6Src{
		Oxm: NewOxm(2147496976),
	}
	return obj
}
func (self *OxmIpv6Src) GetOXMName() string {
	return "ipv6_src"
}

func (self *OxmIpv6Src) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpv6Src) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmIpv6SrcMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type IOxmIpv6SrcMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *OxmIpv6SrcMasked) GetValue() net.IP {
	return self.Value
}

func (self *OxmIpv6SrcMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *OxmIpv6SrcMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *OxmIpv6SrcMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To16())
	encoder.Write(self.ValueMask.To16())

	return nil
}

func DecodeOxmIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6SrcMasked, error) {
	_oxmipv6srcmasked := &OxmIpv6SrcMasked{Oxm: parent}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("OxmIpv6SrcMasked packet too short: %d < 32", decoder.Length())
	}
	_oxmipv6srcmasked.Value = net.IP(decoder.Read(16))
	_oxmipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
	return _oxmipv6srcmasked, nil
}

func NewOxmIpv6SrcMasked() *OxmIpv6SrcMasked {
	obj := &OxmIpv6SrcMasked{
		Oxm: NewOxm(2147497248),
	}
	return obj
}
func (self *OxmIpv6SrcMasked) GetOXMName() string {
	return "ipv6_src_masked"
}

func (self *OxmIpv6SrcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmIpv6SrcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmIpv6SrcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmMetadata struct {
	*Oxm
	Value uint64
}

type IOxmMetadata interface {
	goloxi.IOxm
	GetValue() uint64
}

func (self *OxmMetadata) GetValue() uint64 {
	return self.Value
}

func (self *OxmMetadata) SetValue(v uint64) {
	self.Value = v
}

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

	encoder.PutUint64(uint64(self.Value))

	return nil
}

func DecodeOxmMetadata(parent *Oxm, decoder *goloxi.Decoder) (*OxmMetadata, error) {
	_oxmmetadata := &OxmMetadata{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmMetadata packet too short: %d < 8", decoder.Length())
	}
	_oxmmetadata.Value = uint64(decoder.ReadUint64())
	return _oxmmetadata, nil
}

func NewOxmMetadata() *OxmMetadata {
	obj := &OxmMetadata{
		Oxm: NewOxm(2147484680),
	}
	return obj
}
func (self *OxmMetadata) GetOXMName() string {
	return "metadata"
}

func (self *OxmMetadata) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmMetadata) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmMetadataMasked struct {
	*Oxm
	Value     uint64
	ValueMask uint64
}

type IOxmMetadataMasked interface {
	goloxi.IOxm
	GetValue() uint64
	GetValueMask() uint64
}

func (self *OxmMetadataMasked) GetValue() uint64 {
	return self.Value
}

func (self *OxmMetadataMasked) SetValue(v uint64) {
	self.Value = v
}

func (self *OxmMetadataMasked) GetValueMask() uint64 {
	return self.ValueMask
}

func (self *OxmMetadataMasked) SetValueMask(v uint64) {
	self.ValueMask = v
}

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

	encoder.PutUint64(uint64(self.Value))
	encoder.PutUint64(uint64(self.ValueMask))

	return nil
}

func DecodeOxmMetadataMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMetadataMasked, error) {
	_oxmmetadatamasked := &OxmMetadataMasked{Oxm: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("OxmMetadataMasked packet too short: %d < 16", decoder.Length())
	}
	_oxmmetadatamasked.Value = uint64(decoder.ReadUint64())
	_oxmmetadatamasked.ValueMask = uint64(decoder.ReadUint64())
	return _oxmmetadatamasked, nil
}

func NewOxmMetadataMasked() *OxmMetadataMasked {
	obj := &OxmMetadataMasked{
		Oxm: NewOxm(2147484944),
	}
	return obj
}
func (self *OxmMetadataMasked) GetOXMName() string {
	return "metadata_masked"
}

func (self *OxmMetadataMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmMetadataMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmMetadataMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmMplsLabel struct {
	*Oxm
	Value uint32
}

type IOxmMplsLabel interface {
	goloxi.IOxm
	GetValue() uint32
}

func (self *OxmMplsLabel) GetValue() uint32 {
	return self.Value
}

func (self *OxmMplsLabel) SetValue(v uint32) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeOxmMplsLabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsLabel, error) {
	_oxmmplslabel := &OxmMplsLabel{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmMplsLabel packet too short: %d < 4", decoder.Length())
	}
	_oxmmplslabel.Value = uint32(decoder.ReadUint32())
	return _oxmmplslabel, nil
}

func NewOxmMplsLabel() *OxmMplsLabel {
	obj := &OxmMplsLabel{
		Oxm: NewOxm(2147501060),
	}
	return obj
}
func (self *OxmMplsLabel) GetOXMName() string {
	return "mpls_label"
}

func (self *OxmMplsLabel) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmMplsLabel) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmMplsLabelMasked struct {
	*Oxm
	Value     uint32
	ValueMask uint32
}

type IOxmMplsLabelMasked interface {
	goloxi.IOxm
	GetValue() uint32
	GetValueMask() uint32
}

func (self *OxmMplsLabelMasked) GetValue() uint32 {
	return self.Value
}

func (self *OxmMplsLabelMasked) SetValue(v uint32) {
	self.Value = v
}

func (self *OxmMplsLabelMasked) GetValueMask() uint32 {
	return self.ValueMask
}

func (self *OxmMplsLabelMasked) SetValueMask(v uint32) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.Value))
	encoder.PutUint32(uint32(self.ValueMask))

	return nil
}

func DecodeOxmMplsLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsLabelMasked, error) {
	_oxmmplslabelmasked := &OxmMplsLabelMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmMplsLabelMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmmplslabelmasked.Value = uint32(decoder.ReadUint32())
	_oxmmplslabelmasked.ValueMask = uint32(decoder.ReadUint32())
	return _oxmmplslabelmasked, nil
}

func NewOxmMplsLabelMasked() *OxmMplsLabelMasked {
	obj := &OxmMplsLabelMasked{
		Oxm: NewOxm(2147501320),
	}
	return obj
}
func (self *OxmMplsLabelMasked) GetOXMName() string {
	return "mpls_label_masked"
}

func (self *OxmMplsLabelMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmMplsLabelMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmMplsLabelMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmMplsTc struct {
	*Oxm
	Value uint8
}

type IOxmMplsTc interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *OxmMplsTc) GetValue() uint8 {
	return self.Value
}

func (self *OxmMplsTc) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeOxmMplsTc(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsTc, error) {
	_oxmmplstc := &OxmMplsTc{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("OxmMplsTc packet too short: %d < 1", decoder.Length())
	}
	_oxmmplstc.Value = uint8(decoder.ReadByte())
	return _oxmmplstc, nil
}

func NewOxmMplsTc() *OxmMplsTc {
	obj := &OxmMplsTc{
		Oxm: NewOxm(2147501569),
	}
	return obj
}
func (self *OxmMplsTc) GetOXMName() string {
	return "mpls_tc"
}

func (self *OxmMplsTc) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmMplsTc) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmMplsTcMasked struct {
	*Oxm
	Value     uint8
	ValueMask uint8
}

type IOxmMplsTcMasked interface {
	goloxi.IOxm
	GetValue() uint8
	GetValueMask() uint8
}

func (self *OxmMplsTcMasked) GetValue() uint8 {
	return self.Value
}

func (self *OxmMplsTcMasked) SetValue(v uint8) {
	self.Value = v
}

func (self *OxmMplsTcMasked) GetValueMask() uint8 {
	return self.ValueMask
}

func (self *OxmMplsTcMasked) SetValueMask(v uint8) {
	self.ValueMask = v
}

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

	encoder.PutUint8(uint8(self.Value))
	encoder.PutUint8(uint8(self.ValueMask))

	return nil
}

func DecodeOxmMplsTcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsTcMasked, error) {
	_oxmmplstcmasked := &OxmMplsTcMasked{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmMplsTcMasked packet too short: %d < 2", decoder.Length())
	}
	_oxmmplstcmasked.Value = uint8(decoder.ReadByte())
	_oxmmplstcmasked.ValueMask = uint8(decoder.ReadByte())
	return _oxmmplstcmasked, nil
}

func NewOxmMplsTcMasked() *OxmMplsTcMasked {
	obj := &OxmMplsTcMasked{
		Oxm: NewOxm(2147501826),
	}
	return obj
}
func (self *OxmMplsTcMasked) GetOXMName() string {
	return "mpls_tc_masked"
}

func (self *OxmMplsTcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmMplsTcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmMplsTcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmOvsTcpFlags struct {
	*Oxm
	ExperimenterId uint32
	Value          uint16
}

type IOxmOvsTcpFlags interface {
	goloxi.IOxm
	GetExperimenterId() uint32
	GetValue() uint16
}

func (self *OxmOvsTcpFlags) GetExperimenterId() uint32 {
	return self.ExperimenterId
}

func (self *OxmOvsTcpFlags) SetExperimenterId(v uint32) {
	self.ExperimenterId = v
}

func (self *OxmOvsTcpFlags) GetValue() uint16 {
	return self.Value
}

func (self *OxmOvsTcpFlags) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint32(uint32(self.ExperimenterId))
	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeOxmOvsTcpFlags(parent *Oxm, decoder *goloxi.Decoder) (*OxmOvsTcpFlags, error) {
	_oxmovstcpflags := &OxmOvsTcpFlags{Oxm: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("OxmOvsTcpFlags packet too short: %d < 6", decoder.Length())
	}
	_oxmovstcpflags.ExperimenterId = uint32(decoder.ReadUint32())
	_oxmovstcpflags.Value = uint16(decoder.ReadUint16())
	return _oxmovstcpflags, nil
}

func NewOxmOvsTcpFlags() *OxmOvsTcpFlags {
	obj := &OxmOvsTcpFlags{
		Oxm: NewOxm(4294923270),
	}
	return obj
}
func (self *OxmOvsTcpFlags) GetOXMName() string {
	return "ovs_tcp_flags"
}

func (self *OxmOvsTcpFlags) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmOvsTcpFlags) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmOvsTcpFlagsMasked struct {
	*Oxm
	ExperimenterId uint32
	Value          uint16
	ValueMask      uint16
}

type IOxmOvsTcpFlagsMasked interface {
	goloxi.IOxm
	GetExperimenterId() uint32
	GetValue() uint16
	GetValueMask() uint16
}

func (self *OxmOvsTcpFlagsMasked) GetExperimenterId() uint32 {
	return self.ExperimenterId
}

func (self *OxmOvsTcpFlagsMasked) SetExperimenterId(v uint32) {
	self.ExperimenterId = v
}

func (self *OxmOvsTcpFlagsMasked) GetValue() uint16 {
	return self.Value
}

func (self *OxmOvsTcpFlagsMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *OxmOvsTcpFlagsMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *OxmOvsTcpFlagsMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint32(uint32(self.ExperimenterId))
	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeOxmOvsTcpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmOvsTcpFlagsMasked, error) {
	_oxmovstcpflagsmasked := &OxmOvsTcpFlagsMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmOvsTcpFlagsMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmovstcpflagsmasked.ExperimenterId = uint32(decoder.ReadUint32())
	_oxmovstcpflagsmasked.Value = uint16(decoder.ReadUint16())
	_oxmovstcpflagsmasked.ValueMask = uint16(decoder.ReadUint16())
	return _oxmovstcpflagsmasked, nil
}

func NewOxmOvsTcpFlagsMasked() *OxmOvsTcpFlagsMasked {
	obj := &OxmOvsTcpFlagsMasked{
		Oxm: NewOxm(4294923528),
	}
	return obj
}
func (self *OxmOvsTcpFlagsMasked) GetOXMName() string {
	return "ovs_tcp_flags_masked"
}

func (self *OxmOvsTcpFlagsMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmOvsTcpFlagsMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmOvsTcpFlagsMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmSctpDst struct {
	*Oxm
	Value uint16
}

type IOxmSctpDst interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *OxmSctpDst) GetValue() uint16 {
	return self.Value
}

func (self *OxmSctpDst) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeOxmSctpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpDst, error) {
	_oxmsctpdst := &OxmSctpDst{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmSctpDst packet too short: %d < 2", decoder.Length())
	}
	_oxmsctpdst.Value = uint16(decoder.ReadUint16())
	return _oxmsctpdst, nil
}

func NewOxmSctpDst() *OxmSctpDst {
	obj := &OxmSctpDst{
		Oxm: NewOxm(2147492866),
	}
	return obj
}
func (self *OxmSctpDst) GetOXMName() string {
	return "sctp_dst"
}

func (self *OxmSctpDst) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmSctpDst) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmSctpDstMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type IOxmSctpDstMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *OxmSctpDstMasked) GetValue() uint16 {
	return self.Value
}

func (self *OxmSctpDstMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *OxmSctpDstMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *OxmSctpDstMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeOxmSctpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpDstMasked, error) {
	_oxmsctpdstmasked := &OxmSctpDstMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmSctpDstMasked packet too short: %d < 4", decoder.Length())
	}
	_oxmsctpdstmasked.Value = uint16(decoder.ReadUint16())
	_oxmsctpdstmasked.ValueMask = uint16(decoder.ReadUint16())
	return _oxmsctpdstmasked, nil
}

func NewOxmSctpDstMasked() *OxmSctpDstMasked {
	obj := &OxmSctpDstMasked{
		Oxm: NewOxm(2147493124),
	}
	return obj
}
func (self *OxmSctpDstMasked) GetOXMName() string {
	return "sctp_dst_masked"
}

func (self *OxmSctpDstMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmSctpDstMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmSctpDstMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmSctpSrc struct {
	*Oxm
	Value uint16
}

type IOxmSctpSrc interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *OxmSctpSrc) GetValue() uint16 {
	return self.Value
}

func (self *OxmSctpSrc) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeOxmSctpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpSrc, error) {
	_oxmsctpsrc := &OxmSctpSrc{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmSctpSrc packet too short: %d < 2", decoder.Length())
	}
	_oxmsctpsrc.Value = uint16(decoder.ReadUint16())
	return _oxmsctpsrc, nil
}

func NewOxmSctpSrc() *OxmSctpSrc {
	obj := &OxmSctpSrc{
		Oxm: NewOxm(2147492354),
	}
	return obj
}
func (self *OxmSctpSrc) GetOXMName() string {
	return "sctp_src"
}

func (self *OxmSctpSrc) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmSctpSrc) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmSctpSrcMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type IOxmSctpSrcMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *OxmSctpSrcMasked) GetValue() uint16 {
	return self.Value
}

func (self *OxmSctpSrcMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *OxmSctpSrcMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *OxmSctpSrcMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeOxmSctpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpSrcMasked, error) {
	_oxmsctpsrcmasked := &OxmSctpSrcMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmSctpSrcMasked packet too short: %d < 4", decoder.Length())
	}
	_oxmsctpsrcmasked.Value = uint16(decoder.ReadUint16())
	_oxmsctpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
	return _oxmsctpsrcmasked, nil
}

func NewOxmSctpSrcMasked() *OxmSctpSrcMasked {
	obj := &OxmSctpSrcMasked{
		Oxm: NewOxm(2147492612),
	}
	return obj
}
func (self *OxmSctpSrcMasked) GetOXMName() string {
	return "sctp_src_masked"
}

func (self *OxmSctpSrcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmSctpSrcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmSctpSrcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmTcpDst struct {
	*Oxm
	Value uint16
}

type IOxmTcpDst interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *OxmTcpDst) GetValue() uint16 {
	return self.Value
}

func (self *OxmTcpDst) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeOxmTcpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpDst, error) {
	_oxmtcpdst := &OxmTcpDst{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmTcpDst packet too short: %d < 2", decoder.Length())
	}
	_oxmtcpdst.Value = uint16(decoder.ReadUint16())
	return _oxmtcpdst, nil
}

func NewOxmTcpDst() *OxmTcpDst {
	obj := &OxmTcpDst{
		Oxm: NewOxm(2147490818),
	}
	return obj
}
func (self *OxmTcpDst) GetOXMName() string {
	return "tcp_dst"
}

func (self *OxmTcpDst) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmTcpDst) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmTcpDstMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type IOxmTcpDstMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *OxmTcpDstMasked) GetValue() uint16 {
	return self.Value
}

func (self *OxmTcpDstMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *OxmTcpDstMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *OxmTcpDstMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeOxmTcpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpDstMasked, error) {
	_oxmtcpdstmasked := &OxmTcpDstMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmTcpDstMasked packet too short: %d < 4", decoder.Length())
	}
	_oxmtcpdstmasked.Value = uint16(decoder.ReadUint16())
	_oxmtcpdstmasked.ValueMask = uint16(decoder.ReadUint16())
	return _oxmtcpdstmasked, nil
}

func NewOxmTcpDstMasked() *OxmTcpDstMasked {
	obj := &OxmTcpDstMasked{
		Oxm: NewOxm(2147491076),
	}
	return obj
}
func (self *OxmTcpDstMasked) GetOXMName() string {
	return "tcp_dst_masked"
}

func (self *OxmTcpDstMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmTcpDstMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmTcpDstMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmTcpSrc struct {
	*Oxm
	Value uint16
}

type IOxmTcpSrc interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *OxmTcpSrc) GetValue() uint16 {
	return self.Value
}

func (self *OxmTcpSrc) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeOxmTcpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpSrc, error) {
	_oxmtcpsrc := &OxmTcpSrc{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmTcpSrc packet too short: %d < 2", decoder.Length())
	}
	_oxmtcpsrc.Value = uint16(decoder.ReadUint16())
	return _oxmtcpsrc, nil
}

func NewOxmTcpSrc() *OxmTcpSrc {
	obj := &OxmTcpSrc{
		Oxm: NewOxm(2147490306),
	}
	return obj
}
func (self *OxmTcpSrc) GetOXMName() string {
	return "tcp_src"
}

func (self *OxmTcpSrc) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmTcpSrc) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmTcpSrcMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type IOxmTcpSrcMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *OxmTcpSrcMasked) GetValue() uint16 {
	return self.Value
}

func (self *OxmTcpSrcMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *OxmTcpSrcMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *OxmTcpSrcMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeOxmTcpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpSrcMasked, error) {
	_oxmtcpsrcmasked := &OxmTcpSrcMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmTcpSrcMasked packet too short: %d < 4", decoder.Length())
	}
	_oxmtcpsrcmasked.Value = uint16(decoder.ReadUint16())
	_oxmtcpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
	return _oxmtcpsrcmasked, nil
}

func NewOxmTcpSrcMasked() *OxmTcpSrcMasked {
	obj := &OxmTcpSrcMasked{
		Oxm: NewOxm(2147490564),
	}
	return obj
}
func (self *OxmTcpSrcMasked) GetOXMName() string {
	return "tcp_src_masked"
}

func (self *OxmTcpSrcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmTcpSrcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmTcpSrcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmTunnelIpv4Dst struct {
	*Oxm
	Value net.IP
}

type IOxmTunnelIpv4Dst interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *OxmTunnelIpv4Dst) GetValue() net.IP {
	return self.Value
}

func (self *OxmTunnelIpv4Dst) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To4())

	return nil
}

func DecodeOxmTunnelIpv4Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIpv4Dst, error) {
	_oxmtunnelipv4dst := &OxmTunnelIpv4Dst{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmTunnelIpv4Dst packet too short: %d < 4", decoder.Length())
	}
	_oxmtunnelipv4dst.Value = net.IP(decoder.Read(4))
	return _oxmtunnelipv4dst, nil
}

func NewOxmTunnelIpv4Dst() *OxmTunnelIpv4Dst {
	obj := &OxmTunnelIpv4Dst{
		Oxm: NewOxm(81924),
	}
	return obj
}
func (self *OxmTunnelIpv4Dst) GetOXMName() string {
	return "tunnel_ipv4_dst"
}

func (self *OxmTunnelIpv4Dst) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmTunnelIpv4Dst) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmTunnelIpv4DstMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type IOxmTunnelIpv4DstMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *OxmTunnelIpv4DstMasked) GetValue() net.IP {
	return self.Value
}

func (self *OxmTunnelIpv4DstMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *OxmTunnelIpv4DstMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *OxmTunnelIpv4DstMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To4())
	encoder.Write(self.ValueMask.To4())

	return nil
}

func DecodeOxmTunnelIpv4DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIpv4DstMasked, error) {
	_oxmtunnelipv4dstmasked := &OxmTunnelIpv4DstMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmTunnelIpv4DstMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmtunnelipv4dstmasked.Value = net.IP(decoder.Read(4))
	_oxmtunnelipv4dstmasked.ValueMask = net.IP(decoder.Read(4))
	return _oxmtunnelipv4dstmasked, nil
}

func NewOxmTunnelIpv4DstMasked() *OxmTunnelIpv4DstMasked {
	obj := &OxmTunnelIpv4DstMasked{
		Oxm: NewOxm(82184),
	}
	return obj
}
func (self *OxmTunnelIpv4DstMasked) GetOXMName() string {
	return "tunnel_ipv4_dst_masked"
}

func (self *OxmTunnelIpv4DstMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmTunnelIpv4DstMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmTunnelIpv4DstMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmTunnelIpv4Src struct {
	*Oxm
	Value net.IP
}

type IOxmTunnelIpv4Src interface {
	goloxi.IOxm
	GetValue() net.IP
}

func (self *OxmTunnelIpv4Src) GetValue() net.IP {
	return self.Value
}

func (self *OxmTunnelIpv4Src) SetValue(v net.IP) {
	self.Value = v
}

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

	encoder.Write(self.Value.To4())

	return nil
}

func DecodeOxmTunnelIpv4Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIpv4Src, error) {
	_oxmtunnelipv4src := &OxmTunnelIpv4Src{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmTunnelIpv4Src packet too short: %d < 4", decoder.Length())
	}
	_oxmtunnelipv4src.Value = net.IP(decoder.Read(4))
	return _oxmtunnelipv4src, nil
}

func NewOxmTunnelIpv4Src() *OxmTunnelIpv4Src {
	obj := &OxmTunnelIpv4Src{
		Oxm: NewOxm(81412),
	}
	return obj
}
func (self *OxmTunnelIpv4Src) GetOXMName() string {
	return "tunnel_ipv4_src"
}

func (self *OxmTunnelIpv4Src) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmTunnelIpv4Src) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmTunnelIpv4SrcMasked struct {
	*Oxm
	Value     net.IP
	ValueMask net.IP
}

type IOxmTunnelIpv4SrcMasked interface {
	goloxi.IOxm
	GetValue() net.IP
	GetValueMask() net.IP
}

func (self *OxmTunnelIpv4SrcMasked) GetValue() net.IP {
	return self.Value
}

func (self *OxmTunnelIpv4SrcMasked) SetValue(v net.IP) {
	self.Value = v
}

func (self *OxmTunnelIpv4SrcMasked) GetValueMask() net.IP {
	return self.ValueMask
}

func (self *OxmTunnelIpv4SrcMasked) SetValueMask(v net.IP) {
	self.ValueMask = v
}

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

	encoder.Write(self.Value.To4())
	encoder.Write(self.ValueMask.To4())

	return nil
}

func DecodeOxmTunnelIpv4SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIpv4SrcMasked, error) {
	_oxmtunnelipv4srcmasked := &OxmTunnelIpv4SrcMasked{Oxm: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("OxmTunnelIpv4SrcMasked packet too short: %d < 8", decoder.Length())
	}
	_oxmtunnelipv4srcmasked.Value = net.IP(decoder.Read(4))
	_oxmtunnelipv4srcmasked.ValueMask = net.IP(decoder.Read(4))
	return _oxmtunnelipv4srcmasked, nil
}

func NewOxmTunnelIpv4SrcMasked() *OxmTunnelIpv4SrcMasked {
	obj := &OxmTunnelIpv4SrcMasked{
		Oxm: NewOxm(81672),
	}
	return obj
}
func (self *OxmTunnelIpv4SrcMasked) GetOXMName() string {
	return "tunnel_ipv4_src_masked"
}

func (self *OxmTunnelIpv4SrcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmTunnelIpv4SrcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmTunnelIpv4SrcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmUdpDst struct {
	*Oxm
	Value uint16
}

type IOxmUdpDst interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *OxmUdpDst) GetValue() uint16 {
	return self.Value
}

func (self *OxmUdpDst) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeOxmUdpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpDst, error) {
	_oxmudpdst := &OxmUdpDst{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmUdpDst packet too short: %d < 2", decoder.Length())
	}
	_oxmudpdst.Value = uint16(decoder.ReadUint16())
	return _oxmudpdst, nil
}

func NewOxmUdpDst() *OxmUdpDst {
	obj := &OxmUdpDst{
		Oxm: NewOxm(2147491842),
	}
	return obj
}
func (self *OxmUdpDst) GetOXMName() string {
	return "udp_dst"
}

func (self *OxmUdpDst) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmUdpDst) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmUdpDstMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type IOxmUdpDstMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *OxmUdpDstMasked) GetValue() uint16 {
	return self.Value
}

func (self *OxmUdpDstMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *OxmUdpDstMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *OxmUdpDstMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeOxmUdpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpDstMasked, error) {
	_oxmudpdstmasked := &OxmUdpDstMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmUdpDstMasked packet too short: %d < 4", decoder.Length())
	}
	_oxmudpdstmasked.Value = uint16(decoder.ReadUint16())
	_oxmudpdstmasked.ValueMask = uint16(decoder.ReadUint16())
	return _oxmudpdstmasked, nil
}

func NewOxmUdpDstMasked() *OxmUdpDstMasked {
	obj := &OxmUdpDstMasked{
		Oxm: NewOxm(2147492100),
	}
	return obj
}
func (self *OxmUdpDstMasked) GetOXMName() string {
	return "udp_dst_masked"
}

func (self *OxmUdpDstMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmUdpDstMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmUdpDstMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmUdpSrc struct {
	*Oxm
	Value uint16
}

type IOxmUdpSrc interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *OxmUdpSrc) GetValue() uint16 {
	return self.Value
}

func (self *OxmUdpSrc) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeOxmUdpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpSrc, error) {
	_oxmudpsrc := &OxmUdpSrc{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmUdpSrc packet too short: %d < 2", decoder.Length())
	}
	_oxmudpsrc.Value = uint16(decoder.ReadUint16())
	return _oxmudpsrc, nil
}

func NewOxmUdpSrc() *OxmUdpSrc {
	obj := &OxmUdpSrc{
		Oxm: NewOxm(2147491330),
	}
	return obj
}
func (self *OxmUdpSrc) GetOXMName() string {
	return "udp_src"
}

func (self *OxmUdpSrc) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmUdpSrc) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmUdpSrcMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type IOxmUdpSrcMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *OxmUdpSrcMasked) GetValue() uint16 {
	return self.Value
}

func (self *OxmUdpSrcMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *OxmUdpSrcMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *OxmUdpSrcMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeOxmUdpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpSrcMasked, error) {
	_oxmudpsrcmasked := &OxmUdpSrcMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmUdpSrcMasked packet too short: %d < 4", decoder.Length())
	}
	_oxmudpsrcmasked.Value = uint16(decoder.ReadUint16())
	_oxmudpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
	return _oxmudpsrcmasked, nil
}

func NewOxmUdpSrcMasked() *OxmUdpSrcMasked {
	obj := &OxmUdpSrcMasked{
		Oxm: NewOxm(2147491588),
	}
	return obj
}
func (self *OxmUdpSrcMasked) GetOXMName() string {
	return "udp_src_masked"
}

func (self *OxmUdpSrcMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmUdpSrcMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmUdpSrcMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmVlanPcp struct {
	*Oxm
	Value uint8
}

type IOxmVlanPcp interface {
	goloxi.IOxm
	GetValue() uint8
}

func (self *OxmVlanPcp) GetValue() uint8 {
	return self.Value
}

func (self *OxmVlanPcp) SetValue(v uint8) {
	self.Value = v
}

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

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeOxmVlanPcp(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanPcp, error) {
	_oxmvlanpcp := &OxmVlanPcp{Oxm: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("OxmVlanPcp packet too short: %d < 1", decoder.Length())
	}
	_oxmvlanpcp.Value = uint8(decoder.ReadByte())
	return _oxmvlanpcp, nil
}

func NewOxmVlanPcp() *OxmVlanPcp {
	obj := &OxmVlanPcp{
		Oxm: NewOxm(2147487233),
	}
	return obj
}
func (self *OxmVlanPcp) GetOXMName() string {
	return "vlan_pcp"
}

func (self *OxmVlanPcp) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmVlanPcp) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmVlanPcpMasked struct {
	*Oxm
	Value     uint8
	ValueMask uint8
}

type IOxmVlanPcpMasked interface {
	goloxi.IOxm
	GetValue() uint8
	GetValueMask() uint8
}

func (self *OxmVlanPcpMasked) GetValue() uint8 {
	return self.Value
}

func (self *OxmVlanPcpMasked) SetValue(v uint8) {
	self.Value = v
}

func (self *OxmVlanPcpMasked) GetValueMask() uint8 {
	return self.ValueMask
}

func (self *OxmVlanPcpMasked) SetValueMask(v uint8) {
	self.ValueMask = v
}

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

	encoder.PutUint8(uint8(self.Value))
	encoder.PutUint8(uint8(self.ValueMask))

	return nil
}

func DecodeOxmVlanPcpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanPcpMasked, error) {
	_oxmvlanpcpmasked := &OxmVlanPcpMasked{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmVlanPcpMasked packet too short: %d < 2", decoder.Length())
	}
	_oxmvlanpcpmasked.Value = uint8(decoder.ReadByte())
	_oxmvlanpcpmasked.ValueMask = uint8(decoder.ReadByte())
	return _oxmvlanpcpmasked, nil
}

func NewOxmVlanPcpMasked() *OxmVlanPcpMasked {
	obj := &OxmVlanPcpMasked{
		Oxm: NewOxm(2147487490),
	}
	return obj
}
func (self *OxmVlanPcpMasked) GetOXMName() string {
	return "vlan_pcp_masked"
}

func (self *OxmVlanPcpMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmVlanPcpMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmVlanPcpMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}

type OxmVlanVid struct {
	*Oxm
	Value uint16
}

type IOxmVlanVid interface {
	goloxi.IOxm
	GetValue() uint16
}

func (self *OxmVlanVid) GetValue() uint16 {
	return self.Value
}

func (self *OxmVlanVid) SetValue(v uint16) {
	self.Value = v
}

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

	encoder.PutUint16(uint16(self.Value))

	return nil
}

func DecodeOxmVlanVid(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanVid, error) {
	_oxmvlanvid := &OxmVlanVid{Oxm: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("OxmVlanVid packet too short: %d < 2", decoder.Length())
	}
	_oxmvlanvid.Value = uint16(decoder.ReadUint16())
	return _oxmvlanvid, nil
}

func NewOxmVlanVid() *OxmVlanVid {
	obj := &OxmVlanVid{
		Oxm: NewOxm(2147486722),
	}
	return obj
}
func (self *OxmVlanVid) GetOXMName() string {
	return "vlan_vid"
}

func (self *OxmVlanVid) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmVlanVid) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
}

type OxmVlanVidMasked struct {
	*Oxm
	Value     uint16
	ValueMask uint16
}

type IOxmVlanVidMasked interface {
	goloxi.IOxm
	GetValue() uint16
	GetValueMask() uint16
}

func (self *OxmVlanVidMasked) GetValue() uint16 {
	return self.Value
}

func (self *OxmVlanVidMasked) SetValue(v uint16) {
	self.Value = v
}

func (self *OxmVlanVidMasked) GetValueMask() uint16 {
	return self.ValueMask
}

func (self *OxmVlanVidMasked) SetValueMask(v uint16) {
	self.ValueMask = v
}

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

	encoder.PutUint16(uint16(self.Value))
	encoder.PutUint16(uint16(self.ValueMask))

	return nil
}

func DecodeOxmVlanVidMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanVidMasked, error) {
	_oxmvlanvidmasked := &OxmVlanVidMasked{Oxm: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmVlanVidMasked packet too short: %d < 4", decoder.Length())
	}
	_oxmvlanvidmasked.Value = uint16(decoder.ReadUint16())
	_oxmvlanvidmasked.ValueMask = uint16(decoder.ReadUint16())
	return _oxmvlanvidmasked, nil
}

func NewOxmVlanVidMasked() *OxmVlanVidMasked {
	obj := &OxmVlanVidMasked{
		Oxm: NewOxm(2147486980),
	}
	return obj
}
func (self *OxmVlanVidMasked) GetOXMName() string {
	return "vlan_vid_masked"
}

func (self *OxmVlanVidMasked) GetOXMValue() interface{} {
	return self.Value
}

func (self *OxmVlanVidMasked) GetOXMValueMask() interface{} {
	return self.ValueMask
}

func (self *OxmVlanVidMasked) MarshalJSON() ([]byte, error) {
	value, err := jsonValue(self.GetOXMValue())
	if err != nil {
		return nil, err
	}
	valueMask, err := jsonValue(self.GetOXMValueMask())
	if err != nil {
		return nil, err
	}
	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
}