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

package pipeline_v1

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

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

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

type AtomicType int32

const (
	AtomicType_UNSPECIFIED AtomicType = 0
	AtomicType_BYTE        AtomicType = 1
	AtomicType_INT16       AtomicType = 2
	AtomicType_INT32       AtomicType = 3
	AtomicType_INT64       AtomicType = 4
	AtomicType_FLOAT       AtomicType = 5
	AtomicType_DOUBLE      AtomicType = 6
	AtomicType_STRING      AtomicType = 7
	AtomicType_BOOLEAN     AtomicType = 8
	AtomicType_BYTES       AtomicType = 9
)

var AtomicType_name = map[int32]string{
	0: "UNSPECIFIED",
	1: "BYTE",
	2: "INT16",
	3: "INT32",
	4: "INT64",
	5: "FLOAT",
	6: "DOUBLE",
	7: "STRING",
	8: "BOOLEAN",
	9: "BYTES",
}

var AtomicType_value = map[string]int32{
	"UNSPECIFIED": 0,
	"BYTE":        1,
	"INT16":       2,
	"INT32":       3,
	"INT64":       4,
	"FLOAT":       5,
	"DOUBLE":      6,
	"STRING":      7,
	"BOOLEAN":     8,
	"BYTES":       9,
}

func (x AtomicType) String() string {
	return proto.EnumName(AtomicType_name, int32(x))
}

func (AtomicType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1c5fb4d8cc22d66a, []int{0}
}

type Schema struct {
	Fields               []*Field  `protobuf:"bytes,1,rep,name=fields,proto3" json:"fields,omitempty"`
	Id                   string    `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	Options              []*Option `protobuf:"bytes,3,rep,name=options,proto3" json:"options,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

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

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

var xxx_messageInfo_Schema proto.InternalMessageInfo

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

func (m *Schema) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Schema) GetOptions() []*Option {
	if m != nil {
		return m.Options
	}
	return nil
}

type Field struct {
	Name                 string     `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Description          string     `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
	Type                 *FieldType `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"`
	Id                   int32      `protobuf:"varint,4,opt,name=id,proto3" json:"id,omitempty"`
	EncodingPosition     int32      `protobuf:"varint,5,opt,name=encoding_position,json=encodingPosition,proto3" json:"encoding_position,omitempty"`
	Options              []*Option  `protobuf:"bytes,6,rep,name=options,proto3" json:"options,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

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

var xxx_messageInfo_Field proto.InternalMessageInfo

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

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

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

func (m *Field) GetId() int32 {
	if m != nil {
		return m.Id
	}
	return 0
}

func (m *Field) GetEncodingPosition() int32 {
	if m != nil {
		return m.EncodingPosition
	}
	return 0
}

func (m *Field) GetOptions() []*Option {
	if m != nil {
		return m.Options
	}
	return nil
}

type FieldType struct {
	Nullable bool `protobuf:"varint,1,opt,name=nullable,proto3" json:"nullable,omitempty"`
	// Types that are valid to be assigned to TypeInfo:
	//	*FieldType_AtomicType
	//	*FieldType_ArrayType
	//	*FieldType_IterableType
	//	*FieldType_MapType
	//	*FieldType_RowType
	//	*FieldType_LogicalType
	TypeInfo             isFieldType_TypeInfo `protobuf_oneof:"type_info"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_FieldType proto.InternalMessageInfo

func (m *FieldType) GetNullable() bool {
	if m != nil {
		return m.Nullable
	}
	return false
}

type isFieldType_TypeInfo interface {
	isFieldType_TypeInfo()
}

type FieldType_AtomicType struct {
	AtomicType AtomicType `protobuf:"varint,2,opt,name=atomic_type,json=atomicType,proto3,enum=org.apache.beam.model.pipeline.v1.AtomicType,oneof"`
}

type FieldType_ArrayType struct {
	ArrayType *ArrayType `protobuf:"bytes,3,opt,name=array_type,json=arrayType,proto3,oneof"`
}

type FieldType_IterableType struct {
	IterableType *IterableType `protobuf:"bytes,4,opt,name=iterable_type,json=iterableType,proto3,oneof"`
}

type FieldType_MapType struct {
	MapType *MapType `protobuf:"bytes,5,opt,name=map_type,json=mapType,proto3,oneof"`
}

type FieldType_RowType struct {
	RowType *RowType `protobuf:"bytes,6,opt,name=row_type,json=rowType,proto3,oneof"`
}

type FieldType_LogicalType struct {
	LogicalType *LogicalType `protobuf:"bytes,7,opt,name=logical_type,json=logicalType,proto3,oneof"`
}

func (*FieldType_AtomicType) isFieldType_TypeInfo() {}

func (*FieldType_ArrayType) isFieldType_TypeInfo() {}

func (*FieldType_IterableType) isFieldType_TypeInfo() {}

func (*FieldType_MapType) isFieldType_TypeInfo() {}

func (*FieldType_RowType) isFieldType_TypeInfo() {}

func (*FieldType_LogicalType) isFieldType_TypeInfo() {}

func (m *FieldType) GetTypeInfo() isFieldType_TypeInfo {
	if m != nil {
		return m.TypeInfo
	}
	return nil
}

func (m *FieldType) GetAtomicType() AtomicType {
	if x, ok := m.GetTypeInfo().(*FieldType_AtomicType); ok {
		return x.AtomicType
	}
	return AtomicType_UNSPECIFIED
}

func (m *FieldType) GetArrayType() *ArrayType {
	if x, ok := m.GetTypeInfo().(*FieldType_ArrayType); ok {
		return x.ArrayType
	}
	return nil
}

func (m *FieldType) GetIterableType() *IterableType {
	if x, ok := m.GetTypeInfo().(*FieldType_IterableType); ok {
		return x.IterableType
	}
	return nil
}

func (m *FieldType) GetMapType() *MapType {
	if x, ok := m.GetTypeInfo().(*FieldType_MapType); ok {
		return x.MapType
	}
	return nil
}

func (m *FieldType) GetRowType() *RowType {
	if x, ok := m.GetTypeInfo().(*FieldType_RowType); ok {
		return x.RowType
	}
	return nil
}

func (m *FieldType) GetLogicalType() *LogicalType {
	if x, ok := m.GetTypeInfo().(*FieldType_LogicalType); ok {
		return x.LogicalType
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*FieldType) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*FieldType_AtomicType)(nil),
		(*FieldType_ArrayType)(nil),
		(*FieldType_IterableType)(nil),
		(*FieldType_MapType)(nil),
		(*FieldType_RowType)(nil),
		(*FieldType_LogicalType)(nil),
	}
}

type ArrayType struct {
	ElementType          *FieldType `protobuf:"bytes,1,opt,name=element_type,json=elementType,proto3" json:"element_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

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

var xxx_messageInfo_ArrayType proto.InternalMessageInfo

func (m *ArrayType) GetElementType() *FieldType {
	if m != nil {
		return m.ElementType
	}
	return nil
}

type IterableType struct {
	ElementType          *FieldType `protobuf:"bytes,1,opt,name=element_type,json=elementType,proto3" json:"element_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

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

var xxx_messageInfo_IterableType proto.InternalMessageInfo

func (m *IterableType) GetElementType() *FieldType {
	if m != nil {
		return m.ElementType
	}
	return nil
}

type MapType struct {
	KeyType              *FieldType `protobuf:"bytes,1,opt,name=key_type,json=keyType,proto3" json:"key_type,omitempty"`
	ValueType            *FieldType `protobuf:"bytes,2,opt,name=value_type,json=valueType,proto3" json:"value_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

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

var xxx_messageInfo_MapType proto.InternalMessageInfo

func (m *MapType) GetKeyType() *FieldType {
	if m != nil {
		return m.KeyType
	}
	return nil
}

func (m *MapType) GetValueType() *FieldType {
	if m != nil {
		return m.ValueType
	}
	return nil
}

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

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

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

var xxx_messageInfo_RowType proto.InternalMessageInfo

func (m *RowType) GetSchema() *Schema {
	if m != nil {
		return m.Schema
	}
	return nil
}

type LogicalType struct {
	Urn                  string      `protobuf:"bytes,1,opt,name=urn,proto3" json:"urn,omitempty"`
	Payload              []byte      `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
	Representation       *FieldType  `protobuf:"bytes,3,opt,name=representation,proto3" json:"representation,omitempty"`
	ArgumentType         *FieldType  `protobuf:"bytes,4,opt,name=argument_type,json=argumentType,proto3" json:"argument_type,omitempty"`
	Argument             *FieldValue `protobuf:"bytes,5,opt,name=argument,proto3" json:"argument,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_LogicalType proto.InternalMessageInfo

func (m *LogicalType) GetUrn() string {
	if m != nil {
		return m.Urn
	}
	return ""
}

func (m *LogicalType) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *LogicalType) GetRepresentation() *FieldType {
	if m != nil {
		return m.Representation
	}
	return nil
}

func (m *LogicalType) GetArgumentType() *FieldType {
	if m != nil {
		return m.ArgumentType
	}
	return nil
}

func (m *LogicalType) GetArgument() *FieldValue {
	if m != nil {
		return m.Argument
	}
	return nil
}

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

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

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

var xxx_messageInfo_Option proto.InternalMessageInfo

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

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

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

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

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

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

var xxx_messageInfo_Row proto.InternalMessageInfo

func (m *Row) GetValues() []*FieldValue {
	if m != nil {
		return m.Values
	}
	return nil
}

type FieldValue struct {
	// Types that are valid to be assigned to FieldValue:
	//	*FieldValue_AtomicValue
	//	*FieldValue_ArrayValue
	//	*FieldValue_IterableValue
	//	*FieldValue_MapValue
	//	*FieldValue_RowValue
	//	*FieldValue_LogicalTypeValue
	FieldValue           isFieldValue_FieldValue `protobuf_oneof:"field_value"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

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

var xxx_messageInfo_FieldValue proto.InternalMessageInfo

type isFieldValue_FieldValue interface {
	isFieldValue_FieldValue()
}

type FieldValue_AtomicValue struct {
	AtomicValue *AtomicTypeValue `protobuf:"bytes,1,opt,name=atomic_value,json=atomicValue,proto3,oneof"`
}

type FieldValue_ArrayValue struct {
	ArrayValue *ArrayTypeValue `protobuf:"bytes,2,opt,name=array_value,json=arrayValue,proto3,oneof"`
}

type FieldValue_IterableValue struct {
	IterableValue *IterableTypeValue `protobuf:"bytes,3,opt,name=iterable_value,json=iterableValue,proto3,oneof"`
}

type FieldValue_MapValue struct {
	MapValue *MapTypeValue `protobuf:"bytes,4,opt,name=map_value,json=mapValue,proto3,oneof"`
}

type FieldValue_RowValue struct {
	RowValue *Row `protobuf:"bytes,5,opt,name=row_value,json=rowValue,proto3,oneof"`
}

type FieldValue_LogicalTypeValue struct {
	LogicalTypeValue *LogicalTypeValue `protobuf:"bytes,6,opt,name=logical_type_value,json=logicalTypeValue,proto3,oneof"`
}

func (*FieldValue_AtomicValue) isFieldValue_FieldValue() {}

func (*FieldValue_ArrayValue) isFieldValue_FieldValue() {}

func (*FieldValue_IterableValue) isFieldValue_FieldValue() {}

func (*FieldValue_MapValue) isFieldValue_FieldValue() {}

func (*FieldValue_RowValue) isFieldValue_FieldValue() {}

func (*FieldValue_LogicalTypeValue) isFieldValue_FieldValue() {}

func (m *FieldValue) GetFieldValue() isFieldValue_FieldValue {
	if m != nil {
		return m.FieldValue
	}
	return nil
}

func (m *FieldValue) GetAtomicValue() *AtomicTypeValue {
	if x, ok := m.GetFieldValue().(*FieldValue_AtomicValue); ok {
		return x.AtomicValue
	}
	return nil
}

func (m *FieldValue) GetArrayValue() *ArrayTypeValue {
	if x, ok := m.GetFieldValue().(*FieldValue_ArrayValue); ok {
		return x.ArrayValue
	}
	return nil
}

func (m *FieldValue) GetIterableValue() *IterableTypeValue {
	if x, ok := m.GetFieldValue().(*FieldValue_IterableValue); ok {
		return x.IterableValue
	}
	return nil
}

func (m *FieldValue) GetMapValue() *MapTypeValue {
	if x, ok := m.GetFieldValue().(*FieldValue_MapValue); ok {
		return x.MapValue
	}
	return nil
}

func (m *FieldValue) GetRowValue() *Row {
	if x, ok := m.GetFieldValue().(*FieldValue_RowValue); ok {
		return x.RowValue
	}
	return nil
}

func (m *FieldValue) GetLogicalTypeValue() *LogicalTypeValue {
	if x, ok := m.GetFieldValue().(*FieldValue_LogicalTypeValue); ok {
		return x.LogicalTypeValue
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*FieldValue) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*FieldValue_AtomicValue)(nil),
		(*FieldValue_ArrayValue)(nil),
		(*FieldValue_IterableValue)(nil),
		(*FieldValue_MapValue)(nil),
		(*FieldValue_RowValue)(nil),
		(*FieldValue_LogicalTypeValue)(nil),
	}
}

type AtomicTypeValue struct {
	// Types that are valid to be assigned to Value:
	//	*AtomicTypeValue_Byte
	//	*AtomicTypeValue_Int16
	//	*AtomicTypeValue_Int32
	//	*AtomicTypeValue_Int64
	//	*AtomicTypeValue_Float
	//	*AtomicTypeValue_Double
	//	*AtomicTypeValue_String_
	//	*AtomicTypeValue_Boolean
	//	*AtomicTypeValue_Bytes
	Value                isAtomicTypeValue_Value `protobuf_oneof:"value"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

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

var xxx_messageInfo_AtomicTypeValue proto.InternalMessageInfo

type isAtomicTypeValue_Value interface {
	isAtomicTypeValue_Value()
}

type AtomicTypeValue_Byte struct {
	Byte int32 `protobuf:"varint,1,opt,name=byte,proto3,oneof"`
}

type AtomicTypeValue_Int16 struct {
	Int16 int32 `protobuf:"varint,2,opt,name=int16,proto3,oneof"`
}

type AtomicTypeValue_Int32 struct {
	Int32 int32 `protobuf:"varint,3,opt,name=int32,proto3,oneof"`
}

type AtomicTypeValue_Int64 struct {
	Int64 int64 `protobuf:"varint,4,opt,name=int64,proto3,oneof"`
}

type AtomicTypeValue_Float struct {
	Float float32 `protobuf:"fixed32,5,opt,name=float,proto3,oneof"`
}

type AtomicTypeValue_Double struct {
	Double float64 `protobuf:"fixed64,6,opt,name=double,proto3,oneof"`
}

type AtomicTypeValue_String_ struct {
	String_ string `protobuf:"bytes,7,opt,name=string,proto3,oneof"`
}

type AtomicTypeValue_Boolean struct {
	Boolean bool `protobuf:"varint,8,opt,name=boolean,proto3,oneof"`
}

type AtomicTypeValue_Bytes struct {
	Bytes []byte `protobuf:"bytes,9,opt,name=bytes,proto3,oneof"`
}

func (*AtomicTypeValue_Byte) isAtomicTypeValue_Value() {}

func (*AtomicTypeValue_Int16) isAtomicTypeValue_Value() {}

func (*AtomicTypeValue_Int32) isAtomicTypeValue_Value() {}

func (*AtomicTypeValue_Int64) isAtomicTypeValue_Value() {}

func (*AtomicTypeValue_Float) isAtomicTypeValue_Value() {}

func (*AtomicTypeValue_Double) isAtomicTypeValue_Value() {}

func (*AtomicTypeValue_String_) isAtomicTypeValue_Value() {}

func (*AtomicTypeValue_Boolean) isAtomicTypeValue_Value() {}

func (*AtomicTypeValue_Bytes) isAtomicTypeValue_Value() {}

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

func (m *AtomicTypeValue) GetByte() int32 {
	if x, ok := m.GetValue().(*AtomicTypeValue_Byte); ok {
		return x.Byte
	}
	return 0
}

func (m *AtomicTypeValue) GetInt16() int32 {
	if x, ok := m.GetValue().(*AtomicTypeValue_Int16); ok {
		return x.Int16
	}
	return 0
}

func (m *AtomicTypeValue) GetInt32() int32 {
	if x, ok := m.GetValue().(*AtomicTypeValue_Int32); ok {
		return x.Int32
	}
	return 0
}

func (m *AtomicTypeValue) GetInt64() int64 {
	if x, ok := m.GetValue().(*AtomicTypeValue_Int64); ok {
		return x.Int64
	}
	return 0
}

func (m *AtomicTypeValue) GetFloat() float32 {
	if x, ok := m.GetValue().(*AtomicTypeValue_Float); ok {
		return x.Float
	}
	return 0
}

func (m *AtomicTypeValue) GetDouble() float64 {
	if x, ok := m.GetValue().(*AtomicTypeValue_Double); ok {
		return x.Double
	}
	return 0
}

func (m *AtomicTypeValue) GetString_() string {
	if x, ok := m.GetValue().(*AtomicTypeValue_String_); ok {
		return x.String_
	}
	return ""
}

func (m *AtomicTypeValue) GetBoolean() bool {
	if x, ok := m.GetValue().(*AtomicTypeValue_Boolean); ok {
		return x.Boolean
	}
	return false
}

func (m *AtomicTypeValue) GetBytes() []byte {
	if x, ok := m.GetValue().(*AtomicTypeValue_Bytes); ok {
		return x.Bytes
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*AtomicTypeValue) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*AtomicTypeValue_Byte)(nil),
		(*AtomicTypeValue_Int16)(nil),
		(*AtomicTypeValue_Int32)(nil),
		(*AtomicTypeValue_Int64)(nil),
		(*AtomicTypeValue_Float)(nil),
		(*AtomicTypeValue_Double)(nil),
		(*AtomicTypeValue_String_)(nil),
		(*AtomicTypeValue_Boolean)(nil),
		(*AtomicTypeValue_Bytes)(nil),
	}
}

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

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

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

var xxx_messageInfo_ArrayTypeValue proto.InternalMessageInfo

func (m *ArrayTypeValue) GetElement() []*FieldValue {
	if m != nil {
		return m.Element
	}
	return nil
}

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

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

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

var xxx_messageInfo_IterableTypeValue proto.InternalMessageInfo

func (m *IterableTypeValue) GetElement() []*FieldValue {
	if m != nil {
		return m.Element
	}
	return nil
}

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

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

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

var xxx_messageInfo_MapTypeValue proto.InternalMessageInfo

func (m *MapTypeValue) GetEntries() []*MapTypeEntry {
	if m != nil {
		return m.Entries
	}
	return nil
}

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

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

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

var xxx_messageInfo_MapTypeEntry proto.InternalMessageInfo

func (m *MapTypeEntry) GetKey() *FieldValue {
	if m != nil {
		return m.Key
	}
	return nil
}

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

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

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

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

var xxx_messageInfo_LogicalTypeValue proto.InternalMessageInfo

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

func init() {
	proto.RegisterEnum("org.apache.beam.model.pipeline.v1.AtomicType", AtomicType_name, AtomicType_value)
	proto.RegisterType((*Schema)(nil), "org.apache.beam.model.pipeline.v1.Schema")
	proto.RegisterType((*Field)(nil), "org.apache.beam.model.pipeline.v1.Field")
	proto.RegisterType((*FieldType)(nil), "org.apache.beam.model.pipeline.v1.FieldType")
	proto.RegisterType((*ArrayType)(nil), "org.apache.beam.model.pipeline.v1.ArrayType")
	proto.RegisterType((*IterableType)(nil), "org.apache.beam.model.pipeline.v1.IterableType")
	proto.RegisterType((*MapType)(nil), "org.apache.beam.model.pipeline.v1.MapType")
	proto.RegisterType((*RowType)(nil), "org.apache.beam.model.pipeline.v1.RowType")
	proto.RegisterType((*LogicalType)(nil), "org.apache.beam.model.pipeline.v1.LogicalType")
	proto.RegisterType((*Option)(nil), "org.apache.beam.model.pipeline.v1.Option")
	proto.RegisterType((*Row)(nil), "org.apache.beam.model.pipeline.v1.Row")
	proto.RegisterType((*FieldValue)(nil), "org.apache.beam.model.pipeline.v1.FieldValue")
	proto.RegisterType((*AtomicTypeValue)(nil), "org.apache.beam.model.pipeline.v1.AtomicTypeValue")
	proto.RegisterType((*ArrayTypeValue)(nil), "org.apache.beam.model.pipeline.v1.ArrayTypeValue")
	proto.RegisterType((*IterableTypeValue)(nil), "org.apache.beam.model.pipeline.v1.IterableTypeValue")
	proto.RegisterType((*MapTypeValue)(nil), "org.apache.beam.model.pipeline.v1.MapTypeValue")
	proto.RegisterType((*MapTypeEntry)(nil), "org.apache.beam.model.pipeline.v1.MapTypeEntry")
	proto.RegisterType((*LogicalTypeValue)(nil), "org.apache.beam.model.pipeline.v1.LogicalTypeValue")
}

func init() { proto.RegisterFile("schema.proto", fileDescriptor_1c5fb4d8cc22d66a) }

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