vendor: re-vendor agent to fix mount error

The agent gRPC protocol has changed meaning the order of the gRPC
`Storage` message members has changed. This manifested itself with the
following error:

```
"OCI runtime create failed: rpc error: code = Internal desc = Could not
resolve symlink for source 9p: unknown."
```

This was caused by the agent attempting to mount a 9p FS with a blank
mountpoint - in fact due to the change in ordering, the mountpoint was
in the mount options!

Changes:

9760c10 device: Add SCSI block device support
15e851f storage: Rework the way Storage and Device are handled
4683745 lint: Remove unnecessary conversions
058182d lint: Fix vet error
ebcb3af reaper: removed unused type
902b82c device: Use standard functions to get device Major and Minor
6e262da main: Display full stacktrace on internal error

Signed-off-by: James O. D. Hunt <james.o.hunt@intel.com>
Signed-off-by: Jose Carlos Venegas Munoz <jose.carlos.venegas.munoz@intel.com>

Gopkg.lock

@@ -94,7 +94,7 @@
     "protocols/client",
     "protocols/grpc"
   ]
-  revision = "33eecb2a445f906811a5bc9713d2dafd10768d18"
+  revision = "a93071539feee29bfa22b6184380d3fd7c156ef7"
 
 [[projects]]
   name = "github.com/kubernetes-incubator/cri-o"
@@ -245,6 +245,6 @@
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
-  inputs-digest = "8331e15417ca6d2fead042dca2d5d9e2d24c53d5f3e2f1896be962e19b0c6981"
+  inputs-digest = "8dba9fde76331ee3c2baa2a34230f174e3ab122a6b17975c533cdfbf42b49617"
   solver-name = "gps-cdcl"
   solver-version = 1

Gopkg.toml

@@ -60,7 +60,7 @@
 
 [[constraint]]
   name = "github.com/kata-containers/agent"
-  revision = "33eecb2a445f906811a5bc9713d2dafd10768d18"
+  revision = "a93071539feee29bfa22b6184380d3fd7c156ef7"
 
 [[constraint]]
   name = "github.com/containerd/cri-containerd"

vendor/github.com/kata-containers/agent/protocols/grpc/agent.pb.go

@@ -756,12 +756,34 @@ func (m *OnlineCPUMemRequest) String() string            { return proto.CompactT
 func (*OnlineCPUMemRequest) ProtoMessage()               {}
 func (*OnlineCPUMemRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{23} }
 
+// Storage represents both the rootfs of the container, and any volume that
+// could have been defined through the Mount list of the OCI specification.
 type Storage struct {
-	Driver     string   `protobuf:"bytes,1,opt,name=driver,proto3" json:"driver,omitempty"`
+	// Driver is used to define the way the storage is passed through the
-	Source     string   `protobuf:"bytes,2,opt,name=source,proto3" json:"source,omitempty"`
+	// virtual machine. It can be "9p", "blk", or something else, but for
-	Fstype     string   `protobuf:"bytes,3,opt,name=fstype,proto3" json:"fstype,omitempty"`
+	// all cases, this will define if some extra steps are required before
-	Options    []string `protobuf:"bytes,4,rep,name=options" json:"options,omitempty"`
+	// this storage gets mounted into the container.
-	MountPoint string   `protobuf:"bytes,5,opt,name=mount_point,json=mountPoint,proto3" json:"mount_point,omitempty"`
+	Driver string `protobuf:"bytes,1,opt,name=driver,proto3" json:"driver,omitempty"`
+	// DriverOptions allows the caller to define a list of options such
+	// as block sizes, numbers of luns, ... which are very specific to
+	// every device and cannot be generalized through extra fields.
+	DriverOptions []string `protobuf:"bytes,2,rep,name=driver_options,json=driverOptions" json:"driver_options,omitempty"`
+	// Source can be anything representing the source of the storage. This
+	// will be handled by the proper handler based on the Driver used.
+	// For instance, it can be a very simple path if the caller knows the
+	// name of device inside the VM, or it can be some sort of identifier
+	// to let the agent find the device inside the VM.
+	Source string `protobuf:"bytes,3,opt,name=source,proto3" json:"source,omitempty"`
+	// Fstype represents the filesystem that needs to be used to mount the
+	// storage inside the VM. For instance, it could be "xfs" for block
+	// device, "9p" for shared filesystem, or "tmpfs" for shared /dev/shm.
+	Fstype string `protobuf:"bytes,4,opt,name=fstype,proto3" json:"fstype,omitempty"`
+	// Options describes the additional options that might be needed to
+	// mount properly the storage filesytem.
+	Options []string `protobuf:"bytes,5,rep,name=options" json:"options,omitempty"`
+	// MountPoint refers to the path where the storage should be mounted
+	// inside the VM.
+	MountPoint string `protobuf:"bytes,6,opt,name=mount_point,json=mountPoint,proto3" json:"mount_point,omitempty"`
 }
 
 func (m *Storage) Reset()                    { *m = Storage{} }
@@ -776,6 +798,13 @@ func (m *Storage) GetDriver() string {
 	return ""
 }
 
+func (m *Storage) GetDriverOptions() []string {
+	if m != nil {
+		return m.DriverOptions
+	}
+	return nil
+}
+
 func (m *Storage) GetSource() string {
 	if m != nil {
 		return m.Source
@@ -804,23 +833,25 @@ func (m *Storage) GetMountPoint() string {
 	return ""
 }
 
+// Device represents only the devices that could have been defined through the
+// Linux Device list of the OCI specification.
 type Device struct {
-	// id can be used to identify the device inside the VM. Some devices
+	// Id can be used to identify the device inside the VM. Some devices
 	// might not need it to be identified on the VM, and will rely on the
-	// provided vm_path instead.
+	// provided VmPath instead.
 	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
-	// type defines the type of device described. This can be "blk",
+	// Type defines the type of device described. This can be "blk",
 	// "scsi", "vfio", ...
 	// Particularly, this should be used to trigger the use of the
 	// appropriate device handler.
 	Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
-	// vm_path can be used by the caller to provide directly the path of
+	// VmPath can be used by the caller to provide directly the path of
 	// the device as it will appear inside the VM. For some devices, the
 	// device id or the list of options passed might not be enough to find
 	// the device. In those cases, the caller should predict and provide
 	// this vm_path.
 	VmPath string `protobuf:"bytes,3,opt,name=vm_path,json=vmPath,proto3" json:"vm_path,omitempty"`
-	// container_path defines the path where the device should be found inside
+	// ContainerPath defines the path where the device should be found inside
 	// the container. This path should match the path of the device from
 	// the device list listed inside the OCI spec. This is used in order
 	// to identify the right device in the spec and update it with the
@@ -832,7 +863,7 @@ type Device struct {
 	// been hotplugged. An equivalent Storage entry should be defined if
 	// any mount needs to be performed afterwards.
 	ContainerPath string `protobuf:"bytes,4,opt,name=container_path,json=containerPath,proto3" json:"container_path,omitempty"`
-	// options allows the caller to define a list of options such as block
+	// Options allows the caller to define a list of options such as block
 	// sizes, numbers of luns, ... which are very specific to every device
 	// and cannot be generalized through extra fields.
 	Options []string `protobuf:"bytes,5,rep,name=options" json:"options,omitempty"`
@@ -2442,21 +2473,36 @@ func (m *Storage) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintAgent(dAtA, i, uint64(len(m.Driver)))
 		i += copy(dAtA[i:], m.Driver)
 	}
+	if len(m.DriverOptions) > 0 {
+		for _, s := range m.DriverOptions {
+			dAtA[i] = 0x12
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
+		}
+	}
 	if len(m.Source) > 0 {
-		dAtA[i] = 0x12
+		dAtA[i] = 0x1a
 		i++
 		i = encodeVarintAgent(dAtA, i, uint64(len(m.Source)))
 		i += copy(dAtA[i:], m.Source)
 	}
 	if len(m.Fstype) > 0 {
-		dAtA[i] = 0x1a
+		dAtA[i] = 0x22
 		i++
 		i = encodeVarintAgent(dAtA, i, uint64(len(m.Fstype)))
 		i += copy(dAtA[i:], m.Fstype)
 	}
 	if len(m.Options) > 0 {
 		for _, s := range m.Options {
-			dAtA[i] = 0x22
+			dAtA[i] = 0x2a
 			i++
 			l = len(s)
 			for l >= 1<<7 {
@@ -2470,7 +2516,7 @@ func (m *Storage) MarshalTo(dAtA []byte) (int, error) {
 		}
 	}
 	if len(m.MountPoint) > 0 {
-		dAtA[i] = 0x2a
+		dAtA[i] = 0x32
 		i++
 		i = encodeVarintAgent(dAtA, i, uint64(len(m.MountPoint)))
 		i += copy(dAtA[i:], m.MountPoint)
@@ -2961,6 +3007,12 @@ func (m *Storage) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovAgent(uint64(l))
 	}
+	if len(m.DriverOptions) > 0 {
+		for _, s := range m.DriverOptions {
+			l = len(s)
+			n += 1 + l + sovAgent(uint64(l))
+		}
+	}
 	l = len(m.Source)
 	if l > 0 {
 		n += 1 + l + sovAgent(uint64(l))
@@ -5834,6 +5886,35 @@ func (m *Storage) Unmarshal(dAtA []byte) error {
 			m.Driver = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DriverOptions", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowAgent
+				}
+				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 ErrInvalidLengthAgent
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.DriverOptions = append(m.DriverOptions, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
+		case 3:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
 			}
@@ -5862,7 +5943,7 @@ func (m *Storage) Unmarshal(dAtA []byte) error {
 			}
 			m.Source = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
-		case 3:
+		case 4:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Fstype", wireType)
 			}
@@ -5891,7 +5972,7 @@ func (m *Storage) Unmarshal(dAtA []byte) error {
 			}
 			m.Fstype = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
-		case 4:
+		case 5:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
 			}
@@ -5920,7 +6001,7 @@ func (m *Storage) Unmarshal(dAtA []byte) error {
 			}
 			m.Options = append(m.Options, string(dAtA[iNdEx:postIndex]))
 			iNdEx = postIndex
-		case 5:
+		case 6:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field MountPoint", wireType)
 			}
@@ -6410,84 +6491,85 @@ var (
 func init() { proto.RegisterFile("agent.proto", fileDescriptorAgent) }
 
 var fileDescriptorAgent = []byte{
-	// 1261 bytes of a gzipped FileDescriptorProto
+	// 1271 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x56, 0xdf, 0x6e, 0x1b, 0xc5,
 	0x17, 0xfe, 0x6d, 0x9c, 0x38, 0xf1, 0xb1, 0x9d, 0xa4, 0x93, 0x36, 0xd9, 0x9f, 0x5b, 0x95, 0xb0,
-	0x40, 0x1b, 0x90, 0x9a, 0x8a, 0x80, 0x40, 0x2a, 0x42, 0x25, 0x4d, 0x4b, 0x94, 0x0b, 0x54, 0x6b,
+	0x40, 0x1b, 0x90, 0x9a, 0x8a, 0x80, 0x40, 0x2a, 0x42, 0x25, 0x4d, 0x4b, 0x94, 0x0b, 0x14, 0x6b,
-	0x4c, 0x54, 0xee, 0xa2, 0xe9, 0xee, 0xc4, 0x59, 0xf0, 0xee, 0x2c, 0x33, 0xb3, 0x49, 0x4d, 0xef,
+	0x4c, 0x54, 0xee, 0xa2, 0xe9, 0xee, 0xc4, 0x59, 0xf0, 0xee, 0x2c, 0x33, 0xb3, 0x4e, 0x4d, 0xef,
-	0xb9, 0xe2, 0x92, 0xc7, 0xe0, 0x21, 0xb8, 0xe4, 0x92, 0x47, 0x40, 0x7d, 0x0a, 0x2e, 0xd1, 0xfc,
+	0x79, 0x02, 0x1e, 0x83, 0x3b, 0x5e, 0x80, 0x4b, 0x2e, 0x79, 0x04, 0xd4, 0xa7, 0xe0, 0x12, 0xcd,
-	0x5b, 0xef, 0xda, 0xeb, 0x22, 0xb5, 0x96, 0xb8, 0xf2, 0x9c, 0x73, 0xc6, 0xdf, 0xf9, 0xce, 0x99,
+	0xbf, 0xb5, 0xd7, 0x5e, 0x17, 0x29, 0xb5, 0xc4, 0x95, 0xe7, 0x9c, 0x33, 0xfe, 0xce, 0x77, 0xce,
-	0xd9, 0x33, 0x1f, 0xb4, 0xc9, 0x90, 0xa6, 0x72, 0x3f, 0xe3, 0x4c, 0x32, 0xb4, 0x3c, 0xe4, 0x59,
+	0xcc, 0x9c, 0xfd, 0xa0, 0x49, 0xfa, 0x34, 0x95, 0xfb, 0x19, 0x67, 0x92, 0xa1, 0xe5, 0x3e, 0xcf,
-	0xd8, 0x6b, 0xb1, 0x30, 0x36, 0x8e, 0xde, 0xcd, 0x21, 0x63, 0xc3, 0x11, 0xbd, 0xaf, 0xad, 0xe7,
+	0xc2, 0x4e, 0x83, 0x85, 0xb1, 0x71, 0x74, 0x6e, 0xf7, 0x19, 0xeb, 0x0f, 0xe8, 0x43, 0x6d, 0xbd,
-	0xf9, 0xf9, 0x7d, 0x9a, 0x64, 0x72, 0x6c, 0x82, 0xc1, 0xdf, 0x1e, 0x6c, 0x1f, 0x71, 0x4a, 0x24,
+	0xc8, 0x2f, 0x1e, 0xd2, 0x24, 0x93, 0x23, 0x13, 0x0c, 0xfe, 0xf6, 0x60, 0xfb, 0x88, 0x53, 0x22,
-	0x3d, 0x62, 0xa9, 0x24, 0x71, 0x4a, 0x39, 0xa6, 0x3f, 0xe6, 0x54, 0x48, 0xf4, 0x2e, 0x74, 0x42,
+	0xe9, 0x11, 0x4b, 0x25, 0x89, 0x53, 0xca, 0x31, 0xfd, 0x31, 0xa7, 0x42, 0xa2, 0x77, 0xa1, 0x15,
-	0xe7, 0x3b, 0x8b, 0x23, 0xdf, 0xdb, 0xf5, 0xf6, 0x5a, 0xb8, 0x5d, 0xf8, 0x4e, 0x22, 0xb4, 0x03,
+	0x3a, 0xdf, 0x79, 0x1c, 0xf9, 0xde, 0xae, 0xb7, 0xd7, 0xc0, 0xcd, 0xc2, 0x77, 0x12, 0xa1, 0x1d,
-	0xab, 0xf4, 0x05, 0x0d, 0x55, 0x74, 0x49, 0x47, 0x9b, 0xca, 0x3c, 0x89, 0xd0, 0xc7, 0xd0, 0x16,
+	0x58, 0xa5, 0x2f, 0x69, 0xa8, 0xa2, 0x4b, 0x3a, 0x5a, 0x57, 0xe6, 0x49, 0x84, 0x3e, 0x86, 0xa6,
-	0x92, 0xc7, 0xe9, 0xf0, 0x2c, 0x17, 0x94, 0xfb, 0x8d, 0x5d, 0x6f, 0xaf, 0x7d, 0xb0, 0xb9, 0xaf,
+	0x90, 0x3c, 0x4e, 0xfb, 0xe7, 0xb9, 0xa0, 0xdc, 0xaf, 0xed, 0x7a, 0x7b, 0xcd, 0x83, 0xcd, 0x7d,
-	0xa8, 0xed, 0x0f, 0x74, 0xe0, 0x54, 0x50, 0x8e, 0x41, 0x14, 0x6b, 0x74, 0x07, 0x56, 0x23, 0x7a,
+	0x45, 0x6d, 0xbf, 0xa7, 0x03, 0x67, 0x82, 0x72, 0x0c, 0xa2, 0x58, 0xa3, 0x7b, 0xb0, 0x1a, 0xd1,
-	0x19, 0x87, 0x54, 0xf8, 0xcb, 0xbb, 0x8d, 0xbd, 0xf6, 0x41, 0xc7, 0x6c, 0x7f, 0xac, 0x9d, 0xd8,
+	0x61, 0x1c, 0x52, 0xe1, 0x2f, 0xef, 0xd6, 0xf6, 0x9a, 0x07, 0x2d, 0xb3, 0xfd, 0xa9, 0x76, 0x62,
-	0x05, 0xd1, 0x87, 0xb0, 0x26, 0x24, 0xe3, 0x64, 0x48, 0x85, 0xbf, 0xa2, 0x37, 0x76, 0x1d, 0xae,
+	0x17, 0x44, 0x1f, 0xc2, 0x9a, 0x90, 0x8c, 0x93, 0x3e, 0x15, 0xfe, 0x8a, 0xde, 0xd8, 0x76, 0xb8,
-	0xf6, 0xe2, 0x22, 0x8c, 0x6e, 0x41, 0xe3, 0xe9, 0xd1, 0x89, 0xdf, 0xd4, 0xd9, 0xc1, 0xee, 0xca,
+	0xda, 0x8b, 0x8b, 0x30, 0xba, 0x03, 0xb5, 0xd3, 0xa3, 0x13, 0xbf, 0xae, 0xb3, 0x83, 0xdd, 0x95,
-	0x68, 0x88, 0x95, 0x3b, 0x78, 0x00, 0x37, 0x06, 0x92, 0x70, 0xf9, 0x06, 0x85, 0x07, 0xa7, 0xb0,
+	0xd1, 0x10, 0x2b, 0x77, 0xf0, 0x08, 0x6e, 0xf5, 0x24, 0xe1, 0xf2, 0x1a, 0x85, 0x07, 0x67, 0xb0,
-	0x8d, 0x69, 0xc2, 0x2e, 0xdf, 0xa8, 0x6b, 0x3e, 0xac, 0xca, 0x38, 0xa1, 0x2c, 0x97, 0xba, 0x6b,
+	0x8d, 0x69, 0xc2, 0x86, 0xd7, 0xea, 0x9a, 0x0f, 0xab, 0x32, 0x4e, 0x28, 0xcb, 0xa5, 0xee, 0x5a,
-	0x5d, 0xec, 0xcc, 0xe0, 0x37, 0x0f, 0xd0, 0x93, 0x17, 0x34, 0xec, 0x73, 0x16, 0x52, 0x21, 0xfe,
+	0x1b, 0x3b, 0x33, 0xf8, 0xd5, 0x03, 0xf4, 0xec, 0x25, 0x0d, 0xbb, 0x9c, 0x85, 0x54, 0x88, 0xff,
-	0xa3, 0x93, 0xb8, 0x0b, 0xab, 0x99, 0x21, 0xe0, 0x2f, 0xeb, 0xed, 0xb6, 0xc1, 0x8e, 0x95, 0x8b,
+	0xe8, 0x24, 0xee, 0xc3, 0x6a, 0x66, 0x08, 0xf8, 0xcb, 0x7a, 0xbb, 0x6d, 0xb0, 0x63, 0xe5, 0xa2,
-	0x06, 0xdf, 0xc3, 0xf5, 0x41, 0x3c, 0x4c, 0xc9, 0x68, 0x81, 0x7c, 0xb7, 0xa1, 0x29, 0x34, 0xa6,
+	0xc1, 0xf7, 0x70, 0xb3, 0x17, 0xf7, 0x53, 0x32, 0x58, 0x20, 0xdf, 0x6d, 0xa8, 0x0b, 0x8d, 0xa9,
-	0xa6, 0xda, 0xc5, 0xd6, 0x0a, 0xfa, 0x80, 0x9e, 0x91, 0x58, 0x2e, 0x2e, 0x53, 0x70, 0x0f, 0xb6,
+	0xa9, 0xb6, 0xb1, 0xb5, 0x82, 0x2e, 0xa0, 0xe7, 0x24, 0x96, 0x8b, 0xcb, 0x14, 0x3c, 0x80, 0xad,
-	0x2a, 0x88, 0x22, 0x63, 0xa9, 0xa0, 0x9a, 0x80, 0x24, 0x32, 0x17, 0x1a, 0x6c, 0x05, 0x5b, 0x2b,
+	0x12, 0xa2, 0xc8, 0x58, 0x2a, 0xa8, 0x26, 0x20, 0x89, 0xcc, 0x85, 0x06, 0x5b, 0xc1, 0xd6, 0x0a,
-	0x88, 0x00, 0x3d, 0xe3, 0xb1, 0xa4, 0x03, 0xc9, 0x29, 0x49, 0x16, 0x51, 0x2a, 0x82, 0xe5, 0x88,
+	0x22, 0x40, 0xcf, 0x79, 0x2c, 0x69, 0x4f, 0x72, 0x4a, 0x92, 0x45, 0x94, 0x8a, 0x60, 0x39, 0x22,
-	0x48, 0xa2, 0x0b, 0xed, 0x60, 0xbd, 0x0e, 0xee, 0xc2, 0x56, 0x25, 0x8b, 0x25, 0xb5, 0x09, 0x8d,
+	0x92, 0xe8, 0x42, 0x5b, 0x58, 0xaf, 0x83, 0xfb, 0xb0, 0x55, 0xca, 0x62, 0x49, 0x6d, 0x42, 0x6d,
-	0x11, 0x4d, 0x35, 0x7a, 0x17, 0xab, 0x65, 0x40, 0xe0, 0x1a, 0xa6, 0x24, 0x5a, 0x1c, 0x1b, 0x9b,
+	0x40, 0x53, 0x8d, 0xde, 0xc6, 0x6a, 0x19, 0x10, 0xb8, 0x81, 0x29, 0x89, 0x16, 0xc7, 0xc6, 0xa6,
-	0xa2, 0x31, 0x49, 0xb1, 0x07, 0xa8, 0x9c, 0xc2, 0x52, 0x71, 0xac, 0xbd, 0x12, 0xeb, 0xa7, 0x70,
+	0xa8, 0x8d, 0x53, 0xec, 0x01, 0x9a, 0x4c, 0x61, 0xa9, 0x38, 0xd6, 0xde, 0x04, 0xeb, 0x53, 0xb8,
-	0xed, 0x68, 0xc4, 0x04, 0x1d, 0xc8, 0x28, 0x4e, 0x17, 0x71, 0x36, 0x2f, 0x61, 0xeb, 0x5b, 0x39,
+	0x71, 0x34, 0x60, 0x82, 0xf6, 0x64, 0x14, 0xa7, 0x8b, 0x38, 0x9b, 0x57, 0xb0, 0xf5, 0xad, 0x1c,
-	0x7e, 0xa6, 0xc0, 0x44, 0xfc, 0x13, 0x5d, 0x50, 0x7d, 0x9c, 0x5d, 0xb9, 0xfa, 0x38, 0xbb, 0x52,
+	0x3d, 0x57, 0x60, 0x22, 0xfe, 0x89, 0x2e, 0xa8, 0x3e, 0xce, 0xae, 0x5c, 0x7d, 0x9c, 0x5d, 0xa9,
-	0x27, 0x1d, 0xb2, 0x51, 0x9e, 0xa4, 0xfa, 0x9a, 0x77, 0xb1, 0xb5, 0x82, 0x5f, 0x3d, 0xb8, 0x6e,
+	0x93, 0x0e, 0xd9, 0x20, 0x4f, 0x52, 0x7d, 0xcd, 0xdb, 0xd8, 0x5a, 0xc1, 0x2f, 0x1e, 0xdc, 0x34,
-	0x66, 0xe2, 0x80, 0xa4, 0xd1, 0x73, 0xf6, 0xc2, 0xa5, 0xef, 0xc1, 0xda, 0x05, 0x13, 0x32, 0x25,
+	0x33, 0xb1, 0x47, 0xd2, 0xe8, 0x05, 0x7b, 0xe9, 0xd2, 0x77, 0x60, 0xed, 0x92, 0x09, 0x99, 0x92,
-	0x09, 0xb5, 0xa9, 0x0b, 0x5b, 0xc1, 0x47, 0xa9, 0xf0, 0x97, 0x76, 0x1b, 0x7b, 0x2d, 0xac, 0x96,
+	0x84, 0xda, 0xd4, 0x85, 0xad, 0xe0, 0xa3, 0x54, 0xf8, 0x4b, 0xbb, 0xb5, 0xbd, 0x06, 0x56, 0xcb,
-	0x95, 0x41, 0xd5, 0x78, 0xfd, 0xa0, 0x7a, 0x0f, 0xba, 0xc2, 0xa4, 0x3a, 0xcb, 0x62, 0x05, 0xa3,
+	0xd2, 0xa0, 0xaa, 0xbd, 0x79, 0x50, 0xbd, 0x07, 0x6d, 0x61, 0x52, 0x9d, 0x67, 0xb1, 0x82, 0x51,
-	0x08, 0xad, 0xe1, 0x8e, 0x75, 0xf6, 0x95, 0x2f, 0xd8, 0x81, 0x1b, 0x8f, 0xa9, 0x90, 0x9c, 0x8d,
+	0x84, 0xd6, 0x70, 0xcb, 0x3a, 0xbb, 0xca, 0x17, 0xec, 0xc0, 0xad, 0xa7, 0x54, 0x48, 0xce, 0x46,
-	0xab, 0xb4, 0x02, 0x02, 0xad, 0x93, 0xfe, 0x61, 0x14, 0x71, 0x2a, 0x04, 0xba, 0x03, 0xcd, 0x73,
+	0x65, 0x5a, 0x01, 0x81, 0xc6, 0x49, 0xf7, 0x30, 0x8a, 0x38, 0x15, 0x02, 0xdd, 0x83, 0xfa, 0x05,
-	0x92, 0xc4, 0xa3, 0xb1, 0x66, 0xb8, 0x7e, 0xb0, 0x6e, 0x72, 0x9e, 0xf4, 0xbf, 0xd6, 0x5e, 0x6c,
+	0x49, 0xe2, 0xc1, 0x48, 0x33, 0x5c, 0x3f, 0x58, 0x37, 0x39, 0x4f, 0xba, 0x5f, 0x6b, 0x2f, 0xb6,
-	0xa3, 0x6a, 0x08, 0x11, 0xf3, 0x17, 0xdb, 0x27, 0x67, 0xaa, 0x03, 0x4e, 0x88, 0xf8, 0x41, 0x77,
+	0x51, 0x35, 0x84, 0x88, 0xf9, 0x8b, 0xed, 0x93, 0x33, 0xd5, 0x01, 0x27, 0x44, 0xfc, 0xa0, 0x3b,
-	0xaa, 0x85, 0xf5, 0x5a, 0xb5, 0xa4, 0x75, 0x92, 0x4a, 0xca, 0xcf, 0x49, 0xa8, 0x3f, 0x11, 0x33,
+	0xd5, 0xc0, 0x7a, 0xad, 0x5a, 0xd2, 0x38, 0x49, 0x25, 0xe5, 0x17, 0x24, 0xd4, 0x4f, 0xc4, 0x4c,
-	0x8d, 0x6d, 0x17, 0xac, 0xa5, 0xfe, 0xa9, 0x7b, 0x63, 0x00, 0xf5, 0x5a, 0xcd, 0x9f, 0x82, 0x5c,
+	0x63, 0xdb, 0x05, 0x6b, 0xa9, 0x7f, 0xea, 0xde, 0x18, 0x40, 0xbd, 0x56, 0xf3, 0xa7, 0x20, 0x57,
-	0xd1, 0x88, 0x0d, 0x47, 0xca, 0x06, 0x70, 0x79, 0x8f, 0x6a, 0x65, 0x22, 0x73, 0xdd, 0x83, 0x65,
+	0x34, 0x62, 0xc3, 0x91, 0xb2, 0x01, 0x3c, 0xb9, 0x47, 0xb5, 0x32, 0x91, 0xb9, 0xee, 0xc1, 0x32,
-	0xac, 0x96, 0x2a, 0xe1, 0xc5, 0x95, 0xda, 0xe0, 0xaf, 0x98, 0x84, 0xc6, 0x0a, 0x5e, 0xc2, 0x0a,
+	0x56, 0x4b, 0x95, 0xf0, 0xf2, 0x4a, 0x6d, 0xf0, 0x57, 0x4c, 0x42, 0x63, 0x05, 0xaf, 0x60, 0x05,
-	0x66, 0xb9, 0x34, 0x97, 0x92, 0x0a, 0x69, 0xf9, 0xe8, 0xb5, 0xaa, 0x70, 0x48, 0x24, 0xbd, 0x22,
+	0xb3, 0x5c, 0x9a, 0x4b, 0x49, 0x85, 0xb4, 0x7c, 0xf4, 0x5a, 0x55, 0xd8, 0x27, 0x92, 0x5e, 0x91,
-	0x63, 0x57, 0xa1, 0x35, 0x4b, 0xfc, 0x1b, 0x15, 0xfe, 0xea, 0xd3, 0x67, 0x39, 0x0f, 0xa9, 0xce,
+	0x91, 0xab, 0xd0, 0x9a, 0x13, 0xfc, 0x6b, 0x25, 0xfe, 0xea, 0xe9, 0xb3, 0x9c, 0x87, 0x54, 0xe7,
-	0xdd, 0xc2, 0xd6, 0x42, 0xd7, 0x61, 0x45, 0x84, 0x2c, 0xa3, 0x3a, 0x7b, 0x17, 0x1b, 0x23, 0xb8,
+	0x6e, 0x60, 0x6b, 0xa1, 0x9b, 0xb0, 0x22, 0x42, 0x96, 0x51, 0x9d, 0xbd, 0x8d, 0x8d, 0x11, 0x3c,
-	0x07, 0x4d, 0x9d, 0x5c, 0x1d, 0x9f, 0x5d, 0xf9, 0x9e, 0x2e, 0xaf, 0x6d, 0xca, 0xd3, 0x3e, 0x6c,
+	0x80, 0xba, 0x4e, 0xae, 0x8e, 0xcf, 0xae, 0x7c, 0x4f, 0x97, 0xd7, 0x34, 0xe5, 0x69, 0x1f, 0xb6,
-	0x43, 0xc1, 0x31, 0x6c, 0x9f, 0x66, 0x11, 0x91, 0xb4, 0xe8, 0xa3, 0xbb, 0x56, 0xf7, 0xa0, 0x15,
+	0xa1, 0xe0, 0x18, 0xb6, 0xcf, 0xb2, 0x88, 0x48, 0x5a, 0xf4, 0xd1, 0x5d, 0xab, 0x07, 0xd0, 0x88,
-	0x3b, 0x9f, 0xae, 0x60, 0xd2, 0xa0, 0x62, 0xeb, 0x64, 0x47, 0xf0, 0x18, 0xb6, 0x0e, 0xa3, 0xe8,
+	0x9d, 0x4f, 0x57, 0x30, 0x6e, 0x50, 0xb1, 0x75, 0xbc, 0x23, 0x78, 0x0a, 0x5b, 0x87, 0x51, 0xf4,
-	0x6d, 0x51, 0x8e, 0xdd, 0x0b, 0xf6, 0xb6, 0x40, 0x5f, 0xc0, 0x96, 0xa9, 0xcb, 0xd4, 0xe9, 0x50,
+	0xb6, 0x28, 0xc7, 0xee, 0x0b, 0xf6, 0xb6, 0x40, 0x5f, 0xc0, 0x96, 0xa9, 0xcb, 0xd4, 0xe9, 0x50,
-	0xde, 0x87, 0x26, 0x77, 0x3d, 0xf1, 0x26, 0xaf, 0xb9, 0xdd, 0x64, 0x63, 0xc1, 0x0d, 0xd8, 0x7a,
+	0xde, 0x87, 0x3a, 0x77, 0x3d, 0xf1, 0xc6, 0x5f, 0x73, 0xbb, 0xc9, 0xc6, 0x82, 0x5b, 0xb0, 0x75,
-	0x9a, 0x8e, 0xe2, 0x94, 0x1e, 0xf5, 0x4f, 0xbf, 0xa1, 0x6e, 0x8e, 0x05, 0xbf, 0x78, 0xb0, 0x6a,
+	0x9a, 0x0e, 0xe2, 0x94, 0x1e, 0x75, 0xcf, 0xbe, 0xa1, 0x6e, 0x8e, 0x05, 0xbf, 0x79, 0xb0, 0x6a,
-	0xbf, 0x12, 0x7d, 0x58, 0x3c, 0xbe, 0xa4, 0xbc, 0xb8, 0x6c, 0xda, 0x2a, 0x1d, 0xd6, 0x52, 0xe5,
+	0x5f, 0x89, 0x3e, 0x2c, 0x1e, 0x0f, 0x29, 0x2f, 0x2e, 0x9b, 0xb6, 0xd0, 0x07, 0xb0, 0x6e, 0x56,
-	0xb0, 0xb6, 0xa1, 0x79, 0x2e, 0xe4, 0x38, 0x2b, 0x0e, 0xd7, 0x58, 0xea, 0x3a, 0xb0, 0x4c, 0xc6,
+	0xe7, 0x2c, 0x93, 0x31, 0x2b, 0xde, 0x5e, 0xdb, 0x78, 0x4f, 0x8d, 0x73, 0xe2, 0x4c, 0x6b, 0xa5,
-	0x2c, 0x35, 0xfa, 0xa2, 0x85, 0x9d, 0x89, 0xde, 0x81, 0x76, 0xc2, 0xf2, 0x54, 0x9e, 0x65, 0x2c,
+	0x33, 0xdd, 0x86, 0xfa, 0x85, 0x90, 0xa3, 0xac, 0x38, 0x6b, 0x63, 0xa9, 0x5b, 0xe3, 0xf0, 0x56,
-	0x4e, 0xa5, 0xbd, 0x62, 0xa0, 0x5d, 0x7d, 0xe5, 0x09, 0x7e, 0xf6, 0xa0, 0x69, 0x64, 0x08, 0x5a,
+	0x34, 0x9e, 0x33, 0xd1, 0x3b, 0xd0, 0x4c, 0x58, 0x9e, 0xca, 0xf3, 0x8c, 0xc5, 0xa9, 0xd4, 0xaa,
-	0x87, 0xa5, 0x62, 0xee, 0x2c, 0xc5, 0x7a, 0x86, 0xeb, 0x5c, 0xf6, 0xca, 0xeb, 0x4c, 0x3b, 0xb0,
+	0xa2, 0x81, 0x41, 0xbb, 0xba, 0xca, 0x13, 0xfc, 0xec, 0x41, 0xdd, 0xa8, 0x15, 0xb4, 0x0e, 0x4b,
-	0x7a, 0x99, 0x9c, 0x65, 0x44, 0x5e, 0x38, 0x0a, 0x97, 0x49, 0x9f, 0xc8, 0x0b, 0xf4, 0x01, 0xac,
+	0xc5, 0x78, 0x5a, 0x8a, 0xf5, 0xa8, 0xd7, 0xb9, 0xec, 0xcb, 0xd0, 0x99, 0x76, 0x60, 0x75, 0x98,
-	0x4f, 0xc6, 0x97, 0x8e, 0x9b, 0x7b, 0xd6, 0x2d, 0xbc, 0x7a, 0x5b, 0x89, 0xe9, 0x4a, 0x85, 0x69,
+	0x9c, 0x67, 0x44, 0x5e, 0x3a, 0x6a, 0xc3, 0xa4, 0x4b, 0xe4, 0xa5, 0xaa, 0x6c, 0x3c, 0xe5, 0x74,
-	0xf0, 0x1d, 0xc0, 0xe4, 0xcd, 0x56, 0xdf, 0x49, 0x5e, 0x90, 0x51, 0x4b, 0xe5, 0x19, 0x16, 0x83,
+	0xdc, 0x50, 0x6c, 0x17, 0x5e, 0xbd, 0x6d, 0x2e, 0xd3, 0xe0, 0x3b, 0x80, 0xf1, 0xa7, 0x5d, 0x3d,
-	0x4f, 0x2d, 0xd1, 0x1d, 0x58, 0x27, 0x51, 0x14, 0xab, 0xbf, 0x93, 0xd1, 0x71, 0x1c, 0x99, 0x2f,
+	0xa7, 0xbc, 0x20, 0xa3, 0x96, 0xca, 0xd3, 0x2f, 0xe6, 0xa3, 0x5a, 0xa2, 0x7b, 0xb0, 0x4e, 0xa2,
-	0xb0, 0x85, 0xa7, 0xbc, 0x1f, 0xf5, 0x60, 0xcd, 0x8d, 0x08, 0xd4, 0x84, 0xa5, 0xcb, 0x4f, 0x37,
+	0x28, 0x56, 0x7f, 0x27, 0x83, 0xe3, 0x38, 0x32, 0x0f, 0xb5, 0x81, 0xa7, 0xbc, 0x1f, 0x75, 0x60,
-	0xff, 0xa7, 0x7f, 0x3f, 0xdb, 0xf4, 0x0e, 0x7e, 0x6f, 0x41, 0xe7, 0x50, 0x29, 0xcc, 0x01, 0xe5,
+	0xcd, 0x4d, 0x12, 0x54, 0x87, 0xa5, 0xe1, 0xa7, 0x9b, 0xff, 0xd3, 0xbf, 0x9f, 0x6d, 0x7a, 0x07,
-	0xba, 0x09, 0xc7, 0xb0, 0x31, 0xa5, 0x19, 0xd1, 0x2d, 0x73, 0xbc, 0xf5, 0x52, 0xb2, 0xb7, 0xbd,
+	0xbf, 0x37, 0xa0, 0x75, 0xa8, 0x84, 0x68, 0x8f, 0x72, 0xdd, 0x84, 0x63, 0xd8, 0x98, 0x92, 0x96,
-	0x6f, 0x34, 0xe8, 0xbe, 0xd3, 0xa0, 0xfb, 0x4f, 0x94, 0x06, 0x45, 0x4f, 0x60, 0xbd, 0x2a, 0xc1,
+	0xe8, 0x8e, 0xb9, 0x05, 0xd5, 0x8a, 0xb3, 0xb3, 0xbd, 0x6f, 0xa4, 0xea, 0xbe, 0x93, 0xaa, 0xfb,
-	0xd0, 0x4d, 0x37, 0x22, 0x6b, 0x84, 0xd9, 0x5c, 0x98, 0x63, 0xd8, 0x98, 0x52, 0x63, 0x8e, 0x4f,
+	0xcf, 0x94, 0x54, 0x45, 0xcf, 0x60, 0xbd, 0xac, 0xd4, 0xd0, 0x6d, 0x37, 0x49, 0x2b, 0xf4, 0xdb,
-	0xbd, 0x48, 0x9b, 0x0b, 0xf4, 0x10, 0xda, 0x25, 0xf9, 0x85, 0x7c, 0x03, 0x32, 0xab, 0xc8, 0xe6,
+	0x5c, 0x98, 0x63, 0xd8, 0x98, 0x12, 0x6d, 0x8e, 0x4f, 0xb5, 0x96, 0x9b, 0x0b, 0xf4, 0x18, 0x9a,
-	0x02, 0x1c, 0x41, 0xb7, 0xa2, 0x88, 0x50, 0xcf, 0xd6, 0x53, 0x23, 0x93, 0xe6, 0x82, 0x3c, 0x82,
+	0x13, 0x2a, 0x0d, 0xf9, 0x06, 0x64, 0x56, 0xb8, 0xcd, 0x05, 0x38, 0x82, 0x76, 0x49, 0x38, 0xa1,
-	0x76, 0x49, 0x98, 0x38, 0x16, 0xb3, 0xea, 0xa7, 0xf7, 0xff, 0x9a, 0x88, 0x7d, 0xa5, 0x0f, 0x01,
+	0x8e, 0xad, 0xa7, 0x42, 0x4d, 0xcd, 0x05, 0x79, 0x02, 0xcd, 0x09, 0xfd, 0xe2, 0x58, 0xcc, 0x8a,
-	0xac, 0x8e, 0x88, 0xe2, 0xb4, 0x80, 0x98, 0xd1, 0x2f, 0x05, 0x44, 0x8d, 0xe6, 0x78, 0x08, 0x60,
+	0xa4, 0xce, 0xff, 0x2b, 0x22, 0xf6, 0x63, 0x7e, 0x08, 0x60, 0xe5, 0x46, 0x14, 0xa7, 0x05, 0xc4,
-	0x9e, 0xff, 0x88, 0xe5, 0x12, 0xed, 0xb8, 0x86, 0x4e, 0x69, 0x8e, 0x9e, 0x3f, 0x1b, 0x98, 0x01,
+	0x8c, 0xcc, 0x29, 0x20, 0x2a, 0xa4, 0xc9, 0x63, 0x00, 0xa3, 0x12, 0x22, 0x96, 0x4b, 0xb4, 0xe3,
-	0xa0, 0x9c, 0xbf, 0x09, 0xc0, 0x97, 0x00, 0x13, 0x59, 0xe1, 0x00, 0x66, 0x84, 0xc6, 0xdc, 0x3e,
+	0x1a, 0x3a, 0x25, 0x4d, 0x3a, 0xfe, 0x6c, 0x60, 0x06, 0x80, 0x72, 0x7e, 0x1d, 0x80, 0x2f, 0x01,
-	0x1e, 0x42, 0xa7, 0x2c, 0x22, 0x90, 0xad, 0xb5, 0x46, 0x58, 0xcc, 0x85, 0x78, 0x00, 0x9d, 0xf2,
+	0xc6, 0xea, 0xc3, 0x01, 0xcc, 0xe8, 0x91, 0xb9, 0x7d, 0x3c, 0x84, 0xd6, 0xa4, 0xd6, 0x40, 0xb6,
-	0xac, 0x75, 0x10, 0x35, 0xf3, 0xb7, 0x37, 0x3d, 0x23, 0xd1, 0x57, 0xb0, 0x31, 0x35, 0xf0, 0xdd,
+	0xd6, 0x0a, 0xfd, 0x31, 0x17, 0xe2, 0x11, 0xb4, 0x26, 0x47, 0xb2, 0x83, 0xa8, 0x18, 0xd3, 0x9d,
-	0xad, 0xac, 0x7f, 0x07, 0x6a, 0x11, 0xa6, 0x66, 0x74, 0xf5, 0x5e, 0xff, 0x3b, 0xc2, 0xe7, 0xd0,
+	0xe9, 0x51, 0x8a, 0xbe, 0x82, 0x8d, 0xa9, 0xef, 0x82, 0xbb, 0x95, 0xd5, 0x9f, 0x8b, 0x4a, 0x84,
-	0x29, 0x0f, 0x67, 0xc7, 0xbf, 0x66, 0x60, 0xf7, 0x2a, 0x03, 0x5a, 0x5d, 0xe4, 0x8a, 0x04, 0x72,
+	0xa9, 0x51, 0x5e, 0xbe, 0xd7, 0xff, 0x8e, 0xf0, 0x39, 0xb4, 0x26, 0x67, 0xb8, 0xe3, 0x5f, 0x31,
-	0x17, 0xb9, 0x4e, 0x17, 0xbd, 0xee, 0xf3, 0xae, 0x2a, 0x16, 0xf7, 0x79, 0xd7, 0xea, 0x98, 0xd7,
+	0xd7, 0x3b, 0xa5, 0x39, 0xae, 0x2e, 0x72, 0x49, 0x29, 0xb9, 0x8b, 0x5c, 0x25, 0x9f, 0xde, 0xf4,
-	0x9d, 0x63, 0xf9, 0x91, 0x70, 0x45, 0xd4, 0x3c, 0x1c, 0xf3, 0x20, 0x1e, 0x75, 0xfe, 0x78, 0x75,
+	0xbc, 0xcb, 0xc2, 0xc6, 0x3d, 0xef, 0x4a, 0xb9, 0xf3, 0xa6, 0x73, 0x9c, 0xfc, 0x96, 0xb8, 0x22,
-	0xdb, 0xfb, 0xf3, 0xd5, 0x6d, 0xef, 0xaf, 0x57, 0xb7, 0xbd, 0xe7, 0x4d, 0x1d, 0xfd, 0xe4, 0x9f,
+	0x2a, 0xbe, 0x2f, 0xf3, 0x20, 0x9e, 0xb4, 0xfe, 0x78, 0x7d, 0xd7, 0xfb, 0xf3, 0xf5, 0x5d, 0xef,
-	0x00, 0x00, 0x00, 0xff, 0xff, 0x39, 0x12, 0x9c, 0xa5, 0x38, 0x0f, 0x00, 0x00,
+	0xaf, 0xd7, 0x77, 0xbd, 0x17, 0x75, 0x1d, 0xfd, 0xe4, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x60,
+	0xd6, 0x13, 0xd5, 0x5f, 0x0f, 0x00, 0x00,
 }