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

package schema_go_proto

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	storage_go_proto "kythe.io/kythe/proto/storage_go_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 NodeKind int32

const (
	NodeKind_UNKNOWN_NODE_KIND NodeKind = 0
	NodeKind_ABS               NodeKind = 1
	NodeKind_ABSVAR            NodeKind = 2
	NodeKind_ANCHOR            NodeKind = 3
	NodeKind_CONSTANT          NodeKind = 4
	NodeKind_DIAGNOSTIC        NodeKind = 5
	NodeKind_DOC               NodeKind = 6
	NodeKind_FILE              NodeKind = 7
	NodeKind_INTERFACE         NodeKind = 8
	NodeKind_FUNCTION          NodeKind = 9
	NodeKind_LOOKUP            NodeKind = 10
	NodeKind_MACRO             NodeKind = 11
	NodeKind_META              NodeKind = 12
	NodeKind_NAME              NodeKind = 13
	NodeKind_PACKAGE           NodeKind = 14
	NodeKind_PROCESS           NodeKind = 15
	NodeKind_RECORD            NodeKind = 16
	NodeKind_SUM               NodeKind = 17
	NodeKind_SYMBOL            NodeKind = 18
	NodeKind_TALIAS            NodeKind = 19
	NodeKind_TAPP              NodeKind = 20
	NodeKind_TBUILTIN          NodeKind = 21
	NodeKind_TNOMINAL          NodeKind = 22
	NodeKind_TSIGMA            NodeKind = 23
	NodeKind_VARIABLE          NodeKind = 24
	NodeKind_VCS               NodeKind = 25
)

var NodeKind_name = map[int32]string{
	0:  "UNKNOWN_NODE_KIND",
	1:  "ABS",
	2:  "ABSVAR",
	3:  "ANCHOR",
	4:  "CONSTANT",
	5:  "DIAGNOSTIC",
	6:  "DOC",
	7:  "FILE",
	8:  "INTERFACE",
	9:  "FUNCTION",
	10: "LOOKUP",
	11: "MACRO",
	12: "META",
	13: "NAME",
	14: "PACKAGE",
	15: "PROCESS",
	16: "RECORD",
	17: "SUM",
	18: "SYMBOL",
	19: "TALIAS",
	20: "TAPP",
	21: "TBUILTIN",
	22: "TNOMINAL",
	23: "TSIGMA",
	24: "VARIABLE",
	25: "VCS",
}

var NodeKind_value = map[string]int32{
	"UNKNOWN_NODE_KIND": 0,
	"ABS":               1,
	"ABSVAR":            2,
	"ANCHOR":            3,
	"CONSTANT":          4,
	"DIAGNOSTIC":        5,
	"DOC":               6,
	"FILE":              7,
	"INTERFACE":         8,
	"FUNCTION":          9,
	"LOOKUP":            10,
	"MACRO":             11,
	"META":              12,
	"NAME":              13,
	"PACKAGE":           14,
	"PROCESS":           15,
	"RECORD":            16,
	"SUM":               17,
	"SYMBOL":            18,
	"TALIAS":            19,
	"TAPP":              20,
	"TBUILTIN":          21,
	"TNOMINAL":          22,
	"TSIGMA":            23,
	"VARIABLE":          24,
	"VCS":               25,
}

func (x NodeKind) String() string {
	return proto.EnumName(NodeKind_name, int32(x))
}

func (NodeKind) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a9abda27437812b0, []int{0}
}

type Subkind int32

const (
	Subkind_UNKNOWN_SUBKIND Subkind = 0
	Subkind_CATEGORY        Subkind = 1
	Subkind_CLASS           Subkind = 2
	Subkind_CONSTRUCTOR     Subkind = 3
	Subkind_DESTRUCTOR      Subkind = 4
	Subkind_ENUM            Subkind = 5
	Subkind_ENUM_CLASS      Subkind = 6
	Subkind_FIELD           Subkind = 7
	Subkind_IMPLICIT        Subkind = 8
	Subkind_IMPORT          Subkind = 9
	Subkind_INITIALIZER     Subkind = 10
	Subkind_LOCAL           Subkind = 11
	Subkind_LOCAL_PARAMETER Subkind = 12
	Subkind_METHOD          Subkind = 13
	Subkind_NAMESPACE       Subkind = 14
	Subkind_STRUCT          Subkind = 15
	Subkind_TYPE            Subkind = 16
	Subkind_UNION           Subkind = 17
)

var Subkind_name = map[int32]string{
	0:  "UNKNOWN_SUBKIND",
	1:  "CATEGORY",
	2:  "CLASS",
	3:  "CONSTRUCTOR",
	4:  "DESTRUCTOR",
	5:  "ENUM",
	6:  "ENUM_CLASS",
	7:  "FIELD",
	8:  "IMPLICIT",
	9:  "IMPORT",
	10: "INITIALIZER",
	11: "LOCAL",
	12: "LOCAL_PARAMETER",
	13: "METHOD",
	14: "NAMESPACE",
	15: "STRUCT",
	16: "TYPE",
	17: "UNION",
}

var Subkind_value = map[string]int32{
	"UNKNOWN_SUBKIND": 0,
	"CATEGORY":        1,
	"CLASS":           2,
	"CONSTRUCTOR":     3,
	"DESTRUCTOR":      4,
	"ENUM":            5,
	"ENUM_CLASS":      6,
	"FIELD":           7,
	"IMPLICIT":        8,
	"IMPORT":          9,
	"INITIALIZER":     10,
	"LOCAL":           11,
	"LOCAL_PARAMETER": 12,
	"METHOD":          13,
	"NAMESPACE":       14,
	"STRUCT":          15,
	"TYPE":            16,
	"UNION":           17,
}

func (x Subkind) String() string {
	return proto.EnumName(Subkind_name, int32(x))
}

func (Subkind) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a9abda27437812b0, []int{1}
}

type FactName int32

const (
	FactName_UNKNOWN_FACT_NAME FactName = 0
	FactName_CODE              FactName = 1
	FactName_COMPLETE          FactName = 2
	FactName_CONTEXT_URL       FactName = 3
	FactName_DETAILS           FactName = 4
	FactName_DOC_URI           FactName = 5
	FactName_LABEL             FactName = 6
	FactName_LOC_END           FactName = 7
	FactName_LOC_START         FactName = 8
	FactName_MESSAGE           FactName = 9
	FactName_NODE_KIND         FactName = 10
	FactName_PARAM_DEFAULT     FactName = 11
	FactName_RULE_CLASS        FactName = 12
	FactName_SNIPPET_END       FactName = 13
	FactName_SNIPPET_START     FactName = 14
	FactName_SUBKIND           FactName = 15
	FactName_TEXT              FactName = 16
	FactName_TEXT_ENCODING     FactName = 17
	FactName_VISIBILITY        FactName = 18
	FactName_BUILD_CONFIG      FactName = 19
)

var FactName_name = map[int32]string{
	0:  "UNKNOWN_FACT_NAME",
	1:  "CODE",
	2:  "COMPLETE",
	3:  "CONTEXT_URL",
	4:  "DETAILS",
	5:  "DOC_URI",
	6:  "LABEL",
	7:  "LOC_END",
	8:  "LOC_START",
	9:  "MESSAGE",
	10: "NODE_KIND",
	11: "PARAM_DEFAULT",
	12: "RULE_CLASS",
	13: "SNIPPET_END",
	14: "SNIPPET_START",
	15: "SUBKIND",
	16: "TEXT",
	17: "TEXT_ENCODING",
	18: "VISIBILITY",
	19: "BUILD_CONFIG",
}

var FactName_value = map[string]int32{
	"UNKNOWN_FACT_NAME": 0,
	"CODE":              1,
	"COMPLETE":          2,
	"CONTEXT_URL":       3,
	"DETAILS":           4,
	"DOC_URI":           5,
	"LABEL":             6,
	"LOC_END":           7,
	"LOC_START":         8,
	"MESSAGE":           9,
	"NODE_KIND":         10,
	"PARAM_DEFAULT":     11,
	"RULE_CLASS":        12,
	"SNIPPET_END":       13,
	"SNIPPET_START":     14,
	"SUBKIND":           15,
	"TEXT":              16,
	"TEXT_ENCODING":     17,
	"VISIBILITY":        18,
	"BUILD_CONFIG":      19,
}

func (x FactName) String() string {
	return proto.EnumName(FactName_name, int32(x))
}

func (FactName) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a9abda27437812b0, []int{2}
}

type EdgeKind int32

const (
	EdgeKind_UNKNOWN_EDGE_KIND        EdgeKind = 0
	EdgeKind_ALIASES                  EdgeKind = 1
	EdgeKind_ALIASES_ROOT             EdgeKind = 2
	EdgeKind_ANNOTATED_BY             EdgeKind = 3
	EdgeKind_BOUNDED_LOWER            EdgeKind = 4
	EdgeKind_BOUNDED_UPPER            EdgeKind = 5
	EdgeKind_CHILD_OF                 EdgeKind = 6
	EdgeKind_CHILD_OF_CONTEXT         EdgeKind = 7
	EdgeKind_COMPLETES                EdgeKind = 8
	EdgeKind_COMPLETES_UNIQUELY       EdgeKind = 9
	EdgeKind_DEFINES                  EdgeKind = 10
	EdgeKind_DEFINES_BINDING          EdgeKind = 11
	EdgeKind_DEPENDS                  EdgeKind = 12
	EdgeKind_DOCUMENTS                EdgeKind = 13
	EdgeKind_EXPORTS                  EdgeKind = 14
	EdgeKind_EXTENDS                  EdgeKind = 15
	EdgeKind_GENERATES                EdgeKind = 16
	EdgeKind_IMPUTES                  EdgeKind = 17
	EdgeKind_INSTANTIATES             EdgeKind = 18
	EdgeKind_INSTANTIATES_SPECULATIVE EdgeKind = 19
	EdgeKind_NAMED                    EdgeKind = 20
	EdgeKind_OVERRIDES                EdgeKind = 21
	EdgeKind_OVERRIDES_ROOT           EdgeKind = 22
	EdgeKind_OVERRIDES_TRANSITIVE     EdgeKind = 23
	EdgeKind_PARAM                    EdgeKind = 24
	EdgeKind_REF                      EdgeKind = 25
	EdgeKind_REF_CALL                 EdgeKind = 26
	EdgeKind_REF_CALL_IMPLICIT        EdgeKind = 27
	EdgeKind_REF_DOC                  EdgeKind = 28
	EdgeKind_REF_EXPANDS              EdgeKind = 29
	EdgeKind_REF_EXPANDS_TRANSITIVE   EdgeKind = 30
	EdgeKind_REF_FILE                 EdgeKind = 31
	EdgeKind_REF_IMPLICIT             EdgeKind = 32
	EdgeKind_REF_IMPORTS              EdgeKind = 33
	EdgeKind_REF_INCLUDES             EdgeKind = 34
	EdgeKind_REF_INIT                 EdgeKind = 35
	EdgeKind_REF_INIT_IMPLICIT        EdgeKind = 36
	EdgeKind_REF_QUERIES              EdgeKind = 37
	EdgeKind_SATISFIES                EdgeKind = 38
	EdgeKind_SPECIALIZES              EdgeKind = 39
	EdgeKind_SPECIALIZES_SPECULATIVE  EdgeKind = 40
	EdgeKind_TAGGED                   EdgeKind = 41
	EdgeKind_TYPED                    EdgeKind = 42
	EdgeKind_UNDEFINES                EdgeKind = 43
)

var EdgeKind_name = map[int32]string{
	0:  "UNKNOWN_EDGE_KIND",
	1:  "ALIASES",
	2:  "ALIASES_ROOT",
	3:  "ANNOTATED_BY",
	4:  "BOUNDED_LOWER",
	5:  "BOUNDED_UPPER",
	6:  "CHILD_OF",
	7:  "CHILD_OF_CONTEXT",
	8:  "COMPLETES",
	9:  "COMPLETES_UNIQUELY",
	10: "DEFINES",
	11: "DEFINES_BINDING",
	12: "DEPENDS",
	13: "DOCUMENTS",
	14: "EXPORTS",
	15: "EXTENDS",
	16: "GENERATES",
	17: "IMPUTES",
	18: "INSTANTIATES",
	19: "INSTANTIATES_SPECULATIVE",
	20: "NAMED",
	21: "OVERRIDES",
	22: "OVERRIDES_ROOT",
	23: "OVERRIDES_TRANSITIVE",
	24: "PARAM",
	25: "REF",
	26: "REF_CALL",
	27: "REF_CALL_IMPLICIT",
	28: "REF_DOC",
	29: "REF_EXPANDS",
	30: "REF_EXPANDS_TRANSITIVE",
	31: "REF_FILE",
	32: "REF_IMPLICIT",
	33: "REF_IMPORTS",
	34: "REF_INCLUDES",
	35: "REF_INIT",
	36: "REF_INIT_IMPLICIT",
	37: "REF_QUERIES",
	38: "SATISFIES",
	39: "SPECIALIZES",
	40: "SPECIALIZES_SPECULATIVE",
	41: "TAGGED",
	42: "TYPED",
	43: "UNDEFINES",
}

var EdgeKind_value = map[string]int32{
	"UNKNOWN_EDGE_KIND":        0,
	"ALIASES":                  1,
	"ALIASES_ROOT":             2,
	"ANNOTATED_BY":             3,
	"BOUNDED_LOWER":            4,
	"BOUNDED_UPPER":            5,
	"CHILD_OF":                 6,
	"CHILD_OF_CONTEXT":         7,
	"COMPLETES":                8,
	"COMPLETES_UNIQUELY":       9,
	"DEFINES":                  10,
	"DEFINES_BINDING":          11,
	"DEPENDS":                  12,
	"DOCUMENTS":                13,
	"EXPORTS":                  14,
	"EXTENDS":                  15,
	"GENERATES":                16,
	"IMPUTES":                  17,
	"INSTANTIATES":             18,
	"INSTANTIATES_SPECULATIVE": 19,
	"NAMED":                    20,
	"OVERRIDES":                21,
	"OVERRIDES_ROOT":           22,
	"OVERRIDES_TRANSITIVE":     23,
	"PARAM":                    24,
	"REF":                      25,
	"REF_CALL":                 26,
	"REF_CALL_IMPLICIT":        27,
	"REF_DOC":                  28,
	"REF_EXPANDS":              29,
	"REF_EXPANDS_TRANSITIVE":   30,
	"REF_FILE":                 31,
	"REF_IMPLICIT":             32,
	"REF_IMPORTS":              33,
	"REF_INCLUDES":             34,
	"REF_INIT":                 35,
	"REF_INIT_IMPLICIT":        36,
	"REF_QUERIES":              37,
	"SATISFIES":                38,
	"SPECIALIZES":              39,
	"SPECIALIZES_SPECULATIVE":  40,
	"TAGGED":                   41,
	"TYPED":                    42,
	"UNDEFINES":                43,
}

func (x EdgeKind) String() string {
	return proto.EnumName(EdgeKind_name, int32(x))
}

func (EdgeKind) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a9abda27437812b0, []int{3}
}

type Index struct {
	EdgeKinds            []*Index_EdgeKinds `protobuf:"bytes,1,rep,name=edge_kinds,json=edgeKinds,proto3" json:"edge_kinds,omitempty"`
	NodeKinds            []*Index_NodeKinds `protobuf:"bytes,2,rep,name=node_kinds,json=nodeKinds,proto3" json:"node_kinds,omitempty"`
	Subkinds             []*Index_Subkinds  `protobuf:"bytes,3,rep,name=subkinds,proto3" json:"subkinds,omitempty"`
	FactNames            []*Index_FactNames `protobuf:"bytes,4,rep,name=fact_names,json=factNames,proto3" json:"fact_names,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

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

var xxx_messageInfo_Index proto.InternalMessageInfo

func (m *Index) GetEdgeKinds() []*Index_EdgeKinds {
	if m != nil {
		return m.EdgeKinds
	}
	return nil
}

func (m *Index) GetNodeKinds() []*Index_NodeKinds {
	if m != nil {
		return m.NodeKinds
	}
	return nil
}

func (m *Index) GetSubkinds() []*Index_Subkinds {
	if m != nil {
		return m.Subkinds
	}
	return nil
}

func (m *Index) GetFactNames() []*Index_FactNames {
	if m != nil {
		return m.FactNames
	}
	return nil
}

type Index_EdgeKinds struct {
	Prefix               string              `protobuf:"bytes,1,opt,name=prefix,proto3" json:"prefix,omitempty"`
	EdgeKind             map[string]EdgeKind `protobuf:"bytes,2,rep,name=edge_kind,json=edgeKind,proto3" json:"edge_kind,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=kythe.proto.schema.EdgeKind"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_Index_EdgeKinds proto.InternalMessageInfo

func (m *Index_EdgeKinds) GetPrefix() string {
	if m != nil {
		return m.Prefix
	}
	return ""
}

func (m *Index_EdgeKinds) GetEdgeKind() map[string]EdgeKind {
	if m != nil {
		return m.EdgeKind
	}
	return nil
}

type Index_NodeKinds struct {
	Prefix               string              `protobuf:"bytes,1,opt,name=prefix,proto3" json:"prefix,omitempty"`
	NodeKind             map[string]NodeKind `protobuf:"bytes,2,rep,name=node_kind,json=nodeKind,proto3" json:"node_kind,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=kythe.proto.schema.NodeKind"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_Index_NodeKinds proto.InternalMessageInfo

func (m *Index_NodeKinds) GetPrefix() string {
	if m != nil {
		return m.Prefix
	}
	return ""
}

func (m *Index_NodeKinds) GetNodeKind() map[string]NodeKind {
	if m != nil {
		return m.NodeKind
	}
	return nil
}

type Index_Subkinds struct {
	Prefix               string             `protobuf:"bytes,1,opt,name=prefix,proto3" json:"prefix,omitempty"`
	Subkind              map[string]Subkind `protobuf:"bytes,2,rep,name=subkind,proto3" json:"subkind,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=kythe.proto.schema.Subkind"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

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

var xxx_messageInfo_Index_Subkinds proto.InternalMessageInfo

func (m *Index_Subkinds) GetPrefix() string {
	if m != nil {
		return m.Prefix
	}
	return ""
}

func (m *Index_Subkinds) GetSubkind() map[string]Subkind {
	if m != nil {
		return m.Subkind
	}
	return nil
}

type Index_FactNames struct {
	Prefix               string              `protobuf:"bytes,1,opt,name=prefix,proto3" json:"prefix,omitempty"`
	FactName             map[string]FactName `protobuf:"bytes,2,rep,name=fact_name,json=factName,proto3" json:"fact_name,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=kythe.proto.schema.FactName"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_Index_FactNames proto.InternalMessageInfo

func (m *Index_FactNames) GetPrefix() string {
	if m != nil {
		return m.Prefix
	}
	return ""
}

func (m *Index_FactNames) GetFactName() map[string]FactName {
	if m != nil {
		return m.FactName
	}
	return nil
}

type Node struct {
	Source *storage_go_proto.VName `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"`
	Fact   []*Fact                 `protobuf:"bytes,2,rep,name=fact,proto3" json:"fact,omitempty"`
	Edge   []*Edge                 `protobuf:"bytes,3,rep,name=edge,proto3" json:"edge,omitempty"`
	// Types that are valid to be assigned to Kind:
	//	*Node_KytheKind
	//	*Node_GenericKind
	Kind isNode_Kind `protobuf_oneof:"kind"`
	// Types that are valid to be assigned to Subkind:
	//	*Node_KytheSubkind
	//	*Node_GenericSubkind
	Subkind              isNode_Subkind `protobuf_oneof:"subkind"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_Node proto.InternalMessageInfo

func (m *Node) GetSource() *storage_go_proto.VName {
	if m != nil {
		return m.Source
	}
	return nil
}

func (m *Node) GetFact() []*Fact {
	if m != nil {
		return m.Fact
	}
	return nil
}

func (m *Node) GetEdge() []*Edge {
	if m != nil {
		return m.Edge
	}
	return nil
}

type isNode_Kind interface {
	isNode_Kind()
}

type Node_KytheKind struct {
	KytheKind NodeKind `protobuf:"varint,4,opt,name=kythe_kind,json=kytheKind,proto3,enum=kythe.proto.schema.NodeKind,oneof"`
}

type Node_GenericKind struct {
	GenericKind string `protobuf:"bytes,5,opt,name=generic_kind,json=genericKind,proto3,oneof"`
}

func (*Node_KytheKind) isNode_Kind() {}

func (*Node_GenericKind) isNode_Kind() {}

func (m *Node) GetKind() isNode_Kind {
	if m != nil {
		return m.Kind
	}
	return nil
}

func (m *Node) GetKytheKind() NodeKind {
	if x, ok := m.GetKind().(*Node_KytheKind); ok {
		return x.KytheKind
	}
	return NodeKind_UNKNOWN_NODE_KIND
}

func (m *Node) GetGenericKind() string {
	if x, ok := m.GetKind().(*Node_GenericKind); ok {
		return x.GenericKind
	}
	return ""
}

type isNode_Subkind interface {
	isNode_Subkind()
}

type Node_KytheSubkind struct {
	KytheSubkind Subkind `protobuf:"varint,6,opt,name=kythe_subkind,json=kytheSubkind,proto3,enum=kythe.proto.schema.Subkind,oneof"`
}

type Node_GenericSubkind struct {
	GenericSubkind string `protobuf:"bytes,7,opt,name=generic_subkind,json=genericSubkind,proto3,oneof"`
}

func (*Node_KytheSubkind) isNode_Subkind() {}

func (*Node_GenericSubkind) isNode_Subkind() {}

func (m *Node) GetSubkind() isNode_Subkind {
	if m != nil {
		return m.Subkind
	}
	return nil
}

func (m *Node) GetKytheSubkind() Subkind {
	if x, ok := m.GetSubkind().(*Node_KytheSubkind); ok {
		return x.KytheSubkind
	}
	return Subkind_UNKNOWN_SUBKIND
}

func (m *Node) GetGenericSubkind() string {
	if x, ok := m.GetSubkind().(*Node_GenericSubkind); ok {
		return x.GenericSubkind
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Node) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Node_KytheKind)(nil),
		(*Node_GenericKind)(nil),
		(*Node_KytheSubkind)(nil),
		(*Node_GenericSubkind)(nil),
	}
}

type Fact struct {
	Source *storage_go_proto.VName `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"`
	// Types that are valid to be assigned to Name:
	//	*Fact_KytheName
	//	*Fact_GenericName
	Name                 isFact_Name `protobuf_oneof:"name"`
	Value                []byte      `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_Fact proto.InternalMessageInfo

func (m *Fact) GetSource() *storage_go_proto.VName {
	if m != nil {
		return m.Source
	}
	return nil
}

type isFact_Name interface {
	isFact_Name()
}

type Fact_KytheName struct {
	KytheName FactName `protobuf:"varint,2,opt,name=kythe_name,json=kytheName,proto3,enum=kythe.proto.schema.FactName,oneof"`
}

type Fact_GenericName struct {
	GenericName string `protobuf:"bytes,3,opt,name=generic_name,json=genericName,proto3,oneof"`
}

func (*Fact_KytheName) isFact_Name() {}

func (*Fact_GenericName) isFact_Name() {}

func (m *Fact) GetName() isFact_Name {
	if m != nil {
		return m.Name
	}
	return nil
}

func (m *Fact) GetKytheName() FactName {
	if x, ok := m.GetName().(*Fact_KytheName); ok {
		return x.KytheName
	}
	return FactName_UNKNOWN_FACT_NAME
}

func (m *Fact) GetGenericName() string {
	if x, ok := m.GetName().(*Fact_GenericName); ok {
		return x.GenericName
	}
	return ""
}

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

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Fact) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Fact_KytheName)(nil),
		(*Fact_GenericName)(nil),
	}
}

type Edge struct {
	Source *storage_go_proto.VName `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"`
	Target *storage_go_proto.VName `protobuf:"bytes,2,opt,name=target,proto3" json:"target,omitempty"`
	// Types that are valid to be assigned to Kind:
	//	*Edge_KytheKind
	//	*Edge_GenericKind
	Kind                 isEdge_Kind `protobuf_oneof:"kind"`
	Ordinal              int32       `protobuf:"varint,5,opt,name=ordinal,proto3" json:"ordinal,omitempty"`
	SourceNode           *Node       `protobuf:"bytes,6,opt,name=source_node,json=sourceNode,proto3" json:"source_node,omitempty"`
	TargetNode           *Node       `protobuf:"bytes,7,opt,name=target_node,json=targetNode,proto3" json:"target_node,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_Edge proto.InternalMessageInfo

func (m *Edge) GetSource() *storage_go_proto.VName {
	if m != nil {
		return m.Source
	}
	return nil
}

func (m *Edge) GetTarget() *storage_go_proto.VName {
	if m != nil {
		return m.Target
	}
	return nil
}

type isEdge_Kind interface {
	isEdge_Kind()
}

type Edge_KytheKind struct {
	KytheKind EdgeKind `protobuf:"varint,3,opt,name=kythe_kind,json=kytheKind,proto3,enum=kythe.proto.schema.EdgeKind,oneof"`
}

type Edge_GenericKind struct {
	GenericKind string `protobuf:"bytes,4,opt,name=generic_kind,json=genericKind,proto3,oneof"`
}

func (*Edge_KytheKind) isEdge_Kind() {}

func (*Edge_GenericKind) isEdge_Kind() {}

func (m *Edge) GetKind() isEdge_Kind {
	if m != nil {
		return m.Kind
	}
	return nil
}

func (m *Edge) GetKytheKind() EdgeKind {
	if x, ok := m.GetKind().(*Edge_KytheKind); ok {
		return x.KytheKind
	}
	return EdgeKind_UNKNOWN_EDGE_KIND
}

func (m *Edge) GetGenericKind() string {
	if x, ok := m.GetKind().(*Edge_GenericKind); ok {
		return x.GenericKind
	}
	return ""
}

func (m *Edge) GetOrdinal() int32 {
	if m != nil {
		return m.Ordinal
	}
	return 0
}

func (m *Edge) GetSourceNode() *Node {
	if m != nil {
		return m.SourceNode
	}
	return nil
}

func (m *Edge) GetTargetNode() *Node {
	if m != nil {
		return m.TargetNode
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Edge) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Edge_KytheKind)(nil),
		(*Edge_GenericKind)(nil),
	}
}

type Entry struct {
	// Types that are valid to be assigned to Entry:
	//	*Entry_Fact
	//	*Entry_Edge
	Entry                isEntry_Entry `protobuf_oneof:"entry"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_Entry proto.InternalMessageInfo

type isEntry_Entry interface {
	isEntry_Entry()
}

type Entry_Fact struct {
	Fact *Fact `protobuf:"bytes,1,opt,name=fact,proto3,oneof"`
}

type Entry_Edge struct {
	Edge *Edge `protobuf:"bytes,2,opt,name=edge,proto3,oneof"`
}

func (*Entry_Fact) isEntry_Entry() {}

func (*Entry_Edge) isEntry_Entry() {}

func (m *Entry) GetEntry() isEntry_Entry {
	if m != nil {
		return m.Entry
	}
	return nil
}

func (m *Entry) GetFact() *Fact {
	if x, ok := m.GetEntry().(*Entry_Fact); ok {
		return x.Fact
	}
	return nil
}

func (m *Entry) GetEdge() *Edge {
	if x, ok := m.GetEntry().(*Entry_Edge); ok {
		return x.Edge
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Entry) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Entry_Fact)(nil),
		(*Entry_Edge)(nil),
	}
}

func init() {
	proto.RegisterEnum("kythe.proto.schema.NodeKind", NodeKind_name, NodeKind_value)
	proto.RegisterEnum("kythe.proto.schema.Subkind", Subkind_name, Subkind_value)
	proto.RegisterEnum("kythe.proto.schema.FactName", FactName_name, FactName_value)
	proto.RegisterEnum("kythe.proto.schema.EdgeKind", EdgeKind_name, EdgeKind_value)
	proto.RegisterType((*Index)(nil), "kythe.proto.schema.Index")
	proto.RegisterType((*Index_EdgeKinds)(nil), "kythe.proto.schema.Index.EdgeKinds")
	proto.RegisterMapType((map[string]EdgeKind)(nil), "kythe.proto.schema.Index.EdgeKinds.EdgeKindEntry")
	proto.RegisterType((*Index_NodeKinds)(nil), "kythe.proto.schema.Index.NodeKinds")
	proto.RegisterMapType((map[string]NodeKind)(nil), "kythe.proto.schema.Index.NodeKinds.NodeKindEntry")
	proto.RegisterType((*Index_Subkinds)(nil), "kythe.proto.schema.Index.Subkinds")
	proto.RegisterMapType((map[string]Subkind)(nil), "kythe.proto.schema.Index.Subkinds.SubkindEntry")
	proto.RegisterType((*Index_FactNames)(nil), "kythe.proto.schema.Index.FactNames")
	proto.RegisterMapType((map[string]FactName)(nil), "kythe.proto.schema.Index.FactNames.FactNameEntry")
	proto.RegisterType((*Node)(nil), "kythe.proto.schema.Node")
	proto.RegisterType((*Fact)(nil), "kythe.proto.schema.Fact")
	proto.RegisterType((*Edge)(nil), "kythe.proto.schema.Edge")
	proto.RegisterType((*Entry)(nil), "kythe.proto.schema.Entry")
}

func init() { proto.RegisterFile("kythe/proto/schema.proto", fileDescriptor_a9abda27437812b0) }

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