gubernator.pb.go

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

/*
Package gubernator is a generated protocol buffer package.

It is generated from these files:
	gubernator.proto
	peers.proto

It has these top-level messages:
	GetRateLimitsReq
	GetRateLimitsResp
	RateLimitReq
	RateLimitResp
	HealthCheckReq
	HealthCheckResp
	GetPeerRateLimitsReq
	GetPeerRateLimitsResp
	UpdatePeerGlobalsReq
	UpdatePeerGlobal
	UpdatePeerGlobalsResp
*/
package gubernator

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"

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 Algorithm int32

const (
	// Token bucket algorithm https://en.wikipedia.org/wiki/Token_bucket
	Algorithm_TOKEN_BUCKET Algorithm = 0
	// Leaky bucket algorithm https://en.wikipedia.org/wiki/Leaky_bucket
	Algorithm_LEAKY_BUCKET Algorithm = 1
)

var Algorithm_name = map[int32]string{
	0: "TOKEN_BUCKET",
	1: "LEAKY_BUCKET",
}
var Algorithm_value = map[string]int32{
	"TOKEN_BUCKET": 0,
	"LEAKY_BUCKET": 1,
}

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

type Behavior int32

const (
	// BATCHING is the default behavior. This enables batching requests which protects the
	// service from thundering herd. IE: When a service experiences spikes of unexpected high
	// volume requests.
	//
	// Using this option introduces a small amount of latency depending on
	// the `batchWait` setting. Defaults to around 500 Microseconds of additional
	// latency in low throughput situations. For high volume loads, batching can reduce
	// the overall load on the system substantially.
	Behavior_BATCHING Behavior = 0
	// Disables batching. Use this for super low latency rate limit requests when
	// thundering herd is not a concern but latency of requests is of paramount importance.
	Behavior_NO_BATCHING Behavior = 1
	// Enables Global caching of the rate limit. Use this if the rate limit applies globally to
	// all ingress requests. (IE: Throttle hundreds of thousands of requests to an entire
	// datacenter or cluster of http servers)
	//
	// Using this option gubernator will continue to use a single peer as the rate limit coordinator
	// to increment and manage the state of the rate limit, however the result of the rate limit is
	// distributed to each peer and cached locally. A rate limit request received from any peer in the
	// cluster will first check the local cache for a rate limit answer, if it exists the peer will
	// immediately return the answer to the client and asynchronously forward the aggregate hits to
	// the peer coordinator. Because of GLOBALS async nature we lose some accuracy in rate limit
	// reporting, which may result in allowing some requests beyond the chosen rate limit. However we
	// gain massive performance as every request coming into the system does not have to wait for a
	// single peer to decide if the rate limit has been reached.
	Behavior_GLOBAL Behavior = 2
)

var Behavior_name = map[int32]string{
	0: "BATCHING",
	1: "NO_BATCHING",
	2: "GLOBAL",
}
var Behavior_value = map[string]int32{
	"BATCHING":    0,
	"NO_BATCHING": 1,
	"GLOBAL":      2,
}

func (x Behavior) String() string {
	return proto.EnumName(Behavior_name, int32(x))
}
func (Behavior) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }

type Status int32

const (
	Status_UNDER_LIMIT Status = 0
	Status_OVER_LIMIT  Status = 1
)

var Status_name = map[int32]string{
	0: "UNDER_LIMIT",
	1: "OVER_LIMIT",
}
var Status_value = map[string]int32{
	"UNDER_LIMIT": 0,
	"OVER_LIMIT":  1,
}

func (x Status) String() string {
	return proto.EnumName(Status_name, int32(x))
}
func (Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }

// Must specify at least one Request
type GetRateLimitsReq struct {
	Requests []*RateLimitReq `protobuf:"bytes,1,rep,name=requests" json:"requests,omitempty"`
}

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

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

// RateLimits returned are in the same order as the Requests
type GetRateLimitsResp struct {
	Responses []*RateLimitResp `protobuf:"bytes,1,rep,name=responses" json:"responses,omitempty"`
}

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

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

type RateLimitReq struct {
	// The name of the rate limit IE: 'requests_per_second', 'gets_per_minute`
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	// Uniquely identifies this rate limit IE: 'ip:10.2.10.7' or 'account:123445'
	UniqueKey string `protobuf:"bytes,2,opt,name=unique_key,json=uniqueKey" json:"unique_key,omitempty"`
	// Rate limit requests optionally specify the number of hits a request adds to the matched limit. If Hit
	// is zero, the request returns the current limit, but does not increment the hit count.
	Hits int64 `protobuf:"varint,3,opt,name=hits" json:"hits,omitempty"`
	// The number of requests that can occur for the duration of the rate limit
	Limit int64 `protobuf:"varint,4,opt,name=limit" json:"limit,omitempty"`
	// The duration of the rate limit in milliseconds
	// Second = 1000 Milliseconds
	// Minute = 60000 Milliseconds
	// Hour = 3600000 Milliseconds
	Duration int64 `protobuf:"varint,5,opt,name=duration" json:"duration,omitempty"`
	// The algorithm used to calculate the rate limit. The algorithm may change on
	// subsequent requests, when this occurs any previous rate limit hit counts are reset.
	Algorithm Algorithm `protobuf:"varint,6,opt,name=algorithm,enum=pb.gubernator.Algorithm" json:"algorithm,omitempty"`
	// The behavior of the rate limit in gubernator.
	Behavior Behavior `protobuf:"varint,7,opt,name=behavior,enum=pb.gubernator.Behavior" json:"behavior,omitempty"`
}

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

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

func (m *RateLimitReq) GetUniqueKey() string {
	if m != nil {
		return m.UniqueKey
	}
	return ""
}

func (m *RateLimitReq) GetHits() int64 {
	if m != nil {
		return m.Hits
	}
	return 0
}

func (m *RateLimitReq) GetLimit() int64 {
	if m != nil {
		return m.Limit
	}
	return 0
}

func (m *RateLimitReq) GetDuration() int64 {
	if m != nil {
		return m.Duration
	}
	return 0
}

func (m *RateLimitReq) GetAlgorithm() Algorithm {
	if m != nil {
		return m.Algorithm
	}
	return Algorithm_TOKEN_BUCKET
}

func (m *RateLimitReq) GetBehavior() Behavior {
	if m != nil {
		return m.Behavior
	}
	return Behavior_BATCHING
}

type RateLimitResp struct {
	// The status of the rate limit.
	Status Status `protobuf:"varint,1,opt,name=status,enum=pb.gubernator.Status" json:"status,omitempty"`
	// The currently configured request limit (Identical to RateLimitRequest.rate_limit_config.limit).
	Limit int64 `protobuf:"varint,2,opt,name=limit" json:"limit,omitempty"`
	// This is the number of requests remaining before the limit is hit.
	Remaining int64 `protobuf:"varint,3,opt,name=remaining" json:"remaining,omitempty"`
	// This is the time when the rate limit span will be reset, provided as a unix timestamp in milliseconds.
	ResetTime int64 `protobuf:"varint,4,opt,name=reset_time,json=resetTime" json:"reset_time,omitempty"`
	// Contains the error; If set all other values should be ignored
	Error string `protobuf:"bytes,5,opt,name=error" json:"error,omitempty"`
	// This is additional metadata that a client might find useful. (IE: Additional headers, corrdinator ownership, etc..)
	Metadata map[string]string `protobuf:"bytes,6,rep,name=metadata" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
}

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

func (m *RateLimitResp) GetStatus() Status {
	if m != nil {
		return m.Status
	}
	return Status_UNDER_LIMIT
}

func (m *RateLimitResp) GetLimit() int64 {
	if m != nil {
		return m.Limit
	}
	return 0
}

func (m *RateLimitResp) GetRemaining() int64 {
	if m != nil {
		return m.Remaining
	}
	return 0
}

func (m *RateLimitResp) GetResetTime() int64 {
	if m != nil {
		return m.ResetTime
	}
	return 0
}

func (m *RateLimitResp) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

func (m *RateLimitResp) GetMetadata() map[string]string {
	if m != nil {
		return m.Metadata
	}
	return nil
}

type HealthCheckReq struct {
}

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

type HealthCheckResp struct {
	// Valid entries are 'healthy' or 'unhealthy'
	Status string `protobuf:"bytes,1,opt,name=status" json:"status,omitempty"`
	// If 'unhealthy', message indicates the problem
	Message string `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
	// The number of peers we know about
	PeerCount int32 `protobuf:"varint,3,opt,name=peer_count,json=peerCount" json:"peer_count,omitempty"`
}

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

func (m *HealthCheckResp) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

func (m *HealthCheckResp) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *HealthCheckResp) GetPeerCount() int32 {
	if m != nil {
		return m.PeerCount
	}
	return 0
}

func init() {
	proto.RegisterType((*GetRateLimitsReq)(nil), "pb.gubernator.GetRateLimitsReq")
	proto.RegisterType((*GetRateLimitsResp)(nil), "pb.gubernator.GetRateLimitsResp")
	proto.RegisterType((*RateLimitReq)(nil), "pb.gubernator.RateLimitReq")
	proto.RegisterType((*RateLimitResp)(nil), "pb.gubernator.RateLimitResp")
	proto.RegisterType((*HealthCheckReq)(nil), "pb.gubernator.HealthCheckReq")
	proto.RegisterType((*HealthCheckResp)(nil), "pb.gubernator.HealthCheckResp")
	proto.RegisterEnum("pb.gubernator.Algorithm", Algorithm_name, Algorithm_value)
	proto.RegisterEnum("pb.gubernator.Behavior", Behavior_name, Behavior_value)
	proto.RegisterEnum("pb.gubernator.Status", Status_name, Status_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 V1 service

type V1Client interface {
	// Given a list of rate limit requests, return the rate limits of each.
	GetRateLimits(ctx context.Context, in *GetRateLimitsReq, opts ...grpc.CallOption) (*GetRateLimitsResp, error)
	// This method is for round trip benchmarking and can be used by
	// the client to determine connectivity to the server
	HealthCheck(ctx context.Context, in *HealthCheckReq, opts ...grpc.CallOption) (*HealthCheckResp, error)
}

type v1Client struct {
	cc *grpc.ClientConn
}

func NewV1Client(cc *grpc.ClientConn) V1Client {
	return &v1Client{cc}
}

func (c *v1Client) GetRateLimits(ctx context.Context, in *GetRateLimitsReq, opts ...grpc.CallOption) (*GetRateLimitsResp, error) {
	out := new(GetRateLimitsResp)
	err := grpc.Invoke(ctx, "/pb.gubernator.V1/GetRateLimits", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *v1Client) HealthCheck(ctx context.Context, in *HealthCheckReq, opts ...grpc.CallOption) (*HealthCheckResp, error) {
	out := new(HealthCheckResp)
	err := grpc.Invoke(ctx, "/pb.gubernator.V1/HealthCheck", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for V1 service

type V1Server interface {
	// Given a list of rate limit requests, return the rate limits of each.
	GetRateLimits(context.Context, *GetRateLimitsReq) (*GetRateLimitsResp, error)
	// This method is for round trip benchmarking and can be used by
	// the client to determine connectivity to the server
	HealthCheck(context.Context, *HealthCheckReq) (*HealthCheckResp, error)
}

func RegisterV1Server(s *grpc.Server, srv V1Server) {
	s.RegisterService(&_V1_serviceDesc, srv)
}

func _V1_GetRateLimits_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRateLimitsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(V1Server).GetRateLimits(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.gubernator.V1/GetRateLimits",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(V1Server).GetRateLimits(ctx, req.(*GetRateLimitsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _V1_HealthCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HealthCheckReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(V1Server).HealthCheck(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.gubernator.V1/HealthCheck",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(V1Server).HealthCheck(ctx, req.(*HealthCheckReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _V1_serviceDesc = grpc.ServiceDesc{
	ServiceName: "pb.gubernator.V1",
	HandlerType: (*V1Server)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetRateLimits",
			Handler:    _V1_GetRateLimits_Handler,
		},
		{
			MethodName: "HealthCheck",
			Handler:    _V1_HealthCheck_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "gubernator.proto",
}

func init() { proto.RegisterFile("gubernator.proto", fileDescriptor0) }

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