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

/*
Package conduit_proxy_telemetry is a generated protocol buffer package.

It is generated from these files:
	proxy/telemetry/telemetry.proto

It has these top-level messages:
	ReportRequest
	Process
	ServerTransport
	ClientTransport
	TransportSummary
	RequestScope
	RequestCtx
	ResponseScope
	ResponseCtx
	EosScope
	EosCtx
	ReportResponse
*/
package conduit_proxy_telemetry

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import conduit_common "github.com/runconduit/conduit/controller/gen/common"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

// 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 ReportRequest_Proxy int32

const (
	ReportRequest_INBOUND  ReportRequest_Proxy = 0
	ReportRequest_OUTBOUND ReportRequest_Proxy = 1
)

var ReportRequest_Proxy_name = map[int32]string{
	0: "INBOUND",
	1: "OUTBOUND",
}
var ReportRequest_Proxy_value = map[string]int32{
	"INBOUND":  0,
	"OUTBOUND": 1,
}

func (x ReportRequest_Proxy) String() string {
	return proto.EnumName(ReportRequest_Proxy_name, int32(x))
}
func (ReportRequest_Proxy) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0, 0} }

type ReportRequest struct {
	Process          *Process            `protobuf:"bytes,1,opt,name=process" json:"process,omitempty"`
	Proxy            ReportRequest_Proxy `protobuf:"varint,2,opt,name=proxy,enum=conduit.proxy.telemetry.ReportRequest_Proxy" json:"proxy,omitempty"`
	ServerTransports []*ServerTransport  `protobuf:"bytes,3,rep,name=server_transports,json=serverTransports" json:"server_transports,omitempty"`
	ClientTransports []*ClientTransport  `protobuf:"bytes,4,rep,name=client_transports,json=clientTransports" json:"client_transports,omitempty"`
	Requests         []*RequestScope     `protobuf:"bytes,5,rep,name=requests" json:"requests,omitempty"`
	// The inclusive upper bound of each bucket in the response latency histogram,
	// in tenths of a millisecond.
	//
	// Each ResponseScope message will contain an array of numbers representing
	// the number of observed response latencies in each bucket of the latency
	// histogram. Since the structure of the latency histogram will be the same
	// across all ResponseScopes, we only need to report the max values for these
	// buckets a single time.
	HistogramBucketBoundsTenthMs []uint32 `protobuf:"varint,6,rep,packed,name=histogram_bucket_bounds_tenth_ms,json=histogramBucketBoundsTenthMs" json:"histogram_bucket_bounds_tenth_ms,omitempty"`
}

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

func (m *ReportRequest) GetProcess() *Process {
	if m != nil {
		return m.Process
	}
	return nil
}

func (m *ReportRequest) GetProxy() ReportRequest_Proxy {
	if m != nil {
		return m.Proxy
	}
	return ReportRequest_INBOUND
}

func (m *ReportRequest) GetServerTransports() []*ServerTransport {
	if m != nil {
		return m.ServerTransports
	}
	return nil
}

func (m *ReportRequest) GetClientTransports() []*ClientTransport {
	if m != nil {
		return m.ClientTransports
	}
	return nil
}

func (m *ReportRequest) GetRequests() []*RequestScope {
	if m != nil {
		return m.Requests
	}
	return nil
}

func (m *ReportRequest) GetHistogramBucketBoundsTenthMs() []uint32 {
	if m != nil {
		return m.HistogramBucketBoundsTenthMs
	}
	return nil
}

type Process struct {
	Node               string `protobuf:"bytes,1,opt,name=node" json:"node,omitempty"`
	ScheduledInstance  string `protobuf:"bytes,2,opt,name=scheduled_instance,json=scheduledInstance" json:"scheduled_instance,omitempty"`
	ScheduledNamespace string `protobuf:"bytes,3,opt,name=scheduled_namespace,json=scheduledNamespace" json:"scheduled_namespace,omitempty"`
}

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

func (m *Process) GetNode() string {
	if m != nil {
		return m.Node
	}
	return ""
}

func (m *Process) GetScheduledInstance() string {
	if m != nil {
		return m.ScheduledInstance
	}
	return ""
}

func (m *Process) GetScheduledNamespace() string {
	if m != nil {
		return m.ScheduledNamespace
	}
	return ""
}

type ServerTransport struct {
	SourceIp    *conduit_common.IPAddress `protobuf:"bytes,1,opt,name=source_ip,json=sourceIp" json:"source_ip,omitempty"`
	Connects    uint32                    `protobuf:"varint,2,opt,name=connects" json:"connects,omitempty"`
	Disconnects []*TransportSummary       `protobuf:"bytes,3,rep,name=disconnects" json:"disconnects,omitempty"`
	Protocol    conduit_common.Protocol   `protobuf:"varint,4,opt,name=protocol,enum=conduit.common.Protocol" json:"protocol,omitempty"`
}

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

func (m *ServerTransport) GetSourceIp() *conduit_common.IPAddress {
	if m != nil {
		return m.SourceIp
	}
	return nil
}

func (m *ServerTransport) GetConnects() uint32 {
	if m != nil {
		return m.Connects
	}
	return 0
}

func (m *ServerTransport) GetDisconnects() []*TransportSummary {
	if m != nil {
		return m.Disconnects
	}
	return nil
}

func (m *ServerTransport) GetProtocol() conduit_common.Protocol {
	if m != nil {
		return m.Protocol
	}
	return conduit_common.Protocol_HTTP
}

type ClientTransport struct {
	TargetAddr  *conduit_common.TcpAddress `protobuf:"bytes,1,opt,name=target_addr,json=targetAddr" json:"target_addr,omitempty"`
	Connects    uint32                     `protobuf:"varint,2,opt,name=connects" json:"connects,omitempty"`
	Disconnects []*TransportSummary        `protobuf:"bytes,3,rep,name=disconnects" json:"disconnects,omitempty"`
	Protocol    conduit_common.Protocol    `protobuf:"varint,4,opt,name=protocol,enum=conduit.common.Protocol" json:"protocol,omitempty"`
}

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

func (m *ClientTransport) GetTargetAddr() *conduit_common.TcpAddress {
	if m != nil {
		return m.TargetAddr
	}
	return nil
}

func (m *ClientTransport) GetConnects() uint32 {
	if m != nil {
		return m.Connects
	}
	return 0
}

func (m *ClientTransport) GetDisconnects() []*TransportSummary {
	if m != nil {
		return m.Disconnects
	}
	return nil
}

func (m *ClientTransport) GetProtocol() conduit_common.Protocol {
	if m != nil {
		return m.Protocol
	}
	return conduit_common.Protocol_HTTP
}

type TransportSummary struct {
	DurationMs uint64 `protobuf:"varint,1,opt,name=duration_ms,json=durationMs" json:"duration_ms,omitempty"`
	BytesSent  uint64 `protobuf:"varint,2,opt,name=bytes_sent,json=bytesSent" json:"bytes_sent,omitempty"`
}

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

func (m *TransportSummary) GetDurationMs() uint64 {
	if m != nil {
		return m.DurationMs
	}
	return 0
}

func (m *TransportSummary) GetBytesSent() uint64 {
	if m != nil {
		return m.BytesSent
	}
	return 0
}

type RequestScope struct {
	Ctx       *RequestCtx      `protobuf:"bytes,1,opt,name=ctx" json:"ctx,omitempty"`
	Count     uint32           `protobuf:"varint,2,opt,name=count" json:"count,omitempty"`
	Responses []*ResponseScope `protobuf:"bytes,3,rep,name=responses" json:"responses,omitempty"`
}

func (m *RequestScope) Reset()                    { *m = RequestScope{} }
func (m *RequestScope) String() string            { return proto.CompactTextString(m) }
func (*RequestScope) ProtoMessage()               {}
func (*RequestScope) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }

func (m *RequestScope) GetCtx() *RequestCtx {
	if m != nil {
		return m.Ctx
	}
	return nil
}

func (m *RequestScope) GetCount() uint32 {
	if m != nil {
		return m.Count
	}
	return 0
}

func (m *RequestScope) GetResponses() []*ResponseScope {
	if m != nil {
		return m.Responses
	}
	return nil
}

type RequestCtx struct {
	SourceIp   *conduit_common.IPAddress  `protobuf:"bytes,1,opt,name=source_ip,json=sourceIp" json:"source_ip,omitempty"`
	TargetAddr *conduit_common.TcpAddress `protobuf:"bytes,2,opt,name=target_addr,json=targetAddr" json:"target_addr,omitempty"`
	Authority  string                     `protobuf:"bytes,3,opt,name=authority" json:"authority,omitempty"`
}

func (m *RequestCtx) Reset()                    { *m = RequestCtx{} }
func (m *RequestCtx) String() string            { return proto.CompactTextString(m) }
func (*RequestCtx) ProtoMessage()               {}
func (*RequestCtx) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }

func (m *RequestCtx) GetSourceIp() *conduit_common.IPAddress {
	if m != nil {
		return m.SourceIp
	}
	return nil
}

func (m *RequestCtx) GetTargetAddr() *conduit_common.TcpAddress {
	if m != nil {
		return m.TargetAddr
	}
	return nil
}

func (m *RequestCtx) GetAuthority() string {
	if m != nil {
		return m.Authority
	}
	return ""
}

type ResponseScope struct {
	Ctx *ResponseCtx `protobuf:"bytes,1,opt,name=ctx" json:"ctx,omitempty"`
	// Response latencies (time from request headers sent to response headers
	// received). Represented as a histogram with buckets whose inclusive
	// upper bounds are given in the `histogram_bucket_bounds_tenths_ms` array in
	// `ReportRequest`. Each number in this array represents the number of times a
	// latency falling into that bucket was observed.
	ResponseLatencyCounts []uint32    `protobuf:"varint,2,rep,packed,name=response_latency_counts,json=responseLatencyCounts" json:"response_latency_counts,omitempty"`
	Ends                  []*EosScope `protobuf:"bytes,3,rep,name=ends" json:"ends,omitempty"`
}

func (m *ResponseScope) Reset()                    { *m = ResponseScope{} }
func (m *ResponseScope) String() string            { return proto.CompactTextString(m) }
func (*ResponseScope) ProtoMessage()               {}
func (*ResponseScope) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }

func (m *ResponseScope) GetCtx() *ResponseCtx {
	if m != nil {
		return m.Ctx
	}
	return nil
}

func (m *ResponseScope) GetResponseLatencyCounts() []uint32 {
	if m != nil {
		return m.ResponseLatencyCounts
	}
	return nil
}

func (m *ResponseScope) GetEnds() []*EosScope {
	if m != nil {
		return m.Ends
	}
	return nil
}

type ResponseCtx struct {
	HttpStatusCode uint32 `protobuf:"varint,1,opt,name=http_status_code,json=httpStatusCode" json:"http_status_code,omitempty"`
}

func (m *ResponseCtx) Reset()                    { *m = ResponseCtx{} }
func (m *ResponseCtx) String() string            { return proto.CompactTextString(m) }
func (*ResponseCtx) ProtoMessage()               {}
func (*ResponseCtx) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }

func (m *ResponseCtx) GetHttpStatusCode() uint32 {
	if m != nil {
		return m.HttpStatusCode
	}
	return 0
}

type EosScope struct {
	Ctx     *EosCtx `protobuf:"bytes,1,opt,name=ctx" json:"ctx,omitempty"`
	Streams uint32  `protobuf:"varint,2,opt,name=streams" json:"streams,omitempty"`
}

func (m *EosScope) Reset()                    { *m = EosScope{} }
func (m *EosScope) String() string            { return proto.CompactTextString(m) }
func (*EosScope) ProtoMessage()               {}
func (*EosScope) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }

func (m *EosScope) GetCtx() *EosCtx {
	if m != nil {
		return m.Ctx
	}
	return nil
}

func (m *EosScope) GetStreams() uint32 {
	if m != nil {
		return m.Streams
	}
	return 0
}

type EosCtx struct {
	// Types that are valid to be assigned to End:
	//	*EosCtx_GrpcStatusCode
	//	*EosCtx_ResetErrorCode
	//	*EosCtx_Other
	End isEosCtx_End `protobuf_oneof:"end"`
}

func (m *EosCtx) Reset()                    { *m = EosCtx{} }
func (m *EosCtx) String() string            { return proto.CompactTextString(m) }
func (*EosCtx) ProtoMessage()               {}
func (*EosCtx) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }

type isEosCtx_End interface{ isEosCtx_End() }

type EosCtx_GrpcStatusCode struct {
	GrpcStatusCode uint32 `protobuf:"varint,1,opt,name=grpc_status_code,json=grpcStatusCode,oneof"`
}
type EosCtx_ResetErrorCode struct {
	ResetErrorCode uint32 `protobuf:"varint,2,opt,name=reset_error_code,json=resetErrorCode,oneof"`
}
type EosCtx_Other struct {
	Other bool `protobuf:"varint,3,opt,name=other,oneof"`
}

func (*EosCtx_GrpcStatusCode) isEosCtx_End() {}
func (*EosCtx_ResetErrorCode) isEosCtx_End() {}
func (*EosCtx_Other) isEosCtx_End()          {}

func (m *EosCtx) GetEnd() isEosCtx_End {
	if m != nil {
		return m.End
	}
	return nil
}

func (m *EosCtx) GetGrpcStatusCode() uint32 {
	if x, ok := m.GetEnd().(*EosCtx_GrpcStatusCode); ok {
		return x.GrpcStatusCode
	}
	return 0
}

func (m *EosCtx) GetResetErrorCode() uint32 {
	if x, ok := m.GetEnd().(*EosCtx_ResetErrorCode); ok {
		return x.ResetErrorCode
	}
	return 0
}

func (m *EosCtx) GetOther() bool {
	if x, ok := m.GetEnd().(*EosCtx_Other); ok {
		return x.Other
	}
	return false
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*EosCtx) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _EosCtx_OneofMarshaler, _EosCtx_OneofUnmarshaler, _EosCtx_OneofSizer, []interface{}{
		(*EosCtx_GrpcStatusCode)(nil),
		(*EosCtx_ResetErrorCode)(nil),
		(*EosCtx_Other)(nil),
	}
}

func _EosCtx_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*EosCtx)
	// end
	switch x := m.End.(type) {
	case *EosCtx_GrpcStatusCode:
		b.EncodeVarint(1<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.GrpcStatusCode))
	case *EosCtx_ResetErrorCode:
		b.EncodeVarint(2<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.ResetErrorCode))
	case *EosCtx_Other:
		t := uint64(0)
		if x.Other {
			t = 1
		}
		b.EncodeVarint(3<<3 | proto.WireVarint)
		b.EncodeVarint(t)
	case nil:
	default:
		return fmt.Errorf("EosCtx.End has unexpected type %T", x)
	}
	return nil
}

func _EosCtx_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*EosCtx)
	switch tag {
	case 1: // end.grpc_status_code
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.End = &EosCtx_GrpcStatusCode{uint32(x)}
		return true, err
	case 2: // end.reset_error_code
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.End = &EosCtx_ResetErrorCode{uint32(x)}
		return true, err
	case 3: // end.other
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.End = &EosCtx_Other{x != 0}
		return true, err
	default:
		return false, nil
	}
}

func _EosCtx_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*EosCtx)
	// end
	switch x := m.End.(type) {
	case *EosCtx_GrpcStatusCode:
		n += proto.SizeVarint(1<<3 | proto.WireVarint)
		n += proto.SizeVarint(uint64(x.GrpcStatusCode))
	case *EosCtx_ResetErrorCode:
		n += proto.SizeVarint(2<<3 | proto.WireVarint)
		n += proto.SizeVarint(uint64(x.ResetErrorCode))
	case *EosCtx_Other:
		n += proto.SizeVarint(3<<3 | proto.WireVarint)
		n += 1
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type ReportResponse struct {
}

func (m *ReportResponse) Reset()                    { *m = ReportResponse{} }
func (m *ReportResponse) String() string            { return proto.CompactTextString(m) }
func (*ReportResponse) ProtoMessage()               {}
func (*ReportResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }

func init() {
	proto.RegisterType((*ReportRequest)(nil), "conduit.proxy.telemetry.ReportRequest")
	proto.RegisterType((*Process)(nil), "conduit.proxy.telemetry.Process")
	proto.RegisterType((*ServerTransport)(nil), "conduit.proxy.telemetry.ServerTransport")
	proto.RegisterType((*ClientTransport)(nil), "conduit.proxy.telemetry.ClientTransport")
	proto.RegisterType((*TransportSummary)(nil), "conduit.proxy.telemetry.TransportSummary")
	proto.RegisterType((*RequestScope)(nil), "conduit.proxy.telemetry.RequestScope")
	proto.RegisterType((*RequestCtx)(nil), "conduit.proxy.telemetry.RequestCtx")
	proto.RegisterType((*ResponseScope)(nil), "conduit.proxy.telemetry.ResponseScope")
	proto.RegisterType((*ResponseCtx)(nil), "conduit.proxy.telemetry.ResponseCtx")
	proto.RegisterType((*EosScope)(nil), "conduit.proxy.telemetry.EosScope")
	proto.RegisterType((*EosCtx)(nil), "conduit.proxy.telemetry.EosCtx")
	proto.RegisterType((*ReportResponse)(nil), "conduit.proxy.telemetry.ReportResponse")
	proto.RegisterEnum("conduit.proxy.telemetry.ReportRequest_Proxy", ReportRequest_Proxy_name, ReportRequest_Proxy_value)
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// Client API for Telemetry service

type TelemetryClient interface {
	Report(ctx context.Context, in *ReportRequest, opts ...grpc.CallOption) (*ReportResponse, error)
}

type telemetryClient struct {
	cc *grpc.ClientConn
}

func NewTelemetryClient(cc *grpc.ClientConn) TelemetryClient {
	return &telemetryClient{cc}
}

func (c *telemetryClient) Report(ctx context.Context, in *ReportRequest, opts ...grpc.CallOption) (*ReportResponse, error) {
	out := new(ReportResponse)
	err := grpc.Invoke(ctx, "/conduit.proxy.telemetry.Telemetry/Report", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for Telemetry service

type TelemetryServer interface {
	Report(context.Context, *ReportRequest) (*ReportResponse, error)
}

func RegisterTelemetryServer(s *grpc.Server, srv TelemetryServer) {
	s.RegisterService(&_Telemetry_serviceDesc, srv)
}

func _Telemetry_Report_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReportRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TelemetryServer).Report(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/conduit.proxy.telemetry.Telemetry/Report",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TelemetryServer).Report(ctx, req.(*ReportRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Telemetry_serviceDesc = grpc.ServiceDesc{
	ServiceName: "conduit.proxy.telemetry.Telemetry",
	HandlerType: (*TelemetryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Report",
			Handler:    _Telemetry_Report_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proxy/telemetry/telemetry.proto",
}

func init() { proto.RegisterFile("proxy/telemetry/telemetry.proto", fileDescriptor0) }

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