sysl.pb.go

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

package sysl

import (
	fmt "fmt"
	math "math"

	proto "github.com/golang/protobuf/proto"
)

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

// Deltas are diff annotations set for each major element in a model.
// TODO: Is this really needed? Investigate protobuf diff tools.
type Delta int32

const (
	Delta_NO_Delta     Delta = 0
	Delta_DELTA_SAME   Delta = 1
	Delta_DELTA_CHANGE Delta = 2
	Delta_DELTA_ADD    Delta = 3
	Delta_DELTA_REMOVE Delta = 4
)

var Delta_name = map[int32]string{
	0: "NO_Delta",
	1: "DELTA_SAME",
	2: "DELTA_CHANGE",
	3: "DELTA_ADD",
	4: "DELTA_REMOVE",
}

var Delta_value = map[string]int32{
	"NO_Delta":     0,
	"DELTA_SAME":   1,
	"DELTA_CHANGE": 2,
	"DELTA_ADD":    3,
	"DELTA_REMOVE": 4,
}

func (x Delta) String() string {
	return proto.EnumName(Delta_name, int32(x))
}

func (Delta) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a9d185230f424090, []int{0}
}

type Endpoint_RestParams_Method int32

const (
	Endpoint_RestParams_NO_Method        Endpoint_RestParams_Method = 0
	Endpoint_RestParams_GET              Endpoint_RestParams_Method = 1
	Endpoint_RestParams_PUT              Endpoint_RestParams_Method = 3
	Endpoint_RestParams_POST             Endpoint_RestParams_Method = 4
	Endpoint_RestParams_DELETE           Endpoint_RestParams_Method = 5
	Endpoint_RestParams_PATCH            Endpoint_RestParams_Method = 6
	Endpoint_RestParams_DONOTUSE_OPTIONS Endpoint_RestParams_Method = 7
	Endpoint_RestParams_DONOTUSE_HEAD    Endpoint_RestParams_Method = 2
)

var Endpoint_RestParams_Method_name = map[int32]string{
	0: "NO_Method",
	1: "GET",
	3: "PUT",
	4: "POST",
	5: "DELETE",
	6: "PATCH",
	7: "DONOTUSE_OPTIONS",
	2: "DONOTUSE_HEAD",
}

var Endpoint_RestParams_Method_value = map[string]int32{
	"NO_Method":        0,
	"GET":              1,
	"PUT":              3,
	"POST":             4,
	"DELETE":           5,
	"PATCH":            6,
	"DONOTUSE_OPTIONS": 7,
	"DONOTUSE_HEAD":    2,
}

func (x Endpoint_RestParams_Method) String() string {
	return proto.EnumName(Endpoint_RestParams_Method_name, int32(x))
}

func (Endpoint_RestParams_Method) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a9d185230f424090, []int{5, 1, 0}
}

type Loop_Mode int32

const (
	Loop_NO_Mode Loop_Mode = 0
	Loop_WHILE   Loop_Mode = 1
	Loop_UNTIL   Loop_Mode = 2
)

var Loop_Mode_name = map[int32]string{
	0: "NO_Mode",
	1: "WHILE",
	2: "UNTIL",
}

var Loop_Mode_value = map[string]int32{
	"NO_Mode": 0,
	"WHILE":   1,
	"UNTIL":   2,
}

func (x Loop_Mode) String() string {
	return proto.EnumName(Loop_Mode_name, int32(x))
}

func (Loop_Mode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a9d185230f424090, []int{11, 0}
}

type Type_Primitive int32

const (
	Type_NO_Primitive Type_Primitive = 0
	Type_EMPTY        Type_Primitive = 1
	Type_ANY          Type_Primitive = 2
	Type_BOOL         Type_Primitive = 3
	Type_INT          Type_Primitive = 4
	Type_FLOAT        Type_Primitive = 5
	Type_DECIMAL      Type_Primitive = 12
	// Unicode string (Python 2 unicode, Python 3 str, and SQL nvarchar).
	Type_STRING Type_Primitive = 6
	// Octet sequence, like Python 3 bytes and SQL varbinary.
	Type_BYTES Type_Primitive = 7
	// = STRING, but only 8-bit, like Python 2 str or SQL varchar.
	Type_STRING_8 Type_Primitive = 8
	Type_DATE     Type_Primitive = 9
	Type_DATETIME Type_Primitive = 10
	Type_XML      Type_Primitive = 11
	Type_UUID     Type_Primitive = 13
)

var Type_Primitive_name = map[int32]string{
	0:  "NO_Primitive",
	1:  "EMPTY",
	2:  "ANY",
	3:  "BOOL",
	4:  "INT",
	5:  "FLOAT",
	12: "DECIMAL",
	6:  "STRING",
	7:  "BYTES",
	8:  "STRING_8",
	9:  "DATE",
	10: "DATETIME",
	11: "XML",
	13: "UUID",
}

var Type_Primitive_value = map[string]int32{
	"NO_Primitive": 0,
	"EMPTY":        1,
	"ANY":          2,
	"BOOL":         3,
	"INT":          4,
	"FLOAT":        5,
	"DECIMAL":      12,
	"STRING":       6,
	"BYTES":        7,
	"STRING_8":     8,
	"DATE":         9,
	"DATETIME":     10,
	"XML":          11,
	"UUID":         13,
}

func (x Type_Primitive) String() string {
	return proto.EnumName(Type_Primitive_name, int32(x))
}

func (Type_Primitive) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a9d185230f424090, []int{17, 0}
}

type Expr_UnExpr_Op int32

const (
	Expr_UnExpr_NO_Op          Expr_UnExpr_Op = 0
	Expr_UnExpr_NEG            Expr_UnExpr_Op = 1
	Expr_UnExpr_POS            Expr_UnExpr_Op = 2
	Expr_UnExpr_NOT            Expr_UnExpr_Op = 3
	Expr_UnExpr_INV            Expr_UnExpr_Op = 4
	Expr_UnExpr_SINGLE         Expr_UnExpr_Op = 5
	Expr_UnExpr_SINGLE_OR_NULL Expr_UnExpr_Op = 6
	Expr_UnExpr_STRING         Expr_UnExpr_Op = 7
)

var Expr_UnExpr_Op_name = map[int32]string{
	0: "NO_Op",
	1: "NEG",
	2: "POS",
	3: "NOT",
	4: "INV",
	5: "SINGLE",
	6: "SINGLE_OR_NULL",
	7: "STRING",
}

var Expr_UnExpr_Op_value = map[string]int32{
	"NO_Op":          0,
	"NEG":            1,
	"POS":            2,
	"NOT":            3,
	"INV":            4,
	"SINGLE":         5,
	"SINGLE_OR_NULL": 6,
	"STRING":         7,
}

func (x Expr_UnExpr_Op) String() string {
	return proto.EnumName(Expr_UnExpr_Op_name, int32(x))
}

func (Expr_UnExpr_Op) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a9d185230f424090, []int{19, 6, 0}
}

type Expr_BinExpr_Op int32

const (
	Expr_BinExpr_NO_Op           Expr_BinExpr_Op = 0
	Expr_BinExpr_EQ              Expr_BinExpr_Op = 1
	Expr_BinExpr_NE              Expr_BinExpr_Op = 2
	Expr_BinExpr_LT              Expr_BinExpr_Op = 3
	Expr_BinExpr_LE              Expr_BinExpr_Op = 4
	Expr_BinExpr_GT              Expr_BinExpr_Op = 5
	Expr_BinExpr_GE              Expr_BinExpr_Op = 6
	Expr_BinExpr_IN              Expr_BinExpr_Op = 24
	Expr_BinExpr_CONTAINS        Expr_BinExpr_Op = 25
	Expr_BinExpr_NOT_IN          Expr_BinExpr_Op = 26
	Expr_BinExpr_NOT_CONTAINS    Expr_BinExpr_Op = 27
	Expr_BinExpr_ADD             Expr_BinExpr_Op = 7
	Expr_BinExpr_SUB             Expr_BinExpr_Op = 8
	Expr_BinExpr_MUL             Expr_BinExpr_Op = 9
	Expr_BinExpr_DIV             Expr_BinExpr_Op = 10
	Expr_BinExpr_MOD             Expr_BinExpr_Op = 11
	Expr_BinExpr_POW             Expr_BinExpr_Op = 12
	Expr_BinExpr_AND             Expr_BinExpr_Op = 13
	Expr_BinExpr_OR              Expr_BinExpr_Op = 14
	Expr_BinExpr_BUTNOT          Expr_BinExpr_Op = 21
	Expr_BinExpr_BITAND          Expr_BinExpr_Op = 15
	Expr_BinExpr_BITOR           Expr_BinExpr_Op = 16
	Expr_BinExpr_BITXOR          Expr_BinExpr_Op = 17
	Expr_BinExpr_COALESCE        Expr_BinExpr_Op = 18
	Expr_BinExpr_WHERE           Expr_BinExpr_Op = 19
	Expr_BinExpr_TO_MATCHING     Expr_BinExpr_Op = 20
	Expr_BinExpr_TO_NOT_MATCHING Expr_BinExpr_Op = 23
	Expr_BinExpr_FLATTEN         Expr_BinExpr_Op = 22
)

var Expr_BinExpr_Op_name = map[int32]string{
	0:  "NO_Op",
	1:  "EQ",
	2:  "NE",
	3:  "LT",
	4:  "LE",
	5:  "GT",
	6:  "GE",
	24: "IN",
	25: "CONTAINS",
	26: "NOT_IN",
	27: "NOT_CONTAINS",
	7:  "ADD",
	8:  "SUB",
	9:  "MUL",
	10: "DIV",
	11: "MOD",
	12: "POW",
	13: "AND",
	14: "OR",
	21: "BUTNOT",
	15: "BITAND",
	16: "BITOR",
	17: "BITXOR",
	18: "COALESCE",
	19: "WHERE",
	20: "TO_MATCHING",
	23: "TO_NOT_MATCHING",
	22: "FLATTEN",
}

var Expr_BinExpr_Op_value = map[string]int32{
	"NO_Op":           0,
	"EQ":              1,
	"NE":              2,
	"LT":              3,
	"LE":              4,
	"GT":              5,
	"GE":              6,
	"IN":              24,
	"CONTAINS":        25,
	"NOT_IN":          26,
	"NOT_CONTAINS":    27,
	"ADD":             7,
	"SUB":             8,
	"MUL":             9,
	"DIV":             10,
	"MOD":             11,
	"POW":             12,
	"AND":             13,
	"OR":              14,
	"BUTNOT":          21,
	"BITAND":          15,
	"BITOR":           16,
	"BITXOR":          17,
	"COALESCE":        18,
	"WHERE":           19,
	"TO_MATCHING":     20,
	"TO_NOT_MATCHING": 23,
	"FLATTEN":         22,
}

func (x Expr_BinExpr_Op) String() string {
	return proto.EnumName(Expr_BinExpr_Op_name, int32(x))
}

func (Expr_BinExpr_Op) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a9d185230f424090, []int{19, 7, 0}
}

type Expr_RelExpr_Op int32

const (
	Expr_RelExpr_NO_Op          Expr_RelExpr_Op = 0
	Expr_RelExpr_MIN            Expr_RelExpr_Op = 1
	Expr_RelExpr_MAX            Expr_RelExpr_Op = 2
	Expr_RelExpr_SUM            Expr_RelExpr_Op = 3
	Expr_RelExpr_AVERAGE        Expr_RelExpr_Op = 4
	Expr_RelExpr_FUTURE_WHERE   Expr_RelExpr_Op = 5
	Expr_RelExpr_FUTURE_FLATTEN Expr_RelExpr_Op = 6
	Expr_RelExpr_RANK           Expr_RelExpr_Op = 7
	Expr_RelExpr_SNAPSHOT       Expr_RelExpr_Op = 8
	Expr_RelExpr_FIRST_BY       Expr_RelExpr_Op = 9
)

var Expr_RelExpr_Op_name = map[int32]string{
	0: "NO_Op",
	1: "MIN",
	2: "MAX",
	3: "SUM",
	4: "AVERAGE",
	5: "FUTURE_WHERE",
	6: "FUTURE_FLATTEN",
	7: "RANK",
	8: "SNAPSHOT",
	9: "FIRST_BY",
}

var Expr_RelExpr_Op_value = map[string]int32{
	"NO_Op":          0,
	"MIN":            1,
	"MAX":            2,
	"SUM":            3,
	"AVERAGE":        4,
	"FUTURE_WHERE":   5,
	"FUTURE_FLATTEN": 6,
	"RANK":           7,
	"SNAPSHOT":       8,
	"FIRST_BY":       9,
}

func (x Expr_RelExpr_Op) String() string {
	return proto.EnumName(Expr_RelExpr_Op_name, int32(x))
}

func (Expr_RelExpr_Op) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a9d185230f424090, []int{19, 8, 0}
}

type SourceContext struct {
	File                 string                  `protobuf:"bytes,1,opt,name=file,proto3" json:"file,omitempty"`
	Start                *SourceContext_Location `protobuf:"bytes,2,opt,name=start,proto3" json:"start,omitempty"`
	End                  *SourceContext_Location `protobuf:"bytes,3,opt,name=end,proto3" json:"end,omitempty"`
	Text                 string                  `protobuf:"bytes,4,opt,name=text,proto3" json:"text,omitempty"`
	Delta                Delta                   `protobuf:"varint,6,opt,name=delta,proto3,enum=sysl.Delta" json:"delta,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

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

var xxx_messageInfo_SourceContext proto.InternalMessageInfo

func (m *SourceContext) GetFile() string {
	if m != nil {
		return m.File
	}
	return ""
}

func (m *SourceContext) GetStart() *SourceContext_Location {
	if m != nil {
		return m.Start
	}
	return nil
}

func (m *SourceContext) GetEnd() *SourceContext_Location {
	if m != nil {
		return m.End
	}
	return nil
}

func (m *SourceContext) GetText() string {
	if m != nil {
		return m.Text
	}
	return ""
}

func (m *SourceContext) GetDelta() Delta {
	if m != nil {
		return m.Delta
	}
	return Delta_NO_Delta
}

type SourceContext_Location struct {
	Line                 int32    `protobuf:"varint,1,opt,name=line,proto3" json:"line,omitempty"`
	Col                  int32    `protobuf:"varint,2,opt,name=col,proto3" json:"col,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SourceContext_Location proto.InternalMessageInfo

func (m *SourceContext_Location) GetLine() int32 {
	if m != nil {
		return m.Line
	}
	return 0
}

func (m *SourceContext_Location) GetCol() int32 {
	if m != nil {
		return m.Col
	}
	return 0
}

type Module struct {
	Apps                 map[string]*Application `protobuf:"bytes,2,rep,name=apps,proto3" json:"apps,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	SourceContext        *SourceContext          `protobuf:"bytes,99,opt,name=source_context,json=sourceContext,proto3" json:"source_context,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

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

var xxx_messageInfo_Module proto.InternalMessageInfo

func (m *Module) GetApps() map[string]*Application {
	if m != nil {
		return m.Apps
	}
	return nil
}

func (m *Module) GetSourceContext() *SourceContext {
	if m != nil {
		return m.SourceContext
	}
	return nil
}

type Attribute struct {
	// Types that are valid to be assigned to Attribute:
	//	*Attribute_S
	//	*Attribute_I
	//	*Attribute_N
	//	*Attribute_A
	Attribute            isAttribute_Attribute `protobuf_oneof:"attribute"`
	SourceContext        *SourceContext        `protobuf:"bytes,99,opt,name=source_context,json=sourceContext,proto3" json:"source_context,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_Attribute proto.InternalMessageInfo

type isAttribute_Attribute interface {
	isAttribute_Attribute()
}

type Attribute_S struct {
	S string `protobuf:"bytes,4,opt,name=s,proto3,oneof"`
}

type Attribute_I struct {
	I int64 `protobuf:"varint,5,opt,name=i,proto3,oneof"`
}

type Attribute_N struct {
	N float64 `protobuf:"fixed64,6,opt,name=n,proto3,oneof"`
}

type Attribute_A struct {
	A *Attribute_Array `protobuf:"bytes,7,opt,name=a,proto3,oneof"`
}

func (*Attribute_S) isAttribute_Attribute() {}

func (*Attribute_I) isAttribute_Attribute() {}

func (*Attribute_N) isAttribute_Attribute() {}

func (*Attribute_A) isAttribute_Attribute() {}

func (m *Attribute) GetAttribute() isAttribute_Attribute {
	if m != nil {
		return m.Attribute
	}
	return nil
}

func (m *Attribute) GetS() string {
	if x, ok := m.GetAttribute().(*Attribute_S); ok {
		return x.S
	}
	return ""
}

func (m *Attribute) GetI() int64 {
	if x, ok := m.GetAttribute().(*Attribute_I); ok {
		return x.I
	}
	return 0
}

func (m *Attribute) GetN() float64 {
	if x, ok := m.GetAttribute().(*Attribute_N); ok {
		return x.N
	}
	return 0
}

func (m *Attribute) GetA() *Attribute_Array {
	if x, ok := m.GetAttribute().(*Attribute_A); ok {
		return x.A
	}
	return nil
}

func (m *Attribute) GetSourceContext() *SourceContext {
	if m != nil {
		return m.SourceContext
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Attribute) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Attribute_S)(nil),
		(*Attribute_I)(nil),
		(*Attribute_N)(nil),
		(*Attribute_A)(nil),
	}
}

type Attribute_Array struct {
	Elt                  []*Attribute `protobuf:"bytes,1,rep,name=elt,proto3" json:"elt,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_Attribute_Array proto.InternalMessageInfo

func (m *Attribute_Array) GetElt() []*Attribute {
	if m != nil {
		return m.Elt
	}
	return nil
}

type AppName struct {
	Part                 []string `protobuf:"bytes,1,rep,name=part,proto3" json:"part,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_AppName proto.InternalMessageInfo

func (m *AppName) GetPart() []string {
	if m != nil {
		return m.Part
	}
	return nil
}

type Application struct {
	Name                 *AppName              `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	LongName             string                `protobuf:"bytes,2,opt,name=long_name,json=longName,proto3" json:"long_name,omitempty"`
	Docstring            string                `protobuf:"bytes,3,opt,name=docstring,proto3" json:"docstring,omitempty"`
	Attrs                map[string]*Attribute `protobuf:"bytes,4,rep,name=attrs,proto3" json:"attrs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Endpoints            map[string]*Endpoint  `protobuf:"bytes,5,rep,name=endpoints,proto3" json:"endpoints,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Types                map[string]*Type      `protobuf:"bytes,6,rep,name=types,proto3" json:"types,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Views                map[string]*View      `protobuf:"bytes,10,rep,name=views,proto3" json:"views,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Mixin2               []*Application        `protobuf:"bytes,8,rep,name=mixin2,proto3" json:"mixin2,omitempty"`
	Wrapped              *Application          `protobuf:"bytes,9,opt,name=wrapped,proto3" json:"wrapped,omitempty"`
	SourceContext        *SourceContext        `protobuf:"bytes,99,opt,name=source_context,json=sourceContext,proto3" json:"source_context,omitempty"`
	DONOTUSEMixin        []*AppName            `protobuf:"bytes,7,rep,name=DONOTUSE_mixin,json=DONOTUSEMixin,proto3" json:"DONOTUSE_mixin,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_Application proto.InternalMessageInfo

func (m *Application) GetName() *AppName {
	if m != nil {
		return m.Name
	}
	return nil
}

func (m *Application) GetLongName() string {
	if m != nil {
		return m.LongName
	}
	return ""
}

func (m *Application) GetDocstring() string {
	if m != nil {
		return m.Docstring
	}
	return ""
}

func (m *Application) GetAttrs() map[string]*Attribute {
	if m != nil {
		return m.Attrs
	}
	return nil
}

func (m *Application) GetEndpoints() map[string]*Endpoint {
	if m != nil {
		return m.Endpoints
	}
	return nil
}

func (m *Application) GetTypes() map[string]*Type {
	if m != nil {
		return m.Types
	}
	return nil
}

func (m *Application) GetViews() map[string]*View {
	if m != nil {
		return m.Views
	}
	return nil
}

func (m *Application) GetMixin2() []*Application {
	if m != nil {
		return m.Mixin2
	}
	return nil
}

func (m *Application) GetWrapped() *Application {
	if m != nil {
		return m.Wrapped
	}
	return nil
}

func (m *Application) GetSourceContext() *SourceContext {
	if m != nil {
		return m.SourceContext
	}
	return nil
}

func (m *Application) GetDONOTUSEMixin() []*AppName {
	if m != nil {
		return m.DONOTUSEMixin
	}
	return nil
}

type Endpoint struct {
	Name                 string                `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	LongName             string                `protobuf:"bytes,2,opt,name=long_name,json=longName,proto3" json:"long_name,omitempty"`
	Docstring            string                `protobuf:"bytes,3,opt,name=docstring,proto3" json:"docstring,omitempty"`
	Attrs                map[string]*Attribute `protobuf:"bytes,4,rep,name=attrs,proto3" json:"attrs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Flag                 []string              `protobuf:"bytes,10,rep,name=flag,proto3" json:"flag,omitempty"`
	Source               *AppName              `protobuf:"bytes,5,opt,name=source,proto3" json:"source,omitempty"`
	IsPubsub             bool                  `protobuf:"varint,6,opt,name=is_pubsub,json=isPubsub,proto3" json:"is_pubsub,omitempty"`
	Param                []*Param              `protobuf:"bytes,9,rep,name=param,proto3" json:"param,omitempty"`
	Stmt                 []*Statement          `protobuf:"bytes,7,rep,name=stmt,proto3" json:"stmt,omitempty"`
	RestParams           *Endpoint_RestParams  `protobuf:"bytes,8,opt,name=rest_params,json=restParams,proto3" json:"rest_params,omitempty"`
	SourceContext        *SourceContext        `protobuf:"bytes,99,opt,name=source_context,json=sourceContext,proto3" json:"source_context,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_Endpoint proto.InternalMessageInfo

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

func (m *Endpoint) GetLongName() string {
	if m != nil {
		return m.LongName
	}
	return ""
}

func (m *Endpoint) GetDocstring() string {
	if m != nil {
		return m.Docstring
	}
	return ""
}

func (m *Endpoint) GetAttrs() map[string]*Attribute {
	if m != nil {
		return m.Attrs
	}
	return nil
}

func (m *Endpoint) GetFlag() []string {
	if m != nil {
		return m.Flag
	}
	return nil
}

func (m *Endpoint) GetSource() *AppName {
	if m != nil {
		return m.Source
	}
	return nil
}

func (m *Endpoint) GetIsPubsub() bool {
	if m != nil {
		return m.IsPubsub
	}
	return false
}

func (m *Endpoint) GetParam() []*Param {
	if m != nil {
		return m.Param
	}
	return nil
}

func (m *Endpoint) GetStmt() []*Statement {
	if m != nil {
		return m.Stmt
	}
	return nil
}

func (m *Endpoint) GetRestParams() *Endpoint_RestParams {
	if m != nil {
		return m.RestParams
	}
	return nil
}

func (m *Endpoint) GetSourceContext() *SourceContext {
	if m != nil {
		return m.SourceContext
	}
	return nil
}

type Endpoint_RestParams struct {
	Method               Endpoint_RestParams_Method        `protobuf:"varint,1,opt,name=method,proto3,enum=sysl.Endpoint_RestParams_Method" json:"method,omitempty"`
	Path                 string                            `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	QueryParam           []*Endpoint_RestParams_QueryParam `protobuf:"bytes,3,rep,name=query_param,json=queryParam,proto3" json:"query_param,omitempty"`
	UrlParam             []*Endpoint_RestParams_QueryParam `protobuf:"bytes,4,rep,name=url_param,json=urlParam,proto3" json:"url_param,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
	XXX_unrecognized     []byte                            `json:"-"`
	XXX_sizecache        int32                             `json:"-"`
}

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

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

var xxx_messageInfo_Endpoint_RestParams proto.InternalMessageInfo

func (m *Endpoint_RestParams) GetMethod() Endpoint_RestParams_Method {
	if m != nil {
		return m.Method
	}
	return Endpoint_RestParams_NO_Method
}

func (m *Endpoint_RestParams) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *Endpoint_RestParams) GetQueryParam() []*Endpoint_RestParams_QueryParam {
	if m != nil {
		return m.QueryParam
	}
	return nil
}

func (m *Endpoint_RestParams) GetUrlParam() []*Endpoint_RestParams_QueryParam {
	if m != nil {
		return m.UrlParam
	}
	return nil
}

type Endpoint_RestParams_QueryParam struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Type                 *Type    `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
	Loc                  bool     `protobuf:"varint,4,opt,name=loc,proto3" json:"loc,omitempty"`
	DONOTUSEParam        string   `protobuf:"bytes,3,opt,name=DONOTUSE_param,json=DONOTUSEParam,proto3" json:"DONOTUSE_param,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Endpoint_RestParams_QueryParam proto.InternalMessageInfo

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

func (m *Endpoint_RestParams_QueryParam) GetType() *Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *Endpoint_RestParams_QueryParam) GetLoc() bool {
	if m != nil {
		return m.Loc
	}
	return false
}

func (m *Endpoint_RestParams_QueryParam) GetDONOTUSEParam() string {
	if m != nil {
		return m.DONOTUSEParam
	}
	return ""
}

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

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

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

var xxx_messageInfo_Param proto.InternalMessageInfo

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

func (m *Param) GetType() *Type {
	if m != nil {
		return m.Type
	}
	return nil
}

type Statement struct {
	// Types that are valid to be assigned to Stmt:
	//	*Statement_Action
	//	*Statement_Call
	//	*Statement_Cond
	//	*Statement_Loop
	//	*Statement_LoopN
	//	*Statement_Foreach
	//	*Statement_Alt
	//	*Statement_Group
	//	*Statement_Ret
	Stmt                 isStatement_Stmt      `protobuf_oneof:"stmt"`
	Attrs                map[string]*Attribute `protobuf:"bytes,10,rep,name=attrs,proto3" json:"attrs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	SourceContext        *SourceContext        `protobuf:"bytes,99,opt,name=source_context,json=sourceContext,proto3" json:"source_context,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_Statement proto.InternalMessageInfo

type isStatement_Stmt interface {
	isStatement_Stmt()
}

type Statement_Action struct {
	Action *Action `protobuf:"bytes,1,opt,name=action,proto3,oneof"`
}

type Statement_Call struct {
	Call *Call `protobuf:"bytes,2,opt,name=call,proto3,oneof"`
}

type Statement_Cond struct {
	Cond *Cond `protobuf:"bytes,3,opt,name=cond,proto3,oneof"`
}

type Statement_Loop struct {
	Loop *Loop `protobuf:"bytes,4,opt,name=loop,proto3,oneof"`
}

type Statement_LoopN struct {
	LoopN *LoopN `protobuf:"bytes,5,opt,name=loop_n,json=loopN,proto3,oneof"`
}

type Statement_Foreach struct {
	Foreach *Foreach `protobuf:"bytes,9,opt,name=foreach,proto3,oneof"`
}

type Statement_Alt struct {
	Alt *Alt `protobuf:"bytes,6,opt,name=alt,proto3,oneof"`
}

type Statement_Group struct {
	Group *Group `protobuf:"bytes,7,opt,name=group,proto3,oneof"`
}

type Statement_Ret struct {
	Ret *Return `protobuf:"bytes,8,opt,name=ret,proto3,oneof"`
}

func (*Statement_Action) isStatement_Stmt() {}

func (*Statement_Call) isStatement_Stmt() {}

func (*Statement_Cond) isStatement_Stmt() {}

func (*Statement_Loop) isStatement_Stmt() {}

func (*Statement_LoopN) isStatement_Stmt() {}

func (*Statement_Foreach) isStatement_Stmt() {}

func (*Statement_Alt) isStatement_Stmt() {}

func (*Statement_Group) isStatement_Stmt() {}

func (*Statement_Ret) isStatement_Stmt() {}

func (m *Statement) GetStmt() isStatement_Stmt {
	if m != nil {
		return m.Stmt
	}
	return nil
}

func (m *Statement) GetAction() *Action {
	if x, ok := m.GetStmt().(*Statement_Action); ok {
		return x.Action
	}
	return nil
}

func (m *Statement) GetCall() *Call {
	if x, ok := m.GetStmt().(*Statement_Call); ok {
		return x.Call
	}
	return nil
}

func (m *Statement) GetCond() *Cond {
	if x, ok := m.GetStmt().(*Statement_Cond); ok {
		return x.Cond
	}
	return nil
}

func (m *Statement) GetLoop() *Loop {
	if x, ok := m.GetStmt().(*Statement_Loop); ok {
		return x.Loop
	}
	return nil
}

func (m *Statement) GetLoopN() *LoopN {
	if x, ok := m.GetStmt().(*Statement_LoopN); ok {
		return x.LoopN
	}
	return nil
}

func (m *Statement) GetForeach() *Foreach {
	if x, ok := m.GetStmt().(*Statement_Foreach); ok {
		return x.Foreach
	}
	return nil
}

func (m *Statement) GetAlt() *Alt {
	if x, ok := m.GetStmt().(*Statement_Alt); ok {
		return x.Alt
	}
	return nil
}

func (m *Statement) GetGroup() *Group {
	if x, ok := m.GetStmt().(*Statement_Group); ok {
		return x.Group
	}
	return nil
}

func (m *Statement) GetRet() *Return {
	if x, ok := m.GetStmt().(*Statement_Ret); ok {
		return x.Ret
	}
	return nil
}

func (m *Statement) GetAttrs() map[string]*Attribute {
	if m != nil {
		return m.Attrs
	}
	return nil
}

func (m *Statement) GetSourceContext() *SourceContext {
	if m != nil {
		return m.SourceContext
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Statement) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Statement_Action)(nil),
		(*Statement_Call)(nil),
		(*Statement_Cond)(nil),
		(*Statement_Loop)(nil),
		(*Statement_LoopN)(nil),
		(*Statement_Foreach)(nil),
		(*Statement_Alt)(nil),
		(*Statement_Group)(nil),
		(*Statement_Ret)(nil),
	}
}

type Action struct {
	Action               string   `protobuf:"bytes,2,opt,name=action,proto3" json:"action,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Action proto.InternalMessageInfo

func (m *Action) GetAction() string {
	if m != nil {
		return m.Action
	}
	return ""
}

type Call struct {
	Target               *AppName              `protobuf:"bytes,1,opt,name=target,proto3" json:"target,omitempty"`
	Endpoint             string                `protobuf:"bytes,2,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
	Arg                  []*Call_Arg           `protobuf:"bytes,4,rep,name=arg,proto3" json:"arg,omitempty"`
	DONOTUSEAttrs        map[string]*Attribute `protobuf:"bytes,3,rep,name=DONOTUSE_attrs,json=DONOTUSEAttrs,proto3" json:"DONOTUSE_attrs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_Call proto.InternalMessageInfo

func (m *Call) GetTarget() *AppName {
	if m != nil {
		return m.Target
	}
	return nil
}

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

func (m *Call) GetArg() []*Call_Arg {
	if m != nil {
		return m.Arg
	}
	return nil
}

func (m *Call) GetDONOTUSEAttrs() map[string]*Attribute {
	if m != nil {
		return m.DONOTUSEAttrs
	}
	return nil
}

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

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

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

var xxx_messageInfo_Call_Arg proto.InternalMessageInfo

func (m *Call_Arg) GetValue() *Value {
	if m != nil {
		return m.Value
	}
	return nil
}

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

func (m *Call_Arg) GetDONOTUSEType() *Type {
	if m != nil {
		return m.DONOTUSEType
	}
	return nil
}

type Cond struct {
	Test                 string       `protobuf:"bytes,1,opt,name=test,proto3" json:"test,omitempty"`
	Stmt                 []*Statement `protobuf:"bytes,2,rep,name=stmt,proto3" json:"stmt,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_Cond proto.InternalMessageInfo

func (m *Cond) GetTest() string {
	if m != nil {
		return m.Test
	}
	return ""
}

func (m *Cond) GetStmt() []*Statement {
	if m != nil {
		return m.Stmt
	}
	return nil
}

type Loop struct {
	Mode                 Loop_Mode    `protobuf:"varint,1,opt,name=mode,proto3,enum=sysl.Loop_Mode" json:"mode,omitempty"`
	Criterion            string       `protobuf:"bytes,2,opt,name=criterion,proto3" json:"criterion,omitempty"`
	Stmt                 []*Statement `protobuf:"bytes,3,rep,name=stmt,proto3" json:"stmt,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_Loop proto.InternalMessageInfo

func (m *Loop) GetMode() Loop_Mode {
	if m != nil {
		return m.Mode
	}
	return Loop_NO_Mode
}

func (m *Loop) GetCriterion() string {
	if m != nil {
		return m.Criterion
	}
	return ""
}

func (m *Loop) GetStmt() []*Statement {
	if m != nil {
		return m.Stmt
	}
	return nil
}

type LoopN struct {
	Count                int32        `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
	Stmt                 []*Statement `protobuf:"bytes,3,rep,name=stmt,proto3" json:"stmt,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_LoopN proto.InternalMessageInfo

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

func (m *LoopN) GetStmt() []*Statement {
	if m != nil {
		return m.Stmt
	}
	return nil
}

type Foreach struct {
	Collection           string       `protobuf:"bytes,1,opt,name=collection,proto3" json:"collection,omitempty"`
	Stmt                 []*Statement `protobuf:"bytes,3,rep,name=stmt,proto3" json:"stmt,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_Foreach proto.InternalMessageInfo

func (m *Foreach) GetCollection() string {
	if m != nil {
		return m.Collection
	}
	return ""
}

func (m *Foreach) GetStmt() []*Statement {
	if m != nil {
		return m.Stmt
	}
	return nil
}

type Alt struct {
	Choice               []*Alt_Choice `protobuf:"bytes,1,rep,name=choice,proto3" json:"choice,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_Alt proto.InternalMessageInfo

func (m *Alt) GetChoice() []*Alt_Choice {
	if m != nil {
		return m.Choice
	}
	return nil
}

type Alt_Choice struct {
	Cond                 string       `protobuf:"bytes,1,opt,name=cond,proto3" json:"cond,omitempty"`
	Stmt                 []*Statement `protobuf:"bytes,2,rep,name=stmt,proto3" json:"stmt,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_Alt_Choice proto.InternalMessageInfo

func (m *Alt_Choice) GetCond() string {
	if m != nil {
		return m.Cond
	}
	return ""
}

func (m *Alt_Choice) GetStmt() []*Statement {
	if m != nil {
		return m.Stmt
	}
	return nil
}

type Group struct {
	Title                string       `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	Stmt                 []*Statement `protobuf:"bytes,2,rep,name=stmt,proto3" json:"stmt,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_Group proto.InternalMessageInfo

func (m *Group) GetTitle() string {
	if m != nil {
		return m.Title
	}
	return ""
}

func (m *Group) GetStmt() []*Statement {
	if m != nil {
		return m.Stmt
	}
	return nil
}

type Return struct {
	Payload              string   `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Return proto.InternalMessageInfo

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

type Type struct {
	// Types that are valid to be assigned to Type:
	//	*Type_Primitive_
	//	*Type_Enum_
	//	*Type_Tuple_
	//	*Type_List_
	//	*Type_Map_
	//	*Type_OneOf_
	//	*Type_Relation_
	//	*Type_TypeRef
	//	*Type_Set
	//	*Type_Sequence
	//	*Type_NoType_
	Type                 isType_Type           `protobuf_oneof:"type"`
	Attrs                map[string]*Attribute `protobuf:"bytes,8,rep,name=attrs,proto3" json:"attrs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Constraint           []*Type_Constraint    `protobuf:"bytes,10,rep,name=constraint,proto3" json:"constraint,omitempty"`
	Docstring            string                `protobuf:"bytes,11,opt,name=docstring,proto3" json:"docstring,omitempty"`
	Opt                  bool                  `protobuf:"varint,12,opt,name=opt,proto3" json:"opt,omitempty"`
	SourceContext        *SourceContext        `protobuf:"bytes,99,opt,name=source_context,json=sourceContext,proto3" json:"source_context,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_Type proto.InternalMessageInfo

type isType_Type interface {
	isType_Type()
}

type Type_Primitive_ struct {
	Primitive Type_Primitive `protobuf:"varint,1,opt,name=primitive,proto3,enum=sysl.Type_Primitive,oneof"`
}

type Type_Enum_ struct {
	Enum *Type_Enum `protobuf:"bytes,2,opt,name=enum,proto3,oneof"`
}

type Type_Tuple_ struct {
	Tuple *Type_Tuple `protobuf:"bytes,3,opt,name=tuple,proto3,oneof"`
}

type Type_List_ struct {
	List *Type_List `protobuf:"bytes,4,opt,name=list,proto3,oneof"`
}

type Type_Map_ struct {
	Map *Type_Map `protobuf:"bytes,5,opt,name=map,proto3,oneof"`
}

type Type_OneOf_ struct {
	OneOf *Type_OneOf `protobuf:"bytes,6,opt,name=one_of,json=oneOf,proto3,oneof"`
}

type Type_Relation_ struct {
	Relation *Type_Relation `protobuf:"bytes,7,opt,name=relation,proto3,oneof"`
}

type Type_TypeRef struct {
	TypeRef *ScopedRef `protobuf:"bytes,9,opt,name=type_ref,json=typeRef,proto3,oneof"`
}

type Type_Set struct {
	Set *Type `protobuf:"bytes,13,opt,name=set,proto3,oneof"`
}

type Type_Sequence struct {
	Sequence *Type `protobuf:"bytes,15,opt,name=sequence,proto3,oneof"`
}

type Type_NoType_ struct {
	NoType *Type_NoType `protobuf:"bytes,14,opt,name=no_type,json=noType,proto3,oneof"`
}

func (*Type_Primitive_) isType_Type() {}

func (*Type_Enum_) isType_Type() {}

func (*Type_Tuple_) isType_Type() {}

func (*Type_List_) isType_Type() {}

func (*Type_Map_) isType_Type() {}

func (*Type_OneOf_) isType_Type() {}

func (*Type_Relation_) isType_Type() {}

func (*Type_TypeRef) isType_Type() {}

func (*Type_Set) isType_Type() {}

func (*Type_Sequence) isType_Type() {}

func (*Type_NoType_) isType_Type() {}

func (m *Type) GetType() isType_Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *Type) GetPrimitive() Type_Primitive {
	if x, ok := m.GetType().(*Type_Primitive_); ok {
		return x.Primitive
	}
	return Type_NO_Primitive
}

func (m *Type) GetEnum() *Type_Enum {
	if x, ok := m.GetType().(*Type_Enum_); ok {
		return x.Enum
	}
	return nil
}

func (m *Type) GetTuple() *Type_Tuple {
	if x, ok := m.GetType().(*Type_Tuple_); ok {
		return x.Tuple
	}
	return nil
}

func (m *Type) GetList() *Type_List {
	if x, ok := m.GetType().(*Type_List_); ok {
		return x.List
	}
	return nil
}

func (m *Type) GetMap() *Type_Map {
	if x, ok := m.GetType().(*Type_Map_); ok {
		return x.Map
	}
	return nil
}

func (m *Type) GetOneOf() *Type_OneOf {
	if x, ok := m.GetType().(*Type_OneOf_); ok {
		return x.OneOf
	}
	return nil
}

func (m *Type) GetRelation() *Type_Relation {
	if x, ok := m.GetType().(*Type_Relation_); ok {
		return x.Relation
	}
	return nil
}

func (m *Type) GetTypeRef() *ScopedRef {
	if x, ok := m.GetType().(*Type_TypeRef); ok {
		return x.TypeRef
	}
	return nil
}

func (m *Type) GetSet() *Type {
	if x, ok := m.GetType().(*Type_Set); ok {
		return x.Set
	}
	return nil
}

func (m *Type) GetSequence() *Type {
	if x, ok := m.GetType().(*Type_Sequence); ok {
		return x.Sequence
	}
	return nil
}

func (m *Type) GetNoType() *Type_NoType {
	if x, ok := m.GetType().(*Type_NoType_); ok {
		return x.NoType
	}
	return nil
}

func (m *Type) GetAttrs() map[string]*Attribute {
	if m != nil {
		return m.Attrs
	}
	return nil
}

func (m *Type) GetConstraint() []*Type_Constraint {
	if m != nil {
		return m.Constraint
	}
	return nil
}

func (m *Type) GetDocstring() string {
	if m != nil {
		return m.Docstring
	}
	return ""
}

func (m *Type) GetOpt() bool {
	if m != nil {
		return m.Opt
	}
	return false
}

func (m *Type) GetSourceContext() *SourceContext {
	if m != nil {
		return m.SourceContext
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Type) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Type_Primitive_)(nil),
		(*Type_Enum_)(nil),
		(*Type_Tuple_)(nil),
		(*Type_List_)(nil),
		(*Type_Map_)(nil),
		(*Type_OneOf_)(nil),
		(*Type_Relation_)(nil),
		(*Type_TypeRef)(nil),
		(*Type_Set)(nil),
		(*Type_Sequence)(nil),
		(*Type_NoType_)(nil),
	}
}

type Type_Enum struct {
	Items                map[string]int64 `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

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

var xxx_messageInfo_Type_Enum proto.InternalMessageInfo

func (m *Type_Enum) GetItems() map[string]int64 {
	if m != nil {
		return m.Items
	}
	return nil
}

type Type_Tuple struct {
	AttrDefs             map[string]*Type             `protobuf:"bytes,1,rep,name=attr_defs,json=attrDefs,proto3" json:"attr_defs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	FUTUREFields         map[string]*Type_Tuple_Field `protobuf:"bytes,2,rep,name=FUTURE_fields,json=FUTUREFields,proto3" json:"FUTURE_fields,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

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

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

var xxx_messageInfo_Type_Tuple proto.InternalMessageInfo

func (m *Type_Tuple) GetAttrDefs() map[string]*Type {
	if m != nil {
		return m.AttrDefs
	}
	return nil
}

func (m *Type_Tuple) GetFUTUREFields() map[string]*Type_Tuple_Field {
	if m != nil {
		return m.FUTUREFields
	}
	return nil
}

type Type_Tuple_Field struct {
	Type                 *Type    `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	MinRepeats           int64    `protobuf:"varint,2,opt,name=min_repeats,json=minRepeats,proto3" json:"min_repeats,omitempty"`
	MaxRepeats           int64    `protobuf:"varint,3,opt,name=max_repeats,json=maxRepeats,proto3" json:"max_repeats,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Type_Tuple_Field proto.InternalMessageInfo

func (m *Type_Tuple_Field) GetType() *Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *Type_Tuple_Field) GetMinRepeats() int64 {
	if m != nil {
		return m.MinRepeats
	}
	return 0
}

func (m *Type_Tuple_Field) GetMaxRepeats() int64 {
	if m != nil {
		return m.MaxRepeats
	}
	return 0
}

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

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

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

var xxx_messageInfo_Type_List proto.InternalMessageInfo

func (m *Type_List) GetType() *Type {
	if m != nil {
		return m.Type
	}
	return nil
}

type Type_Map struct {
	Key                  *Type    `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value                *Type    `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Type_Map proto.InternalMessageInfo

func (m *Type_Map) GetKey() *Type {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *Type_Map) GetValue() *Type {
	if m != nil {
		return m.Value
	}
	return nil
}

type Type_OneOf struct {
	Type                 []*Type  `protobuf:"bytes,1,rep,name=type,proto3" json:"type,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Type_OneOf proto.InternalMessageInfo

func (m *Type_OneOf) GetType() []*Type {
	if m != nil {
		return m.Type
	}
	return nil
}

type Type_Relation struct {
	AttrDefs             map[string]*Type     `protobuf:"bytes,1,rep,name=attr_defs,json=attrDefs,proto3" json:"attr_defs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	PrimaryKey           *Type_Relation_Key   `protobuf:"bytes,2,opt,name=primary_key,json=primaryKey,proto3" json:"primary_key,omitempty"`
	Key                  []*Type_Relation_Key `protobuf:"bytes,3,rep,name=key,proto3" json:"key,omitempty"`
	Inject               []string             `protobuf:"bytes,4,rep,name=inject,proto3" json:"inject,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_Type_Relation proto.InternalMessageInfo

func (m *Type_Relation) GetAttrDefs() map[string]*Type {
	if m != nil {
		return m.AttrDefs
	}
	return nil
}

func (m *Type_Relation) GetPrimaryKey() *Type_Relation_Key {
	if m != nil {
		return m.PrimaryKey
	}
	return nil
}

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

func (m *Type_Relation) GetInject() []string {
	if m != nil {
		return m.Inject
	}
	return nil
}

type Type_Relation_Key struct {
	AttrName             []string `protobuf:"bytes,1,rep,name=attr_name,json=attrName,proto3" json:"attr_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Type_Relation_Key proto.InternalMessageInfo

func (m *Type_Relation_Key) GetAttrName() []string {
	if m != nil {
		return m.AttrName
	}
	return nil
}

type Type_Foreign struct {
	App                  *AppName `protobuf:"bytes,1,opt,name=app,proto3" json:"app,omitempty"`
	Relation             string   `protobuf:"bytes,2,opt,name=relation,proto3" json:"relation,omitempty"`
	AttrName             string   `protobuf:"bytes,3,opt,name=attr_name,json=attrName,proto3" json:"attr_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Type_Foreign proto.InternalMessageInfo

func (m *Type_Foreign) GetApp() *AppName {
	if m != nil {
		return m.App
	}
	return nil
}

func (m *Type_Foreign) GetRelation() string {
	if m != nil {
		return m.Relation
	}
	return ""
}

func (m *Type_Foreign) GetAttrName() string {
	if m != nil {
		return m.AttrName
	}
	return ""
}

type Type_Constraint struct {
	Range                *Type_Constraint_Range      `protobuf:"bytes,1,opt,name=range,proto3" json:"range,omitempty"`
	Length               *Type_Constraint_Length     `protobuf:"bytes,2,opt,name=length,proto3" json:"length,omitempty"`
	Resolution           *Type_Constraint_Resolution `protobuf:"bytes,3,opt,name=resolution,proto3" json:"resolution,omitempty"`
	Precision            int32                       `protobuf:"varint,4,opt,name=precision,proto3" json:"precision,omitempty"`
	Scale                int32                       `protobuf:"varint,5,opt,name=scale,proto3" json:"scale,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

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

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

var xxx_messageInfo_Type_Constraint proto.InternalMessageInfo

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

func (m *Type_Constraint) GetLength() *Type_Constraint_Length {
	if m != nil {
		return m.Length
	}
	return nil
}

func (m *Type_Constraint) GetResolution() *Type_Constraint_Resolution {
	if m != nil {
		return m.Resolution
	}
	return nil
}

func (m *Type_Constraint) GetPrecision() int32 {
	if m != nil {
		return m.Precision
	}
	return 0
}

func (m *Type_Constraint) GetScale() int32 {
	if m != nil {
		return m.Scale
	}
	return 0
}

type Type_Constraint_Range struct {
	Min                  *Value   `protobuf:"bytes,1,opt,name=min,proto3" json:"min,omitempty"`
	Max                  *Value   `protobuf:"bytes,2,opt,name=max,proto3" json:"max,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Type_Constraint_Range proto.InternalMessageInfo

func (m *Type_Constraint_Range) GetMin() *Value {
	if m != nil {
		return m.Min
	}
	return nil
}

func (m *Type_Constraint_Range) GetMax() *Value {
	if m != nil {
		return m.Max
	}
	return nil
}

type Type_Constraint_Length struct {
	Min                  int64    `protobuf:"varint,1,opt,name=min,proto3" json:"min,omitempty"`
	Max                  int64    `protobuf:"varint,2,opt,name=max,proto3" json:"max,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Type_Constraint_Length) Reset()         { *m = Type_Constraint_Length{} }
func (m *Type_Constraint_Length) String() string { return proto.CompactTextString(m) }
func (*Type_Constraint_Length) ProtoMessage()    {}
func (*Type_Constraint_Length) Descriptor() ([]byte, []int) {
	return fileDescriptor_a9d185230f424090, []int{17, 8, 1}
}

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

var xxx_messageInfo_Type_Constraint_Length proto.InternalMessageInfo

func (m *Type_Constraint_Length) GetMin() int64 {
	if m != nil {
		return m.Min
	}
	return 0
}

func (m *Type_Constraint_Length) GetMax() int64 {
	if m != nil {
		return m.Max
	}
	return 0
}

// e.g.: 3 decimal places = {base = 10, index = -3}
type Type_Constraint_Resolution struct {
	Base                 int32    `protobuf:"varint,1,opt,name=base,proto3" json:"base,omitempty"`
	Index                int32    `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Type_Constraint_Resolution) Reset()         { *m = Type_Constraint_Resolution{} }
func (m *Type_Constraint_Resolution) String() string { return proto.CompactTextString(m) }
func (*Type_Constraint_Resolution) ProtoMessage()    {}
func (*Type_Constraint_Resolution) Descriptor() ([]byte, []int) {
	return fileDescriptor_a9d185230f424090, []int{17, 8, 2}
}

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

var xxx_messageInfo_Type_Constraint_Resolution proto.InternalMessageInfo

func (m *Type_Constraint_Resolution) GetBase() int32 {
	if m != nil {
		return m.Base
	}
	return 0
}

func (m *Type_Constraint_Resolution) GetIndex() int32 {
	if m != nil {
		return m.Index
	}
	return 0
}

type Type_NoType struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Type_NoType proto.InternalMessageInfo

type View struct {
	Param                []*Param              `protobuf:"bytes,1,rep,name=param,proto3" json:"param,omitempty"`
	RetType              *Type                 `protobuf:"bytes,2,opt,name=ret_type,json=retType,proto3" json:"ret_type,omitempty"`
	Expr                 *Expr                 `protobuf:"bytes,3,opt,name=expr,proto3" json:"expr,omitempty"`
	Views                map[string]*View      `protobuf:"bytes,4,rep,name=views,proto3" json:"views,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Attrs                map[string]*Attribute `protobuf:"bytes,8,rep,name=attrs,proto3" json:"attrs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	SourceContext        *SourceContext        `protobuf:"bytes,99,opt,name=source_context,json=sourceContext,proto3" json:"source_context,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_View proto.InternalMessageInfo

func (m *View) GetParam() []*Param {
	if m != nil {
		return m.Param
	}
	return nil
}

func (m *View) GetRetType() *Type {
	if m != nil {
		return m.RetType
	}
	return nil
}

func (m *View) GetExpr() *Expr {
	if m != nil {
		return m.Expr
	}
	return nil
}

func (m *View) GetViews() map[string]*View {
	if m != nil {
		return m.Views
	}
	return nil
}

func (m *View) GetAttrs() map[string]*Attribute {
	if m != nil {
		return m.Attrs
	}
	return nil
}

func (m *View) GetSourceContext() *SourceContext {
	if m != nil {
		return m.SourceContext
	}
	return nil
}

type Expr struct {
	// Types that are valid to be assigned to Expr:
	//	*Expr_Name
	//	*Expr_Literal
	//	*Expr_GetAttr_
	//	*Expr_Transform_
	//	*Expr_Ifelse
	//	*Expr_Call_
	//	*Expr_Unexpr
	//	*Expr_Binexpr
	//	*Expr_Relexpr
	//	*Expr_Navigate_
	//	*Expr_List_
	//	*Expr_Set
	//	*Expr_Tuple_
	Expr                 isExpr_Expr    `protobuf_oneof:"expr"`
	Type                 *Type          `protobuf:"bytes,13,opt,name=type,proto3" json:"type,omitempty"`
	SourceContext        *SourceContext `protobuf:"bytes,99,opt,name=source_context,json=sourceContext,proto3" json:"source_context,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_Expr proto.InternalMessageInfo

type isExpr_Expr interface {
	isExpr_Expr()
}

type Expr_Name struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3,oneof"`
}

type Expr_Literal struct {
	Literal *Value `protobuf:"bytes,2,opt,name=literal,proto3,oneof"`
}

type Expr_GetAttr_ struct {
	GetAttr *Expr_GetAttr `protobuf:"bytes,3,opt,name=get_attr,json=getAttr,proto3,oneof"`
}

type Expr_Transform_ struct {
	Transform *Expr_Transform `protobuf:"bytes,4,opt,name=transform,proto3,oneof"`
}

type Expr_Ifelse struct {
	Ifelse *Expr_IfElse `protobuf:"bytes,5,opt,name=ifelse,proto3,oneof"`
}

type Expr_Call_ struct {
	Call *Expr_Call `protobuf:"bytes,6,opt,name=call,proto3,oneof"`
}

type Expr_Unexpr struct {
	Unexpr *Expr_UnExpr `protobuf:"bytes,7,opt,name=unexpr,proto3,oneof"`
}

type Expr_Binexpr struct {
	Binexpr *Expr_BinExpr `protobuf:"bytes,8,opt,name=binexpr,proto3,oneof"`
}

type Expr_Relexpr struct {
	Relexpr *Expr_RelExpr `protobuf:"bytes,12,opt,name=relexpr,proto3,oneof"`
}

type Expr_Navigate_ struct {
	Navigate *Expr_Navigate `protobuf:"bytes,9,opt,name=navigate,proto3,oneof"`
}

type Expr_List_ struct {
	List *Expr_List `protobuf:"bytes,10,opt,name=list,proto3,oneof"`
}

type Expr_Set struct {
	Set *Expr_List `protobuf:"bytes,11,opt,name=set,proto3,oneof"`
}

type Expr_Tuple_ struct {
	Tuple *Expr_Tuple `protobuf:"bytes,14,opt,name=tuple,proto3,oneof"`
}

func (*Expr_Name) isExpr_Expr() {}

func (*Expr_Literal) isExpr_Expr() {}

func (*Expr_GetAttr_) isExpr_Expr() {}

func (*Expr_Transform_) isExpr_Expr() {}

func (*Expr_Ifelse) isExpr_Expr() {}

func (*Expr_Call_) isExpr_Expr() {}

func (*Expr_Unexpr) isExpr_Expr() {}

func (*Expr_Binexpr) isExpr_Expr() {}

func (*Expr_Relexpr) isExpr_Expr() {}

func (*Expr_Navigate_) isExpr_Expr() {}

func (*Expr_List_) isExpr_Expr() {}

func (*Expr_Set) isExpr_Expr() {}

func (*Expr_Tuple_) isExpr_Expr() {}

func (m *Expr) GetExpr() isExpr_Expr {
	if m != nil {
		return m.Expr
	}
	return nil
}

func (m *Expr) GetName() string {
	if x, ok := m.GetExpr().(*Expr_Name); ok {
		return x.Name
	}
	return ""
}

func (m *Expr) GetLiteral() *Value {
	if x, ok := m.GetExpr().(*Expr_Literal); ok {
		return x.Literal
	}
	return nil
}

func (m *Expr) GetGetAttr() *Expr_GetAttr {
	if x, ok := m.GetExpr().(*Expr_GetAttr_); ok {
		return x.GetAttr
	}
	return nil
}

func (m *Expr) GetTransform() *Expr_Transform {
	if x, ok := m.GetExpr().(*Expr_Transform_); ok {
		return x.Transform
	}
	return nil
}

func (m *Expr) GetIfelse() *Expr_IfElse {
	if x, ok := m.GetExpr().(*Expr_Ifelse); ok {
		return x.Ifelse
	}
	return nil
}

func (m *Expr) GetCall() *Expr_Call {
	if x, ok := m.GetExpr().(*Expr_Call_); ok {
		return x.Call
	}
	return nil
}

func (m *Expr) GetUnexpr() *Expr_UnExpr {
	if x, ok := m.GetExpr().(*Expr_Unexpr); ok {
		return x.Unexpr
	}
	return nil
}

func (m *Expr) GetBinexpr() *Expr_BinExpr {
	if x, ok := m.GetExpr().(*Expr_Binexpr); ok {
		return x.Binexpr
	}
	return nil
}

func (m *Expr) GetRelexpr() *Expr_RelExpr {
	if x, ok := m.GetExpr().(*Expr_Relexpr); ok {
		return x.Relexpr
	}
	return nil
}

func (m *Expr) GetNavigate() *Expr_Navigate {
	if x, ok := m.GetExpr().(*Expr_Navigate_); ok {
		return x.Navigate
	}
	return nil
}

func (m *Expr) GetList() *Expr_List {
	if x, ok := m.GetExpr().(*Expr_List_); ok {
		return x.List
	}
	return nil
}

func (m *Expr) GetSet() *Expr_List {
	if x, ok := m.GetExpr().(*Expr_Set); ok {
		return x.Set
	}
	return nil
}

func (m *Expr) GetTuple() *Expr_Tuple {
	if x, ok := m.GetExpr().(*Expr_Tuple_); ok {
		return x.Tuple
	}
	return nil
}

func (m *Expr) GetType() *Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *Expr) GetSourceContext() *SourceContext {
	if m != nil {
		return m.SourceContext
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Expr) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Expr_Name)(nil),
		(*Expr_Literal)(nil),
		(*Expr_GetAttr_)(nil),
		(*Expr_Transform_)(nil),
		(*Expr_Ifelse)(nil),
		(*Expr_Call_)(nil),
		(*Expr_Unexpr)(nil),
		(*Expr_Binexpr)(nil),
		(*Expr_Relexpr)(nil),
		(*Expr_Navigate_)(nil),
		(*Expr_List_)(nil),
		(*Expr_Set)(nil),
		(*Expr_Tuple_)(nil),
	}
}

type Expr_GetAttr struct {
	Arg                  *Expr    `protobuf:"bytes,1,opt,name=arg,proto3" json:"arg,omitempty"`
	Attr                 string   `protobuf:"bytes,2,opt,name=attr,proto3" json:"attr,omitempty"`
	Nullsafe             bool     `protobuf:"varint,3,opt,name=nullsafe,proto3" json:"nullsafe,omitempty"`
	Setof                bool     `protobuf:"varint,4,opt,name=setof,proto3" json:"setof,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Expr_GetAttr proto.InternalMessageInfo

func (m *Expr_GetAttr) GetArg() *Expr {
	if m != nil {
		return m.Arg
	}
	return nil
}

func (m *Expr_GetAttr) GetAttr() string {
	if m != nil {
		return m.Attr
	}
	return ""
}

func (m *Expr_GetAttr) GetNullsafe() bool {
	if m != nil {
		return m.Nullsafe
	}
	return false
}

func (m *Expr_GetAttr) GetSetof() bool {
	if m != nil {
		return m.Setof
	}
	return false
}

type Expr_Navigate struct {
	Arg                  *Expr    `protobuf:"bytes,1,opt,name=arg,proto3" json:"arg,omitempty"`
	Attr                 string   `protobuf:"bytes,2,opt,name=attr,proto3" json:"attr,omitempty"`
	Nullsafe             bool     `protobuf:"varint,3,opt,name=nullsafe,proto3" json:"nullsafe,omitempty"`
	Setof                bool     `protobuf:"varint,4,opt,name=setof,proto3" json:"setof,omitempty"`
	Via                  string   `protobuf:"bytes,5,opt,name=via,proto3" json:"via,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Expr_Navigate proto.InternalMessageInfo

func (m *Expr_Navigate) GetArg() *Expr {
	if m != nil {
		return m.Arg
	}
	return nil
}

func (m *Expr_Navigate) GetAttr() string {
	if m != nil {
		return m.Attr
	}
	return ""
}

func (m *Expr_Navigate) GetNullsafe() bool {
	if m != nil {
		return m.Nullsafe
	}
	return false
}

func (m *Expr_Navigate) GetSetof() bool {
	if m != nil {
		return m.Setof
	}
	return false
}

func (m *Expr_Navigate) GetVia() string {
	if m != nil {
		return m.Via
	}
	return ""
}

type Expr_List struct {
	Expr                 []*Expr  `protobuf:"bytes,1,rep,name=expr,proto3" json:"expr,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Expr_List proto.InternalMessageInfo

func (m *Expr_List) GetExpr() []*Expr {
	if m != nil {
		return m.Expr
	}
	return nil
}

type Expr_Transform struct {
	Arg                  *Expr                  `protobuf:"bytes,1,opt,name=arg,proto3" json:"arg,omitempty"`
	Scopevar             string                 `protobuf:"bytes,2,opt,name=scopevar,proto3" json:"scopevar,omitempty"`
	Stmt                 []*Expr_Transform_Stmt `protobuf:"bytes,3,rep,name=stmt,proto3" json:"stmt,omitempty"`
	AllAttrs             bool                   `protobuf:"varint,4,opt,name=all_attrs,json=allAttrs,proto3" json:"all_attrs,omitempty"`
	ExceptAttrs          []string               `protobuf:"bytes,5,rep,name=except_attrs,json=exceptAttrs,proto3" json:"except_attrs,omitempty"`
	Nullsafe             bool                   `protobuf:"varint,6,opt,name=nullsafe,proto3" json:"nullsafe,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

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

var xxx_messageInfo_Expr_Transform proto.InternalMessageInfo

func (m *Expr_Transform) GetArg() *Expr {
	if m != nil {
		return m.Arg
	}
	return nil
}

func (m *Expr_Transform) GetScopevar() string {
	if m != nil {
		return m.Scopevar
	}
	return ""
}

func (m *Expr_Transform) GetStmt() []*Expr_Transform_Stmt {
	if m != nil {
		return m.Stmt
	}
	return nil
}

func (m *Expr_Transform) GetAllAttrs() bool {
	if m != nil {
		return m.AllAttrs
	}
	return false
}

func (m *Expr_Transform) GetExceptAttrs() []string {
	if m != nil {
		return m.ExceptAttrs
	}
	return nil
}

func (m *Expr_Transform) GetNullsafe() bool {
	if m != nil {
		return m.Nullsafe
	}
	return false
}

type Expr_Transform_Stmt struct {
	// Types that are valid to be assigned to Stmt:
	//	*Expr_Transform_Stmt_Assign_
	//	*Expr_Transform_Stmt_Let
	//	*Expr_Transform_Stmt_Inject
	Stmt                 isExpr_Transform_Stmt_Stmt `protobuf_oneof:"stmt"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

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

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

var xxx_messageInfo_Expr_Transform_Stmt proto.InternalMessageInfo

type isExpr_Transform_Stmt_Stmt interface {
	isExpr_Transform_Stmt_Stmt()
}

type Expr_Transform_Stmt_Assign_ struct {
	Assign *Expr_Transform_Stmt_Assign `protobuf:"bytes,1,opt,name=assign,proto3,oneof"`
}

type Expr_Transform_Stmt_Let struct {
	Let *Expr_Transform_Stmt_Assign `protobuf:"bytes,2,opt,name=let,proto3,oneof"`
}

type Expr_Transform_Stmt_Inject struct {
	Inject *Expr `protobuf:"bytes,4,opt,name=inject,proto3,oneof"`
}

func (*Expr_Transform_Stmt_Assign_) isExpr_Transform_Stmt_Stmt() {}

func (*Expr_Transform_Stmt_Let) isExpr_Transform_Stmt_Stmt() {}

func (*Expr_Transform_Stmt_Inject) isExpr_Transform_Stmt_Stmt() {}

func (m *Expr_Transform_Stmt) GetStmt() isExpr_Transform_Stmt_Stmt {
	if m != nil {
		return m.Stmt
	}
	return nil
}

func (m *Expr_Transform_Stmt) GetAssign() *Expr_Transform_Stmt_Assign {
	if x, ok := m.GetStmt().(*Expr_Transform_Stmt_Assign_); ok {
		return x.Assign
	}
	return nil
}

func (m *Expr_Transform_Stmt) GetLet() *Expr_Transform_Stmt_Assign {
	if x, ok := m.GetStmt().(*Expr_Transform_Stmt_Let); ok {
		return x.Let
	}
	return nil
}

func (m *Expr_Transform_Stmt) GetInject() *Expr {
	if x, ok := m.GetStmt().(*Expr_Transform_Stmt_Inject); ok {
		return x.Inject
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Expr_Transform_Stmt) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Expr_Transform_Stmt_Assign_)(nil),
		(*Expr_Transform_Stmt_Let)(nil),
		(*Expr_Transform_Stmt_Inject)(nil),
	}
}

type Expr_Transform_Stmt_Assign struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Expr                 *Expr    `protobuf:"bytes,2,opt,name=expr,proto3" json:"expr,omitempty"`
	Table                bool     `protobuf:"varint,3,opt,name=table,proto3" json:"table,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Expr_Transform_Stmt_Assign proto.InternalMessageInfo

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

func (m *Expr_Transform_Stmt_Assign) GetExpr() *Expr {
	if m != nil {
		return m.Expr
	}
	return nil
}

func (m *Expr_Transform_Stmt_Assign) GetTable() bool {
	if m != nil {
		return m.Table
	}
	return false
}

type Expr_IfElse struct {
	Cond                 *Expr    `protobuf:"bytes,1,opt,name=cond,proto3" json:"cond,omitempty"`
	IfTrue               *Expr    `protobuf:"bytes,2,opt,name=if_true,json=ifTrue,proto3" json:"if_true,omitempty"`
	IfFalse              *Expr    `protobuf:"bytes,3,opt,name=if_false,json=ifFalse,proto3" json:"if_false,omitempty"`
	Nullsafe             bool     `protobuf:"varint,4,opt,name=nullsafe,proto3" json:"nullsafe,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Expr_IfElse proto.InternalMessageInfo

func (m *Expr_IfElse) GetCond() *Expr {
	if m != nil {
		return m.Cond
	}
	return nil
}

func (m *Expr_IfElse) GetIfTrue() *Expr {
	if m != nil {
		return m.IfTrue
	}
	return nil
}

func (m *Expr_IfElse) GetIfFalse() *Expr {
	if m != nil {
		return m.IfFalse
	}
	return nil
}

func (m *Expr_IfElse) GetNullsafe() bool {
	if m != nil {
		return m.Nullsafe
	}
	return false
}

type Expr_Call struct {
	Func                 string   `protobuf:"bytes,1,opt,name=func,proto3" json:"func,omitempty"`
	Arg                  []*Expr  `protobuf:"bytes,2,rep,name=arg,proto3" json:"arg,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Expr_Call proto.InternalMessageInfo

func (m *Expr_Call) GetFunc() string {
	if m != nil {
		return m.Func
	}
	return ""
}

func (m *Expr_Call) GetArg() []*Expr {
	if m != nil {
		return m.Arg
	}
	return nil
}

type Expr_UnExpr struct {
	Op                   Expr_UnExpr_Op `protobuf:"varint,1,opt,name=op,proto3,enum=sysl.Expr_UnExpr_Op" json:"op,omitempty"`
	Arg                  *Expr          `protobuf:"bytes,2,opt,name=arg,proto3" json:"arg,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_Expr_UnExpr proto.InternalMessageInfo

func (m *Expr_UnExpr) GetOp() Expr_UnExpr_Op {
	if m != nil {
		return m.Op
	}
	return Expr_UnExpr_NO_Op
}

func (m *Expr_UnExpr) GetArg() *Expr {
	if m != nil {
		return m.Arg
	}
	return nil
}

type Expr_BinExpr struct {
	Op                   Expr_BinExpr_Op `protobuf:"varint,1,opt,name=op,proto3,enum=sysl.Expr_BinExpr_Op" json:"op,omitempty"`
	Lhs                  *Expr           `protobuf:"bytes,2,opt,name=lhs,proto3" json:"lhs,omitempty"`
	Rhs                  *Expr           `protobuf:"bytes,3,opt,name=rhs,proto3" json:"rhs,omitempty"`
	Scopevar             string          `protobuf:"bytes,4,opt,name=scopevar,proto3" json:"scopevar,omitempty"`
	AttrName             []string        `protobuf:"bytes,5,rep,name=attr_name,json=attrName,proto3" json:"attr_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_Expr_BinExpr proto.InternalMessageInfo

func (m *Expr_BinExpr) GetOp() Expr_BinExpr_Op {
	if m != nil {
		return m.Op
	}
	return Expr_BinExpr_NO_Op
}

func (m *Expr_BinExpr) GetLhs() *Expr {
	if m != nil {
		return m.Lhs
	}
	return nil
}

func (m *Expr_BinExpr) GetRhs() *Expr {
	if m != nil {
		return m.Rhs
	}
	return nil
}

func (m *Expr_BinExpr) GetScopevar() string {
	if m != nil {
		return m.Scopevar
	}
	return ""
}

func (m *Expr_BinExpr) GetAttrName() []string {
	if m != nil {
		return m.AttrName
	}
	return nil
}

// TODO: Migrate BinExpr ops to RelExpr as appropriate.
type Expr_RelExpr struct {
	Op                   Expr_RelExpr_Op `protobuf:"varint,1,opt,name=op,proto3,enum=sysl.Expr_RelExpr_Op" json:"op,omitempty"`
	Target               *Expr           `protobuf:"bytes,2,opt,name=target,proto3" json:"target,omitempty"`
	Arg                  []*Expr         `protobuf:"bytes,3,rep,name=arg,proto3" json:"arg,omitempty"`
	Scopevar             string          `protobuf:"bytes,4,opt,name=scopevar,proto3" json:"scopevar,omitempty"`
	Descending           []bool          `protobuf:"varint,5,rep,packed,name=descending,proto3" json:"descending,omitempty"`
	AttrName             []string        `protobuf:"bytes,6,rep,name=attr_name,json=attrName,proto3" json:"attr_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_Expr_RelExpr proto.InternalMessageInfo

func (m *Expr_RelExpr) GetOp() Expr_RelExpr_Op {
	if m != nil {
		return m.Op
	}
	return Expr_RelExpr_NO_Op
}

func (m *Expr_RelExpr) GetTarget() *Expr {
	if m != nil {
		return m.Target
	}
	return nil
}

func (m *Expr_RelExpr) GetArg() []*Expr {
	if m != nil {
		return m.Arg
	}
	return nil
}

func (m *Expr_RelExpr) GetScopevar() string {
	if m != nil {
		return m.Scopevar
	}
	return ""
}

func (m *Expr_RelExpr) GetDescending() []bool {
	if m != nil {
		return m.Descending
	}
	return nil
}

func (m *Expr_RelExpr) GetAttrName() []string {
	if m != nil {
		return m.AttrName
	}
	return nil
}

type Expr_Tuple struct {
	Attrs                map[string]*Expr `protobuf:"bytes,1,rep,name=attrs,proto3" json:"attrs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

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

var xxx_messageInfo_Expr_Tuple proto.InternalMessageInfo

func (m *Expr_Tuple) GetAttrs() map[string]*Expr {
	if m != nil {
		return m.Attrs
	}
	return nil
}

type Value struct {
	// Types that are valid to be assigned to Value:
	//	*Value_B
	//	*Value_I
	//	*Value_D
	//	*Value_S
	//	*Value_Decimal
	//	*Value_Data
	//	*Value_Enum
	//	*Value_List_
	//	*Value_Map_
	//	*Value_Set
	//	*Value_Null_
	//	*Value_Uuid
	Value                isValue_Value `protobuf_oneof:"value"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_Value proto.InternalMessageInfo

type isValue_Value interface {
	isValue_Value()
}

type Value_B struct {
	B bool `protobuf:"varint,1,opt,name=b,proto3,oneof"`
}

type Value_I struct {
	I int64 `protobuf:"varint,2,opt,name=i,proto3,oneof"`
}

type Value_D struct {
	D float64 `protobuf:"fixed64,3,opt,name=d,proto3,oneof"`
}

type Value_S struct {
	S string `protobuf:"bytes,4,opt,name=s,proto3,oneof"`
}

type Value_Decimal struct {
	Decimal string `protobuf:"bytes,11,opt,name=decimal,proto3,oneof"`
}

type Value_Data struct {
	Data []byte `protobuf:"bytes,5,opt,name=data,proto3,oneof"`
}

type Value_Enum struct {
	Enum int64 `protobuf:"varint,6,opt,name=enum,proto3,oneof"`
}

type Value_List_ struct {
	List *Value_List `protobuf:"bytes,7,opt,name=list,proto3,oneof"`
}

type Value_Map_ struct {
	Map *Value_Map `protobuf:"bytes,8,opt,name=map,proto3,oneof"`
}

type Value_Set struct {
	Set *Value_List `protobuf:"bytes,9,opt,name=set,proto3,oneof"`
}

type Value_Null_ struct {
	Null *Value_Null `protobuf:"bytes,10,opt,name=null,proto3,oneof"`
}

type Value_Uuid struct {
	Uuid []byte `protobuf:"bytes,12,opt,name=uuid,proto3,oneof"`
}

func (*Value_B) isValue_Value() {}

func (*Value_I) isValue_Value() {}

func (*Value_D) isValue_Value() {}

func (*Value_S) isValue_Value() {}

func (*Value_Decimal) isValue_Value() {}

func (*Value_Data) isValue_Value() {}

func (*Value_Enum) isValue_Value() {}

func (*Value_List_) isValue_Value() {}

func (*Value_Map_) isValue_Value() {}

func (*Value_Set) isValue_Value() {}

func (*Value_Null_) isValue_Value() {}

func (*Value_Uuid) isValue_Value() {}

func (m *Value) GetValue() isValue_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *Value) GetB() bool {
	if x, ok := m.GetValue().(*Value_B); ok {
		return x.B
	}
	return false
}

func (m *Value) GetI() int64 {
	if x, ok := m.GetValue().(*Value_I); ok {
		return x.I
	}
	return 0
}

func (m *Value) GetD() float64 {
	if x, ok := m.GetValue().(*Value_D); ok {
		return x.D
	}
	return 0
}

func (m *Value) GetS() string {
	if x, ok := m.GetValue().(*Value_S); ok {
		return x.S
	}
	return ""
}

func (m *Value) GetDecimal() string {
	if x, ok := m.GetValue().(*Value_Decimal); ok {
		return x.Decimal
	}
	return ""
}

func (m *Value) GetData() []byte {
	if x, ok := m.GetValue().(*Value_Data); ok {
		return x.Data
	}
	return nil
}

func (m *Value) GetEnum() int64 {
	if x, ok := m.GetValue().(*Value_Enum); ok {
		return x.Enum
	}
	return 0
}

func (m *Value) GetList() *Value_List {
	if x, ok := m.GetValue().(*Value_List_); ok {
		return x.List
	}
	return nil
}

func (m *Value) GetMap() *Value_Map {
	if x, ok := m.GetValue().(*Value_Map_); ok {
		return x.Map
	}
	return nil
}

func (m *Value) GetSet() *Value_List {
	if x, ok := m.GetValue().(*Value_Set); ok {
		return x.Set
	}
	return nil
}

func (m *Value) GetNull() *Value_Null {
	if x, ok := m.GetValue().(*Value_Null_); ok {
		return x.Null
	}
	return nil
}

func (m *Value) GetUuid() []byte {
	if x, ok := m.GetValue().(*Value_Uuid); ok {
		return x.Uuid
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Value) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Value_B)(nil),
		(*Value_I)(nil),
		(*Value_D)(nil),
		(*Value_S)(nil),
		(*Value_Decimal)(nil),
		(*Value_Data)(nil),
		(*Value_Enum)(nil),
		(*Value_List_)(nil),
		(*Value_Map_)(nil),
		(*Value_Set)(nil),
		(*Value_Null_)(nil),
		(*Value_Uuid)(nil),
	}
}

type Value_List struct {
	Value                []*Value `protobuf:"bytes,1,rep,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Value_List proto.InternalMessageInfo

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

type Value_Map struct {
	Items                map[string]*Value `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_Value_Map proto.InternalMessageInfo

func (m *Value_Map) GetItems() map[string]*Value {
	if m != nil {
		return m.Items
	}
	return nil
}

type Value_Null struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Value_Null proto.InternalMessageInfo

type ScopedRef struct {
	Context              *Scope   `protobuf:"bytes,1,opt,name=context,proto3" json:"context,omitempty"`
	Ref                  *Scope   `protobuf:"bytes,2,opt,name=ref,proto3" json:"ref,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ScopedRef proto.InternalMessageInfo

func (m *ScopedRef) GetContext() *Scope {
	if m != nil {
		return m.Context
	}
	return nil
}

func (m *ScopedRef) GetRef() *Scope {
	if m != nil {
		return m.Ref
	}
	return nil
}

type Scope struct {
	Appname              *AppName `protobuf:"bytes,1,opt,name=appname,proto3" json:"appname,omitempty"`
	Path                 []string `protobuf:"bytes,2,rep,name=path,proto3" json:"path,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Scope proto.InternalMessageInfo

func (m *Scope) GetAppname() *AppName {
	if m != nil {
		return m.Appname
	}
	return nil
}

func (m *Scope) GetPath() []string {
	if m != nil {
		return m.Path
	}
	return nil
}

func init() {
	proto.RegisterEnum("sysl.Delta", Delta_name, Delta_value)
	proto.RegisterEnum("sysl.Endpoint_RestParams_Method", Endpoint_RestParams_Method_name, Endpoint_RestParams_Method_value)
	proto.RegisterEnum("sysl.Loop_Mode", Loop_Mode_name, Loop_Mode_value)
	proto.RegisterEnum("sysl.Type_Primitive", Type_Primitive_name, Type_Primitive_value)
	proto.RegisterEnum("sysl.Expr_UnExpr_Op", Expr_UnExpr_Op_name, Expr_UnExpr_Op_value)
	proto.RegisterEnum("sysl.Expr_BinExpr_Op", Expr_BinExpr_Op_name, Expr_BinExpr_Op_value)
	proto.RegisterEnum("sysl.Expr_RelExpr_Op", Expr_RelExpr_Op_name, Expr_RelExpr_Op_value)
	proto.RegisterType((*SourceContext)(nil), "sysl.SourceContext")
	proto.RegisterType((*SourceContext_Location)(nil), "sysl.SourceContext.Location")
	proto.RegisterType((*Module)(nil), "sysl.Module")
	proto.RegisterMapType((map[string]*Application)(nil), "sysl.Module.AppsEntry")
	proto.RegisterType((*Attribute)(nil), "sysl.Attribute")
	proto.RegisterType((*Attribute_Array)(nil), "sysl.Attribute.Array")
	proto.RegisterType((*AppName)(nil), "sysl.AppName")
	proto.RegisterType((*Application)(nil), "sysl.Application")
	proto.RegisterMapType((map[string]*Attribute)(nil), "sysl.Application.AttrsEntry")
	proto.RegisterMapType((map[string]*Endpoint)(nil), "sysl.Application.EndpointsEntry")
	proto.RegisterMapType((map[string]*Type)(nil), "sysl.Application.TypesEntry")
	proto.RegisterMapType((map[string]*View)(nil), "sysl.Application.ViewsEntry")
	proto.RegisterType((*Endpoint)(nil), "sysl.Endpoint")
	proto.RegisterMapType((map[string]*Attribute)(nil), "sysl.Endpoint.AttrsEntry")
	proto.RegisterType((*Endpoint_RestParams)(nil), "sysl.Endpoint.RestParams")
	proto.RegisterType((*Endpoint_RestParams_QueryParam)(nil), "sysl.Endpoint.RestParams.QueryParam")
	proto.RegisterType((*Param)(nil), "sysl.Param")
	proto.RegisterType((*Statement)(nil), "sysl.Statement")
	proto.RegisterMapType((map[string]*Attribute)(nil), "sysl.Statement.AttrsEntry")
	proto.RegisterType((*Action)(nil), "sysl.Action")
	proto.RegisterType((*Call)(nil), "sysl.Call")
	proto.RegisterMapType((map[string]*Attribute)(nil), "sysl.Call.DONOTUSEAttrsEntry")
	proto.RegisterType((*Call_Arg)(nil), "sysl.Call.Arg")
	proto.RegisterType((*Cond)(nil), "sysl.Cond")
	proto.RegisterType((*Loop)(nil), "sysl.Loop")
	proto.RegisterType((*LoopN)(nil), "sysl.LoopN")
	proto.RegisterType((*Foreach)(nil), "sysl.Foreach")
	proto.RegisterType((*Alt)(nil), "sysl.Alt")
	proto.RegisterType((*Alt_Choice)(nil), "sysl.Alt.Choice")
	proto.RegisterType((*Group)(nil), "sysl.Group")
	proto.RegisterType((*Return)(nil), "sysl.Return")
	proto.RegisterType((*Type)(nil), "sysl.Type")
	proto.RegisterMapType((map[string]*Attribute)(nil), "sysl.Type.AttrsEntry")
	proto.RegisterType((*Type_Enum)(nil), "sysl.Type.Enum")
	proto.RegisterMapType((map[string]int64)(nil), "sysl.Type.Enum.ItemsEntry")
	proto.RegisterType((*Type_Tuple)(nil), "sysl.Type.Tuple")
	proto.RegisterMapType((map[string]*Type)(nil), "sysl.Type.Tuple.AttrDefsEntry")
	proto.RegisterMapType((map[string]*Type_Tuple_Field)(nil), "sysl.Type.Tuple.FUTUREFieldsEntry")
	proto.RegisterType((*Type_Tuple_Field)(nil), "sysl.Type.Tuple.Field")
	proto.RegisterType((*Type_List)(nil), "sysl.Type.List")
	proto.RegisterType((*Type_Map)(nil), "sysl.Type.Map")
	proto.RegisterType((*Type_OneOf)(nil), "sysl.Type.OneOf")
	proto.RegisterType((*Type_Relation)(nil), "sysl.Type.Relation")
	proto.RegisterMapType((map[string]*Type)(nil), "sysl.Type.Relation.AttrDefsEntry")
	proto.RegisterType((*Type_Relation_Key)(nil), "sysl.Type.Relation.Key")
	proto.RegisterType((*Type_Foreign)(nil), "sysl.Type.Foreign")
	proto.RegisterType((*Type_Constraint)(nil), "sysl.Type.Constraint")
	proto.RegisterType((*Type_Constraint_Range)(nil), "sysl.Type.Constraint.Range")
	proto.RegisterType((*Type_Constraint_Length)(nil), "sysl.Type.Constraint.Length")
	proto.RegisterType((*Type_Constraint_Resolution)(nil), "sysl.Type.Constraint.Resolution")
	proto.RegisterType((*Type_NoType)(nil), "sysl.Type.NoType")
	proto.RegisterType((*View)(nil), "sysl.View")
	proto.RegisterMapType((map[string]*Attribute)(nil), "sysl.View.AttrsEntry")
	proto.RegisterMapType((map[string]*View)(nil), "sysl.View.ViewsEntry")
	proto.RegisterType((*Expr)(nil), "sysl.Expr")
	proto.RegisterType((*Expr_GetAttr)(nil), "sysl.Expr.GetAttr")
	proto.RegisterType((*Expr_Navigate)(nil), "sysl.Expr.Navigate")
	proto.RegisterType((*Expr_List)(nil), "sysl.Expr.List")
	proto.RegisterType((*Expr_Transform)(nil), "sysl.Expr.Transform")
	proto.RegisterType((*Expr_Transform_Stmt)(nil), "sysl.Expr.Transform.Stmt")
	proto.RegisterType((*Expr_Transform_Stmt_Assign)(nil), "sysl.Expr.Transform.Stmt.Assign")
	proto.RegisterType((*Expr_IfElse)(nil), "sysl.Expr.IfElse")
	proto.RegisterType((*Expr_Call)(nil), "sysl.Expr.Call")
	proto.RegisterType((*Expr_UnExpr)(nil), "sysl.Expr.UnExpr")
	proto.RegisterType((*Expr_BinExpr)(nil), "sysl.Expr.BinExpr")
	proto.RegisterType((*Expr_RelExpr)(nil), "sysl.Expr.RelExpr")
	proto.RegisterType((*Expr_Tuple)(nil), "sysl.Expr.Tuple")
	proto.RegisterMapType((map[string]*Expr)(nil), "sysl.Expr.Tuple.AttrsEntry")
	proto.RegisterType((*Value)(nil), "sysl.Value")
	proto.RegisterType((*Value_List)(nil), "sysl.Value.List")
	proto.RegisterType((*Value_Map)(nil), "sysl.Value.Map")
	proto.RegisterMapType((map[string]*Value)(nil), "sysl.Value.Map.ItemsEntry")
	proto.RegisterType((*Value_Null)(nil), "sysl.Value.Null")
	proto.RegisterType((*ScopedRef)(nil), "sysl.ScopedRef")
	proto.RegisterType((*Scope)(nil), "sysl.Scope")
}

func init() { proto.RegisterFile("sysl.proto", fileDescriptor_a9d185230f424090) }

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