github.com/0xPolygon/supernets2-node@v0.0.0-20230711153321-2fe574524eaa/merkletree/pb/statedb.pb.go

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

package pb

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	_ "google.golang.org/protobuf/types/known/emptypb"
	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 ResultCode_Code int32

const (
	ResultCode_CODE_UNSPECIFIED           ResultCode_Code = 0
	ResultCode_CODE_SUCCESS               ResultCode_Code = 1
	ResultCode_CODE_DB_KEY_NOT_FOUND      ResultCode_Code = 2
	ResultCode_CODE_DB_ERROR              ResultCode_Code = 3
	ResultCode_CODE_INTERNAL_ERROR        ResultCode_Code = 4
	ResultCode_CODE_SMT_INVALID_DATA_SIZE ResultCode_Code = 14
)

var ResultCode_Code_name = map[int32]string{
	0:  "CODE_UNSPECIFIED",
	1:  "CODE_SUCCESS",
	2:  "CODE_DB_KEY_NOT_FOUND",
	3:  "CODE_DB_ERROR",
	4:  "CODE_INTERNAL_ERROR",
	14: "CODE_SMT_INVALID_DATA_SIZE",
}

var ResultCode_Code_value = map[string]int32{
	"CODE_UNSPECIFIED":           0,
	"CODE_SUCCESS":               1,
	"CODE_DB_KEY_NOT_FOUND":      2,
	"CODE_DB_ERROR":              3,
	"CODE_INTERNAL_ERROR":        4,
	"CODE_SMT_INVALID_DATA_SIZE": 14,
}

func (x ResultCode_Code) String() string {
	return proto.EnumName(ResultCode_Code_name, int32(x))
}

func (ResultCode_Code) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ca8273a45d2a357a, []int{15, 0}
}

type Version struct {
	V0_0_1               string   `protobuf:"bytes,1,opt,name=v0_0_1,json=v001,proto3" json:"v0_0_1,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Version proto.InternalMessageInfo

func (m *Version) GetV0_0_1() string {
	if m != nil {
		return m.V0_0_1
	}
	return ""
}

//*
// @dev SetRequest
// @param {old_root} - merkle-tree root
// @param {key} - key to set
// @param {value} - scalar value to set (HEX string format)
// @param {persistent} - indicates if it should be stored in the SQL database (true) or only in the memory cache (false)
// @param {details} - indicates if it should return all response parameters (true) or just the new root (false)
// @param {get_db_read_log} - indicates if it should return the DB reads generated during the execution of the request
type SetRequest struct {
	OldRoot              *Fea     `protobuf:"bytes,1,opt,name=old_root,json=oldRoot,proto3" json:"old_root,omitempty"`
	Key                  *Fea     `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	Value                string   `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	Persistent           bool     `protobuf:"varint,4,opt,name=persistent,proto3" json:"persistent,omitempty"`
	Details              bool     `protobuf:"varint,5,opt,name=details,proto3" json:"details,omitempty"`
	GetDbReadLog         bool     `protobuf:"varint,6,opt,name=get_db_read_log,json=getDbReadLog,proto3" json:"get_db_read_log,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SetRequest proto.InternalMessageInfo

func (m *SetRequest) GetOldRoot() *Fea {
	if m != nil {
		return m.OldRoot
	}
	return nil
}

func (m *SetRequest) GetKey() *Fea {
	if m != nil {
		return m.Key
	}
	return nil
}

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

func (m *SetRequest) GetPersistent() bool {
	if m != nil {
		return m.Persistent
	}
	return false
}

func (m *SetRequest) GetDetails() bool {
	if m != nil {
		return m.Details
	}
	return false
}

func (m *SetRequest) GetGetDbReadLog() bool {
	if m != nil {
		return m.GetDbReadLog
	}
	return false
}

//*
// @dev GetRequest
// @param {root} - merkle-tree root
// @param {key} - key to look for
// @param {details} - indicates if it should return all response parameters (true) or just the new root (false)
// @param {get_db_read_log} - indicates if it should return the DB reads generated during the execution of the request
type GetRequest struct {
	Root                 *Fea     `protobuf:"bytes,1,opt,name=root,proto3" json:"root,omitempty"`
	Key                  *Fea     `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	Details              bool     `protobuf:"varint,3,opt,name=details,proto3" json:"details,omitempty"`
	GetDbReadLog         bool     `protobuf:"varint,4,opt,name=get_db_read_log,json=getDbReadLog,proto3" json:"get_db_read_log,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_GetRequest proto.InternalMessageInfo

func (m *GetRequest) GetRoot() *Fea {
	if m != nil {
		return m.Root
	}
	return nil
}

func (m *GetRequest) GetKey() *Fea {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *GetRequest) GetDetails() bool {
	if m != nil {
		return m.Details
	}
	return false
}

func (m *GetRequest) GetGetDbReadLog() bool {
	if m != nil {
		return m.GetDbReadLog
	}
	return false
}

//*
// @dev SetProgramRequest
// @param {key} - key to set
// @param {data} - Program data to store
// @param {persistent} - indicates if it should be stored in the SQL database (true) or only in the memory cache (false)
type SetProgramRequest struct {
	Key                  *Fea     `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Data                 []byte   `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	Persistent           bool     `protobuf:"varint,3,opt,name=persistent,proto3" json:"persistent,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SetProgramRequest proto.InternalMessageInfo

func (m *SetProgramRequest) GetKey() *Fea {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *SetProgramRequest) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *SetProgramRequest) GetPersistent() bool {
	if m != nil {
		return m.Persistent
	}
	return false
}

//*
// @dev GetProgramRequest
// @param {key} - key to get program data
type GetProgramRequest struct {
	Key                  *Fea     `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_GetProgramRequest proto.InternalMessageInfo

func (m *GetProgramRequest) GetKey() *Fea {
	if m != nil {
		return m.Key
	}
	return nil
}

//*
// @dev LoadDBRequest
// @param {input_db} - list of db records (MT) to load in the database
// @param {persistent} - indicates if it should be stored in the SQL database (true) or only in the memory cache (false)
type LoadDBRequest struct {
	InputDb              map[string]*FeList `protobuf:"bytes,1,rep,name=input_db,json=inputDb,proto3" json:"input_db,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Persistent           bool               `protobuf:"varint,2,opt,name=persistent,proto3" json:"persistent,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

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

var xxx_messageInfo_LoadDBRequest proto.InternalMessageInfo

func (m *LoadDBRequest) GetInputDb() map[string]*FeList {
	if m != nil {
		return m.InputDb
	}
	return nil
}

func (m *LoadDBRequest) GetPersistent() bool {
	if m != nil {
		return m.Persistent
	}
	return false
}

//*
// @dev LoadProgramDBRequest
// @param {input_program_db} - list of db records (program) to load in the database
// @param {persistent} - indicates if it should be stored in the SQL database (true) or only in the memory cache (false)
type LoadProgramDBRequest struct {
	InputProgramDb       map[string][]byte `protobuf:"bytes,1,rep,name=input_program_db,json=inputProgramDb,proto3" json:"input_program_db,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Persistent           bool              `protobuf:"varint,2,opt,name=persistent,proto3" json:"persistent,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_LoadProgramDBRequest proto.InternalMessageInfo

func (m *LoadProgramDBRequest) GetInputProgramDb() map[string][]byte {
	if m != nil {
		return m.InputProgramDb
	}
	return nil
}

func (m *LoadProgramDBRequest) GetPersistent() bool {
	if m != nil {
		return m.Persistent
	}
	return false
}

//*
// @dev SetResponse
// @param {old_root} - merkle-tree root
// @param {new_root} - merkle-tree new root
// @param {key} - key to look for
// @param {siblings} - array of siblings
// @param {ins_key} - key found
// @param {ins_value} - value found (HEX string format)
// @param {is_old0} - is new insert or delete
// @param {old_value} - old value (HEX string format)
// @param {new_value} - new value (HEX string format)
// @param {mode}
// @param {proof_hash_counter}
// @param {db_read_log} - list of db records read during the execution of the request
// @param {result} - result code
type SetResponse struct {
	OldRoot              *Fea                    `protobuf:"bytes,1,opt,name=old_root,json=oldRoot,proto3" json:"old_root,omitempty"`
	NewRoot              *Fea                    `protobuf:"bytes,2,opt,name=new_root,json=newRoot,proto3" json:"new_root,omitempty"`
	Key                  *Fea                    `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
	Siblings             map[uint64]*SiblingList `protobuf:"bytes,4,rep,name=siblings,proto3" json:"siblings,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	InsKey               *Fea                    `protobuf:"bytes,5,opt,name=ins_key,json=insKey,proto3" json:"ins_key,omitempty"`
	InsValue             string                  `protobuf:"bytes,6,opt,name=ins_value,json=insValue,proto3" json:"ins_value,omitempty"`
	IsOld0               bool                    `protobuf:"varint,7,opt,name=is_old0,json=isOld0,proto3" json:"is_old0,omitempty"`
	OldValue             string                  `protobuf:"bytes,8,opt,name=old_value,json=oldValue,proto3" json:"old_value,omitempty"`
	NewValue             string                  `protobuf:"bytes,9,opt,name=new_value,json=newValue,proto3" json:"new_value,omitempty"`
	Mode                 string                  `protobuf:"bytes,10,opt,name=mode,proto3" json:"mode,omitempty"`
	ProofHashCounter     uint64                  `protobuf:"varint,11,opt,name=proof_hash_counter,json=proofHashCounter,proto3" json:"proof_hash_counter,omitempty"`
	DbReadLog            map[string]*FeList      `protobuf:"bytes,12,rep,name=db_read_log,json=dbReadLog,proto3" json:"db_read_log,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Result               *ResultCode             `protobuf:"bytes,13,opt,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

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

var xxx_messageInfo_SetResponse proto.InternalMessageInfo

func (m *SetResponse) GetOldRoot() *Fea {
	if m != nil {
		return m.OldRoot
	}
	return nil
}

func (m *SetResponse) GetNewRoot() *Fea {
	if m != nil {
		return m.NewRoot
	}
	return nil
}

func (m *SetResponse) GetKey() *Fea {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *SetResponse) GetSiblings() map[uint64]*SiblingList {
	if m != nil {
		return m.Siblings
	}
	return nil
}

func (m *SetResponse) GetInsKey() *Fea {
	if m != nil {
		return m.InsKey
	}
	return nil
}

func (m *SetResponse) GetInsValue() string {
	if m != nil {
		return m.InsValue
	}
	return ""
}

func (m *SetResponse) GetIsOld0() bool {
	if m != nil {
		return m.IsOld0
	}
	return false
}

func (m *SetResponse) GetOldValue() string {
	if m != nil {
		return m.OldValue
	}
	return ""
}

func (m *SetResponse) GetNewValue() string {
	if m != nil {
		return m.NewValue
	}
	return ""
}

func (m *SetResponse) GetMode() string {
	if m != nil {
		return m.Mode
	}
	return ""
}

func (m *SetResponse) GetProofHashCounter() uint64 {
	if m != nil {
		return m.ProofHashCounter
	}
	return 0
}

func (m *SetResponse) GetDbReadLog() map[string]*FeList {
	if m != nil {
		return m.DbReadLog
	}
	return nil
}

func (m *SetResponse) GetResult() *ResultCode {
	if m != nil {
		return m.Result
	}
	return nil
}

//*
// @dev GetResponse
// @param {root} - merkle-tree root
// @param {key} - key to look for
// @param {siblings} - array of siblings
// @param {ins_key} - key found
// @param {ins_value} - value found (HEX string format)
// @param {is_old0} - is new insert or delete
// @param {value} - value retrieved (HEX string format)
// @param {proof_hash_counter}
// @param {db_read_log} - list of db records read during the execution of the request
// @param {result} - result code
type GetResponse struct {
	Root                 *Fea                    `protobuf:"bytes,1,opt,name=root,proto3" json:"root,omitempty"`
	Key                  *Fea                    `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	Siblings             map[uint64]*SiblingList `protobuf:"bytes,3,rep,name=siblings,proto3" json:"siblings,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	InsKey               *Fea                    `protobuf:"bytes,4,opt,name=ins_key,json=insKey,proto3" json:"ins_key,omitempty"`
	InsValue             string                  `protobuf:"bytes,5,opt,name=ins_value,json=insValue,proto3" json:"ins_value,omitempty"`
	IsOld0               bool                    `protobuf:"varint,6,opt,name=is_old0,json=isOld0,proto3" json:"is_old0,omitempty"`
	Value                string                  `protobuf:"bytes,7,opt,name=value,proto3" json:"value,omitempty"`
	ProofHashCounter     uint64                  `protobuf:"varint,8,opt,name=proof_hash_counter,json=proofHashCounter,proto3" json:"proof_hash_counter,omitempty"`
	DbReadLog            map[string]*FeList      `protobuf:"bytes,9,rep,name=db_read_log,json=dbReadLog,proto3" json:"db_read_log,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Result               *ResultCode             `protobuf:"bytes,10,opt,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

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

var xxx_messageInfo_GetResponse proto.InternalMessageInfo

func (m *GetResponse) GetRoot() *Fea {
	if m != nil {
		return m.Root
	}
	return nil
}

func (m *GetResponse) GetKey() *Fea {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *GetResponse) GetSiblings() map[uint64]*SiblingList {
	if m != nil {
		return m.Siblings
	}
	return nil
}

func (m *GetResponse) GetInsKey() *Fea {
	if m != nil {
		return m.InsKey
	}
	return nil
}

func (m *GetResponse) GetInsValue() string {
	if m != nil {
		return m.InsValue
	}
	return ""
}

func (m *GetResponse) GetIsOld0() bool {
	if m != nil {
		return m.IsOld0
	}
	return false
}

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

func (m *GetResponse) GetProofHashCounter() uint64 {
	if m != nil {
		return m.ProofHashCounter
	}
	return 0
}

func (m *GetResponse) GetDbReadLog() map[string]*FeList {
	if m != nil {
		return m.DbReadLog
	}
	return nil
}

func (m *GetResponse) GetResult() *ResultCode {
	if m != nil {
		return m.Result
	}
	return nil
}

//*
// @dev SetProgramResponse
// @param {result} - result code
type SetProgramResponse struct {
	Result               *ResultCode `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_SetProgramResponse proto.InternalMessageInfo

func (m *SetProgramResponse) GetResult() *ResultCode {
	if m != nil {
		return m.Result
	}
	return nil
}

//*
// @dev GetProgramResponse
// @param {data} - program data retrieved
// @param {result} - result code
type GetProgramResponse struct {
	Data                 []byte      `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	Result               *ResultCode `protobuf:"bytes,2,opt,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_GetProgramResponse proto.InternalMessageInfo

func (m *GetProgramResponse) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *GetProgramResponse) GetResult() *ResultCode {
	if m != nil {
		return m.Result
	}
	return nil
}

//*
// @dev FlushResponse
// @param {result} - result code
type FlushResponse struct {
	Result               *ResultCode `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_FlushResponse proto.InternalMessageInfo

func (m *FlushResponse) GetResult() *ResultCode {
	if m != nil {
		return m.Result
	}
	return nil
}

//*
// @dev Array of 4 FE
// @param {fe0} - Field Element value for pos 0
// @param {fe1} - Field Element value for pos 1
// @param {fe2} - Field Element value for pos 2
// @param {fe3} - Field Element value for pos 3
type Fea struct {
	Fe0                  uint64   `protobuf:"varint,1,opt,name=fe0,proto3" json:"fe0,omitempty"`
	Fe1                  uint64   `protobuf:"varint,2,opt,name=fe1,proto3" json:"fe1,omitempty"`
	Fe2                  uint64   `protobuf:"varint,3,opt,name=fe2,proto3" json:"fe2,omitempty"`
	Fe3                  uint64   `protobuf:"varint,4,opt,name=fe3,proto3" json:"fe3,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Fea proto.InternalMessageInfo

func (m *Fea) GetFe0() uint64 {
	if m != nil {
		return m.Fe0
	}
	return 0
}

func (m *Fea) GetFe1() uint64 {
	if m != nil {
		return m.Fe1
	}
	return 0
}

func (m *Fea) GetFe2() uint64 {
	if m != nil {
		return m.Fe2
	}
	return 0
}

func (m *Fea) GetFe3() uint64 {
	if m != nil {
		return m.Fe3
	}
	return 0
}

//*
// @dev FE (Field Element) List
// @param {fe} - list of Fe
type FeList struct {
	Fe                   []uint64 `protobuf:"varint,1,rep,packed,name=fe,proto3" json:"fe,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_FeList proto.InternalMessageInfo

func (m *FeList) GetFe() []uint64 {
	if m != nil {
		return m.Fe
	}
	return nil
}

//*
// @dev Siblings List
// @param {sibling} - list of siblings
type SiblingList struct {
	Sibling              []uint64 `protobuf:"varint,1,rep,packed,name=sibling,proto3" json:"sibling,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SiblingList proto.InternalMessageInfo

func (m *SiblingList) GetSibling() []uint64 {
	if m != nil {
		return m.Sibling
	}
	return nil
}

//*
// @dev Result code
// @param {code} - result code
type ResultCode struct {
	Code                 ResultCode_Code `protobuf:"varint,1,opt,name=code,proto3,enum=statedb.v1.ResultCode_Code" json:"code,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_ResultCode proto.InternalMessageInfo

func (m *ResultCode) GetCode() ResultCode_Code {
	if m != nil {
		return m.Code
	}
	return ResultCode_CODE_UNSPECIFIED
}

func init() {
	proto.RegisterEnum("statedb.v1.ResultCode_Code", ResultCode_Code_name, ResultCode_Code_value)
	proto.RegisterType((*Version)(nil), "statedb.v1.Version")
	proto.RegisterType((*SetRequest)(nil), "statedb.v1.SetRequest")
	proto.RegisterType((*GetRequest)(nil), "statedb.v1.GetRequest")
	proto.RegisterType((*SetProgramRequest)(nil), "statedb.v1.SetProgramRequest")
	proto.RegisterType((*GetProgramRequest)(nil), "statedb.v1.GetProgramRequest")
	proto.RegisterType((*LoadDBRequest)(nil), "statedb.v1.LoadDBRequest")
	proto.RegisterMapType((map[string]*FeList)(nil), "statedb.v1.LoadDBRequest.InputDbEntry")
	proto.RegisterType((*LoadProgramDBRequest)(nil), "statedb.v1.LoadProgramDBRequest")
	proto.RegisterMapType((map[string][]byte)(nil), "statedb.v1.LoadProgramDBRequest.InputProgramDbEntry")
	proto.RegisterType((*SetResponse)(nil), "statedb.v1.SetResponse")
	proto.RegisterMapType((map[string]*FeList)(nil), "statedb.v1.SetResponse.DbReadLogEntry")
	proto.RegisterMapType((map[uint64]*SiblingList)(nil), "statedb.v1.SetResponse.SiblingsEntry")
	proto.RegisterType((*GetResponse)(nil), "statedb.v1.GetResponse")
	proto.RegisterMapType((map[string]*FeList)(nil), "statedb.v1.GetResponse.DbReadLogEntry")
	proto.RegisterMapType((map[uint64]*SiblingList)(nil), "statedb.v1.GetResponse.SiblingsEntry")
	proto.RegisterType((*SetProgramResponse)(nil), "statedb.v1.SetProgramResponse")
	proto.RegisterType((*GetProgramResponse)(nil), "statedb.v1.GetProgramResponse")
	proto.RegisterType((*FlushResponse)(nil), "statedb.v1.FlushResponse")
	proto.RegisterType((*Fea)(nil), "statedb.v1.Fea")
	proto.RegisterType((*FeList)(nil), "statedb.v1.FeList")
	proto.RegisterType((*SiblingList)(nil), "statedb.v1.SiblingList")
	proto.RegisterType((*ResultCode)(nil), "statedb.v1.ResultCode")
}

func init() {
	proto.RegisterFile("statedb.proto", fileDescriptor_ca8273a45d2a357a)
}

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