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

package cycler

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 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.ProtoPackageIsVersion3 // please upgrade the proto package

// Closure of all config for a single cycler run.
type RunConfig struct {
	// The runlog configuration.
	RunLogConfiguration *RunLogConfiguration `protobuf:"bytes,1,opt,name=run_log_configuration,json=runLogConfiguration,proto3" json:"run_log_configuration,omitempty"`
	// The stats configuration for the prefix and the action statistics.
	StatsConfiguration *StatsConfiguration `protobuf:"bytes,2,opt,name=stats_configuration,json=statsConfiguration,proto3" json:"stats_configuration,omitempty"`
	// Policy effect configuration.
	PolicyEffectConfiguration *PolicyEffectConfiguration `protobuf:"bytes,3,opt,name=policy_effect_configuration,json=policyEffectConfiguration,proto3" json:"policy_effect_configuration,omitempty"`
	// Must match the command line argument and policy effect as well.
	MutationAllowed bool `protobuf:"varint,4,opt,name=mutation_allowed,json=mutationAllowed,proto3" json:"mutation_allowed,omitempty"`
	// The bucket to operate on (can be overridden on the command line).
	Bucket               string   `protobuf:"bytes,5,opt,name=bucket,proto3" json:"bucket,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_RunConfig proto.InternalMessageInfo

func (m *RunConfig) GetRunLogConfiguration() *RunLogConfiguration {
	if m != nil {
		return m.RunLogConfiguration
	}
	return nil
}

func (m *RunConfig) GetStatsConfiguration() *StatsConfiguration {
	if m != nil {
		return m.StatsConfiguration
	}
	return nil
}

func (m *RunConfig) GetPolicyEffectConfiguration() *PolicyEffectConfiguration {
	if m != nil {
		return m.PolicyEffectConfiguration
	}
	return nil
}

func (m *RunConfig) GetMutationAllowed() bool {
	if m != nil {
		return m.MutationAllowed
	}
	return false
}

func (m *RunConfig) GetBucket() string {
	if m != nil {
		return m.Bucket
	}
	return ""
}

// Options for the log generation during a cycler run.
type RunLogConfiguration struct {
	// The destination url 'directory' for the logs, can be file:// or gs://.
	DestinationUrl string `protobuf:"bytes,1,opt,name=destination_url,json=destinationUrl,proto3" json:"destination_url,omitempty"`
	// The rough chunk size in bytes to deliver the logs in (before compression).
	ChunkSizeBytes int64 `protobuf:"varint,2,opt,name=chunk_size_bytes,json=chunkSizeBytes,proto3" json:"chunk_size_bytes,omitempty"`
	// How many outstanding log messages can we have before blocking producers.
	ChannelSize int64 `protobuf:"varint,3,opt,name=channel_size,json=channelSize,proto3" json:"channel_size,omitempty"`
	// How many retries we should make to persist logs.
	PersistRetries int64 `protobuf:"varint,4,opt,name=persist_retries,json=persistRetries,proto3" json:"persist_retries,omitempty"`
	// How many logs we'll allow to fail persistence and still continue.
	// Since we do log shipping in goroutines this is also the cap on the number
	// of those.
	MaxUnpersistedLogs   int64    `protobuf:"varint,5,opt,name=max_unpersisted_logs,json=maxUnpersistedLogs,proto3" json:"max_unpersisted_logs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_RunLogConfiguration proto.InternalMessageInfo

func (m *RunLogConfiguration) GetDestinationUrl() string {
	if m != nil {
		return m.DestinationUrl
	}
	return ""
}

func (m *RunLogConfiguration) GetChunkSizeBytes() int64 {
	if m != nil {
		return m.ChunkSizeBytes
	}
	return 0
}

func (m *RunLogConfiguration) GetChannelSize() int64 {
	if m != nil {
		return m.ChannelSize
	}
	return 0
}

func (m *RunLogConfiguration) GetPersistRetries() int64 {
	if m != nil {
		return m.PersistRetries
	}
	return 0
}

func (m *RunLogConfiguration) GetMaxUnpersistedLogs() int64 {
	if m != nil {
		return m.MaxUnpersistedLogs
	}
	return 0
}

// Options provided to any run providing stats.
type StatsConfiguration struct {
	// When generating a report for a prefix, how deep should the breakdown be.
	PrefixReportMaxDepth int64 `protobuf:"varint,1,opt,name=prefix_report_max_depth,json=prefixReportMaxDepth,proto3" json:"prefix_report_max_depth,omitempty"`
	// Histogram options for the objects ages.
	AgeDaysHistogramOptions *HistogramOptions `protobuf:"bytes,2,opt,name=age_days_histogram_options,json=ageDaysHistogramOptions,proto3" json:"age_days_histogram_options,omitempty"`
	// Histogram options for the objects sizes.
	SizeBytesHistogramOptions *HistogramOptions `protobuf:"bytes,3,opt,name=size_bytes_histogram_options,json=sizeBytesHistogramOptions,proto3" json:"size_bytes_histogram_options,omitempty"`
	XXX_NoUnkeyedLiteral      struct{}          `json:"-"`
	XXX_unrecognized          []byte            `json:"-"`
	XXX_sizecache             int32             `json:"-"`
}

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

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

var xxx_messageInfo_StatsConfiguration proto.InternalMessageInfo

func (m *StatsConfiguration) GetPrefixReportMaxDepth() int64 {
	if m != nil {
		return m.PrefixReportMaxDepth
	}
	return 0
}

func (m *StatsConfiguration) GetAgeDaysHistogramOptions() *HistogramOptions {
	if m != nil {
		return m.AgeDaysHistogramOptions
	}
	return nil
}

func (m *StatsConfiguration) GetSizeBytesHistogramOptions() *HistogramOptions {
	if m != nil {
		return m.SizeBytesHistogramOptions
	}
	return nil
}

// Options for the Histogram generation during a cycler run.
// See definition in: "google.golang.org/grpc/benchmark/stats"
type HistogramOptions struct {
	// The number of unique buckets in the histrogram.
	NumBuckets int32 `protobuf:"varint,1,opt,name=num_buckets,json=numBuckets,proto3" json:"num_buckets,omitempty"`
	// The growth factor of each bucket to the next.
	GrowthFactor float64 `protobuf:"fixed64,2,opt,name=growth_factor,json=growthFactor,proto3" json:"growth_factor,omitempty"`
	// The base bucket's size.
	BaseBucketSize float64 `protobuf:"fixed64,3,opt,name=base_bucket_size,json=baseBucketSize,proto3" json:"base_bucket_size,omitempty"`
	// The minimum valued bucket's value.
	MinValue             int64    `protobuf:"varint,4,opt,name=min_value,json=minValue,proto3" json:"min_value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_HistogramOptions proto.InternalMessageInfo

func (m *HistogramOptions) GetNumBuckets() int32 {
	if m != nil {
		return m.NumBuckets
	}
	return 0
}

func (m *HistogramOptions) GetGrowthFactor() float64 {
	if m != nil {
		return m.GrowthFactor
	}
	return 0
}

func (m *HistogramOptions) GetBaseBucketSize() float64 {
	if m != nil {
		return m.BaseBucketSize
	}
	return 0
}

func (m *HistogramOptions) GetMinValue() int64 {
	if m != nil {
		return m.MinValue
	}
	return 0
}

// A policy effect configuration defines the policy and the resulting effect.
type PolicyEffectConfiguration struct {
	// The effect configuration must be one of the following configs.
	//
	// Types that are valid to be assigned to EffectConfiguration:
	//	*PolicyEffectConfiguration_Noop
	//	*PolicyEffectConfiguration_Move
	//	*PolicyEffectConfiguration_Chill
	//	*PolicyEffectConfiguration_Duplicate
	EffectConfiguration isPolicyEffectConfiguration_EffectConfiguration `protobuf_oneof:"effect_configuration"`
	// The policy document to be parsed by rego and executed to determine if an
	// effect is going to be taken upon the object.
	PolicyDocumentPath string `protobuf:"bytes,5,opt,name=policy_document_path,json=policyDocumentPath,proto3" json:"policy_document_path,omitempty"`
	// Constrain the prefix iterators to paths that match the following go regexp.
	PrefixRegexp         string   `protobuf:"bytes,6,opt,name=prefix_regexp,json=prefixRegexp,proto3" json:"prefix_regexp,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PolicyEffectConfiguration) Reset()         { *m = PolicyEffectConfiguration{} }
func (m *PolicyEffectConfiguration) String() string { return proto.CompactTextString(m) }
func (*PolicyEffectConfiguration) ProtoMessage()    {}
func (*PolicyEffectConfiguration) Descriptor() ([]byte, []int) {
	return fileDescriptor_093cc71b7e56221a, []int{4}
}

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

var xxx_messageInfo_PolicyEffectConfiguration proto.InternalMessageInfo

type isPolicyEffectConfiguration_EffectConfiguration interface {
	isPolicyEffectConfiguration_EffectConfiguration()
}

type PolicyEffectConfiguration_Noop struct {
	Noop *NoopEffectConfiguration `protobuf:"bytes,1,opt,name=noop,proto3,oneof"`
}

type PolicyEffectConfiguration_Move struct {
	Move *MoveEffectConfiguration `protobuf:"bytes,2,opt,name=move,proto3,oneof"`
}

type PolicyEffectConfiguration_Chill struct {
	Chill *ChillEffectConfiguration `protobuf:"bytes,3,opt,name=chill,proto3,oneof"`
}

type PolicyEffectConfiguration_Duplicate struct {
	Duplicate *DuplicateEffectConfiguration `protobuf:"bytes,4,opt,name=duplicate,proto3,oneof"`
}

func (*PolicyEffectConfiguration_Noop) isPolicyEffectConfiguration_EffectConfiguration() {}

func (*PolicyEffectConfiguration_Move) isPolicyEffectConfiguration_EffectConfiguration() {}

func (*PolicyEffectConfiguration_Chill) isPolicyEffectConfiguration_EffectConfiguration() {}

func (*PolicyEffectConfiguration_Duplicate) isPolicyEffectConfiguration_EffectConfiguration() {}

func (m *PolicyEffectConfiguration) GetEffectConfiguration() isPolicyEffectConfiguration_EffectConfiguration {
	if m != nil {
		return m.EffectConfiguration
	}
	return nil
}

func (m *PolicyEffectConfiguration) GetNoop() *NoopEffectConfiguration {
	if x, ok := m.GetEffectConfiguration().(*PolicyEffectConfiguration_Noop); ok {
		return x.Noop
	}
	return nil
}

func (m *PolicyEffectConfiguration) GetMove() *MoveEffectConfiguration {
	if x, ok := m.GetEffectConfiguration().(*PolicyEffectConfiguration_Move); ok {
		return x.Move
	}
	return nil
}

func (m *PolicyEffectConfiguration) GetChill() *ChillEffectConfiguration {
	if x, ok := m.GetEffectConfiguration().(*PolicyEffectConfiguration_Chill); ok {
		return x.Chill
	}
	return nil
}

func (m *PolicyEffectConfiguration) GetDuplicate() *DuplicateEffectConfiguration {
	if x, ok := m.GetEffectConfiguration().(*PolicyEffectConfiguration_Duplicate); ok {
		return x.Duplicate
	}
	return nil
}

func (m *PolicyEffectConfiguration) GetPolicyDocumentPath() string {
	if m != nil {
		return m.PolicyDocumentPath
	}
	return ""
}

func (m *PolicyEffectConfiguration) GetPrefixRegexp() string {
	if m != nil {
		return m.PrefixRegexp
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*PolicyEffectConfiguration) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*PolicyEffectConfiguration_Noop)(nil),
		(*PolicyEffectConfiguration_Move)(nil),
		(*PolicyEffectConfiguration_Chill)(nil),
		(*PolicyEffectConfiguration_Duplicate)(nil),
	}
}

func init() {
	proto.RegisterType((*RunConfig)(nil), "cycler.RunConfig")
	proto.RegisterType((*RunLogConfiguration)(nil), "cycler.RunLogConfiguration")
	proto.RegisterType((*StatsConfiguration)(nil), "cycler.StatsConfiguration")
	proto.RegisterType((*HistogramOptions)(nil), "cycler.HistogramOptions")
	proto.RegisterType((*PolicyEffectConfiguration)(nil), "cycler.PolicyEffectConfiguration")
}

func init() { proto.RegisterFile("cycler/config.proto", fileDescriptor_093cc71b7e56221a) }

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