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

package pb

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

type ProcedureState int32

const (
	ProcedureState_INITIALIZING    ProcedureState = 1
	ProcedureState_RUNNABLE        ProcedureState = 2
	ProcedureState_WAITING         ProcedureState = 3
	ProcedureState_WAITING_TIMEOUT ProcedureState = 4
	ProcedureState_ROLLEDBACK      ProcedureState = 5
	ProcedureState_FINISHED        ProcedureState = 6
)

var ProcedureState_name = map[int32]string{
	1: "INITIALIZING",
	2: "RUNNABLE",
	3: "WAITING",
	4: "WAITING_TIMEOUT",
	5: "ROLLEDBACK",
	6: "FINISHED",
}
var ProcedureState_value = map[string]int32{
	"INITIALIZING":    1,
	"RUNNABLE":        2,
	"WAITING":         3,
	"WAITING_TIMEOUT": 4,
	"ROLLEDBACK":      5,
	"FINISHED":        6,
}

func (x ProcedureState) Enum() *ProcedureState {
	p := new(ProcedureState)
	*p = x
	return p
}
func (x ProcedureState) String() string {
	return proto.EnumName(ProcedureState_name, int32(x))
}
func (x *ProcedureState) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ProcedureState_value, data, "ProcedureState")
	if err != nil {
		return err
	}
	*x = ProcedureState(value)
	return nil
}
func (ProcedureState) EnumDescriptor() ([]byte, []int) { return fileDescriptor13, []int{0} }

type ProcedureWALEntry_Type int32

const (
	ProcedureWALEntry_PROCEDURE_WAL_EOF     ProcedureWALEntry_Type = 1
	ProcedureWALEntry_PROCEDURE_WAL_INIT    ProcedureWALEntry_Type = 2
	ProcedureWALEntry_PROCEDURE_WAL_INSERT  ProcedureWALEntry_Type = 3
	ProcedureWALEntry_PROCEDURE_WAL_UPDATE  ProcedureWALEntry_Type = 4
	ProcedureWALEntry_PROCEDURE_WAL_DELETE  ProcedureWALEntry_Type = 5
	ProcedureWALEntry_PROCEDURE_WAL_COMPACT ProcedureWALEntry_Type = 6
)

var ProcedureWALEntry_Type_name = map[int32]string{
	1: "PROCEDURE_WAL_EOF",
	2: "PROCEDURE_WAL_INIT",
	3: "PROCEDURE_WAL_INSERT",
	4: "PROCEDURE_WAL_UPDATE",
	5: "PROCEDURE_WAL_DELETE",
	6: "PROCEDURE_WAL_COMPACT",
}
var ProcedureWALEntry_Type_value = map[string]int32{
	"PROCEDURE_WAL_EOF":     1,
	"PROCEDURE_WAL_INIT":    2,
	"PROCEDURE_WAL_INSERT":  3,
	"PROCEDURE_WAL_UPDATE":  4,
	"PROCEDURE_WAL_DELETE":  5,
	"PROCEDURE_WAL_COMPACT": 6,
}

func (x ProcedureWALEntry_Type) Enum() *ProcedureWALEntry_Type {
	p := new(ProcedureWALEntry_Type)
	*p = x
	return p
}
func (x ProcedureWALEntry_Type) String() string {
	return proto.EnumName(ProcedureWALEntry_Type_name, int32(x))
}
func (x *ProcedureWALEntry_Type) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ProcedureWALEntry_Type_value, data, "ProcedureWALEntry_Type")
	if err != nil {
		return err
	}
	*x = ProcedureWALEntry_Type(value)
	return nil
}
func (ProcedureWALEntry_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor13, []int{6, 0} }

// *
// Procedure metadata, serialized by the ProcedureStore to be able to recover the old state.
type Procedure struct {
	// internal "static" state
	ClassName *string `protobuf:"bytes,1,req,name=class_name,json=className" json:"class_name,omitempty"`
	ParentId  *uint64 `protobuf:"varint,2,opt,name=parent_id,json=parentId" json:"parent_id,omitempty"`
	ProcId    *uint64 `protobuf:"varint,3,req,name=proc_id,json=procId" json:"proc_id,omitempty"`
	StartTime *uint64 `protobuf:"varint,4,req,name=start_time,json=startTime" json:"start_time,omitempty"`
	Owner     *string `protobuf:"bytes,5,opt,name=owner" json:"owner,omitempty"`
	// internal "runtime" state
	State      *ProcedureState `protobuf:"varint,6,req,name=state,enum=pb.ProcedureState" json:"state,omitempty"`
	StackId    []uint32        `protobuf:"varint,7,rep,name=stack_id,json=stackId" json:"stack_id,omitempty"`
	LastUpdate *uint64         `protobuf:"varint,8,req,name=last_update,json=lastUpdate" json:"last_update,omitempty"`
	Timeout    *uint32         `protobuf:"varint,9,opt,name=timeout" json:"timeout,omitempty"`
	// user state/results
	Exception *ForeignExceptionMessage `protobuf:"bytes,10,opt,name=exception" json:"exception,omitempty"`
	Result    []byte                   `protobuf:"bytes,11,opt,name=result" json:"result,omitempty"`
	StateData []byte                   `protobuf:"bytes,12,opt,name=state_data,json=stateData" json:"state_data,omitempty"`
	// Nonce to prevent same procedure submit by multiple times
	NonceGroup       *uint64 `protobuf:"varint,13,opt,name=nonce_group,json=nonceGroup,def=0" json:"nonce_group,omitempty"`
	Nonce            *uint64 `protobuf:"varint,14,opt,name=nonce,def=0" json:"nonce,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

const Default_Procedure_NonceGroup uint64 = 0
const Default_Procedure_Nonce uint64 = 0

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

func (m *Procedure) GetParentId() uint64 {
	if m != nil && m.ParentId != nil {
		return *m.ParentId
	}
	return 0
}

func (m *Procedure) GetProcId() uint64 {
	if m != nil && m.ProcId != nil {
		return *m.ProcId
	}
	return 0
}

func (m *Procedure) GetStartTime() uint64 {
	if m != nil && m.StartTime != nil {
		return *m.StartTime
	}
	return 0
}

func (m *Procedure) GetOwner() string {
	if m != nil && m.Owner != nil {
		return *m.Owner
	}
	return ""
}

func (m *Procedure) GetState() ProcedureState {
	if m != nil && m.State != nil {
		return *m.State
	}
	return ProcedureState_INITIALIZING
}

func (m *Procedure) GetStackId() []uint32 {
	if m != nil {
		return m.StackId
	}
	return nil
}

func (m *Procedure) GetLastUpdate() uint64 {
	if m != nil && m.LastUpdate != nil {
		return *m.LastUpdate
	}
	return 0
}

func (m *Procedure) GetTimeout() uint32 {
	if m != nil && m.Timeout != nil {
		return *m.Timeout
	}
	return 0
}

func (m *Procedure) GetException() *ForeignExceptionMessage {
	if m != nil {
		return m.Exception
	}
	return nil
}

func (m *Procedure) GetResult() []byte {
	if m != nil {
		return m.Result
	}
	return nil
}

func (m *Procedure) GetStateData() []byte {
	if m != nil {
		return m.StateData
	}
	return nil
}

func (m *Procedure) GetNonceGroup() uint64 {
	if m != nil && m.NonceGroup != nil {
		return *m.NonceGroup
	}
	return Default_Procedure_NonceGroup
}

func (m *Procedure) GetNonce() uint64 {
	if m != nil && m.Nonce != nil {
		return *m.Nonce
	}
	return Default_Procedure_Nonce
}

// *
// SequentialProcedure data
type SequentialProcedureData struct {
	Executed         *bool  `protobuf:"varint,1,req,name=executed" json:"executed,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *SequentialProcedureData) GetExecuted() bool {
	if m != nil && m.Executed != nil {
		return *m.Executed
	}
	return false
}

// *
// StateMachineProcedure data
type StateMachineProcedureData struct {
	State            []uint32 `protobuf:"varint,1,rep,name=state" json:"state,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

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

func (m *StateMachineProcedureData) GetState() []uint32 {
	if m != nil {
		return m.State
	}
	return nil
}

// *
// Procedure WAL header
type ProcedureWALHeader struct {
	Version          *uint32 `protobuf:"varint,1,req,name=version" json:"version,omitempty"`
	Type             *uint32 `protobuf:"varint,2,req,name=type" json:"type,omitempty"`
	LogId            *uint64 `protobuf:"varint,3,req,name=log_id,json=logId" json:"log_id,omitempty"`
	MinProcId        *uint64 `protobuf:"varint,4,req,name=min_proc_id,json=minProcId" json:"min_proc_id,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *ProcedureWALHeader) GetVersion() uint32 {
	if m != nil && m.Version != nil {
		return *m.Version
	}
	return 0
}

func (m *ProcedureWALHeader) GetType() uint32 {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return 0
}

func (m *ProcedureWALHeader) GetLogId() uint64 {
	if m != nil && m.LogId != nil {
		return *m.LogId
	}
	return 0
}

func (m *ProcedureWALHeader) GetMinProcId() uint64 {
	if m != nil && m.MinProcId != nil {
		return *m.MinProcId
	}
	return 0
}

// *
// Procedure WAL trailer
type ProcedureWALTrailer struct {
	Version          *uint32 `protobuf:"varint,1,req,name=version" json:"version,omitempty"`
	TrackerPos       *uint64 `protobuf:"varint,2,req,name=tracker_pos,json=trackerPos" json:"tracker_pos,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *ProcedureWALTrailer) GetVersion() uint32 {
	if m != nil && m.Version != nil {
		return *m.Version
	}
	return 0
}

func (m *ProcedureWALTrailer) GetTrackerPos() uint64 {
	if m != nil && m.TrackerPos != nil {
		return *m.TrackerPos
	}
	return 0
}

type ProcedureStoreTracker struct {
	Node             []*ProcedureStoreTracker_TrackerNode `protobuf:"bytes,1,rep,name=node" json:"node,omitempty"`
	XXX_unrecognized []byte                               `json:"-"`
}

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

func (m *ProcedureStoreTracker) GetNode() []*ProcedureStoreTracker_TrackerNode {
	if m != nil {
		return m.Node
	}
	return nil
}

type ProcedureStoreTracker_TrackerNode struct {
	StartId          *uint64  `protobuf:"varint,1,req,name=start_id,json=startId" json:"start_id,omitempty"`
	Updated          []uint64 `protobuf:"varint,2,rep,name=updated" json:"updated,omitempty"`
	Deleted          []uint64 `protobuf:"varint,3,rep,name=deleted" json:"deleted,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

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

func (m *ProcedureStoreTracker_TrackerNode) GetStartId() uint64 {
	if m != nil && m.StartId != nil {
		return *m.StartId
	}
	return 0
}

func (m *ProcedureStoreTracker_TrackerNode) GetUpdated() []uint64 {
	if m != nil {
		return m.Updated
	}
	return nil
}

func (m *ProcedureStoreTracker_TrackerNode) GetDeleted() []uint64 {
	if m != nil {
		return m.Deleted
	}
	return nil
}

type ProcedureWALEntry struct {
	Type             *ProcedureWALEntry_Type `protobuf:"varint,1,req,name=type,enum=pb.ProcedureWALEntry_Type" json:"type,omitempty"`
	Procedure        []*Procedure            `protobuf:"bytes,2,rep,name=procedure" json:"procedure,omitempty"`
	ProcId           *uint64                 `protobuf:"varint,3,opt,name=proc_id,json=procId" json:"proc_id,omitempty"`
	XXX_unrecognized []byte                  `json:"-"`
}

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

func (m *ProcedureWALEntry) GetType() ProcedureWALEntry_Type {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return ProcedureWALEntry_PROCEDURE_WAL_EOF
}

func (m *ProcedureWALEntry) GetProcedure() []*Procedure {
	if m != nil {
		return m.Procedure
	}
	return nil
}

func (m *ProcedureWALEntry) GetProcId() uint64 {
	if m != nil && m.ProcId != nil {
		return *m.ProcId
	}
	return 0
}

func init() {
	proto.RegisterType((*Procedure)(nil), "pb.Procedure")
	proto.RegisterType((*SequentialProcedureData)(nil), "pb.SequentialProcedureData")
	proto.RegisterType((*StateMachineProcedureData)(nil), "pb.StateMachineProcedureData")
	proto.RegisterType((*ProcedureWALHeader)(nil), "pb.ProcedureWALHeader")
	proto.RegisterType((*ProcedureWALTrailer)(nil), "pb.ProcedureWALTrailer")
	proto.RegisterType((*ProcedureStoreTracker)(nil), "pb.ProcedureStoreTracker")
	proto.RegisterType((*ProcedureStoreTracker_TrackerNode)(nil), "pb.ProcedureStoreTracker.TrackerNode")
	proto.RegisterType((*ProcedureWALEntry)(nil), "pb.ProcedureWALEntry")
	proto.RegisterEnum("pb.ProcedureState", ProcedureState_name, ProcedureState_value)
	proto.RegisterEnum("pb.ProcedureWALEntry_Type", ProcedureWALEntry_Type_name, ProcedureWALEntry_Type_value)
}

func init() { proto.RegisterFile("Procedure.proto", fileDescriptor13) }

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