message/common.pb.go

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

/*
Package message is a generated protocol buffer package.

It is generated from these files:
	common.proto
	requests.proto
	responses.proto

It has these top-level messages:
	ConnectionProperties
	StatementHandle
	Signature
	ColumnMetaData
	AvaticaType
	AvaticaParameter
	CursorFactory
	Frame
	Row
	DatabaseProperty
	WireMessage
	ColumnValue
	TypedValue
	MetaDataOperationArgument
	QueryState
	CatalogsRequest
	DatabasePropertyRequest
	SchemasRequest
	TablesRequest
	TableTypesRequest
	ColumnsRequest
	TypeInfoRequest
	PrepareAndExecuteRequest
	PrepareRequest
	FetchRequest
	CreateStatementRequest
	CloseStatementRequest
	OpenConnectionRequest
	CloseConnectionRequest
	ConnectionSyncRequest
	ExecuteRequest
	SyncResultsRequest
	CommitRequest
	RollbackRequest
	PrepareAndExecuteBatchRequest
	UpdateBatch
	ExecuteBatchRequest
	ResultSetResponse
	ExecuteResponse
	PrepareResponse
	FetchResponse
	CreateStatementResponse
	CloseStatementResponse
	OpenConnectionResponse
	CloseConnectionResponse
	ConnectionSyncResponse
	DatabasePropertyElement
	DatabasePropertyResponse
	ErrorResponse
	SyncResultsResponse
	RpcMetadata
	CommitResponse
	RollbackResponse
	ExecuteBatchResponse
*/
package message

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import 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.ProtoPackageIsVersion2 // please upgrade the proto package

// Has to be consistent with Meta.StatementType
type StatementType int32

const (
	StatementType_SELECT    StatementType = 0
	StatementType_INSERT    StatementType = 1
	StatementType_UPDATE    StatementType = 2
	StatementType_DELETE    StatementType = 3
	StatementType_UPSERT    StatementType = 4
	StatementType_MERGE     StatementType = 5
	StatementType_OTHER_DML StatementType = 6
	StatementType_CREATE    StatementType = 7
	StatementType_DROP      StatementType = 8
	StatementType_ALTER     StatementType = 9
	StatementType_OTHER_DDL StatementType = 10
	StatementType_CALL      StatementType = 11
)

var StatementType_name = map[int32]string{
	0:  "SELECT",
	1:  "INSERT",
	2:  "UPDATE",
	3:  "DELETE",
	4:  "UPSERT",
	5:  "MERGE",
	6:  "OTHER_DML",
	7:  "CREATE",
	8:  "DROP",
	9:  "ALTER",
	10: "OTHER_DDL",
	11: "CALL",
}
var StatementType_value = map[string]int32{
	"SELECT":    0,
	"INSERT":    1,
	"UPDATE":    2,
	"DELETE":    3,
	"UPSERT":    4,
	"MERGE":     5,
	"OTHER_DML": 6,
	"CREATE":    7,
	"DROP":      8,
	"ALTER":     9,
	"OTHER_DDL": 10,
	"CALL":      11,
}

func (x StatementType) String() string {
	return proto.EnumName(StatementType_name, int32(x))
}
func (StatementType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }

type Rep int32

const (
	Rep_PRIMITIVE_BOOLEAN  Rep = 0
	Rep_PRIMITIVE_BYTE     Rep = 1
	Rep_PRIMITIVE_CHAR     Rep = 2
	Rep_PRIMITIVE_SHORT    Rep = 3
	Rep_PRIMITIVE_INT      Rep = 4
	Rep_PRIMITIVE_LONG     Rep = 5
	Rep_PRIMITIVE_FLOAT    Rep = 6
	Rep_PRIMITIVE_DOUBLE   Rep = 7
	Rep_BOOLEAN            Rep = 8
	Rep_BYTE               Rep = 9
	Rep_CHARACTER          Rep = 10
	Rep_SHORT              Rep = 11
	Rep_INTEGER            Rep = 12
	Rep_LONG               Rep = 13
	Rep_FLOAT              Rep = 14
	Rep_DOUBLE             Rep = 15
	Rep_BIG_INTEGER        Rep = 25
	Rep_BIG_DECIMAL        Rep = 26
	Rep_JAVA_SQL_TIME      Rep = 16
	Rep_JAVA_SQL_TIMESTAMP Rep = 17
	Rep_JAVA_SQL_DATE      Rep = 18
	Rep_JAVA_UTIL_DATE     Rep = 19
	Rep_BYTE_STRING        Rep = 20
	Rep_STRING             Rep = 21
	Rep_NUMBER             Rep = 22
	Rep_OBJECT             Rep = 23
	Rep_NULL               Rep = 24
	Rep_ARRAY              Rep = 27
	Rep_STRUCT             Rep = 28
	Rep_MULTISET           Rep = 29
)

var Rep_name = map[int32]string{
	0:  "PRIMITIVE_BOOLEAN",
	1:  "PRIMITIVE_BYTE",
	2:  "PRIMITIVE_CHAR",
	3:  "PRIMITIVE_SHORT",
	4:  "PRIMITIVE_INT",
	5:  "PRIMITIVE_LONG",
	6:  "PRIMITIVE_FLOAT",
	7:  "PRIMITIVE_DOUBLE",
	8:  "BOOLEAN",
	9:  "BYTE",
	10: "CHARACTER",
	11: "SHORT",
	12: "INTEGER",
	13: "LONG",
	14: "FLOAT",
	15: "DOUBLE",
	25: "BIG_INTEGER",
	26: "BIG_DECIMAL",
	16: "JAVA_SQL_TIME",
	17: "JAVA_SQL_TIMESTAMP",
	18: "JAVA_SQL_DATE",
	19: "JAVA_UTIL_DATE",
	20: "BYTE_STRING",
	21: "STRING",
	22: "NUMBER",
	23: "OBJECT",
	24: "NULL",
	27: "ARRAY",
	28: "STRUCT",
	29: "MULTISET",
}
var Rep_value = map[string]int32{
	"PRIMITIVE_BOOLEAN":  0,
	"PRIMITIVE_BYTE":     1,
	"PRIMITIVE_CHAR":     2,
	"PRIMITIVE_SHORT":    3,
	"PRIMITIVE_INT":      4,
	"PRIMITIVE_LONG":     5,
	"PRIMITIVE_FLOAT":    6,
	"PRIMITIVE_DOUBLE":   7,
	"BOOLEAN":            8,
	"BYTE":               9,
	"CHARACTER":          10,
	"SHORT":              11,
	"INTEGER":            12,
	"LONG":               13,
	"FLOAT":              14,
	"DOUBLE":             15,
	"BIG_INTEGER":        25,
	"BIG_DECIMAL":        26,
	"JAVA_SQL_TIME":      16,
	"JAVA_SQL_TIMESTAMP": 17,
	"JAVA_SQL_DATE":      18,
	"JAVA_UTIL_DATE":     19,
	"BYTE_STRING":        20,
	"STRING":             21,
	"NUMBER":             22,
	"OBJECT":             23,
	"NULL":               24,
	"ARRAY":              27,
	"STRUCT":             28,
	"MULTISET":           29,
}

func (x Rep) String() string {
	return proto.EnumName(Rep_name, int32(x))
}
func (Rep) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }

// The severity of some unexpected outcome to an operation.
// Protobuf enum values must be unique across all other enums
type Severity int32

const (
	Severity_UNKNOWN_SEVERITY Severity = 0
	Severity_FATAL_SEVERITY   Severity = 1
	Severity_ERROR_SEVERITY   Severity = 2
	Severity_WARNING_SEVERITY Severity = 3
)

var Severity_name = map[int32]string{
	0: "UNKNOWN_SEVERITY",
	1: "FATAL_SEVERITY",
	2: "ERROR_SEVERITY",
	3: "WARNING_SEVERITY",
}
var Severity_value = map[string]int32{
	"UNKNOWN_SEVERITY": 0,
	"FATAL_SEVERITY":   1,
	"ERROR_SEVERITY":   2,
	"WARNING_SEVERITY": 3,
}

func (x Severity) String() string {
	return proto.EnumName(Severity_name, int32(x))
}
func (Severity) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }

// Enumeration corresponding to DatabaseMetaData operations
type MetaDataOperation int32

const (
	MetaDataOperation_GET_ATTRIBUTES             MetaDataOperation = 0
	MetaDataOperation_GET_BEST_ROW_IDENTIFIER    MetaDataOperation = 1
	MetaDataOperation_GET_CATALOGS               MetaDataOperation = 2
	MetaDataOperation_GET_CLIENT_INFO_PROPERTIES MetaDataOperation = 3
	MetaDataOperation_GET_COLUMN_PRIVILEGES      MetaDataOperation = 4
	MetaDataOperation_GET_COLUMNS                MetaDataOperation = 5
	MetaDataOperation_GET_CROSS_REFERENCE        MetaDataOperation = 6
	MetaDataOperation_GET_EXPORTED_KEYS          MetaDataOperation = 7
	MetaDataOperation_GET_FUNCTION_COLUMNS       MetaDataOperation = 8
	MetaDataOperation_GET_FUNCTIONS              MetaDataOperation = 9
	MetaDataOperation_GET_IMPORTED_KEYS          MetaDataOperation = 10
	MetaDataOperation_GET_INDEX_INFO             MetaDataOperation = 11
	MetaDataOperation_GET_PRIMARY_KEYS           MetaDataOperation = 12
	MetaDataOperation_GET_PROCEDURE_COLUMNS      MetaDataOperation = 13
	MetaDataOperation_GET_PROCEDURES             MetaDataOperation = 14
	MetaDataOperation_GET_PSEUDO_COLUMNS         MetaDataOperation = 15
	MetaDataOperation_GET_SCHEMAS                MetaDataOperation = 16
	MetaDataOperation_GET_SCHEMAS_WITH_ARGS      MetaDataOperation = 17
	MetaDataOperation_GET_SUPER_TABLES           MetaDataOperation = 18
	MetaDataOperation_GET_SUPER_TYPES            MetaDataOperation = 19
	MetaDataOperation_GET_TABLE_PRIVILEGES       MetaDataOperation = 20
	MetaDataOperation_GET_TABLES                 MetaDataOperation = 21
	MetaDataOperation_GET_TABLE_TYPES            MetaDataOperation = 22
	MetaDataOperation_GET_TYPE_INFO              MetaDataOperation = 23
	MetaDataOperation_GET_UDTS                   MetaDataOperation = 24
	MetaDataOperation_GET_VERSION_COLUMNS        MetaDataOperation = 25
)

var MetaDataOperation_name = map[int32]string{
	0:  "GET_ATTRIBUTES",
	1:  "GET_BEST_ROW_IDENTIFIER",
	2:  "GET_CATALOGS",
	3:  "GET_CLIENT_INFO_PROPERTIES",
	4:  "GET_COLUMN_PRIVILEGES",
	5:  "GET_COLUMNS",
	6:  "GET_CROSS_REFERENCE",
	7:  "GET_EXPORTED_KEYS",
	8:  "GET_FUNCTION_COLUMNS",
	9:  "GET_FUNCTIONS",
	10: "GET_IMPORTED_KEYS",
	11: "GET_INDEX_INFO",
	12: "GET_PRIMARY_KEYS",
	13: "GET_PROCEDURE_COLUMNS",
	14: "GET_PROCEDURES",
	15: "GET_PSEUDO_COLUMNS",
	16: "GET_SCHEMAS",
	17: "GET_SCHEMAS_WITH_ARGS",
	18: "GET_SUPER_TABLES",
	19: "GET_SUPER_TYPES",
	20: "GET_TABLE_PRIVILEGES",
	21: "GET_TABLES",
	22: "GET_TABLE_TYPES",
	23: "GET_TYPE_INFO",
	24: "GET_UDTS",
	25: "GET_VERSION_COLUMNS",
}
var MetaDataOperation_value = map[string]int32{
	"GET_ATTRIBUTES":             0,
	"GET_BEST_ROW_IDENTIFIER":    1,
	"GET_CATALOGS":               2,
	"GET_CLIENT_INFO_PROPERTIES": 3,
	"GET_COLUMN_PRIVILEGES":      4,
	"GET_COLUMNS":                5,
	"GET_CROSS_REFERENCE":        6,
	"GET_EXPORTED_KEYS":          7,
	"GET_FUNCTION_COLUMNS":       8,
	"GET_FUNCTIONS":              9,
	"GET_IMPORTED_KEYS":          10,
	"GET_INDEX_INFO":             11,
	"GET_PRIMARY_KEYS":           12,
	"GET_PROCEDURE_COLUMNS":      13,
	"GET_PROCEDURES":             14,
	"GET_PSEUDO_COLUMNS":         15,
	"GET_SCHEMAS":                16,
	"GET_SCHEMAS_WITH_ARGS":      17,
	"GET_SUPER_TABLES":           18,
	"GET_SUPER_TYPES":            19,
	"GET_TABLE_PRIVILEGES":       20,
	"GET_TABLES":                 21,
	"GET_TABLE_TYPES":            22,
	"GET_TYPE_INFO":              23,
	"GET_UDTS":                   24,
	"GET_VERSION_COLUMNS":        25,
}

func (x MetaDataOperation) String() string {
	return proto.EnumName(MetaDataOperation_name, int32(x))
}
func (MetaDataOperation) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }

type StateType int32

const (
	StateType_SQL      StateType = 0
	StateType_METADATA StateType = 1
)

var StateType_name = map[int32]string{
	0: "SQL",
	1: "METADATA",
}
var StateType_value = map[string]int32{
	"SQL":      0,
	"METADATA": 1,
}

func (x StateType) String() string {
	return proto.EnumName(StateType_name, int32(x))
}
func (StateType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }

type CursorFactory_Style int32

const (
	CursorFactory_OBJECT            CursorFactory_Style = 0
	CursorFactory_RECORD            CursorFactory_Style = 1
	CursorFactory_RECORD_PROJECTION CursorFactory_Style = 2
	CursorFactory_ARRAY             CursorFactory_Style = 3
	CursorFactory_LIST              CursorFactory_Style = 4
	CursorFactory_MAP               CursorFactory_Style = 5
)

var CursorFactory_Style_name = map[int32]string{
	0: "OBJECT",
	1: "RECORD",
	2: "RECORD_PROJECTION",
	3: "ARRAY",
	4: "LIST",
	5: "MAP",
}
var CursorFactory_Style_value = map[string]int32{
	"OBJECT":            0,
	"RECORD":            1,
	"RECORD_PROJECTION": 2,
	"ARRAY":             3,
	"LIST":              4,
	"MAP":               5,
}

func (x CursorFactory_Style) String() string {
	return proto.EnumName(CursorFactory_Style_name, int32(x))
}
func (CursorFactory_Style) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{6, 0} }

type MetaDataOperationArgument_ArgumentType int32

const (
	MetaDataOperationArgument_STRING          MetaDataOperationArgument_ArgumentType = 0
	MetaDataOperationArgument_BOOL            MetaDataOperationArgument_ArgumentType = 1
	MetaDataOperationArgument_INT             MetaDataOperationArgument_ArgumentType = 2
	MetaDataOperationArgument_REPEATED_STRING MetaDataOperationArgument_ArgumentType = 3
	MetaDataOperationArgument_REPEATED_INT    MetaDataOperationArgument_ArgumentType = 4
	MetaDataOperationArgument_NULL            MetaDataOperationArgument_ArgumentType = 5
)

var MetaDataOperationArgument_ArgumentType_name = map[int32]string{
	0: "STRING",
	1: "BOOL",
	2: "INT",
	3: "REPEATED_STRING",
	4: "REPEATED_INT",
	5: "NULL",
}
var MetaDataOperationArgument_ArgumentType_value = map[string]int32{
	"STRING":          0,
	"BOOL":            1,
	"INT":             2,
	"REPEATED_STRING": 3,
	"REPEATED_INT":    4,
	"NULL":            5,
}

func (x MetaDataOperationArgument_ArgumentType) String() string {
	return proto.EnumName(MetaDataOperationArgument_ArgumentType_name, int32(x))
}
func (MetaDataOperationArgument_ArgumentType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor0, []int{13, 0}
}

// Details about a connection
type ConnectionProperties struct {
	IsDirty              bool   `protobuf:"varint,1,opt,name=is_dirty,json=isDirty" json:"is_dirty,omitempty"`
	AutoCommit           bool   `protobuf:"varint,2,opt,name=auto_commit,json=autoCommit" json:"auto_commit,omitempty"`
	HasAutoCommit        bool   `protobuf:"varint,7,opt,name=has_auto_commit,json=hasAutoCommit" json:"has_auto_commit,omitempty"`
	ReadOnly             bool   `protobuf:"varint,3,opt,name=read_only,json=readOnly" json:"read_only,omitempty"`
	HasReadOnly          bool   `protobuf:"varint,8,opt,name=has_read_only,json=hasReadOnly" json:"has_read_only,omitempty"`
	TransactionIsolation uint32 `protobuf:"varint,4,opt,name=transaction_isolation,json=transactionIsolation" json:"transaction_isolation,omitempty"`
	Catalog              string `protobuf:"bytes,5,opt,name=catalog" json:"catalog,omitempty"`
	Schema               string `protobuf:"bytes,6,opt,name=schema" json:"schema,omitempty"`
}

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

func (m *ConnectionProperties) GetIsDirty() bool {
	if m != nil {
		return m.IsDirty
	}
	return false
}

func (m *ConnectionProperties) GetAutoCommit() bool {
	if m != nil {
		return m.AutoCommit
	}
	return false
}

func (m *ConnectionProperties) GetHasAutoCommit() bool {
	if m != nil {
		return m.HasAutoCommit
	}
	return false
}

func (m *ConnectionProperties) GetReadOnly() bool {
	if m != nil {
		return m.ReadOnly
	}
	return false
}

func (m *ConnectionProperties) GetHasReadOnly() bool {
	if m != nil {
		return m.HasReadOnly
	}
	return false
}

func (m *ConnectionProperties) GetTransactionIsolation() uint32 {
	if m != nil {
		return m.TransactionIsolation
	}
	return 0
}

func (m *ConnectionProperties) GetCatalog() string {
	if m != nil {
		return m.Catalog
	}
	return ""
}

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

// Statement handle
type StatementHandle struct {
	ConnectionId string     `protobuf:"bytes,1,opt,name=connection_id,json=connectionId" json:"connection_id,omitempty"`
	Id           uint32     `protobuf:"varint,2,opt,name=id" json:"id,omitempty"`
	Signature    *Signature `protobuf:"bytes,3,opt,name=signature" json:"signature,omitempty"`
}

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

func (m *StatementHandle) GetConnectionId() string {
	if m != nil {
		return m.ConnectionId
	}
	return ""
}

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

func (m *StatementHandle) GetSignature() *Signature {
	if m != nil {
		return m.Signature
	}
	return nil
}

// Results of preparing a statement
type Signature struct {
	Columns       []*ColumnMetaData   `protobuf:"bytes,1,rep,name=columns" json:"columns,omitempty"`
	Sql           string              `protobuf:"bytes,2,opt,name=sql" json:"sql,omitempty"`
	Parameters    []*AvaticaParameter `protobuf:"bytes,3,rep,name=parameters" json:"parameters,omitempty"`
	CursorFactory *CursorFactory      `protobuf:"bytes,4,opt,name=cursor_factory,json=cursorFactory" json:"cursor_factory,omitempty"`
	StatementType StatementType       `protobuf:"varint,5,opt,name=statementType,enum=StatementType" json:"statementType,omitempty"`
}

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

func (m *Signature) GetColumns() []*ColumnMetaData {
	if m != nil {
		return m.Columns
	}
	return nil
}

func (m *Signature) GetSql() string {
	if m != nil {
		return m.Sql
	}
	return ""
}

func (m *Signature) GetParameters() []*AvaticaParameter {
	if m != nil {
		return m.Parameters
	}
	return nil
}

func (m *Signature) GetCursorFactory() *CursorFactory {
	if m != nil {
		return m.CursorFactory
	}
	return nil
}

func (m *Signature) GetStatementType() StatementType {
	if m != nil {
		return m.StatementType
	}
	return StatementType_SELECT
}

type ColumnMetaData struct {
	Ordinal            uint32       `protobuf:"varint,1,opt,name=ordinal" json:"ordinal,omitempty"`
	AutoIncrement      bool         `protobuf:"varint,2,opt,name=auto_increment,json=autoIncrement" json:"auto_increment,omitempty"`
	CaseSensitive      bool         `protobuf:"varint,3,opt,name=case_sensitive,json=caseSensitive" json:"case_sensitive,omitempty"`
	Searchable         bool         `protobuf:"varint,4,opt,name=searchable" json:"searchable,omitempty"`
	Currency           bool         `protobuf:"varint,5,opt,name=currency" json:"currency,omitempty"`
	Nullable           uint32       `protobuf:"varint,6,opt,name=nullable" json:"nullable,omitempty"`
	Signed             bool         `protobuf:"varint,7,opt,name=signed" json:"signed,omitempty"`
	DisplaySize        uint32       `protobuf:"varint,8,opt,name=display_size,json=displaySize" json:"display_size,omitempty"`
	Label              string       `protobuf:"bytes,9,opt,name=label" json:"label,omitempty"`
	ColumnName         string       `protobuf:"bytes,10,opt,name=column_name,json=columnName" json:"column_name,omitempty"`
	SchemaName         string       `protobuf:"bytes,11,opt,name=schema_name,json=schemaName" json:"schema_name,omitempty"`
	Precision          uint32       `protobuf:"varint,12,opt,name=precision" json:"precision,omitempty"`
	Scale              uint32       `protobuf:"varint,13,opt,name=scale" json:"scale,omitempty"`
	TableName          string       `protobuf:"bytes,14,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
	CatalogName        string       `protobuf:"bytes,15,opt,name=catalog_name,json=catalogName" json:"catalog_name,omitempty"`
	ReadOnly           bool         `protobuf:"varint,16,opt,name=read_only,json=readOnly" json:"read_only,omitempty"`
	Writable           bool         `protobuf:"varint,17,opt,name=writable" json:"writable,omitempty"`
	DefinitelyWritable bool         `protobuf:"varint,18,opt,name=definitely_writable,json=definitelyWritable" json:"definitely_writable,omitempty"`
	ColumnClassName    string       `protobuf:"bytes,19,opt,name=column_class_name,json=columnClassName" json:"column_class_name,omitempty"`
	Type               *AvaticaType `protobuf:"bytes,20,opt,name=type" json:"type,omitempty"`
}

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

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

func (m *ColumnMetaData) GetAutoIncrement() bool {
	if m != nil {
		return m.AutoIncrement
	}
	return false
}

func (m *ColumnMetaData) GetCaseSensitive() bool {
	if m != nil {
		return m.CaseSensitive
	}
	return false
}

func (m *ColumnMetaData) GetSearchable() bool {
	if m != nil {
		return m.Searchable
	}
	return false
}

func (m *ColumnMetaData) GetCurrency() bool {
	if m != nil {
		return m.Currency
	}
	return false
}

func (m *ColumnMetaData) GetNullable() uint32 {
	if m != nil {
		return m.Nullable
	}
	return 0
}

func (m *ColumnMetaData) GetSigned() bool {
	if m != nil {
		return m.Signed
	}
	return false
}

func (m *ColumnMetaData) GetDisplaySize() uint32 {
	if m != nil {
		return m.DisplaySize
	}
	return 0
}

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

func (m *ColumnMetaData) GetColumnName() string {
	if m != nil {
		return m.ColumnName
	}
	return ""
}

func (m *ColumnMetaData) GetSchemaName() string {
	if m != nil {
		return m.SchemaName
	}
	return ""
}

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

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

func (m *ColumnMetaData) GetTableName() string {
	if m != nil {
		return m.TableName
	}
	return ""
}

func (m *ColumnMetaData) GetCatalogName() string {
	if m != nil {
		return m.CatalogName
	}
	return ""
}

func (m *ColumnMetaData) GetReadOnly() bool {
	if m != nil {
		return m.ReadOnly
	}
	return false
}

func (m *ColumnMetaData) GetWritable() bool {
	if m != nil {
		return m.Writable
	}
	return false
}

func (m *ColumnMetaData) GetDefinitelyWritable() bool {
	if m != nil {
		return m.DefinitelyWritable
	}
	return false
}

func (m *ColumnMetaData) GetColumnClassName() string {
	if m != nil {
		return m.ColumnClassName
	}
	return ""
}

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

// Base class for a column type
type AvaticaType struct {
	Id        uint32            `protobuf:"varint,1,opt,name=id" json:"id,omitempty"`
	Name      string            `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
	Rep       Rep               `protobuf:"varint,3,opt,name=rep,enum=Rep" json:"rep,omitempty"`
	Columns   []*ColumnMetaData `protobuf:"bytes,4,rep,name=columns" json:"columns,omitempty"`
	Component *AvaticaType      `protobuf:"bytes,5,opt,name=component" json:"component,omitempty"`
}

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

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

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

func (m *AvaticaType) GetRep() Rep {
	if m != nil {
		return m.Rep
	}
	return Rep_PRIMITIVE_BOOLEAN
}

func (m *AvaticaType) GetColumns() []*ColumnMetaData {
	if m != nil {
		return m.Columns
	}
	return nil
}

func (m *AvaticaType) GetComponent() *AvaticaType {
	if m != nil {
		return m.Component
	}
	return nil
}

// Metadata for a parameter
type AvaticaParameter struct {
	Signed        bool   `protobuf:"varint,1,opt,name=signed" json:"signed,omitempty"`
	Precision     uint32 `protobuf:"varint,2,opt,name=precision" json:"precision,omitempty"`
	Scale         uint32 `protobuf:"varint,3,opt,name=scale" json:"scale,omitempty"`
	ParameterType uint32 `protobuf:"varint,4,opt,name=parameter_type,json=parameterType" json:"parameter_type,omitempty"`
	TypeName      string `protobuf:"bytes,5,opt,name=type_name,json=typeName" json:"type_name,omitempty"`
	ClassName     string `protobuf:"bytes,6,opt,name=class_name,json=className" json:"class_name,omitempty"`
	Name          string `protobuf:"bytes,7,opt,name=name" json:"name,omitempty"`
}

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

func (m *AvaticaParameter) GetSigned() bool {
	if m != nil {
		return m.Signed
	}
	return false
}

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

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

func (m *AvaticaParameter) GetParameterType() uint32 {
	if m != nil {
		return m.ParameterType
	}
	return 0
}

func (m *AvaticaParameter) GetTypeName() string {
	if m != nil {
		return m.TypeName
	}
	return ""
}

func (m *AvaticaParameter) GetClassName() string {
	if m != nil {
		return m.ClassName
	}
	return ""
}

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

// Information necessary to convert an Iterable into a Calcite Cursor
type CursorFactory struct {
	Style      CursorFactory_Style `protobuf:"varint,1,opt,name=style,enum=CursorFactory_Style" json:"style,omitempty"`
	ClassName  string              `protobuf:"bytes,2,opt,name=class_name,json=className" json:"class_name,omitempty"`
	FieldNames []string            `protobuf:"bytes,3,rep,name=field_names,json=fieldNames" json:"field_names,omitempty"`
}

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

func (m *CursorFactory) GetStyle() CursorFactory_Style {
	if m != nil {
		return m.Style
	}
	return CursorFactory_OBJECT
}

func (m *CursorFactory) GetClassName() string {
	if m != nil {
		return m.ClassName
	}
	return ""
}

func (m *CursorFactory) GetFieldNames() []string {
	if m != nil {
		return m.FieldNames
	}
	return nil
}

// A collection of rows
type Frame struct {
	Offset uint64 `protobuf:"varint,1,opt,name=offset" json:"offset,omitempty"`
	Done   bool   `protobuf:"varint,2,opt,name=done" json:"done,omitempty"`
	Rows   []*Row `protobuf:"bytes,3,rep,name=rows" json:"rows,omitempty"`
}

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

func (m *Frame) GetOffset() uint64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *Frame) GetDone() bool {
	if m != nil {
		return m.Done
	}
	return false
}

func (m *Frame) GetRows() []*Row {
	if m != nil {
		return m.Rows
	}
	return nil
}

// A row is a collection of values
type Row struct {
	Value []*ColumnValue `protobuf:"bytes,1,rep,name=value" json:"value,omitempty"`
}

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

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

// Database property, list of functions the database provides for a certain operation
type DatabaseProperty struct {
	Name      string   `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Functions []string `protobuf:"bytes,2,rep,name=functions" json:"functions,omitempty"`
}

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

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

func (m *DatabaseProperty) GetFunctions() []string {
	if m != nil {
		return m.Functions
	}
	return nil
}

// Message which encapsulates another message to support a single RPC endpoint
type WireMessage struct {
	Name           string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	WrappedMessage []byte `protobuf:"bytes,2,opt,name=wrapped_message,json=wrappedMessage,proto3" json:"wrapped_message,omitempty"`
}

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

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

func (m *WireMessage) GetWrappedMessage() []byte {
	if m != nil {
		return m.WrappedMessage
	}
	return nil
}

// A value might be a TypedValue or an Array of TypedValue's
type ColumnValue struct {
	Value         []*TypedValue `protobuf:"bytes,1,rep,name=value" json:"value,omitempty"`
	ArrayValue    []*TypedValue `protobuf:"bytes,2,rep,name=array_value,json=arrayValue" json:"array_value,omitempty"`
	HasArrayValue bool          `protobuf:"varint,3,opt,name=has_array_value,json=hasArrayValue" json:"has_array_value,omitempty"`
	ScalarValue   *TypedValue   `protobuf:"bytes,4,opt,name=scalar_value,json=scalarValue" json:"scalar_value,omitempty"`
}

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

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

func (m *ColumnValue) GetArrayValue() []*TypedValue {
	if m != nil {
		return m.ArrayValue
	}
	return nil
}

func (m *ColumnValue) GetHasArrayValue() bool {
	if m != nil {
		return m.HasArrayValue
	}
	return false
}

func (m *ColumnValue) GetScalarValue() *TypedValue {
	if m != nil {
		return m.ScalarValue
	}
	return nil
}

// Generic wrapper to support any SQL type. Struct-like to work around no polymorphism construct.
type TypedValue struct {
	Type        Rep    `protobuf:"varint,1,opt,name=type,enum=Rep" json:"type,omitempty"`
	BoolValue   bool   `protobuf:"varint,2,opt,name=bool_value,json=boolValue" json:"bool_value,omitempty"`
	StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue" json:"string_value,omitempty"`
	NumberValue int64  `protobuf:"zigzag64,4,opt,name=number_value,json=numberValue" json:"number_value,omitempty"`
	// includes numeric types and date/time types.
	BytesValue     []byte        `protobuf:"bytes,5,opt,name=bytes_value,json=bytesValue,proto3" json:"bytes_value,omitempty"`
	DoubleValue    float64       `protobuf:"fixed64,6,opt,name=double_value,json=doubleValue" json:"double_value,omitempty"`
	Null           bool          `protobuf:"varint,7,opt,name=null" json:"null,omitempty"`
	ArrayValue     []*TypedValue `protobuf:"bytes,8,rep,name=array_value,json=arrayValue" json:"array_value,omitempty"`
	ComponentType  Rep           `protobuf:"varint,9,opt,name=component_type,json=componentType,enum=Rep" json:"component_type,omitempty"`
	ImplicitlyNull bool          `protobuf:"varint,10,opt,name=implicitly_null,json=implicitlyNull" json:"implicitly_null,omitempty"`
}

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

func (m *TypedValue) GetType() Rep {
	if m != nil {
		return m.Type
	}
	return Rep_PRIMITIVE_BOOLEAN
}

func (m *TypedValue) GetBoolValue() bool {
	if m != nil {
		return m.BoolValue
	}
	return false
}

func (m *TypedValue) GetStringValue() string {
	if m != nil {
		return m.StringValue
	}
	return ""
}

func (m *TypedValue) GetNumberValue() int64 {
	if m != nil {
		return m.NumberValue
	}
	return 0
}

func (m *TypedValue) GetBytesValue() []byte {
	if m != nil {
		return m.BytesValue
	}
	return nil
}

func (m *TypedValue) GetDoubleValue() float64 {
	if m != nil {
		return m.DoubleValue
	}
	return 0
}

func (m *TypedValue) GetNull() bool {
	if m != nil {
		return m.Null
	}
	return false
}

func (m *TypedValue) GetArrayValue() []*TypedValue {
	if m != nil {
		return m.ArrayValue
	}
	return nil
}

func (m *TypedValue) GetComponentType() Rep {
	if m != nil {
		return m.ComponentType
	}
	return Rep_PRIMITIVE_BOOLEAN
}

func (m *TypedValue) GetImplicitlyNull() bool {
	if m != nil {
		return m.ImplicitlyNull
	}
	return false
}

// Represents the breadth of arguments to DatabaseMetaData functions
type MetaDataOperationArgument struct {
	StringValue       string                                 `protobuf:"bytes,1,opt,name=string_value,json=stringValue" json:"string_value,omitempty"`
	BoolValue         bool                                   `protobuf:"varint,2,opt,name=bool_value,json=boolValue" json:"bool_value,omitempty"`
	IntValue          int32                                  `protobuf:"zigzag32,3,opt,name=int_value,json=intValue" json:"int_value,omitempty"`
	StringArrayValues []string                               `protobuf:"bytes,4,rep,name=string_array_values,json=stringArrayValues" json:"string_array_values,omitempty"`
	IntArrayValues    []int32                                `protobuf:"zigzag32,5,rep,packed,name=int_array_values,json=intArrayValues" json:"int_array_values,omitempty"`
	Type              MetaDataOperationArgument_ArgumentType `protobuf:"varint,6,opt,name=type,enum=MetaDataOperationArgument_ArgumentType" json:"type,omitempty"`
}

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

func (m *MetaDataOperationArgument) GetStringValue() string {
	if m != nil {
		return m.StringValue
	}
	return ""
}

func (m *MetaDataOperationArgument) GetBoolValue() bool {
	if m != nil {
		return m.BoolValue
	}
	return false
}

func (m *MetaDataOperationArgument) GetIntValue() int32 {
	if m != nil {
		return m.IntValue
	}
	return 0
}

func (m *MetaDataOperationArgument) GetStringArrayValues() []string {
	if m != nil {
		return m.StringArrayValues
	}
	return nil
}

func (m *MetaDataOperationArgument) GetIntArrayValues() []int32 {
	if m != nil {
		return m.IntArrayValues
	}
	return nil
}

func (m *MetaDataOperationArgument) GetType() MetaDataOperationArgument_ArgumentType {
	if m != nil {
		return m.Type
	}
	return MetaDataOperationArgument_STRING
}

type QueryState struct {
	Type    StateType                    `protobuf:"varint,1,opt,name=type,enum=StateType" json:"type,omitempty"`
	Sql     string                       `protobuf:"bytes,2,opt,name=sql" json:"sql,omitempty"`
	Op      MetaDataOperation            `protobuf:"varint,3,opt,name=op,enum=MetaDataOperation" json:"op,omitempty"`
	Args    []*MetaDataOperationArgument `protobuf:"bytes,4,rep,name=args" json:"args,omitempty"`
	HasArgs bool                         `protobuf:"varint,5,opt,name=has_args,json=hasArgs" json:"has_args,omitempty"`
	HasSql  bool                         `protobuf:"varint,6,opt,name=has_sql,json=hasSql" json:"has_sql,omitempty"`
	HasOp   bool                         `protobuf:"varint,7,opt,name=has_op,json=hasOp" json:"has_op,omitempty"`
}

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

func (m *QueryState) GetType() StateType {
	if m != nil {
		return m.Type
	}
	return StateType_SQL
}

func (m *QueryState) GetSql() string {
	if m != nil {
		return m.Sql
	}
	return ""
}

func (m *QueryState) GetOp() MetaDataOperation {
	if m != nil {
		return m.Op
	}
	return MetaDataOperation_GET_ATTRIBUTES
}

func (m *QueryState) GetArgs() []*MetaDataOperationArgument {
	if m != nil {
		return m.Args
	}
	return nil
}

func (m *QueryState) GetHasArgs() bool {
	if m != nil {
		return m.HasArgs
	}
	return false
}

func (m *QueryState) GetHasSql() bool {
	if m != nil {
		return m.HasSql
	}
	return false
}

func (m *QueryState) GetHasOp() bool {
	if m != nil {
		return m.HasOp
	}
	return false
}

func init() {
	proto.RegisterType((*ConnectionProperties)(nil), "ConnectionProperties")
	proto.RegisterType((*StatementHandle)(nil), "StatementHandle")
	proto.RegisterType((*Signature)(nil), "Signature")
	proto.RegisterType((*ColumnMetaData)(nil), "ColumnMetaData")
	proto.RegisterType((*AvaticaType)(nil), "AvaticaType")
	proto.RegisterType((*AvaticaParameter)(nil), "AvaticaParameter")
	proto.RegisterType((*CursorFactory)(nil), "CursorFactory")
	proto.RegisterType((*Frame)(nil), "Frame")
	proto.RegisterType((*Row)(nil), "Row")
	proto.RegisterType((*DatabaseProperty)(nil), "DatabaseProperty")
	proto.RegisterType((*WireMessage)(nil), "WireMessage")
	proto.RegisterType((*ColumnValue)(nil), "ColumnValue")
	proto.RegisterType((*TypedValue)(nil), "TypedValue")
	proto.RegisterType((*MetaDataOperationArgument)(nil), "MetaDataOperationArgument")
	proto.RegisterType((*QueryState)(nil), "QueryState")
	proto.RegisterEnum("StatementType", StatementType_name, StatementType_value)
	proto.RegisterEnum("Rep", Rep_name, Rep_value)
	proto.RegisterEnum("Severity", Severity_name, Severity_value)
	proto.RegisterEnum("MetaDataOperation", MetaDataOperation_name, MetaDataOperation_value)
	proto.RegisterEnum("StateType", StateType_name, StateType_value)
	proto.RegisterEnum("CursorFactory_Style", CursorFactory_Style_name, CursorFactory_Style_value)
	proto.RegisterEnum("MetaDataOperationArgument_ArgumentType", MetaDataOperationArgument_ArgumentType_name, MetaDataOperationArgument_ArgumentType_value)
}

func init() { proto.RegisterFile("common.proto", fileDescriptor0) }

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