// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google.golang.org/appengine/internal/taskqueue/taskqueue_service.proto

/*
Package taskqueue is a generated protocol buffer package.

It is generated from these files:
	google.golang.org/appengine/internal/taskqueue/taskqueue_service.proto

It has these top-level messages:
	TaskQueueServiceError
	TaskPayload
	TaskQueueRetryParameters
	TaskQueueAcl
	TaskQueueHttpHeader
	TaskQueueMode
	TaskQueueAddRequest
	TaskQueueAddResponse
	TaskQueueBulkAddRequest
	TaskQueueBulkAddResponse
	TaskQueueDeleteRequest
	TaskQueueDeleteResponse
	TaskQueueForceRunRequest
	TaskQueueForceRunResponse
	TaskQueueUpdateQueueRequest
	TaskQueueUpdateQueueResponse
	TaskQueueFetchQueuesRequest
	TaskQueueFetchQueuesResponse
	TaskQueueFetchQueueStatsRequest
	TaskQueueScannerQueueInfo
	TaskQueueFetchQueueStatsResponse
	TaskQueuePauseQueueRequest
	TaskQueuePauseQueueResponse
	TaskQueuePurgeQueueRequest
	TaskQueuePurgeQueueResponse
	TaskQueueDeleteQueueRequest
	TaskQueueDeleteQueueResponse
	TaskQueueDeleteGroupRequest
	TaskQueueDeleteGroupResponse
	TaskQueueQueryTasksRequest
	TaskQueueQueryTasksResponse
	TaskQueueFetchTaskRequest
	TaskQueueFetchTaskResponse
	TaskQueueUpdateStorageLimitRequest
	TaskQueueUpdateStorageLimitResponse
	TaskQueueQueryAndOwnTasksRequest
	TaskQueueQueryAndOwnTasksResponse
	TaskQueueModifyTaskLeaseRequest
	TaskQueueModifyTaskLeaseResponse
*/
package taskqueue

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import appengine "google.golang.org/appengine/internal/datastore"

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

const (
	TaskQueueServiceError_OK                              TaskQueueServiceError_ErrorCode = 0
	TaskQueueServiceError_UNKNOWN_QUEUE                   TaskQueueServiceError_ErrorCode = 1
	TaskQueueServiceError_TRANSIENT_ERROR                 TaskQueueServiceError_ErrorCode = 2
	TaskQueueServiceError_INTERNAL_ERROR                  TaskQueueServiceError_ErrorCode = 3
	TaskQueueServiceError_TASK_TOO_LARGE                  TaskQueueServiceError_ErrorCode = 4
	TaskQueueServiceError_INVALID_TASK_NAME               TaskQueueServiceError_ErrorCode = 5
	TaskQueueServiceError_INVALID_QUEUE_NAME              TaskQueueServiceError_ErrorCode = 6
	TaskQueueServiceError_INVALID_URL                     TaskQueueServiceError_ErrorCode = 7
	TaskQueueServiceError_INVALID_QUEUE_RATE              TaskQueueServiceError_ErrorCode = 8
	TaskQueueServiceError_PERMISSION_DENIED               TaskQueueServiceError_ErrorCode = 9
	TaskQueueServiceError_TASK_ALREADY_EXISTS             TaskQueueServiceError_ErrorCode = 10
	TaskQueueServiceError_TOMBSTONED_TASK                 TaskQueueServiceError_ErrorCode = 11
	TaskQueueServiceError_INVALID_ETA                     TaskQueueServiceError_ErrorCode = 12
	TaskQueueServiceError_INVALID_REQUEST                 TaskQueueServiceError_ErrorCode = 13
	TaskQueueServiceError_UNKNOWN_TASK                    TaskQueueServiceError_ErrorCode = 14
	TaskQueueServiceError_TOMBSTONED_QUEUE                TaskQueueServiceError_ErrorCode = 15
	TaskQueueServiceError_DUPLICATE_TASK_NAME             TaskQueueServiceError_ErrorCode = 16
	TaskQueueServiceError_SKIPPED                         TaskQueueServiceError_ErrorCode = 17
	TaskQueueServiceError_TOO_MANY_TASKS                  TaskQueueServiceError_ErrorCode = 18
	TaskQueueServiceError_INVALID_PAYLOAD                 TaskQueueServiceError_ErrorCode = 19
	TaskQueueServiceError_INVALID_RETRY_PARAMETERS        TaskQueueServiceError_ErrorCode = 20
	TaskQueueServiceError_INVALID_QUEUE_MODE              TaskQueueServiceError_ErrorCode = 21
	TaskQueueServiceError_ACL_LOOKUP_ERROR                TaskQueueServiceError_ErrorCode = 22
	TaskQueueServiceError_TRANSACTIONAL_REQUEST_TOO_LARGE TaskQueueServiceError_ErrorCode = 23
	TaskQueueServiceError_INCORRECT_CREATOR_NAME          TaskQueueServiceError_ErrorCode = 24
	TaskQueueServiceError_TASK_LEASE_EXPIRED              TaskQueueServiceError_ErrorCode = 25
	TaskQueueServiceError_QUEUE_PAUSED                    TaskQueueServiceError_ErrorCode = 26
	TaskQueueServiceError_INVALID_TAG                     TaskQueueServiceError_ErrorCode = 27
	// Reserved range for the Datastore error codes.
	// Original Datastore error code is shifted by DATASTORE_ERROR offset.
	TaskQueueServiceError_DATASTORE_ERROR TaskQueueServiceError_ErrorCode = 10000
)

var TaskQueueServiceError_ErrorCode_name = map[int32]string{
	0:     "OK",
	1:     "UNKNOWN_QUEUE",
	2:     "TRANSIENT_ERROR",
	3:     "INTERNAL_ERROR",
	4:     "TASK_TOO_LARGE",
	5:     "INVALID_TASK_NAME",
	6:     "INVALID_QUEUE_NAME",
	7:     "INVALID_URL",
	8:     "INVALID_QUEUE_RATE",
	9:     "PERMISSION_DENIED",
	10:    "TASK_ALREADY_EXISTS",
	11:    "TOMBSTONED_TASK",
	12:    "INVALID_ETA",
	13:    "INVALID_REQUEST",
	14:    "UNKNOWN_TASK",
	15:    "TOMBSTONED_QUEUE",
	16:    "DUPLICATE_TASK_NAME",
	17:    "SKIPPED",
	18:    "TOO_MANY_TASKS",
	19:    "INVALID_PAYLOAD",
	20:    "INVALID_RETRY_PARAMETERS",
	21:    "INVALID_QUEUE_MODE",
	22:    "ACL_LOOKUP_ERROR",
	23:    "TRANSACTIONAL_REQUEST_TOO_LARGE",
	24:    "INCORRECT_CREATOR_NAME",
	25:    "TASK_LEASE_EXPIRED",
	26:    "QUEUE_PAUSED",
	27:    "INVALID_TAG",
	10000: "DATASTORE_ERROR",
}
var TaskQueueServiceError_ErrorCode_value = map[string]int32{
	"OK":                              0,
	"UNKNOWN_QUEUE":                   1,
	"TRANSIENT_ERROR":                 2,
	"INTERNAL_ERROR":                  3,
	"TASK_TOO_LARGE":                  4,
	"INVALID_TASK_NAME":               5,
	"INVALID_QUEUE_NAME":              6,
	"INVALID_URL":                     7,
	"INVALID_QUEUE_RATE":              8,
	"PERMISSION_DENIED":               9,
	"TASK_ALREADY_EXISTS":             10,
	"TOMBSTONED_TASK":                 11,
	"INVALID_ETA":                     12,
	"INVALID_REQUEST":                 13,
	"UNKNOWN_TASK":                    14,
	"TOMBSTONED_QUEUE":                15,
	"DUPLICATE_TASK_NAME":             16,
	"SKIPPED":                         17,
	"TOO_MANY_TASKS":                  18,
	"INVALID_PAYLOAD":                 19,
	"INVALID_RETRY_PARAMETERS":        20,
	"INVALID_QUEUE_MODE":              21,
	"ACL_LOOKUP_ERROR":                22,
	"TRANSACTIONAL_REQUEST_TOO_LARGE": 23,
	"INCORRECT_CREATOR_NAME":          24,
	"TASK_LEASE_EXPIRED":              25,
	"QUEUE_PAUSED":                    26,
	"INVALID_TAG":                     27,
	"DATASTORE_ERROR":                 10000,
}

func (x TaskQueueServiceError_ErrorCode) Enum() *TaskQueueServiceError_ErrorCode {
	p := new(TaskQueueServiceError_ErrorCode)
	*p = x
	return p
}
func (x TaskQueueServiceError_ErrorCode) String() string {
	return proto.EnumName(TaskQueueServiceError_ErrorCode_name, int32(x))
}
func (x *TaskQueueServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(TaskQueueServiceError_ErrorCode_value, data, "TaskQueueServiceError_ErrorCode")
	if err != nil {
		return err
	}
	*x = TaskQueueServiceError_ErrorCode(value)
	return nil
}
func (TaskQueueServiceError_ErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor0, []int{0, 0}
}

type TaskQueueMode_Mode int32

const (
	TaskQueueMode_PUSH TaskQueueMode_Mode = 0
	TaskQueueMode_PULL TaskQueueMode_Mode = 1
)

var TaskQueueMode_Mode_name = map[int32]string{
	0: "PUSH",
	1: "PULL",
}
var TaskQueueMode_Mode_value = map[string]int32{
	"PUSH": 0,
	"PULL": 1,
}

func (x TaskQueueMode_Mode) Enum() *TaskQueueMode_Mode {
	p := new(TaskQueueMode_Mode)
	*p = x
	return p
}
func (x TaskQueueMode_Mode) String() string {
	return proto.EnumName(TaskQueueMode_Mode_name, int32(x))
}
func (x *TaskQueueMode_Mode) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(TaskQueueMode_Mode_value, data, "TaskQueueMode_Mode")
	if err != nil {
		return err
	}
	*x = TaskQueueMode_Mode(value)
	return nil
}
func (TaskQueueMode_Mode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{5, 0} }

type TaskQueueAddRequest_RequestMethod int32

const (
	TaskQueueAddRequest_GET    TaskQueueAddRequest_RequestMethod = 1
	TaskQueueAddRequest_POST   TaskQueueAddRequest_RequestMethod = 2
	TaskQueueAddRequest_HEAD   TaskQueueAddRequest_RequestMethod = 3
	TaskQueueAddRequest_PUT    TaskQueueAddRequest_RequestMethod = 4
	TaskQueueAddRequest_DELETE TaskQueueAddRequest_RequestMethod = 5
)

var TaskQueueAddRequest_RequestMethod_name = map[int32]string{
	1: "GET",
	2: "POST",
	3: "HEAD",
	4: "PUT",
	5: "DELETE",
}
var TaskQueueAddRequest_RequestMethod_value = map[string]int32{
	"GET":    1,
	"POST":   2,
	"HEAD":   3,
	"PUT":    4,
	"DELETE": 5,
}

func (x TaskQueueAddRequest_RequestMethod) Enum() *TaskQueueAddRequest_RequestMethod {
	p := new(TaskQueueAddRequest_RequestMethod)
	*p = x
	return p
}
func (x TaskQueueAddRequest_RequestMethod) String() string {
	return proto.EnumName(TaskQueueAddRequest_RequestMethod_name, int32(x))
}
func (x *TaskQueueAddRequest_RequestMethod) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(TaskQueueAddRequest_RequestMethod_value, data, "TaskQueueAddRequest_RequestMethod")
	if err != nil {
		return err
	}
	*x = TaskQueueAddRequest_RequestMethod(value)
	return nil
}
func (TaskQueueAddRequest_RequestMethod) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor0, []int{6, 0}
}

type TaskQueueQueryTasksResponse_Task_RequestMethod int32

const (
	TaskQueueQueryTasksResponse_Task_GET    TaskQueueQueryTasksResponse_Task_RequestMethod = 1
	TaskQueueQueryTasksResponse_Task_POST   TaskQueueQueryTasksResponse_Task_RequestMethod = 2
	TaskQueueQueryTasksResponse_Task_HEAD   TaskQueueQueryTasksResponse_Task_RequestMethod = 3
	TaskQueueQueryTasksResponse_Task_PUT    TaskQueueQueryTasksResponse_Task_RequestMethod = 4
	TaskQueueQueryTasksResponse_Task_DELETE TaskQueueQueryTasksResponse_Task_RequestMethod = 5
)

var TaskQueueQueryTasksResponse_Task_RequestMethod_name = map[int32]string{
	1: "GET",
	2: "POST",
	3: "HEAD",
	4: "PUT",
	5: "DELETE",
}
var TaskQueueQueryTasksResponse_Task_RequestMethod_value = map[string]int32{
	"GET":    1,
	"POST":   2,
	"HEAD":   3,
	"PUT":    4,
	"DELETE": 5,
}

func (x TaskQueueQueryTasksResponse_Task_RequestMethod) Enum() *TaskQueueQueryTasksResponse_Task_RequestMethod {
	p := new(TaskQueueQueryTasksResponse_Task_RequestMethod)
	*p = x
	return p
}
func (x TaskQueueQueryTasksResponse_Task_RequestMethod) String() string {
	return proto.EnumName(TaskQueueQueryTasksResponse_Task_RequestMethod_name, int32(x))
}
func (x *TaskQueueQueryTasksResponse_Task_RequestMethod) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(TaskQueueQueryTasksResponse_Task_RequestMethod_value, data, "TaskQueueQueryTasksResponse_Task_RequestMethod")
	if err != nil {
		return err
	}
	*x = TaskQueueQueryTasksResponse_Task_RequestMethod(value)
	return nil
}
func (TaskQueueQueryTasksResponse_Task_RequestMethod) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor0, []int{30, 0, 0}
}

type TaskQueueServiceError struct {
	XXX_unrecognized []byte `json:"-"`
}

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

type TaskPayload struct {
	proto.XXX_InternalExtensions `json:"-"`
	XXX_unrecognized             []byte `json:"-"`
}

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

func (m *TaskPayload) Marshal() ([]byte, error) {
	return proto.MarshalMessageSet(&m.XXX_InternalExtensions)
}
func (m *TaskPayload) Unmarshal(buf []byte) error {
	return proto.UnmarshalMessageSet(buf, &m.XXX_InternalExtensions)
}
func (m *TaskPayload) MarshalJSON() ([]byte, error) {
	return proto.MarshalMessageSetJSON(&m.XXX_InternalExtensions)
}
func (m *TaskPayload) UnmarshalJSON(buf []byte) error {
	return proto.UnmarshalMessageSetJSON(buf, &m.XXX_InternalExtensions)
}

// ensure TaskPayload satisfies proto.Marshaler and proto.Unmarshaler
var _ proto.Marshaler = (*TaskPayload)(nil)
var _ proto.Unmarshaler = (*TaskPayload)(nil)

var extRange_TaskPayload = []proto.ExtensionRange{
	{10, 2147483646},
}

func (*TaskPayload) ExtensionRangeArray() []proto.ExtensionRange {
	return extRange_TaskPayload
}

type TaskQueueRetryParameters struct {
	RetryLimit       *int32   `protobuf:"varint,1,opt,name=retry_limit,json=retryLimit" json:"retry_limit,omitempty"`
	AgeLimitSec      *int64   `protobuf:"varint,2,opt,name=age_limit_sec,json=ageLimitSec" json:"age_limit_sec,omitempty"`
	MinBackoffSec    *float64 `protobuf:"fixed64,3,opt,name=min_backoff_sec,json=minBackoffSec,def=0.1" json:"min_backoff_sec,omitempty"`
	MaxBackoffSec    *float64 `protobuf:"fixed64,4,opt,name=max_backoff_sec,json=maxBackoffSec,def=3600" json:"max_backoff_sec,omitempty"`
	MaxDoublings     *int32   `protobuf:"varint,5,opt,name=max_doublings,json=maxDoublings,def=16" json:"max_doublings,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

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

const Default_TaskQueueRetryParameters_MinBackoffSec float64 = 0.1
const Default_TaskQueueRetryParameters_MaxBackoffSec float64 = 3600
const Default_TaskQueueRetryParameters_MaxDoublings int32 = 16

func (m *TaskQueueRetryParameters) GetRetryLimit() int32 {
	if m != nil && m.RetryLimit != nil {
		return *m.RetryLimit
	}
	return 0
}

func (m *TaskQueueRetryParameters) GetAgeLimitSec() int64 {
	if m != nil && m.AgeLimitSec != nil {
		return *m.AgeLimitSec
	}
	return 0
}

func (m *TaskQueueRetryParameters) GetMinBackoffSec() float64 {
	if m != nil && m.MinBackoffSec != nil {
		return *m.MinBackoffSec
	}
	return Default_TaskQueueRetryParameters_MinBackoffSec
}

func (m *TaskQueueRetryParameters) GetMaxBackoffSec() float64 {
	if m != nil && m.MaxBackoffSec != nil {
		return *m.MaxBackoffSec
	}
	return Default_TaskQueueRetryParameters_MaxBackoffSec
}

func (m *TaskQueueRetryParameters) GetMaxDoublings() int32 {
	if m != nil && m.MaxDoublings != nil {
		return *m.MaxDoublings
	}
	return Default_TaskQueueRetryParameters_MaxDoublings
}

type TaskQueueAcl struct {
	UserEmail        [][]byte `protobuf:"bytes,1,rep,name=user_email,json=userEmail" json:"user_email,omitempty"`
	WriterEmail      [][]byte `protobuf:"bytes,2,rep,name=writer_email,json=writerEmail" json:"writer_email,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

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

func (m *TaskQueueAcl) GetUserEmail() [][]byte {
	if m != nil {
		return m.UserEmail
	}
	return nil
}

func (m *TaskQueueAcl) GetWriterEmail() [][]byte {
	if m != nil {
		return m.WriterEmail
	}
	return nil
}

type TaskQueueHttpHeader struct {
	Key              []byte `protobuf:"bytes,1,req,name=key" json:"key,omitempty"`
	Value            []byte `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *TaskQueueHttpHeader) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *TaskQueueHttpHeader) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

type TaskQueueMode struct {
	XXX_unrecognized []byte `json:"-"`
}

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

type TaskQueueAddRequest struct {
	QueueName        []byte                             `protobuf:"bytes,1,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	TaskName         []byte                             `protobuf:"bytes,2,req,name=task_name,json=taskName" json:"task_name,omitempty"`
	EtaUsec          *int64                             `protobuf:"varint,3,req,name=eta_usec,json=etaUsec" json:"eta_usec,omitempty"`
	Method           *TaskQueueAddRequest_RequestMethod `protobuf:"varint,5,opt,name=method,enum=appengine.TaskQueueAddRequest_RequestMethod,def=2" json:"method,omitempty"`
	Url              []byte                             `protobuf:"bytes,4,opt,name=url" json:"url,omitempty"`
	Header           []*TaskQueueAddRequest_Header      `protobuf:"group,6,rep,name=Header,json=header" json:"header,omitempty"`
	Body             []byte                             `protobuf:"bytes,9,opt,name=body" json:"body,omitempty"`
	Transaction      *appengine.Transaction             `protobuf:"bytes,10,opt,name=transaction" json:"transaction,omitempty"`
	AppId            []byte                             `protobuf:"bytes,11,opt,name=app_id,json=appId" json:"app_id,omitempty"`
	Crontimetable    *TaskQueueAddRequest_CronTimetable `protobuf:"group,12,opt,name=CronTimetable,json=crontimetable" json:"crontimetable,omitempty"`
	Description      []byte                             `protobuf:"bytes,15,opt,name=description" json:"description,omitempty"`
	Payload          *TaskPayload                       `protobuf:"bytes,16,opt,name=payload" json:"payload,omitempty"`
	RetryParameters  *TaskQueueRetryParameters          `protobuf:"bytes,17,opt,name=retry_parameters,json=retryParameters" json:"retry_parameters,omitempty"`
	Mode             *TaskQueueMode_Mode                `protobuf:"varint,18,opt,name=mode,enum=appengine.TaskQueueMode_Mode,def=0" json:"mode,omitempty"`
	Tag              []byte                             `protobuf:"bytes,19,opt,name=tag" json:"tag,omitempty"`
	XXX_unrecognized []byte                             `json:"-"`
}

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

const Default_TaskQueueAddRequest_Method TaskQueueAddRequest_RequestMethod = TaskQueueAddRequest_POST
const Default_TaskQueueAddRequest_Mode TaskQueueMode_Mode = TaskQueueMode_PUSH

func (m *TaskQueueAddRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueueAddRequest) GetTaskName() []byte {
	if m != nil {
		return m.TaskName
	}
	return nil
}

func (m *TaskQueueAddRequest) GetEtaUsec() int64 {
	if m != nil && m.EtaUsec != nil {
		return *m.EtaUsec
	}
	return 0
}

func (m *TaskQueueAddRequest) GetMethod() TaskQueueAddRequest_RequestMethod {
	if m != nil && m.Method != nil {
		return *m.Method
	}
	return Default_TaskQueueAddRequest_Method
}

func (m *TaskQueueAddRequest) GetUrl() []byte {
	if m != nil {
		return m.Url
	}
	return nil
}

func (m *TaskQueueAddRequest) GetHeader() []*TaskQueueAddRequest_Header {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *TaskQueueAddRequest) GetBody() []byte {
	if m != nil {
		return m.Body
	}
	return nil
}

func (m *TaskQueueAddRequest) GetTransaction() *appengine.Transaction {
	if m != nil {
		return m.Transaction
	}
	return nil
}

func (m *TaskQueueAddRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueueAddRequest) GetCrontimetable() *TaskQueueAddRequest_CronTimetable {
	if m != nil {
		return m.Crontimetable
	}
	return nil
}

func (m *TaskQueueAddRequest) GetDescription() []byte {
	if m != nil {
		return m.Description
	}
	return nil
}

func (m *TaskQueueAddRequest) GetPayload() *TaskPayload {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *TaskQueueAddRequest) GetRetryParameters() *TaskQueueRetryParameters {
	if m != nil {
		return m.RetryParameters
	}
	return nil
}

func (m *TaskQueueAddRequest) GetMode() TaskQueueMode_Mode {
	if m != nil && m.Mode != nil {
		return *m.Mode
	}
	return Default_TaskQueueAddRequest_Mode
}

func (m *TaskQueueAddRequest) GetTag() []byte {
	if m != nil {
		return m.Tag
	}
	return nil
}

type TaskQueueAddRequest_Header struct {
	Key              []byte `protobuf:"bytes,7,req,name=key" json:"key,omitempty"`
	Value            []byte `protobuf:"bytes,8,req,name=value" json:"value,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *TaskQueueAddRequest_Header) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *TaskQueueAddRequest_Header) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

type TaskQueueAddRequest_CronTimetable struct {
	Schedule         []byte `protobuf:"bytes,13,req,name=schedule" json:"schedule,omitempty"`
	Timezone         []byte `protobuf:"bytes,14,req,name=timezone" json:"timezone,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *TaskQueueAddRequest_CronTimetable) GetSchedule() []byte {
	if m != nil {
		return m.Schedule
	}
	return nil
}

func (m *TaskQueueAddRequest_CronTimetable) GetTimezone() []byte {
	if m != nil {
		return m.Timezone
	}
	return nil
}

type TaskQueueAddResponse struct {
	ChosenTaskName   []byte `protobuf:"bytes,1,opt,name=chosen_task_name,json=chosenTaskName" json:"chosen_task_name,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *TaskQueueAddResponse) GetChosenTaskName() []byte {
	if m != nil {
		return m.ChosenTaskName
	}
	return nil
}

type TaskQueueBulkAddRequest struct {
	AddRequest       []*TaskQueueAddRequest `protobuf:"bytes,1,rep,name=add_request,json=addRequest" json:"add_request,omitempty"`
	XXX_unrecognized []byte                 `json:"-"`
}

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

func (m *TaskQueueBulkAddRequest) GetAddRequest() []*TaskQueueAddRequest {
	if m != nil {
		return m.AddRequest
	}
	return nil
}

type TaskQueueBulkAddResponse struct {
	Taskresult       []*TaskQueueBulkAddResponse_TaskResult `protobuf:"group,1,rep,name=TaskResult,json=taskresult" json:"taskresult,omitempty"`
	XXX_unrecognized []byte                                 `json:"-"`
}

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

func (m *TaskQueueBulkAddResponse) GetTaskresult() []*TaskQueueBulkAddResponse_TaskResult {
	if m != nil {
		return m.Taskresult
	}
	return nil
}

type TaskQueueBulkAddResponse_TaskResult struct {
	Result           *TaskQueueServiceError_ErrorCode `protobuf:"varint,2,req,name=result,enum=appengine.TaskQueueServiceError_ErrorCode" json:"result,omitempty"`
	ChosenTaskName   []byte                           `protobuf:"bytes,3,opt,name=chosen_task_name,json=chosenTaskName" json:"chosen_task_name,omitempty"`
	XXX_unrecognized []byte                           `json:"-"`
}

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

func (m *TaskQueueBulkAddResponse_TaskResult) GetResult() TaskQueueServiceError_ErrorCode {
	if m != nil && m.Result != nil {
		return *m.Result
	}
	return TaskQueueServiceError_OK
}

func (m *TaskQueueBulkAddResponse_TaskResult) GetChosenTaskName() []byte {
	if m != nil {
		return m.ChosenTaskName
	}
	return nil
}

type TaskQueueDeleteRequest struct {
	QueueName        []byte   `protobuf:"bytes,1,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	TaskName         [][]byte `protobuf:"bytes,2,rep,name=task_name,json=taskName" json:"task_name,omitempty"`
	AppId            []byte   `protobuf:"bytes,3,opt,name=app_id,json=appId" json:"app_id,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

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

func (m *TaskQueueDeleteRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueueDeleteRequest) GetTaskName() [][]byte {
	if m != nil {
		return m.TaskName
	}
	return nil
}

func (m *TaskQueueDeleteRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

type TaskQueueDeleteResponse struct {
	Result           []TaskQueueServiceError_ErrorCode `protobuf:"varint,3,rep,name=result,enum=appengine.TaskQueueServiceError_ErrorCode" json:"result,omitempty"`
	XXX_unrecognized []byte                            `json:"-"`
}

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

func (m *TaskQueueDeleteResponse) GetResult() []TaskQueueServiceError_ErrorCode {
	if m != nil {
		return m.Result
	}
	return nil
}

type TaskQueueForceRunRequest struct {
	AppId            []byte `protobuf:"bytes,1,opt,name=app_id,json=appId" json:"app_id,omitempty"`
	QueueName        []byte `protobuf:"bytes,2,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	TaskName         []byte `protobuf:"bytes,3,req,name=task_name,json=taskName" json:"task_name,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *TaskQueueForceRunRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueueForceRunRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueueForceRunRequest) GetTaskName() []byte {
	if m != nil {
		return m.TaskName
	}
	return nil
}

type TaskQueueForceRunResponse struct {
	Result           *TaskQueueServiceError_ErrorCode `protobuf:"varint,3,req,name=result,enum=appengine.TaskQueueServiceError_ErrorCode" json:"result,omitempty"`
	XXX_unrecognized []byte                           `json:"-"`
}

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

func (m *TaskQueueForceRunResponse) GetResult() TaskQueueServiceError_ErrorCode {
	if m != nil && m.Result != nil {
		return *m.Result
	}
	return TaskQueueServiceError_OK
}

type TaskQueueUpdateQueueRequest struct {
	AppId                 []byte                    `protobuf:"bytes,1,opt,name=app_id,json=appId" json:"app_id,omitempty"`
	QueueName             []byte                    `protobuf:"bytes,2,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	BucketRefillPerSecond *float64                  `protobuf:"fixed64,3,req,name=bucket_refill_per_second,json=bucketRefillPerSecond" json:"bucket_refill_per_second,omitempty"`
	BucketCapacity        *int32                    `protobuf:"varint,4,req,name=bucket_capacity,json=bucketCapacity" json:"bucket_capacity,omitempty"`
	UserSpecifiedRate     *string                   `protobuf:"bytes,5,opt,name=user_specified_rate,json=userSpecifiedRate" json:"user_specified_rate,omitempty"`
	RetryParameters       *TaskQueueRetryParameters `protobuf:"bytes,6,opt,name=retry_parameters,json=retryParameters" json:"retry_parameters,omitempty"`
	MaxConcurrentRequests *int32                    `protobuf:"varint,7,opt,name=max_concurrent_requests,json=maxConcurrentRequests" json:"max_concurrent_requests,omitempty"`
	Mode                  *TaskQueueMode_Mode       `protobuf:"varint,8,opt,name=mode,enum=appengine.TaskQueueMode_Mode,def=0" json:"mode,omitempty"`
	Acl                   *TaskQueueAcl             `protobuf:"bytes,9,opt,name=acl" json:"acl,omitempty"`
	HeaderOverride        []*TaskQueueHttpHeader    `protobuf:"bytes,10,rep,name=header_override,json=headerOverride" json:"header_override,omitempty"`
	XXX_unrecognized      []byte                    `json:"-"`
}

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

const Default_TaskQueueUpdateQueueRequest_Mode TaskQueueMode_Mode = TaskQueueMode_PUSH

func (m *TaskQueueUpdateQueueRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueueUpdateQueueRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueueUpdateQueueRequest) GetBucketRefillPerSecond() float64 {
	if m != nil && m.BucketRefillPerSecond != nil {
		return *m.BucketRefillPerSecond
	}
	return 0
}

func (m *TaskQueueUpdateQueueRequest) GetBucketCapacity() int32 {
	if m != nil && m.BucketCapacity != nil {
		return *m.BucketCapacity
	}
	return 0
}

func (m *TaskQueueUpdateQueueRequest) GetUserSpecifiedRate() string {
	if m != nil && m.UserSpecifiedRate != nil {
		return *m.UserSpecifiedRate
	}
	return ""
}

func (m *TaskQueueUpdateQueueRequest) GetRetryParameters() *TaskQueueRetryParameters {
	if m != nil {
		return m.RetryParameters
	}
	return nil
}

func (m *TaskQueueUpdateQueueRequest) GetMaxConcurrentRequests() int32 {
	if m != nil && m.MaxConcurrentRequests != nil {
		return *m.MaxConcurrentRequests
	}
	return 0
}

func (m *TaskQueueUpdateQueueRequest) GetMode() TaskQueueMode_Mode {
	if m != nil && m.Mode != nil {
		return *m.Mode
	}
	return Default_TaskQueueUpdateQueueRequest_Mode
}

func (m *TaskQueueUpdateQueueRequest) GetAcl() *TaskQueueAcl {
	if m != nil {
		return m.Acl
	}
	return nil
}

func (m *TaskQueueUpdateQueueRequest) GetHeaderOverride() []*TaskQueueHttpHeader {
	if m != nil {
		return m.HeaderOverride
	}
	return nil
}

type TaskQueueUpdateQueueResponse struct {
	XXX_unrecognized []byte `json:"-"`
}

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

type TaskQueueFetchQueuesRequest struct {
	AppId            []byte `protobuf:"bytes,1,opt,name=app_id,json=appId" json:"app_id,omitempty"`
	MaxRows          *int32 `protobuf:"varint,2,req,name=max_rows,json=maxRows" json:"max_rows,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *TaskQueueFetchQueuesRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueueFetchQueuesRequest) GetMaxRows() int32 {
	if m != nil && m.MaxRows != nil {
		return *m.MaxRows
	}
	return 0
}

type TaskQueueFetchQueuesResponse struct {
	Queue            []*TaskQueueFetchQueuesResponse_Queue `protobuf:"group,1,rep,name=Queue,json=queue" json:"queue,omitempty"`
	XXX_unrecognized []byte                                `json:"-"`
}

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

func (m *TaskQueueFetchQueuesResponse) GetQueue() []*TaskQueueFetchQueuesResponse_Queue {
	if m != nil {
		return m.Queue
	}
	return nil
}

type TaskQueueFetchQueuesResponse_Queue struct {
	QueueName             []byte                    `protobuf:"bytes,2,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	BucketRefillPerSecond *float64                  `protobuf:"fixed64,3,req,name=bucket_refill_per_second,json=bucketRefillPerSecond" json:"bucket_refill_per_second,omitempty"`
	BucketCapacity        *float64                  `protobuf:"fixed64,4,req,name=bucket_capacity,json=bucketCapacity" json:"bucket_capacity,omitempty"`
	UserSpecifiedRate     *string                   `protobuf:"bytes,5,opt,name=user_specified_rate,json=userSpecifiedRate" json:"user_specified_rate,omitempty"`
	Paused                *bool                     `protobuf:"varint,6,req,name=paused,def=0" json:"paused,omitempty"`
	RetryParameters       *TaskQueueRetryParameters `protobuf:"bytes,7,opt,name=retry_parameters,json=retryParameters" json:"retry_parameters,omitempty"`
	MaxConcurrentRequests *int32                    `protobuf:"varint,8,opt,name=max_concurrent_requests,json=maxConcurrentRequests" json:"max_concurrent_requests,omitempty"`
	Mode                  *TaskQueueMode_Mode       `protobuf:"varint,9,opt,name=mode,enum=appengine.TaskQueueMode_Mode,def=0" json:"mode,omitempty"`
	Acl                   *TaskQueueAcl             `protobuf:"bytes,10,opt,name=acl" json:"acl,omitempty"`
	HeaderOverride        []*TaskQueueHttpHeader    `protobuf:"bytes,11,rep,name=header_override,json=headerOverride" json:"header_override,omitempty"`
	CreatorName           *string                   `protobuf:"bytes,12,opt,name=creator_name,json=creatorName,def=apphosting" json:"creator_name,omitempty"`
	XXX_unrecognized      []byte                    `json:"-"`
}

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

const Default_TaskQueueFetchQueuesResponse_Queue_Paused bool = false
const Default_TaskQueueFetchQueuesResponse_Queue_Mode TaskQueueMode_Mode = TaskQueueMode_PUSH
const Default_TaskQueueFetchQueuesResponse_Queue_CreatorName string = "apphosting"

func (m *TaskQueueFetchQueuesResponse_Queue) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueueFetchQueuesResponse_Queue) GetBucketRefillPerSecond() float64 {
	if m != nil && m.BucketRefillPerSecond != nil {
		return *m.BucketRefillPerSecond
	}
	return 0
}

func (m *TaskQueueFetchQueuesResponse_Queue) GetBucketCapacity() float64 {
	if m != nil && m.BucketCapacity != nil {
		return *m.BucketCapacity
	}
	return 0
}

func (m *TaskQueueFetchQueuesResponse_Queue) GetUserSpecifiedRate() string {
	if m != nil && m.UserSpecifiedRate != nil {
		return *m.UserSpecifiedRate
	}
	return ""
}

func (m *TaskQueueFetchQueuesResponse_Queue) GetPaused() bool {
	if m != nil && m.Paused != nil {
		return *m.Paused
	}
	return Default_TaskQueueFetchQueuesResponse_Queue_Paused
}

func (m *TaskQueueFetchQueuesResponse_Queue) GetRetryParameters() *TaskQueueRetryParameters {
	if m != nil {
		return m.RetryParameters
	}
	return nil
}

func (m *TaskQueueFetchQueuesResponse_Queue) GetMaxConcurrentRequests() int32 {
	if m != nil && m.MaxConcurrentRequests != nil {
		return *m.MaxConcurrentRequests
	}
	return 0
}

func (m *TaskQueueFetchQueuesResponse_Queue) GetMode() TaskQueueMode_Mode {
	if m != nil && m.Mode != nil {
		return *m.Mode
	}
	return Default_TaskQueueFetchQueuesResponse_Queue_Mode
}

func (m *TaskQueueFetchQueuesResponse_Queue) GetAcl() *TaskQueueAcl {
	if m != nil {
		return m.Acl
	}
	return nil
}

func (m *TaskQueueFetchQueuesResponse_Queue) GetHeaderOverride() []*TaskQueueHttpHeader {
	if m != nil {
		return m.HeaderOverride
	}
	return nil
}

func (m *TaskQueueFetchQueuesResponse_Queue) GetCreatorName() string {
	if m != nil && m.CreatorName != nil {
		return *m.CreatorName
	}
	return Default_TaskQueueFetchQueuesResponse_Queue_CreatorName
}

type TaskQueueFetchQueueStatsRequest struct {
	AppId            []byte   `protobuf:"bytes,1,opt,name=app_id,json=appId" json:"app_id,omitempty"`
	QueueName        [][]byte `protobuf:"bytes,2,rep,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	MaxNumTasks      *int32   `protobuf:"varint,3,opt,name=max_num_tasks,json=maxNumTasks,def=0" json:"max_num_tasks,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

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

const Default_TaskQueueFetchQueueStatsRequest_MaxNumTasks int32 = 0

func (m *TaskQueueFetchQueueStatsRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueueFetchQueueStatsRequest) GetQueueName() [][]byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueueFetchQueueStatsRequest) GetMaxNumTasks() int32 {
	if m != nil && m.MaxNumTasks != nil {
		return *m.MaxNumTasks
	}
	return Default_TaskQueueFetchQueueStatsRequest_MaxNumTasks
}

type TaskQueueScannerQueueInfo struct {
	ExecutedLastMinute      *int64   `protobuf:"varint,1,req,name=executed_last_minute,json=executedLastMinute" json:"executed_last_minute,omitempty"`
	ExecutedLastHour        *int64   `protobuf:"varint,2,req,name=executed_last_hour,json=executedLastHour" json:"executed_last_hour,omitempty"`
	SamplingDurationSeconds *float64 `protobuf:"fixed64,3,req,name=sampling_duration_seconds,json=samplingDurationSeconds" json:"sampling_duration_seconds,omitempty"`
	RequestsInFlight        *int32   `protobuf:"varint,4,opt,name=requests_in_flight,json=requestsInFlight" json:"requests_in_flight,omitempty"`
	EnforcedRate            *float64 `protobuf:"fixed64,5,opt,name=enforced_rate,json=enforcedRate" json:"enforced_rate,omitempty"`
	XXX_unrecognized        []byte   `json:"-"`
}

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

func (m *TaskQueueScannerQueueInfo) GetExecutedLastMinute() int64 {
	if m != nil && m.ExecutedLastMinute != nil {
		return *m.ExecutedLastMinute
	}
	return 0
}

func (m *TaskQueueScannerQueueInfo) GetExecutedLastHour() int64 {
	if m != nil && m.ExecutedLastHour != nil {
		return *m.ExecutedLastHour
	}
	return 0
}

func (m *TaskQueueScannerQueueInfo) GetSamplingDurationSeconds() float64 {
	if m != nil && m.SamplingDurationSeconds != nil {
		return *m.SamplingDurationSeconds
	}
	return 0
}

func (m *TaskQueueScannerQueueInfo) GetRequestsInFlight() int32 {
	if m != nil && m.RequestsInFlight != nil {
		return *m.RequestsInFlight
	}
	return 0
}

func (m *TaskQueueScannerQueueInfo) GetEnforcedRate() float64 {
	if m != nil && m.EnforcedRate != nil {
		return *m.EnforcedRate
	}
	return 0
}

type TaskQueueFetchQueueStatsResponse struct {
	Queuestats       []*TaskQueueFetchQueueStatsResponse_QueueStats `protobuf:"group,1,rep,name=QueueStats,json=queuestats" json:"queuestats,omitempty"`
	XXX_unrecognized []byte                                         `json:"-"`
}

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

func (m *TaskQueueFetchQueueStatsResponse) GetQueuestats() []*TaskQueueFetchQueueStatsResponse_QueueStats {
	if m != nil {
		return m.Queuestats
	}
	return nil
}

type TaskQueueFetchQueueStatsResponse_QueueStats struct {
	NumTasks         *int32                     `protobuf:"varint,2,req,name=num_tasks,json=numTasks" json:"num_tasks,omitempty"`
	OldestEtaUsec    *int64                     `protobuf:"varint,3,req,name=oldest_eta_usec,json=oldestEtaUsec" json:"oldest_eta_usec,omitempty"`
	ScannerInfo      *TaskQueueScannerQueueInfo `protobuf:"bytes,4,opt,name=scanner_info,json=scannerInfo" json:"scanner_info,omitempty"`
	XXX_unrecognized []byte                     `json:"-"`
}

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

func (m *TaskQueueFetchQueueStatsResponse_QueueStats) GetNumTasks() int32 {
	if m != nil && m.NumTasks != nil {
		return *m.NumTasks
	}
	return 0
}

func (m *TaskQueueFetchQueueStatsResponse_QueueStats) GetOldestEtaUsec() int64 {
	if m != nil && m.OldestEtaUsec != nil {
		return *m.OldestEtaUsec
	}
	return 0
}

func (m *TaskQueueFetchQueueStatsResponse_QueueStats) GetScannerInfo() *TaskQueueScannerQueueInfo {
	if m != nil {
		return m.ScannerInfo
	}
	return nil
}

type TaskQueuePauseQueueRequest struct {
	AppId            []byte `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
	QueueName        []byte `protobuf:"bytes,2,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	Pause            *bool  `protobuf:"varint,3,req,name=pause" json:"pause,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *TaskQueuePauseQueueRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueuePauseQueueRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueuePauseQueueRequest) GetPause() bool {
	if m != nil && m.Pause != nil {
		return *m.Pause
	}
	return false
}

type TaskQueuePauseQueueResponse struct {
	XXX_unrecognized []byte `json:"-"`
}

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

type TaskQueuePurgeQueueRequest struct {
	AppId            []byte `protobuf:"bytes,1,opt,name=app_id,json=appId" json:"app_id,omitempty"`
	QueueName        []byte `protobuf:"bytes,2,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *TaskQueuePurgeQueueRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueuePurgeQueueRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

type TaskQueuePurgeQueueResponse struct {
	XXX_unrecognized []byte `json:"-"`
}

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

type TaskQueueDeleteQueueRequest struct {
	AppId            []byte `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
	QueueName        []byte `protobuf:"bytes,2,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *TaskQueueDeleteQueueRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueueDeleteQueueRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

type TaskQueueDeleteQueueResponse struct {
	XXX_unrecognized []byte `json:"-"`
}

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

type TaskQueueDeleteGroupRequest struct {
	AppId            []byte `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *TaskQueueDeleteGroupRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

type TaskQueueDeleteGroupResponse struct {
	XXX_unrecognized []byte `json:"-"`
}

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

type TaskQueueQueryTasksRequest struct {
	AppId            []byte `protobuf:"bytes,1,opt,name=app_id,json=appId" json:"app_id,omitempty"`
	QueueName        []byte `protobuf:"bytes,2,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	StartTaskName    []byte `protobuf:"bytes,3,opt,name=start_task_name,json=startTaskName" json:"start_task_name,omitempty"`
	StartEtaUsec     *int64 `protobuf:"varint,4,opt,name=start_eta_usec,json=startEtaUsec" json:"start_eta_usec,omitempty"`
	StartTag         []byte `protobuf:"bytes,6,opt,name=start_tag,json=startTag" json:"start_tag,omitempty"`
	MaxRows          *int32 `protobuf:"varint,5,opt,name=max_rows,json=maxRows,def=1" json:"max_rows,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

const Default_TaskQueueQueryTasksRequest_MaxRows int32 = 1

func (m *TaskQueueQueryTasksRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueueQueryTasksRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueueQueryTasksRequest) GetStartTaskName() []byte {
	if m != nil {
		return m.StartTaskName
	}
	return nil
}

func (m *TaskQueueQueryTasksRequest) GetStartEtaUsec() int64 {
	if m != nil && m.StartEtaUsec != nil {
		return *m.StartEtaUsec
	}
	return 0
}

func (m *TaskQueueQueryTasksRequest) GetStartTag() []byte {
	if m != nil {
		return m.StartTag
	}
	return nil
}

func (m *TaskQueueQueryTasksRequest) GetMaxRows() int32 {
	if m != nil && m.MaxRows != nil {
		return *m.MaxRows
	}
	return Default_TaskQueueQueryTasksRequest_MaxRows
}

type TaskQueueQueryTasksResponse struct {
	Task             []*TaskQueueQueryTasksResponse_Task `protobuf:"group,1,rep,name=Task,json=task" json:"task,omitempty"`
	XXX_unrecognized []byte                              `json:"-"`
}

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

func (m *TaskQueueQueryTasksResponse) GetTask() []*TaskQueueQueryTasksResponse_Task {
	if m != nil {
		return m.Task
	}
	return nil
}

type TaskQueueQueryTasksResponse_Task struct {
	TaskName         []byte                                          `protobuf:"bytes,2,req,name=task_name,json=taskName" json:"task_name,omitempty"`
	EtaUsec          *int64                                          `protobuf:"varint,3,req,name=eta_usec,json=etaUsec" json:"eta_usec,omitempty"`
	Url              []byte                                          `protobuf:"bytes,4,opt,name=url" json:"url,omitempty"`
	Method           *TaskQueueQueryTasksResponse_Task_RequestMethod `protobuf:"varint,5,opt,name=method,enum=appengine.TaskQueueQueryTasksResponse_Task_RequestMethod" json:"method,omitempty"`
	RetryCount       *int32                                          `protobuf:"varint,6,opt,name=retry_count,json=retryCount,def=0" json:"retry_count,omitempty"`
	Header           []*TaskQueueQueryTasksResponse_Task_Header      `protobuf:"group,7,rep,name=Header,json=header" json:"header,omitempty"`
	BodySize         *int32                                          `protobuf:"varint,10,opt,name=body_size,json=bodySize" json:"body_size,omitempty"`
	Body             []byte                                          `protobuf:"bytes,11,opt,name=body" json:"body,omitempty"`
	CreationTimeUsec *int64                                          `protobuf:"varint,12,req,name=creation_time_usec,json=creationTimeUsec" json:"creation_time_usec,omitempty"`
	Crontimetable    *TaskQueueQueryTasksResponse_Task_CronTimetable `protobuf:"group,13,opt,name=CronTimetable,json=crontimetable" json:"crontimetable,omitempty"`
	Runlog           *TaskQueueQueryTasksResponse_Task_RunLog        `protobuf:"group,16,opt,name=RunLog,json=runlog" json:"runlog,omitempty"`
	Description      []byte                                          `protobuf:"bytes,21,opt,name=description" json:"description,omitempty"`
	Payload          *TaskPayload                                    `protobuf:"bytes,22,opt,name=payload" json:"payload,omitempty"`
	RetryParameters  *TaskQueueRetryParameters                       `protobuf:"bytes,23,opt,name=retry_parameters,json=retryParameters" json:"retry_parameters,omitempty"`
	FirstTryUsec     *int64                                          `protobuf:"varint,24,opt,name=first_try_usec,json=firstTryUsec" json:"first_try_usec,omitempty"`
	Tag              []byte                                          `protobuf:"bytes,25,opt,name=tag" json:"tag,omitempty"`
	ExecutionCount   *int32                                          `protobuf:"varint,26,opt,name=execution_count,json=executionCount,def=0" json:"execution_count,omitempty"`
	XXX_unrecognized []byte                                          `json:"-"`
}

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

const Default_TaskQueueQueryTasksResponse_Task_RetryCount int32 = 0
const Default_TaskQueueQueryTasksResponse_Task_ExecutionCount int32 = 0

func (m *TaskQueueQueryTasksResponse_Task) GetTaskName() []byte {
	if m != nil {
		return m.TaskName
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task) GetEtaUsec() int64 {
	if m != nil && m.EtaUsec != nil {
		return *m.EtaUsec
	}
	return 0
}

func (m *TaskQueueQueryTasksResponse_Task) GetUrl() []byte {
	if m != nil {
		return m.Url
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task) GetMethod() TaskQueueQueryTasksResponse_Task_RequestMethod {
	if m != nil && m.Method != nil {
		return *m.Method
	}
	return TaskQueueQueryTasksResponse_Task_GET
}

func (m *TaskQueueQueryTasksResponse_Task) GetRetryCount() int32 {
	if m != nil && m.RetryCount != nil {
		return *m.RetryCount
	}
	return Default_TaskQueueQueryTasksResponse_Task_RetryCount
}

func (m *TaskQueueQueryTasksResponse_Task) GetHeader() []*TaskQueueQueryTasksResponse_Task_Header {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task) GetBodySize() int32 {
	if m != nil && m.BodySize != nil {
		return *m.BodySize
	}
	return 0
}

func (m *TaskQueueQueryTasksResponse_Task) GetBody() []byte {
	if m != nil {
		return m.Body
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task) GetCreationTimeUsec() int64 {
	if m != nil && m.CreationTimeUsec != nil {
		return *m.CreationTimeUsec
	}
	return 0
}

func (m *TaskQueueQueryTasksResponse_Task) GetCrontimetable() *TaskQueueQueryTasksResponse_Task_CronTimetable {
	if m != nil {
		return m.Crontimetable
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task) GetRunlog() *TaskQueueQueryTasksResponse_Task_RunLog {
	if m != nil {
		return m.Runlog
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task) GetDescription() []byte {
	if m != nil {
		return m.Description
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task) GetPayload() *TaskPayload {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task) GetRetryParameters() *TaskQueueRetryParameters {
	if m != nil {
		return m.RetryParameters
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task) GetFirstTryUsec() int64 {
	if m != nil && m.FirstTryUsec != nil {
		return *m.FirstTryUsec
	}
	return 0
}

func (m *TaskQueueQueryTasksResponse_Task) GetTag() []byte {
	if m != nil {
		return m.Tag
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task) GetExecutionCount() int32 {
	if m != nil && m.ExecutionCount != nil {
		return *m.ExecutionCount
	}
	return Default_TaskQueueQueryTasksResponse_Task_ExecutionCount
}

type TaskQueueQueryTasksResponse_Task_Header struct {
	Key              []byte `protobuf:"bytes,8,req,name=key" json:"key,omitempty"`
	Value            []byte `protobuf:"bytes,9,req,name=value" json:"value,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *TaskQueueQueryTasksResponse_Task_Header) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task_Header) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

type TaskQueueQueryTasksResponse_Task_CronTimetable struct {
	Schedule         []byte `protobuf:"bytes,14,req,name=schedule" json:"schedule,omitempty"`
	Timezone         []byte `protobuf:"bytes,15,req,name=timezone" json:"timezone,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *TaskQueueQueryTasksResponse_Task_CronTimetable) GetSchedule() []byte {
	if m != nil {
		return m.Schedule
	}
	return nil
}

func (m *TaskQueueQueryTasksResponse_Task_CronTimetable) GetTimezone() []byte {
	if m != nil {
		return m.Timezone
	}
	return nil
}

type TaskQueueQueryTasksResponse_Task_RunLog struct {
	DispatchedUsec   *int64  `protobuf:"varint,17,req,name=dispatched_usec,json=dispatchedUsec" json:"dispatched_usec,omitempty"`
	LagUsec          *int64  `protobuf:"varint,18,req,name=lag_usec,json=lagUsec" json:"lag_usec,omitempty"`
	ElapsedUsec      *int64  `protobuf:"varint,19,req,name=elapsed_usec,json=elapsedUsec" json:"elapsed_usec,omitempty"`
	ResponseCode     *int64  `protobuf:"varint,20,opt,name=response_code,json=responseCode" json:"response_code,omitempty"`
	RetryReason      *string `protobuf:"bytes,27,opt,name=retry_reason,json=retryReason" json:"retry_reason,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *TaskQueueQueryTasksResponse_Task_RunLog) GetDispatchedUsec() int64 {
	if m != nil && m.DispatchedUsec != nil {
		return *m.DispatchedUsec
	}
	return 0
}

func (m *TaskQueueQueryTasksResponse_Task_RunLog) GetLagUsec() int64 {
	if m != nil && m.LagUsec != nil {
		return *m.LagUsec
	}
	return 0
}

func (m *TaskQueueQueryTasksResponse_Task_RunLog) GetElapsedUsec() int64 {
	if m != nil && m.ElapsedUsec != nil {
		return *m.ElapsedUsec
	}
	return 0
}

func (m *TaskQueueQueryTasksResponse_Task_RunLog) GetResponseCode() int64 {
	if m != nil && m.ResponseCode != nil {
		return *m.ResponseCode
	}
	return 0
}

func (m *TaskQueueQueryTasksResponse_Task_RunLog) GetRetryReason() string {
	if m != nil && m.RetryReason != nil {
		return *m.RetryReason
	}
	return ""
}

type TaskQueueFetchTaskRequest struct {
	AppId            []byte `protobuf:"bytes,1,opt,name=app_id,json=appId" json:"app_id,omitempty"`
	QueueName        []byte `protobuf:"bytes,2,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	TaskName         []byte `protobuf:"bytes,3,req,name=task_name,json=taskName" json:"task_name,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *TaskQueueFetchTaskRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

func (m *TaskQueueFetchTaskRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueueFetchTaskRequest) GetTaskName() []byte {
	if m != nil {
		return m.TaskName
	}
	return nil
}

type TaskQueueFetchTaskResponse struct {
	Task             *TaskQueueQueryTasksResponse `protobuf:"bytes,1,req,name=task" json:"task,omitempty"`
	XXX_unrecognized []byte                       `json:"-"`
}

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

func (m *TaskQueueFetchTaskResponse) GetTask() *TaskQueueQueryTasksResponse {
	if m != nil {
		return m.Task
	}
	return nil
}

type TaskQueueUpdateStorageLimitRequest struct {
	AppId            []byte `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
	Limit            *int64 `protobuf:"varint,2,req,name=limit" json:"limit,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *TaskQueueUpdateStorageLimitRequest) GetAppId() []byte {
	if m != nil {
		return m.AppId
	}
	return nil
}

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

type TaskQueueUpdateStorageLimitResponse struct {
	NewLimit         *int64 `protobuf:"varint,1,req,name=new_limit,json=newLimit" json:"new_limit,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *TaskQueueUpdateStorageLimitResponse) GetNewLimit() int64 {
	if m != nil && m.NewLimit != nil {
		return *m.NewLimit
	}
	return 0
}

type TaskQueueQueryAndOwnTasksRequest struct {
	QueueName        []byte   `protobuf:"bytes,1,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	LeaseSeconds     *float64 `protobuf:"fixed64,2,req,name=lease_seconds,json=leaseSeconds" json:"lease_seconds,omitempty"`
	MaxTasks         *int64   `protobuf:"varint,3,req,name=max_tasks,json=maxTasks" json:"max_tasks,omitempty"`
	GroupByTag       *bool    `protobuf:"varint,4,opt,name=group_by_tag,json=groupByTag,def=0" json:"group_by_tag,omitempty"`
	Tag              []byte   `protobuf:"bytes,5,opt,name=tag" json:"tag,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

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

const Default_TaskQueueQueryAndOwnTasksRequest_GroupByTag bool = false

func (m *TaskQueueQueryAndOwnTasksRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueueQueryAndOwnTasksRequest) GetLeaseSeconds() float64 {
	if m != nil && m.LeaseSeconds != nil {
		return *m.LeaseSeconds
	}
	return 0
}

func (m *TaskQueueQueryAndOwnTasksRequest) GetMaxTasks() int64 {
	if m != nil && m.MaxTasks != nil {
		return *m.MaxTasks
	}
	return 0
}

func (m *TaskQueueQueryAndOwnTasksRequest) GetGroupByTag() bool {
	if m != nil && m.GroupByTag != nil {
		return *m.GroupByTag
	}
	return Default_TaskQueueQueryAndOwnTasksRequest_GroupByTag
}

func (m *TaskQueueQueryAndOwnTasksRequest) GetTag() []byte {
	if m != nil {
		return m.Tag
	}
	return nil
}

type TaskQueueQueryAndOwnTasksResponse struct {
	Task             []*TaskQueueQueryAndOwnTasksResponse_Task `protobuf:"group,1,rep,name=Task,json=task" json:"task,omitempty"`
	XXX_unrecognized []byte                                    `json:"-"`
}

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

func (m *TaskQueueQueryAndOwnTasksResponse) GetTask() []*TaskQueueQueryAndOwnTasksResponse_Task {
	if m != nil {
		return m.Task
	}
	return nil
}

type TaskQueueQueryAndOwnTasksResponse_Task struct {
	TaskName         []byte `protobuf:"bytes,2,req,name=task_name,json=taskName" json:"task_name,omitempty"`
	EtaUsec          *int64 `protobuf:"varint,3,req,name=eta_usec,json=etaUsec" json:"eta_usec,omitempty"`
	RetryCount       *int32 `protobuf:"varint,4,opt,name=retry_count,json=retryCount,def=0" json:"retry_count,omitempty"`
	Body             []byte `protobuf:"bytes,5,opt,name=body" json:"body,omitempty"`
	Tag              []byte `protobuf:"bytes,6,opt,name=tag" json:"tag,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

const Default_TaskQueueQueryAndOwnTasksResponse_Task_RetryCount int32 = 0

func (m *TaskQueueQueryAndOwnTasksResponse_Task) GetTaskName() []byte {
	if m != nil {
		return m.TaskName
	}
	return nil
}

func (m *TaskQueueQueryAndOwnTasksResponse_Task) GetEtaUsec() int64 {
	if m != nil && m.EtaUsec != nil {
		return *m.EtaUsec
	}
	return 0
}

func (m *TaskQueueQueryAndOwnTasksResponse_Task) GetRetryCount() int32 {
	if m != nil && m.RetryCount != nil {
		return *m.RetryCount
	}
	return Default_TaskQueueQueryAndOwnTasksResponse_Task_RetryCount
}

func (m *TaskQueueQueryAndOwnTasksResponse_Task) GetBody() []byte {
	if m != nil {
		return m.Body
	}
	return nil
}

func (m *TaskQueueQueryAndOwnTasksResponse_Task) GetTag() []byte {
	if m != nil {
		return m.Tag
	}
	return nil
}

type TaskQueueModifyTaskLeaseRequest struct {
	QueueName        []byte   `protobuf:"bytes,1,req,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	TaskName         []byte   `protobuf:"bytes,2,req,name=task_name,json=taskName" json:"task_name,omitempty"`
	EtaUsec          *int64   `protobuf:"varint,3,req,name=eta_usec,json=etaUsec" json:"eta_usec,omitempty"`
	LeaseSeconds     *float64 `protobuf:"fixed64,4,req,name=lease_seconds,json=leaseSeconds" json:"lease_seconds,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

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

func (m *TaskQueueModifyTaskLeaseRequest) GetQueueName() []byte {
	if m != nil {
		return m.QueueName
	}
	return nil
}

func (m *TaskQueueModifyTaskLeaseRequest) GetTaskName() []byte {
	if m != nil {
		return m.TaskName
	}
	return nil
}

func (m *TaskQueueModifyTaskLeaseRequest) GetEtaUsec() int64 {
	if m != nil && m.EtaUsec != nil {
		return *m.EtaUsec
	}
	return 0
}

func (m *TaskQueueModifyTaskLeaseRequest) GetLeaseSeconds() float64 {
	if m != nil && m.LeaseSeconds != nil {
		return *m.LeaseSeconds
	}
	return 0
}

type TaskQueueModifyTaskLeaseResponse struct {
	UpdatedEtaUsec   *int64 `protobuf:"varint,1,req,name=updated_eta_usec,json=updatedEtaUsec" json:"updated_eta_usec,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *TaskQueueModifyTaskLeaseResponse) GetUpdatedEtaUsec() int64 {
	if m != nil && m.UpdatedEtaUsec != nil {
		return *m.UpdatedEtaUsec
	}
	return 0
}

func init() {
	proto.RegisterType((*TaskQueueServiceError)(nil), "appengine.TaskQueueServiceError")
	proto.RegisterType((*TaskPayload)(nil), "appengine.TaskPayload")
	proto.RegisterType((*TaskQueueRetryParameters)(nil), "appengine.TaskQueueRetryParameters")
	proto.RegisterType((*TaskQueueAcl)(nil), "appengine.TaskQueueAcl")
	proto.RegisterType((*TaskQueueHttpHeader)(nil), "appengine.TaskQueueHttpHeader")
	proto.RegisterType((*TaskQueueMode)(nil), "appengine.TaskQueueMode")
	proto.RegisterType((*TaskQueueAddRequest)(nil), "appengine.TaskQueueAddRequest")
	proto.RegisterType((*TaskQueueAddRequest_Header)(nil), "appengine.TaskQueueAddRequest.Header")
	proto.RegisterType((*TaskQueueAddRequest_CronTimetable)(nil), "appengine.TaskQueueAddRequest.CronTimetable")
	proto.RegisterType((*TaskQueueAddResponse)(nil), "appengine.TaskQueueAddResponse")
	proto.RegisterType((*TaskQueueBulkAddRequest)(nil), "appengine.TaskQueueBulkAddRequest")
	proto.RegisterType((*TaskQueueBulkAddResponse)(nil), "appengine.TaskQueueBulkAddResponse")
	proto.RegisterType((*TaskQueueBulkAddResponse_TaskResult)(nil), "appengine.TaskQueueBulkAddResponse.TaskResult")
	proto.RegisterType((*TaskQueueDeleteRequest)(nil), "appengine.TaskQueueDeleteRequest")
	proto.RegisterType((*TaskQueueDeleteResponse)(nil), "appengine.TaskQueueDeleteResponse")
	proto.RegisterType((*TaskQueueForceRunRequest)(nil), "appengine.TaskQueueForceRunRequest")
	proto.RegisterType((*TaskQueueForceRunResponse)(nil), "appengine.TaskQueueForceRunResponse")
	proto.RegisterType((*TaskQueueUpdateQueueRequest)(nil), "appengine.TaskQueueUpdateQueueRequest")
	proto.RegisterType((*TaskQueueUpdateQueueResponse)(nil), "appengine.TaskQueueUpdateQueueResponse")
	proto.RegisterType((*TaskQueueFetchQueuesRequest)(nil), "appengine.TaskQueueFetchQueuesRequest")
	proto.RegisterType((*TaskQueueFetchQueuesResponse)(nil), "appengine.TaskQueueFetchQueuesResponse")
	proto.RegisterType((*TaskQueueFetchQueuesResponse_Queue)(nil), "appengine.TaskQueueFetchQueuesResponse.Queue")
	proto.RegisterType((*TaskQueueFetchQueueStatsRequest)(nil), "appengine.TaskQueueFetchQueueStatsRequest")
	proto.RegisterType((*TaskQueueScannerQueueInfo)(nil), "appengine.TaskQueueScannerQueueInfo")
	proto.RegisterType((*TaskQueueFetchQueueStatsResponse)(nil), "appengine.TaskQueueFetchQueueStatsResponse")
	proto.RegisterType((*TaskQueueFetchQueueStatsResponse_QueueStats)(nil), "appengine.TaskQueueFetchQueueStatsResponse.QueueStats")
	proto.RegisterType((*TaskQueuePauseQueueRequest)(nil), "appengine.TaskQueuePauseQueueRequest")
	proto.RegisterType((*TaskQueuePauseQueueResponse)(nil), "appengine.TaskQueuePauseQueueResponse")
	proto.RegisterType((*TaskQueuePurgeQueueRequest)(nil), "appengine.TaskQueuePurgeQueueRequest")
	proto.RegisterType((*TaskQueuePurgeQueueResponse)(nil), "appengine.TaskQueuePurgeQueueResponse")
	proto.RegisterType((*TaskQueueDeleteQueueRequest)(nil), "appengine.TaskQueueDeleteQueueRequest")
	proto.RegisterType((*TaskQueueDeleteQueueResponse)(nil), "appengine.TaskQueueDeleteQueueResponse")
	proto.RegisterType((*TaskQueueDeleteGroupRequest)(nil), "appengine.TaskQueueDeleteGroupRequest")
	proto.RegisterType((*TaskQueueDeleteGroupResponse)(nil), "appengine.TaskQueueDeleteGroupResponse")
	proto.RegisterType((*TaskQueueQueryTasksRequest)(nil), "appengine.TaskQueueQueryTasksRequest")
	proto.RegisterType((*TaskQueueQueryTasksResponse)(nil), "appengine.TaskQueueQueryTasksResponse")
	proto.RegisterType((*TaskQueueQueryTasksResponse_Task)(nil), "appengine.TaskQueueQueryTasksResponse.Task")
	proto.RegisterType((*TaskQueueQueryTasksResponse_Task_Header)(nil), "appengine.TaskQueueQueryTasksResponse.Task.Header")
	proto.RegisterType((*TaskQueueQueryTasksResponse_Task_CronTimetable)(nil), "appengine.TaskQueueQueryTasksResponse.Task.CronTimetable")
	proto.RegisterType((*TaskQueueQueryTasksResponse_Task_RunLog)(nil), "appengine.TaskQueueQueryTasksResponse.Task.RunLog")
	proto.RegisterType((*TaskQueueFetchTaskRequest)(nil), "appengine.TaskQueueFetchTaskRequest")
	proto.RegisterType((*TaskQueueFetchTaskResponse)(nil), "appengine.TaskQueueFetchTaskResponse")
	proto.RegisterType((*TaskQueueUpdateStorageLimitRequest)(nil), "appengine.TaskQueueUpdateStorageLimitRequest")
	proto.RegisterType((*TaskQueueUpdateStorageLimitResponse)(nil), "appengine.TaskQueueUpdateStorageLimitResponse")
	proto.RegisterType((*TaskQueueQueryAndOwnTasksRequest)(nil), "appengine.TaskQueueQueryAndOwnTasksRequest")
	proto.RegisterType((*TaskQueueQueryAndOwnTasksResponse)(nil), "appengine.TaskQueueQueryAndOwnTasksResponse")
	proto.RegisterType((*TaskQueueQueryAndOwnTasksResponse_Task)(nil), "appengine.TaskQueueQueryAndOwnTasksResponse.Task")
	proto.RegisterType((*TaskQueueModifyTaskLeaseRequest)(nil), "appengine.TaskQueueModifyTaskLeaseRequest")
	proto.RegisterType((*TaskQueueModifyTaskLeaseResponse)(nil), "appengine.TaskQueueModifyTaskLeaseResponse")
}

func init() {
	proto.RegisterFile("google.golang.org/appengine/internal/taskqueue/taskqueue_service.proto", fileDescriptor0)
}

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