diff --git a/vendor/github.com/skydive-project/goloxi/of13/oxm.go b/vendor/github.com/skydive-project/goloxi/of13/oxm.go
new file mode 100644
index 0000000..be8bb7d
--- /dev/null
+++ b/vendor/github.com/skydive-project/goloxi/of13/oxm.go
@@ -0,0 +1,29586 @@
+/*
+ * 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 of13
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/skydive-project/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 65540:
+		return DecodeNxmReg0(_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 203780:
+		return DecodeOxmBsnUdf6(_oxm, decoder)
+	case 111228:
+		return DecodeNxmTunMetadata49(_oxm, decoder)
+	case 74758:
+		return DecodeNxmArpTha(_oxm, decoder)
+	case 2147503112:
+		return DecodeOxmTunnelId(_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 2147483652:
+		return DecodeOxmInPort(_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 2147502338:
+		return DecodeOxmMplsBosMasked(_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 1030:
+		return DecodeNxmEthSrc(_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 209156:
+		return DecodeOxmBsnInnerVlanVidMasked(_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 208898:
+		return DecodeOxmBsnInnerVlanVid(_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 2561:
+		return DecodeNxmNwTos(_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 2147486468:
+		return DecodeOxmEthTypeMasked(_oxm, decoder)
+	case 204552:
+		return DecodeOxmBsnUdf7Masked(_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 208652:
+		return DecodeOxmBsnInnerEthSrcMasked(_oxm, decoder)
+	case 2147503376:
+		return DecodeOxmTunnelIdMasked(_oxm, decoder)
+	case 96380:
+		return DecodeNxmTunMetadata20(_oxm, decoder)
+	case 92152:
+		return DecodeNxmTunMetadata11Masked(_oxm, decoder)
+	case 129796:
+		return DecodeOxmConnTrackingTpDstMasked(_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 2147483912:
+		return DecodeOxmInPortMasked(_oxm, decoder)
+	case 2147498754:
+		return DecodeOxmIcmpv6TypeMasked(_oxm, decoder)
+	case 209668:
+		return DecodeOxmBsnVfiMasked(_oxm, decoder)
+	case 70408:
+		return DecodeNxmReg9Masked(_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 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 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 73480:
+		return DecodeNxmReg15Masked(_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 199684:
+		return DecodeOxmBsnL3DstClassId(_oxm, decoder)
+	case 207878:
+		return DecodeOxmBsnInnerEthDst(_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 2147502081:
+		return DecodeOxmMplsBos(_oxm, decoder)
+	case 78342:
+		return DecodeNxmNdTll(_oxm, decoder)
+	case 111740:
+		return DecodeNxmTunMetadata50(_oxm, decoder)
+	case 107512:
+		return DecodeNxmTunMetadata41Masked(_oxm, decoder)
+	case 207624:
+		return DecodeOxmBsnVxlanNetworkIdMasked(_oxm, decoder)
+	case 121360:
+		return DecodeNxmTunIpv6Src(_oxm, decoder)
+	case 2147495688:
+		return DecodeOxmArpTpaMasked(_oxm, decoder)
+	case 113788:
+		return DecodeNxmTunMetadata54(_oxm, decoder)
+	case 109560:
+		return DecodeNxmTunMetadata45Masked(_oxm, decoder)
+	case 2147501826:
+		return DecodeOxmMplsTcMasked(_oxm, decoder)
+	case 103548:
+		return DecodeNxmTunMetadata34(_oxm, decoder)
+	case 66052:
+		return DecodeNxmReg1(_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 2147485190:
+		return DecodeOxmEthDst(_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 2147503876:
+		return DecodeOxmIpv6ExthdrMasked(_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 208140:
+		return DecodeOxmBsnInnerEthDstMasked(_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 2147500812:
+		return DecodeOxmIpv6NdTllMasked(_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 207364:
+		return DecodeOxmBsnVxlanNetworkId(_oxm, decoder)
+	case 209410:
+		return DecodeOxmBsnVfi(_oxm, decoder)
+	case 2147498497:
+		return DecodeOxmIcmpv6Type(_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 208390:
+		return DecodeOxmBsnInnerEthSrc(_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 2147503618:
+		return DecodeOxmIpv6Exthdr(_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 2147484164:
+		return DecodeOxmInPhyPort(_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 65800:
+		return DecodeNxmReg0Masked(_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 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 2147484424:
+		return DecodeOxmInPhyPortMasked(_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 OxmBsnInnerEthDst struct {
+	*Oxm
+	Value net.HardwareAddr
+}
+
+type IOxmBsnInnerEthDst interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+}
+
+func (self *OxmBsnInnerEthDst) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *OxmBsnInnerEthDst) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *OxmBsnInnerEthDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeOxmBsnInnerEthDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerEthDst, error) {
+	_oxmbsninnerethdst := &OxmBsnInnerEthDst{Oxm: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("OxmBsnInnerEthDst packet too short: %d < 6", decoder.Length())
+	}
+	_oxmbsninnerethdst.Value = net.HardwareAddr(decoder.Read(6))
+	return _oxmbsninnerethdst, nil
+}
+
+func NewOxmBsnInnerEthDst() *OxmBsnInnerEthDst {
+	obj := &OxmBsnInnerEthDst{
+		Oxm: NewOxm(207878),
+	}
+	return obj
+}
+func (self *OxmBsnInnerEthDst) GetOXMName() string {
+	return "bsn_inner_eth_dst"
+}
+
+func (self *OxmBsnInnerEthDst) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmBsnInnerEthDst) 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 OxmBsnInnerEthDstMasked struct {
+	*Oxm
+	Value     net.HardwareAddr
+	ValueMask net.HardwareAddr
+}
+
+type IOxmBsnInnerEthDstMasked interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+	GetValueMask() net.HardwareAddr
+}
+
+func (self *OxmBsnInnerEthDstMasked) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *OxmBsnInnerEthDstMasked) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *OxmBsnInnerEthDstMasked) GetValueMask() net.HardwareAddr {
+	return self.ValueMask
+}
+
+func (self *OxmBsnInnerEthDstMasked) SetValueMask(v net.HardwareAddr) {
+	self.ValueMask = v
+}
+
+func (self *OxmBsnInnerEthDstMasked) 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 DecodeOxmBsnInnerEthDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerEthDstMasked, error) {
+	_oxmbsninnerethdstmasked := &OxmBsnInnerEthDstMasked{Oxm: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("OxmBsnInnerEthDstMasked packet too short: %d < 12", decoder.Length())
+	}
+	_oxmbsninnerethdstmasked.Value = net.HardwareAddr(decoder.Read(6))
+	_oxmbsninnerethdstmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+	return _oxmbsninnerethdstmasked, nil
+}
+
+func NewOxmBsnInnerEthDstMasked() *OxmBsnInnerEthDstMasked {
+	obj := &OxmBsnInnerEthDstMasked{
+		Oxm: NewOxm(208140),
+	}
+	return obj
+}
+func (self *OxmBsnInnerEthDstMasked) GetOXMName() string {
+	return "bsn_inner_eth_dst_masked"
+}
+
+func (self *OxmBsnInnerEthDstMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmBsnInnerEthDstMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmBsnInnerEthDstMasked) 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 OxmBsnInnerEthSrc struct {
+	*Oxm
+	Value net.HardwareAddr
+}
+
+type IOxmBsnInnerEthSrc interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+}
+
+func (self *OxmBsnInnerEthSrc) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *OxmBsnInnerEthSrc) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *OxmBsnInnerEthSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeOxmBsnInnerEthSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerEthSrc, error) {
+	_oxmbsninnerethsrc := &OxmBsnInnerEthSrc{Oxm: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("OxmBsnInnerEthSrc packet too short: %d < 6", decoder.Length())
+	}
+	_oxmbsninnerethsrc.Value = net.HardwareAddr(decoder.Read(6))
+	return _oxmbsninnerethsrc, nil
+}
+
+func NewOxmBsnInnerEthSrc() *OxmBsnInnerEthSrc {
+	obj := &OxmBsnInnerEthSrc{
+		Oxm: NewOxm(208390),
+	}
+	return obj
+}
+func (self *OxmBsnInnerEthSrc) GetOXMName() string {
+	return "bsn_inner_eth_src"
+}
+
+func (self *OxmBsnInnerEthSrc) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmBsnInnerEthSrc) 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 OxmBsnInnerEthSrcMasked struct {
+	*Oxm
+	Value     net.HardwareAddr
+	ValueMask net.HardwareAddr
+}
+
+type IOxmBsnInnerEthSrcMasked interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+	GetValueMask() net.HardwareAddr
+}
+
+func (self *OxmBsnInnerEthSrcMasked) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *OxmBsnInnerEthSrcMasked) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *OxmBsnInnerEthSrcMasked) GetValueMask() net.HardwareAddr {
+	return self.ValueMask
+}
+
+func (self *OxmBsnInnerEthSrcMasked) SetValueMask(v net.HardwareAddr) {
+	self.ValueMask = v
+}
+
+func (self *OxmBsnInnerEthSrcMasked) 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 DecodeOxmBsnInnerEthSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerEthSrcMasked, error) {
+	_oxmbsninnerethsrcmasked := &OxmBsnInnerEthSrcMasked{Oxm: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("OxmBsnInnerEthSrcMasked packet too short: %d < 12", decoder.Length())
+	}
+	_oxmbsninnerethsrcmasked.Value = net.HardwareAddr(decoder.Read(6))
+	_oxmbsninnerethsrcmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+	return _oxmbsninnerethsrcmasked, nil
+}
+
+func NewOxmBsnInnerEthSrcMasked() *OxmBsnInnerEthSrcMasked {
+	obj := &OxmBsnInnerEthSrcMasked{
+		Oxm: NewOxm(208652),
+	}
+	return obj
+}
+func (self *OxmBsnInnerEthSrcMasked) GetOXMName() string {
+	return "bsn_inner_eth_src_masked"
+}
+
+func (self *OxmBsnInnerEthSrcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmBsnInnerEthSrcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmBsnInnerEthSrcMasked) 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 OxmBsnInnerVlanVid struct {
+	*Oxm
+	Value uint16
+}
+
+type IOxmBsnInnerVlanVid interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *OxmBsnInnerVlanVid) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmBsnInnerVlanVid) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmBsnInnerVlanVid) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeOxmBsnInnerVlanVid(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerVlanVid, error) {
+	_oxmbsninnervlanvid := &OxmBsnInnerVlanVid{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmBsnInnerVlanVid packet too short: %d < 2", decoder.Length())
+	}
+	_oxmbsninnervlanvid.Value = uint16(decoder.ReadUint16())
+	return _oxmbsninnervlanvid, nil
+}
+
+func NewOxmBsnInnerVlanVid() *OxmBsnInnerVlanVid {
+	obj := &OxmBsnInnerVlanVid{
+		Oxm: NewOxm(208898),
+	}
+	return obj
+}
+func (self *OxmBsnInnerVlanVid) GetOXMName() string {
+	return "bsn_inner_vlan_vid"
+}
+
+func (self *OxmBsnInnerVlanVid) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmBsnInnerVlanVid) 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 OxmBsnInnerVlanVidMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type IOxmBsnInnerVlanVidMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *OxmBsnInnerVlanVidMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmBsnInnerVlanVidMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmBsnInnerVlanVidMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *OxmBsnInnerVlanVidMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *OxmBsnInnerVlanVidMasked) 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 DecodeOxmBsnInnerVlanVidMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerVlanVidMasked, error) {
+	_oxmbsninnervlanvidmasked := &OxmBsnInnerVlanVidMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmBsnInnerVlanVidMasked packet too short: %d < 4", decoder.Length())
+	}
+	_oxmbsninnervlanvidmasked.Value = uint16(decoder.ReadUint16())
+	_oxmbsninnervlanvidmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _oxmbsninnervlanvidmasked, nil
+}
+
+func NewOxmBsnInnerVlanVidMasked() *OxmBsnInnerVlanVidMasked {
+	obj := &OxmBsnInnerVlanVidMasked{
+		Oxm: NewOxm(209156),
+	}
+	return obj
+}
+func (self *OxmBsnInnerVlanVidMasked) GetOXMName() string {
+	return "bsn_inner_vlan_vid_masked"
+}
+
+func (self *OxmBsnInnerVlanVidMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmBsnInnerVlanVidMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmBsnInnerVlanVidMasked) 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 OxmBsnVfi struct {
+	*Oxm
+	Value uint16
+}
+
+type IOxmBsnVfi interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *OxmBsnVfi) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmBsnVfi) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmBsnVfi) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeOxmBsnVfi(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVfi, error) {
+	_oxmbsnvfi := &OxmBsnVfi{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmBsnVfi packet too short: %d < 2", decoder.Length())
+	}
+	_oxmbsnvfi.Value = uint16(decoder.ReadUint16())
+	return _oxmbsnvfi, nil
+}
+
+func NewOxmBsnVfi() *OxmBsnVfi {
+	obj := &OxmBsnVfi{
+		Oxm: NewOxm(209410),
+	}
+	return obj
+}
+func (self *OxmBsnVfi) GetOXMName() string {
+	return "bsn_vfi"
+}
+
+func (self *OxmBsnVfi) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmBsnVfi) 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 OxmBsnVfiMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type IOxmBsnVfiMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *OxmBsnVfiMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmBsnVfiMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmBsnVfiMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *OxmBsnVfiMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *OxmBsnVfiMasked) 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 DecodeOxmBsnVfiMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVfiMasked, error) {
+	_oxmbsnvfimasked := &OxmBsnVfiMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmBsnVfiMasked packet too short: %d < 4", decoder.Length())
+	}
+	_oxmbsnvfimasked.Value = uint16(decoder.ReadUint16())
+	_oxmbsnvfimasked.ValueMask = uint16(decoder.ReadUint16())
+	return _oxmbsnvfimasked, nil
+}
+
+func NewOxmBsnVfiMasked() *OxmBsnVfiMasked {
+	obj := &OxmBsnVfiMasked{
+		Oxm: NewOxm(209668),
+	}
+	return obj
+}
+func (self *OxmBsnVfiMasked) GetOXMName() string {
+	return "bsn_vfi_masked"
+}
+
+func (self *OxmBsnVfiMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmBsnVfiMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmBsnVfiMasked) 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 OxmBsnVxlanNetworkId struct {
+	*Oxm
+	Value uint32
+}
+
+type IOxmBsnVxlanNetworkId interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *OxmBsnVxlanNetworkId) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *OxmBsnVxlanNetworkId) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *OxmBsnVxlanNetworkId) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeOxmBsnVxlanNetworkId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVxlanNetworkId, error) {
+	_oxmbsnvxlannetworkid := &OxmBsnVxlanNetworkId{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmBsnVxlanNetworkId packet too short: %d < 4", decoder.Length())
+	}
+	_oxmbsnvxlannetworkid.Value = uint32(decoder.ReadUint32())
+	return _oxmbsnvxlannetworkid, nil
+}
+
+func NewOxmBsnVxlanNetworkId() *OxmBsnVxlanNetworkId {
+	obj := &OxmBsnVxlanNetworkId{
+		Oxm: NewOxm(207364),
+	}
+	return obj
+}
+func (self *OxmBsnVxlanNetworkId) GetOXMName() string {
+	return "bsn_vxlan_network_id"
+}
+
+func (self *OxmBsnVxlanNetworkId) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmBsnVxlanNetworkId) 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 OxmBsnVxlanNetworkIdMasked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type IOxmBsnVxlanNetworkIdMasked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *OxmBsnVxlanNetworkIdMasked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *OxmBsnVxlanNetworkIdMasked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *OxmBsnVxlanNetworkIdMasked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *OxmBsnVxlanNetworkIdMasked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *OxmBsnVxlanNetworkIdMasked) 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 DecodeOxmBsnVxlanNetworkIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVxlanNetworkIdMasked, error) {
+	_oxmbsnvxlannetworkidmasked := &OxmBsnVxlanNetworkIdMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("OxmBsnVxlanNetworkIdMasked packet too short: %d < 8", decoder.Length())
+	}
+	_oxmbsnvxlannetworkidmasked.Value = uint32(decoder.ReadUint32())
+	_oxmbsnvxlannetworkidmasked.ValueMask = uint32(decoder.ReadUint32())
+	return _oxmbsnvxlannetworkidmasked, nil
+}
+
+func NewOxmBsnVxlanNetworkIdMasked() *OxmBsnVxlanNetworkIdMasked {
+	obj := &OxmBsnVxlanNetworkIdMasked{
+		Oxm: NewOxm(207624),
+	}
+	return obj
+}
+func (self *OxmBsnVxlanNetworkIdMasked) GetOXMName() string {
+	return "bsn_vxlan_network_id_masked"
+}
+
+func (self *OxmBsnVxlanNetworkIdMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmBsnVxlanNetworkIdMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmBsnVxlanNetworkIdMasked) 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 OxmIpv6Exthdr struct {
+	*Oxm
+	Value uint16
+}
+
+type IOxmIpv6Exthdr interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *OxmIpv6Exthdr) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmIpv6Exthdr) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmIpv6Exthdr) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeOxmIpv6Exthdr(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Exthdr, error) {
+	_oxmipv6exthdr := &OxmIpv6Exthdr{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmIpv6Exthdr packet too short: %d < 2", decoder.Length())
+	}
+	_oxmipv6exthdr.Value = uint16(decoder.ReadUint16())
+	return _oxmipv6exthdr, nil
+}
+
+func NewOxmIpv6Exthdr() *OxmIpv6Exthdr {
+	obj := &OxmIpv6Exthdr{
+		Oxm: NewOxm(2147503618),
+	}
+	return obj
+}
+func (self *OxmIpv6Exthdr) GetOXMName() string {
+	return "ipv6_exthdr"
+}
+
+func (self *OxmIpv6Exthdr) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpv6Exthdr) 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 OxmIpv6ExthdrMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type IOxmIpv6ExthdrMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *OxmIpv6ExthdrMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmIpv6ExthdrMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmIpv6ExthdrMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *OxmIpv6ExthdrMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *OxmIpv6ExthdrMasked) 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 DecodeOxmIpv6ExthdrMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6ExthdrMasked, error) {
+	_oxmipv6exthdrmasked := &OxmIpv6ExthdrMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmIpv6ExthdrMasked packet too short: %d < 4", decoder.Length())
+	}
+	_oxmipv6exthdrmasked.Value = uint16(decoder.ReadUint16())
+	_oxmipv6exthdrmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _oxmipv6exthdrmasked, nil
+}
+
+func NewOxmIpv6ExthdrMasked() *OxmIpv6ExthdrMasked {
+	obj := &OxmIpv6ExthdrMasked{
+		Oxm: NewOxm(2147503876),
+	}
+	return obj
+}
+func (self *OxmIpv6ExthdrMasked) GetOXMName() string {
+	return "ipv6_exthdr_masked"
+}
+
+func (self *OxmIpv6ExthdrMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpv6ExthdrMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmIpv6ExthdrMasked) 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 OxmMplsBos struct {
+	*Oxm
+	Value uint8
+}
+
+type IOxmMplsBos interface {
+	goloxi.IOxm
+	GetValue() uint8
+}
+
+func (self *OxmMplsBos) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *OxmMplsBos) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *OxmMplsBos) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeOxmMplsBos(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsBos, error) {
+	_oxmmplsbos := &OxmMplsBos{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("OxmMplsBos packet too short: %d < 1", decoder.Length())
+	}
+	_oxmmplsbos.Value = uint8(decoder.ReadByte())
+	return _oxmmplsbos, nil
+}
+
+func NewOxmMplsBos() *OxmMplsBos {
+	obj := &OxmMplsBos{
+		Oxm: NewOxm(2147502081),
+	}
+	return obj
+}
+func (self *OxmMplsBos) GetOXMName() string {
+	return "mpls_bos"
+}
+
+func (self *OxmMplsBos) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmMplsBos) 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 OxmMplsBosMasked struct {
+	*Oxm
+	Value     uint8
+	ValueMask uint8
+}
+
+type IOxmMplsBosMasked interface {
+	goloxi.IOxm
+	GetValue() uint8
+	GetValueMask() uint8
+}
+
+func (self *OxmMplsBosMasked) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *OxmMplsBosMasked) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *OxmMplsBosMasked) GetValueMask() uint8 {
+	return self.ValueMask
+}
+
+func (self *OxmMplsBosMasked) SetValueMask(v uint8) {
+	self.ValueMask = v
+}
+
+func (self *OxmMplsBosMasked) 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 DecodeOxmMplsBosMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsBosMasked, error) {
+	_oxmmplsbosmasked := &OxmMplsBosMasked{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmMplsBosMasked packet too short: %d < 2", decoder.Length())
+	}
+	_oxmmplsbosmasked.Value = uint8(decoder.ReadByte())
+	_oxmmplsbosmasked.ValueMask = uint8(decoder.ReadByte())
+	return _oxmmplsbosmasked, nil
+}
+
+func NewOxmMplsBosMasked() *OxmMplsBosMasked {
+	obj := &OxmMplsBosMasked{
+		Oxm: NewOxm(2147502338),
+	}
+	return obj
+}
+func (self *OxmMplsBosMasked) GetOXMName() string {
+	return "mpls_bos_masked"
+}
+
+func (self *OxmMplsBosMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmMplsBosMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmMplsBosMasked) 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 OxmTunnelId struct {
+	*Oxm
+	Value uint64
+}
+
+type IOxmTunnelId interface {
+	goloxi.IOxm
+	GetValue() uint64
+}
+
+func (self *OxmTunnelId) GetValue() uint64 {
+	return self.Value
+}
+
+func (self *OxmTunnelId) SetValue(v uint64) {
+	self.Value = v
+}
+
+func (self *OxmTunnelId) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint64(uint64(self.Value))
+
+	return nil
+}
+
+func DecodeOxmTunnelId(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelId, error) {
+	_oxmtunnelid := &OxmTunnelId{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("OxmTunnelId packet too short: %d < 8", decoder.Length())
+	}
+	_oxmtunnelid.Value = uint64(decoder.ReadUint64())
+	return _oxmtunnelid, nil
+}
+
+func NewOxmTunnelId() *OxmTunnelId {
+	obj := &OxmTunnelId{
+		Oxm: NewOxm(2147503112),
+	}
+	return obj
+}
+func (self *OxmTunnelId) GetOXMName() string {
+	return "tunnel_id"
+}
+
+func (self *OxmTunnelId) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmTunnelId) 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 OxmTunnelIdMasked struct {
+	*Oxm
+	Value     uint64
+	ValueMask uint64
+}
+
+type IOxmTunnelIdMasked interface {
+	goloxi.IOxm
+	GetValue() uint64
+	GetValueMask() uint64
+}
+
+func (self *OxmTunnelIdMasked) GetValue() uint64 {
+	return self.Value
+}
+
+func (self *OxmTunnelIdMasked) SetValue(v uint64) {
+	self.Value = v
+}
+
+func (self *OxmTunnelIdMasked) GetValueMask() uint64 {
+	return self.ValueMask
+}
+
+func (self *OxmTunnelIdMasked) SetValueMask(v uint64) {
+	self.ValueMask = v
+}
+
+func (self *OxmTunnelIdMasked) 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 DecodeOxmTunnelIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIdMasked, error) {
+	_oxmtunnelidmasked := &OxmTunnelIdMasked{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("OxmTunnelIdMasked packet too short: %d < 16", decoder.Length())
+	}
+	_oxmtunnelidmasked.Value = uint64(decoder.ReadUint64())
+	_oxmtunnelidmasked.ValueMask = uint64(decoder.ReadUint64())
+	return _oxmtunnelidmasked, nil
+}
+
+func NewOxmTunnelIdMasked() *OxmTunnelIdMasked {
+	obj := &OxmTunnelIdMasked{
+		Oxm: NewOxm(2147503376),
+	}
+	return obj
+}
+func (self *OxmTunnelIdMasked) GetOXMName() string {
+	return "tunnel_id_masked"
+}
+
+func (self *OxmTunnelIdMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmTunnelIdMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmTunnelIdMasked) 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
+}