From 5b45539ff5c7c375d3b5a7b97460f0bf2c0ba684 Mon Sep 17 00:00:00 2001 From: Michael Diamant Date: Fri, 18 Nov 2022 13:48:46 -0500 Subject: [PATCH] Catchpoints: Enrich catchpoint generation and status with KV metadata (#4808) --- catchup/catchpointService.go | 19 +- cmd/catchpointdump/file.go | 2 + cmd/goal/messages.go | 2 +- cmd/goal/node.go | 3 +- .../mocks/mockCatchpointCatchupAccessor.go | 2 +- daemon/algod/api/algod.oas2.json | 12 + daemon/algod/api/algod.oas3.yml | 36 ++ .../api/server/v2/generated/model/types.go | 9 + .../nonparticipating/private/routes.go | 308 ++++++++-------- .../nonparticipating/public/routes.go | 343 +++++++++--------- .../generated/participating/private/routes.go | 311 ++++++++-------- .../generated/participating/public/routes.go | 249 ++++++------- daemon/algod/api/server/v2/handlers.go | 3 + .../algod/api/server/v2/test/handlers_test.go | 3 + daemon/algod/api/server/v2/test/helpers.go | 3 + ledger/accountdb.go | 40 +- ledger/catchpointfileheader.go | 1 + ledger/catchpointtracker.go | 92 +++-- ledger/catchpointtracker_test.go | 140 ++++++- ledger/catchpointwriter.go | 7 + ledger/catchupaccessor.go | 46 ++- ledger/catchupaccessor_test.go | 11 +- ledger/hashkind_string.go | 26 ++ ledger/msgp_gen.go | 120 +++++- logging/telemetryspec/event.go | 2 + node/node.go | 6 + 26 files changed, 1106 insertions(+), 690 deletions(-) create mode 100644 ledger/hashkind_string.go diff --git a/catchup/catchpointService.go b/catchup/catchpointService.go index c55b3ea8d1..41c75172e8 100644 --- a/catchup/catchpointService.go +++ b/catchup/catchpointService.go @@ -53,11 +53,15 @@ type CatchpointCatchupStats struct { TotalAccounts uint64 ProcessedAccounts uint64 VerifiedAccounts uint64 + TotalKVs uint64 + ProcessedKVs uint64 + VerifiedKVs uint64 TotalBlocks uint64 AcquiredBlocks uint64 VerifiedBlocks uint64 ProcessedBytes uint64 TotalAccountHashes uint64 + TotalKVHashes uint64 StartTime time.Time } @@ -303,7 +307,7 @@ func (cs *CatchpointCatchupService) processStageLedgerDownload() (err error) { if err == nil { cs.log.Infof("ledger downloaded in %d seconds", time.Since(start)/time.Second) start = time.Now() - err = cs.ledgerAccessor.BuildMerkleTrie(cs.ctx, cs.updateVerifiedAccounts) + err = cs.ledgerAccessor.BuildMerkleTrie(cs.ctx, cs.updateVerifiedCounts) if err == nil { cs.log.Infof("built merkle trie in %d seconds", time.Since(start)/time.Second) break @@ -335,12 +339,17 @@ func (cs *CatchpointCatchupService) processStageLedgerDownload() (err error) { return nil } -// updateVerifiedAccounts update the user's statistics for the given verified accounts -func (cs *CatchpointCatchupService) updateVerifiedAccounts(addedTrieHashes uint64) { +// updateVerifiedCounts update the user's statistics for the given verified hashes +func (cs *CatchpointCatchupService) updateVerifiedCounts(accountCount, kvCount uint64) { cs.statsMu.Lock() defer cs.statsMu.Unlock() + if cs.stats.TotalAccountHashes > 0 { - cs.stats.VerifiedAccounts = cs.stats.TotalAccounts * addedTrieHashes / cs.stats.TotalAccountHashes + cs.stats.VerifiedAccounts = cs.stats.TotalAccounts * accountCount / cs.stats.TotalAccountHashes + } + + if cs.stats.TotalKVs > 0 { + cs.stats.VerifiedKVs = kvCount } } @@ -756,6 +765,8 @@ func (cs *CatchpointCatchupService) updateLedgerFetcherProgress(fetcherStats *le defer cs.statsMu.Unlock() cs.stats.TotalAccounts = fetcherStats.TotalAccounts cs.stats.ProcessedAccounts = fetcherStats.ProcessedAccounts + cs.stats.TotalKVs = fetcherStats.TotalKVs + cs.stats.ProcessedKVs = fetcherStats.ProcessedKVs cs.stats.ProcessedBytes = fetcherStats.ProcessedBytes cs.stats.TotalAccountHashes = fetcherStats.TotalAccountHashes } diff --git a/cmd/catchpointdump/file.go b/cmd/catchpointdump/file.go index c2f337046d..1735726411 100644 --- a/cmd/catchpointdump/file.go +++ b/cmd/catchpointdump/file.go @@ -266,6 +266,7 @@ func printAccountsDatabase(databaseName string, fileHeader ledger.CatchpointFile "Block Header Digest: %s", "Catchpoint: %s", "Total Accounts: %d", + "Total KVs: %d", "Total Chunks: %d", } var headerValues = []interface{}{ @@ -275,6 +276,7 @@ func printAccountsDatabase(databaseName string, fileHeader ledger.CatchpointFile fileHeader.BlockHeaderDigest.String(), fileHeader.Catchpoint, fileHeader.TotalAccounts, + fileHeader.TotalKVs, fileHeader.TotalChunks, } // safety check diff --git a/cmd/goal/messages.go b/cmd/goal/messages.go index 98f8e215d0..3fd1ce36cd 100644 --- a/cmd/goal/messages.go +++ b/cmd/goal/messages.go @@ -64,7 +64,7 @@ const ( infoNodeStatus = "Last committed block: %d\nTime since last block: %s\nSync Time: %s\nLast consensus protocol: %s\nNext consensus protocol: %s\nRound for next consensus protocol: %d\nNext consensus protocol supported: %v" catchupStoppedOnUnsupported = "Last supported block (%d) is committed. The next block consensus protocol is not supported. Catchup service is stopped." infoNodeCatchpointCatchupStatus = "Last committed block: %d\nSync Time: %s\nCatchpoint: %s" - infoNodeCatchpointCatchupAccounts = "Catchpoint total accounts: %d\nCatchpoint accounts processed: %d\nCatchpoint accounts verified: %d" + infoNodeCatchpointCatchupAccounts = "Catchpoint total accounts: %d\nCatchpoint accounts processed: %d\nCatchpoint accounts verified: %d\nCatchpoint total KVs: %d\nCatchpoint KVs processed: %d\nCatchpoint KVs verified: %d" infoNodeCatchpointCatchupBlocks = "Catchpoint total blocks: %d\nCatchpoint downloaded blocks: %d" nodeLastCatchpoint = "Last Catchpoint: %s" errorNodeCreationIPFailure = "Parsing passed IP %v failed: need a valid IPv4 or IPv6 address with a specified port number" diff --git a/cmd/goal/node.go b/cmd/goal/node.go index 0fdcb27903..a17551c475 100644 --- a/cmd/goal/node.go +++ b/cmd/goal/node.go @@ -467,7 +467,8 @@ func makeStatusString(stat model.NodeStatusResponse) string { if stat.CatchpointTotalAccounts != nil && (*stat.CatchpointTotalAccounts > 0) && stat.CatchpointProcessedAccounts != nil { statusString = statusString + "\n" + fmt.Sprintf(infoNodeCatchpointCatchupAccounts, *stat.CatchpointTotalAccounts, - *stat.CatchpointProcessedAccounts, *stat.CatchpointVerifiedAccounts) + *stat.CatchpointProcessedAccounts, *stat.CatchpointVerifiedAccounts, + *stat.CatchpointTotalKvs, *stat.CatchpointProcessedKvs, *stat.CatchpointVerifiedKvs) } if stat.CatchpointAcquiredBlocks != nil && stat.CatchpointTotalBlocks != nil && (*stat.CatchpointAcquiredBlocks+*stat.CatchpointTotalBlocks > 0) { statusString = statusString + "\n" + fmt.Sprintf(infoNodeCatchpointCatchupBlocks, *stat.CatchpointTotalBlocks, diff --git a/components/mocks/mockCatchpointCatchupAccessor.go b/components/mocks/mockCatchpointCatchupAccessor.go index a9ecb02d4c..00758de72d 100644 --- a/components/mocks/mockCatchpointCatchupAccessor.go +++ b/components/mocks/mockCatchpointCatchupAccessor.go @@ -58,7 +58,7 @@ func (m *MockCatchpointCatchupAccessor) ProcessStagingBalances(ctx context.Conte } // BuildMerkleTrie inserts the account hashes into the merkle trie -func (m *MockCatchpointCatchupAccessor) BuildMerkleTrie(ctx context.Context, progressUpdates func(uint64)) (err error) { +func (m *MockCatchpointCatchupAccessor) BuildMerkleTrie(ctx context.Context, progressUpdates func(uint64, uint64)) (err error) { return nil } diff --git a/daemon/algod/api/algod.oas2.json b/daemon/algod/api/algod.oas2.json index 7254cd6485..3961ad0b84 100644 --- a/daemon/algod/api/algod.oas2.json +++ b/daemon/algod/api/algod.oas2.json @@ -3523,6 +3523,18 @@ "description": "The number of accounts from the current catchpoint that have been verified so far as part of the catchup", "type": "integer" }, + "catchpoint-total-kvs": { + "description": "The total number of key-values (KVs) included in the current catchpoint", + "type": "integer" + }, + "catchpoint-processed-kvs": { + "description": "The number of key-values (KVs) from the current catchpoint that have been processed so far as part of the catchup", + "type": "integer" + }, + "catchpoint-verified-kvs": { + "description": "The number of key-values (KVs) from the current catchpoint that have been verified so far as part of the catchup", + "type": "integer" + }, "catchpoint-total-blocks": { "description": "The total number of blocks that are required to complete the current catchpoint catchup", "type": "integer" diff --git a/daemon/algod/api/algod.oas3.yml b/daemon/algod/api/algod.oas3.yml index bf22db307f..0dd7a6c2e8 100644 --- a/daemon/algod/api/algod.oas3.yml +++ b/daemon/algod/api/algod.oas3.yml @@ -525,6 +525,10 @@ "description": "The number of accounts from the current catchpoint that have been processed so far as part of the catchup", "type": "integer" }, + "catchpoint-processed-kvs": { + "description": "The number of key-values (KVs) from the current catchpoint that have been processed so far as part of the catchup", + "type": "integer" + }, "catchpoint-total-accounts": { "description": "The total number of accounts included in the current catchpoint", "type": "integer" @@ -533,10 +537,18 @@ "description": "The total number of blocks that are required to complete the current catchpoint catchup", "type": "integer" }, + "catchpoint-total-kvs": { + "description": "The total number of key-values (KVs) included in the current catchpoint", + "type": "integer" + }, "catchpoint-verified-accounts": { "description": "The number of accounts from the current catchpoint that have been verified so far as part of the catchup", "type": "integer" }, + "catchpoint-verified-kvs": { + "description": "The number of key-values (KVs) from the current catchpoint that have been verified so far as part of the catchup", + "type": "integer" + }, "catchup-time": { "description": "CatchupTime in nanoseconds", "type": "integer" @@ -4101,6 +4113,10 @@ "description": "The number of accounts from the current catchpoint that have been processed so far as part of the catchup", "type": "integer" }, + "catchpoint-processed-kvs": { + "description": "The number of key-values (KVs) from the current catchpoint that have been processed so far as part of the catchup", + "type": "integer" + }, "catchpoint-total-accounts": { "description": "The total number of accounts included in the current catchpoint", "type": "integer" @@ -4109,10 +4125,18 @@ "description": "The total number of blocks that are required to complete the current catchpoint catchup", "type": "integer" }, + "catchpoint-total-kvs": { + "description": "The total number of key-values (KVs) included in the current catchpoint", + "type": "integer" + }, "catchpoint-verified-accounts": { "description": "The number of accounts from the current catchpoint that have been verified so far as part of the catchup", "type": "integer" }, + "catchpoint-verified-kvs": { + "description": "The number of key-values (KVs) from the current catchpoint that have been verified so far as part of the catchup", + "type": "integer" + }, "catchup-time": { "description": "CatchupTime in nanoseconds", "type": "integer" @@ -4232,6 +4256,10 @@ "description": "The number of accounts from the current catchpoint that have been processed so far as part of the catchup", "type": "integer" }, + "catchpoint-processed-kvs": { + "description": "The number of key-values (KVs) from the current catchpoint that have been processed so far as part of the catchup", + "type": "integer" + }, "catchpoint-total-accounts": { "description": "The total number of accounts included in the current catchpoint", "type": "integer" @@ -4240,10 +4268,18 @@ "description": "The total number of blocks that are required to complete the current catchpoint catchup", "type": "integer" }, + "catchpoint-total-kvs": { + "description": "The total number of key-values (KVs) included in the current catchpoint", + "type": "integer" + }, "catchpoint-verified-accounts": { "description": "The number of accounts from the current catchpoint that have been verified so far as part of the catchup", "type": "integer" }, + "catchpoint-verified-kvs": { + "description": "The number of key-values (KVs) from the current catchpoint that have been verified so far as part of the catchup", + "type": "integer" + }, "catchup-time": { "description": "CatchupTime in nanoseconds", "type": "integer" diff --git a/daemon/algod/api/server/v2/generated/model/types.go b/daemon/algod/api/server/v2/generated/model/types.go index f901ac6897..215d06e906 100644 --- a/daemon/algod/api/server/v2/generated/model/types.go +++ b/daemon/algod/api/server/v2/generated/model/types.go @@ -834,15 +834,24 @@ type NodeStatusResponse struct { // CatchpointProcessedAccounts The number of accounts from the current catchpoint that have been processed so far as part of the catchup CatchpointProcessedAccounts *uint64 `json:"catchpoint-processed-accounts,omitempty"` + // CatchpointProcessedKvs The number of key-values (KVs) from the current catchpoint that have been processed so far as part of the catchup + CatchpointProcessedKvs *uint64 `json:"catchpoint-processed-kvs,omitempty"` + // CatchpointTotalAccounts The total number of accounts included in the current catchpoint CatchpointTotalAccounts *uint64 `json:"catchpoint-total-accounts,omitempty"` // CatchpointTotalBlocks The total number of blocks that are required to complete the current catchpoint catchup CatchpointTotalBlocks *uint64 `json:"catchpoint-total-blocks,omitempty"` + // CatchpointTotalKvs The total number of key-values (KVs) included in the current catchpoint + CatchpointTotalKvs *uint64 `json:"catchpoint-total-kvs,omitempty"` + // CatchpointVerifiedAccounts The number of accounts from the current catchpoint that have been verified so far as part of the catchup CatchpointVerifiedAccounts *uint64 `json:"catchpoint-verified-accounts,omitempty"` + // CatchpointVerifiedKvs The number of key-values (KVs) from the current catchpoint that have been verified so far as part of the catchup + CatchpointVerifiedKvs *uint64 `json:"catchpoint-verified-kvs,omitempty"` + // CatchupTime CatchupTime in nanoseconds CatchupTime uint64 `json:"catchup-time"` diff --git a/daemon/algod/api/server/v2/generated/nonparticipating/private/routes.go b/daemon/algod/api/server/v2/generated/nonparticipating/private/routes.go index c2e99323c1..538419b26e 100644 --- a/daemon/algod/api/server/v2/generated/nonparticipating/private/routes.go +++ b/daemon/algod/api/server/v2/generated/nonparticipating/private/routes.go @@ -130,160 +130,160 @@ func RegisterHandlersWithBaseURL(router EchoRouter, si ServerInterface, baseURL // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+x9+5PbNtLgv4LSflV+nCjN+LXrqUp9N7Gd7Nw6jsszm737bF8CkS0JOyTAAOBIim/+", - "9ys0ABIkQYnzWOdL1f5kj4hHo9Fo9BtfJqkoSsGBazU5+TIpqaQFaJD4F01TUXGdsMz8lYFKJSs1E3xy", - "4r8RpSXjq8l0wsyvJdXryXTCaQFNG9N/OpHwa8UkZJMTLSuYTlS6hoKagfWuNK3rkbbJSiRuiFM7xNnr", - "yfWeDzTLJCjVh/JHnu8I42leZUC0pFzR1HxSZMP0mug1U8R1JowTwYGIJdHrVmOyZJBnauYX+WsFches", - "0k0+vKTrBsREihz6cL4SxYJx8FBBDVS9IUQLksESG62pJmYGA6tvqAVRQGW6JkshD4BqgQjhBV4Vk5OP", - "EwU8A4m7lQK7wv8uJcBvkGgqV6Ann6exxS01yESzIrK0M4d9CarKtSLYFte4YlfAiek1Iz9USpMFEMrJ", - "h+9ekadPn740Cymo1pA5IhtcVTN7uCbbfXIyyagG/7lPazRfCUl5ltTtP3z3Cuc/dwsc24oqBfHDcmq+", - "kLPXQwvwHSMkxLiGFe5Di/pNj8ihaH5ewFJIGLkntvG9bko4/++6KynV6boUjOvIvhD8SuznKA8Luu/j", - "YTUArfalwZQ0g348Sl5+/nI8PT66/tPH0+S/3J/Pn16PXP6retwDGIg2TCspgae7ZCWB4mlZU97HxwdH", - "D2otqjwja3qFm08LZPWuLzF9Leu8onll6ISlUpzmK6EIdWSUwZJWuSZ+YlLx3LApM5qjdsIUKaW4Yhlk", - "U8N9N2uWrklKlR0C25ENy3NDg5WCbIjW4qvbc5iuQ5QYuG6FD1zQf19kNOs6gAnYIjdI0lwoSLQ4cD35", - "G4fyjIQXSnNXqZtdVuRiDQQnNx/sZYu444am83xHNO5rRqgilPiraUrYkuxERTa4OTm7xP5uNQZrBTFI", - "w81p3aPm8A6hr4eMCPIWQuRAOSLPn7s+yviSrSoJimzWoNfuzpOgSsEVELH4J6TabPv/Ov/xHRGS/ABK", - "0RW8p+klAZ6KbHiP3aSxG/yfSpgNL9SqpOll/LrOWcEiIP9At6yoCsKrYgHS7Je/H7QgEnQl+RBAdsQD", - "dFbQbX/SC1nxFDe3mbYlqBlSYqrM6W5GzpakoNtvjqYOHEVonpMSeMb4iugtHxTSzNyHwUukqHg2QobR", - "ZsOCW1OVkLIlg4zUo+yBxE1zCB7GbwZPI1kF4PhBBsGpZzkADodthGbM0TVfSElXEJDMjPzdcS78qsUl", - "8JrBkcUOP5USrpioVN1pAEacer94zYWGpJSwZBEaO3foMNzDtnHstXACTiq4poxDZjgvAi00WE40CFMw", - "4X5lpn9FL6iCF8+GLvDm68jdX4ruru/d8VG7jY0SeyQj96L56g5sXGxq9R+h/IVzK7ZK7M+9jWSrC3OV", - "LFmO18w/zf55NFQKmUALEf7iUWzFqa4knHzij81fJCHnmvKMysz8Utiffqhyzc7ZyvyU25/eihVLz9lq", - "AJk1rFFtCrsV9h8zXpwd621UaXgrxGVVhgtKW1rpYkfOXg9tsh3zpoR5WquyoVZxsfWaxk176G29kQNA", - "DuKupKbhJewkGGhpusR/tkukJ7qUv5l/yjI3vXW5jKHW0LG7b9E24GwGp2WZs5QaJH5wn81XwwTAagm0", - "aTHHC/XkSwBiKUUJUjM7KC3LJBcpzROlqcaR/kPCcnIy+dO8Ma7MbXc1DyZ/a3qdYycjj1oZJ6FleYMx", - "3hu5Ru1hFoZB4ydkE5btoUTEuN1EQ0rMsOAcrijXs0YfafGD+gB/dDM1+LaijMV3R78aRDixDRegrHhr", - "Gz5QJEA9QbQSRCtKm6tcLOofHp6WZYNB/H5alhYfKBoCQ6kLtkxp9QiXT5uTFM5z9npGvg/HRjlb8Hxn", - "Lgcrapi7YeluLXeL1YYjt4ZmxAeK4HYKOTNb49FgZPj7oDjUGdYiN1LPQVoxjf/q2oZkZn4f1fmPQWIh", - "boeJC7UohzmrwOAvgebysEM5fcJxtpwZOe32vR3ZmFHiBHMrWtm7n3bcPXisUbiRtLQAui/2LmUcNTDb", - "yMJ6R246ktFFYQ7OcEBrCNWtz9rB8xCFBEmhA8O3uUgv/0rV+h7O/MKP1T9+OA1ZA81AkjVV69kkJmWE", - "x6sZbcwRMw1ReyeLYKpZvcT7Wt6BpWVU02BpDt64WGJRj/2Q6YGM6C4/4n9oTsxnc7YN67fDzsgFMjBl", - "j7PzIGRGlbcKgp3JNEATgyCF1d6J0bpvBOWrZvL4Po3aozfWYOB2yC0Cd0hs7/0YfCu2MRi+FdveERBb", - "UPdBH2YcFCM1FGoEfK8dZAL336GPSkl3fSTj2GOQbBZoRFeFp4GHN76ZpbG8ni6EvB336bAVThp7MqFm", - "1ID5TjtIwqZVmThSjNikbIPOQI0Lbz/T6A4fw1gLC+ea/guwoMyo94GF9kD3jQVRlCyHeyD9dZTpL6iC", - "p0/I+V9Pnx8/+fnJ8xeGJEspVpIWZLHToMhDp5sRpXc5POqvDLWjKtfx0V8881bI9rixcZSoZAoFLftD", - "WeumFYFsM2La9bHWRjOuugZwzOG8AMPJLdqJNdwb0F4zZSSsYnEvmzGEsKyZJSMOkgwOEtNNl9dMswuX", - "KHeyug9VFqQUMmJfwyOmRSry5AqkYiLiKnnvWhDXwou3Zfd3Cy3ZUEXM3Gj6rTgKFBHK0ls+nu/boS+2", - "vMHNXs5v1xtZnZt3zL60ke8tiYqUIBO95SSDRbVqaUJLKQpCSYYd8Y5+y1ZrHYgs76UQy3u/taOzxJaE", - "H6zAl5s+fbHvncjAqN2Vugf23gzWYM9QTogzuhCVJpRwkQHq6JWKM/4BRy96mNAxpsO7RK+tDLcAow+m", - "tDKrrUqCbp8eLTYdE5paKkoQNWrALl47NGwrO511IuYSaGb0ROBELJzx2ZnFcZEUfVbas0537UQ05xZc", - "pRQpKGX0e6u1HQTNt7NkqffgCQFHgOtZiBJkSeUtgdVC0/wAoNgmBm4tkjuLfR/qcdPv28Du5OE2UmlU", - "fEsFRv43By4HDUMoHImTK5Bouf6X7p+f5LbbV5UDcSVOtLpgBVoKOOVCQSp4pqKD5VTp5NCxNY1a8p9Z", - "QXBSYicVBx6wVr2lSlv/BeMZql2W3eA81oxlphgGePAKNCP/5G+//tip4ZNcVaq+ClVVlkJqyGJr4LDd", - "M9c72NZziWUwdn3fakEqBYdGHsJSML5Dll2JRRDVtZnPOfj6i0NjmLkHdlFUtoBoELEPkHPfKsBu6Fsf", - "AMTo6HVPJBymOpRTO/SnE6VFWZrzp5OK1/2G0HRuW5/qvzdt+8RFdcPXMwFmdu1hcpBvLGZtVMWaGqEd", - "RyYFvTR3E4rg1tHSh9kcxkQxnkKyj/LNsTw3rcIjcOCQDmg/Lm4rmK1zODr0GyW6QSI4sAtDCx5Qxd5T", - "qVnKSpQk/ga7exesuhNEDYQkA02ZUQ+CD1bIKsP+xHrOumPeTtAaJTX3we+JzZHl5EzhhdEG/hJ26Cl4", - "b0MyLoJAjnuQFCOjmtNNOUFAvaPXXMhhE9jSVOc7c83pNezIBiQQVS0KprWNsWkLklqUSThA1CKxZ0Zn", - "frPhDH4HxtgDz3GoYHn9rZhOrNiyH76LjuDSQocTmEoh8hGemB4yohCM8tSQUphdZy6ky8f9eEpqAemE", - "GLS91szzgWqhGVdA/o+oSEo5CmCVhvpGEBLZLF6/ZgZzgdVzOp9MgyHIoQArV+KXx4+7C3/82O05U2QJ", - "Gx8HaRp20fH4MWpJ74XSrcN1Dyq6OW5nEd6OphpzUTgZrstTDvsE3MhjdvJ9Z/DavmPOlFKOcM3y78wA", - "OidzO2btIY2M84fguKOsMMHQsXXjvqND+l+jwzdDx6DrTxy48ZqPQ548I1/lu3vg03YgIqGUoPBUhXqJ", - "sl/FMgyVdcdO7ZSGoq/a264/Dwg2H7xY0JMyBc8Zh6QQHHbR7BDG4Qf8GOttT/ZAZ+SxQ327YlML/g5Y", - "7XnGUOFd8Yu7HZDy+9qFfQ+b3x23Y9UJg4RRK4W8JJSkOUOdVXClZZXqT5yiVByc5Yip38v6w3rSK98k", - "rphF9CY31CdO0c1Ty8pR8+QSIlrwdwBeXVLVagVKd+SDJcAn7loxTirONM5VmP1K7IaVINHePrMtC7oj", - "S5qjWvcbSEEWlW7fmBjLqLTRuqyJyUxDxPITp5rkYDTQHxi/2OJwPmTQ0wwHvRHyssbCLHoeVsBBMZXE", - "XRLf26/oLXbLXzvPMSaW2M/WiGLGbwIedxpayRL/9+F/nnw8Tf6LJr8dJS//x/zzl2fXjx73fnxy/c03", - "/6/909Prbx7953/EdsrDHou0c5CfvXbS5NlrFBka41IP9q9mcSgYT6JEdrEGUjCOAdsd2iIPjeDjCehR", - "Y6Zyu/6J6y03hHRFc5ZRfTty6LK43lm0p6NDNa2N6CiQfq2fY97zlUhKml6iR2+yYnpdLWapKOZeip6v", - "RC1RzzMKheD4LZvTks1VCen86vjAlX4HfkUi7KrDZG8tEPT9gfHoWDRZuoBXPHnLiluiqJQzUmLwl/fL", - "iOW0joC2mY8nBMNj19Q7Fd2fT56/mEybsNb6u9HU7dfPkTPBsm0seDmDbUxSc0cNj9gDRUq6U6DjfAhh", - "j7qgrN8iHLYAI+KrNSu/Ps9Rmi3ivNKH1DiNb8vPuI11MScRzbM7Z/URy68Pt5YAGZR6HcuIaskc2KrZ", - "TYCOS6WU4gr4lLAZzLoaV7YC5Z1hOdAlZuagiVGMCRGsz4ElNE8VAdbDhYxSa2L0g2Ky4/vX04kTI9S9", - "S/Zu4Bhc3TlrW6z/Wwvy4Ps3F2TuWK96YOPo7dBB5HPEkuGC+1rONsPNbB6oTST4xD/x17BknJnvJ594", - "RjWdL6hiqZpXCuS3NKc8hdlKkBMfL/iaavqJ92S2wVTtIFKTlNUiZym5DGXrhjxt+l1/hE+fPhqO/+nT", - "557npi8Ju6mi/MVOkGyYXotKJy6/KJGwoTKLgK7q/BIc2WYH7pt1StzYlhW7/CU3fpzn0bJU3Tjz/vLL", - "MjfLD8hQuShqs2VEaSG9VGNEHQsN7u874S4GSTc+Oa1SoMgvBS0/Mq4/k+RTdXT0FEgr8PoXJzwYmtyV", - "0LJ53SoOvmvvwoVbDQm2WtKkpCtQ0eVroCXuPkreBVpX85xgt1bAtw9owaGaBXh8DG+AhePGwau4uHPb", - "yyeKx5eAn3ALsY0RNxqnxW33KwgBv/V2dcLIe7tU6XViznZ0VcqQuN+ZOn90ZYQs70lSbMXNIXCptgsg", - "6RrSS8gw6w+KUu+mre7eWelEVs86mLLZsTaAE1O40Dy4AFKVGXVCPeW7bi6NAq19AtEHuITdhWgywG6S", - "PNPO5VBDBxUpNZAuDbGGx9aN0d185/jG+PWy9CkRGBvryeKkpgvfZ/ggW5H3Hg5xjChauQZDiKAygghL", - "/AMouMVCzXh3Iv3Y8oy+srA3XySZ1vN+4po0aphzXoerwRQK+70ATLUXG0UW1MjtwmWJ23yFgItViq5g", - "QEIOLbQjswJaVl0c5NC9F73pxLJ7ofXumyjItnFi1hylFDBfDKmgMtMJWfAzWScArmBGsPiLQ9giRzGp", - "jpawTIfKlqXcVrMYAi1OwCB5I3B4MNoYCSWbNVU+gR3z/P1ZHiUD/Avzb/ZlXZ4F3vYgmb/OqfQ8t3tO", - "e9qly730CZc+yzJULUdkTBoJHwPAYtshOApAGeSwsgu3jT2hNLlAzQYZOH5cLnPGgSQxxz1VSqTMViBo", - "rhk3Bxj5+DEh1phMRo8QI+MAbHRu4cDknQjPJl/dBEjucpmoHxvdYsHfEA+7tKFZRuQRpWHhjA8E1XkO", - "QF20R31/dWKOcBjC+JQYNndFc8PmnMbXDNJL/kOxtZPq59yrj4bE2T22fHux3GhN9iq6zWpCmckDHRfo", - "9kC8ENvExl1HJd7FdmHoPRqthlHgsYNp0ywfKLIQW3TZ49WC9UvUAViG4fBgBBr+limkV+w3dJtbYPZN", - "u1+ailGhQpJx5ryaXIbEiTFTD0gwQ+TyMMicvBUAHWNHU2PMKb8HldS2eNK/zJtbbdpUBPCBtbHjP3SE", - "ors0gL++FabOdXzflViidoq257md5hmIkDGiN2yi7+7pO5UU5IBKQdISopLLmBPQ6DaAN8657xYYLzCZ", - "lPLdoyCcQcKKKQ2NOd5czN6/9LXNkxRrWAixHF6dLuXSrO+DEPU1ZZOksWNrmV99BVdCQ7JkUukEfRnR", - "JZhG3ylUqr8zTeOyUjtgwpZzYlmcN+C0l7BLMpZXcXp18/7ttZn2Xc0SVbVAfss4AZquyQLLj0XDqPZM", - "bSPt9i74rV3wW3pv6x13GkxTM7E05NKe4w9yLjqcdx87iBBgjDj6uzaI0j0MEmWf15DrWIZcIDfZw5mZ", - "hrN91tfeYcr82AcDUCwUw3eUHSm6lsBgsHcVDN1ERixhOqje1c/6GDgDtCxZtu3YQu2ogxozvZHBw5dF", - "6GABd9cNdgADgd0zFlgsQbUrYDQCvq3D1kpAnY3CzEW7TkXIEMKpmPJVRPuIMqSNouIhXF0Azf8Gu59M", - "W1zO5Ho6uZvpNIZrN+IBXL+vtzeKZ3TyW1NayxNyQ5TTspTiiuaJMzAPkaYUV440sbm3R39lVhc3Y168", - "OX373oF/PZ2kOVCZ1KLC4KqwXfmHWZUttjFwQHyVQqPzeZndipLB5tcVAkKj9GYNriJcII32Stc0Dofg", - "KDoj9TIea3TQ5Ox8I3aJe3wkUNYuksZ8Zz0kba8IvaIs93YzD+1AXBAublz9oyhXCAe4s3clcJIl98pu", - "eqc7fjoa6jrAk8K59tSsK2xZRkUE77rQjQiJ5jgk1YJi4RlrFekzJ14VaElIVM7SuI2VL5QhDm59Z6Yx", - "wcYDwqgZsWIDrlhesWAs00yNUHQ7QAZzRJHpixgN4W4hXD3tirNfKyAsA67NJ4mnsnNQsdKPs7b3r1Mj", - "O/TncgNbC30z/F1kjLDoUvfGQyD2Cxihp64H7utaZfYLrS1S5ofAJXEDh384Y+9K3OOsd/ThqNmGQa7b", - "Hrew/HWf/xnCsKUSD9fe9sqrq/40MEe0ljZTyVKK3yCu56F6HMk68GWmGEa5/AZ8Fkne6rKY2rrTlARv", - "Zh/c7iHpJrRCtYMUBqgedz5wy2G9G2+hptxutS1t24p1ixNMGJ86t+M3BONg7sX05nSzoLFiQEbIMDCd", - "Ng7gli1dC+I7e9w7sz9zlb9mJPAl122ZzccrQTYJQf3c71sKDHba0aJCIxkg1YYywdT6/3IlIsNUfEO5", - "rZBs+tmj5HorsMYv02sjJGbTqrjZP4OUFTSPSw5Z2jfxZmzFbH3gSkFQgNYNZAurWypyRXyti71BzdmS", - "HE2DEtduNzJ2xRRb5IAtjm2LBVXIyWtDVN3FLA+4Xits/mRE83XFMwmZXiuLWCVILdShelM7rxagNwCc", - "HGG745fkIbrtFLuCRwaL7n6enBy/RKOr/eModgG4QuD7uEmG7OQfjp3E6Rj9lnYMw7jdqLNobqh9vWGY", - "ce05TbbrmLOELR2vO3yWCsrpCuKRIsUBmGxf3E00pHXwwjNbelxpKXaE6fj8oKnhTwNx7Ib9WTBIKoqC", - "6cI5d5QoDD011WXtpH44W8fcFQbzcPmP6CMtvYuoo0R+XaOpvd9iq0ZP9jtaQButU0JtCnXOmugFX66Q", - "nPlCDFgprS6QZnFj5jJLRzEHgxmWpJSMa1QsKr1M/kLSNZU0NexvNgRusnjxLFIdrl2liN8M8K+OdwkK", - "5FUc9XKA7L0M4fqSh1zwpDAcJXvU5I0Ep3LQmRt32w35DvcPPVYoM6Mkg+RWtciNBpz6ToTH9wx4R1Ks", - "13Mjerzxyr46ZVYyTh60Mjv09w9vnZRRCBkry9McdydxSNCSwRXG7sU3yYx5x72Q+ahduAv0v6/nwYuc", - "gVjmz3JMEfhWRLRTX7GwtqS7WPWIdWDomJoPhgwWbqgpaVeH+/pOP2987jufzBcPK/7RBfZ33lJEsl/B", - "wCYGlSuj25nV3wP/NyXfiu3YTe2cEL+x/w1QE0VJxfLspya/s1MYVFKerqP+rIXp+HPzhEG9OHs/Rasb", - "rSnnkEeHs7Lgz15mjEi1/xRj5ykYH9m2W6vULrezuAbwNpgeKD+hQS/TuZkgxGo74a0OqM5XIiM4T1NK", - "p+Ge/Rq3QSXCXytQOpY8hB9sUBfaLY2+awvhEeAZaosz8r19gmwNpFXpA7U0VlS5rRoB2QqkM6hXZS5o", - "NiVmnIs3p2+JndX2sYW4bSG+FSop7VV07FVB3a1x4cG+pnY8dWH8OPtjqc2qlcbCO0rTooylmZoWF74B", - "5rKGNnxUX0LszMhrqzkqr5fYSQw9LJksjMZVj2ZlF6QJ8x+tabpGlazFUodJfnwFSU+VKni1pa6+XpfO", - "wnNn4HZFJG0NySkRRm/eMGVfnoIraGe21mneziTgM13by5MV55ZSorLHvjIEt0G7B84GangzfxSyDuJv", - "KJDbAqw3Lah5jr2itWi61Tl7z7XY7Ma6qrZ/UTClXHCWYiWY2NXsXrEa4wMbUTSna2T1R9yd0MjhitYE", - "rcPkHBYHq4R6RugQ1zfCB1/NplrqsH9qfC5pTTVZgVaOs0E29aVtnR2QcQWuFBo+aBbwSSFbfkXkkFFX", - "dVK7NG5IRpgWM6DYfWe+vXNqP8aLXzKOAr5DmwtNt5Y6fGRHG62AabISoNx62rnB6qPpM8M02Qy2n2f+", - "UR4cw7rlzLKtD7o/1Kn3SDsPsGn7yrS1RVGan1sRyHbS07J0kw4XPo7KA3rLBxEc8Swm3rUTILcePxxt", - "D7ntDSXB+9QQGlyhIxpKvId7hFEXAe4UmDdCq6UobEFsCFe0FgLjETDeMg7Nk1GRCyKNXgm4MXheB/qp", - "VFJtRcBRPO0CaI7e5xhDU9q5Hu46VGeDESW4Rj/H8DY29YsHGEfdoBHcKN/VL1UZ6g6EiVf4RJ5DZL8a", - "MUpVTojKMKOgU584xjgM4/YV0NsXQP8Y9GUi211Lak/OTW6ioSTRRZWtQCc0y2I1JL/FrwS/kqxCyQG2", - "kFZ1Db6yJClWV2mXm+lTm5soFVxVxZ65fIM7TpeKmBz9DidQPmWiGXxGkP0a1vv6zfsPb16dXrx5be8L", - "RVRls0SNzC2hMAxxRs640mBE50oB+SVE4y/Y75fOguNgBnXJI0Qb1kb3hIi5Mosd/hurkzdMQC5W5MbR", - "ij4wBDveWLxvj9QTzs3RSxRbJeMxgVff3dHRTH2789j0v9cDmYtVG5CvXMFiHzMO9yjGht+Y+y0s8NAr", - "/mhvwLr+AsYGCv+aDGq3deZwm3nijdurBok+qfq1iv12kuF3J6Z4Rw9ECAd1O6gVA6yTcyhOOB0Ma6fa", - "JdhpSvZyysGkJRtkZNOT7KPJUQPvUGCRjSsyn3u9xwmwPXUAx96LUB+x1gfobz4clpSUOQ9+wyz6mHWB", - "88NWzX2Hrtng7iJcOPqgYTFe/H+4hE5TNgevgVIo1hSsjb0KMDJc6gIL+wclgPpj+ViFK0i1EeoDH6wE", - "uElBIDNZ8IbJv0vpDKgfdVSZq6Czr2xOvzTxAWbTy2wJsrNsWdfZ+CIxp3WkDfr/8RWRFXD3jEg7Zn10", - "5OxyCalmVwcyif5htNQmS2Xq9Vj7HFiQWMTqSEz/TPsN1esGoH2JPnvhCUrL3RmcoTyCS9g9UKRFDdE6", - "s1PP825TgwAxgNwhMSQiVMyTbQ1vzrnIVE0ZiAUfOWK7Q1PNabDAf5AXd8u5PEkSGubK7ZnySsQ091Fz", - "ma43yiDFoMKhZKN+ie1hQeg1VjRX9eMs9TvsgVZDzvqV3jauBgLmfdW2Zl8NAZT/zSd52lns+/7NEwRo", - "2d9QmfkWUVXVa8HJnvuolyHky0N3gV7WM7Mmzq+fExKpHYTRnGkuFOOrZCgkth1aF74NigEEeB1g7XKE", - "awnSPT2CJuRcKEi08HGB++DYhwr3juVtkKAG6/VZ4AaraHxoyoRgBVSKVTOoC44IF2j0Vmqgk0Exj+E5", - "9yH7lf3ukyB8BcwRGrmj1+RgNQ4f4clUD4kh1S+Juy0PJ1fcRutlnNunqFSssgc3qAytx6UUWZXaCzo8", - "GI2NYWzdnD2sJKowpv1V9mT/HKtIvQ1S1S5hN7fyd7qmvCnn1T7WVoSyawhSwzu7fa8Ggbjuk6/sAlb3", - "AufvqVRPJ6UQeTJgLj7rFyjpnoFLll5CRszd4WOjBor8k4dopaz9gZv1zhfkKEvgkD2aEWLU8qLUO+8a", - "bNfa7UzOH+h9829x1qyyNYOcvj/7xONhfVjNR96Rv/lh9nM1BYb53XEqO8iB8hfbgeIokm4iT16MffE2", - "4qzrPkPQEJWFIial3DIXetT57uv8EdIP6vDv137CUglNDJa0piOUlrxBpyu8/NBYhMa9COA7HAAvVIqD", - "NwE8N3Lg/M6BUj/USAmWMkgJreUf0rP9Q801Xwq2SGFkvVmmLVxjneztfQmMKOpVbZuI47lvwsC6CIJj", - "rZi+6UOhKRFLzoaEY86lvKL51zdfYMGMU8SHe9gqvtBQ/w2RbFGpbhet8JaOmjvQde9vav4ezS3/ALNH", - "URuwG8rZUeu3GHwJSSyNRnOSi+ZNFhySbHBMazQ+fkEWLtK6lJAyxTpJKBtfDbNW97A4dPPe2X798tA6", - "fxL6DmTsFARRkndNZT0t8H5oIGyO6O/MVAZObpTKY9TXI4sI/mI8Kkx5PnBdXLasybZSaSeaQ0i4Z6ty", - "4Ma+oVW5n8w9dnm4Drx0KgX9dY6+rVu4jVzUzdrGukT6yN1Xfm2MJyNeVdF0R1eKRQiWJCUIKvnl+Bci", - "YYlvDgjy+DFO8Pjx1DX95Un7sznOjx9Hxbiv5kRpPQ3u5o1RzE9D0X82wm0g0LSzHxXLs0OE0Qobbt7/", - "wMDYn13iwO/yAsnP1p7aP6qudvtN3LfdTUDERNbamjyYKggIHhEL7LrNoo+3K0gryfQO6xl48xv7OVon", - "6vvaYu88PnUGrLv7tLiEuiJGY9+vlL9dvxf2sffCyNToPNf4GNybLS3KHNxB+ebB4s/w9C/PsqOnx39e", - "/OXo+VEKz56/PDqiL5/R45dPj+HJX54/O4Lj5YuXiyfZk2dPFs+ePHvx/GX69Nnx4tmLl39+YPiQAdkC", - "OvHZc5P/jc/0JKfvz5ILA2yDE1qy+g1IQ8b+hQCa4kmEgrJ8cuJ/+p/+hM1SUTTD+18nLjlnsta6VCfz", - "+WazmYVd5is06CVaVOl67ufpv733/qwOsLYJ37ijNnbWkAJuqiOFU/z24c35BTl9fzZrCGZyMjmaHc2O", - "8WWtEjgt2eRk8hR/wtOzxn2fO2KbnHy5nk7ma6A5+r/MHwVoyVL/SW3oagVy5p5KMD9dPZl7UWL+xRkz", - "r/d9m4dVR+dfWjbf7EBPrEo4/+KT7fe3bmWzO1t30GEkFPuazReYwzO2Kaig8fBS7KvV8y8oIg/+PneJ", - "DfGPqKrYMzD3jpF4yxaWvuitgbXTwz0iO//SvOp8bZlEDjE3iM0HoMEj0FPCNKELITHLXadrwxd8ei1T", - "7UfAayI/ywxxm16v6heug8piJx97Ur4diPiRkBMYMm8OamumhhdrWUFY7Kq+aVrtm/vm41Hy8vOX4+nx", - "0fWfzH3i/nz+9HqkP/NV80D2eX1ZjGz4GXNT0TKL5/fJ0dEd3n875eFr3bhJwTOD0Uf7qzIphrR3t1Wd", - "gUiNjAM5dJ3hB54IfnbDFe+1H7WihyLPuXxLM+JTZHDu46839xlHb7Lh68TeW9fTyfOvufozbkie5gRb", - "BkUR+lv/d37JxYb7lkbIqIqCyp0/xqrFFPy79XiV0ZVCa6JkVxRlOy54q9L75DNasGPhlQP8Rml6C35z", - "bnr9m998LX6Dm3Qf/KY90D3zmyc3PPN//BX/m8P+0TjsuWV3d+KwTuCzuZpz+zBtIwd2HymJ/Tz/0i6S", - "25Js1brSmdjYtOAoK8dKcDR3ZWPQdFmrQVoQP0ATikZ+dGG8+Q7ttSwDQjENUlS60VNNZ+9gbDwJZoTm", - "AaMV4zgBmoRxFlsfiQZBHgpSwe1zH51rw0H2TmTQvzbwYvi1ArlrbgYH42Ta4htu4yPViO7MhvvH/Ppm", - "ZIGma+t36Wsn9Rsfrb/nG8q0uVxcTBhitN9ZA83nLmGu82sT/N37ghHtwY/tJ/Yjv87rgn7Rj10VMfbV", - "qUi+UWMDCm0quOe1NeXjZ7N1WA/GkUNjIjiZzzGQYi2Unk+up1865oPw4+d6t3yhgHrXrj9f//8AAAD/", - "//7jKXoargAA", + "H4sIAAAAAAAC/+x9+5PbNtLgv4LSflV+nCjN+JFdT1Xqu4ntZOfiOC7PbPbus30JRLYk7JAAA4AjKb75", + "36/QAEiQBCXOI86Xqv3JHhGPRqPR6Dc+T1JRlIID12py8nlSUkkL0CDxL5qmouI6YZn5KwOVSlZqJvjk", + "xH8jSkvGV5PphJlfS6rXk+mE0wKaNqb/dCLh14pJyCYnWlYwnah0DQU1A+tdaVrXI22TlUjcEKd2iLNX", + "k+s9H2iWSVCqD+WPPN8RxtO8yoBoSbmiqfmkyIbpNdFrpojrTBgnggMRS6LXrcZkySDP1Mwv8tcK5C5Y", + "pZt8eEnXDYiJFDn04XwpigXj4KGCGqh6Q4gWJIMlNlpTTcwMBlbfUAuigMp0TZZCHgDVAhHCC7wqJicf", + "Jgp4BhJ3KwV2hf9dSoDfINFUrkBPPk1ji1tqkIlmRWRpZw77ElSVa0WwLa5xxa6AE9NrRn6olCYLIJST", + "99++JE+fPn1hFlJQrSFzRDa4qmb2cE22++RkklEN/nOf1mi+EpLyLKnbv//2Jc5/7hY4thVVCuKH5dR8", + "IWevhhbgO0ZIiHENK9yHFvWbHpFD0fy8gKWQMHJPbON73ZRw/j90V1Kq03UpGNeRfSH4ldjPUR4WdN/H", + "w2oAWu1LgylpBv1wlLz49Pl4enx0/ZcPp8l/uT+fP70eufyX9bgHMBBtmFZSAk93yUoCxdOypryPj/eO", + "HtRaVHlG1vQKN58WyOpdX2L6WtZ5RfPK0AlLpTjNV0IR6sgogyWtck38xKTiuWFTZjRH7YQpUkpxxTLI", + "pob7btYsXZOUKjsEtiMblueGBisF2RCtxVe35zBdhygxcN0KH7ig/77IaNZ1ABOwRW6QpLlQkGhx4Hry", + "Nw7lGQkvlOauUje7rMjFGghObj7YyxZxxw1N5/mOaNzXjFBFKPFX05SwJdmJimxwc3J2if3dagzWCmKQ", + "hpvTukfN4R1CXw8ZEeQthMiBckSeP3d9lPElW1USFNmsQa/dnSdBlYIrIGLxL0i12fb/df7jWyIk+QGU", + "oit4R9NLAjwV2fAeu0ljN/i/lDAbXqhVSdPL+HWds4JFQP6BbllRFYRXxQKk2S9/P2hBJOhK8iGA7IgH", + "6Kyg2/6kF7LiKW5uM21LUDOkxFSZ092MnC1JQbdfH00dOIrQPCcl8IzxFdFbPiikmbkPg5dIUfFshAyj", + "zYYFt6YqIWVLBhmpR9kDiZvmEDyM3wyeRrIKwPGDDIJTz3IAHA7bCM2Yo2u+kJKuICCZGfmH41z4VYtL", + "4DWDI4sdfiolXDFRqbrTAIw49X7xmgsNSSlhySI0du7QYbiHbePYa+EEnFRwTRmHzHBeBFposJxoEKZg", + "wv3KTP+KXlAFXz0busCbryN3fym6u753x0ftNjZK7JGM3IvmqzuwcbGp1X+E8hfOrdgqsT/3NpKtLsxV", + "smQ5XjP/Mvvn0VApZAItRPiLR7EVp7qScPKRPzZ/kYSca8ozKjPzS2F/+qHKNTtnK/NTbn96I1YsPWer", + "AWTWsEa1KexW2H/MeHF2rLdRpeGNEJdVGS4obWmlix05ezW0yXbMmxLmaa3KhlrFxdZrGjftobf1Rg4A", + "OYi7kpqGl7CTYKCl6RL/2S6RnuhS/mb+Kcvc9NblMoZaQ8fuvkXbgLMZnJZlzlJqkPjefTZfDRMAqyXQ", + "psUcL9STzwGIpRQlSM3soLQsk1ykNE+UphpH+g8Jy8nJ5C/zxrgyt93VPJj8jel1jp2MPGplnISW5Q3G", + "eGfkGrWHWRgGjZ+QTVi2hxIR43YTDSkxw4JzuKJczxp9pMUP6gP8wc3U4NuKMhbfHf1qEOHENlyAsuKt", + "bfhAkQD1BNFKEK0oba5ysah/eHhalg0G8ftpWVp8oGgIDKUu2DKl1SNcPm1OUjjP2asZ+S4cG+VswfOd", + "uRysqGHuhqW7tdwtVhuO3BqaER8ogtsp5MxsjUeDkeHvg+JQZ1iL3Eg9B2nFNP67axuSmfl9VOc/B4mF", + "uB0mLtSiHOasAoO/BJrLww7l9AnH2XJm5LTb93ZkY0aJE8ytaGXvftpx9+CxRuFG0tIC6L7Yu5Rx1MBs", + "IwvrHbnpSEYXhTk4wwGtIVS3PmsHz0MUEiSFDgzf5CK9/DtV63s48ws/Vv/44TRkDTQDSdZUrWeTmJQR", + "Hq9mtDFHzDRE7Z0sgqlm9RLva3kHlpZRTYOlOXjjYolFPfZDpgcyorv8iP+hOTGfzdk2rN8OOyMXyMCU", + "Pc7Og5AZVd4qCHYm0wBNDIIUVnsnRuu+EZQvm8nj+zRqj15bg4HbIbcI3CGxvfdj8I3YxmD4Rmx7R0Bs", + "Qd0HfZhxUIzUUKgR8L1ykAncf4c+KiXd9ZGMY49BslmgEV0VngYe3vhmlsbyeroQ8nbcp8NWOGnsyYSa", + "UQPmO+0gCZtWZeJIMWKTsg06AzUuvP1Mozt8DGMtLJxr+jtgQZlR7wML7YHuGwuiKFkO90D66yjTX1AF", + "T5+Q87+fPj9+8vOT518ZkiylWElakMVOgyIPnW5GlN7l8Ki/MtSOqlzHR//qmbdCtseNjaNEJVMoaNkf", + "ylo3rQhkmxHTro+1Nppx1TWAYw7nBRhObtFOrOHegPaKKSNhFYt72YwhhGXNLBlxkGRwkJhuurxmml24", + "RLmT1X2osiClkBH7Gh4xLVKRJ1cgFRMRV8k714K4Fl68Lbu/W2jJhipi5kbTb8VRoIhQlt7y8XzfDn2x", + "5Q1u9nJ+u97I6ty8Y/aljXxvSVSkBJnoLScZLKpVSxNaSlEQSjLsiHf0G7Za60BkeSeFWN77rR2dJbYk", + "/GAFvtz06Yt9b0UGRu2u1D2w92awBnuGckKc0YWoNKGEiwxQR69UnPEPOHrRw4SOMR3eJXptZbgFGH0w", + "pZVZbVUSdPv0aLHpmNDUUlGCqFEDdvHaoWFb2emsEzGXQDOjJwInYuGMz84sjouk6LPSnnW6ayeiObfg", + "KqVIQSmj31ut7SBovp0lS70HTwg4AlzPQpQgSyrvDOzl1UE4L2GXoIdVkYff/6Qe/QHwaqFpfgCx2CaG", + "3lqFcB6GPtTjpt9HcN3JQ7KjEojnfUZfMQwiBw1DKLwRTgb3rwtRbxfvjpYrkGjr/10p3k9yNwKqQf2d", + "6f2u0FblQNyQE50vWIGWIE65UJAKnqnoYDlVOjnElk2jlnxvVhBwwhgnxoEHrJFvqNLWP8V4hmq1vU5w", + "HmumNFMMAzwo4piRf/LSTX/s1NyDXFWqFnVUVZZCashia+Cw3TPXW9jWc4llMHYtT2lBKgWHRh7CUjC+", + "Q5ZdiUUQ1bUZ1zlw+4tDY6e553dRVLaAaBCxD5Bz3yrAbhg7MQAIUw2iLeEw1aGcOmBjOlFalKXhFjqp", + "eN1vCE3ntvWp/kfTtk9cVDf3dibAzK49TA7yjcWsjZpZU6OU4cikoJdG9kAVyzrS+jCbw5goxlNI9lG+", + "OZbnplV4BA4c0gHt1sXlBbN1DkeHfqNEN0gEB3ZhaMEDqvY7KjVLWYmS4vewu3fBuTtB1ABMMtCUGfUv", + "+GCF6DLsT6xntDvm7QTpUVpRH/yeWhRZTs4UXhht4C9hh56gdzbk5iII1LkHTSAyqjndlBME1DvyjQAT", + "NoEtTXW+M9ecXsOObEACUdWiYFrbGKq2oqBFmYQDRC1Oe2Z05lUbruJ3YIy99xyHCpbX34rpxEpU++G7", + "6IhVLXQ4SaoUIh/haeshIwrBKE8cKYXZdeZC9nxcl6ekFpBOiEHbes08H6gWmnEF5P+IiqSUo8Baaahv", + "BCGRzeL1a2YwF1g9p/O5NRiCHAqwcjh+efy4u/DHj92eM0WWsPFxrqZhFx2PH6MW/E4o3Tpc92CCMcft", + "LMLb0RRnLgonw3V5ymGfjxt5zE6+6wxe2+/MmVLKEa5Z/p0ZQOdkbsesPaSRcf4uHHeUlS0YOrZu3HcM", + "OPh9bDTN0DHo+hMHbtrm45Cn1shX+e4e+LQdiEgoJSg8VaFeouxXsQxDod2xUzuloeibbmzXnwcEm/de", + "LOhJmYLnjENSCA67aPYP4/ADfoz1tid7oDPy2KG+XbGpBX8HrPY8Y6jwrvjF3Q5I+V0donAPm98dt2O1", + "C4PAUSuFvCSUpDlDnVVwpWWV6o+colQcnOWIK8fL+sN60kvfJK6YRfQmN9RHTtGNV8vKUfPzEiJa8LcA", + "Xl1S1WoFSnfkgyXAR+5aMU4qzjTOVZj9SuyGlSDRnzKzLQu6I0uao1r3G0hBFpVu35gYq6q00bqsCdFM", + "Q8TyI6ea5GA00B8Yv9jicD4k1NMMB70R8rLGwix6HlbAQTGVxF1O39mvGA3glr92kQGYOGQ/W6OTGb8J", + "aN1paCXD/N+H/3ny4TT5L5r8dpS8+B/zT5+fXT963PvxyfXXX/+/9k9Pr79+9J//EdspD3ssktJBfvbK", + "SZNnr1BkaKxOPdi/mMWhYDyJEtnFGkjBOAbkd2iLPDSCjyegR41Zz+36R6633BDSFc1ZRvXtyKHL4npn", + "0Z6ODtW0NqKjQPq1fopFR6xEUtL0Ej22kxXT62oxS0Ux91L0fCVqiXqeUSgEx2/ZnJZsrkpI51fHB670", + "O/ArEmFXHSZ7a4Gg7++NRz+jQdUFNOPJW1bcEkWlnFEXg/u8300sp3WEu81sPSEY/rym3mns/nzy/KvJ", + "tAlbrr8bTd1+/RQ5EyzbxoLTM9jGJDV31PCIPVCkpDsFOs6HEPaoi9H6pcJhCzAivlqz8svzHKXZIs4r", + "fciU0/i2/IzbWCZzEtE8u3NWH7H88nBrCZBBqdexjLeWzIGtmt0E6LjMSimugE8Jm8Gsq3FlK1De2ZkD", + "XWLmFZoYxZgQ0PocWELzVBFgPVzIKLUmRj8oJju+fz2dODFC3btk7waOwdWds7bF+r+1IA++e31B5o71", + "qgc2T8IOHUS2RywZLniz5Uw13Mzm+dpEkY/8I38FS8aZ+X7ykWdU0/mCKpaqeaVAfkNzylOYrQQ58fGg", + "r6imH3lPZhtMxQ8icUlZLXKWkstQtm7I06ZX9kf4+PGD4fgfP37q+ZX6krCbKspf7ATJhum1qHTi8scS", + "CRsqswjoqs4fwpFt9ue+WafEjW1ZsctPc+PHeR4tS9XNI+gvvyxzs/yADJWLkjdbRpQW0ks1RtSx0OD+", + "vhXuYpB045MPKwWK/FLQ8gPj+hNJPlZHR0+BtALrf3HCg6HJXQktm9et8hy69i5cuNWQYKslTUq6AhVd", + "vgZa4u6j5F2gdTXPCXZrBfT7gCUcqlmAx8fwBlg4bhycjIs7t718IYD4EvATbiG2MeJG47S47X4FIf63", + "3q5OmkBvlyq9TszZjq5KGRL3O1PnB6+MkOU9SYqtuDkELpV6ASRdQ3oJGWZ1QlHq3bTV3TsrncjqWQdT", + "NvvZBuhiih6aBxdAqjKjTqinfNfNlVKgtU8Qew+XsLsQTYbfTZKj2rk6auigIqUG0qUh1vDYujG6m+88", + "4pifUJY+5QVjnz1ZnNR04fsMH2Qr8t7DIY4RRSuXZAgRVEYQYYl/AAW3WKgZ706kH1ue0VcW9uaLJEt7", + "3k9ck0YNc87rcDWYImO/F4ClFMRGkQU1crtwVQBsPkrAxSpFVzAgIYcW2pFZHy2rLg5y6N6L3nRi2b3Q", + "evdNFGTbODFrjlIKmC+GVFCZ6YQs+JmsEwBXMCNY3MchbJGjmFTHdlimQ2XLUm6rlQyBFidgkLwRODwY", + "bYyEks2aKl+gAOs4+LM8Sgb4HfOr9mXVngXe9qBYQ50z63lu95z2tEuXW+sTan0WbahajsiINRI+BvjF", + "tkNwFIAyyGFlF24be0Jpcr2aDTJw/Lhc5owDSWKOe6qUSJmtMNFcM24OMPLxY0KsMZmMHiFGxgHY6NzC", + "gclbEZ5NvroJkNzlqlE/NrrFgr8hHlZrQ9mMyCNKw8IZHwia9ByAumiP+v7qxBzhMITxKTFs7ormhs05", + "ja8ZpJfciWJrJ5XTuVcfDYmze2z59mK50ZrsVXSb1YQykwc6LtDtgXghtomNq49KvIvtwtB7NLoPo/xj", + "B9Om0T5QZCG26LLHq8VGkx2AZRgOD0ag4W+ZQnrFfkO3uQVm37T7pakYFSokGWfOq8llSJwYM/WABDNE", + "Lg+DzNhbAdAxdjQ15Jzye1BJbYsn/cu8udWmTcUHHzgdO/5DRyi6SwP461th6lzWd12JJWqnaHue22m8", + "gQgZI3rDJvrunr5TSUEOqBQkLSEquYw5AY1uA3jjnPtugfECk4Up3z0KwhkkrJjS0JjjzcXs/Utf2jxJ", + "sUaJEMvh1elSLs363gtRX1M2CR47tpb5xVdwJTQkSyaVTtCXEV2CafStQqX6W9M0Liu1AyZsuS6WxXkD", + "TnsJuyRjeRWnVzfv96/MtG9rlqiqBfJbxgnQdE0WWF4uGka1Z2obabd3wW/sgt/Qe1vvuNNgmpqJpSGX", + "9hx/knPR4bz72EGEAGPE0d+1QZTuYZAo+7yCXMcyIAO5yR7OzDSc7bO+9g5T5sc+GIBioRi+o+xI0bUE", + "BoO9q2DoJjJiCdNBdbZ+Vs/AGaBlybJtxxZqRx3UmOmNDB6+7EUHC7i7brADGAjsnrHAYgmqXeGkEfBt", + "nb1WgvFsFGYu2nVIQoYQTsWUrxLbR1SdeHAIVxdA8+9h95Npi8uZXE8ndzOdxnDtRjyA63f19kbxjE5+", + "a0preUJuiHJallJc0TxxBuYh0pTiypEmNvf26C/M6uJmzIvXp2/eOfCvp5M0ByqTWlQYXBW2K/80q7LF", + "VAYOiK9CaXQ+L7NbUTLY/LoCRGiU3qzBVfwLpNFeaaLG4RAcRWekXsZjjQ6anJ1vxC5xj48EytpF0pjv", + "rIek7RWhV5Tl3m7moR2IC8LFjatvFeUK4QB39q4ETrLkXtlN73THT0dDXQd4UjjXnpqEhS27qYjgXRe6", + "ESHRHIekWlAsLGStIn3mxKsCLQmJylkat7HyhTLEwa3vzDQm2HhAGDUjVmzAFcsrFoxlmqkRim4HyGCO", + "KDJ9kaoh3C2Eq5decfZrBYRlwLX5JPFUdg4qVnJy1vb+dWpkh/5cbmBroW+Gv4uMERbV6t54CMR+ASP0", + "1PXAfVWrzH6htUXK/BC4JG7g8A9n7F2Je5z1jj4cNdswyHXb4xaWN+/zP0MYthTm4drqXnl11b0G5ojW", + "SmcqWUrxG8T1PFSPI1kHvowYwyiX34DPIslbXRZTW3eaku/N7IPbPSTdhFaodpDCANXjzgduOaxn5C3U", + "lNuttqWLW7FucYIJ41PndvyGYBzMvZjenG4WNFbsyQgZBqbTxgHcsqVrQXxnj3tn9meustuMBL7kui2z", + "+XglyCYhqJ/bf0uBwU47WlRoJAOk2lAmmFr/X65EZJiKbyi3FbBNP3uUXG8F1vhlem2ExGxaFTf7Z5Cy", + "guZxySFL+ybejK2Yrf9cKQgKDLuBbOF8S0WuSLN1sTeoOVuSo2lQwtztRsaumGKLHLDFsW2xoAo5eW2I", + "qruY5QHXa4XNn4xovq54JiHTa2URqwSphTpUb2rn1QL0BoCTI2x3/II8RLedYlfwyGDR3c+Tk+MXaHS1", + "fxzFLgBX6H0fN8mQnfzTsZM4HaPf0o5hGLcbdRbNDbWvcwwzrj2nyXYdc5awpeN1h89SQTldQTxSpDgA", + "k+2Lu4mGtA5eeGZLyystxY4wHZ8fNDX8aSCO3bA/CwZJRVEwXTjnjhKFoaemerCd1A9n69S7wm8eLv8R", + "faSldxF1lMgvazS191ts1ejJfksLaKN1SqhNoc5ZE73gy1GSM1+hASvh1QXwLG7MXGbpKOZgMMOSlJJx", + "jYpFpZfJ30i6ppKmhv3NhsBNFl89i1T/a1eh4jcD/IvjXYICeRVHvRwgey9DuL7kIRc8KQxHyR41eSPB", + "qRx05sbddkO+w/1DjxXKzCjJILlVLXKjAae+E+HxPQPekRTr9dyIHm+8si9OmZWMkwetzA794/0bJ2UU", + "QsbKLjXH3UkcErRkcIWxe/FNMmPecS9kPmoX7gL9H+t58CJnIJb5sxxTBL4REe3UV6SsLekuVj1iHRg6", + "puaDIYOFG2pK2tX/vrzTzxuf+84n88XDin90gf2DtxSR7FcwsIlBZdLodmb198D/Tck3Yjt2UzsnxG/s", + "fwPURFFSsTz7qcnv7BR+lZSn66g/a2E6/tw8UVEvzt5P0epGa8o55NHhrCz4s5cZI1Ltv8TYeQrGR7bt", + "1qK1y+0srgG8DaYHyk9o0Mt0biYIsdpOeKsDqvOVyAjO05TSabhnv4ZxUGny1wqUjiUP4Qcb1IV2S6Pv", + "2kKHBHiG2uKMfGefmFsDaVX6QC2NFVVuq0ZAtgLpDOpVmQuaTYkZ5+L16RtiZ7V9bKF1W2hxhUpKexUd", + "e1VQJWxceLCvmR5PXRg/zv5YarNqpbHwjtK0KGNppqbFhW+AuayhDR/VlxA7M/LKao7K6yV2EkMPSyYL", + "o3HVo1nZBWnC/Edrmq5RJWux1GGSH18h1FOlCl7lqavr16Wz8NwZuF2RUFsjdEqE0Zs3TNmXxeAK2pmt", + "dZq3Mwn4TNf28mTFuaWUqOyxrwzBbdDugbOBGt7MH4Wsg/gbCuS2wO5NC6aeY69oLZpu9dXeczw2u7Gu", + "mu5fjEwpF5ylWAkmdjW7V8rG+MBGFM3pGln9EXcnNHK4ojVf6zA5h8XBKrCeETrE9Y3wwVezqZY67J8a", + "n8NaU01WoJXjbJBNfeliZwdkXIErhYYP1gV8UsiWXxE5ZNRVndQujRuSEabFDCh235pvb53aj/Hil4yj", + "gO/Q5kLTraUOH1HSRitgmqwEKLeedm6w+mD6zDBNNoPtp5l/dAnHsG45s2zrg+4Pdeo90s4DbNq+NG1t", + "UZTm51YEsp30tCzdpMOFraPygN7yQQRHPIuJd+0EyK3HD0fbQ257Q0nwPjWEBlfoiIYS7+EeYdRFnjsP", + "CBih1VIUtiA2hCtaC4HxCBhvGIfmSbDIBZFGrwTcGDyvA/1UKqm2IuAonnYBNEfvc4yhKe1cD3cdqrPB", + "iBJco59jeBub+tQDjKNu0AhulO/ql8gMdQfCxEt8AtEhsl9tGqUqJ0RlmFHQqT8dYxyGcfsK9+0LoH8M", + "+jKR7a4ltSfnJjfRUJLoospWoBOaZbEakt/gV4JfSVah5ABbSKu6Bl9ZkhSrq7TLzfSpzU2UCq6qYs9c", + "vsEdp0tFTI5+ixMonzLRDD4jyH4N6331+t371y9PL16/sveFIqqyWaJG5pZQGIY4I2dcaTCic6WA/BKi", + "8Rfs90tnwXEwg7rzEaINa997QsRcmcUO/43VyRsmIBcrcuNoRR8Ygh1vLN63R+oJ5+boJYqtkvGYwKvv", + "7uhopr7deWz63+uBzMWqDcgXrmCxjxmHexRjw6/N/RYWeOgVf7Q3YF1/AWMDhX8tCLXbOnO4zTzxxu1V", + "g0SfVP0ayX47yfC7IlO8owcihIO6HdSKAdbJORQnnA6GtVPtEuw0JXs55WDSkg0ysulJ9lHsqIF3KLDI", + "xhWZz73e4wTYnjqAY+9FqI9Y6wP0vQ+HJSVlzoPfMIs+Zl3g/LBVc9+haza4uwgXjj5oWIw/7jBcQqcp", + "m4PXQCkUawrWxl59GBkudYEPNwQlgPpj+ViFK0i1EeoDH6wEuElBIDNZ8EbNv0vpDKgfdVSZq6Czr2xO", + "vzTxAWbTy2wJsrNsWdfZ+CIxp3WkDfr/8ZWYFXD3TEw7Zn105OxyCalmVwcyif5ptNQmS2Xq9Vj73FuQ", + "WMTqSEz/DP8N1esGoH2JPnvhCUrL3RmcoTyCS9g9UKRFDdE6s1PP825TgwAxgNwhMSQiVMyTbQ1vzrnI", + "VE0ZiAUfOWK7Q1PNabDAf5AXd8u5PEkSGubK7ZnySsQ091Fzma43yiDFoMKhZKN+ie1hQegVVjRX9eM7", + "9Tv7gVZDzvqV3jauBgLmfdW2Zl8NAZT/zSd52llydgnhEwRo2d9QmfkWUVXVa8HJnvuolyHky0N3gV7W", + "M7Mmzq+fExKpHYTRnGkuFOOrZCgkth1aF779igEEeB1g7XKEawnSPdWCJuRcKEi08HGB++DYhwr3Tult", + "kKAG6/VZ4AaraLxvyoRgBVSKVTOoC44IF2j0Vmqgk0Exj+E59yH7pf3ukyB8BcwRGrmj1+RgNQ4f4clU", + "D4kh1S+Juy0PJ1fcRutlnNunxlSssgc3qAytx6UUWZXaCzo8GI2NYWzdnD2sJKowpv1V9mT/HKtIvQlS", + "1S5hN7fyd7qmvCnn1T7WVoSyawhSwzu7fa8Ggbjuk6/sAlb3AucfqVRPJ6UQeTJgLj7rFyjpnoFLll5C", + "Rszd4WOjBor8k4dopaz9gZv1zhfkKEvgkD2aEWLU8qLUO+8abNfa7UzOH+h9829x1qyyNYOcvj/7yONh", + "fVjNR96Rv/lh9nM1BYb53XEqO8iB8hfbgeIokm4iT16MfdE44qzrPkPQEJWFIial3DIXetT57uv8EdIP", + "6vDv137CUglNDJa0piOUlrxBpyu8/NBYhMa9COA7HAAvVIqDNwE8N3Lg/MGBUj/USAmWMkgJreUf0rP9", + "Q9w1Xwq2SGFkvVmmLVxjneztfQmMKOplbZuI47lvwsC6CIJjrZi+6UOhKRFLzoaEY86lvKL5lzdfYMGM", + "U8SHe9gqvtBQ/w2RbFGpbhet8IaOmjvQde9vav4OzS3/BLNHURuwG8rZUeu3GHwJSSyNRnOSi+ZNFhyS", + "bHBMazQ+/oosXKR1KSFlinWSUDa+Gmat7mFx6Oa9s/365aF1/iT0HcjYKQiiJG+bynpa4P3QQNgc0T+Y", + "qQyc3CiVx6ivRxYR/MV4VJjyfOC6uGxZk22l0k40h5Bwz1blwI19Q6tyP5l77PJwHXjpVAr66xx9W7dw", + "G7mom7WNdYn0kbuv/NoYT0a8qqLpjq4UixAsSUoQVPLL8S9EwhLfHBDk8WOc4PHjqWv6y5P2Z3OcHz+O", + "inFfzInSevrdzRujmJ+Gov9shNtAoGlnPyqWZ4cIoxU23Lz/gYGxP7vEgT/kBZKfrT21f1Rd7fabuG+7", + "m4CIiay1NXkwVRAQPCIW2HWbRR/nV5BWkukd1jPw5jf2c7RO1He1xd55fOoMWHf3aXEJdUWMxr5fKX+7", + "fifsY/6FkanRea7xMbjXW1qUObiD8vWDxV/h6d+eZUdPj/+6+NvR86MUnj1/cXREXzyjxy+eHsOTvz1/", + "dgTHy69eLJ5kT549WTx78uyr5y/Sp8+OF8++evHXB4YPGZAtoBOfPTf53/hMT3L67iy5MMA2OKElq9+A", + "NGTsXwigKZ5EKCjLJyf+p//pT9gsFUUzvP914pJzJmutS3Uyn282m1nYZb5Cg16iRZWu536e/tt7787q", + "AGub8I07amNnDSngpjpSOMVv71+fX5DTd2ezhmAmJ5Oj2dHsGF/WKoHTkk1OJk/xJzw9a9z3uSO2ycnn", + "6+lkvgaao//L/FGAliz1n9SGrlYgZ+6pBPPT1ZO5FyXmn50x83rft3lYdXT+uWXzzQ70xKqE888+2X5/", + "61Y2u7N1Bx1GQrGv2XyBOTxjm4IKGg8vxb7yPf+MIvLg73OX2BD/iKqKPQNz7xiJt2xh6bPeGlg7Pdwj", + "svPPzavO15ZJ5BBzg9h8ABo8Aj0lTBO6EBKz3HW6NnzBp9cy1X4dvCbys8wQt+n1sn7hOqgsdvKhJ+Xb", + "gYgfCTmBIfPmoLZmanixlhWExa7qm6bVvrlvPhwlLz59Pp4eH13/xdwn7s/nT69H+jNfNg9kn9eXxciG", + "nzA3FS2zeH6fHB3d4f23Ux6+1o2bFDwz2Cv34B4ULoa0d7dVnYFIjYwDOXSd4QeeCH52wxXvtR+1ooci", + "z7l8QzPiU2Rw7uMvN/cZR2+y4evE3lvX08nzL7n6M25InuYEWwZFEfpb/w9+ycWG+5ZGyKiKgsqdP8aq", + "xRT8u/V4ldGVQmuiZFcUZTsueKvS++QTWrBj4ZUD/EZpegt+c256/ZvffCl+g5t0H/ymPdA985snNzzz", + "f/4V/5vD/tk47Llld3fisE7gs7mac/swbSMHdh8pif08/9wuktuSbNW60pnY2LTgKCvHSnA0d2Vj0HRZ", + "q0FaED9AE4pGfnRhvPkO7bUsA0IxDVJUutFTTWfvYGw8CWaE5gGjFeM4AZqEcRZbH4kGQR4KUsHtcx+d", + "a8NB9lZk0L828GL4tQK5a24GB+Nk2uIbbuMj1YjuzIb7x/z6ZmSBpmvrd+lrJ/UbH62/5xvKtLlcXEwY", + "YrTfWQPN5y5hrvNrE/zd+4IR7cGP7Sf2I7/O64J+0Y9dFTH21alIvlFjAwptKrjntTXlwyezdVgPxpFD", + "YyI4mc8xkGItlJ5PrqefO+aD8OOnerd8oYB6164/Xf//AAAA//9kloV/+q8AAA==", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/daemon/algod/api/server/v2/generated/nonparticipating/public/routes.go b/daemon/algod/api/server/v2/generated/nonparticipating/public/routes.go index 74dffe17c3..234fa90c88 100644 --- a/daemon/algod/api/server/v2/generated/nonparticipating/public/routes.go +++ b/daemon/algod/api/server/v2/generated/nonparticipating/public/routes.go @@ -585,177 +585,178 @@ var swaggerSpec = []string{ "5g1utnJ+u97I6ty8Y/aljXxvSVSkBJnoNScZzKtlSxNaSFEQSjLsiHf0K7Zc6UBkeSuFWFz7rR2dJbYk", "/GAFvtz06Yt9b0QGRu2u1DWw92awBnuGckKc0bmoNKGEiwxQR69UnPEPOHrRw4SOMR3eJXplZbg5GH0w", "pZVZbVUSdPv0aLHpmNDUUlGCqFEDdvHaoWFb2emsEzGXQDOjJwInYu6Mz84sjouk6LPSnnW6ayeiObfg", - "KqVIQSmj31utbSdovp0lS70FTwg4AlzPQpQgCyovCawWmuY7AMU2MXBrkdxZ7PtQj5t+2wZ2Jw+3kUqj", - "4lsqMPK/OXA5aBhC4UicnIFEy/UX3T8/yWW3ryoH4kqcaHXCCrQUcMqFglTwTEUHy6nSya5jaxq15D+z", - "guCkxE4qDjxgrXpFlbb+C8YzVLssu8F5rBnLTDEM8OAVaEb+2d9+/bFTwye5qlR9FaqqLIXUkMXWwGG9", - "Za43sK7nEotg7Pq+1YJUCnaNPISlYHyHLLsSiyCqazOfc/D1F4fGMHMPbKKobAHRIGIbIMe+VYDd0Lc+", - "AIjR0eueSDhMdSinduhPJ0qLsjTnTycVr/sNoenYtj7Uf2/a9omL6oavZwLM7NrD5CA/t5i1URUraoR2", - "HJkU9NTcTSiCW0dLH2ZzGBPFeArJNso3x/LYtAqPwI5DOqD9uLitYLbO4ejQb5ToBolgxy4MLXhAFXtL", - "pWYpK1GS+Btsrl2w6k4QNRCSDDRlRj0IPlghqwz7E+s56455OUFrlNTcB78nNkeWkzOFF0Yb+FPYoKfg", - "rQ3JOAkCOa5BUoyMak435QQB9Y5ecyGHTWBNU51vzDWnV7Ah5yCBqGpeMK1tjE1bkNSiTMIBohaJLTM6", - "85sNZ/A7MMYeeIxDBcvrb8V0YsWW7fCddASXFjqcwFQKkY/wxPSQEYVglKeGlMLsOnMhXT7ux1NSC0gn", - "xKDttWaed1QLzbgC8j+iIinlKIBVGuobQUhks3j9mhnMBVbP6XwyDYYghwKsXIlf7t/vLvz+fbfnTJEF", - "nPs4SNOwi47791FLeiuUbh2ua1DRzXE7ivB2NNWYi8LJcF2estsn4EYes5NvO4PX9h1zppRyhGuWf2UG", - "0DmZ6zFrD2lknD8Exx1lhQmGjq0b9x0d0l9Gh2+GjkHXnzhw4zUfhzx5Rr7KN9fAp+1AREIpQeGpCvUS", - "Zb+KRRgq646d2igNRV+1t11/HRBs3nmxoCdlCp4zDkkhOGyi2SGMw2v8GOttT/ZAZ+SxQ327YlML/g5Y", - "7XnGUOFV8Yu7HZDy29qFfQ2b3x23Y9UJg4RRK4W8JJSkOUOdVXClZZXq95yiVByc5Yip38v6w3rSc98k", - "rphF9CY31HtO0c1Ty8pR8+QCIlrwDwBeXVLVcglKd+SDBcB77loxTirONM5VmP1K7IaVINHePrMtC7oh", - "C5qjWvcbSEHmlW7fmBjLqLTRuqyJyUxDxOI9p5rkYDTQ14yfrHE4HzLoaYaDPhfytMbCLHoelsBBMZXE", - "XRI/2q/oLXbLXznPMSaW2M/WiGLGbwIeNxpayRL/9+5/HPxymPwvTX7bT57+296HT48/37vf+/Hh5++/", - "/3/tnx59/v7ef/xrbKc87LFIOwf50QsnTR69QJGhMS71YL8xi0PBeBIlspMVkIJxDNju0Ba5awQfT0D3", - "GjOV2/X3XK+5IaQzmrOM6suRQ5fF9c6iPR0dqmltREeB9Gv9EPOeL0VS0vQUPXqTJdOraj5LRbHnpei9", - "pagl6r2MQiE4fsv2aMn2VAnp3tmDHVf6FfgVibCrDpO9tEDQ9wfGo2PRZOkCXvHkLSpuiaJSzkiJwV/e", - "LyMW0zoC2mY+HhAMj11R71R0fz588t1k2oS11t+Npm6/foicCZatY8HLGaxjkpo7anjE7ihS0o0CHedD", - "CHvUBWX9FuGwBRgRX61YefM8R2k2j/NKH1LjNL41P+I21sWcRDTPbpzVRyxuHm4tATIo9SqWEdWSObBV", - "s5sAHZdKKcUZ8ClhM5h1Na5sCco7w3KgC8zMQROjGBMiWJ8DS2ieKgKshwsZpdbE6AfFZMf3P08nToxQ", - "1y7Zu4FjcHXnrG2x/m8tyJ0fX56QPcd61R0bR2+HDiKfI5YMF9zXcrYZbmbzQG0iwXv+nr+ABePMfD94", - "zzOq6d6cKpaqvUqBfEZzylOYLQU58PGCL6im73lPZhtM1Q4iNUlZzXOWktNQtm7I06bf9Ud4//4Xw/Hf", - "v//Q89z0JWE3VZS/2AmSc6ZXotKJyy9KJJxTmUVAV3V+CY5sswO3zTolbmzLil3+khs/zvNoWapunHl/", - "+WWZm+UHZKhcFLXZMqK0kF6qMaKOhQb3941wF4Ok5z45rVKgyMeClr8wrj+Q5H21v/8ISCvw+qMTHgxN", - "bkpo2bwuFQfftXfhwq2GBGstaVLSJajo8jXQEncfJe8Crat5TrBbK+DbB7TgUM0CPD6GN8DCceHgVVzc", - "se3lE8XjS8BPuIXYxogbjdPisvsVhIBfers6YeS9Xar0KjFnO7oqZUjc70ydP7o0Qpb3JCm25OYQuFTb", - "OZB0BekpZJj1B0WpN9NWd++sdCKrZx1M2exYG8CJKVxoHpwDqcqMOqGe8k03l0aB1j6B6B2cwuZENBlg", - "F0meaedyqKGDipQaSJeGWMNj68bobr5zfGP8eln6lAiMjfVkcVDThe8zfJCtyHsNhzhGFK1cgyFEUBlB", - "hCX+ARRcYqFmvCuRfmx5Rl+Z25svkkzreT9xTRo1zDmvw9VgCoX9XgCm2otzRebUyO3CZYnbfIWAi1WK", - "LmFAQg4ttCOzAlpWXRxk170XvenEonuh9e6bKMi2cWLWHKUUMF8MqaAy0wlZ8DNZJwCuYEaw+ItD2DxH", - "MamOlrBMh8qWpdxWsxgCLU7AIHkjcHgw2hgJJZsVVT6BHfP8/VkeJQN8wfybbVmXR4G3PUjmr3MqPc/t", - "ntOedulyL33Cpc+yDFXLERmTRsLHALDYdgiOAlAGOSztwm1jTyhNLlCzQQaOnxaLnHEgScxxT5USKbMV", - "CJprxs0BRj6+T4g1JpPRI8TIOAAbnVs4MHkjwrPJlxcBkrtcJurHRrdY8DfEwy5taJYReURpWDjjA0F1", - "ngNQF+1R31+dmCMchjA+JYbNndHcsDmn8TWD9JL/UGztpPo59+q9IXF2iy3fXiwXWpO9ii6zmlBm8kDH", - "BbotEM/FOrFx11GJd76eG3qPRqthFHjsYNo0yzuKzMUaXfZ4tWD9ErUDlmE4PBiBhr9mCukV+w3d5haY", - "bdNul6ZiVKiQZJw5ryaXIXFizNQDEswQudwNMicvBUDH2NHUGHPK704ltS2e9C/z5labNhUBfGBt7PgP", - "HaHoLg3gr2+FqXMd33Yllqidou15bqd5BiJkjOgNm+i7e/pOJQU5oFKQtISo5DTmBDS6DeCNc+y7BcYL", - "TCalfHMvCGeQsGRKQ2OONxez9y/dtHmSYg0LIRbDq9OlXJj1vROivqZskjR2bC3zxldwJjQkCyaVTtCX", - "EV2CafSDQqX6B9M0Liu1AyZsOSeWxXkDTnsKmyRjeRWnVzfv316Yad/ULFFVc+S3jBOg6YrMsfxYNIxq", - "y9Q20m7rgl/ZBb+i17becafBNDUTS0Mu7Tm+kXPR4bzb2EGEAGPE0d+1QZRuYZAo+7yAXMcy5AK5yR7O", - "zDScbbO+9g5T5sfeGYBioRi+o+xI0bUEBoOtq2DoJjJiCdNB9a5+1sfAGaBlybJ1xxZqRx3UmOmFDB6+", - "LEIHC7i7brAdGAjsnrHAYgmqXQGjEfBtHbZWAupsFGZO2nUqQoYQTsWUryLaR5QhbRQVd+HqBGj+N9j8", - "bNriciafp5OrmU5juHYj7sD123p7o3hGJ781pbU8IRdEOS1LKc5onjgD8xBpSnHmSBObe3v0DbO6uBnz", - "5OXhq7cO/M/TSZoDlUktKgyuCtuV38yqbLGNgQPiqxQanc/L7FaUDDa/rhAQGqXPV+AqwgXSaK90TeNw", - "CI6iM1Iv4rFGO03Ozjdil7jFRwJl7SJpzHfWQ9L2itAzynJvN/PQDsQF4eLG1T+KcoVwgCt7VwInWXKt", - "7KZ3uuOno6GuHTwpnGtLzbrClmVURPCuC92IkGiOQ1ItKBaesVaRPnPiVYGWhETlLI3bWPlcGeLg1ndm", - "GhNsPCCMmhErNuCK5RULxjLN1AhFtwNkMEcUmb6I0RDu5sLV0644+2cFhGXAtfkk8VR2DipW+nHW9v51", - "amSH/lxuYGuhb4a/iowRFl3q3ngIxHYBI/TU9cB9UavMfqG1Rcr8ELgkLuDwD2fsXYlbnPWOPhw12zDI", - "VdvjFpa/7vM/Qxi2VOLu2tteeXXVnwbmiNbSZipZSPEbxPU8VI8jWQe+zBTDKJffgM8iyVtdFlNbd5qS", - "4M3sg9s9JN2EVqh2kMIA1ePOB245rHfjLdSU2622pW1bsW5xggnjU/fs+A3BOJh7Mb05PZ/TWDEgI2QY", - "mA4bB3DLlq4F8Z097p3Zn7nKXzMS+JLrtszm45Ugm4Sgfu73JQUGO+1oUaGRDJBqQ5lgav1/uRKRYSp+", - "TrmtkGz62aPkeiuwxi/T61xIzKZVcbN/BikraB6XHLK0b+LN2JLZ+sCVgqAArRvIFla3VOSK+FoXe4Oa", - "owXZnwYlrt1uZOyMKTbPAVs8sC3mVCEnrw1RdRezPOB6pbD5wxHNVxXPJGR6pSxilSC1UIfqTe28moM+", - "B+BkH9s9eEruottOsTO4Z7Do7ufJwYOnaHS1f+zHLgBXCHwbN8mQnfyXYydxOka/pR3DMG436iyaG2pf", - "bxhmXFtOk+065ixhS8frdp+lgnK6hHikSLEDJtsXdxMNaR288MyWHldaig1hOj4/aGr400Acu2F/FgyS", - "iqJgunDOHSUKQ09NdVk7qR/O1jF3hcE8XP4j+khL7yLqKJE3azS191ts1ejJfkMLaKN1SqhNoc5ZE73g", - "yxWSI1+IASul1QXSLG7MXGbpKOZgMMOClJJxjYpFpRfJX0i6opKmhv3NhsBN5t89jlSHa1cp4hcD/Mbx", - "LkGBPIujXg6QvZchXF9ylwueFIajZPeavJHgVA46c+NuuyHf4fahxwplZpRkkNyqFrnRgFNfifD4lgGv", - "SIr1ei5Ejxde2Y1TZiXj5EErs0N/f/fKSRmFkLGyPM1xdxKHBC0ZnGHsXnyTzJhX3AuZj9qFq0D/dT0P", - "XuQMxDJ/lmOKwDMR0U59xcLaku5i1SPWgaFjaj4YMpi7oaakXR3u5p1+3vjcdz6ZLx5W/KML7FfeUkSy", - "X8HAJgaVK6PbmdXfA/83Jc/Eeuymdk6I39jfAWqiKKlYnv3c5Hd2CoNKytNV1J81Nx1/bZ4wqBdn76do", - "daMV5Rzy6HBWFvzVy4wRqfYfYuw8BeMj23ZrldrldhbXAN4G0wPlJzToZTo3E4RYbSe81QHV+VJkBOdp", - "Suk03LNf4zaoRPjPCpSOJQ/hBxvUhXZLo+/aQngEeIba4oz8aJ8gWwFpVfpALY0VVW6rRkC2BOkM6lWZ", - "C5pNiRnn5OXhK2JntX1sIW5biG+JSkp7FR17VVB3a1x4sK+pHU9dGD/O9lhqs2qlsfCO0rQoY2mmpsWJ", - "b4C5rKENH9WXEDsz8sJqjsrrJXYSQw8LJgujcdWjWdkFacL8R2uarlAla7HUYZIfX0HSU6UKXm2pq6/X", - "pbPw3Bm4XRFJW0NySoTRm8+Zsi9PwRm0M1vrNG9nEvCZru3lyYpzSylR2WNbGYLLoN0DZwM1vJk/ClkH", - "8RcUyG0B1osW1DzGXtFaNN3qnL3nWmx2Y11V278omFIuOEuxEkzsanavWI3xgY0omtM1svoj7k5o5HBF", - "a4LWYXIOi4NVQj0jdIjrG+GDr2ZTLXXYPzU+l7SimixBK8fZIJv60rbODsi4AlcKDR80C/ikkC2/InLI", - "qKs6qV0aFyQjTIsZUOx+MN/eOLUf48VPGUcB36HNhaZbSx0+sqONVsA0WQpQbj3t3GD1i+kzwzTZDNYf", - "Zv5RHhzDuuXMsq0Puj/UofdIOw+wafvctLVFUZqfWxHIdtLDsnSTDhc+jsoDes0HERzxLCbetRMgtx4/", - "HG0LuW0NJcH71BAanKEjGkq8h3uEURcB7hSYN0KrpShsQWwIV7QWAuMRMF4xDs2TUZELIo1eCbgxeF4H", - "+qlUUm1FwFE87QRojt7nGENT2rkerjpUZ4MRJbhGP8fwNjb1iwcYR92gEdwo39QvVRnqDoSJ5/hEnkNk", - "vxoxSlVOiMowo6BTnzjGOAzj9hXQ2xdA/xj0ZSLbXUtqT85FbqKhJNF5lS1BJzTLYjUkn+FXgl9JVqHk", - "AGtIq7oGX1mSFKurtMvN9KnNTZQKrqpiy1y+wRWnS0VMjn6DEyifMtEMPiPIfg3rffHy7buXzw9PXr6w", - "94UiqrJZokbmllAYhjgjR1xpMKJzpYB8DNH4Eft97Cw4DmZQlzxCtGFtdE+ImCsz3+C/sTp5wwTkYkUu", - "HK3oA0Ow44XF+/ZIPeHcHL1EsWUyHhN49V0dHc3UlzuPTf9rPZC5WLYBueEKFtuYcbhHMTb80txvYYGH", - "XvFHewPW9RcwNlD412RQu60zh9vME2/cXjVI9EnVr1Vst5MMvzsxxTt6IEI4qNtBrRhgnZxDccLpYFg7", - "1S7BTlOylVMOJi3ZICObnmQfTY4aeIcCi2xckfnc6z1OgO2pAzj2VoT6iLU+QH/z4bCkpMx58Btm0ces", - "C5wftmpuO3TNBncX4cLRBw2L8eL/wyV0mrI5eA2UQrGmYG3sVYCR4VInWNg/KAHUH8vHKpxBqo1QH/hg", - "JcBFCgKZyYI3TG5L6QyoH3VUmaugs61sTr808Q5m08tsCbKzbFnX2fgiMYd1pA36//EVkSVw94xIO2Z9", - "dOTsYgGpZmc7Mon+y2ipTZbK1Oux9jmwILGI1ZGY/pn2C6rXDUDbEn22whOUlrsyOEN5BKewuaNIixqi", - "dWannuddpgYBYgC5Q2JIRKiYJ9sa3pxzkamaMhALPnLEdoemmtNggf8gL+6Sc3mSJDTMldsy5ZmIae6j", - "5jJdL5RBikGFQ8lG/RLbw4LQC6xorurHWep32AOthhz1K72duxoImPdV25p9NQRQ/jef5Glnse/7N08Q", - "oGX/nMrMt4iqql4LTrbcR70MIV8eugv0op6ZNXF+/ZyQSO0gjOZMc6EYXyZDIbHt0LrwbVAMIMDrAGuX", - "I1wLkO7pETQh50JBooWPC9wGxzZUuHcsL4MENVivzwI3WEXjXVMmBCugUqyaQV1wRLhAo7dSA50MinkM", - "z7kN2c/td58E4StgjtDIHb0mO6tx+AhPpnpIDKl+QdxtuTu54jJaL+PcPkWlYpU9uEFlaD0upciq1F7Q", - "4cFobAxj6+ZsYSVRhTHtr7In++dYRepVkKp2Cps9K3+nK8qbcl7tY21FKLuGIDW8s9vXahCI6z750i5g", - "eS1wfk2lejophciTAXPxUb9ASfcMnLL0FDJi7g4fGzVQ5J/cRStl7Q88X218QY6yBA7ZvRkhRi0vSr3x", - "rsF2rd3O5PyO3jb/GmfNKlszyOn7s/c8HtaH1XzkFfmbH2Y7V1NgmN8Vp7KD7Ch/sR4ojiLpeeTJi7Ev", - "3kacdd1nCBqislDEpJRL5kKPOt99nT9C+kEd/u3aT1gqoYnBktZ0hNKSN+h0hZfXjUVo3IsAvsMO8EKl", - "OHgTwHMjB85XDpR6XSMlWMogJbSWv0vP9g8113wp2CKFkfVmmbZwjXWyt/clMKKo57VtIo7nvgkD6yII", - "jrVi+qYPhaZELDkbEo45l/KM5jdvvsCCGYeID/ewVXyhof4bItmiUl0uWuEVHTV3oOte39T8LZpb/gvM", - "HkVtwG4oZ0et32LwJSSxNBrNSS6aN1lwSHKOY1qj8YPvyNxFWpcSUqZYJwnl3FfDrNU9LA7dvHe2Xb/c", - "tc6fhb4CGTsFQZTkTVNZTwu8HxoImyP6lZnKwMmNUnmM+npkEcFfjEeFKc87rovTljXZVirtRHMICdds", - "VQ7c2Be0KveTuccuD9eBl06loL/O0bd1C7eRi7pZ21iXSB+528qvjfFkxKsqmu7oSrEIwZKkBEElHx98", - "JBIW+OaAIPfv4wT3709d048P25/Ncb5/PyrG3ZgTpfU0uJs3RjE/D0X/2Qi3gUDTzn5ULM92EUYrbLh5", - "/wMDY391iQNf5QWSX609tX9UXe32i7hvu5uAiImstTV5MFUQEDwiFth1m0Ufb1eQVpLpDdYz8OY39mu0", - "TtSPtcXeeXzqDFh392lxCnVFjMa+Xyl/u/4o7GPvhZGp0Xmu8TG4l2talDm4g/L9nfm/w6O/PM72Hz34", - "9/lf9p/sp/D4ydP9ffr0MX3w9NEDePiXJ4/34cHiu6fzh9nDxw/njx8+/u7J0/TR4wfzx989/fc7hg8Z", - "kC2gE589N/lvfKYnOXx7lJwYYBuc0JLVb0AaMvYvBNAUTyIUlOWTA//T//EnbJaKohne/zpxyTmTldal", - "OtjbOz8/n4Vd9pZo0Eu0qNLVnp+n//be26M6wNomfOOO2thZQwq4qY4UDvHbu5fHJ+Tw7dGsIZjJwWR/", - "tj97gC9rlcBpySYHk0f4E56eFe77niO2ycGnz9PJ3gpojv4v80cBWrLUf1LndLkEOXNPJZifzh7ueVFi", - "75MzZn42oy5jlR5sqHgQH9x/QcA5RjDexoaCtyryKlcgdlrXaXa2Bp5hBK+1DxrWViPrKGsKEh41jMqX", - "ZbB1qg5+iTxFtWDLSnZera2jCFwRd6bIfx7/9IYISZxK85amp2GULBLkPyuQm4ZgHCsLCyz5mroulrZQ", - "y7IdeNaISbH3LWNPMeDMZp8DSq39Cg0n0rKCEJKGrxpeuZ88/fDpyV8+T0YAgk4uBZh++5Hm+Uf7rDCs", - "0VPgC1i4BOVppH4sisfTxk6NHZptmmLkXP01fCKgbtOO1/7IBYePQ9vgAIvuA81z01BwiO3BB0wQRUrA", - "Q/Rwf//a3hapUxRs/F09iieJSwzU5zD2U+ThQf/EyMCrg4+vcaHtyJ0rL7c7XG/Rz2iGZdtBabuUB9/s", - "Uo44+pkNxyf2Rvs8nTz5hvfmiBueQ3OCLYPqC/1b5O/8lItz7lsaaaYqCio3KKsEb0t00p/oUqHJElmk", - "PdutavKTD58Hr7S9sFj23qeWqzK70oXXeyfg6MWOO/COGuKc/dplnVrc5ntdahmdWa7gOBZ/Vvdm5Mew", - "N3JvTAW2ibaV5M1rvKUUZywzfNhFefiKKQ1sd1SYJR29kQP77+3l/EUv58O2aaJV/CoGTIvEt8LUi2W4", - "6u3YD2HvPKV0qaeKgpLXlygc+kXfc+hohoMP5I/gwre4G8DdkAwUwFuLQ+1S5V+e71olL7gmWvfBF+TK", - "37hE95rmhk6C5XbS6WxFuFtJ708j6dXhbfZFRF8E9WqyHz6HsPfJV/m7BnnPVTkcIemFOnPQN6hCd7fD", - "Tu7NbMm+sM3leIaLZ9spw2HtxVvp7UtLb/2ipTEwmlKUX09iQxhWTVXTi7xV2HqE5ELVV79REe1PjKxB", - "mcxAulsauwRv7ElajhN/MZ75h5SwHNJuZas/tWxVh5BfSbpqlR12SQmBd+lKdreuXY3pWsxqpxEEnK1+", - "5NEd4WnzRIJhMVi1wmcCq6lX+9CzaTVCu1nTnlLYl59+hFD7fLY5erFLdPqGjDijqydFboH43nxpXhp1", - "GLy7GYfBON70eP/xzUEQ7sIbockPeIt/YQ75RVlanKwuysK2caS9ua3ruI0r8Q5bQkbR1GsMeBSWxQ5r", - "QtpAibvuMbKwLuC9GfHVI1VdC9ul5i4FzZsqFlQubSfD4wwSyB3/5wGOf2dGfhCSMK6VLTShXaFkcodx", - "ffDg4aPHromk5zacqttu/t3jg8Pvv3fNmlqhVr/pNVdaHqwgz4Xr4O6G/rjmw8F//8//zmazOzvZqVg/", - "27yxhXl+Lzy1r9aFGz+0W9/4JsW0dFcwaSfqbsTh/kyso9xfrG9vn692+xjs/yFunXmbjJwCWpsnW6mo", - "13gL2WNykXto6mtvGr5TXyYz8ka4qgBVTiURMgPpHg9YVlRSrgGymadUssD0X8yCTnMGXBuFEcuhy0Sx", - "DGwy5bKSkJGcFfheoIQzDFPH6VGXb0Gwm9FjMOvvlsm/puvwoef6mtbCLRnzrgu69g8yYMlxIfGn778n", - "+9NGa8lzM0BSIybGXAu6ntygta8mtlEh4O2ayTtjZHHsMZajRvqxb9/QdoHWPzfn/mYldkvubmOviXNe", - "2JvTeGtC+4HLvd9qObCCnX2uAd8P2JA6N9ZIeV6EirM4M8NYo8Dv2Dew0yQdVT676L09xLfK/5VYSZeg", - "Lsg2MPFT7X1CX0bIM3rnFhPX/kA+0MAhJEXhPUKCLECnK5cQ28FrhPf4cszDjGfbY1zXLbLgFvWrgYZ1", - "zfCRqJGJ8kGuInrlQEYo9CdfctB8Zgssd1CX2vZvzqG/iflnWOoXWNw7VUz58HqfN2t28UJQPm8m70tb", - "iJbrcGreIvhiCO5xvpf+uQ/EmFvEHyEA3+uJCXkjmrRsV2n6j+hP/JLX9pde0BvBwTrOjVhrafHWR1rL", - "FGifR6T4ehxWOZH1q+CXlS/2/MM1W4WMv9pnY7YKGmNubzPZN3mF/zX6JGTrljFrm+0sNtCMNoY5m4a2", - "tmq7qupXVFG+Cj/9HeotX4Nj3QyLwUPq+YwTC/j1Mh0scWOJea8uqDnEgeI1ikdzIy3q2LJoWeE55IIv", - "1e+TFW2jjjheIlRSV2+Ol2j+853d51g9hwtfqNLVU1KMp2AfZvJv8xZMKRcB+Xj/LzcHoWaFr0HHw1TS", - "r8xdnuw/urnpj0GesRTICRSlkFSyfEP+zutHtK7C7bAAdV3fzJt6ozXH0ZXUrruVhkWCLs8EW/Fon/Sa", - "ZZ93M8OgRt4F+SDjAR8M6x7SsgQqL88Ad/ulTjozHr0IQ35bdZHrilURUAyKLhj1/m+TkXYnzEIXC3f5", - "VdwC6qtrOTbh4nHFYlpHvhgpQCwOyHt+n6gVffLg4a8Pn3zn/3z45LsBy5mZxxXF6dvOmoHMZzvMGAPa", - "79fWd70ieY28g5veyovt0HTCsnW0CGrz0EF4LlxgDvKJO4qUdDNYO7nc8VBDOGzzaMPNVwpUms3j7+l7", - "3aZ+DfCIP6tVXFvOzr1vcPtAw0C6Q8BEDKE1LzXUWN/+aMMWUbFDlnV1/JvWPJu0AHuLeeTJzoXyVaVY", - "/bU00AQVUOBeammj5esJjFiodxo4quv3VTHqpCpLIXV9utVslCwHQw63lig3RLgXktRSqtNVVe59wv9g", - "eazPTaqAfWN4z/rZtwlrx7bFFe++jlRsvfuyzYR8RTbn+xcL8pqlUhxinWd3raiN0lD0yua5rr9ue702", - "egUJnjMOSSF4rJjbT/j1NX6MVpIWmuZDnU/Mx6G+3ffwW/B3wGrPM4YDXhW/vxN9+kp2oM5qJZjj2jzO", - "Y+n/gkeq9d5Pc5ZaP+99av3pYmZcS7WqdCbOg76ok1kOMsZdHpSMHm/KrtWUTullRTJQhgS/PbtRgIcY", - "/ddfIzW7gsLgg2W7/qSWpAXjWYdIUA5MxRlIVdsYpA9vuTUn/XHMSaP3/UIc0xag3MXRKnW98sUbkYEd", - "t13zNZaeyUUGrk5mX6yoJae4lu7vmKZdR29KabVcaVKVRIuYhtZ0TGhqmax9EUztekLJtvJPhZwBobkE", - "mm3IHIATMTeLbj9FR6jC0HSv5jn5MP4SUANXKUUKSkGW1G/L7wCtrj6KSqHegicEHAGuZyFKkAWVlwTW", - "CkrbAbUBphFw6zgXJwv1oR43/bYN7E4ebiOVQPxVi1YeUZQ5ODtPBIUjcYJmCPaF989Pctntq8rE8PfI", - "W1b26wkr8KbmlAsFqeCZGn5xbtexxVcVgrUos4LgpEQffjcDD6gXr6jS75x9OnyYJ3i9wUyx5Ym8ocrh", - "ZuSf67rhvbFTwy+5qlRdXNyppZDF1sBhvWWuN7Cu50IHgR+71nu1IJWCXSMPYSkY3yFLhW/e6cCyj28r", - "9BeHNSaoU0f7qGwB0SBiGyDHvlWA3dDqPAAIvjhehgqFe2CpgWsuRA6UW/OhKEtz/nRS8brfEJqObetD", - "/fembZ+43PsuyNczASq0STjIzy1mFQbRr6giDg5S0FNntli6Gjx9mM1hTNCXmGyjfHMsj02r8AjsOKRd", - "1Tc8/q1z1jkcHfqNEt0gEezYhaEFx5TtbzJHpevL+IJRGG1jQyBezS4jOu6dU6aThZDupVS60CAjmnKn", - "tjZl2qfAWKuiFs5HSHAEx3XcOO7FzSaP3D2WZkEg/pE3VkTKUpipfhByVBx7O6CDMk0qrlke5PLVgujv", - "Tx2/FbFvRexbEftWxL4VsW9F7FsR+1bE/tIi9tcKDU88n/YxNVzwhMOSanYGdcz4bar6HyqUsj7pXuRH", - "JcGI6K7w0xVjxzXQHFfNcryBS6EGc+jxvT4lKpkCSQ1MjJMyp0ZkgrWuC4+0S1r5InvuxT6skkUVPHpI", - "jv966MPAVi5cqd327qErVqn0Jod7LvuvflLLpwECN2h2WYDUq0i+QIkr18JyIMog9CW2fgFnkBtx30aY", - "EKOw9FWoE6D5c4ebHRpU69EkM9rHaUtxc2graBm8TIprpYpQDBnsvHm0oLkafvTIjlfQMlYjpGbmVrdC", - "/vFMZJvOmTC7tocb2D4NTTAY41RuIlGevTPQIw0tDIdyhNVXDj9fe8hin2j7ZLaLwuJPjavoyd1G5dFY", - "vXrDekPZeNFFh06iL/51A9QmNYBjwi8MPfs9Ie9sv6+b7YQQuSPWsO/fjZ+73bJmGtjWSF2O9XyrqUke", - "8dHTi2d/agg7q1LAR9R91OPu62U6WSdmpCXwxDGgZC6yTdJiX5PWLZQxRZWCYr77Jgr5p6uK5y4f82X7", - "PfV1rpEXweK28eSQaNaJY8AD3NmG6o7jzTW2cETHngOMf2kWPcRGQxCI408xLbxbi/yCTK+ZZnPL+G4Z", - "X3AaOxIB4y5KvMtEZl+Q8cmNrPgwz3u5hrQywIUn+a66Z/gaon2tW46CDObVconV/XpGb7M0wPGaV+9v", - "mhXa5Y7lghejIDt4XfHpqnUIusP1uUsQEX1XSLKUoirv2WcM+AbtqUVJ+cb7UCBRrKhyi0NbO+V6Ga0N", - "5I49Y+1tecNmwLfe2hcYu9xV2/7dooWcU+WeM4aMVDxzcau9dI81H19Z0A59suYNm95aW9CuN7I6N++Y", - "K8LvsgvJrP1GJchEr7k9UO3ynzatxJ7c2W1Vsz/HtfHWPhcywGD7KRINQ7im20MGfA2vjyDLtQndbr/F", - "YF+KGQp0DFNebctr9cb2hm87ZYN3WqxTCfKSUF9yNhVcaVml+j2naNQOFjbrO2y9qX6Yvz33TeJ+lYjb", - "ww31nlOsSFqbuqN8bgERJ9YPAJ6Nqmq5BGV4ZUgkC4D33LVinFTcaFpiQQqWSpHYJAhzhox8MrMtC7oh", - "C5qjV+Y3kILMzc0e7Lo1ESvN8tx5iM00RCzec6pJDlRp8poZLmuG81bEOjQC9LmQpzUW4kmS7sH5JG58", - "+dF+xTxEt3xv5EODpf3c5A/dbAKih51lg5AfvTBwU8ynzpnSjW+4B/uNOQwLxpMokZ2sgLgYiy5tkbuG", - "8XoCutd4md2uv+fmhtOCIFen+nLk0HXs9M6iPR0dqmltRMf/49f6IVa0bSkSI8fRpfl9yfSqms9SUez5", - "Ym57S1EXdtvLKBSC47dsj5ZsT5WQ7p092CHOXYFfkQi7unXL/IFSEgI6MKel3niset7d+ws6ZLY+pBT7", - "6spb+Eb2wKE4YOCGtJJMb9BlQUv26ymY/3/4/MF8k2fem1HJfHIwWWldHuzt4RNIK6H03uTzNPymOh8/", - "1Ev75B0TpWRnWDTxw+f/HwAA///UWJys6SIBAA==", + "KqVIQSmj31utbSdovp0lS70FTwg4AlzPQpQgCyqvDOzp2U44T2GToIdVkbt/+1nd+wrwaqFpvgOx2CaG", + "3lqFcB6GPtTjpt9GcN3JQ7KjEojnfUZfMQwiBw1DKLwQTgb3rwtRbxevjpYzkGjr/6IU7ye5GgHVoH5h", + "er8qtFU5EDfkROcTVqAliFMuFKSCZyo6WE6VTnaxZdOoJd+bFQScMMaJceABa+QrqrT1TzGeoVptrxOc", + "x5opzRTDAA+KOGbkn7100x87NfcgV5WqRR1VlaWQGrLYGjist8z1Btb1XGIRjF3LU1qQSsGukYewFIzv", + "kGVXYhFEdW3GdQ7c/uLQ2Gnu+U0UlS0gGkRsA+TYtwqwG8ZODADCVINoSzhMdSinDtiYTpQWZWm4hU4q", + "XvcbQtOxbX2o/9607RMX1c29nQkws2sPk4P83GLWRs2sqFHKcGRS0FMje6CKZR1pfZjNYUwU4ykk2yjf", + "HMtj0yo8AjsO6YB26+Lygtk6h6NDv1GiGySCHbswtOABVfstlZqlrERJ8W+wuXbBuTtB1ABMMtCUGfUv", + "+GCF6DLsT6xntDvm5QTpUVpRH/yeWhRZTs4UXhht4E9hg56gtzbk5iQI1LkGTSAyqjndlBME1DvyjQAT", + "NoE1TXW+MdecXsGGnIMEoqp5wbS2MVRtRUGLMgkHiFqctszozKs2XMXvwBh77zEOFSyvvxXTiZWotsN3", + "0hGrWuhwklQpRD7C09ZDRhSCUZ44Ugqz68yF7Pm4Lk9JLSCdEIO29Zp53lEtNOMKyP+IiqSUo8Baaahv", + "BCGRzeL1a2YwF1g9p/O5NRiCHAqwcjh+uX+/u/D7992eM0UWcO7jXE3DLjru30ct+K1QunW4rsEEY47b", + "UYS3oynOXBROhuvylN0+HzfymJ182xm8tt+ZM6WUI1yz/CszgM7JXI9Ze0gj4/xdOO4oK1swdGzduO8Y", + "cPBlbDTN0DHo+hMHbtrm45Cn1shX+eYa+LQdiEgoJSg8VaFeouxXsQhDod2xUxuloeibbmzXXwcEm3de", + "LOhJmYLnjENSCA6baPYP4/AaP8Z625M90Bl57FDfrtjUgr8DVnueMVR4Vfzibgek/LYOUbiGze+O27Ha", + "hUHgqJVCXhJK0pyhziq40rJK9XtOUSoOznLEleNl/WE96blvElfMInqTG+o9p+jGq2XlqPl5AREt+AcA", + "ry6parkEpTvywQLgPXetGCcVZxrnKsx+JXbDSpDoT5nZlgXdkAXNUa37DaQg80q3b0yMVVXaaF3WhGim", + "IWLxnlNNcjAa6GvGT9Y4nA8J9TTDQZ8LeVpjYRY9D0vgoJhK4i6nH+1XjAZwy1+5yABMHLKfrdHJjN8E", + "tG40tJJh/u/d/zj45TD5X5r8tp88/be9D58ef753v/fjw8/ff///2j89+vz9vf/419hOedhjkZQO8qMX", + "Tpo8eoEiQ2N16sF+YxaHgvEkSmQnKyAF4xiQ36EtctcIPp6A7jVmPbfr77lec0NIZzRnGdWXI4cui+ud", + "RXs6OlTT2oiOAunX+iEWHbEUSUnTU/TYTpZMr6r5LBXFnpei95ailqj3MgqF4Pgt26Ml21MlpHtnD3Zc", + "6VfgVyTCrjpM9tICQd/fG49+RoOqC2jGk7eouCWKSjmjLgb3eb+bWEzrCHeb2XpAMPx5Rb3T2P358Ml3", + "k2kTtlx/N5q6/fohciZYto4Fp2ewjklq7qjhEbujSEk3CnScDyHsURej9UuFwxZgRHy1YuXN8xyl2TzO", + "K33IlNP41vyI21gmcxLRPLtxVh+xuHm4tQTIoNSrWMZbS+bAVs1uAnRcZqUUZ8CnhM1g1tW4siUo7+zM", + "gS4w8wpNjGJMCGh9DiyheaoIsB4uZJRaE6MfFJMd3/88nTgxQl27ZO8GjsHVnbO2xfq/tSB3fnx5QvYc", + "61V3bJ6EHTqIbI9YMlzwZsuZariZzfO1iSLv+Xv+AhaMM/P94D3PqKZ7c6pYqvYqBfIZzSlPYbYU5MDH", + "g76gmr7nPZltMBU/iMQlZTXPWUpOQ9m6IU+bXtkf4f37XwzHf//+Q8+v1JeE3VRR/mInSM6ZXolKJy5/", + "LJFwTmUWAV3V+UM4ss3+3DbrlLixLSt2+Wlu/DjPo2WpunkE/eWXZW6WH5ChclHyZsuI0kJ6qcaIOhYa", + "3N83wl0Mkp775MNKgSIfC1r+wrj+QJL31f7+IyCtwPqPTngwNLkpoWXzulSeQ9fehQu3GhKstaRJSZeg", + "osvXQEvcfZS8C7Su5jnBbq2Afh+whEM1C/D4GN4AC8eFg5Nxcce2ly8EEF8CfsItxDZG3GicFpfdryDE", + "/9Lb1UkT6O1SpVeJOdvRVSlD4n5n6vzgpRGyvCdJsSU3h8ClUs+BpCtITyHDrE4oSr2Ztrp7Z6UTWT3r", + "YMpmP9sAXUzRQ/PgHEhVZtQJ9ZRvurlSCrT2CWLv4BQ2J6LJ8LtIclQ7V0cNHVSk1EC6NMQaHls3Rnfz", + "nUcc8xPK0qe8YOyzJ4uDmi58n+GDbEXeazjEMaJo5ZIMIYLKCCIs8Q+g4BILNeNdifRjyzP6ytzefJFk", + "ac/7iWvSqGHOeR2uBlNk7PcCsJSCOFdkTo3cLlwVAJuPEnCxStElDEjIoYV2ZNZHy6qLg+y696I3nVh0", + "L7TefRMF2TZOzJqjlALmiyEVVGY6IQt+JusEwBXMCBb3cQib5ygm1bEdlulQ2bKU22olQ6DFCRgkbwQO", + "D0YbI6Fks6LKFyjAOg7+LI+SAb5gftW2rNqjwNseFGuoc2Y9z+2e05526XJrfUKtz6INVcsRGbFGwscA", + "v9h2CI4CUAY5LO3CbWNPKE2uV7NBBo6fFouccSBJzHFPlRIpsxUmmmvGzQFGPr5PiDUmk9EjxMg4ABud", + "WzgweSPCs8mXFwGSu1w16sdGt1jwN8TDam0omxF5RGlYOOMDQZOeA1AX7VHfX52YIxyGMD4lhs2d0dyw", + "OafxNYP0kjtRbO2kcjr36r0hcXaLLd9eLBdak72KLrOaUGbyQMcFui0Qz8U6sXH1UYl3vp4beo9G92GU", + "f+xg2jTaO4rMxRpd9ni12GiyHbAMw+HBCDT8NVNIr9hv6Da3wGybdrs0FaNChSTjzHk1uQyJE2OmHpBg", + "hsjlbpAZeykAOsaOpoacU353Kqlt8aR/mTe32rSp+OADp2PHf+gIRXdpAH99K0ydy/q2K7FE7RRtz3M7", + "jTcQIWNEb9hE393TdyopyAGVgqQlRCWnMSeg0W0Ab5xj3y0wXmCyMOWbe0E4g4QlUxoac7y5mL1/6abN", + "kxRrlAixGF6dLuXCrO+dEPU1ZZPgsWNrmTe+gjOhIVkwqXSCvozoEkyjHxQq1T+YpnFZqR0wYct1sSzO", + "G3DaU9gkGcurOL26ef/2wkz7pmaJqpojv2WcAE1XZI7l5aJhVFumtpF2Wxf8yi74Fb229Y47DaapmVga", + "cmnP8Y2ciw7n3cYOIgQYI47+rg2idAuDRNnnBeQ6lgEZyE32cGam4Wyb9bV3mDI/9s4AFAvF8B1lR4qu", + "JTAYbF0FQzeREUuYDqqz9bN6Bs4ALUuWrTu2UDvqoMZML2Tw8GUvOljA3XWD7cBAYPeMBRZLUO0KJ42A", + "b+vstRKMZ6Mwc9KuQxIyhHAqpnyV2D6i6sSDXbg6AZr/DTY/m7a4nMnn6eRqptMYrt2IO3D9tt7eKJ7R", + "yW9NaS1PyAVRTstSijOaJ87APESaUpw50sTm3h59w6wubsY8eXn46q0D//N0kuZAZVKLCoOrwnblN7Mq", + "W0xl4ID4KpRG5/MyuxUlg82vK0CERunzFbiKf4E02itN1DgcgqPojNSLeKzRTpOz843YJW7xkUBZu0ga", + "8531kLS9IvSMstzbzTy0A3FBuLhx9a2iXCEc4MrelcBJllwru+md7vjpaKhrB08K59pSk7CwZTcVEbzr", + "QjciJJrjkFQLioWFrFWkz5x4VaAlIVE5S+M2Vj5Xhji49Z2ZxgQbDwijZsSKDbhiecWCsUwzNULR7QAZ", + "zBFFpi9SNYS7uXD10ivO/lkBYRlwbT5JPJWdg4qVnJy1vX+dGtmhP5cb2From+GvImOERbW6Nx4CsV3A", + "CD11PXBf1CqzX2htkTI/BC6JCzj8wxl7V+IWZ72jD0fNNgxy1fa4heXN+/zPEIYthbm7trpXXl11r4E5", + "orXSmUoWUvwGcT0P1eNI1oEvI8YwyuU34LNI8laXxdTWnabkezP74HYPSTehFaodpDBA9bjzgVsO6xl5", + "CzXldqtt6eJWrFucYML41D07fkMwDuZeTG9Oz+c0VuzJCBkGpsPGAdyypWtBfGePe2f2Z66y24wEvuS6", + "LbP5eCXIJiGon9t/SYHBTjtaVGgkA6TaUCaYWv9frkRkmIqfU24rYJt+9ii53gqs8cv0OhcSs2lV3Oyf", + "QcoKmsclhyztm3gztmS2/nOlICgw7AayhfMtFbkizdbF3qDmaEH2p0EJc7cbGTtjis1zwBYPbIs5VcjJ", + "a0NU3cUsD7heKWz+cETzVcUzCZleKYtYJUgt1KF6Uzuv5qDPATjZx3YPnpK76LZT7AzuGSy6+3ly8OAp", + "Gl3tH/uxC8AVet/GTTJkJ//l2EmcjtFvaccwjNuNOovmhtrXOYYZ15bTZLuOOUvY0vG63WepoJwuIR4p", + "UuyAyfbF3URDWgcvPLOl5ZWWYkOYjs8Pmhr+NBDHbtifBYOkoiiYLpxzR4nC0FNTPdhO6oezdepd4TcP", + "l/+IPtLSu4g6SuTNGk3t/RZbNXqy39AC2midEmpTqHPWRC/4cpTkyFdowEp4dQE8ixszl1k6ijkYzLAg", + "pWRco2JR6UXyF5KuqKSpYX+zIXCT+XePI9X/2lWo+MUAv3G8S1Agz+KolwNk72UI15fc5YInheEo2b0m", + "byQ4lYPO3Ljbbsh3uH3osUKZGSUZJLeqRW404NRXIjy+ZcArkmK9ngvR44VXduOUWck4edDK7NDf371y", + "UkYhZKzsUnPcncQhQUsGZxi7F98kM+YV90Lmo3bhKtB/Xc+DFzkDscyf5Zgi8ExEtFNfkbK2pLtY9Yh1", + "YOiYmg+GDOZuqClpV/+7eaefNz73nU/mi4cV/+gC+5W3FJHsVzCwiUFl0uh2ZvX3wP9NyTOxHrupnRPi", + "N/Z3gJooSiqWZz83+Z2dwq+S8nQV9WfNTcdfmycq6sXZ+yla3WhFOYc8OpyVBX/1MmNEqv2HGDtPwfjI", + "tt1atHa5ncU1gLfB9ED5CQ16mc7NBCFW2wlvdUB1vhQZwXmaUjoN9+zXMA4qTf6zAqVjyUP4wQZ1od3S", + "6Lu20CEBnqG2OCM/2ifmVkBalT5QS2NFlduqEZAtQTqDelXmgmZTYsY5eXn4ithZbR9baN0WWlyiktJe", + "RcdeFVQJGxce7Gumx1MXxo+zPZbarFppLLyjNC3KWJqpaXHiG2Aua2jDR/UlxM6MvLCao/J6iZ3E0MOC", + "ycJoXPVoVnZBmjD/0ZqmK1TJWix1mOTHVwj1VKmCV3nq6vp16Sw8dwZuVyTU1gidEmH05nOm7MticAbt", + "zNY6zduZBHyma3t5suLcUkpU9thWhuAyaPfA2UANb+aPQtZB/AUFcltg96IFU4+xV7QWTbf6au85Hpvd", + "WFdN9y9GppQLzlKsBBO7mt0rZWN8YCOK5nSNrP6IuxMaOVzRmq91mJzD4mAVWM8IHeL6Rvjgq9lUSx32", + "T43PYa2oJkvQynE2yKa+dLGzAzKuwJVCwwfrAj4pZMuviBwy6qpOapfGBckI02IGFLsfzLc3Tu3HePFT", + "xlHAd2hzoenWUoePKGmjFTBNlgKUW087N1j9YvrMME02g/WHmX90CcewbjmzbOuD7g916D3SzgNs2j43", + "bW1RlObnVgSynfSwLN2kw4Wto/KAXvNBBEc8i4l37QTIrccPR9tCbltDSfA+NYQGZ+iIhhLv4R5h1EWe", + "Ow8IGKHVUhS2IDaEK1oLgfEIGK8Yh+ZJsMgFkUavBNwYPK8D/VQqqbYi4CiedgI0R+9zjKEp7VwPVx2q", + "s8GIElyjn2N4G5v61AOMo27QCG6Ub+qXyAx1B8LEc3wC0SGyX20apSonRGWYUdCpPx1jHIZx+wr37Qug", + "fwz6MpHtriW1J+ciN9FQkui8ypagE5plsRqSz/Arwa8kq1BygDWkVV2DryxJitVV2uVm+tTmJkoFV1Wx", + "ZS7f4IrTpSImR7/BCZRPmWgGnxFkv4b1vnj59t3L54cnL1/Y+0IRVdksUSNzSygMQ5yRI640GNG5UkA+", + "hmj8iP0+dhYcBzOoOx8h2rD2vSdEzJWZb/DfWJ28YQJysSIXjlb0gSHY8cLifXuknnBujl6i2DIZjwm8", + "+q6Ojmbqy53Hpv+1HshcLNuA3HAFi23MONyjGBt+ae63sMBDr/ijvQHr+gsYGyj8a0Go3daZw23miTdu", + "rxok+qTq10i220mG3xWZ4h09ECEc1O2gVgywTs6hOOF0MKydapdgpynZyikHk5ZskJFNT7KPYkcNvEOB", + "RTauyHzu9R4nwPbUARx7K0J9xFofoL/5cFhSUuY8+A2z6GPWBc4PWzW3Hbpmg7uLcOHog4bF+OMOwyV0", + "mrI5eA2UQrGmYG3s1YeR4VIn+HBDUAKoP5aPVTiDVBuhPvDBSoCLFAQykwVv1NyW0hlQP+qoMldBZ1vZ", + "nH5p4h3MppfZEmRn2bKus/FFYg7rSBv0/+MrMUvg7pmYdsz66MjZxQJSzc52ZBL9l9FSmyyVqddj7XNv", + "QWIRqyMx/TP8F1SvG4C2JfpshScoLXdlcIbyCE5hc0eRFjVE68xOPc+7TA0CxAByh8SQiFAxT7Y1vDnn", + "IlM1ZSAWfOSI7Q5NNafBAv9BXtwl5/IkSWiYK7dlyjMR09xHzWW6XiiDFIMKh5KN+iW2hwWhF1jRXNWP", + "79Tv7AdaDTnqV3o7dzUQMO+rtjX7agig/G8+ydPOkrNTCJ8gQMv+OZWZbxFVVb0WnGy5j3oZQr48dBfo", + "RT0za+L8+jkhkdpBGM2Z5kIxvkyGQmLboXXh268YQIDXAdYuR7gWIN1TLWhCzoWCRAsfF7gNjm2ocO+U", + "XgYJarBenwVusIrGu6ZMCFZApVg1g7rgiHCBRm+lBjoZFPMYnnMbsp/b7z4JwlfAHKGRO3pNdlbj8BGe", + "TPWQGFL9grjbcndyxWW0Xsa5fWpMxSp7cIPK0HpcSpFVqb2gw4PR2BjG1s3ZwkqiCmPaX2VP9s+xitSr", + "IFXtFDZ7Vv5OV5Q35bzax9qKUHYNQWp4Z7ev1SAQ133ypV3A8lrg/JpK9XRSCpEnA+bio36Bku4ZOGXp", + "KWTE3B0+NmqgyD+5i1bK2h94vtr4ghxlCRyyezNCjFpelHrjXYPtWrudyfkdvW3+Nc6aVbZmkNP3Z+95", + "PKwPq/nIK/I3P8x2rqbAML8rTmUH2VH+Yj1QHEXS88iTF2NfNI4467rPEDREZaGISSmXzIUedb77On+E", + "9IM6/Nu1n7BUQhODJa3pCKUlb9DpCi+vG4vQuBcBfIcd4IVKcfAmgOdGDpyvHCj1ukZKsJRBSmgtf5ee", + "7R/irvlSsEUKI+vNMm3hGutkb+9LYERRz2vbRBzPfRMG1kUQHGvF9E0fCk2JWHI2JBxzLuUZzW/efIEF", + "Mw4RH+5hq/hCQ/03RLJFpbpctMIrOmruQNe9vqn5WzS3/BeYPYragN1Qzo5av8XgS0hiaTSak1w0b7Lg", + "kOQcx7RG4wffkbmLtC4lpEyxThLKua+GWat7WBy6ee9su365a50/C30FMnYKgijJm6aynhZ4PzQQNkf0", + "KzOVgZMbpfIY9fXIIoK/GI8KU553XBenLWuyrVTaieYQEq7Zqhy4sS9oVe4nc49dHq4DL51KQX+do2/r", + "Fm4jF3WztrEukT5yt5VfG+PJiFdVNN3RlWIRgiVJCYJKPj74SCQs8M0BQe7fxwnu35+6ph8ftj+b43z/", + "flSMuzEnSuvpdzdvjGJ+Hor+sxFuA4Gmnf2oWJ7tIoxW2HDz/gcGxv7qEge+ygskv1p7av+outrtF3Hf", + "djcBERNZa2vyYKogIHhELLDrNos+zq8grSTTG6xn4M1v7Ndonagfa4u98/jUGbDu7tPiFOqKGI19v1L+", + "dv1R2Mf8CyNTo/Nc42NwL9e0KHNwB+X7O/N/h0d/eZztP3rw7/O/7D/ZT+Hxk6f7+/TpY/rg6aMH8PAv", + "Tx7vw4PFd0/nD7OHjx/OHz98/N2Tp+mjxw/mj797+u93DB8yIFtAJz57bvLf+ExPcvj2KDkxwDY4oSWr", + "34A0ZOxfCKApnkQoKMsnB/6n/+NP2CwVRTO8/3XiknMmK61LdbC3d35+Pgu77C3RoJdoUaWrPT9P/+29", + "t0d1gLVN+MYdtbGzhhRwUx0pHOK3dy+PT8jh26NZQzCTg8n+bH/2AF/WKoHTkk0OJo/wJzw9K9z3PUds", + "k4NPn6eTvRXQHP1f5o8CtGSp/6TO6XIJcuaeSjA/nT3c86LE3idnzPxsRl3GKj3YUPEgPrj/goBzjGC8", + "jQ0Fb1XkVa5A7LSu0+xsDTzDCF5rHzSsrUbWUdYUJDxqGJUvy2DrVB38EnmKasGWley8WltHEbgi7kyR", + "/zz+6Q0RkjiV5i1NT8MoWSTIf1YgNw3BOFYWFljyNXVdLG2hlmU78KwRk2LvW8aeYsCZzT4HlFr7FRpO", + "pGUFISQNXzW8cj95+uHTk798nowABJ1cCjD99iPN84/2WWFYo6fAF7BwCcrTSP1YFI+njZ0aOzTbNMXI", + "ufpr+ERA3aYdr/2RCw4fh7bBARbdB5rnpqHgENuDD5ggipSAh+jh/v61vS1SpyjY+Lt6FE8Slxioz2Hs", + "p8jDg/6JkYFXBx9f40LbkTtXXm53uN6in9EMy7aD0nYpD77ZpRxx9DMbjk/sjfZ5OnnyDe/NETc8h+YE", + "WwbVF/q3yN/5KRfn3Lc00kxVFFRuUFYJ3pbopD/RpUKTJbJIe7Zb1eQnHz4PXml7YbHsvU8tV2V2pQuv", + "907A0Ysdd+AdNcQ5+7XLOrW4zfe61DI6s1zBcSz+rO7NyI9hb+TemApsE20ryZvXeEspzlhm+LCL8vAV", + "UxrY7qgwSzp6Iwf239vL+Ytezodt00Sr+FUMmBaJb4WpF8tw1duxH8LeeUrpUk8VBSWvL1E49Iu+59DR", + "DAcfyB/BhW9xN4C7IRkogLcWh9qlyr8837VKXnBNtO6DL8iVv3GJ7jXNDZ0Ey+2k09mKcLeS3p9G0qvD", + "2+yLiL4I6tVkP3wOYe+Tr/J3DfKeq3I4QtILdeagb1CF7m6Hndyb2ZJ9YZvL8QwXz7ZThsPai7fS25eW", + "3vpFS2NgNKUov57EhjCsmqqmF3mrsPUIyYWqr36jItqfGFmDMpmBdLc0dgne2JO0HCf+YjzzDylhOaTd", + "ylZ/atmqDiG/knTVKjvskhIC79KV7G5duxrTtZjVTiMIOFv9yKM7wtPmiQTDYrBqhc8EVlOv9qFn02qE", + "drOmPaWwLz/9CKH2+Wxz9GKX6PQNGXFGV0+K3ALxvfnSvDTqMHh3Mw6Dcbzp8f7jm4Mg3IU3QpMf8Bb/", + "whzyi7K0OFldlIVt40h7c1vXcRtX4h22hIyiqdcY8Cgsix3WhLSBEnfdY2RhXcB7M+KrR6q6FrZLzV0K", + "mjdVLKhc2k6GxxkkkDv+zwMc/86M/CAkYVwrW2hCu0LJ5A7j+uDBw0ePXRNJz204Vbfd/LvHB4fff++a", + "NbVCrX7Ta660PFhBngvXwd0N/XHNh4P//p//nc1md3ayU7F+tnljC/P8XnhqX60LN35ot77xTYpp6a5g", + "0k7U3YjD/ZlYR7m/WN/ePl/t9jHY/0PcOvM2GTkFtDZPtlJRr/EWssfkIvfQ1NfeNHynvkxm5I1wVQGq", + "nEoiZAbSPR6wrKikXANkM0+pZIHpv5gFneYMuDYKI5ZDl4liGdhkymUlISM5K/C9QAlnGKaO06Mu34Jg", + "N6PHYNbfLZN/TdfhQ8/1Na2FWzLmXRd07R9kwJLjQuJP339P9qeN1pLnZoCkRkyMuRZ0PblBa19NbKNC", + "wNs1k3fGyOLYYyxHjfRj376h7QKtf27O/c1K7Jbc3cZeE+e8sDen8daE9gOXe7/VcmAFO/tcA74fsCF1", + "bqyR8rwIFWdxZoaxRoHfsW9gp0k6qnx20Xt7iG+V/yuxki5BXZBtYOKn2vuEvoyQZ/TOLSau/YF8oIFD", + "SIrCe4QEWYBOVy4htoPXCO/x5ZiHGc+2x7iuW2TBLepXAw3rmuEjUSMT5YNcRfTKgYxQ6E++5KD5zBZY", + "7qAute3fnEN/E/PPsNQvsLh3qpjy4fU+b9bs4oWgfN5M3pe2EC3X4dS8RfDFENzjfC/9cx+IMbeIP0IA", + "vtcTE/JGNGnZrtL0H9Gf+CWv7S+9oDeCg3WcG7HW0uKtj7SWKdA+j0jx9TisciLrV8EvK1/s+YdrtgoZ", + "f7XPxmwVNMbc3mayb/IK/2v0ScjWLWPWNttZbKAZbQxzNg1tbdV2VdWvqKJ8FX76O9RbvgbHuhkWg4fU", + "8xknFvDrZTpY4sYS815dUHOIA8VrFI/mRlrUsWXRssJzyAVfqt8nK9pGHXG8RKikrt4cL9H85zu7z7F6", + "Dhe+UKWrp6QYT8E+zOTf5i2YUi4C8vH+X24OQs0KX4OOh6mkX5m7PNl/dHPTH4M8YymQEyhKIalk+Yb8", + "ndePaF2F22EB6rq+mTf1RmuOoyupXXcrDYsEXZ4JtuLRPuk1yz7vZoZBjbwL8kHGAz4Y1j2kZQlUXp4B", + "7vZLnXRmPHoRhvy26iLXFasioBgUXTDq/d8mI+1OmIUuFu7yq7gF1FfXcmzCxeOKxbSOfDFSgFgckPf8", + "PlEr+uTBw18fPvnO//nwyXcDljMzjyuK07edNQOZz3aYMQa036+t73pF8hp5Bze9lRfboemEZetoEdTm", + "oYPwXLjAHOQTdxQp6WawdnK546GGcNjm0YabrxSoNJvH39P3uk39GuARf1aruLacnXvf4PaBhoF0h4CJ", + "GEJrXmqosb790YYtomKHLOvq+DeteTZpAfYW88iTnQvlq0qx+mtpoAkqoMC91NJGy9cTGLFQ7zRwVNfv", + "q2LUSVWWQur6dKvZKFkOhhxuLVFuiHAvJKmlVKerqtz7hP/B8lifm1QB+8bwnvWzbxPWjm2LK959HanY", + "evdlmwn5imzO9y8W5DVLpTjEOs/uWlEbpaHolc1zXX/d9npt9AoSPGcckkLwWDG3n/Dra/wYrSQtNM2H", + "Op+Yj0N9u+/ht+DvgNWeZwwHvCp+fyf69JXsQJ3VSjDHtXmcx9L/BY9U672f5iy1ft771PrTxcy4lmpV", + "6UycB31RJ7McZIy7PCgZPd6UXaspndLLimSgDAl+e3ajAA8x+q+/Rmp2BYXBB8t2/UktSQvGsw6RoByY", + "ijOQqrYxSB/ecmtO+uOYk0bv+4U4pi1AuYujVep65Ys3IgM7brvmayw9k4sMXJ3MvlhRS05xLd3fMU27", + "jt6U0mq50qQqiRYxDa3pmNDUMln7Ipja9YSSbeWfCjkDQnMJNNuQOQAnYm4W3X6KjlCFoelezXPyYfwl", + "oAauUooUlIIsqd+W3wFaXX0UlUK9BU8IOAJcz0KUIAsqrwzs6dlOOOuK3Yrc/dvP6t5XgNcKdtsRawNi", + "I+it43Kc7NaHetz02wiuO3lIdlQC8aIBWqVEUebg7FIRFF4IJ4P714Wot4tXRwsabtgXpng/ydUIqAb1", + "C9P7VaGtysTc35G3yuzXE1agJMYpFwpSwTM1/KLgLraMr2YEa1FmBQEnjD7sbwYeUB9fUaXfOf9D+PBS", + "8DqHmWLLE4hDleHNyD/XdeF7Y6fmPuSqUnXxeGd2gCy2Bg7rLXO9gXU9FzqA/Ni1XUMLUinYNfIQloLx", + "HbJU+KahDjw3+HZGf3FYQ4Q6c0MflS0gGkRsA+TYtwqwG3oVBgDBF+XLUGF0D2g1cM2FyIFyax4WZWm4", + "hU4qXvcbQtOxbX2o/9607ROXe78H7+1MgAptTg7yc4tZhUkSK6qIg4MU9NSZpZauxlIfZnMYE/QVJ9so", + "3xzLY9MqPAI7DmnXtBEe/9Y56xyODv1GiW6QCHbswtCCY8aUbzIHqeur+oJRNm1jUiA+zy6jGuydU6aT", + "hZDuJVy60CAjlpBO7XTKtE9xslZjLZwPmOAIjuu4cdyLqk2dAPcYngWB+Ef8WBEpO2Km+kHIUXkK7YAd", + "yjSpuGZ5kKtZKxq/P3PLrQp1q0LdqlC3KtStCnWrQt2qULcq1K0KdatCXUWF+lqpHYnn1z4mjguecFhS", + "zc6gzvm4LTXxhwqFrk+6V+lQCTQqmCvcdsXcDw00x1WzHG/gUqjBGhj43qYSlUyBpAYmxkmZUyNLwVrX", + "hYPaJel8kUz34iZWuaMKHj0kx3899GGcKxdu2G5799AVm1V6k8M9l71bP4nn03iBGzS7LF7qVWBfYMiV", + "W2I5EGUQ+hJbv4AzyI06ZyPEiFFI+yryCdD8ucPNDg259eiZGe3jtKWYO7QVtAxeFsa1UkUohvx23ixb", + "0FwNP1pmxytoGavxUzNzqzsj/3gmsk3nTJhd28MNbJ+GJpiTcSo3kSjt3hnokYYWhkM5wuor/5+vPeS4", + "T7R9MttFYTHxRoKKntxtVB6Nta03rDeUjfdedOgk+mJnN8B0UgM4JnzK0LPfE/LO9vu62YoIkTtiDfv+", + "3cSptFvWTAPbGqnLsZ5vNbXQIz56evHsTw1hZ1UKhGlFfNTy7utlOlknZqQl8MQxoGQusk3SYl+T1i2U", + "MUWVgmK++yYK+aeraukuH/Nl+z31da6RF8HitvHkkGjWiWPAA9zZhtqP4801tnBEx54DjH9pFj3ERkMQ", + "iONPMS28+5bABZleM83mlvHdMr7gNHYkAsZdlkeXicy+IOOTG1nxYZ73cg1pZYALT/JdNGeiDwPWuuUI", + "ymBeLZdYnbPn1DBLAxyPCf6VWKFd7lgueDEKsoPXFduuWkekO1yfuwQZDXeFJEspqvKefYaEb9D6W5SU", + "b7yPDBLFiiq3OLS1j66X0dpEjNgz9N6WN2wGfOutfYGxy1217d8tWsg5Ve45cshIxTMXd95L11rz8ZVB", + "7dAna96w6a21Qe16I6tz8465Ivwuu5Dq2i9Ygkz0mtsD1S7fa9PC7Mmd3VYl/HNcG2/tcz8DDLaf4tQw", + "hGu6PWTA1/D6CLLUm9SL9lsq9qWnoUDlMGXdtrxWb3tv+LbTPXhnyTqVIC8J9SWjU8GVllWq33OKRu1g", + "YbO+Q96b6of523PfJO5Xibg93FDvOcWKwrWpO8rnFhBxYv0A4NmoqpZLUIZXhkSyAHjPXSvGScWNpiUW", + "pGCpFIlNYjJnyMgnM9uyoBuyoDl6ZX4DKcjc3OzBrlsTsdIsz10EgJmGiMV7TjXJgSpNXjPDZc1w3opY", + "h76APhfytMZCPMl5CRwUU0nc+PKj/Yp5xG753siHBkv7ucn/u9kEYg87ywYhP3ph4KZYDyFnSjdO4x7s", + "N+YwLBhPokR2sgLiYmi6tEXuGsbrCehe45V3u/6emxtOC4JcnerLkUPXsdM7i/Z0dKimtREd/49f64dY", + "0cWlSIwcR5fm9yXTq2o+S0Wx54sx7i1FXZhxL6NQCI7fsj1asj1VQrp39mCHOHcFfkUi7OrWLfMHSikK", + "6MCclnrj8dWC7t5f0CGz9SG02FdXnsY3sgcOxQEDN6SVZHqDLgtasl9Pwfz/w+cP5ps8896MSuaTg8lK", + "6/Jgbw+fMFsJpfcmn6fhN9X5+KFe2ifvmCglO8Oipx8+//8AAAD//zLWiFKJKAEA", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/daemon/algod/api/server/v2/generated/participating/private/routes.go b/daemon/algod/api/server/v2/generated/participating/private/routes.go index 31ab2cfe60..ca1a6eef44 100644 --- a/daemon/algod/api/server/v2/generated/participating/private/routes.go +++ b/daemon/algod/api/server/v2/generated/participating/private/routes.go @@ -158,161 +158,162 @@ func RegisterHandlersWithBaseURL(router EchoRouter, si ServerInterface, baseURL // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+x9a3PbOLbgX0Hp3qo8VpSc5524quuuE6d7vJ3OpGJ3z+5Nst0QeSRhTAIcALSlzvq/", - "b+EAIEESlOjHuG9X5VNiEY+Dg4OD88bXSSqKUnDgWk0Ov05KKmkBGiT+RdNUVFwnLDN/ZaBSyUrNBJ8c", - "+m9Eacn4ajKdMPNrSfV6Mp1wWkDTxvSfTiT8s2ISssmhlhVMJypdQ0HNwHpbmtb1SJtkJRI3xJEd4uR4", - "crXjA80yCUr1ofwbz7eE8TSvMiBaUq5oaj4pcsn0mug1U8R1JowTwYGIJdHrVmOyZJBnauYX+c8K5DZY", - "pZt8eElXDYiJFDn04XwjigXj4KGCGqh6Q4gWJIMlNlpTTcwMBlbfUAuigMp0TZZC7gHVAhHCC7wqJoef", - "Jgp4BhJ3KwV2gf9dSoDfIdFUrkBPvkxji1tqkIlmRWRpJw77ElSVa0WwLa5xxS6AE9NrRn6qlCYLIJST", - "j9+/Ic+ePXtlFlJQrSFzRDa4qmb2cE22++RwklEN/nOf1mi+EpLyLKnbf/z+Dc5/6hY4thVVCuKH5ch8", - "ISfHQwvwHSMkxLiGFe5Di/pNj8ihaH5ewFJIGLkntvGdbko4/x+6KynV6boUjOvIvhD8SuznKA8Luu/i", - "YTUArfalwZQ0g346SF59+fpk+uTg6t8+HSX/5f588exq5PLf1OPuwUC0YVpJCTzdJisJFE/LmvI+Pj46", - "elBrUeUZWdML3HxaIKt3fYnpa1nnBc0rQycsleIoXwlFqCOjDJa0yjXxE5OK54ZNmdEctROmSCnFBcsg", - "mxrue7lm6ZqkVNkhsB25ZHluaLBSkA3RWnx1Ow7TVYgSA9eN8IEL+u+LjGZdezABG+QGSZoLBYkWe64n", - "f+NQnpHwQmnuKnW9y4qcrYHg5OaDvWwRd9zQdJ5vicZ9zQhVhBJ/NU0JW5KtqMglbk7OzrG/W43BWkEM", - "0nBzWveoObxD6OshI4K8hRA5UI7I8+eujzK+ZKtKgiKXa9Brd+dJUKXgCohY/ANSbbb9f53+7T0RkvwE", - "StEVfKDpOQGeimx4j92ksRv8H0qYDS/UqqTpefy6zlnBIiD/RDesqArCq2IB0uyXvx+0IBJ0JfkQQHbE", - "PXRW0E1/0jNZ8RQ3t5m2JagZUmKqzOl2Rk6WpKCb7w6mDhxFaJ6TEnjG+IroDR8U0szc+8FLpKh4NkKG", - "0WbDgltTlZCyJYOM1KPsgMRNsw8exq8HTyNZBeD4QQbBqWfZAw6HTYRmzNE1X0hJVxCQzIz87DgXftXi", - "HHjN4Mhii59KCRdMVKruNAAjTr1bvOZCQ1JKWLIIjZ06dBjuYds49lo4AScVXFPGITOcF4EWGiwnGoQp", - "mHC3MtO/ohdUwcvnQxd483Xk7i9Fd9d37vio3cZGiT2SkXvRfHUHNi42tfqPUP7CuRVbJfbn3kay1Zm5", - "SpYsx2vmH2b/PBoqhUyghQh/8Si24lRXEg4/88fmL5KQU015RmVmfinsTz9VuWanbGV+yu1P78SKpads", - "NYDMGtaoNoXdCvuPGS/OjvUmqjS8E+K8KsMFpS2tdLElJ8dDm2zHvC5hHtWqbKhVnG28pnHdHnpTb+QA", - "kIO4K6lpeA5bCQZami7xn80S6Yku5e/mn7LMTW9dLmOoNXTs7lu0DTibwVFZ5iylBokf3Wfz1TABsFoC", - "bVrM8UI9/BqAWEpRgtTMDkrLMslFSvNEaapxpH+XsJwcTv5t3hhX5ra7mgeTvzO9TrGTkUetjJPQsrzG", - "GB+MXKN2MAvDoPETsgnL9lAiYtxuoiElZlhwDheU61mjj7T4QX2AP7mZGnxbUcbiu6NfDSKc2IYLUFa8", - "tQ0fKBKgniBaCaIVpc1VLhb1Dw+PyrLBIH4/KkuLDxQNgaHUBRumtHqEy6fNSQrnOTmekR/CsVHOFjzf", - "msvBihrmbli6W8vdYrXhyK2hGfGBIridQs7M1ng0GBn+LigOdYa1yI3Us5dWTOO/urYhmZnfR3X+c5BY", - "iNth4kItymHOKjD4S6C5POxQTp9wnC1nRo66fW9GNmaUOMHciFZ27qcddwceaxReSlpaAN0Xe5cyjhqY", - "bWRhvSU3HcnoojAHZzigNYTqxmdt73mIQoKk0IHhdS7S879Stb6DM7/wY/WPH05D1kAzkGRN1Xo2iUkZ", - "4fFqRhtzxExD1N7JIphqVi/xrpa3Z2kZ1TRYmoM3LpZY1GM/ZHogI7rL3/A/NCfmsznbhvXbYWfkDBmY", - "ssfZeRAyo8pbBcHOZBqgiUGQwmrvxGjd14LyTTN5fJ9G7dFbazBwO+QWgTskNnd+DF6LTQyG12LTOwJi", - "A+ou6MOMg2KkhkKNgO/YQSZw/x36qJR020cyjj0GyWaBRnRVeBp4eOObWRrL69FCyJtxnw5b4aSxJxNq", - "Rg2Y77SDJGxalYkjxYhNyjboDNS48HYzje7wMYy1sHCq6b8AC8qMehdYaA9011gQRclyuAPSX0eZ/oIq", - "ePaUnP716MWTp78+ffHSkGQpxUrSgiy2GhR56HQzovQ2h0f9laF2VOU6PvrL594K2R43No4SlUyhoGV/", - "KGvdtCKQbUZMuz7W2mjGVdcAjjmcZ2A4uUU7sYZ7A9oxU0bCKhZ3shlDCMuaWTLiIMlgLzFdd3nNNNtw", - "iXIrq7tQZUFKISP2NTxiWqQiTy5AKiYirpIPrgVxLbx4W3Z/t9CSS6qImRtNvxVHgSJCWXrDx/N9O/TZ", - "hje42cn57Xojq3PzjtmXNvK9JVGREmSiN5xksKhWLU1oKUVBKMmwI97R79hqrQOR5YMUYnnnt3Z0ltiS", - "8IMV+HLTpy/2vRcZGLW7UnfA3pvBGuwZyglxRhei0oQSLjJAHb1SccY/4OhFDxM6xnR4l+i1leEWYPTB", - "lFZmtVVJ0O3To8WmY0JTS0UJokYN2MVrh4ZtZaezTsRcAs2MngiciIUzPjuzOC6Sos9Ke9bprp2I5tyC", - "q5QiBaWMfm+1tr2g+XaWLPUOPCHgCHA9C1GCLKm8IbBaaJrvARTbxMCtRXJnse9DPW76XRvYnTzcRiqN", - "im+pwMj/5sDloGEIhSNxcgESLdf/0v3zk9x0+6pyIK7EiVZnrEBLAadcKEgFz1R0sJwqnew7tqZRS/4z", - "KwhOSuyk4sAD1qp3VGnrv2A8Q7XLshucx5qxzBTDAA9egWbkX/zt1x87NXySq0rVV6GqylJIDVlsDRw2", - "O+Z6D5t6LrEMxq7vWy1IpWDfyENYCsZ3yLIrsQiiujbzOQdff3FoDDP3wDaKyhYQDSJ2AXLqWwXYDX3r", - "A4AYHb3uiYTDVIdyaof+dKK0KEtz/nRS8brfEJpObesj/XPTtk9cVDd8PRNgZtceJgf5pcWsjapYUyO0", - "48ikoOfmbkIR3Dpa+jCbw5goxlNIdlG+OZanplV4BPYc0gHtx8VtBbN1DkeHfqNEN0gEe3ZhaMEDqtgH", - "KjVLWYmSxI+wvXPBqjtB1EBIMtCUGfUg+GCFrDLsT6znrDvmzQStUVJzH/ye2BxZTs4UXhht4M9hi56C", - "DzYk4ywI5LgDSTEyqjndlBME1Dt6zYUcNoENTXW+NdecXsOWXIIEoqpFwbS2MTZtQVKLMgkHiFokdszo", - "zG82nMHvwBh74CkOFSyvvxXTiRVbdsN31hFcWuhwAlMpRD7CE9NDRhSCUZ4aUgqz68yFdPm4H09JLSCd", - "EIO215p5PlAtNOMKyP8RFUkpRwGs0lDfCEIim8Xr18xgLrB6TueTaTAEORRg5Ur88vhxd+GPH7s9Z4os", - "4dLHQZqGXXQ8foxa0gehdOtw3YGKbo7bSYS3o6nGXBROhuvylP0+ATfymJ380Bm8tu+YM6WUI1yz/Fsz", - "gM7J3IxZe0gj4/whOO4oK0wwdGzduO/okP7X6PDN0DHo+hMHbrzm45Anz8hX+fYO+LQdiEgoJSg8VaFe", - "ouxXsQxDZd2xU1uloeir9rbrrwOCzUcvFvSkTMFzxiEpBIdtNDuEcfgJP8Z625M90Bl57FDfrtjUgr8D", - "VnueMVR4W/zibgek/KF2Yd/B5nfH7Vh1wiBh1EohLwklac5QZxVcaVml+jOnKBUHZzli6vey/rCe9MY3", - "iStmEb3JDfWZU3Tz1LJy1Dy5hIgW/D2AV5dUtVqB0h35YAnwmbtWjJOKM41zFWa/ErthJUi0t89sy4Ju", - "yZLmqNb9DlKQRaXbNybGMipttC5rYjLTELH8zKkmORgN9CfGzzY4nA8Z9DTDQV8KeV5jYRY9DyvgoJhK", - "4i6JH+xX9Ba75a+d5xgTS+xna0Qx4zcBj1sNrWSJ//vwPw8/HSX/RZPfD5JX/2P+5evzq0ePez8+vfru", - "u//X/unZ1XeP/vPfYzvlYY9F2jnIT46dNHlyjCJDY1zqwX5vFoeC8SRKZGdrIAXjGLDdoS3y0Ag+noAe", - "NWYqt+ufud5wQ0gXNGcZ1Tcjhy6L651Fezo6VNPaiI4C6df6JeY9X4mkpOk5evQmK6bX1WKWimLupej5", - "StQS9TyjUAiO37I5LdlclZDOL57sudJvwa9IhF11mOyNBYK+PzAeHYsmSxfwiidvWXFLFJVyRkoM/vJ+", - "GbGc1hHQNvPxkGB47Jp6p6L78+mLl5NpE9Zafzeauv36JXImWLaJBS9nsIlJau6o4RF7oEhJtwp0nA8h", - "7FEXlPVbhMMWYER8tWbl/fMcpdkizit9SI3T+Db8hNtYF3MS0Ty7dVYfsbx/uLUEyKDU61hGVEvmwFbN", - "bgJ0XCqlFBfAp4TNYNbVuLIVKO8My4EuMTMHTYxiTIhgfQ4soXmqCLAeLmSUWhOjHxSTHd+/mk6cGKHu", - "XLJ3A8fg6s5Z22L931qQBz+8PSNzx3rVAxtHb4cOIp8jlgwX3NdythluZvNAbSLBZ/6ZH8OScWa+H37m", - "GdV0vqCKpWpeKZCvaU55CrOVIIc+XvCYavqZ92S2wVTtIFKTlNUiZyk5D2Xrhjxt+l1/hM+fPxmO//nz", - "l57npi8Ju6mi/MVOkFwyvRaVTlx+USLhksosArqq80twZJsduGvWKXFjW1bs8pfc+HGeR8tSdePM+8sv", - "y9wsPyBD5aKozZYRpYX0Uo0RdSw0uL/vhbsYJL30yWmVAkV+K2j5iXH9hSSfq4ODZ0Bagde/OeHB0OS2", - "hJbN60Zx8F17Fy7cakiw0ZImJV2Bii5fAy1x91HyLtC6mucEu7UCvn1ACw7VLMDjY3gDLBzXDl7FxZ3a", - "Xj5RPL4E/IRbiG2MuNE4LW66X0EI+I23qxNG3tulSq8Tc7ajq1KGxP3O1PmjKyNkeU+SYituDoFLtV0A", - "SdeQnkOGWX9QlHo7bXX3zkonsnrWwZTNjrUBnJjChebBBZCqzKgT6infdnNpFGjtE4g+wjlsz0STAXad", - "5Jl2LocaOqhIqYF0aYg1PLZujO7mO8c3xq+XpU+JwNhYTxaHNV34PsMH2Yq8d3CIY0TRyjUYQgSVEURY", - "4h9AwQ0Wasa7FenHlmf0lYW9+SLJtJ73E9ekUcOc8zpcDaZQ2O8FYKq9uFRkQY3cLlyWuM1XCLhYpegK", - "BiTk0EI7MiugZdXFQfbde9GbTiy7F1rvvomCbBsnZs1RSgHzxZAKKjOdkAU/k3UC4ApmBIu/OIQtchST", - "6mgJy3SobFnKbTWLIdDiBAySNwKHB6ONkVCyWVPlE9gxz9+f5VEywL8w/2ZX1uVJ4G0PkvnrnErPc7vn", - "tKddutxLn3DpsyxD1XJExqSR8DEALLYdgqMAlEEOK7tw29gTSpML1GyQgeNvy2XOOJAk5rinSomU2QoE", - "zTXj5gAjHz8mxBqTyegRYmQcgI3OLRyYvBfh2eSr6wDJXS4T9WOjWyz4G+JhlzY0y4g8ojQsnPGBoDrP", - "AaiL9qjvr07MEQ5DGJ8Sw+YuaG7YnNP4mkF6yX8otnZS/Zx79dGQOLvDlm8vlmutyV5FN1lNKDN5oOMC", - "3Q6IF2KT2LjrqMS72CwMvUej1TAKPHYwbZrlA0UWYoMue7xasH6J2gPLMBwejEDD3zCF9Ir9hm5zC8yu", - "aXdLUzEqVEgyzpxXk8uQODFm6gEJZohcHgaZkzcCoGPsaGqMOeV3r5LaFk/6l3lzq02bigA+sDZ2/IeO", - "UHSXBvDXt8LUuY4fuhJL1E7R9jy30zwDETJG9IZN9N09faeSghxQKUhaQlRyHnMCGt0G8MY59d0C4wUm", - "k1K+fRSEM0hYMaWhMcebi9n7l+7bPEmxhoUQy+HV6VIuzfo+ClFfUzZJGju2lnnvK7gQGpIlk0on6MuI", - "LsE0+l6hUv29aRqXldoBE7acE8vivAGnPYdtkrG8itOrm/fHYzPt+5olqmqB/JZxAjRdkwWWH4uGUe2Y", - "2kba7VzwO7vgd/TO1jvuNJimZmJpyKU9x5/kXHQ47y52ECHAGHH0d20QpTsYJMo+x5DrWIZcIDfZw5mZ", - "hrNd1tfeYcr82HsDUCwUw3eUHSm6lsBgsHMVDN1ERixhOqje1c/6GDgDtCxZtunYQu2ogxozvZbBw5dF", - "6GABd9cNtgcDgd0zFlgsQbUrYDQCvq3D1kpAnY3CzFm7TkXIEMKpmPJVRPuIMqSNouI+XJ0BzX+E7S+m", - "LS5ncjWd3M50GsO1G3EPrj/U2xvFMzr5rSmt5Qm5JsppWUpxQfPEGZiHSFOKC0ea2Nzbo++Z1cXNmGdv", - "j959cOBfTSdpDlQmtagwuCpsV/5pVmWLbQwcEF+l0Oh8Xma3omSw+XWFgNAofbkGVxEukEZ7pWsah0Nw", - "FJ2RehmPNdprcna+EbvEHT4SKGsXSWO+sx6StleEXlCWe7uZh3YgLggXN67+UZQrhAPc2rsSOMmSO2U3", - "vdMdPx0Nde3hSeFcO2rWFbYsoyKCd13oRoREcxySakGx8Iy1ivSZE68KtCQkKmdp3MbKF8oQB7e+M9OY", - "YOMBYdSMWLEBVyyvWDCWaaZGKLodIIM5osj0RYyGcLcQrp52xdk/KyAsA67NJ4mnsnNQsdKPs7b3r1Mj", - "O/TncgNbC30z/G1kjLDoUvfGQyB2Cxihp64H7nGtMvuF1hYp80PgkriGwz+csXcl7nDWO/pw1GzDINdt", - "j1tY/rrP/wxh2FKJ+2tve+XVVX8amCNaS5upZCnF7xDX81A9jmQd+DJTDKNcfgc+iyRvdVlMbd1pSoI3", - "sw9u95B0E1qh2kEKA1SPOx+45bDejbdQU2632pa2bcW6xQkmjE+d2/EbgnEw92J6c3q5oLFiQEbIMDAd", - "NQ7gli1dC+I7e9w7sz9zlb9mJPAl122ZzccrQTYJQf3c7xsKDHba0aJCIxkg1YYywdT6/3IlIsNU/JJy", - "WyHZ9LNHyfVWYI1fptelkJhNq+Jm/wxSVtA8Ljlkad/Em7EVs/WBKwVBAVo3kC2sbqnIFfG1LvYGNSdL", - "cjANSly73cjYBVNskQO2eGJbLKhCTl4bououZnnA9Vph86cjmq8rnknI9FpZxCpBaqEO1ZvaebUAfQnA", - "yQG2e/KKPES3nWIX8Mhg0d3Pk8Mnr9Doav84iF0ArhD4Lm6SITv5u2MncTpGv6UdwzBuN+osmhtqX28Y", - "Zlw7TpPtOuYsYUvH6/afpYJyuoJ4pEixBybbF3cTDWkdvPDMlh5XWootYTo+P2hq+NNAHLthfxYMkoqi", - "YLpwzh0lCkNPTXVZO6kfztYxd4XBPFz+I/pIS+8i6iiR92s0tfdbbNXoyX5PC2ijdUqoTaHOWRO94MsV", - "khNfiAErpdUF0ixuzFxm6SjmYDDDkpSScY2KRaWXyV9IuqaSpob9zYbATRYvn0eqw7WrFPHrAX7veJeg", - "QF7EUS8HyN7LEK4vecgFTwrDUbJHTd5IcCoHnblxt92Q73D30GOFMjNKMkhuVYvcaMCpb0V4fMeAtyTF", - "ej3Xosdrr+zeKbOScfKgldmhnz++c1JGIWSsLE9z3J3EIUFLBhcYuxffJDPmLfdC5qN24TbQ/7GeBy9y", - "BmKZP8sxReC1iGinvmJhbUl3seoR68DQMTUfDBks3FBT0q4Od/9OP2987jufzBcPK/7RBfYP3lJEsl/B", - "wCYGlSuj25nV3wP/NyWvxWbspnZOiN/Y/waoiaKkYnn2S5Pf2SkMKilP11F/1sJ0/LV5wqBenL2fotWN", - "1pRzyKPDWVnwVy8zRqTaf4ix8xSMj2zbrVVql9tZXAN4G0wPlJ/QoJfp3EwQYrWd8FYHVOcrkRGcpyml", - "03DPfo3boBLhPytQOpY8hB9sUBfaLY2+awvhEeAZaosz8oN9gmwNpFXpA7U0VlS5rRoB2QqkM6hXZS5o", - "NiVmnLO3R++IndX2sYW4bSG+FSop7VV07FVB3a1x4cG+pnY8dWH8OLtjqc2qlcbCO0rTooylmZoWZ74B", - "5rKGNnxUX0LszMix1RyV10vsJIYelkwWRuOqR7OyC9KE+Y/WNF2jStZiqcMkP76CpKdKFbzaUldfr0tn", - "4bkzcLsikraG5JQIozdfMmVfnoILaGe21mneziTgM13by5MV55ZSorLHrjIEN0G7B84GangzfxSyDuKv", - "KZDbAqzXLah5ir2itWi61Tl7z7XY7Ma6qrZ/UTClXHCWYiWY2NXsXrEa4wMbUTSna2T1R9yd0MjhitYE", - "rcPkHBYHq4R6RugQ1zfCB1/NplrqsH9qfC5pTTVZgVaOs0E29aVtnR2QcQWuFBo+aBbwSSFbfkXkkFFX", - "dVK7NK5JRpgWM6DYfW++vXdqP8aLnzOOAr5DmwtNt5Y6fGRHG62AabISoNx62rnB6pPpM8M02Qw2X2b+", - "UR4cw7rlzLKtD7o/1JH3SDsPsGn7xrS1RVGan1sRyHbSo7J0kw4XPo7KA3rDBxEc8Swm3rUTILcePxxt", - "B7ntDCXB+9QQGlygIxpKvId7hFEXAe4UmDdCq6UobEFsCFe0FgLjETDeMQ7Nk1GRCyKNXgm4MXheB/qp", - "VFJtRcBRPO0MaI7e5xhDU9q5Hm47VGeDESW4Rj/H8DY29YsHGEfdoBHcKN/WL1UZ6g6EiTf4RJ5DZL8a", - "MUpVTojKMKOgU584xjgM4/YV0NsXQP8Y9GUi211Lak/OdW6ioSTRRZWtQCc0y2I1JF/jV4JfSVah5AAb", - "SKu6Bl9ZkhSrq7TLzfSpzU2UCq6qYsdcvsEtp0tFTI5+jxMonzLRDD4jyH4N6z1+++Hj2zdHZ2+P7X2h", - "iKpslqiRuSUUhiHOyAlXGozoXCkgv4Vo/A37/dZZcBzMoC55hGjD2uieEDFXZrHFf2N18oYJyMWKXDta", - "0QeGYMdri/ftkXrCuTl6iWKrZDwm8Oq7PTqaqW92Hpv+d3ogc7FqA3LPFSx2MeNwj2Js+K2538ICD73i", - "j/YGrOsvYGyg8K/JoHZbZw63mSfeuL1qkOiTql+r2G0nGX53Yop39ECEcFC3g1oxwDo5h+KE08Gwdqpd", - "gp2mZCenHExaskFGNj3JPpocNfAOBRbZuCLzudd7nADbUwdw7J0I9RFrfYB+9OGwpKTMefAbZtHHrAuc", - "H7Zq7jp0zQZ3F+HC0QcNi/Hi/8MldJqyOXgNlEKxpmBt7FWAkeFSZ1jYPygB1B/LxypcQKqNUB/4YCXA", - "dQoCmcmCN0y+ldIZUD/qqDJXQWdX2Zx+aeI9zKaX2RJkZ9myrrPxRWKO6kgb9P/jKyIr4O4ZkXbM+ujI", - "2eUSUs0u9mQS/d1oqU2WytTrsfY5sCCxiNWRmP6Z9muq1w1AuxJ9dsITlJa7NThDeQTnsH2gSIsaonVm", - "p57n3aQGAWIAuUNiSESomCfbGt6cc5GpmjIQCz5yxHaHpprTYIH/IC/uhnN5kiQ0zJXbMeWFiGnuo+Yy", - "Xa+VQYpBhUPJRv0S28OC0DFWNFf14yz1O+yBVkNO+pXeLl0NBMz7qm3NvhoCKP+bT/K0s9j3/ZsnCNCy", - "f0ll5ltEVVWvBSc77qNehpAvD90FelnPzJo4v35OSKR2EEZzprlQjK+SoZDYdmhd+DYoBhDgdYC1yxGu", - "JUj39AiakHOhINHCxwXugmMXKtw7ljdBghqs12eBG6yi8bEpE4IVUClWzaAuOCJcoNFbqYFOBsU8hufc", - "hew39rtPgvAVMEdo5I5ek73VOHyEJ1M9JIZUvyTuttyfXHETrZdxbp+iUrHKHtygMrQel1JkVWov6PBg", - "NDaGsXVzdrCSqMKY9lfZk/1zrCL1LkhVO4ft3Mrf6ZryppxX+1hbEcquIUgN7+z2nRoE4rpPvrILWN0J", - "nH+kUj2dlELkyYC5+KRfoKR7Bs5Zeg4ZMXeHj40aKPJPHqKVsvYHXq63viBHWQKH7NGMEKOWF6Xeetdg", - "u9ZuZ3L+QO+af4OzZpWtGeT0/dlnHg/rw2o+8pb8zQ+zm6spMMzvllPZQfaUv9gMFEeR9DLy5MXYF28j", - "zrruMwQNUVkoYlLKDXOhR53vvs4fIf2gDv9u7ScsldDEYElrOkJpyRt0usLLT41FaNyLAL7DHvBCpTh4", - "E8BzIwfOHxwo9VONlGApg5TQWv4+Pds/1FzzpWCLFEbWm2XawjXWyd7el8CIot7Utok4nvsmDKyLIDjW", - "iumbPhSaErHkbEg45lzKC5rfv/kCC2YcIT7cw1bxhYb6b4hki0p1s2iFd3TU3IGue3dT8w9obvk7mD2K", - "2oDdUM6OWr/F4EtIYmk0mpNcNG+y4JDkEse0RuMnL8nCRVqXElKmWCcJ5dJXw6zVPSwO3bx3tlu/3LfO", - "X4S+BRk7BUGU5H1TWU8LvB8aCJsj+gczlYGTG6XyGPX1yCKCvxiPClOe91wX5y1rsq1U2onmEBLu2Koc", - "uLGvaVXuJ3OPXR6uAy+dSkF/naNv6xZuIxd1s7axLpE+cneVXxvjyYhXVTTd0ZViEYIlSQmCSn578huR", - "sMQ3BwR5/BgnePx46pr+9rT92Rznx4+jYty9OVFaT4O7eWMU88tQ9J+NcBsINO3sR8XybB9htMKGm/c/", - "MDD2V5c48Ie8QPKrtaf2j6qr3X4d9213ExAxkbW2Jg+mCgKCR8QCu26z6OPtCtJKMr3Fegbe/MZ+jdaJ", - "+qG22DuPT50B6+4+Lc6hrojR2Pcr5W/XH4R97L0wMjU6zzU+Bvd2Q4syB3dQvnuw+A949pfn2cGzJ/+x", - "+MvBi4MUnr94dXBAXz2nT149ewJP//Li+QE8Wb58tXiaPX3+dPH86fOXL16lz54/WTx/+eo/Hhg+ZEC2", - "gE589tzkf+MzPcnRh5PkzADb4ISWrH4D0pCxfyGApngSoaAsnxz6n/6nP2GzVBTN8P7XiUvOmay1LtXh", - "fH55eTkLu8xXaNBLtKjS9dzP039778NJHWBtE75xR23srCEF3FRHCkf47ePb0zNy9OFk1hDM5HByMDuY", - "PcGXtUrgtGSTw8kz/AlPzxr3fe6IbXL49Wo6ma+B5uj/Mn8UoCVL/Sd1SVcrkDP3VIL56eLp3IsS86/O", - "mHm169s8rDo6/9qy+WZ7emJVwvlXn2y/u3Urm93ZuoMOI6HY1Wy+wByesU1BBY2Hl2JfrZ5/RRF58Pe5", - "S2yIf0RVxZ6BuXeMxFu2sPRVbwysnR7uEdn51+ZV5wAsG9g/t6+YNT/3KlqvIJphgLH+dNfzpEi7luxP", - "MuRGuvfaKpbHtMZKJOmnBwd/jodXn18T0J2WkFYcTASY1zQjPtkD535yf3OfcPSLGg5FLAdGCJ7fHwTt", - "WqQ/wpa8F5p8j6rC1XTy4j534oQbwYXmBFsGpQb6R+Rnfs7FJfctzdVdFQWV29HHR9OVQlOdZBfUCU5B", - "eerJF7QN28DF9lE7yrIe0VsRBpR+LbLtDowValW64NwGaY0Ex7hZQl8F7L/31Xsd9Ry2xHrOvIXUvQ7e", - "yFZaVnB1S57wp33I9RtP+cZTpJ3+2f1NfwrygqVAzqAohaSS5VvyM69Tq27M446yLBqV1D76e3mc0Y5T", - "kcEKeOIYWLIQ2daXj2pNcA5WWesJMvOv7RqwVnCbZJCDjkZcmN/r17n6i1hsyclxT8Kx3bqc9/UWmwa1", - "VQ8/fbXajhHlG2WkC2KPM4ZlPbu86Uuca+4ie7OQldDEYiFzi/rGiL4xolsJN6MPzxj5Jqp92MRl2ruz", - "pz4HOVZ9guo+KGN0lD/0+N7Jxvf1n5i+Y6O7ICPBBxuG3EXzNxbxjUXcjkX8AJHDiKfWMY0I0V1PHxrL", - "MDCwJeu+tIAGf9+8yqkkCsaaOY5wRGfcuA+ucd9KXRRXVqejvHmMJrKBd6vnfWN531jen4flHe1nNG3B", - "5Naa0TlsC1rW+pBaVzoTl4H9H2Gx8Th9q3X99lvr7/klZTpZCulyBbASab+zBprPXSGFzq9NUmDvC2Y6", - "Bj8GFu74r/O60HP0Y9d1EPvqTOe+UeMbDH1tyLtrL9unL4bvYp1Ax9Yb19HhfI4Btmuh9HxyNf3acSuF", - "H7/Ue/y1vgzcXl99ufr/AQAA//+KH5i1MrgAAA==", + "H4sIAAAAAAAC/+x9+3PcNtLgv4Ka76vy44Yz8iPZtapS38mWk9XF8bosJXv32b4EQ/bMYEUCXACUZuLT", + "/36FBkCCJDhDPSJvqvyTrSEejUaj0W98nqSiKAUHrtXk8POkpJIWoEHiXzRNRcV1wjLzVwYqlazUTPDJ", + "of9GlJaMrybTCTO/llSvJ9MJpwU0bUz/6UTCvyomIZscalnBdKLSNRTUDKy3pWldj7RJViJxQxzZIU6O", + "J1c7PtAsk6BUH8q/83xLGE/zKgOiJeWKpuaTIpdMr4leM0VcZ8I4ERyIWBK9bjUmSwZ5pmZ+kf+qQG6D", + "VbrJh5d01YCYSJFDH85XolgwDh4qqIGqN4RoQTJYYqM11cTMYGD1DbUgCqhM12Qp5B5QLRAhvMCrYnL4", + "YaKAZyBxt1JgF/jfpQT4HRJN5Qr05NM0trilBploVkSWduKwL0FVuVYE2+IaV+wCODG9ZuSnSmmyAEI5", + "ef/9K/Ls2bMXZiEF1RoyR2SDq2pmD9dku08OJxnV4D/3aY3mKyEpz5K6/fvvX+H8p26BY1tRpSB+WI7M", + "F3JyPLQA3zFCQoxrWOE+tKjf9IgciubnBSyFhJF7Yhvf6aaE83/RXUmpTtelYFxH9oXgV2I/R3lY0H0X", + "D6sBaLUvDaakGfTDQfLi0+cn0ycHV//x4Sj5b/fnN8+uRi7/VT3uHgxEG6aVlMDTbbKSQPG0rCnv4+O9", + "owe1FlWekTW9wM2nBbJ615eYvpZ1XtC8MnTCUimO8pVQhDoyymBJq1wTPzGpeG7YlBnNUTthipRSXLAM", + "sqnhvpdrlq5JSpUdAtuRS5bnhgYrBdkQrcVXt+MwXYUoMXDdCB+4oH9fZDTr2oMJ2CA3SNJcKEi02HM9", + "+RuH8oyEF0pzV6nrXVbkbA0EJzcf7GWLuOOGpvN8SzTua0aoIpT4q2lK2JJsRUUucXNydo793WoM1gpi", + "kIab07pHzeEdQl8PGRHkLYTIgXJEnj93fZTxJVtVEhS5XINeuztPgioFV0DE4p+QarPt/+v072+JkOQn", + "UIqu4B1NzwnwVGTDe+wmjd3g/1TCbHihViVNz+PXdc4KFgH5J7phRVUQXhULkGa//P2gBZGgK8mHALIj", + "7qGzgm76k57Jiqe4uc20LUHNkBJTZU63M3KyJAXdfHcwdeAoQvOclMAzxldEb/igkGbm3g9eIkXFsxEy", + "jDYbFtyaqoSULRlkpB5lByRumn3wMH49eBrJKgDHDzIITj3LHnA4bCI0Y46u+UJKuoKAZGbkZ8e58KsW", + "58BrBkcWW/xUSrhgolJ1pwEYcerd4jUXGpJSwpJFaOzUocNwD9vGsdfCCTip4JoyDpnhvAi00GA50SBM", + "wYS7lZn+Fb2gCr59PnSBN19H7v5SdHd9546P2m1slNgjGbkXzVd3YONiU6v/COUvnFuxVWJ/7m0kW52Z", + "q2TJcrxm/mn2z6OhUsgEWojwF49iK051JeHwI39s/iIJOdWUZ1Rm5pfC/vRTlWt2ylbmp9z+9EasWHrK", + "VgPIrGGNalPYrbD/mPHi7FhvokrDGyHOqzJcUNrSShdbcnI8tMl2zOsS5lGtyoZaxdnGaxrX7aE39UYO", + "ADmIu5KahuewlWCgpekS/9kskZ7oUv5u/inL3PTW5TKGWkPH7r5F24CzGRyVZc5SapD43n02Xw0TAKsl", + "0KbFHC/Uw88BiKUUJUjN7KC0LJNcpDRPlKYaR/pPCcvJ4eQ/5o1xZW67q3kw+RvT6xQ7GXnUyjgJLctr", + "jPHOyDVqB7MwDBo/IZuwbA8lIsbtJhpSYoYF53BBuZ41+kiLH9QH+IObqcG3FWUsvjv61SDCiW24AGXF", + "W9vwgSIB6gmilSBaUdpc5WJR//DwqCwbDOL3o7K0+EDREBhKXbBhSqtHuHzanKRwnpPjGfkhHBvlbMHz", + "rbkcrKhh7oalu7XcLVYbjtwamhEfKILbKeTMbI1Hg5Hh74LiUGdYi9xIPXtpxTT+m2sbkpn5fVTnPweJ", + "hbgdJi7UohzmrAKDvwSay8MO5fQJx9lyZuSo2/dmZGNGiRPMjWhl537acXfgsUbhpaSlBdB9sXcp46iB", + "2UYW1lty05GMLgpzcIYDWkOobnzW9p6HKCRICh0YXuYiPf8bVes7OPMLP1b/+OE0ZA00A0nWVK1nk5iU", + "ER6vZrQxR8w0RO2dLIKpZvUS72p5e5aWUU2DpTl442KJRT32Q6YHMqK7/B3/Q3NiPpuzbVi/HXZGzpCB", + "KXucnQchM6q8VRDsTKYBmhgEKaz2TozWfS0oXzWTx/dp1B69tgYDt0NuEbhDYnPnx+Cl2MRgeCk2vSMg", + "NqDugj7MOChGaijUCPiOHWQC99+hj0pJt30k49hjkGwWaERXhaeBhze+maWxvB4thLwZ9+mwFU4aezKh", + "ZtSA+U47SMKmVZk4UozYpGyDzkCNC2830+gOH8NYCwunmv4BWFBm1LvAQnugu8aCKEqWwx2Q/jrK9BdU", + "wbOn5PRvR988efrr02++NSRZSrGStCCLrQZFHjrdjCi9zeFRf2WoHVW5jo/+7XNvhWyPGxtHiUqmUNCy", + "P5S1bloRyDYjpl0fa20046prAMcczjMwnNyinVjDvQHtmCkjYRWLO9mMIYRlzSwZcZBksJeYrru8Zppt", + "uES5ldVdqLIgpZAR+xoeMS1SkScXIBUTEVfJO9eCuBZevC27v1toySVVxMyNpt+Ko0ARoSy94eP5vh36", + "bMMb3Ozk/Ha9kdW5ecfsSxv53pKoSAky0RtOMlhUq5YmtJSiIJRk2BHv6DdstdaByPJOCrG881s7Okts", + "SfjBCny56dMX+96KDIzaXak7YO/NYA32DOWEOKMLUWlCCRcZoI5eqTjjH3D0oocJHWM6vEv02spwCzD6", + "YEors9qqJOj26dFi0zGhqaWiBFGjBuzitUPDtrLTWSdiLoFmRk8ETsTCGZ+dWRwXSdFnpT3rdNdORHNu", + "wVVKkYJSRr+3Wtte0Hw7S5Z6B54QcAS4noUoQZZU3hrY84u9cJ7DNkEPqyIPf/xFPfoC8Gqhab4Hsdgm", + "ht5ahXAehj7U46bfRXDdyUOyoxKI531GXzEMIgcNQyi8Fk4G968LUW8Xb4+WC5Bo6/9DKd5PcjsCqkH9", + "g+n9ttBW5UDckBOdz1iBliBOuVCQCp6p6GA5VTrZx5ZNo5Z8b1YQcMIYJ8aBB6yRb6jS1j/FeIZqtb1O", + "cB5rpjRTDAM8KOKYkX/x0k1/7NTcg1xVqhZ1VFWWQmrIYmvgsNkx11vY1HOJZTB2LU9pQSoF+0YewlIw", + "vkOWXYlFENW1Gdc5cPuLQ2Onuee3UVS2gGgQsQuQU98qwG4YOzEACFMNoi3hMNWhnDpgYzpRWpSl4RY6", + "qXjdbwhNp7b1kf65adsnLqqbezsTYGbXHiYH+aXFrI2aWVOjlOHIpKDnRvZAFcs60vowm8OYKMZTSHZR", + "vjmWp6ZVeAT2HNIB7dbF5QWzdQ5Hh36jRDdIBHt2YWjBA6r2Oyo1S1mJkuKPsL1zwbk7QdQATDLQlBn1", + "L/hghegy7E+sZ7Q75s0E6VFaUR/8nloUWU7OFF4YbeDPYYueoHc25OYsCNS5A00gMqo53ZQTBNQ78o0A", + "EzaBDU11vjXXnF7DllyCBKKqRcG0tjFUbUVBizIJB4hanHbM6MyrNlzF78AYe+8pDhUsr78V04mVqHbD", + "d9YRq1rocJJUKUQ+wtPWQ0YUglGeOFIKs+vMhez5uC5PSS0gnRCDtvWaeT5QLTTjCsj/ERVJKUeBtdJQ", + "3whCIpvF69fMYC6wek7nc2swBDkUYOVw/PL4cXfhjx+7PWeKLOHSx7mahl10PH6MWvA7oXTrcN2BCcYc", + "t5MIb0dTnLkonAzX5Sn7fT5u5DE7+a4zeG2/M2dKKUe4Zvm3ZgCdk7kZs/aQRsb5u3DcUVa2YOjYunHf", + "MeDgj7HRNEPHoOtPHLhpm49DnlojX+XbO+DTdiAioZSg8FSFeomyX8UyDIV2x05tlYaib7qxXX8dEGze", + "e7GgJ2UKnjMOSSE4bKPZP4zDT/gx1tue7IHOyGOH+nbFphb8HbDa84yhwtviF3c7IOV3dYjCHWx+d9yO", + "1S4MAketFPKSUJLmDHVWwZWWVao/copScXCWI64cL+sP60mvfJO4YhbRm9xQHzlFN14tK0fNz0uIaMHf", + "A3h1SVWrFSjdkQ+WAB+5a8U4qTjTOFdh9iuxG1aCRH/KzLYs6JYsaY5q3e8gBVlUun1jYqyq0kbrsiZE", + "Mw0Ry4+capKD0UB/Yvxsg8P5kFBPMxz0pZDnNRZm0fOwAg6KqSTucvrBfsVoALf8tYsMwMQh+9kancz4", + "TUDrVkMrGeb/Pvyvww9HyX/T5PeD5MX/mH/6/Pzq0ePej0+vvvvu/7V/enb13aP/+s/YTnnYY5GUDvKT", + "YydNnhyjyNBYnXqw35vFoWA8iRLZ2RpIwTgG5Hdoizw0go8noEeNWc/t+keuN9wQ0gXNWUb1zcihy+J6", + "Z9Gejg7VtDaio0D6tX6KRUesRFLS9Bw9tpMV0+tqMUtFMfdS9Hwlaol6nlEoBMdv2ZyWbK5KSOcXT/Zc", + "6bfgVyTCrjpM9sYCQd/fG49+RoOqC2jGk7esuCWKSjmjLgb3eb+bWE7rCHeb2XpIMPx5Tb3T2P359Jtv", + "J9MmbLn+bjR1+/VT5EywbBMLTs9gE5PU3FHDI/ZAkZJuFeg4H0LYoy5G65cKhy3AiPhqzcr75zlKs0Wc", + "V/qQKafxbfgJt7FM5iSieXbrrD5ief9wawmQQanXsYy3lsyBrZrdBOi4zEopLoBPCZvBrKtxZStQ3tmZ", + "A11i5hWaGMWYEND6HFhC81QRYD1cyCi1JkY/KCY7vn81nTgxQt25ZO8GjsHVnbO2xfq/tSAPfnh9RuaO", + "9aoHNk/CDh1EtkcsGS54s+VMNdzM5vnaRJGP/CM/hiXjzHw//Mgzqul8QRVL1bxSIF/SnPIUZitBDn08", + "6DHV9CPvyWyDqfhBJC4pq0XOUnIeytYNedr0yv4IHz9+MBz/48dPPb9SXxJ2U0X5i50guWR6LSqduPyx", + "RMIllVkEdFXnD+HINvtz16xT4sa2rNjlp7nx4zyPlqXq5hH0l1+WuVl+QIbKRcmbLSNKC+mlGiPqWGhw", + "f98KdzFIeumTDysFivxW0PID4/oTST5WBwfPgLQC639zwoOhyW0JLZvXjfIcuvYuXLjVkGCjJU1KugIV", + "Xb4GWuLuo+RdoHU1zwl2awX0+4AlHKpZgMfH8AZYOK4dnIyLO7W9fCGA+BLwE24htjHiRuO0uOl+BSH+", + "N96uTppAb5cqvU7M2Y6uShkS9ztT5wevjJDlPUmKrbg5BC6VegEkXUN6DhlmdUJR6u201d07K53I6lkH", + "Uzb72QboYooemgcXQKoyo06op3zbzZVSoLVPEHsP57A9E02G33WSo9q5OmrooCKlBtKlIdbw2Loxupvv", + "POKYn1CWPuUFY589WRzWdOH7DB9kK/LewSGOEUUrl2QIEVRGEGGJfwAFN1ioGe9WpB9bntFXFvbmiyRL", + "e95PXJNGDXPO63A1mCJjvxeApRTEpSILauR24aoA2HyUgItViq5gQEIOLbQjsz5aVl0cZN+9F73pxLJ7", + "ofXumyjItnFi1hylFDBfDKmgMtMJWfAzWScArmBGsLiPQ9giRzGpju2wTIfKlqXcVisZAi1OwCB5I3B4", + "MNoYCSWbNVW+QAHWcfBneZQM8AfmV+3Kqj0JvO1BsYY6Z9bz3O457WmXLrfWJ9T6LNpQtRyREWskfAzw", + "i22H4CgAZZDDyi7cNvaE0uR6NRtk4Pj7cpkzDiSJOe6pUiJltsJEc824OcDIx48JscZkMnqEGBkHYKNz", + "Cwcmb0V4NvnqOkByl6tG/djoFgv+hnhYrQ1lMyKPKA0LZ3wgaNJzAOqiPer7qxNzhMMQxqfEsLkLmhs2", + "5zS+ZpBecieKrZ1UTudefTQkzu6w5duL5VprslfRTVYTykwe6LhAtwPihdgkNq4+KvEuNgtD79HoPozy", + "jx1Mm0b7QJGF2KDLHq8WG022B5ZhODwYgYa/YQrpFfsN3eYWmF3T7pamYlSokGScOa8mlyFxYszUAxLM", + "ELk8DDJjbwRAx9jR1JBzyu9eJbUtnvQv8+ZWmzYVH3zgdOz4Dx2h6C4N4K9vhalzWd91JZaonaLteW6n", + "8QYiZIzoDZvou3v6TiUFOaBSkLSEqOQ85gQ0ug3gjXPquwXGC0wWpnz7KAhnkLBiSkNjjjcXs/cv3bd5", + "kmKNEiGWw6vTpVya9b0Xor6mbBI8dmwt895XcCE0JEsmlU7QlxFdgmn0vUKl+nvTNC4rtQMmbLkulsV5", + "A057DtskY3kVp1c374/HZtq3NUtU1QL5LeMEaLomCywvFw2j2jG1jbTbueA3dsFv6J2td9xpME3NxNKQ", + "S3uOP8m56HDeXewgQoAx4ujv2iBKdzBIlH2OIdexDMhAbrKHMzMNZ7usr73DlPmx9wagWCiG7yg7UnQt", + "gcFg5yoYuomMWMJ0UJ2tn9UzcAZoWbJs07GF2lEHNWZ6LYOHL3vRwQLurhtsDwYCu2cssFiCalc4aQR8", + "W2evlWA8G4WZs3YdkpAhhFMx5avE9hFVJx7sw9UZ0PxH2P5i2uJyJlfTye1MpzFcuxH34Ppdvb1RPKOT", + "35rSWp6Qa6KclqUUFzRPnIF5iDSluHCkic29PfqeWV3cjHn2+ujNOwf+1XSS5kBlUosKg6vCduWfZlW2", + "mMrAAfFVKI3O52V2K0oGm19XgAiN0pdrcBX/Amm0V5qocTgER9EZqZfxWKO9JmfnG7FL3OEjgbJ2kTTm", + "O+shaXtF6AVlubebeWgH4oJwcePqW0W5QjjArb0rgZMsuVN20zvd8dPRUNcenhTOtaMmYWHLbioieNeF", + "bkRINMchqRYUCwtZq0ifOfGqQEtConKWxm2sfKEMcXDrOzONCTYeEEbNiBUbcMXyigVjmWZqhKLbATKY", + "I4pMX6RqCHcL4eqlV5z9qwLCMuDafJJ4KjsHFSs5OWt7/zo1skN/LjewtdA3w99GxgiLanVvPARit4AR", + "eup64B7XKrNfaG2RMj8ELolrOPzDGXtX4g5nvaMPR802DHLd9riF5c37/M8Qhi2Fub+2uldeXXWvgTmi", + "tdKZSpZS/A5xPQ/V40jWgS8jxjDK5Xfgs0jyVpfF1NadpuR7M/vgdg9JN6EVqh2kMED1uPOBWw7rGXkL", + "NeV2q23p4lasW5xgwvjUuR2/IRgHcy+mN6eXCxor9mSEDAPTUeMAbtnStSC+s8e9M/szV9ltRgJfct2W", + "2Xy8EmSTENTP7b+hwGCnHS0qNJIBUm0oE0yt/y9XIjJMxS8ptxWwTT97lFxvBdb4ZXpdConZtCpu9s8g", + "ZQXN45JDlvZNvBlbMVv/uVIQFBh2A9nC+ZaKXJFm62JvUHOyJAfToIS5242MXTDFFjlgiye2xYIq5OS1", + "IaruYpYHXK8VNn86ovm64pmETK+VRawSpBbqUL2pnVcL0JcAnBxguycvyEN02yl2AY8MFt39PDl88gKN", + "rvaPg9gF4Aq97+ImGbKTfzh2Eqdj9FvaMQzjdqPOormh9nWOYca14zTZrmPOErZ0vG7/WSoopyuIR4oU", + "e2CyfXE30ZDWwQvPbGl5paXYEqbj84Omhj8NxLEb9mfBIKkoCqYL59xRojD01FQPtpP64Wydelf4zcPl", + "P6KPtPQuoo4Seb9GU3u/xVaNnuy3tIA2WqeE2hTqnDXRC74cJTnxFRqwEl5dAM/ixsxllo5iDgYzLEkp", + "GdeoWFR6mfyVpGsqaWrY32wI3GTx7fNI9b92FSp+PcDvHe8SFMiLOOrlANl7GcL1JQ+54ElhOEr2qMkb", + "CU7loDM37rYb8h3uHnqsUGZGSQbJrWqRGw049a0Ij+8Y8JakWK/nWvR47ZXdO2VWMk4etDI79PP7N07K", + "KISMlV1qjruTOCRoyeACY/fim2TGvOVeyHzULtwG+i/refAiZyCW+bMcUwReioh26itS1pZ0F6sesQ4M", + "HVPzwZDBwg01Je3qf/fv9PPG577zyXzxsOIfXWC/8JYikv0KBjYxqEwa3c6s/h74vyl5KTZjN7VzQvzG", + "/hugJoqSiuXZL01+Z6fwq6Q8XUf9WQvT8dfmiYp6cfZ+ilY3WlPOIY8OZ2XBX73MGJFq/ynGzlMwPrJt", + "txatXW5ncQ3gbTA9UH5Cg16mczNBiNV2wlsdUJ2vREZwnqaUTsM9+zWMg0qT/6pA6VjyEH6wQV1otzT6", + "ri10SIBnqC3OyA/2ibk1kFalD9TSWFHltmoEZCuQzqBelbmg2ZSYcc5eH70hdlbbxxZat4UWV6iktFfR", + "sVcFVcLGhQf7munx1IXx4+yOpTarVhoL7yhNizKWZmpanPkGmMsa2vBRfQmxMyPHVnNUXi+xkxh6WDJZ", + "GI2rHs3KLkgT5j9a03SNKlmLpQ6T/PgKoZ4qVfAqT11dvy6dhefOwO2KhNoaoVMijN58yZR9WQwuoJ3Z", + "Wqd5O5OAz3RtL09WnFtKicoeu8oQ3ATtHjgbqOHN/FHIOoi/pkBuC+xet2DqKfaK1qLpVl/tPcdjsxvr", + "qun+xciUcsFZipVgYleze6VsjA9sRNGcrpHVH3F3QiOHK1rztQ6Tc1gcrALrGaFDXN8IH3w1m2qpw/6p", + "8TmsNdVkBVo5zgbZ1JcudnZAxhW4Umj4YF3AJ4Vs+RWRQ0Zd1Unt0rgmGWFazIBi97359tap/Rgvfs44", + "CvgObS403Vrq8BElbbQCpslKgHLraecGqw+mzwzTZDPYfJr5R5dwDOuWM8u2Puj+UEfeI+08wKbtK9PW", + "FkVpfm5FINtJj8rSTTpc2DoqD+gNH0RwxLOYeNdOgNx6/HC0HeS2M5QE71NDaHCBjmgo8R7uEUZd5Lnz", + "gIARWi1FYQtiQ7iitRAYj4DxhnFongSLXBBp9ErAjcHzOtBPpZJqKwKO4mlnQHP0PscYmtLO9XDboTob", + "jCjBNfo5hrexqU89wDjqBo3gRvm2fonMUHcgTLzCJxAdIvvVplGqckJUhhkFnfrTMcZhGLevcN++APrH", + "oC8T2e5aUntyrnMTDSWJLqpsBTqhWRarIfkSvxL8SrIKJQfYQFrVNfjKkqRYXaVdbqZPbW6iVHBVFTvm", + "8g1uOV0qYnL0W5xA+ZSJZvAZQfZrWO/x63fvX786Ont9bO8LRVRls0SNzC2hMAxxRk640mBE50oB+S1E", + "42/Y77fOguNgBnXnI0Qb1r73hIi5Most/hurkzdMQC5W5NrRij4wBDteW7xvj9QTzs3RSxRbJeMxgVff", + "7dHRTH2z89j0v9MDmYtVG5B7rmCxixmHexRjw6/N/RYWeOgVf7Q3YF1/AWMDhX8tCLXbOnO4zTzxxu1V", + "g0SfVP0ayW47yfC7IlO8owcihIO6HdSKAdbJORQnnA6GtVPtEuw0JTs55WDSkg0ysulJ9lHsqIF3KLDI", + "xhWZz73e4wTYnjqAY+9EqI9Y6wP0ow+HJSVlzoPfMIs+Zl3g/LBVc9ehaza4uwgXjj5oWIw/7jBcQqcp", + "m4PXQCkUawrWxl59GBkudYYPNwQlgPpj+ViFC0i1EeoDH6wEuE5BIDNZ8EbN11I6A+pHHVXmKujsKpvT", + "L028h9n0MluC7Cxb1nU2vkjMUR1pg/5/fCVmBdw9E9OOWR8dObtcQqrZxZ5Mon8YLbXJUpl6PdY+9xYk", + "FrE6EtM/w39N9boBaFeiz054gtJytwZnKI/gHLYPFGlRQ7TO7NTzvJvUIEAMIHdIDIkIFfNkW8Obcy4y", + "VVMGYsFHjtju0FRzGizwH+TF3XAuT5KEhrlyO6a8EDHNfdRcpuu1MkgxqHAo2ahfYntYEDrGiuaqfnyn", + "fmc/0GrISb/S26WrgYB5X7Wt2VdDAOV/80medpacnUP4BAFa9i+pzHyLqKrqteBkx33UyxDy5aG7QC/r", + "mVkT59fPCYnUDsJozjQXivFVMhQS2w6tC99+xQACvA6wdjnCtQTpnmpBE3IuFCRa+LjAXXDsQoV7p/Qm", + "SFCD9foscINVNN43ZUKwAirFqhnUBUeECzR6KzXQyaCYx/Ccu5D9yn73SRC+AuYIjdzRa7K3GoeP8GSq", + "h8SQ6pfE3Zb7kytuovUyzu1TYypW2YMbVIbW41KKrErtBR0ejMbGMLZuzg5WElUY0/4qe7J/jlWk3gSp", + "auewnVv5O11T3pTzah9rK0LZNQSp4Z3dvlODQFz3yVd2Aas7gfNLKtXTSSlEngyYi0/6BUq6Z+CcpeeQ", + "EXN3+NiogSL/5CFaKWt/4OV66wtylCVwyB7NCDFqeVHqrXcNtmvtdibnD/Su+Tc4a1bZmkFO35995PGw", + "PqzmI2/J3/wwu7maAsP8bjmVHWRP+YvNQHEUSS8jT16MfdE44qzrPkPQEJWFIial3DAXetT57uv8EdIP", + "6vDv1n7CUglNDJa0piOUlrxBpyu8/NRYhMa9COA77AEvVIqDNwE8N3LgfOFAqZ9qpARLGaSE1vL36dn+", + "Ie6aLwVbpDCy3izTFq6xTvb2vgRGFPWqtk3E8dw3YWBdBMGxVkzf9KHQlIglZ0PCMedSXtD8/s0XWDDj", + "CPHhHraKLzTUf0MkW1Sqm0UrvKGj5g503bubmr9Dc8s/wOxR1AbshnJ21PotBl9CEkuj0ZzkonmTBYck", + "lzimNRo/+ZYsXKR1KSFlinWSUC59Ncxa3cPi0M17Z7v1y33r/EXoW5CxUxBESd42lfW0wPuhgbA5ol+Y", + "qQyc3CiVx6ivRxYR/MV4VJjyvOe6OG9Zk22l0k40h5Bwx1blwI19TatyP5l77PJwHXjpVAr66xx9W7dw", + "G7mom7WNdYn0kbur/NoYT0a8qqLpjq4UixAsSUoQVPLbk9+IhCW+OSDI48c4wePHU9f0t6ftz+Y4P34c", + "FePuzYnSevrdzRujmF+Gov9shNtAoGlnPyqWZ/sIoxU23Lz/gYGxv7rEgS/yAsmv1p7aP6qudvt13Lfd", + "TUDERNbamjyYKggIHhEL7LrNoo/zK0gryfQW6xl48xv7NVon6ofaYu88PnUGrLv7tDiHuiJGY9+vlL9d", + "fxD2Mf/CyNToPNf4GNzrDS3KHNxB+e7B4i/w7K/Ps4NnT/6y+OvBNwcpPP/mxcEBffGcPnnx7Ak8/es3", + "zw/gyfLbF4un2dPnTxfPnz7/9psX6bPnTxbPv33xlweGDxmQLaATnz03+d/4TE9y9O4kOTPANjihJavf", + "gDRk7F8IoCmeRCgoyyeH/qf/6U/YLBVFM7z/deKScyZrrUt1OJ9fXl7Owi7zFRr0Ei2qdD338/Tf3nt3", + "UgdY24Rv3FEbO2tIATfVkcIRfnv/+vSMHL07mTUEMzmcHMwOZk/wZa0SOC3Z5HDyDH/C07PGfZ87Ypsc", + "fr6aTuZroDn6v8wfBWjJUv9JXdLVCuTMPZVgfrp4OveixPyzM2Ze7fo2D6uOzj+3bL7Znp5YlXD+2Sfb", + "727dymZ3tu6gw0godjWbLzCHZ2xTUEHj4aXYV77nn1FEHvx97hIb4h9RVbFnYO4dI/GWLSx91hsDa6eH", + "e0R2/rl51TkAywb2z+0rZs3PvYrWK4hmGGCsP931PCnSriX7kwy5ke69torlMa2xEkn66cHBn+Ph1efX", + "BHSnJaQVBxMB5iXNiE/2wLmf3N/cJxz9ooZDEcuBEYLn9wdBuxbpj7Alb4Um36OqcDWdfHOfO3HCjeBC", + "c4Itg1ID/SPyMz/n4pL7lubqroqCyu3o46PpSqGpTrIL6gSnoDz15BPahm3gYvuoHWVZj+itCANKvxTZ", + "dgfGCrUqXXBug7RGgmPcLKGvAvbf++q9jnoOW2I9Z95C6l4Hb2QrLSu4uiVP+NM+5PqVp3zlKdJO/+z+", + "pj8FecFSIGdQlEJSyfIt+ZnXqVU35nFHWRaNSmof/b08zmjHqchgBTxxDCxZiGzry0e1JjgHq6z1BJn5", + "53YNWCu4TTLIQUcjLszv9etc/UUstuTkuCfh2G5dzvtyi02D2qqHHz5bbceI8o0y0gWxxxnDsp5d3vQp", + "zjV3kb1ZyEpoYrGQuUV9ZURfGdGthJvRh2eMfBPVPmziMu3d2VOfgxyrPkF1H5QxOsoXPb53svF9/Sem", + "79joLshI8MGGIXfR/JVFfGURt2MRP0DkMOKpdUwjQnTX04fGMgwMbMm6Ly2gwd83r3IqiYKxZo4jHNEZ", + "N+6Da9y3UhfFldXpKG8eo4ls4N3qeV9Z3leW9+dheUf7GU1bMLm1ZnQO24KWtT6k1pXOxGVg/0dYbDxO", + "32pdv/3W+nt+SZlOlkK6XAGsRNrvrIHmc1dIofNrkxTY+4KZjsGPgYU7/uu8LvQc/dh1HcS+OtO5b9T4", + "BkNfG/Lu2sv24ZPhu1gn0LH1xnV0OJ9jgO1aKD2fXE0/d9xK4cdP9R5/ri8Dt9dXn67+fwAAAP//ROgk", + "pRK6AAA=", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/daemon/algod/api/server/v2/generated/participating/public/routes.go b/daemon/algod/api/server/v2/generated/participating/public/routes.go index 01f0e69dad..541e80e663 100644 --- a/daemon/algod/api/server/v2/generated/participating/public/routes.go +++ b/daemon/algod/api/server/v2/generated/participating/public/routes.go @@ -214,130 +214,131 @@ var swaggerSpec = []string{ "wxvc7OT8dr2R1bl5x+xLG/nekqhICTLRG04yWFSrlia0lKIglGTYEe/oV2y11oHI8lYKsbz1Wzs6S2xJ", "+MEKfLnp0xf73ogMjNpdqVtg781gDfYM5YQ4owtRaUIJFxmgjl6pOOMfcPSihwkdYzq8S/TaynALMPpg", "Siuz2qok6Pbp0WLTMaGppaIEUaMG7OK1Q8O2stNZJ2IugWZGTwROxMIZn51ZHBdJ0WelPet0105Ec27B", - "VUqRglJGv7da217QfDtLlnoHnhBwBLiehShBllReE1gtNM33AIptYuDWIrmz2PehHjf9rg3sTh5uI5VG", - "xbdUYOR/c+By0DCEwpE4uQCJluvfdf/8JNfdvqociCtxotUpK9BSwCkXClLBMxUdLKdKJ/uOrWnUkv/M", - "CoKTEjupOPCAteoVVdr6LxjPUO2y7AbnsWYsM8UwwINXoBn5J3/79cdODZ/kqlL1VaiqshRSQxZbA4fN", - "jrnewKaeSyyDsev7VgtSKdg38hCWgvEdsuxKLIKors18zsHXXxwaw8w9sI2isgVEg4hdgJz4VgF2Q9/6", - "ACBGR697IuEw1aGc2qE/nSgtytKcP51UvO43hKYT2/pI/9i07RMX1Q1fzwSY2bWHyUF+aTFroyrW1Ajt", - "ODIp6Lm5m1AEt46WPszmMCaK8RSSXZRvjuWJaRUegT2HdED7cXFbwWydw9Gh3yjRDRLBnl0YWvCAKvaW", - "Ss1SVqIk8VfY3rpg1Z0gaiAkGWjKjHoQfLBCVhn2J9Zz1h3zeoLWKKm5D35PbI4sJ2cKL4w28OewRU/B", - "WxuScRoEctyCpBgZ1ZxuygkC6h295kIOm8CGpjrfmmtOr2FLLkECUdWiYFrbGJu2IKlFmYQDRC0SO2Z0", - "5jcbzuB3YIw98ASHCpbX34rpxIotu+E77QguLXQ4gakUIh/hiekhIwrBKE8NKYXZdeZCunzcj6ekFpBO", - "iEHba80876gWmnEF5P+IiqSUowBWaahvBCGRzeL1a2YwF1g9p/PJNBiCHAqwciV+uX+/u/D7992eM0WW", - "cOnjIE3DLjru30ct6a1QunW4bkFFN8ftOMLb0VRjLgonw3V5yn6fgBt5zE6+7Qxe23fMmVLKEa5Z/o0Z", - "QOdkbsasPaSRcf4QHHeUFSYYOrZu3Hd0SP8+OnwzdAy6/sSBG6/5OOTJM/JVvr0FPm0HIhJKCQpPVaiX", - "KPtVLMNQWXfs1FZpKPqqve3684Bg886LBT0pU/CccUgKwWEbzQ5hHF7jx1hve7IHOiOPHerbFZta8HfA", - "as8zhgpvil/c7YCU39Yu7FvY/O64HatOGCSMWinkJaEkzRnqrIIrLatUn3GKUnFwliOmfi/rD+tJz32T", - "uGIW0ZvcUGecopunlpWj5sklRLTg7wC8uqSq1QqU7sgHS4Az7loxTirONM5VmP1K7IaVINHePrMtC7ol", - "S5qjWvcbSEEWlW7fmBjLqLTRuqyJyUxDxPKMU01yMBroa8ZPNzicDxn0NMNBXwp5XmNhFj0PK+CgmEri", - "Lonv7Vf0Frvlr53nGBNL7GdrRDHjNwGPWw2tZIn/e/c/D98fJf9Nk98Okqf/Mf/w8fGne/d7Pz789O23", - "/6/906NP3977z3+P7ZSHPRZp5yA/fuGkyeMXKDI0xqUe7J/N4lAwnkSJ7HQNpGAcA7Y7tEXuGsHHE9C9", - "xkzldv2M6w03hHRBc5ZRfT1y6LK43lm0p6NDNa2N6CiQfq0fYt7zlUhKmp6jR2+yYnpdLWapKOZeip6v", - "RC1RzzMKheD4LZvTks1VCen84sGeK/0G/IpE2FWHyV5bIOj7A+PRsWiydAGvePKWFbdEUSlnpMTgL++X", - "EctpHQFtMx8PCYbHrql3Kro/Hz75ZjJtwlrr70ZTt18/RM4Eyzax4OUMNjFJzR01PGJ3FCnpVoGO8yGE", - "PeqCsn6LcNgCjIiv1qz8/DxHabaI80ofUuM0vg0/5jbWxZxENM9undVHLD8/3FoCZFDqdSwjqiVzYKtm", - "NwE6LpVSigvgU8JmMOtqXNkKlHeG5UCXmJmDJkYxJkSwPgeW0DxVBFgPFzJKrYnRD4rJju9/mk6cGKFu", - "XbJ3A8fg6s5Z22L931qQO9+/PCVzx3rVHRtHb4cOIp8jlgwX3NdythluZvNAbSLBGT/jL2DJODPfD894", - "RjWdL6hiqZpXCuQzmlOewmwlyKGPF3xBNT3jPZltMFU7iNQkZbXIWUrOQ9m6IU+bftcf4ezsveH4Z2cf", - "ep6bviTsporyFztBcsn0WlQ6cflFiYRLKrMI6KrOL8GRbXbgrlmnxI1tWbHLX3Ljx3keLUvVjTPvL78s", - "c7P8gAyVi6I2W0aUFtJLNUbUsdDg/r4R7mKQ9NInp1UKFPmloOV7xvUHkpxVBwePgLQCr39xwoOhyW0J", - "LZvXteLgu/YuXLjVkGCjJU1KugIVXb4GWuLuo+RdoHU1zwl2awV8+4AWHKpZgMfH8AZYOK4cvIqLO7G9", - "fKJ4fAn4CbcQ2xhxo3FaXHe/ghDwa29XJ4y8t0uVXifmbEdXpQyJ+52p80dXRsjyniTFVtwcApdquwCS", - "riE9hwyz/qAo9Xba6u6dlU5k9ayDKZsdawM4MYULzYMLIFWZUSfUU77t5tIo0NonEL2Dc9ieiiYD7CrJ", - "M+1cDjV0UJFSA+nSEGt4bN0Y3c13jm+MXy9LnxKBsbGeLA5ruvB9hg+yFXlv4RDHiKKVazCECCojiLDE", - "P4CCayzUjHcj0o8tz+grC3vzRZJpPe8nrkmjhjnndbgaTKGw3wvAVHtxqciCGrlduCxxm68QcLFK0RUM", - "SMihhXZkVkDLqouD7Lv3ojedWHYvtN59EwXZNk7MmqOUAuaLIRVUZjohC34m6wTAFcwIFn9xCFvkKCbV", - "0RKW6VDZspTbahZDoMUJGCRvBA4PRhsjoWSzpsonsGOevz/Lo2SA3zH/ZlfW5XHgbQ+S+eucSs9zu+e0", - "p1263EufcOmzLEPVckTGpJHwMQAsth2CowCUQQ4ru3Db2BNKkwvUbJCB44flMmccSBJz3FOlRMpsBYLm", - "mnFzgJGP7xNijclk9AgxMg7ARucWDkzeiPBs8tVVgOQul4n6sdEtFvwN8bBLG5plRB5RGhbO+EBQnecA", - "1EV71PdXJ+YIhyGMT4lhcxc0N2zOaXzNIL3kPxRbO6l+zr16b0ic3WHLtxfLldZkr6LrrCaUmTzQcYFu", - "B8QLsUls3HVU4l1sFobeo9FqGAUeO5g2zfKOIguxQZc9Xi1Yv0TtgWUYDg9GoOFvmEJ6xX5Dt7kFZte0", - "u6WpGBUqJBlnzqvJZUicGDP1gAQzRC53g8zJawHQMXY0Ncac8rtXSW2LJ/3LvLnVpk1FAB9YGzv+Q0co", - "uksD+OtbYepcx7ddiSVqp2h7nttpnoEIGSN6wyb67p6+U0lBDqgUJC0hKjmPOQGNbgN445z4boHxApNJ", - "Kd/eC8IZJKyY0tCY483F7P1Ln9s8SbGGhRDL4dXpUi7N+t4JUV9TNkkaO7aW+dlXcCE0JEsmlU7QlxFd", - "gmn0nUKl+jvTNC4rtQMmbDknlsV5A057DtskY3kVp1c3719fmGnf1CxRVQvkt4wToOmaLLD8WDSMasfU", - "NtJu54Jf2QW/ore23nGnwTQ1E0tDLu05/iDnosN5d7GDCAHGiKO/a4Mo3cEgUfZ5AbmOZcgFcpM9nJlp", - "ONtlfe0dpsyPvTcAxUIxfEfZkaJrCQwGO1fB0E1kxBKmg+pd/ayPgTNAy5Jlm44t1I46qDHTKxk8fFmE", - "DhZwd91gezAQ2D1jgcUSVLsCRiPg2zpsrQTU2SjMnLbrVIQMIZyKKV9FtI8oQ9ooKu7D1SnQ/K+w/cm0", - "xeVMPk0nNzOdxnDtRtyD67f19kbxjE5+a0preUKuiHJallJc0DxxBuYh0pTiwpEmNvf26M/M6uJmzNOX", - "R6/eOvA/TSdpDlQmtagwuCpsV/5hVmWLbQwcEF+l0Oh8Xma3omSw+XWFgNAofbkGVxEukEZ7pWsah0Nw", - "FJ2RehmPNdprcna+EbvEHT4SKGsXSWO+sx6StleEXlCWe7uZh3YgLggXN67+UZQrhAPc2LsSOMmSW2U3", - "vdMdPx0Nde3hSeFcO2rWFbYsoyKCd13oRoREcxySakGx8Iy1ivSZE68KtCQkKmdp3MbKF8oQB7e+M9OY", - "YOMBYdSMWLEBVyyvWDCWaaZGKLodIIM5osj0RYyGcLcQrp52xdmvFRCWAdfmk8RT2TmoWOnHWdv716mR", - "HfpzuYGthb4Z/iYyRlh0qXvjIRC7BYzQU9cD90WtMvuF1hYp80PgkriCwz+csXcl7nDWO/pw1GzDINdt", - "j1tY/rrP/wxh2FKJ+2tve+XVVX8amCNaS5upZCnFbxDX81A9jmQd+DJTDKNcfgM+iyRvdVlMbd1pSoI3", - "sw9u95B0E1qh2kEKA1SPOx+45bDejbdQU2632pa2bcW6xQkmjE+d2/EbgnEw92J6c3q5oLFiQEbIMDAd", - "NQ7gli1dC+I7e9w7sz9zlb9mJPAl122ZzccrQTYJQf3c72sKDHba0aJCIxkg1YYywdT6/3IlIsNU/JJy", - "WyHZ9LNHyfVWYI1fptelkJhNq+Jm/wxSVtA8Ljlkad/Em7EVs/WBKwVBAVo3kC2sbqnIFfG1LvYGNcdL", - "cjANSly73cjYBVNskQO2eGBbLKhCTl4bououZnnA9Vph84cjmq8rnknI9FpZxCpBaqEO1ZvaebUAfQnA", - "yQG2e/CU3EW3nWIXcM9g0d3Pk8MHT9Hoav84iF0ArhD4Lm6SITv5m2MncTpGv6UdwzBuN+osmhtqX28Y", - "Zlw7TpPtOuYsYUvH6/afpYJyuoJ4pEixBybbF3cTDWkdvPDMlh5XWootYTo+P2hq+NNAHLthfxYMkoqi", - "YLpwzh0lCkNPTXVZO6kfztYxd4XBPFz+I/pIS+8i6iiRn9doau+32KrRk/2GFtBG65RQm0KdsyZ6wZcr", - "JMe+EANWSqsLpFncmLnM0lHMwWCGJSkl4xoVi0ovkz+TdE0lTQ37mw2Bmyy+eRypDteuUsSvBvhnx7sE", - "BfIijno5QPZehnB9yV0ueFIYjpLda/JGglM56MyNu+2GfIe7hx4rlJlRkkFyq1rkRgNOfSPC4zsGvCEp", - "1uu5Ej1eeWWfnTIrGScPWpkd+vHdKydlFELGyvI0x91JHBK0ZHCBsXvxTTJj3nAvZD5qF24C/Zf1PHiR", - "MxDL/FmOKQLPREQ79RULa0u6i1WPWAeGjqn5YMhg4YaaknZ1uM/v9PPG577zyXzxsOIfXWC/8JYikv0K", - "BjYxqFwZ3c6s/h74vyl5JjZjN7VzQvzG/hOgJoqSiuXZT01+Z6cwqKQ8XUf9WQvT8efmCYN6cfZ+ilY3", - "WlPOIY8OZ2XBn73MGJFq/yHGzlMwPrJtt1apXW5ncQ3gbTA9UH5Cg16mczNBiNV2wlsdUJ2vREZwnqaU", - "TsM9+zVug0qEv1agdCx5CD/YoC60Wxp91xbCI8Az1BZn5Hv7BNkaSKvSB2pprKhyWzUCshVIZ1CvylzQ", - "bErMOKcvj14RO6vtYwtx20J8K1RS2qvo2KuCulvjwoN9Te146sL4cXbHUptVK42Fd5SmRRlLMzUtTn0D", - "zGUNbfiovoTYmZEXVnNUXi+xkxh6WDJZGI2rHs3KLkgT5j9a03SNKlmLpQ6T/PgKkp4qVfBqS119vS6d", - "hefOwO2KSNoaklMijN58yZR9eQouoJ3ZWqd5O5OAz3RtL09WnFtKicoeu8oQXAftHjgbqOHN/FHIOoi/", - "okBuC7BetaDmCfaK1qLpVufsPddisxvrqtr+RcGUcsFZipVgYleze8VqjA9sRNGcrpHVH3F3QiOHK1oT", - "tA6Tc1gcrBLqGaFDXN8IH3w1m2qpw/6p8bmkNdVkBVo5zgbZ1Je2dXZAxhW4Umj4oFnAJ4Vs+RWRQ0Zd", - "1Unt0rgiGWFazIBi95359sap/Rgvfs44CvgObS403Vrq8JEdbbQCpslKgHLraecGq/emzwzTZDPYfJj5", - "R3lwDOuWM8u2Puj+UEfeI+08wKbtc9PWFkVpfm5FINtJj8rSTTpc+DgqD+gNH0RwxLOYeNdOgNx6/HC0", - "HeS2M5QE71NDaHCBjmgo8R7uEUZdBLhTYN4IrZaisAWxIVzRWgiMR8B4xTg0T0ZFLog0eiXgxuB5Hein", - "Ukm1FQFH8bRToDl6n2MMTWnnerjpUJ0NRpTgGv0cw9vY1C8eYBx1g0Zwo3xbv1RlqDsQJp7jE3kOkf1q", - "xChVOSEqw4yCTn3iGOMwjNtXQG9fAP1j0JeJbHctqT05V7mJhpJEF1W2Ap3QLIvVkHyGXwl+JVmFkgNs", - "IK3qGnxlSVKsrtIuN9OnNjdRKriqih1z+QY3nC4VMTn6DU6gfMpEM/iMIPs1rPfFy7fvXj4/On35wt4X", - "iqjKZokamVtCYRjijBxzpcGIzpUC8kuIxl+w3y+dBcfBDOqSR4g2rI3uCRFzZRZb/DdWJ2+YgFysyJWj", - "FX1gCHa8snjfHqknnJujlyi2SsZjAq++m6Ojmfp657Hpf6sHMherNiCfuYLFLmYc7lGMDb8091tY4KFX", - "/NHegHX9BYwNFP41GdRu68zhNvPEG7dXDRJ9UvVrFbvtJMPvTkzxjh6IEA7qdlArBlgn51CccDoY1k61", - "S7DTlOzklINJSzbIyKYn2UeTowbeocAiG1dkPvd6jxNge+oAjr0ToT5irQ/QX304LCkpcx78hln0MesC", - "54etmrsOXbPB3UW4cPRBw2K8+P9wCZ2mbA5eA6VQrClYG3sVYGS41CkW9g9KAPXH8rEKF5BqI9QHPlgJ", - "cJWCQGay4A2Tr6V0BtSPOqrMVdDZVTanX5p4D7PpZbYE2Vm2rOtsfJGYozrSBv3/+IrICrh7RqQdsz46", - "cna5hFSziz2ZRH8zWmqTpTL1eqx9DixILGJ1JKZ/pv2K6nUD0K5En53wBKXlbgzOUB7BOWzvKNKihmid", - "2annedepQYAYQO6QGBIRKubJtoY351xkqqYMxIKPHLHdoanmNFjgP8iLu+ZcniQJDXPldkx5IWKa+6i5", - "TNcrZZBiUOFQslG/xPawIPQCK5qr+nGW+h32QKshx/1Kb5euBgLmfdW2Zl8NAZT/zSd52lns+/7NEwRo", - "2b+kMvMtoqqq14KTHfdRL0PIl4fuAr2sZ2ZNnF8/JyRSOwijOdNcKMZXyVBIbDu0LnwbFAMI8DrA2uUI", - "1xKke3oETci5UJBo4eMCd8GxCxXuHcvrIEEN1uuzwA1W0XjXlAnBCqgUq2ZQFxwRLtDordRAJ4NiHsNz", - "7kL2c/vdJ0H4CpgjNHJHr8neahw+wpOpHhJDql8Sd1vuT664jtbLOLdPUalYZQ9uUBlaj0spsiq1F3R4", - "MBobw9i6OTtYSVRhTPur7Mn+OVaRehWkqp3Ddm7l73RNeVPOq32srQhl1xCkhnd2+1YNAnHdJ1/ZBaxu", - "Bc4vqVRPJ6UQeTJgLj7uFyjpnoFzlp5DRszd4WOjBor8k7topaz9gZfrrS/IUZbAIbs3I8So5UWpt941", - "2K6125mc39G75t/grFllawY5fX92xuNhfVjNR96Qv/lhdnM1BYb53XAqO8ie8hebgeIokl5GnrwY++Jt", - "xFnXfYagISoLRUxKuWYu9Kjz3df5I6Qf1OHfrf2EpRKaGCxpTUcoLXmDTld4ed1YhMa9COA77AEvVIqD", - "NwE8N3LgfOFAqdc1UoKlDFJCa/n79Gz/UHPNl4ItUhhZb5ZpC9dYJ3t7XwIjinpe2ybieO6bMLAuguBY", - "K6Zv+lBoSsSSsyHhmHMpL2j++c0XWDDjCPHhHraKLzTUf0MkW1Sq60UrvKKj5g503dubmr9Fc8vfwOxR", - "1AbshnJ21PotBl9CEkuj0ZzkonmTBYcklzimNRo/+IYsXKR1KSFlinWSUC59Ncxa3cPi0M17Z7v1y33r", - "/EnoG5CxUxBESd40lfW0wPuhgbA5ol+YqQyc3CiVx6ivRxYR/MV4VJjyvOe6OG9Zk22l0k40h5Bwy1bl", - "wI19RatyP5l77PJwHXjpVAr66xx9W7dwG7mom7WNdYn0kbur/NoYT0a8qqLpjq4UixAsSUoQVPLLg1+I", - "hCW+OSDI/fs4wf37U9f0l4ftz+Y4378fFeM+mxOl9TS4mzdGMT8NRf/ZCLeBQNPOflQsz/YRRitsuHn/", - "AwNjf3aJA1/kBZKfrT21f1Rd7faruG+7m4CIiay1NXkwVRAQPCIW2HWbRR9vV5BWkukt1jPw5jf2c7RO", - "1Pe1xd55fOoMWHf3aXEOdUWMxr5fKX+7fi/sY++FkanRea7xMbiXG1qUObiD8u2dxZ/g0Z8fZwePHvxp", - "8eeDJwcpPH7y9OCAPn1MHzx99AAe/vnJ4wN4sPzm6eJh9vDxw8Xjh4+/efI0ffT4weLxN0//dMfwIQOy", - "BXTis+cmf8dnepKjt8fJqQG2wQktWf0GpCFj/0IATfEkQkFZPjn0P/1vf8JmqSia4f2vE5ecM1lrXarD", - "+fzy8nIWdpmv0KCXaFGl67mfp//23tvjOsDaJnzjjtrYWUMKuKmOFI7w27uXJ6fk6O3xrCGYyeHkYHYw", - "e4Ava5XAackmh5NH+BOenjXu+9wR2+Tw46fpZL4GmqP/y/xRgJYs9Z/UJV2tQM7cUwnmp4uHcy9KzD86", - "Y+anXd/mYdXR+ceWzTfb0xOrEs4/+mT73a1b2ezO1m2Wu4qVoPgegqcHg5LILVvbYuvNtVOi6vdpS8mE", - "OUlTcy1mkEqgSPdCYoBz84ih01/APsj7+ujvaG1/ffR38i05mLq4d4WqRmx6a8+oSeA4s2BHHtl8tj2q", - "vQdBKa7D97F3MWNPOOARMvQRUHg9YsPBtKwgLBHV8GPDYw+Spx8+Pvnzp5ic13+EzCNp4BFMLXxCOiKt", - "oJtvh1C2sacD1/BrBXLbLKKgm0kIcN8HE3mPbMlWlew8XVyHkrhK/kyR/zr54Q0Rkji99i1Nz8NQ6Rg4", - "7j4LIfKFlV1AdaFWZTv6sMbhB8xQRSjwFD88OPj6VOv/jKdap62t9TTydXe/PsT7r/EQ7+MrsrKd5uFW", - "cOCos3OV4Xqb9Zpu6koklHDBE44l4i+ABHre44MHf9gVHnOMcDGyJrGy9Kfp5MkfeMuOuZFaaE6wpV3N", - "oz/sak5AXrAUyCkUpZBUsnxLfuR1iltQ1qbP/n7k51xcco8IoyZWRUHl1knItOY5FQ+SDnfyn55zsJGi", - "kYvSlUI/Esqfk9ZTKHw1+fDJC/gjtYZdzeYLzLkf2xRU0HhY9UCHgJp/RJP24O9zl4gc/4iuBauzzn0g", - "U7xlS6v5qDcG1k6PlOp0XZXzj/gf1CEDsGwi7ty+Otz83H2BJvbz/GO7AnILDWpd6UxcBn3R1G39NH3s", - "1G+CtP6eX1Kmzb3uYsiwQlW/swaaz12CXefXJli89wUj4IMfO5JA6XI32hrWO3oZyhX2jgeln4lsu4NH", - "bJIF43hwwoPdGLDsx75U33/udA22sKP3AUbEJi3IQgqapVRh4SOXitrT1T7dUGX4Iz7u/nvKEj2IntGM", - "+KT5hLymudlwyMiRk1hb2Pi95YAvf3F/4Zv2s12Nz/zhU4RiwEXncAbp4WOuPKPjmLO+Ap44bpMsRLb1", - "lS4lvdQbG4nR5WPzumRp9OMtGMH+uS1f+wxeX+1MX+1MXy0RX+1MX3f3q53pqxXmqxXmf6wV5iqml5gM", - "6UwPw6Ik1gSjrXmtjkabXKKaxYfNpoTpWuDql39kekbIKWZqUHNLwAVImmOJbBWkXhUYs6eqNAXIDs94", - "0oLERsaZie82/7Uhie4F4oN73T5KszwPeXO/Lwqz+MkmnH9LziZnk95IWMwBMpsAGkau2157h/1f9bg/", - "9JJgMHcQ3730sfZEVcslS5lFeS74itCVaMJpDd8mXOAXwEoTNpWYMD11jy4wRS7N4l1ltnaAfVss70sA", - "x80W7nVHd8gl7ok2hHdFN/R/jPFB/+uK4NfN+rkpl9w5do9lfmUZn4NlfHGm8Ud38AU2vn9JGfLxweM/", - "7IJCi/Abocl3GAd+M1mrLmUZS5ceLUU1waJh8CXegXXY5fsPhtNj4Xh3PTaxhIfzOWZcroXS84m5vNpx", - "huHHDzVQvqLwpJTsAiv/fPj0/wMAAP//rlT5XEPGAAA=", + "VUqRglJGv7da217QfDtLlnoHnhBwBLiehShBllTeGNjzi71wnsM2QQ+rInf/+pO69wXg1ULTfA9isU0M", + "vbUK4TwMfajHTb+L4LqTh2RHJRDP+4y+YhhEDhqGUHglnAzuXxei3i7eHC0XINHW/7tSvJ/kZgRUg/o7", + "0/tNoa3KgbghJzqfsgItQZxyoSAVPFPRwXKqdLKPLZtGLfnerCDghDFOjAMPWCNfUaWtf4rxDNVqe53g", + "PNZMaaYYBnhQxDEj/+Slm/7YqbkHuapULeqoqiyF1JDF1sBhs2OuN7Cp5xLLYOxantKCVAr2jTyEpWB8", + "hyy7EosgqmszrnPg9heHxk5zz2+jqGwB0SBiFyAnvlWA3TB2YgAQphpEW8JhqkM5dcDGdKK0KEvDLXRS", + "8brfEJpObOsj/WPTtk9cVDf3dibAzK49TA7yS4tZGzWzpkYpw5FJQc+N7IEqlnWk9WE2hzFRjKeQ7KJ8", + "cyxPTKvwCOw5pAParYvLC2brHI4O/UaJbpAI9uzC0IIHVO23VGqWshIlxb/C9tYF5+4EUQMwyUBTZtS/", + "4IMVosuwP7Ge0e6Y1xOkR2lFffB7alFkOTlTeGG0gT+HLXqC3tqQm9MgUOcWNIHIqOZ0U04QUO/INwJM", + "2AQ2NNX51lxzeg1bcgkSiKoWBdPaxlC1FQUtyiQcIGpx2jGjM6/acBW/A2PsvSc4VLC8/lZMJ1ai2g3f", + "aUesaqHDSVKlEPkIT1sPGVEIRnniSCnMrjMXsufjujwltYB0Qgza1mvmeUe10IwrIP9HVCSlHAXWSkN9", + "IwiJbBavXzODucDqOZ3PrcEQ5FCAlcPxy/373YXfv+/2nCmyhEsf52oadtFx/z5qwW+F0q3DdQsmGHPc", + "jiO8HU1x5qJwMlyXp+z3+biRx+zk287gtf3OnCmlHOGa5d+YAXRO5mbM2kMaGefvwnFHWdmCoWPrxn3H", + "gIPfx0bTDB2Drj9x4KZtPg55ao18lW9vgU/bgYiEUoLCUxXqJcp+FcswFNodO7VVGoq+6cZ2/XlAsHnn", + "xYKelCl4zjgkheCwjWb/MA6v8WOstz3ZA52Rxw717YpNLfg7YLXnGUOFN8Uv7nZAym/rEIVb2PzuuB2r", + "XRgEjlop5CWhJM0Z6qyCKy2rVJ9xilJxcJYjrhwv6w/rSc99k7hiFtGb3FBnnKIbr5aVo+bnJUS04O8A", + "vLqkqtUKlO7IB0uAM+5aMU4qzjTOVZj9SuyGlSDRnzKzLQu6JUuao1r3G0hBFpVu35gYq6q00bqsCdFM", + "Q8TyjFNNcjAa6GvGTzc4nA8J9TTDQV8KeV5jYRY9DyvgoJhK4i6n7+1XjAZwy1+7yABMHLKfrdHJjN8E", + "tG41tJJh/u/d/zx8f5T8N01+O0ie/sf8w8fHn+7d7/348NO33/6/9k+PPn177z//PbZTHvZYJKWD/PiF", + "kyaPX6DI0FiderB/NotDwXgSJbLTNZCCcQzI79AWuWsEH09A9xqzntv1M6433BDSBc1ZRvX1yKHL4npn", + "0Z6ODtW0NqKjQPq1fohFR6xEUtL0HD22kxXT62oxS0Ux91L0fCVqiXqeUSgEx2/ZnJZsrkpI5xcP9lzp", + "N+BXJMKuOkz22gJB398bj35Gg6oLaMaTt6y4JYpKOaMuBvd5v5tYTusId5vZekgw/HlNvdPY/fnwyTeT", + "aRO2XH83mrr9+iFyJli2iQWnZ7CJSWruqOERu6NISbcKdJwPIexRF6P1S4XDFmBEfLVm5efnOUqzRZxX", + "+pApp/Ft+DG3sUzmJKJ5duusPmL5+eHWEiCDUq9jGW8tmQNbNbsJ0HGZlVJcAJ8SNoNZV+PKVqC8szMH", + "usTMKzQxijEhoPU5sITmqSLAeriQUWpNjH5QTHZ8/9N04sQIdeuSvRs4Bld3ztoW6//Wgtz5/uUpmTvW", + "q+7YPAk7dBDZHrFkuODNljPVcDOb52sTRc74GX8BS8aZ+X54xjOq6XxBFUvVvFIgn9Gc8hRmK0EOfTzo", + "C6rpGe/JbIOp+EEkLimrRc5Sch7K1g152vTK/ghnZ+8Nxz87+9DzK/UlYTdVlL/YCZJLptei0onLH0sk", + "XFKZRUBXdf4QjmyzP3fNOiVubMuKXX6aGz/O82hZqm4eQX/5ZZmb5QdkqFyUvNkyorSQXqoxoo6FBvf3", + "jXAXg6SXPvmwUqDILwUt3zOuP5DkrDo4eASkFVj/ixMeDE1uS2jZvK6V59C1d+HCrYYEGy1pUtIVqOjy", + "NdASdx8l7wKtq3lOsFsroN8HLOFQzQI8PoY3wMJx5eBkXNyJ7eULAcSXgJ9wC7GNETcap8V19ysI8b/2", + "dnXSBHq7VOl1Ys52dFXKkLjfmTo/eGWELO9JUmzFzSFwqdQLIOka0nPIMKsTilJvp63u3lnpRFbPOpiy", + "2c82QBdT9NA8uABSlRl1Qj3l226ulAKtfYLYOziH7aloMvyukhzVztVRQwcVKTWQLg2xhsfWjdHdfOcR", + "x/yEsvQpLxj77MnisKYL32f4IFuR9xYOcYwoWrkkQ4igMoIIS/wDKLjGQs14NyL92PKMvrKwN18kWdrz", + "fuKaNGqYc16Hq8EUGfu9ACylIC4VWVAjtwtXBcDmowRcrFJ0BQMScmihHZn10bLq4iD77r3oTSeW3Qut", + "d99EQbaNE7PmKKWA+WJIBZWZTsiCn8k6AXAFM4LFfRzCFjmKSXVsh2U6VLYs5bZayRBocQIGyRuBw4PR", + "xkgo2ayp8gUKsI6DP8ujZIDfMb9qV1btceBtD4o11Dmznud2z2lPu3S5tT6h1mfRhqrliIxYI+FjgF9s", + "OwRHASiDHFZ24baxJ5Qm16vZIAPHD8tlzjiQJOa4p0qJlNkKE8014+YAIx/fJ8Qak8noEWJkHICNzi0c", + "mLwR4dnkq6sAyV2uGvVjo1ss+BviYbU2lM2IPKI0LJzxgaBJzwGoi/ao769OzBEOQxifEsPmLmhu2JzT", + "+JpBesmdKLZ2Ujmde/XekDi7w5ZvL5YrrcleRddZTSgzeaDjAt0OiBdik9i4+qjEu9gsDL1Ho/swyj92", + "MG0a7R1FFmKDLnu8Wmw02R5YhuHwYAQa/oYppFfsN3SbW2B2TbtbmopRoUKScea8mlyGxIkxUw9IMEPk", + "cjfIjL0WAB1jR1NDzim/e5XUtnjSv8ybW23aVHzwgdOx4z90hKK7NIC/vhWmzmV925VYonaKtue5ncYb", + "iJAxojdsou/u6TuVFOSASkHSEqKS85gT0Og2gDfOie8WGC8wWZjy7b0gnEHCiikNjTneXMzev/S5zZMU", + "a5QIsRxenS7l0qzvnRD1NWWT4LFja5mffQUXQkOyZFLpBH0Z0SWYRt8pVKq/M03jslI7YMKW62JZnDfg", + "tOewTTKWV3F6dfP+9YWZ9k3NElW1QH7LOAGarskCy8tFw6h2TG0j7XYu+JVd8Ct6a+sddxpMUzOxNOTS", + "nuMPci46nHcXO4gQYIw4+rs2iNIdDBJlnxeQ61gGZCA32cOZmYazXdbX3mHK/Nh7A1AsFMN3lB0pupbA", + "YLBzFQzdREYsYTqoztbP6hk4A7QsWbbp2ELtqIMaM72SwcOXvehgAXfXDbYHA4HdMxZYLEG1K5w0Ar6t", + "s9dKMJ6Nwsxpuw5JyBDCqZjyVWL7iKoTD/bh6hRo/lfY/mTa4nImn6aTm5lOY7h2I+7B9dt6e6N4Rie/", + "NaW1PCFXRDktSykuaJ44A/MQaUpx4UgTm3t79GdmdXEz5unLo1dvHfifppM0ByqTWlQYXBW2K/8wq7LF", + "VAYOiK9CaXQ+L7NbUTLY/LoCRGiUvlyDq/gXSKO90kSNwyE4is5IvYzHGu01OTvfiF3iDh8JlLWLpDHf", + "WQ9J2ytCLyjLvd3MQzsQF4SLG1ffKsoVwgFu7F0JnGTJrbKb3umOn46GuvbwpHCuHTUJC1t2UxHBuy50", + "I0KiOQ5JtaBYWMhaRfrMiVcFWhISlbM0bmPlC2WIg1vfmWlMsPGAMGpGrNiAK5ZXLBjLNFMjFN0OkMEc", + "UWT6IlVDuFsIVy+94uzXCgjLgGvzSeKp7BxUrOTkrO3969TIDv253MDWQt8MfxMZIyyq1b3xEIjdAkbo", + "qeuB+6JWmf1Ca4uU+SFwSVzB4R/O2LsSdzjrHX04arZhkOu2xy0sb97nf4YwbCnM/bXVvfLqqnsNzBGt", + "lc5UspTiN4jreageR7IOfBkxhlEuvwGfRZK3uiymtu40Jd+b2Qe3e0i6Ca1Q7SCFAarHnQ/ccljPyFuo", + "KbdbbUsXt2Ld4gQTxqfO7fgNwTiYezG9Ob1c0FixJyNkGJiOGgdwy5auBfGdPe6d2Z+5ym4zEviS67bM", + "5uOVIJuEoH5u/zUFBjvtaFGhkQyQakOZYGr9f7kSkWEqfkm5rYBt+tmj5HorsMYv0+tSSMymVXGzfwYp", + "K2gelxyytG/izdiK2frPlYKgwLAbyBbOt1TkijRbF3uDmuMlOZgGJczdbmTsgim2yAFbPLAtFlQhJ68N", + "UXUXszzgeq2w+cMRzdcVzyRkeq0sYpUgtVCH6k3tvFqAvgTg5ADbPXhK7qLbTrELuGew6O7nyeGDp2h0", + "tX8cxC4AV+h9FzfJkJ38zbGTOB2j39KOYRi3G3UWzQ21r3MMM64dp8l2HXOWsKXjdfvPUkE5XUE8UqTY", + "A5Pti7uJhrQOXnhmS8srLcWWMB2fHzQ1/Gkgjt2wPwsGSUVRMF04544ShaGnpnqwndQPZ+vUu8JvHi7/", + "EX2kpXcRdZTIz2s0tfdbbNXoyX5DC2ijdUqoTaHOWRO94MtRkmNfoQEr4dUF8CxuzFxm6SjmYDDDkpSS", + "cY2KRaWXyZ9JuqaSpob9zYbATRbfPI5U/2tXoeJXA/yz412CAnkRR70cIHsvQ7i+5C4XPCkMR8nuNXkj", + "wakcdObG3XZDvsPdQ48VyswoySC5VS1yowGnvhHh8R0D3pAU6/VciR6vvLLPTpmVjJMHrcwO/fjulZMy", + "CiFjZZea4+4kDglaMrjA2L34Jpkxb7gXMh+1CzeB/st6HrzIGYhl/izHFIFnIqKd+oqUtSXdxapHrAND", + "x9R8MGSwcENNSbv63+d3+nnjc9/5ZL54WPGPLrBfeEsRyX4FA5sYVCaNbmdWfw/835Q8E5uxm9o5IX5j", + "/wlQE0VJxfLspya/s1P4VVKerqP+rIXp+HPzREW9OHs/RasbrSnnkEeHs7Lgz15mjEi1/xBj5ykYH9m2", + "W4vWLrezuAbwNpgeKD+hQS/TuZkgxGo74a0OqM5XIiM4T1NKp+Ge/RrGQaXJXytQOpY8hB9sUBfaLY2+", + "awsdEuAZaosz8r19Ym4NpFXpA7U0VlS5rRoB2QqkM6hXZS5oNiVmnNOXR6+IndX2sYXWbaHFFSop7VV0", + "7FVBlbBx4cG+Zno8dWH8OLtjqc2qlcbCO0rTooylmZoWp74B5rKGNnxUX0LszMgLqzkqr5fYSQw9LJks", + "jMZVj2ZlF6QJ8x+tabpGlazFUodJfnyFUE+VKniVp66uX5fOwnNn4HZFQm2N0CkRRm++ZMq+LAYX0M5s", + "rdO8nUnAZ7q2lycrzi2lRGWPXWUIroN2D5wN1PBm/ihkHcRfUSC3BXavWjD1BHtFa9F0q6/2nuOx2Y11", + "1XT/YmRKueAsxUowsavZvVI2xgc2omhO18jqj7g7oZHDFa35WofJOSwOVoH1jNAhrm+ED76aTbXUYf/U", + "+BzWmmqyAq0cZ4Ns6ksXOzsg4wpcKTR8sC7gk0K2/IrIIaOu6qR2aVyRjDAtZkCx+858e+PUfowXP2cc", + "BXyHNheabi11+IiSNloB02QlQLn1tHOD1XvTZ4ZpshlsPsz8o0s4hnXLmWVbH3R/qCPvkXYeYNP2uWlr", + "i6I0P7cikO2kR2XpJh0ubB2VB/SGDyI44llMvGsnQG49fjjaDnLbGUqC96khNLhARzSUeA/3CKMu8tx5", + "QMAIrZaisAWxIVzRWgiMR8B4xTg0T4JFLog0eiXgxuB5HeinUkm1FQFH8bRToDl6n2MMTWnnerjpUJ0N", + "RpTgGv0cw9vY1KceYBx1g0Zwo3xbv0RmqDsQJp7jE4gOkf1q0yhVOSEqw4yCTv3pGOMwjNtXuG9fAP1j", + "0JeJbHctqT05V7mJhpJEF1W2Ap3QLIvVkHyGXwl+JVmFkgNsIK3qGnxlSVKsrtIuN9OnNjdRKriqih1z", + "+QY3nC4VMTn6DU6gfMpEM/iMIPs1rPfFy7fvXj4/On35wt4XiqjKZokamVtCYRjijBxzpcGIzpUC8kuI", + "xl+w3y+dBcfBDOrOR4g2rH3vCRFzZRZb/DdWJ2+YgFysyJWjFX1gCHa8snjfHqknnJujlyi2SsZjAq++", + "m6Ojmfp657Hpf6sHMherNiCfuYLFLmYc7lGMDb8091tY4KFX/NHegHX9BYwNFP61INRu68zhNvPEG7dX", + "DRJ9UvVrJLvtJMPvikzxjh6IEA7qdlArBlgn51CccDoY1k61S7DTlOzklINJSzbIyKYn2UexowbeocAi", + "G1dkPvd6jxNge+oAjr0ToT5irQ/QX304LCkpcx78hln0MesC54etmrsOXbPB3UW4cPRBw2L8cYfhEjpN", + "2Ry8BkqhWFOwNvbqw8hwqVN8uCEoAdQfy8cqXECqjVAf+GAlwFUKApnJgjdqvpbSGVA/6qgyV0FnV9mc", + "fmniPcyml9kSZGfZsq6z8UVijupIG/T/4ysxK+DumZh2zProyNnlElLNLvZkEv3NaKlNlsrU67H2ubcg", + "sYjVkZj+Gf4rqtcNQLsSfXbCE5SWuzE4Q3kE57C9o0iLGqJ1Zqee512nBgFiALlDYkhEqJgn2xrenHOR", + "qZoyEAs+csR2h6aa02CB/yAv7ppzeZIkNMyV2zHlhYhp7qPmMl2vlEGKQYVDyUb9EtvDgtALrGiu6sd3", + "6nf2A62GHPcrvV26GgiY91Xbmn01BFD+N5/kaWfJ2TmETxCgZf+Sysy3iKqqXgtOdtxHvQwhXx66C/Sy", + "npk1cX79nJBI7SCM5kxzoRhfJUMhse3QuvDtVwwgwOsAa5cjXEuQ7qkWNCHnQkGihY8L3AXHLlS4d0qv", + "gwQ1WK/PAjdYReNdUyYEK6BSrJpBXXBEuECjt1IDnQyKeQzPuQvZz+13nwThK2CO0MgdvSZ7q3H4CE+m", + "ekgMqX5J3G25P7niOlov49w+NaZilT24QWVoPS6lyKrUXtDhwWhsDGPr5uxgJVGFMe2vsif751hF6lWQ", + "qnYO27mVv9M15U05r/axtiKUXUOQGt7Z7Vs1CMR1n3xlF7C6FTi/pFI9nZRC5MmAufi4X6CkewbOWXoO", + "GTF3h4+NGijyT+6ilbL2B16ut74gR1kCh+zejBCjlhel3nrXYLvWbmdyfkfvmn+Ds2aVrRnk9P3ZGY+H", + "9WE1H3lD/uaH2c3VFBjmd8Op7CB7yl9sBoqjSHoZefJi7IvGEWdd9xmChqgsFDEp5Zq50KPOd1/nj5B+", + "UId/t/YTlkpoYrCkNR2htOQNOl3h5XVjERr3IoDvsAe8UCkO3gTw3MiB84UDpV7XSAmWMkgJreXv07P9", + "Q9w1Xwq2SGFkvVmmLVxjneztfQmMKOp5bZuI47lvwsC6CIJjrZi+6UOhKRFLzoaEY86lvKD55zdfYMGM", + "I8SHe9gqvtBQ/w2RbFGprhet8IqOmjvQdW9vav4WzS1/A7NHURuwG8rZUeu3GHwJSSyNRnOSi+ZNFhyS", + "XOKY1mj84BuycJHWpYSUKdZJQrn01TBrdQ+LQzfvne3WL/et8yehb0DGTkEQJXnTVNbTAu+HBsLmiH5h", + "pjJwcqNUHqO+HllE8BfjUWHK857r4rxlTbaVSjvRHELCLVuVAzf2Fa3K/WTuscvDdeClUynor3P0bd3C", + "beSibtY21iXSR+6u8mtjPBnxqoqmO7pSLEKwJClBUMkvD34hEpb45oAg9+/jBPfvT13TXx62P5vjfP9+", + "VIz7bE6U1tPvbt4Yxfw0FP1nI9wGAk07+1GxPNtHGK2w4eb9DwyM/dklDnyRF0h+tvbU/lF1tduv4r7t", + "bgIiJrLW1uTBVEFA8IhYYNdtFn2cX0FaSaa3WM/Am9/Yz9E6Ud/XFnvn8akzYN3dp8U51BUxGvt+pfzt", + "+r2wj/kXRqZG57nGx+BebmhR5uAOyrd3Fn+CR39+nB08evCnxZ8Pnhyk8PjJ04MD+vQxffD00QN4+Ocn", + "jw/gwfKbp4uH2cPHDxePHz7+5snT9NHjB4vH3zz90x3DhwzIFtCJz56b/B2f6UmO3h4npwbYBie0ZPUb", + "kIaM/QsBNMWTCAVl+eTQ//S//QmbpaJohve/TlxyzmStdakO5/PLy8tZ2GW+QoNeokWVrud+nv7be2+P", + "6wBrm/CNO2pjZw0p4KY6UjjCb+9enpySo7fHs4ZgJoeTg9nB7AG+rFUCpyWbHE4e4U94eta473NHbJPD", + "j5+mk/kaaI7+L/NHAVqy1H9Sl3S1AjlzTyWYny4ezr0oMf/ojJmfdn2bh1VH5x9bNt9sT0+sSjj/6JPt", + "d7duZbM7W7dZ7ipWguJ7CJ4eDEoit2xti603106Jqt+nLSUT5iRNzbWYQSqBIt0LiQHOzSOGTn8B+yDv", + "66O/o7X99dHfybfkYOri3hWqGrHprT2jJoHjzIIdeWTz2fao9h4EpbgO38fexYw94YBHyNBHQOH1iA0H", + "07KCsERUw48Njz1Inn74+OTPn2JyXv8RMo+kgUcwtfAJ6Yi0gm6+HULZxp4OXMOvFchts4iCbiYhwH0f", + "TOQ9siVbVbLzdHEdSuIq+TNF/uvkhzdESOL02rc0PQ9DpWPguPsshMgXVnYB1YVale3owxqHHzBDFaHA", + "U/zw4ODrU63/M55qnba21tPI1939+hDvv8ZDvI+vyMp2modbwYGjzs5Vhutt1mu6qSuRUMIFTziWiL8A", + "Euh5jw8e/GFXeMwxwsXImsTK0p+mkyd/4C075kZqoTnBlnY1j/6wqzkBecFSIKdQlEJSyfIt+ZHXKW5B", + "WZs++/uRn3NxyT0ijJpYFQWVWych05rnVDxIOtzJf3rOwUaKRi5KVwr9SCh/TlpPofDV5MMnL+CP1Bp2", + "NZsvMOd+bFNQQeNh1QMdAmr+EU3ag7/PXSJy/CO6FqzOOveBTPGWLa3mo94YWDs9UqrTdVXOP+J/UIcM", + "wLKJuHP76nDzc/cFmtjP84/tCsgtNKh1pTNxGfRFU7f10/SxU78J0vp7fkmZNve6iyHDClX9zhpoPncJ", + "dp1fm2Dx3heMgA9+7EgCpcvdaGtY7+hlKFfYOx6Ufiay7Q4esUkWjOPBCQ92Y8CyH/tSff+50zXYwo7e", + "BxgRm7QgCylollKFhY9cKmpPV/t0Q5Xhj/i4++8pS/QgekYz4pPmE/Ka5mbDISNHTmJtYeP3lgO+/MX9", + "hW/az3Y1PvOHTxGKARedwxmkh4+58oyOY876CnjiuE2yENnWV7qU9FJvbCRGl4/N65Kl0Y+3YAT757Z8", + "7TN4fbUzfbUzfbVEfLUzfd3dr3amr1aYr1aY/7FWmKuYXmIypDM9DIuSWBOMtua1OhptcolqFh82mxKm", + "a4GrX/6R6Rkhp5ipQc0tARcgaY4lslWQelVgzJ6q0hQgOzzjSQsSGxlnJr7b/NeGJLoXiA/udfsozfI8", + "5M39vijM4iebcP4tOZucTXojYTEHyGwCaBi5bnvtHfZ/1eP+0EuCwdxBfPfSx9oTVS2XLGUW5bngK0JX", + "ogmnNXybcIFfACtN2FRiwvTUPbrAFLk0i3eV2doB9m2xvC8BHDdbuNcd3SGXuCfaEN4V3dD/McYH/a8r", + "gl836+emXHLn2D2W+ZVlfA6W8cWZxh/dwRfY+P4lZcjHB4//sAsKLcJvhCbfYRz4zWStupRlLF16tBTV", + "BIuGwZd4B9Zhl+8/GE6PhePd9djEEh7O55hxuRZKzyfm8mrHGYYfP9RA+YrCk1KyC6z88+HT/w8AAP//", + "Cjn3ciPIAAA=", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/daemon/algod/api/server/v2/handlers.go b/daemon/algod/api/server/v2/handlers.go index 8dc6969af6..07816a504f 100644 --- a/daemon/algod/api/server/v2/handlers.go +++ b/daemon/algod/api/server/v2/handlers.go @@ -777,6 +777,9 @@ func (v2 *Handlers) GetStatus(ctx echo.Context) error { CatchpointTotalAccounts: &stat.CatchpointCatchupTotalAccounts, CatchpointProcessedAccounts: &stat.CatchpointCatchupProcessedAccounts, CatchpointVerifiedAccounts: &stat.CatchpointCatchupVerifiedAccounts, + CatchpointTotalKvs: &stat.CatchpointCatchupTotalKVs, + CatchpointProcessedKvs: &stat.CatchpointCatchupProcessedKVs, + CatchpointVerifiedKvs: &stat.CatchpointCatchupVerifiedKVs, CatchpointTotalBlocks: &stat.CatchpointCatchupTotalBlocks, CatchpointAcquiredBlocks: &stat.CatchpointCatchupAcquiredBlocks, } diff --git a/daemon/algod/api/server/v2/test/handlers_test.go b/daemon/algod/api/server/v2/test/handlers_test.go index d7d3c88e53..30ee0f7995 100644 --- a/daemon/algod/api/server/v2/test/handlers_test.go +++ b/daemon/algod/api/server/v2/test/handlers_test.go @@ -332,6 +332,9 @@ func TestGetStatus(t *testing.T) { CatchpointVerifiedAccounts: &stat.CatchpointCatchupVerifiedAccounts, CatchpointTotalBlocks: &stat.CatchpointCatchupTotalBlocks, CatchpointAcquiredBlocks: &stat.CatchpointCatchupAcquiredBlocks, + CatchpointTotalKvs: &stat.CatchpointCatchupTotalKVs, + CatchpointProcessedKvs: &stat.CatchpointCatchupProcessedKVs, + CatchpointVerifiedKvs: &stat.CatchpointCatchupVerifiedKVs, } actualResult := model.NodeStatusResponse{} err = protocol.DecodeJSON(rec.Body.Bytes(), &actualResult) diff --git a/daemon/algod/api/server/v2/test/helpers.go b/daemon/algod/api/server/v2/test/helpers.go index a44c66ec88..65c84ec71b 100644 --- a/daemon/algod/api/server/v2/test/helpers.go +++ b/daemon/algod/api/server/v2/test/helpers.go @@ -53,6 +53,9 @@ var cannedStatusReportGolden = node.StatusReport{ CatchpointCatchupProcessedAccounts: 0, CatchpointCatchupVerifiedAccounts: 0, CatchpointCatchupTotalAccounts: 0, + CatchpointCatchupTotalKVs: 0, + CatchpointCatchupProcessedKVs: 0, + CatchpointCatchupVerifiedKVs: 0, CatchpointCatchupTotalBlocks: 0, LastCatchpoint: "", } diff --git a/ledger/accountdb.go b/ledger/accountdb.go index 1596a54cff..b2a01b9704 100644 --- a/ledger/accountdb.go +++ b/ledger/accountdb.go @@ -478,15 +478,10 @@ func prepareNormalizedBalancesV6(bals []encodedBalanceRecordV6, proto config.Con if err != nil { return nil, err } - var ctype basics.CreatableType - if resData.IsAsset() { - ctype = basics.AssetCreatable - } else if resData.IsApp() { - ctype = basics.AppCreatable - } else { - err = fmt.Errorf("unknown creatable for addr %s, aidx %d, data %v", balance.Address.String(), cidx, resData) + normalizedAccountBalances[i].accountHashes[curHashIdx], err = resourcesHashBuilderV6(&resData, balance.Address, basics.CreatableIndex(cidx), resData.UpdateRound, res) + if err != nil { + return nil, err } - normalizedAccountBalances[i].accountHashes[curHashIdx] = resourcesHashBuilderV6(balance.Address, basics.CreatableIndex(cidx), ctype, resData.UpdateRound, res) normalizedAccountBalances[i].resources[basics.CreatableIndex(cidx)] = resData normalizedAccountBalances[i].encodedResources[basics.CreatableIndex(cidx)] = res curHashIdx++ @@ -4126,6 +4121,16 @@ func totalAccounts(ctx context.Context, tx *sql.Tx) (total uint64, err error) { return } +func totalKVs(ctx context.Context, tx *sql.Tx) (total uint64, err error) { + err = tx.QueryRowContext(ctx, "SELECT count(1) FROM kvstore").Scan(&total) + if err == sql.ErrNoRows { + total = 0 + err = nil + return + } + return +} + // reencodeAccounts reads all the accounts in the accountbase table, decode and reencode the account data. // if the account data is found to have a different encoding, it would update the encoded account on disk. // on return, it returns the number of modified accounts as well as an error ( if we had any ) @@ -4816,21 +4821,15 @@ func (iterator *orderedAccountsIter) Next(ctx context.Context) (acct []accountAd } resCb := func(addr basics.Address, cidx basics.CreatableIndex, resData *resourcesData, encodedResourceData []byte, lastResource bool) error { - var err error if resData != nil { - var ctype basics.CreatableType - if resData.IsAsset() { - ctype = basics.AssetCreatable - } else if resData.IsApp() { - ctype = basics.AppCreatable - } else { - err = fmt.Errorf("unknown creatable for addr %s, aidx %d, data %v", addr.String(), cidx, resData) + hash, err := resourcesHashBuilderV6(resData, addr, cidx, resData.UpdateRound, encodedResourceData) + if err != nil { return err } - hash := resourcesHashBuilderV6(addr, cidx, ctype, resData.UpdateRound, encodedResourceData) _, err = iterator.insertStmt.ExecContext(ctx, lastAddrID, hash) + return err } - return err + return nil } count := 0 @@ -5165,6 +5164,11 @@ type catchpointFirstStageInfo struct { // Total number of accounts in the catchpoint data file. Only set when catchpoint // data files are generated. TotalAccounts uint64 `codec:"accountsCount"` + + // Total number of accounts in the catchpoint data file. Only set when catchpoint + // data files are generated. + TotalKVs uint64 `codec:"kvsCount"` + // Total number of chunks in the catchpoint data file. Only set when catchpoint // data files are generated. TotalChunks uint64 `codec:"chunksCount"` diff --git a/ledger/catchpointfileheader.go b/ledger/catchpointfileheader.go index 741e13aa02..3b46002704 100644 --- a/ledger/catchpointfileheader.go +++ b/ledger/catchpointfileheader.go @@ -33,6 +33,7 @@ type CatchpointFileHeader struct { Totals ledgercore.AccountTotals `codec:"accountTotals"` TotalAccounts uint64 `codec:"accountsCount"` TotalChunks uint64 `codec:"chunksCount"` + TotalKVs uint64 `codec:"kvsCount"` Catchpoint string `codec:"catchpoint"` BlockHeaderDigest crypto.Digest `codec:"blockHeaderDigest"` } diff --git a/ledger/catchpointtracker.go b/ledger/catchpointtracker.go index 4d664518f3..584a9447d8 100644 --- a/ledger/catchpointtracker.go +++ b/ledger/catchpointtracker.go @@ -210,6 +210,7 @@ func (ct *catchpointTracker) GetLastCatchpointLabel() string { func (ct *catchpointTracker) finishFirstStage(ctx context.Context, dbRound basics.Round, updatingBalancesDuration time.Duration) error { ct.log.Infof("finishing catchpoint's first stage dbRound: %d", dbRound) + var totalKVs uint64 var totalAccounts uint64 var totalChunks uint64 var biggestChunkLen uint64 @@ -220,7 +221,7 @@ func (ct *catchpointTracker) finishFirstStage(ctx context.Context, dbRound basic // expects that the accounts data would not be modified in the // background during its execution. var err error - totalAccounts, totalChunks, biggestChunkLen, err = ct.generateCatchpointData( + totalKVs, totalAccounts, totalChunks, biggestChunkLen, err = ct.generateCatchpointData( ctx, dbRound, updatingBalancesDuration) atomic.StoreInt32(&ct.catchpointDataWriting, 0) if err != nil { @@ -229,7 +230,7 @@ func (ct *catchpointTracker) finishFirstStage(ctx context.Context, dbRound basic } f := func(ctx context.Context, tx *sql.Tx) error { - err := ct.recordFirstStageInfo(ctx, tx, dbRound, totalAccounts, totalChunks, biggestChunkLen) + err := ct.recordFirstStageInfo(ctx, tx, dbRound, totalKVs, totalAccounts, totalChunks, biggestChunkLen) if err != nil { return err } @@ -761,6 +762,7 @@ func (ct *catchpointTracker) createCatchpoint(ctx context.Context, accountsRound BlocksRound: round, Totals: dataInfo.Totals, TotalAccounts: dataInfo.TotalAccounts, + TotalKVs: dataInfo.TotalKVs, TotalChunks: dataInfo.TotalChunks, Catchpoint: label, BlockHeaderDigest: blockHash, @@ -799,6 +801,7 @@ func (ct *catchpointTracker) createCatchpoint(ctx context.Context, accountsRound ct.log.With("accountsRound", accountsRound). With("writingDuration", uint64(time.Since(startTime).Nanoseconds())). With("accountsCount", dataInfo.TotalAccounts). + With("kvsCount", dataInfo.TotalKVs). With("fileSize", fileInfo.Size()). With("catchpointLabel", label). Infof("Catchpoint file was created") @@ -968,15 +971,10 @@ func (ct *catchpointTracker) accountsUpdateBalances(accountsDeltas compactAccoun resDelta := resourcesDeltas.getByIdx(i) addr := resDelta.address if !resDelta.oldResource.data.IsEmpty() { - var ctype basics.CreatableType - if resDelta.oldResource.data.IsAsset() { - ctype = basics.AssetCreatable - } else if resDelta.oldResource.data.IsApp() { - ctype = basics.AppCreatable - } else { - return fmt.Errorf("unknown old creatable for addr %s (%d), aidx %d, data %v", addr.String(), resDelta.oldResource.addrid, resDelta.oldResource.aidx, resDelta.oldResource.data) + deleteHash, err := resourcesHashBuilderV6(&resDelta.oldResource.data, addr, resDelta.oldResource.aidx, resDelta.oldResource.data.UpdateRound, protocol.Encode(&resDelta.oldResource.data)) + if err != nil { + return err } - deleteHash := resourcesHashBuilderV6(addr, resDelta.oldResource.aidx, ctype, uint64(resDelta.oldResource.data.UpdateRound), protocol.Encode(&resDelta.oldResource.data)) deleted, err = ct.balancesTrie.Delete(deleteHash) if err != nil { return fmt.Errorf("failed to delete resource hash '%s' from merkle trie for account %v: %w", hex.EncodeToString(deleteHash), addr, err) @@ -989,15 +987,10 @@ func (ct *catchpointTracker) accountsUpdateBalances(accountsDeltas compactAccoun } if !resDelta.newResource.IsEmpty() { - var ctype basics.CreatableType - if resDelta.newResource.IsAsset() { - ctype = basics.AssetCreatable - } else if resDelta.newResource.IsApp() { - ctype = basics.AppCreatable - } else { - return fmt.Errorf("unknown new creatable for addr %s, aidx %d, data %v", addr.String(), resDelta.oldResource.aidx, resDelta.newResource) + addHash, err := resourcesHashBuilderV6(&resDelta.newResource, addr, resDelta.oldResource.aidx, resDelta.newResource.UpdateRound, protocol.Encode(&resDelta.newResource)) + if err != nil { + return err } - addHash := resourcesHashBuilderV6(addr, resDelta.oldResource.aidx, ctype, uint64(resDelta.newResource.UpdateRound), protocol.Encode(&resDelta.newResource)) added, err = ct.balancesTrie.Add(addHash) if err != nil { return fmt.Errorf("attempted to add duplicate resource hash '%s' to merkle trie for account %v: %w", hex.EncodeToString(addHash), addr, err) @@ -1082,7 +1075,7 @@ func (ct *catchpointTracker) IsWritingCatchpointDataFile() bool { } // Generates a (first stage) catchpoint data file. -func (ct *catchpointTracker) generateCatchpointData(ctx context.Context, accountsRound basics.Round, updatingBalancesDuration time.Duration) (uint64 /*totalAccounts*/, uint64 /*totalChunks*/, uint64 /*biggestChunkLen*/, error) { +func (ct *catchpointTracker) generateCatchpointData(ctx context.Context, accountsRound basics.Round, updatingBalancesDuration time.Duration) (totalKVs, totalAccounts, totalChunks, biggestChunkLen uint64, err error) { ct.log.Debugf("catchpointTracker.generateCatchpointData() writing catchpoint accounts for round %d", accountsRound) startTime := time.Now() @@ -1108,7 +1101,7 @@ func (ct *catchpointTracker) generateCatchpointData(ctx context.Context, account var catchpointWriter *catchpointWriter start := time.Now() ledgerGeneratecatchpointCount.Inc(nil) - err := ct.dbs.Rdb.AtomicContext(ctx, func(dbCtx context.Context, tx *sql.Tx) (err error) { + err = ct.dbs.Rdb.AtomicContext(ctx, func(dbCtx context.Context, tx *sql.Tx) (err error) { catchpointWriter, err = makeCatchpointWriter(dbCtx, catchpointDataFilePath, tx, ResourcesPerCatchpointFileChunk) if err != nil { return @@ -1163,26 +1156,28 @@ func (ct *catchpointTracker) generateCatchpointData(ctx context.Context, account ledgerGeneratecatchpointMicros.AddMicrosecondsSince(start, nil) if err != nil { ct.log.Warnf("catchpointTracker.generateCatchpointData() %v", err) - return 0, 0, 0, err + return 0, 0, 0, 0, err } catchpointGenerationStats.FileSize = uint64(catchpointWriter.writtenBytes) catchpointGenerationStats.WritingDuration = uint64(time.Since(startTime).Nanoseconds()) catchpointGenerationStats.AccountsCount = catchpointWriter.totalAccounts + catchpointGenerationStats.KVsCount = catchpointWriter.totalKVs ct.log.EventWithDetails(telemetryspec.Accounts, telemetryspec.CatchpointGenerationEvent, catchpointGenerationStats) ct.log.With("accountsRound", accountsRound). With("writingDuration", catchpointGenerationStats.WritingDuration). With("CPUTime", catchpointGenerationStats.CPUTime). With("balancesWriteTime", catchpointGenerationStats.BalancesWriteTime). With("accountsCount", catchpointGenerationStats.AccountsCount). + With("kvsCount", catchpointGenerationStats.KVsCount). With("fileSize", catchpointGenerationStats.FileSize). With("catchpointLabel", catchpointGenerationStats.CatchpointLabel). Infof("Catchpoint data file was generated") - return catchpointWriter.totalAccounts, catchpointWriter.chunkNum, catchpointWriter.biggestChunkLen, nil + return catchpointWriter.totalKVs, catchpointWriter.totalAccounts, catchpointWriter.chunkNum, catchpointWriter.biggestChunkLen, nil } -func (ct *catchpointTracker) recordFirstStageInfo(ctx context.Context, tx *sql.Tx, accountsRound basics.Round, totalAccounts uint64, totalChunks uint64, biggestChunkLen uint64) error { +func (ct *catchpointTracker) recordFirstStageInfo(ctx context.Context, tx *sql.Tx, accountsRound basics.Round, totalKVs uint64, totalAccounts uint64, totalChunks uint64, biggestChunkLen uint64) error { accountTotals, err := accountsTotals(ctx, tx, false) if err != nil { return err @@ -1211,6 +1206,7 @@ func (ct *catchpointTracker) recordFirstStageInfo(ctx context.Context, tx *sql.T info := catchpointFirstStageInfo{ Totals: accountTotals, TotalAccounts: totalAccounts, + TotalKVs: totalKVs, TotalChunks: totalChunks, BiggestChunkLen: biggestChunkLen, TrieBalancesHash: trieBalancesHash, @@ -1409,7 +1405,7 @@ func removeSingleCatchpointFileFromDisk(dbDirectory, fileToDelete string) (err e return nil } -func hashBufV6(affinity uint64, kind byte) []byte { +func hashBufV6(affinity uint64, kind hashKind) []byte { hash := make([]byte, 4+crypto.DigestSize) // write out the lowest 32 bits of the affinity value. This should improve // the caching of the trie by allowing recent updates to be in-cache, and @@ -1418,7 +1414,7 @@ func hashBufV6(affinity uint64, kind byte) []byte { // the following takes the prefix & 255 -> hash[i] hash[i] = byte(prefix) } - hash[4] = kind + hash[hashKindEncodingIndex] = byte(kind) return hash } @@ -1435,7 +1431,7 @@ func accountHashBuilderV6(addr basics.Address, accountData *baseAccountData, enc if hashIntPrefix == 0 { hashIntPrefix = accountData.RewardsBase } - hash := hashBufV6(hashIntPrefix, 0) // 0 indicates an account + hash := hashBufV6(hashIntPrefix, accountHK) // write out the lowest 32 bits of the reward base. This should improve the caching of the trie by allowing // recent updated to be in-cache, and "older" nodes will be left alone. @@ -1446,21 +1442,55 @@ func accountHashBuilderV6(addr basics.Address, accountData *baseAccountData, enc return finishV6(hash, prehash) } -// accountHashBuilderV6 calculates the hash key used for the trie by combining the account address and the account data -func resourcesHashBuilderV6(addr basics.Address, cidx basics.CreatableIndex, ctype basics.CreatableType, updateRound uint64, encodedResourceData []byte) []byte { - hash := hashBufV6(updateRound, byte(ctype+1)) // one or two ( asset / application ) so we could differentiate the hashes. +// hashKind enumerates the possible data types hashed into a catchpoint merkle +// trie. Each merkle trie hash includes the hashKind byte at a known-offset. +// By encoding hashKind at a known-offset, it's possible for hash readers to +// disambiguate the hashed resource. +//go:generate stringer -type=hashKind +type hashKind byte + +// Defines known kinds of hashes. Changing an enum ordinal value is a +// breaking change. +const ( + accountHK hashKind = iota + assetHK + appHK + kvHK +) + +// hashKindEncodingIndex defines the []byte offset where the hash kind is +// encoded. +const hashKindEncodingIndex = 4 + +func rdGetCreatableHashKind(rd *resourcesData, a basics.Address, ci basics.CreatableIndex) (hashKind, error) { + if rd.IsAsset() { + return assetHK, nil + } else if rd.IsApp() { + return appHK, nil + } + return accountHK, fmt.Errorf("unknown creatable for addr %s, aidx %d, data %v", a.String(), ci, rd) +} + +// resourcesHashBuilderV6 calculates the hash key used for the trie by combining the creatable's resource data and its index +func resourcesHashBuilderV6(rd *resourcesData, addr basics.Address, cidx basics.CreatableIndex, updateRound uint64, encodedResourceData []byte) ([]byte, error) { + hk, err := rdGetCreatableHashKind(rd, addr, cidx) + if err != nil { + return nil, err + } + + hash := hashBufV6(updateRound, hk) prehash := make([]byte, 8+crypto.DigestSize+len(encodedResourceData)) copy(prehash[:], addr[:]) binary.LittleEndian.PutUint64(prehash[crypto.DigestSize:], uint64(cidx)) copy(prehash[crypto.DigestSize+8:], encodedResourceData[:]) - return finishV6(hash, prehash) + return finishV6(hash, prehash), nil } // kvHashBuilderV6 calculates the hash key used for the trie by combining the key and value func kvHashBuilderV6(key string, value []byte) []byte { - hash := hashBufV6(0, 3) // 3 indicates a kv pair + hash := hashBufV6(0, kvHK) prehash := make([]byte, len(key)+len(value)) copy(prehash[:], key) diff --git a/ledger/catchpointtracker_test.go b/ledger/catchpointtracker_test.go index 004f6572ee..7e9b4d19a4 100644 --- a/ledger/catchpointtracker_test.go +++ b/ledger/catchpointtracker_test.go @@ -19,6 +19,7 @@ package ledger import ( "context" "database/sql" + "encoding/hex" "errors" "fmt" "os" @@ -296,7 +297,7 @@ func TestRecordCatchpointFile(t *testing.T) { for _, round := range []basics.Round{2000000, 3000010, 3000015, 3000020} { accountsRound := round - 1 - _, _, biggestChunkLen, err := ct.generateCatchpointData( + _, _, _, biggestChunkLen, err := ct.generateCatchpointData( context.Background(), accountsRound, time.Second) require.NoError(t, err) @@ -1340,3 +1341,140 @@ func TestSecondStageDeletesUnfinishedCatchpointRecordAfterRestart(t *testing.T) require.NoError(t, err) require.Empty(t, unfinishedCatchpoints) } + +// TestHashContract confirms the account, resource, and KV hashing algorithm +// remains unchanged by comparing a newly calculated hash against a +// known-to-be-correct hex-encoded hash. +// +// When the test fails a hash equality check, it implies a hash calculated +// before the change != hash calculated now. Accepting the new hash risks +// breaking backwards compatibility. +// +// The test also confirms each hashKind has at least 1 test case. The check +// defends against the addition of a hashed data type without test coverage. +func TestHashContract(t *testing.T) { + partitiontest.PartitionTest(t) + t.Parallel() + + type testCase struct { + genHash func() []byte + expectedHex string + expectedHashKind hashKind + } + + accountCase := func(genHash func() []byte, expectedHex string) testCase { + return testCase{ + genHash, expectedHex, accountHK, + } + } + + resourceAssetCase := func(genHash func() []byte, expectedHex string) testCase { + return testCase{ + genHash, expectedHex, assetHK, + } + } + + resourceAppCase := func(genHash func() []byte, expectedHex string) testCase { + return testCase{ + genHash, expectedHex, appHK, + } + } + + kvCase := func(genHash func() []byte, expectedHex string) testCase { + return testCase{ + genHash, expectedHex, kvHK, + } + } + + a := basics.Address{0x7, 0xda, 0xcb, 0x4b, 0x6d, 0x9e, 0xd1, 0x41, 0xb1, 0x75, 0x76, 0xbd, 0x45, 0x9a, 0xe6, 0x42, 0x1d, 0x48, 0x6d, 0xa3, 0xd4, 0xef, 0x22, 0x47, 0xc4, 0x9, 0xa3, 0x96, 0xb8, 0x2e, 0xa2, 0x21} + + accounts := []testCase{ + accountCase( + func() []byte { + b := baseAccountData{ + UpdateRound: 1024, + } + return accountHashBuilderV6(a, &b, protocol.Encode(&b)) + }, + "0000040000c3c39a72c146dc6bcb87b499b63ef730145a8fe4a187c96e9a52f74ef17f54", + ), + accountCase( + func() []byte { + b := baseAccountData{ + RewardsBase: 10000, + } + return accountHashBuilderV6(a, &b, protocol.Encode(&b)) + }, + "0000271000804b58bcc81190c3c7343c1db9c737621ff0438104bdd20a25d12aa4e9b6e5", + ), + } + + resourceAssets := []testCase{ + resourceAssetCase( + func() []byte { + r := resourcesData{ + Amount: 1000, + Decimals: 3, + AssetName: "test", + Manager: a, + } + + bytes, err := resourcesHashBuilderV6(&r, a, 7, 1024, protocol.Encode(&r)) + require.NoError(t, err) + return bytes + }, + "0000040001ca4157130516bd7f120cef4b3a28715e464d9a29f7575db9b2173b4eccd18e", + ), + } + + resourceApps := []testCase{ + resourceAppCase( + func() []byte { + r := resourcesData{ + ApprovalProgram: []byte{1, 3, 10, 15}, + ClearStateProgram: []byte{15, 10, 3, 1}, + LocalStateSchemaNumUint: 2, + GlobalStateSchemaNumUint: 2, + } + + bytes, err := resourcesHashBuilderV6(&r, a, 7, 1024, protocol.Encode(&r)) + require.NoError(t, err) + return bytes + }, + "00000400023547567f3234873b48fd4152f296a92ae260b024b93c2408f35caccff57c32", + ), + } + + kvs := []testCase{ + kvCase( + func() []byte { + return kvHashBuilderV6("sample key", []byte("sample value")) + }, + "0000000003cca3d1a8d7d724daa445c795ad277a7a64b351b4b9407f738841282f9c348b", + ), + } + + allCases := append(append(append(accounts, resourceAssets...), resourceApps...), kvs...) + for i, tc := range allCases { + t.Run(fmt.Sprintf("index=%d", i), func(t *testing.T) { + h := tc.genHash() + require.Equal(t, byte(tc.expectedHashKind), h[hashKindEncodingIndex]) + require.Equal(t, tc.expectedHex, hex.EncodeToString(h)) + }) + } + + hasTestCoverageForKind := func(hk hashKind) bool { + for _, c := range allCases { + if c.expectedHashKind == hk { + return true + } + } + return false + } + + for i := byte(0); i < 255; i++ { + if !strings.HasPrefix(hashKind(i).String(), "hashKind(") { + require.True(t, hasTestCoverageForKind(hashKind(i)), fmt.Sprintf("Missing test coverage for hashKind ordinal value = %d", i)) + } + } +} diff --git a/ledger/catchpointwriter.go b/ledger/catchpointwriter.go index 7ce7b521a9..c7f87961b2 100644 --- a/ledger/catchpointwriter.go +++ b/ledger/catchpointwriter.go @@ -56,6 +56,7 @@ type catchpointWriter struct { tx *sql.Tx filePath string totalAccounts uint64 + totalKVs uint64 file *os.File tar *tar.Writer compressor io.WriteCloser @@ -134,6 +135,11 @@ func makeCatchpointWriter(ctx context.Context, filePath string, tx *sql.Tx, maxR return nil, err } + totalKVs, err := totalKVs(ctx, tx) + if err != nil { + return nil, err + } + err = os.MkdirAll(filepath.Dir(filePath), 0700) if err != nil { return nil, err @@ -153,6 +159,7 @@ func makeCatchpointWriter(ctx context.Context, filePath string, tx *sql.Tx, maxR tx: tx, filePath: filePath, totalAccounts: totalAccounts, + totalKVs: totalKVs, file: file, compressor: compressor, tar: tar, diff --git a/ledger/catchupaccessor.go b/ledger/catchupaccessor.go index fa1b6803b3..d7b764606f 100644 --- a/ledger/catchupaccessor.go +++ b/ledger/catchupaccessor.go @@ -59,7 +59,7 @@ type CatchpointCatchupAccessor interface { ProcessStagingBalances(ctx context.Context, sectionName string, bytes []byte, progress *CatchpointCatchupAccessorProgress) (err error) // BuildMerkleTrie inserts the account hashes into the merkle trie - BuildMerkleTrie(ctx context.Context, progressUpdates func(uint64)) (err error) + BuildMerkleTrie(ctx context.Context, progressUpdates func(uint64, uint64)) (err error) // GetCatchupBlockRound returns the latest block round matching the current catchpoint GetCatchupBlockRound(ctx context.Context) (round basics.Round, err error) @@ -275,6 +275,8 @@ type CatchpointCatchupAccessorProgress struct { TotalAccounts uint64 ProcessedAccounts uint64 ProcessedBytes uint64 + TotalKVs uint64 + ProcessedKVs uint64 TotalChunks uint64 SeenHeader bool Version uint64 @@ -344,6 +346,8 @@ func (c *catchpointCatchupAccessorImpl) processStagingContent(ctx context.Contex if err == nil { progress.SeenHeader = true progress.TotalAccounts = fileHeader.TotalAccounts + progress.TotalKVs = fileHeader.TotalKVs + progress.TotalChunks = fileHeader.TotalChunks progress.Version = fileHeader.Version c.ledger.setSynchronousMode(ctx, c.ledger.accountsRebuildSynchronousMode) @@ -569,6 +573,7 @@ func (c *catchpointCatchupAccessorImpl) processStagingBalances(ctx context.Conte ledgerProcessstagingbalancesMicros.AddMicrosecondsSince(start, nil) progress.ProcessedBytes += uint64(len(bytes)) + progress.ProcessedKVs += uint64(len(chunkKVs)) for _, acctBal := range normalizedAccountBalances { progress.TotalAccountHashes += uint64(len(acctBal.accountHashes)) if !acctBal.partialBalance { @@ -588,8 +593,24 @@ func (c *catchpointCatchupAccessorImpl) processStagingBalances(ctx context.Conte return err } +// countHashes disambiguates the 2 hash types included in the merkle trie: +// * accounts + createables (assets + apps) +// * KVs +// +// The function is _not_ a general purpose way to count hashes by hash kind. +func countHashes(hashes [][]byte) (accountCount, kvCount uint64) { + for _, hash := range hashes { + if hash[hashKindEncodingIndex] == byte(kvHK) { + kvCount++ + } else { + accountCount++ + } + } + return accountCount, kvCount +} + // BuildMerkleTrie would process the catchpointpendinghashes and insert all the items in it into the merkle trie -func (c *catchpointCatchupAccessorImpl) BuildMerkleTrie(ctx context.Context, progressUpdates func(uint64)) (err error) { +func (c *catchpointCatchupAccessorImpl) BuildMerkleTrie(ctx context.Context, progressUpdates func(uint64, uint64)) (err error) { wdb := c.ledger.trackerDB().Wdb rdb := c.ledger.trackerDB().Rdb err = wdb.Atomic(func(ctx context.Context, tx *sql.Tx) (err error) { @@ -649,11 +670,8 @@ func (c *catchpointCatchupAccessorImpl) BuildMerkleTrie(ctx context.Context, pro var trie *merkletrie.Trie uncommitedHashesCount := 0 keepWriting := true - hashesWritten := uint64(0) + accountHashesWritten, kvHashesWritten := uint64(0), uint64(0) var mc *MerkleCommitter - if progressUpdates != nil { - progressUpdates(hashesWritten) - } err := wdb.Atomic(func(transactionCtx context.Context, tx *sql.Tx) (err error) { // create the merkle trie for the balances @@ -690,18 +708,23 @@ func (c *catchpointCatchupAccessorImpl) BuildMerkleTrie(ctx context.Context, pro return } trie.SetCommitter(mc) - for _, accountHash := range hashesToWrite { + for _, hash := range hashesToWrite { var added bool - added, err = trie.Add(accountHash) + added, err = trie.Add(hash) if !added { - return fmt.Errorf("CatchpointCatchupAccessorImpl::BuildMerkleTrie: The provided catchpoint file contained the same account more than once. hash '%s'", hex.EncodeToString(accountHash)) + return fmt.Errorf("CatchpointCatchupAccessorImpl::BuildMerkleTrie: The provided catchpoint file contained the same account more than once. hash = '%s' hash kind = %s", hex.EncodeToString(hash), hashKind(hash[hashKindEncodingIndex])) } if err != nil { return } + } uncommitedHashesCount += len(hashesToWrite) - hashesWritten += uint64(len(hashesToWrite)) + + accounts, kvs := countHashes(hashesToWrite) + kvHashesWritten += kvs + accountHashesWritten += accounts + return nil }) if err != nil { @@ -729,8 +752,9 @@ func (c *catchpointCatchupAccessorImpl) BuildMerkleTrie(ctx context.Context, pro continue } } + if progressUpdates != nil { - progressUpdates(hashesWritten) + progressUpdates(accountHashesWritten, kvHashesWritten) } } if err != nil { diff --git a/ledger/catchupaccessor_test.go b/ledger/catchupaccessor_test.go index adc1dcb5fc..b95a924ce3 100644 --- a/ledger/catchupaccessor_test.go +++ b/ledger/catchupaccessor_test.go @@ -218,7 +218,7 @@ func TestBuildMerkleTrie(t *testing.T) { catchpointAccessor := MakeCatchpointCatchupAccessor(l, log) progressCallCount := 0 - progressNop := func(uint64) { + progressNop := func(uint64, uint64) { progressCallCount++ } @@ -234,10 +234,9 @@ func TestBuildMerkleTrie(t *testing.T) { require.NoError(t, err, "ResetStagingBalances") err = catchpointAccessor.BuildMerkleTrie(ctx, progressNop) require.NoError(t, err) - require.True(t, progressCallCount > 0) + require.False(t, progressCallCount > 0) // process some data... - progressCallCount = 0 err = catchpointAccessor.ResetStagingBalances(ctx, true) require.NoError(t, err, "ResetStagingBalances") // TODO: catchpointAccessor.ProcessStagingBalances() like in ledgerFetcher.downloadLedger(cs.ctx, peer, round) like catchup/catchpointService.go which is the real usage of BuildMerkleTrie() @@ -316,13 +315,9 @@ func TestCatchupAccessorBlockdb(t *testing.T) { }() catchpointAccessor := MakeCatchpointCatchupAccessor(l, log) ctx := context.Background() - progressCallCount := 0 - progressNop := func(uint64) { - progressCallCount++ - } // actual testing... - err = catchpointAccessor.BuildMerkleTrie(ctx, progressNop) + err = catchpointAccessor.BuildMerkleTrie(ctx, func(uint64, uint64) {}) require.Error(t, err) } diff --git a/ledger/hashkind_string.go b/ledger/hashkind_string.go new file mode 100644 index 0000000000..6549ae63b6 --- /dev/null +++ b/ledger/hashkind_string.go @@ -0,0 +1,26 @@ +// Code generated by "stringer -type=hashKind"; DO NOT EDIT. + +package ledger + +import "strconv" + +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[accountHK-0] + _ = x[assetHK-1] + _ = x[appHK-2] + _ = x[kvHK-3] +} + +const _hashKind_name = "accountHKassetHKappHKkvHK" + +var _hashKind_index = [...]uint8{0, 9, 16, 21, 25} + +func (i hashKind) String() string { + if i >= hashKind(len(_hashKind_index)-1) { + return "hashKind(" + strconv.FormatInt(int64(i), 10) + ")" + } + return _hashKind_name[_hashKind_index[i]:_hashKind_index[i+1]] +} diff --git a/ledger/msgp_gen.go b/ledger/msgp_gen.go index 3e0a185ab3..9a1be6eb6c 100644 --- a/ledger/msgp_gen.go +++ b/ledger/msgp_gen.go @@ -109,6 +109,14 @@ import ( // |-----> (*) Msgsize // |-----> (*) MsgIsZero // +// hashKind +// |-----> MarshalMsg +// |-----> CanMarshalMsg +// |-----> (*) UnmarshalMsg +// |-----> (*) CanUnmarshalMsg +// |-----> Msgsize +// |-----> MsgIsZero +// // resourceFlags // |-----> MarshalMsg // |-----> CanMarshalMsg @@ -192,8 +200,8 @@ func (z CatchpointCatchupState) MsgIsZero() bool { func (z *CatchpointFileHeader) MarshalMsg(b []byte) (o []byte) { o = msgp.Require(b, z.Msgsize()) // omitempty: check for empty values - zb0001Len := uint32(8) - var zb0001Mask uint16 /* 9 bits */ + zb0001Len := uint32(9) + var zb0001Mask uint16 /* 10 bits */ if (*z).Totals.MsgIsZero() { zb0001Len-- zb0001Mask |= 0x2 @@ -222,10 +230,14 @@ func (z *CatchpointFileHeader) MarshalMsg(b []byte) (o []byte) { zb0001Len-- zb0001Mask |= 0x80 } - if (*z).Version == 0 { + if (*z).TotalKVs == 0 { zb0001Len-- zb0001Mask |= 0x100 } + if (*z).Version == 0 { + zb0001Len-- + zb0001Mask |= 0x200 + } // variable map header, size zb0001Len o = append(o, 0x80|uint8(zb0001Len)) if zb0001Len != 0 { @@ -265,6 +277,11 @@ func (z *CatchpointFileHeader) MarshalMsg(b []byte) (o []byte) { o = msgp.AppendUint64(o, (*z).TotalChunks) } if (zb0001Mask & 0x100) == 0 { // if not empty + // string "kvsCount" + o = append(o, 0xa8, 0x6b, 0x76, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74) + o = msgp.AppendUint64(o, (*z).TotalKVs) + } + if (zb0001Mask & 0x200) == 0 { // if not empty // string "version" o = append(o, 0xa7, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e) o = msgp.AppendUint64(o, (*z).Version) @@ -339,6 +356,14 @@ func (z *CatchpointFileHeader) UnmarshalMsg(bts []byte) (o []byte, err error) { return } } + if zb0001 > 0 { + zb0001-- + (*z).TotalKVs, bts, err = msgp.ReadUint64Bytes(bts) + if err != nil { + err = msgp.WrapError(err, "struct-from-array", "TotalKVs") + return + } + } if zb0001 > 0 { zb0001-- (*z).Catchpoint, bts, err = msgp.ReadStringBytes(bts) @@ -414,6 +439,12 @@ func (z *CatchpointFileHeader) UnmarshalMsg(bts []byte) (o []byte, err error) { err = msgp.WrapError(err, "TotalChunks") return } + case "kvsCount": + (*z).TotalKVs, bts, err = msgp.ReadUint64Bytes(bts) + if err != nil { + err = msgp.WrapError(err, "TotalKVs") + return + } case "catchpoint": (*z).Catchpoint, bts, err = msgp.ReadStringBytes(bts) if err != nil { @@ -446,13 +477,13 @@ func (_ *CatchpointFileHeader) CanUnmarshalMsg(z interface{}) bool { // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message func (z *CatchpointFileHeader) Msgsize() (s int) { - s = 1 + 8 + msgp.Uint64Size + 14 + (*z).BalancesRound.Msgsize() + 12 + (*z).BlocksRound.Msgsize() + 14 + (*z).Totals.Msgsize() + 14 + msgp.Uint64Size + 12 + msgp.Uint64Size + 11 + msgp.StringPrefixSize + len((*z).Catchpoint) + 18 + (*z).BlockHeaderDigest.Msgsize() + s = 1 + 8 + msgp.Uint64Size + 14 + (*z).BalancesRound.Msgsize() + 12 + (*z).BlocksRound.Msgsize() + 14 + (*z).Totals.Msgsize() + 14 + msgp.Uint64Size + 12 + msgp.Uint64Size + 9 + msgp.Uint64Size + 11 + msgp.StringPrefixSize + len((*z).Catchpoint) + 18 + (*z).BlockHeaderDigest.Msgsize() return } // MsgIsZero returns whether this is a zero value func (z *CatchpointFileHeader) MsgIsZero() bool { - return ((*z).Version == 0) && ((*z).BalancesRound.MsgIsZero()) && ((*z).BlocksRound.MsgIsZero()) && ((*z).Totals.MsgIsZero()) && ((*z).TotalAccounts == 0) && ((*z).TotalChunks == 0) && ((*z).Catchpoint == "") && ((*z).BlockHeaderDigest.MsgIsZero()) + return ((*z).Version == 0) && ((*z).BalancesRound.MsgIsZero()) && ((*z).BlocksRound.MsgIsZero()) && ((*z).Totals.MsgIsZero()) && ((*z).TotalAccounts == 0) && ((*z).TotalChunks == 0) && ((*z).TotalKVs == 0) && ((*z).Catchpoint == "") && ((*z).BlockHeaderDigest.MsgIsZero()) } // MarshalMsg implements msgp.Marshaler @@ -2285,8 +2316,8 @@ func (z *catchpointFileChunkV6) MsgIsZero() bool { func (z *catchpointFirstStageInfo) MarshalMsg(b []byte) (o []byte) { o = msgp.Require(b, z.Msgsize()) // omitempty: check for empty values - zb0001Len := uint32(5) - var zb0001Mask uint8 /* 6 bits */ + zb0001Len := uint32(6) + var zb0001Mask uint8 /* 7 bits */ if (*z).Totals.MsgIsZero() { zb0001Len-- zb0001Mask |= 0x2 @@ -2303,10 +2334,14 @@ func (z *catchpointFirstStageInfo) MarshalMsg(b []byte) (o []byte) { zb0001Len-- zb0001Mask |= 0x10 } - if (*z).TrieBalancesHash.MsgIsZero() { + if (*z).TotalKVs == 0 { zb0001Len-- zb0001Mask |= 0x20 } + if (*z).TrieBalancesHash.MsgIsZero() { + zb0001Len-- + zb0001Mask |= 0x40 + } // variable map header, size zb0001Len o = append(o, 0x80|uint8(zb0001Len)) if zb0001Len != 0 { @@ -2331,6 +2366,11 @@ func (z *catchpointFirstStageInfo) MarshalMsg(b []byte) (o []byte) { o = msgp.AppendUint64(o, (*z).TotalChunks) } if (zb0001Mask & 0x20) == 0 { // if not empty + // string "kvsCount" + o = append(o, 0xa8, 0x6b, 0x76, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74) + o = msgp.AppendUint64(o, (*z).TotalKVs) + } + if (zb0001Mask & 0x40) == 0 { // if not empty // string "trieBalancesHash" o = append(o, 0xb0, 0x74, 0x72, 0x69, 0x65, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x48, 0x61, 0x73, 0x68) o = (*z).TrieBalancesHash.MarshalMsg(o) @@ -2381,6 +2421,14 @@ func (z *catchpointFirstStageInfo) UnmarshalMsg(bts []byte) (o []byte, err error return } } + if zb0001 > 0 { + zb0001-- + (*z).TotalKVs, bts, err = msgp.ReadUint64Bytes(bts) + if err != nil { + err = msgp.WrapError(err, "struct-from-array", "TotalKVs") + return + } + } if zb0001 > 0 { zb0001-- (*z).TotalChunks, bts, err = msgp.ReadUint64Bytes(bts) @@ -2438,6 +2486,12 @@ func (z *catchpointFirstStageInfo) UnmarshalMsg(bts []byte) (o []byte, err error err = msgp.WrapError(err, "TotalAccounts") return } + case "kvsCount": + (*z).TotalKVs, bts, err = msgp.ReadUint64Bytes(bts) + if err != nil { + err = msgp.WrapError(err, "TotalKVs") + return + } case "chunksCount": (*z).TotalChunks, bts, err = msgp.ReadUint64Bytes(bts) if err != nil { @@ -2470,13 +2524,13 @@ func (_ *catchpointFirstStageInfo) CanUnmarshalMsg(z interface{}) bool { // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message func (z *catchpointFirstStageInfo) Msgsize() (s int) { - s = 1 + 14 + (*z).Totals.Msgsize() + 17 + (*z).TrieBalancesHash.Msgsize() + 14 + msgp.Uint64Size + 12 + msgp.Uint64Size + 13 + msgp.Uint64Size + s = 1 + 14 + (*z).Totals.Msgsize() + 17 + (*z).TrieBalancesHash.Msgsize() + 14 + msgp.Uint64Size + 9 + msgp.Uint64Size + 12 + msgp.Uint64Size + 13 + msgp.Uint64Size return } // MsgIsZero returns whether this is a zero value func (z *catchpointFirstStageInfo) MsgIsZero() bool { - return ((*z).Totals.MsgIsZero()) && ((*z).TrieBalancesHash.MsgIsZero()) && ((*z).TotalAccounts == 0) && ((*z).TotalChunks == 0) && ((*z).BiggestChunkLen == 0) + return ((*z).Totals.MsgIsZero()) && ((*z).TrieBalancesHash.MsgIsZero()) && ((*z).TotalAccounts == 0) && ((*z).TotalKVs == 0) && ((*z).TotalChunks == 0) && ((*z).BiggestChunkLen == 0) } // MarshalMsg implements msgp.Marshaler @@ -3077,6 +3131,52 @@ func (z *encodedKVRecordV6) MsgIsZero() bool { return (len((*z).Key) == 0) && (len((*z).Value) == 0) } +// MarshalMsg implements msgp.Marshaler +func (z hashKind) MarshalMsg(b []byte) (o []byte) { + o = msgp.Require(b, z.Msgsize()) + o = msgp.AppendByte(o, byte(z)) + return +} + +func (_ hashKind) CanMarshalMsg(z interface{}) bool { + _, ok := (z).(hashKind) + if !ok { + _, ok = (z).(*hashKind) + } + return ok +} + +// UnmarshalMsg implements msgp.Unmarshaler +func (z *hashKind) UnmarshalMsg(bts []byte) (o []byte, err error) { + { + var zb0001 byte + zb0001, bts, err = msgp.ReadByteBytes(bts) + if err != nil { + err = msgp.WrapError(err) + return + } + (*z) = hashKind(zb0001) + } + o = bts + return +} + +func (_ *hashKind) CanUnmarshalMsg(z interface{}) bool { + _, ok := (z).(*hashKind) + return ok +} + +// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message +func (z hashKind) Msgsize() (s int) { + s = msgp.ByteSize + return +} + +// MsgIsZero returns whether this is a zero value +func (z hashKind) MsgIsZero() bool { + return z == 0 +} + // MarshalMsg implements msgp.Marshaler func (z resourceFlags) MarshalMsg(b []byte) (o []byte) { o = msgp.Require(b, z.Msgsize()) diff --git a/logging/telemetryspec/event.go b/logging/telemetryspec/event.go index eb7340e2d7..0cc633429c 100644 --- a/logging/telemetryspec/event.go +++ b/logging/telemetryspec/event.go @@ -329,6 +329,8 @@ type CatchpointGenerationEventDetails struct { BalancesWriteTime uint64 // AccountsCount is the number of accounts that were written into the generated catchpoint file AccountsCount uint64 + // KVsCount is the number of accounts that were written into the generated catchpoint file + KVsCount uint64 // FileSize is the size of the catchpoint file, in bytes. FileSize uint64 // CatchpointLabel is the catchpoint label for which the catchpoint file was generated. diff --git a/node/node.go b/node/node.go index 11ce27fda7..c1617f2ba2 100644 --- a/node/node.go +++ b/node/node.go @@ -84,6 +84,9 @@ type StatusReport struct { CatchpointCatchupTotalAccounts uint64 CatchpointCatchupProcessedAccounts uint64 CatchpointCatchupVerifiedAccounts uint64 + CatchpointCatchupTotalKVs uint64 + CatchpointCatchupProcessedKVs uint64 + CatchpointCatchupVerifiedKVs uint64 CatchpointCatchupTotalBlocks uint64 CatchpointCatchupAcquiredBlocks uint64 } @@ -675,6 +678,9 @@ func (node *AlgorandFullNode) Status() (s StatusReport, err error) { s.CatchpointCatchupTotalAccounts = stats.TotalAccounts s.CatchpointCatchupProcessedAccounts = stats.ProcessedAccounts s.CatchpointCatchupVerifiedAccounts = stats.VerifiedAccounts + s.CatchpointCatchupTotalKVs = stats.TotalKVs + s.CatchpointCatchupProcessedKVs = stats.ProcessedKVs + s.CatchpointCatchupVerifiedKVs = stats.VerifiedKVs s.CatchpointCatchupTotalBlocks = stats.TotalBlocks s.CatchpointCatchupAcquiredBlocks = stats.AcquiredBlocks s.CatchupTime = time.Now().Sub(stats.StartTime)