diff --git a/core/block/editor/clipboard/clipboard.go b/core/block/editor/clipboard/clipboard.go index 6b503b79e..e0c6cce1f 100644 --- a/core/block/editor/clipboard/clipboard.go +++ b/core/block/editor/clipboard/clipboard.go @@ -226,7 +226,7 @@ func isRangeSelect(firstTextBlock *model.Block, lastTextBlock *model.Block, rang lastTextBlock == nil && rang != nil && rang.To-rang.From != int32(textutil.UTF16RuneCountString(firstTextBlock.GetText().Text)) && - rang.To != 0 && rang.From != 0 + rang.To > 0 } func unlinkAndClearBlocks( diff --git a/core/block/editor/clipboard/clipboard_test.go b/core/block/editor/clipboard/clipboard_test.go index c445628a4..c1953e6f9 100644 --- a/core/block/editor/clipboard/clipboard_test.go +++ b/core/block/editor/clipboard/clipboard_test.go @@ -1310,6 +1310,124 @@ func Test_CopyAndCutText(t *testing.T) { assert.Equal(t, expected, textSlotCopy) assert.Equal(t, expected, textSlotCut) }) + + t.Run("cut/copy - text range from 0", func(t *testing.T) { + // given + sb := smarttest.New("text") + require.NoError(t, smartblock.ObjectApplyTemplate(sb, nil, template.WithEmpty)) + s := sb.NewState() + + bl := givenBlockWithStyle(0, "") + insertBlock(s, bl, "") + require.NoError(t, sb.Apply(s)) + + // when + cb := newFixture(sb) + textSlotCopy, _, _, err := cb.Copy(nil, pb.RpcBlockCopyRequest{ + SelectedTextRange: &model.Range{From: 0, To: 7}, + Blocks: []*model.Block{bl}, + }) + textSlotCut, _, _, err := cb.Cut(nil, pb.RpcBlockCutRequest{ + SelectedTextRange: &model.Range{From: 0, To: 7}, + Blocks: []*model.Block{bl}, + }) + + // then + require.NoError(t, err) + const expected = "some te" + assert.Equal(t, expected, textSlotCopy) + assert.Equal(t, expected, textSlotCut) + assert.Len(t, sb.Blocks(), 2) + }) + + t.Run("cut/copy - text range from 0 to the end of block", func(t *testing.T) { + // given + const expected = "some text 1" + sb := smarttest.New("text") + require.NoError(t, smartblock.ObjectApplyTemplate(sb, nil, template.WithEmpty)) + s := sb.NewState() + + bl := givenBlockWithStyle(0, "") + insertBlock(s, bl, "") + require.NoError(t, sb.Apply(s)) + + // when + cb := newFixture(sb) + textSlotCopy, _, _, err := cb.Copy(nil, pb.RpcBlockCopyRequest{ + SelectedTextRange: &model.Range{From: 0, To: int32(len(expected))}, + Blocks: []*model.Block{bl}, + }) + textSlotCut, _, _, err := cb.Cut(nil, pb.RpcBlockCutRequest{ + SelectedTextRange: &model.Range{From: 0, To: int32(len(expected))}, + Blocks: []*model.Block{bl}, + }) + + // then + require.NoError(t, err) + assert.Equal(t, expected, textSlotCopy) + assert.Equal(t, expected, textSlotCut) + assert.Len(t, sb.Blocks(), 1) + }) + + t.Run("cut/copy - inner text range", func(t *testing.T) { + // given + sb := smarttest.New("text") + require.NoError(t, smartblock.ObjectApplyTemplate(sb, nil, template.WithEmpty)) + s := sb.NewState() + + bl := givenBlockWithStyle(0, "") + insertBlock(s, bl, "") + require.NoError(t, sb.Apply(s)) + + // when + cb := newFixture(sb) + textSlotCopy, _, _, err := cb.Copy(nil, pb.RpcBlockCopyRequest{ + SelectedTextRange: &model.Range{From: 2, To: 8}, + Blocks: []*model.Block{bl}, + }) + textSlotCut, _, _, err := cb.Cut(nil, pb.RpcBlockCutRequest{ + SelectedTextRange: &model.Range{From: 2, To: 8}, + Blocks: []*model.Block{bl}, + }) + + // then + require.NoError(t, err) + const expected = "me tex" + assert.Equal(t, expected, textSlotCopy) + assert.Equal(t, expected, textSlotCut) + assert.Len(t, sb.Blocks(), 2) + }) + + t.Run("cut/copy - text range from 0 to 0", func(t *testing.T) { + // given + sb := smarttest.New("text") + require.NoError(t, smartblock.ObjectApplyTemplate(sb, nil, template.WithEmpty)) + s := sb.NewState() + + bl := givenBlockWithStyle(0, "") + insertBlock(s, bl, "") + require.NoError(t, sb.Apply(s)) + + // when + cb := newFixture(sb) + textSlotCopy, _, anySlotCopy, err := cb.Copy(nil, pb.RpcBlockCopyRequest{ + SelectedTextRange: &model.Range{From: 0, To: 0}, + Blocks: []*model.Block{bl}, + }) + textSlotCut, _, anySlotCut, err := cb.Cut(nil, pb.RpcBlockCutRequest{ + SelectedTextRange: &model.Range{From: 0, To: 0}, + Blocks: []*model.Block{bl}, + }) + + // then + require.NoError(t, err) + const expected = "some text 1" + assert.Equal(t, expected, textSlotCopy) + assert.Equal(t, expected, textSlotCut) + assert.Len(t, sb.Blocks(), 1) + assert.Len(t, anySlotCopy, 1) + assert.Len(t, anySlotCut, 1) + }) } func givenRow3Level1NumberedBlock(s *state.State) *model.Block { diff --git a/core/block/editor/profile.go b/core/block/editor/profile.go index 4b4a4fb7e..405fb5f1a 100644 --- a/core/block/editor/profile.go +++ b/core/block/editor/profile.go @@ -82,10 +82,7 @@ func (p *Profile) CreationStateMigration(ctx *smartblock.InitContext) migration. template.InitTemplate(st, template.WithObjectTypesAndLayout([]domain.TypeKey{bundle.TypeKeyProfile}, model.ObjectType_profile), template.WithDetail(bundle.RelationKeyLayoutAlign, pbtypes.Float64(float64(model.Block_AlignCenter))), - template.WithTitle, - template.WithFeaturedRelations, template.WithRequiredRelations(), - migrationWithIdentityBlock, migrationSetHidden, ) }, @@ -126,6 +123,11 @@ func (p *Profile) StateMigrations() migration.Migrations { Version: 3, Proc: migrationSetHidden, }, + { + Version: 4, + Proc: func(s *state.State) { + }, + }, }) } diff --git a/core/block/editor/profilemigration/profilemigration.go b/core/block/editor/profilemigration/profilemigration.go new file mode 100644 index 000000000..caee94cb6 --- /dev/null +++ b/core/block/editor/profilemigration/profilemigration.go @@ -0,0 +1,98 @@ +package profilemigration + +import ( + "fmt" + "strings" + + "golang.org/x/exp/slices" + + "github.com/anyproto/anytype-heart/core/block/editor/state" + "github.com/anyproto/anytype-heart/core/block/simple" + "github.com/anyproto/anytype-heart/core/block/simple/text" + "github.com/anyproto/anytype-heart/core/domain" + "github.com/anyproto/anytype-heart/pkg/lib/bundle" + coresb "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock" + "github.com/anyproto/anytype-heart/util/pbtypes" +) + +const InternalKeyOldProfileData = "oldprofile" + +var ErrNoCustomStateFound = fmt.Errorf("no custom state found") + +// ExtractCustomState extract user-added state to the separate state and removes all the custom blocks/details from the original one +func ExtractCustomState(st *state.State) (userState *state.State, err error) { + identityBlockId := "identity" + // we leave identity and other blocks in the original object to avoid them being re-added by old clients + whitelistBlocks := []string{state.HeaderLayoutID, state.DescriptionBlockID, state.FeaturedRelationsID, state.TitleBlockID, identityBlockId} + hasCustomState := false + st.Iterate(func(b simple.Block) (isContinue bool) { + if slices.Contains(whitelistBlocks, b.Model().Id) { + return true + } + if textBlock, ok := b.(text.Block); ok { + // custom one for text block + if strings.TrimSpace(textBlock.GetText()) != "" { + hasCustomState = true + return false + } + } else if emptyChecker, ok := b.(IsEmpty); ok && !emptyChecker.IsEmpty() { + hasCustomState = true + return false + } + return true + }) + if !hasCustomState { + return nil, ErrNoCustomStateFound + } + blocksMap := map[string]simple.Block{} + + st.Iterate(func(b simple.Block) (isContinue bool) { + blocksMap[b.Model().Id] = b.Copy() + return true + }) + + uk, err := domain.NewUniqueKey(coresb.SmartBlockTypePage, InternalKeyOldProfileData) + if err != nil { + return nil, err + } + newState := state.NewDocWithUniqueKey(st.RootId(), blocksMap, uk).(*state.State) + newState.AddRelationLinks(st.GetRelationLinks()...) + newStateDetails := pbtypes.CopyStruct(st.Details()) + newName := pbtypes.GetString(newStateDetails, bundle.RelationKeyName.String()) + " [migrated]" + newStateDetails.Fields[bundle.RelationKeyName.String()] = pbtypes.String(newName) + newStateDetails.Fields[bundle.RelationKeyIsHidden.String()] = pbtypes.Bool(false) + newState.SetDetails(newStateDetails) + // remove the identity block + newState.Unlink(identityBlockId) + newState.CleanupBlock(identityBlockId) + + rootBlock := st.Get(st.RootId()) + rootBlock.Model().ChildrenIds = slices.DeleteFunc(rootBlock.Model().ChildrenIds, func(s string) bool { + return !slices.Contains(whitelistBlocks, s) + }) + + whitelistDetailKeys := []string{ + "iconEmoji", + "name", + "isHidden", + "featuredRelations", + "layout", + "layoutAlign", + "iconImage", + "iconOption", + } + var keysToRemove []string + for k := range st.Details().GetFields() { + if !slices.Contains(whitelistDetailKeys, k) { + keysToRemove = append(keysToRemove, k) + } + } + // cleanup custom details from old state + st.RemoveDetail(keysToRemove...) + st.RemoveRelation(keysToRemove...) + return newState, nil +} + +type IsEmpty interface { + IsEmpty() bool +} diff --git a/core/block/editor/profilemigration/profilemigration_test.go b/core/block/editor/profilemigration/profilemigration_test.go new file mode 100644 index 000000000..1f44ba8f8 --- /dev/null +++ b/core/block/editor/profilemigration/profilemigration_test.go @@ -0,0 +1,920 @@ +package profilemigration + +import ( + "testing" + + "github.com/gogo/protobuf/jsonpb" + "github.com/stretchr/testify/require" + + "github.com/anyproto/anytype-heart/core/block/editor/state" + "github.com/anyproto/anytype-heart/pb" + "github.com/anyproto/anytype-heart/pkg/lib/bundle" + "github.com/anyproto/anytype-heart/util/pbtypes" +) + +var ( + stateOriginalRootId = "bafyreiew6ma6fkw3hyceivukjd2zelgwcsfdyr2mmbb34slf2575y6s63a" + stateOriginal = `{ + "sbType": "ProfilePage", + "snapshot": { + "data": { + "blocks": [ + { + "id": "bafyreiew6ma6fkw3hyceivukjd2zelgwcsfdyr2mmbb34slf2575y6s63a", + "childrenIds": [ + "header", + "65d7c13961fab283c2729ad5", + "65d7c14061fab283c2729ad8", + "65d7c14f61fab283c2729adb", + "65d7c15a61fab283c2729add", + "65d7c16f61fab283c2729ae0", + "65d7c17a61fab283c2729ae2" + ], + "smartblock": { + + } + }, + { + "id": "header", + "restrictions": { + "edit": true, + "remove": true, + "drag": true, + "dropOn": true + }, + "childrenIds": [ + "title", + "identity", + "featuredRelations" + ], + "layout": { + "style": "Header" + } + }, + { + "id": "65d7c13961fab283c2729ad5", + "text": { + "text": "block1", + "marks": { + + } + } + }, + { + "id": "65d7c14061fab283c2729ad8", + "text": { + "text": "block2", + "marks": { + "marks": [ + { + "range": { + "to": 6 + }, + "type": "Bold" + } + ] + } + } + }, + { + "id": "65d7c14f61fab283c2729adb", + "file": { + "hash": "bafybeiarwjntnmjxc3wysufrqb6udvlm5s6exj6o5wzqjppvwpx4hvxx6m", + "name": "image.png", + "type": "Image", + "mime": "image/png", + "size": "42782", + "targetObjectId": "bafyreibdezouiipznowdp7wi7hsvysakdavydjjzu7ny7hcstdnqhthpqi", + "state": "Done", + "style": "Embed" + } + }, + { + "id": "65d7c15a61fab283c2729add", + "relation": { + "key": "lastModifiedBy" + } + }, + { + "id": "65d7c16f61fab283c2729ae0", + "relation": { + "key": "tag" + } + }, + { + "id": "65d7c17a61fab283c2729ae2", + "dataview": { + "views": [ + { + "id": "63c59da2c54d2d6c985c2b6b", + "name": "All", + "sorts": [ + { + "id": "63db97200e01101ff536a754", + "RelationKey": "type" + }, + { + "id": "63db97200e01101ff536a755", + "RelationKey": "lastModifiedDate", + "type": "Desc" + } + ], + "filters": [ + { + "id": "63d24bef257d7bad62f58c7d", + "RelationKey": "type", + "condition": "NotIn", + "value": [ + "bafyreihatd4tx3xsdgp7hr72amclva3x4x35webt5vuufxhxc5ikhp77hy", + "bafyreih33gcr4t4fq3kgmsuq5dou42otzfrou6rn6eohkeidcd7aw7tme4", + "bafyreiaparytg33b7ekqjfchni3axdrzrevbcw3uq7a5m5324slmtzq4ai", + "bafyreiawofrlyhnlobrrjh2qkdfz5rzfa5nvz7salq62573v4ktqrcytey", + "bafyreib2tcsejm5pvkj5b77ac7ezrt2kc5htlqlnlrqwa2vbh56byryvva", + "bafyreifn7xdb6wzawml5ymf6i67raq2yxjgcgrfcyuxoiiiuglygdxyxni", + "bafyreic6ncroguyctlvsepoaay67fve75xg3ongvc2yiz46r4tcxftzkva", + "bafyreic7jleoay7jaeaonqdpaeqimivgzsdgsqnrklhgodh6to6aenze6q", + "bafyreibyffj6c5surbofv3mjdpkwyozygmutqhn2pkz4g3gajr4bzqlv2e", + "bafyreibz5s4pjua57dnukiglqzi63jskryfd4g7xppbzoqyjbevyb6lche", + "bafyreieayrnuafcadst7x6emrsdc2wf4db2y72zbpikvciam2o7huc76iy" + ], + "format": "object" + }, + { + "id": "63d24bef257d7bad62f58c7e", + "RelationKey": "name", + "value": "" + } + ], + "relations": [ + { + "key": "name", + "isVisible": true, + "width": 500 + }, + { + "key": "type", + "isVisible": true, + "width": 192 + }, + { + "key": "lastModifiedDate", + "width": 178 + }, + { + "key": "description", + "width": 192 + }, + { + "key": "createdDate", + "width": 192 + }, + { + "key": "lastModifiedBy", + "width": 192 + }, + { + "key": "lastOpenedDate", + "width": 192 + }, + { + "key": "done" + } + ] + }, + { + "id": "e83e70ab-0601-4ab7-abd9-d4dc09b9e703", + "type": "Gallery", + "name": "Media", + "sorts": [ + { + "id": "63db97200e01101ff536a758", + "RelationKey": "type" + }, + { + "id": "63db97200e01101ff536a759", + "RelationKey": "name" + } + ], + "filters": [ + { + "id": "63d24bef257d7bad62f58c81", + "RelationKey": "type", + "condition": "In", + "value": [ + "bafyreic7jleoay7jaeaonqdpaeqimivgzsdgsqnrklhgodh6to6aenze6q", + "bafyreib2tcsejm5pvkj5b77ac7ezrt2kc5htlqlnlrqwa2vbh56byryvva", + "bafyreibyffj6c5surbofv3mjdpkwyozygmutqhn2pkz4g3gajr4bzqlv2e", + "bafyreieayrnuafcadst7x6emrsdc2wf4db2y72zbpikvciam2o7huc76iy" + ] + } + ], + "relations": [ + { + "key": "name", + "isVisible": true, + "width": 500 + }, + { + "key": "type", + "width": 192 + }, + { + "key": "createdDate", + "width": 192 + }, + { + "key": "description", + "width": 192 + }, + { + "key": "lastModifiedDate", + "width": 192 + }, + { + "key": "lastModifiedBy", + "width": 192 + }, + { + "key": "lastOpenedDate", + "width": 192 + }, + { + "key": "done" + } + ], + "coverRelationKey": "iconImage", + "groupRelationKey": "done" + }, + { + "id": "2589f7e2-aad5-43ed-8759-f0771a6a40c9", + "name": "Pre-installed", + "sorts": [ + { + "id": "63db97200e01101ff536a754", + "RelationKey": "type" + }, + { + "id": "63db97200e01101ff536a757", + "RelationKey": "name" + }, + { + "id": "63db97200e01101ff536a755", + "RelationKey": "lastModifiedDate", + "type": "Desc" + } + ], + "filters": [ + { + "id": "63d24bef257d7bad62f58c7d", + "RelationKey": "type", + "condition": "NotIn", + "value": [ + "bafyreihatd4tx3xsdgp7hr72amclva3x4x35webt5vuufxhxc5ikhp77hy", + "bafyreih33gcr4t4fq3kgmsuq5dou42otzfrou6rn6eohkeidcd7aw7tme4", + "bafyreiaparytg33b7ekqjfchni3axdrzrevbcw3uq7a5m5324slmtzq4ai", + "bafyreiawofrlyhnlobrrjh2qkdfz5rzfa5nvz7salq62573v4ktqrcytey", + "bafyreib2tcsejm5pvkj5b77ac7ezrt2kc5htlqlnlrqwa2vbh56byryvva", + "bafyreifn7xdb6wzawml5ymf6i67raq2yxjgcgrfcyuxoiiiuglygdxyxni", + "bafyreic6ncroguyctlvsepoaay67fve75xg3ongvc2yiz46r4tcxftzkva", + "bafyreic7jleoay7jaeaonqdpaeqimivgzsdgsqnrklhgodh6to6aenze6q", + "bafyreibyffj6c5surbofv3mjdpkwyozygmutqhn2pkz4g3gajr4bzqlv2e", + "bafyreibz5s4pjua57dnukiglqzi63jskryfd4g7xppbzoqyjbevyb6lche", + "bafyreieayrnuafcadst7x6emrsdc2wf4db2y72zbpikvciam2o7huc76iy" + ] + }, + { + "id": "63d24bef257d7bad62f58c7e", + "RelationKey": "tag", + "condition": "In", + "value": [ + "bafyreiawm24apxzqyhiz36a3aguwpywqyka7l7qpt2hxvasx3ivww7dawq" + ], + "format": "tag" + } + ], + "relations": [ + { + "key": "name", + "isVisible": true, + "width": 500 + }, + { + "key": "type", + "isVisible": true, + "width": 192 + }, + { + "key": "lastModifiedDate", + "width": 178 + }, + { + "key": "description", + "width": 192 + }, + { + "key": "createdDate", + "width": 192 + }, + { + "key": "lastModifiedBy", + "width": 192 + }, + { + "key": "lastOpenedDate", + "width": 192 + }, + { + "key": "done", + "width": 192 + }, + { + "key": "tag", + "isVisible": true, + "width": 192 + } + ], + "cardSize": "Medium", + "groupRelationKey": "done" + } + ], + "relationLinks": [ + { + "key": "name", + "format": "shorttext" + }, + { + "key": "type", + "format": "object" + }, + { + "key": "lastModifiedDate", + "format": "date" + }, + { + "key": "description" + }, + { + "key": "createdDate", + "format": "date" + }, + { + "key": "lastModifiedBy", + "format": "object" + }, + { + "key": "lastOpenedDate", + "format": "date" + }, + { + "key": "done", + "format": "checkbox" + }, + { + "key": "tag", + "format": "tag" + } + ], + "TargetObjectId": "bafyreibgdh7ka67etpdwwsckhnsez7k7qjqtxkxo2nkrx67w5otgsl4bsi" + } + }, + { + "id": "title", + "fields": { + "_detailsKey": [ + "name", + "done" + ] + }, + "restrictions": { + "remove": true, + "drag": true, + "dropOn": true + }, + "align": "AlignCenter", + "text": { + "style": "Title", + "marks": { + + } + } + }, + { + "id": "identity", + "restrictions": { + "edit": true, + "remove": true, + "drag": true, + "dropOn": true + }, + "relation": { + "key": "profileOwnerIdentity" + } + }, + { + "id": "featuredRelations", + "restrictions": { + "remove": true, + "drag": true, + "dropOn": true + }, + "align": "AlignCenter", + "featuredRelations": { + + } + } + ], + "details": { + "backlinks": [ + ], + "createdDate": 1708638507, + "creator": "_participant_bafyreifqavrshf5l2ovfexjzboibyvmweh6edx477mggj6lvpprp2tltgq_2msp3m2jb2vcd_A9YAB51C9MMWR5HLDzBR4A3BnkReMYHSR1wdmYEVfP4biKfr", + "featuredRelations": [ + "backlinks" + ], + "iconEmoji": "", + "iconImage": "bafyreifhebpqmp3kx52wyfhmje23j7du3kguziddj4ilri7m5jngogbs24", + "iconOption": 5, + "id": "bafyreiew6ma6fkw3hyceivukjd2zelgwcsfdyr2mmbb34slf2575y6s63a", + "isHidden": true, + "lastModifiedBy": "_participant_bafyreifqavrshf5l2ovfexjzboibyvmweh6edx477mggj6lvpprp2tltgq_2msp3m2jb2vcd_A9YAB51C9MMWR5HLDzBR4A3BnkReMYHSR1wdmYEVfP4biKfr", + "lastModifiedDate": 1708694933, + "layout": 1, + "layoutAlign": 1, + "links": [ + "bafyreibgdh7ka67etpdwwsckhnsez7k7qjqtxkxo2nkrx67w5otgsl4bsi" + ], + "name": "Roma", + "profileOwnerIdentity": "_participant_bafyreifqavrshf5l2ovfexjzboibyvmweh6edx477mggj6lvpprp2tltgq_2msp3m2jb2vcd_A9YAB51C9MMWR5HLDzBR4A3BnkReMYHSR1wdmYEVfP4biKfr", + "restrictions": [ + 6, + 5, + 1, + 8 + ], + "snippet": "block1\nblock2", + "spaceId": "bafyreifqavrshf5l2ovfexjzboibyvmweh6edx477mggj6lvpprp2tltgq.2msp3m2jb2vcd", + "tag": [ + "bafyreiayeo7sk3i56v5cqyenjgr73wuz2fn52mmcuirqqdefhjiy6qji24" + ], + "type": "bafyreifci7gcmxafbn6eikujw2elra4ynpxmdqs4fqzhql5n63gus7olpm" + }, + "objectTypes": [ + "ot-profile" + ], + "relationLinks": [ + { + "key": "backlinks", + "format": "object" + }, + { + "key": "featuredRelations", + "format": "object" + }, + { + "key": "id", + "format": "object" + }, + { + "key": "spaceId", + "format": "object" + }, + { + "key": "snippet" + }, + { + "key": "layout", + "format": "number" + }, + { + "key": "layoutAlign", + "format": "number" + }, + { + "key": "name", + "format": "shorttext" + }, + { + "key": "description" + }, + { + "key": "iconEmoji", + "format": "emoji" + }, + { + "key": "iconImage", + "format": "file" + }, + { + "key": "type", + "format": "object" + }, + { + "key": "coverId" + }, + { + "key": "coverScale", + "format": "number" + }, + { + "key": "coverType", + "format": "number" + }, + { + "key": "coverX", + "format": "number" + }, + { + "key": "coverY", + "format": "number" + }, + { + "key": "createdDate", + "format": "date" + }, + { + "key": "creator", + "format": "object" + }, + { + "key": "lastModifiedDate", + "format": "date" + }, + { + "key": "lastModifiedBy", + "format": "object" + }, + { + "key": "lastOpenedDate", + "format": "date" + }, + { + "key": "isFavorite", + "format": "checkbox" + }, + { + "key": "workspaceId", + "format": "object" + }, + { + "key": "links", + "format": "object" + }, + { + "key": "internalFlags", + "format": "number" + }, + { + "key": "restrictions", + "format": "number" + }, + { + "key": "iconOption", + "format": "number" + }, + { + "key": "tag", + "format": "tag" + }, + { + "key": "isHidden", + "format": "checkbox" + }, + { + "key": "profileOwnerIdentity", + "format": "shorttext" + } + ] + } + } +}` + + stateOriginalEmptyRootId = "bafyreif5rmdsvap7ieqnpvlm6vafizxw7igz37bmixtboopaiygpepyycm" + stateOriginalEmpty = ` +{ + "sbType": "ProfilePage", + "snapshot": { + "data": { + "blocks": [ + { + "id": "bafyreif5rmdsvap7ieqnpvlm6vafizxw7igz37bmixtboopaiygpepyycm", + "childrenIds": [ + "header", + "65d8a97961fab22b735aa569", + "65d8a98061fab22b735aa56b", + "65d8a98061fab22b735aa56c" + ], + "smartblock": { + + } + }, + { + "id": "header", + "restrictions": { + "edit": true, + "remove": true, + "drag": true, + "dropOn": true + }, + "childrenIds": [ + "title", + "identity", + "featuredRelations" + ], + "layout": { + "style": "Header" + } + }, + { + "id": "65d8a97961fab22b735aa569", + "text": { + "marks": { + + } + } + }, + { + "id": "65d8a98061fab22b735aa56b", + "text": { + "marks": { + + } + } + }, + { + "id": "65d8a98061fab22b735aa56c", + "text": { + "marks": { + + } + } + }, + { + "id": "title", + "fields": { + "_detailsKey": [ + "name", + "done" + ] + }, + "restrictions": { + "remove": true, + "drag": true, + "dropOn": true + }, + "align": "AlignCenter", + "text": { + "style": "Title", + "marks": { + + } + } + }, + { + "id": "identity", + "restrictions": { + "edit": true, + "remove": true, + "drag": true, + "dropOn": true + }, + "relation": { + "key": "profileOwnerIdentity" + } + }, + { + "id": "featuredRelations", + "restrictions": { + "remove": true, + "drag": true, + "dropOn": true + }, + "align": "AlignCenter", + "featuredRelations": { + + } + } + ], + "details": { + "backlinks": [ + ], + "createdDate": 1708697957, + "creator": "_participant_bafyreicqzro4ea6ibejpswsq3ygdvl5yrswdhv3wcaeiya4zrhgxijorhi_25fl2y3kgedrp_ABG7CU4WFNtAtdYMbDoJArFguPJRHqq9Bag5un1iBoy2qqkn", + "featuredRelations": [ + "backlinks" + ], + "iconOption": 15, + "id": "bafyreif5rmdsvap7ieqnpvlm6vafizxw7igz37bmixtboopaiygpepyycm", + "isHidden": true, + "lastModifiedBy": "_participant_bafyreicqzro4ea6ibejpswsq3ygdvl5yrswdhv3wcaeiya4zrhgxijorhi_25fl2y3kgedrp_ABG7CU4WFNtAtdYMbDoJArFguPJRHqq9Bag5un1iBoy2qqkn", + "lastModifiedDate": 1708698142, + "layout": 1, + "layoutAlign": 1, + "links": [ + ], + "name": "ooo", + "profileOwnerIdentity": "_participant_bafyreicqzro4ea6ibejpswsq3ygdvl5yrswdhv3wcaeiya4zrhgxijorhi_25fl2y3kgedrp_ABG7CU4WFNtAtdYMbDoJArFguPJRHqq9Bag5un1iBoy2qqkn", + "restrictions": [ + 6, + 5, + 1, + 8 + ], + "snippet": "", + "spaceId": "bafyreicqzro4ea6ibejpswsq3ygdvl5yrswdhv3wcaeiya4zrhgxijorhi.25fl2y3kgedrp", + "type": "bafyreiawi7jklmbhjqfux73ncl2t3ujytjahv2steorcqabydchkfze4iy" + }, + "objectTypes": [ + "ot-profile" + ], + "relationLinks": [ + { + "key": "backlinks", + "format": "object" + }, + { + "key": "featuredRelations", + "format": "object" + }, + { + "key": "id", + "format": "object" + }, + { + "key": "spaceId", + "format": "object" + }, + { + "key": "snippet" + }, + { + "key": "layout", + "format": "number" + }, + { + "key": "layoutAlign", + "format": "number" + }, + { + "key": "name", + "format": "shorttext" + }, + { + "key": "description" + }, + { + "key": "iconEmoji", + "format": "emoji" + }, + { + "key": "iconImage", + "format": "file" + }, + { + "key": "type", + "format": "object" + }, + { + "key": "coverId" + }, + { + "key": "coverScale", + "format": "number" + }, + { + "key": "coverType", + "format": "number" + }, + { + "key": "coverX", + "format": "number" + }, + { + "key": "coverY", + "format": "number" + }, + { + "key": "createdDate", + "format": "date" + }, + { + "key": "creator", + "format": "object" + }, + { + "key": "lastModifiedDate", + "format": "date" + }, + { + "key": "lastModifiedBy", + "format": "object" + }, + { + "key": "lastOpenedDate", + "format": "date" + }, + { + "key": "isFavorite", + "format": "checkbox" + }, + { + "key": "workspaceId", + "format": "object" + }, + { + "key": "links", + "format": "object" + }, + { + "key": "internalFlags", + "format": "number" + }, + { + "key": "restrictions", + "format": "number" + }, + { + "key": "iconOption", + "format": "number" + }, + { + "key": "isHidden", + "format": "checkbox" + }, + { + "key": "profileOwnerIdentity", + "format": "shorttext" + } + ] + } + } +}` +) + +func TestProfileMigrationExtractCustomState(t *testing.T) { + sn := pb.SnapshotWithType{} + err := jsonpb.UnmarshalString(stateOriginal, &sn) + require.NoError(t, err) + var identityBlockId = "identity" + originalState := state.NewDocFromSnapshot(stateOriginalRootId, sn.Snapshot).(*state.State) + originalStateCopy := originalState.Copy() + extractedState, err := ExtractCustomState(originalState) + require.NoError(t, err) + for _, block := range originalState.Blocks() { + // should contains only whitelisted blocks + require.Containsf(t, []string{ + stateOriginalRootId, + state.FeaturedRelationsID, + state.TitleBlockID, + state.HeaderLayoutID, + state.FeaturedRelationsID, + identityBlockId, // we do not remove this block + }, block.Id, "state should not contain block %s", block.Id) + } + + for _, block := range originalStateCopy.Blocks() { + if block.Id == identityBlockId { + require.Nilf(t, extractedState.Get(block.Id), "extractedState should not contain block %s", block.Id) + } else { + require.NotNilf(t, extractedState.Get(block.Id), "extractedState should contain block %s", block.Id) + } + } + + var whitelistedDetailKeys = []string{ + "iconEmoji", + "name", + "isHidden", + "featuredRelations", + "layout", + "layoutAlign", + "iconImage", + "iconOption", + } + for k, v := range originalStateCopy.Details().GetFields() { + if k == bundle.RelationKeyName.String() { + // should has suffix in the name + v = pbtypes.String(v.GetStringValue() + " [migrated]") + } + if k == bundle.RelationKeyIsHidden.String() { + // extracted state should not be hidden + v = pbtypes.Bool(false) + } + require.Truef(t, v.Equal(extractedState.Details().Fields[k]), "detail %s should be equal to original state", k) + } + + for k, _ := range originalState.Details().GetFields() { + require.Contains(t, whitelistedDetailKeys, k, "old state should not contain %s", k) + } + + _, err = ExtractCustomState(originalState.NewState()) + require.ErrorIsf(t, err, ErrNoCustomStateFound, "should return error on the second time call") +} + +func TestProfileMigrationExtractCustomStateEmpty(t *testing.T) { + sn := pb.SnapshotWithType{} + err := jsonpb.UnmarshalString(stateOriginalEmpty, &sn) + require.NoError(t, err) + originalStateEmpty := state.NewDocFromSnapshot(stateOriginalEmptyRootId, sn.Snapshot).(*state.State) + _, err = ExtractCustomState(originalStateEmpty) + + require.ErrorIsf(t, err, ErrNoCustomStateFound, "should return error because profile was not changed by user") +} diff --git a/core/block/object/objectcreator/creator.go b/core/block/object/objectcreator/creator.go index 1b281ab33..7a87180e0 100644 --- a/core/block/object/objectcreator/creator.go +++ b/core/block/object/objectcreator/creator.go @@ -6,8 +6,10 @@ import ( "github.com/anyproto/any-sync/app" "github.com/gogo/protobuf/types" + "github.com/pkg/errors" "github.com/anyproto/anytype-heart/core/block/editor/state" + "github.com/anyproto/anytype-heart/core/block/restriction" "github.com/anyproto/anytype-heart/core/domain" "github.com/anyproto/anytype-heart/core/files" "github.com/anyproto/anytype-heart/pb" @@ -109,6 +111,8 @@ func (s *service) CreateObjectUsingObjectUniqueTypeKey( return s.CreateObject(ctx, spaceID, req) } +// createObjectInSpace is supposed to be called for user-initiated object creation requests +// will return Restricted error in case called with types like File or Participant func (s *service) createObjectInSpace( ctx context.Context, space clientspace.Space, req CreateObjectRequest, ) (id string, details *types.Struct, err error) { @@ -118,6 +122,11 @@ func (s *service) createObjectInSpace( } details = internalflag.PutToDetails(details, req.InternalFlags) + if bundle.HasObjectTypeByKey(req.ObjectTypeKey) { + if t := bundle.MustGetType(req.ObjectTypeKey); t.RestrictObjectCreation { + return "", nil, errors.Wrap(restriction.ErrRestricted, "creation of this object type is restricted") + } + } switch req.ObjectTypeKey { case bundle.TypeKeyBookmark: return s.bookmarkService.CreateObjectAndFetch(ctx, space.Id(), &pb.RpcObjectCreateBookmarkRequest{ diff --git a/core/block/object/objectcreator/systemobjectreviser.go b/core/block/object/objectcreator/systemobjectreviser.go index 78a032428..d19941974 100644 --- a/core/block/object/objectcreator/systemobjectreviser.go +++ b/core/block/object/objectcreator/systemobjectreviser.go @@ -61,7 +61,7 @@ func (s *service) listAllTypesAndRelations(spaceId string) (map[string]*types.St func reviseSystemObject(space clientspace.Space, localObject *types.Struct, marketObjects map[string]*types.Struct) { source := pbtypes.GetString(localObject, bundle.RelationKeySourceObject.String()) marketObject, found := marketObjects[source] - if !found || !isSystemObject(localObject) || pbtypes.GetInt64(marketObject, revisionKey) < pbtypes.GetInt64(localObject, revisionKey) { + if !found || !isSystemObject(localObject) || pbtypes.GetInt64(marketObject, revisionKey) <= pbtypes.GetInt64(localObject, revisionKey) { return } details := buildDiffDetails(marketObject, localObject) @@ -98,10 +98,17 @@ func buildDiffDetails(origin, current *types.Struct) (details []*pb.RpcObjectSet bundle.RelationKeyName.String(), bundle.RelationKeyDescription.String(), bundle.RelationKeyIsReadonly.String(), bundle.RelationKeyIsHidden.String(), bundle.RelationKeyRevision.String(), bundle.RelationKeyRelationReadonlyValue.String(), - bundle.RelationKeyRelationMaxCount.String(), + bundle.RelationKeyRelationMaxCount.String(), bundle.RelationKeyTargetObjectType.String(), }) for key, value := range diff.Fields { + if key == bundle.RelationKeyTargetObjectType.String() { + // special case. We don't want to remove the types that was set by user, so only add ones that we have + currentList := pbtypes.GetStringList(current, bundle.RelationKeyTargetObjectType.String()) + missedInCurrent, _ := lo.Difference(pbtypes.GetStringList(origin, bundle.RelationKeyTargetObjectType.String()), currentList) + currentList = append(currentList, missedInCurrent...) + value = pbtypes.StringList(currentList) + } details = append(details, &pb.RpcObjectSetDetailsDetail{Key: key, Value: value}) } return diff --git a/core/block/simple/bookmark/bookmark.go b/core/block/simple/bookmark/bookmark.go index b07057257..35601f623 100644 --- a/core/block/simple/bookmark/bookmark.go +++ b/core/block/simple/bookmark/bookmark.go @@ -218,3 +218,7 @@ func (b *Bookmark) FillSmartIds(ids []string) []string { func (b *Bookmark) HasSmartIds() bool { return b.content.TargetObjectId != "" } + +func (l *Bookmark) IsEmpty() bool { + return l.content.TargetObjectId == "" +} diff --git a/core/block/simple/dataview/dataview.go b/core/block/simple/dataview/dataview.go index 736108bcf..e56dd21a2 100644 --- a/core/block/simple/dataview/dataview.go +++ b/core/block/simple/dataview/dataview.go @@ -516,3 +516,7 @@ func (s *Dataview) UpdateRelationOld(relationKey string, rel model.Relation) err return nil } + +func (d *Dataview) IsEmpty() bool { + return d.content.TargetObjectId == "" && len(d.content.Views) == 0 +} diff --git a/core/block/simple/embed/embed.go b/core/block/simple/embed/embed.go index 57f2da022..405d3e263 100644 --- a/core/block/simple/embed/embed.go +++ b/core/block/simple/embed/embed.go @@ -96,3 +96,7 @@ func (l *Latex) ApplyEvent(e *pb.EventBlockSetLatex) error { } return nil } + +func (l *Latex) IsEmpty() bool { + return l.content.Text == "" +} diff --git a/core/block/simple/file/file.go b/core/block/simple/file/file.go index d7b6814f7..ff5c48bcf 100644 --- a/core/block/simple/file/file.go +++ b/core/block/simple/file/file.go @@ -241,6 +241,10 @@ func (f *File) HasSmartIds() bool { return f.content.TargetObjectId != "" } +func (f *File) IsEmpty() bool { + return f.content.TargetObjectId == "" && f.content.Hash == "" +} + func DetectTypeByMIME(mime string) model.BlockContentFileType { if mill.IsImage(mime) { return model.BlockContentFile_Image diff --git a/core/block/simple/link/link.go b/core/block/simple/link/link.go index f40af959c..2dc7aaa84 100644 --- a/core/block/simple/link/link.go +++ b/core/block/simple/link/link.go @@ -188,3 +188,7 @@ func (l *Link) ToText(targetDetails *types.Struct) simple.Block { } return simple.New(m) } + +func (l *Link) IsEmpty() bool { + return l.content.TargetBlockId == "" +} diff --git a/core/block/source/sub_object_links_migration.go b/core/block/source/sub_object_links_migration.go index be194792f..a1b423556 100644 --- a/core/block/source/sub_object_links_migration.go +++ b/core/block/source/sub_object_links_migration.go @@ -136,12 +136,10 @@ func (m *subObjectsAndProfileLinksMigration) Migrate(s *state.State) { func (m *subObjectsAndProfileLinksMigration) migrateId(oldId string) (newId string) { if m.profileID != "" && m.identityObjectID != "" { - // we substitute all links to profile object with identity object EXCEPT the case with - // widget to identity in Personal space, we must substitute identity with profile to show links correctly - if oldId == m.profileID && (m.space.Id() != m.personalSpaceId || m.sbType != smartblock.SmartBlockTypeWidget) { + // we substitute all links to profile object with space member object + if oldId == m.profileID || + strings.HasPrefix(oldId, "_id_") { // we don't need to check the exact accountID here, because we only have links to our own identity return m.identityObjectID - } else if oldId == m.identityObjectID && m.space.Id() == m.personalSpaceId && m.sbType == smartblock.SmartBlockTypeWidget { - return m.profileID } } uniqueKey, valid := subObjectIdToUniqueKey(oldId) diff --git a/core/domain/uniquekey.go b/core/domain/uniquekey.go index 264bd1576..f451b4881 100644 --- a/core/domain/uniquekey.go +++ b/core/domain/uniquekey.go @@ -11,16 +11,17 @@ import ( const uniqueKeySeparator = "-" var smartBlockTypeToKey = map[smartblock.SmartBlockType]string{ - smartblock.SmartBlockTypeObjectType: "ot", - smartblock.SmartBlockTypeRelation: "rel", - smartblock.SmartBlockTypeRelationOption: "opt", - smartblock.SmartBlockTypeWorkspace: "ws", - smartblock.SmartBlockTypeHome: "home", - smartblock.SmartBlockTypeArchive: "archive", - smartblock.SmartBlockTypeProfilePage: "profile", - smartblock.SmartBlockTypeWidget: "widget", - smartblock.SmartBlockTypeSpaceView: "spaceview", - smartblock.SmartBlockTypeFileObject: "file", // For migration purposes only + smartblock.SmartBlockTypeObjectType: "ot", + smartblock.SmartBlockTypeRelation: "rel", + smartblock.SmartBlockTypeRelationOption: "opt", + smartblock.SmartBlockTypeWorkspace: "ws", + smartblock.SmartBlockTypeHome: "home", + smartblock.SmartBlockTypeArchive: "archive", + smartblock.SmartBlockTypeProfilePage: "profile", + smartblock.SmartBlockTypeWidget: "widget", + smartblock.SmartBlockTypeSpaceView: "spaceview", + smartblock.SmartBlockTypeFileObject: "file", // For migration purposes only + smartblock.SmartBlockTypePage: "page", // For migration purposes only, used for old profile data migration smartblock.SmartBlockTypeNotificationObject: "notification", } diff --git a/docs/proto.md b/docs/proto.md index 2011991a6..6737aa90f 100644 --- a/docs/proto.md +++ b/docs/proto.md @@ -24784,6 +24784,7 @@ Used to decode block meta only, without the content itself | installedByDefault | [bool](#bool) | | | | key | [string](#string) | | name of objectType (can be localized for bundled types) | | revision | [int64](#int64) | | revision of system objectType. Used to check if we should change type content or not | +| restrictObjectCreation | [bool](#bool) | | restricts creating objects of this type for users | @@ -25807,6 +25808,7 @@ RelationFormat describes how the underlying data is stored in the google.protobu | LayoutChange | 6 | restricts layout changing | | Template | 7 | restricts template creation from this object | | Duplicate | 8 | restricts duplicate object | +| CreateObjectOfThisType | 9 | can be set only for types. Restricts creating objects of this type | diff --git a/pkg/lib/bundle/generator/main.go b/pkg/lib/bundle/generator/main.go index 82f64609f..376d3f1cb 100644 --- a/pkg/lib/bundle/generator/main.go +++ b/pkg/lib/bundle/generator/main.go @@ -52,15 +52,16 @@ type Relation struct { } type ObjectType struct { - ID string `json:"id"` - Name string `json:"name"` - Types []string `json:"types"` - Emoji string `json:"emoji"` - Hidden bool `json:"hidden"` - Layout string `json:"layout"` - Relations []string `json:"relations"` - Description string `json:"description"` - Revision int `json:"revision"` + ID string `json:"id"` + Name string `json:"name"` + Types []string `json:"types"` + Emoji string `json:"emoji"` + Hidden bool `json:"hidden"` + Layout string `json:"layout"` + Relations []string `json:"relations"` + Description string `json:"description"` + Revision int `json:"revision"` + RestrictObjectCreation bool `json:"restrictObjectCreation"` } type Layout struct { @@ -305,6 +306,10 @@ func generateTypes() error { dictS[Id("Revision")] = Lit(ot.Revision) } + if ot.RestrictObjectCreation { + dictS[Id("RestrictObjectCreation")] = Lit(ot.RestrictObjectCreation) + } + dict[Id(typeConst(ot.ID))] = Block(dictS) } g.Id("types").Op("=").Map(Qual(domainPkg, "TypeKey")).Op("*").Qual(relPbPkg, "ObjectType").Values(Dict(dict)) diff --git a/pkg/lib/bundle/relation.gen.go b/pkg/lib/bundle/relation.gen.go index cc98c71e1..36213ae52 100644 --- a/pkg/lib/bundle/relation.gen.go +++ b/pkg/lib/bundle/relation.gen.go @@ -9,7 +9,7 @@ import ( "github.com/anyproto/anytype-heart/pkg/lib/pb/model" ) -const RelationChecksum = "56d2e69285cd7e22d75e27e8538a9f8d0d542816b9ad97568436543afa724447" +const RelationChecksum = "f2cc0befbfea6768c50fd6be77f1233dee9f2352eb08e7d8fb156c0518d6160f" const ( RelationKeyTag domain.RelationKey = "tag" RelationKeyCamera domain.RelationKey = "camera" @@ -253,9 +253,10 @@ var ( Id: "_brassignee", Key: "assignee", Name: "Assignee", - ObjectTypes: []string{TypePrefix + "profile", TypePrefix + "contact"}, + ObjectTypes: []string{TypePrefix + "profile", TypePrefix + "contact", TypePrefix + "participant"}, ReadOnly: false, ReadOnlyRelation: true, + Revision: 1, Scope: model.Relation_type, }, RelationKeyAttachments: { @@ -344,9 +345,10 @@ var ( Id: "_brauthor", Key: "author", Name: "Author", - ObjectTypes: []string{TypePrefix + "profile", TypePrefix + "contact"}, + ObjectTypes: []string{TypePrefix + "profile", TypePrefix + "contact", TypePrefix + "participant"}, ReadOnly: false, ReadOnlyRelation: true, + Revision: 1, Scope: model.Relation_type, }, RelationKeyBacklinks: { @@ -1200,9 +1202,10 @@ var ( Key: "lastModifiedBy", MaxCount: 1, Name: "Last modified by", - ObjectTypes: []string{TypePrefix + "profile"}, + ObjectTypes: []string{TypePrefix + "participant"}, ReadOnly: true, ReadOnlyRelation: true, + Revision: 1, Scope: model.Relation_type, }, RelationKeyLastModifiedDate: { diff --git a/pkg/lib/bundle/relations.json b/pkg/lib/bundle/relations.json index fe039946d..b25baf3d5 100644 --- a/pkg/lib/bundle/relations.json +++ b/pkg/lib/bundle/relations.json @@ -609,8 +609,10 @@ "source": "details", "objectTypes": [ "profile", - "contact" - ] + "contact", + "participant" + ], + "revision": 1 }, { "description": "Name of artist", @@ -751,8 +753,10 @@ "source": "details", "objectTypes": [ "profile", - "contact" - ] + "contact", + "participant" + ], + "revision": 1 }, { "format": "longtext", @@ -1164,10 +1168,11 @@ "maxCount": 1, "name": "Last modified by", "objectTypes": [ - "profile" + "participant" ], "readonly": true, - "source": "derived" + "source": "derived", + "revision": 1 }, { "description": "Relation allows multi values", diff --git a/pkg/lib/bundle/types.gen.go b/pkg/lib/bundle/types.gen.go index a355cff45..988d13f16 100644 --- a/pkg/lib/bundle/types.gen.go +++ b/pkg/lib/bundle/types.gen.go @@ -9,7 +9,7 @@ import ( "github.com/anyproto/anytype-heart/pkg/lib/pb/model" ) -const TypeChecksum = "d793d61e0b07300056e692cfe82dee8f23a436a70c36e066067b837b24b09ee1" +const TypeChecksum = "fea3b06c998f4c974f06b3b0714b26dd2c5a7fa35ce9dc8b8f17d7c619215f7b" const ( TypePrefix = "_ot" ) @@ -54,14 +54,15 @@ var ( types = map[domain.TypeKey]*model.ObjectType{ TypeKeyAudio: { - Description: "Auto-generated object from .wav, .mp3, .ogg files added to Anytype. Sound when recorded, with ability to reproduce", - IconEmoji: "🎵", - Layout: model.ObjectType_file, - Name: "Audio", - Readonly: true, - RelationLinks: []*model.RelationLink{MustGetRelationLink(RelationKeyArtist), MustGetRelationLink(RelationKeyAudioAlbum), MustGetRelationLink(RelationKeyAudioAlbumTrackNumber), MustGetRelationLink(RelationKeyAudioGenre), MustGetRelationLink(RelationKeyReleasedYear), MustGetRelationLink(RelationKeyThumbnailImage), MustGetRelationLink(RelationKeyComposer), MustGetRelationLink(RelationKeySizeInBytes), MustGetRelationLink(RelationKeyFileMimeType), MustGetRelationLink(RelationKeyAddedDate), MustGetRelationLink(RelationKeyFileExt), MustGetRelationLink(RelationKeyAudioArtist), MustGetRelationLink(RelationKeyAudioLyrics)}, - Types: []model.SmartBlockType{model.SmartBlockType_File}, - Url: TypePrefix + "audio", + Description: "Sound when recorded, with ability to reproduce", + IconEmoji: "🎵", + Layout: model.ObjectType_file, + Name: "Audio", + Readonly: true, + RelationLinks: []*model.RelationLink{MustGetRelationLink(RelationKeyArtist), MustGetRelationLink(RelationKeyAudioAlbum), MustGetRelationLink(RelationKeyAudioAlbumTrackNumber), MustGetRelationLink(RelationKeyAudioGenre), MustGetRelationLink(RelationKeyReleasedYear), MustGetRelationLink(RelationKeyThumbnailImage), MustGetRelationLink(RelationKeyComposer), MustGetRelationLink(RelationKeySizeInBytes), MustGetRelationLink(RelationKeyFileMimeType), MustGetRelationLink(RelationKeyAddedDate), MustGetRelationLink(RelationKeyFileExt), MustGetRelationLink(RelationKeyAudioArtist), MustGetRelationLink(RelationKeyAudioLyrics)}, + RestrictObjectCreation: true, + Types: []model.SmartBlockType{model.SmartBlockType_File}, + Url: TypePrefix + "audio", }, TypeKeyBook: { @@ -142,13 +143,14 @@ var ( }, TypeKeyDashboard: { - Description: "Internal home dashboard with favourite objects", - Hidden: true, - Layout: model.ObjectType_dashboard, - Name: "Dashboard", - Readonly: true, - Types: []model.SmartBlockType{model.SmartBlockType_Home}, - Url: TypePrefix + "dashboard", + Description: "Internal home dashboard with favourite objects", + Hidden: true, + Layout: model.ObjectType_dashboard, + Name: "Dashboard", + Readonly: true, + RestrictObjectCreation: true, + Types: []model.SmartBlockType{model.SmartBlockType_Home}, + Url: TypePrefix + "dashboard", }, TypeKeyDate: { @@ -197,14 +199,15 @@ var ( }, TypeKeyFile: { - Description: "Auto-generated object from files added to Anytype. Computer resource for recording data in a computer storage device", - IconEmoji: "📎", - Layout: model.ObjectType_file, - Name: "File", - Readonly: true, - RelationLinks: []*model.RelationLink{MustGetRelationLink(RelationKeyFileMimeType), MustGetRelationLink(RelationKeySizeInBytes), MustGetRelationLink(RelationKeyAddedDate), MustGetRelationLink(RelationKeyFileExt)}, - Types: []model.SmartBlockType{model.SmartBlockType_File}, - Url: TypePrefix + "file", + Description: "Computer resource for recording data in a computer storage device", + IconEmoji: "📎", + Layout: model.ObjectType_file, + Name: "File", + Readonly: true, + RelationLinks: []*model.RelationLink{MustGetRelationLink(RelationKeyFileMimeType), MustGetRelationLink(RelationKeySizeInBytes), MustGetRelationLink(RelationKeyAddedDate), MustGetRelationLink(RelationKeyFileExt)}, + RestrictObjectCreation: true, + Types: []model.SmartBlockType{model.SmartBlockType_File}, + Url: TypePrefix + "file", }, TypeKeyGoal: { @@ -230,14 +233,15 @@ var ( }, TypeKeyImage: { - Description: "Auto-generated object from .jpg & .png files added to Anytype. A representation of the external form of a person or thing in art", - IconEmoji: "🏞", - Layout: model.ObjectType_image, - Name: "Image", - Readonly: true, - RelationLinks: []*model.RelationLink{MustGetRelationLink(RelationKeyFileMimeType), MustGetRelationLink(RelationKeyWidthInPixels), MustGetRelationLink(RelationKeyCamera), MustGetRelationLink(RelationKeyHeightInPixels), MustGetRelationLink(RelationKeySizeInBytes), MustGetRelationLink(RelationKeyCameraIso), MustGetRelationLink(RelationKeyAperture), MustGetRelationLink(RelationKeyExposure), MustGetRelationLink(RelationKeyAddedDate), MustGetRelationLink(RelationKeyFocalRatio), MustGetRelationLink(RelationKeyFileExt)}, - Types: []model.SmartBlockType{model.SmartBlockType_File}, - Url: TypePrefix + "image", + Description: "A representation of the external form of a person or thing in art", + IconEmoji: "🏞", + Layout: model.ObjectType_image, + Name: "Image", + Readonly: true, + RelationLinks: []*model.RelationLink{MustGetRelationLink(RelationKeyFileMimeType), MustGetRelationLink(RelationKeyWidthInPixels), MustGetRelationLink(RelationKeyCamera), MustGetRelationLink(RelationKeyHeightInPixels), MustGetRelationLink(RelationKeySizeInBytes), MustGetRelationLink(RelationKeyCameraIso), MustGetRelationLink(RelationKeyAperture), MustGetRelationLink(RelationKeyExposure), MustGetRelationLink(RelationKeyAddedDate), MustGetRelationLink(RelationKeyFocalRatio), MustGetRelationLink(RelationKeyFileExt)}, + RestrictObjectCreation: true, + Types: []model.SmartBlockType{model.SmartBlockType_File}, + Url: TypePrefix + "image", }, TypeKeyMovie: { @@ -285,15 +289,16 @@ var ( }, TypeKeyParticipant: { - Description: "Participant", - Hidden: true, - IconEmoji: "🧑", - Layout: model.ObjectType_participant, - Name: "Participant", - Readonly: true, - RelationLinks: []*model.RelationLink{MustGetRelationLink(RelationKeyTag)}, - Types: []model.SmartBlockType{model.SmartBlockType_Participant}, - Url: TypePrefix + "participant", + Description: "Anytype identity as a space participant", + IconEmoji: "🧑", + Layout: model.ObjectType_participant, + Name: "Space member", + Readonly: true, + RelationLinks: []*model.RelationLink{MustGetRelationLink(RelationKeyTag)}, + RestrictObjectCreation: true, + Revision: 1, + Types: []model.SmartBlockType{model.SmartBlockType_Participant}, + Url: TypePrefix + "participant", }, TypeKeyProfile: { @@ -364,27 +369,29 @@ var ( }, TypeKeySpace: { - Description: "Workspace", - Hidden: true, - IconEmoji: "🌎", - Layout: model.ObjectType_space, - Name: "Space", - Readonly: true, - RelationLinks: []*model.RelationLink{MustGetRelationLink(RelationKeyTag)}, - Types: []model.SmartBlockType{model.SmartBlockType_Workspace}, - Url: TypePrefix + "space", + Description: "Workspace", + Hidden: true, + IconEmoji: "🌎", + Layout: model.ObjectType_space, + Name: "Space", + Readonly: true, + RelationLinks: []*model.RelationLink{MustGetRelationLink(RelationKeyTag)}, + RestrictObjectCreation: true, + Types: []model.SmartBlockType{model.SmartBlockType_Workspace}, + Url: TypePrefix + "space", }, TypeKeySpaceView: { - Description: "Space", - Hidden: true, - IconEmoji: "🌎", - Layout: model.ObjectType_spaceView, - Name: "Space", - Readonly: true, - RelationLinks: []*model.RelationLink{MustGetRelationLink(RelationKeyTag)}, - Types: []model.SmartBlockType{model.SmartBlockType_SpaceView}, - Url: TypePrefix + "spaceView", + Description: "Space", + Hidden: true, + IconEmoji: "🌎", + Layout: model.ObjectType_spaceView, + Name: "Space", + Readonly: true, + RelationLinks: []*model.RelationLink{MustGetRelationLink(RelationKeyTag)}, + RestrictObjectCreation: true, + Types: []model.SmartBlockType{model.SmartBlockType_SpaceView}, + Url: TypePrefix + "spaceView", }, TypeKeyTask: { @@ -410,14 +417,15 @@ var ( }, TypeKeyVideo: { - Description: "Auto-generated object from .mpeg-4 files added to Anytype. The recording of moving visual images", - IconEmoji: "📽", - Layout: model.ObjectType_file, - Name: "Video", - Readonly: true, - RelationLinks: []*model.RelationLink{MustGetRelationLink(RelationKeySizeInBytes), MustGetRelationLink(RelationKeyFileMimeType), MustGetRelationLink(RelationKeyCamera), MustGetRelationLink(RelationKeyThumbnailImage), MustGetRelationLink(RelationKeyHeightInPixels), MustGetRelationLink(RelationKeyWidthInPixels), MustGetRelationLink(RelationKeyCameraIso), MustGetRelationLink(RelationKeyAperture), MustGetRelationLink(RelationKeyExposure), MustGetRelationLink(RelationKeyAddedDate), MustGetRelationLink(RelationKeyFileExt)}, - Types: []model.SmartBlockType{model.SmartBlockType_File}, - Url: TypePrefix + "video", + Description: "The recording of moving visual images", + IconEmoji: "📽", + Layout: model.ObjectType_file, + Name: "Video", + Readonly: true, + RelationLinks: []*model.RelationLink{MustGetRelationLink(RelationKeySizeInBytes), MustGetRelationLink(RelationKeyFileMimeType), MustGetRelationLink(RelationKeyCamera), MustGetRelationLink(RelationKeyThumbnailImage), MustGetRelationLink(RelationKeyHeightInPixels), MustGetRelationLink(RelationKeyWidthInPixels), MustGetRelationLink(RelationKeyCameraIso), MustGetRelationLink(RelationKeyAperture), MustGetRelationLink(RelationKeyExposure), MustGetRelationLink(RelationKeyAddedDate), MustGetRelationLink(RelationKeyFileExt)}, + RestrictObjectCreation: true, + Types: []model.SmartBlockType{model.SmartBlockType_File}, + Url: TypePrefix + "video", }, TypeKeyWeeklyPlan: { diff --git a/pkg/lib/bundle/types.json b/pkg/lib/bundle/types.json index 5d7c41b67..312124e5d 100644 --- a/pkg/lib/bundle/types.json +++ b/pkg/lib/bundle/types.json @@ -203,7 +203,8 @@ "addedDate", "fileExt" ], - "description": "Auto-generated object from .mpeg-4 files added to Anytype. The recording of moving visual images" + "description": "The recording of moving visual images", + "restrictObjectCreation": true }, { "id": "dashboard", @@ -215,7 +216,8 @@ "hidden": true, "layout": "dashboard", "relations": [], - "description": "Internal home dashboard with favourite objects" + "description": "Internal home dashboard with favourite objects", + "restrictObjectCreation": true }, { "id": "dailyPlan", @@ -295,7 +297,8 @@ "relations": [ "tag" ], - "description": "Workspace" + "description": "Workspace", + "restrictObjectCreation": true }, { "id": "spaceView", @@ -309,21 +312,24 @@ "relations": [ "tag" ], - "description": "Space" + "description": "Space", + "restrictObjectCreation": true }, { "id": "participant", - "name": "Participant", + "name": "Space member", "types": [ "Participant" ], "emoji": "\uD83E\uDDD1", - "hidden": true, + "hidden": false, "layout": "participant", "relations": [ "tag" ], - "description": "Participant" + "description": "Anytype identity as a space participant", + "restrictObjectCreation": true, + "revision": 1 }, { "id": "template", @@ -441,7 +447,8 @@ "focalRatio", "fileExt" ], - "description": "Auto-generated object from .jpg \u0026 .png files added to Anytype. A representation of the external form of a person or thing in art" + "description": "A representation of the external form of a person or thing in art", + "restrictObjectCreation": true }, { "id": "bug", @@ -503,7 +510,8 @@ "audioArtist", "audioLyrics" ], - "description": "Auto-generated object from .wav, .mp3, .ogg files added to Anytype. Sound when recorded, with ability to reproduce" + "description": "Sound when recorded, with ability to reproduce", + "restrictObjectCreation": true }, { "id": "goal", @@ -575,7 +583,8 @@ "addedDate", "fileExt" ], - "description": "Auto-generated object from files added to Anytype. Computer resource for recording data in a computer storage device" + "description": "Computer resource for recording data in a computer storage device", + "restrictObjectCreation": true }, { "id": "project", diff --git a/pkg/lib/pb/model/models.pb.go b/pkg/lib/pb/model/models.pb.go index 1925c1791..8fba291b2 100644 --- a/pkg/lib/pb/model/models.pb.go +++ b/pkg/lib/pb/model/models.pb.go @@ -26,30 +26,29 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type SmartBlockType int32 const ( - SmartBlockType_AccountOld SmartBlockType = 0 - SmartBlockType_Page SmartBlockType = 16 - SmartBlockType_ProfilePage SmartBlockType = 17 - SmartBlockType_Home SmartBlockType = 32 - SmartBlockType_Archive SmartBlockType = 48 - SmartBlockType_Widget SmartBlockType = 112 - SmartBlockType_File SmartBlockType = 256 - SmartBlockType_Template SmartBlockType = 288 - SmartBlockType_BundledTemplate SmartBlockType = 289 - SmartBlockType_BundledRelation SmartBlockType = 512 - SmartBlockType_SubObject SmartBlockType = 513 - SmartBlockType_BundledObjectType SmartBlockType = 514 - SmartBlockType_AnytypeProfile SmartBlockType = 515 - SmartBlockType_Date SmartBlockType = 516 - SmartBlockType_Workspace SmartBlockType = 518 - SmartBlockType_STRelation SmartBlockType = 521 - SmartBlockType_STType SmartBlockType = 528 - SmartBlockType_STRelationOption SmartBlockType = 529 - SmartBlockType_SpaceView SmartBlockType = 530 - SmartBlockType_Identity SmartBlockType = 532 - SmartBlockType_Participant SmartBlockType = 534 - SmartBlockType_MissingObject SmartBlockType = 519 - SmartBlockType_FileObject SmartBlockType = 533 - SmartBlockType_NotificationObject SmartBlockType = 535 + SmartBlockType_AccountOld SmartBlockType = 0 + SmartBlockType_Page SmartBlockType = 16 + SmartBlockType_ProfilePage SmartBlockType = 17 + SmartBlockType_Home SmartBlockType = 32 + SmartBlockType_Archive SmartBlockType = 48 + SmartBlockType_Widget SmartBlockType = 112 + SmartBlockType_File SmartBlockType = 256 + SmartBlockType_Template SmartBlockType = 288 + SmartBlockType_BundledTemplate SmartBlockType = 289 + SmartBlockType_BundledRelation SmartBlockType = 512 + SmartBlockType_SubObject SmartBlockType = 513 + SmartBlockType_BundledObjectType SmartBlockType = 514 + SmartBlockType_AnytypeProfile SmartBlockType = 515 + SmartBlockType_Date SmartBlockType = 516 + SmartBlockType_Workspace SmartBlockType = 518 + SmartBlockType_STRelation SmartBlockType = 521 + SmartBlockType_STType SmartBlockType = 528 + SmartBlockType_STRelationOption SmartBlockType = 529 + SmartBlockType_SpaceView SmartBlockType = 530 + SmartBlockType_Identity SmartBlockType = 532 + SmartBlockType_Participant SmartBlockType = 534 + SmartBlockType_MissingObject SmartBlockType = 519 + SmartBlockType_FileObject SmartBlockType = 533 ) var SmartBlockType_name = map[int32]string{ @@ -76,34 +75,32 @@ var SmartBlockType_name = map[int32]string{ 534: "Participant", 519: "MissingObject", 533: "FileObject", - 535: "NotificationObject", } var SmartBlockType_value = map[string]int32{ - "AccountOld": 0, - "Page": 16, - "ProfilePage": 17, - "Home": 32, - "Archive": 48, - "Widget": 112, - "File": 256, - "Template": 288, - "BundledTemplate": 289, - "BundledRelation": 512, - "SubObject": 513, - "BundledObjectType": 514, - "AnytypeProfile": 515, - "Date": 516, - "Workspace": 518, - "STRelation": 521, - "STType": 528, - "STRelationOption": 529, - "SpaceView": 530, - "Identity": 532, - "Participant": 534, - "MissingObject": 519, - "FileObject": 533, - "NotificationObject": 535, + "AccountOld": 0, + "Page": 16, + "ProfilePage": 17, + "Home": 32, + "Archive": 48, + "Widget": 112, + "File": 256, + "Template": 288, + "BundledTemplate": 289, + "BundledRelation": 512, + "SubObject": 513, + "BundledObjectType": 514, + "AnytypeProfile": 515, + "Date": 516, + "Workspace": 518, + "STRelation": 521, + "STType": 528, + "STRelationOption": 529, + "SpaceView": 530, + "Identity": 532, + "Participant": 534, + "MissingObject": 519, + "FileObject": 533, } func (x SmartBlockType) String() string { @@ -1454,6 +1451,8 @@ const ( Restrictions_Template RestrictionsObjectRestriction = 7 // restricts duplicate object Restrictions_Duplicate RestrictionsObjectRestriction = 8 + // can be set only for types. Restricts creating objects of this type + Restrictions_CreateObjectOfThisType RestrictionsObjectRestriction = 9 ) var RestrictionsObjectRestriction_name = map[int32]string{ @@ -1466,18 +1465,20 @@ var RestrictionsObjectRestriction_name = map[int32]string{ 6: "LayoutChange", 7: "Template", 8: "Duplicate", + 9: "CreateObjectOfThisType", } var RestrictionsObjectRestriction_value = map[string]int32{ - "None": 0, - "Delete": 1, - "Relations": 2, - "Blocks": 3, - "Details": 4, - "TypeChange": 5, - "LayoutChange": 6, - "Template": 7, - "Duplicate": 8, + "None": 0, + "Delete": 1, + "Relations": 2, + "Blocks": 3, + "Details": 4, + "TypeChange": 5, + "LayoutChange": 6, + "Template": 7, + "Duplicate": 8, + "CreateObjectOfThisType": 9, } func (x RestrictionsObjectRestriction) String() string { @@ -5386,19 +5387,20 @@ func (m *SpaceObjectHeader) GetSpaceID() string { } type ObjectType struct { - Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - RelationLinks []*RelationLink `protobuf:"bytes,3,rep,name=relationLinks,proto3" json:"relationLinks,omitempty"` - Layout ObjectTypeLayout `protobuf:"varint,4,opt,name=layout,proto3,enum=anytype.model.ObjectTypeLayout" json:"layout,omitempty"` - IconEmoji string `protobuf:"bytes,5,opt,name=iconEmoji,proto3" json:"iconEmoji,omitempty"` - Description string `protobuf:"bytes,6,opt,name=description,proto3" json:"description,omitempty"` - Hidden bool `protobuf:"varint,7,opt,name=hidden,proto3" json:"hidden,omitempty"` - Readonly bool `protobuf:"varint,10,opt,name=readonly,proto3" json:"readonly,omitempty"` - Types []SmartBlockType `protobuf:"varint,8,rep,packed,name=types,proto3,enum=anytype.model.SmartBlockType" json:"types,omitempty"` - IsArchived bool `protobuf:"varint,9,opt,name=isArchived,proto3" json:"isArchived,omitempty"` - InstalledByDefault bool `protobuf:"varint,11,opt,name=installedByDefault,proto3" json:"installedByDefault,omitempty"` - Key string `protobuf:"bytes,12,opt,name=key,proto3" json:"key,omitempty"` - Revision int64 `protobuf:"varint,13,opt,name=revision,proto3" json:"revision,omitempty"` + Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + RelationLinks []*RelationLink `protobuf:"bytes,3,rep,name=relationLinks,proto3" json:"relationLinks,omitempty"` + Layout ObjectTypeLayout `protobuf:"varint,4,opt,name=layout,proto3,enum=anytype.model.ObjectTypeLayout" json:"layout,omitempty"` + IconEmoji string `protobuf:"bytes,5,opt,name=iconEmoji,proto3" json:"iconEmoji,omitempty"` + Description string `protobuf:"bytes,6,opt,name=description,proto3" json:"description,omitempty"` + Hidden bool `protobuf:"varint,7,opt,name=hidden,proto3" json:"hidden,omitempty"` + Readonly bool `protobuf:"varint,10,opt,name=readonly,proto3" json:"readonly,omitempty"` + Types []SmartBlockType `protobuf:"varint,8,rep,packed,name=types,proto3,enum=anytype.model.SmartBlockType" json:"types,omitempty"` + IsArchived bool `protobuf:"varint,9,opt,name=isArchived,proto3" json:"isArchived,omitempty"` + InstalledByDefault bool `protobuf:"varint,11,opt,name=installedByDefault,proto3" json:"installedByDefault,omitempty"` + Key string `protobuf:"bytes,12,opt,name=key,proto3" json:"key,omitempty"` + Revision int64 `protobuf:"varint,13,opt,name=revision,proto3" json:"revision,omitempty"` + RestrictObjectCreation bool `protobuf:"varint,14,opt,name=restrictObjectCreation,proto3" json:"restrictObjectCreation,omitempty"` } func (m *ObjectType) Reset() { *m = ObjectType{} } @@ -5525,6 +5527,13 @@ func (m *ObjectType) GetRevision() int64 { return 0 } +func (m *ObjectType) GetRestrictObjectCreation() bool { + if m != nil { + return m.RestrictObjectCreation + } + return false +} + type Layout struct { Id ObjectTypeLayout `protobuf:"varint,1,opt,name=id,proto3,enum=anytype.model.ObjectTypeLayout" json:"id,omitempty"` Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` @@ -6550,13 +6559,8 @@ type Notification struct { // *NotificationPayloadOfGalleryImport // *NotificationPayloadOfRequestToJoin // *NotificationPayloadOfTest - // *NotificationPayloadOfRequestResponse - // *NotificationPayloadOfParticipantRequestApproved - // *NotificationPayloadOfLeaveRequest - // *NotificationPayloadOfParticipantRemove - Payload IsNotificationPayload `protobuf_oneof:"payload"` - Space string `protobuf:"bytes,7,opt,name=space,proto3" json:"space,omitempty"` - AclHeadId string `protobuf:"bytes,14,opt,name=aclHeadId,proto3" json:"aclHeadId,omitempty"` + Payload IsNotificationPayload `protobuf_oneof:"payload"` + Space string `protobuf:"bytes,7,opt,name=space,proto3" json:"space,omitempty"` } func (m *Notification) Reset() { *m = Notification{} } @@ -6613,28 +6617,12 @@ type NotificationPayloadOfRequestToJoin struct { type NotificationPayloadOfTest struct { Test *NotificationTest `protobuf:"bytes,11,opt,name=test,proto3,oneof" json:"test,omitempty"` } -type NotificationPayloadOfRequestResponse struct { - RequestResponse *NotificationRequestResponse `protobuf:"bytes,12,opt,name=requestResponse,proto3,oneof" json:"requestResponse,omitempty"` -} -type NotificationPayloadOfParticipantRequestApproved struct { - ParticipantRequestApproved *NotificationParticipantRequestApproved `protobuf:"bytes,13,opt,name=participantRequestApproved,proto3,oneof" json:"participantRequestApproved,omitempty"` -} -type NotificationPayloadOfLeaveRequest struct { - LeaveRequest *NotificationLeaveRequest `protobuf:"bytes,15,opt,name=leaveRequest,proto3,oneof" json:"leaveRequest,omitempty"` -} -type NotificationPayloadOfParticipantRemove struct { - ParticipantRemove *NotificationParticipantRemove `protobuf:"bytes,16,opt,name=participantRemove,proto3,oneof" json:"participantRemove,omitempty"` -} -func (*NotificationPayloadOfImport) IsNotificationPayload() {} -func (*NotificationPayloadOfExport) IsNotificationPayload() {} -func (*NotificationPayloadOfGalleryImport) IsNotificationPayload() {} -func (*NotificationPayloadOfRequestToJoin) IsNotificationPayload() {} -func (*NotificationPayloadOfTest) IsNotificationPayload() {} -func (*NotificationPayloadOfRequestResponse) IsNotificationPayload() {} -func (*NotificationPayloadOfParticipantRequestApproved) IsNotificationPayload() {} -func (*NotificationPayloadOfLeaveRequest) IsNotificationPayload() {} -func (*NotificationPayloadOfParticipantRemove) IsNotificationPayload() {} +func (*NotificationPayloadOfImport) IsNotificationPayload() {} +func (*NotificationPayloadOfExport) IsNotificationPayload() {} +func (*NotificationPayloadOfGalleryImport) IsNotificationPayload() {} +func (*NotificationPayloadOfRequestToJoin) IsNotificationPayload() {} +func (*NotificationPayloadOfTest) IsNotificationPayload() {} func (m *Notification) GetPayload() IsNotificationPayload { if m != nil { @@ -6706,34 +6694,6 @@ func (m *Notification) GetTest() *NotificationTest { return nil } -func (m *Notification) GetRequestResponse() *NotificationRequestResponse { - if x, ok := m.GetPayload().(*NotificationPayloadOfRequestResponse); ok { - return x.RequestResponse - } - return nil -} - -func (m *Notification) GetParticipantRequestApproved() *NotificationParticipantRequestApproved { - if x, ok := m.GetPayload().(*NotificationPayloadOfParticipantRequestApproved); ok { - return x.ParticipantRequestApproved - } - return nil -} - -func (m *Notification) GetLeaveRequest() *NotificationLeaveRequest { - if x, ok := m.GetPayload().(*NotificationPayloadOfLeaveRequest); ok { - return x.LeaveRequest - } - return nil -} - -func (m *Notification) GetParticipantRemove() *NotificationParticipantRemove { - if x, ok := m.GetPayload().(*NotificationPayloadOfParticipantRemove); ok { - return x.ParticipantRemove - } - return nil -} - func (m *Notification) GetSpace() string { if m != nil { return m.Space @@ -6741,13 +6701,6 @@ func (m *Notification) GetSpace() string { return "" } -func (m *Notification) GetAclHeadId() string { - if m != nil { - return m.AclHeadId - } - return "" -} - // XXX_OneofWrappers is for the internal use of the proto package. func (*Notification) XXX_OneofWrappers() []interface{} { return []interface{}{ @@ -6756,10 +6709,6 @@ func (*Notification) XXX_OneofWrappers() []interface{} { (*NotificationPayloadOfGalleryImport)(nil), (*NotificationPayloadOfRequestToJoin)(nil), (*NotificationPayloadOfTest)(nil), - (*NotificationPayloadOfRequestResponse)(nil), - (*NotificationPayloadOfParticipantRequestApproved)(nil), - (*NotificationPayloadOfLeaveRequest)(nil), - (*NotificationPayloadOfParticipantRemove)(nil), } } @@ -7063,264 +7012,6 @@ func (m *NotificationTest) XXX_DiscardUnknown() { var xxx_messageInfo_NotificationTest proto.InternalMessageInfo -type NotificationRequestResponse struct { - Identity string `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"` - IdentityName string `protobuf:"bytes,2,opt,name=identityName,proto3" json:"identityName,omitempty"` - IdentityIcon string `protobuf:"bytes,3,opt,name=identityIcon,proto3" json:"identityIcon,omitempty"` - IsApproved bool `protobuf:"varint,4,opt,name=isApproved,proto3" json:"isApproved,omitempty"` - Permission ParticipantPermissions `protobuf:"varint,5,opt,name=permission,proto3,enum=anytype.model.ParticipantPermissions" json:"permission,omitempty"` -} - -func (m *NotificationRequestResponse) Reset() { *m = NotificationRequestResponse{} } -func (m *NotificationRequestResponse) String() string { return proto.CompactTextString(m) } -func (*NotificationRequestResponse) ProtoMessage() {} -func (*NotificationRequestResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_98a910b73321e591, []int{20, 5} -} -func (m *NotificationRequestResponse) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *NotificationRequestResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_NotificationRequestResponse.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *NotificationRequestResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_NotificationRequestResponse.Merge(m, src) -} -func (m *NotificationRequestResponse) XXX_Size() int { - return m.Size() -} -func (m *NotificationRequestResponse) XXX_DiscardUnknown() { - xxx_messageInfo_NotificationRequestResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_NotificationRequestResponse proto.InternalMessageInfo - -func (m *NotificationRequestResponse) GetIdentity() string { - if m != nil { - return m.Identity - } - return "" -} - -func (m *NotificationRequestResponse) GetIdentityName() string { - if m != nil { - return m.IdentityName - } - return "" -} - -func (m *NotificationRequestResponse) GetIdentityIcon() string { - if m != nil { - return m.IdentityIcon - } - return "" -} - -func (m *NotificationRequestResponse) GetIsApproved() bool { - if m != nil { - return m.IsApproved - } - return false -} - -func (m *NotificationRequestResponse) GetPermission() ParticipantPermissions { - if m != nil { - return m.Permission - } - return ParticipantPermissions_Reader -} - -type NotificationParticipantRequestApproved struct { - SpaceID string `protobuf:"bytes,1,opt,name=spaceID,proto3" json:"spaceID,omitempty"` - Permission ParticipantPermissions `protobuf:"varint,2,opt,name=permission,proto3,enum=anytype.model.ParticipantPermissions" json:"permission,omitempty"` -} - -func (m *NotificationParticipantRequestApproved) Reset() { - *m = NotificationParticipantRequestApproved{} -} -func (m *NotificationParticipantRequestApproved) String() string { return proto.CompactTextString(m) } -func (*NotificationParticipantRequestApproved) ProtoMessage() {} -func (*NotificationParticipantRequestApproved) Descriptor() ([]byte, []int) { - return fileDescriptor_98a910b73321e591, []int{20, 6} -} -func (m *NotificationParticipantRequestApproved) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *NotificationParticipantRequestApproved) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_NotificationParticipantRequestApproved.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *NotificationParticipantRequestApproved) XXX_Merge(src proto.Message) { - xxx_messageInfo_NotificationParticipantRequestApproved.Merge(m, src) -} -func (m *NotificationParticipantRequestApproved) XXX_Size() int { - return m.Size() -} -func (m *NotificationParticipantRequestApproved) XXX_DiscardUnknown() { - xxx_messageInfo_NotificationParticipantRequestApproved.DiscardUnknown(m) -} - -var xxx_messageInfo_NotificationParticipantRequestApproved proto.InternalMessageInfo - -func (m *NotificationParticipantRequestApproved) GetSpaceID() string { - if m != nil { - return m.SpaceID - } - return "" -} - -func (m *NotificationParticipantRequestApproved) GetPermission() ParticipantPermissions { - if m != nil { - return m.Permission - } - return ParticipantPermissions_Reader -} - -type NotificationLeaveRequest struct { - SpaceId string `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"` - Identity string `protobuf:"bytes,2,opt,name=identity,proto3" json:"identity,omitempty"` - IdentityName string `protobuf:"bytes,3,opt,name=identityName,proto3" json:"identityName,omitempty"` - IdentityIcon string `protobuf:"bytes,4,opt,name=identityIcon,proto3" json:"identityIcon,omitempty"` -} - -func (m *NotificationLeaveRequest) Reset() { *m = NotificationLeaveRequest{} } -func (m *NotificationLeaveRequest) String() string { return proto.CompactTextString(m) } -func (*NotificationLeaveRequest) ProtoMessage() {} -func (*NotificationLeaveRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_98a910b73321e591, []int{20, 7} -} -func (m *NotificationLeaveRequest) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *NotificationLeaveRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_NotificationLeaveRequest.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *NotificationLeaveRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_NotificationLeaveRequest.Merge(m, src) -} -func (m *NotificationLeaveRequest) XXX_Size() int { - return m.Size() -} -func (m *NotificationLeaveRequest) XXX_DiscardUnknown() { - xxx_messageInfo_NotificationLeaveRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_NotificationLeaveRequest proto.InternalMessageInfo - -func (m *NotificationLeaveRequest) GetSpaceId() string { - if m != nil { - return m.SpaceId - } - return "" -} - -func (m *NotificationLeaveRequest) GetIdentity() string { - if m != nil { - return m.Identity - } - return "" -} - -func (m *NotificationLeaveRequest) GetIdentityName() string { - if m != nil { - return m.IdentityName - } - return "" -} - -func (m *NotificationLeaveRequest) GetIdentityIcon() string { - if m != nil { - return m.IdentityIcon - } - return "" -} - -type NotificationParticipantRemove struct { - Identity string `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"` - IdentityName string `protobuf:"bytes,2,opt,name=identityName,proto3" json:"identityName,omitempty"` - IdentityIcon string `protobuf:"bytes,3,opt,name=identityIcon,proto3" json:"identityIcon,omitempty"` -} - -func (m *NotificationParticipantRemove) Reset() { *m = NotificationParticipantRemove{} } -func (m *NotificationParticipantRemove) String() string { return proto.CompactTextString(m) } -func (*NotificationParticipantRemove) ProtoMessage() {} -func (*NotificationParticipantRemove) Descriptor() ([]byte, []int) { - return fileDescriptor_98a910b73321e591, []int{20, 8} -} -func (m *NotificationParticipantRemove) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *NotificationParticipantRemove) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_NotificationParticipantRemove.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *NotificationParticipantRemove) XXX_Merge(src proto.Message) { - xxx_messageInfo_NotificationParticipantRemove.Merge(m, src) -} -func (m *NotificationParticipantRemove) XXX_Size() int { - return m.Size() -} -func (m *NotificationParticipantRemove) XXX_DiscardUnknown() { - xxx_messageInfo_NotificationParticipantRemove.DiscardUnknown(m) -} - -var xxx_messageInfo_NotificationParticipantRemove proto.InternalMessageInfo - -func (m *NotificationParticipantRemove) GetIdentity() string { - if m != nil { - return m.Identity - } - return "" -} - -func (m *NotificationParticipantRemove) GetIdentityName() string { - if m != nil { - return m.IdentityName - } - return "" -} - -func (m *NotificationParticipantRemove) GetIdentityIcon() string { - if m != nil { - return m.IdentityIcon - } - return "" -} - type Export struct { } @@ -7969,10 +7660,6 @@ func init() { proto.RegisterType((*NotificationGalleryImport)(nil), "anytype.model.Notification.GalleryImport") proto.RegisterType((*NotificationRequestToJoin)(nil), "anytype.model.Notification.RequestToJoin") proto.RegisterType((*NotificationTest)(nil), "anytype.model.Notification.Test") - proto.RegisterType((*NotificationRequestResponse)(nil), "anytype.model.Notification.RequestResponse") - proto.RegisterType((*NotificationParticipantRequestApproved)(nil), "anytype.model.Notification.ParticipantRequestApproved") - proto.RegisterType((*NotificationLeaveRequest)(nil), "anytype.model.Notification.LeaveRequest") - proto.RegisterType((*NotificationParticipantRemove)(nil), "anytype.model.Notification.ParticipantRemove") proto.RegisterType((*Export)(nil), "anytype.model.Export") proto.RegisterType((*Import)(nil), "anytype.model.Import") proto.RegisterType((*Invite)(nil), "anytype.model.Invite") @@ -7988,461 +7675,449 @@ func init() { } var fileDescriptor_98a910b73321e591 = []byte{ - // 7250 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x7c, 0x4b, 0x8c, 0x64, 0xd9, + // 7072 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x7c, 0x4b, 0x8c, 0x64, 0xd9, 0x95, 0x50, 0xc6, 0x3f, 0xe2, 0x44, 0x7e, 0x6e, 0xde, 0xaa, 0xae, 0x8a, 0x89, 0xae, 0x29, 0x6a, - 0xde, 0xf4, 0xb4, 0xcb, 0xe5, 0x76, 0x56, 0x77, 0xf5, 0xd7, 0x3d, 0x6e, 0xb7, 0xf3, 0x5b, 0x19, - 0xee, 0xcc, 0x8c, 0xf4, 0x8b, 0xa8, 0xaa, 0x71, 0x8b, 0xa1, 0x78, 0x19, 0xef, 0x66, 0xc4, 0xeb, - 0x7c, 0xf1, 0x6e, 0xf8, 0xbd, 0x1b, 0xf9, 0xb1, 0x18, 0xc9, 0xc0, 0x30, 0x80, 0xc4, 0x48, 0xc6, - 0xc2, 0x20, 0x8d, 0x04, 0x32, 0x3b, 0x16, 0x6c, 0x00, 0x8d, 0x00, 0x01, 0x0b, 0x76, 0x48, 0x2c, - 0x6c, 0x58, 0x21, 0x40, 0x02, 0xd9, 0x4b, 0x16, 0x48, 0x6c, 0x06, 0x21, 0x16, 0xe8, 0x9c, 0x7b, - 0xdf, 0x27, 0x3e, 0x95, 0x15, 0xd5, 0x63, 0x60, 0x95, 0x71, 0xcf, 0x3b, 0xe7, 0xdc, 0xff, 0xf9, - 0xdf, 0x84, 0x37, 0x46, 0x67, 0xfd, 0x87, 0xbe, 0x77, 0xf2, 0x70, 0x74, 0xf2, 0x70, 0x28, 0x5d, - 0xe1, 0x3f, 0x1c, 0x85, 0x52, 0xc9, 0x48, 0x37, 0xa2, 0x0d, 0x6a, 0xf1, 0x15, 0x27, 0xb8, 0x52, - 0x57, 0x23, 0xb1, 0x41, 0xd0, 0xe6, 0x9d, 0xbe, 0x94, 0x7d, 0x5f, 0x68, 0xd4, 0x93, 0xf1, 0xe9, - 0xc3, 0x48, 0x85, 0xe3, 0x9e, 0xd2, 0xc8, 0xd6, 0xcf, 0x8b, 0x70, 0xab, 0x33, 0x74, 0x42, 0xb5, - 0xe5, 0xcb, 0xde, 0x59, 0x27, 0x70, 0x46, 0xd1, 0x40, 0xaa, 0x2d, 0x27, 0x12, 0xfc, 0x2d, 0x28, - 0x9f, 0x20, 0x30, 0x6a, 0xe4, 0xee, 0x15, 0xee, 0xd7, 0x1f, 0xdd, 0xdc, 0x98, 0x60, 0xbc, 0x41, - 0x14, 0xb6, 0xc1, 0xe1, 0xef, 0x40, 0xc5, 0x15, 0xca, 0xf1, 0xfc, 0xa8, 0x91, 0xbf, 0x97, 0xbb, - 0x5f, 0x7f, 0x74, 0x7b, 0x43, 0x77, 0xbc, 0x11, 0x77, 0xbc, 0xd1, 0xa1, 0x8e, 0xed, 0x18, 0x8f, - 0x7f, 0x08, 0xd5, 0x53, 0xcf, 0x17, 0x9f, 0x89, 0xab, 0xa8, 0x51, 0xb8, 0x96, 0x66, 0x2b, 0xdf, - 0xc8, 0xd9, 0x09, 0x32, 0xdf, 0x86, 0x55, 0x71, 0xa9, 0x42, 0xc7, 0x16, 0xbe, 0xa3, 0x3c, 0x19, - 0x44, 0x8d, 0x22, 0x8d, 0xf0, 0xf6, 0xd4, 0x08, 0xe3, 0xef, 0x44, 0x3e, 0x45, 0xc2, 0xef, 0x41, - 0x5d, 0x9e, 0x7c, 0x21, 0x7a, 0xaa, 0x7b, 0x35, 0x12, 0x51, 0xa3, 0x74, 0xaf, 0x70, 0xbf, 0x66, - 0x67, 0x41, 0xfc, 0x1b, 0x50, 0xef, 0x49, 0xdf, 0x17, 0x3d, 0xdd, 0x47, 0xf9, 0xfa, 0x69, 0x65, - 0x71, 0xf9, 0x7b, 0xf0, 0x5a, 0x28, 0x86, 0xf2, 0x5c, 0xb8, 0xdb, 0x09, 0x94, 0xe6, 0x59, 0xa5, - 0x6e, 0xe6, 0x7f, 0xe4, 0x9b, 0xb0, 0x12, 0x9a, 0xf1, 0x1d, 0x78, 0xc1, 0x59, 0xd4, 0xa8, 0xd0, - 0xb4, 0x5e, 0x7f, 0xc1, 0xb4, 0x10, 0xc7, 0x9e, 0xa4, 0xe0, 0x0c, 0x0a, 0x67, 0xe2, 0xaa, 0x51, - 0xbb, 0x97, 0xbb, 0x5f, 0xb3, 0xf1, 0x27, 0xff, 0x18, 0x1a, 0x32, 0xf4, 0xfa, 0x5e, 0xe0, 0xf8, - 0xdb, 0xa1, 0x70, 0x94, 0x70, 0xbb, 0xde, 0x50, 0x44, 0xca, 0x19, 0x8e, 0x1a, 0x70, 0x2f, 0x77, - 0xbf, 0x60, 0xbf, 0xf0, 0x3b, 0x7f, 0x57, 0xef, 0x50, 0x2b, 0x38, 0x95, 0x8d, 0xba, 0x99, 0xfe, - 0xe4, 0x58, 0xf6, 0xcc, 0x67, 0x3b, 0x41, 0xb4, 0xfe, 0xe3, 0x1e, 0x94, 0xe8, 0x6c, 0xf0, 0x55, - 0xc8, 0x7b, 0x6e, 0x23, 0x47, 0x63, 0xc9, 0x7b, 0x2e, 0x7f, 0x08, 0xe5, 0x53, 0x4f, 0xf8, 0xee, - 0x4b, 0x8f, 0x88, 0x41, 0xe3, 0xbb, 0xb0, 0x1c, 0x8a, 0x48, 0x85, 0x9e, 0xd9, 0x02, 0x7d, 0x4a, - 0x7e, 0x63, 0xde, 0x41, 0xdc, 0xb0, 0x33, 0x88, 0xf6, 0x04, 0x19, 0x6e, 0x75, 0x6f, 0xe0, 0xf9, - 0x6e, 0x28, 0x82, 0x96, 0xab, 0x0f, 0x4b, 0xcd, 0xce, 0x82, 0xf8, 0x7d, 0x58, 0x3b, 0x71, 0x7a, - 0x67, 0xfd, 0x50, 0x8e, 0x03, 0xdc, 0x15, 0x19, 0x36, 0x4a, 0x34, 0xec, 0x69, 0x30, 0x7f, 0x1b, - 0x4a, 0x8e, 0xef, 0xf5, 0x03, 0x3a, 0x0e, 0xab, 0x8f, 0x9a, 0x73, 0xc7, 0xb2, 0x89, 0x18, 0xb6, - 0x46, 0xe4, 0xfb, 0xb0, 0x72, 0x2e, 0x42, 0xe5, 0xf5, 0x1c, 0x9f, 0xe0, 0x8d, 0x0a, 0x51, 0x5a, - 0x73, 0x29, 0x9f, 0x66, 0x31, 0xed, 0x49, 0x42, 0xde, 0x02, 0x88, 0xf0, 0xae, 0xd2, 0x95, 0x33, - 0x1b, 0xf2, 0x95, 0xb9, 0x6c, 0xb6, 0x65, 0xa0, 0x44, 0xa0, 0x36, 0x3a, 0x09, 0xfa, 0xfe, 0x92, - 0x9d, 0x21, 0xe6, 0x1f, 0x42, 0x51, 0x89, 0x4b, 0xd5, 0x58, 0xbd, 0x66, 0x45, 0x63, 0x26, 0x5d, - 0x71, 0xa9, 0xf6, 0x97, 0x6c, 0x22, 0x40, 0x42, 0xdc, 0xe9, 0xc6, 0xda, 0x02, 0x84, 0x78, 0x38, - 0x90, 0x10, 0x09, 0xf8, 0x27, 0x50, 0xf6, 0x9d, 0x2b, 0x39, 0x56, 0x0d, 0x46, 0xa4, 0xbf, 0x79, - 0x2d, 0xe9, 0x01, 0xa1, 0xee, 0x2f, 0xd9, 0x86, 0x88, 0xbf, 0x07, 0x05, 0xd7, 0x3b, 0x6f, 0xac, - 0x13, 0xed, 0xbd, 0x6b, 0x69, 0x77, 0xbc, 0xf3, 0xfd, 0x25, 0x1b, 0xd1, 0xf9, 0x36, 0x54, 0x4f, - 0xa4, 0x3c, 0x1b, 0x3a, 0xe1, 0x59, 0x83, 0x13, 0xe9, 0x6f, 0x5d, 0x4b, 0xba, 0x65, 0x90, 0xf7, - 0x97, 0xec, 0x84, 0x10, 0xa7, 0xec, 0xf5, 0x64, 0xd0, 0xb8, 0xb1, 0xc0, 0x94, 0x5b, 0x3d, 0x19, - 0xe0, 0x94, 0x91, 0x00, 0x09, 0x7d, 0x2f, 0x38, 0x6b, 0xdc, 0x5c, 0x80, 0x10, 0xaf, 0x2f, 0x12, - 0x22, 0x01, 0x0e, 0xdb, 0x75, 0x94, 0x73, 0xee, 0x89, 0x8b, 0xc6, 0x6b, 0x0b, 0x0c, 0x7b, 0xc7, - 0x20, 0xe3, 0xb0, 0x63, 0x42, 0x64, 0x12, 0xcb, 0x86, 0xc6, 0xad, 0x05, 0x98, 0xc4, 0x62, 0x05, - 0x99, 0xc4, 0x84, 0xfc, 0xcf, 0xc1, 0xfa, 0xa9, 0x70, 0xd4, 0x38, 0x14, 0x6e, 0x2a, 0x6d, 0x6f, - 0x13, 0xb7, 0x8d, 0xeb, 0xf7, 0x7e, 0x9a, 0x6a, 0x7f, 0xc9, 0x9e, 0x65, 0xc5, 0x3f, 0x86, 0x92, - 0xef, 0x28, 0x71, 0xd9, 0x68, 0x10, 0x4f, 0xeb, 0x25, 0x87, 0x42, 0x89, 0xcb, 0xfd, 0x25, 0x5b, - 0x93, 0xf0, 0xdf, 0x81, 0x35, 0xe5, 0x9c, 0xf8, 0xa2, 0x7d, 0x6a, 0x10, 0xa2, 0xc6, 0xaf, 0x11, - 0x97, 0xb7, 0xae, 0x3f, 0xce, 0x93, 0x34, 0xfb, 0x4b, 0xf6, 0x34, 0x1b, 0x1c, 0x15, 0x81, 0x1a, - 0xcd, 0x05, 0x46, 0x45, 0xfc, 0x70, 0x54, 0x44, 0xc2, 0x0f, 0xa0, 0x4e, 0x3f, 0xb6, 0xa5, 0x3f, - 0x1e, 0x06, 0x8d, 0xd7, 0x89, 0xc3, 0xfd, 0x97, 0x73, 0xd0, 0xf8, 0xfb, 0x4b, 0x76, 0x96, 0x1c, - 0x37, 0x91, 0x9a, 0xb6, 0xbc, 0x68, 0xdc, 0x59, 0x60, 0x13, 0xbb, 0x06, 0x19, 0x37, 0x31, 0x26, - 0xc4, 0xab, 0x77, 0xe1, 0xb9, 0x7d, 0xa1, 0x1a, 0xbf, 0xbe, 0xc0, 0xd5, 0x7b, 0x46, 0xa8, 0x78, - 0xf5, 0x34, 0x51, 0xf3, 0x07, 0xb0, 0x9c, 0x15, 0xae, 0x9c, 0x43, 0x31, 0x14, 0x8e, 0x16, 0xec, - 0x55, 0x9b, 0x7e, 0x23, 0x4c, 0xb8, 0x9e, 0x22, 0xc1, 0x5e, 0xb5, 0xe9, 0x37, 0xbf, 0x05, 0x65, - 0xad, 0xe7, 0x48, 0x6e, 0x57, 0x6d, 0xd3, 0x42, 0x5c, 0x37, 0x74, 0xfa, 0x8d, 0xa2, 0xc6, 0xc5, - 0xdf, 0x88, 0xeb, 0x86, 0x72, 0xd4, 0x0e, 0x48, 0xee, 0x56, 0x6d, 0xd3, 0x6a, 0xfe, 0xb5, 0x8f, - 0xa0, 0x62, 0x06, 0xd6, 0xfc, 0xbb, 0x39, 0x28, 0x6b, 0xb9, 0xc0, 0x3f, 0x85, 0x52, 0xa4, 0xae, - 0x7c, 0x41, 0x63, 0x58, 0x7d, 0xf4, 0xd5, 0x05, 0x64, 0xc9, 0x46, 0x07, 0x09, 0x6c, 0x4d, 0x67, - 0xd9, 0x50, 0xa2, 0x36, 0xaf, 0x40, 0xc1, 0x96, 0x17, 0x6c, 0x89, 0x03, 0x94, 0xf5, 0x9a, 0xb3, - 0x1c, 0x02, 0x77, 0xbc, 0x73, 0x96, 0x47, 0xe0, 0xbe, 0x70, 0x5c, 0x11, 0xb2, 0x02, 0x5f, 0x81, - 0x5a, 0xbc, 0xba, 0x11, 0x2b, 0x72, 0x06, 0xcb, 0x99, 0x7d, 0x8b, 0x58, 0xa9, 0xf9, 0x3f, 0x8a, - 0x50, 0xc4, 0x6b, 0xcc, 0xdf, 0x80, 0x15, 0xe5, 0x84, 0x7d, 0xa1, 0x8d, 0xaa, 0x56, 0xac, 0x02, - 0x27, 0x81, 0xfc, 0x93, 0x78, 0x0e, 0x79, 0x9a, 0xc3, 0x57, 0x5e, 0x2a, 0x1e, 0x26, 0x66, 0x90, - 0x51, 0xa6, 0x85, 0xc5, 0x94, 0xe9, 0x1e, 0x54, 0x51, 0x2a, 0x75, 0xbc, 0x1f, 0x08, 0x5a, 0xfa, - 0xd5, 0x47, 0x0f, 0x5e, 0xde, 0x65, 0xcb, 0x50, 0xd8, 0x09, 0x2d, 0x6f, 0x41, 0xad, 0xe7, 0x84, - 0x2e, 0x0d, 0x86, 0x76, 0x6b, 0xf5, 0xd1, 0xd7, 0x5e, 0xce, 0x68, 0x3b, 0x26, 0xb1, 0x53, 0x6a, - 0xde, 0x86, 0xba, 0x2b, 0xa2, 0x5e, 0xe8, 0x8d, 0x48, 0x4a, 0x69, 0x95, 0xfa, 0xf5, 0x97, 0x33, - 0xdb, 0x49, 0x89, 0xec, 0x2c, 0x07, 0x7e, 0x07, 0x6a, 0x61, 0x22, 0xa6, 0x2a, 0xa4, 0xe7, 0x53, - 0x80, 0xf5, 0x21, 0x54, 0xe3, 0xf9, 0xf0, 0x65, 0xa8, 0xe2, 0xdf, 0x23, 0x19, 0x08, 0xb6, 0x84, - 0x7b, 0x8b, 0xad, 0xce, 0xd0, 0xf1, 0x7d, 0x96, 0xe3, 0xab, 0x00, 0xd8, 0x3c, 0x14, 0xae, 0x37, - 0x1e, 0xb2, 0xbc, 0xf5, 0xdb, 0xf1, 0x69, 0xa9, 0x42, 0xf1, 0xd8, 0xe9, 0x23, 0xc5, 0x32, 0x54, - 0x63, 0xa9, 0xcb, 0x72, 0x48, 0xbf, 0xe3, 0x44, 0x83, 0x13, 0xe9, 0x84, 0x2e, 0xcb, 0xf3, 0x3a, - 0x54, 0x36, 0xc3, 0xde, 0xc0, 0x3b, 0x17, 0xac, 0x60, 0x3d, 0x84, 0x7a, 0x66, 0xbc, 0xc8, 0xc2, - 0x74, 0x5a, 0x83, 0xd2, 0xa6, 0xeb, 0x0a, 0x97, 0xe5, 0x90, 0xc0, 0x4c, 0x90, 0xe5, 0xad, 0xaf, - 0x41, 0x2d, 0x59, 0x2d, 0x44, 0x47, 0xfd, 0xcb, 0x96, 0xf0, 0x17, 0x82, 0x59, 0x0e, 0x4f, 0x65, - 0x2b, 0xf0, 0xbd, 0x40, 0xb0, 0x7c, 0xf3, 0xcf, 0xd3, 0x51, 0xe5, 0xdf, 0x9c, 0xbc, 0x10, 0x6f, - 0xbe, 0x4c, 0x41, 0x4e, 0xde, 0x86, 0xd7, 0x33, 0xf3, 0x3b, 0xf0, 0x68, 0x70, 0x55, 0x28, 0xee, - 0x48, 0x15, 0xb1, 0x5c, 0xf3, 0xbf, 0xe5, 0xa1, 0x1a, 0xeb, 0x45, 0xb4, 0x2f, 0xc7, 0xa1, 0x6f, - 0x0e, 0x34, 0xfe, 0xe4, 0x37, 0xa1, 0xa4, 0x3c, 0x65, 0x8e, 0x71, 0xcd, 0xd6, 0x0d, 0x34, 0xb9, - 0xb2, 0x3b, 0x5b, 0xa0, 0x6f, 0xd3, 0x5b, 0xe5, 0x0d, 0x9d, 0xbe, 0xd8, 0x77, 0xa2, 0x01, 0x9d, - 0xc7, 0x9a, 0x9d, 0x02, 0x90, 0xfe, 0xd4, 0x39, 0xc7, 0x33, 0x47, 0xdf, 0xb5, 0x31, 0x96, 0x05, - 0xf1, 0x77, 0xa1, 0x88, 0x13, 0x34, 0x87, 0xe6, 0xcf, 0x4c, 0x4d, 0x18, 0x8f, 0xc9, 0x71, 0x28, - 0x70, 0x7b, 0x36, 0xd0, 0x9a, 0xb7, 0x09, 0x99, 0xbf, 0x09, 0xab, 0xfa, 0x12, 0xb6, 0xc9, 0xce, - 0x6f, 0xb9, 0x64, 0x8c, 0xd5, 0xec, 0x29, 0x28, 0xdf, 0xc4, 0xe5, 0x74, 0x94, 0x68, 0x54, 0x17, - 0x38, 0xdf, 0xf1, 0xe2, 0x6c, 0x74, 0x90, 0xc4, 0xd6, 0x94, 0xd6, 0xfb, 0xb8, 0xa6, 0x8e, 0x12, - 0xb8, 0xcd, 0xbb, 0xc3, 0x91, 0xba, 0xd2, 0x87, 0x66, 0x4f, 0xa8, 0xde, 0xc0, 0x0b, 0xfa, 0x2c, - 0xa7, 0x97, 0x18, 0x37, 0x91, 0x50, 0xc2, 0x50, 0x86, 0xac, 0xd0, 0x6c, 0x42, 0x11, 0xcf, 0x28, - 0x0a, 0xc9, 0xc0, 0x19, 0x0a, 0xb3, 0xd2, 0xf4, 0xbb, 0x79, 0x03, 0xd6, 0x67, 0xd4, 0x6a, 0xf3, - 0x9f, 0x97, 0xf5, 0x09, 0x41, 0x0a, 0x32, 0xe9, 0x0c, 0x05, 0x59, 0x6b, 0xaf, 0x24, 0x63, 0x90, - 0xcb, 0xa4, 0x8c, 0xf9, 0x04, 0x4a, 0x38, 0xb1, 0x58, 0xc4, 0x2c, 0x40, 0x7e, 0x88, 0xe8, 0xb6, - 0xa6, 0xe2, 0x0d, 0xa8, 0xf4, 0x06, 0xa2, 0x77, 0x26, 0x5c, 0x23, 0xeb, 0xe3, 0x26, 0x1e, 0x9a, - 0x5e, 0xc6, 0xca, 0xd6, 0x0d, 0x3a, 0x12, 0x3d, 0x19, 0xec, 0x0e, 0xe5, 0x17, 0x1e, 0xed, 0x2b, - 0x1e, 0x89, 0x18, 0x10, 0x7f, 0x6d, 0xe1, 0x19, 0x31, 0xdb, 0x96, 0x02, 0x9a, 0xbb, 0x50, 0xa2, - 0xbe, 0xf1, 0x26, 0xe8, 0x31, 0x6b, 0xaf, 0xf5, 0xcd, 0xc5, 0xc6, 0x6c, 0x86, 0xdc, 0xfc, 0x87, - 0x79, 0x28, 0x62, 0x9b, 0x3f, 0x80, 0x52, 0xe8, 0x04, 0x7d, 0xbd, 0x01, 0xb3, 0xce, 0xaf, 0x8d, - 0xdf, 0x6c, 0x8d, 0xc2, 0x3f, 0x35, 0x47, 0x31, 0xbf, 0xc0, 0x61, 0x49, 0x7a, 0xcc, 0x1e, 0xcb, - 0x9b, 0x50, 0x1a, 0x39, 0xa1, 0x33, 0x34, 0xf7, 0x44, 0x37, 0xac, 0x9f, 0xe6, 0xa0, 0x88, 0x48, - 0x7c, 0x1d, 0x56, 0x3a, 0x2a, 0xf4, 0xce, 0x84, 0x1a, 0x84, 0x72, 0xdc, 0x1f, 0xe8, 0x93, 0xf4, - 0x99, 0xb8, 0xd2, 0xf2, 0x46, 0x0b, 0x04, 0xe5, 0xf8, 0x5e, 0x8f, 0xe5, 0xf1, 0x54, 0x6d, 0x49, - 0xdf, 0x65, 0x05, 0xbe, 0x06, 0xf5, 0x27, 0x81, 0x2b, 0xc2, 0xa8, 0x27, 0x43, 0xe1, 0xb2, 0xa2, - 0xb9, 0xdd, 0x67, 0xac, 0x44, 0xba, 0x4c, 0x5c, 0x2a, 0x72, 0x69, 0x58, 0x99, 0xdf, 0x80, 0xb5, - 0xad, 0x49, 0x3f, 0x87, 0x55, 0x50, 0x26, 0x1d, 0x8a, 0x00, 0x0f, 0x19, 0xab, 0xea, 0x43, 0x2c, - 0xbf, 0xf0, 0x58, 0x0d, 0x3b, 0xd3, 0xf7, 0x84, 0x81, 0xf5, 0x2f, 0x73, 0xb1, 0xe4, 0x58, 0x81, - 0xda, 0xb1, 0x13, 0x3a, 0xfd, 0xd0, 0x19, 0xe1, 0xf8, 0xea, 0x50, 0xd1, 0x8a, 0xf3, 0x1d, 0x2d, - 0xdd, 0x74, 0xe3, 0x91, 0x96, 0x8d, 0xba, 0xf1, 0x2e, 0x2b, 0xa4, 0x8d, 0xf7, 0x58, 0x11, 0xfb, - 0xf8, 0xee, 0x58, 0x2a, 0xc1, 0x4a, 0x24, 0xeb, 0xa4, 0x2b, 0x58, 0x19, 0x81, 0x5d, 0x94, 0x28, - 0xac, 0x82, 0x73, 0xde, 0xc6, 0xf3, 0x73, 0x22, 0x2f, 0x59, 0x15, 0x87, 0x81, 0xcb, 0x28, 0x5c, - 0x56, 0xc3, 0x2f, 0x47, 0xe3, 0xe1, 0x89, 0xc0, 0x69, 0x02, 0x7e, 0xe9, 0xca, 0x7e, 0xdf, 0x17, - 0xac, 0x8e, 0x6b, 0x90, 0x11, 0xbe, 0x6c, 0x99, 0x24, 0xad, 0xe3, 0xfb, 0x72, 0xac, 0xd8, 0x4a, - 0xf3, 0x7f, 0x16, 0xa0, 0x88, 0x4e, 0x0a, 0xde, 0x9d, 0x01, 0xca, 0x19, 0x73, 0x77, 0xf0, 0x77, - 0x72, 0x03, 0xf3, 0xe9, 0x0d, 0xe4, 0x1f, 0x9b, 0x9d, 0x2e, 0x2c, 0x20, 0x65, 0x91, 0x71, 0x76, - 0x93, 0x39, 0x14, 0x87, 0xde, 0x50, 0x18, 0x59, 0x47, 0xbf, 0x11, 0x16, 0xa1, 0x3e, 0x2e, 0x91, - 0x23, 0x4e, 0xbf, 0xf1, 0xd6, 0x38, 0xa8, 0x16, 0x36, 0x15, 0xdd, 0x81, 0x82, 0x1d, 0x37, 0xe7, - 0x48, 0xaf, 0xda, 0x5c, 0xe9, 0xf5, 0x49, 0x2c, 0xbd, 0x2a, 0x0b, 0xdc, 0x7a, 0x1a, 0x66, 0x56, - 0x72, 0xa5, 0x42, 0xa3, 0xba, 0x38, 0x79, 0x46, 0x99, 0xec, 0x98, 0x53, 0x9b, 0x2a, 0xba, 0xaa, - 0x5e, 0x65, 0x96, 0xc3, 0xdd, 0xa4, 0xeb, 0xaa, 0x65, 0xde, 0x53, 0xcf, 0x15, 0x92, 0x15, 0x48, - 0x11, 0x8e, 0x5d, 0x4f, 0xb2, 0x22, 0x5a, 0x5e, 0xc7, 0x3b, 0x7b, 0xac, 0x64, 0xbd, 0x99, 0x51, - 0x49, 0x9b, 0x63, 0x25, 0x35, 0x1b, 0x3a, 0xbe, 0x39, 0x7d, 0x1a, 0x4f, 0x84, 0xcb, 0xf2, 0xd6, - 0x07, 0x73, 0xc4, 0xec, 0x0a, 0xd4, 0x9e, 0x8c, 0x7c, 0xe9, 0xb8, 0xd7, 0xc8, 0xd9, 0x65, 0x80, - 0xd4, 0x39, 0x6e, 0xfe, 0xf0, 0x6e, 0xaa, 0xce, 0xd1, 0x16, 0x8d, 0xe4, 0x38, 0xec, 0x09, 0x12, - 0x21, 0x35, 0xdb, 0xb4, 0xf8, 0xb7, 0xa1, 0x84, 0xdf, 0xa3, 0x46, 0x9e, 0x24, 0xcb, 0x83, 0x85, - 0x5c, 0xb2, 0x8d, 0xa7, 0x9e, 0xb8, 0xb0, 0x35, 0x21, 0x7f, 0x3f, 0x6b, 0x9e, 0x5c, 0x1f, 0xb3, - 0xca, 0xd8, 0x2d, 0xfc, 0x2e, 0x80, 0xd3, 0x53, 0xde, 0xb9, 0x40, 0x5e, 0x46, 0x46, 0x64, 0x20, - 0xdc, 0x86, 0x3a, 0x5e, 0xdd, 0x51, 0x3b, 0xc4, 0xdb, 0xde, 0x58, 0x26, 0xc6, 0x6f, 0x2f, 0x36, - 0xbc, 0xc7, 0x09, 0xa1, 0x9d, 0x65, 0xc2, 0x9f, 0xc0, 0xb2, 0x8e, 0x85, 0x19, 0xa6, 0x2b, 0xc4, - 0xf4, 0x9d, 0xc5, 0x98, 0xb6, 0x53, 0x4a, 0x7b, 0x82, 0xcd, 0x6c, 0x88, 0xab, 0xf4, 0xca, 0x21, - 0xae, 0x37, 0x61, 0xb5, 0x3b, 0x79, 0x0b, 0xb4, 0xaa, 0x98, 0x82, 0x72, 0x0b, 0x96, 0xbd, 0x28, - 0x8d, 0xb0, 0x51, 0xa8, 0xa3, 0x6a, 0x4f, 0xc0, 0x9a, 0xff, 0xae, 0x0c, 0x45, 0x5a, 0xc2, 0xe9, - 0x50, 0xd5, 0xf6, 0x84, 0x48, 0x7f, 0xb8, 0xf8, 0x56, 0x4f, 0xdd, 0x78, 0x92, 0x20, 0x85, 0x8c, - 0x04, 0xf9, 0x36, 0x94, 0x22, 0x19, 0xaa, 0x78, 0xfb, 0x17, 0x3c, 0x44, 0x1d, 0x19, 0x2a, 0x5b, - 0x13, 0xf2, 0x3d, 0xa8, 0x9c, 0x7a, 0xbe, 0xc2, 0x4d, 0xd1, 0x8b, 0xf7, 0xd6, 0x62, 0x3c, 0xf6, - 0x88, 0xc8, 0x8e, 0x89, 0xf9, 0x41, 0xf6, 0x30, 0x96, 0x89, 0xd3, 0xc6, 0x62, 0x9c, 0xe6, 0x9d, - 0xd1, 0x07, 0xc0, 0x7a, 0xf2, 0x5c, 0x84, 0xf1, 0xb7, 0xcf, 0xc4, 0x95, 0x51, 0xd2, 0x33, 0x70, - 0xde, 0x84, 0xea, 0xc0, 0x73, 0x05, 0xda, 0x39, 0x24, 0x63, 0xaa, 0x76, 0xd2, 0xe6, 0x9f, 0x41, - 0x95, 0xfc, 0x03, 0x94, 0x8a, 0xb5, 0x57, 0x5e, 0x7c, 0xed, 0xaa, 0xc4, 0x0c, 0xb0, 0x23, 0xea, - 0x7c, 0xcf, 0x53, 0x14, 0xeb, 0xac, 0xda, 0x49, 0x1b, 0x07, 0x4c, 0xe7, 0x3d, 0x3b, 0xe0, 0xba, - 0x1e, 0xf0, 0x34, 0x9c, 0xbf, 0x07, 0xaf, 0x11, 0x6c, 0x4a, 0x49, 0xe2, 0x55, 0x43, 0xa6, 0xf3, - 0x3f, 0xa2, 0xc1, 0x32, 0x72, 0xfa, 0xe2, 0xc0, 0x1b, 0x7a, 0xaa, 0xb1, 0x72, 0x2f, 0x77, 0xbf, - 0x64, 0xa7, 0x00, 0xfe, 0x16, 0xac, 0xbb, 0xe2, 0xd4, 0x19, 0xfb, 0xaa, 0x2b, 0x86, 0x23, 0xdf, - 0x51, 0xa2, 0xe5, 0xd2, 0x19, 0xad, 0xd9, 0xb3, 0x1f, 0xf8, 0xdb, 0x70, 0xc3, 0x00, 0xdb, 0x49, - 0x84, 0xba, 0xe5, 0x52, 0x14, 0xae, 0x66, 0xcf, 0xfb, 0x64, 0x1d, 0x1a, 0x31, 0x8c, 0x0a, 0x14, - 0xfd, 0xd4, 0x58, 0x80, 0x46, 0x4a, 0x6b, 0xe4, 0xc7, 0x8e, 0xef, 0x8b, 0xf0, 0x4a, 0x3b, 0xb9, - 0x9f, 0x39, 0xc1, 0x89, 0x13, 0xb0, 0x02, 0xe9, 0x58, 0xc7, 0x17, 0x81, 0xeb, 0x84, 0x5a, 0x23, - 0x3f, 0x26, 0x85, 0x5e, 0xb2, 0xee, 0x43, 0x91, 0x96, 0xb4, 0x06, 0x25, 0xed, 0x25, 0x91, 0xc7, - 0x6c, 0x3c, 0x24, 0x92, 0xc8, 0x07, 0x78, 0xfd, 0x58, 0xbe, 0xf9, 0xcf, 0x0a, 0x50, 0x8d, 0x17, - 0x2f, 0x8e, 0x47, 0xe7, 0xd2, 0x78, 0x34, 0x9a, 0x71, 0xd1, 0x53, 0x2f, 0xf2, 0x4e, 0x8c, 0x59, - 0x5a, 0xb5, 0x53, 0x00, 0x5a, 0x42, 0x17, 0x9e, 0xab, 0x06, 0x74, 0x67, 0x4a, 0xb6, 0x6e, 0xf0, - 0xfb, 0xb0, 0xe6, 0xe2, 0x3a, 0x04, 0x3d, 0x7f, 0xec, 0x8a, 0x2e, 0x6a, 0x51, 0x1d, 0x26, 0x98, - 0x06, 0xf3, 0xef, 0x01, 0x28, 0x6f, 0x28, 0xf6, 0x64, 0x38, 0x74, 0x94, 0xf1, 0x0d, 0xbe, 0xf1, - 0x6a, 0xa7, 0x7a, 0xa3, 0x9b, 0x30, 0xb0, 0x33, 0xcc, 0x90, 0x35, 0xf6, 0x66, 0x58, 0x57, 0xbe, - 0x14, 0xeb, 0x9d, 0x84, 0x81, 0x9d, 0x61, 0x66, 0xfd, 0x59, 0x80, 0xf4, 0x0b, 0xbf, 0x05, 0xfc, - 0x50, 0x06, 0x6a, 0xb0, 0x79, 0x72, 0x12, 0x6e, 0x89, 0x53, 0x19, 0x8a, 0x1d, 0x07, 0xd5, 0xda, - 0x6b, 0xb0, 0x9e, 0xc0, 0x37, 0x4f, 0x95, 0x08, 0x11, 0x4c, 0x4b, 0xdf, 0x19, 0xc8, 0x50, 0x69, - 0xdb, 0x8a, 0x7e, 0x3e, 0xe9, 0xb0, 0x02, 0xaa, 0xd2, 0x56, 0xa7, 0xcd, 0x8a, 0xd6, 0x7d, 0x80, - 0x74, 0x4a, 0xe4, 0x83, 0xd0, 0xaf, 0x77, 0x1e, 0x19, 0x8f, 0x84, 0x5a, 0x8f, 0xde, 0x63, 0xb9, - 0xe6, 0x3f, 0xcd, 0x43, 0x11, 0x45, 0x8d, 0x11, 0x87, 0xe5, 0x44, 0x1c, 0xde, 0x83, 0x7a, 0xf6, - 0x9e, 0xe8, 0xed, 0xcc, 0x82, 0xbe, 0x9c, 0xc0, 0xc4, 0xbe, 0xb2, 0x02, 0xf3, 0x23, 0xa8, 0xf7, - 0xc6, 0x91, 0x92, 0x43, 0xd2, 0x16, 0x8d, 0x02, 0x09, 0xa5, 0x5b, 0x33, 0x81, 0x8d, 0xa7, 0x8e, - 0x3f, 0x16, 0x76, 0x16, 0x95, 0xbf, 0x0f, 0xe5, 0x53, 0xbd, 0x31, 0x3a, 0xb4, 0xf1, 0xeb, 0x2f, - 0x50, 0x28, 0x66, 0xf1, 0x0d, 0x32, 0xce, 0xcb, 0x9b, 0x39, 0x54, 0x59, 0x90, 0xf5, 0x5b, 0xe6, - 0x1a, 0x55, 0xa0, 0xb0, 0x19, 0xf5, 0x8c, 0x63, 0x2c, 0xa2, 0x9e, 0xb6, 0xba, 0xb7, 0x69, 0x08, - 0x2c, 0xdf, 0xfc, 0x59, 0x05, 0xca, 0x5a, 0xc0, 0x9a, 0xb5, 0xab, 0x25, 0x6b, 0xf7, 0x5d, 0xa8, - 0xca, 0x91, 0x08, 0x1d, 0x25, 0x43, 0xe3, 0x9d, 0xbf, 0xff, 0x2a, 0x02, 0x7b, 0xa3, 0x6d, 0x88, - 0xed, 0x84, 0xcd, 0xf4, 0x76, 0xe4, 0x67, 0xb7, 0xe3, 0x01, 0xb0, 0x58, 0x36, 0x1f, 0x87, 0x48, - 0xa7, 0xae, 0x8c, 0xaf, 0x35, 0x03, 0xe7, 0x5d, 0xa8, 0xf5, 0x64, 0xe0, 0x7a, 0x89, 0xa7, 0xbe, - 0xfa, 0xe8, 0x83, 0x57, 0x1a, 0xe1, 0x76, 0x4c, 0x6d, 0xa7, 0x8c, 0xf8, 0x5b, 0x50, 0x3a, 0xc7, - 0x7d, 0xa2, 0x0d, 0x79, 0xf1, 0x2e, 0x6a, 0x24, 0xfe, 0x39, 0xd4, 0xbf, 0x3f, 0xf6, 0x7a, 0x67, - 0xed, 0x6c, 0x24, 0xe8, 0xa3, 0x57, 0x1a, 0xc5, 0x77, 0x53, 0x7a, 0x3b, 0xcb, 0x2c, 0x73, 0x36, - 0x2a, 0x7f, 0x8a, 0xb3, 0x51, 0x9d, 0x3d, 0x1b, 0xaf, 0x43, 0x35, 0xde, 0x1c, 0x3a, 0x1f, 0x81, - 0xcb, 0x96, 0x78, 0x19, 0xf2, 0xed, 0x90, 0xe5, 0xac, 0xff, 0x9e, 0x83, 0x5a, 0xb2, 0x30, 0x93, - 0x51, 0x9f, 0xdd, 0xef, 0x8f, 0x1d, 0x9f, 0xe5, 0xc8, 0x6d, 0x91, 0x4a, 0xb7, 0xe8, 0xf2, 0x3e, - 0xa6, 0x04, 0x5c, 0xc8, 0x0a, 0x24, 0xaa, 0x45, 0x14, 0xb1, 0x22, 0xe7, 0xb0, 0x6a, 0xc0, 0xed, - 0x50, 0xa3, 0x96, 0xd0, 0xab, 0xc1, 0xaf, 0x31, 0xa0, 0xac, 0x25, 0xfb, 0x99, 0xd0, 0x5e, 0xdb, - 0x91, 0x54, 0xd4, 0xa8, 0xe2, 0x58, 0x5a, 0x01, 0xab, 0x61, 0x9f, 0x47, 0x52, 0xb5, 0x02, 0x06, - 0xa9, 0x99, 0x5c, 0x8f, 0xbb, 0xa7, 0xd6, 0x32, 0x19, 0xe1, 0xbe, 0xdf, 0x0a, 0xd8, 0x8a, 0xf9, - 0xa0, 0x5b, 0xab, 0xc8, 0x71, 0xf7, 0xd2, 0xe9, 0x21, 0xf9, 0x1a, 0x5f, 0x05, 0x40, 0x1a, 0xd3, - 0x66, 0x78, 0x07, 0x76, 0x2f, 0xbd, 0x48, 0x45, 0x6c, 0xdd, 0xfa, 0xb7, 0x39, 0xa8, 0x67, 0x36, - 0x01, 0xcd, 0x70, 0x42, 0x44, 0xd1, 0xa6, 0xad, 0xf2, 0xef, 0x89, 0x48, 0x89, 0xd0, 0x8d, 0xc5, - 0x56, 0x57, 0xe2, 0xcf, 0x3c, 0xf6, 0xd7, 0x95, 0x43, 0x19, 0x86, 0xf2, 0x42, 0xab, 0xa0, 0x03, - 0x27, 0x52, 0xcf, 0x84, 0x38, 0x63, 0x45, 0x9c, 0xea, 0xf6, 0x38, 0x0c, 0x45, 0xa0, 0x01, 0x25, - 0x1a, 0x9c, 0xb8, 0xd4, 0xad, 0x32, 0x32, 0x45, 0x64, 0x92, 0x8b, 0xac, 0xc2, 0x19, 0x2c, 0x1b, - 0x6c, 0x0d, 0xa9, 0x22, 0x02, 0xa2, 0xeb, 0x66, 0x0d, 0x3d, 0x5d, 0xed, 0x29, 0xb6, 0x4f, 0x77, - 0x9c, 0xab, 0x68, 0xb3, 0x2f, 0x19, 0x4c, 0x03, 0x8f, 0xe4, 0x05, 0xab, 0x37, 0xc7, 0x00, 0xa9, - 0x6d, 0x8c, 0x3e, 0x01, 0x9e, 0xb5, 0x24, 0x96, 0x6b, 0x5a, 0xbc, 0x0d, 0x80, 0xbf, 0x08, 0x33, - 0x76, 0x0c, 0x5e, 0xc1, 0x60, 0x21, 0x3a, 0x3b, 0xc3, 0xa2, 0xf9, 0x7b, 0x50, 0x4b, 0x3e, 0xa0, - 0x2b, 0x48, 0xa6, 0x45, 0xd2, 0x6d, 0xdc, 0x44, 0x3d, 0xe9, 0x05, 0xae, 0xb8, 0xa4, 0xbb, 0x5f, - 0xb2, 0x75, 0x03, 0x47, 0x39, 0xf0, 0x5c, 0x57, 0x04, 0x71, 0xc4, 0x5d, 0xb7, 0xe6, 0xa5, 0x37, - 0x8b, 0x73, 0xd3, 0x9b, 0xcd, 0xdf, 0x85, 0x7a, 0xc6, 0x78, 0x7f, 0xe1, 0xb4, 0x33, 0x03, 0xcb, - 0x4f, 0x0e, 0xec, 0x0e, 0xd4, 0xa4, 0xb1, 0xc0, 0x23, 0x12, 0xe0, 0x35, 0x3b, 0x05, 0xa0, 0x82, - 0x29, 0xe9, 0xa9, 0x4d, 0x1b, 0xdc, 0x7b, 0x50, 0x46, 0xef, 0x73, 0x1c, 0xe7, 0x86, 0x17, 0x34, - 0x6a, 0x3b, 0x44, 0xb3, 0xbf, 0x64, 0x1b, 0x6a, 0xfe, 0x09, 0x14, 0x94, 0xd3, 0x37, 0x01, 0xab, - 0xaf, 0x2e, 0xc6, 0xa4, 0xeb, 0xf4, 0xf7, 0x97, 0x6c, 0xa4, 0xe3, 0x07, 0x50, 0xed, 0x99, 0x18, - 0x83, 0x11, 0x5c, 0x0b, 0xda, 0xc4, 0x71, 0x64, 0x62, 0x7f, 0xc9, 0x4e, 0x38, 0xf0, 0x6f, 0x43, - 0x11, 0xb5, 0x3c, 0x49, 0xde, 0x85, 0x6d, 0x7d, 0xbc, 0x2e, 0xfb, 0x4b, 0x36, 0x51, 0x6e, 0x55, - 0xa0, 0x44, 0x72, 0xb2, 0xd9, 0x80, 0xb2, 0x9e, 0xeb, 0xf4, 0xca, 0x35, 0x6f, 0x43, 0xa1, 0xeb, - 0xf4, 0xd1, 0xd2, 0xf2, 0xdc, 0xc8, 0xb8, 0xac, 0xf8, 0xb3, 0xf9, 0x46, 0x1a, 0x2f, 0xc9, 0x86, - 0xe2, 0x72, 0x13, 0xa1, 0xb8, 0x66, 0x19, 0x8a, 0xd8, 0x63, 0xf3, 0xce, 0x75, 0x56, 0x5b, 0xf3, - 0x4f, 0xf2, 0x68, 0xe0, 0x29, 0x71, 0x39, 0x37, 0xcc, 0xf8, 0x1d, 0xa8, 0x8d, 0x42, 0xd9, 0x13, - 0x51, 0x24, 0x43, 0x63, 0x01, 0xbc, 0xf5, 0xf2, 0x4c, 0xde, 0xc6, 0x71, 0x4c, 0x63, 0xa7, 0xe4, - 0xd6, 0x1f, 0xe6, 0xa1, 0x96, 0x7c, 0xd0, 0x76, 0xa5, 0x12, 0x97, 0x3a, 0xa4, 0x74, 0x28, 0xc2, - 0xa1, 0xe3, 0xb9, 0x5a, 0x7a, 0x6c, 0x0f, 0x9c, 0xd8, 0xe8, 0xf9, 0x9e, 0x1c, 0xab, 0xf1, 0x89, - 0xd0, 0xa1, 0x84, 0xa7, 0xde, 0x50, 0x48, 0x56, 0xa4, 0x20, 0x3e, 0x1e, 0xec, 0x9e, 0x2f, 0xc7, - 0x2e, 0x2b, 0x61, 0xfb, 0x31, 0xa9, 0xa0, 0x43, 0x67, 0x14, 0x69, 0x99, 0x79, 0xe8, 0x85, 0x92, - 0x55, 0x90, 0x68, 0xcf, 0xeb, 0x0f, 0x1d, 0x56, 0x45, 0x66, 0xdd, 0x0b, 0x4f, 0xa1, 0x10, 0xae, - 0xf1, 0x75, 0x58, 0x69, 0x8f, 0x44, 0xd0, 0x51, 0xa1, 0x10, 0xea, 0xd0, 0x19, 0xe9, 0xd8, 0x92, - 0x2d, 0x5c, 0xd7, 0x53, 0x5a, 0x7e, 0xee, 0x39, 0x3d, 0x71, 0x22, 0xe5, 0x19, 0x5b, 0x46, 0x41, - 0xd3, 0x0a, 0x22, 0xe5, 0xf4, 0x43, 0x67, 0xa8, 0x65, 0x68, 0x57, 0xf8, 0x82, 0x5a, 0xab, 0xd4, - 0xb7, 0xa7, 0x06, 0xe3, 0x93, 0xc7, 0x68, 0x7f, 0xaf, 0xe9, 0x78, 0xbf, 0x2b, 0x46, 0x02, 0x65, - 0xe8, 0x32, 0x54, 0xb7, 0x3c, 0xdf, 0x3b, 0xf1, 0x7c, 0x8f, 0xad, 0x23, 0xea, 0xee, 0x65, 0xcf, - 0xf1, 0x3d, 0x37, 0x74, 0x2e, 0x18, 0x6f, 0xae, 0xc3, 0xda, 0x54, 0xc6, 0xb2, 0x59, 0x31, 0x26, - 0x7d, 0x73, 0x05, 0xea, 0x99, 0x1c, 0x54, 0xf3, 0x4d, 0xa8, 0xc6, 0x19, 0x2a, 0x74, 0x7d, 0xbc, - 0x48, 0xc7, 0xd6, 0xcc, 0x8e, 0x27, 0xed, 0xe6, 0x3f, 0xc9, 0x41, 0x59, 0x67, 0xf9, 0xf8, 0x56, - 0x92, 0x95, 0xcf, 0x2d, 0x90, 0x12, 0xd2, 0x44, 0x26, 0xa1, 0x96, 0xa4, 0xe6, 0x6f, 0x42, 0xc9, - 0x27, 0x1f, 0xc7, 0xc8, 0x22, 0x6a, 0x64, 0x44, 0x47, 0x21, 0x2b, 0x3a, 0xac, 0x0f, 0x93, 0x24, - 0x5e, 0x1c, 0xcf, 0x21, 0x9b, 0xaa, 0x1b, 0x0a, 0xa1, 0x63, 0x35, 0xe4, 0xa2, 0xe4, 0x49, 0xf0, - 0xcb, 0xe1, 0xc8, 0xe9, 0x29, 0x02, 0x14, 0xac, 0x53, 0xa8, 0x1e, 0xcb, 0x68, 0x5a, 0x9d, 0x56, - 0xa0, 0xd0, 0x95, 0x23, 0x6d, 0x8d, 0x6d, 0x49, 0x45, 0xd6, 0x98, 0xd6, 0x9e, 0xa7, 0x4a, 0x9f, - 0x07, 0xdb, 0xeb, 0x0f, 0x94, 0x76, 0x66, 0x5a, 0x41, 0x20, 0x42, 0x56, 0xc2, 0xe5, 0xb7, 0xc5, - 0xc8, 0x77, 0x7a, 0x82, 0x95, 0x71, 0xc1, 0x09, 0xbe, 0xe7, 0x85, 0x91, 0x62, 0x15, 0xeb, 0x43, - 0x54, 0x84, 0x5e, 0x9f, 0xf4, 0x17, 0xfd, 0x20, 0x56, 0x4b, 0x38, 0x20, 0x6a, 0x6e, 0x8b, 0x00, - 0x8f, 0x07, 0x65, 0x89, 0x74, 0x99, 0x06, 0x75, 0x90, 0xb7, 0x9e, 0xc1, 0xca, 0x44, 0xf9, 0x06, - 0xbf, 0x09, 0x6c, 0x02, 0x80, 0x03, 0x5d, 0xe2, 0xb7, 0xe1, 0xc6, 0x04, 0xf4, 0xd0, 0x73, 0x5d, - 0x0a, 0x8e, 0x4d, 0x7f, 0x88, 0xa7, 0xb3, 0x55, 0x83, 0x4a, 0x4f, 0xef, 0x80, 0x75, 0x0c, 0x2b, - 0xb4, 0x25, 0x87, 0x42, 0x39, 0xed, 0xc0, 0xbf, 0xfa, 0x53, 0xd7, 0xd8, 0x58, 0x5f, 0x83, 0x12, - 0x05, 0xb3, 0xf1, 0x62, 0x9f, 0x86, 0x72, 0x48, 0xbc, 0x4a, 0x36, 0xfd, 0x46, 0xee, 0x4a, 0x9a, - 0x7d, 0xcd, 0x2b, 0x69, 0xfd, 0x04, 0xa0, 0xb2, 0xd9, 0xeb, 0xc9, 0x71, 0xa0, 0x66, 0x7a, 0x9e, - 0x17, 0x2f, 0x7d, 0x1f, 0xca, 0xce, 0xb9, 0xa3, 0x9c, 0xd0, 0x08, 0xe4, 0x69, 0xd3, 0xcb, 0xf0, - 0xda, 0xd8, 0x24, 0x24, 0xdb, 0x20, 0x23, 0x59, 0x4f, 0x06, 0xa7, 0x5e, 0xdf, 0xc8, 0xe0, 0x17, - 0x91, 0x6d, 0x13, 0x92, 0x6d, 0x90, 0x91, 0xcc, 0xe8, 0x90, 0xd2, 0xb5, 0x64, 0x5a, 0x90, 0x26, - 0x2a, 0xe3, 0x21, 0x14, 0xbd, 0xe0, 0x54, 0x9a, 0x02, 0xaf, 0xd7, 0x5f, 0x40, 0x44, 0x55, 0x4e, - 0x84, 0xd8, 0x14, 0x50, 0xd6, 0x03, 0xe6, 0xdf, 0x80, 0x12, 0xe5, 0xac, 0x4c, 0x96, 0x60, 0xa1, - 0x72, 0x18, 0x4d, 0xc1, 0x6f, 0xc5, 0x29, 0x10, 0x5a, 0x2f, 0x84, 0x53, 0x73, 0xab, 0x1a, 0x2f, - 0x59, 0xf3, 0xbf, 0xe4, 0xa0, 0xac, 0x67, 0xc8, 0xdf, 0x84, 0x55, 0x11, 0xe0, 0xd5, 0x8e, 0xb5, - 0x84, 0xb9, 0xd3, 0x53, 0x50, 0xb4, 0x59, 0x0d, 0x44, 0x9c, 0x8c, 0xfb, 0xc6, 0xbd, 0xce, 0x82, - 0xf8, 0x47, 0x70, 0x5b, 0x37, 0x8f, 0x43, 0x11, 0x0a, 0x5f, 0x38, 0x91, 0xd8, 0x1e, 0x38, 0x41, - 0x20, 0x7c, 0x63, 0x33, 0xbc, 0xe8, 0x33, 0xb7, 0x60, 0x59, 0x7f, 0xea, 0x8c, 0x9c, 0x9e, 0x88, - 0x4c, 0x4a, 0x67, 0x02, 0xc6, 0xbf, 0x0e, 0x25, 0x2a, 0xb3, 0x6b, 0xb8, 0xd7, 0x1f, 0x3e, 0x8d, - 0xd5, 0x94, 0x89, 0x52, 0xdb, 0x04, 0xd0, 0xbb, 0x81, 0xce, 0x96, 0x91, 0x45, 0xbf, 0x71, 0xed, - 0xf6, 0x91, 0xdb, 0x98, 0x21, 0xc2, 0xf1, 0xb9, 0xc2, 0x17, 0x28, 0x1f, 0x50, 0xa1, 0xd1, 0xe4, - 0x0b, 0xf6, 0x04, 0xac, 0xf9, 0xfb, 0x45, 0x28, 0xe2, 0x46, 0x22, 0xf2, 0x40, 0x0e, 0x45, 0x12, - 0x42, 0xd4, 0x87, 0x76, 0x02, 0x86, 0x56, 0x93, 0xa3, 0xb3, 0xb8, 0x09, 0x9a, 0x16, 0x65, 0xd3, - 0x60, 0xc4, 0x1c, 0x85, 0xf2, 0xd4, 0xf3, 0x53, 0x4c, 0x63, 0x5f, 0x4d, 0x81, 0xf9, 0x07, 0x70, - 0x6b, 0xe8, 0x84, 0x67, 0x42, 0x91, 0xf4, 0x79, 0x26, 0xc3, 0xb3, 0x08, 0x57, 0xae, 0xe5, 0x9a, - 0xd8, 0xd3, 0x0b, 0xbe, 0xa2, 0x38, 0x77, 0xc5, 0xb9, 0x47, 0x98, 0x55, 0xc2, 0x4c, 0xda, 0x78, - 0x38, 0x1c, 0xbd, 0x34, 0x1d, 0xc3, 0xcb, 0xa4, 0x05, 0x26, 0xa1, 0x68, 0x9a, 0xe9, 0x8a, 0x8e, - 0xa8, 0xe5, 0x52, 0x38, 0xac, 0x66, 0xa7, 0x00, 0x3c, 0x3a, 0xd4, 0xd9, 0x53, 0x2d, 0xb4, 0x57, - 0xb4, 0x4f, 0x99, 0x01, 0x21, 0x86, 0x12, 0xbd, 0x41, 0xdc, 0x89, 0x8e, 0x55, 0x65, 0x41, 0xfc, - 0x2e, 0x40, 0xdf, 0x51, 0xe2, 0xc2, 0xb9, 0x7a, 0x12, 0xfa, 0x0d, 0xa1, 0x03, 0xd5, 0x29, 0x04, - 0xbd, 0x52, 0x5f, 0xf6, 0x1c, 0xbf, 0xa3, 0x64, 0xe8, 0xf4, 0xc5, 0xb1, 0xa3, 0x06, 0x8d, 0xbe, - 0xf6, 0x4a, 0xa7, 0xe1, 0x38, 0x63, 0xe5, 0x0d, 0xc5, 0xe7, 0x32, 0x10, 0x8d, 0x81, 0x9e, 0x71, - 0xdc, 0xc6, 0x91, 0x38, 0x81, 0xe3, 0x5f, 0x29, 0xaf, 0x87, 0x73, 0xf1, 0xf4, 0x48, 0x32, 0x20, - 0x9c, 0x6b, 0x20, 0xd4, 0x85, 0x0c, 0xcf, 0x5a, 0x6e, 0xe3, 0x0b, 0x3d, 0xd7, 0x04, 0x60, 0xb5, - 0x01, 0xd2, 0x43, 0x84, 0x9a, 0x63, 0x93, 0x82, 0xe9, 0x6c, 0x09, 0x5d, 0x81, 0x63, 0x11, 0xb8, - 0x5e, 0xd0, 0xdf, 0x31, 0xe7, 0x86, 0xe5, 0x10, 0xd8, 0x51, 0x4e, 0xa8, 0x84, 0x9b, 0x00, 0xc9, - 0xec, 0xa0, 0x96, 0x70, 0x59, 0xc1, 0xfa, 0xdf, 0x39, 0xa8, 0x67, 0x52, 0xce, 0xbf, 0xc2, 0x34, - 0x39, 0xea, 0x71, 0x94, 0x17, 0xb8, 0xa0, 0xfa, 0x4c, 0x25, 0x6d, 0x5c, 0x6e, 0x93, 0x11, 0xc7, - 0xaf, 0xda, 0xbd, 0xcf, 0x40, 0xbe, 0x54, 0x8a, 0xdc, 0x7a, 0x64, 0x02, 0x1e, 0x75, 0xa8, 0x3c, - 0x09, 0xce, 0x02, 0x79, 0x11, 0x68, 0x05, 0x4d, 0x75, 0x0f, 0x13, 0x19, 0x9c, 0xb8, 0x34, 0xa1, - 0x60, 0xfd, 0xb8, 0x38, 0x55, 0x22, 0xb4, 0x0b, 0x65, 0x6d, 0xf4, 0x93, 0x3d, 0x3a, 0x5b, 0xd3, - 0x91, 0x45, 0x36, 0xd9, 0x82, 0x0c, 0xc8, 0x36, 0xc4, 0x68, 0x8d, 0x27, 0x75, 0x70, 0xf9, 0xb9, - 0x59, 0x8d, 0x09, 0x46, 0xb1, 0x18, 0x9c, 0x28, 0x05, 0x4d, 0x38, 0x34, 0xff, 0x4a, 0x0e, 0x6e, - 0xce, 0x43, 0x41, 0xe3, 0xf8, 0x64, 0xa2, 0x52, 0x27, 0x6e, 0xf2, 0xce, 0x54, 0x01, 0x6a, 0x9e, - 0x66, 0xf3, 0xf0, 0x15, 0x07, 0x31, 0x59, 0x8e, 0x6a, 0xfd, 0x28, 0x07, 0xeb, 0x33, 0x73, 0xce, - 0x98, 0x34, 0x00, 0x65, 0x7d, 0xb2, 0x74, 0x61, 0x49, 0x92, 0xea, 0xd7, 0xa1, 0x5a, 0xd2, 0x29, - 0x91, 0xce, 0x9d, 0xee, 0xe8, 0x4a, 0x6a, 0x6d, 0xec, 0xe2, 0xae, 0xa1, 0xac, 0xee, 0x0b, 0x56, - 0x42, 0x47, 0x58, 0x5b, 0x59, 0x06, 0x52, 0xd6, 0x06, 0xa9, 0x8e, 0x27, 0xb3, 0x0a, 0x15, 0xac, - 0x8c, 0x47, 0xbe, 0xd7, 0xc3, 0x66, 0xd5, 0xb2, 0xe1, 0xc6, 0x9c, 0x71, 0xd3, 0x48, 0x9e, 0x9a, - 0x51, 0xad, 0x02, 0xec, 0x3c, 0x8d, 0xc7, 0xc2, 0x72, 0x9c, 0xc3, 0xea, 0xce, 0x53, 0x5d, 0x31, - 0x6c, 0xd2, 0xc1, 0xfa, 0x4e, 0x3c, 0x45, 0x69, 0x11, 0xb1, 0x82, 0xf5, 0x07, 0xb9, 0x38, 0x51, - 0xdc, 0xfc, 0x0b, 0xb0, 0xa2, 0xc7, 0x71, 0xec, 0x5c, 0xf9, 0xd2, 0x71, 0xf9, 0x2e, 0xac, 0x46, - 0x49, 0xd5, 0x79, 0x46, 0xe4, 0x4f, 0x6b, 0xec, 0xce, 0x04, 0x92, 0x3d, 0x45, 0x14, 0xfb, 0x29, - 0xf9, 0x34, 0xba, 0xcc, 0xc9, 0xe3, 0x72, 0xe8, 0x26, 0x2d, 0x93, 0x0f, 0xe5, 0x58, 0x5f, 0x87, - 0x75, 0x12, 0x50, 0x7a, 0x30, 0xda, 0x06, 0xc6, 0x3d, 0xd7, 0xb2, 0x75, 0x27, 0xde, 0x73, 0xd3, - 0xb4, 0xfe, 0xa4, 0x04, 0x90, 0x46, 0xd2, 0xe7, 0x5c, 0xe5, 0x79, 0x86, 0xce, 0x4c, 0x5e, 0xab, - 0xf0, 0xca, 0x79, 0xad, 0x8f, 0x12, 0x53, 0x5c, 0x87, 0x30, 0xa7, 0x8b, 0x5c, 0xd3, 0x31, 0x4d, - 0x1b, 0xe0, 0x13, 0x75, 0x13, 0xa5, 0xe9, 0xba, 0x89, 0x7b, 0xb3, 0x45, 0x56, 0x53, 0x32, 0x26, - 0x0d, 0x1b, 0x54, 0x26, 0xc2, 0x06, 0x4d, 0xa8, 0x86, 0xc2, 0x71, 0x65, 0xe0, 0x5f, 0xc5, 0xe9, - 0x93, 0xb8, 0xcd, 0xdf, 0x85, 0x92, 0xa2, 0xc2, 0xf9, 0x2a, 0x5d, 0x89, 0x97, 0x6c, 0x9c, 0xc6, - 0x45, 0x81, 0xe5, 0x45, 0xa6, 0x32, 0x4a, 0x6b, 0xa9, 0xaa, 0x9d, 0x81, 0xf0, 0x0d, 0xe0, 0x1e, - 0xfa, 0x50, 0xbe, 0x2f, 0xdc, 0xad, 0xab, 0x1d, 0x9d, 0xd5, 0x20, 0xcd, 0x58, 0xb5, 0xe7, 0x7c, - 0x89, 0xf7, 0x7f, 0x39, 0xdd, 0x7f, 0x1a, 0xf2, 0xb9, 0x17, 0xe1, 0x4c, 0x57, 0xc8, 0x00, 0x48, - 0xda, 0xd6, 0xdf, 0xcb, 0x27, 0xae, 0x47, 0x0d, 0x4a, 0x27, 0x4e, 0xe4, 0xf5, 0xb4, 0x5b, 0x69, - 0x94, 0xb4, 0x76, 0x3f, 0x94, 0x74, 0x25, 0xcb, 0xa3, 0x5f, 0x11, 0x09, 0xf4, 0x20, 0x56, 0x01, - 0xd2, 0x47, 0x01, 0xac, 0x88, 0xf7, 0x28, 0xde, 0x37, 0x5d, 0xa8, 0x40, 0xa4, 0x14, 0x89, 0x72, - 0x93, 0x12, 0x30, 0xf2, 0x29, 0x49, 0x4e, 0xb3, 0x2a, 0xe2, 0x04, 0x52, 0x09, 0x1d, 0x87, 0xa3, - 0x53, 0xc6, 0x00, 0xd9, 0xc4, 0x05, 0xc6, 0xac, 0x8e, 0xa6, 0x7f, 0xcc, 0x54, 0x07, 0xcf, 0x22, - 0x72, 0x7a, 0x96, 0xf1, 0x96, 0x4d, 0x7e, 0x60, 0x2b, 0x38, 0xa2, 0xf4, 0xad, 0x01, 0x5b, 0x45, - 0xae, 0x0e, 0xa5, 0xcf, 0xd7, 0xf0, 0xe7, 0x39, 0x25, 0xd5, 0x19, 0xf6, 0xea, 0xe2, 0xe5, 0x5e, - 0xc7, 0x91, 0x25, 0x6a, 0x9c, 0x71, 0xf4, 0x63, 0x46, 0x0e, 0xba, 0x19, 0xde, 0xc8, 0x09, 0x14, - 0xbb, 0x81, 0x53, 0x1d, 0xb9, 0xa7, 0xec, 0xa6, 0xf5, 0x93, 0xb4, 0xc0, 0xf2, 0xed, 0xc4, 0xb8, - 0x5f, 0xe4, 0x20, 0xbe, 0xc8, 0xfc, 0xdf, 0x85, 0xf5, 0x50, 0x7c, 0x7f, 0xec, 0x4d, 0x54, 0x0f, - 0x17, 0xae, 0xcf, 0x7b, 0xcf, 0x52, 0x58, 0xe7, 0xb0, 0x1e, 0x37, 0x9e, 0x79, 0x6a, 0x40, 0x01, - 0x11, 0xfe, 0x6e, 0xa6, 0xbc, 0x39, 0x37, 0xf7, 0x6d, 0x42, 0xc2, 0x32, 0x2d, 0x67, 0x4e, 0x82, - 0xd2, 0xf9, 0x05, 0x82, 0xd2, 0xd6, 0xff, 0x2a, 0x67, 0x62, 0x22, 0xda, 0xdd, 0x71, 0x13, 0x77, - 0x67, 0x36, 0xb3, 0x95, 0xc6, 0x99, 0xf3, 0xaf, 0x12, 0x67, 0x9e, 0x97, 0x25, 0xfe, 0x18, 0x6d, - 0x59, 0x3a, 0xe3, 0x4f, 0x17, 0x88, 0xa1, 0x4f, 0xe0, 0xf2, 0x2d, 0xca, 0x53, 0x39, 0x1d, 0x5d, - 0xc2, 0x50, 0x9a, 0xfb, 0xd8, 0x20, 0x9b, 0x90, 0x32, 0x98, 0x76, 0x86, 0x2a, 0x23, 0x11, 0xca, - 0xf3, 0x24, 0x02, 0x7a, 0x9e, 0x46, 0x56, 0x24, 0x6d, 0x9d, 0x72, 0xd0, 0xbf, 0x63, 0xf6, 0x94, - 0x9f, 0xac, 0xda, 0x33, 0x70, 0xb4, 0x86, 0x86, 0x63, 0x5f, 0x79, 0x26, 0xaa, 0xae, 0x1b, 0xd3, - 0x4f, 0x72, 0x6a, 0xb3, 0x4f, 0x72, 0xbe, 0x05, 0x10, 0x09, 0x3c, 0xf9, 0x3b, 0x5e, 0x4f, 0x99, - 0x42, 0x87, 0xbb, 0x2f, 0x9a, 0x9b, 0xc9, 0x05, 0x64, 0x28, 0x70, 0xfc, 0x43, 0xe7, 0x72, 0x1b, - 0xad, 0x62, 0x93, 0x91, 0x4d, 0xda, 0xd3, 0x72, 0x72, 0x75, 0x56, 0x4e, 0xbe, 0x0b, 0xa5, 0xa8, - 0x27, 0x47, 0x82, 0x0a, 0xfa, 0x5f, 0xbc, 0xbf, 0x1b, 0x1d, 0x44, 0xb2, 0x35, 0x2e, 0x45, 0xde, - 0x50, 0x4b, 0xca, 0x90, 0x4a, 0xf9, 0x6b, 0x76, 0xdc, 0x9c, 0x90, 0x55, 0xb7, 0x26, 0x65, 0x55, - 0xd3, 0x85, 0xb2, 0x89, 0xa2, 0xcf, 0x71, 0xb3, 0x29, 0xfe, 0x96, 0xcf, 0xc4, 0xdf, 0x92, 0x72, - 0xba, 0x42, 0xb6, 0x9c, 0xee, 0x1e, 0xd4, 0xc3, 0x4c, 0x96, 0xc8, 0xd4, 0x50, 0x66, 0x40, 0xd6, - 0xe7, 0x50, 0xa2, 0xb1, 0xa2, 0xa2, 0xd7, 0xcb, 0xac, 0x6d, 0x3d, 0x9c, 0x14, 0xcb, 0xf1, 0x9b, - 0xc0, 0x22, 0xa1, 0xda, 0xa7, 0xdd, 0x81, 0xe8, 0x38, 0x43, 0x41, 0x02, 0x30, 0xcf, 0x1b, 0x70, - 0x53, 0xe3, 0x46, 0x93, 0x5f, 0xc8, 0x22, 0xf1, 0xbd, 0x93, 0xd0, 0x09, 0xaf, 0x58, 0xd1, 0xfa, - 0x16, 0xe5, 0x34, 0xe3, 0x03, 0x55, 0x4f, 0x9e, 0x87, 0x69, 0x91, 0xeb, 0x8a, 0x10, 0x25, 0xbe, - 0x4e, 0x45, 0x1b, 0x3f, 0x45, 0x17, 0xe8, 0x90, 0x23, 0xc0, 0x0a, 0xd6, 0x33, 0x34, 0x29, 0x53, - 0xfd, 0xf8, 0x2b, 0xbb, 0x6f, 0xd6, 0x56, 0xc6, 0xa4, 0x9a, 0xac, 0xc8, 0xc9, 0x2d, 0x5a, 0x91, - 0x63, 0x7d, 0x06, 0x6b, 0xf6, 0xa4, 0xbc, 0xe6, 0x1f, 0x41, 0x45, 0x8e, 0xb2, 0x7c, 0x5e, 0x76, - 0x2e, 0x63, 0x74, 0xeb, 0x8f, 0x73, 0xb0, 0xdc, 0x0a, 0x94, 0x08, 0x03, 0xc7, 0xdf, 0xf3, 0x9d, - 0x3e, 0xff, 0x30, 0x96, 0x52, 0xf3, 0xfd, 0xe0, 0x2c, 0xee, 0xa4, 0xc0, 0xf2, 0x4d, 0xb4, 0x98, - 0xbf, 0x06, 0xeb, 0xc2, 0xf5, 0x94, 0x0c, 0xb5, 0x21, 0x19, 0x17, 0x46, 0xdd, 0x04, 0xa6, 0xc1, - 0x1d, 0xba, 0x12, 0x5d, 0xbd, 0xcd, 0x0d, 0xb8, 0x39, 0x01, 0x8d, 0xad, 0xc4, 0x3c, 0xbf, 0x03, - 0x8d, 0x54, 0xd3, 0xec, 0xc8, 0x40, 0xb5, 0x02, 0x57, 0x5c, 0x92, 0xb9, 0xc2, 0x0a, 0xd6, 0x7f, - 0x4a, 0x0c, 0xa5, 0xa7, 0xa6, 0x6c, 0x2a, 0x94, 0x52, 0xa5, 0xb9, 0x02, 0xdd, 0xca, 0xbc, 0x23, - 0xcc, 0x2f, 0xf0, 0x8e, 0xf0, 0x5b, 0xe9, 0x3b, 0x42, 0xad, 0x28, 0xde, 0x98, 0xab, 0x7d, 0xa8, - 0xda, 0xc3, 0x98, 0xbf, 0x1d, 0x91, 0x79, 0x54, 0xf8, 0x8e, 0xf1, 0x79, 0x8a, 0x8b, 0xd8, 0x93, - 0x3a, 0xeb, 0xfc, 0xfe, 0x74, 0xd1, 0xf8, 0x62, 0x55, 0x59, 0x33, 0x26, 0x1f, 0xbc, 0xb2, 0xc9, - 0xf7, 0xe9, 0x94, 0x7b, 0x51, 0x9d, 0x1b, 0x81, 0xba, 0xe6, 0x65, 0xdb, 0xa7, 0x50, 0x19, 0x78, - 0x91, 0x92, 0xa1, 0x7e, 0xf2, 0x37, 0xfb, 0x3a, 0x24, 0xb3, 0x5a, 0xfb, 0x1a, 0x91, 0x4a, 0x64, - 0x62, 0xaa, 0x66, 0x1f, 0x20, 0x5d, 0xc5, 0x19, 0x59, 0xf3, 0x25, 0x1e, 0x75, 0xde, 0x82, 0x72, - 0x34, 0x3e, 0x49, 0x93, 0x3f, 0xa6, 0xd5, 0xbc, 0x84, 0xe6, 0x8c, 0x0e, 0x3f, 0x16, 0xa1, 0x1e, - 0x1f, 0x8a, 0xc2, 0x38, 0x49, 0x64, 0xba, 0x4f, 0xda, 0xfc, 0x5b, 0xd9, 0xed, 0xd1, 0x47, 0xe8, - 0xde, 0x0b, 0xd6, 0x38, 0xe1, 0x9c, 0xd9, 0xa7, 0xe6, 0xfb, 0x50, 0xcf, 0x4c, 0x1d, 0xe5, 0xe7, - 0x38, 0x70, 0x65, 0x1c, 0xe6, 0xc4, 0xdf, 0xfa, 0x45, 0x8b, 0x1b, 0x07, 0x3a, 0xe9, 0xb7, 0x75, - 0x0e, 0xaf, 0x1f, 0xa7, 0x66, 0xd2, 0xb1, 0x08, 0x87, 0x5e, 0x84, 0xa2, 0x59, 0x3b, 0x32, 0xe4, - 0x97, 0xbb, 0x22, 0x50, 0x9e, 0x8a, 0x65, 0x52, 0xd2, 0xe6, 0xbf, 0x0d, 0xa5, 0x91, 0x08, 0x87, - 0x91, 0x91, 0x4b, 0xd3, 0x7b, 0x32, 0x97, 0x6d, 0x64, 0x6b, 0x1a, 0xeb, 0x1f, 0xe4, 0xa0, 0x7a, - 0x28, 0x94, 0x83, 0xda, 0x98, 0x1f, 0x4e, 0xf5, 0x32, 0x9b, 0x5c, 0x8c, 0x51, 0x37, 0x8c, 0x6b, - 0xb5, 0xd1, 0x32, 0xf8, 0xa6, 0xbd, 0xbf, 0x94, 0x0e, 0xac, 0xb9, 0x05, 0x15, 0x03, 0x6e, 0x7e, - 0x08, 0x6b, 0x53, 0x98, 0xfc, 0x0d, 0x58, 0x31, 0x96, 0x70, 0xe7, 0x6a, 0x18, 0x97, 0x79, 0x2c, - 0xdb, 0x93, 0xc0, 0xad, 0x1a, 0x54, 0x46, 0x9a, 0xc0, 0xfa, 0xc7, 0x1c, 0x96, 0x8f, 0xa4, 0xf2, - 0x4e, 0xd1, 0x8d, 0x9c, 0xa7, 0xab, 0xee, 0x02, 0x90, 0xb2, 0xd3, 0x19, 0x74, 0x1d, 0x90, 0xcb, - 0x40, 0xf8, 0xc7, 0x49, 0xc0, 0xb6, 0x38, 0xd7, 0x4c, 0xc9, 0x32, 0x9f, 0x8e, 0xda, 0x36, 0xa0, - 0xe2, 0x45, 0x07, 0xa8, 0x2c, 0x4c, 0xd9, 0x46, 0xdc, 0xe4, 0xdf, 0x84, 0xb2, 0x37, 0x1c, 0xc9, - 0x50, 0x99, 0x88, 0xee, 0xb5, 0x5c, 0x5b, 0x84, 0xb9, 0xbf, 0x64, 0x1b, 0x1a, 0xa4, 0x16, 0x97, - 0x44, 0x5d, 0x7d, 0x39, 0xf5, 0xee, 0x65, 0x4c, 0xad, 0x69, 0xf8, 0x77, 0x61, 0xa5, 0xaf, 0x0b, - 0xab, 0x34, 0x63, 0x73, 0x2d, 0xbf, 0x7a, 0x1d, 0x93, 0xc7, 0x59, 0x82, 0xfd, 0x25, 0x7b, 0x92, - 0x03, 0xb2, 0x44, 0x93, 0x58, 0x44, 0xaa, 0x2b, 0xbf, 0x23, 0xbd, 0x80, 0x5c, 0xb1, 0x97, 0xb0, - 0xb4, 0xb3, 0x04, 0xc8, 0x72, 0x82, 0x03, 0xff, 0x00, 0x6d, 0x88, 0x48, 0x99, 0x27, 0xa4, 0xf7, - 0xae, 0xe3, 0xd4, 0x15, 0x91, 0x79, 0xfc, 0x19, 0x29, 0xfe, 0x0c, 0xd6, 0x0c, 0x23, 0x5b, 0x44, - 0x23, 0x19, 0x44, 0x82, 0x7c, 0xaf, 0xfa, 0x4c, 0xcd, 0xfb, 0xbc, 0xc1, 0xc4, 0x24, 0xfb, 0x4b, - 0xf6, 0x34, 0x17, 0x7e, 0x09, 0xcd, 0x8c, 0x4f, 0x62, 0x08, 0x36, 0x47, 0xa3, 0x50, 0xa2, 0xa3, - 0xb8, 0x42, 0x7d, 0x7c, 0x70, 0x5d, 0x1f, 0xc7, 0x2f, 0xa4, 0xde, 0x5f, 0xb2, 0xaf, 0xe1, 0xcd, - 0x8f, 0x60, 0xd9, 0x17, 0xce, 0xb9, 0x30, 0x70, 0xf3, 0xae, 0xf5, 0xfe, 0x75, 0x7d, 0x1d, 0x64, - 0xf0, 0xf7, 0x97, 0xec, 0x09, 0x7a, 0xfe, 0xbb, 0xb0, 0x3e, 0xd1, 0x1b, 0xbd, 0x7f, 0xd3, 0x2f, - 0x5e, 0xbf, 0xbe, 0xf0, 0x04, 0x90, 0x68, 0x7f, 0xc9, 0x9e, 0xe5, 0x84, 0x96, 0x1e, 0xf9, 0x72, - 0xa6, 0xb6, 0x52, 0x37, 0xf8, 0x1d, 0xa8, 0x39, 0x3d, 0x7f, 0x5f, 0x38, 0x6e, 0x12, 0x97, 0x4d, - 0x01, 0xcd, 0x9f, 0xe5, 0xa0, 0x6c, 0xce, 0xd2, 0x9d, 0x24, 0x51, 0x9b, 0x08, 0xda, 0x14, 0xc0, - 0x3f, 0x81, 0x9a, 0x08, 0x43, 0x19, 0x6e, 0x4b, 0x37, 0x2e, 0xe4, 0x9a, 0x0e, 0x1a, 0x6a, 0x3e, - 0x1b, 0xbb, 0x31, 0x9a, 0x9d, 0x52, 0xf0, 0x8f, 0x01, 0xf4, 0x1d, 0xea, 0xa6, 0x25, 0xf2, 0xcd, - 0xf9, 0xf4, 0x3a, 0x78, 0x9f, 0x62, 0xa7, 0xe1, 0x98, 0x38, 0x72, 0x1e, 0x37, 0x13, 0xf7, 0xa8, - 0x94, 0x79, 0x08, 0xf3, 0xaf, 0x73, 0x50, 0xd6, 0x57, 0x8f, 0xef, 0xce, 0x8e, 0xf9, 0x2b, 0x2f, - 0xbf, 0xb1, 0x1b, 0xd3, 0x63, 0xff, 0x26, 0x80, 0xbe, 0xc1, 0x99, 0xb1, 0xdf, 0x99, 0xe2, 0x63, - 0x48, 0xe3, 0xfa, 0xbd, 0x14, 0xdf, 0x7a, 0xa4, 0x9f, 0x2b, 0x50, 0x0c, 0xef, 0xc9, 0xc1, 0x01, - 0x5b, 0xe2, 0xeb, 0xb0, 0xf2, 0xe4, 0xe8, 0xb3, 0xa3, 0xf6, 0xb3, 0xa3, 0xe7, 0xbb, 0xb6, 0xdd, - 0xb6, 0x75, 0x28, 0x6f, 0x6b, 0x73, 0xe7, 0x79, 0xeb, 0xe8, 0xf8, 0x49, 0x97, 0xe5, 0x9b, 0x7f, - 0x94, 0x83, 0x95, 0x89, 0x9b, 0xff, 0x7f, 0x77, 0x73, 0x32, 0x0b, 0x5c, 0x98, 0xbf, 0xc0, 0xc5, - 0xcc, 0x02, 0xff, 0x61, 0x0e, 0x56, 0x26, 0x64, 0x48, 0x96, 0x3e, 0x37, 0x49, 0x9f, 0xd5, 0x84, - 0xf9, 0x29, 0x4d, 0x68, 0xc1, 0x72, 0xfc, 0xfb, 0x28, 0xf5, 0x71, 0x27, 0x60, 0x59, 0x1c, 0xaa, - 0x08, 0x2e, 0x4e, 0xe2, 0x20, 0xac, 0x49, 0x6f, 0x9c, 0x22, 0xd5, 0xfc, 0xcf, 0x39, 0x34, 0xbc, - 0x27, 0x65, 0xc7, 0x75, 0x9a, 0x78, 0xba, 0xff, 0xfc, 0x02, 0xfd, 0x17, 0x66, 0xfb, 0x37, 0x81, - 0xab, 0x58, 0x1e, 0x15, 0x93, 0xc0, 0x55, 0x2c, 0x45, 0x76, 0x01, 0x46, 0x89, 0x2a, 0x37, 0x3e, - 0xf7, 0x82, 0x6a, 0x3f, 0x43, 0xd8, 0xfc, 0x3d, 0x68, 0xbe, 0x58, 0x90, 0xbd, 0x38, 0x64, 0x39, - 0xd5, 0x7d, 0xfe, 0xcb, 0x76, 0xff, 0x37, 0x72, 0xb0, 0x9c, 0x15, 0x6e, 0xff, 0x9f, 0x37, 0xfd, - 0x02, 0xd6, 0x67, 0xa4, 0xe2, 0xff, 0x8b, 0xdd, 0xb6, 0x3e, 0x4c, 0xd2, 0x92, 0x75, 0xa8, 0x98, - 0x7f, 0x8a, 0xa1, 0x2b, 0xf7, 0x3a, 0x03, 0x79, 0x11, 0xe8, 0x38, 0xa1, 0x2d, 0x1c, 0xf3, 0xd4, - 0xd3, 0x16, 0x23, 0xdf, 0xa3, 0x34, 0xd0, 0x6d, 0x80, 0x4d, 0xb2, 0xcc, 0xe3, 0xca, 0xeb, 0xed, - 0x83, 0x76, 0x67, 0x97, 0x2d, 0x65, 0x8d, 0xa6, 0xcf, 0x63, 0xd1, 0x65, 0x1d, 0x43, 0x39, 0xad, - 0xc9, 0x3d, 0x74, 0xc2, 0x33, 0x57, 0x27, 0x5b, 0x96, 0xa1, 0x7a, 0x6c, 0xcc, 0x6b, 0xdd, 0xd5, - 0x77, 0x3a, 0xed, 0x23, 0x1d, 0x92, 0xdc, 0x69, 0x77, 0x75, 0x65, 0x6f, 0xe7, 0xe9, 0x63, 0x1d, - 0xf5, 0x7f, 0x6c, 0x6f, 0x1e, 0xef, 0x3f, 0x27, 0x8c, 0x92, 0xf5, 0x47, 0xf9, 0x58, 0xd2, 0x5b, - 0xb6, 0x49, 0xe3, 0x00, 0x94, 0x51, 0xfe, 0x49, 0xc3, 0x38, 0xe9, 0x86, 0xaa, 0x0f, 0x77, 0x2f, - 0xb5, 0x27, 0xc9, 0xf2, 0xbc, 0x0c, 0xf9, 0xe3, 0x13, 0x5d, 0x78, 0xb8, 0xaf, 0x86, 0xbe, 0x7e, - 0x8a, 0xd3, 0xbd, 0x54, 0xac, 0x84, 0x3f, 0xb6, 0xa3, 0x73, 0x56, 0xb6, 0xfe, 0x45, 0x0e, 0x6a, - 0x89, 0x70, 0x79, 0x15, 0x61, 0xc7, 0x39, 0xac, 0xb6, 0x8e, 0xba, 0xbb, 0xf6, 0xd1, 0xe6, 0x81, - 0x41, 0x29, 0xa0, 0xdb, 0x79, 0xd4, 0x7e, 0xde, 0xde, 0xfa, 0xce, 0xee, 0x76, 0xb7, 0xf3, 0xbc, - 0xdb, 0x7e, 0xde, 0x3a, 0x3c, 0x6e, 0xdb, 0x5d, 0x56, 0xe2, 0xb7, 0x80, 0xeb, 0xdf, 0xcf, 0x5b, - 0x9d, 0xe7, 0xdb, 0x9b, 0x47, 0xdb, 0xbb, 0x07, 0xbb, 0x3b, 0xac, 0xcc, 0xbf, 0x02, 0xbf, 0x79, - 0xd0, 0x3a, 0x6c, 0x75, 0x9f, 0xb7, 0xf7, 0x9e, 0xdb, 0xed, 0x67, 0x9d, 0xe7, 0x6d, 0xfb, 0xb9, - 0xbd, 0x7b, 0xb0, 0xd9, 0x6d, 0xb5, 0x8f, 0x3a, 0xcf, 0x77, 0x7f, 0x67, 0x7b, 0x77, 0x77, 0x67, - 0x77, 0x87, 0x55, 0xf8, 0x0d, 0x58, 0xdb, 0x6b, 0x1d, 0xec, 0x3e, 0x3f, 0x68, 0x6f, 0xee, 0x98, - 0xfe, 0xaa, 0xd6, 0xb7, 0xa1, 0xdc, 0x0a, 0xce, 0x3d, 0x45, 0xb2, 0xd0, 0xec, 0x86, 0x31, 0x71, - 0xe3, 0x26, 0x8a, 0xe0, 0xc8, 0xeb, 0x07, 0xf4, 0xc6, 0x92, 0x8e, 0xcf, 0xb2, 0x9d, 0x02, 0xac, - 0x7f, 0x94, 0x87, 0x15, 0xcd, 0x22, 0x36, 0x99, 0xef, 0xc3, 0x9a, 0x89, 0xe6, 0xb4, 0x26, 0x0f, - 0xe5, 0x34, 0x98, 0xfe, 0x07, 0x89, 0x06, 0x65, 0x8e, 0x66, 0x16, 0x44, 0x51, 0x7c, 0x62, 0x8e, - 0xa6, 0xb7, 0xce, 0x5f, 0xa4, 0x80, 0x6b, 0x14, 0xe4, 0x1d, 0x13, 0xde, 0x3d, 0x4a, 0xb5, 0x64, - 0x0a, 0xc0, 0xf3, 0xae, 0x11, 0x7b, 0x32, 0xd8, 0x4e, 0x6a, 0xba, 0x27, 0x60, 0xfc, 0x73, 0xb8, - 0x9d, 0xb4, 0x77, 0x83, 0x5e, 0x78, 0x35, 0x4a, 0xfe, 0x5f, 0x4d, 0x65, 0xae, 0xbf, 0xb5, 0xe7, - 0xf9, 0x62, 0x02, 0xd1, 0x7e, 0x11, 0x03, 0xeb, 0x67, 0xb9, 0x8c, 0xa3, 0xa1, 0x1d, 0x89, 0x6b, - 0xef, 0xf0, 0xbc, 0x30, 0x32, 0x9a, 0xfa, 0x66, 0xf8, 0x46, 0x77, 0x99, 0x26, 0x3f, 0x06, 0xee, - 0xcd, 0x0e, 0xba, 0xb8, 0xe0, 0xa0, 0xe7, 0xd0, 0x4e, 0x47, 0x01, 0x4b, 0x33, 0x51, 0x40, 0xcb, - 0x87, 0x6a, 0xfc, 0x5f, 0x6f, 0xd0, 0xdb, 0xa5, 0xff, 0x7b, 0x93, 0xc4, 0x3c, 0x74, 0x8b, 0xef, - 0xc3, 0xaa, 0x98, 0x1c, 0x53, 0x7e, 0xc1, 0x31, 0x4d, 0xd1, 0x59, 0xdf, 0x80, 0xf5, 0x19, 0x24, - 0x5c, 0xa4, 0x91, 0xa3, 0x92, 0xe7, 0x8a, 0xf8, 0x7b, 0x36, 0x17, 0x66, 0xfd, 0xfb, 0x3c, 0x2c, - 0x1f, 0x3a, 0x81, 0x77, 0x2a, 0x22, 0x15, 0x8f, 0x36, 0xea, 0x0d, 0xc4, 0xd0, 0x89, 0x47, 0xab, - 0x5b, 0xc6, 0x6d, 0xcb, 0xcf, 0x54, 0xf2, 0x64, 0x23, 0xd2, 0xb7, 0xa0, 0xec, 0x8c, 0xd5, 0x20, - 0xa9, 0x1c, 0x35, 0x2d, 0xdc, 0x1b, 0xdf, 0xeb, 0x09, 0x74, 0x05, 0xf4, 0x5a, 0xc5, 0xcd, 0x34, - 0xe3, 0x5d, 0xbe, 0x26, 0xe3, 0x5d, 0x99, 0x8d, 0xb2, 0xde, 0x83, 0x7a, 0xd4, 0x0b, 0x85, 0x08, - 0xa2, 0x81, 0x54, 0xf1, 0x7f, 0x4c, 0xca, 0x82, 0xa8, 0xd2, 0x43, 0x5e, 0x04, 0x78, 0x03, 0x0f, - 0xbc, 0xe0, 0xcc, 0x94, 0x3b, 0x4c, 0xc0, 0xf0, 0x8c, 0x91, 0xd3, 0xea, 0xfd, 0x40, 0x90, 0xc3, - 0x54, 0xb2, 0x93, 0x36, 0xb9, 0xa5, 0x8e, 0x12, 0x7d, 0x19, 0x7a, 0x22, 0x6a, 0xd4, 0xa9, 0x83, - 0x0c, 0x04, 0x69, 0x7d, 0x27, 0xe8, 0x8f, 0x9d, 0xbe, 0x30, 0xb9, 0xa5, 0xa4, 0xfd, 0xe0, 0xa7, - 0x05, 0x58, 0x9d, 0x8c, 0x22, 0x51, 0x1d, 0x98, 0x8e, 0x60, 0xb6, 0x7d, 0x37, 0x93, 0x2c, 0x67, - 0x7c, 0x0d, 0xea, 0xe6, 0xcc, 0x13, 0x60, 0x9d, 0xa4, 0xab, 0x1c, 0x0a, 0x76, 0x2f, 0xfb, 0x2f, - 0x02, 0xde, 0x46, 0x21, 0xad, 0x4b, 0xeb, 0xd8, 0x88, 0xd7, 0xcc, 0x63, 0xc9, 0x1f, 0xe6, 0xf9, - 0x4a, 0x26, 0x65, 0xfb, 0xd3, 0x3c, 0xbf, 0x09, 0x6b, 0x5b, 0xe3, 0xc0, 0xf5, 0x85, 0x9b, 0x40, - 0xff, 0x7e, 0x16, 0x9a, 0x24, 0x67, 0x7f, 0x88, 0x9a, 0xa1, 0xd6, 0x19, 0x9f, 0x98, 0xc4, 0xec, - 0x5f, 0x2c, 0xf2, 0x5b, 0xb0, 0x6e, 0xb0, 0xd2, 0xec, 0x0d, 0xfb, 0x4b, 0x45, 0x7e, 0x03, 0x56, - 0x37, 0xf5, 0x89, 0x34, 0x03, 0x65, 0x7f, 0xb9, 0x88, 0x43, 0xa0, 0x9a, 0xed, 0xdf, 0x27, 0x3e, - 0x49, 0x19, 0x0a, 0xfb, 0x83, 0x22, 0x5f, 0x03, 0xe8, 0x74, 0x93, 0x8e, 0xfe, 0x7a, 0x91, 0xd7, - 0xa1, 0xdc, 0xe9, 0x12, 0xb7, 0x1f, 0x15, 0xf9, 0x6b, 0xc0, 0xd2, 0xaf, 0x26, 0x5f, 0xf5, 0x37, - 0xf5, 0x60, 0x92, 0x04, 0xd4, 0x8f, 0x8b, 0x38, 0xaf, 0x58, 0x24, 0xb0, 0xbf, 0x55, 0xe4, 0x0c, - 0xea, 0x19, 0x3d, 0xcf, 0xfe, 0x76, 0x91, 0x73, 0x58, 0x39, 0x44, 0x9b, 0x24, 0xe8, 0x9b, 0x19, - 0xfc, 0x55, 0xea, 0x79, 0x2f, 0xa9, 0xa4, 0x61, 0x3f, 0x29, 0xf2, 0xdb, 0xc0, 0xb3, 0x96, 0xbd, - 0xf9, 0xf0, 0x77, 0x8a, 0x0f, 0xfe, 0x38, 0x07, 0xab, 0x93, 0xb1, 0x5f, 0xd4, 0x75, 0xbe, 0x0c, - 0xfa, 0x4a, 0xff, 0x27, 0x85, 0x15, 0xa8, 0x45, 0x03, 0x19, 0x2a, 0x6a, 0x52, 0xe5, 0x60, 0x40, - 0xe5, 0xdf, 0x3a, 0xc1, 0xae, 0xe3, 0x0b, 0x5a, 0xcd, 0x2a, 0xa7, 0xcf, 0xea, 0x49, 0x2a, 0xad, - 0x98, 0xa4, 0xfb, 0xa8, 0x0c, 0x3d, 0x2e, 0xf3, 0x65, 0x65, 0x44, 0x1d, 0x87, 0xbe, 0x4e, 0xfb, - 0x89, 0xa1, 0xe3, 0xf9, 0xfa, 0xc9, 0xf4, 0x68, 0x20, 0x03, 0x93, 0xf7, 0x13, 0xf4, 0x7a, 0x1a, - 0x32, 0x91, 0x76, 0x17, 0xc7, 0x91, 0x84, 0xa9, 0x98, 0x78, 0xf0, 0xe3, 0x1c, 0x2c, 0xc7, 0xc5, - 0xd7, 0x5e, 0xdf, 0x0b, 0x74, 0xe2, 0x30, 0xfe, 0xff, 0x14, 0x3d, 0xdf, 0x1b, 0xc5, 0xef, 0xbd, - 0xd7, 0xa0, 0xee, 0x86, 0x4e, 0x7f, 0x33, 0x70, 0x77, 0x42, 0x39, 0xd2, 0xc3, 0xd6, 0xce, 0x94, - 0x4e, 0x58, 0x5e, 0x88, 0x13, 0x44, 0x1f, 0x89, 0x90, 0x15, 0x29, 0x8a, 0x3f, 0x70, 0x42, 0x2f, - 0xe8, 0xa3, 0xba, 0x0f, 0x22, 0x9d, 0xb8, 0xac, 0x43, 0x65, 0x1c, 0x89, 0x9e, 0x13, 0x09, 0x56, - 0xc6, 0xc6, 0xc9, 0xd8, 0xf3, 0x95, 0x17, 0xe8, 0x67, 0xd6, 0x49, 0x66, 0xb2, 0xfa, 0xe0, 0x5f, - 0xe5, 0xa0, 0x4e, 0x9b, 0x97, 0x5a, 0x44, 0x69, 0x59, 0x48, 0x1d, 0x2a, 0x07, 0xc9, 0x33, 0xdb, - 0x32, 0xe4, 0xdb, 0x67, 0xda, 0x22, 0x32, 0x9b, 0xa7, 0xeb, 0x2f, 0xf5, 0x8b, 0xdb, 0x22, 0xff, - 0x35, 0x78, 0x0d, 0x6d, 0x38, 0x25, 0x9e, 0x39, 0x9e, 0xca, 0x16, 0xd8, 0x94, 0xd0, 0x80, 0xd0, - 0x9f, 0xe2, 0x8a, 0x9a, 0x32, 0x67, 0xb0, 0x4c, 0xdd, 0xc6, 0x90, 0x0a, 0x4e, 0x9a, 0x20, 0xa6, - 0x56, 0xa7, 0x9a, 0xa0, 0xa0, 0x7f, 0x82, 0xbd, 0x51, 0xc1, 0x2e, 0x41, 0xc8, 0x56, 0x44, 0x10, - 0x3c, 0x38, 0x82, 0x5b, 0xf3, 0x2d, 0x5f, 0x5d, 0xca, 0x4b, 0xff, 0xdb, 0x85, 0x4a, 0x2e, 0x9e, - 0x85, 0x9e, 0x2e, 0xeb, 0xac, 0x41, 0xa9, 0x7d, 0x11, 0xd0, 0x69, 0x58, 0x87, 0x95, 0x23, 0x99, - 0xa1, 0x61, 0x85, 0x07, 0xbd, 0x09, 0xa3, 0x34, 0x5d, 0x94, 0x78, 0x10, 0x4b, 0x99, 0x72, 0xa2, - 0x9c, 0xb6, 0x0e, 0xe9, 0x5f, 0xbd, 0xe9, 0x67, 0x0e, 0x3b, 0xa2, 0xe7, 0x7b, 0x01, 0xda, 0x8a, - 0xd8, 0x4a, 0x86, 0x59, 0xd4, 0xef, 0xee, 0x82, 0x9e, 0xf0, 0x85, 0xcb, 0x4a, 0x0f, 0x3e, 0x82, - 0x35, 0x33, 0x55, 0x74, 0xfe, 0xe2, 0x72, 0x9c, 0xe3, 0xd0, 0x3b, 0xd7, 0x4f, 0x29, 0xd0, 0x42, - 0x14, 0x61, 0x24, 0x03, 0x7a, 0x46, 0x02, 0x50, 0xee, 0x0c, 0x9c, 0x10, 0xfb, 0x78, 0xf0, 0x35, - 0xa8, 0x51, 0x79, 0xce, 0x67, 0x5e, 0xe0, 0xe2, 0x4c, 0xb6, 0x4c, 0x96, 0x1b, 0x6d, 0x51, 0x79, - 0x4e, 0xf3, 0xab, 0xea, 0xff, 0x30, 0xc1, 0xf2, 0x0f, 0x3e, 0x05, 0xae, 0x35, 0x99, 0x2b, 0x2e, - 0xbd, 0xa0, 0x9f, 0xd4, 0x97, 0x03, 0x3d, 0x16, 0x71, 0xc5, 0x25, 0x99, 0xbd, 0x75, 0xa8, 0xc4, - 0x8d, 0xf8, 0xc9, 0xca, 0x9e, 0x1c, 0x07, 0x2e, 0xcb, 0x6f, 0x3d, 0xf8, 0x37, 0xbf, 0xb8, 0x9b, - 0xfb, 0xf9, 0x2f, 0xee, 0xe6, 0xfe, 0xeb, 0x2f, 0xee, 0xe6, 0x7e, 0xf4, 0xcb, 0xbb, 0x4b, 0x3f, - 0xff, 0xe5, 0xdd, 0xa5, 0xff, 0xf0, 0xcb, 0xbb, 0x4b, 0x9f, 0xb3, 0xe9, 0x7f, 0x55, 0x78, 0x52, - 0xa6, 0x90, 0xf1, 0xbb, 0xff, 0x27, 0x00, 0x00, 0xff, 0xff, 0x16, 0xce, 0xbc, 0x14, 0xc5, 0x50, - 0x00, 0x00, + 0xde, 0xf4, 0xb4, 0xcb, 0xe5, 0x76, 0x56, 0x77, 0x75, 0xb7, 0xab, 0xdd, 0xe3, 0x76, 0x3b, 0xbf, + 0x95, 0xe1, 0xca, 0xcc, 0x48, 0xbf, 0x88, 0xaa, 0x1a, 0xb7, 0x80, 0xe2, 0x65, 0xbc, 0x9b, 0x11, + 0xcf, 0xf9, 0xe2, 0xdd, 0xf0, 0x7b, 0x37, 0xf2, 0x63, 0x81, 0x64, 0x60, 0x98, 0x81, 0xc5, 0x48, + 0xc3, 0x08, 0xb3, 0x18, 0x09, 0x34, 0xec, 0x58, 0x58, 0x20, 0x84, 0x46, 0x80, 0x80, 0x05, 0x3b, + 0x24, 0x16, 0x36, 0xac, 0x10, 0x2c, 0x40, 0xf6, 0x92, 0x05, 0x12, 0x1b, 0x10, 0x62, 0x81, 0xce, + 0xb9, 0xf7, 0x7d, 0xe2, 0x53, 0x59, 0x51, 0x3d, 0x9e, 0x55, 0xc6, 0x3d, 0xef, 0x9c, 0xf3, 0xee, + 0xe7, 0xdc, 0xf3, 0x7f, 0x09, 0xef, 0x8c, 0xce, 0xfa, 0x0f, 0x7d, 0xef, 0xe4, 0xe1, 0xe8, 0xe4, + 0xe1, 0x50, 0xba, 0xc2, 0x7f, 0x38, 0x0a, 0xa5, 0x92, 0x91, 0x1e, 0x44, 0x1b, 0x34, 0xe2, 0x2b, + 0x4e, 0x70, 0xa5, 0xae, 0x46, 0x62, 0x83, 0xa0, 0xcd, 0x3b, 0x7d, 0x29, 0xfb, 0xbe, 0xd0, 0xa8, + 0x27, 0xe3, 0xd3, 0x87, 0x91, 0x0a, 0xc7, 0x3d, 0xa5, 0x91, 0xad, 0x9f, 0x17, 0xe1, 0x56, 0x67, + 0xe8, 0x84, 0x6a, 0xcb, 0x97, 0xbd, 0xb3, 0x4e, 0xe0, 0x8c, 0xa2, 0x81, 0x54, 0x5b, 0x4e, 0x24, + 0xf8, 0x7b, 0x50, 0x3e, 0x41, 0x60, 0xd4, 0xc8, 0xdd, 0x2b, 0xdc, 0xaf, 0x3f, 0xba, 0xb9, 0x31, + 0xc1, 0x78, 0x83, 0x28, 0x6c, 0x83, 0xc3, 0x3f, 0x80, 0x8a, 0x2b, 0x94, 0xe3, 0xf9, 0x51, 0x23, + 0x7f, 0x2f, 0x77, 0xbf, 0xfe, 0xe8, 0xf6, 0x86, 0x7e, 0xf1, 0x46, 0xfc, 0xe2, 0x8d, 0x0e, 0xbd, + 0xd8, 0x8e, 0xf1, 0xf8, 0x63, 0xa8, 0x9e, 0x7a, 0xbe, 0x78, 0x2a, 0xae, 0xa2, 0x46, 0xe1, 0x5a, + 0x9a, 0xad, 0x7c, 0x23, 0x67, 0x27, 0xc8, 0x7c, 0x1b, 0x56, 0xc5, 0xa5, 0x0a, 0x1d, 0x5b, 0xf8, + 0x8e, 0xf2, 0x64, 0x10, 0x35, 0x8a, 0x34, 0xc3, 0xdb, 0x53, 0x33, 0x8c, 0x9f, 0x13, 0xf9, 0x14, + 0x09, 0xbf, 0x07, 0x75, 0x79, 0xf2, 0x03, 0xd1, 0x53, 0xdd, 0xab, 0x91, 0x88, 0x1a, 0xa5, 0x7b, + 0x85, 0xfb, 0x35, 0x3b, 0x0b, 0xe2, 0xdf, 0x84, 0x7a, 0x4f, 0xfa, 0xbe, 0xe8, 0xe9, 0x77, 0x94, + 0xaf, 0x5f, 0x56, 0x16, 0x97, 0x7f, 0x04, 0x6f, 0x85, 0x62, 0x28, 0xcf, 0x85, 0xbb, 0x9d, 0x40, + 0x69, 0x9d, 0x55, 0x7a, 0xcd, 0xfc, 0x87, 0x7c, 0x13, 0x56, 0x42, 0x33, 0xbf, 0x03, 0x2f, 0x38, + 0x8b, 0x1a, 0x15, 0x5a, 0xd6, 0xdb, 0xaf, 0x58, 0x16, 0xe2, 0xd8, 0x93, 0x14, 0x9c, 0x41, 0xe1, + 0x4c, 0x5c, 0x35, 0x6a, 0xf7, 0x72, 0xf7, 0x6b, 0x36, 0xfe, 0xe4, 0x9f, 0x42, 0x43, 0x86, 0x5e, + 0xdf, 0x0b, 0x1c, 0x7f, 0x3b, 0x14, 0x8e, 0x12, 0x6e, 0xd7, 0x1b, 0x8a, 0x48, 0x39, 0xc3, 0x51, + 0x03, 0xee, 0xe5, 0xee, 0x17, 0xec, 0x57, 0x3e, 0xe7, 0x1f, 0xea, 0x13, 0x6a, 0x05, 0xa7, 0xb2, + 0x51, 0x37, 0xcb, 0x9f, 0x9c, 0xcb, 0x9e, 0x79, 0x6c, 0x27, 0x88, 0xd6, 0x7f, 0xd9, 0x83, 0x12, + 0xc9, 0x06, 0x5f, 0x85, 0xbc, 0xe7, 0x36, 0x72, 0x34, 0x97, 0xbc, 0xe7, 0xf2, 0x87, 0x50, 0x3e, + 0xf5, 0x84, 0xef, 0xbe, 0x56, 0x44, 0x0c, 0x1a, 0xdf, 0x85, 0xe5, 0x50, 0x44, 0x2a, 0xf4, 0xcc, + 0x11, 0x68, 0x29, 0xf9, 0x8d, 0x79, 0x82, 0xb8, 0x61, 0x67, 0x10, 0xed, 0x09, 0x32, 0x3c, 0xea, + 0xde, 0xc0, 0xf3, 0xdd, 0x50, 0x04, 0x2d, 0x57, 0x0b, 0x4b, 0xcd, 0xce, 0x82, 0xf8, 0x7d, 0x58, + 0x3b, 0x71, 0x7a, 0x67, 0xfd, 0x50, 0x8e, 0x03, 0x3c, 0x15, 0x19, 0x36, 0x4a, 0x34, 0xed, 0x69, + 0x30, 0x7f, 0x1f, 0x4a, 0x8e, 0xef, 0xf5, 0x03, 0x12, 0x87, 0xd5, 0x47, 0xcd, 0xb9, 0x73, 0xd9, + 0x44, 0x0c, 0x5b, 0x23, 0xf2, 0x7d, 0x58, 0x39, 0x17, 0xa1, 0xf2, 0x7a, 0x8e, 0x4f, 0xf0, 0x46, + 0x85, 0x28, 0xad, 0xb9, 0x94, 0xcf, 0xb3, 0x98, 0xf6, 0x24, 0x21, 0x6f, 0x01, 0x44, 0x78, 0x57, + 0xe9, 0xca, 0x99, 0x03, 0xf9, 0xca, 0x5c, 0x36, 0xdb, 0x32, 0x50, 0x22, 0x50, 0x1b, 0x9d, 0x04, + 0x7d, 0x7f, 0xc9, 0xce, 0x10, 0xf3, 0xc7, 0x50, 0x54, 0xe2, 0x52, 0x35, 0x56, 0xaf, 0xd9, 0xd1, + 0x98, 0x49, 0x57, 0x5c, 0xaa, 0xfd, 0x25, 0x9b, 0x08, 0x90, 0x10, 0x4f, 0xba, 0xb1, 0xb6, 0x00, + 0x21, 0x0a, 0x07, 0x12, 0x22, 0x01, 0xff, 0x0c, 0xca, 0xbe, 0x73, 0x25, 0xc7, 0xaa, 0xc1, 0x88, + 0xf4, 0x37, 0xaf, 0x25, 0x3d, 0x20, 0xd4, 0xfd, 0x25, 0xdb, 0x10, 0xf1, 0x8f, 0xa0, 0xe0, 0x7a, + 0xe7, 0x8d, 0x75, 0xa2, 0xbd, 0x77, 0x2d, 0xed, 0x8e, 0x77, 0xbe, 0xbf, 0x64, 0x23, 0x3a, 0xdf, + 0x86, 0xea, 0x89, 0x94, 0x67, 0x43, 0x27, 0x3c, 0x6b, 0x70, 0x22, 0xfd, 0xad, 0x6b, 0x49, 0xb7, + 0x0c, 0xf2, 0xfe, 0x92, 0x9d, 0x10, 0xe2, 0x92, 0xbd, 0x9e, 0x0c, 0x1a, 0x37, 0x16, 0x58, 0x72, + 0xab, 0x27, 0x03, 0x5c, 0x32, 0x12, 0x20, 0xa1, 0xef, 0x05, 0x67, 0x8d, 0x9b, 0x0b, 0x10, 0xe2, + 0xf5, 0x45, 0x42, 0x24, 0xc0, 0x69, 0xbb, 0x8e, 0x72, 0xce, 0x3d, 0x71, 0xd1, 0x78, 0x6b, 0x81, + 0x69, 0xef, 0x18, 0x64, 0x9c, 0x76, 0x4c, 0x88, 0x4c, 0x62, 0xdd, 0xd0, 0xb8, 0xb5, 0x00, 0x93, + 0x58, 0xad, 0x20, 0x93, 0x98, 0x90, 0xff, 0x65, 0x58, 0x3f, 0x15, 0x8e, 0x1a, 0x87, 0xc2, 0x4d, + 0xb5, 0xed, 0x6d, 0xe2, 0xb6, 0x71, 0xfd, 0xd9, 0x4f, 0x53, 0xed, 0x2f, 0xd9, 0xb3, 0xac, 0xf8, + 0xa7, 0x50, 0xf2, 0x1d, 0x25, 0x2e, 0x1b, 0x0d, 0xe2, 0x69, 0xbd, 0x46, 0x28, 0x94, 0xb8, 0xdc, + 0x5f, 0xb2, 0x35, 0x09, 0xff, 0x1d, 0x58, 0x53, 0xce, 0x89, 0x2f, 0xda, 0xa7, 0x06, 0x21, 0x6a, + 0xfc, 0x1a, 0x71, 0x79, 0xef, 0x7a, 0x71, 0x9e, 0xa4, 0xd9, 0x5f, 0xb2, 0xa7, 0xd9, 0xe0, 0xac, + 0x08, 0xd4, 0x68, 0x2e, 0x30, 0x2b, 0xe2, 0x87, 0xb3, 0x22, 0x12, 0x7e, 0x00, 0x75, 0xfa, 0xb1, + 0x2d, 0xfd, 0xf1, 0x30, 0x68, 0xbc, 0x4d, 0x1c, 0xee, 0xbf, 0x9e, 0x83, 0xc6, 0xdf, 0x5f, 0xb2, + 0xb3, 0xe4, 0x78, 0x88, 0x34, 0xb4, 0xe5, 0x45, 0xe3, 0xce, 0x02, 0x87, 0xd8, 0x35, 0xc8, 0x78, + 0x88, 0x31, 0x21, 0x5e, 0xbd, 0x0b, 0xcf, 0xed, 0x0b, 0xd5, 0xf8, 0xf5, 0x05, 0xae, 0xde, 0x0b, + 0x42, 0xc5, 0xab, 0xa7, 0x89, 0x9a, 0x3f, 0x82, 0xe5, 0xac, 0x72, 0xe5, 0x1c, 0x8a, 0xa1, 0x70, + 0xb4, 0x62, 0xaf, 0xda, 0xf4, 0x1b, 0x61, 0xc2, 0xf5, 0x14, 0x29, 0xf6, 0xaa, 0x4d, 0xbf, 0xf9, + 0x2d, 0x28, 0x6b, 0x3b, 0x47, 0x7a, 0xbb, 0x6a, 0x9b, 0x11, 0xe2, 0xba, 0xa1, 0xd3, 0x6f, 0x14, + 0x35, 0x2e, 0xfe, 0x46, 0x5c, 0x37, 0x94, 0xa3, 0x76, 0x40, 0x7a, 0xb7, 0x6a, 0x9b, 0x51, 0xf3, + 0x6f, 0x7f, 0x02, 0x15, 0x33, 0xb1, 0xe6, 0x3f, 0xc8, 0x41, 0x59, 0xeb, 0x05, 0xfe, 0x39, 0x94, + 0x22, 0x75, 0xe5, 0x0b, 0x9a, 0xc3, 0xea, 0xa3, 0xaf, 0x2e, 0xa0, 0x4b, 0x36, 0x3a, 0x48, 0x60, + 0x6b, 0x3a, 0xcb, 0x86, 0x12, 0x8d, 0x79, 0x05, 0x0a, 0xb6, 0xbc, 0x60, 0x4b, 0x1c, 0xa0, 0xac, + 0xf7, 0x9c, 0xe5, 0x10, 0xb8, 0xe3, 0x9d, 0xb3, 0x3c, 0x02, 0xf7, 0x85, 0xe3, 0x8a, 0x90, 0x15, + 0xf8, 0x0a, 0xd4, 0xe2, 0xdd, 0x8d, 0x58, 0x91, 0x33, 0x58, 0xce, 0x9c, 0x5b, 0xc4, 0x4a, 0xcd, + 0xff, 0x55, 0x84, 0x22, 0x5e, 0x63, 0xfe, 0x0e, 0xac, 0x28, 0x27, 0xec, 0x0b, 0xed, 0x54, 0xb5, + 0x62, 0x13, 0x38, 0x09, 0xe4, 0x9f, 0xc5, 0x6b, 0xc8, 0xd3, 0x1a, 0xbe, 0xf2, 0x5a, 0xf5, 0x30, + 0xb1, 0x82, 0x8c, 0x31, 0x2d, 0x2c, 0x66, 0x4c, 0xf7, 0xa0, 0x8a, 0x5a, 0xa9, 0xe3, 0xfd, 0x48, + 0xd0, 0xd6, 0xaf, 0x3e, 0x7a, 0xf0, 0xfa, 0x57, 0xb6, 0x0c, 0x85, 0x9d, 0xd0, 0xf2, 0x16, 0xd4, + 0x7a, 0x4e, 0xe8, 0xd2, 0x64, 0xe8, 0xb4, 0x56, 0x1f, 0x7d, 0xed, 0xf5, 0x8c, 0xb6, 0x63, 0x12, + 0x3b, 0xa5, 0xe6, 0x6d, 0xa8, 0xbb, 0x22, 0xea, 0x85, 0xde, 0x88, 0xb4, 0x94, 0x36, 0xa9, 0x5f, + 0x7f, 0x3d, 0xb3, 0x9d, 0x94, 0xc8, 0xce, 0x72, 0xe0, 0x77, 0xa0, 0x16, 0x26, 0x6a, 0xaa, 0x42, + 0x76, 0x3e, 0x05, 0x58, 0x8f, 0xa1, 0x1a, 0xaf, 0x87, 0x2f, 0x43, 0x15, 0xff, 0x1e, 0xc9, 0x40, + 0xb0, 0x25, 0x3c, 0x5b, 0x1c, 0x75, 0x86, 0x8e, 0xef, 0xb3, 0x1c, 0x5f, 0x05, 0xc0, 0xe1, 0xa1, + 0x70, 0xbd, 0xf1, 0x90, 0xe5, 0xad, 0xdf, 0x8e, 0xa5, 0xa5, 0x0a, 0xc5, 0x63, 0xa7, 0x8f, 0x14, + 0xcb, 0x50, 0x8d, 0xb5, 0x2e, 0xcb, 0x21, 0xfd, 0x8e, 0x13, 0x0d, 0x4e, 0xa4, 0x13, 0xba, 0x2c, + 0xcf, 0xeb, 0x50, 0xd9, 0x0c, 0x7b, 0x03, 0xef, 0x5c, 0xb0, 0x82, 0xf5, 0x10, 0xea, 0x99, 0xf9, + 0x22, 0x0b, 0xf3, 0xd2, 0x1a, 0x94, 0x36, 0x5d, 0x57, 0xb8, 0x2c, 0x87, 0x04, 0x66, 0x81, 0x2c, + 0x6f, 0x7d, 0x0d, 0x6a, 0xc9, 0x6e, 0x21, 0x3a, 0xda, 0x5f, 0xb6, 0x84, 0xbf, 0x10, 0xcc, 0x72, + 0x28, 0x95, 0xad, 0xc0, 0xf7, 0x02, 0xc1, 0xf2, 0xcd, 0xbf, 0x42, 0xa2, 0xca, 0xbf, 0x35, 0x79, + 0x21, 0xde, 0x7d, 0x9d, 0x81, 0x9c, 0xbc, 0x0d, 0x6f, 0x67, 0xd6, 0x77, 0xe0, 0xd1, 0xe4, 0xaa, + 0x50, 0xdc, 0x91, 0x2a, 0x62, 0xb9, 0xe6, 0xff, 0xc8, 0x43, 0x35, 0xb6, 0x8b, 0xe8, 0x5f, 0x8e, + 0x43, 0xdf, 0x08, 0x34, 0xfe, 0xe4, 0x37, 0xa1, 0xa4, 0x3c, 0x65, 0xc4, 0xb8, 0x66, 0xeb, 0x01, + 0xba, 0x5c, 0xd9, 0x93, 0x2d, 0xd0, 0xb3, 0xe9, 0xa3, 0xf2, 0x86, 0x4e, 0x5f, 0xec, 0x3b, 0xd1, + 0x80, 0xe4, 0xb1, 0x66, 0xa7, 0x00, 0xa4, 0x3f, 0x75, 0xce, 0x51, 0xe6, 0xe8, 0xb9, 0x76, 0xc6, + 0xb2, 0x20, 0xfe, 0x21, 0x14, 0x71, 0x81, 0x46, 0x68, 0xfe, 0xc2, 0xd4, 0x82, 0x51, 0x4c, 0x8e, + 0x43, 0x81, 0xc7, 0xb3, 0x81, 0xde, 0xbc, 0x4d, 0xc8, 0xfc, 0x5d, 0x58, 0xd5, 0x97, 0xb0, 0x4d, + 0x7e, 0x7e, 0xcb, 0x25, 0x67, 0xac, 0x66, 0x4f, 0x41, 0xf9, 0x26, 0x6e, 0xa7, 0xa3, 0x44, 0xa3, + 0xba, 0x80, 0x7c, 0xc7, 0x9b, 0xb3, 0xd1, 0x41, 0x12, 0x5b, 0x53, 0x5a, 0x1f, 0xe3, 0x9e, 0x3a, + 0x4a, 0xe0, 0x31, 0xef, 0x0e, 0x47, 0xea, 0x4a, 0x0b, 0xcd, 0x9e, 0x50, 0xbd, 0x81, 0x17, 0xf4, + 0x59, 0x4e, 0x6f, 0x31, 0x1e, 0x22, 0xa1, 0x84, 0xa1, 0x0c, 0x59, 0xa1, 0xd9, 0x84, 0x22, 0xca, + 0x28, 0x2a, 0xc9, 0xc0, 0x19, 0x0a, 0xb3, 0xd3, 0xf4, 0xbb, 0x79, 0x03, 0xd6, 0x67, 0xcc, 0x6a, + 0xf3, 0x5f, 0x95, 0xb5, 0x84, 0x20, 0x05, 0xb9, 0x74, 0x86, 0x82, 0xbc, 0xb5, 0x37, 0xd2, 0x31, + 0xc8, 0x65, 0x52, 0xc7, 0x7c, 0x06, 0x25, 0x5c, 0x58, 0xac, 0x62, 0x16, 0x20, 0x3f, 0x44, 0x74, + 0x5b, 0x53, 0xf1, 0x06, 0x54, 0x7a, 0x03, 0xd1, 0x3b, 0x13, 0xae, 0xd1, 0xf5, 0xf1, 0x10, 0x85, + 0xa6, 0x97, 0xf1, 0xb2, 0xf5, 0x80, 0x44, 0xa2, 0x27, 0x83, 0xdd, 0xa1, 0xfc, 0x81, 0x47, 0xe7, + 0x8a, 0x22, 0x11, 0x03, 0xe2, 0xa7, 0x2d, 0x94, 0x11, 0x73, 0x6c, 0x29, 0xa0, 0xb9, 0x0b, 0x25, + 0x7a, 0x37, 0xde, 0x04, 0x3d, 0x67, 0x1d, 0xb5, 0xbe, 0xbb, 0xd8, 0x9c, 0xcd, 0x94, 0x9b, 0x3f, + 0xcd, 0x43, 0x11, 0xc7, 0xfc, 0x01, 0x94, 0x42, 0x27, 0xe8, 0xeb, 0x03, 0x98, 0x0d, 0x7e, 0x6d, + 0x7c, 0x66, 0x6b, 0x14, 0xfe, 0xb9, 0x11, 0xc5, 0xfc, 0x02, 0xc2, 0x92, 0xbc, 0x31, 0x2b, 0x96, + 0x37, 0xa1, 0x34, 0x72, 0x42, 0x67, 0x68, 0xee, 0x89, 0x1e, 0x58, 0x7f, 0x92, 0x83, 0x22, 0x22, + 0xf1, 0x75, 0x58, 0xe9, 0xa8, 0xd0, 0x3b, 0x13, 0x6a, 0x10, 0xca, 0x71, 0x7f, 0xa0, 0x25, 0xe9, + 0xa9, 0xb8, 0xd2, 0xfa, 0x46, 0x2b, 0x04, 0xe5, 0xf8, 0x5e, 0x8f, 0xe5, 0x51, 0xaa, 0xb6, 0xa4, + 0xef, 0xb2, 0x02, 0x5f, 0x83, 0xfa, 0xb3, 0xc0, 0x15, 0x61, 0xd4, 0x93, 0xa1, 0x70, 0x59, 0xd1, + 0xdc, 0xee, 0x33, 0x56, 0x22, 0x5b, 0x26, 0x2e, 0x15, 0x85, 0x34, 0xac, 0xcc, 0x6f, 0xc0, 0xda, + 0xd6, 0x64, 0x9c, 0xc3, 0x2a, 0xa8, 0x93, 0x0e, 0x45, 0x80, 0x42, 0xc6, 0xaa, 0x5a, 0x88, 0xe5, + 0x0f, 0x3c, 0x56, 0xc3, 0x97, 0xe9, 0x7b, 0xc2, 0xc0, 0xfa, 0x37, 0xb9, 0x58, 0x73, 0xac, 0x40, + 0xed, 0xd8, 0x09, 0x9d, 0x7e, 0xe8, 0x8c, 0x70, 0x7e, 0x75, 0xa8, 0x68, 0xc3, 0xf9, 0x81, 0xd6, + 0x6e, 0x7a, 0xf0, 0x48, 0xeb, 0x46, 0x3d, 0xf8, 0x90, 0x15, 0xd2, 0xc1, 0x47, 0xac, 0x88, 0xef, + 0xf8, 0xde, 0x58, 0x2a, 0xc1, 0x4a, 0xa4, 0xeb, 0xa4, 0x2b, 0x58, 0x19, 0x81, 0x5d, 0xd4, 0x28, + 0xac, 0x82, 0x6b, 0xde, 0x46, 0xf9, 0x39, 0x91, 0x97, 0xac, 0x8a, 0xd3, 0xc0, 0x6d, 0x14, 0x2e, + 0xab, 0xe1, 0x93, 0xa3, 0xf1, 0xf0, 0x44, 0xe0, 0x32, 0x01, 0x9f, 0x74, 0x65, 0xbf, 0xef, 0x0b, + 0x56, 0xc7, 0x3d, 0xc8, 0x28, 0x5f, 0xb6, 0x4c, 0x9a, 0xd6, 0xf1, 0x7d, 0x39, 0x56, 0x6c, 0xa5, + 0xf9, 0x7f, 0x0a, 0x50, 0xc4, 0x20, 0x05, 0xef, 0xce, 0x00, 0xf5, 0x8c, 0xb9, 0x3b, 0xf8, 0x3b, + 0xb9, 0x81, 0xf9, 0xf4, 0x06, 0xf2, 0x4f, 0xcd, 0x49, 0x17, 0x16, 0xd0, 0xb2, 0xc8, 0x38, 0x7b, + 0xc8, 0x1c, 0x8a, 0x43, 0x6f, 0x28, 0x8c, 0xae, 0xa3, 0xdf, 0x08, 0x8b, 0xd0, 0x1e, 0x97, 0x28, + 0x10, 0xa7, 0xdf, 0x78, 0x6b, 0x1c, 0x34, 0x0b, 0x9b, 0x8a, 0xee, 0x40, 0xc1, 0x8e, 0x87, 0x73, + 0xb4, 0x57, 0x6d, 0xae, 0xf6, 0xfa, 0x2c, 0xd6, 0x5e, 0x95, 0x05, 0x6e, 0x3d, 0x4d, 0x33, 0xab, + 0xb9, 0x52, 0xa5, 0x51, 0x5d, 0x9c, 0x3c, 0x63, 0x4c, 0x76, 0x8c, 0xd4, 0xa6, 0x86, 0xae, 0xaa, + 0x77, 0x99, 0xe5, 0xf0, 0x34, 0xe9, 0xba, 0x6a, 0x9d, 0xf7, 0xdc, 0x73, 0x85, 0x64, 0x05, 0x32, + 0x84, 0x63, 0xd7, 0x93, 0xac, 0x88, 0x9e, 0xd7, 0xf1, 0xce, 0x1e, 0x2b, 0x59, 0xef, 0x66, 0x4c, + 0xd2, 0xe6, 0x58, 0x49, 0xcd, 0x86, 0xc4, 0x37, 0xa7, 0xa5, 0xf1, 0x44, 0xb8, 0x2c, 0x6f, 0x7d, + 0x63, 0x8e, 0x9a, 0x5d, 0x81, 0xda, 0xb3, 0x91, 0x2f, 0x1d, 0xf7, 0x1a, 0x3d, 0xbb, 0x0c, 0x90, + 0x06, 0xc7, 0xcd, 0x1f, 0xdf, 0x4d, 0xcd, 0x39, 0xfa, 0xa2, 0x91, 0x1c, 0x87, 0x3d, 0x41, 0x2a, + 0xa4, 0x66, 0x9b, 0x11, 0xff, 0x0e, 0x94, 0xf0, 0x79, 0xd4, 0xc8, 0x93, 0x66, 0x79, 0xb0, 0x50, + 0x48, 0xb6, 0xf1, 0xdc, 0x13, 0x17, 0xb6, 0x26, 0xe4, 0x1f, 0x67, 0xdd, 0x93, 0xeb, 0x73, 0x56, + 0x19, 0xbf, 0x85, 0xdf, 0x05, 0x70, 0x7a, 0xca, 0x3b, 0x17, 0xc8, 0xcb, 0xe8, 0x88, 0x0c, 0x84, + 0xdb, 0x50, 0xc7, 0xab, 0x3b, 0x6a, 0x87, 0x78, 0xdb, 0x1b, 0xcb, 0xc4, 0xf8, 0xfd, 0xc5, 0xa6, + 0xf7, 0x24, 0x21, 0xb4, 0xb3, 0x4c, 0xf8, 0x33, 0x58, 0xd6, 0xb9, 0x30, 0xc3, 0x74, 0x85, 0x98, + 0x7e, 0xb0, 0x18, 0xd3, 0x76, 0x4a, 0x69, 0x4f, 0xb0, 0x99, 0x4d, 0x71, 0x95, 0xde, 0x38, 0xc5, + 0xf5, 0x2e, 0xac, 0x76, 0x27, 0x6f, 0x81, 0x36, 0x15, 0x53, 0x50, 0x6e, 0xc1, 0xb2, 0x17, 0xa5, + 0x19, 0x36, 0x4a, 0x75, 0x54, 0xed, 0x09, 0x58, 0xf3, 0x3f, 0x96, 0xa1, 0x48, 0x5b, 0x38, 0x9d, + 0xaa, 0xda, 0x9e, 0x50, 0xe9, 0x0f, 0x17, 0x3f, 0xea, 0xa9, 0x1b, 0x4f, 0x1a, 0xa4, 0x90, 0xd1, + 0x20, 0xdf, 0x81, 0x52, 0x24, 0x43, 0x15, 0x1f, 0xff, 0x82, 0x42, 0xd4, 0x91, 0xa1, 0xb2, 0x35, + 0x21, 0xdf, 0x83, 0xca, 0xa9, 0xe7, 0x2b, 0x3c, 0x14, 0xbd, 0x79, 0xef, 0x2d, 0xc6, 0x63, 0x8f, + 0x88, 0xec, 0x98, 0x98, 0x1f, 0x64, 0x85, 0xb1, 0x4c, 0x9c, 0x36, 0x16, 0xe3, 0x34, 0x4f, 0x46, + 0x1f, 0x00, 0xeb, 0xc9, 0x73, 0x11, 0xc6, 0xcf, 0x9e, 0x8a, 0x2b, 0x63, 0xa4, 0x67, 0xe0, 0xbc, + 0x09, 0xd5, 0x81, 0xe7, 0x0a, 0xf4, 0x73, 0x48, 0xc7, 0x54, 0xed, 0x64, 0xcc, 0x9f, 0x42, 0x95, + 0xe2, 0x03, 0xd4, 0x8a, 0xb5, 0x37, 0xde, 0x7c, 0x1d, 0xaa, 0xc4, 0x0c, 0xf0, 0x45, 0xf4, 0xf2, + 0x3d, 0x4f, 0x51, 0xae, 0xb3, 0x6a, 0x27, 0x63, 0x9c, 0x30, 0xc9, 0x7b, 0x76, 0xc2, 0x75, 0x3d, + 0xe1, 0x69, 0x38, 0xff, 0x08, 0xde, 0x22, 0xd8, 0x94, 0x91, 0xc4, 0xab, 0x86, 0x4c, 0xe7, 0x3f, + 0x44, 0x87, 0x65, 0xe4, 0xf4, 0xc5, 0x81, 0x37, 0xf4, 0x54, 0x63, 0xe5, 0x5e, 0xee, 0x7e, 0xc9, + 0x4e, 0x01, 0xfc, 0x3d, 0x58, 0x77, 0xc5, 0xa9, 0x33, 0xf6, 0x55, 0x57, 0x0c, 0x47, 0xbe, 0xa3, + 0x44, 0xcb, 0x25, 0x19, 0xad, 0xd9, 0xb3, 0x0f, 0xf8, 0xfb, 0x70, 0xc3, 0x00, 0xdb, 0x49, 0x86, + 0xba, 0xe5, 0x52, 0x16, 0xae, 0x66, 0xcf, 0x7b, 0x64, 0x1d, 0x1a, 0x35, 0x8c, 0x06, 0x14, 0xe3, + 0xd4, 0x58, 0x81, 0x46, 0x4a, 0x5b, 0xe4, 0x27, 0x8e, 0xef, 0x8b, 0xf0, 0x4a, 0x07, 0xb9, 0x4f, + 0x9d, 0xe0, 0xc4, 0x09, 0x58, 0x81, 0x6c, 0xac, 0xe3, 0x8b, 0xc0, 0x75, 0x42, 0x6d, 0x91, 0x9f, + 0x90, 0x41, 0x2f, 0x59, 0xf7, 0xa1, 0x48, 0x5b, 0x5a, 0x83, 0x92, 0x8e, 0x92, 0x28, 0x62, 0x36, + 0x11, 0x12, 0x69, 0xe4, 0x03, 0xbc, 0x7e, 0x2c, 0xdf, 0xfc, 0x97, 0x05, 0xa8, 0xc6, 0x9b, 0x17, + 0xe7, 0xa3, 0x73, 0x69, 0x3e, 0x1a, 0xdd, 0xb8, 0xe8, 0xb9, 0x17, 0x79, 0x27, 0xc6, 0x2d, 0xad, + 0xda, 0x29, 0x00, 0x3d, 0xa1, 0x0b, 0xcf, 0x55, 0x03, 0xba, 0x33, 0x25, 0x5b, 0x0f, 0xf8, 0x7d, + 0x58, 0x73, 0x71, 0x1f, 0x82, 0x9e, 0x3f, 0x76, 0x45, 0x17, 0xad, 0xa8, 0x4e, 0x13, 0x4c, 0x83, + 0xf9, 0xf7, 0x01, 0x94, 0x37, 0x14, 0x7b, 0x32, 0x1c, 0x3a, 0xca, 0xc4, 0x06, 0xdf, 0x7c, 0x33, + 0xa9, 0xde, 0xe8, 0x26, 0x0c, 0xec, 0x0c, 0x33, 0x64, 0x8d, 0x6f, 0x33, 0xac, 0x2b, 0x5f, 0x8a, + 0xf5, 0x4e, 0xc2, 0xc0, 0xce, 0x30, 0xb3, 0xfe, 0x22, 0x40, 0xfa, 0x84, 0xdf, 0x02, 0x7e, 0x28, + 0x03, 0x35, 0xd8, 0x3c, 0x39, 0x09, 0xb7, 0xc4, 0xa9, 0x0c, 0xc5, 0x8e, 0x83, 0x66, 0xed, 0x2d, + 0x58, 0x4f, 0xe0, 0x9b, 0xa7, 0x4a, 0x84, 0x08, 0xa6, 0xad, 0xef, 0x0c, 0x64, 0xa8, 0xb4, 0x6f, + 0x45, 0x3f, 0x9f, 0x75, 0x58, 0x01, 0x4d, 0x69, 0xab, 0xd3, 0x66, 0x45, 0xeb, 0x3e, 0x40, 0xba, + 0x24, 0x8a, 0x41, 0xe8, 0xd7, 0x07, 0x8f, 0x4c, 0x44, 0x42, 0xa3, 0x47, 0x1f, 0xb1, 0x5c, 0xf3, + 0x5f, 0xe4, 0xa1, 0x88, 0xaa, 0xc6, 0xa8, 0xc3, 0x72, 0xa2, 0x0e, 0xef, 0x41, 0x3d, 0x7b, 0x4f, + 0xf4, 0x71, 0x66, 0x41, 0x5f, 0x4e, 0x61, 0xe2, 0xbb, 0xb2, 0x0a, 0xf3, 0x13, 0xa8, 0xf7, 0xc6, + 0x91, 0x92, 0x43, 0xb2, 0x16, 0x8d, 0x02, 0x29, 0xa5, 0x5b, 0x33, 0x89, 0x8d, 0xe7, 0x8e, 0x3f, + 0x16, 0x76, 0x16, 0x95, 0x7f, 0x0c, 0xe5, 0x53, 0x7d, 0x30, 0x3a, 0xb5, 0xf1, 0xeb, 0xaf, 0x30, + 0x28, 0x66, 0xf3, 0x0d, 0x32, 0xae, 0xcb, 0x9b, 0x11, 0xaa, 0x2c, 0xc8, 0xfa, 0x2d, 0x73, 0x8d, + 0x2a, 0x50, 0xd8, 0x8c, 0x7a, 0x26, 0x30, 0x16, 0x51, 0x4f, 0x7b, 0xdd, 0xdb, 0x34, 0x05, 0x96, + 0x6f, 0xfe, 0xac, 0x02, 0x65, 0xad, 0x60, 0xcd, 0xde, 0xd5, 0x92, 0xbd, 0xfb, 0x1e, 0x54, 0xe5, + 0x48, 0x84, 0x8e, 0x92, 0xa1, 0x89, 0xce, 0x3f, 0x7e, 0x13, 0x85, 0xbd, 0xd1, 0x36, 0xc4, 0x76, + 0xc2, 0x66, 0xfa, 0x38, 0xf2, 0xb3, 0xc7, 0xf1, 0x00, 0x58, 0xac, 0x9b, 0x8f, 0x43, 0xa4, 0x53, + 0x57, 0x26, 0xd6, 0x9a, 0x81, 0xf3, 0x2e, 0xd4, 0x7a, 0x32, 0x70, 0xbd, 0x24, 0x52, 0x5f, 0x7d, + 0xf4, 0x8d, 0x37, 0x9a, 0xe1, 0x76, 0x4c, 0x6d, 0xa7, 0x8c, 0xf8, 0x7b, 0x50, 0x3a, 0xc7, 0x73, + 0xa2, 0x03, 0x79, 0xf5, 0x29, 0x6a, 0x24, 0xfe, 0x05, 0xd4, 0x7f, 0x38, 0xf6, 0x7a, 0x67, 0xed, + 0x6c, 0x26, 0xe8, 0x93, 0x37, 0x9a, 0xc5, 0xf7, 0x52, 0x7a, 0x3b, 0xcb, 0x2c, 0x23, 0x1b, 0x95, + 0x3f, 0x83, 0x6c, 0x54, 0x67, 0x65, 0xe3, 0x6d, 0xa8, 0xc6, 0x87, 0x43, 0xf2, 0x11, 0xb8, 0x6c, + 0x89, 0x97, 0x21, 0xdf, 0x0e, 0x59, 0xce, 0xfa, 0x9f, 0x39, 0xa8, 0x25, 0x1b, 0x33, 0x99, 0xf5, + 0xd9, 0xfd, 0xe1, 0xd8, 0xf1, 0x59, 0x8e, 0xc2, 0x16, 0xa9, 0xf4, 0x88, 0x2e, 0xef, 0x13, 0x2a, + 0xc0, 0x85, 0xac, 0x40, 0xaa, 0x5a, 0x44, 0x11, 0x2b, 0x72, 0x0e, 0xab, 0x06, 0xdc, 0x0e, 0x35, + 0x6a, 0x09, 0xa3, 0x1a, 0x7c, 0x1a, 0x03, 0xca, 0x5a, 0xb3, 0x9f, 0x09, 0x1d, 0xb5, 0x1d, 0x49, + 0x45, 0x83, 0x2a, 0xce, 0xa5, 0x15, 0xb0, 0x1a, 0xbe, 0xf3, 0x48, 0xaa, 0x56, 0xc0, 0x20, 0x75, + 0x93, 0xeb, 0xf1, 0xeb, 0x69, 0xb4, 0x4c, 0x4e, 0xb8, 0xef, 0xb7, 0x02, 0xb6, 0x62, 0x1e, 0xe8, + 0xd1, 0x2a, 0x72, 0xdc, 0xbd, 0x74, 0x7a, 0x48, 0xbe, 0xc6, 0x57, 0x01, 0x90, 0xc6, 0x8c, 0x19, + 0xde, 0x81, 0xdd, 0x4b, 0x2f, 0x52, 0x11, 0x5b, 0xb7, 0xfe, 0x43, 0x0e, 0xea, 0x99, 0x43, 0x40, + 0x37, 0x9c, 0x10, 0x51, 0xb5, 0x69, 0xaf, 0xfc, 0xfb, 0x22, 0x52, 0x22, 0x74, 0x63, 0xb5, 0xd5, + 0x95, 0xf8, 0x33, 0x8f, 0xef, 0xeb, 0xca, 0xa1, 0x0c, 0x43, 0x79, 0xa1, 0x4d, 0xd0, 0x81, 0x13, + 0xa9, 0x17, 0x42, 0x9c, 0xb1, 0x22, 0x2e, 0x75, 0x7b, 0x1c, 0x86, 0x22, 0xd0, 0x80, 0x12, 0x4d, + 0x4e, 0x5c, 0xea, 0x51, 0x19, 0x99, 0x22, 0x32, 0xe9, 0x45, 0x56, 0xe1, 0x0c, 0x96, 0x0d, 0xb6, + 0x86, 0x54, 0x11, 0x01, 0xd1, 0xf5, 0xb0, 0x86, 0x91, 0xae, 0x8e, 0x14, 0xdb, 0xa7, 0x3b, 0xce, + 0x55, 0xb4, 0xd9, 0x97, 0x0c, 0xa6, 0x81, 0x47, 0xf2, 0x82, 0xd5, 0x9b, 0x63, 0x80, 0xd4, 0x37, + 0xc6, 0x98, 0x00, 0x65, 0x2d, 0xc9, 0xe5, 0x9a, 0x11, 0x6f, 0x03, 0xe0, 0x2f, 0xc2, 0x8c, 0x03, + 0x83, 0x37, 0x70, 0x58, 0x88, 0xce, 0xce, 0xb0, 0x68, 0xfe, 0x35, 0xa8, 0x25, 0x0f, 0x30, 0x14, + 0x24, 0xd7, 0x22, 0x79, 0x6d, 0x3c, 0x44, 0x3b, 0xe9, 0x05, 0xae, 0xb8, 0xa4, 0xbb, 0x5f, 0xb2, + 0xf5, 0x00, 0x67, 0x39, 0xf0, 0x5c, 0x57, 0x04, 0x71, 0xc6, 0x5d, 0x8f, 0xe6, 0x95, 0x37, 0x8b, + 0x73, 0xcb, 0x9b, 0xcd, 0xbf, 0x04, 0xf5, 0x8c, 0xf3, 0xfe, 0xca, 0x65, 0x67, 0x26, 0x96, 0x9f, + 0x9c, 0xd8, 0x1d, 0xa8, 0x49, 0xe3, 0x81, 0x47, 0xa4, 0xc0, 0x6b, 0x76, 0x0a, 0x40, 0x03, 0x53, + 0xd2, 0x4b, 0x9b, 0x76, 0xb8, 0xf7, 0xa0, 0x8c, 0xd1, 0xe7, 0x38, 0xae, 0x0d, 0x2f, 0xe8, 0xd4, + 0x76, 0x88, 0x66, 0x7f, 0xc9, 0x36, 0xd4, 0xfc, 0x33, 0x28, 0x28, 0xa7, 0x6f, 0x12, 0x56, 0x5f, + 0x5d, 0x8c, 0x49, 0xd7, 0xe9, 0xef, 0x2f, 0xd9, 0x48, 0xc7, 0x0f, 0xa0, 0xda, 0x33, 0x39, 0x06, + 0xa3, 0xb8, 0x16, 0xf4, 0x89, 0xe3, 0xcc, 0xc4, 0xfe, 0x92, 0x9d, 0x70, 0xe0, 0xdf, 0x81, 0x22, + 0x5a, 0x79, 0xd2, 0xbc, 0x0b, 0xfb, 0xfa, 0x78, 0x5d, 0xf6, 0x97, 0x6c, 0xa2, 0xdc, 0xaa, 0x40, + 0x89, 0xf4, 0x64, 0xb3, 0x01, 0x65, 0xbd, 0xd6, 0xe9, 0x9d, 0x6b, 0xde, 0x86, 0x42, 0xd7, 0xe9, + 0xa3, 0xa7, 0xe5, 0xb9, 0x91, 0x09, 0x59, 0xf1, 0x67, 0xf3, 0x9d, 0x34, 0x5f, 0x92, 0x4d, 0xc5, + 0xe5, 0x26, 0x52, 0x71, 0xcd, 0x32, 0x14, 0xf1, 0x8d, 0xcd, 0x3b, 0xd7, 0x79, 0x6d, 0xcd, 0xff, + 0x9d, 0x47, 0x07, 0x4f, 0x89, 0xcb, 0xb9, 0x69, 0xc6, 0xef, 0x42, 0x6d, 0x14, 0xca, 0x9e, 0x88, + 0x22, 0x19, 0x1a, 0x0f, 0xe0, 0xbd, 0xd7, 0x57, 0xf2, 0x36, 0x8e, 0x63, 0x1a, 0x3b, 0x25, 0xb7, + 0xfe, 0x20, 0x0f, 0xb5, 0xe4, 0x81, 0xf6, 0x2b, 0x95, 0xb8, 0xd4, 0x29, 0xa5, 0x43, 0x11, 0x0e, + 0x1d, 0xcf, 0xd5, 0xda, 0x63, 0x7b, 0xe0, 0xc4, 0x4e, 0xcf, 0xf7, 0xe5, 0x58, 0x8d, 0x4f, 0x84, + 0x4e, 0x25, 0x3c, 0xf7, 0x86, 0x42, 0xb2, 0x22, 0x25, 0xf1, 0x51, 0xb0, 0x7b, 0xbe, 0x1c, 0xbb, + 0xac, 0x84, 0xe3, 0x27, 0x64, 0x82, 0x0e, 0x9d, 0x51, 0xa4, 0x75, 0xe6, 0xa1, 0x17, 0x4a, 0x56, + 0x41, 0xa2, 0x3d, 0xaf, 0x3f, 0x74, 0x58, 0x15, 0x99, 0x75, 0x2f, 0x3c, 0x85, 0x4a, 0xb8, 0xc6, + 0xd7, 0x61, 0xa5, 0x3d, 0x12, 0x41, 0x47, 0x85, 0x42, 0xa8, 0x43, 0x67, 0xa4, 0x73, 0x4b, 0xb6, + 0x70, 0x5d, 0x4f, 0x69, 0xfd, 0xb9, 0xe7, 0xf4, 0xc4, 0x89, 0x94, 0x67, 0x6c, 0x19, 0x15, 0x4d, + 0x2b, 0x88, 0x94, 0xd3, 0x0f, 0x9d, 0xa1, 0xd6, 0xa1, 0x5d, 0xe1, 0x0b, 0x1a, 0xad, 0xd2, 0xbb, + 0x3d, 0x35, 0x18, 0x9f, 0x3c, 0x41, 0xff, 0x7b, 0x4d, 0xe7, 0xfb, 0x5d, 0x31, 0x12, 0xa8, 0x43, + 0x97, 0xa1, 0xba, 0xe5, 0xf9, 0xde, 0x89, 0xe7, 0x7b, 0x6c, 0x1d, 0x51, 0x77, 0x2f, 0x7b, 0x8e, + 0xef, 0xb9, 0xa1, 0x73, 0xc1, 0x78, 0x73, 0x1d, 0xd6, 0xa6, 0x2a, 0x96, 0xcd, 0x8a, 0x71, 0xe9, + 0x9b, 0x2b, 0x50, 0xcf, 0xd4, 0xa0, 0x9a, 0xef, 0x42, 0x35, 0xae, 0x50, 0x61, 0xe8, 0xe3, 0x45, + 0x3a, 0xb7, 0x66, 0x4e, 0x3c, 0x19, 0x37, 0xff, 0x79, 0x0e, 0xca, 0xba, 0xca, 0xc7, 0xb7, 0x92, + 0xaa, 0x7c, 0x6e, 0x81, 0x92, 0x90, 0x26, 0x32, 0x05, 0xb5, 0xa4, 0x34, 0x7f, 0x13, 0x4a, 0x3e, + 0xc5, 0x38, 0x46, 0x17, 0xd1, 0x20, 0xa3, 0x3a, 0x0a, 0x59, 0xd5, 0x61, 0x3d, 0x4e, 0x8a, 0x78, + 0x71, 0x3e, 0x87, 0x7c, 0xaa, 0x6e, 0x28, 0x84, 0xce, 0xd5, 0x50, 0x88, 0x92, 0x27, 0xc5, 0x2f, + 0x87, 0x23, 0xa7, 0xa7, 0x08, 0x50, 0xb0, 0x4e, 0xa1, 0x7a, 0x2c, 0xa3, 0x69, 0x73, 0x5a, 0x81, + 0x42, 0x57, 0x8e, 0xb4, 0x37, 0xb6, 0x25, 0x15, 0x79, 0x63, 0xda, 0x7a, 0x9e, 0x2a, 0x2d, 0x0f, + 0xb6, 0xd7, 0x1f, 0x28, 0x1d, 0xcc, 0xb4, 0x82, 0x40, 0x84, 0xac, 0x84, 0xdb, 0x6f, 0x8b, 0x91, + 0xef, 0xf4, 0x04, 0x2b, 0xe3, 0x86, 0x13, 0x7c, 0xcf, 0x0b, 0x23, 0xc5, 0x2a, 0xd6, 0x63, 0x34, + 0x84, 0x5e, 0x9f, 0xec, 0x17, 0xfd, 0x20, 0x56, 0x4b, 0x38, 0x21, 0x1a, 0x6e, 0x8b, 0x00, 0xc5, + 0x83, 0xaa, 0x44, 0xba, 0x4d, 0x83, 0x5e, 0x90, 0xb7, 0x5e, 0xc0, 0xca, 0x44, 0xfb, 0x06, 0xbf, + 0x09, 0x6c, 0x02, 0x80, 0x13, 0x5d, 0xe2, 0xb7, 0xe1, 0xc6, 0x04, 0xf4, 0xd0, 0x73, 0x5d, 0x4a, + 0x8e, 0x4d, 0x3f, 0x88, 0x97, 0xb3, 0x55, 0x83, 0x4a, 0x4f, 0x9f, 0x80, 0x75, 0x0c, 0x2b, 0x74, + 0x24, 0x87, 0x42, 0x39, 0xed, 0xc0, 0xbf, 0xfa, 0x33, 0xf7, 0xd8, 0x58, 0x5f, 0x83, 0x12, 0x25, + 0xb3, 0xf1, 0x62, 0x9f, 0x86, 0x72, 0x48, 0xbc, 0x4a, 0x36, 0xfd, 0x46, 0xee, 0x4a, 0x9a, 0x73, + 0xcd, 0x2b, 0x69, 0xfd, 0x04, 0xa0, 0xb2, 0xd9, 0xeb, 0xc9, 0x71, 0xa0, 0x66, 0xde, 0x3c, 0x2f, + 0x5f, 0xfa, 0x31, 0x94, 0x9d, 0x73, 0x47, 0x39, 0xa1, 0x51, 0xc8, 0xd3, 0xae, 0x97, 0xe1, 0xb5, + 0xb1, 0x49, 0x48, 0xb6, 0x41, 0x46, 0xb2, 0x9e, 0x0c, 0x4e, 0xbd, 0xbe, 0xd1, 0xc1, 0xaf, 0x22, + 0xdb, 0x26, 0x24, 0xdb, 0x20, 0x23, 0x99, 0xb1, 0x21, 0xa5, 0x6b, 0xc9, 0xb4, 0x22, 0x4d, 0x4c, + 0xc6, 0x43, 0x28, 0x7a, 0xc1, 0xa9, 0x34, 0x0d, 0x5e, 0x6f, 0xbf, 0x82, 0x88, 0xba, 0x9c, 0x08, + 0xb1, 0x29, 0xa0, 0xac, 0x27, 0xcc, 0xbf, 0x09, 0x25, 0xaa, 0x59, 0x99, 0x2a, 0xc1, 0x42, 0xed, + 0x30, 0x9a, 0x82, 0xdf, 0x8a, 0x4b, 0x20, 0xb4, 0x5f, 0x08, 0xa7, 0xe1, 0x56, 0x35, 0xde, 0xb2, + 0xe6, 0x7f, 0xcb, 0x41, 0x59, 0xaf, 0x90, 0xbf, 0x0b, 0xab, 0x22, 0xc0, 0xab, 0x1d, 0x5b, 0x09, + 0x73, 0xa7, 0xa7, 0xa0, 0xe8, 0xb3, 0x1a, 0x88, 0x38, 0x19, 0xf7, 0x4d, 0x78, 0x9d, 0x05, 0xf1, + 0x4f, 0xe0, 0xb6, 0x1e, 0x1e, 0x87, 0x22, 0x14, 0xbe, 0x70, 0x22, 0xb1, 0x3d, 0x70, 0x82, 0x40, + 0xf8, 0xc6, 0x67, 0x78, 0xd5, 0x63, 0x6e, 0xc1, 0xb2, 0x7e, 0xd4, 0x19, 0x39, 0x3d, 0x11, 0x99, + 0x92, 0xce, 0x04, 0x8c, 0x7f, 0x1d, 0x4a, 0xd4, 0x66, 0xd7, 0x70, 0xaf, 0x17, 0x3e, 0x8d, 0xd5, + 0x94, 0x89, 0x51, 0xdb, 0x04, 0xd0, 0xa7, 0x81, 0xc1, 0x96, 0xd1, 0x45, 0xbf, 0x71, 0xed, 0xf1, + 0x51, 0xd8, 0x98, 0x21, 0xc2, 0xf9, 0xb9, 0xc2, 0x17, 0xa8, 0x1f, 0xd0, 0xa0, 0xd1, 0xe2, 0x0b, + 0xf6, 0x04, 0xac, 0xf9, 0xbb, 0x45, 0x28, 0xe2, 0x41, 0x22, 0xf2, 0x40, 0x0e, 0x45, 0x92, 0x42, + 0xd4, 0x42, 0x3b, 0x01, 0x43, 0xaf, 0xc9, 0xd1, 0x55, 0xdc, 0x04, 0x4d, 0xab, 0xb2, 0x69, 0x30, + 0x62, 0x8e, 0x42, 0x79, 0xea, 0xf9, 0x29, 0xa6, 0xf1, 0xaf, 0xa6, 0xc0, 0xfc, 0x1b, 0x70, 0x6b, + 0xe8, 0x84, 0x67, 0x42, 0x91, 0xf6, 0x79, 0x21, 0xc3, 0xb3, 0x08, 0x77, 0xae, 0xe5, 0x9a, 0xdc, + 0xd3, 0x2b, 0x9e, 0xa2, 0x3a, 0x77, 0xc5, 0xb9, 0x47, 0x98, 0x55, 0xc2, 0x4c, 0xc6, 0x28, 0x1c, + 0x8e, 0xde, 0x9a, 0x8e, 0xe1, 0x65, 0xca, 0x02, 0x93, 0x50, 0x74, 0xcd, 0x74, 0x47, 0x47, 0xd4, + 0x72, 0x29, 0x1d, 0x56, 0xb3, 0x53, 0x00, 0x8a, 0x0e, 0xbd, 0xec, 0xb9, 0x56, 0xda, 0x2b, 0x3a, + 0xa6, 0xcc, 0x80, 0x10, 0x43, 0x89, 0xde, 0x20, 0x7e, 0x89, 0xce, 0x55, 0x65, 0x41, 0xfc, 0x2e, + 0x40, 0xdf, 0x51, 0xe2, 0xc2, 0xb9, 0x7a, 0x16, 0xfa, 0x0d, 0xa1, 0x13, 0xd5, 0x29, 0x04, 0xa3, + 0x52, 0x5f, 0xf6, 0x1c, 0xbf, 0xa3, 0x64, 0xe8, 0xf4, 0xc5, 0xb1, 0xa3, 0x06, 0x8d, 0xbe, 0x8e, + 0x4a, 0xa7, 0xe1, 0xb8, 0x62, 0xe5, 0x0d, 0xc5, 0x17, 0x32, 0x10, 0x8d, 0x81, 0x5e, 0x71, 0x3c, + 0xc6, 0x99, 0x38, 0x81, 0xe3, 0x5f, 0x29, 0xaf, 0x87, 0x6b, 0xf1, 0xf4, 0x4c, 0x32, 0x20, 0x5c, + 0x6b, 0x20, 0xd4, 0x85, 0x0c, 0xcf, 0x5a, 0x6e, 0xe3, 0x07, 0x7a, 0xad, 0x09, 0xc0, 0x6a, 0x03, + 0xa4, 0x42, 0x84, 0x96, 0x63, 0x93, 0x92, 0xe9, 0x6c, 0x09, 0x43, 0x81, 0x63, 0x11, 0xb8, 0x5e, + 0xd0, 0xdf, 0x31, 0x72, 0xc3, 0x72, 0x08, 0xec, 0x28, 0x27, 0x54, 0xc2, 0x4d, 0x80, 0xe4, 0x76, + 0xd0, 0x48, 0xb8, 0xac, 0x60, 0xfd, 0xbf, 0x1c, 0xd4, 0x33, 0x25, 0xe7, 0x5f, 0x61, 0x99, 0x1c, + 0xed, 0x38, 0xea, 0x0b, 0xdc, 0x50, 0x2d, 0x53, 0xc9, 0x18, 0xb7, 0xdb, 0x54, 0xc4, 0xf1, 0xa9, + 0x0e, 0xef, 0x33, 0x90, 0x2f, 0x55, 0x22, 0xb7, 0x1e, 0x99, 0x84, 0x47, 0x1d, 0x2a, 0xcf, 0x82, + 0xb3, 0x40, 0x5e, 0x04, 0xda, 0x40, 0x53, 0xdf, 0xc3, 0x44, 0x05, 0x27, 0x6e, 0x4d, 0x28, 0x58, + 0xff, 0xa4, 0x38, 0xd5, 0x22, 0xb4, 0x0b, 0x65, 0xed, 0xf4, 0x93, 0x3f, 0x3a, 0xdb, 0xd3, 0x91, + 0x45, 0x36, 0xd5, 0x82, 0x0c, 0xc8, 0x36, 0xc4, 0xe8, 0x8d, 0x27, 0x7d, 0x70, 0xf9, 0xb9, 0x55, + 0x8d, 0x09, 0x46, 0xb1, 0x1a, 0x9c, 0x68, 0x05, 0x4d, 0x38, 0x34, 0xff, 0x56, 0x0e, 0x6e, 0xce, + 0x43, 0x41, 0xe7, 0xf8, 0x64, 0xa2, 0x53, 0x27, 0x1e, 0xf2, 0xce, 0x54, 0x03, 0x6a, 0x9e, 0x56, + 0xf3, 0xf0, 0x0d, 0x27, 0x31, 0xd9, 0x8e, 0x6a, 0xfd, 0x34, 0x07, 0xeb, 0x33, 0x6b, 0xce, 0xb8, + 0x34, 0x00, 0x65, 0x2d, 0x59, 0xba, 0xb1, 0x24, 0x29, 0xf5, 0xeb, 0x54, 0x2d, 0xd9, 0x94, 0x48, + 0xd7, 0x4e, 0x77, 0x74, 0x27, 0xb5, 0x76, 0x76, 0xf1, 0xd4, 0x50, 0x57, 0xf7, 0x05, 0x2b, 0x61, + 0x20, 0xac, 0xbd, 0x2c, 0x03, 0x29, 0x6b, 0x87, 0x54, 0xe7, 0x93, 0x59, 0x85, 0x1a, 0x56, 0xc6, + 0x23, 0xdf, 0xeb, 0xe1, 0xb0, 0xca, 0x9b, 0x70, 0x4b, 0x37, 0xff, 0x9a, 0xe0, 0xef, 0xb4, 0x3b, + 0xf0, 0xe8, 0x72, 0xb0, 0x9a, 0x65, 0xc3, 0x8d, 0x39, 0x6b, 0xa2, 0x59, 0x3e, 0x37, 0x33, 0x5e, + 0x05, 0xd8, 0x79, 0x1e, 0xcf, 0x93, 0xe5, 0x38, 0x87, 0xd5, 0x9d, 0xe7, 0x59, 0x86, 0xe6, 0xbe, + 0x3c, 0x47, 0x4d, 0x12, 0xb1, 0x82, 0xf5, 0x7b, 0xb9, 0xb8, 0x88, 0xdc, 0xfc, 0xab, 0xb0, 0xa2, + 0xe7, 0x78, 0xec, 0x5c, 0xf9, 0xd2, 0x71, 0xf9, 0x2e, 0xac, 0x46, 0x49, 0x47, 0x7a, 0xc6, 0x1c, + 0x4c, 0x5b, 0xf3, 0xce, 0x04, 0x92, 0x3d, 0x45, 0x14, 0xc7, 0x30, 0xf9, 0x34, 0xf3, 0xcc, 0x29, + 0x1a, 0x73, 0xe8, 0x96, 0x2d, 0x53, 0x7c, 0xe5, 0x58, 0x5f, 0x87, 0x75, 0x52, 0x5e, 0x7a, 0x32, + 0xda, 0x3f, 0x46, 0x79, 0xd0, 0x7a, 0x77, 0x27, 0x96, 0x07, 0x33, 0xb4, 0xfe, 0x69, 0x19, 0x20, + 0xcd, 0xb2, 0xcf, 0xb9, 0xe6, 0xf3, 0x9c, 0xa0, 0x99, 0x9a, 0x57, 0xe1, 0x8d, 0x6b, 0x5e, 0x9f, + 0x24, 0x6e, 0xba, 0x4e, 0x6f, 0x4e, 0x37, 0xc0, 0xa6, 0x73, 0x9a, 0x76, 0xce, 0x27, 0x7a, 0x2a, + 0x4a, 0xd3, 0x3d, 0x15, 0xf7, 0x66, 0x1b, 0xb0, 0xa6, 0xf4, 0x4f, 0x9a, 0x52, 0xa8, 0x4c, 0xa4, + 0x14, 0x9a, 0x50, 0x0d, 0x85, 0xe3, 0xca, 0xc0, 0xbf, 0x8a, 0x4b, 0x2b, 0xf1, 0x98, 0x7f, 0x08, + 0x25, 0x45, 0x4d, 0xf5, 0x55, 0xba, 0x2e, 0xaf, 0x39, 0x38, 0x8d, 0x8b, 0xca, 0xcc, 0x8b, 0x4c, + 0xd7, 0x94, 0xb6, 0x60, 0x55, 0x3b, 0x03, 0xe1, 0x1b, 0xc0, 0x3d, 0x8c, 0xaf, 0x7c, 0x5f, 0xb8, + 0x5b, 0x57, 0x3b, 0xba, 0xe2, 0x41, 0x56, 0xb3, 0x6a, 0xcf, 0x79, 0x12, 0x9f, 0xff, 0x72, 0x7a, + 0xfe, 0x34, 0xe5, 0x73, 0x2f, 0xc2, 0x95, 0xae, 0x90, 0x73, 0x90, 0x8c, 0xd1, 0x2e, 0xc7, 0x77, + 0x54, 0xef, 0x25, 0x49, 0x6f, 0x5a, 0x36, 0x7c, 0xc5, 0x53, 0xeb, 0x1f, 0xe6, 0x93, 0x70, 0xa6, + 0x06, 0xa5, 0x13, 0x27, 0xf2, 0x7a, 0x3a, 0x54, 0x35, 0x86, 0x5f, 0x87, 0x34, 0x4a, 0xba, 0x92, + 0xe5, 0x31, 0x56, 0x89, 0x04, 0x46, 0x25, 0xab, 0x00, 0xe9, 0x87, 0x06, 0xac, 0x88, 0x77, 0x33, + 0x3e, 0x6f, 0xdd, 0xfc, 0x40, 0xa4, 0x94, 0xdd, 0x72, 0x93, 0xb6, 0x32, 0x8a, 0x53, 0x49, 0xf7, + 0xb3, 0x2a, 0xe2, 0x04, 0x52, 0x09, 0x9d, 0xdb, 0x23, 0xe9, 0x64, 0x80, 0x6c, 0xe2, 0xa6, 0x65, + 0x56, 0xc7, 0x70, 0x22, 0x66, 0xaa, 0x13, 0x72, 0x11, 0x05, 0x52, 0xcb, 0x78, 0x3b, 0x27, 0x1f, + 0xb0, 0x15, 0x9c, 0x51, 0xfa, 0xfd, 0x02, 0x5b, 0x45, 0xae, 0x0e, 0x95, 0xe4, 0xd7, 0xf0, 0xe7, + 0x39, 0x15, 0xea, 0x19, 0xbe, 0xd5, 0x45, 0x85, 0xb1, 0x8e, 0x33, 0x4b, 0x5c, 0x03, 0xc6, 0x31, + 0x36, 0x1a, 0x39, 0x18, 0xba, 0x78, 0x23, 0x27, 0x50, 0xec, 0x06, 0x2e, 0x75, 0xe4, 0x9e, 0xb2, + 0x9b, 0xd6, 0x4f, 0xd2, 0xa6, 0xcd, 0xf7, 0x93, 0x80, 0x61, 0x11, 0x01, 0x7e, 0x55, 0x48, 0xb1, + 0x0b, 0xeb, 0xa1, 0xf8, 0xe1, 0xd8, 0x9b, 0xe8, 0x48, 0x2e, 0x5c, 0x5f, 0x4b, 0x9f, 0xa5, 0xb0, + 0xce, 0x61, 0x3d, 0x1e, 0xbc, 0xf0, 0xd4, 0x80, 0x92, 0x2c, 0xfc, 0xc3, 0x4c, 0xcb, 0x74, 0x6e, + 0xee, 0xf7, 0x0e, 0x09, 0xcb, 0xb4, 0x45, 0x3a, 0x49, 0x74, 0xe7, 0x17, 0x48, 0x74, 0x5b, 0xff, + 0xb7, 0x9c, 0xc9, 0xb3, 0xe8, 0x10, 0xca, 0x4d, 0x42, 0xa8, 0xd9, 0x6a, 0x59, 0x9a, 0xbb, 0xce, + 0xbf, 0x49, 0xee, 0x7a, 0x5e, 0xe5, 0xf9, 0x53, 0xf4, 0x8f, 0xe9, 0x6e, 0x3c, 0x5f, 0x20, 0x2f, + 0x3f, 0x81, 0xcb, 0xb7, 0xa8, 0xf6, 0xe5, 0x74, 0x74, 0x5b, 0x44, 0x69, 0xee, 0x07, 0x0c, 0xd9, + 0x22, 0x97, 0xc1, 0xb4, 0x33, 0x54, 0x19, 0x4d, 0x52, 0x9e, 0xa7, 0x49, 0x30, 0x9a, 0x35, 0x3a, + 0x26, 0x19, 0xeb, 0x32, 0x86, 0xfe, 0x1d, 0xb3, 0xa7, 0x9a, 0x67, 0xd5, 0x9e, 0x81, 0xa3, 0x87, + 0x35, 0x1c, 0xfb, 0xca, 0x33, 0x99, 0x7a, 0x3d, 0x98, 0xfe, 0xcc, 0xa7, 0x36, 0xfb, 0x99, 0xcf, + 0xb7, 0x01, 0x22, 0x81, 0x92, 0xbf, 0xe3, 0xf5, 0x94, 0x69, 0x9e, 0xb8, 0xfb, 0xaa, 0xb5, 0x99, + 0xfa, 0x42, 0x86, 0x02, 0xe7, 0x3f, 0x74, 0x2e, 0xb7, 0xd1, 0xd3, 0x36, 0x55, 0xde, 0x64, 0x3c, + 0xad, 0x5f, 0x57, 0x67, 0xf5, 0xeb, 0x87, 0x50, 0x8a, 0x7a, 0x72, 0x24, 0xe8, 0x23, 0x81, 0x57, + 0x9f, 0xef, 0x46, 0x07, 0x91, 0x6c, 0x8d, 0x4b, 0xd9, 0x3c, 0xd4, 0x40, 0x32, 0xa4, 0xcf, 0x03, + 0x6a, 0x76, 0x3c, 0x9c, 0xd0, 0x71, 0xb7, 0x26, 0x75, 0x5c, 0xd3, 0x85, 0xb2, 0xc9, 0xcc, 0xcf, + 0x09, 0xdd, 0x29, 0xa7, 0x97, 0xcf, 0xe4, 0xf4, 0x92, 0x16, 0xbd, 0x42, 0xb6, 0x45, 0xef, 0x1e, + 0xd4, 0xc3, 0x4c, 0xe5, 0xc9, 0xf4, 0x65, 0x66, 0x40, 0xd6, 0x17, 0x50, 0xa2, 0xb9, 0xa2, 0x83, + 0xa0, 0xb7, 0x59, 0xfb, 0x8f, 0xb8, 0x28, 0x96, 0xe3, 0x37, 0x81, 0x45, 0x82, 0x1c, 0x0c, 0xd1, + 0x71, 0x86, 0x82, 0x14, 0x60, 0x9e, 0x37, 0xe0, 0xa6, 0xc6, 0x8d, 0x26, 0x9f, 0x90, 0x97, 0xe3, + 0x7b, 0x27, 0xa1, 0x13, 0x5e, 0xb1, 0xa2, 0xf5, 0x6d, 0xaa, 0x93, 0xc6, 0x02, 0x55, 0x4f, 0x3e, + 0x39, 0xd3, 0x2a, 0xd7, 0x15, 0x21, 0x5a, 0x0a, 0x5d, 0xde, 0x36, 0xb1, 0x8f, 0x6e, 0xfa, 0xa1, + 0xe0, 0x82, 0x15, 0xac, 0x17, 0xe8, 0xa6, 0xa6, 0x76, 0xf5, 0x57, 0x76, 0xdf, 0xac, 0xad, 0x8c, + 0x9b, 0x36, 0xd9, 0xe5, 0x93, 0x5b, 0xb4, 0xcb, 0xc7, 0x7a, 0x0a, 0x6b, 0xf6, 0xa4, 0xbe, 0xe6, + 0x9f, 0x40, 0x45, 0x8e, 0xb2, 0x7c, 0x5e, 0x27, 0x97, 0x31, 0xba, 0xf5, 0xa7, 0x39, 0x58, 0x6e, + 0x05, 0x4a, 0x84, 0x81, 0xe3, 0xef, 0xf9, 0x4e, 0x9f, 0x3f, 0x8e, 0xb5, 0xd4, 0xfc, 0xd8, 0x3a, + 0x8b, 0x3b, 0xa9, 0xb0, 0x7c, 0x93, 0x81, 0xe6, 0x6f, 0xc1, 0xba, 0x70, 0x3d, 0x25, 0x43, 0xed, + 0x9c, 0xc6, 0xcd, 0x56, 0x37, 0x81, 0x69, 0x70, 0x87, 0xae, 0x44, 0x57, 0x1f, 0x73, 0x03, 0x6e, + 0x4e, 0x40, 0x63, 0xcf, 0x33, 0xcf, 0xef, 0x40, 0x23, 0xb5, 0x34, 0x3b, 0x32, 0x50, 0xad, 0xc0, + 0x15, 0x97, 0xe4, 0xe6, 0xb0, 0x82, 0xf5, 0x5f, 0x4b, 0xb1, 0x83, 0xf5, 0xdc, 0xb4, 0x62, 0x85, + 0x52, 0xaa, 0xb4, 0xfe, 0xa0, 0x47, 0x99, 0x6f, 0x13, 0xf3, 0x0b, 0x7c, 0x9b, 0xf8, 0xed, 0xf4, + 0xdb, 0x44, 0x6d, 0x28, 0xde, 0x99, 0x6b, 0x7d, 0xa8, 0x83, 0xc4, 0xb8, 0xd4, 0x1d, 0x91, 0xf9, + 0x50, 0xf1, 0x03, 0x13, 0x47, 0x15, 0x17, 0xf1, 0x43, 0x75, 0x25, 0xfb, 0xe3, 0xe9, 0x46, 0xf4, + 0xc5, 0x3a, 0xbd, 0x66, 0x5c, 0x45, 0x78, 0x63, 0x57, 0xf1, 0xf3, 0xa9, 0x90, 0xa5, 0x3a, 0x37, + 0xab, 0x75, 0xcd, 0xd7, 0x72, 0x9f, 0x43, 0x65, 0xe0, 0x45, 0x4a, 0x86, 0xfa, 0x33, 0xc2, 0xd9, + 0x2f, 0x4e, 0x32, 0xbb, 0xb5, 0xaf, 0x11, 0xa9, 0xed, 0x26, 0xa6, 0x6a, 0xf6, 0x01, 0xd2, 0x5d, + 0x9c, 0xd1, 0x35, 0x5f, 0xe2, 0x43, 0xd1, 0x5b, 0x50, 0x8e, 0xc6, 0x27, 0x69, 0x41, 0xc9, 0x8c, + 0x9a, 0x97, 0xd0, 0x9c, 0xb1, 0xe1, 0xc7, 0x22, 0xd4, 0xf3, 0x43, 0x55, 0x18, 0x17, 0x9e, 0xcc, + 0xeb, 0x93, 0x31, 0xff, 0x76, 0xf6, 0x78, 0xb4, 0x08, 0xdd, 0x7b, 0xc5, 0x1e, 0x27, 0x9c, 0x33, + 0xe7, 0xd4, 0xfc, 0x18, 0xea, 0x99, 0xa5, 0xa3, 0xfe, 0x1c, 0x07, 0xae, 0x8c, 0x53, 0xa7, 0xf8, + 0x5b, 0x7f, 0x25, 0xe3, 0xc6, 0xc9, 0x53, 0xfa, 0x6d, 0x9d, 0xc3, 0xdb, 0xc7, 0xa9, 0x9b, 0x74, + 0x2c, 0xc2, 0xa1, 0x17, 0xa1, 0x6a, 0xd6, 0x01, 0x10, 0xc5, 0xfa, 0xae, 0x08, 0x94, 0xa7, 0x62, + 0x9d, 0x94, 0x8c, 0xf9, 0x6f, 0x43, 0x69, 0x24, 0xc2, 0x61, 0x64, 0xf4, 0xd2, 0xf4, 0x99, 0xcc, + 0x65, 0x1b, 0xd9, 0x9a, 0xc6, 0xfa, 0xc7, 0x39, 0xa8, 0x1e, 0x0a, 0xe5, 0xa0, 0x35, 0xe6, 0x87, + 0x53, 0x6f, 0x99, 0x2d, 0x58, 0xc6, 0xa8, 0x1b, 0x26, 0x24, 0xdb, 0x68, 0x19, 0x7c, 0x33, 0xde, + 0x5f, 0x4a, 0x27, 0xd6, 0xdc, 0x82, 0x8a, 0x01, 0x37, 0x1f, 0xc3, 0xda, 0x14, 0x26, 0x7f, 0x07, + 0x56, 0x8c, 0x27, 0xdc, 0xb9, 0x1a, 0xc6, 0xad, 0x23, 0xcb, 0xf6, 0x24, 0x70, 0xab, 0x06, 0x95, + 0x91, 0x26, 0xb0, 0x7e, 0x0a, 0xb0, 0x7c, 0x24, 0x95, 0x77, 0x8a, 0xa1, 0xe9, 0x3c, 0x5b, 0x75, + 0x17, 0x80, 0x8c, 0x9d, 0xae, 0xca, 0xeb, 0x24, 0x5f, 0x06, 0xc2, 0x3f, 0x4d, 0x92, 0xc0, 0xc5, + 0xb9, 0x6e, 0x4a, 0x96, 0xf9, 0x74, 0x26, 0xb8, 0x01, 0x15, 0x2f, 0x3a, 0x40, 0x63, 0x61, 0x5a, + 0x41, 0xe2, 0x21, 0xff, 0x16, 0x94, 0xbd, 0xe1, 0x48, 0x86, 0xca, 0x64, 0x89, 0xaf, 0xe5, 0xda, + 0x22, 0xcc, 0xfd, 0x25, 0xdb, 0xd0, 0x20, 0xb5, 0xb8, 0x24, 0xea, 0xea, 0xeb, 0xa9, 0x77, 0x2f, + 0x63, 0x6a, 0x4d, 0xc3, 0xbf, 0x07, 0x2b, 0x7d, 0xdd, 0xac, 0xa5, 0x19, 0x9b, 0x6b, 0xf9, 0xd5, + 0xeb, 0x98, 0x3c, 0xc9, 0x12, 0xec, 0x2f, 0xd9, 0x93, 0x1c, 0x90, 0x25, 0xba, 0xc4, 0x22, 0x52, + 0x5d, 0xf9, 0x5d, 0xe9, 0x05, 0x14, 0xc2, 0xbd, 0x86, 0xa5, 0x9d, 0x25, 0x40, 0x96, 0x13, 0x1c, + 0xf8, 0x37, 0xd0, 0x87, 0x88, 0x94, 0xf9, 0x2c, 0xf5, 0xde, 0x75, 0x9c, 0xba, 0x22, 0x32, 0x1f, + 0x94, 0x46, 0xe4, 0x67, 0x50, 0x24, 0x61, 0xba, 0x05, 0xf5, 0xa0, 0xf9, 0xb3, 0x1c, 0x94, 0xcd, + 0x5c, 0xef, 0x24, 0xc5, 0xc5, 0xe4, 0x22, 0xa7, 0x00, 0xfe, 0x19, 0xd4, 0x44, 0x18, 0xca, 0x70, + 0x5b, 0xba, 0x71, 0xf3, 0xd1, 0x74, 0xa2, 0x4b, 0xf3, 0xd9, 0xd8, 0x8d, 0xd1, 0xec, 0x94, 0x82, + 0x7f, 0x0a, 0xa0, 0xcf, 0xa8, 0x9b, 0xb6, 0x75, 0x37, 0xe7, 0xd3, 0xeb, 0x84, 0x73, 0x8a, 0x9d, + 0xa6, 0x09, 0xe2, 0x6c, 0x6f, 0x3c, 0x4c, 0xdc, 0xef, 0x52, 0xe6, 0xe3, 0x8d, 0x7f, 0x97, 0x83, + 0xb2, 0x3e, 0x5a, 0xbe, 0x3b, 0x3b, 0xe7, 0xaf, 0xbc, 0x5e, 0x22, 0x36, 0xa6, 0xe7, 0xfe, 0x2d, + 0x00, 0x2d, 0x21, 0x99, 0xb9, 0xdf, 0x99, 0xe2, 0x63, 0x48, 0xe3, 0x9e, 0xb3, 0x14, 0xdf, 0x7a, + 0xa4, 0x5b, 0xec, 0x29, 0xef, 0xf4, 0xec, 0xe0, 0x80, 0x2d, 0xf1, 0x75, 0x58, 0x79, 0x76, 0xf4, + 0xf4, 0xa8, 0xfd, 0xe2, 0xe8, 0xe5, 0xae, 0x6d, 0xb7, 0x6d, 0x9d, 0x7e, 0xda, 0xda, 0xdc, 0x79, + 0xd9, 0x3a, 0x3a, 0x7e, 0xd6, 0x65, 0xf9, 0xe6, 0x1f, 0xe7, 0x60, 0x65, 0x42, 0xb2, 0xfe, 0x7c, + 0x0f, 0x27, 0xb3, 0xc1, 0x85, 0xf9, 0x1b, 0x5c, 0xcc, 0x6c, 0xf0, 0x1f, 0xe4, 0x60, 0x65, 0x42, + 0x46, 0xb3, 0xf4, 0xb9, 0x49, 0xfa, 0xac, 0xa6, 0xcd, 0x4f, 0x69, 0x5a, 0x0b, 0x96, 0xe3, 0xdf, + 0x47, 0x69, 0x0c, 0x35, 0x01, 0xcb, 0xe2, 0x50, 0x17, 0x6b, 0x71, 0x12, 0x07, 0x61, 0x4d, 0xfa, + 0x2e, 0x27, 0x52, 0xd6, 0xe3, 0xa4, 0xc8, 0x51, 0x87, 0x8a, 0xf9, 0xc4, 0x5e, 0xf7, 0x01, 0x75, + 0x06, 0xf2, 0x22, 0xd0, 0x19, 0x02, 0x5b, 0x38, 0xe6, 0xc3, 0x31, 0x5b, 0x8c, 0x7c, 0x8f, 0x92, + 0xca, 0xb7, 0x01, 0x36, 0xc9, 0x26, 0xc7, 0x7d, 0x9c, 0xdb, 0x07, 0xed, 0xce, 0x2e, 0x5b, 0xca, + 0xaa, 0xcb, 0x2f, 0x62, 0xa1, 0xb2, 0x8e, 0xa1, 0x9c, 0x76, 0xf8, 0x1d, 0x3a, 0xe1, 0x99, 0xab, + 0x53, 0xb7, 0xcb, 0x50, 0x3d, 0x36, 0x86, 0x55, 0xbf, 0xea, 0xbb, 0x9d, 0xf6, 0x91, 0x4e, 0x46, + 0xec, 0xb4, 0xbb, 0xba, 0x4f, 0xb0, 0xf3, 0xfc, 0x89, 0xce, 0x21, 0x3e, 0xb1, 0x37, 0x8f, 0xf7, + 0x5f, 0x12, 0x46, 0xc9, 0xfa, 0xe3, 0x7c, 0x7c, 0x07, 0x2d, 0xdb, 0x24, 0x85, 0x01, 0xca, 0x28, + 0x99, 0xd2, 0x30, 0x4e, 0x5e, 0x43, 0xbd, 0x4c, 0xbb, 0x97, 0xda, 0x87, 0x64, 0x79, 0x5e, 0x86, + 0xfc, 0xf1, 0x89, 0x6e, 0x63, 0xda, 0x57, 0x43, 0x5f, 0x37, 0xf6, 0x77, 0x2f, 0x15, 0x2b, 0xe1, + 0x8f, 0xed, 0xe8, 0x9c, 0x95, 0xad, 0x7f, 0x9d, 0x83, 0x5a, 0x72, 0xec, 0x6f, 0x22, 0x86, 0x9c, + 0xc3, 0x6a, 0xeb, 0xa8, 0xbb, 0x6b, 0x1f, 0x6d, 0x1e, 0x18, 0x94, 0x02, 0x3a, 0x9c, 0x47, 0xed, + 0x97, 0xed, 0xad, 0xef, 0xee, 0x6e, 0x77, 0x3b, 0x2f, 0xbb, 0xed, 0x97, 0xad, 0xc3, 0xe3, 0xb6, + 0xdd, 0x65, 0x25, 0x7e, 0x0b, 0xb8, 0xfe, 0xfd, 0xb2, 0xd5, 0x79, 0xb9, 0xbd, 0x79, 0xb4, 0xbd, + 0x7b, 0xb0, 0xbb, 0xc3, 0xca, 0xfc, 0x2b, 0xf0, 0x9b, 0x07, 0xad, 0xc3, 0x56, 0xf7, 0x65, 0x7b, + 0xef, 0xa5, 0xdd, 0x7e, 0xd1, 0x79, 0xd9, 0xb6, 0x5f, 0xda, 0xbb, 0x07, 0x9b, 0xdd, 0x56, 0xfb, + 0xa8, 0xf3, 0x72, 0xf7, 0x77, 0xb6, 0x77, 0x77, 0x77, 0x76, 0x77, 0x58, 0x85, 0xdf, 0x80, 0xb5, + 0xbd, 0xd6, 0xc1, 0xee, 0xcb, 0x83, 0xf6, 0xe6, 0x8e, 0x79, 0x5f, 0xd5, 0xfa, 0x0e, 0x94, 0x5b, + 0xc1, 0xb9, 0xa7, 0x48, 0x4a, 0xcd, 0x69, 0x18, 0xe3, 0x16, 0x0f, 0xf1, 0x72, 0x44, 0x5e, 0x3f, + 0xa0, 0x2f, 0xb6, 0x48, 0xcc, 0x96, 0xed, 0x14, 0x60, 0xfd, 0xb3, 0x3c, 0xac, 0x68, 0x16, 0xb1, + 0xb1, 0xbc, 0x0f, 0x6b, 0x26, 0x8e, 0x6b, 0x4d, 0xba, 0x01, 0xd3, 0x60, 0xfa, 0x8f, 0x06, 0x1a, + 0x74, 0x94, 0xe6, 0x47, 0xb2, 0x20, 0xca, 0xfb, 0x11, 0x73, 0x34, 0xba, 0x3a, 0xe3, 0x99, 0x02, + 0xae, 0x51, 0x5d, 0x77, 0x4c, 0x62, 0xe7, 0x28, 0xd5, 0x5f, 0x29, 0x00, 0xe5, 0x5e, 0x23, 0xf6, + 0x64, 0xb0, 0x9d, 0x74, 0x88, 0x4e, 0xc0, 0xf8, 0x17, 0x70, 0x3b, 0x19, 0xef, 0x06, 0xbd, 0xf0, + 0x6a, 0x94, 0xfc, 0xf7, 0x8b, 0xca, 0x5c, 0x4f, 0x6b, 0xcf, 0xf3, 0xc5, 0x04, 0xa2, 0xfd, 0x2a, + 0x06, 0xd6, 0xcf, 0x72, 0x19, 0x17, 0x43, 0xbb, 0x10, 0xd7, 0x7a, 0x4d, 0xf3, 0x12, 0x48, 0x68, + 0xe4, 0xcd, 0xf4, 0x8d, 0x56, 0x31, 0x43, 0x7e, 0x0c, 0xdc, 0x9b, 0x9d, 0x74, 0x71, 0xc1, 0x49, + 0xcf, 0xa1, 0x9d, 0x8e, 0xff, 0x4b, 0x33, 0xf1, 0xbf, 0xe5, 0x43, 0x35, 0xfe, 0x1f, 0x1a, 0xe8, + 0xe7, 0xd2, 0x7f, 0xd1, 0x48, 0xa2, 0x1d, 0x3d, 0xe2, 0xfb, 0xb0, 0x2a, 0x26, 0xe7, 0x94, 0x5f, + 0x70, 0x4e, 0x53, 0x74, 0xd6, 0x37, 0x61, 0x7d, 0x06, 0x09, 0x37, 0x69, 0xe4, 0xa8, 0xe4, 0xe3, + 0x27, 0xfc, 0x3d, 0x9b, 0x3d, 0xb7, 0xfe, 0x53, 0x1e, 0x96, 0x0f, 0x9d, 0xc0, 0x3b, 0x15, 0x91, + 0x8a, 0x67, 0x1b, 0xf5, 0x06, 0x62, 0xe8, 0xc4, 0xb3, 0xd5, 0x23, 0xe3, 0xb0, 0xe5, 0x67, 0xfa, + 0x02, 0xb2, 0xb9, 0xa8, 0x5b, 0x50, 0x76, 0xc6, 0x6a, 0x90, 0xf4, 0xa1, 0x99, 0x11, 0x9e, 0x8d, + 0xef, 0xf5, 0x44, 0x10, 0xc5, 0xb2, 0x17, 0x0f, 0xd3, 0xfa, 0x59, 0xf9, 0x9a, 0xfa, 0x59, 0x65, + 0x36, 0xbf, 0x72, 0x0f, 0xea, 0x51, 0x2f, 0x14, 0x22, 0x88, 0x06, 0x52, 0xc5, 0xff, 0x7f, 0x25, + 0x0b, 0xa2, 0xba, 0xb1, 0xbc, 0x08, 0xf0, 0x06, 0x62, 0x04, 0x65, 0x8a, 0xa7, 0x13, 0x30, 0x94, + 0x31, 0x72, 0x57, 0xbd, 0x1f, 0x09, 0x72, 0x95, 0x4a, 0x76, 0x32, 0x26, 0x87, 0xd4, 0x51, 0xa2, + 0x2f, 0x43, 0x4f, 0x44, 0x8d, 0x3a, 0xbd, 0x20, 0x03, 0x41, 0x5a, 0xdf, 0x09, 0xfa, 0x63, 0xa7, + 0x2f, 0x4c, 0x36, 0x3a, 0x19, 0x3f, 0xf8, 0xfd, 0x02, 0xac, 0x4e, 0xc6, 0x8f, 0xd4, 0x55, 0xa2, + 0x73, 0x17, 0x6d, 0xdf, 0xcd, 0x94, 0xde, 0x18, 0x5f, 0x83, 0xba, 0x91, 0x79, 0x02, 0xac, 0x93, + 0x76, 0x95, 0x43, 0xc1, 0xee, 0x65, 0x3f, 0x38, 0x7e, 0x1f, 0x95, 0xb4, 0x6e, 0xd4, 0x61, 0x23, + 0x5e, 0x33, 0x9f, 0x5e, 0xfd, 0x38, 0xcf, 0x57, 0x32, 0x05, 0xa0, 0x3f, 0xc9, 0xf3, 0x9b, 0xb0, + 0xb6, 0x35, 0x0e, 0x5c, 0x5f, 0xb8, 0x09, 0xf4, 0x1f, 0x65, 0xa1, 0x49, 0x39, 0xe7, 0xc7, 0x68, + 0x19, 0x6a, 0x9d, 0xf1, 0x89, 0x29, 0xe5, 0xfc, 0xf5, 0x22, 0xbf, 0x05, 0xeb, 0x06, 0x2b, 0xcd, + 0xdb, 0xb2, 0xbf, 0x51, 0xe4, 0x37, 0x60, 0x75, 0x53, 0x4b, 0xa4, 0x99, 0x28, 0xfb, 0x9b, 0x45, + 0x9c, 0x02, 0x75, 0x80, 0xfe, 0x2e, 0xf1, 0x49, 0x8a, 0xda, 0xec, 0xf7, 0x8a, 0x7c, 0x0d, 0xa0, + 0xd3, 0x4d, 0x5e, 0xf4, 0x77, 0x8a, 0xbc, 0x0e, 0xe5, 0x4e, 0x97, 0xb8, 0xfd, 0x61, 0x91, 0xbf, + 0x05, 0x2c, 0x7d, 0x6a, 0x32, 0xd5, 0x7f, 0x57, 0x4f, 0x26, 0x49, 0x3d, 0xff, 0x51, 0x11, 0xd7, + 0x15, 0xab, 0x04, 0xf6, 0xf7, 0x8a, 0x9c, 0x41, 0x3d, 0x13, 0x0c, 0xb1, 0xbf, 0x5f, 0xe4, 0x1c, + 0x56, 0x0e, 0x31, 0x20, 0x0a, 0xfa, 0x66, 0x05, 0xbf, 0x4f, 0x6f, 0xde, 0x4b, 0xea, 0xf2, 0xec, + 0x27, 0xc5, 0x07, 0x7f, 0x9a, 0x83, 0xd5, 0xc9, 0xe4, 0x0e, 0x9a, 0x34, 0x5f, 0x06, 0x7d, 0xa5, + 0x3f, 0xbf, 0x5e, 0x81, 0x5a, 0x34, 0x90, 0xa1, 0xa2, 0x21, 0xb5, 0x1b, 0x05, 0xd4, 0x33, 0xaa, + 0xab, 0x72, 0x3a, 0x80, 0xd0, 0xd6, 0x54, 0x39, 0x7d, 0x56, 0x4f, 0x72, 0xe5, 0xc5, 0x24, 0x9f, + 0x4f, 0xbd, 0xab, 0x71, 0x6f, 0x20, 0x2b, 0x23, 0xea, 0x38, 0xf4, 0x75, 0x5e, 0x5f, 0x0c, 0x1d, + 0xcf, 0xd7, 0xdf, 0x59, 0x8e, 0x06, 0x32, 0x30, 0x89, 0x7d, 0x41, 0x9f, 0x5c, 0x42, 0x26, 0x95, + 0xe6, 0xe2, 0x3c, 0x92, 0x38, 0x94, 0x89, 0x07, 0x7f, 0x94, 0x83, 0xe5, 0xb8, 0x63, 0xd3, 0xeb, + 0x7b, 0x81, 0xae, 0x0c, 0xc4, 0x1f, 0xb5, 0xf7, 0x7c, 0x6f, 0x14, 0x7f, 0x24, 0xba, 0x06, 0x75, + 0x37, 0x74, 0xfa, 0x9b, 0x81, 0xbb, 0x13, 0xca, 0x91, 0x9e, 0xb6, 0xf6, 0x66, 0x75, 0x45, 0xe2, + 0x42, 0x9c, 0x20, 0xfa, 0x48, 0x84, 0xac, 0x48, 0x69, 0xba, 0x81, 0x13, 0x7a, 0x41, 0x1f, 0xad, + 0x7a, 0x10, 0xe9, 0xca, 0x44, 0x1d, 0x2a, 0xe3, 0x48, 0xf4, 0x9c, 0x48, 0xb0, 0x32, 0x0e, 0x4e, + 0xc6, 0x9e, 0xaf, 0xbc, 0x40, 0x7f, 0x9b, 0x99, 0x94, 0x1e, 0xaa, 0x0f, 0xfe, 0x6d, 0x0e, 0xea, + 0x74, 0x46, 0xa9, 0xe3, 0x93, 0xd6, 0x92, 0xeb, 0x50, 0x39, 0x48, 0xbe, 0xcd, 0x2b, 0x43, 0xbe, + 0x7d, 0xa6, 0x1d, 0x1f, 0x73, 0x46, 0xba, 0x69, 0x4b, 0x7f, 0xa6, 0x57, 0xe4, 0xbf, 0x06, 0x6f, + 0xd9, 0x62, 0x28, 0x95, 0x78, 0xe1, 0x78, 0x2a, 0x5b, 0x95, 0x2f, 0xa1, 0x9f, 0xa0, 0x1f, 0xc5, + 0x65, 0xf8, 0x32, 0x67, 0xb0, 0x4c, 0xaf, 0x8d, 0x21, 0x15, 0x5c, 0x34, 0x41, 0x4c, 0x81, 0xbf, + 0x9a, 0xa0, 0xa0, 0x83, 0x88, 0x6f, 0xa3, 0x2e, 0x3f, 0x82, 0x20, 0xb3, 0x73, 0x04, 0xc1, 0x83, + 0x23, 0xb8, 0x35, 0x3f, 0xa0, 0xd6, 0xfd, 0x7f, 0xf4, 0x0f, 0x21, 0xa8, 0x4e, 0xfb, 0x22, 0xf4, + 0x74, 0x2f, 0x58, 0x0d, 0x4a, 0xed, 0x8b, 0x80, 0xa4, 0x61, 0x1d, 0x56, 0x8e, 0x64, 0x86, 0x86, + 0x15, 0x1e, 0xf4, 0x60, 0x3d, 0xc3, 0x2f, 0xdd, 0x94, 0x78, 0x12, 0x4b, 0x99, 0x1e, 0x84, 0x9c, + 0x76, 0x02, 0xe9, 0xff, 0x43, 0xe9, 0xde, 0xe8, 0x1d, 0xd1, 0xf3, 0xbd, 0x00, 0x5d, 0x42, 0x1c, + 0x25, 0xd3, 0x2c, 0xea, 0x8f, 0x75, 0x82, 0x9e, 0xf0, 0x85, 0xcb, 0x4a, 0x0f, 0x3e, 0x81, 0x35, + 0xb3, 0x54, 0xf4, 0xbe, 0xe3, 0x1a, 0xfe, 0x71, 0xe8, 0x9d, 0xeb, 0xfe, 0x6b, 0x74, 0x04, 0x45, + 0x18, 0xc9, 0x80, 0x7a, 0xcf, 0x01, 0xca, 0x9d, 0x81, 0x13, 0xe2, 0x3b, 0x1e, 0x7c, 0x0d, 0x6a, + 0x54, 0xd3, 0x7f, 0xea, 0x05, 0x2e, 0xae, 0x64, 0xcb, 0x94, 0xb1, 0xd0, 0xe5, 0x94, 0xe7, 0xb4, + 0xbe, 0xaa, 0xfe, 0x2c, 0x9d, 0xe5, 0x1f, 0x7c, 0x0e, 0x5c, 0x1b, 0x2c, 0x57, 0x5c, 0x7a, 0x41, + 0x3f, 0x69, 0x4a, 0x05, 0xea, 0x30, 0x77, 0xc5, 0x25, 0x79, 0xb7, 0x75, 0xa8, 0xc4, 0x83, 0xb8, + 0xcf, 0x7d, 0x4f, 0x8e, 0x03, 0x97, 0xe5, 0xb7, 0x1e, 0xfc, 0xfb, 0x5f, 0xdc, 0xcd, 0xfd, 0xfc, + 0x17, 0x77, 0x73, 0xff, 0xfd, 0x17, 0x77, 0x73, 0x7f, 0xf8, 0xcb, 0xbb, 0x4b, 0x3f, 0xff, 0xe5, + 0xdd, 0xa5, 0xff, 0xfc, 0xcb, 0xbb, 0x4b, 0x5f, 0xb0, 0xe9, 0xff, 0x6f, 0x76, 0x52, 0xa6, 0x9c, + 0xd0, 0x87, 0xff, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x29, 0x79, 0x9e, 0xa9, 0xfa, 0x4c, 0x00, 0x00, } func (m *SmartBlockSnapshotBase) Marshal() (dAtA []byte, err error) { @@ -11513,6 +11188,16 @@ func (m *ObjectType) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.RestrictObjectCreation { + i-- + if m.RestrictObjectCreation { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x70 + } if m.Revision != 0 { i = encodeVarintModels(dAtA, i, uint64(m.Revision)) i-- @@ -12496,13 +12181,6 @@ func (m *Notification) MarshalToSizedBuffer(dAtA []byte) (int, error) { } } } - if len(m.AclHeadId) > 0 { - i -= len(m.AclHeadId) - copy(dAtA[i:], m.AclHeadId) - i = encodeVarintModels(dAtA, i, uint64(len(m.AclHeadId))) - i-- - dAtA[i] = 0x72 - } if len(m.Space) > 0 { i -= len(m.Space) copy(dAtA[i:], m.Space) @@ -12645,92 +12323,6 @@ func (m *NotificationPayloadOfTest) MarshalToSizedBuffer(dAtA []byte) (int, erro } return len(dAtA) - i, nil } -func (m *NotificationPayloadOfRequestResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *NotificationPayloadOfRequestResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.RequestResponse != nil { - { - size, err := m.RequestResponse.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintModels(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x62 - } - return len(dAtA) - i, nil -} -func (m *NotificationPayloadOfParticipantRequestApproved) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *NotificationPayloadOfParticipantRequestApproved) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.ParticipantRequestApproved != nil { - { - size, err := m.ParticipantRequestApproved.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintModels(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x6a - } - return len(dAtA) - i, nil -} -func (m *NotificationPayloadOfLeaveRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *NotificationPayloadOfLeaveRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.LeaveRequest != nil { - { - size, err := m.LeaveRequest.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintModels(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x7a - } - return len(dAtA) - i, nil -} -func (m *NotificationPayloadOfParticipantRemove) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *NotificationPayloadOfParticipantRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.ParticipantRemove != nil { - { - size, err := m.ParticipantRemove.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintModels(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x82 - } - return len(dAtA) - i, nil -} func (m *NotificationImport) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -12941,195 +12533,6 @@ func (m *NotificationTest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *NotificationRequestResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *NotificationRequestResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *NotificationRequestResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Permission != 0 { - i = encodeVarintModels(dAtA, i, uint64(m.Permission)) - i-- - dAtA[i] = 0x28 - } - if m.IsApproved { - i-- - if m.IsApproved { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x20 - } - if len(m.IdentityIcon) > 0 { - i -= len(m.IdentityIcon) - copy(dAtA[i:], m.IdentityIcon) - i = encodeVarintModels(dAtA, i, uint64(len(m.IdentityIcon))) - i-- - dAtA[i] = 0x1a - } - if len(m.IdentityName) > 0 { - i -= len(m.IdentityName) - copy(dAtA[i:], m.IdentityName) - i = encodeVarintModels(dAtA, i, uint64(len(m.IdentityName))) - i-- - dAtA[i] = 0x12 - } - if len(m.Identity) > 0 { - i -= len(m.Identity) - copy(dAtA[i:], m.Identity) - i = encodeVarintModels(dAtA, i, uint64(len(m.Identity))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *NotificationParticipantRequestApproved) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *NotificationParticipantRequestApproved) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *NotificationParticipantRequestApproved) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Permission != 0 { - i = encodeVarintModels(dAtA, i, uint64(m.Permission)) - i-- - dAtA[i] = 0x10 - } - if len(m.SpaceID) > 0 { - i -= len(m.SpaceID) - copy(dAtA[i:], m.SpaceID) - i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceID))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *NotificationLeaveRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *NotificationLeaveRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *NotificationLeaveRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.IdentityIcon) > 0 { - i -= len(m.IdentityIcon) - copy(dAtA[i:], m.IdentityIcon) - i = encodeVarintModels(dAtA, i, uint64(len(m.IdentityIcon))) - i-- - dAtA[i] = 0x22 - } - if len(m.IdentityName) > 0 { - i -= len(m.IdentityName) - copy(dAtA[i:], m.IdentityName) - i = encodeVarintModels(dAtA, i, uint64(len(m.IdentityName))) - i-- - dAtA[i] = 0x1a - } - if len(m.Identity) > 0 { - i -= len(m.Identity) - copy(dAtA[i:], m.Identity) - i = encodeVarintModels(dAtA, i, uint64(len(m.Identity))) - i-- - dAtA[i] = 0x12 - } - if len(m.SpaceId) > 0 { - i -= len(m.SpaceId) - copy(dAtA[i:], m.SpaceId) - i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceId))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *NotificationParticipantRemove) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *NotificationParticipantRemove) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *NotificationParticipantRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.IdentityIcon) > 0 { - i -= len(m.IdentityIcon) - copy(dAtA[i:], m.IdentityIcon) - i = encodeVarintModels(dAtA, i, uint64(len(m.IdentityIcon))) - i-- - dAtA[i] = 0x1a - } - if len(m.IdentityName) > 0 { - i -= len(m.IdentityName) - copy(dAtA[i:], m.IdentityName) - i = encodeVarintModels(dAtA, i, uint64(len(m.IdentityName))) - i-- - dAtA[i] = 0x12 - } - if len(m.Identity) > 0 { - i -= len(m.Identity) - copy(dAtA[i:], m.Identity) - i = encodeVarintModels(dAtA, i, uint64(len(m.Identity))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - func (m *Export) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -15003,6 +14406,9 @@ func (m *ObjectType) Size() (n int) { if m.Revision != 0 { n += 1 + sovModels(uint64(m.Revision)) } + if m.RestrictObjectCreation { + n += 2 + } return n } @@ -15393,10 +14799,6 @@ func (m *Notification) Size() (n int) { if l > 0 { n += 1 + l + sovModels(uint64(l)) } - l = len(m.AclHeadId) - if l > 0 { - n += 1 + l + sovModels(uint64(l)) - } return n } @@ -15460,54 +14862,6 @@ func (m *NotificationPayloadOfTest) Size() (n int) { } return n } -func (m *NotificationPayloadOfRequestResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.RequestResponse != nil { - l = m.RequestResponse.Size() - n += 1 + l + sovModels(uint64(l)) - } - return n -} -func (m *NotificationPayloadOfParticipantRequestApproved) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ParticipantRequestApproved != nil { - l = m.ParticipantRequestApproved.Size() - n += 1 + l + sovModels(uint64(l)) - } - return n -} -func (m *NotificationPayloadOfLeaveRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.LeaveRequest != nil { - l = m.LeaveRequest.Size() - n += 1 + l + sovModels(uint64(l)) - } - return n -} -func (m *NotificationPayloadOfParticipantRemove) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ParticipantRemove != nil { - l = m.ParticipantRemove.Size() - n += 2 + l + sovModels(uint64(l)) - } - return n -} func (m *NotificationImport) Size() (n int) { if m == nil { return 0 @@ -15608,95 +14962,6 @@ func (m *NotificationTest) Size() (n int) { return n } -func (m *NotificationRequestResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Identity) - if l > 0 { - n += 1 + l + sovModels(uint64(l)) - } - l = len(m.IdentityName) - if l > 0 { - n += 1 + l + sovModels(uint64(l)) - } - l = len(m.IdentityIcon) - if l > 0 { - n += 1 + l + sovModels(uint64(l)) - } - if m.IsApproved { - n += 2 - } - if m.Permission != 0 { - n += 1 + sovModels(uint64(m.Permission)) - } - return n -} - -func (m *NotificationParticipantRequestApproved) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.SpaceID) - if l > 0 { - n += 1 + l + sovModels(uint64(l)) - } - if m.Permission != 0 { - n += 1 + sovModels(uint64(m.Permission)) - } - return n -} - -func (m *NotificationLeaveRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.SpaceId) - if l > 0 { - n += 1 + l + sovModels(uint64(l)) - } - l = len(m.Identity) - if l > 0 { - n += 1 + l + sovModels(uint64(l)) - } - l = len(m.IdentityName) - if l > 0 { - n += 1 + l + sovModels(uint64(l)) - } - l = len(m.IdentityIcon) - if l > 0 { - n += 1 + l + sovModels(uint64(l)) - } - return n -} - -func (m *NotificationParticipantRemove) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Identity) - if l > 0 { - n += 1 + l + sovModels(uint64(l)) - } - l = len(m.IdentityName) - if l > 0 { - n += 1 + l + sovModels(uint64(l)) - } - l = len(m.IdentityIcon) - if l > 0 { - n += 1 + l + sovModels(uint64(l)) - } - return n -} - func (m *Export) Size() (n int) { if m == nil { return 0 @@ -24386,6 +23651,26 @@ func (m *ObjectType) Unmarshal(dAtA []byte) error { break } } + case 14: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RestrictObjectCreation", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowModels + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.RestrictObjectCreation = bool(v != 0) default: iNdEx = preIndex skippy, err := skipModels(dAtA[iNdEx:]) @@ -26976,178 +26261,6 @@ func (m *Notification) Unmarshal(dAtA []byte) error { } m.Payload = &NotificationPayloadOfTest{v} iNdEx = postIndex - case 12: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RequestResponse", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthModels - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthModels - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &NotificationRequestResponse{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Payload = &NotificationPayloadOfRequestResponse{v} - iNdEx = postIndex - case 13: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ParticipantRequestApproved", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthModels - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthModels - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &NotificationParticipantRequestApproved{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Payload = &NotificationPayloadOfParticipantRequestApproved{v} - iNdEx = postIndex - case 14: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AclHeadId", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthModels - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthModels - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.AclHeadId = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 15: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field LeaveRequest", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthModels - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthModels - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &NotificationLeaveRequest{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Payload = &NotificationPayloadOfLeaveRequest{v} - iNdEx = postIndex - case 16: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ParticipantRemove", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthModels - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthModels - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &NotificationParticipantRemove{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Payload = &NotificationPayloadOfParticipantRemove{v} - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipModels(dAtA[iNdEx:]) @@ -27834,616 +26947,6 @@ func (m *NotificationTest) Unmarshal(dAtA []byte) error { } return nil } -func (m *NotificationRequestResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: RequestResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: RequestResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthModels - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthModels - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Identity = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field IdentityName", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthModels - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthModels - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.IdentityName = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field IdentityIcon", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthModels - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthModels - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.IdentityIcon = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IsApproved", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.IsApproved = bool(v != 0) - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Permission", wireType) - } - m.Permission = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Permission |= ParticipantPermissions(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipModels(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthModels - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *NotificationParticipantRequestApproved) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: ParticipantRequestApproved: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ParticipantRequestApproved: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SpaceID", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthModels - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthModels - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.SpaceID = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Permission", wireType) - } - m.Permission = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Permission |= ParticipantPermissions(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipModels(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthModels - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *NotificationLeaveRequest) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: LeaveRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: LeaveRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SpaceId", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthModels - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthModels - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.SpaceId = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthModels - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthModels - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Identity = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field IdentityName", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthModels - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthModels - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.IdentityName = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field IdentityIcon", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthModels - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthModels - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.IdentityIcon = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipModels(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthModels - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *NotificationParticipantRemove) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: ParticipantRemove: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ParticipantRemove: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthModels - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthModels - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Identity = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field IdentityName", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthModels - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthModels - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.IdentityName = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field IdentityIcon", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowModels - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthModels - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthModels - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.IdentityIcon = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipModels(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthModels - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} func (m *Export) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/pkg/lib/pb/model/protos/models.proto b/pkg/lib/pb/model/protos/models.proto index 49c9e38b7..9527622c2 100644 --- a/pkg/lib/pb/model/protos/models.proto +++ b/pkg/lib/pb/model/protos/models.proto @@ -665,6 +665,8 @@ message Restrictions { Template = 7; // restricts duplicate object Duplicate = 8; + // can be set only for types. Restricts creating objects of this type + CreateObjectOfThisType = 9; } @@ -707,6 +709,7 @@ message ObjectType { bool installedByDefault = 11; string key = 12; // name of objectType (can be localized for bundled types) int64 revision = 13; // revision of system objectType. Used to check if we should change type content or not + bool restrictObjectCreation = 14; // restricts creating objects of this type for users enum Layout { basic = 0; diff --git a/space/clientspace/space.go b/space/clientspace/space.go index 0c7766cd9..c49b09cf9 100644 --- a/space/clientspace/space.go +++ b/space/clientspace/space.go @@ -13,9 +13,12 @@ import ( "github.com/anyproto/any-sync/net/peer" "github.com/anyproto/any-sync/util/crypto" "github.com/gogo/protobuf/types" + "go.uber.org/zap" + "github.com/anyproto/anytype-heart/core/block/editor/profilemigration" "github.com/anyproto/anytype-heart/core/block/editor/smartblock" "github.com/anyproto/anytype-heart/core/block/object/objectcache" + "github.com/anyproto/anytype-heart/core/block/object/payloadcreator" "github.com/anyproto/anytype-heart/core/domain" "github.com/anyproto/anytype-heart/pkg/lib/bundle" coresb "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock" @@ -142,6 +145,10 @@ func (s *space) mandatoryObjectsLoad(ctx context.Context, disableRemoteLoad bool if s.loadMandatoryObjectsErr != nil { return } + err := s.migrationProfileObject(ctx) + if err != nil { + log.Error("failed to migrate profile object", zap.Error(err)) + } if !disableRemoteLoad { s.common.TreeSyncer().StartSync() } @@ -248,6 +255,63 @@ func (s *space) InstallBundledObjects(ctx context.Context) error { return nil } +func (s *space) migrationProfileObject(ctx context.Context) error { + if !s.IsPersonal() { + return nil + } + if s.derivedIDs.Profile == "" { + return nil + } + + uniqueKey, err := domain.NewUniqueKey(coresb.SmartBlockTypePage, profilemigration.InternalKeyOldProfileData) + if err != nil { + return err + } + // lets do the cheap check if we already has this extracted object + extractedProfileId, err := s.DeriveObjectID(ctx, uniqueKey) + if err != nil { + return err + } + + extractedProfileExists, _ := s.Storage().HasTree(extractedProfileId) + if extractedProfileExists { + return nil + } + + return s.Do(s.derivedIDs.Profile, func(sb smartblock.SmartBlock) error { + st := sb.NewState() + extractedState, err := profilemigration.ExtractCustomState(st) + if err != nil { + if err == profilemigration.ErrNoCustomStateFound { + log.Error("no extra state found") + return nil + } + return err + } + + payload, err := s.DeriveTreePayload(ctx, payloadcreator.PayloadDerivationParams{UseAccountSignature: true, Key: uniqueKey}) + if err != nil { + return err + } + newSb, err := s.CreateTreeObjectWithPayload(ctx, payload, func(id string) *smartblock.InitContext { + extractedState.SetRootId(id) + return &smartblock.InitContext{ + IsNewObject: true, + ObjectTypeKeys: []domain.TypeKey{bundle.TypeKeyDashboard}, + State: extractedState, + SpaceID: s.Id(), + } + }) + if err != nil { + return err + } + log.Warn("old profile custom state migrated") + newSb.Close() + + return sb.Apply(st) + }) +} + func (s *space) IsReadOnly() bool { return !s.CommonSpace().Acl().AclState().Permissions(s.myIdentity).CanWrite() }