diff --git a/grpc.go b/grpc.go
index 6fc7bef1b2..8a0dffddc6 100644
--- a/grpc.go
+++ b/grpc.go
@@ -1571,6 +1571,10 @@ func (a *agentGRPC) ListRoutes(ctx context.Context, req *pb.ListRoutesRequest) (
 	return a.sandbox.listRoutes(nil)
 }
 
+func (a *agentGRPC) AddARPNeighbors(ctx context.Context, req *pb.AddARPNeighborsRequest) (*gpb.Empty, error) {
+	return emptyResp, a.sandbox.addARPNeighbors(nil, req.Neighbors)
+}
+
 func (a *agentGRPC) OnlineCPUMem(ctx context.Context, req *pb.OnlineCPUMemRequest) (*gpb.Empty, error) {
 	if !req.Wait {
 		go a.onlineCPUMem(req)
diff --git a/network.go b/network.go
index 64a16a99c3..59b93d572b 100644
--- a/network.go
+++ b/network.go
@@ -32,6 +32,7 @@ var (
 	errNoLink               = grpcStatus.Errorf(codes.InvalidArgument, "Need network link")
 	errNoMAC                = grpcStatus.Errorf(codes.InvalidArgument, "Need hardware address")
 	errNoRoutes             = grpcStatus.Errorf(codes.InvalidArgument, "Need network routes")
+	errNoNeighbors          = grpcStatus.Errorf(codes.InvalidArgument, "Need ARP neighbors")
 	guestDNSFile            = "/etc/resolv.conf"
 	kataGuestSandboxDNSFile = "/run/kata-containers/sandbox/resolv.conf"
 )
@@ -625,6 +626,61 @@ func (s *sandbox) updateRoute(netHandle *netlink.Handle, route *types.Route, add
 	return nil
 }
 
+// addARPNeighbors will take neighbors and add them to ARP entries.
+// This is used to mirror any static arp entries created by the network
+// plugin in the network namespace on the host side.
+func (s *sandbox) addARPNeighbors(netHandle *netlink.Handle, requestedNeighbors *pb.ARPNeighbors) error {
+	if requestedNeighbors == nil {
+		return errNoNeighbors
+	}
+
+	var err error
+	if netHandle == nil {
+		netHandle, err = netlink.NewHandle(unix.NETLINK_ROUTE)
+		if err != nil {
+			return err
+		}
+		defer netHandle.Delete()
+	}
+
+	for _, neighbor := range requestedNeighbors.ARPNeighbors {
+		// Find link index from route's device name.
+		link, err := netHandle.LinkByName(neighbor.Device)
+		if err != nil {
+			return grpcStatus.Errorf(codes.Internal, "Could not find link from device %s: %v", neighbor.Device, err)
+		}
+
+		toIP := net.ParseIP(neighbor.ToIPAddress.Address)
+		if toIP == nil {
+			return grpcStatus.Errorf(codes.Internal, "Invalid To IP address %s for device  %s", neighbor.ToIPAddress.Address, neighbor.Device)
+		}
+
+		var mac net.HardwareAddr
+		if neighbor.Lladdr != "" {
+			mac, err = net.ParseMAC(neighbor.Lladdr)
+			if err != nil {
+				return grpcStatus.Errorf(codes.Internal, "Invalid hardware address %s for device  %s: %v", neighbor.Lladdr, neighbor.Device, err)
+			}
+		}
+
+		neigh := netlink.Neigh{
+			LinkIndex:    link.Attrs().Index,
+			HardwareAddr: mac,
+			State:        int(neighbor.State),
+			IP:           toIP,
+			Flags:        int(neighbor.Flags),
+		}
+
+		err = netHandle.NeighAdd(&neigh)
+		if err != nil {
+			return grpcStatus.Errorf(codes.Internal, "Could not add ARP neighbor %+v: %v", neighbor, err)
+		}
+
+	}
+
+	return nil
+}
+
 /////////
 // DNS //
 /////////
diff --git a/network_test.go b/network_test.go
index a143670b3d..a2d2d3bb19 100644
--- a/network_test.go
+++ b/network_test.go
@@ -557,3 +557,71 @@ func TestSetupDNS(t *testing.T) {
 	expectedDNS := strings.Split(string(content), "\n")
 	assert.Equal(t, dns, expectedDNS)
 }
+
+func TestAddARPNeighbors(t *testing.T) {
+	skipUnlessRoot(t)
+
+	tearDown := setupNetworkTest(t)
+	defer tearDown()
+
+	s := sandbox{}
+
+	// create a dummy link which we'll play with
+	macAddr := net.HardwareAddr{0x02, 0x00, 0xCA, 0xFE, 0x00, 0x48}
+	link := &netlink.Dummy{
+		LinkAttrs: netlink.LinkAttrs{
+			MTU:          1500,
+			TxQLen:       -1,
+			Name:         "ifc-name",
+			HardwareAddr: macAddr,
+		},
+	}
+	netHandle, _ := netlink.NewHandle()
+	defer netHandle.Delete()
+
+	netHandle.LinkAdd(link)
+	if err := netHandle.LinkSetUp(link); err != nil {
+		t.Fatal(err)
+	}
+
+	netlinkAddr, _ := netlink.ParseAddr("192.168.0.2/16")
+	netHandle.AddrAdd(link, netlinkAddr)
+
+	mac := "6a:92:3a:59:70:aa"
+	toIP := "169.254.1.1"
+	neighbors := []*types.ARPNeighbor{
+		{
+			Device:      "ifc-name",
+			Lladdr:      mac,
+			ToIPAddress: &types.IPAddress{Address: toIP},
+			State:       netlink.NUD_PERMANENT,
+		},
+	}
+
+	testNeighbors := &pb.ARPNeighbors{
+		ARPNeighbors: neighbors,
+	}
+
+	err := s.addARPNeighbors(netHandle, testNeighbors)
+	assert.Nil(t, err, "Unexpected add neighbors failure: %v", err)
+
+	addedLink, err := netlink.LinkByName(link.Name)
+	assert.Nil(t, err)
+
+	dump, err := netlink.NeighList(addedLink.Attrs().Index, 0)
+	if err != nil {
+		t.Errorf("Failed to NeighList: %v", err)
+	}
+
+	neighFound := false
+	for _, n := range dump {
+		if n.IP.Equal(net.ParseIP(toIP)) && (n.State&netlink.NUD_INCOMPLETE) == 0 && n.HardwareAddr.String() == mac {
+			neighFound = true
+		}
+	}
+
+	if !neighFound {
+		t.Errorf("Failed to find neighbour after AddARPNeighbor()")
+	}
+
+}
diff --git a/pkg/types/types.pb.go b/pkg/types/types.pb.go
index 7ea63e3c0e..a7948049e4 100644
--- a/pkg/types/types.pb.go
+++ b/pkg/types/types.pb.go
@@ -11,6 +11,7 @@
 		IPAddress
 		Interface
 		Route
+		ARPNeighbor
 */
 package types
 
@@ -211,10 +212,59 @@ func (m *Route) GetScope() uint32 {
 	return 0
 }
 
+type ARPNeighbor struct {
+	ToIPAddress *IPAddress `protobuf:"bytes,1,opt,name=toIPAddress" json:"toIPAddress,omitempty"`
+	Device      string     `protobuf:"bytes,2,opt,name=device,proto3" json:"device,omitempty"`
+	Lladdr      string     `protobuf:"bytes,3,opt,name=lladdr,proto3" json:"lladdr,omitempty"`
+	State       int32      `protobuf:"varint,4,opt,name=state,proto3" json:"state,omitempty"`
+	Flags       int32      `protobuf:"varint,5,opt,name=flags,proto3" json:"flags,omitempty"`
+}
+
+func (m *ARPNeighbor) Reset()                    { *m = ARPNeighbor{} }
+func (m *ARPNeighbor) String() string            { return proto.CompactTextString(m) }
+func (*ARPNeighbor) ProtoMessage()               {}
+func (*ARPNeighbor) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{3} }
+
+func (m *ARPNeighbor) GetToIPAddress() *IPAddress {
+	if m != nil {
+		return m.ToIPAddress
+	}
+	return nil
+}
+
+func (m *ARPNeighbor) GetDevice() string {
+	if m != nil {
+		return m.Device
+	}
+	return ""
+}
+
+func (m *ARPNeighbor) GetLladdr() string {
+	if m != nil {
+		return m.Lladdr
+	}
+	return ""
+}
+
+func (m *ARPNeighbor) GetState() int32 {
+	if m != nil {
+		return m.State
+	}
+	return 0
+}
+
+func (m *ARPNeighbor) GetFlags() int32 {
+	if m != nil {
+		return m.Flags
+	}
+	return 0
+}
+
 func init() {
 	proto.RegisterType((*IPAddress)(nil), "types.IPAddress")
 	proto.RegisterType((*Interface)(nil), "types.Interface")
 	proto.RegisterType((*Route)(nil), "types.Route")
+	proto.RegisterType((*ARPNeighbor)(nil), "types.ARPNeighbor")
 	proto.RegisterEnum("types.IPFamily", IPFamily_name, IPFamily_value)
 }
 func (m *IPAddress) Marshal() (dAtA []byte, err error) {
@@ -369,6 +419,56 @@ func (m *Route) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
+func (m *ARPNeighbor) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ARPNeighbor) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.ToIPAddress != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintTypes(dAtA, i, uint64(m.ToIPAddress.Size()))
+		n1, err := m.ToIPAddress.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n1
+	}
+	if len(m.Device) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Device)))
+		i += copy(dAtA[i:], m.Device)
+	}
+	if len(m.Lladdr) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Lladdr)))
+		i += copy(dAtA[i:], m.Lladdr)
+	}
+	if m.State != 0 {
+		dAtA[i] = 0x20
+		i++
+		i = encodeVarintTypes(dAtA, i, uint64(m.State))
+	}
+	if m.Flags != 0 {
+		dAtA[i] = 0x28
+		i++
+		i = encodeVarintTypes(dAtA, i, uint64(m.Flags))
+	}
+	return i, nil
+}
+
 func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -458,6 +558,30 @@ func (m *Route) Size() (n int) {
 	return n
 }
 
+func (m *ARPNeighbor) Size() (n int) {
+	var l int
+	_ = l
+	if m.ToIPAddress != nil {
+		l = m.ToIPAddress.Size()
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	l = len(m.Device)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	l = len(m.Lladdr)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	if m.State != 0 {
+		n += 1 + sovTypes(uint64(m.State))
+	}
+	if m.Flags != 0 {
+		n += 1 + sovTypes(uint64(m.Flags))
+	}
+	return n
+}
+
 func sovTypes(x uint64) (n int) {
 	for {
 		n++
@@ -1047,6 +1171,185 @@ func (m *Route) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *ARPNeighbor) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTypes
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ARPNeighbor: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ARPNeighbor: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ToIPAddress", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.ToIPAddress == nil {
+				m.ToIPAddress = &IPAddress{}
+			}
+			if err := m.ToIPAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Device", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Device = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Lladdr", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Lladdr = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
+			}
+			m.State = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.State |= (int32(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Flags", wireType)
+			}
+			m.Flags = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Flags |= (int32(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTypes(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipTypes(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
@@ -1155,27 +1458,31 @@ var (
 func init() { proto.RegisterFile("pkg/types/types.proto", fileDescriptorTypes) }
 
 var fileDescriptorTypes = []byte{
-	// 345 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x91, 0xd1, 0x6a, 0xfa, 0x30,
-	0x14, 0xc6, 0xff, 0xb1, 0xb6, 0xda, 0xe3, 0xdf, 0xad, 0x84, 0x4d, 0xc2, 0x06, 0x52, 0xbc, 0x59,
-	0xd9, 0x85, 0x03, 0x37, 0x76, 0xbf, 0x5d, 0x08, 0xde, 0x49, 0x5e, 0x60, 0xc4, 0x36, 0x3a, 0xd1,
-	0xda, 0xd2, 0x44, 0x8b, 0xec, 0x05, 0x77, 0xb9, 0x47, 0x10, 0x9f, 0x64, 0xe4, 0x24, 0x8a, 0xbb,
-	0xd1, 0xef, 0x97, 0x93, 0xd3, 0xef, 0x7c, 0x27, 0x70, 0x5b, 0xae, 0x16, 0x4f, 0x7a, 0x5f, 0x4a,
-	0x65, 0x7f, 0x87, 0x65, 0x55, 0xe8, 0x82, 0xfa, 0x08, 0x83, 0x19, 0x84, 0x93, 0xe9, 0x5b, 0x96,
-	0x55, 0x52, 0x29, 0xfa, 0x00, 0xc1, 0x5c, 0xe4, 0xcb, 0xf5, 0x9e, 0x91, 0x98, 0x24, 0x57, 0xa3,
-	0xeb, 0xa1, 0xed, 0x98, 0x4c, 0xc7, 0x78, 0xcc, 0x5d, 0x99, 0x32, 0x68, 0x09, 0xdb, 0xc3, 0x1a,
-	0x31, 0x49, 0x42, 0x7e, 0x42, 0x4a, 0xa1, 0x99, 0x0b, 0xb5, 0x62, 0x1e, 0x1e, 0xa3, 0x1e, 0x1c,
-	0x08, 0x84, 0x93, 0x8d, 0x96, 0xd5, 0x5c, 0xa4, 0x92, 0xf6, 0x20, 0xc8, 0xe4, 0x6e, 0x99, 0x4a,
-	0x34, 0x09, 0xb9, 0x23, 0xd3, 0xb9, 0x11, 0xb9, 0x74, 0x1f, 0x44, 0x4d, 0x47, 0xd0, 0x39, 0x4f,
-	0x27, 0x15, 0xf3, 0x62, 0x2f, 0xe9, 0x8c, 0xa2, 0xf3, 0x54, 0xae, 0xc2, 0x2f, 0x2f, 0xd1, 0x08,
-	0xbc, 0x5c, 0x6f, 0x59, 0x33, 0x26, 0x49, 0x93, 0x1b, 0x69, 0x1c, 0x3f, 0x6b, 0x73, 0x81, 0xf9,
-	0xd6, 0xd1, 0x92, 0x49, 0x51, 0xa6, 0x4b, 0x2c, 0x04, 0x36, 0x85, 0x43, 0x33, 0x8b, 0xf1, 0x60,
-	0x2d, 0x3b, 0x8b, 0xd1, 0xf4, 0x1e, 0xc2, 0x4a, 0xd4, 0x1f, 0xf3, 0xb5, 0x58, 0x28, 0xd6, 0x8e,
-	0x49, 0xd2, 0xe5, 0xed, 0x4a, 0xd4, 0x63, 0xc3, 0x83, 0x2f, 0xf0, 0x79, 0xb1, 0xd5, 0x98, 0x22,
-	0x93, 0x4a, 0xbb, 0x6c, 0xa8, 0x8d, 0xcf, 0x42, 0x68, 0x59, 0x8b, 0xfd, 0x69, 0x5b, 0x0e, 0x2f,
-	0x76, 0xe1, 0xfd, 0xd9, 0x45, 0x0f, 0x02, 0x55, 0x6c, 0xab, 0x54, 0x62, 0x8c, 0x90, 0x3b, 0xa2,
-	0x37, 0xe0, 0xab, 0xb4, 0x28, 0x25, 0x06, 0xe9, 0x72, 0x0b, 0x8f, 0x77, 0xd0, 0x3e, 0xbd, 0x10,
-	0x0d, 0xa0, 0xb1, 0x7b, 0x89, 0xfe, 0xe1, 0xff, 0x6b, 0x44, 0xde, 0xff, 0x7f, 0x1f, 0xfb, 0xe4,
-	0xe7, 0xd8, 0x27, 0x87, 0x63, 0x9f, 0xcc, 0x02, 0x7c, 0xfb, 0xe7, 0xdf, 0x00, 0x00, 0x00, 0xff,
-	0xff, 0xb5, 0x52, 0x37, 0xf2, 0x14, 0x02, 0x00, 0x00,
+	// 404 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x92, 0x41, 0x8a, 0xdb, 0x30,
+	0x14, 0x86, 0xab, 0x38, 0xf6, 0xc4, 0x2f, 0x9d, 0xd6, 0x88, 0x76, 0x10, 0x2d, 0x04, 0xe3, 0x4d,
+	0x4d, 0x17, 0x53, 0x48, 0x4b, 0xf7, 0xd3, 0xc5, 0x40, 0x36, 0x25, 0xe8, 0x02, 0x45, 0xb1, 0x15,
+	0x8f, 0x89, 0x1d, 0x1b, 0x4b, 0x89, 0x09, 0x3d, 0x4b, 0xef, 0xd3, 0x65, 0x8f, 0x10, 0x72, 0x92,
+	0xa2, 0x27, 0x39, 0xb8, 0x65, 0x36, 0xf6, 0xfb, 0x9e, 0x24, 0xbf, 0xff, 0xff, 0x2d, 0x78, 0xdb,
+	0xee, 0x8a, 0x4f, 0xfa, 0xd4, 0x4a, 0x65, 0x9f, 0xf7, 0x6d, 0xd7, 0xe8, 0x86, 0xfa, 0x08, 0xc9,
+	0x06, 0xc2, 0xd5, 0xfa, 0x21, 0xcf, 0x3b, 0xa9, 0x14, 0xfd, 0x00, 0xc1, 0x56, 0xd4, 0x65, 0x75,
+	0x62, 0x24, 0x26, 0xe9, 0xab, 0xe5, 0xeb, 0x7b, 0x7b, 0x62, 0xb5, 0x7e, 0xc4, 0x36, 0x77, 0xcb,
+	0x94, 0xc1, 0x8d, 0xb0, 0x67, 0xd8, 0x24, 0x26, 0x69, 0xc8, 0x07, 0xa4, 0x14, 0xa6, 0xb5, 0x50,
+	0x3b, 0xe6, 0x61, 0x1b, 0xeb, 0xe4, 0x4c, 0x20, 0x5c, 0xed, 0xb5, 0xec, 0xb6, 0x22, 0x93, 0xf4,
+	0x0e, 0x82, 0x5c, 0x1e, 0xcb, 0x4c, 0xe2, 0x90, 0x90, 0x3b, 0x32, 0x27, 0xf7, 0xa2, 0x96, 0xee,
+	0x83, 0x58, 0xd3, 0x25, 0xcc, 0xaf, 0xea, 0xa4, 0x62, 0x5e, 0xec, 0xa5, 0xf3, 0x65, 0x74, 0x55,
+	0xe5, 0x56, 0xf8, 0x78, 0x13, 0x8d, 0xc0, 0xab, 0xf5, 0x81, 0x4d, 0x63, 0x92, 0x4e, 0xb9, 0x29,
+	0xcd, 0xc4, 0xa7, 0xde, 0x6c, 0x60, 0xbe, 0x9d, 0x68, 0xc9, 0xb8, 0x68, 0xb3, 0x12, 0x17, 0x02,
+	0xeb, 0xc2, 0xa1, 0xd1, 0x62, 0x66, 0xb0, 0x1b, 0xab, 0xc5, 0xd4, 0xf4, 0x3d, 0x84, 0x9d, 0xe8,
+	0x7f, 0x6c, 0x2b, 0x51, 0x28, 0x36, 0x8b, 0x49, 0x7a, 0xcb, 0x67, 0x9d, 0xe8, 0x1f, 0x0d, 0x27,
+	0x3f, 0xc1, 0xe7, 0xcd, 0x41, 0xa3, 0x8b, 0x5c, 0x2a, 0xed, 0xbc, 0x61, 0x6d, 0xe6, 0x14, 0x42,
+	0xcb, 0x5e, 0x9c, 0x86, 0xb4, 0x1c, 0x8e, 0xb2, 0xf0, 0xfe, 0xc9, 0xe2, 0x0e, 0x02, 0xd5, 0x1c,
+	0xba, 0x4c, 0xa2, 0x8d, 0x90, 0x3b, 0xa2, 0x6f, 0xc0, 0x57, 0x59, 0xd3, 0x4a, 0x34, 0x72, 0xcb,
+	0x2d, 0x24, 0xbf, 0x08, 0xcc, 0x1f, 0xf8, 0xfa, 0xbb, 0x2c, 0x8b, 0xa7, 0x4d, 0xd3, 0x99, 0xd4,
+	0x74, 0x73, 0x8d, 0x04, 0xa5, 0x3c, 0x9b, 0xda, 0x68, 0xd3, 0x48, 0xc9, 0xe4, 0x7f, 0x25, 0x55,
+	0x65, 0x7e, 0xee, 0xa0, 0xd0, 0x12, 0x2a, 0xd1, 0x42, 0x5b, 0x81, 0x3e, 0xb7, 0x60, 0xba, 0x36,
+	0x1f, 0xdf, 0x76, 0x11, 0x3e, 0xbe, 0x83, 0xd9, 0x70, 0x83, 0x68, 0x00, 0x93, 0xe3, 0x97, 0xe8,
+	0x05, 0xbe, 0xbf, 0x46, 0xe4, 0xdb, 0xcb, 0xdf, 0x97, 0x05, 0xf9, 0x73, 0x59, 0x90, 0xf3, 0x65,
+	0x41, 0x36, 0x01, 0xde, 0xcd, 0xcf, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x99, 0x41, 0x3b, 0x8d,
+	0xb4, 0x02, 0x00, 0x00,
 }
diff --git a/pkg/types/types.proto b/pkg/types/types.proto
index f6856e1e32..5a1cf65576 100644
--- a/pkg/types/types.proto
+++ b/pkg/types/types.proto
@@ -46,3 +46,12 @@ message Route {
 	string source = 4;
 	uint32 scope = 5;
 }
+
+message ARPNeighbor {
+	IPAddress toIPAddress = 1;
+	string device = 2;
+	string lladdr = 3;
+	int32 state = 4;
+	int32 flags = 5;
+}
+
diff --git a/protocols/grpc/agent.pb.go b/protocols/grpc/agent.pb.go
index bf48f7407f..9d036d60f9 100644
--- a/protocols/grpc/agent.pb.go
+++ b/protocols/grpc/agent.pb.go
@@ -50,6 +50,8 @@
 		UpdateRoutesRequest
 		ListInterfacesRequest
 		ListRoutesRequest
+		ARPNeighbors
+		AddARPNeighborsRequest
 		OnlineCPUMemRequest
 		ReseedRandomDevRequest
 		AgentDetails
@@ -108,8 +110,10 @@ import math "math"
 import types "github.com/kata-containers/agent/pkg/types"
 import google_protobuf2 "github.com/gogo/protobuf/types"
 
-import context "golang.org/x/net/context"
-import grpc1 "google.golang.org/grpc"
+import (
+	context "golang.org/x/net/context"
+	grpc1 "google.golang.org/grpc"
+)
 
 import io "io"
 
@@ -1336,6 +1340,38 @@ func (m *ListRoutesRequest) String() string            { return proto.CompactTex
 func (*ListRoutesRequest) ProtoMessage()               {}
 func (*ListRoutesRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{39} }
 
+type ARPNeighbors struct {
+	ARPNeighbors []*types.ARPNeighbor `protobuf:"bytes,1,rep,name=ARPNeighbors" json:"ARPNeighbors,omitempty"`
+}
+
+func (m *ARPNeighbors) Reset()                    { *m = ARPNeighbors{} }
+func (m *ARPNeighbors) String() string            { return proto.CompactTextString(m) }
+func (*ARPNeighbors) ProtoMessage()               {}
+func (*ARPNeighbors) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{40} }
+
+func (m *ARPNeighbors) GetARPNeighbors() []*types.ARPNeighbor {
+	if m != nil {
+		return m.ARPNeighbors
+	}
+	return nil
+}
+
+type AddARPNeighborsRequest struct {
+	Neighbors *ARPNeighbors `protobuf:"bytes,1,opt,name=neighbors" json:"neighbors,omitempty"`
+}
+
+func (m *AddARPNeighborsRequest) Reset()                    { *m = AddARPNeighborsRequest{} }
+func (m *AddARPNeighborsRequest) String() string            { return proto.CompactTextString(m) }
+func (*AddARPNeighborsRequest) ProtoMessage()               {}
+func (*AddARPNeighborsRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{41} }
+
+func (m *AddARPNeighborsRequest) GetNeighbors() *ARPNeighbors {
+	if m != nil {
+		return m.Neighbors
+	}
+	return nil
+}
+
 type OnlineCPUMemRequest struct {
 	// Wait specifies if the caller waits for the agent to online all resources.
 	// If true the agent returns once all resources have been connected, otherwise all
@@ -1350,7 +1386,7 @@ type OnlineCPUMemRequest struct {
 func (m *OnlineCPUMemRequest) Reset()                    { *m = OnlineCPUMemRequest{} }
 func (m *OnlineCPUMemRequest) String() string            { return proto.CompactTextString(m) }
 func (*OnlineCPUMemRequest) ProtoMessage()               {}
-func (*OnlineCPUMemRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{40} }
+func (*OnlineCPUMemRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{42} }
 
 func (m *OnlineCPUMemRequest) GetWait() bool {
 	if m != nil {
@@ -1381,7 +1417,7 @@ type ReseedRandomDevRequest struct {
 func (m *ReseedRandomDevRequest) Reset()                    { *m = ReseedRandomDevRequest{} }
 func (m *ReseedRandomDevRequest) String() string            { return proto.CompactTextString(m) }
 func (*ReseedRandomDevRequest) ProtoMessage()               {}
-func (*ReseedRandomDevRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{41} }
+func (*ReseedRandomDevRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{43} }
 
 func (m *ReseedRandomDevRequest) GetData() []byte {
 	if m != nil {
@@ -1408,7 +1444,7 @@ type AgentDetails struct {
 func (m *AgentDetails) Reset()                    { *m = AgentDetails{} }
 func (m *AgentDetails) String() string            { return proto.CompactTextString(m) }
 func (*AgentDetails) ProtoMessage()               {}
-func (*AgentDetails) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{42} }
+func (*AgentDetails) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{44} }
 
 func (m *AgentDetails) GetVersion() string {
 	if m != nil {
@@ -1459,7 +1495,7 @@ type GuestDetailsRequest struct {
 func (m *GuestDetailsRequest) Reset()                    { *m = GuestDetailsRequest{} }
 func (m *GuestDetailsRequest) String() string            { return proto.CompactTextString(m) }
 func (*GuestDetailsRequest) ProtoMessage()               {}
-func (*GuestDetailsRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{43} }
+func (*GuestDetailsRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{45} }
 
 func (m *GuestDetailsRequest) GetMemBlockSize() bool {
 	if m != nil {
@@ -1485,7 +1521,7 @@ type GuestDetailsResponse struct {
 func (m *GuestDetailsResponse) Reset()                    { *m = GuestDetailsResponse{} }
 func (m *GuestDetailsResponse) String() string            { return proto.CompactTextString(m) }
 func (*GuestDetailsResponse) ProtoMessage()               {}
-func (*GuestDetailsResponse) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{44} }
+func (*GuestDetailsResponse) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{46} }
 
 func (m *GuestDetailsResponse) GetMemBlockSizeBytes() uint64 {
 	if m != nil {
@@ -1517,7 +1553,7 @@ type MemHotplugByProbeRequest struct {
 func (m *MemHotplugByProbeRequest) Reset()                    { *m = MemHotplugByProbeRequest{} }
 func (m *MemHotplugByProbeRequest) String() string            { return proto.CompactTextString(m) }
 func (*MemHotplugByProbeRequest) ProtoMessage()               {}
-func (*MemHotplugByProbeRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{45} }
+func (*MemHotplugByProbeRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{47} }
 
 func (m *MemHotplugByProbeRequest) GetMemHotplugProbeAddr() []uint64 {
 	if m != nil {
@@ -1536,7 +1572,7 @@ type SetGuestDateTimeRequest struct {
 func (m *SetGuestDateTimeRequest) Reset()                    { *m = SetGuestDateTimeRequest{} }
 func (m *SetGuestDateTimeRequest) String() string            { return proto.CompactTextString(m) }
 func (*SetGuestDateTimeRequest) ProtoMessage()               {}
-func (*SetGuestDateTimeRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{46} }
+func (*SetGuestDateTimeRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{48} }
 
 func (m *SetGuestDateTimeRequest) GetSec() int64 {
 	if m != nil {
@@ -1585,7 +1621,7 @@ type Storage struct {
 func (m *Storage) Reset()                    { *m = Storage{} }
 func (m *Storage) String() string            { return proto.CompactTextString(m) }
 func (*Storage) ProtoMessage()               {}
-func (*Storage) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{47} }
+func (*Storage) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{49} }
 
 func (m *Storage) GetDriver() string {
 	if m != nil {
@@ -1668,7 +1704,7 @@ type Device struct {
 func (m *Device) Reset()                    { *m = Device{} }
 func (m *Device) String() string            { return proto.CompactTextString(m) }
 func (*Device) ProtoMessage()               {}
-func (*Device) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{48} }
+func (*Device) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{50} }
 
 func (m *Device) GetId() string {
 	if m != nil {
@@ -1714,7 +1750,7 @@ type StringUser struct {
 func (m *StringUser) Reset()                    { *m = StringUser{} }
 func (m *StringUser) String() string            { return proto.CompactTextString(m) }
 func (*StringUser) ProtoMessage()               {}
-func (*StringUser) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{49} }
+func (*StringUser) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{51} }
 
 func (m *StringUser) GetUid() string {
 	if m != nil {
@@ -1762,7 +1798,7 @@ type CopyFileRequest struct {
 func (m *CopyFileRequest) Reset()                    { *m = CopyFileRequest{} }
 func (m *CopyFileRequest) String() string            { return proto.CompactTextString(m) }
 func (*CopyFileRequest) ProtoMessage()               {}
-func (*CopyFileRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{50} }
+func (*CopyFileRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{52} }
 
 func (m *CopyFileRequest) GetPath() string {
 	if m != nil {
@@ -1826,7 +1862,7 @@ type StartTracingRequest struct {
 func (m *StartTracingRequest) Reset()                    { *m = StartTracingRequest{} }
 func (m *StartTracingRequest) String() string            { return proto.CompactTextString(m) }
 func (*StartTracingRequest) ProtoMessage()               {}
-func (*StartTracingRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{51} }
+func (*StartTracingRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{53} }
 
 type StopTracingRequest struct {
 }
@@ -1834,7 +1870,7 @@ type StopTracingRequest struct {
 func (m *StopTracingRequest) Reset()                    { *m = StopTracingRequest{} }
 func (m *StopTracingRequest) String() string            { return proto.CompactTextString(m) }
 func (*StopTracingRequest) ProtoMessage()               {}
-func (*StopTracingRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{52} }
+func (*StopTracingRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{54} }
 
 type GetOOMEventRequest struct {
 }
@@ -1842,7 +1878,7 @@ type GetOOMEventRequest struct {
 func (m *GetOOMEventRequest) Reset()                    { *m = GetOOMEventRequest{} }
 func (m *GetOOMEventRequest) String() string            { return proto.CompactTextString(m) }
 func (*GetOOMEventRequest) ProtoMessage()               {}
-func (*GetOOMEventRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{53} }
+func (*GetOOMEventRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{55} }
 
 type OOMEvent struct {
 	ContainerId string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
@@ -1851,7 +1887,7 @@ type OOMEvent struct {
 func (m *OOMEvent) Reset()                    { *m = OOMEvent{} }
 func (m *OOMEvent) String() string            { return proto.CompactTextString(m) }
 func (*OOMEvent) ProtoMessage()               {}
-func (*OOMEvent) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{54} }
+func (*OOMEvent) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{56} }
 
 func (m *OOMEvent) GetContainerId() string {
 	if m != nil {
@@ -1901,6 +1937,8 @@ func init() {
 	proto.RegisterType((*UpdateRoutesRequest)(nil), "grpc.UpdateRoutesRequest")
 	proto.RegisterType((*ListInterfacesRequest)(nil), "grpc.ListInterfacesRequest")
 	proto.RegisterType((*ListRoutesRequest)(nil), "grpc.ListRoutesRequest")
+	proto.RegisterType((*ARPNeighbors)(nil), "grpc.ARPNeighbors")
+	proto.RegisterType((*AddARPNeighborsRequest)(nil), "grpc.AddARPNeighborsRequest")
 	proto.RegisterType((*OnlineCPUMemRequest)(nil), "grpc.OnlineCPUMemRequest")
 	proto.RegisterType((*ReseedRandomDevRequest)(nil), "grpc.ReseedRandomDevRequest")
 	proto.RegisterType((*AgentDetails)(nil), "grpc.AgentDetails")
@@ -1958,6 +1996,7 @@ type AgentServiceClient interface {
 	UpdateRoutes(ctx context.Context, in *UpdateRoutesRequest, opts ...grpc1.CallOption) (*Routes, error)
 	ListInterfaces(ctx context.Context, in *ListInterfacesRequest, opts ...grpc1.CallOption) (*Interfaces, error)
 	ListRoutes(ctx context.Context, in *ListRoutesRequest, opts ...grpc1.CallOption) (*Routes, error)
+	AddARPNeighbors(ctx context.Context, in *AddARPNeighborsRequest, opts ...grpc1.CallOption) (*google_protobuf2.Empty, error)
 	// tracing
 	StartTracing(ctx context.Context, in *StartTracingRequest, opts ...grpc1.CallOption) (*google_protobuf2.Empty, error)
 	StopTracing(ctx context.Context, in *StopTracingRequest, opts ...grpc1.CallOption) (*google_protobuf2.Empty, error)
@@ -2161,6 +2200,15 @@ func (c *agentServiceClient) ListRoutes(ctx context.Context, in *ListRoutesReque
 	return out, nil
 }
 
+func (c *agentServiceClient) AddARPNeighbors(ctx context.Context, in *AddARPNeighborsRequest, opts ...grpc1.CallOption) (*google_protobuf2.Empty, error) {
+	out := new(google_protobuf2.Empty)
+	err := grpc1.Invoke(ctx, "/grpc.AgentService/AddARPNeighbors", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *agentServiceClient) StartTracing(ctx context.Context, in *StartTracingRequest, opts ...grpc1.CallOption) (*google_protobuf2.Empty, error) {
 	out := new(google_protobuf2.Empty)
 	err := grpc1.Invoke(ctx, "/grpc.AgentService/StartTracing", in, out, c.cc, opts...)
@@ -2292,6 +2340,7 @@ type AgentServiceServer interface {
 	UpdateRoutes(context.Context, *UpdateRoutesRequest) (*Routes, error)
 	ListInterfaces(context.Context, *ListInterfacesRequest) (*Interfaces, error)
 	ListRoutes(context.Context, *ListRoutesRequest) (*Routes, error)
+	AddARPNeighbors(context.Context, *AddARPNeighborsRequest) (*google_protobuf2.Empty, error)
 	// tracing
 	StartTracing(context.Context, *StartTracingRequest) (*google_protobuf2.Empty, error)
 	StopTracing(context.Context, *StopTracingRequest) (*google_protobuf2.Empty, error)
@@ -2671,6 +2720,24 @@ func _AgentService_ListRoutes_Handler(srv interface{}, ctx context.Context, dec
 	return interceptor(ctx, in, info, handler)
 }
 
+func _AgentService_AddARPNeighbors_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc1.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AddARPNeighborsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AgentServiceServer).AddARPNeighbors(ctx, in)
+	}
+	info := &grpc1.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/grpc.AgentService/AddARPNeighbors",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AgentServiceServer).AddARPNeighbors(ctx, req.(*AddARPNeighborsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _AgentService_StartTracing_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc1.UnaryServerInterceptor) (interface{}, error) {
 	in := new(StartTracingRequest)
 	if err := dec(in); err != nil {
@@ -2953,6 +3020,10 @@ var _AgentService_serviceDesc = grpc1.ServiceDesc{
 			MethodName: "ListRoutes",
 			Handler:    _AgentService_ListRoutes_Handler,
 		},
+		{
+			MethodName: "AddARPNeighbors",
+			Handler:    _AgentService_AddARPNeighbors_Handler,
+		},
 		{
 			MethodName: "StartTracing",
 			Handler:    _AgentService_StartTracing_Handler,
@@ -4576,6 +4647,64 @@ func (m *ListRoutesRequest) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
+func (m *ARPNeighbors) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ARPNeighbors) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.ARPNeighbors) > 0 {
+		for _, msg := range m.ARPNeighbors {
+			dAtA[i] = 0xa
+			i++
+			i = encodeVarintAgent(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	return i, nil
+}
+
+func (m *AddARPNeighborsRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AddARPNeighborsRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Neighbors != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintAgent(dAtA, i, uint64(m.Neighbors.Size()))
+		n21, err := m.Neighbors.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n21
+	}
+	return i, nil
+}
+
 func (m *OnlineCPUMemRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -4779,11 +4908,11 @@ func (m *GuestDetailsResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0x12
 		i++
 		i = encodeVarintAgent(dAtA, i, uint64(m.AgentDetails.Size()))
-		n21, err := m.AgentDetails.MarshalTo(dAtA[i:])
+		n22, err := m.AgentDetails.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n21
+		i += n22
 	}
 	if m.SupportMemHotplugProbe {
 		dAtA[i] = 0x18
@@ -4814,21 +4943,21 @@ func (m *MemHotplugByProbeRequest) MarshalTo(dAtA []byte) (int, error) {
 	var l int
 	_ = l
 	if len(m.MemHotplugProbeAddr) > 0 {
-		dAtA23 := make([]byte, len(m.MemHotplugProbeAddr)*10)
-		var j22 int
+		dAtA24 := make([]byte, len(m.MemHotplugProbeAddr)*10)
+		var j23 int
 		for _, num := range m.MemHotplugProbeAddr {
 			for num >= 1<<7 {
-				dAtA23[j22] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA24[j23] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j22++
+				j23++
 			}
-			dAtA23[j22] = uint8(num)
-			j22++
+			dAtA24[j23] = uint8(num)
+			j23++
 		}
 		dAtA[i] = 0xa
 		i++
-		i = encodeVarintAgent(dAtA, i, uint64(j22))
-		i += copy(dAtA[i:], dAtA23[:j22])
+		i = encodeVarintAgent(dAtA, i, uint64(j23))
+		i += copy(dAtA[i:], dAtA24[:j23])
 	}
 	return i, nil
 }
@@ -5869,6 +5998,28 @@ func (m *ListRoutesRequest) Size() (n int) {
 	return n
 }
 
+func (m *ARPNeighbors) Size() (n int) {
+	var l int
+	_ = l
+	if len(m.ARPNeighbors) > 0 {
+		for _, e := range m.ARPNeighbors {
+			l = e.Size()
+			n += 1 + l + sovAgent(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *AddARPNeighborsRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.Neighbors != nil {
+		l = m.Neighbors.Size()
+		n += 1 + l + sovAgent(uint64(l))
+	}
+	return n
+}
+
 func (m *OnlineCPUMemRequest) Size() (n int) {
 	var l int
 	_ = l
@@ -11204,6 +11355,170 @@ func (m *ListRoutesRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *ARPNeighbors) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowAgent
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ARPNeighbors: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ARPNeighbors: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ARPNeighbors", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowAgent
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthAgent
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ARPNeighbors = append(m.ARPNeighbors, &types.ARPNeighbor{})
+			if err := m.ARPNeighbors[len(m.ARPNeighbors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipAgent(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthAgent
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AddARPNeighborsRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowAgent
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AddARPNeighborsRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AddARPNeighborsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Neighbors", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowAgent
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthAgent
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Neighbors == nil {
+				m.Neighbors = &ARPNeighbors{}
+			}
+			if err := m.Neighbors.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipAgent(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthAgent
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *OnlineCPUMemRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@@ -13100,186 +13415,190 @@ var (
 func init() { proto.RegisterFile("agent.proto", fileDescriptorAgent) }
 
 var fileDescriptorAgent = []byte{
-	// 2896 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x19, 0xcb, 0x6e, 0x23, 0xc7,
-	0x11, 0x7c, 0x88, 0x22, 0x8b, 0x2f, 0xb1, 0xa5, 0xd5, 0x72, 0xb9, 0xf6, 0x66, 0x3d, 0xb6, 0xd7,
-	0x72, 0x1c, 0x53, 0xf6, 0xda, 0xc8, 0xfa, 0x01, 0x67, 0xb1, 0x7a, 0x44, 0x52, 0x6c, 0x45, 0xca,
-	0x68, 0x05, 0x07, 0x08, 0x82, 0xc1, 0x68, 0xa6, 0x45, 0xb5, 0xc5, 0x99, 0x1e, 0xf7, 0xf4, 0x68,
-	0x45, 0x07, 0xc8, 0x31, 0xb9, 0xe5, 0x98, 0x5b, 0x7e, 0x20, 0xc8, 0x2d, 0xc7, 0x5c, 0x73, 0x30,
-	0x82, 0x1c, 0xf2, 0x05, 0x41, 0xe0, 0x4f, 0xc8, 0x17, 0x04, 0xfd, 0x9a, 0x07, 0x49, 0x69, 0x13,
-	0x41, 0x40, 0x2e, 0x44, 0x57, 0x75, 0x75, 0xbd, 0xba, 0xab, 0x58, 0x55, 0x03, 0x4d, 0x77, 0x84,
-	0x43, 0x3e, 0x8c, 0x18, 0xe5, 0x14, 0x55, 0x47, 0x2c, 0xf2, 0x06, 0x0d, 0xea, 0x11, 0x85, 0x18,
-	0xfc, 0x70, 0x44, 0xf8, 0x59, 0x72, 0x32, 0xf4, 0x68, 0xb0, 0x7e, 0xee, 0x72, 0xf7, 0x5d, 0x8f,
-	0x86, 0xdc, 0x25, 0x21, 0x66, 0xf1, 0xba, 0x3c, 0xb8, 0x1e, 0x9d, 0x8f, 0xd6, 0xf9, 0x24, 0xc2,
-	0xb1, 0xfa, 0xd5, 0xe7, 0xee, 0x8f, 0x28, 0x1d, 0x8d, 0xf1, 0xba, 0x84, 0x4e, 0x92, 0xd3, 0x75,
-	0x1c, 0x44, 0x7c, 0xa2, 0x36, 0xad, 0x3f, 0x94, 0x61, 0x75, 0x93, 0x61, 0x97, 0xe3, 0x4d, 0xc3,
-	0xcd, 0xc6, 0x5f, 0x27, 0x38, 0xe6, 0xe8, 0x35, 0x68, 0xa5, 0x12, 0x1c, 0xe2, 0xf7, 0x4b, 0x0f,
-	0x4b, 0x6b, 0x0d, 0xbb, 0x99, 0xe2, 0xf6, 0x7c, 0x74, 0x17, 0x16, 0xf1, 0x25, 0xf6, 0xc4, 0x6e,
-	0x59, 0xee, 0xd6, 0x04, 0xb8, 0xe7, 0xa3, 0xf7, 0xa1, 0x19, 0x73, 0x46, 0xc2, 0x91, 0x93, 0xc4,
-	0x98, 0xf5, 0x2b, 0x0f, 0x4b, 0x6b, 0xcd, 0xc7, 0x4b, 0x43, 0x61, 0xd2, 0xf0, 0x48, 0x6e, 0x1c,
-	0xc7, 0x98, 0xd9, 0x10, 0xa7, 0x6b, 0xf4, 0x08, 0x16, 0x7d, 0x7c, 0x41, 0x3c, 0x1c, 0xf7, 0xab,
-	0x0f, 0x2b, 0x6b, 0xcd, 0xc7, 0x2d, 0x45, 0xbe, 0x25, 0x91, 0xb6, 0xd9, 0x44, 0x6f, 0x43, 0x3d,
-	0xe6, 0x94, 0xb9, 0x23, 0x1c, 0xf7, 0x17, 0x24, 0x61, 0xdb, 0xf0, 0x95, 0x58, 0x3b, 0xdd, 0x46,
-	0xaf, 0x40, 0xe5, 0x60, 0x73, 0xaf, 0x5f, 0x93, 0xd2, 0x41, 0x53, 0x45, 0xd8, 0xb3, 0x05, 0x1a,
-	0xbd, 0x0e, 0xed, 0xd8, 0x0d, 0xfd, 0x13, 0x7a, 0xe9, 0x44, 0xc4, 0x0f, 0xe3, 0xfe, 0xe2, 0xc3,
-	0xd2, 0x5a, 0xdd, 0x6e, 0x69, 0xe4, 0xa1, 0xc0, 0x59, 0x9f, 0xc0, 0x9d, 0x23, 0xee, 0x32, 0x7e,
-	0x03, 0xef, 0x58, 0xc7, 0xb0, 0x6a, 0xe3, 0x80, 0x5e, 0xdc, 0xc8, 0xb5, 0x7d, 0x58, 0xe4, 0x24,
-	0xc0, 0x34, 0xe1, 0xd2, 0xb5, 0x6d, 0xdb, 0x80, 0xd6, 0x9f, 0x4a, 0x80, 0xb6, 0x2f, 0xb1, 0x77,
-	0xc8, 0xa8, 0x87, 0xe3, 0xf8, 0xff, 0x74, 0x5d, 0x6f, 0xc1, 0x62, 0xa4, 0x14, 0xe8, 0x57, 0x25,
-	0xb9, 0xbe, 0x05, 0xa3, 0x95, 0xd9, 0xb5, 0xbe, 0x82, 0x95, 0x23, 0x32, 0x0a, 0xdd, 0xf1, 0x2d,
-	0xea, 0xbb, 0x0a, 0xb5, 0x58, 0xf2, 0x94, 0xaa, 0xb6, 0x6d, 0x0d, 0x59, 0x87, 0x80, 0xbe, 0x74,
-	0x09, 0xbf, 0x3d, 0x49, 0xd6, 0xbb, 0xb0, 0x5c, 0xe0, 0x18, 0x47, 0x34, 0x8c, 0xb1, 0x54, 0x80,
-	0xbb, 0x3c, 0x89, 0x25, 0xb3, 0x05, 0x5b, 0x43, 0x16, 0x86, 0x95, 0x2f, 0x48, 0x6c, 0xc8, 0xf1,
-	0xff, 0xa2, 0xc2, 0x2a, 0xd4, 0x4e, 0x29, 0x0b, 0x5c, 0x6e, 0x34, 0x50, 0x10, 0x42, 0x50, 0x75,
-	0xd9, 0x28, 0xee, 0x57, 0x1e, 0x56, 0xd6, 0x1a, 0xb6, 0x5c, 0x8b, 0x57, 0x39, 0x25, 0x46, 0xeb,
-	0xf5, 0x1a, 0xb4, 0xb4, 0xdf, 0x9d, 0x31, 0x89, 0xb9, 0x94, 0xd3, 0xb2, 0x9b, 0x1a, 0x27, 0xce,
-	0x58, 0x14, 0x56, 0x8f, 0x23, 0xff, 0x86, 0x01, 0xff, 0x18, 0x1a, 0x0c, 0xc7, 0x34, 0x61, 0x22,
-	0x4c, 0xcb, 0xf2, 0xde, 0x57, 0xd4, 0xbd, 0x7f, 0x41, 0xc2, 0xe4, 0xd2, 0x36, 0x7b, 0x76, 0x46,
-	0xa6, 0x43, 0x88, 0xc7, 0x37, 0x09, 0xa1, 0x4f, 0xe0, 0xce, 0xa1, 0x9b, 0xc4, 0x37, 0xd1, 0xd5,
-	0xfa, 0x54, 0x84, 0x5f, 0x9c, 0x04, 0x37, 0x3a, 0xfc, 0xc7, 0x12, 0xd4, 0x37, 0xa3, 0xe4, 0x38,
-	0x76, 0x47, 0x18, 0x7d, 0x0f, 0x9a, 0x9c, 0x72, 0x77, 0xec, 0x24, 0x02, 0x94, 0xe4, 0x55, 0x1b,
-	0x24, 0x4a, 0x11, 0x08, 0xb7, 0x63, 0xe6, 0x45, 0x89, 0xa6, 0x28, 0x3f, 0xac, 0xac, 0x55, 0xed,
-	0xa6, 0xc2, 0x29, 0x92, 0x21, 0x2c, 0xcb, 0x3d, 0x87, 0x84, 0xce, 0x39, 0x66, 0x21, 0x1e, 0x07,
-	0xd4, 0xc7, 0xf2, 0xfd, 0x56, 0xed, 0x9e, 0xdc, 0xda, 0x0b, 0x3f, 0x4f, 0x37, 0xd0, 0xf7, 0xa1,
-	0x97, 0xd2, 0x8b, 0xa0, 0x94, 0xd4, 0x55, 0x49, 0xdd, 0xd5, 0xd4, 0xc7, 0x1a, 0x6d, 0xfd, 0x1a,
-	0x3a, 0xcf, 0xcf, 0x18, 0xe5, 0x7c, 0x4c, 0xc2, 0xd1, 0x96, 0xcb, 0x5d, 0x91, 0x3d, 0x22, 0xcc,
-	0x08, 0xf5, 0x63, 0xad, 0xad, 0x01, 0xd1, 0x3b, 0xd0, 0xe3, 0x8a, 0x16, 0xfb, 0x8e, 0xa1, 0x29,
-	0x4b, 0x9a, 0xa5, 0x74, 0xe3, 0x50, 0x13, 0xbf, 0x09, 0x9d, 0x8c, 0x58, 0xe4, 0x1f, 0xad, 0x6f,
-	0x3b, 0xc5, 0x3e, 0x27, 0x01, 0xb6, 0x2e, 0xa4, 0xaf, 0xe4, 0x25, 0xa3, 0x77, 0xa0, 0x91, 0xf9,
-	0xa1, 0x24, 0x5f, 0x48, 0x47, 0xbd, 0x10, 0xe3, 0x4e, 0xbb, 0x9e, 0x3a, 0xe5, 0x33, 0xe8, 0xf2,
-	0x54, 0x71, 0xc7, 0x77, 0xb9, 0x5b, 0x7c, 0x54, 0x45, 0xab, 0xec, 0x0e, 0x2f, 0xc0, 0xd6, 0xa7,
-	0xd0, 0x38, 0x24, 0x7e, 0xac, 0x04, 0xf7, 0x61, 0xd1, 0x4b, 0x18, 0xc3, 0x21, 0x37, 0x26, 0x6b,
-	0x10, 0xad, 0xc0, 0xc2, 0x98, 0x04, 0x84, 0x6b, 0x33, 0x15, 0x60, 0x51, 0x80, 0x7d, 0x1c, 0x50,
-	0x36, 0x91, 0x0e, 0x5b, 0x81, 0x85, 0xfc, 0xe5, 0x2a, 0x00, 0xdd, 0x87, 0x46, 0xe0, 0x5e, 0xa6,
-	0x97, 0x2a, 0x76, 0xea, 0x81, 0x7b, 0xa9, 0x94, 0xef, 0xc3, 0xe2, 0xa9, 0x4b, 0xc6, 0x5e, 0xc8,
-	0xb5, 0x57, 0x0c, 0x98, 0x09, 0xac, 0xe6, 0x05, 0xfe, 0xb5, 0x0c, 0x4d, 0x25, 0x51, 0x29, 0xbc,
-	0x02, 0x0b, 0x9e, 0xeb, 0x9d, 0xa5, 0x22, 0x25, 0x80, 0x1e, 0x19, 0x45, 0xca, 0xf9, 0x24, 0x9c,
-	0x69, 0x6a, 0x54, 0x5b, 0x07, 0x88, 0x5f, 0xb8, 0x91, 0xd6, 0xad, 0x72, 0x05, 0x71, 0x43, 0xd0,
-	0x28, 0x75, 0x3f, 0x80, 0x96, 0x7a, 0x77, 0xfa, 0x48, 0xf5, 0x8a, 0x23, 0x4d, 0x45, 0xa5, 0x0e,
-	0xbd, 0x0e, 0xed, 0x24, 0xc6, 0xce, 0x19, 0xc1, 0xcc, 0x65, 0xde, 0xd9, 0xa4, 0xbf, 0xa0, 0xfe,
-	0x23, 0x93, 0x18, 0xef, 0x1a, 0x1c, 0x7a, 0x0c, 0x0b, 0x22, 0xfd, 0xc5, 0xfd, 0x9a, 0xfc, 0x3b,
-	0x7e, 0x25, 0xcf, 0x52, 0x9a, 0x3a, 0x94, 0xbf, 0xdb, 0x21, 0x67, 0x13, 0x5b, 0x91, 0x0e, 0x3e,
-	0x02, 0xc8, 0x90, 0x68, 0x09, 0x2a, 0xe7, 0x78, 0xa2, 0xe3, 0x50, 0x2c, 0x85, 0x73, 0x2e, 0xdc,
-	0x71, 0x62, 0xbc, 0xae, 0x80, 0x4f, 0xca, 0x1f, 0x95, 0x2c, 0x0f, 0xba, 0x1b, 0xe3, 0x73, 0x42,
-	0x73, 0xc7, 0x57, 0x60, 0x21, 0x70, 0xbf, 0xa2, 0xcc, 0x78, 0x52, 0x02, 0x12, 0x4b, 0x42, 0xca,
-	0x0c, 0x0b, 0x09, 0xa0, 0x0e, 0x94, 0x69, 0x24, 0xfd, 0xd5, 0xb0, 0xcb, 0x34, 0xca, 0x04, 0x55,
-	0x73, 0x82, 0xac, 0x7f, 0x56, 0x01, 0x32, 0x29, 0xc8, 0x86, 0x01, 0xa1, 0x4e, 0x8c, 0x99, 0x28,
-	0x41, 0x9c, 0x93, 0x09, 0xc7, 0xb1, 0xc3, 0xb0, 0x97, 0xb0, 0x98, 0x5c, 0x88, 0xfb, 0x13, 0x66,
-	0xdf, 0x51, 0x66, 0x4f, 0xe9, 0x66, 0xdf, 0x25, 0xf4, 0x48, 0x9d, 0xdb, 0x10, 0xc7, 0x6c, 0x73,
-	0x0a, 0xed, 0xc1, 0x9d, 0x8c, 0xa7, 0x9f, 0x63, 0x57, 0xbe, 0x8e, 0xdd, 0x72, 0xca, 0xce, 0xcf,
-	0x58, 0x6d, 0xc3, 0x32, 0xa1, 0xce, 0xd7, 0x09, 0x4e, 0x0a, 0x8c, 0x2a, 0xd7, 0x31, 0xea, 0x11,
-	0xfa, 0x33, 0x79, 0x20, 0x63, 0x73, 0x08, 0xf7, 0x72, 0x56, 0x8a, 0x70, 0xcf, 0x31, 0xab, 0x5e,
-	0xc7, 0x6c, 0x35, 0xd5, 0x4a, 0xe4, 0x83, 0x8c, 0xe3, 0x4f, 0x60, 0x95, 0x50, 0xe7, 0x85, 0x4b,
-	0xf8, 0x34, 0xbb, 0x85, 0x97, 0x18, 0x29, 0xfe, 0x74, 0x8b, 0xbc, 0x94, 0x91, 0x01, 0x66, 0xa3,
-	0x82, 0x91, 0xb5, 0x97, 0x18, 0xb9, 0x2f, 0x0f, 0x64, 0x6c, 0x9e, 0x41, 0x8f, 0xd0, 0x69, 0x6d,
-	0x16, 0xaf, 0x63, 0xd2, 0x25, 0xb4, 0xa8, 0xc9, 0x06, 0xf4, 0x62, 0xec, 0x71, 0xca, 0xf2, 0x8f,
-	0xa0, 0x7e, 0x1d, 0x8b, 0x25, 0x4d, 0x9f, 0xf2, 0xb0, 0x7e, 0x01, 0xad, 0xdd, 0x64, 0x84, 0xf9,
-	0xf8, 0x24, 0x4d, 0x06, 0xb7, 0x96, 0x7f, 0xac, 0x7f, 0x97, 0xa1, 0xb9, 0x39, 0x62, 0x34, 0x89,
-	0x0a, 0x39, 0x59, 0x05, 0xe9, 0x74, 0x4e, 0x96, 0x24, 0x32, 0x27, 0x2b, 0xe2, 0x0f, 0xa1, 0x15,
-	0xc8, 0xd0, 0xd5, 0xf4, 0x2a, 0x0f, 0xf5, 0x66, 0x82, 0xda, 0x6e, 0x06, 0xb9, 0x64, 0x36, 0x04,
-	0x88, 0x88, 0x1f, 0xeb, 0x33, 0x2a, 0x1d, 0x75, 0x75, 0x45, 0x68, 0x52, 0xb4, 0xdd, 0x88, 0xd2,
-	0x6c, 0xfd, 0x3e, 0x34, 0x4f, 0x84, 0x93, 0xf4, 0x81, 0x42, 0x32, 0xca, 0xbc, 0x67, 0xc3, 0x49,
-	0x16, 0x84, 0xbb, 0xd0, 0x3e, 0x53, 0x2e, 0xd3, 0x87, 0xd4, 0x1b, 0x7a, 0x5d, 0x5b, 0x92, 0xd9,
-	0x3b, 0xcc, 0x7b, 0x56, 0x5d, 0x40, 0xeb, 0x2c, 0x87, 0x1a, 0x1c, 0x41, 0x6f, 0x86, 0x64, 0x4e,
-	0x0e, 0x5a, 0xcb, 0xe7, 0xa0, 0xe6, 0x63, 0xa4, 0x04, 0xe5, 0x4f, 0xe6, 0xf3, 0xd2, 0xef, 0xca,
-	0xd0, 0xfa, 0x29, 0xe6, 0x2f, 0x28, 0x3b, 0x57, 0xfa, 0x22, 0xa8, 0x86, 0x6e, 0x80, 0x35, 0x47,
-	0xb9, 0x46, 0xf7, 0xa0, 0xce, 0x2e, 0x55, 0x02, 0xd1, 0xf7, 0xb9, 0xc8, 0x2e, 0x65, 0x62, 0x40,
-	0xaf, 0x02, 0xb0, 0x4b, 0x27, 0x72, 0xbd, 0x73, 0xac, 0x3d, 0x58, 0xb5, 0x1b, 0xec, 0xf2, 0x50,
-	0x21, 0xc4, 0x53, 0x60, 0x97, 0x0e, 0x66, 0x8c, 0xb2, 0x58, 0xe7, 0xaa, 0x3a, 0xbb, 0xdc, 0x96,
-	0xb0, 0x3e, 0xeb, 0x33, 0x1a, 0x45, 0xd8, 0x97, 0x39, 0x5a, 0x9e, 0xdd, 0x52, 0x08, 0x21, 0x95,
-	0x1b, 0xa9, 0x35, 0x25, 0x95, 0x67, 0x52, 0x79, 0x26, 0x75, 0x51, 0x9d, 0xe4, 0x79, 0xa9, 0x3c,
-	0x95, 0x5a, 0x57, 0x52, 0x79, 0x4e, 0x2a, 0xcf, 0xa4, 0x36, 0xcc, 0x59, 0x2d, 0xd5, 0xfa, 0x6d,
-	0x09, 0x56, 0xa7, 0x0b, 0x3f, 0x5d, 0xa6, 0x7e, 0x08, 0x2d, 0x4f, 0xde, 0x57, 0xe1, 0x4d, 0xf6,
-	0x66, 0x6e, 0xd2, 0x6e, 0x7a, 0xb9, 0x67, 0xfc, 0x04, 0xda, 0xa1, 0x72, 0x70, 0xfa, 0x34, 0x2b,
-	0xd9, 0xbd, 0xe4, 0x7d, 0x6f, 0xb7, 0xc2, 0x1c, 0x64, 0xf9, 0x80, 0xbe, 0x64, 0x84, 0xe3, 0x23,
-	0xce, 0xb0, 0x1b, 0xdc, 0x46, 0x03, 0x82, 0xa0, 0x2a, 0xab, 0x95, 0x8a, 0xac, 0xaf, 0xe5, 0xda,
-	0x7a, 0x0b, 0x96, 0x0b, 0x52, 0xb4, 0xad, 0x4b, 0x50, 0x19, 0xe3, 0x50, 0x72, 0x6f, 0xdb, 0x62,
-	0x69, 0xb9, 0xd0, 0xb3, 0xb1, 0xeb, 0xdf, 0x9e, 0x36, 0x5a, 0x44, 0x25, 0x13, 0xb1, 0x06, 0x28,
-	0x2f, 0x42, 0xab, 0x62, 0xb4, 0x2e, 0xe5, 0xb4, 0x3e, 0x80, 0xde, 0xe6, 0x98, 0xc6, 0xf8, 0x88,
-	0xfb, 0x24, 0xbc, 0x8d, 0x8e, 0xe9, 0x57, 0xb0, 0xfc, 0x9c, 0x4f, 0xbe, 0x14, 0xcc, 0x62, 0xf2,
-	0x0d, 0xbe, 0x25, 0xfb, 0x18, 0x7d, 0x61, 0xec, 0x63, 0xf4, 0x85, 0x68, 0x96, 0x3c, 0x3a, 0x4e,
-	0x82, 0x50, 0x86, 0x42, 0xdb, 0xd6, 0x90, 0xb5, 0x01, 0x2d, 0x55, 0x43, 0xef, 0x53, 0x3f, 0x19,
-	0xe3, 0xb9, 0x31, 0xf8, 0x00, 0x20, 0x72, 0x99, 0x1b, 0x60, 0x8e, 0x99, 0x7a, 0x43, 0x0d, 0x3b,
-	0x87, 0xb1, 0x7e, 0x5f, 0x86, 0x15, 0x35, 0x12, 0x39, 0x52, 0x93, 0x00, 0x63, 0xc2, 0x00, 0xea,
-	0x67, 0x34, 0xe6, 0x39, 0x86, 0x29, 0x2c, 0x54, 0xf4, 0x43, 0xc3, 0x4d, 0x2c, 0x0b, 0x73, 0x8a,
-	0xca, 0xf5, 0x73, 0x8a, 0x99, 0x49, 0x44, 0x75, 0x76, 0x12, 0x21, 0xa2, 0xcd, 0x10, 0x11, 0x15,
-	0xe3, 0x0d, 0xbb, 0xa1, 0x31, 0x7b, 0x3e, 0x7a, 0x04, 0xdd, 0x91, 0xd0, 0xd2, 0x39, 0xa3, 0xf4,
-	0xdc, 0x89, 0x5c, 0x7e, 0x26, 0x43, 0xbd, 0x61, 0xb7, 0x25, 0x7a, 0x97, 0xd2, 0xf3, 0x43, 0x97,
-	0x9f, 0xa1, 0x8f, 0xa1, 0xa3, 0xcb, 0xc0, 0x40, 0xba, 0x28, 0xd6, 0x7f, 0x7e, 0x3a, 0x8a, 0xf2,
-	0xde, 0xb3, 0xdb, 0xe7, 0x39, 0x28, 0xb6, 0xee, 0xc2, 0x9d, 0x2d, 0x1c, 0x73, 0x46, 0x27, 0x45,
-	0xc7, 0x58, 0x3f, 0x02, 0xd8, 0x0b, 0x39, 0x66, 0xa7, 0xae, 0x87, 0x63, 0xf4, 0x5e, 0x1e, 0xd2,
-	0xc5, 0xd1, 0xd2, 0x50, 0x4d, 0xa4, 0xd2, 0x0d, 0x3b, 0x47, 0x63, 0x0d, 0xa1, 0x66, 0xd3, 0x44,
-	0xa4, 0xa3, 0x37, 0xcc, 0x4a, 0x9f, 0x6b, 0xe9, 0x73, 0x12, 0x69, 0xeb, 0x3d, 0x6b, 0xd7, 0xb4,
-	0xb0, 0x19, 0x3b, 0x7d, 0x45, 0x43, 0x68, 0x10, 0x83, 0xd3, 0x59, 0x65, 0x56, 0x74, 0x46, 0x62,
-	0x7d, 0x0a, 0xcb, 0x8a, 0x93, 0xe2, 0x6c, 0xd8, 0xbc, 0x01, 0x35, 0x66, 0xd4, 0x28, 0x65, 0xa3,
-	0x28, 0x4d, 0xa4, 0xf7, 0x84, 0x3f, 0x44, 0x47, 0x9d, 0x19, 0x62, 0xfc, 0xb1, 0x0c, 0x3d, 0xb1,
-	0x51, 0xe0, 0x69, 0xfd, 0x12, 0x96, 0x0f, 0xc2, 0x31, 0x09, 0xf1, 0xe6, 0xe1, 0xf1, 0x3e, 0x4e,
-	0xe3, 0x1e, 0x41, 0x55, 0xd4, 0x47, 0x52, 0x50, 0xdd, 0x96, 0x6b, 0x11, 0x08, 0xe1, 0x89, 0xe3,
-	0x45, 0x49, 0xac, 0x67, 0x3f, 0xb5, 0xf0, 0x64, 0x33, 0x4a, 0x62, 0x91, 0xc8, 0xc5, 0x1f, 0x39,
-	0x0d, 0xc7, 0x13, 0x19, 0x0d, 0x75, 0x7b, 0xd1, 0x8b, 0x92, 0x83, 0x70, 0x3c, 0xb1, 0x7e, 0x20,
-	0xbb, 0x5d, 0x8c, 0x7d, 0xdb, 0x0d, 0x7d, 0x1a, 0x6c, 0xe1, 0x8b, 0x9c, 0x84, 0xb4, 0xb3, 0x32,
-	0x51, 0xff, 0x6d, 0x09, 0x5a, 0xcf, 0x46, 0x38, 0xe4, 0x5b, 0x98, 0xbb, 0x64, 0x2c, 0xbb, 0xa7,
-	0x0b, 0xcc, 0x62, 0x42, 0x43, 0xfd, 0xb4, 0x0d, 0x28, 0x9a, 0x5f, 0x12, 0x12, 0xee, 0xf8, 0x2e,
-	0x0e, 0x68, 0x28, 0xb9, 0xd4, 0x6d, 0x10, 0xa8, 0x2d, 0x89, 0x41, 0x6f, 0x41, 0x57, 0xcd, 0xe6,
-	0x9c, 0x33, 0x37, 0xf4, 0xc7, 0x22, 0xa8, 0xd4, 0xac, 0xa2, 0xa3, 0xd0, 0xbb, 0x1a, 0x8b, 0xde,
-	0x86, 0x25, 0xfd, 0xe4, 0x33, 0xca, 0xaa, 0xa4, 0xec, 0x6a, 0x7c, 0x81, 0x34, 0x89, 0x22, 0xca,
-	0x78, 0xec, 0xc4, 0xd8, 0xf3, 0x68, 0x10, 0xe9, 0xd6, 0xa3, 0x6b, 0xf0, 0x47, 0x0a, 0x6d, 0x8d,
-	0x60, 0x79, 0x47, 0xd8, 0xa9, 0x2d, 0xc9, 0xae, 0xb0, 0x13, 0xe0, 0xc0, 0x39, 0x19, 0x53, 0xef,
-	0xdc, 0x11, 0x89, 0x48, 0x7b, 0x58, 0x14, 0x37, 0x1b, 0x02, 0x79, 0x44, 0xbe, 0x91, 0x5d, 0xb6,
-	0xa0, 0x3a, 0xa3, 0x3c, 0x1a, 0x27, 0x23, 0x27, 0x62, 0xf4, 0x04, 0x6b, 0x13, 0xbb, 0x01, 0x0e,
-	0x76, 0x15, 0xfe, 0x50, 0xa0, 0xad, 0xbf, 0x94, 0x60, 0xa5, 0x28, 0x49, 0xa7, 0xd5, 0x75, 0x58,
-	0x29, 0x8a, 0xd2, 0x7f, 0xb5, 0xaa, 0x94, 0xeb, 0xe5, 0x05, 0xaa, 0x3f, 0xdd, 0x27, 0xd0, 0x96,
-	0x03, 0x5b, 0xc7, 0x57, 0x9c, 0x8a, 0x05, 0x46, 0xfe, 0x5e, 0xec, 0x96, 0x9b, 0xbf, 0xa5, 0x8f,
-	0xe1, 0x9e, 0x36, 0xdf, 0x99, 0x55, 0x5b, 0x3d, 0x88, 0x55, 0x4d, 0xb0, 0x3f, 0xa5, 0xfd, 0x17,
-	0xd0, 0xcf, 0x50, 0x1b, 0x13, 0x89, 0x34, 0xbe, 0x7a, 0x0f, 0x96, 0xa7, 0x8c, 0x7d, 0xe6, 0xfb,
-	0x4c, 0x86, 0x60, 0xd5, 0x9e, 0xb7, 0x65, 0x3d, 0x85, 0xbb, 0x47, 0x98, 0x2b, 0x6f, 0xb8, 0x5c,
-	0x57, 0xfd, 0x8a, 0xd9, 0x12, 0x54, 0x8e, 0xb0, 0x27, 0x8d, 0xaf, 0xd8, 0x62, 0x29, 0x1e, 0xe0,
-	0x71, 0x8c, 0x3d, 0x69, 0x65, 0xc5, 0x96, 0x6b, 0xeb, 0xcf, 0x25, 0x58, 0xd4, 0x89, 0x50, 0x24,
-	0x73, 0x9f, 0x91, 0x0b, 0xcc, 0xf4, 0xd3, 0xd3, 0x10, 0x7a, 0x13, 0x3a, 0x6a, 0xe5, 0xd0, 0x88,
-	0x13, 0x9a, 0xa6, 0xd7, 0xb6, 0xc2, 0x1e, 0x28, 0xa4, 0x9c, 0xc5, 0xc9, 0x51, 0x93, 0xee, 0xea,
-	0x34, 0x24, 0x07, 0x6a, 0xb1, 0x88, 0x7d, 0x99, 0x4e, 0x1b, 0xb6, 0x86, 0xc4, 0x53, 0x37, 0xfc,
-	0x16, 0x24, 0x3f, 0x03, 0x8a, 0xa7, 0x1e, 0xd0, 0x24, 0xe4, 0x4e, 0x44, 0x49, 0xc8, 0x75, 0xfe,
-	0x04, 0x89, 0x3a, 0x14, 0x18, 0xeb, 0x37, 0x25, 0xa8, 0xa9, 0x79, 0xb4, 0xe8, 0x23, 0xd3, 0x7f,
-	0xb1, 0x32, 0x91, 0x15, 0x81, 0x94, 0xa5, 0xfe, 0xb9, 0xe4, 0x5a, 0xc4, 0xf1, 0x45, 0xa0, 0x72,
-	0xb1, 0x56, 0xed, 0x22, 0x90, 0x49, 0xf8, 0x4d, 0xe8, 0x64, 0x7f, 0x86, 0x72, 0x5f, 0xa9, 0xd8,
-	0x4e, 0xb1, 0x92, 0xec, 0x4a, 0x4d, 0xad, 0x9f, 0x8b, 0xf6, 0x39, 0x9d, 0xc5, 0x2e, 0x41, 0x25,
-	0x49, 0x95, 0x11, 0x4b, 0x81, 0x19, 0xa5, 0x7f, 0xa3, 0x62, 0x89, 0x1e, 0x41, 0xc7, 0xf5, 0x7d,
-	0x22, 0x8e, 0xbb, 0xe3, 0x1d, 0xe2, 0xa7, 0x41, 0x5a, 0xc4, 0x5a, 0x7f, 0x2b, 0x41, 0x77, 0x93,
-	0x46, 0x93, 0x1f, 0x93, 0x31, 0xce, 0x65, 0x10, 0xa9, 0xa4, 0xfe, 0x17, 0x15, 0x6b, 0x51, 0x19,
-	0x9e, 0x92, 0x31, 0x56, 0xa1, 0xa5, 0x6e, 0xb6, 0x2e, 0x10, 0x32, 0xac, 0xcc, 0x66, 0x3a, 0xe2,
-	0x6a, 0xab, 0xcd, 0x7d, 0xea, 0xcb, 0x1a, 0xd8, 0x27, 0xcc, 0x49, 0x07, 0x5a, 0x6d, 0x7b, 0xd1,
-	0x27, 0x4c, 0x6e, 0x69, 0x43, 0x16, 0xe4, 0x4c, 0x35, 0x6f, 0x48, 0x4d, 0x61, 0x84, 0x21, 0xab,
-	0x50, 0xa3, 0xa7, 0xa7, 0x31, 0xe6, 0xb2, 0x5a, 0xad, 0xd8, 0x1a, 0x4a, 0xd3, 0x5c, 0x3d, 0x97,
-	0xe6, 0xee, 0xc0, 0xb2, 0x9c, 0xde, 0x3f, 0x67, 0xae, 0x47, 0xc2, 0x91, 0x49, 0xc5, 0x2b, 0x80,
-	0x8e, 0x38, 0x8d, 0x66, 0xb1, 0x3b, 0x98, 0x1f, 0x1c, 0xec, 0x6f, 0x5f, 0xe0, 0x90, 0x1b, 0xec,
-	0xbb, 0x50, 0x37, 0xa8, 0xff, 0xa2, 0x86, 0x79, 0xfc, 0xf7, 0x25, 0x9d, 0x58, 0x75, 0x3f, 0x8c,
-	0x76, 0xa0, 0x3b, 0xf5, 0x7d, 0x05, 0xe9, 0x01, 0xc9, 0xfc, 0xcf, 0x2e, 0x83, 0xd5, 0xa1, 0xfa,
-	0x5e, 0x33, 0x34, 0xdf, 0x6b, 0x86, 0xdb, 0x41, 0xc4, 0x27, 0x68, 0x1b, 0x3a, 0xc5, 0x2f, 0x11,
-	0xe8, 0xbe, 0xa9, 0x27, 0xe6, 0x7c, 0x9f, 0xb8, 0x92, 0xcd, 0x0e, 0x74, 0xa7, 0x3e, 0x4a, 0x18,
-	0x7d, 0xe6, 0x7f, 0xab, 0xb8, 0x92, 0xd1, 0x53, 0x68, 0xe6, 0xbe, 0x42, 0xa0, 0xbe, 0x62, 0x32,
-	0xfb, 0x61, 0xe2, 0x4a, 0x06, 0x9b, 0xd0, 0x2e, 0x7c, 0x18, 0x40, 0x03, 0x6d, 0xcf, 0x9c, 0xaf,
-	0x05, 0x57, 0x32, 0xd9, 0x80, 0x66, 0x6e, 0x3e, 0x6f, 0xb4, 0x98, 0xfd, 0x08, 0x30, 0xb8, 0x37,
-	0x67, 0x47, 0xe7, 0xef, 0x5d, 0x68, 0x17, 0xa6, 0xe9, 0x46, 0x91, 0x79, 0x93, 0xfc, 0xc1, 0xfd,
-	0xb9, 0x7b, 0x9a, 0xd3, 0x0e, 0x74, 0xa7, 0x66, 0xeb, 0xc6, 0xb9, 0xf3, 0x47, 0xee, 0x57, 0x9a,
-	0xf5, 0xb9, 0xbc, 0xec, 0x5c, 0xeb, 0x94, 0xbb, 0xec, 0xd9, 0x49, 0xfa, 0xe0, 0x95, 0xf9, 0x9b,
-	0x5a, 0xab, 0x6d, 0xe8, 0x14, 0x87, 0xe8, 0x86, 0xd9, 0xdc, 0xd1, 0xfa, 0xf5, 0x2f, 0xa7, 0x30,
-	0x4f, 0xcf, 0x5e, 0xce, 0xbc, 0x31, 0xfb, 0x95, 0x8c, 0x9e, 0x01, 0xe8, 0x46, 0xc9, 0x27, 0x61,
-	0x7a, 0x65, 0x33, 0x0d, 0x5a, 0x7a, 0x65, 0x73, 0x9a, 0xaa, 0xa7, 0x00, 0xaa, 0xbf, 0xf1, 0x69,
-	0xc2, 0xd1, 0x5d, 0xa3, 0xc6, 0x54, 0x53, 0x35, 0xe8, 0xcf, 0x6e, 0xcc, 0x30, 0xc0, 0x8c, 0xdd,
-	0x84, 0xc1, 0x67, 0x00, 0x59, 0xdf, 0x64, 0x18, 0xcc, 0x74, 0x52, 0xd7, 0xf8, 0xa0, 0x95, 0xef,
-	0x92, 0x90, 0xb6, 0x75, 0x4e, 0xe7, 0x74, 0x0d, 0x8b, 0xee, 0x54, 0x15, 0x5c, 0x7c, 0x6c, 0xd3,
-	0xc5, 0xf1, 0x60, 0xa6, 0x12, 0x46, 0x4f, 0xa0, 0x95, 0x2f, 0x7f, 0x8d, 0x16, 0x73, 0x4a, 0xe2,
-	0x41, 0xa1, 0x04, 0x46, 0x4f, 0xa1, 0x53, 0x2c, 0x7d, 0x51, 0x2e, 0x2e, 0x66, 0x0a, 0xe2, 0x81,
-	0x1e, 0xec, 0xe4, 0xc8, 0x3f, 0x00, 0xc8, 0x4a, 0x64, 0xe3, 0xbe, 0x99, 0xa2, 0x79, 0x4a, 0xea,
-	0x33, 0x68, 0xe5, 0xd3, 0xb9, 0x51, 0x77, 0x4e, 0x8a, 0xbf, 0x2e, 0x6b, 0xe5, 0x52, 0xbf, 0x79,
-	0x7c, 0xb3, 0xff, 0x06, 0xd7, 0x65, 0xad, 0x42, 0x73, 0x68, 0x92, 0xc5, 0xbc, 0x8e, 0xf1, 0xba,
-	0x5c, 0x5e, 0xec, 0xa4, 0x8c, 0xfb, 0xe6, 0xf6, 0x57, 0xd7, 0x3d, 0xa2, 0x7c, 0x4b, 0x61, 0xfc,
-	0x31, 0xa7, 0xcd, 0x78, 0x49, 0x50, 0xe7, 0xdb, 0x86, 0x5c, 0x50, 0xcf, 0xe9, 0x26, 0xae, 0x64,
-	0xb4, 0x0b, 0xdd, 0x1d, 0x53, 0x11, 0xea, 0x6a, 0x55, 0xab, 0x33, 0xa7, 0x3a, 0x1f, 0x0c, 0xe6,
-	0x6d, 0xe9, 0xc8, 0xfa, 0x1c, 0x7a, 0x33, 0x95, 0x2a, 0x7a, 0x90, 0xce, 0x1f, 0xe7, 0x96, 0xb0,
-	0x57, 0xaa, 0xb5, 0x07, 0x4b, 0xd3, 0x85, 0x2a, 0x7a, 0x55, 0x5f, 0xfa, 0xfc, 0x02, 0xf6, 0x4a,
-	0x56, 0x1f, 0x43, 0xdd, 0x14, 0x46, 0x48, 0xcf, 0x79, 0xa7, 0x0a, 0xa5, 0x2b, 0x8f, 0x3e, 0x81,
-	0x66, 0xae, 0xb4, 0x30, 0xaf, 0x6e, 0xb6, 0xda, 0x18, 0xe8, 0xb1, 0xac, 0x41, 0x6f, 0xb4, 0xbe,
-	0xfd, 0xee, 0x41, 0xe9, 0x1f, 0xdf, 0x3d, 0x28, 0xfd, 0xeb, 0xbb, 0x07, 0xa5, 0x93, 0x9a, 0x64,
-	0xfb, 0xc1, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xe5, 0xd5, 0xba, 0x65, 0x28, 0x22, 0x00, 0x00,
+	// 2957 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x39, 0x4b, 0x6f, 0x1c, 0xc7,
+	0xd1, 0xd8, 0x07, 0x97, 0xbb, 0xb5, 0x2f, 0x6e, 0x93, 0xa2, 0x56, 0x2b, 0x5b, 0x9f, 0x3c, 0xb6,
+	0x65, 0xfa, 0xf3, 0xe7, 0xa5, 0x2d, 0x1b, 0x96, 0x1f, 0xf0, 0x27, 0x88, 0x14, 0x4d, 0xd2, 0xb6,
+	0x2c, 0x66, 0x28, 0xc1, 0x01, 0x82, 0x60, 0x30, 0x9c, 0x69, 0xee, 0xb6, 0xb9, 0x33, 0x3d, 0xee,
+	0xe9, 0xa1, 0xb8, 0x0e, 0x90, 0x63, 0x72, 0xcb, 0x2d, 0xb9, 0xe5, 0x0f, 0x04, 0xb9, 0xe5, 0x98,
+	0x6b, 0x0e, 0x46, 0x4e, 0xf9, 0x05, 0x41, 0xe0, 0x9f, 0x90, 0x5f, 0x10, 0xf4, 0x6b, 0x1e, 0xbb,
+	0xcb, 0x75, 0x42, 0x10, 0xc8, 0x65, 0x30, 0x5d, 0x5d, 0x5d, 0xaf, 0xee, 0xaa, 0xae, 0xaa, 0x86,
+	0xa6, 0x3b, 0xc2, 0x21, 0x1f, 0x46, 0x8c, 0x72, 0x8a, 0xaa, 0x23, 0x16, 0x79, 0x83, 0x06, 0xf5,
+	0x88, 0x02, 0x0c, 0x3e, 0x18, 0x11, 0x3e, 0x4e, 0x4e, 0x86, 0x1e, 0x0d, 0xb6, 0xcf, 0x5c, 0xee,
+	0xbe, 0xed, 0xd1, 0x90, 0xbb, 0x24, 0xc4, 0x2c, 0xde, 0x96, 0x0b, 0xb7, 0xa3, 0xb3, 0xd1, 0x36,
+	0x9f, 0x46, 0x38, 0x56, 0x5f, 0xbd, 0xee, 0xf6, 0x88, 0xd2, 0xd1, 0x04, 0x6f, 0xcb, 0xd1, 0x49,
+	0x72, 0xba, 0x8d, 0x83, 0x88, 0x4f, 0xd5, 0xa4, 0xf5, 0xfb, 0x32, 0x6c, 0xee, 0x32, 0xec, 0x72,
+	0xbc, 0x6b, 0xa8, 0xd9, 0xf8, 0xdb, 0x04, 0xc7, 0x1c, 0xbd, 0x02, 0xad, 0x94, 0x83, 0x43, 0xfc,
+	0x7e, 0xe9, 0x6e, 0x69, 0xab, 0x61, 0x37, 0x53, 0xd8, 0xa1, 0x8f, 0x6e, 0xc2, 0x2a, 0xbe, 0xc0,
+	0x9e, 0x98, 0x2d, 0xcb, 0xd9, 0x9a, 0x18, 0x1e, 0xfa, 0xe8, 0x5d, 0x68, 0xc6, 0x9c, 0x91, 0x70,
+	0xe4, 0x24, 0x31, 0x66, 0xfd, 0xca, 0xdd, 0xd2, 0x56, 0xf3, 0xfe, 0xda, 0x50, 0xa8, 0x34, 0x3c,
+	0x96, 0x13, 0xcf, 0x63, 0xcc, 0x6c, 0x88, 0xd3, 0x7f, 0x74, 0x0f, 0x56, 0x7d, 0x7c, 0x4e, 0x3c,
+	0x1c, 0xf7, 0xab, 0x77, 0x2b, 0x5b, 0xcd, 0xfb, 0x2d, 0x85, 0xfe, 0x58, 0x02, 0x6d, 0x33, 0x89,
+	0xde, 0x84, 0x7a, 0xcc, 0x29, 0x73, 0x47, 0x38, 0xee, 0xaf, 0x48, 0xc4, 0xb6, 0xa1, 0x2b, 0xa1,
+	0x76, 0x3a, 0x8d, 0x5e, 0x82, 0xca, 0xd3, 0xdd, 0xc3, 0x7e, 0x4d, 0x72, 0x07, 0x8d, 0x15, 0x61,
+	0xcf, 0x16, 0x60, 0xf4, 0x2a, 0xb4, 0x63, 0x37, 0xf4, 0x4f, 0xe8, 0x85, 0x13, 0x11, 0x3f, 0x8c,
+	0xfb, 0xab, 0x77, 0x4b, 0x5b, 0x75, 0xbb, 0xa5, 0x81, 0x47, 0x02, 0x66, 0x7d, 0x0c, 0x37, 0x8e,
+	0xb9, 0xcb, 0xf8, 0x15, 0xac, 0x63, 0x3d, 0x87, 0x4d, 0x1b, 0x07, 0xf4, 0xfc, 0x4a, 0xa6, 0xed,
+	0xc3, 0x2a, 0x27, 0x01, 0xa6, 0x09, 0x97, 0xa6, 0x6d, 0xdb, 0x66, 0x68, 0xfd, 0xb1, 0x04, 0x68,
+	0xef, 0x02, 0x7b, 0x47, 0x8c, 0x7a, 0x38, 0x8e, 0xff, 0x4b, 0xdb, 0xf5, 0x06, 0xac, 0x46, 0x4a,
+	0x80, 0x7e, 0x55, 0xa2, 0xeb, 0x5d, 0x30, 0x52, 0x99, 0x59, 0xeb, 0x1b, 0xd8, 0x38, 0x26, 0xa3,
+	0xd0, 0x9d, 0x5c, 0xa3, 0xbc, 0x9b, 0x50, 0x8b, 0x25, 0x4d, 0x29, 0x6a, 0xdb, 0xd6, 0x23, 0xeb,
+	0x08, 0xd0, 0xd7, 0x2e, 0xe1, 0xd7, 0xc7, 0xc9, 0x7a, 0x1b, 0xd6, 0x0b, 0x14, 0xe3, 0x88, 0x86,
+	0x31, 0x96, 0x02, 0x70, 0x97, 0x27, 0xb1, 0x24, 0xb6, 0x62, 0xeb, 0x91, 0x85, 0x61, 0xe3, 0x4b,
+	0x12, 0x1b, 0x74, 0xfc, 0x9f, 0x88, 0xb0, 0x09, 0xb5, 0x53, 0xca, 0x02, 0x97, 0x1b, 0x09, 0xd4,
+	0x08, 0x21, 0xa8, 0xba, 0x6c, 0x14, 0xf7, 0x2b, 0x77, 0x2b, 0x5b, 0x0d, 0x5b, 0xfe, 0x8b, 0x53,
+	0x39, 0xc3, 0x46, 0xcb, 0xf5, 0x0a, 0xb4, 0xb4, 0xdd, 0x9d, 0x09, 0x89, 0xb9, 0xe4, 0xd3, 0xb2,
+	0x9b, 0x1a, 0x26, 0xd6, 0x58, 0x14, 0x36, 0x9f, 0x47, 0xfe, 0x15, 0x1d, 0xfe, 0x3e, 0x34, 0x18,
+	0x8e, 0x69, 0xc2, 0x84, 0x9b, 0x96, 0xe5, 0xbe, 0x6f, 0xa8, 0x7d, 0xff, 0x92, 0x84, 0xc9, 0x85,
+	0x6d, 0xe6, 0xec, 0x0c, 0x4d, 0xbb, 0x10, 0x8f, 0xaf, 0xe2, 0x42, 0x1f, 0xc3, 0x8d, 0x23, 0x37,
+	0x89, 0xaf, 0x22, 0xab, 0xf5, 0x89, 0x70, 0xbf, 0x38, 0x09, 0xae, 0xb4, 0xf8, 0x0f, 0x25, 0xa8,
+	0xef, 0x46, 0xc9, 0xf3, 0xd8, 0x1d, 0x61, 0xf4, 0x3f, 0xd0, 0xe4, 0x94, 0xbb, 0x13, 0x27, 0x11,
+	0x43, 0x89, 0x5e, 0xb5, 0x41, 0x82, 0x14, 0x82, 0x30, 0x3b, 0x66, 0x5e, 0x94, 0x68, 0x8c, 0xf2,
+	0xdd, 0xca, 0x56, 0xd5, 0x6e, 0x2a, 0x98, 0x42, 0x19, 0xc2, 0xba, 0x9c, 0x73, 0x48, 0xe8, 0x9c,
+	0x61, 0x16, 0xe2, 0x49, 0x40, 0x7d, 0x2c, 0xcf, 0x6f, 0xd5, 0xee, 0xc9, 0xa9, 0xc3, 0xf0, 0x8b,
+	0x74, 0x02, 0xfd, 0x2f, 0xf4, 0x52, 0x7c, 0xe1, 0x94, 0x12, 0xbb, 0x2a, 0xb1, 0xbb, 0x1a, 0xfb,
+	0xb9, 0x06, 0x5b, 0xbf, 0x84, 0xce, 0xb3, 0x31, 0xa3, 0x9c, 0x4f, 0x48, 0x38, 0x7a, 0xec, 0x72,
+	0x57, 0x44, 0x8f, 0x08, 0x33, 0x42, 0xfd, 0x58, 0x4b, 0x6b, 0x86, 0xe8, 0x2d, 0xe8, 0x71, 0x85,
+	0x8b, 0x7d, 0xc7, 0xe0, 0x94, 0x25, 0xce, 0x5a, 0x3a, 0x71, 0xa4, 0x91, 0x5f, 0x87, 0x4e, 0x86,
+	0x2c, 0xe2, 0x8f, 0x96, 0xb7, 0x9d, 0x42, 0x9f, 0x91, 0x00, 0x5b, 0xe7, 0xd2, 0x56, 0x72, 0x93,
+	0xd1, 0x5b, 0xd0, 0xc8, 0xec, 0x50, 0x92, 0x27, 0xa4, 0xa3, 0x4e, 0x88, 0x31, 0xa7, 0x5d, 0x4f,
+	0x8d, 0xf2, 0x29, 0x74, 0x79, 0x2a, 0xb8, 0xe3, 0xbb, 0xdc, 0x2d, 0x1e, 0xaa, 0xa2, 0x56, 0x76,
+	0x87, 0x17, 0xc6, 0xd6, 0x27, 0xd0, 0x38, 0x22, 0x7e, 0xac, 0x18, 0xf7, 0x61, 0xd5, 0x4b, 0x18,
+	0xc3, 0x21, 0x37, 0x2a, 0xeb, 0x21, 0xda, 0x80, 0x95, 0x09, 0x09, 0x08, 0xd7, 0x6a, 0xaa, 0x81,
+	0x45, 0x01, 0x9e, 0xe0, 0x80, 0xb2, 0xa9, 0x34, 0xd8, 0x06, 0xac, 0xe4, 0x37, 0x57, 0x0d, 0xd0,
+	0x6d, 0x68, 0x04, 0xee, 0x45, 0xba, 0xa9, 0x62, 0xa6, 0x1e, 0xb8, 0x17, 0x4a, 0xf8, 0x3e, 0xac,
+	0x9e, 0xba, 0x64, 0xe2, 0x85, 0x5c, 0x5b, 0xc5, 0x0c, 0x33, 0x86, 0xd5, 0x3c, 0xc3, 0xbf, 0x94,
+	0xa1, 0xa9, 0x38, 0x2a, 0x81, 0x37, 0x60, 0xc5, 0x73, 0xbd, 0x71, 0xca, 0x52, 0x0e, 0xd0, 0x3d,
+	0x23, 0x48, 0x39, 0x1f, 0x84, 0x33, 0x49, 0x8d, 0x68, 0xdb, 0x00, 0xf1, 0x0b, 0x37, 0xd2, 0xb2,
+	0x55, 0x2e, 0x41, 0x6e, 0x08, 0x1c, 0x25, 0xee, 0x7b, 0xd0, 0x52, 0xe7, 0x4e, 0x2f, 0xa9, 0x5e,
+	0xb2, 0xa4, 0xa9, 0xb0, 0xd4, 0xa2, 0x57, 0xa1, 0x9d, 0xc4, 0xd8, 0x19, 0x13, 0xcc, 0x5c, 0xe6,
+	0x8d, 0xa7, 0xfd, 0x15, 0x75, 0x47, 0x26, 0x31, 0x3e, 0x30, 0x30, 0x74, 0x1f, 0x56, 0x44, 0xf8,
+	0x8b, 0xfb, 0x35, 0x79, 0x1d, 0xbf, 0x94, 0x27, 0x29, 0x55, 0x1d, 0xca, 0xef, 0x5e, 0xc8, 0xd9,
+	0xd4, 0x56, 0xa8, 0x83, 0x0f, 0x01, 0x32, 0x20, 0x5a, 0x83, 0xca, 0x19, 0x9e, 0x6a, 0x3f, 0x14,
+	0xbf, 0xc2, 0x38, 0xe7, 0xee, 0x24, 0x31, 0x56, 0x57, 0x83, 0x8f, 0xcb, 0x1f, 0x96, 0x2c, 0x0f,
+	0xba, 0x3b, 0x93, 0x33, 0x42, 0x73, 0xcb, 0x37, 0x60, 0x25, 0x70, 0xbf, 0xa1, 0xcc, 0x58, 0x52,
+	0x0e, 0x24, 0x94, 0x84, 0x94, 0x19, 0x12, 0x72, 0x80, 0x3a, 0x50, 0xa6, 0x91, 0xb4, 0x57, 0xc3,
+	0x2e, 0xd3, 0x28, 0x63, 0x54, 0xcd, 0x31, 0xb2, 0xfe, 0x5e, 0x05, 0xc8, 0xb8, 0x20, 0x1b, 0x06,
+	0x84, 0x3a, 0x31, 0x66, 0x22, 0x05, 0x71, 0x4e, 0xa6, 0x1c, 0xc7, 0x0e, 0xc3, 0x5e, 0xc2, 0x62,
+	0x72, 0x2e, 0xf6, 0x4f, 0xa8, 0x7d, 0x43, 0xa9, 0x3d, 0x23, 0x9b, 0x7d, 0x93, 0xd0, 0x63, 0xb5,
+	0x6e, 0x47, 0x2c, 0xb3, 0xcd, 0x2a, 0x74, 0x08, 0x37, 0x32, 0x9a, 0x7e, 0x8e, 0x5c, 0x79, 0x19,
+	0xb9, 0xf5, 0x94, 0x9c, 0x9f, 0x91, 0xda, 0x83, 0x75, 0x42, 0x9d, 0x6f, 0x13, 0x9c, 0x14, 0x08,
+	0x55, 0x96, 0x11, 0xea, 0x11, 0xfa, 0x13, 0xb9, 0x20, 0x23, 0x73, 0x04, 0xb7, 0x72, 0x5a, 0x0a,
+	0x77, 0xcf, 0x11, 0xab, 0x2e, 0x23, 0xb6, 0x99, 0x4a, 0x25, 0xe2, 0x41, 0x46, 0xf1, 0x73, 0xd8,
+	0x24, 0xd4, 0x79, 0xe1, 0x12, 0x3e, 0x4b, 0x6e, 0xe5, 0x47, 0x94, 0x14, 0x97, 0x6e, 0x91, 0x96,
+	0x52, 0x32, 0xc0, 0x6c, 0x54, 0x50, 0xb2, 0xf6, 0x23, 0x4a, 0x3e, 0x91, 0x0b, 0x32, 0x32, 0x8f,
+	0xa0, 0x47, 0xe8, 0xac, 0x34, 0xab, 0xcb, 0x88, 0x74, 0x09, 0x2d, 0x4a, 0xb2, 0x03, 0xbd, 0x18,
+	0x7b, 0x9c, 0xb2, 0xfc, 0x21, 0xa8, 0x2f, 0x23, 0xb1, 0xa6, 0xf1, 0x53, 0x1a, 0xd6, 0xcf, 0xa0,
+	0x75, 0x90, 0x8c, 0x30, 0x9f, 0x9c, 0xa4, 0xc1, 0xe0, 0xda, 0xe2, 0x8f, 0xf5, 0xcf, 0x32, 0x34,
+	0x77, 0x47, 0x8c, 0x26, 0x51, 0x21, 0x26, 0x2b, 0x27, 0x9d, 0x8d, 0xc9, 0x12, 0x45, 0xc6, 0x64,
+	0x85, 0xfc, 0x3e, 0xb4, 0x02, 0xe9, 0xba, 0x1a, 0x5f, 0xc5, 0xa1, 0xde, 0x9c, 0x53, 0xdb, 0xcd,
+	0x20, 0x17, 0xcc, 0x86, 0x00, 0x11, 0xf1, 0x63, 0xbd, 0x46, 0x85, 0xa3, 0xae, 0xce, 0x08, 0x4d,
+	0x88, 0xb6, 0x1b, 0x51, 0x1a, 0xad, 0xdf, 0x85, 0xe6, 0x89, 0x30, 0x92, 0x5e, 0x50, 0x08, 0x46,
+	0x99, 0xf5, 0x6c, 0x38, 0xc9, 0x9c, 0xf0, 0x00, 0xda, 0x63, 0x65, 0x32, 0xbd, 0x48, 0x9d, 0xa1,
+	0x57, 0xb5, 0x26, 0x99, 0xbe, 0xc3, 0xbc, 0x65, 0xd5, 0x06, 0xb4, 0xc6, 0x39, 0xd0, 0xe0, 0x18,
+	0x7a, 0x73, 0x28, 0x0b, 0x62, 0xd0, 0x56, 0x3e, 0x06, 0x35, 0xef, 0x23, 0xc5, 0x28, 0xbf, 0x32,
+	0x1f, 0x97, 0x7e, 0x53, 0x86, 0xd6, 0x57, 0x98, 0xbf, 0xa0, 0xec, 0x4c, 0xc9, 0x8b, 0xa0, 0x1a,
+	0xba, 0x01, 0xd6, 0x14, 0xe5, 0x3f, 0xba, 0x05, 0x75, 0x76, 0xa1, 0x02, 0x88, 0xde, 0xcf, 0x55,
+	0x76, 0x21, 0x03, 0x03, 0x7a, 0x19, 0x80, 0x5d, 0x38, 0x91, 0xeb, 0x9d, 0x61, 0x6d, 0xc1, 0xaa,
+	0xdd, 0x60, 0x17, 0x47, 0x0a, 0x20, 0x8e, 0x02, 0xbb, 0x70, 0x30, 0x63, 0x94, 0xc5, 0x3a, 0x56,
+	0xd5, 0xd9, 0xc5, 0x9e, 0x1c, 0xeb, 0xb5, 0x3e, 0xa3, 0x51, 0x84, 0x7d, 0x19, 0xa3, 0xe5, 0xda,
+	0xc7, 0x0a, 0x20, 0xb8, 0x72, 0xc3, 0xb5, 0xa6, 0xb8, 0xf2, 0x8c, 0x2b, 0xcf, 0xb8, 0xae, 0xaa,
+	0x95, 0x3c, 0xcf, 0x95, 0xa7, 0x5c, 0xeb, 0x8a, 0x2b, 0xcf, 0x71, 0xe5, 0x19, 0xd7, 0x86, 0x59,
+	0xab, 0xb9, 0x5a, 0xbf, 0x2e, 0xc1, 0xe6, 0x6c, 0xe2, 0xa7, 0xd3, 0xd4, 0xf7, 0xa1, 0xe5, 0xc9,
+	0xfd, 0x2a, 0x9c, 0xc9, 0xde, 0xdc, 0x4e, 0xda, 0x4d, 0x2f, 0x77, 0x8c, 0x1f, 0x40, 0x3b, 0x54,
+	0x06, 0x4e, 0x8f, 0x66, 0x25, 0xdb, 0x97, 0xbc, 0xed, 0xed, 0x56, 0x98, 0x1b, 0x59, 0x3e, 0xa0,
+	0xaf, 0x19, 0xe1, 0xf8, 0x98, 0x33, 0xec, 0x06, 0xd7, 0x51, 0x80, 0x20, 0xa8, 0xca, 0x6c, 0xa5,
+	0x22, 0xf3, 0x6b, 0xf9, 0x6f, 0xbd, 0x01, 0xeb, 0x05, 0x2e, 0x5a, 0xd7, 0x35, 0xa8, 0x4c, 0x70,
+	0x28, 0xa9, 0xb7, 0x6d, 0xf1, 0x6b, 0xb9, 0xd0, 0xb3, 0xb1, 0xeb, 0x5f, 0x9f, 0x34, 0x9a, 0x45,
+	0x25, 0x63, 0xb1, 0x05, 0x28, 0xcf, 0x42, 0x8b, 0x62, 0xa4, 0x2e, 0xe5, 0xa4, 0x7e, 0x0a, 0xbd,
+	0xdd, 0x09, 0x8d, 0xf1, 0x31, 0xf7, 0x49, 0x78, 0x1d, 0x15, 0xd3, 0x2f, 0x60, 0xfd, 0x19, 0x9f,
+	0x7e, 0x2d, 0x88, 0xc5, 0xe4, 0x3b, 0x7c, 0x4d, 0xfa, 0x31, 0xfa, 0xc2, 0xe8, 0xc7, 0xe8, 0x0b,
+	0x51, 0x2c, 0x79, 0x74, 0x92, 0x04, 0xa1, 0x74, 0x85, 0xb6, 0xad, 0x47, 0xd6, 0x0e, 0xb4, 0x54,
+	0x0e, 0xfd, 0x84, 0xfa, 0xc9, 0x04, 0x2f, 0xf4, 0xc1, 0x3b, 0x00, 0x91, 0xcb, 0xdc, 0x00, 0x73,
+	0xcc, 0xd4, 0x19, 0x6a, 0xd8, 0x39, 0x88, 0xf5, 0xbb, 0x32, 0x6c, 0xa8, 0x96, 0xc8, 0xb1, 0xea,
+	0x04, 0x18, 0x15, 0x06, 0x50, 0x1f, 0xd3, 0x98, 0xe7, 0x08, 0xa6, 0x63, 0x21, 0xa2, 0x1f, 0x1a,
+	0x6a, 0xe2, 0xb7, 0xd0, 0xa7, 0xa8, 0x2c, 0xef, 0x53, 0xcc, 0x75, 0x22, 0xaa, 0xf3, 0x9d, 0x08,
+	0xe1, 0x6d, 0x06, 0x89, 0x28, 0x1f, 0x6f, 0xd8, 0x0d, 0x0d, 0x39, 0xf4, 0xd1, 0x3d, 0xe8, 0x8e,
+	0x84, 0x94, 0xce, 0x98, 0xd2, 0x33, 0x27, 0x72, 0xf9, 0x58, 0xba, 0x7a, 0xc3, 0x6e, 0x4b, 0xf0,
+	0x01, 0xa5, 0x67, 0x47, 0x2e, 0x1f, 0xa3, 0x8f, 0xa0, 0xa3, 0xd3, 0xc0, 0x40, 0x9a, 0x28, 0xd6,
+	0x97, 0x9f, 0xf6, 0xa2, 0xbc, 0xf5, 0xec, 0xf6, 0x59, 0x6e, 0x14, 0x5b, 0x37, 0xe1, 0xc6, 0x63,
+	0x1c, 0x73, 0x46, 0xa7, 0x45, 0xc3, 0x58, 0xff, 0x0f, 0x70, 0x18, 0x72, 0xcc, 0x4e, 0x5d, 0x0f,
+	0xc7, 0xe8, 0x9d, 0xfc, 0x48, 0x27, 0x47, 0x6b, 0x43, 0xd5, 0x91, 0x4a, 0x27, 0xec, 0x1c, 0x8e,
+	0x35, 0x84, 0x9a, 0x4d, 0x13, 0x11, 0x8e, 0x5e, 0x33, 0x7f, 0x7a, 0x5d, 0x4b, 0xaf, 0x93, 0x40,
+	0x5b, 0xcf, 0x59, 0x07, 0xa6, 0x84, 0xcd, 0xc8, 0xe9, 0x2d, 0x1a, 0x42, 0x83, 0x18, 0x98, 0x8e,
+	0x2a, 0xf3, 0xac, 0x33, 0x14, 0xeb, 0x13, 0x58, 0x57, 0x94, 0x14, 0x65, 0x43, 0xe6, 0x35, 0xa8,
+	0x31, 0x23, 0x46, 0x29, 0x6b, 0x45, 0x69, 0x24, 0x3d, 0x27, 0xec, 0x21, 0x2a, 0xea, 0x4c, 0x11,
+	0x63, 0x8f, 0x75, 0xe8, 0x89, 0x89, 0x02, 0x4d, 0xeb, 0x33, 0x68, 0x3d, 0xb2, 0x8f, 0xbe, 0xc2,
+	0x64, 0x34, 0x3e, 0x11, 0xd1, 0xf3, 0x83, 0xe2, 0x58, 0x2b, 0x8c, 0xb4, 0xb4, 0xb9, 0x29, 0xbb,
+	0x80, 0x67, 0x7d, 0x0e, 0x9b, 0x8f, 0x7c, 0x3f, 0x0f, 0x32, 0x52, 0xbf, 0x03, 0x8d, 0x30, 0x47,
+	0x2e, 0x77, 0x67, 0x15, 0xb0, 0x33, 0x24, 0xeb, 0xe7, 0xb0, 0xfe, 0x34, 0x9c, 0x90, 0x10, 0xef,
+	0x1e, 0x3d, 0x7f, 0x82, 0xd3, 0x58, 0x84, 0xa0, 0x2a, 0x72, 0x36, 0x49, 0xa3, 0x6e, 0xcb, 0x7f,
+	0xe1, 0x9c, 0xe1, 0x89, 0xe3, 0x45, 0x49, 0xac, 0xfb, 0x51, 0xb5, 0xf0, 0x64, 0x37, 0x4a, 0x62,
+	0x71, 0xb9, 0x88, 0xe4, 0x82, 0x86, 0x93, 0xa9, 0xf4, 0xd0, 0xba, 0xbd, 0xea, 0x45, 0xc9, 0xd3,
+	0x70, 0x32, 0xb5, 0xfe, 0x4f, 0x56, 0xe0, 0x18, 0xfb, 0xb6, 0x1b, 0xfa, 0x34, 0x78, 0x8c, 0xcf,
+	0x73, 0x1c, 0xd2, 0x6a, 0xcf, 0x44, 0xa2, 0xef, 0x4b, 0xd0, 0x7a, 0x34, 0xc2, 0x21, 0x7f, 0x8c,
+	0xb9, 0x4b, 0x26, 0xb2, 0xa2, 0x3b, 0xc7, 0x2c, 0x26, 0x34, 0xd4, 0xee, 0x66, 0x86, 0xa2, 0x20,
+	0x27, 0x21, 0xe1, 0x8e, 0xef, 0xe2, 0x80, 0x86, 0x92, 0x4a, 0xdd, 0x06, 0x01, 0x7a, 0x2c, 0x21,
+	0xe8, 0x0d, 0xe8, 0xaa, 0x7e, 0xa1, 0x33, 0x76, 0x43, 0x7f, 0x22, 0x1c, 0x5d, 0xf5, 0x4f, 0x3a,
+	0x0a, 0x7c, 0xa0, 0xa1, 0xe8, 0x4d, 0x58, 0xd3, 0x6e, 0x98, 0x61, 0x56, 0x25, 0x66, 0x57, 0xc3,
+	0x0b, 0xa8, 0x49, 0x14, 0x51, 0xc6, 0x63, 0x27, 0xc6, 0x9e, 0x47, 0x83, 0x48, 0x97, 0x43, 0x5d,
+	0x03, 0x3f, 0x56, 0x60, 0x6b, 0x04, 0xeb, 0xfb, 0x42, 0x4f, 0xad, 0x49, 0x76, 0xac, 0x3a, 0x01,
+	0x0e, 0x9c, 0x93, 0x09, 0xf5, 0xce, 0x1c, 0x11, 0x1c, 0xb5, 0x85, 0x45, 0xc2, 0xb5, 0x23, 0x80,
+	0xc7, 0xe4, 0x3b, 0x59, 0xf9, 0x0b, 0xac, 0x31, 0xe5, 0xd1, 0x24, 0x19, 0x39, 0x11, 0xa3, 0x27,
+	0x58, 0xab, 0xd8, 0x0d, 0x70, 0x70, 0xa0, 0xe0, 0x47, 0x02, 0x6c, 0xfd, 0xb9, 0x04, 0x1b, 0x45,
+	0x4e, 0x3a, 0xd4, 0x6f, 0xc3, 0x46, 0x91, 0x95, 0xbe, 0xfe, 0x55, 0x7a, 0xd9, 0xcb, 0x33, 0x54,
+	0x89, 0xc0, 0x03, 0x68, 0xcb, 0x26, 0xb2, 0xe3, 0x2b, 0x4a, 0xc5, 0xa4, 0x27, 0xbf, 0x2f, 0x76,
+	0xcb, 0xcd, 0xef, 0xd2, 0x47, 0x70, 0x4b, 0xab, 0xef, 0xcc, 0x8b, 0xad, 0x0e, 0xc4, 0xa6, 0x46,
+	0x78, 0x32, 0x23, 0xfd, 0x97, 0xd0, 0xcf, 0x40, 0x3b, 0x53, 0x09, 0xcc, 0x0e, 0xf3, 0xfa, 0x8c,
+	0xb2, 0x8f, 0x7c, 0x9f, 0x49, 0x2f, 0xa9, 0xda, 0x8b, 0xa6, 0xac, 0x87, 0x70, 0xf3, 0x18, 0x73,
+	0x65, 0x0d, 0x97, 0xeb, 0x4a, 0x44, 0x11, 0x5b, 0x83, 0xca, 0x31, 0xf6, 0xa4, 0xf2, 0x15, 0x5b,
+	0xfc, 0x8a, 0x03, 0xf8, 0x3c, 0xc6, 0x9e, 0xd4, 0xb2, 0x62, 0xcb, 0x7f, 0xeb, 0x4f, 0x25, 0x58,
+	0xd5, 0xc1, 0x59, 0x5c, 0x30, 0x3e, 0x23, 0xe7, 0x98, 0xe9, 0xa3, 0xa7, 0x47, 0xe8, 0x75, 0xe8,
+	0xa8, 0x3f, 0x87, 0x46, 0x9c, 0xd0, 0x34, 0xe4, 0xb7, 0x15, 0xf4, 0xa9, 0x02, 0xca, 0xfe, 0xa0,
+	0x6c, 0x7f, 0xe9, 0x4a, 0x53, 0x8f, 0x64, 0x93, 0x2f, 0x16, 0x1e, 0x2e, 0x43, 0x7c, 0xc3, 0xd6,
+	0x23, 0x71, 0xd4, 0x0d, 0xbd, 0x15, 0x49, 0xcf, 0x0c, 0xc5, 0x51, 0x0f, 0x68, 0x12, 0x72, 0x27,
+	0xa2, 0x24, 0xe4, 0x3a, 0xa6, 0x83, 0x04, 0x1d, 0x09, 0x88, 0xf5, 0xab, 0x12, 0xd4, 0x54, 0x8f,
+	0x5c, 0xd4, 0xb6, 0xe9, 0xcd, 0x5a, 0x26, 0x32, 0x4b, 0x91, 0xbc, 0xd4, 0x6d, 0x2a, 0xff, 0x85,
+	0x1f, 0x9f, 0x07, 0xea, 0x7e, 0xd0, 0xa2, 0x9d, 0x07, 0xf2, 0x62, 0x78, 0x1d, 0x3a, 0xd9, 0x05,
+	0x2d, 0xe7, 0x95, 0x88, 0xed, 0x14, 0x2a, 0xd1, 0x2e, 0x95, 0xd4, 0xfa, 0xa9, 0x28, 0xe9, 0xd3,
+	0xfe, 0xf0, 0x1a, 0x54, 0x92, 0x54, 0x18, 0xf1, 0x2b, 0x20, 0xa3, 0xf4, 0x6a, 0x17, 0xbf, 0xe8,
+	0x1e, 0x74, 0x5c, 0xdf, 0x27, 0x62, 0xb9, 0x3b, 0xd9, 0x27, 0x7e, 0xea, 0xa4, 0x45, 0xa8, 0xf5,
+	0xd7, 0x12, 0x74, 0x77, 0x69, 0x34, 0xfd, 0x8c, 0x4c, 0x70, 0x2e, 0x82, 0x48, 0x21, 0xf5, 0xcd,
+	0x2e, 0xfe, 0x45, 0xb6, 0x7a, 0x4a, 0x26, 0x58, 0xb9, 0x96, 0xda, 0xd9, 0xba, 0x00, 0x48, 0xb7,
+	0x32, 0x93, 0x69, 0xdb, 0xad, 0xad, 0x26, 0x9f, 0x50, 0x5f, 0xe6, 0xe5, 0x3e, 0x61, 0x4e, 0xda,
+	0x64, 0x6b, 0xdb, 0xab, 0x3e, 0x61, 0x72, 0x4a, 0x2b, 0xb2, 0x22, 0xfb, 0xbc, 0x79, 0x45, 0x6a,
+	0x0a, 0x22, 0x14, 0xd9, 0x84, 0x1a, 0x3d, 0x3d, 0x8d, 0x31, 0x97, 0x19, 0x74, 0xc5, 0xd6, 0xa3,
+	0x34, 0xcc, 0xd5, 0x73, 0x61, 0xee, 0x06, 0xac, 0xcb, 0x17, 0x85, 0x67, 0xcc, 0xf5, 0x48, 0x38,
+	0x32, 0xd7, 0xc3, 0x06, 0xa0, 0x63, 0x4e, 0xa3, 0x79, 0xe8, 0x3e, 0xe6, 0x4f, 0x9f, 0x3e, 0xd9,
+	0x3b, 0xc7, 0x21, 0x37, 0xd0, 0xb7, 0xa1, 0x6e, 0x40, 0xff, 0x46, 0x5e, 0x75, 0xff, 0xb7, 0x3d,
+	0x1d, 0x58, 0x75, 0x8d, 0x8e, 0xf6, 0xa1, 0x3b, 0xf3, 0xe6, 0x83, 0x74, 0xd3, 0x66, 0xf1, 0x53,
+	0xd0, 0x60, 0x73, 0xa8, 0xde, 0x90, 0x86, 0xe6, 0x0d, 0x69, 0xb8, 0x17, 0x44, 0x7c, 0x8a, 0xf6,
+	0xa0, 0x53, 0x7c, 0x1d, 0x41, 0xb7, 0x4d, 0x8e, 0xb3, 0xe0, 0xcd, 0xe4, 0x52, 0x32, 0xfb, 0xd0,
+	0x9d, 0x79, 0x28, 0x31, 0xf2, 0x2c, 0x7e, 0x3f, 0xb9, 0x94, 0xd0, 0x43, 0x68, 0xe6, 0x5e, 0x46,
+	0x50, 0x5f, 0x11, 0x99, 0x7f, 0x2c, 0xb9, 0x94, 0xc0, 0x2e, 0xb4, 0x0b, 0x8f, 0x15, 0x68, 0xa0,
+	0xf5, 0x59, 0xf0, 0x82, 0x71, 0x29, 0x91, 0x1d, 0x68, 0xe6, 0xde, 0x0c, 0x8c, 0x14, 0xf3, 0x0f,
+	0x13, 0x83, 0x5b, 0x0b, 0x66, 0x74, 0xfc, 0x3e, 0x80, 0x76, 0xa1, 0xc3, 0x6f, 0x04, 0x59, 0xf4,
+	0xba, 0x30, 0xb8, 0xbd, 0x70, 0x4e, 0x53, 0xda, 0x87, 0xee, 0x4c, 0xbf, 0xdf, 0x18, 0x77, 0xf1,
+	0x33, 0xc0, 0xa5, 0x6a, 0x7d, 0x21, 0x37, 0x3b, 0x57, 0xce, 0xe5, 0x36, 0x7b, 0xbe, 0xbb, 0x3f,
+	0x78, 0x69, 0xf1, 0xa4, 0x96, 0x6a, 0x0f, 0x3a, 0xc5, 0xc6, 0xbe, 0x21, 0xb6, 0xb0, 0xdd, 0xbf,
+	0xfc, 0xe4, 0x14, 0x7a, 0xfc, 0xd9, 0xc9, 0x59, 0xd4, 0xfa, 0xbf, 0x94, 0xd0, 0x23, 0x00, 0x5d,
+	0xbc, 0xf9, 0x24, 0x4c, 0xb7, 0x6c, 0xae, 0x68, 0x4c, 0xb7, 0x6c, 0x41, 0xa1, 0xf7, 0x10, 0x40,
+	0xd5, 0x5c, 0x3e, 0x4d, 0x38, 0xba, 0x69, 0xc4, 0x98, 0x29, 0xf4, 0x06, 0xfd, 0xf9, 0x89, 0x39,
+	0x02, 0x98, 0xb1, 0xab, 0x10, 0xf8, 0x14, 0x20, 0xab, 0xe5, 0x0c, 0x81, 0xb9, 0xea, 0x6e, 0x89,
+	0x0d, 0x5a, 0xf9, 0xca, 0x0d, 0x69, 0x5d, 0x17, 0x54, 0x73, 0x4b, 0x48, 0x74, 0x67, 0x32, 0xf3,
+	0xe2, 0x61, 0x9b, 0x4d, 0xd8, 0x07, 0x73, 0xd9, 0x39, 0x7a, 0x00, 0xad, 0x7c, 0x4a, 0x6e, 0xa4,
+	0x58, 0x90, 0xa6, 0x0f, 0x0a, 0x69, 0x39, 0x7a, 0x08, 0x9d, 0x62, 0x3a, 0x8e, 0x72, 0x7e, 0x31,
+	0x97, 0xa4, 0x0f, 0x74, 0xb3, 0x29, 0x87, 0xfe, 0x1e, 0x40, 0x96, 0xb6, 0x1b, 0xf3, 0xcd, 0x25,
+	0xf2, 0x33, 0x5c, 0xf7, 0xa1, 0x3b, 0x93, 0x8e, 0x1b, 0x8d, 0x17, 0x67, 0xe9, 0xcb, 0xac, 0x9f,
+	0xbf, 0x17, 0x8c, 0xde, 0x0b, 0xee, 0x8a, 0x65, 0xe1, 0x2f, 0x77, 0x87, 0x98, 0x53, 0x3c, 0x7f,
+	0xad, 0x2c, 0x0b, 0x7f, 0x85, 0xca, 0xd7, 0x44, 0x9d, 0x45, 0xe5, 0xf0, 0xb2, 0x4b, 0xa1, 0x58,
+	0x26, 0x9a, 0x7d, 0x58, 0x58, 0x3c, 0x2e, 0xb3, 0x47, 0xbe, 0x36, 0x31, 0xf6, 0x58, 0x50, 0xaf,
+	0xfc, 0x48, 0x74, 0xc8, 0xd7, 0x1f, 0xb9, 0xe8, 0xb0, 0xa0, 0x2c, 0xb9, 0x94, 0xd0, 0x01, 0x74,
+	0xf7, 0x4d, 0x6a, 0xa9, 0xd3, 0x5e, 0x2d, 0xce, 0x82, 0x34, 0x7f, 0x30, 0x58, 0x34, 0xa5, 0x5d,
+	0xf4, 0x0b, 0xe8, 0xcd, 0xa5, 0xbc, 0xe8, 0x4e, 0xda, 0x5c, 0x5d, 0x98, 0x0b, 0x5f, 0x2a, 0xd6,
+	0x21, 0xac, 0xcd, 0x66, 0xbc, 0xe8, 0x65, 0xbd, 0xe9, 0x8b, 0x33, 0xe1, 0x4b, 0x49, 0x7d, 0x04,
+	0x75, 0x93, 0x61, 0x21, 0xdd, 0xc4, 0x9e, 0xc9, 0xb8, 0x2e, 0x5d, 0xfa, 0x00, 0x9a, 0xb9, 0x1c,
+	0xc5, 0x9c, 0xba, 0xf9, 0xb4, 0x65, 0xa0, 0x7b, 0xce, 0x06, 0xbc, 0xd3, 0xfa, 0xfe, 0x87, 0x3b,
+	0xa5, 0xbf, 0xfd, 0x70, 0xa7, 0xf4, 0x8f, 0x1f, 0xee, 0x94, 0x4e, 0x6a, 0x92, 0xec, 0x7b, 0xff,
+	0x0a, 0x00, 0x00, 0xff, 0xff, 0xe8, 0x9e, 0x94, 0x1d, 0x05, 0x23, 0x00, 0x00,
 }
diff --git a/protocols/grpc/agent.proto b/protocols/grpc/agent.proto
index 2dae78ac07..24773c93e9 100644
--- a/protocols/grpc/agent.proto
+++ b/protocols/grpc/agent.proto
@@ -46,6 +46,7 @@ service AgentService {
 	rpc UpdateRoutes(UpdateRoutesRequest) returns (Routes);
 	rpc ListInterfaces(ListInterfacesRequest) returns(Interfaces);
 	rpc ListRoutes(ListRoutesRequest) returns (Routes);
+	rpc AddARPNeighbors(AddARPNeighborsRequest) returns (google.protobuf.Empty);
 
 	// tracing
 	rpc StartTracing(StartTracingRequest) returns (google.protobuf.Empty);
@@ -325,6 +326,14 @@ message ListInterfacesRequest {
 message ListRoutesRequest {
 }
 
+message ARPNeighbors {
+       repeated types.ARPNeighbor ARPNeighbors = 1;
+}
+
+message AddARPNeighborsRequest {
+       ARPNeighbors neighbors = 1;
+}
+
 message OnlineCPUMemRequest {
 	// Wait specifies if the caller waits for the agent to online all resources.
 	// If true the agent returns once all resources have been connected, otherwise all
diff --git a/protocols/grpc/health.pb.go b/protocols/grpc/health.pb.go
index 2126ae3259..9dd54fbe32 100644
--- a/protocols/grpc/health.pb.go
+++ b/protocols/grpc/health.pb.go
@@ -8,8 +8,10 @@ import fmt "fmt"
 import math "math"
 import _ "github.com/gogo/protobuf/gogoproto"
 
-import context "golang.org/x/net/context"
-import grpc1 "google.golang.org/grpc"
+import (
+	context "golang.org/x/net/context"
+	grpc1 "google.golang.org/grpc"
+)
 
 import io "io"
 
@@ -108,7 +110,10 @@ func init() {
 }
 func (this *CheckRequest) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*CheckRequest)
@@ -121,7 +126,10 @@ func (this *CheckRequest) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -132,7 +140,10 @@ func (this *CheckRequest) Equal(that interface{}) bool {
 }
 func (this *HealthCheckResponse) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*HealthCheckResponse)
@@ -145,7 +156,10 @@ func (this *HealthCheckResponse) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -156,7 +170,10 @@ func (this *HealthCheckResponse) Equal(that interface{}) bool {
 }
 func (this *VersionCheckResponse) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*VersionCheckResponse)
@@ -169,7 +186,10 @@ func (this *VersionCheckResponse) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
diff --git a/protocols/grpc/healthpb_test.go b/protocols/grpc/healthpb_test.go
index ecbdacff5b..16a23cddc2 100644
--- a/protocols/grpc/healthpb_test.go
+++ b/protocols/grpc/healthpb_test.go
@@ -4,10 +4,11 @@
 package grpc
 
 import testing "testing"
-import rand "math/rand"
+import math_rand "math/rand"
 import time "time"
+import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
+import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb"
 import proto "github.com/gogo/protobuf/proto"
-import jsonpb "github.com/gogo/protobuf/jsonpb"
 import fmt "fmt"
 import math "math"
 import _ "github.com/gogo/protobuf/gogoproto"
@@ -19,14 +20,14 @@ var _ = math.Inf
 
 func TestCheckRequestProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedCheckRequest(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &CheckRequest{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -44,13 +45,13 @@ func TestCheckRequestProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestCheckRequestMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedCheckRequest(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -62,7 +63,7 @@ func TestCheckRequestMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &CheckRequest{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -74,7 +75,7 @@ func TestCheckRequestMarshalTo(t *testing.T) {
 }
 
 func BenchmarkCheckRequestProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*CheckRequest, 10000)
 	for i := 0; i < 10000; i++ {
@@ -82,7 +83,7 @@ func BenchmarkCheckRequestProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -92,11 +93,11 @@ func BenchmarkCheckRequestProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkCheckRequestProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedCheckRequest(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCheckRequest(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -106,7 +107,7 @@ func BenchmarkCheckRequestProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -115,14 +116,14 @@ func BenchmarkCheckRequestProtoUnmarshal(b *testing.B) {
 
 func TestHealthCheckResponseProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedHealthCheckResponse(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &HealthCheckResponse{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -140,13 +141,13 @@ func TestHealthCheckResponseProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestHealthCheckResponseMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedHealthCheckResponse(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -158,7 +159,7 @@ func TestHealthCheckResponseMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &HealthCheckResponse{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -170,7 +171,7 @@ func TestHealthCheckResponseMarshalTo(t *testing.T) {
 }
 
 func BenchmarkHealthCheckResponseProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*HealthCheckResponse, 10000)
 	for i := 0; i < 10000; i++ {
@@ -178,7 +179,7 @@ func BenchmarkHealthCheckResponseProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -188,11 +189,11 @@ func BenchmarkHealthCheckResponseProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkHealthCheckResponseProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedHealthCheckResponse(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedHealthCheckResponse(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -202,7 +203,7 @@ func BenchmarkHealthCheckResponseProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -211,14 +212,14 @@ func BenchmarkHealthCheckResponseProtoUnmarshal(b *testing.B) {
 
 func TestVersionCheckResponseProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedVersionCheckResponse(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &VersionCheckResponse{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -236,13 +237,13 @@ func TestVersionCheckResponseProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestVersionCheckResponseMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedVersionCheckResponse(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -254,7 +255,7 @@ func TestVersionCheckResponseMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &VersionCheckResponse{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -266,7 +267,7 @@ func TestVersionCheckResponseMarshalTo(t *testing.T) {
 }
 
 func BenchmarkVersionCheckResponseProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*VersionCheckResponse, 10000)
 	for i := 0; i < 10000; i++ {
@@ -274,7 +275,7 @@ func BenchmarkVersionCheckResponseProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -284,11 +285,11 @@ func BenchmarkVersionCheckResponseProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkVersionCheckResponseProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedVersionCheckResponse(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedVersionCheckResponse(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -298,7 +299,7 @@ func BenchmarkVersionCheckResponseProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -307,15 +308,15 @@ func BenchmarkVersionCheckResponseProtoUnmarshal(b *testing.B) {
 
 func TestCheckRequestJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedCheckRequest(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &CheckRequest{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -325,15 +326,15 @@ func TestCheckRequestJSON(t *testing.T) {
 }
 func TestHealthCheckResponseJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedHealthCheckResponse(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &HealthCheckResponse{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -343,15 +344,15 @@ func TestHealthCheckResponseJSON(t *testing.T) {
 }
 func TestVersionCheckResponseJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedVersionCheckResponse(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &VersionCheckResponse{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -361,11 +362,11 @@ func TestVersionCheckResponseJSON(t *testing.T) {
 }
 func TestCheckRequestProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedCheckRequest(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &CheckRequest{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -375,11 +376,11 @@ func TestCheckRequestProtoText(t *testing.T) {
 
 func TestCheckRequestProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedCheckRequest(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &CheckRequest{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -389,11 +390,11 @@ func TestCheckRequestProtoCompactText(t *testing.T) {
 
 func TestHealthCheckResponseProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedHealthCheckResponse(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &HealthCheckResponse{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -403,11 +404,11 @@ func TestHealthCheckResponseProtoText(t *testing.T) {
 
 func TestHealthCheckResponseProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedHealthCheckResponse(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &HealthCheckResponse{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -417,11 +418,11 @@ func TestHealthCheckResponseProtoCompactText(t *testing.T) {
 
 func TestVersionCheckResponseProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedVersionCheckResponse(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &VersionCheckResponse{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -431,11 +432,11 @@ func TestVersionCheckResponseProtoText(t *testing.T) {
 
 func TestVersionCheckResponseProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedVersionCheckResponse(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &VersionCheckResponse{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -445,10 +446,10 @@ func TestVersionCheckResponseProtoCompactText(t *testing.T) {
 
 func TestCheckRequestSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedCheckRequest(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -459,14 +460,14 @@ func TestCheckRequestSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkCheckRequestSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*CheckRequest, 1000)
 	for i := 0; i < 1000; i++ {
@@ -481,10 +482,10 @@ func BenchmarkCheckRequestSize(b *testing.B) {
 
 func TestHealthCheckResponseSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedHealthCheckResponse(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -495,14 +496,14 @@ func TestHealthCheckResponseSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkHealthCheckResponseSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*HealthCheckResponse, 1000)
 	for i := 0; i < 1000; i++ {
@@ -517,10 +518,10 @@ func BenchmarkHealthCheckResponseSize(b *testing.B) {
 
 func TestVersionCheckResponseSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedVersionCheckResponse(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -531,14 +532,14 @@ func TestVersionCheckResponseSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkVersionCheckResponseSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*VersionCheckResponse, 1000)
 	for i := 0; i < 1000; i++ {
diff --git a/protocols/grpc/oci.pb.go b/protocols/grpc/oci.pb.go
index 5296a082f2..cbfbab5870 100644
--- a/protocols/grpc/oci.pb.go
+++ b/protocols/grpc/oci.pb.go
@@ -1499,7 +1499,10 @@ func init() {
 }
 func (this *Spec) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*Spec)
@@ -1512,7 +1515,10 @@ func (this *Spec) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -1560,7 +1566,10 @@ func (this *Spec) Equal(that interface{}) bool {
 }
 func (this *Process) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*Process)
@@ -1573,7 +1582,10 @@ func (this *Process) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -1632,7 +1644,10 @@ func (this *Process) Equal(that interface{}) bool {
 }
 func (this *Box) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*Box)
@@ -1645,7 +1660,10 @@ func (this *Box) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -1659,7 +1677,10 @@ func (this *Box) Equal(that interface{}) bool {
 }
 func (this *User) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*User)
@@ -1672,7 +1693,10 @@ func (this *User) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -1697,7 +1721,10 @@ func (this *User) Equal(that interface{}) bool {
 }
 func (this *LinuxCapabilities) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*LinuxCapabilities)
@@ -1710,7 +1737,10 @@ func (this *LinuxCapabilities) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -1758,7 +1788,10 @@ func (this *LinuxCapabilities) Equal(that interface{}) bool {
 }
 func (this *POSIXRlimit) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*POSIXRlimit)
@@ -1771,7 +1804,10 @@ func (this *POSIXRlimit) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -1788,7 +1824,10 @@ func (this *POSIXRlimit) Equal(that interface{}) bool {
 }
 func (this *Mount) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*Mount)
@@ -1801,7 +1840,10 @@ func (this *Mount) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -1826,7 +1868,10 @@ func (this *Mount) Equal(that interface{}) bool {
 }
 func (this *Root) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*Root)
@@ -1839,7 +1884,10 @@ func (this *Root) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -1853,7 +1901,10 @@ func (this *Root) Equal(that interface{}) bool {
 }
 func (this *Hooks) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*Hooks)
@@ -1866,7 +1917,10 @@ func (this *Hooks) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -1898,7 +1952,10 @@ func (this *Hooks) Equal(that interface{}) bool {
 }
 func (this *Hook) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*Hook)
@@ -1911,7 +1968,10 @@ func (this *Hook) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -1941,7 +2001,10 @@ func (this *Hook) Equal(that interface{}) bool {
 }
 func (this *Linux) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*Linux)
@@ -1954,7 +2017,10 @@ func (this *Linux) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -2036,7 +2102,10 @@ func (this *Linux) Equal(that interface{}) bool {
 }
 func (this *Windows) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*Windows)
@@ -2049,7 +2118,10 @@ func (this *Windows) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -2060,7 +2132,10 @@ func (this *Windows) Equal(that interface{}) bool {
 }
 func (this *Solaris) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*Solaris)
@@ -2073,7 +2148,10 @@ func (this *Solaris) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -2084,7 +2162,10 @@ func (this *Solaris) Equal(that interface{}) bool {
 }
 func (this *LinuxIDMapping) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*LinuxIDMapping)
@@ -2097,7 +2178,10 @@ func (this *LinuxIDMapping) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -2114,7 +2198,10 @@ func (this *LinuxIDMapping) Equal(that interface{}) bool {
 }
 func (this *LinuxNamespace) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*LinuxNamespace)
@@ -2127,7 +2214,10 @@ func (this *LinuxNamespace) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -2141,7 +2231,10 @@ func (this *LinuxNamespace) Equal(that interface{}) bool {
 }
 func (this *LinuxDevice) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*LinuxDevice)
@@ -2154,7 +2247,10 @@ func (this *LinuxDevice) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -2183,7 +2279,10 @@ func (this *LinuxDevice) Equal(that interface{}) bool {
 }
 func (this *LinuxResources) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*LinuxResources)
@@ -2196,7 +2295,10 @@ func (this *LinuxResources) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -2235,7 +2337,10 @@ func (this *LinuxResources) Equal(that interface{}) bool {
 }
 func (this *LinuxMemory) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*LinuxMemory)
@@ -2248,7 +2353,10 @@ func (this *LinuxMemory) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -2277,7 +2385,10 @@ func (this *LinuxMemory) Equal(that interface{}) bool {
 }
 func (this *LinuxCPU) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*LinuxCPU)
@@ -2290,7 +2401,10 @@ func (this *LinuxCPU) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -2319,7 +2433,10 @@ func (this *LinuxCPU) Equal(that interface{}) bool {
 }
 func (this *LinuxWeightDevice) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*LinuxWeightDevice)
@@ -2332,7 +2449,10 @@ func (this *LinuxWeightDevice) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -2352,7 +2472,10 @@ func (this *LinuxWeightDevice) Equal(that interface{}) bool {
 }
 func (this *LinuxThrottleDevice) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*LinuxThrottleDevice)
@@ -2365,7 +2488,10 @@ func (this *LinuxThrottleDevice) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -2382,7 +2508,10 @@ func (this *LinuxThrottleDevice) Equal(that interface{}) bool {
 }
 func (this *LinuxBlockIO) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*LinuxBlockIO)
@@ -2395,7 +2524,10 @@ func (this *LinuxBlockIO) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -2449,7 +2581,10 @@ func (this *LinuxBlockIO) Equal(that interface{}) bool {
 }
 func (this *LinuxPids) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*LinuxPids)
@@ -2462,7 +2597,10 @@ func (this *LinuxPids) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -2473,7 +2611,10 @@ func (this *LinuxPids) Equal(that interface{}) bool {
 }
 func (this *LinuxDeviceCgroup) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*LinuxDeviceCgroup)
@@ -2486,7 +2627,10 @@ func (this *LinuxDeviceCgroup) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -2509,7 +2653,10 @@ func (this *LinuxDeviceCgroup) Equal(that interface{}) bool {
 }
 func (this *LinuxNetwork) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*LinuxNetwork)
@@ -2522,7 +2669,10 @@ func (this *LinuxNetwork) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -2541,7 +2691,10 @@ func (this *LinuxNetwork) Equal(that interface{}) bool {
 }
 func (this *LinuxHugepageLimit) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*LinuxHugepageLimit)
@@ -2554,7 +2707,10 @@ func (this *LinuxHugepageLimit) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -2568,7 +2724,10 @@ func (this *LinuxHugepageLimit) Equal(that interface{}) bool {
 }
 func (this *LinuxInterfacePriority) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*LinuxInterfacePriority)
@@ -2581,7 +2740,10 @@ func (this *LinuxInterfacePriority) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -2595,7 +2757,10 @@ func (this *LinuxInterfacePriority) Equal(that interface{}) bool {
 }
 func (this *LinuxSeccomp) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*LinuxSeccomp)
@@ -2608,7 +2773,10 @@ func (this *LinuxSeccomp) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -2635,7 +2803,10 @@ func (this *LinuxSeccomp) Equal(that interface{}) bool {
 }
 func (this *LinuxSeccompArg) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*LinuxSeccompArg)
@@ -2648,7 +2819,10 @@ func (this *LinuxSeccompArg) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -2668,7 +2842,10 @@ func (this *LinuxSeccompArg) Equal(that interface{}) bool {
 }
 func (this *LinuxSyscall) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*LinuxSyscall)
@@ -2681,7 +2858,10 @@ func (this *LinuxSyscall) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
@@ -2708,7 +2888,10 @@ func (this *LinuxSyscall) Equal(that interface{}) bool {
 }
 func (this *LinuxIntelRdt) Equal(that interface{}) bool {
 	if that == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	}
 
 	that1, ok := that.(*LinuxIntelRdt)
@@ -2721,7 +2904,10 @@ func (this *LinuxIntelRdt) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return this == nil
+		if this == nil {
+			return true
+		}
+		return false
 	} else if this == nil {
 		return false
 	}
diff --git a/protocols/grpc/ocipb_test.go b/protocols/grpc/ocipb_test.go
index b9649d07b4..e6538df364 100644
--- a/protocols/grpc/ocipb_test.go
+++ b/protocols/grpc/ocipb_test.go
@@ -4,10 +4,11 @@
 package grpc
 
 import testing "testing"
-import rand "math/rand"
+import math_rand "math/rand"
 import time "time"
+import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
+import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb"
 import proto "github.com/gogo/protobuf/proto"
-import jsonpb "github.com/gogo/protobuf/jsonpb"
 import fmt "fmt"
 import math "math"
 import _ "github.com/gogo/protobuf/gogoproto"
@@ -20,14 +21,14 @@ var _ = math.Inf
 
 func TestSpecProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedSpec(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Spec{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -45,13 +46,13 @@ func TestSpecProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestSpecMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedSpec(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -63,7 +64,7 @@ func TestSpecMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Spec{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -75,7 +76,7 @@ func TestSpecMarshalTo(t *testing.T) {
 }
 
 func BenchmarkSpecProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*Spec, 10000)
 	for i := 0; i < 10000; i++ {
@@ -83,7 +84,7 @@ func BenchmarkSpecProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -93,11 +94,11 @@ func BenchmarkSpecProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkSpecProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedSpec(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedSpec(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -107,7 +108,7 @@ func BenchmarkSpecProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -116,14 +117,14 @@ func BenchmarkSpecProtoUnmarshal(b *testing.B) {
 
 func TestProcessProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedProcess(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Process{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -141,13 +142,13 @@ func TestProcessProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestProcessMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedProcess(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -159,7 +160,7 @@ func TestProcessMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Process{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -171,7 +172,7 @@ func TestProcessMarshalTo(t *testing.T) {
 }
 
 func BenchmarkProcessProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*Process, 10000)
 	for i := 0; i < 10000; i++ {
@@ -179,7 +180,7 @@ func BenchmarkProcessProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -189,11 +190,11 @@ func BenchmarkProcessProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkProcessProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedProcess(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedProcess(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -203,7 +204,7 @@ func BenchmarkProcessProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -212,14 +213,14 @@ func BenchmarkProcessProtoUnmarshal(b *testing.B) {
 
 func TestBoxProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedBox(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Box{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -237,13 +238,13 @@ func TestBoxProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestBoxMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedBox(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -255,7 +256,7 @@ func TestBoxMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Box{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -267,7 +268,7 @@ func TestBoxMarshalTo(t *testing.T) {
 }
 
 func BenchmarkBoxProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*Box, 10000)
 	for i := 0; i < 10000; i++ {
@@ -275,7 +276,7 @@ func BenchmarkBoxProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -285,11 +286,11 @@ func BenchmarkBoxProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkBoxProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedBox(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedBox(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -299,7 +300,7 @@ func BenchmarkBoxProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -308,14 +309,14 @@ func BenchmarkBoxProtoUnmarshal(b *testing.B) {
 
 func TestUserProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedUser(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &User{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -333,13 +334,13 @@ func TestUserProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestUserMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedUser(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -351,7 +352,7 @@ func TestUserMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &User{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -363,7 +364,7 @@ func TestUserMarshalTo(t *testing.T) {
 }
 
 func BenchmarkUserProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*User, 10000)
 	for i := 0; i < 10000; i++ {
@@ -371,7 +372,7 @@ func BenchmarkUserProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -381,11 +382,11 @@ func BenchmarkUserProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkUserProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedUser(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUser(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -395,7 +396,7 @@ func BenchmarkUserProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -404,14 +405,14 @@ func BenchmarkUserProtoUnmarshal(b *testing.B) {
 
 func TestLinuxCapabilitiesProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxCapabilities(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxCapabilities{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -429,13 +430,13 @@ func TestLinuxCapabilitiesProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestLinuxCapabilitiesMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxCapabilities(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -447,7 +448,7 @@ func TestLinuxCapabilitiesMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxCapabilities{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -459,7 +460,7 @@ func TestLinuxCapabilitiesMarshalTo(t *testing.T) {
 }
 
 func BenchmarkLinuxCapabilitiesProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxCapabilities, 10000)
 	for i := 0; i < 10000; i++ {
@@ -467,7 +468,7 @@ func BenchmarkLinuxCapabilitiesProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -477,11 +478,11 @@ func BenchmarkLinuxCapabilitiesProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkLinuxCapabilitiesProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedLinuxCapabilities(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLinuxCapabilities(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -491,7 +492,7 @@ func BenchmarkLinuxCapabilitiesProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -500,14 +501,14 @@ func BenchmarkLinuxCapabilitiesProtoUnmarshal(b *testing.B) {
 
 func TestPOSIXRlimitProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedPOSIXRlimit(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &POSIXRlimit{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -525,13 +526,13 @@ func TestPOSIXRlimitProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestPOSIXRlimitMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedPOSIXRlimit(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -543,7 +544,7 @@ func TestPOSIXRlimitMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &POSIXRlimit{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -555,7 +556,7 @@ func TestPOSIXRlimitMarshalTo(t *testing.T) {
 }
 
 func BenchmarkPOSIXRlimitProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*POSIXRlimit, 10000)
 	for i := 0; i < 10000; i++ {
@@ -563,7 +564,7 @@ func BenchmarkPOSIXRlimitProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -573,11 +574,11 @@ func BenchmarkPOSIXRlimitProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkPOSIXRlimitProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedPOSIXRlimit(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedPOSIXRlimit(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -587,7 +588,7 @@ func BenchmarkPOSIXRlimitProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -596,14 +597,14 @@ func BenchmarkPOSIXRlimitProtoUnmarshal(b *testing.B) {
 
 func TestMountProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedMount(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Mount{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -621,13 +622,13 @@ func TestMountProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestMountMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedMount(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -639,7 +640,7 @@ func TestMountMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Mount{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -651,7 +652,7 @@ func TestMountMarshalTo(t *testing.T) {
 }
 
 func BenchmarkMountProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*Mount, 10000)
 	for i := 0; i < 10000; i++ {
@@ -659,7 +660,7 @@ func BenchmarkMountProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -669,11 +670,11 @@ func BenchmarkMountProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkMountProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedMount(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMount(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -683,7 +684,7 @@ func BenchmarkMountProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -692,14 +693,14 @@ func BenchmarkMountProtoUnmarshal(b *testing.B) {
 
 func TestRootProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedRoot(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Root{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -717,13 +718,13 @@ func TestRootProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestRootMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedRoot(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -735,7 +736,7 @@ func TestRootMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Root{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -747,7 +748,7 @@ func TestRootMarshalTo(t *testing.T) {
 }
 
 func BenchmarkRootProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*Root, 10000)
 	for i := 0; i < 10000; i++ {
@@ -755,7 +756,7 @@ func BenchmarkRootProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -765,11 +766,11 @@ func BenchmarkRootProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkRootProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedRoot(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedRoot(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -779,7 +780,7 @@ func BenchmarkRootProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -788,14 +789,14 @@ func BenchmarkRootProtoUnmarshal(b *testing.B) {
 
 func TestHooksProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedHooks(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Hooks{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -813,13 +814,13 @@ func TestHooksProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestHooksMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedHooks(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -831,7 +832,7 @@ func TestHooksMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Hooks{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -843,7 +844,7 @@ func TestHooksMarshalTo(t *testing.T) {
 }
 
 func BenchmarkHooksProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*Hooks, 10000)
 	for i := 0; i < 10000; i++ {
@@ -851,7 +852,7 @@ func BenchmarkHooksProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -861,11 +862,11 @@ func BenchmarkHooksProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkHooksProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedHooks(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedHooks(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -875,7 +876,7 @@ func BenchmarkHooksProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -884,14 +885,14 @@ func BenchmarkHooksProtoUnmarshal(b *testing.B) {
 
 func TestHookProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedHook(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Hook{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -909,13 +910,13 @@ func TestHookProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestHookMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedHook(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -927,7 +928,7 @@ func TestHookMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Hook{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -939,7 +940,7 @@ func TestHookMarshalTo(t *testing.T) {
 }
 
 func BenchmarkHookProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*Hook, 10000)
 	for i := 0; i < 10000; i++ {
@@ -947,7 +948,7 @@ func BenchmarkHookProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -957,11 +958,11 @@ func BenchmarkHookProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkHookProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedHook(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedHook(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -971,7 +972,7 @@ func BenchmarkHookProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -980,14 +981,14 @@ func BenchmarkHookProtoUnmarshal(b *testing.B) {
 
 func TestLinuxProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinux(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Linux{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -1005,13 +1006,13 @@ func TestLinuxProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestLinuxMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinux(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -1023,7 +1024,7 @@ func TestLinuxMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Linux{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -1035,7 +1036,7 @@ func TestLinuxMarshalTo(t *testing.T) {
 }
 
 func BenchmarkLinuxProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*Linux, 10000)
 	for i := 0; i < 10000; i++ {
@@ -1043,7 +1044,7 @@ func BenchmarkLinuxProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -1053,11 +1054,11 @@ func BenchmarkLinuxProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkLinuxProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedLinux(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLinux(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -1067,7 +1068,7 @@ func BenchmarkLinuxProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -1076,14 +1077,14 @@ func BenchmarkLinuxProtoUnmarshal(b *testing.B) {
 
 func TestWindowsProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedWindows(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Windows{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -1101,13 +1102,13 @@ func TestWindowsProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestWindowsMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedWindows(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -1119,7 +1120,7 @@ func TestWindowsMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Windows{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -1131,7 +1132,7 @@ func TestWindowsMarshalTo(t *testing.T) {
 }
 
 func BenchmarkWindowsProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*Windows, 10000)
 	for i := 0; i < 10000; i++ {
@@ -1139,7 +1140,7 @@ func BenchmarkWindowsProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -1149,11 +1150,11 @@ func BenchmarkWindowsProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkWindowsProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedWindows(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedWindows(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -1163,7 +1164,7 @@ func BenchmarkWindowsProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -1172,14 +1173,14 @@ func BenchmarkWindowsProtoUnmarshal(b *testing.B) {
 
 func TestSolarisProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedSolaris(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Solaris{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -1197,13 +1198,13 @@ func TestSolarisProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestSolarisMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedSolaris(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -1215,7 +1216,7 @@ func TestSolarisMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Solaris{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -1227,7 +1228,7 @@ func TestSolarisMarshalTo(t *testing.T) {
 }
 
 func BenchmarkSolarisProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*Solaris, 10000)
 	for i := 0; i < 10000; i++ {
@@ -1235,7 +1236,7 @@ func BenchmarkSolarisProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -1245,11 +1246,11 @@ func BenchmarkSolarisProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkSolarisProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedSolaris(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedSolaris(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -1259,7 +1260,7 @@ func BenchmarkSolarisProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -1268,14 +1269,14 @@ func BenchmarkSolarisProtoUnmarshal(b *testing.B) {
 
 func TestLinuxIDMappingProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxIDMapping(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxIDMapping{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -1293,13 +1294,13 @@ func TestLinuxIDMappingProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestLinuxIDMappingMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxIDMapping(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -1311,7 +1312,7 @@ func TestLinuxIDMappingMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxIDMapping{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -1323,7 +1324,7 @@ func TestLinuxIDMappingMarshalTo(t *testing.T) {
 }
 
 func BenchmarkLinuxIDMappingProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxIDMapping, 10000)
 	for i := 0; i < 10000; i++ {
@@ -1331,7 +1332,7 @@ func BenchmarkLinuxIDMappingProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -1341,11 +1342,11 @@ func BenchmarkLinuxIDMappingProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkLinuxIDMappingProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedLinuxIDMapping(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLinuxIDMapping(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -1355,7 +1356,7 @@ func BenchmarkLinuxIDMappingProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -1364,14 +1365,14 @@ func BenchmarkLinuxIDMappingProtoUnmarshal(b *testing.B) {
 
 func TestLinuxNamespaceProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxNamespace(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxNamespace{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -1389,13 +1390,13 @@ func TestLinuxNamespaceProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestLinuxNamespaceMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxNamespace(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -1407,7 +1408,7 @@ func TestLinuxNamespaceMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxNamespace{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -1419,7 +1420,7 @@ func TestLinuxNamespaceMarshalTo(t *testing.T) {
 }
 
 func BenchmarkLinuxNamespaceProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxNamespace, 10000)
 	for i := 0; i < 10000; i++ {
@@ -1427,7 +1428,7 @@ func BenchmarkLinuxNamespaceProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -1437,11 +1438,11 @@ func BenchmarkLinuxNamespaceProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkLinuxNamespaceProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedLinuxNamespace(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLinuxNamespace(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -1451,7 +1452,7 @@ func BenchmarkLinuxNamespaceProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -1460,14 +1461,14 @@ func BenchmarkLinuxNamespaceProtoUnmarshal(b *testing.B) {
 
 func TestLinuxDeviceProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxDevice(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxDevice{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -1485,13 +1486,13 @@ func TestLinuxDeviceProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestLinuxDeviceMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxDevice(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -1503,7 +1504,7 @@ func TestLinuxDeviceMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxDevice{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -1515,7 +1516,7 @@ func TestLinuxDeviceMarshalTo(t *testing.T) {
 }
 
 func BenchmarkLinuxDeviceProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxDevice, 10000)
 	for i := 0; i < 10000; i++ {
@@ -1523,7 +1524,7 @@ func BenchmarkLinuxDeviceProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -1533,11 +1534,11 @@ func BenchmarkLinuxDeviceProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkLinuxDeviceProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedLinuxDevice(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLinuxDevice(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -1547,7 +1548,7 @@ func BenchmarkLinuxDeviceProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -1556,14 +1557,14 @@ func BenchmarkLinuxDeviceProtoUnmarshal(b *testing.B) {
 
 func TestLinuxResourcesProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxResources(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxResources{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -1581,13 +1582,13 @@ func TestLinuxResourcesProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestLinuxResourcesMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxResources(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -1599,7 +1600,7 @@ func TestLinuxResourcesMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxResources{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -1611,7 +1612,7 @@ func TestLinuxResourcesMarshalTo(t *testing.T) {
 }
 
 func BenchmarkLinuxResourcesProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxResources, 10000)
 	for i := 0; i < 10000; i++ {
@@ -1619,7 +1620,7 @@ func BenchmarkLinuxResourcesProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -1629,11 +1630,11 @@ func BenchmarkLinuxResourcesProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkLinuxResourcesProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedLinuxResources(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLinuxResources(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -1643,7 +1644,7 @@ func BenchmarkLinuxResourcesProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -1652,14 +1653,14 @@ func BenchmarkLinuxResourcesProtoUnmarshal(b *testing.B) {
 
 func TestLinuxMemoryProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxMemory(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxMemory{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -1677,13 +1678,13 @@ func TestLinuxMemoryProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestLinuxMemoryMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxMemory(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -1695,7 +1696,7 @@ func TestLinuxMemoryMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxMemory{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -1707,7 +1708,7 @@ func TestLinuxMemoryMarshalTo(t *testing.T) {
 }
 
 func BenchmarkLinuxMemoryProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxMemory, 10000)
 	for i := 0; i < 10000; i++ {
@@ -1715,7 +1716,7 @@ func BenchmarkLinuxMemoryProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -1725,11 +1726,11 @@ func BenchmarkLinuxMemoryProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkLinuxMemoryProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedLinuxMemory(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLinuxMemory(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -1739,7 +1740,7 @@ func BenchmarkLinuxMemoryProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -1748,14 +1749,14 @@ func BenchmarkLinuxMemoryProtoUnmarshal(b *testing.B) {
 
 func TestLinuxCPUProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxCPU(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxCPU{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -1773,13 +1774,13 @@ func TestLinuxCPUProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestLinuxCPUMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxCPU(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -1791,7 +1792,7 @@ func TestLinuxCPUMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxCPU{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -1803,7 +1804,7 @@ func TestLinuxCPUMarshalTo(t *testing.T) {
 }
 
 func BenchmarkLinuxCPUProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxCPU, 10000)
 	for i := 0; i < 10000; i++ {
@@ -1811,7 +1812,7 @@ func BenchmarkLinuxCPUProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -1821,11 +1822,11 @@ func BenchmarkLinuxCPUProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkLinuxCPUProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedLinuxCPU(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLinuxCPU(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -1835,7 +1836,7 @@ func BenchmarkLinuxCPUProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -1844,14 +1845,14 @@ func BenchmarkLinuxCPUProtoUnmarshal(b *testing.B) {
 
 func TestLinuxWeightDeviceProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxWeightDevice(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxWeightDevice{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -1869,13 +1870,13 @@ func TestLinuxWeightDeviceProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestLinuxWeightDeviceMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxWeightDevice(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -1887,7 +1888,7 @@ func TestLinuxWeightDeviceMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxWeightDevice{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -1899,7 +1900,7 @@ func TestLinuxWeightDeviceMarshalTo(t *testing.T) {
 }
 
 func BenchmarkLinuxWeightDeviceProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxWeightDevice, 10000)
 	for i := 0; i < 10000; i++ {
@@ -1907,7 +1908,7 @@ func BenchmarkLinuxWeightDeviceProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -1917,11 +1918,11 @@ func BenchmarkLinuxWeightDeviceProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkLinuxWeightDeviceProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedLinuxWeightDevice(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLinuxWeightDevice(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -1931,7 +1932,7 @@ func BenchmarkLinuxWeightDeviceProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -1940,14 +1941,14 @@ func BenchmarkLinuxWeightDeviceProtoUnmarshal(b *testing.B) {
 
 func TestLinuxThrottleDeviceProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxThrottleDevice(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxThrottleDevice{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -1965,13 +1966,13 @@ func TestLinuxThrottleDeviceProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestLinuxThrottleDeviceMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxThrottleDevice(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -1983,7 +1984,7 @@ func TestLinuxThrottleDeviceMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxThrottleDevice{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -1995,7 +1996,7 @@ func TestLinuxThrottleDeviceMarshalTo(t *testing.T) {
 }
 
 func BenchmarkLinuxThrottleDeviceProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxThrottleDevice, 10000)
 	for i := 0; i < 10000; i++ {
@@ -2003,7 +2004,7 @@ func BenchmarkLinuxThrottleDeviceProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -2013,11 +2014,11 @@ func BenchmarkLinuxThrottleDeviceProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkLinuxThrottleDeviceProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedLinuxThrottleDevice(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLinuxThrottleDevice(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -2027,7 +2028,7 @@ func BenchmarkLinuxThrottleDeviceProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -2036,14 +2037,14 @@ func BenchmarkLinuxThrottleDeviceProtoUnmarshal(b *testing.B) {
 
 func TestLinuxBlockIOProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxBlockIO(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxBlockIO{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -2061,13 +2062,13 @@ func TestLinuxBlockIOProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestLinuxBlockIOMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxBlockIO(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -2079,7 +2080,7 @@ func TestLinuxBlockIOMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxBlockIO{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -2091,7 +2092,7 @@ func TestLinuxBlockIOMarshalTo(t *testing.T) {
 }
 
 func BenchmarkLinuxBlockIOProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxBlockIO, 10000)
 	for i := 0; i < 10000; i++ {
@@ -2099,7 +2100,7 @@ func BenchmarkLinuxBlockIOProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -2109,11 +2110,11 @@ func BenchmarkLinuxBlockIOProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkLinuxBlockIOProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedLinuxBlockIO(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLinuxBlockIO(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -2123,7 +2124,7 @@ func BenchmarkLinuxBlockIOProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -2132,14 +2133,14 @@ func BenchmarkLinuxBlockIOProtoUnmarshal(b *testing.B) {
 
 func TestLinuxPidsProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxPids(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxPids{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -2157,13 +2158,13 @@ func TestLinuxPidsProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestLinuxPidsMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxPids(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -2175,7 +2176,7 @@ func TestLinuxPidsMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxPids{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -2187,7 +2188,7 @@ func TestLinuxPidsMarshalTo(t *testing.T) {
 }
 
 func BenchmarkLinuxPidsProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxPids, 10000)
 	for i := 0; i < 10000; i++ {
@@ -2195,7 +2196,7 @@ func BenchmarkLinuxPidsProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -2205,11 +2206,11 @@ func BenchmarkLinuxPidsProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkLinuxPidsProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedLinuxPids(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLinuxPids(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -2219,7 +2220,7 @@ func BenchmarkLinuxPidsProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -2228,14 +2229,14 @@ func BenchmarkLinuxPidsProtoUnmarshal(b *testing.B) {
 
 func TestLinuxDeviceCgroupProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxDeviceCgroup(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxDeviceCgroup{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -2253,13 +2254,13 @@ func TestLinuxDeviceCgroupProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestLinuxDeviceCgroupMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxDeviceCgroup(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -2271,7 +2272,7 @@ func TestLinuxDeviceCgroupMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxDeviceCgroup{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -2283,7 +2284,7 @@ func TestLinuxDeviceCgroupMarshalTo(t *testing.T) {
 }
 
 func BenchmarkLinuxDeviceCgroupProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxDeviceCgroup, 10000)
 	for i := 0; i < 10000; i++ {
@@ -2291,7 +2292,7 @@ func BenchmarkLinuxDeviceCgroupProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -2301,11 +2302,11 @@ func BenchmarkLinuxDeviceCgroupProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkLinuxDeviceCgroupProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedLinuxDeviceCgroup(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLinuxDeviceCgroup(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -2315,7 +2316,7 @@ func BenchmarkLinuxDeviceCgroupProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -2324,14 +2325,14 @@ func BenchmarkLinuxDeviceCgroupProtoUnmarshal(b *testing.B) {
 
 func TestLinuxNetworkProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxNetwork(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxNetwork{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -2349,13 +2350,13 @@ func TestLinuxNetworkProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestLinuxNetworkMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxNetwork(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -2367,7 +2368,7 @@ func TestLinuxNetworkMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxNetwork{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -2379,7 +2380,7 @@ func TestLinuxNetworkMarshalTo(t *testing.T) {
 }
 
 func BenchmarkLinuxNetworkProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxNetwork, 10000)
 	for i := 0; i < 10000; i++ {
@@ -2387,7 +2388,7 @@ func BenchmarkLinuxNetworkProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -2397,11 +2398,11 @@ func BenchmarkLinuxNetworkProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkLinuxNetworkProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedLinuxNetwork(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLinuxNetwork(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -2411,7 +2412,7 @@ func BenchmarkLinuxNetworkProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -2420,14 +2421,14 @@ func BenchmarkLinuxNetworkProtoUnmarshal(b *testing.B) {
 
 func TestLinuxHugepageLimitProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxHugepageLimit(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxHugepageLimit{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -2445,13 +2446,13 @@ func TestLinuxHugepageLimitProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestLinuxHugepageLimitMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxHugepageLimit(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -2463,7 +2464,7 @@ func TestLinuxHugepageLimitMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxHugepageLimit{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -2475,7 +2476,7 @@ func TestLinuxHugepageLimitMarshalTo(t *testing.T) {
 }
 
 func BenchmarkLinuxHugepageLimitProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxHugepageLimit, 10000)
 	for i := 0; i < 10000; i++ {
@@ -2483,7 +2484,7 @@ func BenchmarkLinuxHugepageLimitProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -2493,11 +2494,11 @@ func BenchmarkLinuxHugepageLimitProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkLinuxHugepageLimitProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedLinuxHugepageLimit(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLinuxHugepageLimit(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -2507,7 +2508,7 @@ func BenchmarkLinuxHugepageLimitProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -2516,14 +2517,14 @@ func BenchmarkLinuxHugepageLimitProtoUnmarshal(b *testing.B) {
 
 func TestLinuxInterfacePriorityProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxInterfacePriority(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxInterfacePriority{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -2541,13 +2542,13 @@ func TestLinuxInterfacePriorityProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestLinuxInterfacePriorityMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxInterfacePriority(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -2559,7 +2560,7 @@ func TestLinuxInterfacePriorityMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxInterfacePriority{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -2571,7 +2572,7 @@ func TestLinuxInterfacePriorityMarshalTo(t *testing.T) {
 }
 
 func BenchmarkLinuxInterfacePriorityProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxInterfacePriority, 10000)
 	for i := 0; i < 10000; i++ {
@@ -2579,7 +2580,7 @@ func BenchmarkLinuxInterfacePriorityProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -2589,11 +2590,11 @@ func BenchmarkLinuxInterfacePriorityProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkLinuxInterfacePriorityProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedLinuxInterfacePriority(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLinuxInterfacePriority(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -2603,7 +2604,7 @@ func BenchmarkLinuxInterfacePriorityProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -2612,14 +2613,14 @@ func BenchmarkLinuxInterfacePriorityProtoUnmarshal(b *testing.B) {
 
 func TestLinuxSeccompProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxSeccomp(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxSeccomp{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -2637,13 +2638,13 @@ func TestLinuxSeccompProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestLinuxSeccompMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxSeccomp(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -2655,7 +2656,7 @@ func TestLinuxSeccompMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxSeccomp{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -2667,7 +2668,7 @@ func TestLinuxSeccompMarshalTo(t *testing.T) {
 }
 
 func BenchmarkLinuxSeccompProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxSeccomp, 10000)
 	for i := 0; i < 10000; i++ {
@@ -2675,7 +2676,7 @@ func BenchmarkLinuxSeccompProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -2685,11 +2686,11 @@ func BenchmarkLinuxSeccompProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkLinuxSeccompProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedLinuxSeccomp(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLinuxSeccomp(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -2699,7 +2700,7 @@ func BenchmarkLinuxSeccompProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -2708,14 +2709,14 @@ func BenchmarkLinuxSeccompProtoUnmarshal(b *testing.B) {
 
 func TestLinuxSeccompArgProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxSeccompArg(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxSeccompArg{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -2733,13 +2734,13 @@ func TestLinuxSeccompArgProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestLinuxSeccompArgMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxSeccompArg(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -2751,7 +2752,7 @@ func TestLinuxSeccompArgMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxSeccompArg{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -2763,7 +2764,7 @@ func TestLinuxSeccompArgMarshalTo(t *testing.T) {
 }
 
 func BenchmarkLinuxSeccompArgProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxSeccompArg, 10000)
 	for i := 0; i < 10000; i++ {
@@ -2771,7 +2772,7 @@ func BenchmarkLinuxSeccompArgProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -2781,11 +2782,11 @@ func BenchmarkLinuxSeccompArgProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkLinuxSeccompArgProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedLinuxSeccompArg(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLinuxSeccompArg(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -2795,7 +2796,7 @@ func BenchmarkLinuxSeccompArgProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -2804,14 +2805,14 @@ func BenchmarkLinuxSeccompArgProtoUnmarshal(b *testing.B) {
 
 func TestLinuxSyscallProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxSyscall(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxSyscall{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -2829,13 +2830,13 @@ func TestLinuxSyscallProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestLinuxSyscallMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxSyscall(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -2847,7 +2848,7 @@ func TestLinuxSyscallMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxSyscall{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -2859,7 +2860,7 @@ func TestLinuxSyscallMarshalTo(t *testing.T) {
 }
 
 func BenchmarkLinuxSyscallProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxSyscall, 10000)
 	for i := 0; i < 10000; i++ {
@@ -2867,7 +2868,7 @@ func BenchmarkLinuxSyscallProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -2877,11 +2878,11 @@ func BenchmarkLinuxSyscallProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkLinuxSyscallProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedLinuxSyscall(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLinuxSyscall(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -2891,7 +2892,7 @@ func BenchmarkLinuxSyscallProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -2900,14 +2901,14 @@ func BenchmarkLinuxSyscallProtoUnmarshal(b *testing.B) {
 
 func TestLinuxIntelRdtProto(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxIntelRdt(popr, false)
-	dAtA, err := proto.Marshal(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxIntelRdt{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	littlefuzz := make([]byte, len(dAtA))
@@ -2925,13 +2926,13 @@ func TestLinuxIntelRdtProto(t *testing.T) {
 			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
 		}
 		// shouldn't panic
-		_ = proto.Unmarshal(littlefuzz, msg)
+		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
 	}
 }
 
 func TestLinuxIntelRdtMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxIntelRdt(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
@@ -2943,7 +2944,7 @@ func TestLinuxIntelRdtMarshalTo(t *testing.T) {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxIntelRdt{}
-	if err := proto.Unmarshal(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	for i := range dAtA {
@@ -2955,7 +2956,7 @@ func TestLinuxIntelRdtMarshalTo(t *testing.T) {
 }
 
 func BenchmarkLinuxIntelRdtProtoMarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxIntelRdt, 10000)
 	for i := 0; i < 10000; i++ {
@@ -2963,7 +2964,7 @@ func BenchmarkLinuxIntelRdtProtoMarshal(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		dAtA, err := proto.Marshal(pops[i%10000])
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
 		if err != nil {
 			panic(err)
 		}
@@ -2973,11 +2974,11 @@ func BenchmarkLinuxIntelRdtProtoMarshal(b *testing.B) {
 }
 
 func BenchmarkLinuxIntelRdtProtoUnmarshal(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	datas := make([][]byte, 10000)
 	for i := 0; i < 10000; i++ {
-		dAtA, err := proto.Marshal(NewPopulatedLinuxIntelRdt(popr, false))
+		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLinuxIntelRdt(popr, false))
 		if err != nil {
 			panic(err)
 		}
@@ -2987,7 +2988,7 @@ func BenchmarkLinuxIntelRdtProtoUnmarshal(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		total += len(datas[i%10000])
-		if err := proto.Unmarshal(datas[i%10000], msg); err != nil {
+		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
 			panic(err)
 		}
 	}
@@ -2996,15 +2997,15 @@ func BenchmarkLinuxIntelRdtProtoUnmarshal(b *testing.B) {
 
 func TestSpecJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedSpec(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Spec{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3014,15 +3015,15 @@ func TestSpecJSON(t *testing.T) {
 }
 func TestProcessJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedProcess(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Process{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3032,15 +3033,15 @@ func TestProcessJSON(t *testing.T) {
 }
 func TestBoxJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedBox(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Box{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3050,15 +3051,15 @@ func TestBoxJSON(t *testing.T) {
 }
 func TestUserJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedUser(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &User{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3068,15 +3069,15 @@ func TestUserJSON(t *testing.T) {
 }
 func TestLinuxCapabilitiesJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxCapabilities(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxCapabilities{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3086,15 +3087,15 @@ func TestLinuxCapabilitiesJSON(t *testing.T) {
 }
 func TestPOSIXRlimitJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedPOSIXRlimit(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &POSIXRlimit{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3104,15 +3105,15 @@ func TestPOSIXRlimitJSON(t *testing.T) {
 }
 func TestMountJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedMount(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Mount{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3122,15 +3123,15 @@ func TestMountJSON(t *testing.T) {
 }
 func TestRootJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedRoot(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Root{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3140,15 +3141,15 @@ func TestRootJSON(t *testing.T) {
 }
 func TestHooksJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedHooks(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Hooks{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3158,15 +3159,15 @@ func TestHooksJSON(t *testing.T) {
 }
 func TestHookJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedHook(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Hook{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3176,15 +3177,15 @@ func TestHookJSON(t *testing.T) {
 }
 func TestLinuxJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinux(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Linux{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3194,15 +3195,15 @@ func TestLinuxJSON(t *testing.T) {
 }
 func TestWindowsJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedWindows(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Windows{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3212,15 +3213,15 @@ func TestWindowsJSON(t *testing.T) {
 }
 func TestSolarisJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedSolaris(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &Solaris{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3230,15 +3231,15 @@ func TestSolarisJSON(t *testing.T) {
 }
 func TestLinuxIDMappingJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxIDMapping(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxIDMapping{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3248,15 +3249,15 @@ func TestLinuxIDMappingJSON(t *testing.T) {
 }
 func TestLinuxNamespaceJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxNamespace(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxNamespace{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3266,15 +3267,15 @@ func TestLinuxNamespaceJSON(t *testing.T) {
 }
 func TestLinuxDeviceJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxDevice(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxDevice{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3284,15 +3285,15 @@ func TestLinuxDeviceJSON(t *testing.T) {
 }
 func TestLinuxResourcesJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxResources(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxResources{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3302,15 +3303,15 @@ func TestLinuxResourcesJSON(t *testing.T) {
 }
 func TestLinuxMemoryJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxMemory(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxMemory{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3320,15 +3321,15 @@ func TestLinuxMemoryJSON(t *testing.T) {
 }
 func TestLinuxCPUJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxCPU(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxCPU{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3338,15 +3339,15 @@ func TestLinuxCPUJSON(t *testing.T) {
 }
 func TestLinuxWeightDeviceJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxWeightDevice(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxWeightDevice{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3356,15 +3357,15 @@ func TestLinuxWeightDeviceJSON(t *testing.T) {
 }
 func TestLinuxThrottleDeviceJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxThrottleDevice(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxThrottleDevice{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3374,15 +3375,15 @@ func TestLinuxThrottleDeviceJSON(t *testing.T) {
 }
 func TestLinuxBlockIOJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxBlockIO(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxBlockIO{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3392,15 +3393,15 @@ func TestLinuxBlockIOJSON(t *testing.T) {
 }
 func TestLinuxPidsJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxPids(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxPids{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3410,15 +3411,15 @@ func TestLinuxPidsJSON(t *testing.T) {
 }
 func TestLinuxDeviceCgroupJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxDeviceCgroup(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxDeviceCgroup{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3428,15 +3429,15 @@ func TestLinuxDeviceCgroupJSON(t *testing.T) {
 }
 func TestLinuxNetworkJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxNetwork(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxNetwork{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3446,15 +3447,15 @@ func TestLinuxNetworkJSON(t *testing.T) {
 }
 func TestLinuxHugepageLimitJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxHugepageLimit(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxHugepageLimit{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3464,15 +3465,15 @@ func TestLinuxHugepageLimitJSON(t *testing.T) {
 }
 func TestLinuxInterfacePriorityJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxInterfacePriority(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxInterfacePriority{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3482,15 +3483,15 @@ func TestLinuxInterfacePriorityJSON(t *testing.T) {
 }
 func TestLinuxSeccompJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxSeccomp(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxSeccomp{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3500,15 +3501,15 @@ func TestLinuxSeccompJSON(t *testing.T) {
 }
 func TestLinuxSeccompArgJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxSeccompArg(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxSeccompArg{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3518,15 +3519,15 @@ func TestLinuxSeccompArgJSON(t *testing.T) {
 }
 func TestLinuxSyscallJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxSyscall(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxSyscall{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3536,15 +3537,15 @@ func TestLinuxSyscallJSON(t *testing.T) {
 }
 func TestLinuxIntelRdtJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxIntelRdt(popr, true)
-	marshaler := jsonpb.Marshaler{}
+	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	msg := &LinuxIntelRdt{}
-	err = jsonpb.UnmarshalString(jsondata, msg)
+	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3554,11 +3555,11 @@ func TestLinuxIntelRdtJSON(t *testing.T) {
 }
 func TestSpecProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedSpec(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &Spec{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3568,11 +3569,11 @@ func TestSpecProtoText(t *testing.T) {
 
 func TestSpecProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedSpec(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &Spec{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3582,11 +3583,11 @@ func TestSpecProtoCompactText(t *testing.T) {
 
 func TestProcessProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedProcess(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &Process{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3596,11 +3597,11 @@ func TestProcessProtoText(t *testing.T) {
 
 func TestProcessProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedProcess(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &Process{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3610,11 +3611,11 @@ func TestProcessProtoCompactText(t *testing.T) {
 
 func TestBoxProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedBox(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &Box{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3624,11 +3625,11 @@ func TestBoxProtoText(t *testing.T) {
 
 func TestBoxProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedBox(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &Box{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3638,11 +3639,11 @@ func TestBoxProtoCompactText(t *testing.T) {
 
 func TestUserProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedUser(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &User{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3652,11 +3653,11 @@ func TestUserProtoText(t *testing.T) {
 
 func TestUserProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedUser(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &User{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3666,11 +3667,11 @@ func TestUserProtoCompactText(t *testing.T) {
 
 func TestLinuxCapabilitiesProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxCapabilities(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &LinuxCapabilities{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3680,11 +3681,11 @@ func TestLinuxCapabilitiesProtoText(t *testing.T) {
 
 func TestLinuxCapabilitiesProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxCapabilities(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &LinuxCapabilities{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3694,11 +3695,11 @@ func TestLinuxCapabilitiesProtoCompactText(t *testing.T) {
 
 func TestPOSIXRlimitProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedPOSIXRlimit(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &POSIXRlimit{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3708,11 +3709,11 @@ func TestPOSIXRlimitProtoText(t *testing.T) {
 
 func TestPOSIXRlimitProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedPOSIXRlimit(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &POSIXRlimit{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3722,11 +3723,11 @@ func TestPOSIXRlimitProtoCompactText(t *testing.T) {
 
 func TestMountProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedMount(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &Mount{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3736,11 +3737,11 @@ func TestMountProtoText(t *testing.T) {
 
 func TestMountProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedMount(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &Mount{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3750,11 +3751,11 @@ func TestMountProtoCompactText(t *testing.T) {
 
 func TestRootProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedRoot(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &Root{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3764,11 +3765,11 @@ func TestRootProtoText(t *testing.T) {
 
 func TestRootProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedRoot(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &Root{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3778,11 +3779,11 @@ func TestRootProtoCompactText(t *testing.T) {
 
 func TestHooksProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedHooks(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &Hooks{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3792,11 +3793,11 @@ func TestHooksProtoText(t *testing.T) {
 
 func TestHooksProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedHooks(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &Hooks{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3806,11 +3807,11 @@ func TestHooksProtoCompactText(t *testing.T) {
 
 func TestHookProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedHook(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &Hook{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3820,11 +3821,11 @@ func TestHookProtoText(t *testing.T) {
 
 func TestHookProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedHook(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &Hook{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3834,11 +3835,11 @@ func TestHookProtoCompactText(t *testing.T) {
 
 func TestLinuxProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinux(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &Linux{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3848,11 +3849,11 @@ func TestLinuxProtoText(t *testing.T) {
 
 func TestLinuxProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinux(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &Linux{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3862,11 +3863,11 @@ func TestLinuxProtoCompactText(t *testing.T) {
 
 func TestWindowsProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedWindows(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &Windows{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3876,11 +3877,11 @@ func TestWindowsProtoText(t *testing.T) {
 
 func TestWindowsProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedWindows(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &Windows{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3890,11 +3891,11 @@ func TestWindowsProtoCompactText(t *testing.T) {
 
 func TestSolarisProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedSolaris(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &Solaris{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3904,11 +3905,11 @@ func TestSolarisProtoText(t *testing.T) {
 
 func TestSolarisProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedSolaris(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &Solaris{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3918,11 +3919,11 @@ func TestSolarisProtoCompactText(t *testing.T) {
 
 func TestLinuxIDMappingProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxIDMapping(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &LinuxIDMapping{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3932,11 +3933,11 @@ func TestLinuxIDMappingProtoText(t *testing.T) {
 
 func TestLinuxIDMappingProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxIDMapping(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &LinuxIDMapping{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3946,11 +3947,11 @@ func TestLinuxIDMappingProtoCompactText(t *testing.T) {
 
 func TestLinuxNamespaceProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxNamespace(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &LinuxNamespace{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3960,11 +3961,11 @@ func TestLinuxNamespaceProtoText(t *testing.T) {
 
 func TestLinuxNamespaceProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxNamespace(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &LinuxNamespace{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3974,11 +3975,11 @@ func TestLinuxNamespaceProtoCompactText(t *testing.T) {
 
 func TestLinuxDeviceProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxDevice(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &LinuxDevice{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -3988,11 +3989,11 @@ func TestLinuxDeviceProtoText(t *testing.T) {
 
 func TestLinuxDeviceProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxDevice(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &LinuxDevice{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4002,11 +4003,11 @@ func TestLinuxDeviceProtoCompactText(t *testing.T) {
 
 func TestLinuxResourcesProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxResources(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &LinuxResources{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4016,11 +4017,11 @@ func TestLinuxResourcesProtoText(t *testing.T) {
 
 func TestLinuxResourcesProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxResources(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &LinuxResources{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4030,11 +4031,11 @@ func TestLinuxResourcesProtoCompactText(t *testing.T) {
 
 func TestLinuxMemoryProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxMemory(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &LinuxMemory{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4044,11 +4045,11 @@ func TestLinuxMemoryProtoText(t *testing.T) {
 
 func TestLinuxMemoryProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxMemory(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &LinuxMemory{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4058,11 +4059,11 @@ func TestLinuxMemoryProtoCompactText(t *testing.T) {
 
 func TestLinuxCPUProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxCPU(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &LinuxCPU{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4072,11 +4073,11 @@ func TestLinuxCPUProtoText(t *testing.T) {
 
 func TestLinuxCPUProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxCPU(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &LinuxCPU{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4086,11 +4087,11 @@ func TestLinuxCPUProtoCompactText(t *testing.T) {
 
 func TestLinuxWeightDeviceProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxWeightDevice(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &LinuxWeightDevice{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4100,11 +4101,11 @@ func TestLinuxWeightDeviceProtoText(t *testing.T) {
 
 func TestLinuxWeightDeviceProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxWeightDevice(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &LinuxWeightDevice{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4114,11 +4115,11 @@ func TestLinuxWeightDeviceProtoCompactText(t *testing.T) {
 
 func TestLinuxThrottleDeviceProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxThrottleDevice(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &LinuxThrottleDevice{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4128,11 +4129,11 @@ func TestLinuxThrottleDeviceProtoText(t *testing.T) {
 
 func TestLinuxThrottleDeviceProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxThrottleDevice(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &LinuxThrottleDevice{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4142,11 +4143,11 @@ func TestLinuxThrottleDeviceProtoCompactText(t *testing.T) {
 
 func TestLinuxBlockIOProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxBlockIO(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &LinuxBlockIO{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4156,11 +4157,11 @@ func TestLinuxBlockIOProtoText(t *testing.T) {
 
 func TestLinuxBlockIOProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxBlockIO(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &LinuxBlockIO{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4170,11 +4171,11 @@ func TestLinuxBlockIOProtoCompactText(t *testing.T) {
 
 func TestLinuxPidsProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxPids(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &LinuxPids{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4184,11 +4185,11 @@ func TestLinuxPidsProtoText(t *testing.T) {
 
 func TestLinuxPidsProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxPids(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &LinuxPids{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4198,11 +4199,11 @@ func TestLinuxPidsProtoCompactText(t *testing.T) {
 
 func TestLinuxDeviceCgroupProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxDeviceCgroup(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &LinuxDeviceCgroup{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4212,11 +4213,11 @@ func TestLinuxDeviceCgroupProtoText(t *testing.T) {
 
 func TestLinuxDeviceCgroupProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxDeviceCgroup(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &LinuxDeviceCgroup{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4226,11 +4227,11 @@ func TestLinuxDeviceCgroupProtoCompactText(t *testing.T) {
 
 func TestLinuxNetworkProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxNetwork(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &LinuxNetwork{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4240,11 +4241,11 @@ func TestLinuxNetworkProtoText(t *testing.T) {
 
 func TestLinuxNetworkProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxNetwork(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &LinuxNetwork{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4254,11 +4255,11 @@ func TestLinuxNetworkProtoCompactText(t *testing.T) {
 
 func TestLinuxHugepageLimitProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxHugepageLimit(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &LinuxHugepageLimit{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4268,11 +4269,11 @@ func TestLinuxHugepageLimitProtoText(t *testing.T) {
 
 func TestLinuxHugepageLimitProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxHugepageLimit(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &LinuxHugepageLimit{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4282,11 +4283,11 @@ func TestLinuxHugepageLimitProtoCompactText(t *testing.T) {
 
 func TestLinuxInterfacePriorityProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxInterfacePriority(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &LinuxInterfacePriority{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4296,11 +4297,11 @@ func TestLinuxInterfacePriorityProtoText(t *testing.T) {
 
 func TestLinuxInterfacePriorityProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxInterfacePriority(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &LinuxInterfacePriority{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4310,11 +4311,11 @@ func TestLinuxInterfacePriorityProtoCompactText(t *testing.T) {
 
 func TestLinuxSeccompProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxSeccomp(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &LinuxSeccomp{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4324,11 +4325,11 @@ func TestLinuxSeccompProtoText(t *testing.T) {
 
 func TestLinuxSeccompProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxSeccomp(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &LinuxSeccomp{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4338,11 +4339,11 @@ func TestLinuxSeccompProtoCompactText(t *testing.T) {
 
 func TestLinuxSeccompArgProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxSeccompArg(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &LinuxSeccompArg{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4352,11 +4353,11 @@ func TestLinuxSeccompArgProtoText(t *testing.T) {
 
 func TestLinuxSeccompArgProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxSeccompArg(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &LinuxSeccompArg{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4366,11 +4367,11 @@ func TestLinuxSeccompArgProtoCompactText(t *testing.T) {
 
 func TestLinuxSyscallProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxSyscall(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &LinuxSyscall{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4380,11 +4381,11 @@ func TestLinuxSyscallProtoText(t *testing.T) {
 
 func TestLinuxSyscallProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxSyscall(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &LinuxSyscall{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4394,11 +4395,11 @@ func TestLinuxSyscallProtoCompactText(t *testing.T) {
 
 func TestLinuxIntelRdtProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxIntelRdt(popr, true)
-	dAtA := proto.MarshalTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 	msg := &LinuxIntelRdt{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4408,11 +4409,11 @@ func TestLinuxIntelRdtProtoText(t *testing.T) {
 
 func TestLinuxIntelRdtProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxIntelRdt(popr, true)
-	dAtA := proto.CompactTextString(p)
+	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 	msg := &LinuxIntelRdt{}
-	if err := proto.UnmarshalText(dAtA, msg); err != nil {
+	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
 	if !p.Equal(msg) {
@@ -4422,10 +4423,10 @@ func TestLinuxIntelRdtProtoCompactText(t *testing.T) {
 
 func TestSpecSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedSpec(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -4436,14 +4437,14 @@ func TestSpecSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkSpecSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*Spec, 1000)
 	for i := 0; i < 1000; i++ {
@@ -4458,10 +4459,10 @@ func BenchmarkSpecSize(b *testing.B) {
 
 func TestProcessSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedProcess(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -4472,14 +4473,14 @@ func TestProcessSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkProcessSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*Process, 1000)
 	for i := 0; i < 1000; i++ {
@@ -4494,10 +4495,10 @@ func BenchmarkProcessSize(b *testing.B) {
 
 func TestBoxSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedBox(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -4508,14 +4509,14 @@ func TestBoxSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkBoxSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*Box, 1000)
 	for i := 0; i < 1000; i++ {
@@ -4530,10 +4531,10 @@ func BenchmarkBoxSize(b *testing.B) {
 
 func TestUserSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedUser(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -4544,14 +4545,14 @@ func TestUserSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkUserSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*User, 1000)
 	for i := 0; i < 1000; i++ {
@@ -4566,10 +4567,10 @@ func BenchmarkUserSize(b *testing.B) {
 
 func TestLinuxCapabilitiesSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxCapabilities(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -4580,14 +4581,14 @@ func TestLinuxCapabilitiesSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkLinuxCapabilitiesSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxCapabilities, 1000)
 	for i := 0; i < 1000; i++ {
@@ -4602,10 +4603,10 @@ func BenchmarkLinuxCapabilitiesSize(b *testing.B) {
 
 func TestPOSIXRlimitSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedPOSIXRlimit(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -4616,14 +4617,14 @@ func TestPOSIXRlimitSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkPOSIXRlimitSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*POSIXRlimit, 1000)
 	for i := 0; i < 1000; i++ {
@@ -4638,10 +4639,10 @@ func BenchmarkPOSIXRlimitSize(b *testing.B) {
 
 func TestMountSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedMount(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -4652,14 +4653,14 @@ func TestMountSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkMountSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*Mount, 1000)
 	for i := 0; i < 1000; i++ {
@@ -4674,10 +4675,10 @@ func BenchmarkMountSize(b *testing.B) {
 
 func TestRootSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedRoot(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -4688,14 +4689,14 @@ func TestRootSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkRootSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*Root, 1000)
 	for i := 0; i < 1000; i++ {
@@ -4710,10 +4711,10 @@ func BenchmarkRootSize(b *testing.B) {
 
 func TestHooksSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedHooks(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -4724,14 +4725,14 @@ func TestHooksSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkHooksSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*Hooks, 1000)
 	for i := 0; i < 1000; i++ {
@@ -4746,10 +4747,10 @@ func BenchmarkHooksSize(b *testing.B) {
 
 func TestHookSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedHook(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -4760,14 +4761,14 @@ func TestHookSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkHookSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*Hook, 1000)
 	for i := 0; i < 1000; i++ {
@@ -4782,10 +4783,10 @@ func BenchmarkHookSize(b *testing.B) {
 
 func TestLinuxSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinux(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -4796,14 +4797,14 @@ func TestLinuxSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkLinuxSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*Linux, 1000)
 	for i := 0; i < 1000; i++ {
@@ -4818,10 +4819,10 @@ func BenchmarkLinuxSize(b *testing.B) {
 
 func TestWindowsSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedWindows(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -4832,14 +4833,14 @@ func TestWindowsSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkWindowsSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*Windows, 1000)
 	for i := 0; i < 1000; i++ {
@@ -4854,10 +4855,10 @@ func BenchmarkWindowsSize(b *testing.B) {
 
 func TestSolarisSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedSolaris(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -4868,14 +4869,14 @@ func TestSolarisSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkSolarisSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*Solaris, 1000)
 	for i := 0; i < 1000; i++ {
@@ -4890,10 +4891,10 @@ func BenchmarkSolarisSize(b *testing.B) {
 
 func TestLinuxIDMappingSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxIDMapping(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -4904,14 +4905,14 @@ func TestLinuxIDMappingSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkLinuxIDMappingSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxIDMapping, 1000)
 	for i := 0; i < 1000; i++ {
@@ -4926,10 +4927,10 @@ func BenchmarkLinuxIDMappingSize(b *testing.B) {
 
 func TestLinuxNamespaceSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxNamespace(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -4940,14 +4941,14 @@ func TestLinuxNamespaceSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkLinuxNamespaceSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxNamespace, 1000)
 	for i := 0; i < 1000; i++ {
@@ -4962,10 +4963,10 @@ func BenchmarkLinuxNamespaceSize(b *testing.B) {
 
 func TestLinuxDeviceSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxDevice(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -4976,14 +4977,14 @@ func TestLinuxDeviceSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkLinuxDeviceSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxDevice, 1000)
 	for i := 0; i < 1000; i++ {
@@ -4998,10 +4999,10 @@ func BenchmarkLinuxDeviceSize(b *testing.B) {
 
 func TestLinuxResourcesSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxResources(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -5012,14 +5013,14 @@ func TestLinuxResourcesSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkLinuxResourcesSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxResources, 1000)
 	for i := 0; i < 1000; i++ {
@@ -5034,10 +5035,10 @@ func BenchmarkLinuxResourcesSize(b *testing.B) {
 
 func TestLinuxMemorySize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxMemory(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -5048,14 +5049,14 @@ func TestLinuxMemorySize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkLinuxMemorySize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxMemory, 1000)
 	for i := 0; i < 1000; i++ {
@@ -5070,10 +5071,10 @@ func BenchmarkLinuxMemorySize(b *testing.B) {
 
 func TestLinuxCPUSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxCPU(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -5084,14 +5085,14 @@ func TestLinuxCPUSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkLinuxCPUSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxCPU, 1000)
 	for i := 0; i < 1000; i++ {
@@ -5106,10 +5107,10 @@ func BenchmarkLinuxCPUSize(b *testing.B) {
 
 func TestLinuxWeightDeviceSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxWeightDevice(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -5120,14 +5121,14 @@ func TestLinuxWeightDeviceSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkLinuxWeightDeviceSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxWeightDevice, 1000)
 	for i := 0; i < 1000; i++ {
@@ -5142,10 +5143,10 @@ func BenchmarkLinuxWeightDeviceSize(b *testing.B) {
 
 func TestLinuxThrottleDeviceSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxThrottleDevice(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -5156,14 +5157,14 @@ func TestLinuxThrottleDeviceSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkLinuxThrottleDeviceSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxThrottleDevice, 1000)
 	for i := 0; i < 1000; i++ {
@@ -5178,10 +5179,10 @@ func BenchmarkLinuxThrottleDeviceSize(b *testing.B) {
 
 func TestLinuxBlockIOSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxBlockIO(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -5192,14 +5193,14 @@ func TestLinuxBlockIOSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkLinuxBlockIOSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxBlockIO, 1000)
 	for i := 0; i < 1000; i++ {
@@ -5214,10 +5215,10 @@ func BenchmarkLinuxBlockIOSize(b *testing.B) {
 
 func TestLinuxPidsSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxPids(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -5228,14 +5229,14 @@ func TestLinuxPidsSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkLinuxPidsSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxPids, 1000)
 	for i := 0; i < 1000; i++ {
@@ -5250,10 +5251,10 @@ func BenchmarkLinuxPidsSize(b *testing.B) {
 
 func TestLinuxDeviceCgroupSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxDeviceCgroup(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -5264,14 +5265,14 @@ func TestLinuxDeviceCgroupSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkLinuxDeviceCgroupSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxDeviceCgroup, 1000)
 	for i := 0; i < 1000; i++ {
@@ -5286,10 +5287,10 @@ func BenchmarkLinuxDeviceCgroupSize(b *testing.B) {
 
 func TestLinuxNetworkSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxNetwork(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -5300,14 +5301,14 @@ func TestLinuxNetworkSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkLinuxNetworkSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxNetwork, 1000)
 	for i := 0; i < 1000; i++ {
@@ -5322,10 +5323,10 @@ func BenchmarkLinuxNetworkSize(b *testing.B) {
 
 func TestLinuxHugepageLimitSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxHugepageLimit(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -5336,14 +5337,14 @@ func TestLinuxHugepageLimitSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkLinuxHugepageLimitSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxHugepageLimit, 1000)
 	for i := 0; i < 1000; i++ {
@@ -5358,10 +5359,10 @@ func BenchmarkLinuxHugepageLimitSize(b *testing.B) {
 
 func TestLinuxInterfacePrioritySize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxInterfacePriority(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -5372,14 +5373,14 @@ func TestLinuxInterfacePrioritySize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkLinuxInterfacePrioritySize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxInterfacePriority, 1000)
 	for i := 0; i < 1000; i++ {
@@ -5394,10 +5395,10 @@ func BenchmarkLinuxInterfacePrioritySize(b *testing.B) {
 
 func TestLinuxSeccompSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxSeccomp(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -5408,14 +5409,14 @@ func TestLinuxSeccompSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkLinuxSeccompSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxSeccomp, 1000)
 	for i := 0; i < 1000; i++ {
@@ -5430,10 +5431,10 @@ func BenchmarkLinuxSeccompSize(b *testing.B) {
 
 func TestLinuxSeccompArgSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxSeccompArg(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -5444,14 +5445,14 @@ func TestLinuxSeccompArgSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkLinuxSeccompArgSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxSeccompArg, 1000)
 	for i := 0; i < 1000; i++ {
@@ -5466,10 +5467,10 @@ func BenchmarkLinuxSeccompArgSize(b *testing.B) {
 
 func TestLinuxSyscallSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxSyscall(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -5480,14 +5481,14 @@ func TestLinuxSyscallSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkLinuxSyscallSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxSyscall, 1000)
 	for i := 0; i < 1000; i++ {
@@ -5502,10 +5503,10 @@ func BenchmarkLinuxSyscallSize(b *testing.B) {
 
 func TestLinuxIntelRdtSize(t *testing.T) {
 	seed := time.Now().UnixNano()
-	popr := rand.New(rand.NewSource(seed))
+	popr := math_rand.New(math_rand.NewSource(seed))
 	p := NewPopulatedLinuxIntelRdt(popr, true)
-	size2 := proto.Size(p)
-	dAtA, err := proto.Marshal(p)
+	size2 := github_com_gogo_protobuf_proto.Size(p)
+	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -5516,14 +5517,14 @@ func TestLinuxIntelRdtSize(t *testing.T) {
 	if size2 != size {
 		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 	}
-	size3 := proto.Size(p)
+	size3 := github_com_gogo_protobuf_proto.Size(p)
 	if size3 != size {
 		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 	}
 }
 
 func BenchmarkLinuxIntelRdtSize(b *testing.B) {
-	popr := rand.New(rand.NewSource(616))
+	popr := math_rand.New(math_rand.NewSource(616))
 	total := 0
 	pops := make([]*LinuxIntelRdt, 1000)
 	for i := 0; i < 1000; i++ {
diff --git a/protocols/mockserver/mockserver.go b/protocols/mockserver/mockserver.go
index 1b79411412..85a024b6e3 100644
--- a/protocols/mockserver/mockserver.go
+++ b/protocols/mockserver/mockserver.go
@@ -307,6 +307,16 @@ func (m *mockServer) UpdateRoutes(ctx context.Context, req *pb.UpdateRoutesReque
 	return nil, nil
 }
 
+func (m *mockServer) AddARPNeighbors(ctx context.Context, req *pb.AddARPNeighborsRequest) (*types.Empty, error) {
+	mockLock.RLock()
+	defer mockLock.RUnlock()
+	if err := m.podExist(); err != nil {
+		return nil, err
+	}
+
+	return nil, nil
+}
+
 func (m *mockServer) OnlineCPUMem(ctx context.Context, req *pb.OnlineCPUMemRequest) (*types.Empty, error) {
 	mockLock.RLock()
 	defer mockLock.RUnlock()