admin/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2026-01-07 19:31:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

Make compaction target able to exceed segment max size by a bit (#21068) (#23692)

Browse Source 
issue: #21053

Signed-off-by: yangxuan <xuan.yang@zilliz.com>
Co-authored-by: Ten Thousand Leaves <69466447+soothing-rain@users.noreply.github.com>
Co-authored-by: Yuchen Gao <yuchen.gao@zilliz.com>
This commit is contained in:
XuanYang-cn 2023-04-26 12:02:35 +08:00 committed by GitHub
parent 75b5751117
commit b7cda1b2b4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 735 additions and 469 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
configs/milvus.yaml
View File

@ -305,6 +305,7 @@ dataCoord:
compactableProportion: 0.85 # A compaction will happen on small segments if the segment after compaction will have
# over (compactableProportion * segment max # of rows) rows.
# MUST BE GREATER THAN OR EQUAL TO <smallProportion>!!!
expansionRate: 1.25 # During compaction, the size of segment # of rows is able to exceed segment max # of rows by (expansionRate-1) * 100%.
compaction:
enableAutoCompaction: true

96
internal/datacoord/compaction_trigger.go
View File

@ -23,8 +23,6 @@ import (
"sync"
"time"
"github.com/milvus-io/milvus/internal/util/tsoutil"
"github.com/milvus-io/milvus-proto/go-api/commonpb"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/datapb"
@ -33,6 +31,8 @@ import (
"github.com/milvus-io/milvus/internal/util/funcutil"
"github.com/milvus-io/milvus/internal/util/indexparamcheck"
"github.com/milvus-io/milvus/internal/util/logutil"
"github.com/milvus-io/milvus/internal/util/tsoutil"
"github.com/samber/lo"
"go.uber.org/zap"
)
@ -475,6 +475,7 @@ func (t *compactionTrigger) generatePlans(segments []*SegmentInfo, force bool, i
// TODO add low priority candidates, for example if the segment is smaller than full 0.9 * max segment size but larger than small segment boundary, we only execute compaction when there are no compaction running actively
var prioritizedCandidates []*SegmentInfo
var smallCandidates []*SegmentInfo
var nonPlannedSegments []*SegmentInfo
// TODO, currently we lack of the measurement of data distribution, there should be another compaction help on redistributing segment based on scalar/vector field distribution
for _, segment := range segments {
@ -484,9 +485,10 @@ func (t *compactionTrigger) generatePlans(segments []*SegmentInfo, force bool, i
prioritizedCandidates = append(prioritizedCandidates, segment)
} else if t.isSmallSegment(segment) {
smallCandidates = append(smallCandidates, segment)
} else {
nonPlannedSegments = append(nonPlannedSegments, segment)
}
}
var plans []*datapb.CompactionPlan
// sort segment from large to small
sort.Slice(prioritizedCandidates, func(i, j int) bool {
@ -503,6 +505,17 @@ func (t *compactionTrigger) generatePlans(segments []*SegmentInfo, force bool, i
return smallCandidates[i].GetID() < smallCandidates[j].GetID()
})
// Sort non-planned from small to large.
sort.Slice(nonPlannedSegments, func(i, j int) bool {
if nonPlannedSegments[i].GetNumOfRows() != nonPlannedSegments[j].GetNumOfRows() {
return nonPlannedSegments[i].GetNumOfRows() < nonPlannedSegments[j].GetNumOfRows()
}
return nonPlannedSegments[i].GetID() > nonPlannedSegments[j].GetID()
})
getSegmentIDs := func(segment *SegmentInfo, _ int) int64 {
return segment.GetID()
}
// greedy pick from large segment to small, the goal is to fill each segment to reach 512M
// we must ensure all prioritized candidates is in a plan
//TODO the compaction policy should consider segment with similar timestamp together so timetravel and data expiration could work better.
@ -540,6 +553,14 @@ func (t *compactionTrigger) generatePlans(segments []*SegmentInfo, force bool, i
plans = append(plans, plan)
}
getSegIDsFromPlan := func(plan *datapb.CompactionPlan) []int64 {
var segmentIDs []int64
for _, binLog := range plan.GetSegmentBinlogs() {
segmentIDs = append(segmentIDs, binLog.GetSegmentID())
}
return segmentIDs
}
var remainingSmallSegs []*SegmentInfo
// check if there are small candidates left can be merged into large segments
for len(smallCandidates) > 0 {
var bucket []*SegmentInfo
@ -564,15 +585,67 @@ func (t *compactionTrigger) generatePlans(segments []*SegmentInfo, force bool, i
}
// only merge if candidate number is large than MinSegmentToMerge or if target row is large enough
if len(bucket) >= Params.DataCoordCfg.MinSegmentToMerge ||
len(bucket) > 1 &&
targetRow > int64(float64(segment.GetMaxRowNum())*Params.DataCoordCfg.SegmentCompactableProportion) {
targetRow > int64(float64(segment.GetMaxRowNum())*Params.DataCoordCfg.SegmentCompactableProportion) {
plan := segmentsToPlan(bucket, compactTime)
log.Info("generate a plan for small candidates", zap.Any("plan", plan),
zap.Int64("target segment row", targetRow), zap.Int64("target segment size", size))
log.Info("generate a plan for small candidates",
zap.Int64s("plan segment IDs", lo.Map(bucket, getSegmentIDs)),
zap.Int64("target segment row", targetRow),
zap.Int64("target segment size", size))
plans = append(plans, plan)
} else {
remainingSmallSegs = append(remainingSmallSegs, bucket...)
}
}
// Try adding remaining segments to existing plans.
for i := len(remainingSmallSegs) - 1; i >= 0; i-- {
s := remainingSmallSegs[i]
if !isExpandableSmallSegment(s) {
continue
}
// Try squeeze this segment into existing plans. This could cause segment size to exceed maxSize.
for _, plan := range plans {
if plan.TotalRows+s.GetNumOfRows() <= int64(Params.DataCoordCfg.SegmentExpansionRate*float64(s.GetMaxRowNum())) {
segmentBinLogs := &datapb.CompactionSegmentBinlogs{
SegmentID: s.GetID(),
FieldBinlogs: s.GetBinlogs(),
Field2StatslogPaths: s.GetStatslogs(),
Deltalogs: s.GetDeltalogs(),
}
plan.TotalRows += s.GetNumOfRows()
plan.SegmentBinlogs = append(plan.SegmentBinlogs, segmentBinLogs)
log.Info("small segment appended on existing plan",
zap.Int64("segment ID", s.GetID()),
zap.Int64("target rows", plan.GetTotalRows()),
zap.Int64s("plan segment ID", getSegIDsFromPlan(plan)),
)
remainingSmallSegs = append(remainingSmallSegs[:i], remainingSmallSegs[i+1:]...)
break
}
}
}
// If there are still remaining small segments, try adding them to non-planned segments.
for _, npSeg := range nonPlannedSegments {
bucket := []*SegmentInfo{npSeg}
targetRow := npSeg.GetNumOfRows()
for i := len(remainingSmallSegs) - 1; i >= 0; i-- {
// Note: could also simply use MaxRowNum as limit.
if targetRow+remainingSmallSegs[i].GetNumOfRows() <=
int64(Params.DataCoordCfg.SegmentExpansionRate*float64(npSeg.GetMaxRowNum())) {
bucket = append(bucket, remainingSmallSegs[i])
targetRow += remainingSmallSegs[i].GetNumOfRows()
remainingSmallSegs = append(remainingSmallSegs[:i], remainingSmallSegs[i+1:]...)
}
}
if len(bucket) > 1 {
plan := segmentsToPlan(bucket, compactTime)
plans = append(plans, plan)
log.Info("generate a plan for to squeeze small candidates into non-planned segment",
zap.Int64s("plan segment IDs", lo.Map(bucket, getSegmentIDs)),
zap.Int64("target segment row", targetRow),
)
}
}
return plans
}
@ -591,6 +664,7 @@ func segmentsToPlan(segments []*SegmentInfo, compactTime *compactTime) *datapb.C
Field2StatslogPaths: s.GetStatslogs(),
Deltalogs: s.GetDeltalogs(),
}
plan.TotalRows += s.GetNumOfRows()
plan.SegmentBinlogs = append(plan.SegmentBinlogs, segmentBinlogs)
}
@ -655,6 +729,10 @@ func (t *compactionTrigger) isSmallSegment(segment *SegmentInfo) bool {
return segment.GetNumOfRows() < int64(float64(segment.GetMaxRowNum())*Params.DataCoordCfg.SegmentSmallProportion)
}
func isExpandableSmallSegment(segment *SegmentInfo) bool {
return segment.GetNumOfRows() < int64(float64(segment.GetMaxRowNum())*(Params.DataCoordCfg.SegmentExpansionRate-1))
}
func (t *compactionTrigger) fillOriginPlan(plan *datapb.CompactionPlan) error {
// TODO context
id, err := t.allocator.allocID(context.TODO())
@ -725,7 +803,7 @@ func (t *compactionTrigger) ShouldDoSingleCompaction(segment *SegmentInfo, isDis
}
if float32(totalExpiredRows)/float32(segment.GetNumOfRows()) >= Params.DataCoordCfg.SingleCompactionRatioThreshold || totalExpiredSize > Params.DataCoordCfg.SingleCompactionExpiredLogMaxSize {
log.Info("total expired entities is too much, trigger compation", zap.Int64("segment", segment.ID),
log.Info("total expired entities is too much, trigger compaction", zap.Int64("segment", segment.ID),
zap.Int("expired rows", totalExpiredRows), zap.Int64("expired log size", totalExpiredSize))
return true
}
@ -751,7 +829,7 @@ func (t *compactionTrigger) ShouldDoSingleCompaction(segment *SegmentInfo, isDis
// currently delta log size and delete ratio policy is applied
if float32(totalDeletedRows)/float32(segment.GetNumOfRows()) >= Params.DataCoordCfg.SingleCompactionRatioThreshold || totalDeleteLogSize > Params.DataCoordCfg.SingleCompactionDeltaLogMaxSize {
log.Info("total delete entities is too much, trigger compation", zap.Int64("segment", segment.ID),
log.Info("total delete entities is too much, trigger compaction", zap.Int64("segment", segment.ID),
zap.Int("deleted rows", totalDeletedRows), zap.Int64("delete log size", totalDeleteLogSize))
return true
}

510
internal/datacoord/compaction_trigger_test.go
View File

@ -347,6 +347,7 @@ func Test_compactionTrigger_force(t *testing.T) {
Type: datapb.CompactionType_MixCompaction,
Timetravel: timeTravel,
Channel: "ch1",
TotalRows: 200,
},
},
},
@ -881,7 +882,7 @@ func Test_compactionTrigger_noplan(t *testing.T) {
CollectionID: 2,
PartitionID: 1,
LastExpireTime: 100,
NumOfRows: 1,
NumOfRows: 200,
MaxRowNum: 300,
InsertChannel: "ch1",
State: commonpb.SegmentState_Flushed,
@ -922,66 +923,6 @@ func Test_compactionTrigger_noplan(t *testing.T) {
},
lastFlushTime: time.Now(),
},
3: {
SegmentInfo: &datapb.SegmentInfo{
ID: 3,
CollectionID: 2,
PartitionID: 1,
LastExpireTime: 100,
NumOfRows: 2,
MaxRowNum: 300,
InsertChannel: "ch1",
State: commonpb.SegmentState_Flushed,
Binlogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "log1", LogSize: 100},
},
},
},
},
lastFlushTime: time.Now(),
},
4: {
SegmentInfo: &datapb.SegmentInfo{
ID: 4,
CollectionID: 2,
PartitionID: 1,
LastExpireTime: 100,
NumOfRows: 3,
MaxRowNum: 300,
InsertChannel: "ch1",
State: commonpb.SegmentState_Flushed,
Binlogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "log1", LogSize: 100},
},
},
},
},
lastFlushTime: time.Now(),
},
5: {
SegmentInfo: &datapb.SegmentInfo{
ID: 4,
CollectionID: 2,
PartitionID: 1,
LastExpireTime: 100,
NumOfRows: 3,
MaxRowNum: 300,
InsertChannel: "ch1",
State: commonpb.SegmentState_Flushed,
Binlogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "log1", LogSize: 100},
},
},
},
},
lastFlushTime: time.Unix(0, 0),
},
},
},
collections: map[int64]*collectionInfo{
@ -1032,15 +973,12 @@ func Test_compactionTrigger_noplan(t *testing.T) {
defer tr.stop()
err := tr.triggerCompaction()
assert.Equal(t, tt.wantErr, err != nil)
spy := (tt.fields.compactionHandler).(*spyCompactionHandler)
plan := <-spy.spyChan
assert.Equal(t, len(plan.SegmentBinlogs), 4)
})
}
}
// Test compaction with small files
func Test_compactionTrigger_smallfiles(t *testing.T) {
// Test compaction with prioritized candi
func Test_compactionTrigger_PrioritizedCandi(t *testing.T) {
type fields struct {
meta *meta
allocator allocator
@ -1054,6 +992,33 @@ func Test_compactionTrigger_smallfiles(t *testing.T) {
}
Params.Init()
vecFieldID := int64(201)
genSeg := func(segID, numRows int64) *datapb.SegmentInfo {
return &datapb.SegmentInfo{
ID: segID,
CollectionID: 2,
PartitionID: 1,
LastExpireTime: 100,
NumOfRows: numRows,
MaxRowNum: 110,
InsertChannel: "ch1",
State: commonpb.SegmentState_Flushed,
Binlogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "log1", LogSize: 100},
},
},
},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog1"},
},
},
},
}
}
tests := []struct {
name string
fields fields
@ -1069,111 +1034,35 @@ func Test_compactionTrigger_smallfiles(t *testing.T) {
segments: &SegmentsInfo{
map[int64]*SegmentInfo{
1: {
SegmentInfo: &datapb.SegmentInfo{
ID: 1,
CollectionID: 2,
PartitionID: 1,
LastExpireTime: 100,
NumOfRows: 50,
MaxRowNum: 300,
InsertChannel: "ch1",
State: commonpb.SegmentState_Flushed,
Binlogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "log1", LogSize: 100},
},
},
},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog1"},
},
},
},
},
SegmentInfo: genSeg(1, 20),
lastFlushTime: time.Now().Add(-100 * time.Minute),
},
2: {
SegmentInfo: &datapb.SegmentInfo{
ID: 2,
CollectionID: 2,
PartitionID: 1,
LastExpireTime: 100,
NumOfRows: 50,
MaxRowNum: 300,
InsertChannel: "ch1",
State: commonpb.SegmentState_Flushed,
Binlogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "log2", LogSize: 800},
},
},
},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog2"},
},
},
},
},
SegmentInfo: genSeg(2, 20),
lastFlushTime: time.Now(),
},
3: {
SegmentInfo: &datapb.SegmentInfo{
ID: 3,
CollectionID: 2,
PartitionID: 1,
LastExpireTime: 100,
NumOfRows: 50,
MaxRowNum: 300,
InsertChannel: "ch1",
State: commonpb.SegmentState_Flushed,
Binlogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "log1", LogSize: 100},
},
},
},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog1"},
},
},
},
},
SegmentInfo: genSeg(3, 20),
lastFlushTime: time.Now(),
},
4: {
SegmentInfo: &datapb.SegmentInfo{
ID: 4,
CollectionID: 2,
PartitionID: 1,
LastExpireTime: 100,
NumOfRows: 50,
MaxRowNum: 300,
InsertChannel: "ch1",
State: commonpb.SegmentState_Flushed,
Binlogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "log1", LogSize: 100},
},
},
},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog1"},
},
},
},
},
SegmentInfo: genSeg(4, 20),
lastFlushTime: time.Now(),
},
5: {
SegmentInfo: genSeg(5, 20),
lastFlushTime: time.Now(),
},
6: {
SegmentInfo: genSeg(6, 20),
lastFlushTime: time.Now(),
},
7: {
SegmentInfo: genSeg(7, 20),
lastFlushTime: time.Now(),
},
8: {
SegmentInfo: genSeg(8, 20),
lastFlushTime: time.Now(),
},
},
@ -1229,8 +1118,287 @@ func Test_compactionTrigger_smallfiles(t *testing.T) {
spy := (tt.fields.compactionHandler).(*spyCompactionHandler)
select {
case val := <-spy.spyChan:
// 4 segments in the final pick list
assert.Equal(t, len(val.SegmentBinlogs), 4)
// 5 segments in the final pick list
assert.Equal(t, len(val.SegmentBinlogs), 5)
return
case <-time.After(3 * time.Second):
assert.Fail(t, "failed to get plan")
return
}
})
}
}
// Test compaction with small candi
func Test_compactionTrigger_SmallCandi(t *testing.T) {
type fields struct {
meta *meta
allocator allocator
signals chan *compactionSignal
compactionHandler compactionPlanContext
globalTrigger *time.Ticker
}
type args struct {
collectionID int64
compactTime *compactTime
}
Params.Init()
vecFieldID := int64(201)
genSeg := func(segID, numRows int64) *datapb.SegmentInfo {
return &datapb.SegmentInfo{
ID: segID,
CollectionID: 2,
PartitionID: 1,
LastExpireTime: 100,
NumOfRows: numRows,
MaxRowNum: 110,
InsertChannel: "ch1",
State: commonpb.SegmentState_Flushed,
Binlogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "log1", LogSize: 100},
},
},
},
}
}
tests := []struct {
name string
fields fields
args args
wantErr bool
wantPlans []*datapb.CompactionPlan
}{
{
"test small segment",
fields{
&meta{
// 4 small segments
segments: &SegmentsInfo{
map[int64]*SegmentInfo{
1: {
SegmentInfo: genSeg(1, 20),
lastFlushTime: time.Now().Add(-100 * time.Minute),
},
2: {
SegmentInfo: genSeg(2, 20),
lastFlushTime: time.Now(),
},
3: {
SegmentInfo: genSeg(3, 20),
lastFlushTime: time.Now(),
},
4: {
SegmentInfo: genSeg(4, 20),
lastFlushTime: time.Now(),
},
5: {
SegmentInfo: genSeg(5, 20),
lastFlushTime: time.Now(),
},
6: {
SegmentInfo: genSeg(6, 20),
lastFlushTime: time.Now(),
},
7: {
SegmentInfo: genSeg(7, 20),
lastFlushTime: time.Now(),
},
},
},
collections: map[int64]*collectionInfo{
2: {
ID: 2,
Schema: &schemapb.CollectionSchema{
Fields: []*schemapb.FieldSchema{
{
FieldID: vecFieldID,
DataType: schemapb.DataType_FloatVector,
},
},
},
},
},
},
newMockAllocator(),
make(chan *compactionSignal, 1),
&spyCompactionHandler{spyChan: make(chan *datapb.CompactionPlan, 1)},
nil,
},
args{
2,
&compactTime{travelTime: 200, expireTime: 0},
},
false,
nil,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
indexCoord := newMockIndexCoord()
tr := &compactionTrigger{
meta: tt.fields.meta,
handler: newMockHandlerWithMeta(tt.fields.meta),
allocator: tt.fields.allocator,
signals: tt.fields.signals,
estimateDiskSegmentPolicy: calBySchemaPolicyWithDiskIndex,
estimateNonDiskSegmentPolicy: calBySchemaPolicy,
compactionHandler: tt.fields.compactionHandler,
globalTrigger: tt.fields.globalTrigger,
segRefer: &SegmentReferenceManager{segmentsLock: map[UniqueID]map[UniqueID]*datapb.SegmentReferenceLock{}},
indexCoord: indexCoord,
testingOnly: true,
}
tr.start()
defer tr.stop()
err := tr.triggerCompaction()
assert.Equal(t, tt.wantErr, err != nil)
spy := (tt.fields.compactionHandler).(*spyCompactionHandler)
select {
case val := <-spy.spyChan:
// 6 segments in the final pick list.
// 5 generated by the origin plan, 1 was added as additional segment.
assert.Equal(t, len(val.SegmentBinlogs), 6)
return
case <-time.After(3 * time.Second):
assert.Fail(t, "failed to get plan")
return
}
})
}
}
// Test compaction with small candi
func Test_compactionTrigger_SqueezeNonPlannedSegs(t *testing.T) {
type fields struct {
meta *meta
allocator allocator
signals chan *compactionSignal
compactionHandler compactionPlanContext
globalTrigger *time.Ticker
}
type args struct {
collectionID int64
compactTime *compactTime
}
Params.Init()
vecFieldID := int64(201)
genSeg := func(segID, numRows int64) *datapb.SegmentInfo {
return &datapb.SegmentInfo{
ID: segID,
CollectionID: 2,
PartitionID: 1,
LastExpireTime: 100,
NumOfRows: numRows,
MaxRowNum: 110,
InsertChannel: "ch1",
State: commonpb.SegmentState_Flushed,
Binlogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "log1", LogSize: 100},
},
},
},
}
}
tests := []struct {
name string
fields fields
args args
wantErr bool
wantPlans []*datapb.CompactionPlan
}{
{
"test small segment",
fields{
&meta{
// 4 small segments
segments: &SegmentsInfo{
map[int64]*SegmentInfo{
1: {
SegmentInfo: genSeg(1, 60),
lastFlushTime: time.Now().Add(-100 * time.Minute),
},
2: {
SegmentInfo: genSeg(2, 60),
lastFlushTime: time.Now(),
},
3: {
SegmentInfo: genSeg(3, 60),
lastFlushTime: time.Now(),
},
4: {
SegmentInfo: genSeg(4, 60),
lastFlushTime: time.Now(),
},
5: {
SegmentInfo: genSeg(5, 26),
lastFlushTime: time.Now(),
},
6: {
SegmentInfo: genSeg(6, 26),
lastFlushTime: time.Now(),
},
},
},
collections: map[int64]*collectionInfo{
2: {
ID: 2,
Schema: &schemapb.CollectionSchema{
Fields: []*schemapb.FieldSchema{
{
FieldID: vecFieldID,
DataType: schemapb.DataType_FloatVector,
},
},
},
},
},
},
newMockAllocator(),
make(chan *compactionSignal, 1),
&spyCompactionHandler{spyChan: make(chan *datapb.CompactionPlan, 1)},
nil,
},
args{
2,
&compactTime{travelTime: 200, expireTime: 0},
},
false,
nil,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
indexCoord := newMockIndexCoord()
tr := &compactionTrigger{
meta: tt.fields.meta,
handler: newMockHandlerWithMeta(tt.fields.meta),
allocator: tt.fields.allocator,
signals: tt.fields.signals,
compactionHandler: tt.fields.compactionHandler,
globalTrigger: tt.fields.globalTrigger,
segRefer: &SegmentReferenceManager{segmentsLock: map[UniqueID]map[UniqueID]*datapb.SegmentReferenceLock{}},
indexCoord: indexCoord,
testingOnly: true,
}
tr.start()
defer tr.stop()
err := tr.triggerCompaction()
assert.Equal(t, tt.wantErr, err != nil)
spy := (tt.fields.compactionHandler).(*spyCompactionHandler)
select {
case val := <-spy.spyChan:
// max # of rows == 110, expansion rate == 1.25.
// segment 5 and 6 are squeezed into a non-planned segment. Total # of rows: 60 + 26 + 26 == 112,
// which is greater than 110 but smaller than 110 * 1.25
assert.Equal(t, len(val.SegmentBinlogs), 3)
return
case <-time.After(3 * time.Second):
assert.Fail(t, "failed to get plan")
@ -1365,7 +1533,7 @@ func Test_compactionTrigger_noplan_random_size(t *testing.T) {
select {
case val := <-spy.spyChan:
plans = append(plans, val)
case <-time.After(1 * time.Second):
case <-time.After(3 * time.Second):
break WAIT
}
}
@ -1378,13 +1546,15 @@ func Test_compactionTrigger_noplan_random_size(t *testing.T) {
}
fmt.Println("target ", len(plan.SegmentBinlogs))
}
assert.Equal(t, len(plans), 3)
assert.Equal(t, 4, len(plans))
// plan 1: 250 + 20 * 10 + 3 * 20
// plan 2: 200 + 7 * 20 + 4 * 40
// plan 3 128 + 6 * 40 + 127
assert.Equal(t, len(plans[0].SegmentBinlogs), 24)
assert.Equal(t, len(plans[1].SegmentBinlogs), 12)
assert.Equal(t, len(plans[2].SegmentBinlogs), 8)
// plan 3: 128 + 6 * 40 + 127
// plan 4: 300 + 128 + 128 ( < 512 * 1.25)
assert.Equal(t, 24, len(plans[0].SegmentBinlogs))
assert.Equal(t, 12, len(plans[1].SegmentBinlogs))
assert.Equal(t, 8, len(plans[2].SegmentBinlogs))
assert.Equal(t, 3, len(plans[3].SegmentBinlogs))
})
}
}

1
internal/proto/data_coord.proto
View File

@ -488,6 +488,7 @@ message CompactionPlan {
uint64 timetravel = 6;
string channel = 7;
int64 collection_ttl = 8;
int64 total_rows = 9;
}
message CompactionResult {

588
internal/proto/datapb/data_coord.pb.go
View File

@ -3354,6 +3354,7 @@ type CompactionPlan struct {
Timetravel uint64 `protobuf:"varint,6,opt,name=timetravel,proto3" json:"timetravel,omitempty"`
Channel string `protobuf:"bytes,7,opt,name=channel,proto3" json:"channel,omitempty"`
CollectionTtl int64 `protobuf:"varint,8,opt,name=collection_ttl,json=collectionTtl,proto3" json:"collection_ttl,omitempty"`
TotalRows int64 `protobuf:"varint,9,opt,name=total_rows,json=totalRows,proto3" json:"total_rows,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -3440,6 +3441,13 @@ func (m *CompactionPlan) GetCollectionTtl() int64 {
return 0
}
func (m *CompactionPlan) GetTotalRows() int64 {
if m != nil {
return m.TotalRows
}
return 0
}
type CompactionResult struct {
PlanID int64 `protobuf:"varint,1,opt,name=planID,proto3" json:"planID,omitempty"`
SegmentID int64 `protobuf:"varint,2,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
@ -5305,301 +5313,301 @@ func init() {
func init() { proto.RegisterFile("data_coord.proto", fileDescriptor_82cd95f524594f49) }
var fileDescriptor_82cd95f524594f49 = []byte{
// 4689 bytes of a gzipped FileDescriptorProto
// 4703 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x7c, 0xcd, 0x6f, 0x1b, 0x49,
0x76, 0xb8, 0x9b, 0x5f, 0x22, 0x1f, 0x29, 0x8a, 0x2a, 0x7b, 0x24, 0x9a, 0xfe, 0x9c, 0xb6, 0x3d,
0xe3, 0xf1, 0x78, 0xec, 0x19, 0xcd, 0x6f, 0xb0, 0xfe, 0x8d, 0x77, 0x66, 0x63, 0x49, 0x96, 0x87,
0x89, 0xa4, 0xd5, 0xb6, 0x64, 0x3b, 0x98, 0x0d, 0x40, 0xb4, 0xd9, 0x25, 0xaa, 0x57, 0x64, 0x37,
0xdd, 0xdd, 0x94, 0xac, 0xcd, 0x61, 0x07, 0x09, 0x12, 0x60, 0x83, 0x20, 0x1b, 0x04, 0x09, 0x36,
0xdd, 0xdd, 0x94, 0xac, 0xcd, 0x61, 0x27, 0x09, 0x12, 0x60, 0x83, 0x20, 0x1b, 0x04, 0x09, 0x36,
0x39, 0x04, 0x08, 0x72, 0xda, 0x6c, 0xb0, 0x41, 0x80, 0xcd, 0x5e, 0x72, 0xc9, 0x75, 0x92, 0x1c,
0x16, 0x41, 0x80, 0x1c, 0x13, 0x20, 0x87, 0x24, 0xf7, 0xfc, 0x03, 0x41, 0x7d, 0x74, 0xf5, 0x57,
0x35, 0xd9, 0x22, 0xed, 0xf1, 0x22, 0xb9, 0xb1, 0xaa, 0x5f, 0x55, 0xbd, 0x7a, 0xf5, 0xbe, 0x5f,
0x15, 0xa1, 0x61, 0xe8, 0x9e, 0xde, 0xe9, 0xda, 0xb6, 0x63, 0xdc, 0x19, 0x3a, 0xb6, 0x67, 0xa3,
0xc5, 0x81, 0xd9, 0x3f, 0x1a, 0xb9, 0xac, 0x75, 0x87, 0x7c, 0x6e, 0xd5, 0xba, 0xf6, 0x60, 0x60,
0x5b, 0xac, 0xab, 0x55, 0x37, 0x2d, 0x0f, 0x3b, 0x96, 0xde, 0xe7, 0xed, 0x5a, 0x78, 0x40, 0xab,
0xe6, 0x76, 0x0f, 0xf0, 0x40, 0x67, 0x2d, 0x75, 0x0e, 0x8a, 0x0f, 0x07, 0x43, 0xef, 0x44, 0xfd,
0x1b, 0x05, 0x6a, 0x1b, 0xfd, 0x91, 0x7b, 0xa0, 0xe1, 0xe7, 0x23, 0xec, 0x7a, 0xe8, 0x7d, 0x28,
0x3c, 0xd3, 0x5d, 0xdc, 0x54, 0xae, 0x2a, 0x37, 0xab, 0x2b, 0x17, 0xef, 0x44, 0x56, 0xe5, 0xeb,
0x6d, 0xb9, 0xbd, 0x55, 0xdd, 0xc5, 0x1a, 0x85, 0x44, 0x08, 0x0a, 0xc6, 0xb3, 0xf6, 0x7a, 0x33,
0x77, 0x55, 0xb9, 0x99, 0xd7, 0xe8, 0x6f, 0x74, 0x19, 0xc0, 0xc5, 0xbd, 0x01, 0xb6, 0xbc, 0xf6,
0xba, 0xdb, 0xcc, 0x5f, 0xcd, 0xdf, 0xcc, 0x6b, 0xa1, 0x1e, 0xa4, 0x42, 0xad, 0x6b, 0xf7, 0xfb,
0xb8, 0xeb, 0x99, 0xb6, 0xd5, 0x5e, 0x6f, 0x16, 0xe8, 0xd8, 0x48, 0x1f, 0x6a, 0x41, 0xd9, 0x74,
0xdb, 0x83, 0xa1, 0xed, 0x78, 0xcd, 0xe2, 0x55, 0xe5, 0x66, 0x59, 0x13, 0x6d, 0xf5, 0x3f, 0x14,
0x98, 0xe7, 0x68, 0xbb, 0x43, 0xdb, 0x72, 0x31, 0xfa, 0x10, 0x4a, 0xae, 0xa7, 0x7b, 0x23, 0x97,
0x63, 0x7e, 0x41, 0x8a, 0xf9, 0x2e, 0x05, 0xd1, 0x38, 0xa8, 0x14, 0xf5, 0x38, 0x6a, 0x79, 0x09,
0x6a, 0xd1, 0xed, 0x15, 0x12, 0xdb, 0xbb, 0x09, 0x0b, 0xfb, 0x04, 0xbb, 0xdd, 0x00, 0xa8, 0x48,
0x81, 0xe2, 0xdd, 0x64, 0x26, 0xcf, 0x1c, 0xe0, 0x6f, 0xee, 0xef, 0x62, 0xbd, 0xdf, 0x2c, 0xd1,
0xb5, 0x42, 0x3d, 0xea, 0x3f, 0x29, 0xd0, 0x10, 0xe0, 0xfe, 0x19, 0x9d, 0x83, 0x62, 0xd7, 0x1e,
0x59, 0x1e, 0xdd, 0xea, 0xbc, 0xc6, 0x1a, 0xe8, 0x4d, 0xa8, 0x75, 0x0f, 0x74, 0xcb, 0xc2, 0xfd,
0x8e, 0xa5, 0x0f, 0x30, 0xdd, 0x54, 0x45, 0xab, 0xf2, 0xbe, 0x6d, 0x7d, 0x80, 0x33, 0xed, 0xed,
0x2a, 0x54, 0x87, 0xba, 0xe3, 0x99, 0x91, 0x93, 0x09, 0x77, 0x8d, 0x3b, 0x18, 0xb2, 0x82, 0x49,
0x7f, 0xed, 0xe9, 0xee, 0x61, 0x7b, 0x9d, 0xef, 0x28, 0xd2, 0xa7, 0xfe, 0x99, 0x02, 0x4b, 0x0f,
0x5c, 0xd7, 0xec, 0x59, 0x89, 0x9d, 0x2d, 0x41, 0xc9, 0xb2, 0x0d, 0xdc, 0x5e, 0xa7, 0x5b, 0xcb,
0x6b, 0xbc, 0x85, 0x2e, 0x40, 0x65, 0x88, 0xb1, 0xd3, 0x71, 0xec, 0xbe, 0xbf, 0xb1, 0x32, 0xe9,
0xd0, 0xec, 0x3e, 0x46, 0xdf, 0x82, 0x45, 0x37, 0x36, 0x11, 0xe3, 0xb9, 0xea, 0xca, 0xb5, 0x3b,
0x09, 0xa9, 0xb9, 0x13, 0x5f, 0x54, 0x4b, 0x8e, 0x56, 0xbf, 0xc8, 0xc1, 0x59, 0x01, 0xc7, 0x70,
0x25, 0xbf, 0x09, 0xe5, 0x5d, 0xdc, 0x13, 0xe8, 0xb1, 0x46, 0x16, 0xca, 0x8b, 0x23, 0xcb, 0x87,
0x8f, 0x2c, 0x8b, 0x18, 0xc4, 0xce, 0xa3, 0x98, 0x3c, 0x8f, 0x2b, 0x50, 0xc5, 0x2f, 0x86, 0xa6,
0x83, 0x3b, 0x84, 0x71, 0x28, 0xc9, 0x0b, 0x1a, 0xb0, 0xae, 0x3d, 0x73, 0x10, 0x96, 0x8d, 0xb9,
0xcc, 0xb2, 0xa1, 0xfe, 0xb9, 0x02, 0xcb, 0x89, 0x53, 0xe2, 0xc2, 0xa6, 0x41, 0x83, 0xee, 0x3c,
0xa0, 0x0c, 0x11, 0x3b, 0x42, 0xf0, 0xb7, 0xc6, 0x11, 0x3c, 0x00, 0xd7, 0x12, 0xe3, 0x43, 0x48,
0xe6, 0xb2, 0x23, 0x79, 0x08, 0xcb, 0x8f, 0xb0, 0xc7, 0x17, 0x20, 0xdf, 0xb0, 0x3b, 0xbd, 0x22,
0x8b, 0x4a, 0x75, 0x2e, 0x2e, 0xd5, 0xea, 0x5f, 0xe7, 0x84, 0x2c, 0xd2, 0xa5, 0xda, 0xd6, 0xbe,
0x8d, 0x2e, 0x42, 0x45, 0x80, 0x70, 0xae, 0x08, 0x3a, 0xd0, 0xd7, 0xa0, 0x48, 0x30, 0x65, 0x2c,
0x51, 0x5f, 0x79, 0x53, 0xbe, 0xa7, 0xd0, 0x9c, 0x1a, 0x83, 0x47, 0x6d, 0xa8, 0xbb, 0x9e, 0xee,
0x78, 0x9d, 0xa1, 0xed, 0xd2, 0x73, 0xa6, 0x8c, 0x53, 0x5d, 0x51, 0xa3, 0x33, 0x08, 0x95, 0xbf,
0xe5, 0xf6, 0x76, 0x38, 0xa4, 0x36, 0x4f, 0x47, 0xfa, 0x4d, 0xf4, 0x10, 0x6a, 0xd8, 0x32, 0x82,
0x89, 0x0a, 0x99, 0x27, 0xaa, 0x62, 0xcb, 0x10, 0xd3, 0x04, 0xe7, 0x53, 0xcc, 0x7e, 0x3e, 0xbf,
0xab, 0x40, 0x33, 0x79, 0x40, 0xb3, 0xa8, 0xec, 0xfb, 0x6c, 0x10, 0x66, 0x07, 0x34, 0x56, 0xc2,
0xc5, 0x21, 0x69, 0x7c, 0x88, 0xfa, 0x47, 0x0a, 0xbc, 0x11, 0xa0, 0x43, 0x3f, 0xbd, 0x2a, 0x6e,
0x41, 0xb7, 0xa0, 0x61, 0x5a, 0xdd, 0xfe, 0xc8, 0xc0, 0x8f, 0xad, 0xcf, 0xb0, 0xde, 0xf7, 0x0e,
0x4e, 0xe8, 0x19, 0x96, 0xb5, 0x44, 0xbf, 0xfa, 0xaf, 0x39, 0x58, 0x8a, 0xe3, 0x35, 0x0b, 0x91,
0xfe, 0x1f, 0x14, 0x4d, 0x6b, 0xdf, 0xf6, 0x69, 0x74, 0x79, 0x8c, 0x50, 0x92, 0xb5, 0x18, 0x30,
0xb2, 0x01, 0xf9, 0x6a, 0xac, 0x7b, 0x80, 0xbb, 0x87, 0x43, 0xdb, 0xa4, 0x0a, 0x8b, 0x4c, 0xf1,
0x4b, 0x92, 0x29, 0xe4, 0x18, 0xdf, 0x59, 0x63, 0x73, 0xac, 0x89, 0x29, 0x1e, 0x5a, 0x9e, 0x73,
0xa2, 0x2d, 0x76, 0xe3, 0xfd, 0xad, 0x03, 0x58, 0x92, 0x03, 0xa3, 0x06, 0xe4, 0x0f, 0xf1, 0x09,
0xdd, 0x72, 0x45, 0x23, 0x3f, 0xd1, 0x3d, 0x28, 0x1e, 0xe9, 0xfd, 0x11, 0xe6, 0xda, 0x21, 0x0b,
0xfb, 0xb2, 0x01, 0x1f, 0xe7, 0xee, 0x29, 0xea, 0x0f, 0x15, 0x58, 0xde, 0x34, 0x5d, 0x1f, 0x5f,
0xf7, 0x17, 0xe7, 0xe8, 0x7f, 0x4b, 0x81, 0x66, 0x12, 0xb3, 0xaf, 0xfc, 0xf0, 0xd5, 0x01, 0x5c,
0x78, 0x84, 0xbd, 0xb6, 0xe5, 0x62, 0xc7, 0x5b, 0x35, 0xad, 0xbe, 0xdd, 0xdb, 0xd1, 0xbd, 0x83,
0x19, 0xb4, 0x69, 0x44, 0x31, 0xe6, 0x62, 0x8a, 0x51, 0xfd, 0x91, 0x02, 0x17, 0xe5, 0xeb, 0xf1,
0xad, 0xb7, 0xa0, 0xbc, 0x6f, 0xe2, 0xbe, 0x41, 0x28, 0xac, 0x50, 0x0a, 0x8b, 0x36, 0xd1, 0xaa,
0x43, 0x02, 0xcc, 0x77, 0xf8, 0x66, 0x0a, 0x2f, 0xec, 0x7a, 0x8e, 0x69, 0xf5, 0x08, 0x71, 0x35,
0x06, 0x1f, 0xa2, 0x67, 0x3e, 0xbb, 0x0e, 0xfb, 0x1d, 0x05, 0x2e, 0x3f, 0xc2, 0xde, 0x9a, 0x30,
0xca, 0xe4, 0xbb, 0xe9, 0x7a, 0x66, 0xd7, 0x7d, 0xb9, 0x4e, 0x73, 0x06, 0xef, 0x4c, 0xfd, 0x81,
0x02, 0x57, 0x52, 0x91, 0xe1, 0xa4, 0xe3, 0x46, 0xc7, 0x37, 0xc9, 0x72, 0xa3, 0xf3, 0x2b, 0xf8,
0xe4, 0x09, 0x11, 0x8f, 0x1d, 0xdd, 0x74, 0x98, 0xd1, 0x99, 0xd2, 0x04, 0xff, 0x44, 0x81, 0x4b,
0x8f, 0xb0, 0xb7, 0xe3, 0x3b, 0x24, 0xaf, 0x91, 0x3a, 0x04, 0x26, 0xe4, 0x18, 0xf9, 0x9e, 0x79,
0xa4, 0x4f, 0xfd, 0x3d, 0x76, 0x9c, 0x52, 0x7c, 0x5f, 0x0b, 0x01, 0x2f, 0x53, 0x49, 0x08, 0x89,
0x24, 0xd7, 0x89, 0x9c, 0x7c, 0xea, 0x9f, 0x2a, 0x70, 0xfe, 0x41, 0xf7, 0xf9, 0xc8, 0x74, 0x30,
0x07, 0xda, 0xb4, 0xbb, 0x87, 0xd3, 0x13, 0x37, 0xf0, 0xb1, 0x73, 0x11, 0x1f, 0x7b, 0x52, 0xcc,
0xb6, 0x04, 0x25, 0x8f, 0x39, 0xf5, 0xcc, 0x4d, 0xe5, 0x2d, 0x8a, 0x9f, 0x86, 0xfb, 0x58, 0x77,
0x7f, 0x31, 0xf1, 0xfb, 0x41, 0x01, 0x6a, 0x4f, 0xb8, 0xf1, 0xa1, 0x2e, 0x5b, 0x9c, 0x93, 0x14,
0xb9, 0xd7, 0x1d, 0x72, 0xdf, 0x65, 0x1e, 0xfd, 0x23, 0x98, 0x77, 0x31, 0x3e, 0x9c, 0xc6, 0x41,
0xab, 0x91, 0x81, 0xc2, 0xb1, 0xda, 0x84, 0xc5, 0x91, 0x45, 0xe3, 0x42, 0x6c, 0xf8, 0x56, 0x80,
0x72, 0xee, 0x64, 0xdd, 0x9d, 0x1c, 0x88, 0x3e, 0xe3, 0xa1, 0x67, 0x68, 0xae, 0x62, 0xa6, 0xb9,
0xe2, 0xc3, 0x50, 0x1b, 0x1a, 0x86, 0x63, 0x0f, 0x87, 0xd8, 0xe8, 0xb8, 0xfe, 0x54, 0xa5, 0x6c,
0x53, 0xf1, 0x71, 0x62, 0xaa, 0xf7, 0xe1, 0x6c, 0x1c, 0xd3, 0xb6, 0x41, 0xa2, 0x11, 0x72, 0x86,
0xb2, 0x4f, 0xe8, 0x36, 0x2c, 0x26, 0xe1, 0xcb, 0x14, 0x3e, 0xf9, 0x01, 0xbd, 0x07, 0x28, 0x86,
0x2a, 0x01, 0xaf, 0x30, 0xf0, 0x28, 0x32, 0x6d, 0xc3, 0x55, 0xbf, 0xaf, 0xc0, 0xd2, 0x53, 0xdd,
0xeb, 0x1e, 0xac, 0x0f, 0xb8, 0xac, 0xcd, 0xa0, 0xab, 0x3e, 0x81, 0xca, 0x11, 0xe7, 0x0b, 0xdf,
0x20, 0x5d, 0x91, 0xd0, 0x27, 0xcc, 0x81, 0x5a, 0x30, 0x82, 0x04, 0xc3, 0xe7, 0x36, 0x42, 0x49,
0x81, 0xd7, 0xa0, 0x35, 0x27, 0x64, 0x33, 0xd4, 0x17, 0x00, 0x1c, 0xb9, 0x2d, 0xb7, 0x37, 0x05,
0x5e, 0xf7, 0x60, 0x8e, 0xcf, 0xc6, 0xd5, 0xe2, 0x24, 0xfe, 0xf1, 0xc1, 0xd5, 0x1f, 0x97, 0xa0,
0x1a, 0xfa, 0x80, 0xea, 0x90, 0x13, 0xf2, 0x9a, 0x93, 0xec, 0x2e, 0x37, 0x39, 0x7e, 0xce, 0x27,
0xe3, 0xe7, 0x1b, 0x50, 0x37, 0xa9, 0x1f, 0xd2, 0xe1, 0xa7, 0x42, 0x15, 0x48, 0x45, 0x9b, 0x67,
0xbd, 0x9c, 0x45, 0xd0, 0x65, 0xa8, 0x5a, 0xa3, 0x41, 0xc7, 0xde, 0xef, 0x38, 0xf6, 0xb1, 0xcb,
0x03, 0xf1, 0x8a, 0x35, 0x1a, 0x7c, 0x73, 0x5f, 0xb3, 0x8f, 0xdd, 0x20, 0xd6, 0x2b, 0x9d, 0x32,
0xd6, 0xbb, 0x0c, 0xd5, 0x81, 0xfe, 0x82, 0xcc, 0xda, 0xb1, 0x46, 0x03, 0x1a, 0xa3, 0xe7, 0xb5,
0xca, 0x40, 0x7f, 0xa1, 0xd9, 0xc7, 0xdb, 0xa3, 0x01, 0xba, 0x09, 0x8d, 0xbe, 0xee, 0x7a, 0x9d,
0x70, 0x90, 0x5f, 0xa6, 0x41, 0x7e, 0x9d, 0xf4, 0x3f, 0x0c, 0x02, 0xfd, 0x64, 0xd4, 0x58, 0x99,
0x21, 0x6a, 0x34, 0x06, 0xfd, 0x60, 0x22, 0xc8, 0x1e, 0x35, 0x1a, 0x83, 0xbe, 0x98, 0xe6, 0x1e,
0xcc, 0x3d, 0xa3, 0xde, 0x9d, 0xdb, 0xac, 0xa6, 0xea, 0x8e, 0x0d, 0xe2, 0xd8, 0x31, 0x27, 0x50,
0xf3, 0xc1, 0xd1, 0xd7, 0xa1, 0x42, 0x8d, 0x2a, 0x1d, 0x5b, 0xcb, 0x34, 0x36, 0x18, 0x40, 0x46,
0x1b, 0xb8, 0xef, 0xe9, 0x74, 0xf4, 0x7c, 0xb6, 0xd1, 0x62, 0x00, 0xd1, 0x57, 0x5d, 0x07, 0xeb,
0x1e, 0x36, 0x56, 0x4f, 0xd6, 0xec, 0xc1, 0x50, 0xa7, 0xcc, 0xd4, 0xac, 0x53, 0x1f, 0x5e, 0xf6,
0x09, 0xbd, 0x05, 0xf5, 0xae, 0x68, 0x6d, 0x38, 0xf6, 0xa0, 0xb9, 0x40, 0xe5, 0x28, 0xd6, 0x8b,
0x2e, 0x01, 0xf8, 0x9a, 0x4a, 0xf7, 0x9a, 0x0d, 0x7a, 0x8a, 0x15, 0xde, 0xf3, 0x80, 0xe6, 0xf0,
0x4c, 0xb7, 0xc3, 0xb2, 0x65, 0xa6, 0xd5, 0x6b, 0x2e, 0xd2, 0x15, 0xab, 0x7e, 0x7a, 0xcd, 0xb4,
0x7a, 0x68, 0x19, 0xe6, 0x4c, 0xb7, 0xb3, 0xaf, 0x1f, 0xe2, 0x26, 0xa2, 0x5f, 0x4b, 0xa6, 0xbb,
0xa1, 0x1f, 0x62, 0xf5, 0x7b, 0x70, 0x2e, 0xe0, 0xae, 0xd0, 0x49, 0x26, 0x99, 0x42, 0x99, 0x96,
0x29, 0xc6, 0xfb, 0xf4, 0x3f, 0x2f, 0xc0, 0xd2, 0xae, 0x7e, 0x84, 0x5f, 0x7d, 0xf8, 0x90, 0x49,
0xad, 0x6d, 0xc2, 0x22, 0x8d, 0x18, 0x56, 0x42, 0xf8, 0x8c, 0xb1, 0xab, 0x61, 0x56, 0x48, 0x0e,
0x44, 0xdf, 0x20, 0x0e, 0x01, 0xee, 0x1e, 0xee, 0x90, 0x20, 0xd5, 0xb7, 0xa9, 0x97, 0x24, 0xf3,
0xac, 0x09, 0x28, 0x2d, 0x3c, 0x02, 0xed, 0xc0, 0x42, 0xf4, 0x18, 0x7c, 0x6b, 0xfa, 0xf6, 0xd8,
0x0c, 0x46, 0x40, 0x7d, 0xad, 0x1e, 0x39, 0x0c, 0x17, 0x35, 0x61, 0x8e, 0x9b, 0x42, 0xaa, 0x33,
0xca, 0x9a, 0xdf, 0x44, 0x3b, 0x70, 0x96, 0xed, 0x60, 0x97, 0x0b, 0x04, 0xdb, 0x7c, 0x39, 0xd3,
0xe6, 0x65, 0x43, 0xa3, 0xf2, 0x54, 0x39, 0xad, 0x3c, 0x35, 0x61, 0x8e, 0xf3, 0x38, 0xd5, 0x23,
0x65, 0xcd, 0x6f, 0x92, 0x63, 0x0e, 0xb8, 0xbd, 0x4a, 0xbf, 0x05, 0x1d, 0x24, 0xf4, 0x82, 0x80,
0x9e, 0x13, 0x72, 0x6d, 0x9f, 0x42, 0x59, 0x70, 0x78, 0xf6, 0x24, 0x81, 0x18, 0x13, 0xd7, 0xef,
0xf9, 0x98, 0x7e, 0x57, 0xff, 0x51, 0x81, 0xda, 0x3a, 0xd9, 0xd2, 0xa6, 0xdd, 0xa3, 0xd6, 0xe8,
0x06, 0xd4, 0x1d, 0xdc, 0xb5, 0x1d, 0xa3, 0x83, 0x2d, 0xcf, 0x31, 0x31, 0x8b, 0xd2, 0x0b, 0xda,
0x3c, 0xeb, 0x7d, 0xc8, 0x3a, 0x09, 0x18, 0x51, 0xd9, 0xae, 0xa7, 0x0f, 0x86, 0x9d, 0x7d, 0xa2,
0x1a, 0x72, 0x0c, 0x4c, 0xf4, 0x52, 0xcd, 0xf0, 0x26, 0xd4, 0x02, 0x30, 0xcf, 0xa6, 0xeb, 0x17,
0xb4, 0xaa, 0xe8, 0xdb, 0xb3, 0xd1, 0x75, 0xa8, 0x53, 0x9a, 0x76, 0xfa, 0x76, 0xaf, 0x43, 0x22,
0x5a, 0x6e, 0xa8, 0x6a, 0x06, 0x47, 0x8b, 0x9c, 0x55, 0x14, 0xca, 0x35, 0xbf, 0x8b, 0xb9, 0xa9,
0x12, 0x50, 0xbb, 0xe6, 0x77, 0xb1, 0xfa, 0x0f, 0x0a, 0xcc, 0xaf, 0xeb, 0x9e, 0xbe, 0x6d, 0x1b,
0x78, 0x6f, 0x4a, 0xc3, 0x9e, 0x21, 0xef, 0x7d, 0x11, 0x2a, 0x62, 0x07, 0x7c, 0x4b, 0x41, 0x07,
0xda, 0x80, 0xba, 0xef, 0x5a, 0x76, 0x58, 0xc4, 0x55, 0x48, 0x75, 0xa0, 0x42, 0x96, 0xd3, 0xd5,
0xe6, 0xfd, 0x61, 0xb4, 0xa9, 0x6e, 0x40, 0x2d, 0xfc, 0x99, 0xac, 0xba, 0x1b, 0x67, 0x14, 0xd1,
0x41, 0xb8, 0x71, 0x7b, 0x34, 0x20, 0x67, 0xca, 0x15, 0x8b, 0xdf, 0x54, 0x7f, 0x53, 0x81, 0x79,
0x6e, 0xee, 0x77, 0x45, 0x85, 0x88, 0x6e, 0x8d, 0x65, 0xa2, 0xe8, 0x6f, 0xf4, 0x71, 0x34, 0xa9,
0x7b, 0x5d, 0xaa, 0x04, 0xe8, 0x24, 0xd4, 0xc9, 0x8c, 0xd8, 0xfa, 0x2c, 0x31, 0xfe, 0x17, 0x84,
0xd1, 0xf8, 0xd1, 0x50, 0x46, 0x6b, 0xc2, 0x9c, 0x6e, 0x18, 0x0e, 0x76, 0x5d, 0x8e, 0x87, 0xdf,
0x24, 0x5f, 0x8e, 0xb0, 0xe3, 0xfa, 0x2c, 0x9f, 0xd7, 0xfc, 0x26, 0xfa, 0x3a, 0x94, 0x85, 0x57,
0xca, 0x52, 0x78, 0x57, 0xd3, 0xf1, 0xe4, 0x11, 0xa9, 0x18, 0xa1, 0xfe, 0x2c, 0x07, 0x75, 0x4e,
0xb0, 0x55, 0x6e, 0x8f, 0xc7, 0x0b, 0xdf, 0x2a, 0xd4, 0xf6, 0x03, 0xd9, 0x1f, 0x97, 0x7b, 0x0a,
0xab, 0x88, 0xc8, 0x98, 0x49, 0x02, 0x18, 0xf5, 0x08, 0x0a, 0x33, 0x79, 0x04, 0xc5, 0xd3, 0x6a,
0xb0, 0xa4, 0x8f, 0x58, 0x92, 0xf8, 0x88, 0xea, 0xaf, 0x41, 0x35, 0x34, 0x01, 0xd5, 0xd0, 0x2c,
0x69, 0xc5, 0x29, 0xe6, 0x37, 0xd1, 0x87, 0x81, 0x5f, 0xc4, 0x48, 0x75, 0x5e, 0x82, 0x4b, 0xcc,
0x25, 0x52, 0xff, 0x4e, 0x81, 0x12, 0x9f, 0xf9, 0x0a, 0x54, 0xb9, 0xd2, 0xa1, 0x3e, 0x23, 0x9b,
0x1d, 0x78, 0x17, 0x71, 0x1a, 0x5f, 0x9e, 0xd6, 0x39, 0x0f, 0xe5, 0x98, 0xbe, 0x99, 0xe3, 0x66,
0xc1, 0xff, 0x14, 0x52, 0x32, 0xe4, 0x13, 0xd1, 0x2f, 0xe8, 0x1c, 0x14, 0xfb, 0x76, 0x4f, 0x54,
0x00, 0x59, 0x43, 0xfd, 0x52, 0xa1, 0x05, 0x1b, 0x0d, 0x77, 0xed, 0x23, 0xec, 0x9c, 0xcc, 0x9e,
0xec, 0xbc, 0x1f, 0x62, 0xf3, 0x8c, 0xc1, 0x97, 0x18, 0x80, 0xee, 0x07, 0x87, 0x90, 0x97, 0x65,
0x7a, 0xc2, 0x7a, 0x87, 0x33, 0x69, 0x70, 0x18, 0xbf, 0xaf, 0xd0, 0x9c, 0x7d, 0x74, 0x2b, 0xd3,
0x7a, 0x3b, 0x2f, 0x25, 0x90, 0x51, 0xff, 0x5e, 0x81, 0xf3, 0x29, 0xd4, 0x7d, 0xb2, 0xf2, 0x1a,
0xe8, 0xfb, 0x31, 0x94, 0x45, 0xe6, 0x20, 0x9f, 0x29, 0x73, 0x20, 0xe0, 0xd5, 0x3f, 0x64, 0x95,
0x23, 0x09, 0x79, 0x9f, 0xac, 0xbc, 0x22, 0x02, 0xc7, 0xb3, 0x87, 0x79, 0x49, 0xf6, 0xf0, 0xe7,
0x0a, 0xb4, 0x82, 0x6c, 0x9d, 0xbb, 0x7a, 0x32, 0x6b, 0xd1, 0xf1, 0xe5, 0x84, 0xb0, 0xff, 0x5f,
0x54, 0xc5, 0x88, 0x5e, 0xcc, 0x14, 0x7c, 0xfa, 0x35, 0x31, 0x8b, 0x26, 0xfe, 0x93, 0x1b, 0x9a,
0x45, 0x2a, 0x5b, 0xa1, 0x83, 0x67, 0xe5, 0x91, 0xe0, 0x60, 0xff, 0x8d, 0x31, 0xe9, 0x46, 0x34,
0xdb, 0xf4, 0xba, 0x09, 0x18, 0x2e, 0xd9, 0x1c, 0xf0, 0x92, 0x4d, 0x21, 0x56, 0xb2, 0xe1, 0xfd,
0xfe, 0x9d, 0x8d, 0x55, 0xbc, 0x6f, 0x3b, 0x4c, 0xef, 0x15, 0xb4, 0x50, 0x8f, 0x3a, 0xa0, 0x2c,
0x92, 0xd8, 0xe0, 0xab, 0x22, 0xe8, 0x6f, 0x2b, 0xd0, 0xe4, 0xab, 0xd0, 0x35, 0x49, 0x54, 0xda,
0xc7, 0x1e, 0x36, 0xbe, 0xea, 0x6c, 0xcd, 0x1f, 0xe7, 0xa0, 0x11, 0x76, 0x7c, 0xa8, 0xef, 0xf2,
0x11, 0x14, 0x69, 0xb2, 0x8b, 0x63, 0x30, 0x51, 0x7b, 0x30, 0x68, 0x62, 0x39, 0x69, 0xb4, 0xb3,
0x27, 0x7c, 0x34, 0xde, 0x0c, 0xbc, 0xaf, 0xfc, 0xe9, 0xbd, 0x2f, 0xee, 0x8d, 0xda, 0x23, 0x32,
0x2f, 0xcb, 0x12, 0x07, 0x1d, 0xe8, 0x13, 0x28, 0xb1, 0x4b, 0x52, 0xbc, 0xc2, 0x7d, 0x23, 0x3a,
0x35, 0xbf, 0x40, 0x15, 0x2a, 0xbd, 0xd0, 0x0e, 0x8d, 0x0f, 0x22, 0x67, 0x34, 0x74, 0xec, 0x1e,
0x75, 0xd3, 0x88, 0xd1, 0x2b, 0x6a, 0xa2, 0xad, 0xfe, 0x32, 0x2c, 0x05, 0xc9, 0x02, 0x86, 0xd2,
0xb4, 0x0c, 0xaf, 0xfe, 0x8b, 0x02, 0x67, 0x77, 0x4f, 0xac, 0x6e, 0x5c, 0x74, 0x96, 0xa0, 0x34,
0xec, 0xeb, 0x41, 0x42, 0x9b, 0xb7, 0xa8, 0x97, 0xce, 0xd6, 0xc6, 0x06, 0x31, 0xf1, 0x8c, 0x9e,
0x55, 0xd1, 0xb7, 0x67, 0x4f, 0xf4, 0xbc, 0x6e, 0x88, 0xec, 0x06, 0x36, 0x98, 0x33, 0xc1, 0xb2,
0x84, 0xf3, 0xa2, 0x97, 0x3a, 0x13, 0x9f, 0x00, 0x50, 0x7f, 0xab, 0x73, 0x1a, 0x1f, 0x8b, 0x8e,
0xd8, 0x24, 0x16, 0xf5, 0xa7, 0x39, 0x68, 0x86, 0xa8, 0xf4, 0x55, 0xbb, 0x9f, 0x29, 0x41, 0x73,
0xfe, 0x25, 0x05, 0xcd, 0x85, 0xd9, 0x5d, 0xce, 0xa2, 0xcc, 0xe5, 0xfc, 0xf7, 0x1c, 0xd4, 0x03,
0xaa, 0xed, 0xf4, 0x75, 0x2b, 0x95, 0x13, 0x76, 0x45, 0xb8, 0x15, 0xa5, 0xd3, 0xbb, 0x32, 0x19,
0x4a, 0x39, 0x08, 0x2d, 0x36, 0x05, 0xba, 0x44, 0x0f, 0xdd, 0xf1, 0x58, 0x5e, 0x92, 0x87, 0x78,
0x4c, 0x58, 0xcd, 0x01, 0x46, 0xb7, 0x01, 0x71, 0x09, 0xeb, 0x98, 0x56, 0xc7, 0xc5, 0x5d, 0xdb,
0x32, 0x98, 0xec, 0x15, 0xb5, 0x06, 0xff, 0xd2, 0xb6, 0x76, 0x59, 0x3f, 0xfa, 0x08, 0x0a, 0xde,
0xc9, 0x90, 0x29, 0xd5, 0xba, 0xd4, 0x1d, 0x0b, 0xf0, 0xda, 0x3b, 0x19, 0x62, 0x8d, 0x82, 0xfb,
0x1a, 0xd9, 0x73, 0xf4, 0x23, 0xee, 0x99, 0x73, 0x8d, 0xcc, 0x7a, 0x88, 0x36, 0xf1, 0x69, 0x38,
0xc7, 0x3c, 0x58, 0xde, 0x64, 0x9c, 0xed, 0x0b, 0x74, 0xc7, 0xf3, 0xfa, 0x34, 0xb3, 0x4a, 0x39,
0xdb, 0xef, 0xdd, 0xf3, 0xfa, 0xea, 0x3f, 0x13, 0xd5, 0x26, 0x56, 0xd6, 0xb0, 0x3b, 0xea, 0xa7,
0x0b, 0xdc, 0xf8, 0xd4, 0xd5, 0x24, 0x59, 0xfb, 0x06, 0x54, 0xf9, 0xb1, 0x9f, 0x82, 0x6d, 0x80,
0x0d, 0xd9, 0x1c, 0xc3, 0xc7, 0xc5, 0x97, 0xc4, 0xc7, 0xa5, 0x29, 0x92, 0x3f, 0x72, 0xe2, 0xab,
0x3f, 0x52, 0xe0, 0x8d, 0x84, 0x5a, 0x1c, 0x4b, 0xda, 0xf1, 0xa1, 0x37, 0x57, 0x97, 0xf1, 0x29,
0xb9, 0xf2, 0xbf, 0x0f, 0x25, 0x87, 0xce, 0xce, 0x2b, 0x75, 0xd7, 0xc6, 0x72, 0x17, 0x43, 0x44,
0xe3, 0x43, 0xd4, 0x3f, 0x50, 0x60, 0x39, 0x89, 0xea, 0x0c, 0x16, 0x7d, 0x15, 0xe6, 0xd8, 0xd4,
0xbe, 0x10, 0xde, 0x1c, 0x2f, 0x84, 0x01, 0x71, 0x34, 0x7f, 0xa0, 0xba, 0x0b, 0x4b, 0xbe, 0xe1,
0x0f, 0x48, 0xbf, 0x85, 0x3d, 0x7d, 0x4c, 0xe0, 0x79, 0x05, 0xaa, 0x2c, 0x82, 0x61, 0x01, 0x1d,
0x4b, 0xd9, 0xc0, 0x33, 0x91, 0xe9, 0x54, 0xff, 0x4b, 0x81, 0x73, 0xd4, 0x72, 0xc6, 0x4b, 0x63,
0x59, 0xca, 0xa6, 0xaa, 0xc8, 0x08, 0x6d, 0xeb, 0x03, 0x7e, 0x47, 0xab, 0xa2, 0x45, 0xfa, 0x50,
0x3b, 0x99, 0x08, 0x95, 0x26, 0x28, 0x82, 0x3a, 0xfb, 0xba, 0xee, 0xe9, 0xb4, 0xcc, 0x1e, 0xcf,
0x80, 0x06, 0x16, 0xbb, 0x30, 0x85, 0xc5, 0x56, 0x37, 0xe1, 0x8d, 0xd8, 0x4e, 0x67, 0x38, 0x51,
0xf5, 0x2f, 0x14, 0x72, 0x1c, 0x91, 0xbb, 0x6e, 0xd3, 0x7b, 0xb5, 0x97, 0x44, 0x4d, 0xae, 0x63,
0x1a, 0x71, 0x25, 0x62, 0xa0, 0x4f, 0xa1, 0x62, 0xe1, 0xe3, 0x4e, 0xd8, 0x11, 0xca, 0xe0, 0xf2,
0x97, 0x2d, 0x7c, 0x4c, 0x7f, 0xa9, 0xdb, 0xb0, 0x9c, 0x40, 0x75, 0x96, 0xbd, 0xff, 0xad, 0x02,
0xe7, 0xd7, 0x1d, 0x7b, 0xf8, 0xc4, 0x74, 0xbc, 0x91, 0xde, 0x8f, 0xde, 0x60, 0x78, 0x35, 0x99,
0xc5, 0xcf, 0x12, 0xc1, 0xe5, 0x6d, 0x89, 0x04, 0x25, 0x91, 0xe2, 0x9b, 0x0e, 0x39, 0xd0, 0xff,
0x99, 0x97, 0x21, 0xcf, 0xe1, 0x26, 0x38, 0x1e, 0x59, 0xa2, 0x0f, 0x69, 0x21, 0x22, 0x3f, 0x6d,
0x21, 0x22, 0x45, 0xbd, 0x17, 0x5e, 0x92, 0x7a, 0x3f, 0x75, 0x66, 0xec, 0x33, 0x88, 0x16, 0x89,
0xa8, 0xf9, 0x9d, 0xaa, 0xba, 0xb4, 0x0a, 0x10, 0x14, 0x4c, 0xf8, 0x55, 0xe5, 0x2c, 0xd3, 0x84,
0x46, 0x91, 0xd3, 0x12, 0xa6, 0x94, 0x9b, 0xf2, 0x50, 0x0a, 0xff, 0x5b, 0xd0, 0x92, 0x71, 0xe9,
0x2c, 0x9c, 0xff, 0xd3, 0x1c, 0x40, 0x5b, 0xdc, 0x6e, 0x9f, 0xce, 0x16, 0x5c, 0x83, 0x90, 0xbb,
0x11, 0xc8, 0x7b, 0x98, 0x8b, 0x0c, 0x22, 0x12, 0x22, 0x60, 0x25, 0x30, 0x89, 0x20, 0xd6, 0xa0,
0xf3, 0x84, 0xa4, 0x86, 0x31, 0x45, 0x5c, 0xfd, 0x5e, 0x80, 0x8a, 0x63, 0x1f, 0x77, 0x88, 0x98,
0x19, 0xfe, 0xf5, 0x7d, 0xc7, 0x3e, 0x26, 0xc2, 0x67, 0xa0, 0x65, 0x98, 0xf3, 0x74, 0xf7, 0x90,
0xcc, 0x5f, 0x0a, 0x5d, 0xa2, 0x31, 0xd0, 0x39, 0x28, 0xee, 0x9b, 0x7d, 0xcc, 0xee, 0x6c, 0x54,
0x34, 0xd6, 0x40, 0x5f, 0xf3, 0xaf, 0x1a, 0x96, 0x33, 0x5f, 0x94, 0x62, 0xb7, 0x0d, 0xbf, 0x54,
0x60, 0x21, 0xa0, 0x1a, 0x55, 0x40, 0x44, 0xa7, 0x51, 0x7d, 0xb6, 0x66, 0x1b, 0x4c, 0x55, 0xd4,
0x53, 0x2c, 0x02, 0x1b, 0xc8, 0xb4, 0x56, 0x30, 0x64, 0x5c, 0x8c, 0x4c, 0xf6, 0x45, 0x36, 0x6d,
0x1a, 0x7e, 0x56, 0xa7, 0xe4, 0xd8, 0xc7, 0x6d, 0x43, 0x50, 0x83, 0xdd, 0xcd, 0x67, 0x11, 0x21,
0xa1, 0xc6, 0x1a, 0xbd, 0x9e, 0x7f, 0x0d, 0xe6, 0xb1, 0xe3, 0xd8, 0x4e, 0x67, 0x80, 0x5d, 0x57,
0xef, 0x61, 0xee, 0x80, 0xd7, 0x68, 0xe7, 0x16, 0xeb, 0x53, 0x7f, 0x58, 0x80, 0x7a, 0xb0, 0x15,
0xff, 0x9a, 0x82, 0x69, 0xf8, 0xd7, 0x14, 0x4c, 0x72, 0x74, 0xe0, 0x30, 0x55, 0x28, 0x0e, 0x77,
0x35, 0xd7, 0x54, 0xb4, 0x0a, 0xef, 0x6d, 0x1b, 0xc4, 0x2c, 0x13, 0x21, 0xb3, 0x6c, 0x03, 0x07,
0x87, 0x0b, 0x7e, 0x17, 0x3f, 0xdb, 0x08, 0x8f, 0x14, 0x32, 0xf0, 0x48, 0x31, 0x03, 0x8f, 0x94,
0x24, 0x3c, 0xb2, 0x04, 0xa5, 0x67, 0xa3, 0xee, 0x21, 0xf6, 0xb8, 0xc7, 0xc6, 0x5b, 0x51, 0xde,
0x29, 0xc7, 0x78, 0x47, 0xb0, 0x48, 0x25, 0xcc, 0x22, 0x17, 0xa0, 0xc2, 0xea, 0xe5, 0x1d, 0xcf,
0xa5, 0xc5, 0xbf, 0xbc, 0x56, 0x66, 0x1d, 0x7b, 0x2e, 0xba, 0xe7, 0xbb, 0x73, 0x55, 0x99, 0xb0,
0x53, 0xad, 0x13, 0xe3, 0x12, 0xdf, 0x99, 0x7b, 0x1b, 0x16, 0x42, 0xe4, 0xa0, 0x36, 0xa2, 0x46,
0x51, 0x0d, 0xb9, 0xf3, 0xd4, 0x4c, 0xdc, 0x80, 0x7a, 0x40, 0x12, 0x0a, 0x37, 0xcf, 0xa2, 0x28,
0xd1, 0x4b, 0xc1, 0x04, 0x27, 0xd7, 0x4f, 0xc7, 0xc9, 0xe8, 0x3c, 0x94, 0x79, 0xf8, 0xe3, 0x36,
0x17, 0x22, 0x99, 0x0a, 0xf5, 0x3b, 0x80, 0x02, 0xec, 0x67, 0xf3, 0x16, 0x63, 0xec, 0x91, 0x8b,
0xb3, 0x87, 0xfa, 0x63, 0x05, 0x16, 0xc3, 0x8b, 0x4d, 0x6b, 0x78, 0x3f, 0x85, 0x2a, 0x2b, 0xbf,
0x76, 0x88, 0xe0, 0xf3, 0x0c, 0xd0, 0xa5, 0xb1, 0xe7, 0xa2, 0x41, 0xf0, 0xba, 0x87, 0xb0, 0xd7,
0xb1, 0xed, 0x1c, 0x9a, 0x56, 0xaf, 0x43, 0x30, 0x13, 0x49, 0x54, 0xde, 0xb9, 0x4d, 0xfa, 0xd4,
0xef, 0x2b, 0x70, 0xf9, 0xf1, 0xd0, 0xd0, 0x3d, 0x1c, 0xf2, 0x40, 0x66, 0xbd, 0x33, 0xfa, 0x91,
0x7f, 0x69, 0x33, 0x97, 0xad, 0x84, 0xc8, 0xa0, 0xd5, 0xbf, 0x12, 0xb8, 0x24, 0xae, 0xa2, 0x4f,
0x8f, 0x4b, 0x0b, 0xca, 0x47, 0x7c, 0x3a, 0xff, 0xb5, 0x92, 0xdf, 0x8e, 0x94, 0xa9, 0xf3, 0xa7,
0x2f, 0x53, 0xab, 0x5b, 0x70, 0x5e, 0xc3, 0x2e, 0xb6, 0x8c, 0xc8, 0x6e, 0xa6, 0xce, 0x26, 0x0d,
0xa1, 0x25, 0x9b, 0x6e, 0x16, 0x66, 0x65, 0xbe, 0x6b, 0xc7, 0x21, 0xd3, 0x7a, 0x5c, 0x15, 0x13,
0x97, 0x89, 0xae, 0xe3, 0xa9, 0x7f, 0x99, 0x83, 0xe5, 0x07, 0x86, 0xc1, 0xb5, 0x38, 0xf7, 0xc6,
0x5e, 0x95, 0xa3, 0x1c, 0x77, 0x24, 0xf3, 0x49, 0x47, 0xf2, 0x65, 0x69, 0x56, 0x6e, 0x63, 0xac,
0xd1, 0xc0, 0xb7, 0x9d, 0x0e, 0xbb, 0xbf, 0x75, 0x9f, 0xd7, 0x2d, 0x49, 0x40, 0x4f, 0xed, 0xe7,
0x64, 0xff, 0xaa, 0xec, 0x67, 0xc5, 0xd4, 0x21, 0x34, 0x93, 0xc4, 0x9a, 0x51, 0x95, 0xf8, 0x14,
0x19, 0xda, 0x2c, 0xbb, 0x5a, 0x23, 0x2e, 0x14, 0xed, 0xda, 0xb1, 0x5d, 0xf5, 0xbf, 0x73, 0xd0,
0xdc, 0xd5, 0x8f, 0xf0, 0xff, 0x9d, 0x03, 0xfa, 0x1c, 0xce, 0xb9, 0xfa, 0x11, 0xee, 0x84, 0x02,
0xe3, 0x8e, 0x83, 0x9f, 0x73, 0x17, 0xf4, 0x1d, 0x99, 0x26, 0x91, 0x5e, 0x73, 0xd2, 0x16, 0xdd,
0x48, 0xbf, 0x86, 0x9f, 0xa3, 0xb7, 0x60, 0x21, 0x7c, 0x8f, 0x8e, 0xa0, 0x56, 0xa6, 0x24, 0x9f,
0x0f, 0x5d, 0x93, 0x6b, 0x1b, 0xea, 0x73, 0xb8, 0xf8, 0xd8, 0x72, 0xb1, 0xd7, 0x0e, 0xae, 0x7a,
0xcd, 0x18, 0x42, 0x5e, 0x81, 0x6a, 0x40, 0xf8, 0xc4, 0x33, 0x15, 0xc3, 0x55, 0x6d, 0x68, 0x6d,
0xe9, 0xce, 0xa1, 0x9f, 0x47, 0x5e, 0x67, 0x57, 0x72, 0x5e, 0xe1, 0x82, 0xfb, 0xe2, 0x86, 0x9a,
0x86, 0xf7, 0xb1, 0x83, 0xad, 0x2e, 0xde, 0xb4, 0xbb, 0x87, 0xa1, 0x9b, 0xdb, 0x4a, 0xf8, 0xe6,
0xf6, 0xb4, 0x37, 0xc1, 0xd5, 0x9f, 0xe4, 0x60, 0xe9, 0x41, 0xdf, 0xc3, 0x4e, 0x10, 0xf9, 0x9f,
0x26, 0x89, 0x11, 0x64, 0x15, 0x72, 0xd3, 0xd4, 0x01, 0x32, 0x94, 0x11, 0x65, 0x39, 0x90, 0xc2,
0x94, 0x39, 0x90, 0x07, 0x00, 0x43, 0xc7, 0x1e, 0x62, 0xc7, 0x33, 0xb1, 0x1f, 0xbe, 0x65, 0x70,
0x5f, 0x42, 0x83, 0xd4, 0xcf, 0xa1, 0xf1, 0xa8, 0xbb, 0x66, 0x5b, 0xfb, 0xa6, 0x33, 0xf0, 0x09,
0x95, 0x10, 0x3a, 0x25, 0x83, 0xd0, 0xe5, 0x12, 0x42, 0xa7, 0x9a, 0xb0, 0x18, 0x9a, 0x7b, 0x46,
0xc5, 0xd5, 0xeb, 0x76, 0xf6, 0x4d, 0xcb, 0xa4, 0x57, 0xde, 0x72, 0xd4, 0xfd, 0x84, 0x5e, 0x77,
0x83, 0xf7, 0xdc, 0xfa, 0x54, 0x5c, 0x16, 0xde, 0x3b, 0x19, 0x62, 0x34, 0x07, 0xf9, 0x6d, 0x7c,
0xdc, 0x38, 0x83, 0x00, 0x4a, 0xdb, 0xb6, 0x33, 0xd0, 0xfb, 0x0d, 0x05, 0x55, 0x61, 0x8e, 0x17,
0xe6, 0x1a, 0x39, 0x34, 0x0f, 0x95, 0x35, 0xbf, 0x80, 0xd1, 0xc8, 0xdf, 0xfa, 0x13, 0x05, 0x16,
0x13, 0xa5, 0x23, 0x54, 0x07, 0x78, 0x6c, 0x75, 0x79, 0x4d, 0xad, 0x71, 0x06, 0xd5, 0xa0, 0xec,
0x57, 0xd8, 0xd8, 0x7c, 0x7b, 0x36, 0x85, 0x6e, 0xe4, 0x50, 0x03, 0x6a, 0x6c, 0xe0, 0xa8, 0xdb,
0xc5, 0xae, 0xdb, 0xc8, 0x8b, 0x9e, 0x0d, 0xdd, 0xec, 0x8f, 0x1c, 0xdc, 0x28, 0x90, 0x35, 0xf7,
0x6c, 0xfe, 0x5c, 0xa2, 0x51, 0x44, 0x08, 0xea, 0xfe, 0xdb, 0x09, 0x3e, 0xa8, 0x14, 0xea, 0xf3,
0x87, 0xcd, 0xdd, 0x7a, 0x1a, 0x4e, 0xf2, 0xd3, 0xed, 0x2d, 0xc3, 0xd9, 0xc7, 0x96, 0x81, 0xf7,
0x4d, 0x0b, 0x1b, 0xc1, 0xa7, 0xc6, 0x19, 0x74, 0x16, 0x16, 0xb6, 0xb0, 0xd3, 0xc3, 0xa1, 0xce,
0x1c, 0x5a, 0x84, 0xf9, 0x2d, 0xf3, 0x45, 0xa8, 0x2b, 0xaf, 0x16, 0xca, 0x4a, 0x43, 0x59, 0xf9,
0xd9, 0x55, 0xa8, 0x10, 0xde, 0x5a, 0xb3, 0x6d, 0xc7, 0x40, 0x7d, 0x40, 0xf4, 0x75, 0xd1, 0x60,
0x68, 0x5b, 0xe2, 0xc1, 0x26, 0xba, 0x13, 0x3d, 0x1e, 0xde, 0x48, 0x02, 0x72, 0xde, 0x69, 0x5d,
0x97, 0xc2, 0xc7, 0x80, 0xd5, 0x33, 0x68, 0x40, 0x57, 0xdb, 0x33, 0x07, 0x78, 0xcf, 0xec, 0x1e,
0xfa, 0x0e, 0xd2, 0xfb, 0x29, 0xee, 0x50, 0x12, 0xd4, 0x5f, 0xef, 0x9a, 0x74, 0x3d, 0xf6, 0xfc,
0xcb, 0xe7, 0x39, 0xf5, 0x0c, 0x7a, 0x0e, 0xe7, 0x1e, 0xe1, 0x90, 0xaf, 0xe9, 0x2f, 0xb8, 0x92,
0xbe, 0x60, 0x02, 0xf8, 0x94, 0x4b, 0x6e, 0x42, 0x91, 0xb2, 0x1b, 0x92, 0xb9, 0xa3, 0xe1, 0xff,
0x5d, 0x68, 0x5d, 0x4d, 0x07, 0x10, 0xb3, 0x7d, 0x07, 0x16, 0x62, 0x2f, 0xb2, 0x91, 0xcc, 0x38,
0xc9, 0xdf, 0xd6, 0xb7, 0x6e, 0x65, 0x01, 0x15, 0x6b, 0xf5, 0xa0, 0x1e, 0x7d, 0x95, 0x84, 0x6e,
0x66, 0x78, 0x02, 0xca, 0x56, 0x7a, 0x27, 0xf3, 0x63, 0x51, 0xca, 0x04, 0x8d, 0xf8, 0x0b, 0x61,
0x74, 0x6b, 0xec, 0x04, 0x51, 0x66, 0x7b, 0x37, 0x13, 0xac, 0x58, 0xee, 0x84, 0x32, 0x41, 0xe2,
0xdd, 0x61, 0x9c, 0xc7, 0xfd, 0x69, 0xd2, 0x1e, 0x44, 0xb6, 0xee, 0x66, 0x86, 0x0f, 0xef, 0x34,
0xfe, 0xd2, 0x53, 0xba, 0xd3, 0x94, 0x87, 0xaa, 0xd2, 0x9d, 0xa6, 0x3d, 0x1d, 0x55, 0xcf, 0xa0,
0xdf, 0x60, 0x77, 0xad, 0x64, 0x4f, 0x05, 0xd1, 0x07, 0x72, 0xec, 0xc7, 0xbc, 0x71, 0x6c, 0xad,
0x9c, 0x66, 0x88, 0x40, 0xe2, 0x7b, 0xf4, 0x92, 0x94, 0xe4, 0xb1, 0x5d, 0x5c, 0xcc, 0xfd, 0xf9,
0xd2, 0xdf, 0x11, 0xb6, 0x3e, 0x38, 0xc5, 0x08, 0x81, 0x80, 0x1d, 0x7f, 0xf1, 0xed, 0x4b, 0xfd,
0xdd, 0x89, 0x4c, 0x3a, 0x9d, 0xc8, 0x7f, 0x1b, 0x16, 0x62, 0xde, 0x21, 0xca, 0xee, 0x41, 0xb6,
0xc6, 0x59, 0x42, 0xa6, 0x01, 0x62, 0x97, 0xa2, 0x50, 0x8a, 0xb0, 0x49, 0x2e, 0x4e, 0xb5, 0x6e,
0x65, 0x01, 0x15, 0x1b, 0x19, 0xc2, 0x62, 0xec, 0xe3, 0x93, 0x15, 0xf4, 0x6e, 0xe6, 0xd5, 0x9e,
0xac, 0xb4, 0x6e, 0x67, 0x5f, 0xef, 0xc9, 0x8a, 0x7a, 0x06, 0xb9, 0xd4, 0x1e, 0xc4, 0x2e, 0xce,
0xa0, 0x94, 0x59, 0xe4, 0x17, 0x88, 0x5a, 0xef, 0x65, 0x84, 0x16, 0xdb, 0x3c, 0x82, 0xb3, 0x92,
0xfb, 0x4f, 0xe8, 0xbd, 0xb1, 0xec, 0x11, 0xbf, 0xf8, 0xd5, 0xba, 0x93, 0x15, 0x3c, 0x64, 0x8d,
0x1a, 0x3e, 0x5e, 0x0f, 0xfa, 0x7d, 0xe6, 0x6b, 0xdc, 0x4e, 0x33, 0xb4, 0x11, 0xb0, 0x94, 0xad,
0xa6, 0x42, 0x8b, 0x25, 0x7f, 0x1d, 0xd0, 0xee, 0x81, 0x7d, 0x4c, 0xbd, 0xb1, 0xde, 0xc8, 0xd1,
0x99, 0x03, 0x99, 0x66, 0x6f, 0x93, 0xa0, 0x29, 0x82, 0x38, 0x76, 0x84, 0x58, 0xbc, 0x03, 0xf0,
0x08, 0x7b, 0x5b, 0xd8, 0x73, 0x88, 0xf4, 0xbf, 0x95, 0x86, 0x3b, 0x07, 0xf0, 0x97, 0x7a, 0x7b,
0x22, 0x5c, 0x98, 0xa0, 0x5b, 0xba, 0x35, 0xd2, 0xfb, 0xa1, 0x67, 0x39, 0x72, 0x82, 0xc6, 0xc1,
0xc6, 0x13, 0x34, 0x09, 0x2d, 0x96, 0x3c, 0x16, 0xee, 0x52, 0xa8, 0x4a, 0x3b, 0xde, 0x5d, 0x4a,
0x5e, 0x01, 0x8a, 0x9b, 0x92, 0x31, 0xf0, 0x62, 0xe1, 0x2f, 0x14, 0x7a, 0x6b, 0x2f, 0x06, 0xf0,
0xd4, 0xf4, 0x0e, 0x76, 0xfa, 0xba, 0xe5, 0x66, 0x41, 0x81, 0x02, 0x9e, 0x02, 0x05, 0x0e, 0x2f,
0x50, 0x30, 0x60, 0x3e, 0x52, 0x3c, 0x45, 0xb2, 0x77, 0x2c, 0xb2, 0x42, 0x72, 0xeb, 0xe6, 0x64,
0x40, 0xb1, 0xca, 0x01, 0xcc, 0xfb, 0x0c, 0xcd, 0x88, 0xfb, 0xce, 0x58, 0xa6, 0x8f, 0xd0, 0xf5,
0x56, 0x16, 0x50, 0xb1, 0x92, 0x0b, 0x28, 0x59, 0x1b, 0x42, 0xd9, 0x6a, 0x8a, 0xe3, 0x94, 0x4f,
0x7a, 0xc1, 0x89, 0xe9, 0xf3, 0x58, 0x1d, 0x56, 0x6e, 0x2c, 0xa4, 0x65, 0x65, 0xa9, 0x3e, 0x4f,
0x29, 0xeb, 0xaa, 0x67, 0xd0, 0x53, 0x28, 0xf1, 0x3f, 0x69, 0xba, 0x3e, 0x3e, 0x9f, 0xcb, 0x67,
0xbf, 0x31, 0x01, 0x4a, 0x4c, 0x7c, 0x08, 0xcb, 0x29, 0xd9, 0x5c, 0xa9, 0x9f, 0x31, 0x3e, 0xf3,
0x3b, 0xc9, 0x02, 0x8a, 0xc5, 0x12, 0xe9, 0xda, 0x31, 0x8b, 0xa5, 0xa5, 0x76, 0x27, 0x2d, 0xa6,
0x03, 0x4a, 0xbe, 0xbc, 0x97, 0xf2, 0x44, 0xea, 0x03, 0xfd, 0x0c, 0x4b, 0x24, 0x1f, 0xcf, 0x4b,
0x97, 0x48, 0x7d, 0x63, 0x3f, 0x69, 0x89, 0x0e, 0x2c, 0x26, 0xf2, 0x79, 0x52, 0x43, 0x9e, 0x96,
0xf5, 0x9b, 0xb4, 0x40, 0x0f, 0xde, 0x90, 0xe6, 0xae, 0xa4, 0x3e, 0xd6, 0xb8, 0x2c, 0xd7, 0xa4,
0x85, 0xba, 0x70, 0x56, 0x92, 0xb1, 0x92, 0xda, 0xea, 0xf4, 0xcc, 0xd6, 0xa4, 0x45, 0xf6, 0xa1,
0xb5, 0xea, 0xd8, 0xba, 0xd1, 0xd5, 0x5d, 0x8f, 0x66, 0x91, 0x48, 0x7c, 0xed, 0x3b, 0xb9, 0xf2,
0x80, 0x4b, 0x9a, 0x6b, 0x9a, 0xb4, 0xce, 0x33, 0xa8, 0x52, 0x86, 0x64, 0xff, 0x04, 0x83, 0xe4,
0x96, 0x2e, 0x04, 0x91, 0xa2, 0x3e, 0x65, 0x80, 0x42, 0x34, 0x7f, 0x15, 0x2a, 0x22, 0xfb, 0x82,
0x64, 0x17, 0x9e, 0xe2, 0x79, 0x9f, 0xd6, 0xf5, 0xf1, 0x40, 0xfe, 0xcc, 0x2b, 0x5f, 0x56, 0xa0,
0xec, 0x3f, 0x52, 0xfa, 0x8a, 0xd3, 0x06, 0xaf, 0x21, 0x8e, 0xff, 0x36, 0x2c, 0xc4, 0xfe, 0x30,
0x40, 0xca, 0x08, 0xf2, 0x3f, 0x15, 0x98, 0xc4, 0x08, 0x4f, 0xf9, 0x7f, 0x19, 0x0a, 0x8f, 0xf7,
0xed, 0xb4, 0x5c, 0x40, 0xdc, 0xd9, 0x9d, 0x30, 0xf1, 0xff, 0x6e, 0x7f, 0x6f, 0x1b, 0x20, 0xe4,
0xe9, 0x8d, 0xbf, 0x2b, 0x4a, 0x9c, 0x97, 0x49, 0xd4, 0x1a, 0x48, 0x9d, 0xb9, 0x77, 0xb2, 0x5c,
0xcb, 0x4b, 0x37, 0xc7, 0xe9, 0x2e, 0xdc, 0x63, 0xa8, 0x85, 0x6f, 0x71, 0x23, 0xe9, 0x3f, 0xe7,
0x25, 0xaf, 0x79, 0x4f, 0xda, 0xc5, 0xd6, 0x29, 0xad, 0xfc, 0x84, 0xe9, 0x5c, 0x62, 0x9e, 0xe2,
0xe5, 0xc1, 0x14, 0xf3, 0x94, 0x52, 0x94, 0x94, 0x7a, 0x45, 0xe9, 0x35, 0x47, 0x96, 0x28, 0x89,
0xd7, 0xbc, 0xa4, 0x89, 0x92, 0x94, 0x2a, 0xa2, 0x34, 0x51, 0x92, 0x56, 0x44, 0x53, 0xcf, 0xac,
0x7e, 0xf8, 0xf9, 0x07, 0x3d, 0xd3, 0x3b, 0x18, 0x3d, 0x23, 0xbb, 0xbf, 0xcb, 0x86, 0xbe, 0x67,
0xda, 0xfc, 0xd7, 0x5d, 0x9f, 0xdd, 0xef, 0xd2, 0xd9, 0xee, 0x92, 0xd9, 0x86, 0xcf, 0x9e, 0x95,
0x68, 0xeb, 0xc3, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0x47, 0x64, 0xb9, 0xa5, 0xa9, 0x55, 0x00,
0x00,
0x16, 0x41, 0x80, 0x1c, 0x93, 0x5b, 0x92, 0x7b, 0xfe, 0x81, 0xa0, 0x3e, 0xba, 0xfa, 0xab, 0x9a,
0x6c, 0x91, 0xf6, 0x78, 0x91, 0xdc, 0x58, 0xd5, 0xaf, 0xaa, 0x5e, 0xbd, 0x7a, 0xdf, 0xaf, 0x8a,
0xd0, 0x30, 0x74, 0x4f, 0xef, 0x74, 0x6d, 0xdb, 0x31, 0xee, 0x0c, 0x1d, 0xdb, 0xb3, 0xd1, 0xe2,
0xc0, 0xec, 0x1f, 0x8d, 0x5c, 0xd6, 0xba, 0x43, 0x3e, 0xb7, 0x6a, 0x5d, 0x7b, 0x30, 0xb0, 0x2d,
0xd6, 0xd5, 0xaa, 0x9b, 0x96, 0x87, 0x1d, 0x4b, 0xef, 0xf3, 0x76, 0x2d, 0x3c, 0xa0, 0x55, 0x73,
0xbb, 0x07, 0x78, 0xa0, 0xb3, 0x96, 0x3a, 0x07, 0xc5, 0x87, 0x83, 0xa1, 0x77, 0xa2, 0xfe, 0xad,
0x02, 0xb5, 0x8d, 0xfe, 0xc8, 0x3d, 0xd0, 0xf0, 0xf3, 0x11, 0x76, 0x3d, 0xf4, 0x3e, 0x14, 0x9e,
0xe9, 0x2e, 0x6e, 0x2a, 0x57, 0x95, 0x9b, 0xd5, 0x95, 0x8b, 0x77, 0x22, 0xab, 0xf2, 0xf5, 0xb6,
0xdc, 0xde, 0xaa, 0xee, 0x62, 0x8d, 0x42, 0x22, 0x04, 0x05, 0xe3, 0x59, 0x7b, 0xbd, 0x99, 0xbb,
0xaa, 0xdc, 0xcc, 0x6b, 0xf4, 0x37, 0xba, 0x0c, 0xe0, 0xe2, 0xde, 0x00, 0x5b, 0x5e, 0x7b, 0xdd,
0x6d, 0xe6, 0xaf, 0xe6, 0x6f, 0xe6, 0xb5, 0x50, 0x0f, 0x52, 0xa1, 0xd6, 0xb5, 0xfb, 0x7d, 0xdc,
0xf5, 0x4c, 0xdb, 0x6a, 0xaf, 0x37, 0x0b, 0x74, 0x6c, 0xa4, 0x0f, 0xb5, 0xa0, 0x6c, 0xba, 0xed,
0xc1, 0xd0, 0x76, 0xbc, 0x66, 0xf1, 0xaa, 0x72, 0xb3, 0xac, 0x89, 0xb6, 0xfa, 0x1f, 0x0a, 0xcc,
0x73, 0xb4, 0xdd, 0xa1, 0x6d, 0xb9, 0x18, 0x7d, 0x08, 0x25, 0xd7, 0xd3, 0xbd, 0x91, 0xcb, 0x31,
0xbf, 0x20, 0xc5, 0x7c, 0x97, 0x82, 0x68, 0x1c, 0x54, 0x8a, 0x7a, 0x1c, 0xb5, 0xbc, 0x04, 0xb5,
0xe8, 0xf6, 0x0a, 0x89, 0xed, 0xdd, 0x84, 0x85, 0x7d, 0x82, 0xdd, 0x6e, 0x00, 0x54, 0xa4, 0x40,
0xf1, 0x6e, 0x32, 0x93, 0x67, 0x0e, 0xf0, 0x37, 0xf7, 0x77, 0xb1, 0xde, 0x6f, 0x96, 0xe8, 0x5a,
0xa1, 0x1e, 0xf5, 0x9f, 0x15, 0x68, 0x08, 0x70, 0xff, 0x8c, 0xce, 0x41, 0xb1, 0x6b, 0x8f, 0x2c,
0x8f, 0x6e, 0x75, 0x5e, 0x63, 0x0d, 0xf4, 0x26, 0xd4, 0xba, 0x07, 0xba, 0x65, 0xe1, 0x7e, 0xc7,
0xd2, 0x07, 0x98, 0x6e, 0xaa, 0xa2, 0x55, 0x79, 0xdf, 0xb6, 0x3e, 0xc0, 0x99, 0xf6, 0x76, 0x15,
0xaa, 0x43, 0xdd, 0xf1, 0xcc, 0xc8, 0xc9, 0x84, 0xbb, 0xc6, 0x1d, 0x0c, 0x59, 0xc1, 0xa4, 0xbf,
0xf6, 0x74, 0xf7, 0xb0, 0xbd, 0xce, 0x77, 0x14, 0xe9, 0x53, 0xff, 0x5c, 0x81, 0xa5, 0x07, 0xae,
0x6b, 0xf6, 0xac, 0xc4, 0xce, 0x96, 0xa0, 0x64, 0xd9, 0x06, 0x6e, 0xaf, 0xd3, 0xad, 0xe5, 0x35,
0xde, 0x42, 0x17, 0xa0, 0x32, 0xc4, 0xd8, 0xe9, 0x38, 0x76, 0xdf, 0xdf, 0x58, 0x99, 0x74, 0x68,
0x76, 0x1f, 0xa3, 0x6f, 0xc1, 0xa2, 0x1b, 0x9b, 0x88, 0xf1, 0x5c, 0x75, 0xe5, 0xda, 0x9d, 0x84,
0xd4, 0xdc, 0x89, 0x2f, 0xaa, 0x25, 0x47, 0xab, 0x5f, 0xe4, 0xe0, 0xac, 0x80, 0x63, 0xb8, 0x92,
0xdf, 0x84, 0xf2, 0x2e, 0xee, 0x09, 0xf4, 0x58, 0x23, 0x0b, 0xe5, 0xc5, 0x91, 0xe5, 0xc3, 0x47,
0x96, 0x45, 0x0c, 0x62, 0xe7, 0x51, 0x4c, 0x9e, 0xc7, 0x15, 0xa8, 0xe2, 0x17, 0x43, 0xd3, 0xc1,
0x1d, 0xc2, 0x38, 0x94, 0xe4, 0x05, 0x0d, 0x58, 0xd7, 0x9e, 0x39, 0x08, 0xcb, 0xc6, 0x5c, 0x66,
0xd9, 0x50, 0xff, 0x42, 0x81, 0xe5, 0xc4, 0x29, 0x71, 0x61, 0xd3, 0xa0, 0x41, 0x77, 0x1e, 0x50,
0x86, 0x88, 0x1d, 0x21, 0xf8, 0x5b, 0xe3, 0x08, 0x1e, 0x80, 0x6b, 0x89, 0xf1, 0x21, 0x24, 0x73,
0xd9, 0x91, 0x3c, 0x84, 0xe5, 0x47, 0xd8, 0xe3, 0x0b, 0x90, 0x6f, 0xd8, 0x9d, 0x5e, 0x91, 0x45,
0xa5, 0x3a, 0x17, 0x97, 0x6a, 0xf5, 0x6f, 0x72, 0x42, 0x16, 0xe9, 0x52, 0x6d, 0x6b, 0xdf, 0x46,
0x17, 0xa1, 0x22, 0x40, 0x38, 0x57, 0x04, 0x1d, 0xe8, 0x6b, 0x50, 0x24, 0x98, 0x32, 0x96, 0xa8,
0xaf, 0xbc, 0x29, 0xdf, 0x53, 0x68, 0x4e, 0x8d, 0xc1, 0xa3, 0x36, 0xd4, 0x5d, 0x4f, 0x77, 0xbc,
0xce, 0xd0, 0x76, 0xe9, 0x39, 0x53, 0xc6, 0xa9, 0xae, 0xa8, 0xd1, 0x19, 0x84, 0xca, 0xdf, 0x72,
0x7b, 0x3b, 0x1c, 0x52, 0x9b, 0xa7, 0x23, 0xfd, 0x26, 0x7a, 0x08, 0x35, 0x6c, 0x19, 0xc1, 0x44,
0x85, 0xcc, 0x13, 0x55, 0xb1, 0x65, 0x88, 0x69, 0x82, 0xf3, 0x29, 0x66, 0x3f, 0x9f, 0xdf, 0x53,
0xa0, 0x99, 0x3c, 0xa0, 0x59, 0x54, 0xf6, 0x7d, 0x36, 0x08, 0xb3, 0x03, 0x1a, 0x2b, 0xe1, 0xe2,
0x90, 0x34, 0x3e, 0x44, 0xfd, 0x63, 0x05, 0xde, 0x08, 0xd0, 0xa1, 0x9f, 0x5e, 0x15, 0xb7, 0xa0,
0x5b, 0xd0, 0x30, 0xad, 0x6e, 0x7f, 0x64, 0xe0, 0xc7, 0xd6, 0x67, 0x58, 0xef, 0x7b, 0x07, 0x27,
0xf4, 0x0c, 0xcb, 0x5a, 0xa2, 0x5f, 0xfd, 0xb7, 0x1c, 0x2c, 0xc5, 0xf1, 0x9a, 0x85, 0x48, 0xff,
0x0f, 0x8a, 0xa6, 0xb5, 0x6f, 0xfb, 0x34, 0xba, 0x3c, 0x46, 0x28, 0xc9, 0x5a, 0x0c, 0x18, 0xd9,
0x80, 0x7c, 0x35, 0xd6, 0x3d, 0xc0, 0xdd, 0xc3, 0xa1, 0x6d, 0x52, 0x85, 0x45, 0xa6, 0xf8, 0x25,
0xc9, 0x14, 0x72, 0x8c, 0xef, 0xac, 0xb1, 0x39, 0xd6, 0xc4, 0x14, 0x0f, 0x2d, 0xcf, 0x39, 0xd1,
0x16, 0xbb, 0xf1, 0xfe, 0xd6, 0x01, 0x2c, 0xc9, 0x81, 0x51, 0x03, 0xf2, 0x87, 0xf8, 0x84, 0x6e,
0xb9, 0xa2, 0x91, 0x9f, 0xe8, 0x1e, 0x14, 0x8f, 0xf4, 0xfe, 0x08, 0x73, 0xed, 0x90, 0x85, 0x7d,
0xd9, 0x80, 0x8f, 0x73, 0xf7, 0x14, 0xf5, 0x87, 0x0a, 0x2c, 0x6f, 0x9a, 0xae, 0x8f, 0xaf, 0xfb,
0x8b, 0x73, 0xf4, 0xbf, 0xad, 0x40, 0x33, 0x89, 0xd9, 0x57, 0x7e, 0xf8, 0xea, 0x00, 0x2e, 0x3c,
0xc2, 0x5e, 0xdb, 0x72, 0xb1, 0xe3, 0xad, 0x9a, 0x56, 0xdf, 0xee, 0xed, 0xe8, 0xde, 0xc1, 0x0c,
0xda, 0x34, 0xa2, 0x18, 0x73, 0x31, 0xc5, 0xa8, 0xfe, 0x48, 0x81, 0x8b, 0xf2, 0xf5, 0xf8, 0xd6,
0x5b, 0x50, 0xde, 0x37, 0x71, 0xdf, 0x20, 0x14, 0x56, 0x28, 0x85, 0x45, 0x9b, 0x68, 0xd5, 0x21,
0x01, 0xe6, 0x3b, 0x7c, 0x33, 0x85, 0x17, 0x76, 0x3d, 0xc7, 0xb4, 0x7a, 0x84, 0xb8, 0x1a, 0x83,
0x0f, 0xd1, 0x33, 0x9f, 0x5d, 0x87, 0xfd, 0xae, 0x02, 0x97, 0x1f, 0x61, 0x6f, 0x4d, 0x18, 0x65,
0xf2, 0xdd, 0x74, 0x3d, 0xb3, 0xeb, 0xbe, 0x5c, 0xa7, 0x39, 0x83, 0x77, 0xa6, 0xfe, 0x40, 0x81,
0x2b, 0xa9, 0xc8, 0x70, 0xd2, 0x71, 0xa3, 0xe3, 0x9b, 0x64, 0xb9, 0xd1, 0xf9, 0x15, 0x7c, 0xf2,
0x84, 0x88, 0xc7, 0x8e, 0x6e, 0x3a, 0xcc, 0xe8, 0x4c, 0x69, 0x82, 0x7f, 0xa2, 0xc0, 0xa5, 0x47,
0xd8, 0xdb, 0xf1, 0x1d, 0x92, 0xd7, 0x48, 0x1d, 0x02, 0x13, 0x72, 0x8c, 0x7c, 0xcf, 0x3c, 0xd2,
0xa7, 0xfe, 0x3e, 0x3b, 0x4e, 0x29, 0xbe, 0xaf, 0x85, 0x80, 0x97, 0xa9, 0x24, 0x84, 0x44, 0x92,
0xeb, 0x44, 0x4e, 0x3e, 0xf5, 0xcf, 0x14, 0x38, 0xff, 0xa0, 0xfb, 0x7c, 0x64, 0x3a, 0x98, 0x03,
0x6d, 0xda, 0xdd, 0xc3, 0xe9, 0x89, 0x1b, 0xf8, 0xd8, 0xb9, 0x88, 0x8f, 0x3d, 0x29, 0x66, 0x5b,
0x82, 0x92, 0xc7, 0x9c, 0x7a, 0xe6, 0xa6, 0xf2, 0x16, 0xc5, 0x4f, 0xc3, 0x7d, 0xac, 0xbb, 0xbf,
0x98, 0xf8, 0xfd, 0xa0, 0x00, 0xb5, 0x27, 0xdc, 0xf8, 0x50, 0x97, 0x2d, 0xce, 0x49, 0x8a, 0xdc,
0xeb, 0x0e, 0xb9, 0xef, 0x32, 0x8f, 0xfe, 0x11, 0xcc, 0xbb, 0x18, 0x1f, 0x4e, 0xe3, 0xa0, 0xd5,
0xc8, 0x40, 0xe1, 0x58, 0x6d, 0xc2, 0xe2, 0xc8, 0xa2, 0x71, 0x21, 0x36, 0x7c, 0x2b, 0x40, 0x39,
0x77, 0xb2, 0xee, 0x4e, 0x0e, 0x44, 0x9f, 0xf1, 0xd0, 0x33, 0x34, 0x57, 0x31, 0xd3, 0x5c, 0xf1,
0x61, 0xa8, 0x0d, 0x0d, 0xc3, 0xb1, 0x87, 0x43, 0x6c, 0x74, 0x5c, 0x7f, 0xaa, 0x52, 0xb6, 0xa9,
0xf8, 0x38, 0x31, 0xd5, 0xfb, 0x70, 0x36, 0x8e, 0x69, 0xdb, 0x20, 0xd1, 0x08, 0x39, 0x43, 0xd9,
0x27, 0x74, 0x1b, 0x16, 0x93, 0xf0, 0x65, 0x0a, 0x9f, 0xfc, 0x80, 0xde, 0x03, 0x14, 0x43, 0x95,
0x80, 0x57, 0x18, 0x78, 0x14, 0x99, 0xb6, 0xe1, 0xaa, 0xdf, 0x57, 0x60, 0xe9, 0xa9, 0xee, 0x75,
0x0f, 0xd6, 0x07, 0x5c, 0xd6, 0x66, 0xd0, 0x55, 0x9f, 0x40, 0xe5, 0x88, 0xf3, 0x85, 0x6f, 0x90,
0xae, 0x48, 0xe8, 0x13, 0xe6, 0x40, 0x2d, 0x18, 0x41, 0x82, 0xe1, 0x73, 0x1b, 0xa1, 0xa4, 0xc0,
0x6b, 0xd0, 0x9a, 0x13, 0xb2, 0x19, 0xea, 0x0b, 0x00, 0x8e, 0xdc, 0x96, 0xdb, 0x9b, 0x02, 0xaf,
0x7b, 0x30, 0xc7, 0x67, 0xe3, 0x6a, 0x71, 0x12, 0xff, 0xf8, 0xe0, 0xea, 0x8f, 0x4b, 0x50, 0x0d,
0x7d, 0x40, 0x75, 0xc8, 0x09, 0x79, 0xcd, 0x49, 0x76, 0x97, 0x9b, 0x1c, 0x3f, 0xe7, 0x93, 0xf1,
0xf3, 0x0d, 0xa8, 0x9b, 0xd4, 0x0f, 0xe9, 0xf0, 0x53, 0xa1, 0x0a, 0xa4, 0xa2, 0xcd, 0xb3, 0x5e,
0xce, 0x22, 0xe8, 0x32, 0x54, 0xad, 0xd1, 0xa0, 0x63, 0xef, 0x77, 0x1c, 0xfb, 0xd8, 0xe5, 0x81,
0x78, 0xc5, 0x1a, 0x0d, 0xbe, 0xb9, 0xaf, 0xd9, 0xc7, 0x6e, 0x10, 0xeb, 0x95, 0x4e, 0x19, 0xeb,
0x5d, 0x86, 0xea, 0x40, 0x7f, 0x41, 0x66, 0xed, 0x58, 0xa3, 0x01, 0x8d, 0xd1, 0xf3, 0x5a, 0x65,
0xa0, 0xbf, 0xd0, 0xec, 0xe3, 0xed, 0xd1, 0x00, 0xdd, 0x84, 0x46, 0x5f, 0x77, 0xbd, 0x4e, 0x38,
0xc8, 0x2f, 0xd3, 0x20, 0xbf, 0x4e, 0xfa, 0x1f, 0x06, 0x81, 0x7e, 0x32, 0x6a, 0xac, 0xcc, 0x10,
0x35, 0x1a, 0x83, 0x7e, 0x30, 0x11, 0x64, 0x8f, 0x1a, 0x8d, 0x41, 0x5f, 0x4c, 0x73, 0x0f, 0xe6,
0x9e, 0x51, 0xef, 0xce, 0x6d, 0x56, 0x53, 0x75, 0xc7, 0x06, 0x71, 0xec, 0x98, 0x13, 0xa8, 0xf9,
0xe0, 0xe8, 0xeb, 0x50, 0xa1, 0x46, 0x95, 0x8e, 0xad, 0x65, 0x1a, 0x1b, 0x0c, 0x20, 0xa3, 0x0d,
0xdc, 0xf7, 0x74, 0x3a, 0x7a, 0x3e, 0xdb, 0x68, 0x31, 0x80, 0xe8, 0xab, 0xae, 0x83, 0x75, 0x0f,
0x1b, 0xab, 0x27, 0x6b, 0xf6, 0x60, 0xa8, 0x53, 0x66, 0x6a, 0xd6, 0xa9, 0x0f, 0x2f, 0xfb, 0x84,
0xde, 0x82, 0x7a, 0x57, 0xb4, 0x36, 0x1c, 0x7b, 0xd0, 0x5c, 0xa0, 0x72, 0x14, 0xeb, 0x45, 0x97,
0x00, 0x7c, 0x4d, 0xa5, 0x7b, 0xcd, 0x06, 0x3d, 0xc5, 0x0a, 0xef, 0x79, 0x40, 0x73, 0x78, 0xa6,
0xdb, 0x61, 0xd9, 0x32, 0xd3, 0xea, 0x35, 0x17, 0xe9, 0x8a, 0x55, 0x3f, 0xbd, 0x66, 0x5a, 0x3d,
0xb4, 0x0c, 0x73, 0xa6, 0xdb, 0xd9, 0xd7, 0x0f, 0x71, 0x13, 0xd1, 0xaf, 0x25, 0xd3, 0xdd, 0xd0,
0x0f, 0xb1, 0xfa, 0x3d, 0x38, 0x17, 0x70, 0x57, 0xe8, 0x24, 0x93, 0x4c, 0xa1, 0x4c, 0xcb, 0x14,
0xe3, 0x7d, 0xfa, 0x9f, 0x17, 0x60, 0x69, 0x57, 0x3f, 0xc2, 0xaf, 0x3e, 0x7c, 0xc8, 0xa4, 0xd6,
0x36, 0x61, 0x91, 0x46, 0x0c, 0x2b, 0x21, 0x7c, 0xc6, 0xd8, 0xd5, 0x30, 0x2b, 0x24, 0x07, 0xa2,
0x6f, 0x10, 0x87, 0x00, 0x77, 0x0f, 0x77, 0x48, 0x90, 0xea, 0xdb, 0xd4, 0x4b, 0x92, 0x79, 0xd6,
0x04, 0x94, 0x16, 0x1e, 0x81, 0x76, 0x60, 0x21, 0x7a, 0x0c, 0xbe, 0x35, 0x7d, 0x7b, 0x6c, 0x06,
0x23, 0xa0, 0xbe, 0x56, 0x8f, 0x1c, 0x86, 0x8b, 0x9a, 0x30, 0xc7, 0x4d, 0x21, 0xd5, 0x19, 0x65,
0xcd, 0x6f, 0xa2, 0x1d, 0x38, 0xcb, 0x76, 0xb0, 0xcb, 0x05, 0x82, 0x6d, 0xbe, 0x9c, 0x69, 0xf3,
0xb2, 0xa1, 0x51, 0x79, 0xaa, 0x9c, 0x56, 0x9e, 0x9a, 0x30, 0xc7, 0x79, 0x9c, 0xea, 0x91, 0xb2,
0xe6, 0x37, 0xc9, 0x31, 0x07, 0xdc, 0x5e, 0xa5, 0xdf, 0x82, 0x0e, 0x12, 0x7a, 0x41, 0x40, 0xcf,
0x09, 0xb9, 0xb6, 0x4f, 0xa1, 0x2c, 0x38, 0x3c, 0x7b, 0x92, 0x40, 0x8c, 0x89, 0xeb, 0xf7, 0x7c,
0x4c, 0xbf, 0xab, 0xff, 0xa4, 0x40, 0x6d, 0x9d, 0x6c, 0x69, 0xd3, 0xee, 0x51, 0x6b, 0x74, 0x03,
0xea, 0x0e, 0xee, 0xda, 0x8e, 0xd1, 0xc1, 0x96, 0xe7, 0x98, 0x98, 0x45, 0xe9, 0x05, 0x6d, 0x9e,
0xf5, 0x3e, 0x64, 0x9d, 0x04, 0x8c, 0xa8, 0x6c, 0xd7, 0xd3, 0x07, 0xc3, 0xce, 0x3e, 0x51, 0x0d,
0x39, 0x06, 0x26, 0x7a, 0xa9, 0x66, 0x78, 0x13, 0x6a, 0x01, 0x98, 0x67, 0xd3, 0xf5, 0x0b, 0x5a,
0x55, 0xf4, 0xed, 0xd9, 0xe8, 0x3a, 0xd4, 0x29, 0x4d, 0x3b, 0x7d, 0xbb, 0xd7, 0x21, 0x11, 0x2d,
0x37, 0x54, 0x35, 0x83, 0xa3, 0x45, 0xce, 0x2a, 0x0a, 0xe5, 0x9a, 0xdf, 0xc5, 0xdc, 0x54, 0x09,
0xa8, 0x5d, 0xf3, 0xbb, 0x58, 0xfd, 0x47, 0x05, 0xe6, 0xd7, 0x75, 0x4f, 0xdf, 0xb6, 0x0d, 0xbc,
0x37, 0xa5, 0x61, 0xcf, 0x90, 0xf7, 0xbe, 0x08, 0x15, 0xb1, 0x03, 0xbe, 0xa5, 0xa0, 0x03, 0x6d,
0x40, 0xdd, 0x77, 0x2d, 0x3b, 0x2c, 0xe2, 0x2a, 0xa4, 0x3a, 0x50, 0x21, 0xcb, 0xe9, 0x6a, 0xf3,
0xfe, 0x30, 0xda, 0x54, 0x37, 0xa0, 0x16, 0xfe, 0x4c, 0x56, 0xdd, 0x8d, 0x33, 0x8a, 0xe8, 0x20,
0xdc, 0xb8, 0x3d, 0x1a, 0x90, 0x33, 0xe5, 0x8a, 0xc5, 0x6f, 0xaa, 0xbf, 0xa5, 0xc0, 0x3c, 0x37,
0xf7, 0xbb, 0xa2, 0x42, 0x44, 0xb7, 0xc6, 0x32, 0x51, 0xf4, 0x37, 0xfa, 0x38, 0x9a, 0xd4, 0xbd,
0x2e, 0x55, 0x02, 0x74, 0x12, 0xea, 0x64, 0x46, 0x6c, 0x7d, 0x96, 0x18, 0xff, 0x0b, 0xc2, 0x68,
0xfc, 0x68, 0x28, 0xa3, 0x35, 0x61, 0x4e, 0x37, 0x0c, 0x07, 0xbb, 0x2e, 0xc7, 0xc3, 0x6f, 0x92,
0x2f, 0x47, 0xd8, 0x71, 0x7d, 0x96, 0xcf, 0x6b, 0x7e, 0x13, 0x7d, 0x1d, 0xca, 0xc2, 0x2b, 0x65,
0x29, 0xbc, 0xab, 0xe9, 0x78, 0xf2, 0x88, 0x54, 0x8c, 0x50, 0x7f, 0x96, 0x83, 0x3a, 0x27, 0xd8,
0x2a, 0xb7, 0xc7, 0xe3, 0x85, 0x6f, 0x15, 0x6a, 0xfb, 0x81, 0xec, 0x8f, 0xcb, 0x3d, 0x85, 0x55,
0x44, 0x64, 0xcc, 0x24, 0x01, 0x8c, 0x7a, 0x04, 0x85, 0x99, 0x3c, 0x82, 0xe2, 0x69, 0x35, 0x58,
0xd2, 0x47, 0x2c, 0x49, 0x7c, 0x44, 0xf5, 0xd7, 0xa0, 0x1a, 0x9a, 0x80, 0x6a, 0x68, 0x96, 0xb4,
0xe2, 0x14, 0xf3, 0x9b, 0xe8, 0xc3, 0xc0, 0x2f, 0x62, 0xa4, 0x3a, 0x2f, 0xc1, 0x25, 0xe6, 0x12,
0xa9, 0x7f, 0xaf, 0x40, 0x89, 0xcf, 0x7c, 0x05, 0xaa, 0x5c, 0xe9, 0x50, 0x9f, 0x91, 0xcd, 0x0e,
0xbc, 0x8b, 0x38, 0x8d, 0x2f, 0x4f, 0xeb, 0x9c, 0x87, 0x72, 0x4c, 0xdf, 0xcc, 0x71, 0xb3, 0xe0,
0x7f, 0x0a, 0x29, 0x19, 0xf2, 0x89, 0xe8, 0x17, 0x74, 0x0e, 0x8a, 0x7d, 0xbb, 0x27, 0x2a, 0x80,
0xac, 0xa1, 0x7e, 0xa9, 0xd0, 0x82, 0x8d, 0x86, 0xbb, 0xf6, 0x11, 0x76, 0x4e, 0x66, 0x4f, 0x76,
0xde, 0x0f, 0xb1, 0x79, 0xc6, 0xe0, 0x4b, 0x0c, 0x40, 0xf7, 0x83, 0x43, 0xc8, 0xcb, 0x32, 0x3d,
0x61, 0xbd, 0xc3, 0x99, 0x34, 0x38, 0x8c, 0x3f, 0x50, 0x68, 0xce, 0x3e, 0xba, 0x95, 0x69, 0xbd,
0x9d, 0x97, 0x12, 0xc8, 0xa8, 0xff, 0xa0, 0xc0, 0xf9, 0x14, 0xea, 0x3e, 0x59, 0x79, 0x0d, 0xf4,
0xfd, 0x18, 0xca, 0x22, 0x73, 0x90, 0xcf, 0x94, 0x39, 0x10, 0xf0, 0xea, 0x1f, 0xb1, 0xca, 0x91,
0x84, 0xbc, 0x4f, 0x56, 0x5e, 0x11, 0x81, 0xe3, 0xd9, 0xc3, 0xbc, 0x24, 0x7b, 0xf8, 0x73, 0x05,
0x5a, 0x41, 0xb6, 0xce, 0x5d, 0x3d, 0x99, 0xb5, 0xe8, 0xf8, 0x72, 0x42, 0xd8, 0xff, 0x2f, 0xaa,
0x62, 0x44, 0x2f, 0x66, 0x0a, 0x3e, 0xfd, 0x9a, 0x98, 0x45, 0x13, 0xff, 0xc9, 0x0d, 0xcd, 0x22,
0x95, 0xad, 0xd0, 0xc1, 0xb3, 0xf2, 0x48, 0x70, 0xb0, 0xff, 0xce, 0x98, 0x74, 0x23, 0x9a, 0x6d,
0x7a, 0xdd, 0x04, 0x0c, 0x97, 0x6c, 0x0e, 0x78, 0xc9, 0xa6, 0x10, 0x2b, 0xd9, 0xf0, 0x7e, 0xff,
0xce, 0xc6, 0x2a, 0xde, 0xb7, 0x1d, 0xa6, 0xf7, 0x0a, 0x5a, 0xa8, 0x47, 0x1d, 0x50, 0x16, 0x49,
0x6c, 0xf0, 0x55, 0x11, 0xf4, 0x77, 0x14, 0x68, 0xf2, 0x55, 0xe8, 0x9a, 0x24, 0x2a, 0xed, 0x63,
0x0f, 0x1b, 0x5f, 0x75, 0xb6, 0xe6, 0x4f, 0x72, 0xd0, 0x08, 0x3b, 0x3e, 0xd4, 0x77, 0xf9, 0x08,
0x8a, 0x34, 0xd9, 0xc5, 0x31, 0x98, 0xa8, 0x3d, 0x18, 0x34, 0xb1, 0x9c, 0x34, 0xda, 0xd9, 0x13,
0x3e, 0x1a, 0x6f, 0x06, 0xde, 0x57, 0xfe, 0xf4, 0xde, 0x17, 0xf7, 0x46, 0xed, 0x11, 0x99, 0x97,
0x65, 0x89, 0x83, 0x0e, 0xf4, 0x09, 0x94, 0xd8, 0x25, 0x29, 0x5e, 0xe1, 0xbe, 0x11, 0x9d, 0x9a,
0x5f, 0xa0, 0x0a, 0x95, 0x5e, 0x68, 0x87, 0xc6, 0x07, 0x91, 0x33, 0x1a, 0x3a, 0x76, 0x8f, 0xba,
0x69, 0xc4, 0xe8, 0x15, 0x35, 0xd1, 0x56, 0x7f, 0x19, 0x96, 0x82, 0x64, 0x01, 0x43, 0x69, 0x5a,
0x86, 0x57, 0xff, 0x55, 0x81, 0xb3, 0xbb, 0x27, 0x56, 0x37, 0x2e, 0x3a, 0x4b, 0x50, 0x1a, 0xf6,
0xf5, 0x20, 0xa1, 0xcd, 0x5b, 0xd4, 0x4b, 0x67, 0x6b, 0x63, 0x83, 0x98, 0x78, 0x46, 0xcf, 0xaa,
0xe8, 0xdb, 0xb3, 0x27, 0x7a, 0x5e, 0x37, 0x44, 0x76, 0x03, 0x1b, 0xcc, 0x99, 0x60, 0x59, 0xc2,
0x79, 0xd1, 0x4b, 0x9d, 0x89, 0x4f, 0x00, 0xa8, 0xbf, 0xd5, 0x39, 0x8d, 0x8f, 0x45, 0x47, 0x6c,
0x12, 0x8b, 0xfa, 0xd3, 0x1c, 0x34, 0x43, 0x54, 0xfa, 0xaa, 0xdd, 0xcf, 0x94, 0xa0, 0x39, 0xff,
0x92, 0x82, 0xe6, 0xc2, 0xec, 0x2e, 0x67, 0x51, 0xe6, 0x72, 0xfe, 0x46, 0x1e, 0xea, 0x01, 0xd5,
0x76, 0xfa, 0xba, 0x95, 0xca, 0x09, 0xbb, 0x22, 0xdc, 0x8a, 0xd2, 0xe9, 0x5d, 0x99, 0x0c, 0xa5,
0x1c, 0x84, 0x16, 0x9b, 0x02, 0x5d, 0xa2, 0x87, 0xee, 0x78, 0x2c, 0x2f, 0xc9, 0x43, 0x3c, 0x26,
0xac, 0xe6, 0x00, 0xa3, 0xdb, 0x80, 0xb8, 0x84, 0x75, 0x4c, 0xab, 0xe3, 0xe2, 0xae, 0x6d, 0x19,
0x4c, 0xf6, 0x8a, 0x5a, 0x83, 0x7f, 0x69, 0x5b, 0xbb, 0xac, 0x1f, 0x7d, 0x04, 0x05, 0xef, 0x64,
0xc8, 0x94, 0x6a, 0x5d, 0xea, 0x8e, 0x05, 0x78, 0xed, 0x9d, 0x0c, 0xb1, 0x46, 0xc1, 0x7d, 0x8d,
0xec, 0x39, 0xfa, 0x11, 0xf7, 0xcc, 0xb9, 0x46, 0x66, 0x3d, 0x44, 0x9b, 0xf8, 0x34, 0x9c, 0x63,
0x1e, 0x2c, 0x6f, 0x32, 0xce, 0xf6, 0x05, 0xba, 0xe3, 0x79, 0x7d, 0x9a, 0x59, 0xa5, 0x9c, 0xed,
0xf7, 0xee, 0x79, 0x7d, 0xb2, 0x49, 0xcf, 0xf6, 0xf4, 0x3e, 0x93, 0x8f, 0x0a, 0xd7, 0x1c, 0xa4,
0x87, 0xc6, 0x8d, 0xff, 0x42, 0x34, 0x9f, 0x40, 0x4c, 0xc3, 0xee, 0xa8, 0x9f, 0x2e, 0x8f, 0xe3,
0x33, 0x5b, 0x93, 0x44, 0xf1, 0x1b, 0x50, 0xe5, 0x5c, 0x71, 0x0a, 0xae, 0x02, 0x36, 0x64, 0x73,
0x0c, 0x9b, 0x17, 0x5f, 0x12, 0x9b, 0x97, 0xa6, 0xc8, 0x0d, 0xc9, 0xcf, 0x46, 0xfd, 0x91, 0x02,
0x6f, 0x24, 0xb4, 0xe6, 0x58, 0xd2, 0x8e, 0x8f, 0xcc, 0xb9, 0x36, 0x8d, 0x4f, 0xc9, 0x6d, 0xc3,
0x7d, 0x28, 0x39, 0x74, 0x76, 0x5e, 0xc8, 0xbb, 0x36, 0x96, 0xf9, 0x18, 0x22, 0x1a, 0x1f, 0xa2,
0xfe, 0xa1, 0x02, 0xcb, 0x49, 0x54, 0x67, 0x30, 0xf8, 0xab, 0x30, 0xc7, 0xa6, 0xf6, 0x65, 0xf4,
0xe6, 0x78, 0x19, 0x0d, 0x88, 0xa3, 0xf9, 0x03, 0xd5, 0x5d, 0x58, 0xf2, 0xfd, 0x82, 0x80, 0xf4,
0x5b, 0xd8, 0xd3, 0xc7, 0xc4, 0xa5, 0x57, 0xa0, 0xca, 0x02, 0x1c, 0x16, 0xef, 0xb1, 0x8c, 0x0e,
0x3c, 0x13, 0x89, 0x50, 0xf5, 0xbf, 0x14, 0x38, 0x47, 0x0d, 0x6b, 0xbc, 0x72, 0x96, 0xa5, 0xaa,
0xaa, 0x8a, 0x84, 0xd1, 0xb6, 0x3e, 0xe0, 0x57, 0xb8, 0x2a, 0x5a, 0xa4, 0x0f, 0xb5, 0x93, 0x79,
0x52, 0x69, 0xfe, 0x22, 0x28, 0xc3, 0xaf, 0xeb, 0x9e, 0x4e, 0xab, 0xf0, 0xf1, 0x04, 0x69, 0x60,
0xd0, 0x0b, 0x53, 0x18, 0x74, 0x75, 0x13, 0xde, 0x88, 0xed, 0x74, 0x86, 0x13, 0x55, 0xff, 0x52,
0x21, 0xc7, 0x11, 0xb9, 0x0a, 0x37, 0xbd, 0xd3, 0x7b, 0x49, 0x94, 0xec, 0x3a, 0xa6, 0x11, 0x57,
0x22, 0x06, 0xfa, 0x14, 0x2a, 0x16, 0x3e, 0xee, 0x84, 0xfd, 0xa4, 0x0c, 0x11, 0x41, 0xd9, 0xc2,
0xc7, 0xf4, 0x97, 0xba, 0x0d, 0xcb, 0x09, 0x54, 0x67, 0xd9, 0xfb, 0xdf, 0x29, 0x70, 0x7e, 0xdd,
0xb1, 0x87, 0x4f, 0x4c, 0xc7, 0x1b, 0xe9, 0xfd, 0xe8, 0x05, 0x87, 0x57, 0x93, 0x78, 0xfc, 0x2c,
0x11, 0x7b, 0xde, 0x96, 0x48, 0x50, 0x12, 0x29, 0xbe, 0xe9, 0x90, 0x7f, 0xfd, 0x9f, 0x79, 0x19,
0xf2, 0x1c, 0x6e, 0x82, 0x5f, 0x92, 0x25, 0x38, 0x91, 0xd6, 0x29, 0xf2, 0xd3, 0xd6, 0x29, 0x52,
0xd4, 0x7b, 0xe1, 0x25, 0xa9, 0xf7, 0x53, 0x27, 0xce, 0x3e, 0x83, 0x68, 0x0d, 0x89, 0x5a, 0xe7,
0xa9, 0x8a, 0x4f, 0xab, 0x00, 0x41, 0x3d, 0x85, 0xdf, 0x64, 0xce, 0x32, 0x4d, 0x68, 0x14, 0x39,
0x2d, 0x61, 0x4a, 0xb9, 0xa5, 0x0f, 0x65, 0xf8, 0xbf, 0x05, 0x2d, 0x19, 0x97, 0xce, 0xc2, 0xf9,
0x3f, 0xcd, 0x01, 0xb4, 0xc5, 0xe5, 0xf7, 0xe9, 0x6c, 0xc1, 0x35, 0x08, 0x79, 0x23, 0x81, 0xbc,
0x87, 0xb9, 0xc8, 0x20, 0x22, 0x21, 0xe2, 0x59, 0x02, 0x93, 0x88, 0x71, 0x0d, 0x3a, 0x4f, 0x48,
0x6a, 0x18, 0x53, 0xc4, 0xd5, 0xef, 0x05, 0xa8, 0x38, 0xf6, 0x71, 0x87, 0x88, 0x99, 0xe1, 0xdf,
0xee, 0x77, 0xec, 0x63, 0x22, 0x7c, 0x06, 0x5a, 0x86, 0x39, 0x4f, 0x77, 0x0f, 0xc9, 0xfc, 0xa5,
0xd0, 0x1d, 0x1b, 0x03, 0x9d, 0x83, 0xe2, 0xbe, 0xd9, 0xc7, 0xec, 0x4a, 0x47, 0x45, 0x63, 0x0d,
0xf4, 0x35, 0xff, 0x26, 0x62, 0x39, 0xf3, 0x3d, 0x2a, 0x76, 0x19, 0xf1, 0x4b, 0x05, 0x16, 0x02,
0xaa, 0x51, 0x05, 0x44, 0x74, 0x1a, 0xd5, 0x67, 0x6b, 0xb6, 0xc1, 0x54, 0x45, 0x3d, 0xc5, 0x22,
0xb0, 0x81, 0x4c, 0x6b, 0x05, 0x43, 0xc6, 0x85, 0xd0, 0x64, 0x5f, 0x64, 0xd3, 0xa6, 0xe1, 0x27,
0x7d, 0x4a, 0x8e, 0x7d, 0xdc, 0x36, 0x04, 0x35, 0xd8, 0xd5, 0x7d, 0x16, 0x30, 0x12, 0x6a, 0xac,
0xd1, 0xdb, 0xfb, 0xd7, 0x60, 0x1e, 0x3b, 0x8e, 0xed, 0x74, 0x06, 0xd8, 0x75, 0xf5, 0x1e, 0xe6,
0xfe, 0x79, 0x8d, 0x76, 0x6e, 0xb1, 0x3e, 0xf5, 0x87, 0x05, 0xa8, 0x07, 0x5b, 0xf1, 0x6f, 0x31,
0x98, 0x86, 0x7f, 0x8b, 0xc1, 0x24, 0x47, 0x07, 0x0e, 0x53, 0x85, 0xe2, 0x70, 0x57, 0x73, 0x4d,
0x45, 0xab, 0xf0, 0xde, 0xb6, 0x41, 0xcc, 0x32, 0x11, 0x32, 0xcb, 0x36, 0x70, 0x70, 0xb8, 0xe0,
0x77, 0xf1, 0xb3, 0x8d, 0xf0, 0x48, 0x21, 0x03, 0x8f, 0x14, 0x33, 0xf0, 0x48, 0x49, 0xc2, 0x23,
0x4b, 0x50, 0x7a, 0x36, 0xea, 0x1e, 0x62, 0x8f, 0x7b, 0x6c, 0xbc, 0x15, 0xe5, 0x9d, 0x72, 0x8c,
0x77, 0x04, 0x8b, 0x54, 0xc2, 0x2c, 0x72, 0x01, 0x2a, 0xac, 0x9c, 0xde, 0xf1, 0x5c, 0x5a, 0x1b,
0xcc, 0x6b, 0x65, 0xd6, 0xb1, 0xe7, 0xa2, 0x7b, 0xbe, 0x3b, 0x57, 0x95, 0x09, 0x3b, 0xd5, 0x3a,
0x31, 0x2e, 0xf1, 0x9d, 0xb9, 0xb7, 0x61, 0x21, 0x44, 0x0e, 0x6a, 0x23, 0x6a, 0x14, 0xd5, 0x90,
0xb7, 0x4f, 0xcd, 0xc4, 0x0d, 0xa8, 0x07, 0x24, 0xa1, 0x70, 0xf3, 0x2c, 0xc8, 0x12, 0xbd, 0x14,
0x4c, 0x70, 0x72, 0xfd, 0x74, 0x9c, 0x8c, 0xce, 0x43, 0x99, 0x47, 0x47, 0x6e, 0x73, 0x21, 0x92,
0xc8, 0x50, 0xbf, 0x03, 0x28, 0xc0, 0x7e, 0x36, 0x6f, 0x31, 0xc6, 0x1e, 0xb9, 0x38, 0x7b, 0xa8,
0x3f, 0x56, 0x60, 0x31, 0xbc, 0xd8, 0xb4, 0x86, 0xf7, 0x53, 0xa8, 0xb2, 0xea, 0x6c, 0x87, 0x08,
0x3e, 0x4f, 0x10, 0x5d, 0x1a, 0x7b, 0x2e, 0x1a, 0x04, 0x8f, 0x7f, 0x08, 0x7b, 0x1d, 0xdb, 0xce,
0xa1, 0x69, 0xf5, 0x3a, 0x04, 0x33, 0x91, 0x63, 0xe5, 0x9d, 0xdb, 0xa4, 0x4f, 0xfd, 0xbe, 0x02,
0x97, 0x1f, 0x0f, 0x0d, 0xdd, 0xc3, 0x21, 0x0f, 0x64, 0xd6, 0x2b, 0xa5, 0x1f, 0xf9, 0x77, 0x3a,
0x73, 0xd9, 0x2a, 0x8c, 0x0c, 0x5a, 0xfd, 0x6b, 0x81, 0x4b, 0xe2, 0xa6, 0xfa, 0xf4, 0xb8, 0xb4,
0xa0, 0x7c, 0xc4, 0xa7, 0xf3, 0x1f, 0x33, 0xf9, 0xed, 0x48, 0x15, 0x3b, 0x7f, 0xfa, 0x2a, 0xb6,
0xba, 0x05, 0xe7, 0x35, 0xec, 0x62, 0xcb, 0x88, 0xec, 0x66, 0xea, 0x64, 0xd3, 0x10, 0x5a, 0xb2,
0xe9, 0x66, 0x61, 0x56, 0xe6, 0xbb, 0x76, 0x1c, 0x32, 0xad, 0xc7, 0x55, 0x31, 0x71, 0x99, 0xe8,
0x3a, 0x9e, 0xfa, 0x57, 0x39, 0x58, 0x7e, 0x60, 0x18, 0x5c, 0x8b, 0x73, 0x6f, 0xec, 0x55, 0x39,
0xca, 0x71, 0x47, 0x32, 0x9f, 0x74, 0x24, 0x5f, 0x96, 0x66, 0xe5, 0x36, 0xc6, 0x1a, 0x0d, 0x7c,
0xdb, 0xe9, 0xb0, 0xeb, 0x5d, 0xf7, 0x79, 0x59, 0x93, 0x04, 0xf4, 0xd4, 0x7e, 0x4e, 0xf6, 0xaf,
0xca, 0x7e, 0xd2, 0x4c, 0x1d, 0x42, 0x33, 0x49, 0xac, 0x19, 0x55, 0x89, 0x4f, 0x91, 0xa1, 0xcd,
0x92, 0xaf, 0x35, 0xe2, 0x42, 0xd1, 0xae, 0x1d, 0xdb, 0x55, 0xff, 0x3b, 0x07, 0xcd, 0x5d, 0xfd,
0x08, 0xff, 0xdf, 0x39, 0xa0, 0xcf, 0xe1, 0x9c, 0xab, 0x1f, 0xe1, 0x4e, 0x28, 0x30, 0xee, 0x38,
0xf8, 0x39, 0x77, 0x41, 0xdf, 0x91, 0x69, 0x12, 0xe9, 0x2d, 0x28, 0x6d, 0xd1, 0x8d, 0xf4, 0x6b,
0xf8, 0x39, 0x7a, 0x0b, 0x16, 0xc2, 0xd7, 0xec, 0x08, 0x6a, 0x65, 0x4a, 0xf2, 0xf9, 0xd0, 0x2d,
0xba, 0xb6, 0xa1, 0x3e, 0x87, 0x8b, 0x8f, 0x2d, 0x17, 0x7b, 0xed, 0xe0, 0x26, 0xd8, 0x8c, 0x21,
0xe4, 0x15, 0xa8, 0x06, 0x84, 0x4f, 0xbc, 0x62, 0x31, 0x5c, 0xd5, 0x86, 0xd6, 0x96, 0xee, 0x1c,
0xfa, 0x69, 0xe6, 0x75, 0x76, 0x63, 0xe7, 0x15, 0x2e, 0xb8, 0x2f, 0x2e, 0xb0, 0x69, 0x78, 0x1f,
0x3b, 0xd8, 0xea, 0xe2, 0x4d, 0xbb, 0x7b, 0x18, 0xba, 0xd8, 0xad, 0x84, 0x2f, 0x76, 0x4f, 0x7b,
0x51, 0x5c, 0xfd, 0x49, 0x0e, 0x96, 0x1e, 0xf4, 0x3d, 0xec, 0x04, 0x91, 0xff, 0x69, 0x92, 0x18,
0x41, 0x56, 0x21, 0x37, 0x4d, 0x99, 0x20, 0x43, 0x95, 0x51, 0x96, 0x03, 0x29, 0x4c, 0x99, 0x03,
0x79, 0x00, 0x30, 0x74, 0xec, 0x21, 0x76, 0x3c, 0x13, 0xfb, 0xe1, 0x5b, 0x06, 0xf7, 0x25, 0x34,
0x48, 0xfd, 0x1c, 0x1a, 0x8f, 0xba, 0x6b, 0xb6, 0xb5, 0x6f, 0x3a, 0x03, 0x9f, 0x50, 0x09, 0xa1,
0x53, 0x32, 0x08, 0x5d, 0x2e, 0x21, 0x74, 0xaa, 0x09, 0x8b, 0xa1, 0xb9, 0x67, 0x54, 0x5c, 0xbd,
0x6e, 0x67, 0xdf, 0xb4, 0x4c, 0x7a, 0x23, 0x2e, 0x47, 0xdd, 0x4f, 0xe8, 0x75, 0x37, 0x78, 0xcf,
0xad, 0x4f, 0xc5, 0x5d, 0xe2, 0xbd, 0x93, 0x21, 0x46, 0x73, 0x90, 0xdf, 0xc6, 0xc7, 0x8d, 0x33,
0x08, 0xa0, 0xb4, 0x6d, 0x3b, 0x03, 0xbd, 0xdf, 0x50, 0x50, 0x15, 0xe6, 0x78, 0xdd, 0xae, 0x91,
0x43, 0xf3, 0x50, 0x59, 0xf3, 0xeb, 0x1b, 0x8d, 0xfc, 0xad, 0x3f, 0x55, 0x60, 0x31, 0x51, 0x59,
0x42, 0x75, 0x80, 0xc7, 0x56, 0x97, 0x97, 0xdc, 0x1a, 0x67, 0x50, 0x0d, 0xca, 0x7e, 0x01, 0x8e,
0xcd, 0xb7, 0x67, 0x53, 0xe8, 0x46, 0x0e, 0x35, 0xa0, 0xc6, 0x06, 0x8e, 0xba, 0x5d, 0xec, 0xba,
0x8d, 0xbc, 0xe8, 0xd9, 0xd0, 0xcd, 0xfe, 0xc8, 0xc1, 0x8d, 0x02, 0x59, 0x73, 0xcf, 0xe6, 0xaf,
0x29, 0x1a, 0x45, 0x84, 0xa0, 0xee, 0x3f, 0xad, 0xe0, 0x83, 0x4a, 0xa1, 0x3e, 0x7f, 0xd8, 0xdc,
0xad, 0xa7, 0xe1, 0x1a, 0x00, 0xdd, 0xde, 0x32, 0x9c, 0x7d, 0x6c, 0x19, 0x78, 0xdf, 0xb4, 0xb0,
0x11, 0x7c, 0x6a, 0x9c, 0x41, 0x67, 0x61, 0x61, 0x0b, 0x3b, 0x3d, 0x1c, 0xea, 0xcc, 0xa1, 0x45,
0x98, 0xdf, 0x32, 0x5f, 0x84, 0xba, 0xf2, 0x6a, 0xa1, 0xac, 0x34, 0x94, 0x95, 0x9f, 0x5d, 0x85,
0x0a, 0xe1, 0xad, 0x35, 0xdb, 0x76, 0x0c, 0xd4, 0x07, 0x44, 0x1f, 0x1f, 0x0d, 0x86, 0xb6, 0x25,
0xde, 0x73, 0xa2, 0x3b, 0xd1, 0xe3, 0xe1, 0x8d, 0x24, 0x20, 0xe7, 0x9d, 0xd6, 0x75, 0x29, 0x7c,
0x0c, 0x58, 0x3d, 0x83, 0x06, 0x74, 0xb5, 0x3d, 0x73, 0x80, 0xf7, 0xcc, 0xee, 0xa1, 0xef, 0x20,
0xbd, 0x9f, 0xe2, 0x0e, 0x25, 0x41, 0xfd, 0xf5, 0xae, 0x49, 0xd7, 0x63, 0xaf, 0xc3, 0x7c, 0x9e,
0x53, 0xcf, 0xa0, 0xe7, 0x70, 0xee, 0x11, 0x0e, 0xf9, 0x9a, 0xfe, 0x82, 0x2b, 0xe9, 0x0b, 0x26,
0x80, 0x4f, 0xb9, 0xe4, 0x26, 0x14, 0x29, 0xbb, 0x21, 0x99, 0x3b, 0x1a, 0xfe, 0x5b, 0x86, 0xd6,
0xd5, 0x74, 0x00, 0x31, 0xdb, 0x77, 0x60, 0x21, 0xf6, 0x60, 0x1b, 0xc9, 0x8c, 0x93, 0xfc, 0xe9,
0x7d, 0xeb, 0x56, 0x16, 0x50, 0xb1, 0x56, 0x0f, 0xea, 0xd1, 0x47, 0x4b, 0xe8, 0x66, 0x86, 0x17,
0xa2, 0x6c, 0xa5, 0x77, 0x32, 0xbf, 0x25, 0xa5, 0x4c, 0xd0, 0x88, 0x3f, 0x20, 0x46, 0xb7, 0xc6,
0x4e, 0x10, 0x65, 0xb6, 0x77, 0x33, 0xc1, 0x8a, 0xe5, 0x4e, 0x28, 0x13, 0x24, 0x9e, 0x25, 0xc6,
0x79, 0xdc, 0x9f, 0x26, 0xed, 0xbd, 0x64, 0xeb, 0x6e, 0x66, 0xf8, 0xf0, 0x4e, 0xe3, 0x0f, 0x41,
0xa5, 0x3b, 0x4d, 0x79, 0xc7, 0x2a, 0xdd, 0x69, 0xda, 0xcb, 0x52, 0xf5, 0x0c, 0xfa, 0x4d, 0x76,
0x15, 0x4b, 0xf6, 0x92, 0x10, 0x7d, 0x20, 0xc7, 0x7e, 0xcc, 0x13, 0xc8, 0xd6, 0xca, 0x69, 0x86,
0x08, 0x24, 0xbe, 0x47, 0xef, 0x50, 0x49, 0xde, 0xe2, 0xc5, 0xc5, 0xdc, 0x9f, 0x2f, 0xfd, 0x99,
0x61, 0xeb, 0x83, 0x53, 0x8c, 0x10, 0x08, 0xd8, 0xf1, 0x07, 0xe1, 0xbe, 0xd4, 0xdf, 0x9d, 0xc8,
0xa4, 0xd3, 0x89, 0xfc, 0xb7, 0x61, 0x21, 0xe6, 0x1d, 0xa2, 0xec, 0x1e, 0x64, 0x6b, 0x9c, 0x25,
0x64, 0x1a, 0x20, 0x76, 0x67, 0x0a, 0xa5, 0x08, 0x9b, 0xe4, 0x5e, 0x55, 0xeb, 0x56, 0x16, 0x50,
0xb1, 0x91, 0x21, 0x2c, 0xc6, 0x3e, 0x3e, 0x59, 0x41, 0xef, 0x66, 0x5e, 0xed, 0xc9, 0x4a, 0xeb,
0x76, 0xf6, 0xf5, 0x9e, 0xac, 0xa8, 0x67, 0x90, 0x4b, 0xed, 0x41, 0xec, 0x5e, 0x0d, 0x4a, 0x99,
0x45, 0x7e, 0xbf, 0xa8, 0xf5, 0x5e, 0x46, 0x68, 0xb1, 0xcd, 0x23, 0x38, 0x2b, 0xb9, 0x1e, 0x85,
0xde, 0x1b, 0xcb, 0x1e, 0xf1, 0x7b, 0x61, 0xad, 0x3b, 0x59, 0xc1, 0x43, 0xd6, 0xa8, 0xe1, 0xe3,
0xf5, 0xa0, 0xdf, 0x67, 0xbe, 0xc6, 0xed, 0x34, 0x43, 0x1b, 0x01, 0x4b, 0xd9, 0x6a, 0x2a, 0xb4,
0x58, 0xf2, 0xd7, 0x01, 0xed, 0x1e, 0xd8, 0xc7, 0xd4, 0x1b, 0xeb, 0x8d, 0x1c, 0x9d, 0x39, 0x90,
0x69, 0xf6, 0x36, 0x09, 0x9a, 0x22, 0x88, 0x63, 0x47, 0x88, 0xc5, 0x3b, 0x00, 0x8f, 0xb0, 0xb7,
0x85, 0x3d, 0x87, 0x48, 0xff, 0x5b, 0x69, 0xb8, 0x73, 0x00, 0x7f, 0xa9, 0xb7, 0x27, 0xc2, 0x85,
0x09, 0xba, 0xa5, 0x5b, 0x23, 0xbd, 0x1f, 0x7a, 0xb5, 0x23, 0x27, 0x68, 0x1c, 0x6c, 0x3c, 0x41,
0x93, 0xd0, 0x62, 0xc9, 0x63, 0xe1, 0x2e, 0x85, 0xaa, 0xb4, 0xe3, 0xdd, 0xa5, 0xe4, 0x0d, 0xa1,
0xb8, 0x29, 0x19, 0x03, 0x2f, 0x16, 0xfe, 0x42, 0xa1, 0x97, 0xfa, 0x62, 0x00, 0x4f, 0x4d, 0xef,
0x60, 0xa7, 0xaf, 0x5b, 0x6e, 0x16, 0x14, 0x28, 0xe0, 0x29, 0x50, 0xe0, 0xf0, 0x02, 0x05, 0x03,
0xe6, 0x23, 0xc5, 0x53, 0x24, 0x7b, 0xe6, 0x22, 0x2b, 0x24, 0xb7, 0x6e, 0x4e, 0x06, 0x14, 0xab,
0x1c, 0xc0, 0xbc, 0xcf, 0xd0, 0x8c, 0xb8, 0xef, 0x8c, 0x65, 0xfa, 0x08, 0x5d, 0x6f, 0x65, 0x01,
0x15, 0x2b, 0xb9, 0x80, 0x92, 0xb5, 0x21, 0x94, 0xad, 0xa6, 0x38, 0x4e, 0xf9, 0xa4, 0x17, 0x9c,
0x98, 0x3e, 0x8f, 0xd5, 0x61, 0xe5, 0xc6, 0x42, 0x5a, 0x56, 0x96, 0xea, 0xf3, 0x94, 0xb2, 0xae,
0x7a, 0x06, 0x3d, 0x85, 0x12, 0xff, 0x0f, 0xa7, 0xeb, 0xe3, 0xf3, 0xb9, 0x7c, 0xf6, 0x1b, 0x13,
0xa0, 0xc4, 0xc4, 0x87, 0xb0, 0x9c, 0x92, 0xcd, 0x95, 0xfa, 0x19, 0xe3, 0x33, 0xbf, 0x93, 0x2c,
0xa0, 0x58, 0x2c, 0x91, 0xae, 0x1d, 0xb3, 0x58, 0x5a, 0x6a, 0x77, 0xd2, 0x62, 0x3a, 0xa0, 0xe4,
0xc3, 0x7c, 0x29, 0x4f, 0xa4, 0xbe, 0xdf, 0xcf, 0xb0, 0x44, 0xf2, 0x6d, 0xbd, 0x74, 0x89, 0xd4,
0x27, 0xf8, 0x93, 0x96, 0xe8, 0xc0, 0x62, 0x22, 0x9f, 0x27, 0x35, 0xe4, 0x69, 0x59, 0xbf, 0x49,
0x0b, 0xf4, 0xe0, 0x0d, 0x69, 0xee, 0x4a, 0xea, 0x63, 0x8d, 0xcb, 0x72, 0x4d, 0x5a, 0xa8, 0x0b,
0x67, 0x25, 0x19, 0x2b, 0xa9, 0xad, 0x4e, 0xcf, 0x6c, 0x4d, 0x5a, 0x64, 0x1f, 0x5a, 0xab, 0x8e,
0xad, 0x1b, 0x5d, 0xdd, 0xf5, 0x68, 0x16, 0x89, 0xc4, 0xd7, 0xbe, 0x93, 0x2b, 0x0f, 0xb8, 0xa4,
0xb9, 0xa6, 0x49, 0xeb, 0x3c, 0x83, 0x2a, 0x65, 0x48, 0xf6, 0x47, 0x31, 0x48, 0x6e, 0xe9, 0x42,
0x10, 0x29, 0xea, 0x53, 0x06, 0x28, 0x44, 0xf3, 0x57, 0xa1, 0x22, 0xb2, 0x2f, 0x48, 0x76, 0xe1,
0x29, 0x9e, 0xf7, 0x69, 0x5d, 0x1f, 0x0f, 0xe4, 0xcf, 0xbc, 0xf2, 0x65, 0x05, 0xca, 0xfe, 0x1b,
0xa6, 0xaf, 0x38, 0x6d, 0xf0, 0x1a, 0xe2, 0xf8, 0x6f, 0xc3, 0x42, 0xec, 0xff, 0x04, 0xa4, 0x8c,
0x20, 0xff, 0xcf, 0x81, 0x49, 0x8c, 0xf0, 0x94, 0xff, 0xd5, 0xa1, 0xf0, 0x78, 0xdf, 0x4e, 0xcb,
0x05, 0xc4, 0x9d, 0xdd, 0x09, 0x13, 0xff, 0xef, 0xf6, 0xf7, 0xb6, 0x01, 0x42, 0x9e, 0xde, 0xf8,
0xab, 0xa4, 0xc4, 0x79, 0x99, 0x44, 0xad, 0x81, 0xd4, 0x99, 0x7b, 0x27, 0xcb, 0xb5, 0xbc, 0x74,
0x73, 0x9c, 0xee, 0xc2, 0x3d, 0x86, 0x5a, 0xf8, 0x92, 0x37, 0x92, 0xfe, 0xb1, 0x5e, 0xf2, 0x16,
0xf8, 0xa4, 0x5d, 0x6c, 0x9d, 0xd2, 0xca, 0x4f, 0x98, 0xce, 0x25, 0xe6, 0x29, 0x5e, 0x1e, 0x4c,
0x31, 0x4f, 0x29, 0x45, 0x49, 0xa9, 0x57, 0x94, 0x5e, 0x73, 0x64, 0x89, 0x92, 0x78, 0xcd, 0x4b,
0x9a, 0x28, 0x49, 0xa9, 0x22, 0x4a, 0x13, 0x25, 0x69, 0x45, 0x34, 0xf5, 0xcc, 0xea, 0x87, 0x9f,
0x7f, 0xd0, 0x33, 0xbd, 0x83, 0xd1, 0x33, 0xb2, 0xfb, 0xbb, 0x6c, 0xe8, 0x7b, 0xa6, 0xcd, 0x7f,
0xdd, 0xf5, 0xd9, 0xfd, 0x2e, 0x9d, 0xed, 0x2e, 0x99, 0x6d, 0xf8, 0xec, 0x59, 0x89, 0xb6, 0x3e,
0xfc, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xac, 0xd9, 0x8d, 0x86, 0xc8, 0x55, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

8
internal/util/paramtable/component_param.go
View File

@ -1374,6 +1374,7 @@ type dataCoordConfig struct {
MaxSegmentToMerge int
SegmentSmallProportion float64
SegmentCompactableProportion float64
SegmentExpansionRate float64
CompactionTimeoutInSeconds int32
CompactionCheckIntervalInSeconds int64
SingleCompactionRatioThreshold float32
@ -1413,6 +1414,7 @@ func (p *dataCoordConfig) init(base *BaseTable) {
p.initCompactionMinSegment()
p.initCompactionMaxSegment()
p.initSegmentProportion()
p.initSegmentExpansionRate()
p.initCompactionTimeoutInSeconds()
p.initCompactionCheckIntervalInSeconds()
p.initSingleCompactionRatioThreshold()
@ -1470,6 +1472,12 @@ func (p *dataCoordConfig) initSegmentMinSizeFromIdleToSealed() {
log.Info("init segment min size from idle to sealed", zap.Float64("value", p.SegmentMinSizeFromIdleToSealed))
}
func (p *dataCoordConfig) initSegmentExpansionRate() {
p.SegmentExpansionRate = p.Base.ParseFloatWithDefault("dataCoord.segment.expansionRate", 1.25)
log.Info("init segment expansion rate", zap.Float64("value", p.SegmentExpansionRate))
}
func (p *dataCoordConfig) initSegmentMaxBinlogFileNumber() {
p.SegmentMaxBinlogFileNumber = p.Base.ParseIntWithDefault("dataCoord.segment.maxBinlogFileNumber", 32)
log.Info("init segment max binlog file to sealed", zap.Int("value", p.SegmentMaxBinlogFileNumber))