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

package mako

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type RunOrder int32

const (
	RunOrder_UNSPECIFIED RunOrder = 0
	RunOrder_TIMESTAMP   RunOrder = 1
	RunOrder_BUILD_ID    RunOrder = 2
)

var RunOrder_name = map[int32]string{
	0: "UNSPECIFIED",
	1: "TIMESTAMP",
	2: "BUILD_ID",
}

var RunOrder_value = map[string]int32{
	"UNSPECIFIED": 0,
	"TIMESTAMP":   1,
	"BUILD_ID":    2,
}

func (x RunOrder) Enum() *RunOrder {
	p := new(RunOrder)
	*p = x
	return p
}

func (x RunOrder) String() string {
	return proto.EnumName(RunOrder_name, int32(x))
}

func (x *RunOrder) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(RunOrder_value, data, "RunOrder")
	if err != nil {
		return err
	}
	*x = RunOrder(value)
	return nil
}

func (RunOrder) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b174f87a83ddb952, []int{0}
}

type Status_Code int32

const (
	Status_SUCCESS Status_Code = 0
	Status_FAIL    Status_Code = 1
)

var Status_Code_name = map[int32]string{
	0: "SUCCESS",
	1: "FAIL",
}

var Status_Code_value = map[string]int32{
	"SUCCESS": 0,
	"FAIL":    1,
}

func (x Status_Code) Enum() *Status_Code {
	p := new(Status_Code)
	*p = x
	return p
}

func (x Status_Code) String() string {
	return proto.EnumName(Status_Code_name, int32(x))
}

func (x *Status_Code) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(Status_Code_value, data, "Status_Code")
	if err != nil {
		return err
	}
	*x = Status_Code(value)
	return nil
}

func (Status_Code) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b174f87a83ddb952, []int{0, 0}
}

type ValueInfo_Type int32

const (
	ValueInfo_NUMERIC   ValueInfo_Type = 1
	ValueInfo_TIMESTAMP ValueInfo_Type = 2
)

var ValueInfo_Type_name = map[int32]string{
	1: "NUMERIC",
	2: "TIMESTAMP",
}

var ValueInfo_Type_value = map[string]int32{
	"NUMERIC":   1,
	"TIMESTAMP": 2,
}

func (x ValueInfo_Type) Enum() *ValueInfo_Type {
	p := new(ValueInfo_Type)
	*p = x
	return p
}

func (x ValueInfo_Type) String() string {
	return proto.EnumName(ValueInfo_Type_name, int32(x))
}

func (x *ValueInfo_Type) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ValueInfo_Type_value, data, "ValueInfo_Type")
	if err != nil {
		return err
	}
	*x = ValueInfo_Type(value)
	return nil
}

func (ValueInfo_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b174f87a83ddb952, []int{1, 0}
}

type DataFilter_DataType int32

const (
	DataFilter_METRIC_AGGREGATE_COUNT      DataFilter_DataType = 11
	DataFilter_METRIC_AGGREGATE_MIN        DataFilter_DataType = 1
	DataFilter_METRIC_AGGREGATE_MAX        DataFilter_DataType = 2
	DataFilter_METRIC_AGGREGATE_MEAN       DataFilter_DataType = 3
	DataFilter_METRIC_AGGREGATE_MEDIAN     DataFilter_DataType = 4
	DataFilter_METRIC_AGGREGATE_STDDEV     DataFilter_DataType = 5
	DataFilter_METRIC_AGGREGATE_MAD        DataFilter_DataType = 12
	DataFilter_METRIC_AGGREGATE_PERCENTILE DataFilter_DataType = 6
	DataFilter_CUSTOM_AGGREGATE            DataFilter_DataType = 7
	DataFilter_METRIC_SAMPLEPOINTS         DataFilter_DataType = 8
	DataFilter_BENCHMARK_SCORE             DataFilter_DataType = 9
	DataFilter_ERROR_COUNT                 DataFilter_DataType = 10
)

var DataFilter_DataType_name = map[int32]string{
	11: "METRIC_AGGREGATE_COUNT",
	1:  "METRIC_AGGREGATE_MIN",
	2:  "METRIC_AGGREGATE_MAX",
	3:  "METRIC_AGGREGATE_MEAN",
	4:  "METRIC_AGGREGATE_MEDIAN",
	5:  "METRIC_AGGREGATE_STDDEV",
	12: "METRIC_AGGREGATE_MAD",
	6:  "METRIC_AGGREGATE_PERCENTILE",
	7:  "CUSTOM_AGGREGATE",
	8:  "METRIC_SAMPLEPOINTS",
	9:  "BENCHMARK_SCORE",
	10: "ERROR_COUNT",
}

var DataFilter_DataType_value = map[string]int32{
	"METRIC_AGGREGATE_COUNT":      11,
	"METRIC_AGGREGATE_MIN":        1,
	"METRIC_AGGREGATE_MAX":        2,
	"METRIC_AGGREGATE_MEAN":       3,
	"METRIC_AGGREGATE_MEDIAN":     4,
	"METRIC_AGGREGATE_STDDEV":     5,
	"METRIC_AGGREGATE_MAD":        12,
	"METRIC_AGGREGATE_PERCENTILE": 6,
	"CUSTOM_AGGREGATE":            7,
	"METRIC_SAMPLEPOINTS":         8,
	"BENCHMARK_SCORE":             9,
	"ERROR_COUNT":                 10,
}

func (x DataFilter_DataType) Enum() *DataFilter_DataType {
	p := new(DataFilter_DataType)
	*p = x
	return p
}

func (x DataFilter_DataType) String() string {
	return proto.EnumName(DataFilter_DataType_name, int32(x))
}

func (x *DataFilter_DataType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(DataFilter_DataType_value, data, "DataFilter_DataType")
	if err != nil {
		return err
	}
	*x = DataFilter_DataType(value)
	return nil
}

func (DataFilter_DataType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b174f87a83ddb952, []int{6, 0}
}

type AnalysisTriageInfo_AnalysisTriageType int32

const (
	AnalysisTriageInfo_NONE           AnalysisTriageInfo_AnalysisTriageType = 0
	AnalysisTriageInfo_REGRESSION     AnalysisTriageInfo_AnalysisTriageType = 1
	AnalysisTriageInfo_IGNORE         AnalysisTriageInfo_AnalysisTriageType = 2
	AnalysisTriageInfo_FALSE_POSITIVE AnalysisTriageInfo_AnalysisTriageType = 3
	AnalysisTriageInfo_UNKNOWN        AnalysisTriageInfo_AnalysisTriageType = 4
)

var AnalysisTriageInfo_AnalysisTriageType_name = map[int32]string{
	0: "NONE",
	1: "REGRESSION",
	2: "IGNORE",
	3: "FALSE_POSITIVE",
	4: "UNKNOWN",
}

var AnalysisTriageInfo_AnalysisTriageType_value = map[string]int32{
	"NONE":           0,
	"REGRESSION":     1,
	"IGNORE":         2,
	"FALSE_POSITIVE": 3,
	"UNKNOWN":        4,
}

func (x AnalysisTriageInfo_AnalysisTriageType) Enum() *AnalysisTriageInfo_AnalysisTriageType {
	p := new(AnalysisTriageInfo_AnalysisTriageType)
	*p = x
	return p
}

func (x AnalysisTriageInfo_AnalysisTriageType) String() string {
	return proto.EnumName(AnalysisTriageInfo_AnalysisTriageType_name, int32(x))
}

func (x *AnalysisTriageInfo_AnalysisTriageType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(AnalysisTriageInfo_AnalysisTriageType_value, data, "AnalysisTriageInfo_AnalysisTriageType")
	if err != nil {
		return err
	}
	*x = AnalysisTriageInfo_AnalysisTriageType(value)
	return nil
}

func (AnalysisTriageInfo_AnalysisTriageType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b174f87a83ddb952, []int{37, 0}
}

type AnalysisTriageInfo_EnvironmentType int32

const (
	AnalysisTriageInfo_UNSPECIFIED AnalysisTriageInfo_EnvironmentType = 0
	AnalysisTriageInfo_PRESUBMIT   AnalysisTriageInfo_EnvironmentType = 1
	AnalysisTriageInfo_POSTSUBMIT  AnalysisTriageInfo_EnvironmentType = 2
	AnalysisTriageInfo_PRODUCTION  AnalysisTriageInfo_EnvironmentType = 3
)

var AnalysisTriageInfo_EnvironmentType_name = map[int32]string{
	0: "UNSPECIFIED",
	1: "PRESUBMIT",
	2: "POSTSUBMIT",
	3: "PRODUCTION",
}

var AnalysisTriageInfo_EnvironmentType_value = map[string]int32{
	"UNSPECIFIED": 0,
	"PRESUBMIT":   1,
	"POSTSUBMIT":  2,
	"PRODUCTION":  3,
}

func (x AnalysisTriageInfo_EnvironmentType) Enum() *AnalysisTriageInfo_EnvironmentType {
	p := new(AnalysisTriageInfo_EnvironmentType)
	*p = x
	return p
}

func (x AnalysisTriageInfo_EnvironmentType) String() string {
	return proto.EnumName(AnalysisTriageInfo_EnvironmentType_name, int32(x))
}

func (x *AnalysisTriageInfo_EnvironmentType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(AnalysisTriageInfo_EnvironmentType_value, data, "AnalysisTriageInfo_EnvironmentType")
	if err != nil {
		return err
	}
	*x = AnalysisTriageInfo_EnvironmentType(value)
	return nil
}

func (AnalysisTriageInfo_EnvironmentType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b174f87a83ddb952, []int{37, 1}
}

type TestOutput_TestStatus int32

const (
	TestOutput_PASS          TestOutput_TestStatus = 1
	TestOutput_RATE_FAIL     TestOutput_TestStatus = 2
	TestOutput_FATAL_FAIL    TestOutput_TestStatus = 3
	TestOutput_ANALYSIS_FAIL TestOutput_TestStatus = 4
	TestOutput_IN_PROGRESS   TestOutput_TestStatus = 5
)

var TestOutput_TestStatus_name = map[int32]string{
	1: "PASS",
	2: "RATE_FAIL",
	3: "FATAL_FAIL",
	4: "ANALYSIS_FAIL",
	5: "IN_PROGRESS",
}

var TestOutput_TestStatus_value = map[string]int32{
	"PASS":          1,
	"RATE_FAIL":     2,
	"FATAL_FAIL":    3,
	"ANALYSIS_FAIL": 4,
	"IN_PROGRESS":   5,
}

func (x TestOutput_TestStatus) Enum() *TestOutput_TestStatus {
	p := new(TestOutput_TestStatus)
	*p = x
	return p
}

func (x TestOutput_TestStatus) String() string {
	return proto.EnumName(TestOutput_TestStatus_name, int32(x))
}

func (x *TestOutput_TestStatus) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(TestOutput_TestStatus_value, data, "TestOutput_TestStatus")
	if err != nil {
		return err
	}
	*x = TestOutput_TestStatus(value)
	return nil
}

func (TestOutput_TestStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b174f87a83ddb952, []int{45, 0}
}

type TestOutput_RetryableFailureType int32

const (
	TestOutput_UNKNOWN_OR_UNSET_TYPE TestOutput_RetryableFailureType = 0
	TestOutput_MASTER_RESTART        TestOutput_RetryableFailureType = 1
	TestOutput_JOB_MANAGER_RESTART   TestOutput_RetryableFailureType = 2
	TestOutput_SAMPLER_RESTART       TestOutput_RetryableFailureType = 3
)

var TestOutput_RetryableFailureType_name = map[int32]string{
	0: "UNKNOWN_OR_UNSET_TYPE",
	1: "MASTER_RESTART",
	2: "JOB_MANAGER_RESTART",
	3: "SAMPLER_RESTART",
}

var TestOutput_RetryableFailureType_value = map[string]int32{
	"UNKNOWN_OR_UNSET_TYPE": 0,
	"MASTER_RESTART":        1,
	"JOB_MANAGER_RESTART":   2,
	"SAMPLER_RESTART":       3,
}

func (x TestOutput_RetryableFailureType) Enum() *TestOutput_RetryableFailureType {
	p := new(TestOutput_RetryableFailureType)
	*p = x
	return p
}

func (x TestOutput_RetryableFailureType) String() string {
	return proto.EnumName(TestOutput_RetryableFailureType_name, int32(x))
}

func (x *TestOutput_RetryableFailureType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(TestOutput_RetryableFailureType_value, data, "TestOutput_RetryableFailureType")
	if err != nil {
		return err
	}
	*x = TestOutput_RetryableFailureType(value)
	return nil
}

func (TestOutput_RetryableFailureType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b174f87a83ddb952, []int{45, 1}
}

type Status struct {
	Code                 *Status_Code `protobuf:"varint,1,opt,name=code,enum=mako.Status_Code" json:"code,omitempty"`
	FailMessage          *string      `protobuf:"bytes,2,opt,name=fail_message,json=failMessage" json:"fail_message,omitempty"`
	Retry                *bool        `protobuf:"varint,3,opt,name=retry,def=0" json:"retry,omitempty"`
	WarningMessages      []string     `protobuf:"bytes,4,rep,name=warning_messages,json=warningMessages" json:"warning_messages,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_Status proto.InternalMessageInfo

const Default_Status_Retry bool = false

func (m *Status) GetCode() Status_Code {
	if m != nil && m.Code != nil {
		return *m.Code
	}
	return Status_SUCCESS
}

func (m *Status) GetFailMessage() string {
	if m != nil && m.FailMessage != nil {
		return *m.FailMessage
	}
	return ""
}

func (m *Status) GetRetry() bool {
	if m != nil && m.Retry != nil {
		return *m.Retry
	}
	return Default_Status_Retry
}

func (m *Status) GetWarningMessages() []string {
	if m != nil {
		return m.WarningMessages
	}
	return nil
}

type ValueInfo struct {
	ValueKey             *string         `protobuf:"bytes,1,opt,name=value_key,json=valueKey" json:"value_key,omitempty"`
	Label                *string         `protobuf:"bytes,2,opt,name=label" json:"label,omitempty"`
	Type                 *ValueInfo_Type `protobuf:"varint,3,opt,name=type,enum=mako.ValueInfo_Type" json:"type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_ValueInfo proto.InternalMessageInfo

func (m *ValueInfo) GetValueKey() string {
	if m != nil && m.ValueKey != nil {
		return *m.ValueKey
	}
	return ""
}

func (m *ValueInfo) GetLabel() string {
	if m != nil && m.Label != nil {
		return *m.Label
	}
	return ""
}

func (m *ValueInfo) GetType() ValueInfo_Type {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return ValueInfo_NUMERIC
}

type KeyedValue struct {
	ValueKey             *string  `protobuf:"bytes,1,opt,name=value_key,json=valueKey" json:"value_key,omitempty"`
	Value                *float64 `protobuf:"fixed64,2,opt,name=value" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_KeyedValue proto.InternalMessageInfo

func (m *KeyedValue) GetValueKey() string {
	if m != nil && m.ValueKey != nil {
		return *m.ValueKey
	}
	return ""
}

func (m *KeyedValue) GetValue() float64 {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return 0
}

type NamedData struct {
	Name                 *string  `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Data                 *string  `protobuf:"bytes,2,opt,name=data" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_NamedData proto.InternalMessageInfo

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

func (m *NamedData) GetData() string {
	if m != nil && m.Data != nil {
		return *m.Data
	}
	return ""
}

type Range struct {
	Start                *float64 `protobuf:"fixed64,1,opt,name=start" json:"start,omitempty"`
	End                  *float64 `protobuf:"fixed64,2,opt,name=end" json:"end,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Range proto.InternalMessageInfo

func (m *Range) GetStart() float64 {
	if m != nil && m.Start != nil {
		return *m.Start
	}
	return 0
}

func (m *Range) GetEnd() float64 {
	if m != nil && m.End != nil {
		return *m.End
	}
	return 0
}

type LabeledRange struct {
	Label                *string  `protobuf:"bytes,1,opt,name=label" json:"label,omitempty"`
	Range                *Range   `protobuf:"bytes,2,opt,name=range" json:"range,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_LabeledRange proto.InternalMessageInfo

func (m *LabeledRange) GetLabel() string {
	if m != nil && m.Label != nil {
		return *m.Label
	}
	return ""
}

func (m *LabeledRange) GetRange() *Range {
	if m != nil {
		return m.Range
	}
	return nil
}

type DataFilter struct {
	DataType             *DataFilter_DataType `protobuf:"varint,1,opt,name=data_type,json=dataType,enum=mako.DataFilter_DataType" json:"data_type,omitempty"`
	ValueKey             *string              `protobuf:"bytes,2,opt,name=value_key,json=valueKey" json:"value_key,omitempty"`
	PercentileMilliRank  *int32               `protobuf:"varint,3,opt,name=percentile_milli_rank,json=percentileMilliRank" json:"percentile_milli_rank,omitempty"`
	IgnoreMissingData    *bool                `protobuf:"varint,4,opt,name=ignore_missing_data,json=ignoreMissingData,def=1" json:"ignore_missing_data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_DataFilter proto.InternalMessageInfo

const Default_DataFilter_IgnoreMissingData bool = true

func (m *DataFilter) GetDataType() DataFilter_DataType {
	if m != nil && m.DataType != nil {
		return *m.DataType
	}
	return DataFilter_METRIC_AGGREGATE_COUNT
}

func (m *DataFilter) GetValueKey() string {
	if m != nil && m.ValueKey != nil {
		return *m.ValueKey
	}
	return ""
}

func (m *DataFilter) GetPercentileMilliRank() int32 {
	if m != nil && m.PercentileMilliRank != nil {
		return *m.PercentileMilliRank
	}
	return 0
}

func (m *DataFilter) GetIgnoreMissingData() bool {
	if m != nil && m.IgnoreMissingData != nil {
		return *m.IgnoreMissingData
	}
	return Default_DataFilter_IgnoreMissingData
}

type RunBundle struct {
	BenchmarkInfo        *BenchmarkInfo `protobuf:"bytes,1,opt,name=benchmark_info,json=benchmarkInfo" json:"benchmark_info,omitempty"`
	RunInfo              *RunInfo       `protobuf:"bytes,2,opt,name=run_info,json=runInfo" json:"run_info,omitempty"`
	BatchList            []*SampleBatch `protobuf:"bytes,3,rep,name=batch_list,json=batchList" json:"batch_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_RunBundle proto.InternalMessageInfo

func (m *RunBundle) GetBenchmarkInfo() *BenchmarkInfo {
	if m != nil {
		return m.BenchmarkInfo
	}
	return nil
}

func (m *RunBundle) GetRunInfo() *RunInfo {
	if m != nil {
		return m.RunInfo
	}
	return nil
}

func (m *RunBundle) GetBatchList() []*SampleBatch {
	if m != nil {
		return m.BatchList
	}
	return nil
}

type BenchmarkInfo struct {
	BenchmarkKey              *string      `protobuf:"bytes,1,opt,name=benchmark_key,json=benchmarkKey" json:"benchmark_key,omitempty"`
	BenchmarkName             *string      `protobuf:"bytes,2,opt,name=benchmark_name,json=benchmarkName" json:"benchmark_name,omitempty"`
	ProjectName               *string      `protobuf:"bytes,3,opt,name=project_name,json=projectName" json:"project_name,omitempty"`
	OwnerList                 []string     `protobuf:"bytes,4,rep,name=owner_list,json=ownerList" json:"owner_list,omitempty"`
	InputValueInfo            *ValueInfo   `protobuf:"bytes,5,opt,name=input_value_info,json=inputValueInfo" json:"input_value_info,omitempty"`
	MetricInfoList            []*ValueInfo `protobuf:"bytes,6,rep,name=metric_info_list,json=metricInfoList" json:"metric_info_list,omitempty"`
	CustomAggregationInfoList []*ValueInfo `protobuf:"bytes,7,rep,name=custom_aggregation_info_list,json=customAggregationInfoList" json:"custom_aggregation_info_list,omitempty"`
	Description               *string      `protobuf:"bytes,8,opt,name=description" json:"description,omitempty"`
	PercentileMilliRankList   []int32      `protobuf:"varint,9,rep,name=percentile_milli_rank_list,json=percentileMilliRankList" json:"percentile_milli_rank_list,omitempty"`
	AuxData                   []*NamedData `protobuf:"bytes,10,rep,name=aux_data,json=auxData" json:"aux_data,omitempty"`
	RetainedRunTag            *string      `protobuf:"bytes,11,opt,name=retained_run_tag,json=retainedRunTag" json:"retained_run_tag,omitempty"`
	BuildIdLabel              *string      `protobuf:"bytes,12,opt,name=build_id_label,json=buildIdLabel,def=Changelist" json:"build_id_label,omitempty"`
	BuildIdUrlFormat          *string      `protobuf:"bytes,13,opt,name=build_id_url_format,json=buildIdUrlFormat,def=http://cl/%d" json:"build_id_url_format,omitempty"`
	XXX_NoUnkeyedLiteral      struct{}     `json:"-"`
	XXX_unrecognized          []byte       `json:"-"`
	XXX_sizecache             int32        `json:"-"`
}

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

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

var xxx_messageInfo_BenchmarkInfo proto.InternalMessageInfo

const Default_BenchmarkInfo_BuildIdLabel string = "Changelist"
const Default_BenchmarkInfo_BuildIdUrlFormat string = "http://cl/%d"

func (m *BenchmarkInfo) GetBenchmarkKey() string {
	if m != nil && m.BenchmarkKey != nil {
		return *m.BenchmarkKey
	}
	return ""
}

func (m *BenchmarkInfo) GetBenchmarkName() string {
	if m != nil && m.BenchmarkName != nil {
		return *m.BenchmarkName
	}
	return ""
}

func (m *BenchmarkInfo) GetProjectName() string {
	if m != nil && m.ProjectName != nil {
		return *m.ProjectName
	}
	return ""
}

func (m *BenchmarkInfo) GetOwnerList() []string {
	if m != nil {
		return m.OwnerList
	}
	return nil
}

func (m *BenchmarkInfo) GetInputValueInfo() *ValueInfo {
	if m != nil {
		return m.InputValueInfo
	}
	return nil
}

func (m *BenchmarkInfo) GetMetricInfoList() []*ValueInfo {
	if m != nil {
		return m.MetricInfoList
	}
	return nil
}

func (m *BenchmarkInfo) GetCustomAggregationInfoList() []*ValueInfo {
	if m != nil {
		return m.CustomAggregationInfoList
	}
	return nil
}

func (m *BenchmarkInfo) GetDescription() string {
	if m != nil && m.Description != nil {
		return *m.Description
	}
	return ""
}

func (m *BenchmarkInfo) GetPercentileMilliRankList() []int32 {
	if m != nil {
		return m.PercentileMilliRankList
	}
	return nil
}

func (m *BenchmarkInfo) GetAuxData() []*NamedData {
	if m != nil {
		return m.AuxData
	}
	return nil
}

func (m *BenchmarkInfo) GetRetainedRunTag() string {
	if m != nil && m.RetainedRunTag != nil {
		return *m.RetainedRunTag
	}
	return ""
}

func (m *BenchmarkInfo) GetBuildIdLabel() string {
	if m != nil && m.BuildIdLabel != nil {
		return *m.BuildIdLabel
	}
	return Default_BenchmarkInfo_BuildIdLabel
}

func (m *BenchmarkInfo) GetBuildIdUrlFormat() string {
	if m != nil && m.BuildIdUrlFormat != nil {
		return *m.BuildIdUrlFormat
	}
	return Default_BenchmarkInfo_BuildIdUrlFormat
}

type RunAnnotation struct {
	ValueKey             *string  `protobuf:"bytes,1,opt,name=value_key,json=valueKey" json:"value_key,omitempty"`
	Label                *string  `protobuf:"bytes,2,opt,name=label" json:"label,omitempty"`
	Description          *string  `protobuf:"bytes,3,opt,name=description" json:"description,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_RunAnnotation proto.InternalMessageInfo

func (m *RunAnnotation) GetValueKey() string {
	if m != nil && m.ValueKey != nil {
		return *m.ValueKey
	}
	return ""
}

func (m *RunAnnotation) GetLabel() string {
	if m != nil && m.Label != nil {
		return *m.Label
	}
	return ""
}

func (m *RunAnnotation) GetDescription() string {
	if m != nil && m.Description != nil {
		return *m.Description
	}
	return ""
}

type RunInfo struct {
	BenchmarkKey         *string          `protobuf:"bytes,1,opt,name=benchmark_key,json=benchmarkKey" json:"benchmark_key,omitempty"`
	RunKey               *string          `protobuf:"bytes,2,opt,name=run_key,json=runKey" json:"run_key,omitempty"`
	TimestampMs          *float64         `protobuf:"fixed64,3,opt,name=timestamp_ms,json=timestampMs" json:"timestamp_ms,omitempty"`
	BuildId              *int64           `protobuf:"varint,18,opt,name=build_id,json=buildId" json:"build_id,omitempty"`
	DurationTimeMs       *float64         `protobuf:"fixed64,4,opt,name=duration_time_ms,json=durationTimeMs,def=0" json:"duration_time_ms,omitempty"`
	Tags                 []string         `protobuf:"bytes,5,rep,name=tags" json:"tags,omitempty"`
	IgnoreRangeList      []*LabeledRange  `protobuf:"bytes,6,rep,name=ignore_range_list,json=ignoreRangeList" json:"ignore_range_list,omitempty"`
	Aggregate            *Aggregate       `protobuf:"bytes,7,opt,name=aggregate" json:"aggregate,omitempty"`
	BatchKeyList         []string         `protobuf:"bytes,8,rep,name=batch_key_list,json=batchKeyList" json:"batch_key_list,omitempty"`
	Description          *string          `protobuf:"bytes,9,opt,name=description" json:"description,omitempty"`
	AnnotationList       []*RunAnnotation `protobuf:"bytes,10,rep,name=annotation_list,json=annotationList" json:"annotation_list,omitempty"`
	HoverText            *string          `protobuf:"bytes,15,opt,name=hover_text,json=hoverText" json:"hover_text,omitempty"`
	TestOutput           *TestOutput      `protobuf:"bytes,12,opt,name=test_output,json=testOutput" json:"test_output,omitempty"`
	HyperlinkList        []*NamedData     `protobuf:"bytes,13,rep,name=hyperlink_list,json=hyperlinkList" json:"hyperlink_list,omitempty"`
	AuxData              []*NamedData     `protobuf:"bytes,16,rep,name=aux_data,json=auxData" json:"aux_data,omitempty"`
	TestPassId           *string          `protobuf:"bytes,17,opt,name=test_pass_id,json=testPassId" json:"test_pass_id,omitempty"`
	TestOptionList       []*TestOption    `protobuf:"bytes,14,rep,name=test_option_list,json=testOptionList" json:"test_option_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

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

var xxx_messageInfo_RunInfo proto.InternalMessageInfo

const Default_RunInfo_DurationTimeMs float64 = 0

func (m *RunInfo) GetBenchmarkKey() string {
	if m != nil && m.BenchmarkKey != nil {
		return *m.BenchmarkKey
	}
	return ""
}

func (m *RunInfo) GetRunKey() string {
	if m != nil && m.RunKey != nil {
		return *m.RunKey
	}
	return ""
}

func (m *RunInfo) GetTimestampMs() float64 {
	if m != nil && m.TimestampMs != nil {
		return *m.TimestampMs
	}
	return 0
}

func (m *RunInfo) GetBuildId() int64 {
	if m != nil && m.BuildId != nil {
		return *m.BuildId
	}
	return 0
}

func (m *RunInfo) GetDurationTimeMs() float64 {
	if m != nil && m.DurationTimeMs != nil {
		return *m.DurationTimeMs
	}
	return Default_RunInfo_DurationTimeMs
}

func (m *RunInfo) GetTags() []string {
	if m != nil {
		return m.Tags
	}
	return nil
}

func (m *RunInfo) GetIgnoreRangeList() []*LabeledRange {
	if m != nil {
		return m.IgnoreRangeList
	}
	return nil
}

func (m *RunInfo) GetAggregate() *Aggregate {
	if m != nil {
		return m.Aggregate
	}
	return nil
}

func (m *RunInfo) GetBatchKeyList() []string {
	if m != nil {
		return m.BatchKeyList
	}
	return nil
}

func (m *RunInfo) GetDescription() string {
	if m != nil && m.Description != nil {
		return *m.Description
	}
	return ""
}

func (m *RunInfo) GetAnnotationList() []*RunAnnotation {
	if m != nil {
		return m.AnnotationList
	}
	return nil
}

func (m *RunInfo) GetHoverText() string {
	if m != nil && m.HoverText != nil {
		return *m.HoverText
	}
	return ""
}

func (m *RunInfo) GetTestOutput() *TestOutput {
	if m != nil {
		return m.TestOutput
	}
	return nil
}

func (m *RunInfo) GetHyperlinkList() []*NamedData {
	if m != nil {
		return m.HyperlinkList
	}
	return nil
}

func (m *RunInfo) GetAuxData() []*NamedData {
	if m != nil {
		return m.AuxData
	}
	return nil
}

func (m *RunInfo) GetTestPassId() string {
	if m != nil && m.TestPassId != nil {
		return *m.TestPassId
	}
	return ""
}

func (m *RunInfo) GetTestOptionList() []*TestOption {
	if m != nil {
		return m.TestOptionList
	}
	return nil
}

type SamplePoint struct {
	InputValue            *float64            `protobuf:"fixed64,1,opt,name=input_value,json=inputValue" json:"input_value,omitempty"`
	MetricValueList       []*KeyedValue       `protobuf:"bytes,2,rep,name=metric_value_list,json=metricValueList" json:"metric_value_list,omitempty"`
	SampleAnnotationsList []*SampleAnnotation `protobuf:"bytes,3,rep,name=sample_annotations_list,json=sampleAnnotationsList" json:"sample_annotations_list,omitempty"`
	AuxData               map[string][]byte   `protobuf:"bytes,4,rep,name=aux_data,json=auxData" json:"aux_data,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	XXX_NoUnkeyedLiteral  struct{}            `json:"-"`
	XXX_unrecognized      []byte              `json:"-"`
	XXX_sizecache         int32               `json:"-"`
}

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

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

var xxx_messageInfo_SamplePoint proto.InternalMessageInfo

func (m *SamplePoint) GetInputValue() float64 {
	if m != nil && m.InputValue != nil {
		return *m.InputValue
	}
	return 0
}

func (m *SamplePoint) GetMetricValueList() []*KeyedValue {
	if m != nil {
		return m.MetricValueList
	}
	return nil
}

func (m *SamplePoint) GetSampleAnnotationsList() []*SampleAnnotation {
	if m != nil {
		return m.SampleAnnotationsList
	}
	return nil
}

func (m *SamplePoint) GetAuxData() map[string][]byte {
	if m != nil {
		return m.AuxData
	}
	return nil
}

type SampleAnnotation struct {
	// Types that are valid to be assigned to Annotation:
	//	*SampleAnnotation_Text
	//	*SampleAnnotation_Hyperlink
	Annotation           isSampleAnnotation_Annotation `protobuf_oneof:"annotation"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

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

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

var xxx_messageInfo_SampleAnnotation proto.InternalMessageInfo

type isSampleAnnotation_Annotation interface {
	isSampleAnnotation_Annotation()
}

type SampleAnnotation_Text struct {
	Text string `protobuf:"bytes,1,opt,name=text,oneof"`
}

type SampleAnnotation_Hyperlink struct {
	Hyperlink *NamedData `protobuf:"bytes,2,opt,name=hyperlink,oneof"`
}

func (*SampleAnnotation_Text) isSampleAnnotation_Annotation() {}

func (*SampleAnnotation_Hyperlink) isSampleAnnotation_Annotation() {}

func (m *SampleAnnotation) GetAnnotation() isSampleAnnotation_Annotation {
	if m != nil {
		return m.Annotation
	}
	return nil
}

func (m *SampleAnnotation) GetText() string {
	if x, ok := m.GetAnnotation().(*SampleAnnotation_Text); ok {
		return x.Text
	}
	return ""
}

func (m *SampleAnnotation) GetHyperlink() *NamedData {
	if x, ok := m.GetAnnotation().(*SampleAnnotation_Hyperlink); ok {
		return x.Hyperlink
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*SampleAnnotation) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*SampleAnnotation_Text)(nil),
		(*SampleAnnotation_Hyperlink)(nil),
	}
}

type SampleError struct {
	InputValue           *float64 `protobuf:"fixed64,1,opt,name=input_value,json=inputValue" json:"input_value,omitempty"`
	SamplerName          *string  `protobuf:"bytes,2,opt,name=sampler_name,json=samplerName" json:"sampler_name,omitempty"`
	ErrorMessage         *string  `protobuf:"bytes,3,opt,name=error_message,json=errorMessage" json:"error_message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SampleError proto.InternalMessageInfo

func (m *SampleError) GetInputValue() float64 {
	if m != nil && m.InputValue != nil {
		return *m.InputValue
	}
	return 0
}

func (m *SampleError) GetSamplerName() string {
	if m != nil && m.SamplerName != nil {
		return *m.SamplerName
	}
	return ""
}

func (m *SampleError) GetErrorMessage() string {
	if m != nil && m.ErrorMessage != nil {
		return *m.ErrorMessage
	}
	return ""
}

type SampleBatch struct {
	BenchmarkKey         *string        `protobuf:"bytes,1,opt,name=benchmark_key,json=benchmarkKey" json:"benchmark_key,omitempty"`
	RunKey               *string        `protobuf:"bytes,2,opt,name=run_key,json=runKey" json:"run_key,omitempty"`
	BatchKey             *string        `protobuf:"bytes,3,opt,name=batch_key,json=batchKey" json:"batch_key,omitempty"`
	SamplePointList      []*SamplePoint `protobuf:"bytes,4,rep,name=sample_point_list,json=samplePointList" json:"sample_point_list,omitempty"`
	SampleErrorList      []*SampleError `protobuf:"bytes,5,rep,name=sample_error_list,json=sampleErrorList" json:"sample_error_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_SampleBatch proto.InternalMessageInfo

func (m *SampleBatch) GetBenchmarkKey() string {
	if m != nil && m.BenchmarkKey != nil {
		return *m.BenchmarkKey
	}
	return ""
}

func (m *SampleBatch) GetRunKey() string {
	if m != nil && m.RunKey != nil {
		return *m.RunKey
	}
	return ""
}

func (m *SampleBatch) GetBatchKey() string {
	if m != nil && m.BatchKey != nil {
		return *m.BatchKey
	}
	return ""
}

func (m *SampleBatch) GetSamplePointList() []*SamplePoint {
	if m != nil {
		return m.SamplePointList
	}
	return nil
}

func (m *SampleBatch) GetSampleErrorList() []*SampleError {
	if m != nil {
		return m.SampleErrorList
	}
	return nil
}

type MetricAggregate struct {
	MetricKey               *string   `protobuf:"bytes,1,opt,name=metric_key,json=metricKey" json:"metric_key,omitempty"`
	Min                     *float64  `protobuf:"fixed64,2,opt,name=min" json:"min,omitempty"`
	Max                     *float64  `protobuf:"fixed64,3,opt,name=max" json:"max,omitempty"`
	Mean                    *float64  `protobuf:"fixed64,4,opt,name=mean" json:"mean,omitempty"`
	Median                  *float64  `protobuf:"fixed64,5,opt,name=median" json:"median,omitempty"`
	StandardDeviation       *float64  `protobuf:"fixed64,6,opt,name=standard_deviation,json=standardDeviation" json:"standard_deviation,omitempty"`
	MedianAbsoluteDeviation *float64  `protobuf:"fixed64,9,opt,name=median_absolute_deviation,json=medianAbsoluteDeviation" json:"median_absolute_deviation,omitempty"`
	PercentileList          []float64 `protobuf:"fixed64,7,rep,name=percentile_list,json=percentileList" json:"percentile_list,omitempty"`
	Count                   *int64    `protobuf:"varint,8,opt,name=count" json:"count,omitempty"`
	XXX_NoUnkeyedLiteral    struct{}  `json:"-"`
	XXX_unrecognized        []byte    `json:"-"`
	XXX_sizecache           int32     `json:"-"`
}

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

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

var xxx_messageInfo_MetricAggregate proto.InternalMessageInfo

func (m *MetricAggregate) GetMetricKey() string {
	if m != nil && m.MetricKey != nil {
		return *m.MetricKey
	}
	return ""
}

func (m *MetricAggregate) GetMin() float64 {
	if m != nil && m.Min != nil {
		return *m.Min
	}
	return 0
}

func (m *MetricAggregate) GetMax() float64 {
	if m != nil && m.Max != nil {
		return *m.Max
	}
	return 0
}

func (m *MetricAggregate) GetMean() float64 {
	if m != nil && m.Mean != nil {
		return *m.Mean
	}
	return 0
}

func (m *MetricAggregate) GetMedian() float64 {
	if m != nil && m.Median != nil {
		return *m.Median
	}
	return 0
}

func (m *MetricAggregate) GetStandardDeviation() float64 {
	if m != nil && m.StandardDeviation != nil {
		return *m.StandardDeviation
	}
	return 0
}

func (m *MetricAggregate) GetMedianAbsoluteDeviation() float64 {
	if m != nil && m.MedianAbsoluteDeviation != nil {
		return *m.MedianAbsoluteDeviation
	}
	return 0
}

func (m *MetricAggregate) GetPercentileList() []float64 {
	if m != nil {
		return m.PercentileList
	}
	return nil
}

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

type RunAggregate struct {
	UsableSampleCount    *int64        `protobuf:"varint,1,opt,name=usable_sample_count,json=usableSampleCount" json:"usable_sample_count,omitempty"`
	IgnoreSampleCount    *int64        `protobuf:"varint,2,opt,name=ignore_sample_count,json=ignoreSampleCount,def=0" json:"ignore_sample_count,omitempty"`
	ErrorSampleCount     *int64        `protobuf:"varint,3,opt,name=error_sample_count,json=errorSampleCount,def=0" json:"error_sample_count,omitempty"`
	BenchmarkScore       *int32        `protobuf:"varint,4,opt,name=benchmark_score,json=benchmarkScore,def=0" json:"benchmark_score,omitempty"`
	CustomAggregateList  []*KeyedValue `protobuf:"bytes,5,rep,name=custom_aggregate_list,json=customAggregateList" json:"custom_aggregate_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_RunAggregate proto.InternalMessageInfo

const Default_RunAggregate_IgnoreSampleCount int64 = 0
const Default_RunAggregate_ErrorSampleCount int64 = 0
const Default_RunAggregate_BenchmarkScore int32 = 0

func (m *RunAggregate) GetUsableSampleCount() int64 {
	if m != nil && m.UsableSampleCount != nil {
		return *m.UsableSampleCount
	}
	return 0
}

func (m *RunAggregate) GetIgnoreSampleCount() int64 {
	if m != nil && m.IgnoreSampleCount != nil {
		return *m.IgnoreSampleCount
	}
	return Default_RunAggregate_IgnoreSampleCount
}

func (m *RunAggregate) GetErrorSampleCount() int64 {
	if m != nil && m.ErrorSampleCount != nil {
		return *m.ErrorSampleCount
	}
	return Default_RunAggregate_ErrorSampleCount
}

func (m *RunAggregate) GetBenchmarkScore() int32 {
	if m != nil && m.BenchmarkScore != nil {
		return *m.BenchmarkScore
	}
	return Default_RunAggregate_BenchmarkScore
}

func (m *RunAggregate) GetCustomAggregateList() []*KeyedValue {
	if m != nil {
		return m.CustomAggregateList
	}
	return nil
}

type Aggregate struct {
	MetricAggregateList     []*MetricAggregate `protobuf:"bytes,1,rep,name=metric_aggregate_list,json=metricAggregateList" json:"metric_aggregate_list,omitempty"`
	RunAggregate            *RunAggregate      `protobuf:"bytes,2,opt,name=run_aggregate,json=runAggregate" json:"run_aggregate,omitempty"`
	PercentileMilliRankList []int32            `protobuf:"varint,3,rep,name=percentile_milli_rank_list,json=percentileMilliRankList" json:"percentile_milli_rank_list,omitempty"`
	XXX_NoUnkeyedLiteral    struct{}           `json:"-"`
	XXX_unrecognized        []byte             `json:"-"`
	XXX_sizecache           int32              `json:"-"`
}

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

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

var xxx_messageInfo_Aggregate proto.InternalMessageInfo

func (m *Aggregate) GetMetricAggregateList() []*MetricAggregate {
	if m != nil {
		return m.MetricAggregateList
	}
	return nil
}

func (m *Aggregate) GetRunAggregate() *RunAggregate {
	if m != nil {
		return m.RunAggregate
	}
	return nil
}

func (m *Aggregate) GetPercentileMilliRankList() []int32 {
	if m != nil {
		return m.PercentileMilliRankList
	}
	return nil
}

type BenchmarkInfoQuery struct {
	Cursor               *string  `protobuf:"bytes,1,opt,name=cursor" json:"cursor,omitempty"`
	Limit                *int32   `protobuf:"varint,2,opt,name=limit" json:"limit,omitempty"`
	BenchmarkKey         *string  `protobuf:"bytes,3,opt,name=benchmark_key,json=benchmarkKey" json:"benchmark_key,omitempty"`
	BenchmarkName        *string  `protobuf:"bytes,4,opt,name=benchmark_name,json=benchmarkName" json:"benchmark_name,omitempty"`
	ProjectName          *string  `protobuf:"bytes,5,opt,name=project_name,json=projectName" json:"project_name,omitempty"`
	Owner                *string  `protobuf:"bytes,6,opt,name=owner" json:"owner,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_BenchmarkInfoQuery proto.InternalMessageInfo

func (m *BenchmarkInfoQuery) GetCursor() string {
	if m != nil && m.Cursor != nil {
		return *m.Cursor
	}
	return ""
}

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

func (m *BenchmarkInfoQuery) GetBenchmarkKey() string {
	if m != nil && m.BenchmarkKey != nil {
		return *m.BenchmarkKey
	}
	return ""
}

func (m *BenchmarkInfoQuery) GetBenchmarkName() string {
	if m != nil && m.BenchmarkName != nil {
		return *m.BenchmarkName
	}
	return ""
}

func (m *BenchmarkInfoQuery) GetProjectName() string {
	if m != nil && m.ProjectName != nil {
		return *m.ProjectName
	}
	return ""
}

func (m *BenchmarkInfoQuery) GetOwner() string {
	if m != nil && m.Owner != nil {
		return *m.Owner
	}
	return ""
}

type BenchmarkInfoQueryResponse struct {
	Status               *Status          `protobuf:"bytes,1,opt,name=status" json:"status,omitempty"`
	Cursor               *string          `protobuf:"bytes,2,opt,name=cursor" json:"cursor,omitempty"`
	BenchmarkInfoList    []*BenchmarkInfo `protobuf:"bytes,4,rep,name=benchmark_info_list,json=benchmarkInfoList" json:"benchmark_info_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

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

var xxx_messageInfo_BenchmarkInfoQueryResponse proto.InternalMessageInfo

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

func (m *BenchmarkInfoQueryResponse) GetCursor() string {
	if m != nil && m.Cursor != nil {
		return *m.Cursor
	}
	return ""
}

func (m *BenchmarkInfoQueryResponse) GetBenchmarkInfoList() []*BenchmarkInfo {
	if m != nil {
		return m.BenchmarkInfoList
	}
	return nil
}

type RunInfoQuery struct {
	Cursor               *string   `protobuf:"bytes,1,opt,name=cursor" json:"cursor,omitempty"`
	Limit                *int32    `protobuf:"varint,2,opt,name=limit" json:"limit,omitempty"`
	BenchmarkKey         *string   `protobuf:"bytes,3,opt,name=benchmark_key,json=benchmarkKey" json:"benchmark_key,omitempty"`
	RunKey               *string   `protobuf:"bytes,4,opt,name=run_key,json=runKey" json:"run_key,omitempty"`
	TestPassId           *string   `protobuf:"bytes,11,opt,name=test_pass_id,json=testPassId" json:"test_pass_id,omitempty"`
	RunOrder             *RunOrder `protobuf:"varint,8,opt,name=run_order,json=runOrder,enum=mako.RunOrder,def=1" json:"run_order,omitempty"`
	MinTimestampMs       *float64  `protobuf:"fixed64,5,opt,name=min_timestamp_ms,json=minTimestampMs" json:"min_timestamp_ms,omitempty"`
	MaxTimestampMs       *float64  `protobuf:"fixed64,6,opt,name=max_timestamp_ms,json=maxTimestampMs" json:"max_timestamp_ms,omitempty"`
	MinBuildId           *int64    `protobuf:"varint,9,opt,name=min_build_id,json=minBuildId" json:"min_build_id,omitempty"`
	MaxBuildId           *int64    `protobuf:"varint,10,opt,name=max_build_id,json=maxBuildId" json:"max_build_id,omitempty"`
	Tags                 []string  `protobuf:"bytes,7,rep,name=tags" json:"tags,omitempty"`
	Fields               []string  `protobuf:"bytes,12,rep,name=fields" json:"fields,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

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

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

var xxx_messageInfo_RunInfoQuery proto.InternalMessageInfo

const Default_RunInfoQuery_RunOrder RunOrder = RunOrder_TIMESTAMP

func (m *RunInfoQuery) GetCursor() string {
	if m != nil && m.Cursor != nil {
		return *m.Cursor
	}
	return ""
}

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

func (m *RunInfoQuery) GetBenchmarkKey() string {
	if m != nil && m.BenchmarkKey != nil {
		return *m.BenchmarkKey
	}
	return ""
}

func (m *RunInfoQuery) GetRunKey() string {
	if m != nil && m.RunKey != nil {
		return *m.RunKey
	}
	return ""
}

func (m *RunInfoQuery) GetTestPassId() string {
	if m != nil && m.TestPassId != nil {
		return *m.TestPassId
	}
	return ""
}

func (m *RunInfoQuery) GetRunOrder() RunOrder {
	if m != nil && m.RunOrder != nil {
		return *m.RunOrder
	}
	return Default_RunInfoQuery_RunOrder
}

func (m *RunInfoQuery) GetMinTimestampMs() float64 {
	if m != nil && m.MinTimestampMs != nil {
		return *m.MinTimestampMs
	}
	return 0
}

func (m *RunInfoQuery) GetMaxTimestampMs() float64 {
	if m != nil && m.MaxTimestampMs != nil {
		return *m.MaxTimestampMs
	}
	return 0
}

func (m *RunInfoQuery) GetMinBuildId() int64 {
	if m != nil && m.MinBuildId != nil {
		return *m.MinBuildId
	}
	return 0
}

func (m *RunInfoQuery) GetMaxBuildId() int64 {
	if m != nil && m.MaxBuildId != nil {
		return *m.MaxBuildId
	}
	return 0
}

func (m *RunInfoQuery) GetTags() []string {
	if m != nil {
		return m.Tags
	}
	return nil
}

func (m *RunInfoQuery) GetFields() []string {
	if m != nil {
		return m.Fields
	}
	return nil
}

type RunInfoQueryResponse struct {
	Status               *Status    `protobuf:"bytes,1,opt,name=status" json:"status,omitempty"`
	Cursor               *string    `protobuf:"bytes,2,opt,name=cursor" json:"cursor,omitempty"`
	RunInfoList          []*RunInfo `protobuf:"bytes,4,rep,name=run_info_list,json=runInfoList" json:"run_info_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

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

var xxx_messageInfo_RunInfoQueryResponse proto.InternalMessageInfo

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

func (m *RunInfoQueryResponse) GetCursor() string {
	if m != nil && m.Cursor != nil {
		return *m.Cursor
	}
	return ""
}

func (m *RunInfoQueryResponse) GetRunInfoList() []*RunInfo {
	if m != nil {
		return m.RunInfoList
	}
	return nil
}

type SampleBatchQuery struct {
	Cursor               *string  `protobuf:"bytes,1,opt,name=cursor" json:"cursor,omitempty"`
	Limit                *int32   `protobuf:"varint,2,opt,name=limit" json:"limit,omitempty"`
	BenchmarkKey         *string  `protobuf:"bytes,3,opt,name=benchmark_key,json=benchmarkKey" json:"benchmark_key,omitempty"`
	RunKey               *string  `protobuf:"bytes,4,opt,name=run_key,json=runKey" json:"run_key,omitempty"`
	BatchKey             *string  `protobuf:"bytes,5,opt,name=batch_key,json=batchKey" json:"batch_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SampleBatchQuery proto.InternalMessageInfo

func (m *SampleBatchQuery) GetCursor() string {
	if m != nil && m.Cursor != nil {
		return *m.Cursor
	}
	return ""
}

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

func (m *SampleBatchQuery) GetBenchmarkKey() string {
	if m != nil && m.BenchmarkKey != nil {
		return *m.BenchmarkKey
	}
	return ""
}

func (m *SampleBatchQuery) GetRunKey() string {
	if m != nil && m.RunKey != nil {
		return *m.RunKey
	}
	return ""
}

func (m *SampleBatchQuery) GetBatchKey() string {
	if m != nil && m.BatchKey != nil {
		return *m.BatchKey
	}
	return ""
}

type SampleBatchQueryResponse struct {
	Status               *Status        `protobuf:"bytes,1,opt,name=status" json:"status,omitempty"`
	Cursor               *string        `protobuf:"bytes,2,opt,name=cursor" json:"cursor,omitempty"`
	SampleBatchList      []*SampleBatch `protobuf:"bytes,4,rep,name=sample_batch_list,json=sampleBatchList" json:"sample_batch_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_SampleBatchQueryResponse proto.InternalMessageInfo

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

func (m *SampleBatchQueryResponse) GetCursor() string {
	if m != nil && m.Cursor != nil {
		return *m.Cursor
	}
	return ""
}

func (m *SampleBatchQueryResponse) GetSampleBatchList() []*SampleBatch {
	if m != nil {
		return m.SampleBatchList
	}
	return nil
}

type CreationResponse struct {
	Status               *Status  `protobuf:"bytes,1,opt,name=status" json:"status,omitempty"`
	Key                  *string  `protobuf:"bytes,2,opt,name=key" json:"key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_CreationResponse proto.InternalMessageInfo

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

func (m *CreationResponse) GetKey() string {
	if m != nil && m.Key != nil {
		return *m.Key
	}
	return ""
}

type ModificationResponse struct {
	Status               *Status  `protobuf:"bytes,1,opt,name=status" json:"status,omitempty"`
	Count                *int64   `protobuf:"varint,2,opt,name=count" json:"count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ModificationResponse proto.InternalMessageInfo

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

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

type CountResponse struct {
	Status               *Status  `protobuf:"bytes,1,opt,name=status" json:"status,omitempty"`
	Count                *int64   `protobuf:"varint,2,opt,name=count" json:"count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_CountResponse proto.InternalMessageInfo

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

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

type SecondaryStorageWriteInput struct {
	Bundle               *RunBundle `protobuf:"bytes,1,opt,name=bundle" json:"bundle,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

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

var xxx_messageInfo_SecondaryStorageWriteInput proto.InternalMessageInfo

func (m *SecondaryStorageWriteInput) GetBundle() *RunBundle {
	if m != nil {
		return m.Bundle
	}
	return nil
}

type SecondaryStorageWriteOutput struct {
	Status               *Status      `protobuf:"bytes,1,opt,name=status" json:"status,omitempty"`
	Links                []*NamedData `protobuf:"bytes,2,rep,name=links" json:"links,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_SecondaryStorageWriteOutput proto.InternalMessageInfo

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

func (m *SecondaryStorageWriteOutput) GetLinks() []*NamedData {
	if m != nil {
		return m.Links
	}
	return nil
}

type AggregatorInput struct {
	BenchmarkInfo        *BenchmarkInfo `protobuf:"bytes,1,opt,name=benchmark_info,json=benchmarkInfo" json:"benchmark_info,omitempty"`
	RunInfo              *RunInfo       `protobuf:"bytes,2,opt,name=run_info,json=runInfo" json:"run_info,omitempty"`
	SampleFileList       []*SampleFile  `protobuf:"bytes,3,rep,name=sample_file_list,json=sampleFileList" json:"sample_file_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_AggregatorInput proto.InternalMessageInfo

func (m *AggregatorInput) GetBenchmarkInfo() *BenchmarkInfo {
	if m != nil {
		return m.BenchmarkInfo
	}
	return nil
}

func (m *AggregatorInput) GetRunInfo() *RunInfo {
	if m != nil {
		return m.RunInfo
	}
	return nil
}

func (m *AggregatorInput) GetSampleFileList() []*SampleFile {
	if m != nil {
		return m.SampleFileList
	}
	return nil
}

type AggregatorOutput struct {
	Aggregate            *Aggregate `protobuf:"bytes,1,opt,name=aggregate" json:"aggregate,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

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

var xxx_messageInfo_AggregatorOutput proto.InternalMessageInfo

func (m *AggregatorOutput) GetAggregate() *Aggregate {
	if m != nil {
		return m.Aggregate
	}
	return nil
}

type DownsamplerInput struct {
	RunInfo              *RunInfo      `protobuf:"bytes,1,opt,name=run_info,json=runInfo" json:"run_info,omitempty"`
	SampleFileList       []*SampleFile `protobuf:"bytes,2,rep,name=sample_file_list,json=sampleFileList" json:"sample_file_list,omitempty"`
	MetricValueCountMax  *int64        `protobuf:"varint,6,opt,name=metric_value_count_max,json=metricValueCountMax" json:"metric_value_count_max,omitempty"`
	SampleErrorCountMax  *int64        `protobuf:"varint,4,opt,name=sample_error_count_max,json=sampleErrorCountMax" json:"sample_error_count_max,omitempty"`
	BatchSizeMax         *int64        `protobuf:"varint,5,opt,name=batch_size_max,json=batchSizeMax" json:"batch_size_max,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_DownsamplerInput proto.InternalMessageInfo

func (m *DownsamplerInput) GetRunInfo() *RunInfo {
	if m != nil {
		return m.RunInfo
	}
	return nil
}

func (m *DownsamplerInput) GetSampleFileList() []*SampleFile {
	if m != nil {
		return m.SampleFileList
	}
	return nil
}

func (m *DownsamplerInput) GetMetricValueCountMax() int64 {
	if m != nil && m.MetricValueCountMax != nil {
		return *m.MetricValueCountMax
	}
	return 0
}

func (m *DownsamplerInput) GetSampleErrorCountMax() int64 {
	if m != nil && m.SampleErrorCountMax != nil {
		return *m.SampleErrorCountMax
	}
	return 0
}

func (m *DownsamplerInput) GetBatchSizeMax() int64 {
	if m != nil && m.BatchSizeMax != nil {
		return *m.BatchSizeMax
	}
	return 0
}

type DownsamplerOutput struct {
	SampleBatchList      []*SampleBatch `protobuf:"bytes,1,rep,name=sample_batch_list,json=sampleBatchList" json:"sample_batch_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_DownsamplerOutput proto.InternalMessageInfo

func (m *DownsamplerOutput) GetSampleBatchList() []*SampleBatch {
	if m != nil {
		return m.SampleBatchList
	}
	return nil
}

type AnalyzerHistoricQueryInput struct {
	BenchmarkInfo        *BenchmarkInfo `protobuf:"bytes,1,opt,name=benchmark_info,json=benchmarkInfo" json:"benchmark_info,omitempty"`
	RunInfo              *RunInfo       `protobuf:"bytes,2,opt,name=run_info,json=runInfo" json:"run_info,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_AnalyzerHistoricQueryInput proto.InternalMessageInfo

func (m *AnalyzerHistoricQueryInput) GetBenchmarkInfo() *BenchmarkInfo {
	if m != nil {
		return m.BenchmarkInfo
	}
	return nil
}

func (m *AnalyzerHistoricQueryInput) GetRunInfo() *RunInfo {
	if m != nil {
		return m.RunInfo
	}
	return nil
}

type AnalyzerHistoricQueryOutput struct {
	Status               *Status                                                `protobuf:"bytes,1,opt,name=status" json:"status,omitempty"`
	RunInfoQueryList     []*RunInfoQuery                                        `protobuf:"bytes,2,rep,name=run_info_query_list,json=runInfoQueryList" json:"run_info_query_list,omitempty"`
	GetBatches           *bool                                                  `protobuf:"varint,3,opt,name=get_batches,json=getBatches,def=1" json:"get_batches,omitempty"`
	RunInfoQueryMap      map[string]*AnalyzerHistoricQueryOutput_RunInfoQueries `protobuf:"bytes,4,rep,name=run_info_query_map,json=runInfoQueryMap" json:"run_info_query_map,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	XXX_NoUnkeyedLiteral struct{}                                               `json:"-"`
	XXX_unrecognized     []byte                                                 `json:"-"`
	XXX_sizecache        int32                                                  `json:"-"`
}

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

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

var xxx_messageInfo_AnalyzerHistoricQueryOutput proto.InternalMessageInfo

const Default_AnalyzerHistoricQueryOutput_GetBatches bool = true

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

func (m *AnalyzerHistoricQueryOutput) GetRunInfoQueryList() []*RunInfoQuery {
	if m != nil {
		return m.RunInfoQueryList
	}
	return nil
}

func (m *AnalyzerHistoricQueryOutput) GetGetBatches() bool {
	if m != nil && m.GetBatches != nil {
		return *m.GetBatches
	}
	return Default_AnalyzerHistoricQueryOutput_GetBatches
}

func (m *AnalyzerHistoricQueryOutput) GetRunInfoQueryMap() map[string]*AnalyzerHistoricQueryOutput_RunInfoQueries {
	if m != nil {
		return m.RunInfoQueryMap
	}
	return nil
}

type AnalyzerHistoricQueryOutput_RunInfoQueries struct {
	RunInfoQueryList     []*RunInfoQuery `protobuf:"bytes,1,rep,name=run_info_query_list,json=runInfoQueryList" json:"run_info_query_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_AnalyzerHistoricQueryOutput_RunInfoQueries proto.InternalMessageInfo

func (m *AnalyzerHistoricQueryOutput_RunInfoQueries) GetRunInfoQueryList() []*RunInfoQuery {
	if m != nil {
		return m.RunInfoQueryList
	}
	return nil
}

type AnalyzerInput struct {
	RunToBeAnalyzed      *RunBundle                           `protobuf:"bytes,1,opt,name=run_to_be_analyzed,json=runToBeAnalyzed" json:"run_to_be_analyzed,omitempty"`
	HistoricalRunList    []*RunBundle                         `protobuf:"bytes,2,rep,name=historical_run_list,json=historicalRunList" json:"historical_run_list,omitempty"`
	HistoricalRunMap     map[string]*AnalyzerInput_RunBundles `protobuf:"bytes,3,rep,name=historical_run_map,json=historicalRunMap" json:"historical_run_map,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	XXX_NoUnkeyedLiteral struct{}                             `json:"-"`
	XXX_unrecognized     []byte                               `json:"-"`
	XXX_sizecache        int32                                `json:"-"`
}

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

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

var xxx_messageInfo_AnalyzerInput proto.InternalMessageInfo

func (m *AnalyzerInput) GetRunToBeAnalyzed() *RunBundle {
	if m != nil {
		return m.RunToBeAnalyzed
	}
	return nil
}

func (m *AnalyzerInput) GetHistoricalRunList() []*RunBundle {
	if m != nil {
		return m.HistoricalRunList
	}
	return nil
}

func (m *AnalyzerInput) GetHistoricalRunMap() map[string]*AnalyzerInput_RunBundles {
	if m != nil {
		return m.HistoricalRunMap
	}
	return nil
}

type AnalyzerInput_RunBundles struct {
	HistoricalRunList    []*RunBundle `protobuf:"bytes,1,rep,name=historical_run_list,json=historicalRunList" json:"historical_run_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_AnalyzerInput_RunBundles proto.InternalMessageInfo

func (m *AnalyzerInput_RunBundles) GetHistoricalRunList() []*RunBundle {
	if m != nil {
		return m.HistoricalRunList
	}
	return nil
}

type AnalyzerOutput struct {
	Status                *Status             `protobuf:"bytes,1,opt,name=status" json:"status,omitempty"`
	Regression            *bool               `protobuf:"varint,2,opt,name=regression" json:"regression,omitempty"`
	RunKey                *string             `protobuf:"bytes,7,opt,name=run_key,json=runKey" json:"run_key,omitempty"`
	AnalysisKey           *string             `protobuf:"bytes,8,opt,name=analysis_key,json=analysisKey" json:"analysis_key,omitempty"`
	AnalysisTriageInfo    *AnalysisTriageInfo `protobuf:"bytes,10,opt,name=analysis_triage_info,json=analysisTriageInfo" json:"analysis_triage_info,omitempty"`
	InputConfig           *string             `protobuf:"bytes,6,opt,name=input_config,json=inputConfig" json:"input_config,omitempty"`
	SerializedInputConfig []byte              `protobuf:"bytes,11,opt,name=serialized_input_config,json=serializedInputConfig" json:"serialized_input_config,omitempty"`
	Output                *string             `protobuf:"bytes,3,opt,name=output" json:"output,omitempty"`
	SerializedOutput      []byte              `protobuf:"bytes,12,opt,name=serialized_output,json=serializedOutput" json:"serialized_output,omitempty"`
	AnalyzerType          *string             `protobuf:"bytes,4,opt,name=analyzer_type,json=analyzerType" json:"analyzer_type,omitempty"`
	AnalyzerName          *string             `protobuf:"bytes,5,opt,name=analyzer_name,json=analyzerName" json:"analyzer_name,omitempty"`
	XXX_NoUnkeyedLiteral  struct{}            `json:"-"`
	XXX_unrecognized      []byte              `json:"-"`
	XXX_sizecache         int32               `json:"-"`
}

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

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

var xxx_messageInfo_AnalyzerOutput proto.InternalMessageInfo

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

func (m *AnalyzerOutput) GetRegression() bool {
	if m != nil && m.Regression != nil {
		return *m.Regression
	}
	return false
}

func (m *AnalyzerOutput) GetRunKey() string {
	if m != nil && m.RunKey != nil {
		return *m.RunKey
	}
	return ""
}

func (m *AnalyzerOutput) GetAnalysisKey() string {
	if m != nil && m.AnalysisKey != nil {
		return *m.AnalysisKey
	}
	return ""
}

func (m *AnalyzerOutput) GetAnalysisTriageInfo() *AnalysisTriageInfo {
	if m != nil {
		return m.AnalysisTriageInfo
	}
	return nil
}

func (m *AnalyzerOutput) GetInputConfig() string {
	if m != nil && m.InputConfig != nil {
		return *m.InputConfig
	}
	return ""
}

func (m *AnalyzerOutput) GetSerializedInputConfig() []byte {
	if m != nil {
		return m.SerializedInputConfig
	}
	return nil
}

func (m *AnalyzerOutput) GetOutput() string {
	if m != nil && m.Output != nil {
		return *m.Output
	}
	return ""
}

func (m *AnalyzerOutput) GetSerializedOutput() []byte {
	if m != nil {
		return m.SerializedOutput
	}
	return nil
}

func (m *AnalyzerOutput) GetAnalyzerType() string {
	if m != nil && m.AnalyzerType != nil {
		return *m.AnalyzerType
	}
	return ""
}

func (m *AnalyzerOutput) GetAnalyzerName() string {
	if m != nil && m.AnalyzerName != nil {
		return *m.AnalyzerName
	}
	return ""
}

type AnalysisTriageInfo struct {
	AnalysisState        *AnalysisTriageInfo_AnalysisTriageType `protobuf:"varint,1,opt,name=analysis_state,json=analysisState,enum=mako.AnalysisTriageInfo_AnalysisTriageType" json:"analysis_state,omitempty"`
	Environment          *AnalysisTriageInfo_EnvironmentType    `protobuf:"varint,2,opt,name=environment,enum=mako.AnalysisTriageInfo_EnvironmentType" json:"environment,omitempty"`
	Comment              *string                                `protobuf:"bytes,3,opt,name=comment" json:"comment,omitempty"`
	BuganizerId          *string                                `protobuf:"bytes,4,opt,name=buganizer_id,json=buganizerId" json:"buganizer_id,omitempty"`
	RunKey               *string                                `protobuf:"bytes,5,opt,name=run_key,json=runKey" json:"run_key,omitempty"`
	AnalysisKey          *string                                `protobuf:"bytes,6,opt,name=analysis_key,json=analysisKey" json:"analysis_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                               `json:"-"`
	XXX_unrecognized     []byte                                 `json:"-"`
	XXX_sizecache        int32                                  `json:"-"`
}

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

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

var xxx_messageInfo_AnalysisTriageInfo proto.InternalMessageInfo

func (m *AnalysisTriageInfo) GetAnalysisState() AnalysisTriageInfo_AnalysisTriageType {
	if m != nil && m.AnalysisState != nil {
		return *m.AnalysisState
	}
	return AnalysisTriageInfo_NONE
}

func (m *AnalysisTriageInfo) GetEnvironment() AnalysisTriageInfo_EnvironmentType {
	if m != nil && m.Environment != nil {
		return *m.Environment
	}
	return AnalysisTriageInfo_UNSPECIFIED
}

func (m *AnalysisTriageInfo) GetComment() string {
	if m != nil && m.Comment != nil {
		return *m.Comment
	}
	return ""
}

func (m *AnalysisTriageInfo) GetBuganizerId() string {
	if m != nil && m.BuganizerId != nil {
		return *m.BuganizerId
	}
	return ""
}

func (m *AnalysisTriageInfo) GetRunKey() string {
	if m != nil && m.RunKey != nil {
		return *m.RunKey
	}
	return ""
}

func (m *AnalysisTriageInfo) GetAnalysisKey() string {
	if m != nil && m.AnalysisKey != nil {
		return *m.AnalysisKey
	}
	return ""
}

type DashboardAggregateChartInput struct {
	BenchmarkKey           *string       `protobuf:"bytes,1,opt,name=benchmark_key,json=benchmarkKey" json:"benchmark_key,omitempty"`
	ValueSelections        []*DataFilter `protobuf:"bytes,2,rep,name=value_selections,json=valueSelections" json:"value_selections,omitempty"`
	Tags                   []string      `protobuf:"bytes,3,rep,name=tags" json:"tags,omitempty"`
	RunOrder               *RunOrder     `protobuf:"varint,8,opt,name=run_order,json=runOrder,enum=mako.RunOrder,def=1" json:"run_order,omitempty"`
	MinTimestampMs         *float64      `protobuf:"fixed64,4,opt,name=min_timestamp_ms,json=minTimestampMs" json:"min_timestamp_ms,omitempty"`
	MaxTimestampMs         *float64      `protobuf:"fixed64,5,opt,name=max_timestamp_ms,json=maxTimestampMs" json:"max_timestamp_ms,omitempty"`
	MinBuildId             *int64        `protobuf:"varint,9,opt,name=min_build_id,json=minBuildId" json:"min_build_id,omitempty"`
	MaxBuildId             *int64        `protobuf:"varint,10,opt,name=max_build_id,json=maxBuildId" json:"max_build_id,omitempty"`
	MaxRuns                *int32        `protobuf:"varint,6,opt,name=max_runs,json=maxRuns" json:"max_runs,omitempty"`
	HighlightSeriesOnHover *bool         `protobuf:"varint,7,opt,name=highlight_series_on_hover,json=highlightSeriesOnHover" json:"highlight_series_on_hover,omitempty"`
	XXX_NoUnkeyedLiteral   struct{}      `json:"-"`
	XXX_unrecognized       []byte        `json:"-"`
	XXX_sizecache          int32         `json:"-"`
}

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

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

var xxx_messageInfo_DashboardAggregateChartInput proto.InternalMessageInfo

const Default_DashboardAggregateChartInput_RunOrder RunOrder = RunOrder_TIMESTAMP

func (m *DashboardAggregateChartInput) GetBenchmarkKey() string {
	if m != nil && m.BenchmarkKey != nil {
		return *m.BenchmarkKey
	}
	return ""
}

func (m *DashboardAggregateChartInput) GetValueSelections() []*DataFilter {
	if m != nil {
		return m.ValueSelections
	}
	return nil
}

func (m *DashboardAggregateChartInput) GetTags() []string {
	if m != nil {
		return m.Tags
	}
	return nil
}

func (m *DashboardAggregateChartInput) GetRunOrder() RunOrder {
	if m != nil && m.RunOrder != nil {
		return *m.RunOrder
	}
	return Default_DashboardAggregateChartInput_RunOrder
}

func (m *DashboardAggregateChartInput) GetMinTimestampMs() float64 {
	if m != nil && m.MinTimestampMs != nil {
		return *m.MinTimestampMs
	}
	return 0
}

func (m *DashboardAggregateChartInput) GetMaxTimestampMs() float64 {
	if m != nil && m.MaxTimestampMs != nil {
		return *m.MaxTimestampMs
	}
	return 0
}

func (m *DashboardAggregateChartInput) GetMinBuildId() int64 {
	if m != nil && m.MinBuildId != nil {
		return *m.MinBuildId
	}
	return 0
}

func (m *DashboardAggregateChartInput) GetMaxBuildId() int64 {
	if m != nil && m.MaxBuildId != nil {
		return *m.MaxBuildId
	}
	return 0
}

func (m *DashboardAggregateChartInput) GetMaxRuns() int32 {
	if m != nil && m.MaxRuns != nil {
		return *m.MaxRuns
	}
	return 0
}

func (m *DashboardAggregateChartInput) GetHighlightSeriesOnHover() bool {
	if m != nil && m.HighlightSeriesOnHover != nil {
		return *m.HighlightSeriesOnHover
	}
	return false
}

type DashboardRunChartInput struct {
	RunKey                 *string  `protobuf:"bytes,1,opt,name=run_key,json=runKey" json:"run_key,omitempty"`
	MetricKeys             []string `protobuf:"bytes,2,rep,name=metric_keys,json=metricKeys" json:"metric_keys,omitempty"`
	HighlightSeriesOnHover *bool    `protobuf:"varint,3,opt,name=highlight_series_on_hover,json=highlightSeriesOnHover" json:"highlight_series_on_hover,omitempty"`
	XXX_NoUnkeyedLiteral   struct{} `json:"-"`
	XXX_unrecognized       []byte   `json:"-"`
	XXX_sizecache          int32    `json:"-"`
}

func (m *DashboardRunChartInput) Reset()         { *m = DashboardRunChartInput{} }
func (m *DashboardRunChartInput) String() string { return proto.CompactTextString(m) }
func (*DashboardRunChartInput) ProtoMessage()    {}
func (*DashboardRunChartInput) Descriptor() ([]byte, []int) {
	return fileDescriptor_b174f87a83ddb952, []int{39}
}

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

var xxx_messageInfo_DashboardRunChartInput proto.InternalMessageInfo

func (m *DashboardRunChartInput) GetRunKey() string {
	if m != nil && m.RunKey != nil {
		return *m.RunKey
	}
	return ""
}

func (m *DashboardRunChartInput) GetMetricKeys() []string {
	if m != nil {
		return m.MetricKeys
	}
	return nil
}

func (m *DashboardRunChartInput) GetHighlightSeriesOnHover() bool {
	if m != nil && m.HighlightSeriesOnHover != nil {
		return *m.HighlightSeriesOnHover
	}
	return false
}

type DashboardCompareAggregateChartInput struct {
	SeriesList             []*DashboardCompareAggregateChartInput_Series `protobuf:"bytes,1,rep,name=series_list,json=seriesList" json:"series_list,omitempty"`
	MinTimestampMs         *float64                                      `protobuf:"fixed64,2,opt,name=min_timestamp_ms,json=minTimestampMs" json:"min_timestamp_ms,omitempty"`
	MaxTimestampMs         *float64                                      `protobuf:"fixed64,3,opt,name=max_timestamp_ms,json=maxTimestampMs" json:"max_timestamp_ms,omitempty"`
	MaxRuns                *int32                                        `protobuf:"varint,4,opt,name=max_runs,json=maxRuns" json:"max_runs,omitempty"`
	HighlightSeriesOnHover *bool                                         `protobuf:"varint,5,opt,name=highlight_series_on_hover,json=highlightSeriesOnHover" json:"highlight_series_on_hover,omitempty"`
	XXX_NoUnkeyedLiteral   struct{}                                      `json:"-"`
	XXX_unrecognized       []byte                                        `json:"-"`
	XXX_sizecache          int32                                         `json:"-"`
}

func (m *DashboardCompareAggregateChartInput) Reset()         { *m = DashboardCompareAggregateChartInput{} }
func (m *DashboardCompareAggregateChartInput) String() string { return proto.CompactTextString(m) }
func (*DashboardCompareAggregateChartInput) ProtoMessage()    {}
func (*DashboardCompareAggregateChartInput) Descriptor() ([]byte, []int) {
	return fileDescriptor_b174f87a83ddb952, []int{40}
}

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

var xxx_messageInfo_DashboardCompareAggregateChartInput proto.InternalMessageInfo

func (m *DashboardCompareAggregateChartInput) GetSeriesList() []*DashboardCompareAggregateChartInput_Series {
	if m != nil {
		return m.SeriesList
	}
	return nil
}

func (m *DashboardCompareAggregateChartInput) GetMinTimestampMs() float64 {
	if m != nil && m.MinTimestampMs != nil {
		return *m.MinTimestampMs
	}
	return 0
}

func (m *DashboardCompareAggregateChartInput) GetMaxTimestampMs() float64 {
	if m != nil && m.MaxTimestampMs != nil {
		return *m.MaxTimestampMs
	}
	return 0
}

func (m *DashboardCompareAggregateChartInput) GetMaxRuns() int32 {
	if m != nil && m.MaxRuns != nil {
		return *m.MaxRuns
	}
	return 0
}

func (m *DashboardCompareAggregateChartInput) GetHighlightSeriesOnHover() bool {
	if m != nil && m.HighlightSeriesOnHover != nil {
		return *m.HighlightSeriesOnHover
	}
	return false
}

type DashboardCompareAggregateChartInput_Series struct {
	SeriesLabel          *string     `protobuf:"bytes,1,opt,name=series_label,json=seriesLabel" json:"series_label,omitempty"`
	BenchmarkKey         *string     `protobuf:"bytes,2,opt,name=benchmark_key,json=benchmarkKey" json:"benchmark_key,omitempty"`
	ValueSelection       *DataFilter `protobuf:"bytes,3,opt,name=value_selection,json=valueSelection" json:"value_selection,omitempty"`
	Tags                 []string    `protobuf:"bytes,4,rep,name=tags" json:"tags,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_DashboardCompareAggregateChartInput_Series proto.InternalMessageInfo

func (m *DashboardCompareAggregateChartInput_Series) GetSeriesLabel() string {
	if m != nil && m.SeriesLabel != nil {
		return *m.SeriesLabel
	}
	return ""
}

func (m *DashboardCompareAggregateChartInput_Series) GetBenchmarkKey() string {
	if m != nil && m.BenchmarkKey != nil {
		return *m.BenchmarkKey
	}
	return ""
}

func (m *DashboardCompareAggregateChartInput_Series) GetValueSelection() *DataFilter {
	if m != nil {
		return m.ValueSelection
	}
	return nil
}

func (m *DashboardCompareAggregateChartInput_Series) GetTags() []string {
	if m != nil {
		return m.Tags
	}
	return nil
}

type DashboardCompareRunChartInput struct {
	RunKeys                []string `protobuf:"bytes,1,rep,name=run_keys,json=runKeys" json:"run_keys,omitempty"`
	MetricKeys             []string `protobuf:"bytes,2,rep,name=metric_keys,json=metricKeys" json:"metric_keys,omitempty"`
	HighlightSeriesOnHover *bool    `protobuf:"varint,3,opt,name=highlight_series_on_hover,json=highlightSeriesOnHover" json:"highlight_series_on_hover,omitempty"`
	XXX_NoUnkeyedLiteral   struct{} `json:"-"`
	XXX_unrecognized       []byte   `json:"-"`
	XXX_sizecache          int32    `json:"-"`
}

func (m *DashboardCompareRunChartInput) Reset()         { *m = DashboardCompareRunChartInput{} }
func (m *DashboardCompareRunChartInput) String() string { return proto.CompactTextString(m) }
func (*DashboardCompareRunChartInput) ProtoMessage()    {}
func (*DashboardCompareRunChartInput) Descriptor() ([]byte, []int) {
	return fileDescriptor_b174f87a83ddb952, []int{41}
}

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

var xxx_messageInfo_DashboardCompareRunChartInput proto.InternalMessageInfo

func (m *DashboardCompareRunChartInput) GetRunKeys() []string {
	if m != nil {
		return m.RunKeys
	}
	return nil
}

func (m *DashboardCompareRunChartInput) GetMetricKeys() []string {
	if m != nil {
		return m.MetricKeys
	}
	return nil
}

func (m *DashboardCompareRunChartInput) GetHighlightSeriesOnHover() bool {
	if m != nil && m.HighlightSeriesOnHover != nil {
		return *m.HighlightSeriesOnHover
	}
	return false
}

type DashboardVisualizeAnalysisInput struct {
	RunKey               *string  `protobuf:"bytes,1,opt,name=run_key,json=runKey" json:"run_key,omitempty"`
	AnalysisKey          *string  `protobuf:"bytes,2,opt,name=analysis_key,json=analysisKey" json:"analysis_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DashboardVisualizeAnalysisInput) Reset()         { *m = DashboardVisualizeAnalysisInput{} }
func (m *DashboardVisualizeAnalysisInput) String() string { return proto.CompactTextString(m) }
func (*DashboardVisualizeAnalysisInput) ProtoMessage()    {}
func (*DashboardVisualizeAnalysisInput) Descriptor() ([]byte, []int) {
	return fileDescriptor_b174f87a83ddb952, []int{42}
}

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

var xxx_messageInfo_DashboardVisualizeAnalysisInput proto.InternalMessageInfo

func (m *DashboardVisualizeAnalysisInput) GetRunKey() string {
	if m != nil && m.RunKey != nil {
		return *m.RunKey
	}
	return ""
}

func (m *DashboardVisualizeAnalysisInput) GetAnalysisKey() string {
	if m != nil && m.AnalysisKey != nil {
		return *m.AnalysisKey
	}
	return ""
}

type TestOption struct {
	Name                 *string  `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Value                *string  `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TestOption) Reset()         { *m = TestOption{} }
func (m *TestOption) String() string { return proto.CompactTextString(m) }
func (*TestOption) ProtoMessage()    {}
func (*TestOption) Descriptor() ([]byte, []int) {
	return fileDescriptor_b174f87a83ddb952, []int{43}
}

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

var xxx_messageInfo_TestOption proto.InternalMessageInfo

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

func (m *TestOption) GetValue() string {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return ""
}

type TestInput struct {
	BenchmarkKey         *string           `protobuf:"bytes,1,opt,name=benchmark_key,json=benchmarkKey" json:"benchmark_key,omitempty"`
	TempDir              *string           `protobuf:"bytes,2,opt,name=temp_dir,json=tempDir" json:"temp_dir,omitempty"`
	TimeoutSec           *float64          `protobuf:"fixed64,3,opt,name=timeout_sec,json=timeoutSec" json:"timeout_sec,omitempty"`
	TestOptionList       []*TestOption     `protobuf:"bytes,4,rep,name=test_option_list,json=testOptionList" json:"test_option_list,omitempty"`
	Tags                 []string          `protobuf:"bytes,6,rep,name=tags" json:"tags,omitempty"`
	TestPassId           *string           `protobuf:"bytes,7,opt,name=test_pass_id,json=testPassId" json:"test_pass_id,omitempty"`
	BuildId              *int64            `protobuf:"varint,8,opt,name=build_id,json=buildId" json:"build_id,omitempty"`
	InternalTestOptions  map[string]string `protobuf:"bytes,10,rep,name=internal_test_options,json=internalTestOptions" json:"internal_test_options,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *TestInput) Reset()         { *m = TestInput{} }
func (m *TestInput) String() string { return proto.CompactTextString(m) }
func (*TestInput) ProtoMessage()    {}
func (*TestInput) Descriptor() ([]byte, []int) {
	return fileDescriptor_b174f87a83ddb952, []int{44}
}

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

var xxx_messageInfo_TestInput proto.InternalMessageInfo

func (m *TestInput) GetBenchmarkKey() string {
	if m != nil && m.BenchmarkKey != nil {
		return *m.BenchmarkKey
	}
	return ""
}

func (m *TestInput) GetTempDir() string {
	if m != nil && m.TempDir != nil {
		return *m.TempDir
	}
	return ""
}

func (m *TestInput) GetTimeoutSec() float64 {
	if m != nil && m.TimeoutSec != nil {
		return *m.TimeoutSec
	}
	return 0
}

func (m *TestInput) GetTestOptionList() []*TestOption {
	if m != nil {
		return m.TestOptionList
	}
	return nil
}

func (m *TestInput) GetTags() []string {
	if m != nil {
		return m.Tags
	}
	return nil
}

func (m *TestInput) GetTestPassId() string {
	if m != nil && m.TestPassId != nil {
		return *m.TestPassId
	}
	return ""
}

func (m *TestInput) GetBuildId() int64 {
	if m != nil && m.BuildId != nil {
		return *m.BuildId
	}
	return 0
}

func (m *TestInput) GetInternalTestOptions() map[string]string {
	if m != nil {
		return m.InternalTestOptions
	}
	return nil
}

type TestOutput struct {
	TestStatus           *TestOutput_TestStatus           `protobuf:"varint,1,opt,name=test_status,json=testStatus,enum=mako.TestOutput_TestStatus" json:"test_status,omitempty"`
	AnalyzerOutputList   []*AnalyzerOutput                `protobuf:"bytes,2,rep,name=analyzer_output_list,json=analyzerOutputList" json:"analyzer_output_list,omitempty"`
	SummaryOutput        *string                          `protobuf:"bytes,3,opt,name=summary_output,json=summaryOutput" json:"summary_output,omitempty"`
	RunChartLink         *string                          `protobuf:"bytes,4,opt,name=run_chart_link,json=runChartLink" json:"run_chart_link,omitempty"`
	RunKey               *string                          `protobuf:"bytes,5,opt,name=run_key,json=runKey" json:"run_key,omitempty"`
	RetryableFailureType *TestOutput_RetryableFailureType `protobuf:"varint,6,opt,name=retryable_failure_type,json=retryableFailureType,enum=mako.TestOutput_RetryableFailureType" json:"retryable_failure_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                         `json:"-"`
	XXX_unrecognized     []byte                           `json:"-"`
	XXX_sizecache        int32                            `json:"-"`
}

func (m *TestOutput) Reset()         { *m = TestOutput{} }
func (m *TestOutput) String() string { return proto.CompactTextString(m) }
func (*TestOutput) ProtoMessage()    {}
func (*TestOutput) Descriptor() ([]byte, []int) {
	return fileDescriptor_b174f87a83ddb952, []int{45}
}

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

var xxx_messageInfo_TestOutput proto.InternalMessageInfo

func (m *TestOutput) GetTestStatus() TestOutput_TestStatus {
	if m != nil && m.TestStatus != nil {
		return *m.TestStatus
	}
	return TestOutput_PASS
}

func (m *TestOutput) GetAnalyzerOutputList() []*AnalyzerOutput {
	if m != nil {
		return m.AnalyzerOutputList
	}
	return nil
}

func (m *TestOutput) GetSummaryOutput() string {
	if m != nil && m.SummaryOutput != nil {
		return *m.SummaryOutput
	}
	return ""
}

func (m *TestOutput) GetRunChartLink() string {
	if m != nil && m.RunChartLink != nil {
		return *m.RunChartLink
	}
	return ""
}

func (m *TestOutput) GetRunKey() string {
	if m != nil && m.RunKey != nil {
		return *m.RunKey
	}
	return ""
}

func (m *TestOutput) GetRetryableFailureType() TestOutput_RetryableFailureType {
	if m != nil && m.RetryableFailureType != nil {
		return *m.RetryableFailureType
	}
	return TestOutput_UNKNOWN_OR_UNSET_TYPE
}

type SampleRecord struct {
	SamplePoint          *SamplePoint `protobuf:"bytes,1,opt,name=sample_point,json=samplePoint" json:"sample_point,omitempty"`
	SampleError          *SampleError `protobuf:"bytes,2,opt,name=sample_error,json=sampleError" json:"sample_error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *SampleRecord) Reset()         { *m = SampleRecord{} }
func (m *SampleRecord) String() string { return proto.CompactTextString(m) }
func (*SampleRecord) ProtoMessage()    {}
func (*SampleRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_b174f87a83ddb952, []int{46}
}

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

var xxx_messageInfo_SampleRecord proto.InternalMessageInfo

func (m *SampleRecord) GetSamplePoint() *SamplePoint {
	if m != nil {
		return m.SamplePoint
	}
	return nil
}

func (m *SampleRecord) GetSampleError() *SampleError {
	if m != nil {
		return m.SampleError
	}
	return nil
}

type SampleFile struct {
	SamplerName          *string  `protobuf:"bytes,1,opt,name=sampler_name,json=samplerName" json:"sampler_name,omitempty"`
	FilePath             *string  `protobuf:"bytes,2,opt,name=file_path,json=filePath" json:"file_path,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SampleFile) Reset()         { *m = SampleFile{} }
func (m *SampleFile) String() string { return proto.CompactTextString(m) }
func (*SampleFile) ProtoMessage()    {}
func (*SampleFile) Descriptor() ([]byte, []int) {
	return fileDescriptor_b174f87a83ddb952, []int{47}
}

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

var xxx_messageInfo_SampleFile proto.InternalMessageInfo

func (m *SampleFile) GetSamplerName() string {
	if m != nil && m.SamplerName != nil {
		return *m.SamplerName
	}
	return ""
}

func (m *SampleFile) GetFilePath() string {
	if m != nil && m.FilePath != nil {
		return *m.FilePath
	}
	return ""
}

func init() {
	proto.RegisterEnum("mako.RunOrder", RunOrder_name, RunOrder_value)
	proto.RegisterEnum("mako.Status_Code", Status_Code_name, Status_Code_value)
	proto.RegisterEnum("mako.ValueInfo_Type", ValueInfo_Type_name, ValueInfo_Type_value)
	proto.RegisterEnum("mako.DataFilter_DataType", DataFilter_DataType_name, DataFilter_DataType_value)
	proto.RegisterEnum("mako.AnalysisTriageInfo_AnalysisTriageType", AnalysisTriageInfo_AnalysisTriageType_name, AnalysisTriageInfo_AnalysisTriageType_value)
	proto.RegisterEnum("mako.AnalysisTriageInfo_EnvironmentType", AnalysisTriageInfo_EnvironmentType_name, AnalysisTriageInfo_EnvironmentType_value)
	proto.RegisterEnum("mako.TestOutput_TestStatus", TestOutput_TestStatus_name, TestOutput_TestStatus_value)
	proto.RegisterEnum("mako.TestOutput_RetryableFailureType", TestOutput_RetryableFailureType_name, TestOutput_RetryableFailureType_value)
	proto.RegisterType((*Status)(nil), "mako.Status")
	proto.RegisterType((*ValueInfo)(nil), "mako.ValueInfo")
	proto.RegisterType((*KeyedValue)(nil), "mako.KeyedValue")
	proto.RegisterType((*NamedData)(nil), "mako.NamedData")
	proto.RegisterType((*Range)(nil), "mako.Range")
	proto.RegisterType((*LabeledRange)(nil), "mako.LabeledRange")
	proto.RegisterType((*DataFilter)(nil), "mako.DataFilter")
	proto.RegisterType((*RunBundle)(nil), "mako.RunBundle")
	proto.RegisterType((*BenchmarkInfo)(nil), "mako.BenchmarkInfo")
	proto.RegisterType((*RunAnnotation)(nil), "mako.RunAnnotation")
	proto.RegisterType((*RunInfo)(nil), "mako.RunInfo")
	proto.RegisterType((*SamplePoint)(nil), "mako.SamplePoint")
	proto.RegisterMapType((map[string][]byte)(nil), "mako.SamplePoint.AuxDataEntry")
	proto.RegisterType((*SampleAnnotation)(nil), "mako.SampleAnnotation")
	proto.RegisterType((*SampleError)(nil), "mako.SampleError")
	proto.RegisterType((*SampleBatch)(nil), "mako.SampleBatch")
	proto.RegisterType((*MetricAggregate)(nil), "mako.MetricAggregate")
	proto.RegisterType((*RunAggregate)(nil), "mako.RunAggregate")
	proto.RegisterType((*Aggregate)(nil), "mako.Aggregate")
	proto.RegisterType((*BenchmarkInfoQuery)(nil), "mako.BenchmarkInfoQuery")
	proto.RegisterType((*BenchmarkInfoQueryResponse)(nil), "mako.BenchmarkInfoQueryResponse")
	proto.RegisterType((*RunInfoQuery)(nil), "mako.RunInfoQuery")
	proto.RegisterType((*RunInfoQueryResponse)(nil), "mako.RunInfoQueryResponse")
	proto.RegisterType((*SampleBatchQuery)(nil), "mako.SampleBatchQuery")
	proto.RegisterType((*SampleBatchQueryResponse)(nil), "mako.SampleBatchQueryResponse")
	proto.RegisterType((*CreationResponse)(nil), "mako.CreationResponse")
	proto.RegisterType((*ModificationResponse)(nil), "mako.ModificationResponse")
	proto.RegisterType((*CountResponse)(nil), "mako.CountResponse")
	proto.RegisterType((*SecondaryStorageWriteInput)(nil), "mako.SecondaryStorageWriteInput")
	proto.RegisterType((*SecondaryStorageWriteOutput)(nil), "mako.SecondaryStorageWriteOutput")
	proto.RegisterType((*AggregatorInput)(nil), "mako.AggregatorInput")
	proto.RegisterType((*AggregatorOutput)(nil), "mako.AggregatorOutput")
	proto.RegisterType((*DownsamplerInput)(nil), "mako.DownsamplerInput")
	proto.RegisterType((*DownsamplerOutput)(nil), "mako.DownsamplerOutput")
	proto.RegisterType((*AnalyzerHistoricQueryInput)(nil), "mako.AnalyzerHistoricQueryInput")
	proto.RegisterType((*AnalyzerHistoricQueryOutput)(nil), "mako.AnalyzerHistoricQueryOutput")
	proto.RegisterMapType((map[string]*AnalyzerHistoricQueryOutput_RunInfoQueries)(nil), "mako.AnalyzerHistoricQueryOutput.RunInfoQueryMapEntry")
	proto.RegisterType((*AnalyzerHistoricQueryOutput_RunInfoQueries)(nil), "mako.AnalyzerHistoricQueryOutput.RunInfoQueries")
	proto.RegisterType((*AnalyzerInput)(nil), "mako.AnalyzerInput")
	proto.RegisterMapType((map[string]*AnalyzerInput_RunBundles)(nil), "mako.AnalyzerInput.HistoricalRunMapEntry")
	proto.RegisterType((*AnalyzerInput_RunBundles)(nil), "mako.AnalyzerInput.RunBundles")
	proto.RegisterType((*AnalyzerOutput)(nil), "mako.AnalyzerOutput")
	proto.RegisterType((*AnalysisTriageInfo)(nil), "mako.AnalysisTriageInfo")
	proto.RegisterType((*DashboardAggregateChartInput)(nil), "mako.DashboardAggregateChartInput")
	proto.RegisterType((*DashboardRunChartInput)(nil), "mako.DashboardRunChartInput")
	proto.RegisterType((*DashboardCompareAggregateChartInput)(nil), "mako.DashboardCompareAggregateChartInput")
	proto.RegisterType((*DashboardCompareAggregateChartInput_Series)(nil), "mako.DashboardCompareAggregateChartInput.Series")
	proto.RegisterType((*DashboardCompareRunChartInput)(nil), "mako.DashboardCompareRunChartInput")
	proto.RegisterType((*DashboardVisualizeAnalysisInput)(nil), "mako.DashboardVisualizeAnalysisInput")
	proto.RegisterType((*TestOption)(nil), "mako.TestOption")
	proto.RegisterType((*TestInput)(nil), "mako.TestInput")
	proto.RegisterMapType((map[string]string)(nil), "mako.TestInput.InternalTestOptionsEntry")
	proto.RegisterType((*TestOutput)(nil), "mako.TestOutput")
	proto.RegisterType((*SampleRecord)(nil), "mako.SampleRecord")
	proto.RegisterType((*SampleFile)(nil), "mako.SampleFile")
}

func init() { proto.RegisterFile("spec/proto/mako.proto", fileDescriptor_b174f87a83ddb952) }

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