// Code generated by protoc-gen-go.
// source: golang.conradwood.net/apis/getestservice/getestservice.proto
// DO NOT EDIT!

/*
Package getestservice is a generated protocol buffer package.

It is generated from these files:
	golang.conradwood.net/apis/getestservice/getestservice.proto

It has these top-level messages:
	Call
	PingRequest
	PingResponse
	FindServiceRequest
	FindServiceResponse
	UserByLoginRequest
	UserByTokenRequest
	AuthResponse
	Target
	SerialisedContext
	RequiredContext
	SleepRequest
	TriggerRPCRequest
	Chain
	Count
*/
package getestservice

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import auth "golang.conradwood.net/apis/auth"
import common "golang.conradwood.net/apis/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 Call struct {
	Position  int32  `protobuf:"varint,1,opt,name=Position" json:"Position,omitempty"`
	UserID    string `protobuf:"bytes,2,opt,name=UserID" json:"UserID,omitempty"`
	ServiceID string `protobuf:"bytes,3,opt,name=ServiceID" json:"ServiceID,omitempty"`
	RequestID string `protobuf:"bytes,4,opt,name=RequestID" json:"RequestID,omitempty"`
}

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

func (m *Call) GetPosition() int32 {
	if m != nil {
		return m.Position
	}
	return 0
}

func (m *Call) GetUserID() string {
	if m != nil {
		return m.UserID
	}
	return ""
}

func (m *Call) GetServiceID() string {
	if m != nil {
		return m.ServiceID
	}
	return ""
}

func (m *Call) GetRequestID() string {
	if m != nil {
		return m.RequestID
	}
	return ""
}

type PingRequest struct {
	SequenceNumber uint32 `protobuf:"varint,1,opt,name=SequenceNumber" json:"SequenceNumber,omitempty"`
	Payload        string `protobuf:"bytes,2,opt,name=Payload" json:"Payload,omitempty"`
	TTL            uint32 `protobuf:"varint,3,opt,name=TTL" json:"TTL,omitempty"`
	PleaseFail     bool   `protobuf:"varint,4,opt,name=PleaseFail" json:"PleaseFail,omitempty"`
}

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

func (m *PingRequest) GetSequenceNumber() uint32 {
	if m != nil {
		return m.SequenceNumber
	}
	return 0
}

func (m *PingRequest) GetPayload() string {
	if m != nil {
		return m.Payload
	}
	return ""
}

func (m *PingRequest) GetTTL() uint32 {
	if m != nil {
		return m.TTL
	}
	return 0
}

func (m *PingRequest) GetPleaseFail() bool {
	if m != nil {
		return m.PleaseFail
	}
	return false
}

type PingResponse struct {
	Response   *PingRequest      `protobuf:"bytes,1,opt,name=Response" json:"Response,omitempty"`
	ServerTags map[string]string `protobuf:"bytes,2,rep,name=ServerTags" json:"ServerTags,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
}

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

func (m *PingResponse) GetResponse() *PingRequest {
	if m != nil {
		return m.Response
	}
	return nil
}

func (m *PingResponse) GetServerTags() map[string]string {
	if m != nil {
		return m.ServerTags
	}
	return nil
}

// for internal testing only
type FindServiceRequest struct {
	Name string `protobuf:"bytes,1,opt,name=Name" json:"Name,omitempty"`
}

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

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

// for internal testing only
type FindServiceResponse struct {
	Targets []*Target `protobuf:"bytes,1,rep,name=Targets" json:"Targets,omitempty"`
}

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

func (m *FindServiceResponse) GetTargets() []*Target {
	if m != nil {
		return m.Targets
	}
	return nil
}

// for internal testing only
type UserByLoginRequest struct {
	Username string `protobuf:"bytes,1,opt,name=Username" json:"Username,omitempty"`
	Password string `protobuf:"bytes,2,opt,name=Password" json:"Password,omitempty"`
}

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

func (m *UserByLoginRequest) GetUsername() string {
	if m != nil {
		return m.Username
	}
	return ""
}

func (m *UserByLoginRequest) GetPassword() string {
	if m != nil {
		return m.Password
	}
	return ""
}

// for internal testing only
type UserByTokenRequest struct {
	Token string `protobuf:"bytes,1,opt,name=Token" json:"Token,omitempty"`
}

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

func (m *UserByTokenRequest) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

// for internal testing only
type AuthResponse struct {
	Valid bool       `protobuf:"varint,1,opt,name=Valid" json:"Valid,omitempty"`
	User  *auth.User `protobuf:"bytes,2,opt,name=User" json:"User,omitempty"`
}

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

func (m *AuthResponse) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

func (m *AuthResponse) GetUser() *auth.User {
	if m != nil {
		return m.User
	}
	return nil
}

// for internal testing only
type Target struct {
	IP   string `protobuf:"bytes,1,opt,name=IP" json:"IP,omitempty"`
	Port uint32 `protobuf:"varint,2,opt,name=Port" json:"Port,omitempty"`
}

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

func (m *Target) GetIP() string {
	if m != nil {
		return m.IP
	}
	return ""
}

func (m *Target) GetPort() uint32 {
	if m != nil {
		return m.Port
	}
	return 0
}

type SerialisedContext struct {
	Data    []byte           `protobuf:"bytes,1,opt,name=Data,proto3" json:"Data,omitempty"`
	SData   string           `protobuf:"bytes,2,opt,name=SData" json:"SData,omitempty"`
	User    *auth.SignedUser `protobuf:"bytes,3,opt,name=User" json:"User,omitempty"`
	Service *auth.SignedUser `protobuf:"bytes,4,opt,name=Service" json:"Service,omitempty"`
}

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

func (m *SerialisedContext) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *SerialisedContext) GetSData() string {
	if m != nil {
		return m.SData
	}
	return ""
}

func (m *SerialisedContext) GetUser() *auth.SignedUser {
	if m != nil {
		return m.User
	}
	return nil
}

func (m *SerialisedContext) GetService() *auth.SignedUser {
	if m != nil {
		return m.Service
	}
	return nil
}

type RequiredContext struct {
	User    *auth.SignedUser `protobuf:"bytes,3,opt,name=User" json:"User,omitempty"`
	Service *auth.SignedUser `protobuf:"bytes,4,opt,name=Service" json:"Service,omitempty"`
}

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

func (m *RequiredContext) GetUser() *auth.SignedUser {
	if m != nil {
		return m.User
	}
	return nil
}

func (m *RequiredContext) GetService() *auth.SignedUser {
	if m != nil {
		return m.Service
	}
	return nil
}

type SleepRequest struct {
	Seconds float64 `protobuf:"fixed64,1,opt,name=Seconds" json:"Seconds,omitempty"`
}

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

func (m *SleepRequest) GetSeconds() float64 {
	if m != nil {
		return m.Seconds
	}
	return 0
}

type TriggerRPCRequest struct {
	Action  uint32 `protobuf:"varint,1,opt,name=Action" json:"Action,omitempty"`
	Counter uint32 `protobuf:"varint,2,opt,name=Counter" json:"Counter,omitempty"`
}

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

func (m *TriggerRPCRequest) GetAction() uint32 {
	if m != nil {
		return m.Action
	}
	return 0
}

func (m *TriggerRPCRequest) GetCounter() uint32 {
	if m != nil {
		return m.Counter
	}
	return 0
}

type Chain struct {
	Position int32   `protobuf:"varint,1,opt,name=Position" json:"Position,omitempty"`
	Calls    []*Call `protobuf:"bytes,2,rep,name=Calls" json:"Calls,omitempty"`
}

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

func (m *Chain) GetPosition() int32 {
	if m != nil {
		return m.Position
	}
	return 0
}

func (m *Chain) GetCalls() []*Call {
	if m != nil {
		return m.Calls
	}
	return nil
}

type Count struct {
	Count uint32 `protobuf:"varint,1,opt,name=Count" json:"Count,omitempty"`
}

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

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

func init() {
	proto.RegisterType((*Call)(nil), "getestservice.Call")
	proto.RegisterType((*PingRequest)(nil), "getestservice.PingRequest")
	proto.RegisterType((*PingResponse)(nil), "getestservice.PingResponse")
	proto.RegisterType((*FindServiceRequest)(nil), "getestservice.FindServiceRequest")
	proto.RegisterType((*FindServiceResponse)(nil), "getestservice.FindServiceResponse")
	proto.RegisterType((*UserByLoginRequest)(nil), "getestservice.UserByLoginRequest")
	proto.RegisterType((*UserByTokenRequest)(nil), "getestservice.UserByTokenRequest")
	proto.RegisterType((*AuthResponse)(nil), "getestservice.AuthResponse")
	proto.RegisterType((*Target)(nil), "getestservice.Target")
	proto.RegisterType((*SerialisedContext)(nil), "getestservice.SerialisedContext")
	proto.RegisterType((*RequiredContext)(nil), "getestservice.RequiredContext")
	proto.RegisterType((*SleepRequest)(nil), "getestservice.SleepRequest")
	proto.RegisterType((*TriggerRPCRequest)(nil), "getestservice.TriggerRPCRequest")
	proto.RegisterType((*Chain)(nil), "getestservice.Chain")
	proto.RegisterType((*Count)(nil), "getestservice.Count")
}

// 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 EchoService service

type EchoServiceClient interface {
	Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error)
}

type echoServiceClient struct {
	cc *grpc.ClientConn
}

func NewEchoServiceClient(cc *grpc.ClientConn) EchoServiceClient {
	return &echoServiceClient{cc}
}

func (c *echoServiceClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error) {
	out := new(PingResponse)
	err := grpc.Invoke(ctx, "/getestservice.EchoService/Ping", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for EchoService service

type EchoServiceServer interface {
	Ping(context.Context, *PingRequest) (*PingResponse, error)
}

func RegisterEchoServiceServer(s *grpc.Server, srv EchoServiceServer) {
	s.RegisterService(&_EchoService_serviceDesc, srv)
}

func _EchoService_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EchoServiceServer).Ping(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/getestservice.EchoService/Ping",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EchoServiceServer).Ping(ctx, req.(*PingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _EchoService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "getestservice.EchoService",
	HandlerType: (*EchoServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Ping",
			Handler:    _EchoService_Ping_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "golang.conradwood.net/apis/getestservice/getestservice.proto",
}

// Client API for EchoStreamService service

type EchoStreamServiceClient interface {
	SendToServer(ctx context.Context, opts ...grpc.CallOption) (EchoStreamService_SendToServerClient, error)
}

type echoStreamServiceClient struct {
	cc *grpc.ClientConn
}

func NewEchoStreamServiceClient(cc *grpc.ClientConn) EchoStreamServiceClient {
	return &echoStreamServiceClient{cc}
}

func (c *echoStreamServiceClient) SendToServer(ctx context.Context, opts ...grpc.CallOption) (EchoStreamService_SendToServerClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_EchoStreamService_serviceDesc.Streams[0], c.cc, "/getestservice.EchoStreamService/SendToServer", opts...)
	if err != nil {
		return nil, err
	}
	x := &echoStreamServiceSendToServerClient{stream}
	return x, nil
}

type EchoStreamService_SendToServerClient interface {
	Send(*PingRequest) error
	CloseAndRecv() (*PingResponse, error)
	grpc.ClientStream
}

type echoStreamServiceSendToServerClient struct {
	grpc.ClientStream
}

func (x *echoStreamServiceSendToServerClient) Send(m *PingRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *echoStreamServiceSendToServerClient) CloseAndRecv() (*PingResponse, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(PingResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// Server API for EchoStreamService service

type EchoStreamServiceServer interface {
	SendToServer(EchoStreamService_SendToServerServer) error
}

func RegisterEchoStreamServiceServer(s *grpc.Server, srv EchoStreamServiceServer) {
	s.RegisterService(&_EchoStreamService_serviceDesc, srv)
}

func _EchoStreamService_SendToServer_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(EchoStreamServiceServer).SendToServer(&echoStreamServiceSendToServerServer{stream})
}

type EchoStreamService_SendToServerServer interface {
	SendAndClose(*PingResponse) error
	Recv() (*PingRequest, error)
	grpc.ServerStream
}

type echoStreamServiceSendToServerServer struct {
	grpc.ServerStream
}

func (x *echoStreamServiceSendToServerServer) SendAndClose(m *PingResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *echoStreamServiceSendToServerServer) Recv() (*PingRequest, error) {
	m := new(PingRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _EchoStreamService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "getestservice.EchoStreamService",
	HandlerType: (*EchoStreamServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "SendToServer",
			Handler:       _EchoStreamService_SendToServer_Handler,
			ClientStreams: true,
		},
	},
	Metadata: "golang.conradwood.net/apis/getestservice/getestservice.proto",
}

// Client API for EasyOps service

type EasyOpsClient interface {
	FindService(ctx context.Context, in *FindServiceRequest, opts ...grpc.CallOption) (*FindServiceResponse, error)
	UserByLogin(ctx context.Context, in *UserByLoginRequest, opts ...grpc.CallOption) (*AuthResponse, error)
	UserByToken(ctx context.Context, in *UserByTokenRequest, opts ...grpc.CallOption) (*AuthResponse, error)
}

type easyOpsClient struct {
	cc *grpc.ClientConn
}

func NewEasyOpsClient(cc *grpc.ClientConn) EasyOpsClient {
	return &easyOpsClient{cc}
}

func (c *easyOpsClient) FindService(ctx context.Context, in *FindServiceRequest, opts ...grpc.CallOption) (*FindServiceResponse, error) {
	out := new(FindServiceResponse)
	err := grpc.Invoke(ctx, "/getestservice.EasyOps/FindService", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *easyOpsClient) UserByLogin(ctx context.Context, in *UserByLoginRequest, opts ...grpc.CallOption) (*AuthResponse, error) {
	out := new(AuthResponse)
	err := grpc.Invoke(ctx, "/getestservice.EasyOps/UserByLogin", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *easyOpsClient) UserByToken(ctx context.Context, in *UserByTokenRequest, opts ...grpc.CallOption) (*AuthResponse, error) {
	out := new(AuthResponse)
	err := grpc.Invoke(ctx, "/getestservice.EasyOps/UserByToken", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for EasyOps service

type EasyOpsServer interface {
	FindService(context.Context, *FindServiceRequest) (*FindServiceResponse, error)
	UserByLogin(context.Context, *UserByLoginRequest) (*AuthResponse, error)
	UserByToken(context.Context, *UserByTokenRequest) (*AuthResponse, error)
}

func RegisterEasyOpsServer(s *grpc.Server, srv EasyOpsServer) {
	s.RegisterService(&_EasyOps_serviceDesc, srv)
}

func _EasyOps_FindService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FindServiceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EasyOpsServer).FindService(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/getestservice.EasyOps/FindService",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EasyOpsServer).FindService(ctx, req.(*FindServiceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _EasyOps_UserByLogin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserByLoginRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EasyOpsServer).UserByLogin(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/getestservice.EasyOps/UserByLogin",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EasyOpsServer).UserByLogin(ctx, req.(*UserByLoginRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _EasyOps_UserByToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserByTokenRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EasyOpsServer).UserByToken(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/getestservice.EasyOps/UserByToken",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EasyOpsServer).UserByToken(ctx, req.(*UserByTokenRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _EasyOps_serviceDesc = grpc.ServiceDesc{
	ServiceName: "getestservice.EasyOps",
	HandlerType: (*EasyOpsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "FindService",
			Handler:    _EasyOps_FindService_Handler,
		},
		{
			MethodName: "UserByLogin",
			Handler:    _EasyOps_UserByLogin_Handler,
		},
		{
			MethodName: "UserByToken",
			Handler:    _EasyOps_UserByToken_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "golang.conradwood.net/apis/getestservice/getestservice.proto",
}

// Client API for EasyOpsTest service

type EasyOpsTestClient interface {
	CheckSerialisation(ctx context.Context, in *Count, opts ...grpc.CallOption) (*common.Void, error)
	Ping(ctx context.Context, in *Chain, opts ...grpc.CallOption) (*Chain, error)
	// does exactly nothing
	SimplePing(ctx context.Context, in *common.Void, opts ...grpc.CallOption) (*common.Void, error)
}

type easyOpsTestClient struct {
	cc *grpc.ClientConn
}

func NewEasyOpsTestClient(cc *grpc.ClientConn) EasyOpsTestClient {
	return &easyOpsTestClient{cc}
}

func (c *easyOpsTestClient) CheckSerialisation(ctx context.Context, in *Count, opts ...grpc.CallOption) (*common.Void, error) {
	out := new(common.Void)
	err := grpc.Invoke(ctx, "/getestservice.EasyOpsTest/CheckSerialisation", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *easyOpsTestClient) Ping(ctx context.Context, in *Chain, opts ...grpc.CallOption) (*Chain, error) {
	out := new(Chain)
	err := grpc.Invoke(ctx, "/getestservice.EasyOpsTest/Ping", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *easyOpsTestClient) SimplePing(ctx context.Context, in *common.Void, opts ...grpc.CallOption) (*common.Void, error) {
	out := new(common.Void)
	err := grpc.Invoke(ctx, "/getestservice.EasyOpsTest/SimplePing", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for EasyOpsTest service

type EasyOpsTestServer interface {
	CheckSerialisation(context.Context, *Count) (*common.Void, error)
	Ping(context.Context, *Chain) (*Chain, error)
	// does exactly nothing
	SimplePing(context.Context, *common.Void) (*common.Void, error)
}

func RegisterEasyOpsTestServer(s *grpc.Server, srv EasyOpsTestServer) {
	s.RegisterService(&_EasyOpsTest_serviceDesc, srv)
}

func _EasyOpsTest_CheckSerialisation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Count)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EasyOpsTestServer).CheckSerialisation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/getestservice.EasyOpsTest/CheckSerialisation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EasyOpsTestServer).CheckSerialisation(ctx, req.(*Count))
	}
	return interceptor(ctx, in, info, handler)
}

func _EasyOpsTest_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Chain)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EasyOpsTestServer).Ping(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/getestservice.EasyOpsTest/Ping",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EasyOpsTestServer).Ping(ctx, req.(*Chain))
	}
	return interceptor(ctx, in, info, handler)
}

func _EasyOpsTest_SimplePing_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(common.Void)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EasyOpsTestServer).SimplePing(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/getestservice.EasyOpsTest/SimplePing",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EasyOpsTestServer).SimplePing(ctx, req.(*common.Void))
	}
	return interceptor(ctx, in, info, handler)
}

var _EasyOpsTest_serviceDesc = grpc.ServiceDesc{
	ServiceName: "getestservice.EasyOpsTest",
	HandlerType: (*EasyOpsTestServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CheckSerialisation",
			Handler:    _EasyOpsTest_CheckSerialisation_Handler,
		},
		{
			MethodName: "Ping",
			Handler:    _EasyOpsTest_Ping_Handler,
		},
		{
			MethodName: "SimplePing",
			Handler:    _EasyOpsTest_SimplePing_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "golang.conradwood.net/apis/getestservice/getestservice.proto",
}

// Client API for CtxTest service

type CtxTestClient interface {
	TestFork(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (*common.Void, error)
	TestDeSer(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (*SerialisedContext, error)
	TestStream(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (CtxTest_TestStreamClient, error)
	TestUnary(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (*common.Void, error)
	CallUnaryFromStream(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (CtxTest_CallUnaryFromStreamClient, error)
	CallUnaryFromUnary(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (*common.Void, error)
	CallStreamFromStream(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (CtxTest_CallStreamFromStreamClient, error)
	CallStreamFromUnary(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (*common.Void, error)
	Sleep(ctx context.Context, in *SleepRequest, opts ...grpc.CallOption) (*common.Void, error)
}

type ctxTestClient struct {
	cc *grpc.ClientConn
}

func NewCtxTestClient(cc *grpc.ClientConn) CtxTestClient {
	return &ctxTestClient{cc}
}

func (c *ctxTestClient) TestFork(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (*common.Void, error) {
	out := new(common.Void)
	err := grpc.Invoke(ctx, "/getestservice.CtxTest/TestFork", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ctxTestClient) TestDeSer(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (*SerialisedContext, error) {
	out := new(SerialisedContext)
	err := grpc.Invoke(ctx, "/getestservice.CtxTest/TestDeSer", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ctxTestClient) TestStream(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (CtxTest_TestStreamClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_CtxTest_serviceDesc.Streams[0], c.cc, "/getestservice.CtxTest/TestStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &ctxTestTestStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type CtxTest_TestStreamClient interface {
	Recv() (*common.Void, error)
	grpc.ClientStream
}

type ctxTestTestStreamClient struct {
	grpc.ClientStream
}

func (x *ctxTestTestStreamClient) Recv() (*common.Void, error) {
	m := new(common.Void)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *ctxTestClient) TestUnary(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (*common.Void, error) {
	out := new(common.Void)
	err := grpc.Invoke(ctx, "/getestservice.CtxTest/TestUnary", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ctxTestClient) CallUnaryFromStream(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (CtxTest_CallUnaryFromStreamClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_CtxTest_serviceDesc.Streams[1], c.cc, "/getestservice.CtxTest/CallUnaryFromStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &ctxTestCallUnaryFromStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type CtxTest_CallUnaryFromStreamClient interface {
	Recv() (*common.Void, error)
	grpc.ClientStream
}

type ctxTestCallUnaryFromStreamClient struct {
	grpc.ClientStream
}

func (x *ctxTestCallUnaryFromStreamClient) Recv() (*common.Void, error) {
	m := new(common.Void)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *ctxTestClient) CallUnaryFromUnary(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (*common.Void, error) {
	out := new(common.Void)
	err := grpc.Invoke(ctx, "/getestservice.CtxTest/CallUnaryFromUnary", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ctxTestClient) CallStreamFromStream(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (CtxTest_CallStreamFromStreamClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_CtxTest_serviceDesc.Streams[2], c.cc, "/getestservice.CtxTest/CallStreamFromStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &ctxTestCallStreamFromStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type CtxTest_CallStreamFromStreamClient interface {
	Recv() (*common.Void, error)
	grpc.ClientStream
}

type ctxTestCallStreamFromStreamClient struct {
	grpc.ClientStream
}

func (x *ctxTestCallStreamFromStreamClient) Recv() (*common.Void, error) {
	m := new(common.Void)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *ctxTestClient) CallStreamFromUnary(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (*common.Void, error) {
	out := new(common.Void)
	err := grpc.Invoke(ctx, "/getestservice.CtxTest/CallStreamFromUnary", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ctxTestClient) Sleep(ctx context.Context, in *SleepRequest, opts ...grpc.CallOption) (*common.Void, error) {
	out := new(common.Void)
	err := grpc.Invoke(ctx, "/getestservice.CtxTest/Sleep", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for CtxTest service

type CtxTestServer interface {
	TestFork(context.Context, *RequiredContext) (*common.Void, error)
	TestDeSer(context.Context, *RequiredContext) (*SerialisedContext, error)
	TestStream(*RequiredContext, CtxTest_TestStreamServer) error
	TestUnary(context.Context, *RequiredContext) (*common.Void, error)
	CallUnaryFromStream(*RequiredContext, CtxTest_CallUnaryFromStreamServer) error
	CallUnaryFromUnary(context.Context, *RequiredContext) (*common.Void, error)
	CallStreamFromStream(*RequiredContext, CtxTest_CallStreamFromStreamServer) error
	CallStreamFromUnary(context.Context, *RequiredContext) (*common.Void, error)
	Sleep(context.Context, *SleepRequest) (*common.Void, error)
}

func RegisterCtxTestServer(s *grpc.Server, srv CtxTestServer) {
	s.RegisterService(&_CtxTest_serviceDesc, srv)
}

func _CtxTest_TestFork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequiredContext)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CtxTestServer).TestFork(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/getestservice.CtxTest/TestFork",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CtxTestServer).TestFork(ctx, req.(*RequiredContext))
	}
	return interceptor(ctx, in, info, handler)
}

func _CtxTest_TestDeSer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequiredContext)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CtxTestServer).TestDeSer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/getestservice.CtxTest/TestDeSer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CtxTestServer).TestDeSer(ctx, req.(*RequiredContext))
	}
	return interceptor(ctx, in, info, handler)
}

func _CtxTest_TestStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RequiredContext)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CtxTestServer).TestStream(m, &ctxTestTestStreamServer{stream})
}

type CtxTest_TestStreamServer interface {
	Send(*common.Void) error
	grpc.ServerStream
}

type ctxTestTestStreamServer struct {
	grpc.ServerStream
}

func (x *ctxTestTestStreamServer) Send(m *common.Void) error {
	return x.ServerStream.SendMsg(m)
}

func _CtxTest_TestUnary_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequiredContext)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CtxTestServer).TestUnary(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/getestservice.CtxTest/TestUnary",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CtxTestServer).TestUnary(ctx, req.(*RequiredContext))
	}
	return interceptor(ctx, in, info, handler)
}

func _CtxTest_CallUnaryFromStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RequiredContext)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CtxTestServer).CallUnaryFromStream(m, &ctxTestCallUnaryFromStreamServer{stream})
}

type CtxTest_CallUnaryFromStreamServer interface {
	Send(*common.Void) error
	grpc.ServerStream
}

type ctxTestCallUnaryFromStreamServer struct {
	grpc.ServerStream
}

func (x *ctxTestCallUnaryFromStreamServer) Send(m *common.Void) error {
	return x.ServerStream.SendMsg(m)
}

func _CtxTest_CallUnaryFromUnary_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequiredContext)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CtxTestServer).CallUnaryFromUnary(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/getestservice.CtxTest/CallUnaryFromUnary",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CtxTestServer).CallUnaryFromUnary(ctx, req.(*RequiredContext))
	}
	return interceptor(ctx, in, info, handler)
}

func _CtxTest_CallStreamFromStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RequiredContext)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CtxTestServer).CallStreamFromStream(m, &ctxTestCallStreamFromStreamServer{stream})
}

type CtxTest_CallStreamFromStreamServer interface {
	Send(*common.Void) error
	grpc.ServerStream
}

type ctxTestCallStreamFromStreamServer struct {
	grpc.ServerStream
}

func (x *ctxTestCallStreamFromStreamServer) Send(m *common.Void) error {
	return x.ServerStream.SendMsg(m)
}

func _CtxTest_CallStreamFromUnary_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequiredContext)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CtxTestServer).CallStreamFromUnary(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/getestservice.CtxTest/CallStreamFromUnary",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CtxTestServer).CallStreamFromUnary(ctx, req.(*RequiredContext))
	}
	return interceptor(ctx, in, info, handler)
}

func _CtxTest_Sleep_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SleepRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CtxTestServer).Sleep(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/getestservice.CtxTest/Sleep",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CtxTestServer).Sleep(ctx, req.(*SleepRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _CtxTest_serviceDesc = grpc.ServiceDesc{
	ServiceName: "getestservice.CtxTest",
	HandlerType: (*CtxTestServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "TestFork",
			Handler:    _CtxTest_TestFork_Handler,
		},
		{
			MethodName: "TestDeSer",
			Handler:    _CtxTest_TestDeSer_Handler,
		},
		{
			MethodName: "TestUnary",
			Handler:    _CtxTest_TestUnary_Handler,
		},
		{
			MethodName: "CallUnaryFromUnary",
			Handler:    _CtxTest_CallUnaryFromUnary_Handler,
		},
		{
			MethodName: "CallStreamFromUnary",
			Handler:    _CtxTest_CallStreamFromUnary_Handler,
		},
		{
			MethodName: "Sleep",
			Handler:    _CtxTest_Sleep_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "TestStream",
			Handler:       _CtxTest_TestStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CallUnaryFromStream",
			Handler:       _CtxTest_CallUnaryFromStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CallStreamFromStream",
			Handler:       _CtxTest_CallStreamFromStream_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "golang.conradwood.net/apis/getestservice/getestservice.proto",
}

// Client API for Ctx2Test service

type Ctx2TestClient interface {
	TriggerRPC(ctx context.Context, in *TriggerRPCRequest, opts ...grpc.CallOption) (*common.Void, error)
}

type ctx2TestClient struct {
	cc *grpc.ClientConn
}

func NewCtx2TestClient(cc *grpc.ClientConn) Ctx2TestClient {
	return &ctx2TestClient{cc}
}

func (c *ctx2TestClient) TriggerRPC(ctx context.Context, in *TriggerRPCRequest, opts ...grpc.CallOption) (*common.Void, error) {
	out := new(common.Void)
	err := grpc.Invoke(ctx, "/getestservice.Ctx2Test/TriggerRPC", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for Ctx2Test service

type Ctx2TestServer interface {
	TriggerRPC(context.Context, *TriggerRPCRequest) (*common.Void, error)
}

func RegisterCtx2TestServer(s *grpc.Server, srv Ctx2TestServer) {
	s.RegisterService(&_Ctx2Test_serviceDesc, srv)
}

func _Ctx2Test_TriggerRPC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TriggerRPCRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(Ctx2TestServer).TriggerRPC(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/getestservice.Ctx2Test/TriggerRPC",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(Ctx2TestServer).TriggerRPC(ctx, req.(*TriggerRPCRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Ctx2Test_serviceDesc = grpc.ServiceDesc{
	ServiceName: "getestservice.Ctx2Test",
	HandlerType: (*Ctx2TestServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "TriggerRPC",
			Handler:    _Ctx2Test_TriggerRPC_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "golang.conradwood.net/apis/getestservice/getestservice.proto",
}

func init() {
	proto.RegisterFile("golang.conradwood.net/apis/getestservice/getestservice.proto", fileDescriptor0)
}

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