// Code generated by protoc-gen-go. DO NOT EDIT.
// source: pdu.proto

package pdu

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

type FilesystemVersion_VersionType int32

const (
	FilesystemVersion_Snapshot FilesystemVersion_VersionType = 0
	FilesystemVersion_Bookmark FilesystemVersion_VersionType = 1
)

var FilesystemVersion_VersionType_name = map[int32]string{
	0: "Snapshot",
	1: "Bookmark",
}
var FilesystemVersion_VersionType_value = map[string]int32{
	"Snapshot": 0,
	"Bookmark": 1,
}

func (x FilesystemVersion_VersionType) String() string {
	return proto.EnumName(FilesystemVersion_VersionType_name, int32(x))
}
func (FilesystemVersion_VersionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_pdu_25ca9e5977a7ce3f, []int{5, 0}
}

type ListFilesystemReq struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ListFilesystemReq) Reset()         { *m = ListFilesystemReq{} }
func (m *ListFilesystemReq) String() string { return proto.CompactTextString(m) }
func (*ListFilesystemReq) ProtoMessage()    {}
func (*ListFilesystemReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_25ca9e5977a7ce3f, []int{0}
}
func (m *ListFilesystemReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListFilesystemReq.Unmarshal(m, b)
}
func (m *ListFilesystemReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListFilesystemReq.Marshal(b, m, deterministic)
}
func (dst *ListFilesystemReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListFilesystemReq.Merge(dst, src)
}
func (m *ListFilesystemReq) XXX_Size() int {
	return xxx_messageInfo_ListFilesystemReq.Size(m)
}
func (m *ListFilesystemReq) XXX_DiscardUnknown() {
	xxx_messageInfo_ListFilesystemReq.DiscardUnknown(m)
}

var xxx_messageInfo_ListFilesystemReq proto.InternalMessageInfo

type ListFilesystemRes struct {
	Filesystems          []*Filesystem `protobuf:"bytes,1,rep,name=Filesystems,proto3" json:"Filesystems,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *ListFilesystemRes) Reset()         { *m = ListFilesystemRes{} }
func (m *ListFilesystemRes) String() string { return proto.CompactTextString(m) }
func (*ListFilesystemRes) ProtoMessage()    {}
func (*ListFilesystemRes) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_25ca9e5977a7ce3f, []int{1}
}
func (m *ListFilesystemRes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListFilesystemRes.Unmarshal(m, b)
}
func (m *ListFilesystemRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListFilesystemRes.Marshal(b, m, deterministic)
}
func (dst *ListFilesystemRes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListFilesystemRes.Merge(dst, src)
}
func (m *ListFilesystemRes) XXX_Size() int {
	return xxx_messageInfo_ListFilesystemRes.Size(m)
}
func (m *ListFilesystemRes) XXX_DiscardUnknown() {
	xxx_messageInfo_ListFilesystemRes.DiscardUnknown(m)
}

var xxx_messageInfo_ListFilesystemRes proto.InternalMessageInfo

func (m *ListFilesystemRes) GetFilesystems() []*Filesystem {
	if m != nil {
		return m.Filesystems
	}
	return nil
}

type Filesystem struct {
	Path                 string   `protobuf:"bytes,1,opt,name=Path,proto3" json:"Path,omitempty"`
	ResumeToken          string   `protobuf:"bytes,2,opt,name=ResumeToken,proto3" json:"ResumeToken,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Filesystem) Reset()         { *m = Filesystem{} }
func (m *Filesystem) String() string { return proto.CompactTextString(m) }
func (*Filesystem) ProtoMessage()    {}
func (*Filesystem) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_25ca9e5977a7ce3f, []int{2}
}
func (m *Filesystem) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Filesystem.Unmarshal(m, b)
}
func (m *Filesystem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Filesystem.Marshal(b, m, deterministic)
}
func (dst *Filesystem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Filesystem.Merge(dst, src)
}
func (m *Filesystem) XXX_Size() int {
	return xxx_messageInfo_Filesystem.Size(m)
}
func (m *Filesystem) XXX_DiscardUnknown() {
	xxx_messageInfo_Filesystem.DiscardUnknown(m)
}

var xxx_messageInfo_Filesystem proto.InternalMessageInfo

func (m *Filesystem) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *Filesystem) GetResumeToken() string {
	if m != nil {
		return m.ResumeToken
	}
	return ""
}

type ListFilesystemVersionsReq struct {
	Filesystem           string   `protobuf:"bytes,1,opt,name=Filesystem,proto3" json:"Filesystem,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ListFilesystemVersionsReq) Reset()         { *m = ListFilesystemVersionsReq{} }
func (m *ListFilesystemVersionsReq) String() string { return proto.CompactTextString(m) }
func (*ListFilesystemVersionsReq) ProtoMessage()    {}
func (*ListFilesystemVersionsReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_25ca9e5977a7ce3f, []int{3}
}
func (m *ListFilesystemVersionsReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListFilesystemVersionsReq.Unmarshal(m, b)
}
func (m *ListFilesystemVersionsReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListFilesystemVersionsReq.Marshal(b, m, deterministic)
}
func (dst *ListFilesystemVersionsReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListFilesystemVersionsReq.Merge(dst, src)
}
func (m *ListFilesystemVersionsReq) XXX_Size() int {
	return xxx_messageInfo_ListFilesystemVersionsReq.Size(m)
}
func (m *ListFilesystemVersionsReq) XXX_DiscardUnknown() {
	xxx_messageInfo_ListFilesystemVersionsReq.DiscardUnknown(m)
}

var xxx_messageInfo_ListFilesystemVersionsReq proto.InternalMessageInfo

func (m *ListFilesystemVersionsReq) GetFilesystem() string {
	if m != nil {
		return m.Filesystem
	}
	return ""
}

type ListFilesystemVersionsRes struct {
	Versions             []*FilesystemVersion `protobuf:"bytes,1,rep,name=Versions,proto3" json:"Versions,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *ListFilesystemVersionsRes) Reset()         { *m = ListFilesystemVersionsRes{} }
func (m *ListFilesystemVersionsRes) String() string { return proto.CompactTextString(m) }
func (*ListFilesystemVersionsRes) ProtoMessage()    {}
func (*ListFilesystemVersionsRes) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_25ca9e5977a7ce3f, []int{4}
}
func (m *ListFilesystemVersionsRes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListFilesystemVersionsRes.Unmarshal(m, b)
}
func (m *ListFilesystemVersionsRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListFilesystemVersionsRes.Marshal(b, m, deterministic)
}
func (dst *ListFilesystemVersionsRes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListFilesystemVersionsRes.Merge(dst, src)
}
func (m *ListFilesystemVersionsRes) XXX_Size() int {
	return xxx_messageInfo_ListFilesystemVersionsRes.Size(m)
}
func (m *ListFilesystemVersionsRes) XXX_DiscardUnknown() {
	xxx_messageInfo_ListFilesystemVersionsRes.DiscardUnknown(m)
}

var xxx_messageInfo_ListFilesystemVersionsRes proto.InternalMessageInfo

func (m *ListFilesystemVersionsRes) GetVersions() []*FilesystemVersion {
	if m != nil {
		return m.Versions
	}
	return nil
}

type FilesystemVersion struct {
	Type                 FilesystemVersion_VersionType `protobuf:"varint,1,opt,name=Type,proto3,enum=pdu.FilesystemVersion_VersionType" json:"Type,omitempty"`
	Name                 string                        `protobuf:"bytes,2,opt,name=Name,proto3" json:"Name,omitempty"`
	Guid                 uint64                        `protobuf:"varint,3,opt,name=Guid,proto3" json:"Guid,omitempty"`
	CreateTXG            uint64                        `protobuf:"varint,4,opt,name=CreateTXG,proto3" json:"CreateTXG,omitempty"`
	Creation             string                        `protobuf:"bytes,5,opt,name=Creation,proto3" json:"Creation,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

func (m *FilesystemVersion) Reset()         { *m = FilesystemVersion{} }
func (m *FilesystemVersion) String() string { return proto.CompactTextString(m) }
func (*FilesystemVersion) ProtoMessage()    {}
func (*FilesystemVersion) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_25ca9e5977a7ce3f, []int{5}
}
func (m *FilesystemVersion) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FilesystemVersion.Unmarshal(m, b)
}
func (m *FilesystemVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FilesystemVersion.Marshal(b, m, deterministic)
}
func (dst *FilesystemVersion) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FilesystemVersion.Merge(dst, src)
}
func (m *FilesystemVersion) XXX_Size() int {
	return xxx_messageInfo_FilesystemVersion.Size(m)
}
func (m *FilesystemVersion) XXX_DiscardUnknown() {
	xxx_messageInfo_FilesystemVersion.DiscardUnknown(m)
}

var xxx_messageInfo_FilesystemVersion proto.InternalMessageInfo

func (m *FilesystemVersion) GetType() FilesystemVersion_VersionType {
	if m != nil {
		return m.Type
	}
	return FilesystemVersion_Snapshot
}

func (m *FilesystemVersion) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *FilesystemVersion) GetGuid() uint64 {
	if m != nil {
		return m.Guid
	}
	return 0
}

func (m *FilesystemVersion) GetCreateTXG() uint64 {
	if m != nil {
		return m.CreateTXG
	}
	return 0
}

func (m *FilesystemVersion) GetCreation() string {
	if m != nil {
		return m.Creation
	}
	return ""
}

type SendReq struct {
	Filesystem string `protobuf:"bytes,1,opt,name=Filesystem,proto3" json:"Filesystem,omitempty"`
	From       string `protobuf:"bytes,2,opt,name=From,proto3" json:"From,omitempty"`
	// May be empty / null to request a full transfer of From
	To string `protobuf:"bytes,3,opt,name=To,proto3" json:"To,omitempty"`
	// If ResumeToken is not empty, the resume token that CAN be tried for 'zfs send' by the sender.
	// The sender MUST indicate in SendRes.UsedResumeToken
	// If it does not work, the sender SHOULD clear the resume token on their side
	// and use From and To instead
	// If ResumeToken is not empty, the GUIDs of From and To
	// MUST correspond to those encoded in the ResumeToken.
	// Otherwise, the Sender MUST return an error.
	ResumeToken          string   `protobuf:"bytes,4,opt,name=ResumeToken,proto3" json:"ResumeToken,omitempty"`
	Compress             bool     `protobuf:"varint,5,opt,name=Compress,proto3" json:"Compress,omitempty"`
	Dedup                bool     `protobuf:"varint,6,opt,name=Dedup,proto3" json:"Dedup,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SendReq) Reset()         { *m = SendReq{} }
func (m *SendReq) String() string { return proto.CompactTextString(m) }
func (*SendReq) ProtoMessage()    {}
func (*SendReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_25ca9e5977a7ce3f, []int{6}
}
func (m *SendReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SendReq.Unmarshal(m, b)
}
func (m *SendReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SendReq.Marshal(b, m, deterministic)
}
func (dst *SendReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SendReq.Merge(dst, src)
}
func (m *SendReq) XXX_Size() int {
	return xxx_messageInfo_SendReq.Size(m)
}
func (m *SendReq) XXX_DiscardUnknown() {
	xxx_messageInfo_SendReq.DiscardUnknown(m)
}

var xxx_messageInfo_SendReq proto.InternalMessageInfo

func (m *SendReq) GetFilesystem() string {
	if m != nil {
		return m.Filesystem
	}
	return ""
}

func (m *SendReq) GetFrom() string {
	if m != nil {
		return m.From
	}
	return ""
}

func (m *SendReq) GetTo() string {
	if m != nil {
		return m.To
	}
	return ""
}

func (m *SendReq) GetResumeToken() string {
	if m != nil {
		return m.ResumeToken
	}
	return ""
}

func (m *SendReq) GetCompress() bool {
	if m != nil {
		return m.Compress
	}
	return false
}

func (m *SendReq) GetDedup() bool {
	if m != nil {
		return m.Dedup
	}
	return false
}

type Property struct {
	Name                 string   `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
	Value                string   `protobuf:"bytes,2,opt,name=Value,proto3" json:"Value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Property) Reset()         { *m = Property{} }
func (m *Property) String() string { return proto.CompactTextString(m) }
func (*Property) ProtoMessage()    {}
func (*Property) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_25ca9e5977a7ce3f, []int{7}
}
func (m *Property) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Property.Unmarshal(m, b)
}
func (m *Property) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Property.Marshal(b, m, deterministic)
}
func (dst *Property) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Property.Merge(dst, src)
}
func (m *Property) XXX_Size() int {
	return xxx_messageInfo_Property.Size(m)
}
func (m *Property) XXX_DiscardUnknown() {
	xxx_messageInfo_Property.DiscardUnknown(m)
}

var xxx_messageInfo_Property proto.InternalMessageInfo

func (m *Property) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Property) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type SendRes struct {
	// Whether the resume token provided in the request has been used or not.
	UsedResumeToken      bool        `protobuf:"varint,1,opt,name=UsedResumeToken,proto3" json:"UsedResumeToken,omitempty"`
	Properties           []*Property `protobuf:"bytes,2,rep,name=Properties,proto3" json:"Properties,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *SendRes) Reset()         { *m = SendRes{} }
func (m *SendRes) String() string { return proto.CompactTextString(m) }
func (*SendRes) ProtoMessage()    {}
func (*SendRes) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_25ca9e5977a7ce3f, []int{8}
}
func (m *SendRes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SendRes.Unmarshal(m, b)
}
func (m *SendRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SendRes.Marshal(b, m, deterministic)
}
func (dst *SendRes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SendRes.Merge(dst, src)
}
func (m *SendRes) XXX_Size() int {
	return xxx_messageInfo_SendRes.Size(m)
}
func (m *SendRes) XXX_DiscardUnknown() {
	xxx_messageInfo_SendRes.DiscardUnknown(m)
}

var xxx_messageInfo_SendRes proto.InternalMessageInfo

func (m *SendRes) GetUsedResumeToken() bool {
	if m != nil {
		return m.UsedResumeToken
	}
	return false
}

func (m *SendRes) GetProperties() []*Property {
	if m != nil {
		return m.Properties
	}
	return nil
}

type ReceiveReq struct {
	Filesystem string `protobuf:"bytes,1,opt,name=Filesystem,proto3" json:"Filesystem,omitempty"`
	// If true, the receiver should clear the resume token before perfoming the zfs recv of the stream in the request
	ClearResumeToken     bool     `protobuf:"varint,2,opt,name=ClearResumeToken,proto3" json:"ClearResumeToken,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReceiveReq) Reset()         { *m = ReceiveReq{} }
func (m *ReceiveReq) String() string { return proto.CompactTextString(m) }
func (*ReceiveReq) ProtoMessage()    {}
func (*ReceiveReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_25ca9e5977a7ce3f, []int{9}
}
func (m *ReceiveReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReceiveReq.Unmarshal(m, b)
}
func (m *ReceiveReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReceiveReq.Marshal(b, m, deterministic)
}
func (dst *ReceiveReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiveReq.Merge(dst, src)
}
func (m *ReceiveReq) XXX_Size() int {
	return xxx_messageInfo_ReceiveReq.Size(m)
}
func (m *ReceiveReq) XXX_DiscardUnknown() {
	xxx_messageInfo_ReceiveReq.DiscardUnknown(m)
}

var xxx_messageInfo_ReceiveReq proto.InternalMessageInfo

func (m *ReceiveReq) GetFilesystem() string {
	if m != nil {
		return m.Filesystem
	}
	return ""
}

func (m *ReceiveReq) GetClearResumeToken() bool {
	if m != nil {
		return m.ClearResumeToken
	}
	return false
}

type ReceiveRes struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReceiveRes) Reset()         { *m = ReceiveRes{} }
func (m *ReceiveRes) String() string { return proto.CompactTextString(m) }
func (*ReceiveRes) ProtoMessage()    {}
func (*ReceiveRes) Descriptor() ([]byte, []int) {
	return fileDescriptor_pdu_25ca9e5977a7ce3f, []int{10}
}
func (m *ReceiveRes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReceiveRes.Unmarshal(m, b)
}
func (m *ReceiveRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReceiveRes.Marshal(b, m, deterministic)
}
func (dst *ReceiveRes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiveRes.Merge(dst, src)
}
func (m *ReceiveRes) XXX_Size() int {
	return xxx_messageInfo_ReceiveRes.Size(m)
}
func (m *ReceiveRes) XXX_DiscardUnknown() {
	xxx_messageInfo_ReceiveRes.DiscardUnknown(m)
}

var xxx_messageInfo_ReceiveRes proto.InternalMessageInfo

func init() {
	proto.RegisterType((*ListFilesystemReq)(nil), "pdu.ListFilesystemReq")
	proto.RegisterType((*ListFilesystemRes)(nil), "pdu.ListFilesystemRes")
	proto.RegisterType((*Filesystem)(nil), "pdu.Filesystem")
	proto.RegisterType((*ListFilesystemVersionsReq)(nil), "pdu.ListFilesystemVersionsReq")
	proto.RegisterType((*ListFilesystemVersionsRes)(nil), "pdu.ListFilesystemVersionsRes")
	proto.RegisterType((*FilesystemVersion)(nil), "pdu.FilesystemVersion")
	proto.RegisterType((*SendReq)(nil), "pdu.SendReq")
	proto.RegisterType((*Property)(nil), "pdu.Property")
	proto.RegisterType((*SendRes)(nil), "pdu.SendRes")
	proto.RegisterType((*ReceiveReq)(nil), "pdu.ReceiveReq")
	proto.RegisterType((*ReceiveRes)(nil), "pdu.ReceiveRes")
	proto.RegisterEnum("pdu.FilesystemVersion_VersionType", FilesystemVersion_VersionType_name, FilesystemVersion_VersionType_value)
}

func init() { proto.RegisterFile("pdu.proto", fileDescriptor_pdu_25ca9e5977a7ce3f) }

var fileDescriptor_pdu_25ca9e5977a7ce3f = []byte{
	// 445 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0xc1, 0x6e, 0xd3, 0x40,
	0x10, 0x65, 0x13, 0xa7, 0x38, 0x93, 0xd2, 0xa6, 0x4b, 0x85, 0x0c, 0x42, 0x28, 0xda, 0x53, 0x40,
	0x22, 0x12, 0x01, 0x71, 0xe1, 0xd6, 0xa2, 0xf4, 0x82, 0xa0, 0xda, 0x9a, 0xaa, 0x57, 0x17, 0x8f,
	0x54, 0x2b, 0xb1, 0x77, 0xbb, 0x63, 0x23, 0xe5, 0x73, 0xf8, 0x2b, 0x3e, 0x07, 0x79, 0x6a, 0x27,
	0x4b, 0x0c, 0x52, 0x4e, 0x99, 0xf7, 0x66, 0x32, 0xf3, 0xe6, 0xcd, 0x1a, 0x86, 0x36, 0xad, 0x66,
	0xd6, 0x99, 0xd2, 0xc8, 0xbe, 0x4d, 0x2b, 0xf5, 0x14, 0x4e, 0xbe, 0x64, 0x54, 0x2e, 0xb2, 0x15,
	0xd2, 0x9a, 0x4a, 0xcc, 0x35, 0xde, 0xab, 0x45, 0x97, 0x24, 0xf9, 0x0e, 0x46, 0x5b, 0x82, 0x22,
	0x31, 0xe9, 0x4f, 0x47, 0xf3, 0xe3, 0x59, 0xdd, 0xcf, 0x2b, 0xf4, 0x6b, 0xd4, 0x19, 0xc0, 0x16,
	0x4a, 0x09, 0xc1, 0x65, 0x52, 0xde, 0x45, 0x62, 0x22, 0xa6, 0x43, 0xcd, 0xb1, 0x9c, 0xc0, 0x48,
	0x23, 0x55, 0x39, 0xc6, 0x66, 0x89, 0x45, 0xd4, 0xe3, 0x94, 0x4f, 0xa9, 0x4f, 0xf0, 0xfc, 0x6f,
	0x2d, 0xd7, 0xe8, 0x28, 0x33, 0x05, 0x69, 0xbc, 0x97, 0xaf, 0xfc, 0x01, 0x4d, 0x63, 0x8f, 0x51,
	0xdf, 0xfe, 0xff, 0x67, 0x92, 0x73, 0x08, 0x5b, 0xd8, 0x6c, 0xf3, 0x6c, 0x67, 0x9b, 0x26, 0xad,
	0x37, 0x75, 0xea, 0xb7, 0x80, 0x93, 0x4e, 0x5e, 0x7e, 0x84, 0x20, 0x5e, 0x5b, 0x64, 0x01, 0x47,
	0x73, 0xf5, 0xef, 0x2e, 0xb3, 0xe6, 0xb7, 0xae, 0xd4, 0x5c, 0x5f, 0x3b, 0xf2, 0x35, 0xc9, 0xb1,
	0x59, 0x9b, 0xe3, 0x9a, 0xbb, 0xa8, 0xb2, 0x34, 0xea, 0x4f, 0xc4, 0x34, 0xd0, 0x1c, 0xcb, 0x97,
	0x30, 0x3c, 0x77, 0x98, 0x94, 0x18, 0xdf, 0x5c, 0x44, 0x01, 0x27, 0xb6, 0x84, 0x7c, 0x01, 0x21,
	0x83, 0xcc, 0x14, 0xd1, 0x80, 0x3b, 0x6d, 0xb0, 0x7a, 0x0d, 0x23, 0x6f, 0xac, 0x3c, 0x84, 0xf0,
	0xaa, 0x48, 0x2c, 0xdd, 0x99, 0x72, 0xfc, 0xa8, 0x46, 0x67, 0xc6, 0x2c, 0xf3, 0xc4, 0x2d, 0xc7,
	0x42, 0xfd, 0x12, 0xf0, 0xf8, 0x0a, 0x8b, 0x74, 0x0f, 0x5f, 0x6b, 0x91, 0x0b, 0x67, 0xf2, 0x56,
	0x78, 0x1d, 0xcb, 0x23, 0xe8, 0xc5, 0x86, 0x65, 0x0f, 0x75, 0x2f, 0x36, 0xbb, 0xa7, 0x0d, 0x3a,
	0xa7, 0x65, 0xe1, 0x26, 0xb7, 0x0e, 0x89, 0x58, 0x78, 0xa8, 0x37, 0x58, 0x9e, 0xc2, 0xe0, 0x33,
	0xa6, 0x95, 0x8d, 0x0e, 0x38, 0xf1, 0x00, 0xd4, 0x07, 0x08, 0x2f, 0x9d, 0xb1, 0xe8, 0xca, 0xf5,
	0xc6, 0x3c, 0xe1, 0x99, 0x77, 0x0a, 0x83, 0xeb, 0x64, 0x55, 0xb5, 0x8e, 0x3e, 0x00, 0x75, 0xdb,
	0x2e, 0x46, 0x72, 0x0a, 0xc7, 0xdf, 0x09, 0x53, 0x5f, 0x98, 0xe0, 0x01, 0xbb, 0xb4, 0x7c, 0x0b,
	0xd0, 0x8c, 0xca, 0x90, 0xa2, 0x1e, 0xbf, 0x8f, 0x27, 0x7c, 0xd9, 0x56, 0x81, 0xf6, 0x0a, 0xd4,
	0x0d, 0x80, 0xc6, 0x1f, 0x98, 0xfd, 0xc4, 0x7d, 0xfc, 0x7b, 0x03, 0xe3, 0xf3, 0x15, 0x26, 0x6e,
	0xf7, 0xed, 0x87, 0xba, 0xc3, 0xab, 0x43, 0xaf, 0x33, 0xdd, 0x1e, 0xf0, 0xb7, 0xfb, 0xfe, 0x4f,
	0x00, 0x00, 0x00, 0xff, 0xff, 0xfd, 0xc4, 0x8d, 0xb7, 0xc8, 0x03, 0x00, 0x00,
}