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

package protobuf

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	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 protobuf is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package protobuf to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type ContentManifestPayload struct {
	Mappings             []*ContentManifestPayload_FileMapping `protobuf:"bytes,1,rep,name=mappings" json:"mappings,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                              `json:"-"`
	XXX_unrecognized     []byte                                `json:"-"`
	XXX_sizecache        int32                                 `json:"-"`
}

func (m *ContentManifestPayload) Reset()         { *m = ContentManifestPayload{} }
func (m *ContentManifestPayload) String() string { return proto.CompactTextString(m) }
func (*ContentManifestPayload) ProtoMessage()    {}
func (*ContentManifestPayload) Descriptor() ([]byte, []int) {
	return fileDescriptor_e3cda137a29253ba, []int{0}
}

func (m *ContentManifestPayload) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ContentManifestPayload.Unmarshal(m, b)
}
func (m *ContentManifestPayload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ContentManifestPayload.Marshal(b, m, deterministic)
}
func (m *ContentManifestPayload) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContentManifestPayload.Merge(m, src)
}
func (m *ContentManifestPayload) XXX_Size() int {
	return xxx_messageInfo_ContentManifestPayload.Size(m)
}
func (m *ContentManifestPayload) XXX_DiscardUnknown() {
	xxx_messageInfo_ContentManifestPayload.DiscardUnknown(m)
}

var xxx_messageInfo_ContentManifestPayload proto.InternalMessageInfo

func (m *ContentManifestPayload) GetMappings() []*ContentManifestPayload_FileMapping {
	if m != nil {
		return m.Mappings
	}
	return nil
}

type ContentManifestPayload_FileMapping struct {
	Filename             *string                                         `protobuf:"bytes,1,opt,name=filename" json:"filename,omitempty"`
	Size                 *uint64                                         `protobuf:"varint,2,opt,name=size" json:"size,omitempty"`
	Flags                *uint32                                         `protobuf:"varint,3,opt,name=flags" json:"flags,omitempty"`
	ShaFilename          []byte                                          `protobuf:"bytes,4,opt,name=sha_filename" json:"sha_filename,omitempty"`
	ShaContent           []byte                                          `protobuf:"bytes,5,opt,name=sha_content" json:"sha_content,omitempty"`
	Chunks               []*ContentManifestPayload_FileMapping_ChunkData `protobuf:"bytes,6,rep,name=chunks" json:"chunks,omitempty"`
	Linktarget           *string                                         `protobuf:"bytes,7,opt,name=linktarget" json:"linktarget,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                        `json:"-"`
	XXX_unrecognized     []byte                                          `json:"-"`
	XXX_sizecache        int32                                           `json:"-"`
}

func (m *ContentManifestPayload_FileMapping) Reset()         { *m = ContentManifestPayload_FileMapping{} }
func (m *ContentManifestPayload_FileMapping) String() string { return proto.CompactTextString(m) }
func (*ContentManifestPayload_FileMapping) ProtoMessage()    {}
func (*ContentManifestPayload_FileMapping) Descriptor() ([]byte, []int) {
	return fileDescriptor_e3cda137a29253ba, []int{0, 0}
}

func (m *ContentManifestPayload_FileMapping) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ContentManifestPayload_FileMapping.Unmarshal(m, b)
}
func (m *ContentManifestPayload_FileMapping) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ContentManifestPayload_FileMapping.Marshal(b, m, deterministic)
}
func (m *ContentManifestPayload_FileMapping) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContentManifestPayload_FileMapping.Merge(m, src)
}
func (m *ContentManifestPayload_FileMapping) XXX_Size() int {
	return xxx_messageInfo_ContentManifestPayload_FileMapping.Size(m)
}
func (m *ContentManifestPayload_FileMapping) XXX_DiscardUnknown() {
	xxx_messageInfo_ContentManifestPayload_FileMapping.DiscardUnknown(m)
}

var xxx_messageInfo_ContentManifestPayload_FileMapping proto.InternalMessageInfo

func (m *ContentManifestPayload_FileMapping) GetFilename() string {
	if m != nil && m.Filename != nil {
		return *m.Filename
	}
	return ""
}

func (m *ContentManifestPayload_FileMapping) GetSize() uint64 {
	if m != nil && m.Size != nil {
		return *m.Size
	}
	return 0
}

func (m *ContentManifestPayload_FileMapping) GetFlags() uint32 {
	if m != nil && m.Flags != nil {
		return *m.Flags
	}
	return 0
}

func (m *ContentManifestPayload_FileMapping) GetShaFilename() []byte {
	if m != nil {
		return m.ShaFilename
	}
	return nil
}

func (m *ContentManifestPayload_FileMapping) GetShaContent() []byte {
	if m != nil {
		return m.ShaContent
	}
	return nil
}

func (m *ContentManifestPayload_FileMapping) GetChunks() []*ContentManifestPayload_FileMapping_ChunkData {
	if m != nil {
		return m.Chunks
	}
	return nil
}

func (m *ContentManifestPayload_FileMapping) GetLinktarget() string {
	if m != nil && m.Linktarget != nil {
		return *m.Linktarget
	}
	return ""
}

type ContentManifestPayload_FileMapping_ChunkData struct {
	Sha                  []byte   `protobuf:"bytes,1,opt,name=sha" json:"sha,omitempty"`
	Crc                  *uint32  `protobuf:"fixed32,2,opt,name=crc" json:"crc,omitempty"`
	Offset               *uint64  `protobuf:"varint,3,opt,name=offset" json:"offset,omitempty"`
	CbOriginal           *uint32  `protobuf:"varint,4,opt,name=cb_original" json:"cb_original,omitempty"`
	CbCompressed         *uint32  `protobuf:"varint,5,opt,name=cb_compressed" json:"cb_compressed,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ContentManifestPayload_FileMapping_ChunkData) Reset() {
	*m = ContentManifestPayload_FileMapping_ChunkData{}
}
func (m *ContentManifestPayload_FileMapping_ChunkData) String() string {
	return proto.CompactTextString(m)
}
func (*ContentManifestPayload_FileMapping_ChunkData) ProtoMessage() {}
func (*ContentManifestPayload_FileMapping_ChunkData) Descriptor() ([]byte, []int) {
	return fileDescriptor_e3cda137a29253ba, []int{0, 0, 0}
}

func (m *ContentManifestPayload_FileMapping_ChunkData) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ContentManifestPayload_FileMapping_ChunkData.Unmarshal(m, b)
}
func (m *ContentManifestPayload_FileMapping_ChunkData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ContentManifestPayload_FileMapping_ChunkData.Marshal(b, m, deterministic)
}
func (m *ContentManifestPayload_FileMapping_ChunkData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContentManifestPayload_FileMapping_ChunkData.Merge(m, src)
}
func (m *ContentManifestPayload_FileMapping_ChunkData) XXX_Size() int {
	return xxx_messageInfo_ContentManifestPayload_FileMapping_ChunkData.Size(m)
}
func (m *ContentManifestPayload_FileMapping_ChunkData) XXX_DiscardUnknown() {
	xxx_messageInfo_ContentManifestPayload_FileMapping_ChunkData.DiscardUnknown(m)
}

var xxx_messageInfo_ContentManifestPayload_FileMapping_ChunkData proto.InternalMessageInfo

func (m *ContentManifestPayload_FileMapping_ChunkData) GetSha() []byte {
	if m != nil {
		return m.Sha
	}
	return nil
}

func (m *ContentManifestPayload_FileMapping_ChunkData) GetCrc() uint32 {
	if m != nil && m.Crc != nil {
		return *m.Crc
	}
	return 0
}

func (m *ContentManifestPayload_FileMapping_ChunkData) GetOffset() uint64 {
	if m != nil && m.Offset != nil {
		return *m.Offset
	}
	return 0
}

func (m *ContentManifestPayload_FileMapping_ChunkData) GetCbOriginal() uint32 {
	if m != nil && m.CbOriginal != nil {
		return *m.CbOriginal
	}
	return 0
}

func (m *ContentManifestPayload_FileMapping_ChunkData) GetCbCompressed() uint32 {
	if m != nil && m.CbCompressed != nil {
		return *m.CbCompressed
	}
	return 0
}

type ContentManifestMetadata struct {
	DepotId              *uint32  `protobuf:"varint,1,opt,name=depot_id" json:"depot_id,omitempty"`
	GidManifest          *uint64  `protobuf:"varint,2,opt,name=gid_manifest" json:"gid_manifest,omitempty"`
	CreationTime         *uint32  `protobuf:"varint,3,opt,name=creation_time" json:"creation_time,omitempty"`
	FilenamesEncrypted   *bool    `protobuf:"varint,4,opt,name=filenames_encrypted" json:"filenames_encrypted,omitempty"`
	CbDiskOriginal       *uint64  `protobuf:"varint,5,opt,name=cb_disk_original" json:"cb_disk_original,omitempty"`
	CbDiskCompressed     *uint64  `protobuf:"varint,6,opt,name=cb_disk_compressed" json:"cb_disk_compressed,omitempty"`
	UniqueChunks         *uint32  `protobuf:"varint,7,opt,name=unique_chunks" json:"unique_chunks,omitempty"`
	CrcEncrypted         *uint32  `protobuf:"varint,8,opt,name=crc_encrypted" json:"crc_encrypted,omitempty"`
	CrcClear             *uint32  `protobuf:"varint,9,opt,name=crc_clear" json:"crc_clear,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ContentManifestMetadata) Reset()         { *m = ContentManifestMetadata{} }
func (m *ContentManifestMetadata) String() string { return proto.CompactTextString(m) }
func (*ContentManifestMetadata) ProtoMessage()    {}
func (*ContentManifestMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_e3cda137a29253ba, []int{1}
}

func (m *ContentManifestMetadata) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ContentManifestMetadata.Unmarshal(m, b)
}
func (m *ContentManifestMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ContentManifestMetadata.Marshal(b, m, deterministic)
}
func (m *ContentManifestMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContentManifestMetadata.Merge(m, src)
}
func (m *ContentManifestMetadata) XXX_Size() int {
	return xxx_messageInfo_ContentManifestMetadata.Size(m)
}
func (m *ContentManifestMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_ContentManifestMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_ContentManifestMetadata proto.InternalMessageInfo

func (m *ContentManifestMetadata) GetDepotId() uint32 {
	if m != nil && m.DepotId != nil {
		return *m.DepotId
	}
	return 0
}

func (m *ContentManifestMetadata) GetGidManifest() uint64 {
	if m != nil && m.GidManifest != nil {
		return *m.GidManifest
	}
	return 0
}

func (m *ContentManifestMetadata) GetCreationTime() uint32 {
	if m != nil && m.CreationTime != nil {
		return *m.CreationTime
	}
	return 0
}

func (m *ContentManifestMetadata) GetFilenamesEncrypted() bool {
	if m != nil && m.FilenamesEncrypted != nil {
		return *m.FilenamesEncrypted
	}
	return false
}

func (m *ContentManifestMetadata) GetCbDiskOriginal() uint64 {
	if m != nil && m.CbDiskOriginal != nil {
		return *m.CbDiskOriginal
	}
	return 0
}

func (m *ContentManifestMetadata) GetCbDiskCompressed() uint64 {
	if m != nil && m.CbDiskCompressed != nil {
		return *m.CbDiskCompressed
	}
	return 0
}

func (m *ContentManifestMetadata) GetUniqueChunks() uint32 {
	if m != nil && m.UniqueChunks != nil {
		return *m.UniqueChunks
	}
	return 0
}

func (m *ContentManifestMetadata) GetCrcEncrypted() uint32 {
	if m != nil && m.CrcEncrypted != nil {
		return *m.CrcEncrypted
	}
	return 0
}

func (m *ContentManifestMetadata) GetCrcClear() uint32 {
	if m != nil && m.CrcClear != nil {
		return *m.CrcClear
	}
	return 0
}

type ContentManifestSignature struct {
	Signature            []byte   `protobuf:"bytes,1,opt,name=signature" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ContentManifestSignature) Reset()         { *m = ContentManifestSignature{} }
func (m *ContentManifestSignature) String() string { return proto.CompactTextString(m) }
func (*ContentManifestSignature) ProtoMessage()    {}
func (*ContentManifestSignature) Descriptor() ([]byte, []int) {
	return fileDescriptor_e3cda137a29253ba, []int{2}
}

func (m *ContentManifestSignature) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ContentManifestSignature.Unmarshal(m, b)
}
func (m *ContentManifestSignature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ContentManifestSignature.Marshal(b, m, deterministic)
}
func (m *ContentManifestSignature) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContentManifestSignature.Merge(m, src)
}
func (m *ContentManifestSignature) XXX_Size() int {
	return xxx_messageInfo_ContentManifestSignature.Size(m)
}
func (m *ContentManifestSignature) XXX_DiscardUnknown() {
	xxx_messageInfo_ContentManifestSignature.DiscardUnknown(m)
}

var xxx_messageInfo_ContentManifestSignature proto.InternalMessageInfo

func (m *ContentManifestSignature) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

type ContentDeltaChunks struct {
	DepotId              *uint32                          `protobuf:"varint,1,opt,name=depot_id" json:"depot_id,omitempty"`
	ManifestIdSource     *uint64                          `protobuf:"varint,2,opt,name=manifest_id_source" json:"manifest_id_source,omitempty"`
	ManifestIdTarget     *uint64                          `protobuf:"varint,3,opt,name=manifest_id_target" json:"manifest_id_target,omitempty"`
	DeltaChunks          []*ContentDeltaChunks_DeltaChunk `protobuf:"bytes,4,rep,name=deltaChunks" json:"deltaChunks,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                         `json:"-"`
	XXX_unrecognized     []byte                           `json:"-"`
	XXX_sizecache        int32                            `json:"-"`
}

func (m *ContentDeltaChunks) Reset()         { *m = ContentDeltaChunks{} }
func (m *ContentDeltaChunks) String() string { return proto.CompactTextString(m) }
func (*ContentDeltaChunks) ProtoMessage()    {}
func (*ContentDeltaChunks) Descriptor() ([]byte, []int) {
	return fileDescriptor_e3cda137a29253ba, []int{3}
}

func (m *ContentDeltaChunks) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ContentDeltaChunks.Unmarshal(m, b)
}
func (m *ContentDeltaChunks) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ContentDeltaChunks.Marshal(b, m, deterministic)
}
func (m *ContentDeltaChunks) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContentDeltaChunks.Merge(m, src)
}
func (m *ContentDeltaChunks) XXX_Size() int {
	return xxx_messageInfo_ContentDeltaChunks.Size(m)
}
func (m *ContentDeltaChunks) XXX_DiscardUnknown() {
	xxx_messageInfo_ContentDeltaChunks.DiscardUnknown(m)
}

var xxx_messageInfo_ContentDeltaChunks proto.InternalMessageInfo

func (m *ContentDeltaChunks) GetDepotId() uint32 {
	if m != nil && m.DepotId != nil {
		return *m.DepotId
	}
	return 0
}

func (m *ContentDeltaChunks) GetManifestIdSource() uint64 {
	if m != nil && m.ManifestIdSource != nil {
		return *m.ManifestIdSource
	}
	return 0
}

func (m *ContentDeltaChunks) GetManifestIdTarget() uint64 {
	if m != nil && m.ManifestIdTarget != nil {
		return *m.ManifestIdTarget
	}
	return 0
}

func (m *ContentDeltaChunks) GetDeltaChunks() []*ContentDeltaChunks_DeltaChunk {
	if m != nil {
		return m.DeltaChunks
	}
	return nil
}

type ContentDeltaChunks_DeltaChunk struct {
	ShaSource            []byte   `protobuf:"bytes,1,opt,name=sha_source" json:"sha_source,omitempty"`
	ShaTarget            []byte   `protobuf:"bytes,2,opt,name=sha_target" json:"sha_target,omitempty"`
	SizeOriginal         *uint32  `protobuf:"varint,3,opt,name=size_original" json:"size_original,omitempty"`
	PatchMethod          *uint32  `protobuf:"varint,4,opt,name=patch_method" json:"patch_method,omitempty"`
	Chunk                []byte   `protobuf:"bytes,5,opt,name=chunk" json:"chunk,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ContentDeltaChunks_DeltaChunk) Reset()         { *m = ContentDeltaChunks_DeltaChunk{} }
func (m *ContentDeltaChunks_DeltaChunk) String() string { return proto.CompactTextString(m) }
func (*ContentDeltaChunks_DeltaChunk) ProtoMessage()    {}
func (*ContentDeltaChunks_DeltaChunk) Descriptor() ([]byte, []int) {
	return fileDescriptor_e3cda137a29253ba, []int{3, 0}
}

func (m *ContentDeltaChunks_DeltaChunk) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ContentDeltaChunks_DeltaChunk.Unmarshal(m, b)
}
func (m *ContentDeltaChunks_DeltaChunk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ContentDeltaChunks_DeltaChunk.Marshal(b, m, deterministic)
}
func (m *ContentDeltaChunks_DeltaChunk) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContentDeltaChunks_DeltaChunk.Merge(m, src)
}
func (m *ContentDeltaChunks_DeltaChunk) XXX_Size() int {
	return xxx_messageInfo_ContentDeltaChunks_DeltaChunk.Size(m)
}
func (m *ContentDeltaChunks_DeltaChunk) XXX_DiscardUnknown() {
	xxx_messageInfo_ContentDeltaChunks_DeltaChunk.DiscardUnknown(m)
}

var xxx_messageInfo_ContentDeltaChunks_DeltaChunk proto.InternalMessageInfo

func (m *ContentDeltaChunks_DeltaChunk) GetShaSource() []byte {
	if m != nil {
		return m.ShaSource
	}
	return nil
}

func (m *ContentDeltaChunks_DeltaChunk) GetShaTarget() []byte {
	if m != nil {
		return m.ShaTarget
	}
	return nil
}

func (m *ContentDeltaChunks_DeltaChunk) GetSizeOriginal() uint32 {
	if m != nil && m.SizeOriginal != nil {
		return *m.SizeOriginal
	}
	return 0
}

func (m *ContentDeltaChunks_DeltaChunk) GetPatchMethod() uint32 {
	if m != nil && m.PatchMethod != nil {
		return *m.PatchMethod
	}
	return 0
}

func (m *ContentDeltaChunks_DeltaChunk) GetChunk() []byte {
	if m != nil {
		return m.Chunk
	}
	return nil
}

func init() {
	proto.RegisterType((*ContentManifestPayload)(nil), "ContentManifestPayload")
	proto.RegisterType((*ContentManifestPayload_FileMapping)(nil), "ContentManifestPayload.FileMapping")
	proto.RegisterType((*ContentManifestPayload_FileMapping_ChunkData)(nil), "ContentManifestPayload.FileMapping.ChunkData")
	proto.RegisterType((*ContentManifestMetadata)(nil), "ContentManifestMetadata")
	proto.RegisterType((*ContentManifestSignature)(nil), "ContentManifestSignature")
	proto.RegisterType((*ContentDeltaChunks)(nil), "ContentDeltaChunks")
	proto.RegisterType((*ContentDeltaChunks_DeltaChunk)(nil), "ContentDeltaChunks.DeltaChunk")
}

func init() { proto.RegisterFile("content_manifest.proto", fileDescriptor_e3cda137a29253ba) }

var fileDescriptor_e3cda137a29253ba = []byte{
	// 508 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xcd, 0x8e, 0xd3, 0x30,
	0x10, 0xc7, 0x49, 0xbf, 0x3b, 0x6d, 0x50, 0xf1, 0xb2, 0x8b, 0x55, 0x24, 0x54, 0x95, 0x4b, 0x2f,
	0x9b, 0x03, 0x88, 0x23, 0x17, 0x76, 0x85, 0xb8, 0x54, 0x42, 0xe2, 0x01, 0x2c, 0xd7, 0x76, 0x53,
	0xab, 0x89, 0x1d, 0x6c, 0xe7, 0xb0, 0x9c, 0xb8, 0xf0, 0x18, 0xbc, 0x21, 0x12, 0xaf, 0x80, 0xec,
	0x38, 0x4d, 0x55, 0xf6, 0xb0, 0xb7, 0xcc, 0x47, 0x3c, 0xbf, 0xf9, 0xcf, 0x1f, 0x6e, 0x98, 0x56,
	0x4e, 0x28, 0x47, 0x4a, 0xaa, 0xe4, 0x5e, 0x58, 0x97, 0x55, 0x46, 0x3b, 0xbd, 0xfe, 0xdb, 0x83,
	0x9b, 0xbb, 0xa6, 0xb4, 0x8d, 0x95, 0xaf, 0xf4, 0xa1, 0xd0, 0x94, 0xa3, 0x0f, 0x30, 0x29, 0x69,
	0x55, 0x49, 0x95, 0x5b, 0x9c, 0xac, 0xfa, 0x9b, 0xd9, 0xbb, 0xb7, 0xd9, 0xe3, 0xad, 0xd9, 0x67,
	0x59, 0x88, 0x6d, 0xd3, 0xbb, 0xfc, 0xdd, 0x83, 0xd9, 0x59, 0x8c, 0x16, 0x30, 0xd9, 0xcb, 0x42,
	0x28, 0x5a, 0x0a, 0x9c, 0xac, 0x92, 0xcd, 0x14, 0xcd, 0x61, 0x60, 0xe5, 0x0f, 0x81, 0x7b, 0xab,
	0x64, 0x33, 0x40, 0x29, 0x0c, 0xf7, 0x05, 0xcd, 0x2d, 0xee, 0xaf, 0x92, 0x4d, 0x8a, 0x5e, 0xc2,
	0xdc, 0x1e, 0x28, 0x39, 0xfd, 0x32, 0x58, 0x25, 0x9b, 0x39, 0xba, 0x82, 0x99, 0xcf, 0xc6, 0x25,
	0xf0, 0x30, 0x24, 0x3f, 0xc2, 0x88, 0x1d, 0x6a, 0x75, 0xb4, 0x78, 0x14, 0xf0, 0x6e, 0x9f, 0x80,
	0x97, 0xdd, 0xf9, 0x3f, 0xee, 0xa9, 0xa3, 0x08, 0x01, 0x14, 0x52, 0x1d, 0x1d, 0x35, 0xb9, 0x70,
	0x78, 0xec, 0xd1, 0x96, 0x14, 0xa6, 0x5d, 0xc3, 0x0c, 0xfa, 0xf6, 0x40, 0x03, 0xf4, 0xdc, 0x07,
	0xcc, 0xb0, 0xc0, 0x3c, 0x46, 0xcf, 0x61, 0xa4, 0xf7, 0x7b, 0x2b, 0x5c, 0x80, 0x1e, 0x78, 0x3c,
	0xb6, 0x23, 0xda, 0xc8, 0x5c, 0x2a, 0x5a, 0x04, 0xe6, 0x14, 0x5d, 0x43, 0xca, 0x76, 0x84, 0xe9,
	0xb2, 0x32, 0xc2, 0x5a, 0xc1, 0x03, 0x75, 0xba, 0xfe, 0x93, 0xc0, 0xab, 0x0b, 0xce, 0xad, 0x70,
	0x94, 0xfb, 0x89, 0x0b, 0x98, 0x70, 0x51, 0x69, 0x47, 0x24, 0x0f, 0x63, 0x83, 0x1c, 0xb9, 0xe4,
	0xa7, 0xab, 0x45, 0xcd, 0xfc, 0xd3, 0x46, 0x50, 0x27, 0xb5, 0x22, 0x4e, 0x96, 0x22, 0x6a, 0xf7,
	0x1a, 0xae, 0x5a, 0xdd, 0x2c, 0x11, 0x8a, 0x99, 0x87, 0xca, 0x09, 0x1e, 0x70, 0x26, 0x08, 0xc3,
	0x82, 0xed, 0x08, 0x97, 0xf6, 0xd8, 0x81, 0x0e, 0xc3, 0x6b, 0x4b, 0x40, 0x6d, 0xe5, 0x8c, 0x76,
	0xd4, 0x4e, 0xaa, 0x95, 0xfc, 0x5e, 0x0b, 0x12, 0xa5, 0x1e, 0x9f, 0x76, 0x33, 0xec, 0x6c, 0xc6,
	0x24, 0xa4, 0x5f, 0xc0, 0xd4, 0xa7, 0x59, 0x21, 0xa8, 0xc1, 0xd3, 0xb0, 0xee, 0x2d, 0xe0, 0x8b,
	0x6d, 0xbf, 0xc9, 0x5c, 0x51, 0x57, 0x1b, 0xe1, 0xdb, 0x6d, 0x1b, 0x34, 0x32, 0xaf, 0x7f, 0xf5,
	0x00, 0xc5, 0xfe, 0x7b, 0x51, 0x38, 0x1a, 0xae, 0x61, 0x1f, 0x11, 0x66, 0x09, 0xa8, 0x15, 0x85,
	0x48, 0x4e, 0xac, 0xae, 0x0d, 0x6b, 0x2d, 0x75, 0x51, 0x8b, 0x17, 0x6e, 0x4e, 0xf5, 0x1e, 0x66,
	0xbc, 0x7b, 0x18, 0x0f, 0x82, 0x73, 0xde, 0x64, 0xff, 0xcf, 0xcc, 0xba, 0xef, 0x65, 0x05, 0xd0,
	0x45, 0xde, 0x38, 0xde, 0x8c, 0x71, 0x64, 0x63, 0x8f, 0x98, 0x8b, 0xa3, 0x7a, 0x21, 0x77, 0x0d,
	0xa9, 0xf7, 0x79, 0x27, 0xf7, 0xc9, 0xe1, 0x15, 0x75, 0xec, 0x40, 0x4a, 0xe1, 0x0e, 0x9a, 0x47,
	0xb7, 0xa4, 0x30, 0x0c, 0x0a, 0x37, 0xde, 0xfe, 0x34, 0xfc, 0x92, 0xfc, 0x4c, 0x9e, 0xfd, 0x0b,
	0x00, 0x00, 0xff, 0xff, 0x00, 0x92, 0x22, 0xd7, 0xb7, 0x03, 0x00, 0x00,
}
