From fab265bced5420ad8ca76c59170024fc744c83ca Mon Sep 17 00:00:00 2001 From: Sam Calder-Mason Date: Wed, 30 Sep 2026 17:35:58 +1000 Subject: [PATCH 1/2] feat(consensus): fast confirmation page Adds /ethereum/consensus/fast-confirmation. Every epoch a fast confirmation node has scored since it started reporting is drawn as one cell, one row per UTC day, coloured by the slowest block in the epoch. Clicking a cell or a scar opens that epoch's 32 blocks per client. The page also lists the worst runs of late confirmations, the distribution of time to fast confirmation against time to finality, and a per-client summary. API types regenerated for fct_block_fast_confirmation_by_node, fct_block_fast_confirmation_by_client_hourly and fct_block_fast_confirmation_by_client_daily. --- src/api/@tanstack/react-query.gen.ts | 204 + src/api/index.ts | 45 + src/api/sdk.gen.ts | 144 + src/api/types.gen.ts | 2864 ++++++++++++ src/api/zod.gen.ts | 3985 +++++++++++++++++ src/components/Layout/Sidebar/Sidebar.tsx | 2 + .../consensus/fast-confirmation/IndexPage.tsx | 263 ++ .../components/BlockField/BlockField.tsx | 175 + .../components/BlockField/index.ts | 2 + .../components/ClientTable/ClientTable.tsx | 62 + .../components/ClientTable/index.ts | 2 + .../ConfirmationDistribution.tsx | 145 + .../ConfirmationDistribution/index.ts | 2 + .../components/EpochDetail/EpochDetail.tsx | 123 + .../components/EpochDetail/index.ts | 2 + .../FastConfirmationSkeleton.tsx | 47 + .../FastConfirmationSkeleton/index.ts | 1 + .../components/ScarList/ScarList.tsx | 58 + .../components/ScarList/index.ts | 2 + .../fast-confirmation/components/index.ts | 6 + .../consensus/fast-confirmation/constants.ts | 20 + .../fast-confirmation.api.ts | 54 + .../fast-confirmation.utils.test.ts | 174 + .../fast-confirmation.utils.ts | 320 ++ .../consensus/fast-confirmation/index.ts | 1 + src/routeTree.gen.ts | 23 + .../ethereum/consensus/fast-confirmation.tsx | 41 + 27 files changed, 8767 insertions(+) create mode 100644 src/pages/ethereum/consensus/fast-confirmation/IndexPage.tsx create mode 100644 src/pages/ethereum/consensus/fast-confirmation/components/BlockField/BlockField.tsx create mode 100644 src/pages/ethereum/consensus/fast-confirmation/components/BlockField/index.ts create mode 100644 src/pages/ethereum/consensus/fast-confirmation/components/ClientTable/ClientTable.tsx create mode 100644 src/pages/ethereum/consensus/fast-confirmation/components/ClientTable/index.ts create mode 100644 src/pages/ethereum/consensus/fast-confirmation/components/ConfirmationDistribution/ConfirmationDistribution.tsx create mode 100644 src/pages/ethereum/consensus/fast-confirmation/components/ConfirmationDistribution/index.ts create mode 100644 src/pages/ethereum/consensus/fast-confirmation/components/EpochDetail/EpochDetail.tsx create mode 100644 src/pages/ethereum/consensus/fast-confirmation/components/EpochDetail/index.ts create mode 100644 src/pages/ethereum/consensus/fast-confirmation/components/FastConfirmationSkeleton/FastConfirmationSkeleton.tsx create mode 100644 src/pages/ethereum/consensus/fast-confirmation/components/FastConfirmationSkeleton/index.ts create mode 100644 src/pages/ethereum/consensus/fast-confirmation/components/ScarList/ScarList.tsx create mode 100644 src/pages/ethereum/consensus/fast-confirmation/components/ScarList/index.ts create mode 100644 src/pages/ethereum/consensus/fast-confirmation/components/index.ts create mode 100644 src/pages/ethereum/consensus/fast-confirmation/constants.ts create mode 100644 src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.api.ts create mode 100644 src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.utils.test.ts create mode 100644 src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.utils.ts create mode 100644 src/pages/ethereum/consensus/fast-confirmation/index.ts create mode 100644 src/routes/ethereum/consensus/fast-confirmation.tsx diff --git a/src/api/@tanstack/react-query.gen.ts b/src/api/@tanstack/react-query.gen.ts index d38c00969..6a5b0f46b 100644 --- a/src/api/@tanstack/react-query.gen.ts +++ b/src/api/@tanstack/react-query.gen.ts @@ -76,6 +76,12 @@ import { fctBlockDataColumnSidecarFirstSeenByNodeServiceList, fctBlockDataColumnSidecarFirstSeenServiceGet, fctBlockDataColumnSidecarFirstSeenServiceList, + fctBlockFastConfirmationByClientDailyServiceGet, + fctBlockFastConfirmationByClientDailyServiceList, + fctBlockFastConfirmationByClientHourlyServiceGet, + fctBlockFastConfirmationByClientHourlyServiceList, + fctBlockFastConfirmationByNodeServiceGet, + fctBlockFastConfirmationByNodeServiceList, fctBlockFirstSeenByNodeServiceGet, fctBlockFirstSeenByNodeServiceList, fctBlockHeadServiceGet, @@ -643,6 +649,24 @@ import type { FctBlockDataColumnSidecarFirstSeenServiceListData, FctBlockDataColumnSidecarFirstSeenServiceListError, FctBlockDataColumnSidecarFirstSeenServiceListResponse, + FctBlockFastConfirmationByClientDailyServiceGetData, + FctBlockFastConfirmationByClientDailyServiceGetError, + FctBlockFastConfirmationByClientDailyServiceGetResponse, + FctBlockFastConfirmationByClientDailyServiceListData, + FctBlockFastConfirmationByClientDailyServiceListError, + FctBlockFastConfirmationByClientDailyServiceListResponse, + FctBlockFastConfirmationByClientHourlyServiceGetData, + FctBlockFastConfirmationByClientHourlyServiceGetError, + FctBlockFastConfirmationByClientHourlyServiceGetResponse, + FctBlockFastConfirmationByClientHourlyServiceListData, + FctBlockFastConfirmationByClientHourlyServiceListError, + FctBlockFastConfirmationByClientHourlyServiceListResponse, + FctBlockFastConfirmationByNodeServiceGetData, + FctBlockFastConfirmationByNodeServiceGetError, + FctBlockFastConfirmationByNodeServiceGetResponse, + FctBlockFastConfirmationByNodeServiceListData, + FctBlockFastConfirmationByNodeServiceListError, + FctBlockFastConfirmationByNodeServiceListResponse, FctBlockFirstSeenByNodeServiceGetData, FctBlockFirstSeenByNodeServiceGetError, FctBlockFirstSeenByNodeServiceGetResponse, @@ -3850,6 +3874,186 @@ export const fctBlockDataColumnSidecarFirstSeenByNodeServiceGetOptions = ( queryKey: fctBlockDataColumnSidecarFirstSeenByNodeServiceGetQueryKey(options), }); +export const fctBlockFastConfirmationByClientDailyServiceListQueryKey = ( + options?: Options +) => createQueryKey('fctBlockFastConfirmationByClientDailyServiceList', options); + +/** + * List records + * + * Retrieve paginated results with optional filtering + */ +export const fctBlockFastConfirmationByClientDailyServiceListOptions = ( + options?: Options +) => + queryOptions< + FctBlockFastConfirmationByClientDailyServiceListResponse, + FctBlockFastConfirmationByClientDailyServiceListError, + FctBlockFastConfirmationByClientDailyServiceListResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await fctBlockFastConfirmationByClientDailyServiceList({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: fctBlockFastConfirmationByClientDailyServiceListQueryKey(options), + }); + +export const fctBlockFastConfirmationByClientDailyServiceGetQueryKey = ( + options: Options +) => createQueryKey('fctBlockFastConfirmationByClientDailyServiceGet', options); + +/** + * Get record + * + * Retrieve a single record by day_start_date + */ +export const fctBlockFastConfirmationByClientDailyServiceGetOptions = ( + options: Options +) => + queryOptions< + FctBlockFastConfirmationByClientDailyServiceGetResponse, + FctBlockFastConfirmationByClientDailyServiceGetError, + FctBlockFastConfirmationByClientDailyServiceGetResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await fctBlockFastConfirmationByClientDailyServiceGet({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: fctBlockFastConfirmationByClientDailyServiceGetQueryKey(options), + }); + +export const fctBlockFastConfirmationByClientHourlyServiceListQueryKey = ( + options?: Options +) => createQueryKey('fctBlockFastConfirmationByClientHourlyServiceList', options); + +/** + * List records + * + * Retrieve paginated results with optional filtering + */ +export const fctBlockFastConfirmationByClientHourlyServiceListOptions = ( + options?: Options +) => + queryOptions< + FctBlockFastConfirmationByClientHourlyServiceListResponse, + FctBlockFastConfirmationByClientHourlyServiceListError, + FctBlockFastConfirmationByClientHourlyServiceListResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await fctBlockFastConfirmationByClientHourlyServiceList({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: fctBlockFastConfirmationByClientHourlyServiceListQueryKey(options), + }); + +export const fctBlockFastConfirmationByClientHourlyServiceGetQueryKey = ( + options: Options +) => createQueryKey('fctBlockFastConfirmationByClientHourlyServiceGet', options); + +/** + * Get record + * + * Retrieve a single record by hour_start_date_time + */ +export const fctBlockFastConfirmationByClientHourlyServiceGetOptions = ( + options: Options +) => + queryOptions< + FctBlockFastConfirmationByClientHourlyServiceGetResponse, + FctBlockFastConfirmationByClientHourlyServiceGetError, + FctBlockFastConfirmationByClientHourlyServiceGetResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await fctBlockFastConfirmationByClientHourlyServiceGet({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: fctBlockFastConfirmationByClientHourlyServiceGetQueryKey(options), + }); + +export const fctBlockFastConfirmationByNodeServiceListQueryKey = ( + options?: Options +) => createQueryKey('fctBlockFastConfirmationByNodeServiceList', options); + +/** + * List records + * + * Retrieve paginated results with optional filtering + */ +export const fctBlockFastConfirmationByNodeServiceListOptions = ( + options?: Options +) => + queryOptions< + FctBlockFastConfirmationByNodeServiceListResponse, + FctBlockFastConfirmationByNodeServiceListError, + FctBlockFastConfirmationByNodeServiceListResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await fctBlockFastConfirmationByNodeServiceList({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: fctBlockFastConfirmationByNodeServiceListQueryKey(options), + }); + +export const fctBlockFastConfirmationByNodeServiceGetQueryKey = ( + options: Options +) => createQueryKey('fctBlockFastConfirmationByNodeServiceGet', options); + +/** + * Get record + * + * Retrieve a single record by slot_start_date_time + */ +export const fctBlockFastConfirmationByNodeServiceGetOptions = ( + options: Options +) => + queryOptions< + FctBlockFastConfirmationByNodeServiceGetResponse, + FctBlockFastConfirmationByNodeServiceGetError, + FctBlockFastConfirmationByNodeServiceGetResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await fctBlockFastConfirmationByNodeServiceGet({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: fctBlockFastConfirmationByNodeServiceGetQueryKey(options), + }); + export const fctBlockFirstSeenByNodeServiceListQueryKey = (options?: Options) => createQueryKey('fctBlockFirstSeenByNodeServiceList', options); diff --git a/src/api/index.ts b/src/api/index.ts index c362d6362..eaad2da0e 100644 --- a/src/api/index.ts +++ b/src/api/index.ts @@ -73,6 +73,12 @@ export { fctBlockDataColumnSidecarFirstSeenByNodeServiceList, fctBlockDataColumnSidecarFirstSeenServiceGet, fctBlockDataColumnSidecarFirstSeenServiceList, + fctBlockFastConfirmationByClientDailyServiceGet, + fctBlockFastConfirmationByClientDailyServiceList, + fctBlockFastConfirmationByClientHourlyServiceGet, + fctBlockFastConfirmationByClientHourlyServiceList, + fctBlockFastConfirmationByNodeServiceGet, + fctBlockFastConfirmationByNodeServiceList, fctBlockFirstSeenByNodeServiceGet, fctBlockFirstSeenByNodeServiceList, fctBlockHeadServiceGet, @@ -822,6 +828,39 @@ export type { FctBlockDataColumnSidecarFirstSeenServiceListErrors, FctBlockDataColumnSidecarFirstSeenServiceListResponse, FctBlockDataColumnSidecarFirstSeenServiceListResponses, + FctBlockFastConfirmationByClientDaily, + FctBlockFastConfirmationByClientDailyServiceGetData, + FctBlockFastConfirmationByClientDailyServiceGetError, + FctBlockFastConfirmationByClientDailyServiceGetErrors, + FctBlockFastConfirmationByClientDailyServiceGetResponse, + FctBlockFastConfirmationByClientDailyServiceGetResponses, + FctBlockFastConfirmationByClientDailyServiceListData, + FctBlockFastConfirmationByClientDailyServiceListError, + FctBlockFastConfirmationByClientDailyServiceListErrors, + FctBlockFastConfirmationByClientDailyServiceListResponse, + FctBlockFastConfirmationByClientDailyServiceListResponses, + FctBlockFastConfirmationByClientHourly, + FctBlockFastConfirmationByClientHourlyServiceGetData, + FctBlockFastConfirmationByClientHourlyServiceGetError, + FctBlockFastConfirmationByClientHourlyServiceGetErrors, + FctBlockFastConfirmationByClientHourlyServiceGetResponse, + FctBlockFastConfirmationByClientHourlyServiceGetResponses, + FctBlockFastConfirmationByClientHourlyServiceListData, + FctBlockFastConfirmationByClientHourlyServiceListError, + FctBlockFastConfirmationByClientHourlyServiceListErrors, + FctBlockFastConfirmationByClientHourlyServiceListResponse, + FctBlockFastConfirmationByClientHourlyServiceListResponses, + FctBlockFastConfirmationByNode, + FctBlockFastConfirmationByNodeServiceGetData, + FctBlockFastConfirmationByNodeServiceGetError, + FctBlockFastConfirmationByNodeServiceGetErrors, + FctBlockFastConfirmationByNodeServiceGetResponse, + FctBlockFastConfirmationByNodeServiceGetResponses, + FctBlockFastConfirmationByNodeServiceListData, + FctBlockFastConfirmationByNodeServiceListError, + FctBlockFastConfirmationByNodeServiceListErrors, + FctBlockFastConfirmationByNodeServiceListResponse, + FctBlockFastConfirmationByNodeServiceListResponses, FctBlockFirstSeenByNode, FctBlockFirstSeenByNodeServiceGetData, FctBlockFirstSeenByNodeServiceGetError, @@ -1946,6 +1985,9 @@ export type { GetFctBlockBlobHeadResponse, GetFctBlockDataColumnSidecarFirstSeenByNodeResponse, GetFctBlockDataColumnSidecarFirstSeenResponse, + GetFctBlockFastConfirmationByClientDailyResponse, + GetFctBlockFastConfirmationByClientHourlyResponse, + GetFctBlockFastConfirmationByNodeResponse, GetFctBlockFirstSeenByNodeResponse, GetFctBlockHeadResponse, GetFctBlockMevHeadResponse, @@ -2982,6 +3024,9 @@ export type { ListFctBlockBlobHeadResponse, ListFctBlockDataColumnSidecarFirstSeenByNodeResponse, ListFctBlockDataColumnSidecarFirstSeenResponse, + ListFctBlockFastConfirmationByClientDailyResponse, + ListFctBlockFastConfirmationByClientHourlyResponse, + ListFctBlockFastConfirmationByNodeResponse, ListFctBlockFirstSeenByNodeResponse, ListFctBlockHeadResponse, ListFctBlockMevHeadResponse, diff --git a/src/api/sdk.gen.ts b/src/api/sdk.gen.ts index 25d45ef94..f9e020a65 100644 --- a/src/api/sdk.gen.ts +++ b/src/api/sdk.gen.ts @@ -219,6 +219,24 @@ import type { FctBlockDataColumnSidecarFirstSeenServiceListData, FctBlockDataColumnSidecarFirstSeenServiceListErrors, FctBlockDataColumnSidecarFirstSeenServiceListResponses, + FctBlockFastConfirmationByClientDailyServiceGetData, + FctBlockFastConfirmationByClientDailyServiceGetErrors, + FctBlockFastConfirmationByClientDailyServiceGetResponses, + FctBlockFastConfirmationByClientDailyServiceListData, + FctBlockFastConfirmationByClientDailyServiceListErrors, + FctBlockFastConfirmationByClientDailyServiceListResponses, + FctBlockFastConfirmationByClientHourlyServiceGetData, + FctBlockFastConfirmationByClientHourlyServiceGetErrors, + FctBlockFastConfirmationByClientHourlyServiceGetResponses, + FctBlockFastConfirmationByClientHourlyServiceListData, + FctBlockFastConfirmationByClientHourlyServiceListErrors, + FctBlockFastConfirmationByClientHourlyServiceListResponses, + FctBlockFastConfirmationByNodeServiceGetData, + FctBlockFastConfirmationByNodeServiceGetErrors, + FctBlockFastConfirmationByNodeServiceGetResponses, + FctBlockFastConfirmationByNodeServiceListData, + FctBlockFastConfirmationByNodeServiceListErrors, + FctBlockFastConfirmationByNodeServiceListResponses, FctBlockFirstSeenByNodeServiceGetData, FctBlockFirstSeenByNodeServiceGetErrors, FctBlockFirstSeenByNodeServiceGetResponses, @@ -1409,6 +1427,18 @@ import { zFctBlockDataColumnSidecarFirstSeenServiceGetResponse, zFctBlockDataColumnSidecarFirstSeenServiceListData, zFctBlockDataColumnSidecarFirstSeenServiceListResponse, + zFctBlockFastConfirmationByClientDailyServiceGetData, + zFctBlockFastConfirmationByClientDailyServiceGetResponse, + zFctBlockFastConfirmationByClientDailyServiceListData, + zFctBlockFastConfirmationByClientDailyServiceListResponse, + zFctBlockFastConfirmationByClientHourlyServiceGetData, + zFctBlockFastConfirmationByClientHourlyServiceGetResponse, + zFctBlockFastConfirmationByClientHourlyServiceListData, + zFctBlockFastConfirmationByClientHourlyServiceListResponse, + zFctBlockFastConfirmationByNodeServiceGetData, + zFctBlockFastConfirmationByNodeServiceGetResponse, + zFctBlockFastConfirmationByNodeServiceListData, + zFctBlockFastConfirmationByNodeServiceListResponse, zFctBlockFirstSeenByNodeServiceGetData, zFctBlockFirstSeenByNodeServiceGetResponse, zFctBlockFirstSeenByNodeServiceListData, @@ -3507,6 +3537,120 @@ export const fctBlockDataColumnSidecarFirstSeenByNodeServiceGet = ( + options?: Options +) => + (options?.client ?? client).get< + FctBlockFastConfirmationByClientDailyServiceListResponses, + FctBlockFastConfirmationByClientDailyServiceListErrors, + ThrowOnError + >({ + requestValidator: async data => await zFctBlockFastConfirmationByClientDailyServiceListData.parseAsync(data), + responseValidator: async data => await zFctBlockFastConfirmationByClientDailyServiceListResponse.parseAsync(data), + url: '/api/v1/fct_block_fast_confirmation_by_client_daily', + ...options, + }); + +/** + * Get record + * + * Retrieve a single record by day_start_date + */ +export const fctBlockFastConfirmationByClientDailyServiceGet = ( + options: Options +) => + (options.client ?? client).get< + FctBlockFastConfirmationByClientDailyServiceGetResponses, + FctBlockFastConfirmationByClientDailyServiceGetErrors, + ThrowOnError + >({ + requestValidator: async data => await zFctBlockFastConfirmationByClientDailyServiceGetData.parseAsync(data), + responseValidator: async data => await zFctBlockFastConfirmationByClientDailyServiceGetResponse.parseAsync(data), + url: '/api/v1/fct_block_fast_confirmation_by_client_daily/{day_start_date}', + ...options, + }); + +/** + * List records + * + * Retrieve paginated results with optional filtering + */ +export const fctBlockFastConfirmationByClientHourlyServiceList = ( + options?: Options +) => + (options?.client ?? client).get< + FctBlockFastConfirmationByClientHourlyServiceListResponses, + FctBlockFastConfirmationByClientHourlyServiceListErrors, + ThrowOnError + >({ + requestValidator: async data => await zFctBlockFastConfirmationByClientHourlyServiceListData.parseAsync(data), + responseValidator: async data => await zFctBlockFastConfirmationByClientHourlyServiceListResponse.parseAsync(data), + url: '/api/v1/fct_block_fast_confirmation_by_client_hourly', + ...options, + }); + +/** + * Get record + * + * Retrieve a single record by hour_start_date_time + */ +export const fctBlockFastConfirmationByClientHourlyServiceGet = ( + options: Options +) => + (options.client ?? client).get< + FctBlockFastConfirmationByClientHourlyServiceGetResponses, + FctBlockFastConfirmationByClientHourlyServiceGetErrors, + ThrowOnError + >({ + requestValidator: async data => await zFctBlockFastConfirmationByClientHourlyServiceGetData.parseAsync(data), + responseValidator: async data => await zFctBlockFastConfirmationByClientHourlyServiceGetResponse.parseAsync(data), + url: '/api/v1/fct_block_fast_confirmation_by_client_hourly/{hour_start_date_time}', + ...options, + }); + +/** + * List records + * + * Retrieve paginated results with optional filtering + */ +export const fctBlockFastConfirmationByNodeServiceList = ( + options?: Options +) => + (options?.client ?? client).get< + FctBlockFastConfirmationByNodeServiceListResponses, + FctBlockFastConfirmationByNodeServiceListErrors, + ThrowOnError + >({ + requestValidator: async data => await zFctBlockFastConfirmationByNodeServiceListData.parseAsync(data), + responseValidator: async data => await zFctBlockFastConfirmationByNodeServiceListResponse.parseAsync(data), + url: '/api/v1/fct_block_fast_confirmation_by_node', + ...options, + }); + +/** + * Get record + * + * Retrieve a single record by slot_start_date_time + */ +export const fctBlockFastConfirmationByNodeServiceGet = ( + options: Options +) => + (options.client ?? client).get< + FctBlockFastConfirmationByNodeServiceGetResponses, + FctBlockFastConfirmationByNodeServiceGetErrors, + ThrowOnError + >({ + requestValidator: async data => await zFctBlockFastConfirmationByNodeServiceGetData.parseAsync(data), + responseValidator: async data => await zFctBlockFastConfirmationByNodeServiceGetResponse.parseAsync(data), + url: '/api/v1/fct_block_fast_confirmation_by_node/{slot_start_date_time}', + ...options, + }); + /** * List records * diff --git a/src/api/types.gen.ts b/src/api/types.gen.ts index d2ac60db5..85aa47e9a 100644 --- a/src/api/types.gen.ts +++ b/src/api/types.gen.ts @@ -1819,6 +1819,259 @@ export type FctBlockDataColumnSidecarFirstSeenByNode = { username?: string; }; +export type FctBlockFastConfirmationByClientDaily = { + /** + * Average milliseconds from slot start to fast confirmation + */ + avg_fast_confirmation_ms?: number; + /** + * Average milliseconds from slot start to finality + */ + avg_finality_ms?: number; + /** + * Start of the day period + */ + day_start_date?: string; + /** + * Observations where the block was only confirmed through an event for a later block + */ + descendant_count?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself + */ + direct_count?: number; + /** + * Maximum milliseconds from slot start to fast confirmation + */ + max_fast_confirmation_ms?: number; + /** + * Maximum milliseconds from slot start to finality + */ + max_finality_ms?: number; + /** + * Consensus client implementation running the fast confirmation rule + */ + meta_consensus_implementation?: string; + /** + * Minimum milliseconds from slot start to fast confirmation + */ + min_fast_confirmation_ms?: number; + /** + * Minimum milliseconds from slot start to finality + */ + min_finality_ms?: number; + /** + * Number of fast confirmation nodes running this consensus client + */ + node_count?: number; + /** + * Number of (canonical block, node) observations + */ + observation_count?: number; + /** + * Fast confirmation events for blocks that did not become canonical + */ + orphaned_count?: number; + /** + * Median milliseconds from slot start to fast confirmation + */ + p50_fast_confirmation_ms?: number; + /** + * Median milliseconds from slot start to finality + */ + p50_finality_ms?: number; + /** + * Median per-block ratio of time to finality over time to fast confirmation + */ + p50_speedup?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation + */ + p90_fast_confirmation_ms?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation + */ + p95_fast_confirmation_ms?: number; + /** + * 95th percentile milliseconds from slot start to finality + */ + p95_finality_ms?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation + */ + p99_fast_confirmation_ms?: number; + /** + * Number of canonical blocks scored for this consensus client + */ + slot_count?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes + */ + unconfirmed_count?: number; + /** + * Timestamp when the record was last updated + */ + updated_date_time?: number; +}; + +export type FctBlockFastConfirmationByClientHourly = { + /** + * Average milliseconds from slot start to fast confirmation + */ + avg_fast_confirmation_ms?: number; + /** + * Average milliseconds from slot start to finality + */ + avg_finality_ms?: number; + /** + * Observations where the block was only confirmed through an event for a later block + */ + descendant_count?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself + */ + direct_count?: number; + /** + * Start of the hour period + */ + hour_start_date_time?: number; + /** + * Maximum milliseconds from slot start to fast confirmation + */ + max_fast_confirmation_ms?: number; + /** + * Maximum milliseconds from slot start to finality + */ + max_finality_ms?: number; + /** + * Consensus client implementation running the fast confirmation rule + */ + meta_consensus_implementation?: string; + /** + * Minimum milliseconds from slot start to fast confirmation + */ + min_fast_confirmation_ms?: number; + /** + * Minimum milliseconds from slot start to finality + */ + min_finality_ms?: number; + /** + * Number of fast confirmation nodes running this consensus client + */ + node_count?: number; + /** + * Number of (canonical block, node) observations + */ + observation_count?: number; + /** + * Fast confirmation events for blocks that did not become canonical + */ + orphaned_count?: number; + /** + * Median milliseconds from slot start to fast confirmation + */ + p50_fast_confirmation_ms?: number; + /** + * Median milliseconds from slot start to finality + */ + p50_finality_ms?: number; + /** + * Median per-block ratio of time to finality over time to fast confirmation + */ + p50_speedup?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation + */ + p90_fast_confirmation_ms?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation + */ + p95_fast_confirmation_ms?: number; + /** + * 95th percentile milliseconds from slot start to finality + */ + p95_finality_ms?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation + */ + p99_fast_confirmation_ms?: number; + /** + * Number of canonical blocks scored for this consensus client + */ + slot_count?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes + */ + unconfirmed_count?: number; + /** + * Timestamp when the record was last updated + */ + updated_date_time?: number; +}; + +export type FctBlockFastConfirmationByNode = { + /** + * The beacon block root hash + */ + block_root?: string; + /** + * How the block was fast confirmed: direct (an event for this block), descendant (only implied by an event for a later block), or unconfirmed (no confirmation seen within 30 minutes) + */ + confirmation_type?: string; + /** + * The epoch number containing the slot + */ + epoch?: number; + /** + * The wall clock time when the epoch started + */ + epoch_start_date_time?: number; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations + */ + fast_confirmation_slot?: number | null; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant + */ + fast_confirmed_slot_start_diff?: number | null; + /** + * Epoch of the finalized checkpoint that first covered this block + */ + finalized_epoch?: number | null; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block + */ + finalized_slot_start_diff?: number | null; + /** + * Name of the sentry node that emitted the fast confirmation events + */ + meta_client_name?: string; + /** + * Consensus client implementation running the fast confirmation rule + */ + meta_consensus_implementation?: string; + /** + * Consensus client version running the fast confirmation rule + */ + meta_consensus_version?: string; + /** + * The slot number of the block + */ + slot?: number; + /** + * The wall clock time when the slot started + */ + slot_start_date_time?: number; + /** + * Chain status of the block: canonical, or orphaned when a node fast confirmed a block that did not become canonical + */ + status?: string; + /** + * Timestamp when the record was last updated + */ + updated_date_time?: number; +}; + export type FctBlockFirstSeenByNode = { /** * The beacon block root hash @@ -7003,6 +7256,27 @@ export type GetFctBlockDataColumnSidecarFirstSeenResponse = { item?: FctBlockDataColumnSidecarFirstSeen; }; +/** + * Response for getting a single fct_block_fast_confirmation_by_client_daily record + */ +export type GetFctBlockFastConfirmationByClientDailyResponse = { + item?: FctBlockFastConfirmationByClientDaily; +}; + +/** + * Response for getting a single fct_block_fast_confirmation_by_client_hourly record + */ +export type GetFctBlockFastConfirmationByClientHourlyResponse = { + item?: FctBlockFastConfirmationByClientHourly; +}; + +/** + * Response for getting a single fct_block_fast_confirmation_by_node record + */ +export type GetFctBlockFastConfirmationByNodeResponse = { + item?: FctBlockFastConfirmationByNode; +}; + /** * Response for getting a single fct_block_first_seen_by_node record */ @@ -12073,6 +12347,48 @@ export type ListFctBlockDataColumnSidecarFirstSeenResponse = { next_page_token?: string; }; +/** + * Response for listing fct_block_fast_confirmation_by_client_daily records + */ +export type ListFctBlockFastConfirmationByClientDailyResponse = { + /** + * The list of fct_block_fast_confirmation_by_client_daily. + */ + fct_block_fast_confirmation_by_client_daily?: Array; + /** + * A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages. + */ + next_page_token?: string; +}; + +/** + * Response for listing fct_block_fast_confirmation_by_client_hourly records + */ +export type ListFctBlockFastConfirmationByClientHourlyResponse = { + /** + * The list of fct_block_fast_confirmation_by_client_hourly. + */ + fct_block_fast_confirmation_by_client_hourly?: Array; + /** + * A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages. + */ + next_page_token?: string; +}; + +/** + * Response for listing fct_block_fast_confirmation_by_node records + */ +export type ListFctBlockFastConfirmationByNodeResponse = { + /** + * The list of fct_block_fast_confirmation_by_node. + */ + fct_block_fast_confirmation_by_node?: Array; + /** + * A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages. + */ + next_page_token?: string; +}; + /** * Response for listing fct_block_first_seen_by_node records */ @@ -31140,6 +31456,2554 @@ export type FctBlockDataColumnSidecarFirstSeenByNodeServiceGetResponses = { export type FctBlockDataColumnSidecarFirstSeenByNodeServiceGetResponse = FctBlockDataColumnSidecarFirstSeenByNodeServiceGetResponses[keyof FctBlockDataColumnSidecarFirstSeenByNodeServiceGetResponses]; +export type FctBlockFastConfirmationByClientDailyServiceListData = { + body?: never; + path?: never; + query?: { + /** + * Start of the day period (filter: eq) + */ + day_start_date_eq?: string; + /** + * Start of the day period (filter: ne) + */ + day_start_date_ne?: string; + /** + * Start of the day period (filter: contains) + */ + day_start_date_contains?: string; + /** + * Start of the day period (filter: starts_with) + */ + day_start_date_starts_with?: string; + /** + * Start of the day period (filter: ends_with) + */ + day_start_date_ends_with?: string; + /** + * Start of the day period (filter: like) + */ + day_start_date_like?: string; + /** + * Start of the day period (filter: not_like) + */ + day_start_date_not_like?: string; + /** + * Start of the day period (filter: in_values) (comma-separated list) + */ + day_start_date_in_values?: string; + /** + * Start of the day period (filter: not_in_values) (comma-separated list) + */ + day_start_date_not_in_values?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: eq) + */ + meta_consensus_implementation_eq?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: ne) + */ + meta_consensus_implementation_ne?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: contains) + */ + meta_consensus_implementation_contains?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: starts_with) + */ + meta_consensus_implementation_starts_with?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: ends_with) + */ + meta_consensus_implementation_ends_with?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: like) + */ + meta_consensus_implementation_like?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: not_like) + */ + meta_consensus_implementation_not_like?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: in_values) (comma-separated list) + */ + meta_consensus_implementation_in_values?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: not_in_values) (comma-separated list) + */ + meta_consensus_implementation_not_in_values?: string; + /** + * Timestamp when the record was last updated (filter: eq) + */ + updated_date_time_eq?: number; + /** + * Timestamp when the record was last updated (filter: ne) + */ + updated_date_time_ne?: number; + /** + * Timestamp when the record was last updated (filter: lt) + */ + updated_date_time_lt?: number; + /** + * Timestamp when the record was last updated (filter: lte) + */ + updated_date_time_lte?: number; + /** + * Timestamp when the record was last updated (filter: gt) + */ + updated_date_time_gt?: number; + /** + * Timestamp when the record was last updated (filter: gte) + */ + updated_date_time_gte?: number; + /** + * Timestamp when the record was last updated (filter: between_min) + */ + updated_date_time_between_min?: number; + /** + * Timestamp when the record was last updated (filter: between_max_value) + */ + updated_date_time_between_max_value?: number; + /** + * Timestamp when the record was last updated (filter: in_values) (comma-separated list) + */ + updated_date_time_in_values?: string; + /** + * Timestamp when the record was last updated (filter: not_in_values) (comma-separated list) + */ + updated_date_time_not_in_values?: string; + /** + * Number of fast confirmation nodes running this consensus client (filter: eq) + */ + node_count_eq?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: ne) + */ + node_count_ne?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: lt) + */ + node_count_lt?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: lte) + */ + node_count_lte?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: gt) + */ + node_count_gt?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: gte) + */ + node_count_gte?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: between_min) + */ + node_count_between_min?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: between_max_value) + */ + node_count_between_max_value?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: in_values) (comma-separated list) + */ + node_count_in_values?: string; + /** + * Number of fast confirmation nodes running this consensus client (filter: not_in_values) (comma-separated list) + */ + node_count_not_in_values?: string; + /** + * Number of canonical blocks scored for this consensus client (filter: eq) + */ + slot_count_eq?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: ne) + */ + slot_count_ne?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: lt) + */ + slot_count_lt?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: lte) + */ + slot_count_lte?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: gt) + */ + slot_count_gt?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: gte) + */ + slot_count_gte?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: between_min) + */ + slot_count_between_min?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: between_max_value) + */ + slot_count_between_max_value?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: in_values) (comma-separated list) + */ + slot_count_in_values?: string; + /** + * Number of canonical blocks scored for this consensus client (filter: not_in_values) (comma-separated list) + */ + slot_count_not_in_values?: string; + /** + * Number of (canonical block, node) observations (filter: eq) + */ + observation_count_eq?: number; + /** + * Number of (canonical block, node) observations (filter: ne) + */ + observation_count_ne?: number; + /** + * Number of (canonical block, node) observations (filter: lt) + */ + observation_count_lt?: number; + /** + * Number of (canonical block, node) observations (filter: lte) + */ + observation_count_lte?: number; + /** + * Number of (canonical block, node) observations (filter: gt) + */ + observation_count_gt?: number; + /** + * Number of (canonical block, node) observations (filter: gte) + */ + observation_count_gte?: number; + /** + * Number of (canonical block, node) observations (filter: between_min) + */ + observation_count_between_min?: number; + /** + * Number of (canonical block, node) observations (filter: between_max_value) + */ + observation_count_between_max_value?: number; + /** + * Number of (canonical block, node) observations (filter: in_values) (comma-separated list) + */ + observation_count_in_values?: string; + /** + * Number of (canonical block, node) observations (filter: not_in_values) (comma-separated list) + */ + observation_count_not_in_values?: string; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: eq) + */ + direct_count_eq?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: ne) + */ + direct_count_ne?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: lt) + */ + direct_count_lt?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: lte) + */ + direct_count_lte?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: gt) + */ + direct_count_gt?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: gte) + */ + direct_count_gte?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: between_min) + */ + direct_count_between_min?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: between_max_value) + */ + direct_count_between_max_value?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: in_values) (comma-separated list) + */ + direct_count_in_values?: string; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: not_in_values) (comma-separated list) + */ + direct_count_not_in_values?: string; + /** + * Observations where the block was only confirmed through an event for a later block (filter: eq) + */ + descendant_count_eq?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: ne) + */ + descendant_count_ne?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: lt) + */ + descendant_count_lt?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: lte) + */ + descendant_count_lte?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: gt) + */ + descendant_count_gt?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: gte) + */ + descendant_count_gte?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: between_min) + */ + descendant_count_between_min?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: between_max_value) + */ + descendant_count_between_max_value?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: in_values) (comma-separated list) + */ + descendant_count_in_values?: string; + /** + * Observations where the block was only confirmed through an event for a later block (filter: not_in_values) (comma-separated list) + */ + descendant_count_not_in_values?: string; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: eq) + */ + unconfirmed_count_eq?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: ne) + */ + unconfirmed_count_ne?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: lt) + */ + unconfirmed_count_lt?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: lte) + */ + unconfirmed_count_lte?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: gt) + */ + unconfirmed_count_gt?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: gte) + */ + unconfirmed_count_gte?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: between_min) + */ + unconfirmed_count_between_min?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: between_max_value) + */ + unconfirmed_count_between_max_value?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: in_values) (comma-separated list) + */ + unconfirmed_count_in_values?: string; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: not_in_values) (comma-separated list) + */ + unconfirmed_count_not_in_values?: string; + /** + * Fast confirmation events for blocks that did not become canonical (filter: eq) + */ + orphaned_count_eq?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: ne) + */ + orphaned_count_ne?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: lt) + */ + orphaned_count_lt?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: lte) + */ + orphaned_count_lte?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: gt) + */ + orphaned_count_gt?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: gte) + */ + orphaned_count_gte?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: between_min) + */ + orphaned_count_between_min?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: between_max_value) + */ + orphaned_count_between_max_value?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: in_values) (comma-separated list) + */ + orphaned_count_in_values?: string; + /** + * Fast confirmation events for blocks that did not become canonical (filter: not_in_values) (comma-separated list) + */ + orphaned_count_not_in_values?: string; + /** + * Average milliseconds from slot start to fast confirmation (filter: eq) + */ + avg_fast_confirmation_ms_eq?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: ne) + */ + avg_fast_confirmation_ms_ne?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: lt) + */ + avg_fast_confirmation_ms_lt?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: lte) + */ + avg_fast_confirmation_ms_lte?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: gt) + */ + avg_fast_confirmation_ms_gt?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: gte) + */ + avg_fast_confirmation_ms_gte?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: between_min) + */ + avg_fast_confirmation_ms_between_min?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + avg_fast_confirmation_ms_between_max_value?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + avg_fast_confirmation_ms_in_values?: string; + /** + * Average milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + avg_fast_confirmation_ms_not_in_values?: string; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: eq) + */ + min_fast_confirmation_ms_eq?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: ne) + */ + min_fast_confirmation_ms_ne?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: lt) + */ + min_fast_confirmation_ms_lt?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: lte) + */ + min_fast_confirmation_ms_lte?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: gt) + */ + min_fast_confirmation_ms_gt?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: gte) + */ + min_fast_confirmation_ms_gte?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: between_min) + */ + min_fast_confirmation_ms_between_min?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + min_fast_confirmation_ms_between_max_value?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + min_fast_confirmation_ms_in_values?: string; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + min_fast_confirmation_ms_not_in_values?: string; + /** + * Median milliseconds from slot start to fast confirmation (filter: eq) + */ + p50_fast_confirmation_ms_eq?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: ne) + */ + p50_fast_confirmation_ms_ne?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: lt) + */ + p50_fast_confirmation_ms_lt?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: lte) + */ + p50_fast_confirmation_ms_lte?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: gt) + */ + p50_fast_confirmation_ms_gt?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: gte) + */ + p50_fast_confirmation_ms_gte?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: between_min) + */ + p50_fast_confirmation_ms_between_min?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + p50_fast_confirmation_ms_between_max_value?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + p50_fast_confirmation_ms_in_values?: string; + /** + * Median milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + p50_fast_confirmation_ms_not_in_values?: string; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: eq) + */ + p90_fast_confirmation_ms_eq?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: ne) + */ + p90_fast_confirmation_ms_ne?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: lt) + */ + p90_fast_confirmation_ms_lt?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: lte) + */ + p90_fast_confirmation_ms_lte?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: gt) + */ + p90_fast_confirmation_ms_gt?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: gte) + */ + p90_fast_confirmation_ms_gte?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: between_min) + */ + p90_fast_confirmation_ms_between_min?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + p90_fast_confirmation_ms_between_max_value?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + p90_fast_confirmation_ms_in_values?: string; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + p90_fast_confirmation_ms_not_in_values?: string; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: eq) + */ + p95_fast_confirmation_ms_eq?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: ne) + */ + p95_fast_confirmation_ms_ne?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: lt) + */ + p95_fast_confirmation_ms_lt?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: lte) + */ + p95_fast_confirmation_ms_lte?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: gt) + */ + p95_fast_confirmation_ms_gt?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: gte) + */ + p95_fast_confirmation_ms_gte?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: between_min) + */ + p95_fast_confirmation_ms_between_min?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + p95_fast_confirmation_ms_between_max_value?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + p95_fast_confirmation_ms_in_values?: string; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + p95_fast_confirmation_ms_not_in_values?: string; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: eq) + */ + p99_fast_confirmation_ms_eq?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: ne) + */ + p99_fast_confirmation_ms_ne?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: lt) + */ + p99_fast_confirmation_ms_lt?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: lte) + */ + p99_fast_confirmation_ms_lte?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: gt) + */ + p99_fast_confirmation_ms_gt?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: gte) + */ + p99_fast_confirmation_ms_gte?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: between_min) + */ + p99_fast_confirmation_ms_between_min?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + p99_fast_confirmation_ms_between_max_value?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + p99_fast_confirmation_ms_in_values?: string; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + p99_fast_confirmation_ms_not_in_values?: string; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: eq) + */ + max_fast_confirmation_ms_eq?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: ne) + */ + max_fast_confirmation_ms_ne?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: lt) + */ + max_fast_confirmation_ms_lt?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: lte) + */ + max_fast_confirmation_ms_lte?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: gt) + */ + max_fast_confirmation_ms_gt?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: gte) + */ + max_fast_confirmation_ms_gte?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: between_min) + */ + max_fast_confirmation_ms_between_min?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + max_fast_confirmation_ms_between_max_value?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + max_fast_confirmation_ms_in_values?: string; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + max_fast_confirmation_ms_not_in_values?: string; + /** + * Average milliseconds from slot start to finality (filter: eq) + */ + avg_finality_ms_eq?: number; + /** + * Average milliseconds from slot start to finality (filter: ne) + */ + avg_finality_ms_ne?: number; + /** + * Average milliseconds from slot start to finality (filter: lt) + */ + avg_finality_ms_lt?: number; + /** + * Average milliseconds from slot start to finality (filter: lte) + */ + avg_finality_ms_lte?: number; + /** + * Average milliseconds from slot start to finality (filter: gt) + */ + avg_finality_ms_gt?: number; + /** + * Average milliseconds from slot start to finality (filter: gte) + */ + avg_finality_ms_gte?: number; + /** + * Average milliseconds from slot start to finality (filter: between_min) + */ + avg_finality_ms_between_min?: number; + /** + * Average milliseconds from slot start to finality (filter: between_max_value) + */ + avg_finality_ms_between_max_value?: number; + /** + * Average milliseconds from slot start to finality (filter: in_values) (comma-separated list) + */ + avg_finality_ms_in_values?: string; + /** + * Average milliseconds from slot start to finality (filter: not_in_values) (comma-separated list) + */ + avg_finality_ms_not_in_values?: string; + /** + * Minimum milliseconds from slot start to finality (filter: eq) + */ + min_finality_ms_eq?: number; + /** + * Minimum milliseconds from slot start to finality (filter: ne) + */ + min_finality_ms_ne?: number; + /** + * Minimum milliseconds from slot start to finality (filter: lt) + */ + min_finality_ms_lt?: number; + /** + * Minimum milliseconds from slot start to finality (filter: lte) + */ + min_finality_ms_lte?: number; + /** + * Minimum milliseconds from slot start to finality (filter: gt) + */ + min_finality_ms_gt?: number; + /** + * Minimum milliseconds from slot start to finality (filter: gte) + */ + min_finality_ms_gte?: number; + /** + * Minimum milliseconds from slot start to finality (filter: between_min) + */ + min_finality_ms_between_min?: number; + /** + * Minimum milliseconds from slot start to finality (filter: between_max_value) + */ + min_finality_ms_between_max_value?: number; + /** + * Minimum milliseconds from slot start to finality (filter: in_values) (comma-separated list) + */ + min_finality_ms_in_values?: string; + /** + * Minimum milliseconds from slot start to finality (filter: not_in_values) (comma-separated list) + */ + min_finality_ms_not_in_values?: string; + /** + * Median milliseconds from slot start to finality (filter: eq) + */ + p50_finality_ms_eq?: number; + /** + * Median milliseconds from slot start to finality (filter: ne) + */ + p50_finality_ms_ne?: number; + /** + * Median milliseconds from slot start to finality (filter: lt) + */ + p50_finality_ms_lt?: number; + /** + * Median milliseconds from slot start to finality (filter: lte) + */ + p50_finality_ms_lte?: number; + /** + * Median milliseconds from slot start to finality (filter: gt) + */ + p50_finality_ms_gt?: number; + /** + * Median milliseconds from slot start to finality (filter: gte) + */ + p50_finality_ms_gte?: number; + /** + * Median milliseconds from slot start to finality (filter: between_min) + */ + p50_finality_ms_between_min?: number; + /** + * Median milliseconds from slot start to finality (filter: between_max_value) + */ + p50_finality_ms_between_max_value?: number; + /** + * Median milliseconds from slot start to finality (filter: in_values) (comma-separated list) + */ + p50_finality_ms_in_values?: string; + /** + * Median milliseconds from slot start to finality (filter: not_in_values) (comma-separated list) + */ + p50_finality_ms_not_in_values?: string; + /** + * 95th percentile milliseconds from slot start to finality (filter: eq) + */ + p95_finality_ms_eq?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: ne) + */ + p95_finality_ms_ne?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: lt) + */ + p95_finality_ms_lt?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: lte) + */ + p95_finality_ms_lte?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: gt) + */ + p95_finality_ms_gt?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: gte) + */ + p95_finality_ms_gte?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: between_min) + */ + p95_finality_ms_between_min?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: between_max_value) + */ + p95_finality_ms_between_max_value?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: in_values) (comma-separated list) + */ + p95_finality_ms_in_values?: string; + /** + * 95th percentile milliseconds from slot start to finality (filter: not_in_values) (comma-separated list) + */ + p95_finality_ms_not_in_values?: string; + /** + * Maximum milliseconds from slot start to finality (filter: eq) + */ + max_finality_ms_eq?: number; + /** + * Maximum milliseconds from slot start to finality (filter: ne) + */ + max_finality_ms_ne?: number; + /** + * Maximum milliseconds from slot start to finality (filter: lt) + */ + max_finality_ms_lt?: number; + /** + * Maximum milliseconds from slot start to finality (filter: lte) + */ + max_finality_ms_lte?: number; + /** + * Maximum milliseconds from slot start to finality (filter: gt) + */ + max_finality_ms_gt?: number; + /** + * Maximum milliseconds from slot start to finality (filter: gte) + */ + max_finality_ms_gte?: number; + /** + * Maximum milliseconds from slot start to finality (filter: between_min) + */ + max_finality_ms_between_min?: number; + /** + * Maximum milliseconds from slot start to finality (filter: between_max_value) + */ + max_finality_ms_between_max_value?: number; + /** + * Maximum milliseconds from slot start to finality (filter: in_values) (comma-separated list) + */ + max_finality_ms_in_values?: string; + /** + * Maximum milliseconds from slot start to finality (filter: not_in_values) (comma-separated list) + */ + max_finality_ms_not_in_values?: string; + /** + * Filter p50_speedup using value + */ + p50_speedup_value?: number; + /** + * The maximum number of fct_block_fast_confirmation_by_client_daily to return. If unspecified, at most 100 items will be returned. The maximum value is 10000; values above 10000 will be coerced to 10000. + */ + page_size?: number; + /** + * A page token, received from a previous `ListFctBlockFastConfirmationByClientDaily` call. Provide this to retrieve the subsequent page. + */ + page_token?: string; + /** + * The order of results. Format: comma-separated list of fields. Example: "foo,bar" or "foo desc,bar" for descending order on foo. If unspecified, results will be returned in the default order. + */ + order_by?: string; + }; + url: '/api/v1/fct_block_fast_confirmation_by_client_daily'; +}; + +export type FctBlockFastConfirmationByClientDailyServiceListErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type FctBlockFastConfirmationByClientDailyServiceListError = + FctBlockFastConfirmationByClientDailyServiceListErrors[keyof FctBlockFastConfirmationByClientDailyServiceListErrors]; + +export type FctBlockFastConfirmationByClientDailyServiceListResponses = { + /** + * OK + */ + 200: ListFctBlockFastConfirmationByClientDailyResponse; +}; + +export type FctBlockFastConfirmationByClientDailyServiceListResponse = + FctBlockFastConfirmationByClientDailyServiceListResponses[keyof FctBlockFastConfirmationByClientDailyServiceListResponses]; + +export type FctBlockFastConfirmationByClientDailyServiceGetData = { + body?: never; + path: { + /** + * Start of the day period + */ + day_start_date: string; + }; + query?: never; + url: '/api/v1/fct_block_fast_confirmation_by_client_daily/{day_start_date}'; +}; + +export type FctBlockFastConfirmationByClientDailyServiceGetErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type FctBlockFastConfirmationByClientDailyServiceGetError = + FctBlockFastConfirmationByClientDailyServiceGetErrors[keyof FctBlockFastConfirmationByClientDailyServiceGetErrors]; + +export type FctBlockFastConfirmationByClientDailyServiceGetResponses = { + /** + * OK + */ + 200: GetFctBlockFastConfirmationByClientDailyResponse; +}; + +export type FctBlockFastConfirmationByClientDailyServiceGetResponse = + FctBlockFastConfirmationByClientDailyServiceGetResponses[keyof FctBlockFastConfirmationByClientDailyServiceGetResponses]; + +export type FctBlockFastConfirmationByClientHourlyServiceListData = { + body?: never; + path?: never; + query?: { + /** + * Start of the hour period (filter: eq) + */ + hour_start_date_time_eq?: number; + /** + * Start of the hour period (filter: ne) + */ + hour_start_date_time_ne?: number; + /** + * Start of the hour period (filter: lt) + */ + hour_start_date_time_lt?: number; + /** + * Start of the hour period (filter: lte) + */ + hour_start_date_time_lte?: number; + /** + * Start of the hour period (filter: gt) + */ + hour_start_date_time_gt?: number; + /** + * Start of the hour period (filter: gte) + */ + hour_start_date_time_gte?: number; + /** + * Start of the hour period (filter: between_min) + */ + hour_start_date_time_between_min?: number; + /** + * Start of the hour period (filter: between_max_value) + */ + hour_start_date_time_between_max_value?: number; + /** + * Start of the hour period (filter: in_values) (comma-separated list) + */ + hour_start_date_time_in_values?: string; + /** + * Start of the hour period (filter: not_in_values) (comma-separated list) + */ + hour_start_date_time_not_in_values?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: eq) + */ + meta_consensus_implementation_eq?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: ne) + */ + meta_consensus_implementation_ne?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: contains) + */ + meta_consensus_implementation_contains?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: starts_with) + */ + meta_consensus_implementation_starts_with?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: ends_with) + */ + meta_consensus_implementation_ends_with?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: like) + */ + meta_consensus_implementation_like?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: not_like) + */ + meta_consensus_implementation_not_like?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: in_values) (comma-separated list) + */ + meta_consensus_implementation_in_values?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: not_in_values) (comma-separated list) + */ + meta_consensus_implementation_not_in_values?: string; + /** + * Timestamp when the record was last updated (filter: eq) + */ + updated_date_time_eq?: number; + /** + * Timestamp when the record was last updated (filter: ne) + */ + updated_date_time_ne?: number; + /** + * Timestamp when the record was last updated (filter: lt) + */ + updated_date_time_lt?: number; + /** + * Timestamp when the record was last updated (filter: lte) + */ + updated_date_time_lte?: number; + /** + * Timestamp when the record was last updated (filter: gt) + */ + updated_date_time_gt?: number; + /** + * Timestamp when the record was last updated (filter: gte) + */ + updated_date_time_gte?: number; + /** + * Timestamp when the record was last updated (filter: between_min) + */ + updated_date_time_between_min?: number; + /** + * Timestamp when the record was last updated (filter: between_max_value) + */ + updated_date_time_between_max_value?: number; + /** + * Timestamp when the record was last updated (filter: in_values) (comma-separated list) + */ + updated_date_time_in_values?: string; + /** + * Timestamp when the record was last updated (filter: not_in_values) (comma-separated list) + */ + updated_date_time_not_in_values?: string; + /** + * Number of fast confirmation nodes running this consensus client (filter: eq) + */ + node_count_eq?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: ne) + */ + node_count_ne?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: lt) + */ + node_count_lt?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: lte) + */ + node_count_lte?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: gt) + */ + node_count_gt?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: gte) + */ + node_count_gte?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: between_min) + */ + node_count_between_min?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: between_max_value) + */ + node_count_between_max_value?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: in_values) (comma-separated list) + */ + node_count_in_values?: string; + /** + * Number of fast confirmation nodes running this consensus client (filter: not_in_values) (comma-separated list) + */ + node_count_not_in_values?: string; + /** + * Number of canonical blocks scored for this consensus client (filter: eq) + */ + slot_count_eq?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: ne) + */ + slot_count_ne?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: lt) + */ + slot_count_lt?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: lte) + */ + slot_count_lte?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: gt) + */ + slot_count_gt?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: gte) + */ + slot_count_gte?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: between_min) + */ + slot_count_between_min?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: between_max_value) + */ + slot_count_between_max_value?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: in_values) (comma-separated list) + */ + slot_count_in_values?: string; + /** + * Number of canonical blocks scored for this consensus client (filter: not_in_values) (comma-separated list) + */ + slot_count_not_in_values?: string; + /** + * Number of (canonical block, node) observations (filter: eq) + */ + observation_count_eq?: number; + /** + * Number of (canonical block, node) observations (filter: ne) + */ + observation_count_ne?: number; + /** + * Number of (canonical block, node) observations (filter: lt) + */ + observation_count_lt?: number; + /** + * Number of (canonical block, node) observations (filter: lte) + */ + observation_count_lte?: number; + /** + * Number of (canonical block, node) observations (filter: gt) + */ + observation_count_gt?: number; + /** + * Number of (canonical block, node) observations (filter: gte) + */ + observation_count_gte?: number; + /** + * Number of (canonical block, node) observations (filter: between_min) + */ + observation_count_between_min?: number; + /** + * Number of (canonical block, node) observations (filter: between_max_value) + */ + observation_count_between_max_value?: number; + /** + * Number of (canonical block, node) observations (filter: in_values) (comma-separated list) + */ + observation_count_in_values?: string; + /** + * Number of (canonical block, node) observations (filter: not_in_values) (comma-separated list) + */ + observation_count_not_in_values?: string; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: eq) + */ + direct_count_eq?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: ne) + */ + direct_count_ne?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: lt) + */ + direct_count_lt?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: lte) + */ + direct_count_lte?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: gt) + */ + direct_count_gt?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: gte) + */ + direct_count_gte?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: between_min) + */ + direct_count_between_min?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: between_max_value) + */ + direct_count_between_max_value?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: in_values) (comma-separated list) + */ + direct_count_in_values?: string; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: not_in_values) (comma-separated list) + */ + direct_count_not_in_values?: string; + /** + * Observations where the block was only confirmed through an event for a later block (filter: eq) + */ + descendant_count_eq?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: ne) + */ + descendant_count_ne?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: lt) + */ + descendant_count_lt?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: lte) + */ + descendant_count_lte?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: gt) + */ + descendant_count_gt?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: gte) + */ + descendant_count_gte?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: between_min) + */ + descendant_count_between_min?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: between_max_value) + */ + descendant_count_between_max_value?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: in_values) (comma-separated list) + */ + descendant_count_in_values?: string; + /** + * Observations where the block was only confirmed through an event for a later block (filter: not_in_values) (comma-separated list) + */ + descendant_count_not_in_values?: string; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: eq) + */ + unconfirmed_count_eq?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: ne) + */ + unconfirmed_count_ne?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: lt) + */ + unconfirmed_count_lt?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: lte) + */ + unconfirmed_count_lte?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: gt) + */ + unconfirmed_count_gt?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: gte) + */ + unconfirmed_count_gte?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: between_min) + */ + unconfirmed_count_between_min?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: between_max_value) + */ + unconfirmed_count_between_max_value?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: in_values) (comma-separated list) + */ + unconfirmed_count_in_values?: string; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: not_in_values) (comma-separated list) + */ + unconfirmed_count_not_in_values?: string; + /** + * Fast confirmation events for blocks that did not become canonical (filter: eq) + */ + orphaned_count_eq?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: ne) + */ + orphaned_count_ne?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: lt) + */ + orphaned_count_lt?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: lte) + */ + orphaned_count_lte?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: gt) + */ + orphaned_count_gt?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: gte) + */ + orphaned_count_gte?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: between_min) + */ + orphaned_count_between_min?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: between_max_value) + */ + orphaned_count_between_max_value?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: in_values) (comma-separated list) + */ + orphaned_count_in_values?: string; + /** + * Fast confirmation events for blocks that did not become canonical (filter: not_in_values) (comma-separated list) + */ + orphaned_count_not_in_values?: string; + /** + * Average milliseconds from slot start to fast confirmation (filter: eq) + */ + avg_fast_confirmation_ms_eq?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: ne) + */ + avg_fast_confirmation_ms_ne?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: lt) + */ + avg_fast_confirmation_ms_lt?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: lte) + */ + avg_fast_confirmation_ms_lte?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: gt) + */ + avg_fast_confirmation_ms_gt?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: gte) + */ + avg_fast_confirmation_ms_gte?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: between_min) + */ + avg_fast_confirmation_ms_between_min?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + avg_fast_confirmation_ms_between_max_value?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + avg_fast_confirmation_ms_in_values?: string; + /** + * Average milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + avg_fast_confirmation_ms_not_in_values?: string; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: eq) + */ + min_fast_confirmation_ms_eq?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: ne) + */ + min_fast_confirmation_ms_ne?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: lt) + */ + min_fast_confirmation_ms_lt?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: lte) + */ + min_fast_confirmation_ms_lte?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: gt) + */ + min_fast_confirmation_ms_gt?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: gte) + */ + min_fast_confirmation_ms_gte?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: between_min) + */ + min_fast_confirmation_ms_between_min?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + min_fast_confirmation_ms_between_max_value?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + min_fast_confirmation_ms_in_values?: string; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + min_fast_confirmation_ms_not_in_values?: string; + /** + * Median milliseconds from slot start to fast confirmation (filter: eq) + */ + p50_fast_confirmation_ms_eq?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: ne) + */ + p50_fast_confirmation_ms_ne?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: lt) + */ + p50_fast_confirmation_ms_lt?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: lte) + */ + p50_fast_confirmation_ms_lte?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: gt) + */ + p50_fast_confirmation_ms_gt?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: gte) + */ + p50_fast_confirmation_ms_gte?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: between_min) + */ + p50_fast_confirmation_ms_between_min?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + p50_fast_confirmation_ms_between_max_value?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + p50_fast_confirmation_ms_in_values?: string; + /** + * Median milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + p50_fast_confirmation_ms_not_in_values?: string; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: eq) + */ + p90_fast_confirmation_ms_eq?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: ne) + */ + p90_fast_confirmation_ms_ne?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: lt) + */ + p90_fast_confirmation_ms_lt?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: lte) + */ + p90_fast_confirmation_ms_lte?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: gt) + */ + p90_fast_confirmation_ms_gt?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: gte) + */ + p90_fast_confirmation_ms_gte?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: between_min) + */ + p90_fast_confirmation_ms_between_min?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + p90_fast_confirmation_ms_between_max_value?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + p90_fast_confirmation_ms_in_values?: string; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + p90_fast_confirmation_ms_not_in_values?: string; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: eq) + */ + p95_fast_confirmation_ms_eq?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: ne) + */ + p95_fast_confirmation_ms_ne?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: lt) + */ + p95_fast_confirmation_ms_lt?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: lte) + */ + p95_fast_confirmation_ms_lte?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: gt) + */ + p95_fast_confirmation_ms_gt?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: gte) + */ + p95_fast_confirmation_ms_gte?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: between_min) + */ + p95_fast_confirmation_ms_between_min?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + p95_fast_confirmation_ms_between_max_value?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + p95_fast_confirmation_ms_in_values?: string; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + p95_fast_confirmation_ms_not_in_values?: string; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: eq) + */ + p99_fast_confirmation_ms_eq?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: ne) + */ + p99_fast_confirmation_ms_ne?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: lt) + */ + p99_fast_confirmation_ms_lt?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: lte) + */ + p99_fast_confirmation_ms_lte?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: gt) + */ + p99_fast_confirmation_ms_gt?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: gte) + */ + p99_fast_confirmation_ms_gte?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: between_min) + */ + p99_fast_confirmation_ms_between_min?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + p99_fast_confirmation_ms_between_max_value?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + p99_fast_confirmation_ms_in_values?: string; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + p99_fast_confirmation_ms_not_in_values?: string; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: eq) + */ + max_fast_confirmation_ms_eq?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: ne) + */ + max_fast_confirmation_ms_ne?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: lt) + */ + max_fast_confirmation_ms_lt?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: lte) + */ + max_fast_confirmation_ms_lte?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: gt) + */ + max_fast_confirmation_ms_gt?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: gte) + */ + max_fast_confirmation_ms_gte?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: between_min) + */ + max_fast_confirmation_ms_between_min?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + max_fast_confirmation_ms_between_max_value?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + max_fast_confirmation_ms_in_values?: string; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + max_fast_confirmation_ms_not_in_values?: string; + /** + * Average milliseconds from slot start to finality (filter: eq) + */ + avg_finality_ms_eq?: number; + /** + * Average milliseconds from slot start to finality (filter: ne) + */ + avg_finality_ms_ne?: number; + /** + * Average milliseconds from slot start to finality (filter: lt) + */ + avg_finality_ms_lt?: number; + /** + * Average milliseconds from slot start to finality (filter: lte) + */ + avg_finality_ms_lte?: number; + /** + * Average milliseconds from slot start to finality (filter: gt) + */ + avg_finality_ms_gt?: number; + /** + * Average milliseconds from slot start to finality (filter: gte) + */ + avg_finality_ms_gte?: number; + /** + * Average milliseconds from slot start to finality (filter: between_min) + */ + avg_finality_ms_between_min?: number; + /** + * Average milliseconds from slot start to finality (filter: between_max_value) + */ + avg_finality_ms_between_max_value?: number; + /** + * Average milliseconds from slot start to finality (filter: in_values) (comma-separated list) + */ + avg_finality_ms_in_values?: string; + /** + * Average milliseconds from slot start to finality (filter: not_in_values) (comma-separated list) + */ + avg_finality_ms_not_in_values?: string; + /** + * Minimum milliseconds from slot start to finality (filter: eq) + */ + min_finality_ms_eq?: number; + /** + * Minimum milliseconds from slot start to finality (filter: ne) + */ + min_finality_ms_ne?: number; + /** + * Minimum milliseconds from slot start to finality (filter: lt) + */ + min_finality_ms_lt?: number; + /** + * Minimum milliseconds from slot start to finality (filter: lte) + */ + min_finality_ms_lte?: number; + /** + * Minimum milliseconds from slot start to finality (filter: gt) + */ + min_finality_ms_gt?: number; + /** + * Minimum milliseconds from slot start to finality (filter: gte) + */ + min_finality_ms_gte?: number; + /** + * Minimum milliseconds from slot start to finality (filter: between_min) + */ + min_finality_ms_between_min?: number; + /** + * Minimum milliseconds from slot start to finality (filter: between_max_value) + */ + min_finality_ms_between_max_value?: number; + /** + * Minimum milliseconds from slot start to finality (filter: in_values) (comma-separated list) + */ + min_finality_ms_in_values?: string; + /** + * Minimum milliseconds from slot start to finality (filter: not_in_values) (comma-separated list) + */ + min_finality_ms_not_in_values?: string; + /** + * Median milliseconds from slot start to finality (filter: eq) + */ + p50_finality_ms_eq?: number; + /** + * Median milliseconds from slot start to finality (filter: ne) + */ + p50_finality_ms_ne?: number; + /** + * Median milliseconds from slot start to finality (filter: lt) + */ + p50_finality_ms_lt?: number; + /** + * Median milliseconds from slot start to finality (filter: lte) + */ + p50_finality_ms_lte?: number; + /** + * Median milliseconds from slot start to finality (filter: gt) + */ + p50_finality_ms_gt?: number; + /** + * Median milliseconds from slot start to finality (filter: gte) + */ + p50_finality_ms_gte?: number; + /** + * Median milliseconds from slot start to finality (filter: between_min) + */ + p50_finality_ms_between_min?: number; + /** + * Median milliseconds from slot start to finality (filter: between_max_value) + */ + p50_finality_ms_between_max_value?: number; + /** + * Median milliseconds from slot start to finality (filter: in_values) (comma-separated list) + */ + p50_finality_ms_in_values?: string; + /** + * Median milliseconds from slot start to finality (filter: not_in_values) (comma-separated list) + */ + p50_finality_ms_not_in_values?: string; + /** + * 95th percentile milliseconds from slot start to finality (filter: eq) + */ + p95_finality_ms_eq?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: ne) + */ + p95_finality_ms_ne?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: lt) + */ + p95_finality_ms_lt?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: lte) + */ + p95_finality_ms_lte?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: gt) + */ + p95_finality_ms_gt?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: gte) + */ + p95_finality_ms_gte?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: between_min) + */ + p95_finality_ms_between_min?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: between_max_value) + */ + p95_finality_ms_between_max_value?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: in_values) (comma-separated list) + */ + p95_finality_ms_in_values?: string; + /** + * 95th percentile milliseconds from slot start to finality (filter: not_in_values) (comma-separated list) + */ + p95_finality_ms_not_in_values?: string; + /** + * Maximum milliseconds from slot start to finality (filter: eq) + */ + max_finality_ms_eq?: number; + /** + * Maximum milliseconds from slot start to finality (filter: ne) + */ + max_finality_ms_ne?: number; + /** + * Maximum milliseconds from slot start to finality (filter: lt) + */ + max_finality_ms_lt?: number; + /** + * Maximum milliseconds from slot start to finality (filter: lte) + */ + max_finality_ms_lte?: number; + /** + * Maximum milliseconds from slot start to finality (filter: gt) + */ + max_finality_ms_gt?: number; + /** + * Maximum milliseconds from slot start to finality (filter: gte) + */ + max_finality_ms_gte?: number; + /** + * Maximum milliseconds from slot start to finality (filter: between_min) + */ + max_finality_ms_between_min?: number; + /** + * Maximum milliseconds from slot start to finality (filter: between_max_value) + */ + max_finality_ms_between_max_value?: number; + /** + * Maximum milliseconds from slot start to finality (filter: in_values) (comma-separated list) + */ + max_finality_ms_in_values?: string; + /** + * Maximum milliseconds from slot start to finality (filter: not_in_values) (comma-separated list) + */ + max_finality_ms_not_in_values?: string; + /** + * Filter p50_speedup using value + */ + p50_speedup_value?: number; + /** + * The maximum number of fct_block_fast_confirmation_by_client_hourly to return. If unspecified, at most 100 items will be returned. The maximum value is 10000; values above 10000 will be coerced to 10000. + */ + page_size?: number; + /** + * A page token, received from a previous `ListFctBlockFastConfirmationByClientHourly` call. Provide this to retrieve the subsequent page. + */ + page_token?: string; + /** + * The order of results. Format: comma-separated list of fields. Example: "foo,bar" or "foo desc,bar" for descending order on foo. If unspecified, results will be returned in the default order. + */ + order_by?: string; + }; + url: '/api/v1/fct_block_fast_confirmation_by_client_hourly'; +}; + +export type FctBlockFastConfirmationByClientHourlyServiceListErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type FctBlockFastConfirmationByClientHourlyServiceListError = + FctBlockFastConfirmationByClientHourlyServiceListErrors[keyof FctBlockFastConfirmationByClientHourlyServiceListErrors]; + +export type FctBlockFastConfirmationByClientHourlyServiceListResponses = { + /** + * OK + */ + 200: ListFctBlockFastConfirmationByClientHourlyResponse; +}; + +export type FctBlockFastConfirmationByClientHourlyServiceListResponse = + FctBlockFastConfirmationByClientHourlyServiceListResponses[keyof FctBlockFastConfirmationByClientHourlyServiceListResponses]; + +export type FctBlockFastConfirmationByClientHourlyServiceGetData = { + body?: never; + path: { + /** + * Start of the hour period + */ + hour_start_date_time: number; + }; + query?: never; + url: '/api/v1/fct_block_fast_confirmation_by_client_hourly/{hour_start_date_time}'; +}; + +export type FctBlockFastConfirmationByClientHourlyServiceGetErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type FctBlockFastConfirmationByClientHourlyServiceGetError = + FctBlockFastConfirmationByClientHourlyServiceGetErrors[keyof FctBlockFastConfirmationByClientHourlyServiceGetErrors]; + +export type FctBlockFastConfirmationByClientHourlyServiceGetResponses = { + /** + * OK + */ + 200: GetFctBlockFastConfirmationByClientHourlyResponse; +}; + +export type FctBlockFastConfirmationByClientHourlyServiceGetResponse = + FctBlockFastConfirmationByClientHourlyServiceGetResponses[keyof FctBlockFastConfirmationByClientHourlyServiceGetResponses]; + +export type FctBlockFastConfirmationByNodeServiceListData = { + body?: never; + path?: never; + query?: { + /** + * The wall clock time when the slot started (filter: eq) + */ + slot_start_date_time_eq?: number; + /** + * The wall clock time when the slot started (filter: ne) + */ + slot_start_date_time_ne?: number; + /** + * The wall clock time when the slot started (filter: lt) + */ + slot_start_date_time_lt?: number; + /** + * The wall clock time when the slot started (filter: lte) + */ + slot_start_date_time_lte?: number; + /** + * The wall clock time when the slot started (filter: gt) + */ + slot_start_date_time_gt?: number; + /** + * The wall clock time when the slot started (filter: gte) + */ + slot_start_date_time_gte?: number; + /** + * The wall clock time when the slot started (filter: between_min) + */ + slot_start_date_time_between_min?: number; + /** + * The wall clock time when the slot started (filter: between_max_value) + */ + slot_start_date_time_between_max_value?: number; + /** + * The wall clock time when the slot started (filter: in_values) (comma-separated list) + */ + slot_start_date_time_in_values?: string; + /** + * The wall clock time when the slot started (filter: not_in_values) (comma-separated list) + */ + slot_start_date_time_not_in_values?: string; + /** + * Name of the sentry node that emitted the fast confirmation events (filter: eq) + */ + meta_client_name_eq?: string; + /** + * Name of the sentry node that emitted the fast confirmation events (filter: ne) + */ + meta_client_name_ne?: string; + /** + * Name of the sentry node that emitted the fast confirmation events (filter: contains) + */ + meta_client_name_contains?: string; + /** + * Name of the sentry node that emitted the fast confirmation events (filter: starts_with) + */ + meta_client_name_starts_with?: string; + /** + * Name of the sentry node that emitted the fast confirmation events (filter: ends_with) + */ + meta_client_name_ends_with?: string; + /** + * Name of the sentry node that emitted the fast confirmation events (filter: like) + */ + meta_client_name_like?: string; + /** + * Name of the sentry node that emitted the fast confirmation events (filter: not_like) + */ + meta_client_name_not_like?: string; + /** + * Name of the sentry node that emitted the fast confirmation events (filter: in_values) (comma-separated list) + */ + meta_client_name_in_values?: string; + /** + * Name of the sentry node that emitted the fast confirmation events (filter: not_in_values) (comma-separated list) + */ + meta_client_name_not_in_values?: string; + /** + * The beacon block root hash (filter: eq) + */ + block_root_eq?: string; + /** + * The beacon block root hash (filter: ne) + */ + block_root_ne?: string; + /** + * The beacon block root hash (filter: contains) + */ + block_root_contains?: string; + /** + * The beacon block root hash (filter: starts_with) + */ + block_root_starts_with?: string; + /** + * The beacon block root hash (filter: ends_with) + */ + block_root_ends_with?: string; + /** + * The beacon block root hash (filter: like) + */ + block_root_like?: string; + /** + * The beacon block root hash (filter: not_like) + */ + block_root_not_like?: string; + /** + * The beacon block root hash (filter: in_values) (comma-separated list) + */ + block_root_in_values?: string; + /** + * The beacon block root hash (filter: not_in_values) (comma-separated list) + */ + block_root_not_in_values?: string; + /** + * Timestamp when the record was last updated (filter: eq) + */ + updated_date_time_eq?: number; + /** + * Timestamp when the record was last updated (filter: ne) + */ + updated_date_time_ne?: number; + /** + * Timestamp when the record was last updated (filter: lt) + */ + updated_date_time_lt?: number; + /** + * Timestamp when the record was last updated (filter: lte) + */ + updated_date_time_lte?: number; + /** + * Timestamp when the record was last updated (filter: gt) + */ + updated_date_time_gt?: number; + /** + * Timestamp when the record was last updated (filter: gte) + */ + updated_date_time_gte?: number; + /** + * Timestamp when the record was last updated (filter: between_min) + */ + updated_date_time_between_min?: number; + /** + * Timestamp when the record was last updated (filter: between_max_value) + */ + updated_date_time_between_max_value?: number; + /** + * Timestamp when the record was last updated (filter: in_values) (comma-separated list) + */ + updated_date_time_in_values?: string; + /** + * Timestamp when the record was last updated (filter: not_in_values) (comma-separated list) + */ + updated_date_time_not_in_values?: string; + /** + * The slot number of the block (filter: eq) + */ + slot_eq?: number; + /** + * The slot number of the block (filter: ne) + */ + slot_ne?: number; + /** + * The slot number of the block (filter: lt) + */ + slot_lt?: number; + /** + * The slot number of the block (filter: lte) + */ + slot_lte?: number; + /** + * The slot number of the block (filter: gt) + */ + slot_gt?: number; + /** + * The slot number of the block (filter: gte) + */ + slot_gte?: number; + /** + * The slot number of the block (filter: between_min) + */ + slot_between_min?: number; + /** + * The slot number of the block (filter: between_max_value) + */ + slot_between_max_value?: number; + /** + * The slot number of the block (filter: in_values) (comma-separated list) + */ + slot_in_values?: string; + /** + * The slot number of the block (filter: not_in_values) (comma-separated list) + */ + slot_not_in_values?: string; + /** + * The epoch number containing the slot (filter: eq) + */ + epoch_eq?: number; + /** + * The epoch number containing the slot (filter: ne) + */ + epoch_ne?: number; + /** + * The epoch number containing the slot (filter: lt) + */ + epoch_lt?: number; + /** + * The epoch number containing the slot (filter: lte) + */ + epoch_lte?: number; + /** + * The epoch number containing the slot (filter: gt) + */ + epoch_gt?: number; + /** + * The epoch number containing the slot (filter: gte) + */ + epoch_gte?: number; + /** + * The epoch number containing the slot (filter: between_min) + */ + epoch_between_min?: number; + /** + * The epoch number containing the slot (filter: between_max_value) + */ + epoch_between_max_value?: number; + /** + * The epoch number containing the slot (filter: in_values) (comma-separated list) + */ + epoch_in_values?: string; + /** + * The epoch number containing the slot (filter: not_in_values) (comma-separated list) + */ + epoch_not_in_values?: string; + /** + * The wall clock time when the epoch started (filter: eq) + */ + epoch_start_date_time_eq?: number; + /** + * The wall clock time when the epoch started (filter: ne) + */ + epoch_start_date_time_ne?: number; + /** + * The wall clock time when the epoch started (filter: lt) + */ + epoch_start_date_time_lt?: number; + /** + * The wall clock time when the epoch started (filter: lte) + */ + epoch_start_date_time_lte?: number; + /** + * The wall clock time when the epoch started (filter: gt) + */ + epoch_start_date_time_gt?: number; + /** + * The wall clock time when the epoch started (filter: gte) + */ + epoch_start_date_time_gte?: number; + /** + * The wall clock time when the epoch started (filter: between_min) + */ + epoch_start_date_time_between_min?: number; + /** + * The wall clock time when the epoch started (filter: between_max_value) + */ + epoch_start_date_time_between_max_value?: number; + /** + * The wall clock time when the epoch started (filter: in_values) (comma-separated list) + */ + epoch_start_date_time_in_values?: string; + /** + * The wall clock time when the epoch started (filter: not_in_values) (comma-separated list) + */ + epoch_start_date_time_not_in_values?: string; + /** + * Chain status of the block: canonical, or orphaned when a node fast confirmed a block that did not become canonical (filter: eq) + */ + status_eq?: string; + /** + * Chain status of the block: canonical, or orphaned when a node fast confirmed a block that did not become canonical (filter: ne) + */ + status_ne?: string; + /** + * Chain status of the block: canonical, or orphaned when a node fast confirmed a block that did not become canonical (filter: contains) + */ + status_contains?: string; + /** + * Chain status of the block: canonical, or orphaned when a node fast confirmed a block that did not become canonical (filter: starts_with) + */ + status_starts_with?: string; + /** + * Chain status of the block: canonical, or orphaned when a node fast confirmed a block that did not become canonical (filter: ends_with) + */ + status_ends_with?: string; + /** + * Chain status of the block: canonical, or orphaned when a node fast confirmed a block that did not become canonical (filter: like) + */ + status_like?: string; + /** + * Chain status of the block: canonical, or orphaned when a node fast confirmed a block that did not become canonical (filter: not_like) + */ + status_not_like?: string; + /** + * Chain status of the block: canonical, or orphaned when a node fast confirmed a block that did not become canonical (filter: in_values) (comma-separated list) + */ + status_in_values?: string; + /** + * Chain status of the block: canonical, or orphaned when a node fast confirmed a block that did not become canonical (filter: not_in_values) (comma-separated list) + */ + status_not_in_values?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: eq) + */ + meta_consensus_implementation_eq?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: ne) + */ + meta_consensus_implementation_ne?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: contains) + */ + meta_consensus_implementation_contains?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: starts_with) + */ + meta_consensus_implementation_starts_with?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: ends_with) + */ + meta_consensus_implementation_ends_with?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: like) + */ + meta_consensus_implementation_like?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: not_like) + */ + meta_consensus_implementation_not_like?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: in_values) (comma-separated list) + */ + meta_consensus_implementation_in_values?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: not_in_values) (comma-separated list) + */ + meta_consensus_implementation_not_in_values?: string; + /** + * Consensus client version running the fast confirmation rule (filter: eq) + */ + meta_consensus_version_eq?: string; + /** + * Consensus client version running the fast confirmation rule (filter: ne) + */ + meta_consensus_version_ne?: string; + /** + * Consensus client version running the fast confirmation rule (filter: contains) + */ + meta_consensus_version_contains?: string; + /** + * Consensus client version running the fast confirmation rule (filter: starts_with) + */ + meta_consensus_version_starts_with?: string; + /** + * Consensus client version running the fast confirmation rule (filter: ends_with) + */ + meta_consensus_version_ends_with?: string; + /** + * Consensus client version running the fast confirmation rule (filter: like) + */ + meta_consensus_version_like?: string; + /** + * Consensus client version running the fast confirmation rule (filter: not_like) + */ + meta_consensus_version_not_like?: string; + /** + * Consensus client version running the fast confirmation rule (filter: in_values) (comma-separated list) + */ + meta_consensus_version_in_values?: string; + /** + * Consensus client version running the fast confirmation rule (filter: not_in_values) (comma-separated list) + */ + meta_consensus_version_not_in_values?: string; + /** + * How the block was fast confirmed: direct (an event for this block), descendant (only implied by an event for a later block), or unconfirmed (no confirmation seen within 30 minutes) (filter: eq) + */ + confirmation_type_eq?: string; + /** + * How the block was fast confirmed: direct (an event for this block), descendant (only implied by an event for a later block), or unconfirmed (no confirmation seen within 30 minutes) (filter: ne) + */ + confirmation_type_ne?: string; + /** + * How the block was fast confirmed: direct (an event for this block), descendant (only implied by an event for a later block), or unconfirmed (no confirmation seen within 30 minutes) (filter: contains) + */ + confirmation_type_contains?: string; + /** + * How the block was fast confirmed: direct (an event for this block), descendant (only implied by an event for a later block), or unconfirmed (no confirmation seen within 30 minutes) (filter: starts_with) + */ + confirmation_type_starts_with?: string; + /** + * How the block was fast confirmed: direct (an event for this block), descendant (only implied by an event for a later block), or unconfirmed (no confirmation seen within 30 minutes) (filter: ends_with) + */ + confirmation_type_ends_with?: string; + /** + * How the block was fast confirmed: direct (an event for this block), descendant (only implied by an event for a later block), or unconfirmed (no confirmation seen within 30 minutes) (filter: like) + */ + confirmation_type_like?: string; + /** + * How the block was fast confirmed: direct (an event for this block), descendant (only implied by an event for a later block), or unconfirmed (no confirmation seen within 30 minutes) (filter: not_like) + */ + confirmation_type_not_like?: string; + /** + * How the block was fast confirmed: direct (an event for this block), descendant (only implied by an event for a later block), or unconfirmed (no confirmation seen within 30 minutes) (filter: in_values) (comma-separated list) + */ + confirmation_type_in_values?: string; + /** + * How the block was fast confirmed: direct (an event for this block), descendant (only implied by an event for a later block), or unconfirmed (no confirmation seen within 30 minutes) (filter: not_in_values) (comma-separated list) + */ + confirmation_type_not_in_values?: string; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant (filter: eq) + */ + fast_confirmed_slot_start_diff_eq?: number; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant (filter: ne) + */ + fast_confirmed_slot_start_diff_ne?: number; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant (filter: lt) + */ + fast_confirmed_slot_start_diff_lt?: number; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant (filter: lte) + */ + fast_confirmed_slot_start_diff_lte?: number; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant (filter: gt) + */ + fast_confirmed_slot_start_diff_gt?: number; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant (filter: gte) + */ + fast_confirmed_slot_start_diff_gte?: number; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant (filter: between_min) + */ + fast_confirmed_slot_start_diff_between_min?: number; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant (filter: between_max_value) + */ + fast_confirmed_slot_start_diff_between_max_value?: number; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant (filter: in_values) (comma-separated list) + */ + fast_confirmed_slot_start_diff_in_values?: string; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant (filter: not_in_values) (comma-separated list) + */ + fast_confirmed_slot_start_diff_not_in_values?: string; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations (filter: eq) + */ + fast_confirmation_slot_eq?: number; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations (filter: ne) + */ + fast_confirmation_slot_ne?: number; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations (filter: lt) + */ + fast_confirmation_slot_lt?: number; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations (filter: lte) + */ + fast_confirmation_slot_lte?: number; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations (filter: gt) + */ + fast_confirmation_slot_gt?: number; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations (filter: gte) + */ + fast_confirmation_slot_gte?: number; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations (filter: between_min) + */ + fast_confirmation_slot_between_min?: number; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations (filter: between_max_value) + */ + fast_confirmation_slot_between_max_value?: number; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations (filter: in_values) (comma-separated list) + */ + fast_confirmation_slot_in_values?: string; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations (filter: not_in_values) (comma-separated list) + */ + fast_confirmation_slot_not_in_values?: string; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block (filter: eq) + */ + finalized_slot_start_diff_eq?: number; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block (filter: ne) + */ + finalized_slot_start_diff_ne?: number; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block (filter: lt) + */ + finalized_slot_start_diff_lt?: number; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block (filter: lte) + */ + finalized_slot_start_diff_lte?: number; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block (filter: gt) + */ + finalized_slot_start_diff_gt?: number; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block (filter: gte) + */ + finalized_slot_start_diff_gte?: number; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block (filter: between_min) + */ + finalized_slot_start_diff_between_min?: number; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block (filter: between_max_value) + */ + finalized_slot_start_diff_between_max_value?: number; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block (filter: in_values) (comma-separated list) + */ + finalized_slot_start_diff_in_values?: string; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block (filter: not_in_values) (comma-separated list) + */ + finalized_slot_start_diff_not_in_values?: string; + /** + * Epoch of the finalized checkpoint that first covered this block (filter: eq) + */ + finalized_epoch_eq?: number; + /** + * Epoch of the finalized checkpoint that first covered this block (filter: ne) + */ + finalized_epoch_ne?: number; + /** + * Epoch of the finalized checkpoint that first covered this block (filter: lt) + */ + finalized_epoch_lt?: number; + /** + * Epoch of the finalized checkpoint that first covered this block (filter: lte) + */ + finalized_epoch_lte?: number; + /** + * Epoch of the finalized checkpoint that first covered this block (filter: gt) + */ + finalized_epoch_gt?: number; + /** + * Epoch of the finalized checkpoint that first covered this block (filter: gte) + */ + finalized_epoch_gte?: number; + /** + * Epoch of the finalized checkpoint that first covered this block (filter: between_min) + */ + finalized_epoch_between_min?: number; + /** + * Epoch of the finalized checkpoint that first covered this block (filter: between_max_value) + */ + finalized_epoch_between_max_value?: number; + /** + * Epoch of the finalized checkpoint that first covered this block (filter: in_values) (comma-separated list) + */ + finalized_epoch_in_values?: string; + /** + * Epoch of the finalized checkpoint that first covered this block (filter: not_in_values) (comma-separated list) + */ + finalized_epoch_not_in_values?: string; + /** + * The maximum number of fct_block_fast_confirmation_by_node to return. If unspecified, at most 100 items will be returned. The maximum value is 10000; values above 10000 will be coerced to 10000. + */ + page_size?: number; + /** + * A page token, received from a previous `ListFctBlockFastConfirmationByNode` call. Provide this to retrieve the subsequent page. + */ + page_token?: string; + /** + * The order of results. Format: comma-separated list of fields. Example: "foo,bar" or "foo desc,bar" for descending order on foo. If unspecified, results will be returned in the default order. + */ + order_by?: string; + }; + url: '/api/v1/fct_block_fast_confirmation_by_node'; +}; + +export type FctBlockFastConfirmationByNodeServiceListErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type FctBlockFastConfirmationByNodeServiceListError = + FctBlockFastConfirmationByNodeServiceListErrors[keyof FctBlockFastConfirmationByNodeServiceListErrors]; + +export type FctBlockFastConfirmationByNodeServiceListResponses = { + /** + * OK + */ + 200: ListFctBlockFastConfirmationByNodeResponse; +}; + +export type FctBlockFastConfirmationByNodeServiceListResponse = + FctBlockFastConfirmationByNodeServiceListResponses[keyof FctBlockFastConfirmationByNodeServiceListResponses]; + +export type FctBlockFastConfirmationByNodeServiceGetData = { + body?: never; + path: { + /** + * The wall clock time when the slot started + */ + slot_start_date_time: number; + }; + query?: never; + url: '/api/v1/fct_block_fast_confirmation_by_node/{slot_start_date_time}'; +}; + +export type FctBlockFastConfirmationByNodeServiceGetErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type FctBlockFastConfirmationByNodeServiceGetError = + FctBlockFastConfirmationByNodeServiceGetErrors[keyof FctBlockFastConfirmationByNodeServiceGetErrors]; + +export type FctBlockFastConfirmationByNodeServiceGetResponses = { + /** + * OK + */ + 200: GetFctBlockFastConfirmationByNodeResponse; +}; + +export type FctBlockFastConfirmationByNodeServiceGetResponse = + FctBlockFastConfirmationByNodeServiceGetResponses[keyof FctBlockFastConfirmationByNodeServiceGetResponses]; + export type FctBlockFirstSeenByNodeServiceListData = { body?: never; path?: never; diff --git a/src/api/zod.gen.ts b/src/api/zod.gen.ts index 89ed2b8d7..55e55ddd4 100644 --- a/src/api/zod.gen.ts +++ b/src/api/zod.gen.ts @@ -139297,3 +139297,3988 @@ export const zIntTransactionResourceGasServiceGetData = z.object({ * OK */ export const zIntTransactionResourceGasServiceGetResponse = zGetIntTransactionResourceGasResponse; + +export const zFctBlockFastConfirmationByClientDaily = z.object({ + avg_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + day_start_date: z.optional(z.string()), + descendant_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + meta_consensus_implementation: z.optional(z.string()), + min_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_speedup: z.optional(z.number()), + p90_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), +}); + +export const zFctBlockFastConfirmationByClientHourly = z.object({ + avg_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + hour_start_date_time: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + meta_consensus_implementation: z.optional(z.string()), + min_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_speedup: z.optional(z.number()), + p90_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), +}); + +export const zFctBlockFastConfirmationByNode = z.object({ + block_root: z.optional(z.string()), + confirmation_type: z.optional(z.string()), + epoch: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_start_date_time: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmation_slot: z.optional( + z.union([ + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), + z.null(), + ]) + ), + fast_confirmed_slot_start_diff: z.optional( + z.union([ + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), + z.null(), + ]) + ), + finalized_epoch: z.optional( + z.union([ + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), + z.null(), + ]) + ), + finalized_slot_start_diff: z.optional( + z.union([ + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), + z.null(), + ]) + ), + meta_client_name: z.optional(z.string()), + meta_consensus_implementation: z.optional(z.string()), + meta_consensus_version: z.optional(z.string()), + slot: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_start_date_time: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + status: z.optional(z.string()), + updated_date_time: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), +}); + +export const zGetFctBlockFastConfirmationByClientDailyResponse = z.object({ + item: z.optional(zFctBlockFastConfirmationByClientDaily), +}); + +/** + * Response for getting a single fct_block_fast_confirmation_by_client_hourly record + */ +export const zGetFctBlockFastConfirmationByClientHourlyResponse = z.object({ + item: z.optional(zFctBlockFastConfirmationByClientHourly), +}); + +/** + * Response for getting a single fct_block_fast_confirmation_by_node record + */ +export const zGetFctBlockFastConfirmationByNodeResponse = z.object({ + item: z.optional(zFctBlockFastConfirmationByNode), +}); + +/** + * Response for getting a single fct_block_first_seen_by_node record + */ +export const zListFctBlockFastConfirmationByClientDailyResponse = z.object({ + fct_block_fast_confirmation_by_client_daily: z.optional(z.array(zFctBlockFastConfirmationByClientDaily)), + next_page_token: z.optional(z.string()), +}); + +/** + * Response for listing fct_block_fast_confirmation_by_client_hourly records + */ +export const zListFctBlockFastConfirmationByClientHourlyResponse = z.object({ + fct_block_fast_confirmation_by_client_hourly: z.optional(z.array(zFctBlockFastConfirmationByClientHourly)), + next_page_token: z.optional(z.string()), +}); + +/** + * Response for listing fct_block_fast_confirmation_by_node records + */ +export const zListFctBlockFastConfirmationByNodeResponse = z.object({ + fct_block_fast_confirmation_by_node: z.optional(z.array(zFctBlockFastConfirmationByNode)), + next_page_token: z.optional(z.string()), +}); + +/** + * Response for listing fct_block_first_seen_by_node records + */ +export const zFctBlockFastConfirmationByClientDailyServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + day_start_date_eq: z.optional(z.string()), + day_start_date_ne: z.optional(z.string()), + day_start_date_contains: z.optional(z.string()), + day_start_date_starts_with: z.optional(z.string()), + day_start_date_ends_with: z.optional(z.string()), + day_start_date_like: z.optional(z.string()), + day_start_date_not_like: z.optional(z.string()), + day_start_date_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + day_start_date_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_consensus_implementation_eq: z.optional(z.string()), + meta_consensus_implementation_ne: z.optional(z.string()), + meta_consensus_implementation_contains: z.optional(z.string()), + meta_consensus_implementation_starts_with: z.optional(z.string()), + meta_consensus_implementation_ends_with: z.optional(z.string()), + meta_consensus_implementation_like: z.optional(z.string()), + meta_consensus_implementation_not_like: z.optional(z.string()), + meta_consensus_implementation_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_consensus_implementation_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + updated_date_time_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + node_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + node_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + observation_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + observation_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + direct_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + direct_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + descendant_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + descendant_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + unconfirmed_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + unconfirmed_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + orphaned_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + orphaned_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p90_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p90_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p99_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p99_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_finality_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_finality_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_finality_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_finality_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_finality_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_finality_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_finality_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_finality_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_finality_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_finality_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_speedup_value: z.optional(z.number()), + page_size: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zFctBlockFastConfirmationByClientDailyServiceListResponse = + zListFctBlockFastConfirmationByClientDailyResponse; + +export const zFctBlockFastConfirmationByClientDailyServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + day_start_date: z.string(), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zFctBlockFastConfirmationByClientDailyServiceGetResponse = + zGetFctBlockFastConfirmationByClientDailyResponse; + +export const zFctBlockFastConfirmationByClientHourlyServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + hour_start_date_time_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + hour_start_date_time_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + hour_start_date_time_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + hour_start_date_time_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + hour_start_date_time_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + hour_start_date_time_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + hour_start_date_time_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + hour_start_date_time_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + hour_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + hour_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + meta_consensus_implementation_eq: z.optional(z.string()), + meta_consensus_implementation_ne: z.optional(z.string()), + meta_consensus_implementation_contains: z.optional(z.string()), + meta_consensus_implementation_starts_with: z.optional(z.string()), + meta_consensus_implementation_ends_with: z.optional(z.string()), + meta_consensus_implementation_like: z.optional(z.string()), + meta_consensus_implementation_not_like: z.optional(z.string()), + meta_consensus_implementation_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_consensus_implementation_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + updated_date_time_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + node_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + node_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + observation_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + observation_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + direct_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + direct_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + descendant_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + descendant_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + unconfirmed_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + unconfirmed_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + orphaned_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + orphaned_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p90_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p90_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p99_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p99_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_finality_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_finality_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_finality_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_finality_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_finality_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_finality_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_finality_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_finality_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_finality_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_finality_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_speedup_value: z.optional(z.number()), + page_size: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zFctBlockFastConfirmationByClientHourlyServiceListResponse = + zListFctBlockFastConfirmationByClientHourlyResponse; + +export const zFctBlockFastConfirmationByClientHourlyServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + hour_start_date_time: z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zFctBlockFastConfirmationByClientHourlyServiceGetResponse = + zGetFctBlockFastConfirmationByClientHourlyResponse; + +export const zFctBlockFastConfirmationByNodeServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + slot_start_date_time_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_start_date_time_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_start_date_time_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_start_date_time_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_start_date_time_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_start_date_time_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_start_date_time_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_start_date_time_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + meta_client_name_eq: z.optional(z.string()), + meta_client_name_ne: z.optional(z.string()), + meta_client_name_contains: z.optional(z.string()), + meta_client_name_starts_with: z.optional(z.string()), + meta_client_name_ends_with: z.optional(z.string()), + meta_client_name_like: z.optional(z.string()), + meta_client_name_not_like: z.optional(z.string()), + meta_client_name_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_name_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + block_root_eq: z.optional(z.string()), + block_root_ne: z.optional(z.string()), + block_root_contains: z.optional(z.string()), + block_root_starts_with: z.optional(z.string()), + block_root_ends_with: z.optional(z.string()), + block_root_like: z.optional(z.string()), + block_root_not_like: z.optional(z.string()), + block_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + block_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + updated_date_time_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + epoch_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + epoch_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + epoch_start_date_time_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_start_date_time_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_start_date_time_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_start_date_time_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_start_date_time_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_start_date_time_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_start_date_time_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_start_date_time_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + epoch_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + status_eq: z.optional(z.string()), + status_ne: z.optional(z.string()), + status_contains: z.optional(z.string()), + status_starts_with: z.optional(z.string()), + status_ends_with: z.optional(z.string()), + status_like: z.optional(z.string()), + status_not_like: z.optional(z.string()), + status_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + status_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_consensus_implementation_eq: z.optional(z.string()), + meta_consensus_implementation_ne: z.optional(z.string()), + meta_consensus_implementation_contains: z.optional(z.string()), + meta_consensus_implementation_starts_with: z.optional(z.string()), + meta_consensus_implementation_ends_with: z.optional(z.string()), + meta_consensus_implementation_like: z.optional(z.string()), + meta_consensus_implementation_not_like: z.optional(z.string()), + meta_consensus_implementation_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_consensus_implementation_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_consensus_version_eq: z.optional(z.string()), + meta_consensus_version_ne: z.optional(z.string()), + meta_consensus_version_contains: z.optional(z.string()), + meta_consensus_version_starts_with: z.optional(z.string()), + meta_consensus_version_ends_with: z.optional(z.string()), + meta_consensus_version_like: z.optional(z.string()), + meta_consensus_version_not_like: z.optional(z.string()), + meta_consensus_version_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_consensus_version_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + confirmation_type_eq: z.optional(z.string()), + confirmation_type_ne: z.optional(z.string()), + confirmation_type_contains: z.optional(z.string()), + confirmation_type_starts_with: z.optional(z.string()), + confirmation_type_ends_with: z.optional(z.string()), + confirmation_type_like: z.optional(z.string()), + confirmation_type_not_like: z.optional(z.string()), + confirmation_type_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + confirmation_type_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + fast_confirmed_slot_start_diff_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmed_slot_start_diff_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmed_slot_start_diff_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmed_slot_start_diff_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmed_slot_start_diff_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmed_slot_start_diff_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmed_slot_start_diff_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmed_slot_start_diff_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmed_slot_start_diff_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + fast_confirmed_slot_start_diff_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + fast_confirmation_slot_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmation_slot_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmation_slot_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmation_slot_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmation_slot_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmation_slot_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmation_slot_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmation_slot_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmation_slot_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + fast_confirmation_slot_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + finalized_slot_start_diff_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_slot_start_diff_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_slot_start_diff_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_slot_start_diff_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_slot_start_diff_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_slot_start_diff_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_slot_start_diff_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_slot_start_diff_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_slot_start_diff_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + finalized_slot_start_diff_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + finalized_epoch_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_epoch_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_epoch_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_epoch_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_epoch_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_epoch_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_epoch_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_epoch_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_epoch_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + finalized_epoch_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + page_size: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zFctBlockFastConfirmationByNodeServiceListResponse = zListFctBlockFastConfirmationByNodeResponse; + +export const zFctBlockFastConfirmationByNodeServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + slot_start_date_time: z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zFctBlockFastConfirmationByNodeServiceGetResponse = zGetFctBlockFastConfirmationByNodeResponse; diff --git a/src/components/Layout/Sidebar/Sidebar.tsx b/src/components/Layout/Sidebar/Sidebar.tsx index 51c80cea5..4e814654e 100644 --- a/src/components/Layout/Sidebar/Sidebar.tsx +++ b/src/components/Layout/Sidebar/Sidebar.tsx @@ -5,6 +5,7 @@ import { Link } from '@tanstack/react-router'; import clsx from 'clsx'; import { ArchiveBoxXMarkIcon, + BoltIcon, ChartBarIcon, ChevronLeftIcon, ChevronRightIcon, @@ -159,6 +160,7 @@ interface NavItem { const ethereumConsensusPages: NavItem[] = [ { name: 'Overview', to: '/ethereum/consensus/overview', icon: PresentationChartLineIcon }, { name: 'Live', to: '/ethereum/live', icon: PlayCircleIcon }, + { name: 'Fast Confirmation', to: '/ethereum/consensus/fast-confirmation', icon: BoltIcon }, { name: 'Epochs', to: '/ethereum/epochs', icon: ClockIcon }, { name: 'Slots', to: '/ethereum/slots', icon: Square3Stack3DIcon }, { name: 'Entities', to: '/ethereum/entities', icon: UserGroupIcon }, diff --git a/src/pages/ethereum/consensus/fast-confirmation/IndexPage.tsx b/src/pages/ethereum/consensus/fast-confirmation/IndexPage.tsx new file mode 100644 index 000000000..1b91f2c1b --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/IndexPage.tsx @@ -0,0 +1,263 @@ +import { type JSX, useMemo } from 'react'; +import { useNavigate, useSearch } from '@tanstack/react-router'; +import { useQuery } from '@tanstack/react-query'; +import clsx from 'clsx'; +import { Container } from '@/components/Layout/Container'; +import { Card } from '@/components/Layout/Card'; +import { Header } from '@/components/Layout/Header'; +import { ClientLogo } from '@/components/Ethereum/ClientLogo'; +import { useNetwork } from '@/hooks/useNetwork'; +import { + fctBlockFastConfirmationByClientDailyServiceListOptions, + fctBlockFastConfirmationByClientHourlyServiceListOptions, + fctBlockFastConfirmationByNodeServiceListOptions, +} from '@/api/@tanstack/react-query.gen'; +import { + BlockField, + ClientTable, + ConfirmationDistribution, + EpochDetail, + FastConfirmationSkeleton, + ScarList, +} from './components'; +import { LATE_CONFIRMATION_MS, PAGE_SIZE, RECENT_BLOCK_HOURS } from './constants'; +import { toClientDay, toObservation } from './fast-confirmation.api'; +import { buildField, formatDurationMs, groupStallEpisodes, summarizeClients } from './fast-confirmation.utils'; + +function formatDay(day: string): string { + return new Date(`${day}T00:00:00Z`).toLocaleDateString('en-GB', { + day: 'numeric', + month: 'long', + year: 'numeric', + timeZone: 'UTC', + }); +} + +/** + * Fast Confirmation page: every epoch a fast confirmation node has scored, and how soon + * each block was safe to rely on compared to finality. + */ +export function IndexPage(): JSX.Element { + const navigate = useNavigate({ from: '/ethereum/consensus/fast-confirmation' }); + const search = useSearch({ from: '/ethereum/consensus/fast-confirmation' }); + const { currentNetwork } = useNetwork(); + const genesis = currentNetwork?.genesis_time ?? 0; + const nowSeconds = useMemo(() => Math.floor(Date.now() / 1000), []); + + const dailyQuery = useQuery({ + ...fctBlockFastConfirmationByClientDailyServiceListOptions({ + query: { day_start_date_like: '20%', order_by: 'day_start_date asc', page_size: PAGE_SIZE }, + }), + }); + + const clients = useMemo( + () => summarizeClients((dailyQuery.data?.fct_block_fast_confirmation_by_client_daily ?? []).map(toClientDay)), + [dailyQuery.data] + ); + const client = clients.find(c => c.client === search.client) ?? clients[0]; + + const hourlyQuery = useQuery({ + ...fctBlockFastConfirmationByClientHourlyServiceListOptions({ + query: { + hour_start_date_time_gte: 1, + meta_consensus_implementation_eq: client?.client, + order_by: 'hour_start_date_time asc', + page_size: PAGE_SIZE, + }, + }), + enabled: !!client, + }); + + const lateQuery = useQuery({ + ...fctBlockFastConfirmationByNodeServiceListOptions({ + query: { + slot_start_date_time_gte: 1, + meta_consensus_implementation_eq: client?.client, + fast_confirmed_slot_start_diff_gte: LATE_CONFIRMATION_MS, + order_by: 'slot_start_date_time asc', + page_size: PAGE_SIZE, + }, + }), + enabled: !!client, + }); + + const recentQuery = useQuery({ + ...fctBlockFastConfirmationByNodeServiceListOptions({ + query: { + slot_start_date_time_gte: nowSeconds - (RECENT_BLOCK_HOURS + 3) * 3600, + order_by: 'slot_start_date_time desc', + page_size: PAGE_SIZE, + }, + }), + }); + + const late = useMemo( + () => (lateQuery.data?.fct_block_fast_confirmation_by_node ?? []).map(toObservation), + [lateQuery.data] + ); + + const field = useMemo(() => { + const hours = (hourlyQuery.data?.fct_block_fast_confirmation_by_client_hourly ?? []) + .filter(r => (r.slot_count ?? 0) > 0) + .map(r => r.hour_start_date_time ?? 0); + return buildField(genesis, hours, late); + }, [genesis, hourlyQuery.data, late]); + + const episodes = useMemo(() => groupStallEpisodes(late), [late]); + + const selectedEpoch = useMemo(() => { + if (search.epoch !== undefined && field.byEpoch.has(search.epoch)) return search.epoch; + const worst = [...episodes].sort((a, b) => b.worstMs - a.worstMs)[0]; + return worst ? Math.floor(worst.startSlot / 32) : null; + }, [search.epoch, field, episodes]); + const selected = selectedEpoch !== null ? field.byEpoch.get(selectedEpoch) : undefined; + + const distribution = useMemo(() => { + const rows = (recentQuery.data?.fct_block_fast_confirmation_by_node ?? []).map(toObservation); + const newest = Math.max(0, ...rows.map(r => r.slotStartDateTime)); + const canonical = rows.filter( + r => r.status === 'canonical' && r.slotStartDateTime > newest - RECENT_BLOCK_HOURS * 3600 + ); + return { + fast: canonical.map(r => r.fastConfirmedMs).filter((v): v is number => v !== null), + finalized: canonical.map(r => r.finalizedMs).filter((v): v is number => v !== null), + }; + }, [recentQuery.data]); + + const setSearch = (next: { client?: string; epoch?: number }): void => { + navigate({ search: prev => ({ ...prev, ...next }), replace: true }); + }; + + const isLoading = dailyQuery.isLoading || hourlyQuery.isLoading || lateQuery.isLoading; + const error = dailyQuery.error ?? hourlyQuery.error ?? lateQuery.error; + + return ( + +
+ + {isLoading && } + + {error && ( + +

Failed to load data: {error.message}

+ + )} + + {!isLoading && !error && !client && ( + +

No fast confirmation data for this network yet.

+ + )} + + {!isLoading && client && ( +
+

+ Since {formatDay(client.since)}, our {client.client} node has fast + confirmed {client.blocks.toLocaleString()} blocks. Half of them were + safe to rely on within {formatDurationMs(client.fastMs)}{' '} + of their slot starting. Finality took{' '} + {formatDurationMs(client.finalityMs)}, which is{' '} + {Math.round(client.speedup)} times longer.{' '} + {client.reverted === 0 + ? 'None of those confirmations was ever reverted.' + : `${client.reverted} confirmed blocks were later reorged.`} +

+ +
+ {clients.map(c => ( + + ))} +
+ + +
+
+

Every epoch since {formatDay(client.since)}

+

+ One row per day (UTC), one column per epoch. Each cell is coloured by the slowest of its 32 blocks. + Click a cell to open its blocks. +

+
+ setSearch({ epoch: e.epoch })} /> + {selected && } +
+ + +
+ +
+
+

Scars

+

+ The worst runs of late confirmations. When conditions degrade, the rule waits instead of guessing, + and some blocks are only confirmed once they are final. +

+
+ setSearch({ epoch })} /> +
+ + +
+ + +
+

By client

+ setSearch({ client: c, epoch: undefined })} + /> +
+ + + +
+
+

What it measures

+

+ The time from a block's slot starting until the node's fast confirmation rule marks it + confirmed, either directly or by confirming a later block built on top of it. +

+
+
+

Not the same as finality

+

+ Finality is an economic guarantee: reverting a finalized block burns at least a third of all stake. + Fast confirmation assumes votes arrive on time and less than a quarter of stake is adversarial. +

+
+
+

Where the data comes from

+

+ ethPandaOps sentries subscribe to the beacon node fast confirmation event, joined with canonical + blocks and finalized checkpoints. +

+
+
+ +
+ )} + + ); +} diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/BlockField/BlockField.tsx b/src/pages/ethereum/consensus/fast-confirmation/components/BlockField/BlockField.tsx new file mode 100644 index 000000000..0bbab42d2 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/BlockField/BlockField.tsx @@ -0,0 +1,175 @@ +import { type JSX, useEffect, useRef, useState } from 'react'; +import clsx from 'clsx'; +import { useThemeColors } from '@/hooks/useThemeColors'; +import { hexToRgba } from '@/utils/color'; +import { formatEpoch } from '@/utils'; +import { type FieldEpoch, type FieldModel, type FieldTier, formatDurationMs } from '../../fast-confirmation.utils'; + +export interface BlockFieldProps { + field: FieldModel; + selectedEpoch: number | null; + onSelect: (epoch: FieldEpoch) => void; +} + +const GUTTER = 64; +const HEADER = 22; + +const TIER_LABELS: Array<{ tier: FieldTier; label: string }> = [ + { tier: 'ok', label: 'Every block within a slot' }, + { tier: 'late', label: 'A block took up to 2 slots' }, + { tier: 'slow', label: 'Up to 2 minutes' }, + { tier: 'stalled', label: 'Stalled for minutes' }, + { tier: 'held', label: 'Held until finality' }, +]; + +function tierColors(colors: ReturnType): Record { + return { + none: 'transparent', + ok: hexToRgba(colors.success, 0.18), + late: hexToRgba(colors.warning, 0.5), + slow: hexToRgba(colors.warning, 0.9), + stalled: hexToRgba(colors.danger, 0.6), + held: colors.danger, + }; +} + +function utcDate(seconds: number): string { + return new Date(seconds * 1000).toLocaleDateString('en-GB', { day: 'numeric', month: 'short', timeZone: 'UTC' }); +} + +function utcTime(seconds: number): string { + return new Date(seconds * 1000).toISOString().slice(11, 16); +} + +/** + * Every epoch the node has scored, one row per UTC day and one column per epoch of the day, + * coloured by the slowest fast confirmation in that epoch. + */ +export function BlockField({ field, selectedEpoch, onSelect }: BlockFieldProps): JSX.Element { + const colors = useThemeColors(); + const wrapRef = useRef(null); + const canvasRef = useRef(null); + const [width, setWidth] = useState(0); + const [hover, setHover] = useState<{ epoch: FieldEpoch; x: number; y: number } | null>(null); + + useEffect(() => { + const el = wrapRef.current; + if (!el) return; + const observer = new ResizeObserver(entries => setWidth(entries[0].contentRect.width)); + observer.observe(el); + return () => observer.disconnect(); + }, []); + + const plotWidth = Math.max(0, width - GUTTER); + const cellW = plotWidth / field.columns; + const cellH = Math.max(3, Math.min(6, cellW)); + const gap = cellW >= 4 ? 1 : 0; + const height = HEADER + field.days.length * cellH; + + useEffect(() => { + const canvas = canvasRef.current; + if (!canvas || plotWidth === 0) return; + const ratio = window.devicePixelRatio || 1; + canvas.width = plotWidth * ratio; + canvas.height = field.days.length * cellH * ratio; + const ctx = canvas.getContext('2d'); + if (!ctx) return; + ctx.scale(ratio, ratio); + ctx.clearRect(0, 0, plotWidth, field.days.length * cellH); + const palette = tierColors(colors); + for (const e of field.epochs) { + if (e.tier === 'none') continue; + ctx.fillStyle = palette[e.tier]; + ctx.fillRect(e.column * cellW, e.day * cellH, Math.max(1, cellW - gap), Math.max(1, cellH - gap)); + } + const selected = selectedEpoch !== null ? field.byEpoch.get(selectedEpoch) : undefined; + if (selected) { + ctx.strokeStyle = colors.foreground; + ctx.lineWidth = 1.5; + ctx.strokeRect(selected.column * cellW - 1.5, selected.day * cellH - 1.5, cellW + 2, cellH + 2); + } + }, [field, colors, plotWidth, cellW, cellH, gap, selectedEpoch]); + + const epochAt = (clientX: number, clientY: number): FieldEpoch | null => { + const rect = canvasRef.current?.getBoundingClientRect(); + if (!rect) return null; + const column = Math.floor((clientX - rect.left) / cellW); + const day = Math.floor((clientY - rect.top) / cellH); + return field.epochs.find(e => e.day === day && e.column === column && e.tier !== 'none') ?? null; + }; + + const monthRows = field.days + .map((start, day) => ({ start, day })) + .filter(({ start }, i) => i === 0 || new Date(start * 1000).getUTCDate() === 1); + + return ( +
+
+ {[0, 6, 12, 18].map(h => ( + + {String(h).padStart(2, '0')}:00 + + ))} + {monthRows.map(({ start, day }) => ( + + {utcDate(start)} + + ))} + { + const epoch = epochAt(e.clientX, e.clientY); + setHover(epoch ? { epoch, x: e.nativeEvent.offsetX + GUTTER, y: e.nativeEvent.offsetY + HEADER } : null); + }} + onMouseLeave={() => setHover(null)} + onClick={e => { + const epoch = epochAt(e.clientX, e.clientY); + if (epoch) onSelect(epoch); + }} + /> + {hover && ( +
+
+ {utcDate(hover.epoch.startTime)}, {utcTime(hover.epoch.startTime)} UTC +
+
Epoch {formatEpoch(hover.epoch.epoch)}
+
+ {hover.epoch.lateBlocks + ? `${hover.epoch.lateBlocks} late block${hover.epoch.lateBlocks > 1 ? 's' : ''}, slowest ${formatDurationMs(hover.epoch.worstMs)}` + : 'Every block fast confirmed within its slot'} +
+
+ )} +
+ +
+ {TIER_LABELS.map(({ tier, label }) => ( + + + {label} + + ))} + + + Node not reporting + +
+
+ ); +} diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/BlockField/index.ts b/src/pages/ethereum/consensus/fast-confirmation/components/BlockField/index.ts new file mode 100644 index 000000000..e158d947c --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/BlockField/index.ts @@ -0,0 +1,2 @@ +export { BlockField } from './BlockField'; +export type { BlockFieldProps } from './BlockField'; diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/ClientTable/ClientTable.tsx b/src/pages/ethereum/consensus/fast-confirmation/components/ClientTable/ClientTable.tsx new file mode 100644 index 000000000..f831ba387 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/ClientTable/ClientTable.tsx @@ -0,0 +1,62 @@ +import type { JSX } from 'react'; +import clsx from 'clsx'; +import { ClientLogo } from '@/components/Ethereum/ClientLogo'; +import { type ClientSummary, formatDurationMs } from '../../fast-confirmation.utils'; + +export interface ClientTableProps { + clients: ClientSummary[]; + selected: string; + onSelect: (client: string) => void; +} + +/** + * One row per consensus client running the fast confirmation rule, over its whole history. + */ +export function ClientTable({ clients, selected, onSelect }: ClientTableProps): JSX.Element { + return ( +
+ + + + + + + + + + + + + + + {clients.map(c => ( + onSelect(c.client)} + className={clsx( + 'cursor-pointer transition-colors hover:bg-primary/5', + selected === c.client && 'bg-primary/10' + )} + > + + + + + + + + + + ))} + +
ClientReporting sinceBlocksFast confirmedFinalizedSoonerConfirmed directlyReverted
+ + + {c.client} + + {c.since}{c.blocks.toLocaleString()}{formatDurationMs(c.fastMs)}{formatDurationMs(c.finalityMs)}{Math.round(c.speedup)}×{(c.directShare * 100).toFixed(2)}% + {c.reverted} +
+
+ ); +} diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/ClientTable/index.ts b/src/pages/ethereum/consensus/fast-confirmation/components/ClientTable/index.ts new file mode 100644 index 000000000..bcf94a6f0 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/ClientTable/index.ts @@ -0,0 +1,2 @@ +export { ClientTable } from './ClientTable'; +export type { ClientTableProps } from './ClientTable'; diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/ConfirmationDistribution/ConfirmationDistribution.tsx b/src/pages/ethereum/consensus/fast-confirmation/components/ConfirmationDistribution/ConfirmationDistribution.tsx new file mode 100644 index 000000000..a11cfc95b --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/ConfirmationDistribution/ConfirmationDistribution.tsx @@ -0,0 +1,145 @@ +import { type JSX, useMemo } from 'react'; +import ReactECharts from 'echarts-for-react'; +import { PopoutCard } from '@/components/Layout/PopoutCard'; +import { useThemeColors } from '@/hooks/useThemeColors'; +import { hexToRgba } from '@/utils/color'; +import { formatDurationMs, logHistogram } from '../../fast-confirmation.utils'; + +const MIN_SECONDS = 5; +const MAX_SECONDS = 1800; +const BINS = 72; + +export interface ConfirmationDistributionProps { + fastConfirmedMs: number[]; + finalizedMs: number[]; + subtitle: string; +} + +function tickLabel(seconds: number): string { + if (seconds < 60) return `${seconds}s`; + return `${Math.round(seconds / 60)}m`; +} + +/** + * Log-scale histogram of time to fast confirmation against time to finality. + */ +export function ConfirmationDistribution({ + fastConfirmedMs, + finalizedMs, + subtitle, +}: ConfirmationDistributionProps): JSX.Element { + const colors = useThemeColors(); + + const option = useMemo(() => { + const fast = logHistogram(fastConfirmedMs, MIN_SECONDS, MAX_SECONDS, BINS); + const final = logHistogram(finalizedMs, MIN_SECONDS, MAX_SECONDS, BINS); + const fastTotal = fastConfirmedMs.length || 1; + const finalTotal = finalizedMs.length || 1; + const toShare = (count: number, total: number): number => (count / total) * 100; + + const series = (name: string, color: string, data: Array<[number, number]>): Record => ({ + name, + type: 'line', + smooth: 0.35, + symbol: 'none', + data, + lineStyle: { color, width: 2 }, + itemStyle: { color }, + areaStyle: { + color: { + type: 'linear', + x: 0, + y: 0, + x2: 0, + y2: 1, + colorStops: [ + { offset: 0, color: hexToRgba(color, 0.4) }, + { offset: 1, color: hexToRgba(color, 0.02) }, + ], + }, + }, + }); + + return { + grid: { left: 60, right: 24, top: 40, bottom: 50 }, + legend: { + top: 0, + textStyle: { color: colors.muted }, + data: ['Fast confirmation', 'Finality'], + }, + xAxis: { + type: 'log', + logBase: 10, + min: MIN_SECONDS, + max: MAX_SECONDS, + name: 'Time since slot start', + nameLocation: 'center', + nameGap: 30, + nameTextStyle: { color: colors.muted }, + axisLine: { show: true, lineStyle: { color: colors.border } }, + splitLine: { show: false }, + axisLabel: { color: colors.muted, formatter: (value: number) => tickLabel(value) }, + }, + yAxis: { + type: 'value', + name: 'Share of blocks (%)', + nameLocation: 'center', + nameGap: 40, + nameTextStyle: { color: colors.muted }, + axisLine: { show: true, lineStyle: { color: colors.border } }, + splitLine: { show: false }, + axisLabel: { color: colors.muted }, + }, + tooltip: { + trigger: 'axis', + backgroundColor: colors.surface, + borderColor: colors.border, + textStyle: { color: colors.foreground }, + formatter: (params: Array<{ seriesName: string; value: [number, number]; color: string }>) => { + if (!params.length) return ''; + const header = `${formatDurationMs(params[0].value[0] * 1000)}`; + const rows = params + .filter(p => p.value[1] > 0) + .map(p => `● ${p.seriesName}: ${p.value[1].toFixed(1)}%`); + return [header, ...rows].join('
'); + }, + }, + series: [ + { + ...series( + 'Fast confirmation', + colors.success, + fast.map(b => [b.center, toShare(b.count, fastTotal)]) + ), + markLine: { + silent: true, + symbol: 'none', + label: { color: colors.muted, formatter: '{b}', position: 'insideEndTop' }, + lineStyle: { color: colors.border, type: 'dashed' }, + data: [ + { name: '1 slot', xAxis: 12 }, + { name: '2 epochs', xAxis: 768 }, + ], + }, + }, + series( + 'Finality', + colors.primary, + final.map(b => [b.center, toShare(b.count, finalTotal)]) + ), + ], + }; + }, [colors, fastConfirmedMs, finalizedMs]); + + return ( + + {({ inModal }) => + fastConfirmedMs.length > 0 ? ( + + ) : ( +
No data
+ ) + } + + ); +} diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/ConfirmationDistribution/index.ts b/src/pages/ethereum/consensus/fast-confirmation/components/ConfirmationDistribution/index.ts new file mode 100644 index 000000000..a523358e7 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/ConfirmationDistribution/index.ts @@ -0,0 +1,2 @@ +export { ConfirmationDistribution } from './ConfirmationDistribution'; +export type { ConfirmationDistributionProps } from './ConfirmationDistribution'; diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/EpochDetail/EpochDetail.tsx b/src/pages/ethereum/consensus/fast-confirmation/components/EpochDetail/EpochDetail.tsx new file mode 100644 index 000000000..534447765 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/EpochDetail/EpochDetail.tsx @@ -0,0 +1,123 @@ +import type { JSX } from 'react'; +import { useQuery } from '@tanstack/react-query'; +import { Link } from '@tanstack/react-router'; +import clsx from 'clsx'; +import { ClientLogo } from '@/components/Ethereum/ClientLogo'; +import { fctBlockFastConfirmationByNodeServiceListOptions } from '@/api/@tanstack/react-query.gen'; +import { formatEpoch, formatSlot } from '@/utils'; +import { + type FieldEpoch, + EPOCH_SECONDS, + formatDurationMs, + summarizeSlots, + tierForMs, +} from '../../fast-confirmation.utils'; +import { toObservation } from '../../fast-confirmation.api'; + +export interface EpochDetailProps { + epoch: FieldEpoch; +} + +const TIER_CLASS = { + ok: 'bg-success/20', + late: 'bg-warning/50', + slow: 'bg-warning/90', + stalled: 'bg-danger/60', + held: 'bg-danger', + none: 'bg-transparent', +} as const; + +/** + * The 32 slots of one epoch, one row per consensus client, each cell showing how long + * that client took to fast confirm the block. + */ +export function EpochDetail({ epoch }: EpochDetailProps): JSX.Element { + const query = useQuery({ + ...fctBlockFastConfirmationByNodeServiceListOptions({ + query: { + slot_start_date_time_gte: epoch.startTime, + slot_start_date_time_lt: epoch.startTime + EPOCH_SECONDS, + page_size: 1000, + }, + }), + }); + + const slots = summarizeSlots((query.data?.fct_block_fast_confirmation_by_node ?? []).map(toObservation)); + const bySlot = new Map(slots.map(s => [s.slot, s])); + const clients = [...new Set(slots.flatMap(s => s.byClient.map(c => c.client)))].sort(); + const firstSlot = epoch.epoch * 32; + const finalized = slots.map(s => s.finalizedMs).filter((v): v is number => v !== null); + + return ( +
+
+
+ Epoch {formatEpoch(epoch.epoch)} + {new Date(epoch.startTime * 1000).toUTCString().slice(5, 22)} UTC +
+
+ {finalized.length > 0 && ( + <> + Finalized {formatDurationMs(Math.min(...finalized))} to {formatDurationMs(Math.max(...finalized))} after + each slot + + )} +
+
+ + {query.isLoading &&
} + + {!query.isLoading && ( +
+ +
+ {Array.from({ length: 32 }, (_, i) => ( + + {i} + + ))} +
+ {clients.map(client => ( +
+ + + {client} + +
+ {Array.from({ length: 32 }, (_, i) => { + const slot = bySlot.get(firstSlot + i); + const entry = slot?.byClient.find(c => c.client === client); + if (!slot) { + return ( +
+ ); + } + if (!entry) return
; + const tier = + entry.fastConfirmedMs === null + ? 'held' + : entry.fastConfirmedMs < 13_000 + ? 'ok' + : tierForMs(entry.fastConfirmedMs); + return ( +
+ ); + })} +
+
+ ))} +
+ )} +
+ ); +} diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/EpochDetail/index.ts b/src/pages/ethereum/consensus/fast-confirmation/components/EpochDetail/index.ts new file mode 100644 index 000000000..45a279223 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/EpochDetail/index.ts @@ -0,0 +1,2 @@ +export { EpochDetail } from './EpochDetail'; +export type { EpochDetailProps } from './EpochDetail'; diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/FastConfirmationSkeleton/FastConfirmationSkeleton.tsx b/src/pages/ethereum/consensus/fast-confirmation/components/FastConfirmationSkeleton/FastConfirmationSkeleton.tsx new file mode 100644 index 000000000..73830680c --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/FastConfirmationSkeleton/FastConfirmationSkeleton.tsx @@ -0,0 +1,47 @@ +import type { JSX } from 'react'; +import { Card } from '@/components/Layout/Card'; +import { LoadingContainer } from '@/components/Layout/LoadingContainer'; + +function ChartCardSkeleton({ height }: { height: string }): JSX.Element { + return ( + +
+
+ + +
+ +
+ + ); +} + +/** + * Loading skeleton for the Fast Confirmation page: hero, lattice and chart grid. + */ +export function FastConfirmationSkeleton(): JSX.Element { + return ( +
+ +
+
+ + + +
+ + +
+
+ +
+ +
+ + + + +
+
+ ); +} diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/FastConfirmationSkeleton/index.ts b/src/pages/ethereum/consensus/fast-confirmation/components/FastConfirmationSkeleton/index.ts new file mode 100644 index 000000000..94fac5041 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/FastConfirmationSkeleton/index.ts @@ -0,0 +1 @@ +export { FastConfirmationSkeleton } from './FastConfirmationSkeleton'; diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/ScarList/ScarList.tsx b/src/pages/ethereum/consensus/fast-confirmation/components/ScarList/ScarList.tsx new file mode 100644 index 000000000..999512ddc --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/ScarList/ScarList.tsx @@ -0,0 +1,58 @@ +import type { JSX } from 'react'; +import clsx from 'clsx'; +import { formatSlot } from '@/utils'; +import { HELD_TO_FINALITY_MS, type StallEpisode, formatDurationMs } from '../../fast-confirmation.utils'; + +export interface ScarListProps { + episodes: StallEpisode[]; + selectedEpoch: number | null; + onSelect: (epoch: number) => void; +} + +const MAX_ROWS = 14; + +/** + * The episodes where the node confirmed blocks late, worst first. Selecting one highlights + * its epoch in the block field. + */ +export function ScarList({ episodes, selectedEpoch, onSelect }: ScarListProps): JSX.Element { + const worst = [...episodes].sort((a, b) => b.worstMs - a.worstMs).slice(0, MAX_ROWS); + + if (!worst.length) { + return

No late confirmations yet.

; + } + + return ( +
    + {worst.map(e => { + const epoch = Math.floor(e.startSlot / 32); + const held = e.worstMs >= HELD_TO_FINALITY_MS; + return ( +
  1. + +
    2. + ); + })} +
+ ); +} diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/ScarList/index.ts b/src/pages/ethereum/consensus/fast-confirmation/components/ScarList/index.ts new file mode 100644 index 000000000..b7f13cd74 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/ScarList/index.ts @@ -0,0 +1,2 @@ +export { ScarList } from './ScarList'; +export type { ScarListProps } from './ScarList'; diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/index.ts b/src/pages/ethereum/consensus/fast-confirmation/components/index.ts new file mode 100644 index 000000000..688e72c95 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/index.ts @@ -0,0 +1,6 @@ +export { BlockField } from './BlockField'; +export { ClientTable } from './ClientTable'; +export { ConfirmationDistribution } from './ConfirmationDistribution'; +export { EpochDetail } from './EpochDetail'; +export { FastConfirmationSkeleton } from './FastConfirmationSkeleton'; +export { ScarList } from './ScarList'; diff --git a/src/pages/ethereum/consensus/fast-confirmation/constants.ts b/src/pages/ethereum/consensus/fast-confirmation/constants.ts new file mode 100644 index 000000000..eb64753bd --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/constants.ts @@ -0,0 +1,20 @@ +import { z } from 'zod'; + +/** Zod schema for fast confirmation search params */ +export const fastConfirmationSearchSchema = z.object({ + client: z.string().optional(), + epoch: z.coerce.number().int().nonnegative().optional(), +}); +export type FastConfirmationSearch = z.infer; + +/** Page size for list queries */ +export const PAGE_SIZE = 10_000; + +/** Hours of per-block data fetched for the distribution */ +export const RECENT_BLOCK_HOURS = 3; + +/** A block fast confirmed later than this (ms after slot start) missed its own slot */ +export const LATE_CONFIRMATION_MS = 13_000; + +/** Late blocks within this many slots of each other belong to the same episode */ +export const STALL_EPISODE_GAP_SLOTS = 32; diff --git a/src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.api.ts b/src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.api.ts new file mode 100644 index 000000000..11191de91 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.api.ts @@ -0,0 +1,54 @@ +import type { FctBlockFastConfirmationByClientDaily, FctBlockFastConfirmationByNode } from '@/api/types.gen'; +import type { BlockObservation } from './fast-confirmation.utils'; + +/** One client's daily aggregate, with the fields the page uses */ +export interface ClientDay { + day: string; + client: string; + slots: number; + observations: number; + direct: number; + orphaned: number; + unconfirmed: number; + p50FastMs: number; + p99FastMs: number; + maxFastMs: number; + p50FinalityMs: number; +} + +/** + * Map a fct_block_fast_confirmation_by_node row onto a BlockObservation. + */ +export function toObservation(row: FctBlockFastConfirmationByNode): BlockObservation { + return { + slot: row.slot ?? 0, + slotStartDateTime: row.slot_start_date_time ?? 0, + blockRoot: row.block_root ?? '', + status: row.status ?? '', + client: row.meta_consensus_implementation ?? '', + node: row.meta_client_name ?? '', + confirmationType: row.confirmation_type ?? '', + fastConfirmedMs: row.fast_confirmed_slot_start_diff ?? null, + confirmationSlot: row.fast_confirmation_slot ?? null, + finalizedMs: row.finalized_slot_start_diff ?? null, + }; +} + +/** + * Map a fct_block_fast_confirmation_by_client_daily row onto a ClientDay. + */ +export function toClientDay(row: FctBlockFastConfirmationByClientDaily): ClientDay { + return { + day: row.day_start_date ?? '', + client: row.meta_consensus_implementation ?? '', + slots: row.slot_count ?? 0, + observations: row.observation_count ?? 0, + direct: row.direct_count ?? 0, + orphaned: row.orphaned_count ?? 0, + unconfirmed: row.unconfirmed_count ?? 0, + p50FastMs: row.p50_fast_confirmation_ms ?? 0, + p99FastMs: row.p99_fast_confirmation_ms ?? 0, + maxFastMs: row.max_fast_confirmation_ms ?? 0, + p50FinalityMs: row.p50_finality_ms ?? 0, + }; +} diff --git a/src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.utils.test.ts b/src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.utils.test.ts new file mode 100644 index 000000000..c4a9413dd --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.utils.test.ts @@ -0,0 +1,174 @@ +import { describe, expect, it } from 'vitest'; +import { + type BlockObservation, + buildField, + formatDurationMs, + groupStallEpisodes, + logHistogram, + summarizeSlots, + tierForMs, + summarizeClients, +} from './fast-confirmation.utils'; +import type { ClientDay } from './fast-confirmation.api'; + +function obs(overrides: Partial): BlockObservation { + return { + slot: 100, + slotStartDateTime: 1_000, + blockRoot: '0xabc', + status: 'canonical', + client: 'lighthouse', + node: 'node-a', + confirmationType: 'direct', + fastConfirmedMs: 11_560, + confirmationSlot: 100, + finalizedMs: 950_000, + ...overrides, + }; +} + +describe('formatDurationMs', () => { + it('formats sub-second, seconds, minutes and hours', () => { + expect(formatDurationMs(450)).toBe('450ms'); + expect(formatDurationMs(11_563)).toBe('11.6s'); + expect(formatDurationMs(949_000)).toBe('15m 49s'); + expect(formatDurationMs(60_500)).toBe('1m 01s'); + expect(formatDurationMs(3_840_000)).toBe('1h 4m'); + }); + + it('returns a dash for missing values', () => { + expect(formatDurationMs(null)).toBe('-'); + expect(formatDurationMs(undefined)).toBe('-'); + expect(formatDurationMs(Number.NaN)).toBe('-'); + }); +}); + +describe('summarizeSlots', () => { + it('takes the earliest confirmation across nodes and ignores orphaned rows', () => { + const summaries = summarizeSlots([ + obs({ client: 'nimbus', node: 'node-b', fastConfirmedMs: 12_045 }), + obs({}), + obs({ slot: 101, confirmationType: 'descendant', fastConfirmedMs: 30_000 }), + obs({ slot: 101, blockRoot: '0xdef', status: 'orphaned' }), + ]); + + expect(summaries).toHaveLength(2); + expect(summaries[0]).toMatchObject({ slot: 100, epoch: 3, fastConfirmedMs: 11_560, viaDescendant: false }); + expect(summaries[0].byClient.map(c => c.client)).toEqual(['lighthouse', 'nimbus']); + expect(summaries[1]).toMatchObject({ slot: 101, fastConfirmedMs: 30_000, viaDescendant: true }); + }); + + it('keeps one entry per client using the earliest node', () => { + const [summary] = summarizeSlots([ + obs({ client: 'tysm', node: 'tysm-1', fastConfirmedMs: 12_300 }), + obs({ client: 'tysm', node: 'tysm-2', fastConfirmedMs: 12_080 }), + obs({ client: 'tysm', node: 'tysm-3', fastConfirmedMs: null, confirmationType: 'unconfirmed' }), + ]); + expect(summary.byClient).toEqual([{ client: 'tysm', fastConfirmedMs: 12_080, confirmationType: 'direct' }]); + }); + + it('keeps unconfirmed slots with a null confirmation time', () => { + const [summary] = summarizeSlots([obs({ confirmationType: 'unconfirmed', fastConfirmedMs: null })]); + expect(summary.fastConfirmedMs).toBeNull(); + expect(summary.unconfirmed).toBe(true); + }); +}); + +describe('groupStallEpisodes', () => { + it('merges slow slots within an epoch of each other per node, newest first', () => { + const episodes = groupStallEpisodes([ + obs({ slot: 10, fastConfirmedMs: 200_000 }), + obs({ slot: 11, fastConfirmedMs: 190_000 }), + obs({ slot: 13, fastConfirmedMs: 170_000 }), + obs({ slot: 40, fastConfirmedMs: 30_000 }), + obs({ slot: 100, fastConfirmedMs: 30_000 }), + obs({ slot: 12, node: 'node-b', client: 'nimbus', fastConfirmedMs: 25_000 }), + ]); + + expect(episodes.map(e => [e.node, e.startSlot, e.endSlot, e.blocks, e.worstMs])).toEqual([ + ['node-a', 100, 100, 1, 30_000], + ['node-b', 12, 12, 1, 25_000], + ['node-a', 10, 40, 4, 200_000], + ]); + }); +}); + +describe('logHistogram', () => { + it('buckets values into log-spaced bins and clamps outliers', () => { + const buckets = logHistogram([11_000, 12_000, 900_000, 1, 10_000_000], 1, 1000, 3); + expect(buckets.map(b => b.count)).toEqual([1, 2, 2]); + expect(buckets[0].center).toBeCloseTo(10 ** 0.5); + }); +}); + +describe('tierForMs', () => { + it('maps the slowest confirmation to a tier', () => { + expect(tierForMs(null)).toBe('ok'); + expect(tierForMs(13_000)).toBe('late'); + expect(tierForMs(30_000)).toBe('slow'); + expect(tierForMs(210_000)).toBe('stalled'); + expect(tierForMs(779_603)).toBe('held'); + }); +}); + +describe('buildField', () => { + const genesis = 1_606_824_023; + const hourOf = (epoch: number): number => Math.floor((genesis + epoch * 384) / 3600) * 3600; + + it('lays epochs out by UTC day and marks late epochs and gaps', () => { + const start = 478_000; + const hours = [hourOf(start), hourOf(start) + 3600, hourOf(start) + 3 * 3600]; + const field = buildField(genesis, hours, [ + obs({ slot: (start + 3) * 32 + 5, fastConfirmedMs: 30_000 }), + obs({ slot: (start + 3) * 32 + 6, fastConfirmedMs: 13_000 }), + obs({ slot: (start + 4) * 32, fastConfirmedMs: 779_603, status: 'orphaned' }), + ]); + + expect(field.columns).toBe(225); + const late = field.byEpoch.get(start + 3); + expect(late).toMatchObject({ tier: 'slow', worstMs: 30_000, lateBlocks: 2 }); + expect(field.byEpoch.get(start + 4)?.tier).toBe('ok'); + const gap = field.epochs.find(e => Math.floor(e.startTime / 3600) * 3600 === hourOf(start) + 2 * 3600); + expect(gap?.tier).toBe('none'); + for (const e of field.epochs) { + expect(e.column).toBeGreaterThanOrEqual(0); + expect(e.column).toBeLessThan(225); + expect(field.days[e.day]).toBe(Math.floor(e.startTime / 86_400) * 86_400); + } + }); + + it('returns an empty field without coverage', () => { + expect(buildField(genesis, [], []).epochs).toHaveLength(0); + }); +}); + +describe('summarizeClients', () => { + const day = (over: Partial): ClientDay => ({ + day: '2026-09-29', + client: 'lighthouse', + slots: 7000, + observations: 7000, + direct: 6990, + orphaned: 0, + unconfirmed: 0, + p50FastMs: 11_560, + p99FastMs: 12_000, + maxFastMs: 24_000, + p50FinalityMs: 947_000, + ...over, + }); + + it('weights medians by observations and orders clients by blocks', () => { + const [lh, nimbus] = summarizeClients([ + day({ day: '2026-05-14', slots: 1000, observations: 1000, p50FastMs: 11_700 }), + day({}), + day({ client: 'nimbus', slots: 300, observations: 300, direct: 290, p50FastMs: 12_045, maxFastMs: 84_000 }), + ]); + expect(lh.client).toBe('lighthouse'); + expect(lh.since).toBe('2026-05-14'); + expect(lh.blocks).toBe(8000); + expect(lh.fastMs).toBeCloseTo((11_700 * 1000 + 11_560 * 7000) / 8000); + expect(nimbus.directShare).toBeCloseTo(290 / 300); + expect(nimbus.worstMs).toBe(84_000); + }); +}); diff --git a/src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.utils.ts b/src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.utils.ts new file mode 100644 index 000000000..65d369498 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.utils.ts @@ -0,0 +1,320 @@ +import type { ClientDay } from './fast-confirmation.api'; +import { SLOTS_PER_EPOCH } from '@/utils/beacon'; +import { STALL_EPISODE_GAP_SLOTS } from './constants'; + +/** One (block, node) observation from fct_block_fast_confirmation_by_node */ +export interface BlockObservation { + slot: number; + slotStartDateTime: number; + blockRoot: string; + status: string; + client: string; + node: string; + confirmationType: string; + fastConfirmedMs: number | null; + confirmationSlot: number | null; + finalizedMs: number | null; +} + +/** Per-slot summary across every fast confirmation node */ +export interface SlotSummary { + slot: number; + epoch: number; + slotStartDateTime: number; + blockRoot: string; + /** Earliest fast confirmation across nodes, in ms after slot start */ + fastConfirmedMs: number | null; + finalizedMs: number | null; + /** True when at least one node only confirmed the block through a descendant */ + viaDescendant: boolean; + /** True when a node that was following the chain never fast confirmed the block */ + unconfirmed: boolean; + byClient: Array<{ client: string; fastConfirmedMs: number | null; confirmationType: string }>; +} + +/** A run of slow or indirect confirmations on one node */ +export interface StallEpisode { + node: string; + client: string; + startSlot: number; + endSlot: number; + startDateTime: number; + blocks: number; + worstMs: number; +} + +/** + * Format a duration in milliseconds for display, e.g. "11.6s", "15m 49s", "1h 4m". + */ +export function formatDurationMs(ms: number | null | undefined): string { + if (ms === null || ms === undefined || !Number.isFinite(ms)) return '-'; + if (ms < 1000) return `${Math.round(ms)}ms`; + + const seconds = ms / 1000; + if (seconds < 60) return `${seconds.toFixed(1)}s`; + + const totalSeconds = Math.round(seconds); + const hours = Math.floor(totalSeconds / 3600); + const minutes = Math.floor((totalSeconds % 3600) / 60); + const secs = totalSeconds % 60; + if (hours > 0) return `${hours}h ${minutes}m`; + + return `${minutes}m ${secs.toString().padStart(2, '0')}s`; +} + +/** + * Collapse per-node observations into one summary per canonical slot. + */ +export function summarizeSlots(observations: BlockObservation[]): SlotSummary[] { + const bySlot = new Map(); + for (const obs of observations) { + if (obs.status !== 'canonical') continue; + const list = bySlot.get(obs.slot); + if (list) list.push(obs); + else bySlot.set(obs.slot, [obs]); + } + + const summaries: SlotSummary[] = []; + for (const [slot, list] of bySlot) { + const confirmed = list.map(o => o.fastConfirmedMs).filter((v): v is number => v !== null); + const finalized = list.map(o => o.finalizedMs).filter((v): v is number => v !== null); + summaries.push({ + slot, + epoch: Math.floor(slot / SLOTS_PER_EPOCH), + slotStartDateTime: list[0].slotStartDateTime, + blockRoot: list[0].blockRoot, + fastConfirmedMs: confirmed.length ? Math.min(...confirmed) : null, + finalizedMs: finalized.length ? Math.min(...finalized) : null, + viaDescendant: list.some(o => o.confirmationType === 'descendant'), + unconfirmed: list.some(o => o.confirmationType === 'unconfirmed'), + byClient: earliestByClient(list), + }); + } + + return summaries.sort((a, b) => a.slot - b.slot); +} + +/** One entry per client with its earliest confirmation across that client's nodes. */ +function earliestByClient(list: BlockObservation[]): SlotSummary['byClient'] { + const byClient = new Map(); + for (const o of list) { + const current = byClient.get(o.client); + const earlier = + o.fastConfirmedMs !== null && + (current?.fastConfirmedMs === null || o.fastConfirmedMs < (current?.fastConfirmedMs ?? Infinity)); + if (!current || earlier) { + byClient.set(o.client, { + client: o.client, + fastConfirmedMs: o.fastConfirmedMs, + confirmationType: o.confirmationType, + }); + } + } + return [...byClient.values()].sort((a, b) => a.client.localeCompare(b.client)); +} + +/** + * Group slow or indirect confirmations into stall episodes per node, newest first. + */ +export function groupStallEpisodes(observations: BlockObservation[]): StallEpisode[] { + const byNode = new Map(); + for (const obs of observations) { + if (obs.status !== 'canonical') continue; + const list = byNode.get(obs.node); + if (list) list.push(obs); + else byNode.set(obs.node, [obs]); + } + + const episodes: StallEpisode[] = []; + for (const [node, list] of byNode) { + list.sort((a, b) => a.slot - b.slot); + let current: StallEpisode | null = null; + for (const obs of list) { + const ms = obs.fastConfirmedMs ?? Number.POSITIVE_INFINITY; + if (current && obs.slot - current.endSlot <= STALL_EPISODE_GAP_SLOTS) { + current.endSlot = obs.slot; + current.blocks += 1; + current.worstMs = Math.max(current.worstMs, ms); + continue; + } + current = { + node, + client: obs.client, + startSlot: obs.slot, + endSlot: obs.slot, + startDateTime: obs.slotStartDateTime, + blocks: 1, + worstMs: ms, + }; + episodes.push(current); + } + } + + return episodes.sort((a, b) => b.startSlot - a.startSlot); +} + +/** One bucket of a log-spaced histogram */ +export interface LogBucket { + /** Geometric centre of the bucket in seconds */ + center: number; + count: number; +} + +/** + * Bucket millisecond values into log-spaced bins between minSeconds and maxSeconds. + * Values outside the range are clamped into the edge bins. + */ +export function logHistogram(valuesMs: number[], minSeconds: number, maxSeconds: number, bins: number): LogBucket[] { + const logMin = Math.log10(minSeconds); + const logMax = Math.log10(maxSeconds); + const step = (logMax - logMin) / bins; + const counts = new Array(bins).fill(0); + + for (const ms of valuesMs) { + if (!Number.isFinite(ms) || ms <= 0) continue; + const idx = Math.floor((Math.log10(ms / 1000) - logMin) / step); + counts[Math.min(bins - 1, Math.max(0, idx))] += 1; + } + + return counts.map((count, i) => ({ center: 10 ** (logMin + step * (i + 0.5)), count })); +} + +/** Colour tier of one epoch in the block field */ +export type FieldTier = 'none' | 'ok' | 'late' | 'slow' | 'stalled' | 'held'; + +/** Seconds in one epoch */ +export const EPOCH_SECONDS = 384; + +/** A confirmation this slow means the node only confirmed the block once it was finalized */ +export const HELD_TO_FINALITY_MS = 700_000; + +/** + * Tier for the slowest fast confirmation seen in an epoch. + */ +export function tierForMs(worstMs: number | null): FieldTier { + if (worstMs === null) return 'ok'; + if (worstMs >= HELD_TO_FINALITY_MS) return 'held'; + if (worstMs >= 120_000) return 'stalled'; + if (worstMs >= 25_000) return 'slow'; + return 'late'; +} + +/** One epoch in the block field */ +export interface FieldEpoch { + epoch: number; + startTime: number; + day: number; + column: number; + tier: FieldTier; + worstMs: number | null; + lateBlocks: number; +} + +/** Every epoch between the first and last covered hour, laid out as UTC days by epoch of day */ +export interface FieldModel { + days: number[]; + columns: number; + epochs: FieldEpoch[]; + byEpoch: Map; +} + +/** + * Lay out every epoch covered by the node as rows of UTC days and columns of epoch-of-day. + * Coverage is hourly, taken from the hours where the node scored at least one block. + * Late observations (slow confirmations) set the tier of their epoch. + */ +export function buildField(genesis: number, coveredHours: number[], late: BlockObservation[]): FieldModel { + const covered = new Set(coveredHours); + const columns = Math.round(86_400 / EPOCH_SECONDS); + if (!covered.size) return { days: [], columns, epochs: [], byEpoch: new Map() }; + + const lateByEpoch = new Map }>(); + for (const o of late) { + if (o.status !== 'canonical') continue; + const epoch = Math.floor(o.slot / 32); + const entry = lateByEpoch.get(epoch) ?? { worstMs: 0, blocks: new Set() }; + entry.worstMs = Math.max(entry.worstMs, o.fastConfirmedMs ?? Number.POSITIVE_INFINITY); + entry.blocks.add(o.slot); + lateByEpoch.set(epoch, entry); + } + + const first = Math.min(...covered); + const last = Math.max(...covered) + 3600; + const firstEpoch = Math.ceil((first - genesis) / EPOCH_SECONDS); + const lastEpoch = Math.floor((last - genesis) / EPOCH_SECONDS) - 1; + const firstDay = Math.floor((genesis + firstEpoch * EPOCH_SECONDS) / 86_400) * 86_400; + + const epochs: FieldEpoch[] = []; + const dayStarts = new Set(); + for (let epoch = firstEpoch; epoch <= lastEpoch; epoch++) { + const startTime = genesis + epoch * EPOCH_SECONDS; + const hour = Math.floor(startTime / 3600) * 3600; + const dayStart = Math.floor(startTime / 86_400) * 86_400; + const lateEntry = lateByEpoch.get(epoch); + dayStarts.add(dayStart); + epochs.push({ + epoch, + startTime, + day: (dayStart - firstDay) / 86_400, + column: Math.min(columns - 1, Math.floor((startTime - dayStart) / EPOCH_SECONDS)), + tier: covered.has(hour) ? tierForMs(lateEntry ? lateEntry.worstMs : null) : 'none', + worstMs: lateEntry ? lateEntry.worstMs : null, + lateBlocks: lateEntry ? lateEntry.blocks.size : 0, + }); + } + + return { + days: [...dayStarts].sort((a, b) => a - b), + columns, + epochs, + byEpoch: new Map(epochs.map(e => [e.epoch, e])), + }; +} + +/** Whole-history summary of one client, built from its daily aggregates */ +export interface ClientSummary { + client: string; + since: string; + blocks: number; + fastMs: number; + finalityMs: number; + speedup: number; + directShare: number; + reverted: number; + worstMs: number; +} + +/** + * Summarise each client's daily aggregates, weighting daily medians by blocks scored. + */ +export function summarizeClients(days: ClientDay[]): ClientSummary[] { + const byClient = new Map(); + for (const d of days) { + if (!d.client || d.observations === 0) continue; + const list = byClient.get(d.client); + if (list) list.push(d); + else byClient.set(d.client, [d]); + } + + return [...byClient.entries()] + .map(([client, list]) => { + const blocks = list.reduce((sum, d) => sum + d.slots, 0); + const weight = list.reduce((sum, d) => sum + d.observations, 0); + const weighted = (pick: (d: ClientDay) => number): number => + list.reduce((sum, d) => sum + pick(d) * d.observations, 0) / weight; + const fastMs = weighted(d => d.p50FastMs); + const finalityMs = weighted(d => d.p50FinalityMs); + return { + client, + since: list.map(d => d.day).sort()[0], + blocks, + fastMs, + finalityMs, + speedup: fastMs > 0 ? finalityMs / fastMs : 0, + directShare: list.reduce((sum, d) => sum + d.direct, 0) / weight, + reverted: list.reduce((sum, d) => sum + d.orphaned, 0), + worstMs: Math.max(...list.map(d => d.maxFastMs)), + }; + }) + .sort((a, b) => b.blocks - a.blocks); +} diff --git a/src/pages/ethereum/consensus/fast-confirmation/index.ts b/src/pages/ethereum/consensus/fast-confirmation/index.ts new file mode 100644 index 000000000..b36af7308 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/index.ts @@ -0,0 +1 @@ +export { IndexPage } from './IndexPage'; diff --git a/src/routeTree.gen.ts b/src/routeTree.gen.ts index 7361d2b96..f4f01ff71 100644 --- a/src/routeTree.gen.ts +++ b/src/routeTree.gen.ts @@ -56,6 +56,7 @@ import { Route as EthereumDataAvailabilityProbesRouteImport } from './routes/eth import { Route as EthereumDataAvailabilityCustodyRouteImport } from './routes/ethereum/data-availability/custody' import { Route as EthereumContractsAddressRouteImport } from './routes/ethereum/contracts/$address' import { Route as EthereumConsensusOverviewRouteImport } from './routes/ethereum/consensus/overview' +import { Route as EthereumConsensusFastConfirmationRouteImport } from './routes/ethereum/consensus/fast-confirmation' import { Route as BeaconSlotLiveRouteImport } from './routes/beacon/slot/live' import { Route as BeaconBlockProductionLiveRouteImport } from './routes/beacon/block-production/live' import { Route as EthereumExecutionTimingsIndexRouteImport } from './routes/ethereum/execution/timings/index' @@ -318,6 +319,12 @@ const EthereumConsensusOverviewRoute = path: '/overview', getParentRoute: () => EthereumConsensusRoute, } as any) +const EthereumConsensusFastConfirmationRoute = + EthereumConsensusFastConfirmationRouteImport.update({ + id: '/fast-confirmation', + path: '/fast-confirmation', + getParentRoute: () => EthereumConsensusRoute, + } as any) const BeaconSlotLiveRoute = BeaconSlotLiveRouteImport.update({ id: '/beacon/slot/live', path: '/beacon/slot/live', @@ -412,6 +419,7 @@ export interface FileRoutesByFullPath { '/xatu-data/': typeof XatuDataIndexRoute '/beacon/block-production/live': typeof BeaconBlockProductionLiveRoute '/beacon/slot/live': typeof BeaconSlotLiveRoute + '/ethereum/consensus/fast-confirmation': typeof EthereumConsensusFastConfirmationRoute '/ethereum/consensus/overview': typeof EthereumConsensusOverviewRoute '/ethereum/contracts/$address': typeof EthereumContractsAddressRoute '/ethereum/data-availability/custody': typeof EthereumDataAvailabilityCustodyRouteWithChildren @@ -464,6 +472,7 @@ export interface FileRoutesByTo { '/xatu-data': typeof XatuDataIndexRoute '/beacon/block-production/live': typeof BeaconBlockProductionLiveRoute '/beacon/slot/live': typeof BeaconSlotLiveRoute + '/ethereum/consensus/fast-confirmation': typeof EthereumConsensusFastConfirmationRoute '/ethereum/consensus/overview': typeof EthereumConsensusOverviewRoute '/ethereum/contracts/$address': typeof EthereumContractsAddressRoute '/ethereum/entities/$entity': typeof EthereumEntitiesEntityRoute @@ -520,6 +529,7 @@ export interface FileRoutesById { '/xatu-data/': typeof XatuDataIndexRoute '/beacon/block-production/live': typeof BeaconBlockProductionLiveRoute '/beacon/slot/live': typeof BeaconSlotLiveRoute + '/ethereum/consensus/fast-confirmation': typeof EthereumConsensusFastConfirmationRoute '/ethereum/consensus/overview': typeof EthereumConsensusOverviewRoute '/ethereum/contracts/$address': typeof EthereumContractsAddressRoute '/ethereum/data-availability/custody': typeof EthereumDataAvailabilityCustodyRouteWithChildren @@ -582,6 +592,7 @@ export interface FileRouteTypes { | '/xatu-data/' | '/beacon/block-production/live' | '/beacon/slot/live' + | '/ethereum/consensus/fast-confirmation' | '/ethereum/consensus/overview' | '/ethereum/contracts/$address' | '/ethereum/data-availability/custody' @@ -634,6 +645,7 @@ export interface FileRouteTypes { | '/xatu-data' | '/beacon/block-production/live' | '/beacon/slot/live' + | '/ethereum/consensus/fast-confirmation' | '/ethereum/consensus/overview' | '/ethereum/contracts/$address' | '/ethereum/entities/$entity' @@ -689,6 +701,7 @@ export interface FileRouteTypes { | '/xatu-data/' | '/beacon/block-production/live' | '/beacon/slot/live' + | '/ethereum/consensus/fast-confirmation' | '/ethereum/consensus/overview' | '/ethereum/contracts/$address' | '/ethereum/data-availability/custody' @@ -1066,6 +1079,13 @@ declare module '@tanstack/react-router' { preLoaderRoute: typeof EthereumConsensusOverviewRouteImport parentRoute: typeof EthereumConsensusRoute } + '/ethereum/consensus/fast-confirmation': { + id: '/ethereum/consensus/fast-confirmation' + path: '/fast-confirmation' + fullPath: '/ethereum/consensus/fast-confirmation' + preLoaderRoute: typeof EthereumConsensusFastConfirmationRouteImport + parentRoute: typeof EthereumConsensusRoute + } '/beacon/slot/live': { id: '/beacon/slot/live' path: '/beacon/slot/live' @@ -1147,10 +1167,13 @@ declare module '@tanstack/react-router' { } interface EthereumConsensusRouteChildren { + EthereumConsensusFastConfirmationRoute: typeof EthereumConsensusFastConfirmationRoute EthereumConsensusOverviewRoute: typeof EthereumConsensusOverviewRoute } const EthereumConsensusRouteChildren: EthereumConsensusRouteChildren = { + EthereumConsensusFastConfirmationRoute: + EthereumConsensusFastConfirmationRoute, EthereumConsensusOverviewRoute: EthereumConsensusOverviewRoute, } diff --git a/src/routes/ethereum/consensus/fast-confirmation.tsx b/src/routes/ethereum/consensus/fast-confirmation.tsx new file mode 100644 index 000000000..388274778 --- /dev/null +++ b/src/routes/ethereum/consensus/fast-confirmation.tsx @@ -0,0 +1,41 @@ +import { createFileRoute } from '@tanstack/react-router'; +import { IndexPage } from '@/pages/ethereum/consensus/fast-confirmation'; +import { fastConfirmationSearchSchema } from '@/pages/ethereum/consensus/fast-confirmation/constants'; + +export const Route = createFileRoute('/ethereum/consensus/fast-confirmation')({ + component: IndexPage, + validateSearch: fastConfirmationSearchSchema, + beforeLoad: () => ({ + getBreadcrumb: () => ({ label: 'Fast Confirmation', clickable: false }), + }), + head: () => ({ + meta: [ + { title: `Fast Confirmation | ${import.meta.env.VITE_BASE_TITLE}` }, + { + name: 'description', + content: 'How quickly Ethereum blocks are fast confirmed compared to finality, measured live on mainnet', + }, + { property: 'og:url', content: `${import.meta.env.VITE_BASE_URL}/ethereum/consensus/fast-confirmation` }, + { property: 'og:type', content: 'website' }, + { property: 'og:title', content: `Fast Confirmation | ${import.meta.env.VITE_BASE_TITLE}` }, + { + property: 'og:description', + content: 'How quickly Ethereum blocks are fast confirmed compared to finality, measured live on mainnet', + }, + { + property: 'og:image', + content: `${import.meta.env.VITE_BASE_URL}/images/ethereum/consensus/fast-confirmation.png`, + }, + { name: 'twitter:url', content: `${import.meta.env.VITE_BASE_URL}/ethereum/consensus/fast-confirmation` }, + { name: 'twitter:title', content: `Fast Confirmation | ${import.meta.env.VITE_BASE_TITLE}` }, + { + name: 'twitter:description', + content: 'How quickly Ethereum blocks are fast confirmed compared to finality, measured live on mainnet', + }, + { + name: 'twitter:image', + content: `${import.meta.env.VITE_BASE_URL}/images/ethereum/consensus/fast-confirmation.png`, + }, + ], + }), +}); From b7fc64639c64b0d5926c9354b87f13f8bbf2b8d4 Mon Sep 17 00:00:00 2001 From: Sam Calder-Mason Date: Wed, 30 Sep 2026 18:17:46 +1000 Subject: [PATCH 2/2] feat(consensus): fast confirmation feature image and quieter base colour --- .../ethereum/consensus/fast-confirmation.png | Bin 0 -> 366041 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 public/images/ethereum/consensus/fast-confirmation.png diff --git a/public/images/ethereum/consensus/fast-confirmation.png b/public/images/ethereum/consensus/fast-confirmation.png new file mode 100644 index 0000000000000000000000000000000000000000..63ecc96b72d85f37d000a8012fca5cb947c1a2b7 GIT binary patch literal 366041 zcmdq}Wmr`0*9MGZAPNFXN~1^%h;)~9cY{c`bcZ4!E!~|;cQbV7(B0iI3@{8c@Amin z?&tP7{vZAy-{W|%4-D*m&CK4{wf0))I@h@fQBsh^L?=c^K|#TkminlIg7WMW3JR*s z(}%#3jfPn=6qFYz(jP_C+|!PhQN5?kDA3NPmY1UmevNOaEa{^KycT(FZ9045Fu` zg?_p>kTv4M!9f{c{|PX7VtRUdW@ch$W(T;0|Bfu3Kq(JxZEaK2Mhy-qp3wN-o+Ap% z8Nbm!CDLA8JU=5t@ZRB{$tWn4;<|F0n&mY$-w`)51aVlQ)`skZ;V&M%Mrn5n%@G+y z!+aj@?0lyG?>m$p2?+SepofKF)Yj}FBWh150}8fKP%@~zdqgVH1q2@D1^hc%Cg-6# zgGPR*x<>EdGf!tLy%#SYqVOC3uIfNn9&xLA_h&W#XJq00nKvE!`$vUxK>+DPQ564O zG^9Q?)>B4jX9)K{(@;>9UgDQ&{J<53R8QM1)@! zs!Oy@Y)>uv_&W;9*y{eTRU|-qL(8mH+OtSykga17~HPaBLr5x}AWzFNOtN6di*~?f7TK{tmE0i>k|9ATM zk6xXnQ2!VIdjR-ljpy6{-vc>AUw7i-;ClhobTeO_p7mpnGOgr;|Z-A0M9+4|Q#2)&_fu^`!aoR!-~DV$#3fg94X4 z;HMmBq0?$~y{}8Z1B2Q2vdi6yXU)g<7K?)u5)xvZ=olFnE6tIEwImxGxQq-8OUrt+ z@~OS>$wt`6g)9c7#JC;Gh)auGaJ0mHx|^3zZ z&mGR6HF|g~EG#4>5R9a_b92ufT3D<8kivz-?+gz)?Q#d^NXfV9SYS zW(8?9dHMOvjXq(jn$1|pjX_M*)Z(8}tE;R2vK#u>D2tC5aP66 zk)X}|2iEc5H;59aq4~hb!{atkR+GiBmHBeMzbJUqAf>E0cXPG(v~z`Vm^2(CIN>N5_z6Igby*+sG&z zQW7dF<9aG|Gh;o3ci2zLiiRu=w<8yjk)( zYQ?MEquMNVSNNB1uh>jvU#0 zG~ZcvCnqNtnJGXkkQ}4_Dl9B)auOUK5yABCT}@3bPd+{#o{5=BQgYZA%tza`HOvqq zZ5?fgT2(bI3k#F(zb{L;wW!$t=La?_DzOk&n%-U~v(c=nk@0b*f!n=qY;$-zL zAH}-{Tv9z94I1y6?rtsBkuWR9#5v1ioFmpa>ywp6MI(QQc_icr(PCp`16;|!<3LUy z^}A=2C)onp_wPZM@&PIaHw%o_JEO_D5@A{7c6LKZ_-3ugrQK4KzDD}XgM$O;;j*k` zVK&$4?ID0!(SB=di!LcBBVGzE(4y5K^L{YmaF*xal|(@) zB5{c?Q)afXHojksv8SiXlNwu@frcpxYP6XuCzFzqBH$jsYUAOZv39 z!*l@_SxL-fW?*LiE0Uw2WMNGiUGasUd$+bCZ*4<tfr@@q@@LQE)4J$6x{5KtgWfYa{l>Hib?)TSgTJ@PhT>MWYNA|c)#!@ zFgP(T?hM=SZdC<+>pO0PmwU_QiWlQd$^Aj|=^f@P%JYkIAx+LE)x}@9v~M5E+EW5zAB+d3E+VPAdj zE~tivhMXLo#ta(1K)OSASeicR0NJ-1v~=}u+wCYC29$yq-UmYZ zo*%oR1_pK#nwgq{Zcn_1G)os+k?qCyAOXMiV4~z?z$F}M6PoX~wR)y=yBKV!V@`e# z!M%0<+0fVw;=Gm*v3x`IX0AQ3+MGHA2JOq#;_X)oZ#s)rq_$d4=XD4#mZk893{pb&Ik&wdLsk6+3~y!3Jaai(pXn) z#Qgpa=2Q8+&!5s`@H@b4lpP$R+J!lT-iU=pu6Uoe7IWFf#V1ZCRaI3T*4t6Pef!kV zo$KAZgNa;phsoUh{QN$}bRGEBtcQokk#=ZYZxm5%S`0B^Vt-)}rp9dh36AlCiv^bE{=~hIh}gv9a5n z?mF)8l9Q8p=I0@aF)=w{xfUO9Q(qInRs|c7zjoBCtE>MHU>L6f7J6uKFvs}w9ptEE zmS?Dcc&XAHyBI2YyE-Q1?Z-!Fv6)bc6QZmdMI#|0fw7uyZ)?f{7|eWrejK6i)jhWE zOi5*Rb^fz=Oz-66=083)EcZD)1CFYoAhV&Si7oGt5TC$&w|nYRtm#xc zlcSE2yqU^r&CE)}hylRWe~16hw2`os$R{%mS6LPoXhl`k2U;#JdY)tfxuJfooBhI` z9_p1+9px8v-mhD~_rhy!JOCRp@D(H>!X-&fPwjdrYHMpNM3Gr>c6M>$ctWJ2qSE=R zEUzJ{SoYk(A@iNy7Z(1s$;VV;RLPrHn9tw##w8{?oY_oBHx?0Ih&76R`gJO*;BvH` z?~5^X{OE7rtfWcy8N4;ZY#D#M2ZSA?=?~DwF%A62=wzo%e(@1ce!Ag?BvH69ChXCBs zuxD3QWh-O$sk~9$cm7E*z1-E+2?kFML!cwNIANv2-H+x4XnOfQ-?H{DEyV`8IQ9nF1o}Yr;l2E2iXCwXW8+!SJqCe8wgeGlU2a>B)JR3`XVt1nH-&*cKh`B{Sd7l_KaLY%>3`< zc5Z^Psi=Fkbly;U&&0u)*tvOPa09(_iWGUN-o?bi&-W?m-Gr}1{xSodiJgP+?60ry zQ_~U#qbe&ai9Te3N+TkEg@n}Bs)Gc5Rx+>a8XG-KO{r18Qhzqx-iC}%bgUQmWWqeX zbdyq53-&(QBQN6UA)=fVDQheDcRD(0dm!^4ABDV=iHPW@nW_+)pL24ld%dC4vz^XA zA1^od&@%}M`K@Lw<50!o;9eiEP_crimm>nqWgC4y{aSsuGx*hFJw=_m8t6#e`Ha13m{yZ!vUt62` z%fG@6kay)#(yBfP+xvIfKhDbV`OWVmE zyD#sBc4i_-!h{eO;J9CSg_hRVl0u%4*;9}{zn{U)Z?h2ro@pQC$Sh}F9Xib`UYnae zhfN#XXmZ*ZADp5F3}n;m;Ms*$U)N#w&B9G7WXC4w6+1--1QJ z_U$NG8OnGU(p%o01Rs04F@I|GeZ?ankdrA)QZicwlJ@@{S-*Lo&jBm!-J(m*O3p-ml1{{CItSHITS-Smq(g{Ng8-kP4)bhs+N24*1K}b{`C-QG}a&X=fA^3M*m7gOIthHP)SKo zPeo6!#c{dm%%us-FSKT&}*U2CsG`vGoyB$-64ANVIB0PPKjk43YSp0 zTWLutk2_YsEEu?VM&l8MM=&KqlCQ?97|(Ci%r#n>pad zIt6rT6f!PuXANh$lbeJ4%Kh$_^DI@%B3myJXe@2)(ksZaUt=eWT4bqN{IkaEQmD;+mV;Zil3t z++JM7{c5tV_%I`O~K?Fr-N({gAZGnH6Wtb32CW4OnG?OMnE|_9 zllNE*DRMbuqW_o<@LGgf+Op)VkV^+$bXq&xU4=_M$oRsaukBh_S6v`a!r`3+*lbxO z*0whhQF7r}y4MSQOH)f8lXeu(fo$Wxp+T9&dfUZHeLf5f3?`;hFc_Q{7bkFcU9JNX z6c7l=58zMP%|zb4&Wb4ipsbfGc1TV^n3#}~l9*UnntOb3uyb@|Lk9}z_0-Cc#HIj) zT%pjK?OLn)5g@1D{A^7BAirb+7~NBG0p`(>St*pO@strj^iUb#!Mk3h_0EPY9T@JV zZ$j)bGRgHem9-;AbDVRS85ygqssvF6yHuDEh?0*ui`9U;B}V7t`Rw3$49U%?%FeNps^F+BO8 z%(35ozSZx!c2Tmv0_c^>Tg!+-Ys#L2*3M9EfcSeFB_%sQk4la@_?t8_A|xQ@4*~hl z;2$IQ5-wU#;E|P)O@zY=TbzI5;o}Deu7-KuSX>1~lqpfbbTu^%yQMnot+Q+(kB?wTM|Fqd%gL1c7&N+az0 z0WYap7-M;nR=wpVOg@0|(f8yTv7`kBqF$WEQ0 ze>Vmt3nzku)$_PlUV#bkp-iv8j?Tiu0Xwct$mSJE{gPf94~j(*)MElB3* z?h_3mhs%qdOL{kP$-gXxQ#k>CHV$JY>PHsnD2iAQL;q9(q)6tEe--JcgMW!1`g$CIh<0NCf|!b{%ypJ#D@VtKePa~ zlw`&D_;^VnU-)uNex`53*)f;FYJ+SHJ&*Oz(43 z2ZwWjvjQHJiO0PX61Ltxu`#g};*!mcO)&TRla-FsPp&?=hf@eZOSYqQ(>d-eeuHmT*yNuIg*hwxWuGK}JS&v=3wOXHjG0 z&2OEZ%w)VZm)EfYTNInzaCjTuBg*`RMc^m!qQ-p*PIZNLg7#sL!K1uOOJm`YDcA)J*#h%0?Nou^Ku$#MZCsBJ-&G z2=KRfy=tarX4d~TW`O*9J)t!<)x9jAJTN#o_@TOL0~e=Za4@k@E<5k1#Lo7%GP9PF zl7+pwH9#QS*oaaI@bd$3UAXa+jFpw0UD=0yO3Rs=XNA0jD+P$+lG#gr=hrB z2@Wos(4GKI#p9o^Jl6MUboyJ;E z95?o|z()h`Iudz`jKxtKlYc!k&8Lpa73IDuKflKsJj(vNj>9f)EFa!>)0s4~=oTMO zuRa!qt4Tc!V8nqD`LTXFhIc8fF26G}3>;<9HR-La)g&eRI#v)<^VL96BMl5>{y~`J z{SWB+#^;9XjWZ!z4Koh}cq~xRY4V-^T3@9;c7hk49QK@6b8G2d*bGPFzQ)g1J}+yiD<_osqDkl-^PpmA1UvhOT9=FQiRf0< ziRWx8I2Vp!rjjEj8&Z?e-#Iz_teh%}imRgoVxAAGa4Idt!s$n-` z=v}Px>02xZ`JVMpG~BqGn$5M9BGZyt!XCZF{NaV?3T>hE_C&0U3_Hg=B9_s^9elXx^-N7-9^ZW9A#6| zXJMoHVy|Zv&nehP8pqD|vC2knpINjjoEY?$6SgMSwjTOdmV;^3U8b4I7fEqn4h!O? zLXtVHv^2@mF-{fICn~1T` z3mit-Fd<(=$4F0pFMVxotxtZE`*llJq>l_TaEOwAzNl-WGKsAmfQ@CRetQU({9DYWXrNTDtPRry}+G- zN0`A=K_j@+*1}^bSjhw*MNO%W0L)KOa&Q10!x7sKLCwe%o#A4Cvbl94?q~CvQ_e3) zf(A}HdZZhln7Y4EQwunyIDO@^I`d=fd}{F{ZGu$lKJjJl`ql1XaI^jxfv^7a=kga- zY*2fx&cY~}GRhI?O_|@|kW6ZgjqK!jQg`1=NjLa_;?Lv+cay`@I4t7S;rjQ;f4Bgh zI=jW(d_OKRu~ITKWgiw${v3ffj@pPHB;;?FwW&3so;qg3ZH zMyxMXpNO!XFR!(Hj^>NR3`@crI1d>Fzs}Z-J=HCzWR?r1|UbPzO`re=l1pcV^MTIr0<~|$zfb( zu)b;h9fs@DJ9@y^2*Sw4wc(HRse26C(wm@u(E>+H=1bY7AmtU;{DbH4KwLVnlVg>hI`za5l6 zd^#%Dzl%5>w`LbA5Kk3WSaQhfj>8Lo*1Tj*!Y#Kt-ca;Ds+@!t4@nn?xUzWp$>cN5 ziKQ}xaNOl-#ITh7THIv85Q>OXiVo9)b3T&#V=zWxw)g?qjUTBbtJ{3qpPbgPk@cH# z&S{Rl4O{4u7%nZBBC%9>#3y6A)V$>DSNyjFUY3@ZMz4j;AVU;Suu{6gA_dyTbvcP) zhw?GQQ;$6p+rQ!l4lS8?KR@>p|5alJc&NSA3fN<{jVl+3L@fB3wY_4WSlZDC$U>lfBHZy4x#sBi4F zq^0+dh$a{7G2QReZ?DPui;9Yr_!(2yl%0n!rmYE>^n@FYKLf;MZa}#kBQ4t9&PdAD z{`B%7SjEr~AZ@!?3(GQmbsUF}WrM@QE&`_ss0os0rog?*8?_pokpt)0vE-5sUNC9? z_!}*?a%LF978dLNyQC(sh%&K?u8an2bR-a4ezsLTi&M)lB!FvAa~8mv~1J$pVr-Zd%6SZWPVSRDq>)LIsErlUE? z{D^wFT@tzRL%DyT74<$9?tEALmocJ5#O*v1l>ku2Tz^qWbLw69GkpAbfDE0spDuL|cS`hDFYu<}gm({7u_}ht7jIc*ZK2D& z^*h4sIV~8$o-L}X`aJvFp00IrlFJ!tF|a@*uNVn{BX`eaYdtGYZA`jU())|fzGyd! zWstb_M`;?nMN~Gm*IK#m?d4&LZ3Q)kWsll)F(MhJaL+$EGIw&31I2 zOFJlU=vdc2<;y%tXXRp3*E)>E+cHgzPk2R?3Zxqhpl=te@^~jID+Q&cv6-pjPBYV! zyO~VP3@kXlOw-Icd-!DPW>i$5Is)Mfi@%(pu0$w^# zML|xB_xMd?$rD?x~aySZu3^2(!0 zduY>B`{h_v^Fney9*pL9>AA!viQ-8{0I|Su@?<9P5p_>skVJteEGVtv5uq4}le*k6GhUIPI?hcp#VDk`cdt}aAFl4ai-F_egU%x~lBHe;rB zlWVBOWv+lyo*bp67Bzhf)t=)vDWFLcs;V6OvHxx@@96C4D@UhgXcz{!a&Yt$cv8zz zcwhAEjcX=zlfRovf{=XJc=Ex5<^M ztE=naBDdQ91I&kB2`#(tSf13>)MR-B@w9Y!%_OIxvr(DucTM^s(1n2R_jN*SrR}^q zxq&SmimW@Fl8-8oW>b|}1`)GK(c8D=c4=dLxMsGww!oX^b(4%R0~sn!sT=+x#~aB`eG$eC1FcrRu^SZt3M6C=mlw{aJPxUIVE{{-wQ04fA=hDnjbCKWk-}N>T6P%JORM>+*H+j zpDwOt1OLLMnlHJQD3Uk!^Gk@HE#eeuO+3S!@6JA>N%bZ;`#llKIxV zz5}Ru>2cb8T)~cdBTbJ!0ArO0@o`_0`rh$xtMl?UwFb#s&os4udGN3atHAQY@k7kU z8^EJ=Nmvb>%qrE0yk#I>;B7#2CW*_8^$@yo>|QR$%TCswd!7krUd<|sVWc}e{zz3@ zO!Ba{#(|XAG9$WDTf_hw@RJduX`mrd{eiU>PoBnrK_|K`*L>2dfVNM?nee6ONc*^Z zcic5o$uYfq?y>M>(jV{!&uEO-H}d6VdM_{bm0J9FZUIx)nPR>=02zQBlR{^_=qz=1 z>?C)5qP;z-*WLYgvYMSp7Zrn%Z=Lv@Ojred&g;fmjB0YKJLznZaBsUNlk@sy+->XK z-@5|9QUHjLetj30nP1pVM4YNTTBuJ(IRF$&f8rqfXC@+|e!0^>o7hR<1mgo#;Rm)! zoD!S#+ao0^912O&)vKu7;@x&a0~QuWd09`O{_^o_en#6@NcUj*rwAYcw3N3!($A|$ zVd49er$#u6I5FyakTC71!6|u|Ci%K*^B&B%rZ%s8c=34)aEK?$^QDtRikw7i7 zu1g3iCxRsxsSfmik(6ijZ0ysndnst-6a7G7R1a^`tmP7BW$eZCm;SV z!3~^h_rv->MSVcm``8EIz>A*$`T5WI!-P|OFB18SAOl3hq$0xq-#IWLFCV(`&;9=A zb?w%l`0pYkAQFD5&)2sDq_9PAsP|w0B^4g$&VKUx?>7Uh`2Vx4|L+|5_&;o(zqvjj zv@w&A0D?$%c6LNWM091P49nQafV6@_9StWZLu&<4WS|ldU||_s>RehF)KN4v93TWr z06W_|W+oo&F679aEB$!*gFo#-~8a#~^_410jt*eQM{B z0@P6E3hBI#duxqs=HEA$1^9!oC+)hI_``(cAXMKr|VCQ5#hg{?+ z?&kkerMHf|25L8*kM5x40?vDOQa`?UH)D|nJtyI`>6Ws!ZM01um&H0>b=x{y{|5J7 zziB5Ic=DW>{ma=4)bf7>v8I%O{2S$GSm;!I8hBtnIlx@O+h(bhglq1756+U`I%EKM z2!RO0M4pXs9WS_@S%ANL)#c?EAns-j!JGIL8d2ne@cTrhbQISq^j*zATmT2hb{x&+ ztHSMQ!WSyM{iishczF((Dvpj|%`l;6hx-(WDj*|8++L1}p{omt_B0BIwI)m5f&4L`i~yv8Uz4VL25S9t#}*Bv8G=mS?(0iDC&|?=mu3p$ z05vY_ck{KFBra{+#9TItg^@8f8H-b^k%z~=6`Jx#W68+p0{%F7`LM~$uUeIisk_!(F`N0I9GZu@LZ+wfOvzLn-n!JFHV9@@2~^w&35a3P!*X*| zGoVl5KO>9zk6<5Yv(QW|TmFvi1NUw;mvwc8!Z?a=gVURwm3P!>Bgt@g45|&i(kW(U zR4!q4mepqP_u_hBT>kLzI39<9+O6PIdL(Wn5xYtM@O*V2h+DY&OUX9uWc;_JX5L*i z!A{`|zxP^?V^NtIikh#so*mfi3oN&t&F<<>q?x>vQCp9QirTcE`LAd7Cm#P(k@Htc zK)_O?GBaDuudX26{=DP%YwZ}jW9fn(F+qKi6cpoiWY;$HjkY90OI7NJD?WGn&5q*d zvKN<^eu#ZZ#CoxP%lg62=(Nr?xd4TLcYjcq=&9?;g8Jug6%|Up+!d18z8gV6&3+#c zmBPEqzJAU0hBlU#GI{m$62hUyEVs`9g(m0j)$cYEH=AXdeKI6oj~5{MTh~@s4Jx zL1kK0mY$xTVG3`=k1vhC{eA?xyFTgZ>pR~B!A|%>xR*v(5Y;RooJh+xBBuYCDvGdJ(0^hG zu~@dah6Vvi0geYc7QUj`d{k_8_1Qd7xoGa_xISH#RgeQ@2ssZOG`Z^SmYXNzz|}y( zYiMM^sH@J^)y&Kc@NyGTaasT@g{6momG zg=15lo!@Ankl!BX7Qro!`)^u9&7?8~Z9_Fy1Q8D&#JzSv*A%&pGRW}px>l0t4>~3z zg+UJM{Z7eySVBU>=O~NJp@?7#^vlA9Gl*vuQprj@v$mU{!ReAfXlbFZu;4a?c+r~_ z_wqeMXhLIAMSst9JoF5Z*+ZnI71QF9w6wJPgDf-iDCIqgd7HEY(rO0T85Oegx*z*C z*dq};1O(to$kDRbWiO^plBHj(ge(aA0Yx02pqDatG>Yk* zJ~Qvg$jH`jBCKaGP$7nXNFOU1bS4z!Q9cP5{YsX}=b4({F!eaOce=GYp3!Z3@co`k zb^IWNPF)M2#ZGgyYHTlU^#PRZGNEcO{Q%!7czeW#o@Uav-+FeI=?9CpH&gl%6X3Su zW!PjYwK5?VjDX+Q<7sDi7F8Or8dfMN8fL~uy@{Y`yQO)@uEq^s?Ar~qZ*y_d%nlhU zPGmtMhLC{pI4?7W*QYma)&Q4TLctX}_p)pLz3rUpZl)SW>|92vj+ftiBv}ZrI+Jc~ zLE#n?c_1(7-R=I(L@roSx%0j&CckE^-#hy^MXMY&HMO;7=>~;Dx?p+^RS!$H`%&R( z+b#w4WU}7+6J_D+CQr|r%he`_09;xF)`^MENEqG1?qPkSmwSIWGO*0Bwdp1nC{EaZ zs0rC=yW%{y$6>tds$U(~Fzo^%@3F02ROyaRmXjw7s@DDMjuG08F{*U>-yt+5Ry6GyzFt#nudlWAK*r_BNuT<`@2i7x&N8k&pA@yAuGnm=2>cI_Y*Ar+B1 zkkv8_kil}6s1O6V=s!dBPYW0ddx2!Rfw!>x$q^AlPeMOR(bEh?G#-bR4(xJ+O86=W z5yPX)P-2J}TYW7eA_Rw5w+yNPQu8e_!Juh&l_!RL^3=6@YkQJW35c6qXK&Fmy*9{3 zLnY8!lTemcZ++(~qs7BRN0Q2Q9g%20>U}>_|2Bhxg#`(_9J62?@H$@6Z{FJ$V!odT z56bL3j>&&k9D8cs!4|IgbF4<3wyE`x^@j%Z8GkK7_*ZbS;ZT zh{JxSgoolqFVM2Z?Xh1Diq}MQzj)ZmSD)ei!_`$?2z8B72}f3T!sylcTE|3J@JS$` z)(PuWSP1sHUwBT+ua(bF{@=Ya5vBNpEM$0Gx1RRMen8SmeVTOMpNYuK_>5u{Wg1?g zm39{YeKbvwn#EyV*#^364;u8+ctciVU2C|8k3=xCk(pQ=`an9+08FJgat5YG-KVra z{;eJdl?J7MbN>0P&B=VG#?sq|=2mK#EK#bRKxk$5-rLwXxOX;= zhbW&c)y1n$u*fDz6$U)F-EDN*k$OkYR1JK}^=*zg+VwGR1Dn|n0p5%5&I+AaP=y9*y@ z{mGL2RqE`QI|rm~fq(?*1LYJ2pig>T@5??zC-K|w46Hj|cvjfrzAhckWzqj)Mv$CZ z#gN%xII6IFuhea~{&YM#BOeED>W6eW876{G)s3V|h7*@&owq&+cv5?g{hsjJxUk_- zOg%YB?y_-q&JotzzgUlBFhkJ+_F z$a`K_7b;Gg#nrdx_C=ELn1$!&8e3VRixYMd0zF-1bGc}RO0KS)t5?LgUOh5(!CSk# zen5{8Z4`z1=4`1pn-N%cum((TbcDeY{z{;CU?AiI1oRq_33zL*Y}^A+aHn$xkR8<+ z2>Q06-lDpReM8opJVPG+-X02mPBH3Ai|GqtM*^r&Lql!aiHytWp=PZ5P{MikhkTiu zM_*EA2JfVW-S76fg}C>mi|ba<`6%I=iH0{ugQ&ZHXKjWgelT`6@FZaiU*_pblxqf* zjL#7n7#fN`m<_r=kX;viuNFd_R{Jsd_G_zGBH||Ci^(eDKEH5laWsCv@DwyOJnX$a zt@)2uMJW-e2W*qDKSC*@(9zK$753TZ`-DRAB7@i0`()AnQgK3a>koJg_JLg)KT2da zSPR>ake5T~wWZmYfG39z@2F)7TkcK*oy_Nxa)Yr4F!W8Jx*CM+we6jC!kEvWH(ei1 zXRGcKsnT4w?j5f*#$rFEAA2#w4c`f-0Kj^C(8%yes+Xth0oWAiRMV@a3dTNvfMbf2 z=3kL1PC`P0ZaF+W?0P)c(W`{>j)l^Dv$Vc&B&j2))YhgAc5?Ua+rzdK8dM>UC*N^6 zpf?2X=yfu#PrUG6sGLmOx3}AU{c5$ThpR;b^b*S^xoZY+uwl z%h7x@m#w0JfPn8WI+Roa<0ra0=!EtLpix&Qc^^pHjjGpm0BRZ-$Vp!WNlxjBt~hkS&g3*Hb4{VIpT1vhu>N0PD9n`dOIL}${Q(O5du~Y) zp92O9)3})Uq&*9Sk($X{4DzH={o;Za@AEf8ju%swIQsL-O6&kcLA*8;lYMBaa}|r_ zNUZaTkZ@Mp=`AA)5izmv#r!T@Z16o;MRoqYxGMZ+#Rqn=PZ{;0l%54NEY$J^N-E@i z(e2=Sb9{RWoB*|#x4?*zKONJ7j8Fl6TOyW5Rzn+C<8v-bKygTEdODDoyX{i&s7+&2 zj3BpeF&14N?G;)ydBElE=>Vc;6*)mdG&bx9_`FEBE( zK6F0i(fQ(7WR3SFL%_##beM=GocMMqh8hQ``n(nsyx$0GDsqx@SOW+UNo*2cpg*Iw zSVKB5AnqcP==xjBEI8x#`U2niqj$?qH8vsBLW}Y4pv&R+Vk@_|MXY$VNsR* z!v*}=k6H`Bb25Ix#^CJ$_QPfcs4m3?q6cPWNXHg(H#hZr4=VhGB_*f2oz91qe{|Uf zQv)rab7!U^-Qu@Eh3zGYf`Z&e9}9BVK4fL+tyJ96rB01i&op7gyD#SZmZh|;eeBB zYaSf``7<(|cS2apf=)<;1nEy~F1pI`5}TaA0qJih{%G5D8$3BR_aLu;bgtg*>H`0w zsVEJ=qSj8kzb7(EKLc>iTBB^K$s=}nx~8hm_b~ldEErq!eef!fevdxsWEE`ljcZZx zsQk^LlX5wd%GGqeHvoXQKg0jPisVI=^NV;#lq}^>`;;FH-o$aq(e(EPb|)tv z4EK%>2C*+4q+B%;z7Ura`~jH{KPkM{>=^b4nxHR-L?A=X8V~0KJP4T2>V*idJHB!SIb>Ah$?(Lz5<~rOrjg z7I3;dHZh@`Gh-If;^T9>{&S6z^Gm&_KW>j&Tj=i3`1q^iL_>>;ho-hR^EKy*)UtVf zsvo&L4%kDBN0{Ed%>d&Zc~SRJU+j+H;}5Lt0(vu{yBp)SO4HZ8O@RBHFEkViktxQZ z`;aJwcAMDj<$gBrr1JUAKP0KugdC=*ASDEP+6P!LzmW)SZ?7Drg9Q{I*{$C#!=d z5s6wlo~3O%KC{W8cR9rZRK}Z8gnk5bxw}v%U5o3V8EbyBzPw&LkW)WoF4$GW^1KGX z^}+x;lL4K8Ry7Br#nAQ@J08a|gDx)EIpIKR+4g>2TmipR3j*+AK+=sjv(k8<_jLwn zg$&(&Z{F*SIg_zv`V_XN20qV~qy~!&S_emw&gW{L`q$ZRi#vBF7}Hyr>k9A0g*-cl zSLEkY3$;M{D1d$zz!L%-lI!V&*g(_hai$%bRuRyJ1>YG_^GW?58$&_K{p$Zy3}8Sk z-YU7hI0$YG6rXJuZmX}e)+~pTyk9#2!olO#I|#>1wPMFF&f(!dK6N=6_!;+C7=`ZI z=g7prvpuE_QP40efIL=%mCG$Ai4tqCC0WcrLnkY|J`KFYwzaX%UuB1$Zvy#Fo*@tn zhp>UIs(2t{9yqy#fnmK`nG3N7!QgC%4VpuCw3mtGAhkMbxhx%r!bi#D5-P${_u{zrTM$BP;8rf}HNoLs%*NSHj6} ztY+ORLnDF;{A-aX5egdIMk4oFAAeGqjYM2TM8>pzGY?5!jD5mpoI}CG!zT;Z*3z=)upw$Fyrao``%X;bRrS#+h<*#P zJ0=7)z28-fXI4bJG?jCbc1ALEb&1le?NHR6&WW5`mm9PVW2>&f@4@+0ec_giZ31`I zwbk+0qJSs5F_Iyo&d4W206-#*VKm*xaWvcc%M}c>OCqv_m29g!IJ`b9VGF?DrV6fm z?GKEQ-^%RlY}UFbjNwuX5B*pSR~oG~O`(s`f@wJj%k>*$5>glhFw@!X^gyFRcqaq@ zHTtX=o%n^UG%^%o`n0yJGMCedSPDU}o#*(unf$(K6q6k9mAD4Xh%(?J+t?owby!{UoD}2wUWyqlBrTc0U5Ew z);px&-@n2a_*+5m^HkAR@5e_+03XM`iyA`@-NqRMu+nfOE*7?Ki(!DMxa8xd-ZlB3 z!KeqAM;(5FPgjDb%XF*ErsYrhlH+auH0A zyV2cWY@tQ1-^zJoZ{DM8u=ZCw)EIBduBx{3g@Bkozwg}<)IQ9f;)P2?ox?3}a2I=> z?c$qa&7!9UL;P+%&(K?Zq>pjU`*H1Ns}&msf0sA8-l5i9QB*c&u*=!mLLv zGdE5Z%B))&oJ^Rzx;x3Jj+9sYX>bN{bpS}+2Q!#v`)>+g$mMFlH@_eS&iM57R;M{m z7#GWvzd(iFI~}g9H0QE+VQ%od^{!JO0x{?NH8T^Gj(0$^Er=HCY6Pr-QwHPfriG`|hvuVfMZ^ z{(DY1B=3>wg6R+0mwazI(7){QK_JJ6l2X#}Y6Cx3k3>$Rx9VmXIONR$KIHryoL3uv z29RI3?aJ+<6zO)YmbXAHHvYC7AN4dQOH|0Uqs%EmOyyjcaS~*dmcX72{(xRR* z;%{l@g=}{Q?s(|O1!YkOpGe*(Q}&|K#f^Mxr0@2vC}3)F@#b((n+r&!FM<|fun_&Z zQt#_iE43;EIB}Ef{uc4f0$!T}aBpqTqW?y;yX~Dk7P~PVS&5(5xBRx5(dg8Pfqu-|>5snMSl= z;_dr+5D>5ruMoL_*KH1O1_dw`?=RHs3=}A*e7ePW`el^c=Hb=y1<&}U)5Hjsvc69u z&J7Y7Qa_^sHwtJ#L>Y8!&HVqm{~y3Amge0>d`4Lr%lkb2yL;1x*JOVlJlID}Nf3dH zENi{?fy=~Pyay0fj-cEV^v4`$S8r_wuvm8Inu1t%1U)WTZyjnf+R*c4uO>Isd%Z%& zet>oaiA!I9b#+bgR{qs+WF~2-GXd>hP_7_WvQmzU(NTiFcf*CUPgrxfPzCdEEuB=0 z>C6Y~HeOsl1TT>8nf{GCU!yX=Ah+ZCy_Sh7DC#UP9TSydr$b&aiLS;)b&^LRsk>yP zN(~w!y;WD- z0Np&eyU{iZ4bb;K_wJTUeIt%TCg8Q`c|h;8GV@aJ;<9dOr+V%q8Cj|z>QY@;RmF64 zGkw~5l8)NQNK4b;xN3~9QmesMce7MCfO-d_Z^I3*Nf@1`T<`W0NkYCNA{yb zB-b89o$ub93%=rX1Xy6}<%&cp`KZOWcxYEIu(~4qipm^`KM5m%t5b}sakZB&@Ame< z*WBp8m;FENoO63uSDr3rZ&;?)mkf7js0ZGC&l8PSlh6UTuivXd-*W}Jbx;@w0B8RR z&$>dsNP|jHg#2&Q*rVpVm7oJAjh+IraP$|I6*T}gd17$z^+riH`MuHX_9PHYjFn~m zvFlE2S)=XSp9ydHgj^mUa}6DR6k3f|V5Hq0X&g4)|#6Cr8VJl=>kkVz-yc0eDD z6x99fp4_=FyBS{6H_`%PE##h46c1Ubn^6&G0rtpIH8I>mikz+_K; zhoO{NT%Db?TYNg^>z3j#AKWLt+-P>4vVj+GPyJgWKGt$?K%_K+#4E(oljuIoOsK`o zT&pceQ$SOY*NDnDsD2^fU0qY7aY_mM{gK0ek%u`=`yU~SICK|@L;`r4kx?6mIA?x- zK1eZ|zL)+)k*BHtgUzCjpC+JDT^tP!HQgIRi;BdYRW5tm(Y+ z5F6nnGl%W+0z~X`6N);Hj!J+0e#FKaQ&Ur8N= zJ{7P_uZT#Tq%*>w5k8Mj`l-~bN=!t=$IIhUW3CA$#54hJkMPiNSt+@pzJVMX2Z*C1 z#L)$S(%WRIL|L!@cKL&o=T@w>ks*osK0vIm0lnU4rv!0KY;0`&Op|?mNshwWe0(&m z9$N&dDY3E9X>#fJ*X!TaMTGtMgtoD+@Xth@=1p*~OTg#daRK;2`ReSP&_>XVO-xPA02yBfETj&*bpQ5X8C3r{ z0)!5@Zw@x}eWou96-CR(1WdLX2)qi9nVo_ESC?4x_3yN}KBiSJYwHLw`I3rJwXaLWckT11~M$ zt3sB8;^N+%uvOIa|MNwUK4RU=9N6|7fY*?WjDU*mf4#~^G5wK+xJdAKp^jM6yQu#T zlE2@SuivO+B#y}V4h{w%EZjzgvbo_#GiUu?N{$P248wp!h_;s8(f%DKe;;$2>wxLc zk@wHH`RZNqtDE7Faod~U`Jggk-`ala`;1Phsqh`^xy?|t-Y}3JZ}1&!)tqfuGOf0G zKM(GA5G6NuN#4)YBcD?PYLSamo3*v#E2nf9kMZtfwM9US4cb zTMQWkB*~Ce^BWef$fBCa7w@>8kZ-UD+)U0=ruEl|t5#Qk0;)y!0ViiIKJE0R8Rn_{ zFC4a>zgf0_U)##SN2$>JKR4_9caeJDjpgOPFiLeAvfTQP&4%rh;!|P=#)K25V``)6C@z~>eOEIDlw ze2)M56OZV*@B@&!^LO9yp|id3r)f_hS!xQ1A>;lU2$&Y@aTChhBiv~4gPJQ?NI9r^ zC|O87pH_&AdtsJG!}*8i-@)M)$kF#!oSsaj;EK}e+C@RZ{)aD#VChix<3}@fo~{N4 z2Ii8IK)?mWCj-5|SGc4aT54SuKQh0ynd$qsxJ*jpcuw`=&HW1b=_Uc+0SR1>~MUQ42&oC*{+J3H%@D?C+w#H}9VO znL$=6S$V1h4P?YPo2E}V~$d+q<+osal^{e3^zvVne*OqU-! zT$U%FrFtDGFDu7lJ~LTc@9LhMU;}0#Dq9i5-!kWajVEw-JkIvLPYw;_Qtm6EXq_rU zH;1dfF@O8EIh?ls0jhqmc+!3E11qpetmpb!3;lY|+sNr^Z_x!VjBtH@dT2M|Nvj^} zq>T3j`zhZEDFQK`=(jnXCnx}TPiNb)!liumdW;NK!60PqK(#0WIz*;Lflp=WVX!+O z|9PO;7RkO3ZK|Xc`gY85(6pyRReAPT$?rc@v=i;ux3yWsd7-*)UTon&EbM z=J_Gw#nc%d3$&L`q8T`iJ=RYCdb!BTS+gvJzvVa6fMg^-+?%Phsmmn&x;;dyfluPB zt}S7POct~!j*G@~1rlctInFP;RuQ&oIxRD`yH%_0UL=@xnfRLy*mHkN*yZ!a7nUVC7dcsOXE0&lB{E*?covD#gKRqooGxM1P#8R5r`~BS9Ea&k_tPhj6+{(2yF4pvYVt_sM zNE-VCm&Kz;nZlX=*C((zyz^I2!b`~~dto4>+)P|rx~J2>Qiafc7_Ob_rxbs*AwcAdF6CwkD__n0W^Qlr0S z94DV19TNHk$NGv#kXG4{t+7!~#-rJ;L;gWmv(}oO{=^*aT}MkD6)89Hv39$lQd6T} z-x7$`f>A6Ms7J!qrv`;x<>IJIvMrUf#?W8TLe`A4no9UApXGMRSEd=}`H7 zJ-Irklncx!X#%NquJ7O1<+0WHZ+RY#o^vZ+YON+du)>gci+OMnsq+yQkn2aFa!$eD z4POi>BC9inHE1H*->aApxwwf?D+hnV_S-h>pXhwWP+-t;g%JqsdR0y*BU7V;lEJMM zUKNxq$@_SA`XB$mC+7O5q_nlWhYB9w*4WNb^BFA%FZ3gws^}nsuIAq9(d<0H`Ti>T z*IfUd$*;uRNn3JztL`yitfPH^*5{WuR$!a>8a=$@Y5bZaUs7NGwdm#J(Q|~p z4Oyzow+_hZiN#EBOTc$T%o;`IH{f;a`&E;Ms&LaiaD-QnVJV)33`Brw?s=;#^Rg&&56Z0FW#-O>Y7jq z#>Tat{$5}+bbI9!BR%UH^ul+_=fi?5y7h6Pz4{`MfoLfpkmVtJ_5COW@{PjT28MjA0%zzX20J2 zobawZ`_OT-w&c9M19jegV4BB<9E$5tD7)CCNId@Nc?Ie8`_ZcYuCA`E;TyW1qazz; zxI%aZh3r@JXT%wy-L>VAC}~#A){FRp1`d*gEqJrDP^AB_YufYDjJf7me~CzHk$L`| z@?>o^cZR-61g5qNC7GFXV z7mKk%u=06{33+VIRYcb3j(?GxUmo~{pm?lrWw6KUxQ(fex{Qs;n+eJUR$J#Ic6&7Q zuleTO_9Jg_wiU5jOIPZ|y!G7bc0f5bk&S$!m}X|Pnf2$g8!D1Mahs*KvygOYKIy5f z1l;)1JZa1xcDmfaT^hze!R0pAx{%r*q{%DUu)O@(siwLxes-*@!lKB9Ynb9ui+d8e z9$!m;4T6@`97pUcf#FEK$@SQN#JE`QJnfCgehm!_S(#Y0(0 z@_{;wZZys#pw{WY;B`f0eR&H+#%tqknbd(mOWHLw#7xU~y&4eu&JOGG6L_uraSpvQ zw`#E#?EB;&l8@FJB)+~RB*{6Qoqz%nj0nz*PWL&9PJ_V)^uUUxwCJ%12!E5PcqmXR z=l=fP*475-3utsE71i;g+ZxECIXOwQ#J65r z>3gZ~YjW1gs1AqER^}p)&&|dY;$lnnn*yvS zkp1EDthRp1y}NOF`{DE5YfAq+(Gx$uV#Ng05PB{4DOv(5Ec zMPSV6F!o|gzF#`jscH-?ZZulEqvKrG>l8hG#T0={<_L*!)x~yS zK$7x@FR@s19&02Hj7=Ll9Z~To7bhsyfXjwms^2~fSMtm0x&4lE^Na?qqh)}mFY}IE ziQHd!*E8JP-%H2BD3*Oi47o-caE`#P?Gcs*Q)i{XL%q~!ABFF#lut>S!xx*dc*DuX z*D=r@_yEjDAM%RDe&H}gU<7DWw51(UL5$t+m)k(AeRuudjo2aV`=ci|tr|6AcHZrs{&`#ufyweZS0l4`5y;4$2%z z)Z$e#MJulPTm%J=%gx0>E9z?5NAccyt1pV4oznR9Ogx#Ai-|TzoCf#RKzwQ@t&@htu_J>&Acs{r$%Txt{z-+vH+HaA$mM0ccrhRusi8Q-TXmIDabC8(dQr9XR<727fye)7Y>$TNNl1uyzk2V&FHk6 zVX-+&ma3EEdDdVTeb5UQYL2#*_b(lsRP0eyfK3Z6fXwNl$h;jWjf#UUV-8RCVxf4qb zQ`4toaB~-PcUSW;G!RZ}aZ)zX!pXlKRaA*eNO~npfz1@%5Z96#6OUTA+mS2 zR&_}~rI<?ulGg^H0iGm9{PPr;j^SCTnyZ`hVhmIFA zw&86->?CILckRcI;k=C);*H4Ghby)Kqav7|SE*DU}X1Z$; zg?LwsE1fkw+I4&MPWRK#S~P`z#VCqY8CO@oHH{~2!i*1)6Ft!cj_lF8H@c#u>I_ig zSrXBEG`;_E~2Xm979Jlcz>{AE7~4TT335h_H9c7H?))N;h0z6u!q>{EIGetqo>%1~#rIrI{260GHvIxX+feG4RBP$$cwR}WNM%h3eA6Jf1@S^`V>jzyDUVOy#jZET z{f<87u;kdWGK*q9Q|XJxOpeK1nn>DB-k+g$>P#+qbyv7zz`jw_iD#x%DB4O7lP^ma zpKs$IGQMLec5a9S1hm;V9S&759?QULQB}WeDJ^XA_3yOWvOxaJnS=2o-B5Y=o$h~n zeV(g{)UWaJK?%OYnaakCzeWR)h}$A3bnUp25&<#gv2*`9)NL~eya?gezHn}EM^Wmg zj!RPGR~=OeZdxk1qYlMkKIE-mPL9waWbY0*2vSmJs=_97*G7ZLxevvrO$FMcK~vvM z;T4SWw)N5v!Xu`s*_$UQx@Qmkt*^N4U(-@7lvmtq6kI{^snqsk5I|_VmXyXi$L?i* z%Y1L62ZslsH>7B7v3~Ua;{54^e?_7zIK;yGIxL0$`SD#)H$BS*+yQ<`6Cv8De!v4M z9JtJ{{?1lVG5wf}fKc3DNAUL$gS8^xInmD4e1c1RjHkN7ihwrj6=}(C3TDe;V0mW_ zCyCCd+Z6uTkEwm4+DK3`tGG~-(%ZFNI88*oT;i>u42r_@>9 z&;LdSz(Lm$Nx9-jjqrSpcpUy)}cw6zslluv&P?hkr5;ilyn2RC@wl@#F1gts5))ccs?Vn0nji70Ol#wh~XFqK_L zZV+o11XqNM?)pZ_P)N7H(-to;k{zi82~Qu!yL~c`h(ED;V=D^%F`3_;+QXeZEwE%_ z-ISiPewnvo!+pVU%wOdj-nl)l*)n~INYOIP-q-tBt7#~a#qvX#rI~qj;H!A4NW{UF z`l?QMFf+Q~dJv*rsnNud_b#2kJn%{C<$DP7XlJI?d5*ktQS^ZXW-8YZsSdTncbZb! z7R19WGebLJT`tw)gFzDRWh zR=_+A@{1XH>BJ%8Nm-JY8&2(6e_1Bqm$t7J$s9R-cXsct{Cc?;EPiVQO2{OCyKKE5 zww3;NTzjdx$i)C;7#Sn%Pp2Stwn(J1LqfK~-oQ5wJPM*zJumpFEeUt5vKWAFoPwrC zUq1Al;myEI&3H3L=JPUlS98(p!XnmAPXE$R>mCR5EAGiMmE2LAHIOn@&NJe}ZP<5h z-OR>Uh}`-Vo9aw|k-!yRzt~J=BObhTDm{mc+(IS5C=l98tMqVeX7Yu14qbV3dT_yY z-9o9TI^jQxs41li3{TChZG_~d#-WMF;VLGGWuQc3C(!WEE4}9*5KA5a5 z{LI8d^-WpKiUQCgSHPIb&T(uv7mp3i&Fk^nYj)j~$?^MqjYC%WVgs>wFOq_<4?{1B zq3LOWn$2I!!qyj4gCwMALJvA#YHQ5$GX4r{y|)2nVPQ0Rpwj1JKYr(!#vGg{vzWYj zj;YJTz|YwDM9|gEuTzzqcE9X;E232iKf596(9WA>>owtr!}W_#({cwmFb|#8!X&1> z29X_##U^@E3u}fe)$mSlg1B}5Q`YTX5e5%alTeOD_>uZ#CfD!?Q>s}(K4*k+&SI{F5aJP7`z@tAO(FvU@WL}GRBm5EI0&i&SO?Y_u@{8y#A z=LRR6f8I8cp$iypsz``E#pJyGY~l-snl`70^eWDw;77Sc@a6Lj5Ya2ioXYa-xjTYD z{IEhsx)@?lverxh{)}fbd@LHt8Y5#PJSKx98RPU1vBV#o*dH`f$jF4`Y-Vp`B&Z3R z;hM-n*+%DatTh;Pz34T{p#p7{+gw?nB5j|5cHI=*j#<-mvK%P#Y}Z|eZG*P2gB7Yqt*2Y>6RaN`H>l7uOql9dv~c^bQLW} zJ{?9HX?rK5;w1LivbiQt?i~X?lXvB-OP)kC+|qUV=j{h&RhZKiX|`55T_MWCGYIdZ zH&3*Aj$qPFw*lG7-0S%s+!Gtd`O7InkF91(oW@S6w(z1~$a}El{xrPu%2iKKowV?D zWC+RKYw)c(i4fH`UAm&d!^$Ywd8Rt*+P&y3_-I^M?q*V6KQvZcQobxYdu{cI>E>~K zh$e!xJrE>HjpoHm(i(@wOq;MR<1HDrOMFFju)9o2~ai_%VQ*9q!W{Buw+AEMBo-G%-DdKFjr0WJbA zaj-2{s%Rx<$z&~VK{2i?U7p}hD`L!bG*xn$RqpW^t-G|P{GKkAcUPVhy>6i{e@#qL za5MJnNa?!xCm*)@@l@p`7~+iRGR`hZ{lmw)z1RLxpKo=ld)9~3GJS=jEAt1}1t z2>wcDynfqiVr7@OmYPyn>J5w*0c+V50)`JjiZYM$YV5#tV8Eiug97?WENV0~l!zBk z1_*!n-g|;wWa*d?C#|Ouv?L(^(id_)T`^6^xA_(lKt|}Xw;!(jfo-erJs+#ok)Hi^iLT)8o%g_Co#|T%ze2tULJq*_?xSE1c3!6~LYS&b`+7=d> zeX&q>t^)8Ia}tSXg3C9Nfwd*H}nrMH31JwbZ@k0m40=%ihAbpniB> zaWtC6$rLWjlz)<5YPgo&p^XkPlUG!HNuq#s4S<;S@H$v8)SB(o@^3Mj$01fxQ@=${ z@*v;j)&l{C@COS0oe^s7qAr9bf9`gIr-k9sJLq(cP)gg#D=MO05Ta>naey4>g!O@V z%8?$?qwk75^o){OgRe%M?VS!Hs$nPlxSyDV7P)2XYQ|VHa~r)385!x0_9zQYB5vQLemkbt)&qS{w|- z^LX^h(KIbD9uVpyCXrr= z!=#-|EBHPqEBtmRp&W??nn*eCt{L9?@roGIm(GYzPAyXg{p`o$pS{!Xo}Y|+MrZ0n zQTu5&VPUc{tK=B^{Nh+b+I~N46BaMz3RkwIr?QA`w)2?g#_Gg9q(8=yRH8&9t?#T( z`muPN6{Dq7RNnQ?@Numqn`i$Ht@jMTr|2O+$*4ZT?j;;aa4R0LQ18BiM%&j?%V9AaU*ty!wG-!@ zZ+6B^$MN2}U>Fz<4}Ju5@S)hN!0iyLYXK>HIXBvj?%WfB-(}wM202Zt63r)Fj-X=V z(!BNtY~eBm3UNvm@5co>aCs%IcaQtOcfAI9iq5|OTtS6oGz zoX02Sg2<^sUEL=wgGlLM2pqe=t9`e&l_01DTl~p(A5#v*d>M8?+ByomPl-9hmnKY= zY%nU%2tmFZ@5w9SO)st5p7NcQx}h<0NsEUz55s-;#wO{p8W7d;{o+d{)v3y>6uLY$ zF>=Axo+B>GIsv+q-eFUrEm3xn{`k`m4JqnkJh85HW?s@Pby76>=S}|E5h=O~_{1p2 zLq{8-?Sbn#JDW|2ZJbN1h*wQxhBL?q%~C zW{roLr0U;=WgVvt9p~q|kefOv5)_peS&F~w_82BvW1is?d7b^G#kspOo7doqNqZg- z$%^nK@Yrb=hEtyVu@EKxszJP~>&A2^5ha&h(BeGo$6J?|D2z9vs}fdeF|Bu0I(gj3 zM}A&*XED)Ff$YwPbD^(#raXXbfe^-pYE^As*HQJ}8g|bu;<&{htCyqWf~#mB3LPH$ z+uV31yu0M2+uFZ6?L+x1RFvxS4JUKeIYA?I7R>eeH~)uiA}VrwiASn)Y8`}Qn#VEm zh?(x)%{nyw>|mkDtujP<^8Tln>J9pffq@+Jw1@oM(j)9q4hgDCI!YQEr&yuKQ;*&+G1DzDK=#?=ZJi_b2u{Cx zB0AL?@l2S)xf?mn*4rV!t+#avpH(grAxi7(S<|KE0tBgYKHcLK8g`Vj2vr4FsWX!uToIQZJ@%Y8@7-xN8rn3+1m=A^n||m{%hfM>CS}iIYsT92y08 z|E-}+N_ihFpPDQ^2?Ff!_(nks=or45f*8eAz6I9h7?E^6ro5Z7&b=K{Z{C*?w(+*_ z@==lFIw;ABv2DI>Lb&s+8}E~?;l8Ov=@^8;;pCbZOf{KsBIEC>Ld*itX2~`C5O?0BQm{Te9T9dk;7$! zmQUSB_IDeEGvhle!g5N564}m}j*Na4_Z$-^=?{E9h)`0Ia=N_?%Qr_~02WsgQGO~2 zf3K5#8Romr&JdY#{3`D2e2Y&~O>b9l5r2hAb`3d?^F4irJ>U?t8dn2tb;fY$Syukx z&dH^88T>F|3|ub z>-~<)_`Ljj%fDvSHJhex>f|TScq+neC>Ta^*jQj_Nt`cjUNb1>5`;)=`{y2iyn56% zq|@p8X}rCRagVA=&0D0YbSsFOBW|nUXo|QMP2quzxJ3-IyEwCgh{omQIjBM;tVGu} zA%7TtiP)$$15!xk`*5Je?}9(EIDb-$U|D28**+cA@)IU}Dsn5&U#&^3$jC$A2k0yA#1t8?MTzP9e+D~uL}br9$B22?==WnonOQJlhrE2VV<;hs z#*!9B#>mppvW3`AbIy^xV>C{D-h{C@hSVv}+tc@hRBR`Ot6vqs#F>_5$Hl<1k^N3? z;=aV>a5mp5d5h~pWJ>)fyt|^<`FEoSB>^>kDz~39hZ9tLv*c6kJfqUK-y4Hle}9mH z2SsJVUcImKc4$_$=F0Yqu}-{pR#DOBYx5_n?^VmB(s-Rmo~WoPg=F8%Nh$awtQ{zT z+P6mzp)!B4vMx_CI7;R_+Ho!Xl2>grwl5nu31z-vP&cGR`QhZZ`&;P`$n^9WDRoyb z#&;z}zS;$0TI3U!DO8j7N^wF|FZlZdEvT`yan*bz)`{`@;%2|vb;G>KL>pDI1u+vg zg6eMN%<$mH>*)SZIDdRhYOJwdPN0!ai&s1X@mj%V88w9!#^MNn2$ zR@&}S7urcs&9)pCaw=-xejIBt!_JL~#gX%N$YLdf*xTEmA1>c<*Ss9iDiD8~!_$<1 z*73}NrBc;gdE&zCK%vNX<{ldH+eYZmeV2fcZ!`RbYCjKR9YASTUW(IA6dXy~tLQ@72Vy==iRwzrE{7&Es z)>*~d*eIRnmy#c-Jjr+EO4bSW`^b<-aE9G+e1eda5p$*I$B=Px+*Q=w@0~7xIOy?A z$2o4&v-2rp$+qs`{degWo};q_TLvg9QW-`s)7bH+U&l>_ZRn~X#FL_m3qE{}ont z&H@)$70bG{@9C_gDTFGtL9X{z8;s0Pr?V6?w*1@*GZI}GYU?)Fjp=MnRKn|~F3`Vv zXtc`y7Q4jj&aevtywg((_FL-Th%Yv3DQEV8VN?vJCA?H^{qq^yuH$~_bq+YaLl4N8cis{Fb{4h5(gIyx-`+D)bIFR2r=$LpP*RAF zgYVR+X3Qt015v%T;Pq3DTgFmTo@5~~Qg(6)5TcLm{4JE=!vY~;HE1u=H-7`Mcr^W{ zZ@KK*_fpd55m4)2uj9eOx&S&aIUYz4NK+g@Z83k%Qm9>xE#B3;PAyN%_XkS3kaS#| zOXtnPvP(!gs1P}(dN(GK8ESS1s%z4!TkWH=@1AD!jNj0-mwU`9a!5j$@#?sxDOw;{ zxgW+_8dzurqD)ZbB1ag}64Z6^;pdg2--*{>u}vbAGP~BIIo|v=v5_YPSYxmI7MgruFr9_1(IR!Xd^+N0 z$IFn&vaR{SIu>|^6YcM^7WZ3^Pt99q3R6>@cEi3l*@!)}ySj~kh z85i-&&V}NNV07pQ6q$Bybd@z~fx=(X=XvP%%MiYq?D`LH*|=GDr26N2CsnmWLRI&L z&|}*gdviWX%u8jS^L;R>d0~zZ_&0?_6^E4=9Ft4= zL|7pNA{O-7)`fUZV9KSG&DTJ-TjsN9RKBRZWwLTXl(usK1{D^G1Or?4?AQ@wO^0A6 zAPaBq3-PBdl4U(BU1`lY?rZ&kI5#4%&oKMy|Kt~XRp)ZJ$9q2#c8_O$qQMn3%>df z&`BtJNx4;rmgV11@F5aG;C1?n)^_g3;DQOajB|*b3E>2C-A`hUTc{%|3dEA-9{3vp z^@9AqrmzH^_o)tdqh@1)O=C*E(`CqhqGUFt+ki?+Qw6Z_SBGRx`O$5BnKwJ4>|hY z8yBu~_(}iMdg$ot{j<8>Z-0Op$-~PFF=x4QRHA+xYpx9G=qhnNSiD6wmDTf(*I3n= z_y#j@rwe+TPVLTukgZ4~(KrUWW2=2c?nO-kv&ya4m!pJq*Zt0zD&Qf0h9)H{tOA$y z_#Tx(S=wf`fgmD&%^(V+AYaUk+5P;1i9=QzZ{hr@_$|)3pUi?8g?Iz{333I3OsWAa(1(uqwt~V^m=`klx=}pri_24^e z#0xIkszNRuwU(})&anMbMC4R%aW(h8!7Hpsn$h2KOW2_w7z)QS99Ij3E~Dq z5?P}qEUP%u5iZTIMc>+Hr2=5%M5r=Pp#c4r`cV_XhRh4zS46!wRDF4k+j@F(ljJ>R z5#MwA=HcHWxZ!CKaXeok)qYc&yPM*STn-unGkgo8qIxHT9U(j~>jb|ptxXr~Ij#BpCLZ2=ZN_PvZ8Di|Vzs2*>$ zkv}6W6S7g$@j1@a0(*cIKjx4VsKE)+QnU{i+t(A!U9Rz>ZMq3~;d>S@E}T?&FEjk6 zR%4K9&s;_+_|0AigD!!^ysxACN9(bhY(7+u6N@*8f@ueX@%Yg4*2ZM+0r!)3!e+I< zpQp)~wFt-6pE@BAfg-z5YuTK^(yFh(l z#d3+Eku;Y^3MijzR1j;m6|PnQX9;A+CGO-1W}|D{WjE}a71=TWMnCKcDizhOO!M*V z0AG-KO;9%~K|#|JBIh?Y8OQD5Hy}a_YeChaLq1D=sF77~r*&aTm@z`kJl*0H4KG>( zW$pG}OQC*&KwFSOHq@K0>_|2IAm2+)Q!8t$HWjv3Ife)DxTdr8zY1QLUFrN8Q#qrR z)Hfa*G-BepTJDcn1g z>P!QJJZ>&zOQ$Tl^VJBpk=A3hMEr+}?>pm+fbRQ27YqpVpL#utO^jb=XiX2ZcBtde zLgf0eO41WUNntx2iidd_`>FA@h3A9}?n-pj=4ZV?c!};Gd%sfVPngQ+!77)E=jBVVXV_Q^k&^af6dXxteU3bfG~@nLeKq0QkJV#?*HJPKa$) zhn7Gssb$dJiFZ;HSjy?>8J7Rd|2`5#pHyoRX73spi$85ki%DcC`#?n_uswP^m$LQ6 zVa!}eL#$0AZ@J^9EJ9h;l~rzmP(=^MP;)+!cY~q+=>fl|eU{;UF~P4f>Yu44a(U%d z5AgB$Jqs(=M$^i?au0bOFFVhEY}cllyN87hUJz#A*GZI3aj+zNiS&7yRVYn(Hi+SH zPY8~IV*@WFBh2U)Uoes4*<+d|q6ew&KOQx(nctA~?P3t~yeyDe?+{Ldr#vO3xW-Tt zM9){Lo=Cb)Qn0ZlZpMi|O!wMTO5(7cf+`wJBY6GC9=VKVFlxi+0ONskIK|&rK@Fo663(2v>7(jNXZBQ=aIVXBkL8eb7_Mu zeEGK=g$;g<0?e=6AU{T73(|7xp~Opymwm;Wh~6h}v05CGY~AS$fB?cLx_R(55@X#~em4m=@t9)QSxoD-4G5`AduXNb;ek!g2E2l@HdYpa&b1u|;`LD$m z_H;ej%bSG9E>t;)Wh+^7aJ#Qi*jSKZ$bys_Fh)XL zq`z&W?}`5T+Y@o{k@Od$glOBEQOcpMnzZzLtAH=;AM(i=wjlYcsNg7Q5oPYld3wP_YvkT>cNbztcNN0=l2OFd{ez0Mx z3Lm^vQ>o97q`BJI=CI}^BW|~(0GfNIQ5*6lS8GsL0m)=<%F65ms{+c!g>m`IE?6w6 z1*eD6g~CIgAc2kNV>5ija75q4M9gu%qo>>|lKRtDB^5snGsA9RbFC0hjoN(il`(L$ z&@L>LY0z9Bg$!)axm%LqBnc8#GGY?HdcW?SC>z+PZH?MxGOA!Fh=cTt>YpH!)cOZs zc>9f|*NTExGA*maP;)Yv#|j_1X=n`hpW{dVvmaMMM|{ZKGCs6~N&9vF*^)(F;;P(DVwf zqb_%l)3gDI6sdO&Y$T#@RqdEeESnQ(@Fp0$qw*G?AN|o);U=GKrAN#6#V%S>|4l~# zad>{q;Lq0Xn^4jM}~CYQxZ6S8z1+nIXjw(nwIyxb9uB@kMDK?l)bZ?FNVZsCQnws`N#tW!5kTSipA+ZEYzBh7S|^y zTU*sgg8p$Nx%%DBY>kDgP)`E&xZ0{Olhr}iC+ts&w~jH_!U;2IzWSC1Cd0O^zg;8Q zc*US>t3Ve-IN9h+hEmT*ChTRM^n7p#!Uhx`*z)GF-3m7kS@0Ymm%)RZ+b{*=8D}|> z3+#(66j>tv$O7Baz2t&MLG<;5c)K(~x?|eJlW6{@t!;reU|U+Xg(pf5kpoJ)9#(2j z(fI0meNpX)5GdK$R@F z()Z;rdgH}IAz_5DYJ_Sv8*2^EEwoc08zotO>vSj!i+Ev*#|x<=7@yPIe+Z{f1zVLN4sYAMg?QCPC z!4)klD=(i=kAahTSx&Nsj#5Z!ru;BfGj6t}%I){{B-r!+l*{!QmQ>1VU(i4MbvNok z3b$AdRDS6%5YM|qGrt6?ycLtuN~?rq9~|5sV_E4?q4D&-39~GT(G8?boi3CZ%*shO zZrUayvBzuzbQ${Y2htTQ+fn)bIv>d{`u^tHcN#D2d_U%iT9zifU%SH}e|1=?tOu0( z7+9^8K~vrgNvZvI8t4R2ecr=B9yia93>_h9S`^T)r9vOH<};w$bJk{c|zbfYy5DlH7 z<17pBE0!ng&8KU$yq{=e!msK`wWc*FQjUB#la$z+#_Xgk^Vv;yBEI{9+UKdpn(!K8MpDu!3dqX(I-k)X6Sf@bdpHywLb_akI=;5pVfhi{4YikBkClQ%fe!5H87RxH z@6Tl@ztPH+kJr;&U0i~+?E~ltND2+= z;xU<-Sq{CUy#^ur}Uo>EP{z?}4(J8mA>g~awsqT1>@R+Amh_Bd`IYirQe5F6t+Xh$r{ zU_|3Z-Q(N~Hq6prQg1 z1|%-tc5g|06Kqadp?#ZtF-5FaRnWiM%Zf22ixo1(dy3ukPrynq=7Lli#6vMKt5;oagkY*p`StWV?Ea8**x7Sb4)2YgQXVa)ZzJTw% zX()`kh)XBU=m{4L%Djay#Zcp=iDYgLMBP%Js&o9%EpUqt6_Ic~MnccebiFyfXK|w; zHzDVZoxebs+I+$K^2KLQv1d#tt0}vVbAAtUK82vCn!;YDHvFwAr z)sbyrf62aJ`nQmPE;=j@Dy?!n7L-?Sl)JeBP))hydJ*-`0**s*q0+qaT@m&1BQiEp zroE|(-l0EbPF1=$AWcC!7=f&R%Zw(u!~>PD3>a8LWy$@i3v9~gLIT@BF>gftGZH=mV{#(fdmk(Lm zz*%p|{wRh{(Z^(h_CN|<%Ch_r&aOM9-_W9rw(_}c1p?lq=rcYd)mB7xWUR|l8bOT7t)-V@ag#-y7MsRM$FT4vfd)RNWG z0IoEn<9W?#r<`({o+8VfKoyGIP20wFJ>z6r;a**kl4<1yP@(fHWolxlhLXOG%XW95 z`dO~u-s7UzHyHXhtpP@e-%+)BYX}K2!pv(t-%B2HvF!rH0ORpv^QcSLzkJI)93*=e z2wMq`(OC_-*OrzdCa-bB#Nb`_PqFs4+oqO2heC^ewztT}N;SKCx-ur34Xo=;`JT9h zaG+7Pl@~}ysXH(;@@1ISM`4BYmU5^1NA~)SH;;rUW`hOa9&vni_b*1B&VyV!Sb zNdPB}UE+lNHtW9T(OfdQB?Zg9>?bhNsSsGul%TsqN7QP1W1)I69Z|w+cszqu8HO3( zcwU_}or4w@YY+ds-*r1d*a_x=vbLcWi$ zAVNHsEF_$+(|qP$G2h2n?u#;xz(U24zFyB@OhjP>jf74ZCvM1zNu!fFo)Af=kH>qwc0Eb&JkBMkY z^!Ikt6rkayNdAG!Uq_~p-Xt+0-qlclBZ1*PSZXBmrM3Q|%(M@i9b(z(YWk7IpADU` ztx|$!W2H%65oF16aAJ?hg6^iB1PupJbybp)s-1k5+Wj%^GY^H0o#pz(tnBf!Mn=cc z!}xPp=L+kaZv3)K-@a_G9Ema8F8;j4T5!?JVJ$7{E_Erlglh9UQn{fQA0w*WF`YD? zP>r;f5QNs~wh~Q%ewLc9n|Ri78s=y?kg-8(rE6egQoiPhwx@!Gt+Sq33}Caw;erMH zzLOwu-}M=f(p%ee^T9|Eg}ng@Io^kmj)uJY2n+XIcCWmQBKp(zSBq1PuOuGvXw^!) zdLznG2Bwt)lU*KVeAYT$n=IaAb<+T-{g=jhgH}}6Da7u@>x_DYhH_Xs_caDj3pW{w z$8Qd)3#}4GlExmLy3;UC8f`q}dc^6`Gfw+6)Zmx>(^V#U*#{#^y*CvX=UrUXl_Uu0 ze67FtL^nQ3xn3vGAl2LIdPTXi#&!r)xBDqIl__@AR5IS%+Sk{QVChX`li)Cs+&|!v z^JYGqVlil9Ds)NvCHgC5yf4Qpz@J0Kjf{I{V>mx|gtDgF1Yc<=%IGQN&{X&KLoRhX|;|LlhVFZfDs(NA_ zhuLAWyO-C+#3!GAN%OCBPI0t(Bbts+3C;Q*Q2%xHYnFTJ{$-&;*%m|1ksg$Q^4>@< zWi}bkQBEEEHAXhfDeuv?x6?nA@PW`El?AX zej00Mbv%_G3Psug;d(A{ziaDXK1r2?UyUQCtR%E1=5!sbS~(*k?@j5C;Z9ztr0J+;`1d|ht(M(>&5**b%W2^rGS=Us6@R~Yco(xR-FXyPmJ(QPAi&-y*^b~Xx@~rP?n>?@mRw}h8!7) z0{&Im=v)1t8C%2_wiPt2AkkYQOnRA|Nbl$5pd&hr$9H^|eu8Acu*6ery{lMA%?r8k zOrtBn*6Naoco0>s3yQu~61q?;Q+{YqXYk{n1o@a0bbXKRPD#?YNcJ7LAlY~2pXo*( zEVM8*OWtnogDlt2k46*)D|s#d2+GX&&Nddp-KqbX?VHk@AP1xF^}RGD2;>CQmn?wq z042-#INtjSbi_P2y2#RUPjHu-r_tbnG@mj;39}LuMyiQz&Fuec)e_V-R#Um$;`hGm z_^kE#W9!gh3@D`5{atn+RC1=>{8pCKqZzBeV{u7Z!4Emv9-c?7NS#gX9hPRA74gOG zF3YRAjxTow*}bmCHMU>6OI$e98)CmrzU``UhogApkV+61kxo$`A&<#PeIED!oI{4XT)RqBy-V^*939eSML-P%M4&X0NkGXg0J}A<#W-NCy$n&b?9> zzIh_=6ckf&%QrRTC@pr0c6yI8$>Cdo_$lj~_JS4R`=#dO44I5#mN!+~q@un>v*;^X zt0q=yYiJQi%LOuF$WlH<>;(CcFzG z7T9GDm9y-6@%9B7OBl7FBMq6!z=1#<^Q}-tRA#Kbd4)Y|(ZrjpvC3Ot^Eg*&xd1c| zl=FQ1f|7)y`uePDytmlP!A33v^L|=JQ3fU7GseO@+)ggNv63M5u!c9?;B-80>Oh)N z@byq-A;$32*fRII-Dl4k-K=^LM~DopFBvoXZf>b})tyA?kmEL~GpnE>6A~y5?I7`TWx>jRu~9|S>@`*y9fH=; zl+>kFRS1gu2B(Yi3qJqo_q|7{4uOrgLatf_`AT;iQLj4Atx4OwskjDT)B2GuL928% zm*!vopE@;|R4FwVCf%1Zrk7mAV0y!FfAf9YHt2L-S$bAz#Pvsj$06~$bzUzUs?QdB z`#m)A!M@A$6tkjP4ri;>%(R~P&1;Y0pTB$s0rDva<}dyL&2I0-V+TA!FJc)!C`+%w zjAhif-@jT(i{{jgYoRk>2K(~u_X+WGdte?y(kF>f-B$un?nr|JBsHf?nTz1c_O`Zt zSg6$p08-D(v+kL$J0qc3*rxrF?H_hC6QCwssJLA$kban2-LkruLy^f`#uo1F~&JMX<57phggKIjn_YCyqK4x3DfHKT* z62B1j_}a>)pCiM-w&`#v)q4O9bw^Sd!+HK6?ZY-(Z_3!!gcjn9KO{= zU-;2-p4;-~lUMm4A(g#6nD;r`^4e!#1ynAa0$Kq%cgF4ztK|+L(|dhy!h~de6b{%g zOkEDOTWy|qbxF37s)1$B-KyW!q_OSyOE+8{^nQ%Hjq^6I!Q2(t#IIo`ttay3E>lFq zuP;PPWa1}Ql^BO;aNHL!>ntPh6RG}5(Kn$p0sk0Z@jYhszJ&Bo04xN+lg-yQMoJ8+ zAU!PlSeHffbtb+Keny$>rArr_Cf*pWcx3GOUw^nt7aAk|{P_^nHL+s*X)Um&LX4=r zgib$x%Sb+ghOF|GzcVX264brMqOXFEvRWn1WW@qwUXdkW>10JEZq?aZ%{xvl$P^9BrVfD9+&)fII z9;>$C3rouQ2z`8}M{K%Cz#dm$bFIhbO5(3< z|AXoSilY+LKuEqqnPZTmS8yQ}J>pGSx#hx6?DQhYmpLT5Z2HYhg{vItEpVRchKy%l zZBf8|u{D=#b}K?94}DehleX>4%B^`|>)^TFntreU`78h{9+2PZst$yVTrKi@&9eS% zJ{o?Kk(7#D8QbWVe_sNvp;(s#C2O-=%hl2foDzEkirOY<9OEl?Q65`x*!Hoc1_B{W=*1x#`O7 z_np~C8)IzF=m;^t&E@ru3qPQnVwO7Gk7YE{GXs@rZEb6&Z_Mp4fVzGE!UY&O3}!tj z?-gokc2-9a7oKYC6o_kF=CEpLZO>g2dg!5ho=>jpWb@oGCbQf>%s(OPH0D!GT+Ela z_)nm!^zo=h{C!``!mBV)V-=7XNnS#^^jMlM=STX;c(%A>5>8GoP=}~5v(5f=4_aj| zwv;V)*;Xm5F(=Yu}%z*-sfI7-4jMhTIWCsL41XMLs zlN)nc?&a(f@M0Ah?t}c`AoYv3H49b20y;TlrlwhUhJiC^&4QZ8B~gny#MCqsc#GY_ zX?S89t?e$c4n)mc6s5-wJl8h%7bccA7VuU{RhC0b3`gYn%c~1MXq{|Lz@oo&bCr>+ zjuDGwDANNMt(&)ji0^4(>QK&ZI&)`_tnA0`4khz!=5~)0aR<*A-l{gy-=5R6v4OxA zg^gutZ9X>(Itx}nw+>MRaqy^>1IZE2itBbRjT%|pF}Ad)y@!XyIaLK)^>CiO;X|hj zUu9HZ)A&l8m}m7`CSGR}eA{tG7JbnwpWnBnY+`xYq)%0LTR!-s7b64Db%L;zYpYH| z3|Lh+Gb>rgw*~(2q$ueyAr{}Q)wT$t{r#2CAM2ko7cE+4S22k_dUy^E|M1*WT5V23 z11Fd=DjqIg*|xB#I5`MI*(V>a zMhb0va)a{c5QSA{N0+C{!C&G6%LBvGz1&5rbu2@QZzg{0y2fGJDA}ck`5N=Qjw>Tq zJGWikOgghD+y-S3Z;I#lr_R;NF}vlHIr{W3_SNHC5MRXm1QM&W>4iVjKt9Db zUyfe=nR)#F9sw_VL4JNMt;^E~OMXSE>Hx7tA+On(e~fM3fF@hTFtC1oyK8qyb7S;_(6*pcV)@8fXRodIl5=W$;G9? z@N9b!obe~};=b?(_a^K2E0bkGkQc}@?pJ27yDkWamhCwW2)GtQe6-(dh+YvxGl%BC`V?1X?hF} zH~+49fcFOXj`vvM6>%70i$bz+ThGY9Y6YK<@bBxbIsJWl>hUvp6@T$-7m?rV>Cbof z2TDnAIL!q~jp6k_|MTJRzj4WtqF3%QN(V>M5hQ%M`=7@C{_;1Os?*%Z8$$$tqu0d4 zTky<^zk6O|_PwZVr2I6+)w>C2Xl&R$}!nEiJ92 zW<-R|mW`L8=-Yh`o~MG0TrjBwy|D=a&$|?HPF8I_Z3@aE9qlq{3;n;Qhlcx-)C~Z) zshYltot7?OB+RKUPjV(bt;{0VeAFxj1OU+D;{tr;?sjPf1x-0Y75YO<{r!HqhwlIq z=U-$sq+CRRt>#dR@IOPV@$Ppg3)ygw(_VD_YOo#6a9^3-HNb&K$|;l{rYNIkAF*BZ zx}MY?1R#chXn_>Rq;KRkk~J+7qySi{W};(Y$u37Tf*)1_=$Jv`fK7aQLiT5_93~FH zA^e}101r@m~%Qm^3vI5KfJGC!CglL>L1FG_x89yqrS@3KoB{<2+D2I!bU`Tig zSoN}Rs!yBG(@F>F3)aKLrMFgLYyI|#!Lefh<q$E=I}_$SP^YccP-e z&Oc9>e@K0sP0jGAZxbpdR@F2VFumIw0~w>zk1wMTMH%pliZSkQG?e=Yegk2mqT70e&aLnNCtoET7VFE#`D>bo4drOEQvM#Uy;{&it!r=gS|ab!wlCe5 zVYQEu5TzYiZ=L$~Q?$DI^+Hos(=(c;Iv;qi8X4KbzY{@!vv)?t*#4o7Y~7xtD4)k3;WnMX;j8MA_gtv%qqmo$?!CuxNKGUjiiOH?l{O>3`TIL zxHgjC^Ma|z7o?vN75T{7XQbz47ZeyTFFf_xg9Fr-Q<~u|R`!(9tdm7h?aJlTUM*nP z+}W{_cuUn4Y$oKQ zywwR+KoWs*QD39Wrv;NNhq=p=zT?NKfvK-0jJZHAt8OJ3n}Uu`h>LpRpZUf6%1rU? z`8Ni&vBqq7Ny$rj#Lw^n1x3?Ww(G_#!kKJV^EdnM50Vlro7vnySh56O9<+ztNzGx( zS9^<%jcK(uoj#=r^PksF5kF4~F~0ydiJgsENjZd-jk$k-FPblypdohj+4fDYGFKP+ zWLu>13ysmPximCj3I06y5b!KPY)KvMg070N$cpq?I7#+UxaYggU#NS(ZR{OYFY?6>3@2}t;D7H@x!e~ zIaOw1qARM{>v+TjLUbXxp~kVRYhmSep~>|ZGTi|}@E<^OU?XYmD|-S>4KO(U^UQ1M zV#5h8+JiJdUa|;idUaWdX#azg*f2HM>1~{rHS{39?dVq56NHm9U zNvPj4Vwy0%SKAv%M@h6-BH-Bb&c6l0TuQ8_yd8e~M*k0hnODCvT4t&zt*z`Gn^l%2 zx_S0r5v~%;t?vJcbf|CkB|j4lsIB3;>>!>B#sa^Bees-QZV*q4+njRSq z>JWRnt_mrcEipy~hWXcK=Wiqej;YwF2V(d0^O-o7U%-ww7P?x-yW@x#OwGT)`F|`>I*`o;N>hALCXiM>`y?(KH&Av!lF=q!7+S;L-6cl^FeuoSos7WqjC?@F z_+Rxg7&m@7V6Mg==5vW!%l`)6*VLPXbT8P5C%j2}Q2DNI?HsaIvN%;j8UTZ&ty$$dzgZ zN_sKA&^iM*sdiYD&_nUUYZSPk!sH8o6O+%lc&-HAdq9BK`(~E=(qVc@$wM|~EoteN zj!Gg--2}Uw|6dxz|N`e6uJr)>yroihx>pq@9C0@5=t37 z$wj@?=xQ1L`B028Du#L~-r)CY7@jz<=K8K!yw#y+bK5Pl$gzyAk-ZZV_I z;mrpfp??r?AVL>}wQy!=5&3uxe#HMUBR@ZYS5;#)3@|JFZ3HjaDv_4`1(^3PUtVVV z2Bq|aczCSagMjBk%iXvy0ItBZk%=;_Pm2)%5rY#y?Ctd1pBg1scNa}f0Tg2Fdu`CO zd!$^dLMfM`Pujes3746wO`2kOHIr`ZPQbsv1!T%```5q(UTg&TCDd64*E7F# z^U@}^gQZnqkjpDLEbm1EYAqpe2Wl~AHa1&nzMd_ALyF_}hewUyb^s5}pKFk~E4JRG z?~gCwuK;mfV3}VdP}$D^DNAYU1YlM4$(&D1P4M##x+pZYw35dwKNtyz?8YkFu(Gmc zy~ULt(>OR$jU+)e-IcGyO9ftE*m!7e_Cdg0Hag#gfw8S(p;Y+@WuH>u%pWY2kMmp&Ib)$!|HHt3K3<8BilFa+ZH32A`~5M*)cA}`j7qpx9((P0QxCm9 zUeMy?MB;;?J+_6Ge5PSt;39Arfg3+yeKhc@YqP^T-`dM(hZ1rUm74A?-~6s~r!8at z7>mKtj2(YQM=3PcEoL24Ax>&+wHe~uuXeaNEv@4YqOOy0w2!>M2d509(w--$~1CGlN%hCQA!x>anCJJL?^cJMPZI+l;v zfF4?2{ zUzU=#ab2c$34^g)!#ri*#u^C84SYu~X-~h_!CIwGO3){Nx>rwTUGbD!OLM5fVS`!> zcgCsSdS{yAbd$p`caQ3|uW^FHoeH-jjX|LOp9+ok_Iq}~MYTNpm{`GyF6!ePbWreBLzLNa9?rGvi zMj6U9?`&gDl1r*>QAS5w2W`v!T%=8VUl;n?=uIV@rRiht3sx(XZ2vggn(pF!`lq_v zc|-Y$z9c1;JnrCDYpPwYz`|cB^;2!@uyZ`65L>)iE ztKxCgla=ns4vzYhz#iYAzc2CMH+J6_gZ(vI$pQq^oo@&=x z-2TUR=S^t4r+A}%V`gsNpUlv2S5o-JKYRh;_8<3}jLdI*rq169?13H)kmE?b@g1my z6542_AKbWhit*Fps<2%yS)>kXeBB|Kp7p=om~ox$G_7v!kREddkU90#UScz8UtY2)8|g*wd`um4=?0S0X(b|IY)ve%eMZj(i@Kl!$y-xGcAp*=Wg3P2?|AK)EnO3NUS+>MJ}wCQC1<51jhcsry+{+iOK2(I)zx*K_}U^7 z>X4FG>f!4OZt?fn`g((+t@ppyD{LopQ!G?mmzI}H;u0qi3sT$^An&WEryWPAU+l3Wc8FkM5bS7+-)=fW z0lOx6ggZk(cZWD|fEm0ol;bo7ibW(OB!pxs5c|zKr=Z%Q=-|#8HbU*A1D`z-oX0>+ z*HC;4>I_k2qK2DM#x5j4FyqNn@P(sbKkTyKCZA~WxBb=#D4GPij|&P8y2B6>^s~qZ zJ+kGu+@rC*21jC-khm_S1tl&IaUc(yL)LF&kHU{W?CeU@V$zlU)a+_;{W=1A00CAs^aH*_c19@-*w_kTvjgLLoLqbqq3_L?sg`snqV zOC~WYcG{eQ9Eg)SutVviY&Tpb`IXpX8N>&kVBY??+94QTK!{r;f_&@lFLvsHoQ6eU z*39d70#8q0l%of5JMPEmb#hrya5fx00y!J%!S0i57wHsip^I=m*}0`5p{?B0+n6IL zUE^5Xm@;N81@(BnyRt4R>6&;|?oJ2JPx-K@K`d{k`6xd^=+Du5ILO>rZFP2MA-Xc z)`yfgrp`9EADa=_*Dl7a7b5(;yw(Vi2qZkJK25K>{B|Aa)fXV5q^)IorXTg z8hX^16uYih^so&wRL>W}MNvrT@hkyt^aO`6Ze#uPeRN9?MqR=fMH(X70r6DMSy09u zcjx{Jz#`)%(5HOHK+&oPsbnPds!)iejSt&W; ztNay~^|Q$De>b_$7hMsDy~R5RfAmJ>){pz^jG8q^^arNu66*@}{T4NU%Thxz zts}2#p&GBv_-5M&e=R4n)dsojs=vcw?IHbJ=Eqx8xen`r@ybu?_xeL&VdlwRa@cQ# zMRw4@B;F2hKO@f$ZWhW-YJ(V4tqR2flk+$K?V9Q8q{RO9rSm2)50A2MTi2LR7(HacJaR;^hkS zpX7+)2DW|H_0)osF5M2jT#yX=Y!?KeUW=)JvkIp zFu_8JJ8_4`c9@bcLQs1M#MxFQt`B!ox3+)`3QIU&6rP?oF8L*!{72?un27(|y4qsp z8||Gb3K!a`QqhqJc1X3+Zd1URjoWTg8WG9$ttdiw#D0?f&kjjiznuo{%59a!ZJ&`I zbfdJWE?Z7sUP9vCSjrUi6tZq^ja6Wt7QNHcJm=^pH|er(OEQU*sNU@=f?|5#`tu?E z&d`$^Kw_NqHsGtBaNrIC_3RO)zmgzcW5DyuAJx`gvhCR-ggmQ1*7ZYjDT`nxxq4a= z?Yiv1yl!5;;_ao)ey8@Vdt$q4y?c>WOZceO*xPOUe=WBe^b#@d@+_EcA%6ZRy(8MP zr0qVb(Hi{$HnT}-KyXyD#B&Or{1Op;DSO7;c=ciR=FtT9^#gCleFqr#G+X7ATl-aU z&x{mwlNfei3}swhXWZh3Qpb$ofYn34@5Zy0TbGU*NWnF>Kv8s@(o7MHwAiifT%6bP z#I)P8fxQ8Gh`RuRJwxCMAh^T!qGRMSrv2CW;X3q{)6YM?fZ)rgi!}eM!uTPc#*nAF zvlv=*@7&QGrS$RU)c!s#`iGI*Cm3mf7$!Ef{*Ze6q_+pBPk&3aKE7vJHs1+lpF=&3 zIl`fqq4kI5#pOv?_2w44XyPp5kVYm^T ze~x}}J?X_Qa`@)xme?cf*C5E=7J{D3d)1Sv{=o~sJ|rhwa5pO9w-iTEiN?z^#<~^( zOsH_Z6FWd9B;9mIa2THByTzOtmMr=fReLT-`sxuk?L4%cp9T zw+i$STZui_|Iaxm#$oAJz~{WeYALdZLjTw3p8xph3M;TrV-bWqD*KQe>uv{WH&1>U;RB2Z^mW26&1q{vzM~gDfKAzVkPH^i()w& zT$9GyB6D^dj6_Fz`^N?=9^d#_%ifOnrZh2%khGMHD~oGWBfg+0Ls#8J^bgbe6t(o;HW%_ z_peqY)_o+V@j9r7vemo6^d3-!KyVe1Xx5YL^!$?L#TG-aJ<-{kp~m6vWb5tI>Q_u& zg6B<%15L?6tpA@O_jo^gIJD zqT=)CfrIU}rEMH`n-dH=W7ERuO%&9)BVkW3*XY8Ct3>J({Fx22ZPo~}U4N)Mm7X2J zyGV=L=T+h8at#)$$wM0h32R^Di5%uU^vXmE61O%`67103)K{aD(Op4Ql4qh;>Rl;T zY&D-bREbQE=ER$^S;`P^L3jT2#qExu^mXmd@KZg~#<Y%thecoonP_CfYF&{X)`K6B$4;kKb z;l0WH#?aj=itU1;N+YrOFo6E;&4NxVS#6}jV13I z?UYbI0%FHq?utAJhs5OBlcBa^X?#&_XA7Svjgh$i&27w~y2@p|#I8h}l`0%7)ObR& zV-IpXoU;A0zT#nL)-vtsu(|2hPGC#@0DN|?`OCBO853ScNh7-21rV?D>pi`E9GF3A zg-u$Mod=GOc=#B|$JF-+IE0U;VAdR0f{e#YKu;2v2XBE=+^xAK$+~H`qpR~pBh4b>6SaFpVhoxRc z?p`icwNJ%*bFlJroy9Tf`nEe;1BiKFglb(CVmED_*TBht@(a~wLfl=^OQv`~#yVvK zuUB(JSne!H9p={2Qx(7urx04z@-8#I-I;6R=S$Gc&dbKi=9!&M^~Ui0qz1e8W@upI zWYz3eghor;OWy%%u`@_V#9vR{4t^YEexU2da}ZTGP89gQuY-ct*01L3ArW7wqqzas zGg>LGiB+tp650|aPbLkv;Tz{`^uLR9I`FDhua?(&D{@ai!wyc?*A}M2*lH!0Z%3Po zeznK3?%ncIWlV^V!r9lMwSKLXA82{Lt@}>H$N^D)eh<%q*I6yqcx8pA!a>{bFxNNm z6%&PWS!;7uTOanrUtq{o&b`FiSbH7pVGE{8d+`x|idgUPkUaMG6)B2%!G&Klvj${W z!J7RVPcg5sDAayCm@VQIfoBhDYq6S` za!=Z*DQ z`HmL5C9mN})|f;==|TlBH_p_b^*RfNX4gChuX}ZK3?fa?o^m$s&{qz-w42##8s+4O za18mX!9tb?J(ppR)w~leEg_Nd3GsJDS)!mXN;Nurx}u%m79_E<-uihDv~>CTpPd2I zMm4WdmP5lv_=@*T&DU;6lW)J>6f09VTzRzoC?ba;zP!1q*voTMw|eX-Bl-fKxd0=X zAQhY*$H#{3{J8^m1m9Q}YlmUtzJ~LA~b~kr+xjxuX$@j zhi2+M=`+TAMQTJ1sm`dH-!t%CX4BDZsv<9Z!<#up9(tUN(1#y>*h*H6^gu0T&({0) zpjWI5=UWF2wom0*+Rrz*L-)VEfZc}I)Wx))UW>n=dHFURATAwRE&Uv{iUiUz~cF=)LnZzDG_{J|5B$O>Cop2>q$R<#WOOX zt{xV@P}e(_!C~8rLdTwK`BATYc*S3H!uqepdH=Vs`ptfLGu-F`@b^|9b*HQwmV54w z00jk~#_7R=y@SFxwsfGXlHovc@S9S>%iPaMy&;~$u>wai#@(pl4*M~uF}5MAb4eU! zYG!nTEy5P8^G`m}%AXz|AEG2|DOp8DzQuQ<;Bv57mchNP^j)b;-wpa8`nwGi|87Gm z`ABiOllk**R1PbL(cNE9c_xOZDfPx|CI2%=F0DglYa6cuPk&W7&?k4%6I|ccSGb|& z4;uC@X^KO1Z*Sn3Lv#SdbVh99Uh|S8XXv-{(LfyG4K@yt_-dLFm6Qrebu8hzY+Xm55?P%uO+5bNXSdHq<&UxVJrF-dB)T)>sHknMMEG`i(mT!v zfOSUERy^-hS7!&#*j14+?;0L|hd@rRDoU+etqz`=DUTK7ZrxZ;@We7Oc;No}G}N+ouQJcz9Ogol3FGEPCwlYC)lw544bFX6h(Cf6^xD z^1z$FO$+>gn-*a&*4vB9<0#fgu&!oCGFV!9?iA3V8`t&&DYY4;xV0NA3_8sRoYL!a zHcepv-i^9K-U~RCjapu!Y*)!he*nw*Jn6P(ExQY!eVw$h*z&=(;6`{Vp(=KRFYf@c z=O8ZEY_zz#After>y@cB#6lh~mHn0-Z=6Z~2;Tm|aW)(+t*Dyk`|SAQ)TXv-=IXxw z;=S9^I;gj)j&O~a=<>a=Fc1`yxe|LDx|lyQv$9^)G72QN|12 zIoJPq4t9U`ycB!QDSH$5;x8app-w12RZ+0yBI+>$6+5!YAk61Z*iHgHCIWFf2zohN zOh8~5}48f>)nIm;e zvHUpgi0f}T^@b4a%^Gc(y~k(uBy+!mLvc}fRh0fC)QT@8k%IEm1nY>w%bO3u^7tV@ zqMV%tmgSqM*Z(|AOa)#dm{6kMDTF#yI9nV$pPMS}6_z@pP!+?UpzJjr`JBDS1cz&( zK9sQi7`tQvb=j4N_@1`fW{zk25wn0U5Z@_*E*iFMkPkA4>-M?3;Ola zDe+6ny_Dp;@plE{P+;j%4hs8ys;uE^f2Vk_G7g@HE-{qT8V^^6Yn?BywByTev zC{=GVmXLN@^=t@0(mpIV|6J;n9eS3JjfCfJq^vyVRj|um>e##*ls2RYTif_fm0m!ai@Fuy~!kzM*TqCPjRV@=yaaXH7UZYkc zFXByGJZfo=+Wr-@xS`l;6#wKlAs1e^9ffX9%%Kg{781g;kU7$>n#`uJ00Mi{*lCEp z6~xb~-9OlU@s3?;-OdN0xguW!8`N4s@o83MJ;rIHaIyjy@6!Q{Ob+bVY((O}x6|Cm z#F(OSm$A{_Ss!)-)tKkcl(6$5F?z^DYhpGrl*Zljb=la5Dau$@_R%}~MN|aq*bR0Q zOHu5hhH&*w7W>RzxPPuN0;4`~#VqQ<7YSP`%pXa!@R7uRxP%hZlbNxt+ZfKX$NiW) zrT;CpKlzASKmL*T%ATgXmo$L0&vj;qalcxjytgc0lXSK=_m3}tl0#mjZd8|(PsGh) z#2I$xKprW}A@8AQ$2aVUnP7q-5*eec)S+V+X$~_x z-I4Xa8J-Ce1e)2p(Hi@RHBZDDD%`FZ5dLecqV;G+Oz{loI1 zHU#iKIj^ED3?w9+WA(Ec2!9JR@#zia8_6MzJyh9c`+>nM9BaF+w%)k#>BdAyr@Q)9|R%D%-}ws#uwG88n53R=8F@{+ko|1EBgGwr2MU zz=7DSE?R)E#*3Hza72Z^KHr@*FDy#!_vuC>@ikE;hI%mlFQFSBzhn_)v*V6K~9ty=WH@P?svy)|JiQUk!j&;>6@eeXBM0(kl6~1Nj`RMNQ z3Nd+?QaIz$6+S~3k;uQqllhFCn*h)v=cP=SatXtiyK8wi-0laDA?0m*mr7O_l4EHi z<7#cJ3}ax@ElQu;B|dxxfp}n)b6#@>P>Y#D^Gp+`6Q)}M=XU$wu9<+u5P}-@(v}j7 z1orxzz3*RN>snXn>)bSpYDwN?y+g>^!N}+Hw)fO_L~GBSbGg!Pf`_w|sZu^LaXz}W zdz~_(F4e`%>80M;q%{dSZ#jF!5T91^u715&=pryYRl0T@e;FStE=VhiXiY0x#hPSs zH(4Wmcg^BfLms$&zA`IE)Ef4RseiCS-;7|<&3L_}J*k6p`=$N~ z>)%@Z`=2ed#J~|+rnTt*Zq~xUHNNY~M-N|Powp%sIf>*7j1j)X#W|)rhcqUlMXA+! zB}vIC3};35Rz)_QN^9zNeHNIffjO#i{`%1^YkF0$uRIuK?i(F882dsq!uUvH_NA$@ z(aB2M_rhXyj4euC5M@HM98~>j@bLl|Y2^(So(%53O~oAHoeIR2?nPS11EV#y zduD^_XAm0UlDzujx*S^_1BnUK5!^K)&AE`6v5?nejRqWOrn}+MBpJS*dfMB&$h-fA zKmTi3e>^mwqYRLL{Ur!_%@X@V^QyVLdaOlCE47;~V}g=4HS zsM*4bv3ClkxSIoKi2BrO&rjK5ggb z)*?FP=*jTEM_LH)5pIV-O3$Pz=d1K&@(I?*Ut+M!n-ucbKZZi?!Piwuh`rhSuBGMq zU64b0z54n|aEEKnmQb0b4kD<`zOmJIdVApF#dODN==kc_+03R2-M*UGUarBj*>Xd_ zUof;Q#cZaUu2z8|`C#sDB^o`G{P$p5iS+w&2(x$yaOgLNFv(iv%dGVb0QGUlS1QCb znGCKC-zEo`DiEvi(atWPS~7!W?}a5qV&J)EY~W_E)Y(Mr*JySP?F53571M0ZvWq?>0DtqxQdF zwS27N;&-WRcIOqLIBqPoxN8&-Fx!RN|1|Yk2VG z?uBRC+wC9VXijQZ*iBlG@de7RwYtbvNZ%uuQ%FQEj67)Tiu+7E?5`y+o0dw$;8(36 zt(Q~kp8GJhiF4=wcD7oJ%*az`9hHo73cFvbN-WLa5UpU1-+DV;SKVQ)LOZMyeF4~Y z_Vp^I!wSrSqio9FU^9%H{x4nT^Qsf05jWWL7vy!K9Q^Tu^$YAPpSm<2KK59u^?Gv| zvhP0Mw?ciFg~LA}=K=~y-^W>Q7uqO#o>&A*)>WH;#ogrD z-!Sg1%kTqLG8|8zeaWwAnO)lrC>+q+aPDP=`P>i4w6wvhxp~DjTZ60ozxKW$LjMfy z_3|+VmjKClD++vG{r5rnW9fD|(yyD@6hJN3`N?~|2fbwW!7vu1MT0?$8~nY(Ti8Af zCs~mgE!`;6HPxMr#a_5p%uwRUo-|JU{H4RTC2)nxquH>w(bq2eXcr_tm}t2#+Vo)F z=xDa6P{X?luw~N~(woXmNi`^(&{b5_CQ!tAxgh7Jo@j~Q618^9tZgdH#CW$Tjtg{K z9PPXYIY{ayoc%OrpC@;uWu~K({0Zj@wJ&e%vPJ2PUum+gt*N!62M@p=+q#-c#LMK& zc_%8U-z|99ShM8T8a6S$q( zq`ll>+i>Q&;P>c@^^U!2T)<6azi)!TwJJnCGc{v9Vf5a{uTqXH6toDVCgh$Z%a)49 z>qbft?CMt8UET z%UZR1LALfg$YXtBZI1gU-&rjYV-H>awr_A8nrW@pSoEw_BEi-GU0uJamtfh8O-Wbu zT#QJu+{O&d`CqH!??-DuXwmJ8dWc#K#Gzq~o}D&V;QZ5)JO^J&_KU4;UZ=R?0?)$HSZxSdNCzZOK(LUkfI z=#(^+FOi3gibWJrlW^MeCOVbx=So@je7_v{bZ6CMS3)sGxYc8QgbDw3Mt{Bh3>I`& z8U0_1jPLe89Lm4n{nN9H;?v*Ow?oG6y6`;7wrbm}TXDa`Gr&rd^6SJR8|UG#%SqZw z4R+#*Mz_Ehq5qL%1m(WH`fJNp{$I+2vhLaf=bgE*kjC`>_Ou6@wmcFXF#Q_rd%B0< zyuaR$zK`L*a`!mE{tJ$F8%x}Vw*N=Rbol$^27?>16> zTW4qn>=YuCd^!Ix5QJT!_2A|5a4t>#4|T0W9&+iy0IEq_~a#n~8f0y5iH@nB8isPRq{dB|O_3Fr%$ z#dBGBTdS?O_kM7nQPSjTgT|r!m$`mo*l0d>FVRkj!}!wIw%duL3&v#2InlYwWK3jE zP1@K7y)hG%H}vdIiHso2O9tn49nG~$He)Gyy#~mm_HL%pl8Mkxo( z3smO5l6NTzY~%8ov-U9wY)of>c9tb7b$N%XruSGgoj+YIU%{e!MtkZVi5UDtBLWfT zJh|i^Iv82TqaIw$z+gOoPSu`2QR1j+SV1_8r@o4qJUfRO$ha5o$gfj-xEE^er27bo z*GFS&ty<9A-iX*0<}IW&OSs4LR$CpuHufExC6aL8(pms@<}ddEm`YI=7Ik;O(?LU4 ztui1TqUGh`)bGorhy}q}wlh_ckbJkq$~68ri9&AL_7!oq4L#t_z4M=+wLC$nIHljQ<{{x;j=->MIe$ zXCd1hMEhEDIo#Pi7_x|JTn!yN0oV&UEYlJL%gpOeKlQSE4nQQ!o;BH(=Iw6y-;{Nv z6?itii@n;`mD>Vphs+Au>q)puP~lOd10SHBM_VCN#mRZ zCj0whIBCsGRDa=wpI9FEqxSHJJO2+-&K7`cv?UzPB5?``Csd%N#pw=dhsZZ*$>8DB zvpVYsVQwcgwP*ict;)E66KkJWxdp`df&8xo&{&Uc6KH--^YBZo!?n@G;M2{sX}M}2 z*Q<KJawM^pZPS6@*iJo?`mN0K*jGW_J?a*9b~qIi_5{(hpQ*(b?)u{ ziX6h!kEWFe9?X3mU6x*5jmLcAjMrbmo&eTzXc<5VdV}!}7LO*-jIpG64r`wnc9vf! z(((S^^SfZ;Pl3M#n9mITZ!G>&nj&$@&^>v?i(0F~!^9E|vUXj>05ssp-$ILF*D7CS2Qt4|9T=4XbXiGh?uR9mB3_n}mh0B+h3PM_)uhH7 zhX>y3h@Z$c9t|7cn(-~DmLh1e_xhO%P`fWN_t6Sa4;PWw79t^rMCHRaS#B<;|<9D@UNd9$p zu4grOHw8*1I?Cc%=$q99d0P}wmW1n@t|EJcY$BoDBp?V^Vm^x*%i}pgV(Dx~m8NkI7QoJ0AiAGK;{&5@2KU()ObyPJIXWZF<|B=^ zA5@l%l1R*+-4eQQsslmkXv0H7ybQtXYi$#Hft8@bXT?nEWSjHXN?|kKFx}O%dQQd% z!-!xn*cwM^=pyoOl$^#*_IfPx6`H;~Pzc2F$u_CBYemUoj~GV;gCEf!(+ra*sk2)ij$_N(1L3Q&z!G0{%Y$G`GUymtWkE8Rlb z5VL1b}w%E z%()l9XHifH&PRlm{^(e#UAHeyXiyxKE>dYKqF0hv;ar#f^e$RU$T@IKAN$HgYAZ;? ztx0b51-7^@AlZ=z7ZOky8Ty6TP%hxCk&uWvEYB0RpcZ2)uZJ3@e2uU^j9f8G8{b&3 z!I0^EN|$yV_$9$2xMRqX9yHN2mo}4>n;J=#;T8DHB7P$>yalXnK_LrlixFR86&YL) zicBIBF8y}s_Mq--P^M$;BXw?VFTgIu+xAL}E$=#IuyU*;Cx442mDo)^G?Q2zGCF-z z`_ad)V8(46N}_Sc0OU3TRgQ<^M#s+^Yxx#>{tjn;9urkEtKrD%K7xMy3e9Zyj{ z+vCw%XL>-?D`@g<;pB-NGVn{!N%yTUY#~(jtGSmCkS)xFAsZSgv5q~ta&@)q5KAPX za3zXYNLbu{h%fu$FfDpzD4PVCt2-PuSuegG>@hh}=k6iye>Lrv-Wzl!^bshK@Z z$L}Mya9F>V+>~b3Q0^(zmkQ{<4VjTmg8B$(*pDPhuyU@G(0B26&TU?O4lzuF#q}p~ zpS4hAjn{o4;r5}SUo*=L=U{?@5h~4rh3<5=ROQf3ZXM$K@Z+)Joy{P-5kB?c36^s1 z8pCv60dtv95Z)=&^v`~=*Aja{*>j-~#38jomqU0RtG?oZ5JI-}3TTV=( z#LKr_u>5?|a=UW}3RQmFcX6+Ee}Esr(Y9f`%lBKiO@{H$KmytG*4m?NQ{3MohtKsroQtfi zdiH(zhj4T9K1nl(Fvmd23|$iy2?qAi(;PabGL`z=c}YZbExfYdA~fRWqtCHWF$>eq znrT?IO{i~7%+0FL@e}amDR=LUM;^&{GF6a5c~y#tgmi%0LGTkj{Y30$Wq zq7gC(1HuR0+ve2?jwlCDqOP)cH%eMbLt!7&3R>G?D63V&{x(f+b%+Q_Ox1mjnx&_ zMPT=Jr8OuO810*m`HbWKq>;#Qxb4GX^A~pA1To{Qj6zO`vbsv;)3$yE8kKL;?+T6x z)M7I@;}}Tnt^+T+ti&W1eMWUZbG)>n^qXV%AYz?+j@f-FV>PK6VSnNCEw(FHF}`uY zd9aNQM3Y<;EP| z;^{dwluHUjz%R8B7MH&*oB5{WDr#p#!6n9IcBwU`q0Ga#cyEA0!Z1<`aYH1t#7p<7 zqq<6+hx_nTF=KBy3uS$Qb{mjQw17o(;LX#0254Rnp!1h-lhj$4Rcj&@Z(ba$OKTlZ zfaM5IidueDbX#FjL~ga6O!2v_ZVaWwyxY19OX-WeA?;MAEjj!o-saE|O3%-mJ;e-m zrM*^-DTR$^R326tn31YXMGU)BhV;=yu;b4ni?U{OWTbiNNTS~7!=T>)GFuL7D!;gW z)%*a9^Koj{VbYL`VwrCxgXQ}Qh%RCx8C@+n%mCS2=&&H{#vjB2@wb%96GmGj9ddbw9qU~uk^iZex z->UVDjuK&PG{Dre^*Pnx>O6aS6o)$#tj%$R+PF$-nCJE@G+$GrV-Kb#!Z5EWDww{I z{AlPm9ta}WR8A|^8Mn@rbH&IksdZT1^>jm<=(msfcOoi%wi)(YKlBIakS_`A+E_4cgUzkshKpIAC%#7yB@c3;!CjN(WpQMG%Yes$LKbf%p z=KX)}{9MqV(z{r5o3=r}89)g*q2(3gNbrmH}Q$(##bLDy{6}iRP49OPW#>>fJ;sGxDx7 zBedyl9!esjVlK~|!g?xN*)?z)xN-uw7b<8yazDK?Y>un^oOyAV>&O3)KfPzmEBi?@GB}`c@_JM z3j3*LiL%dw*3U)k-@+U0DsIop!|()r`d@t-IOABC$$r|ugYS2TpW9OnbyS19IA-Z8 zbz~ATnI{md5Gm&;jN^Q^uYHub-2o&mKkCSG!}$2z!S|n(okP=$*(EUgJjOMmwWE%$6~``I~?HRJ~oxR4+rPH)Kta<{{|sxfBXZP#?4)p zemKDGV-K&sBJM6zk$&<_1?vwyNSzq?pfQ?NWtuZVG+`Tit$0g@pzVP?TOMeR5L*Pl zi+BipC);*Wffih=0^Ntvm_@yY&iFm|q)VzUzZl~G;R^JN&1e50s|u=k`}-m@-u}A^ z@u30Zh7;8HS2)ruXx=7MiFW>?8a=vGv-rWXbMzle~&=tWtV=?hF{UP)nX=w}We3|IV4E(f(g@gyZOX!(0q)y`rQRw49apdo?jLP4Bk{ zuF62lY=)f$U$k(IwYPsmK-AX{z!kdg{@TuNPPNCkD?Q=mCBt}lFK6UvX!!tae*>-< z|GPITSKH3`|4DgXJ^K4e|D5shwMAkW^1Baz>!Ba?C@?L^!E}7=74;Z!^gGX zu@bjV(k4)w4{D8#pRSf-=9`VZ_+A$6%sYf4Xwk;0=!FaW_?K&X0i4Q@Wv(kj&efL> z@8~9!1Mb8QR<$d^-}_ZSUjQIL{8l*7?sZ305gDLU0~SL|_DdUlFvnrh-5m0*@d@eS zM2B;ZsDMoE;7Y`}8$BUj5K(E-EPZuND=~r?_;Bh*y8TKrgW^Su`9i`J^n|WoipuRy zj1X*>fo@UvLat$hco>e0Cedt9Eg#AbIo?D52=Z9;``RNIx9B`)3I|iiucr95mQClJ zU$zfl3-hY!s}k5kDyZ`4>6W(W*=MBOlV+Gc?u3l&H6&By7ufhpjwdyW*-?va zbtpU29^J|j<{t1VM~G1Z#&k{MHsk=J62sN>Aln(aJd#y+Tpz?KP4)6j`A1Sy-wM^4 zIqqY6ru|SXgN83uAaul!eA$lf6tNHa#Sad@)p3oMPF~Aen0uk-%!2_5*snAgv<`4# z5gPXesww10_rzCfIE9OM8Uy+hzrS1W!fl+!%t6D!K+KC%L0*xD>%RJsls&VwbE@BX z7+58Ck+MTDz*i$0M&7%l{4!7yHb`pTU0b1x8^ep)?5QTc4XtlwQAUQ6>HX)Io5c(e z-+>s8y*%?ve{Y?VmH*)aKp3`)A8uKC#D+-Sil-cj)oOS#5}a1da?Q1;#vw%oX$@0- zomhUvgy;L$`lw^CwsaGD6+|9B6>e%M7mJf4%`qQHkd!wxg}cVooJBT3*=-QVyCt!i zUxhl~+fm~uV+}>t+FX~{hq3@E{U2}i%V{> zy<-Z{Kr!Hx*a3;S%Ebjq{!CzWq0$s@;Q3BSrTOs_c$il)GlT20U47x~+W=7kx|Uya zF4({xpGfoEqfIv=V2qGW?HIRRhg@A!ZQvKIeW17stx-(+8z}gI+GeUlN#(-biFn&T zjt4_LZ+H3HHE5Cd3*578`^p9)TfxU}KC5@#fEaaXQTqn89#SYRFDGBaoKk#p7%%_`XmG4v&s>&A?d@T{KreZ(># z)g^q~7DWKNOF)+EBBScSbHpdSgIYV(EJJRWM4-Z+TXs~Mpu3&Q0Vo4g+9d3msN-O~ z^9Jd5Va~Ztv-D27+jykRM6<|{O+ga1Hon=Mavdvrs=3wUS-3VM&~Vem6Y-=x38v&H zMr4vn5B(80xjW+O6eQqM$OsUCtW0yP6XRwJ_O`YL#a9o?iurK}KxV4+2J;jV0 z7|PQczNB$fD};`a`+jy7W(|GnwbH@c>>Yn)@nM66G~XhiC^k>gSS82^u#NkBOgRyz zp%GS-$Cw$#aR+sh<~=$KxPD0vo4zjIH7EitHET^fK7M`?e3I!0g8|dD~WMBV9h}n`HXs z=M*$be%yJKhau~{lpJ&&QlYLU6=aQpo-mvC-T0x2Vg?bC!weVwshqt;Lg3z+G`!FB zoqZpX-MiLTK!|%|#F(c`aZz#hb~N5g^8HzN#NwTDOWQQsl!evq@kztU zZu|GW&NY7P^|0}!89K7x@9G|nNAvwTLgL!?Y85}gj7Ag6&*z?DXiuRr zI5QYp5W>}X_E4jQ@X90H8D?Aj$d^4o9`RhHz=%<+`Ti-)NS3iMOx|?xkI^-4UE7RV z$8ax~#;B6&1qz>^{hT7lw%OW7rJ9ihTW=&^qh=JhW3^qh9F|f+mK7e+O`TIdVcLYo zLWtimsnm*L5=~}K(FTpegoY|3&t!#(xqP^038QH%gFPfsHqkuJ`3>jV1aW-}msNh0 z7dSgf8Xd0`oqtcfXY1y_&e-C5`SHXBmL4pk7h@C`v^Mj2G;W76OmFTQ7qTc2GO~D6 zqt{(LsLWka5!Uw{scmOdmM`*{$Y~3nqg}72p}hflaj>3me01vtvtgd1&}8o{{p0K{ zuO&;yLFx6O3!3;tc8j?QjmCCv-#N?Xs;84$ zWP&Q+43&>Au&A+_D!?l;&04Sz zKa_yt_D!E(zMsG>rm=KySF%;C-l3MZAB-mXZu2?8HI+lHS^Z|$h;0@41?S_!XfUA5 zs2p!n{$jH!se;;J9upQZd8v)EEq59-cT**)4rJFktB8aMYNuYDpV>Gos$>)`kcHxk zzJ*_}LiPMQ6SC{MwSU;nsMN5)<%^P5uI8SHmR<~pRv*cRf=yTR36UohXXx@ve%CKq zCqAA1sYWQGAbYQI`;iUl#8LANr`w6s3MV5CkEcq0rTVBOFD-IJgwt$n2VX~7Y#6xG z?yIora+Ud;G3csAvx-IqZ6k$opr$)?QCwX=t{%O->a|k&ab^GR#r~wKn)hp zt40}=Tl^#$EvFa~Z8s8gEShp6s^0b)o%)GyWqRv4q$rmRrJSpv;1sqWkBclNh$`sC z67qKp1F?OxyeKixV~o5a)v$YqIZ>u2_RHewP*rboeI<2{d+D_l0NQG>VIBV{ggVvs zKHxD*2?%@2E->5N=}=--g5I9ZTNV zm=)Cg{$oz#svoh**2)90;LT_={ykI7Y)h^AyL2Jr^?5RLE8; zew3=unW5^I6n(ML5*d2AV|sUiZhoGX(ZY`-6Y)fRX7eGOmow%sGx!6j0E@8j4Cb5@ zl%ANoj@;&BtUPWlR+z;}gOmTQT?^yX(~k@AEoZ! z|2{_QvksthRXifhH9FJr!wclebY^*)+vhu6- zz_;z!M%C8OM4}4~hA(ej6m^>)sleEci&rQCIj;O=N1-!B$jOnUycBmz!_fA95wn8f zt$=h?>k!Z_Z{{YkaEKTR(7y>SX~ecJ%9}1AVYe11a1=J&a-q!mT}eq*!=>x(=c1-| z2ySjSD&beo`C2*CTHjMQ;WK7U{R`NUf}7)72QC(DmHXlr47|RwnlxD5hl(y}L}wOE z>i{Q-foCb>B^PhxQDfxVHJdx(8NxtUDYvF9soCEtZo1Yg6=ewwF3KfCK!G4PsF8Kw zn0qR}E4ap$P;e+8mtwEF-J>>PM@7w*5^`VIAzOs76OqAcGL zjxwEfqZ{q|>Dga`5No)IXVUUCl!DjQ&uQN%$S6aHANZrlGhRp{}6cJSHCSr{P6Nj0<9* z$x7fF##cIV!HyluRS$m4#cFKf-CJ$!W88U zUDy&ft?s>c_N1`)4@X}KLdxn$BMoN?o_KAlKr83nUXaI!Sy~9uPOEu(q--19a`}(? zEemm5KWcXcP=m!2+ZsM!)MX8*uk3SW5n(Pi*1qSTNmSxln%rZx=8VeCSJ(Fk$x%8Q z7PnPhO+{T#=?nx8rQpL}VFP|)#*xShD%-{+%t-Z_H5v^nH@7m*NEnl($np2bC(ebqwdY z1o(UKY`)tFYrZj>#BXt}92>YG1X>Yy4ih9Vcq6CSkOuYn)zvrNViF`ayE{#xg@9DA zJPyw|%nOd@p(D?gf^Ra*;@LfE-}4?t*ac)p)7xl@SsURSAK{@6h7T7w6@)zZAirL;1>#~UaYahvRfkUbWd!xHhZ;MuawBk& z5o&i5Pd6bG@T}R6^>P(Spm2})p|s9-48e^f_dI-J&1;sVck>vFp_@zx%F?M#>h1y21I z>Ar@zNHBn+Cn{2*KQPK?0%2MXDDL=oW@m@={vD<6?olNXuf~t!JC#nm%4ob<13PJL6` z|8D#+rYAtY2pLAEG*OXJTw#)tnF)Ttx%<#E?@~mZQ&ZY@&Q|jX;qOpT>3jGtyXS=W zew3DI`5ycJ)pRA2jd&LCQ)FSkQD>a)8ko>kyw2i^+H7P3&j*Y`kJk+VgH$$0eGP3H zcUcxT3lL;2!2E0A)|tu!S@s5>(XLE9r)8h=o^2NVDkJ{j6*#j0ell4n)ZvGxKI4S^ zOuZVG-rOm6_vOqxGjBw5(uJ*<)2ALLOC5D7hH=jihQ}jei4P%#xaId(q2}%cSu?8x zBqR5)RSaUNTq=!3F6oU~^Z?6F_MMA4=BBNpXamQE;UyD=z0P;ugrQHhr7sgBJ46X- zwwt&~?3g4KT=@;>jD+re*m*$#6$2D0D8PbtB4j+jctH2q9noOscqJ>PO8puYf&UO`~F%;X%|2^9e7KLF+j~K zi8^dvP~iMZ6;-{PCq^Ju?CH*2N}yBBHIQg4ZyM)P!3Eq5Nlw^!TgpY8vGevdDmrcl zaeUSS^%<9iatCAyN0jOqwW#YcR4sSMu%Q-8lss4XX!_VWs^zf(`>jDQ3>Y(z&M!th z>^*}$!4=hox%I`RiM1oo{AXEG zVoJ}QUd!b40DBTQvf;!*Dz5w*?pe&u5=cHN=;n8YHM+8$vW|%}7p01r zPXW8iQS}ToYTN7OKeXfL-+2Tw3e?(?%BQYhr>_pt!bQ`EG+{r=3)uYC^u!?wLa7`X zf(akl*gj592CiEw?9xT+px*IukFZx+x zflj7GRM$VJE8=!(&~7mEG*IvgVjN^;tFtko`ORwdMwWENe`bMoeoV_y;hb{FCxULZ z0IVH(WiG3Q*QHK>B^jNAk!ey)9iSj<4((HKsx;ZcDXjVdg{qw!7PE9lf$MDEMjm05 zU%WNj98qw=m4#gm?xE&i!eW3OKAW|)ov$*J<9862w(AgOPw{WEXgc_TNU;bZz`;J{BJh!94PF#YE0S;d;`{A%)%oQJq~ zETuo{)gyZX3s{jKG*U#0B-7Z}H|lYLbK}hTW5*jl|3}kAG9L4QPL)Fuk57d|<(1+d zrd>uN}!vpw?PgW=!rclpQV z^@rfj`#J-eH&2+1Gcy?_=_R%p`H8dO0n2wj7is$MrG-ON;`i{uuAsiOFNeP28Jh*5 z%1}#b#!Oqc@Y+D_zQgVkhPGS2>C`tGX{0ghAo7%1+hjF+g=)GH#fgZucV`~F%EOUm zXg(v}KG&ONqZip@wij2To9}6d&$KAehgbBJJz?WEtdc|EwW1%ai$f7S;BU59tEybJ z6OC;=s8J_q!J4g%vVQ~N@%yy2ZJWT3+?l(A zTzCLjjBdHO=OQm^ve&!NVMA-9EHS>-JtN+2kQT8Ky#Q@-ZA zOUrb7mL=pU%)}YT*P&Y+?W3KSM9t1v*r~hK_CsaszJt^VaUu8D(oK;l%pmLqP-;)n z_bb(|F^0@UFq21;5iYlEF+EfNSO>01rQ(-7_29M3dLOYwnv=(_1}7lnylwwhtnA`nKxX;*OWjwMOIm=KmrJGiuwZ^wlLZJr=b);3}<@suY_Um`i z(eHBq`0$0z__32laI$rYh)euFr^5G2jXss)C@_0)6bXnq=^dX!x6oM^iM(^Mx1e&2 zWx{R*S-a;!bPPPq1qQoiAxoN zeyHeWD#7Y6qB4`DC#@|gS4tMq-8e#S>}4;9rFU=BZrnPi zSw6avR=QmXK5z{@byl&!&wHjt|JY0qNP0z|;2z8%GOwF@r1!2d1Hg#%a<&^*%P%^~ ze*3b=buTvLswdQ$^u%sbHO&?*U|IxMem=hH|7d=2Bx#ZU%jq^tLZ*WfBJgV}Ek0&8 zLocP0B7s}b#ES3}U`L!&PKs~(zNv5Y1!cDQ+25zm-5)aDho!R?v-Hg(@yMPxstQhyjG3f}{{>+` zqoOg$ZePdnL3$GKN9*y(hZ38*-;g+Ew)mXAr!x$e+5?qY2-Bp@D+KT~cH1Jrp_qIG zSZqv0j8sv#c!UXF;&0oj>>f8rakh>{l0`B64ns`(ALyNUx18|{r`Hn$>yQ2{e|cbe zQMUC*|Fpw0>~j~b&2r7N5QplM>qY{@?uOr4^}GkrBcEBK{EGl$j9Pvc?A!+1xyt4=l2&{Yc`Fw#oKdIF05rwUOId4#8(?^0SBKKpIv_~nOHUC z^?tPkY%>jX=WGuzgfZL*$9XAG3qV>#_*{FUuRjvzl_pbg7Z|_lh|kY_>A=&p>u`fa z`@#{!OW3j@4xYCxdhRfgSKAD^@eeJaq~EM-*93T#idv_{ym64ggJE>;vWdwzw9wp3 zoU8O@Ur>y!huhq^XlFstbn>-p@a$F?0?b%?ik7s1>_}}e6Y4qV!kNxGjyp+FUC9LX zxnhviiM%@(`~KPOX9{in0DU#1?4$9u`|tJKSR&20Pbe2YS&Q?GIXoi7b2ngW;pWmE zD5ba*FGG=$jeCb2s-lLbKU;M79*_#WydqVD^V`rsbGMR_rYeCDQCTKlMY}J>fj-j4b2b zIA=De;C6jA)wM?rQi@t)QMw?TJAV^j=8y`tm~@KVnN>1_{AhdsbWSyRTlz$aEP`p0 z__dDm%L`;tE6nu%8)f}a5n1F~8#MH=d#)U9SU2e0c!WIZ&1B5rY^bW)G(?jlyaqX& z@F=M}gYsb39t)mi0V&+y{6?(AC&=%g^RPtj6BL-@czH&A0a(;AADzyA-qqUNQJ&cZ zd49%3`gSG!b|j`27^&`9@VKM`0SFB96JUQ1iSp_K2-BR+iGD|46q@Up%h31dfCNz| zG^j)L1%-z$s-1nS?Zm`@#KgPRNV5HECb2Ekd zT>0Q=y`aTQ9EPe?SKqte6O&-$F+~!2Vm9k6C{4`J%`ZF7Z15-YR#+dQDI+hhTn!k~ z>Q=oDct*KJUT{Vy#qBDInZ9Y9?dAJfKi6i^75Eh5>AERP~ah-%%t$~k{ zA6q)hS=0>%3tHrSEvIp3J%?H3w%@PRyHUu*m27ktL~R$OiC>C8QQ~~I8&*$>Yu_ro z%8Ao3aXE)Gf>p*@NWn=&C6iKkgu9-rU+vB^zG`q6bAL;TaXBh-;t;PHli5z#a2|w^hb=a zO)j36!rX_F=8aBJ*#c&Xh=GXvnCpGBxU2Efv!h30Bv(<84hcB~3`PcAyI4p#~oVnDEloLJhnk)WbudPfU*ohmQiw5G7Mw`;Pe;Bd8Of;Z!0@CtNF=0+Hb8vOEd34 z?kl;oRHuwsk=REwe+Hh9)Y?v7`wx4c<@hOy*@g0UKtWZZ@d^LK1?&a2xbaRfzko5v zf07yxY@}Nf25Rj1r{w=G9_g}O9=XpGg?cJhJw>>msby;;ECwtK(KJVvK@pRdb+eys zmXt`Qs*Aw5ftb7uga&f2y)ejE4BU?a94 zPg+Q$V8>vasO6MSrbR~tHc9@D*Opje=zv*Rzu&V>=|pkGHEI^7vHGJ3i+ZdNXh_Um z)pe^uGAX=N?68NfrhNdfq$vGfNh;Bm`Ta8JWM=q%S?pt_(YzjP1!T!+wDR<&!Q$Kb z2`qg&8pe2qE*}1Wf2TUAp~**Vr$iVHVDqGx+R+HWzAuHmRD_ujr3zI~CLdDSm9(w~g=Z~FSL-yc?6 zD6Js>bV!wHx3@j*b!EF7ad_z7R(Y9n>5#i0%%M%5W1UP1g0L>+eEvp0tI94q?CZy6a94mX20O}eYRB%rk5>i;b*;~ zXQUf{`g>)QN}R4Y?bna?4DONoM(3-gk=#F4vlgrtsan zSP85E`6it}2ncq)-NE)|QSJjxd77{Hf1? z|0&RpL1QSJmze{f2uR){jk>^ukJ~)lW|5k!TMX_xv<@?FdD%1{BDEBFS_EB@ z{MiW#`znR=ToUwOXyAt(X{ugIjIKZ5+t77jf9lZ zb)5H;VFYbvv#%%Qr*giAq7`;SnGnqAt|lBm4OkcHle3ZRqOZkTWmUb6BuBN=fUu`t zV>Mg!K}0HeL6lV48N75!s;lQ7R^>?bmCZ{Hbe042nZP~eYR1ZHc^MUERH0*p$dio= zatV#JOzY;fLL|P}3*2#Dy4_L}uYqAF@rEmbP%v#xr@SecF$3TG#fP0(ndFqkyMr#yI^L)4C3+#WD?Y0wB#vUr*kgA1Cfdocba4u*&I>olM+ z3ZyxZAgOgrtG4-KddXnDp!#VBk)n)-tT9D&ucn1j+?PQeKr(R@^ylxx&a>AucOt!+ zZmnO*5QxI3gZX$AxcZ@$j>pqU%UH!TNe7ue8G$osE7e*|zL$z}L1VvMB^pp%H6LQVJ7T zeU?aW7#$!J6vgS{>3q#OvLFw^R7eC|U_a*NVQ3ECgKq>eP z%ecrV*0>EV#DP1n+PV$Dia6PkvZHf3?}DPO*1n_o%xcrQFMpSqty{9lgd;$Ws;=f; z-hz4tr7@*_p`(}@m9w)r5(8ryvi@6pc%M!Uo-$kDwWMn`Y?V`0*wwgR#?bHNDAU_3 zdHlIasy>dN9ihn!4>LjMS*6Yu6XkF{1nbzr2cGi3IMxBQ=~)a+8H&teV(_xJgS<$y zI!Ilt@eGzrxLOog_$BNvlUIkod&T{77a zxD}O{0mS@T??)AQ1=GD&nk7}VG$Y2*OcfO^g1Yg}06<~~W9H8|4sRa?4r;l!0fLBSf6j4efi<0X=*aKI5ejZTV88X=? zO`JTNFBR5+CiyV#r#FWkrzs`x^>Gj9&X1(bmKdoQWk~FA0P+^9R(w*UhjpK()+Glq z?XDdYXT3TL=*p5(Gp7Tfy7Ye5NQu|WQvWWSrgpoS2QgQuCtt84Nu^yYhnaxf4h`$- zb#uIbV962-hn?Kq4Uh{!z-CRBQ{7Q(CfWaouD^_GqkY%7;k)H7rA3OgXmNLUEn3_? zKq(&FAxKMchvLC4NN@-qXrVxH3k0XQL-AtmGu`{$YwiELpC=z!5GE^=nanlUd0xly zJ8VaeJP-E5r!v>XVwfjV9*uF1?f+Xif|r0xnJ&E{r{v;~9w2E91*++rIGd-8DOLl7 zVL9isW9HQwz9+MN|E{5a6{z9={uKZ?JOjfxOLl{=HvYu!GTSkCpS$K)I$3zld>OsH2gWJMf)azSFCC?t5jMyIJ24_tDh%0YbR|aO-;f z;dom5_EveuB}3&ea`4q4z<`S1zS^3(1vpNB4imfg#C#Axvm(1Z*3x{PT6b?127%jr z=^rgo4Mym~>h0In8mvUBx!;>Fxbr0elxH8pRl`V=X?ol1#mg>>?vCKy9iBampMM8B>YKH}~5V&4cC zoxpSPxU8cYLIS6>LDC{(`|d&Ej_mZb;STG_udoWzAY<9=gNA65XrBF8tP?!5V`}>% z`2E-2=jo6bEICdRl9$7AzDq>{iEz7;@VoazA*tR+IV}l3m#@ROz_mKFm8Pa=vxFNV zttR1Wm8{|~yRZnL=@y)eIdc-Q*KZ4hgWibtu^pWax!pgZ!y(?m$*QaB#}Z@TUEB^W zZ2mY!YN^o1=Csi8%jE8PSF_OZF*CTvmD4beN4I6+v_@lgc;>z^(tbW-6ly+g*KkqZ zveN%dz1DaX=F1iz{kb2jEx0i6qMs8i+_XvO;L>37o-}>C$vKIsL{bc-~t=MS85YVb^rSC%Em&FAwIW zTizHNGRbr#pU%v`dSzS5_{0Ka=CV=0!phiFm3>0b8$uzqof>7rf+Ev#5}fz%4J;4O z#iB~-dgE|8lVz2NZ<*`yA~K3A+fZ`Cuq;nqH=$WU)3BkZy0Ti#I}iT{F~RL8T-_n$ zlfv!S*@c$OY#B`F-#!L!zjT=Ij|a~=u$5r=k3S~ck)ka>HLlY?>e0^9Wyav*Us8mI z3LMOy1Mcpgp70Mm(`x6lMV-65@i&DwmAx06b~BG!av19+ndi&+g9}{FQ_mp9>Wz0J zDDA|zOzM>Td|&&kE1Bi}l2Ge*id83$@}tfj=H>M*F8sa{DgUk!%_je$0e5Y=8orRn zR7{6e$dCHbl7y#0mVbf0X;`>t0-k~hz%93XA*p}|q=`@y)!_XbBJ`7HGDf~VY(aJp zek_BaIdNTDRfI?FGWEva7?6 zk4HH+1f_PsnU{N*kLm0ERkSjWMJ{m1Bo0)!C=60P^}t9Ershvr>MltpMI7bL^W1hE z`+}4p!1_i@0{wEqUVqsC56K(A|i&|*D`^rbAnPk)-BCyKD zYO*<8G22kjSUDAu^G9nx;(u0 zqZ?B{(l}f?+Hy2r!pR5}1NdTU``VB3J)f4NF0?ly7k;tiYR%`iIBK-NV!}vzRqiWD zV(d7FVwV@`KCJ2VHGk=Lb`-SA2p%D^g6^%4p3`cAmppP4DvsnwtEV~2HpOaG70Y+% z-}t$BUICc%`LE42XM&YWzou62TVn2U?4BBn=K45c5@RW(PXVD;XO*oD1^mKh=H`0< z0F_a}kd4@uDUt#zDNIhiaK5zebJ7n4Pyq6=)j#9iwEnHnF(Q2*eu@7H>|LfdPSxY4 zdid4x2Xw}zoFjXr>h5=<3Lr7`^|_`40QN1l@W|gBwq%qr;))woSC%5(rbk5$L;nQO zOKJaZ-j8VJJp;1qY=J@f%jpCtjGOi)C`V+qn3Fw|wv(hZheEdP%ex_ZO6>4(kFUil zLufr!fpLBEVo*bBEdUPK!)x>Tqe_-U*ILN3XCQ-u4BL>wEic139m2>fCyuprYhfJd z?tk;p>s(t)Ww4lVB}~a9PeiX6Dzz^jE?D zowyl~^(JOBtHABq*Nix@!e*i}NqXqIiP8+&n~9`S-{}QNeDibv&i01(q(1P0;8wF+ zWqB;&!g(P!WyEJ10aSVGH?A!3y~##dKL|vGQ7TV{CGb?IOBN7vYOBhyl-K`HFTgnW zGy{t=qI@lYIF_XBrMF(C!#B{-Mbo^hf9*R2O6NR!`o)EyKeyqqhxUPy?#9Pq!4>w_ ziuQE82P*ISsG0YH^Q48?jn&9@m2lz`&&hCuJf z6>S8kHF(4j&f|qt#HGCbYGT?PI5im8HyOd9emFyBVMpw|l#ZzvF6h0+7&opLJ$8Xe z=uvBwbN;>_^T%Na3%a52%W|>NAcQ$<8(4$jN8_~$5WCBvf&5=Yd0&9&j$i_ZDh?EC zq&H2|b1A7IY&ZLBlJ!Na>PSO6v>sJZg1qPOT)$}+D)(SQ6)g~z2}?Q0+2-(FI2-hn zo8LJ_qCM9AM$a`78>xwgM2ub;H&C;)1=%f~GUe(w;_9VHM4)QXtU>!b`GjkRekJqb zolwt6a^^rgXy4%v&Xe2L`-+lh^P2SHM%xI|o%5#&#fa8@?ZKayHQn~w9&YGH`L>fU z^*hf14%(3L9{|F&dY9O3K7t42F(qfg+6Ef`;J-;H(aR)f(K_-`6Mb9GS;)GDFb>VM%IuA^dFist2+-P zdVIStNanq6E>(a}lBbY!9mT}`8W4`jH+}Ed=6tbcE&N7-{0vSB zHUEv}ZaqM}k4;1$ZeUZ)y*b&M#}z0={aJ!2>idK%1g@2l!Crk)6Vi;^hn+aor6 z=tCQ)>DlL=6k`l@9YXD05}8eKdXpkqiPFzLwB_bVU%6T8s*?O~N8H~%vkPnFedE_$ z|LY>pjEzdEdSACDu>PIrT}*Uxan=2N_fgtQvkIfkpraWmT$noGBlqQkxHMy*Z1Wjd zi}S|GJ|3c9~)@suurRi9Z_(cVZx4Okl(+>o>Y_E{bG7n;lC#`(rN} zB*G{R>&LW~)rQHke{imZ2(tn^@r76_QiGwUE_{!^r|>qzxm9XQ=5@=LpbO_U$EuIDdxV;*UW)h{ z+SM7rj4rI0>cpws@;au4XsuE*-#lwcGiKq5>ee6le=Ji}n-;)n) ztOQ*(jXi3wT##?|uiOwTt>QsC`-C~NIlJVDmz!+AyG!f)xD#ieh@Q;#nyj1GaH>rI zPSj#p--s`?<28H4H}H;$z$M_GUcTr4(l+>Wx^p`U7lFUl{`&+#(95pbzlNn6gx{_B zS2#kBDX`PF^-PTigSJQDamSPId#+UC`mz^^9me7rJ}X84w4a{UIWVncjL0<=zQwAh z4Vudd&cb?8dsn(N`^SKjU}}o#q1{Jr-+pn)obI)~Q3jqj{@Qk#RP!&~ljrBB`VZN` zvD!|Twp)*HRK0Q_pfP+ViA>$Gk7N%Evq?&bMKm&c>7@z^*)!fxH#p*tjD zM~0XMW|U}?m2)zdvFn8Cj8}rA#||n~Og#@rhVvovK-UQmdm?%?m0JYXG*8@fCYGI} zRn1I~W#!(hBk5M>ZdG&o2^HMMKrDn5% zv;Hrii^<%SdaE0U;%r8Lyx^>b9e_1J=Z7`h{$lo24($_H1CpGReJc@d56+%X?dJuh zEpYB_5n&w)>Y5oHL;}{hLN4D0{o}ZMb>p>rGUqK}iTG>Bs((I5;H_omXv7%2?ko$q zRiF#JJo~eAD@k3EJgqQXAb1Be=NX`)mn}PBBJ_D2exqNUNQ78xf93g1Orx4CaAL== zFq(si2g%-yd?>?M@`n?O^QK!H9dm z&n2cJPpWZg@$=u@j`mAa`I6k(yCv7b0ublmUGW`P**LAh__0e~8J<vbk4slmH{&XNDw{Npi-nnXPYF?0}z}Ex3eqEtq|u`-T+m2uiJ83G`=FU?#Ha3!J6K83rw{TNpZv z_>3ALNxza9RTib(f-L@y!IwF`JPFrA3tF3V42XJf<3EMD*n;VX4NOW2W^Y@(tJD7o zBe>uUSObwS0D~DvuxEV*GW%}>Tpx?EAs61$YyBrM!OilsKPD%CfxVOON{zWTuLO=S;#l>4;5?RqzCO*gwta?j)Iqyf0T zft~@eZK9p0Yfe*m{%foilYK$Oq`ZO%N;xvh$B%L!St)G&43te0R2sg3+hDX83=Q$p zo;XDBq2oxpTD5v|2)C8WQo zsUv@j?BNCPVaDWge#m^KDPaU4UtV>8#z6YiaX}K%d_ziV@VfUAVj5XcsUkZ1N+y-J zh3iO03wb|utBv0{Tv9`WZRYDj!Ok+DU}(lqW&uT(fP$S}9QGP)YY!G|FJA*VLz3*jMfA(pO7_E#TOv)nb7>UP9}NV+m!mT(OrKzA_6~rVolT zL=$e^N6I}7V6XC#bFNKp1nuucXi6$+^gfZ@!-MIr8;|GG!4N7tNb+&v+@iJWzW64` z?ftIueFfR8*2fNwr4@9jN>O?~BEhMkw*2|LhAoBQlQa#o+*5V>^5=U>FS+aiKaPz9zW(iXeioPLJP8L_#gd)ZbGTa3FuV^x z=492Xelv^q{k3%sLxdX8q2xflVt>y(J@Dc_L({$2n)&^y@fW9di7SSk1T!gpbD4#y z`2g!xb`L9$*6!+qxzIR|mXIIO%(uY!^AXRyF|S-%v;2u87rd=o$yamZa}N<#`pf-S zj^*p52+Czm4Ch#dBZG+}9mL4qVa*l9vAJ==p)zk7P7S$L1vv}=hR;v#og~OeNgOx~I3y3L$3D1hDT2X%pmO>Icl19)$jjGC)EW8?eE756<*qu~FeEdNH&aMq;_0&c23E1Ssc> zY4W)Y{zde`8=Ux0v-jmtJ`l0seibn}v1E*PJJiJ;oUaHtxfxbFW9FX7%p<++m;ST2 zzVoajKsdQ2q;}cku$PUWNG|BErQ^7s85)3e1=ineRc)-Ceom-r2G`yue6*wf4Oj>N zd|As~{neBIdgnaM1YBhnJK_~lJg`D}JGF5=h{^F=+4gtvugeeLZMOmD#&<*MyU5rM zAju>BWKPu7I1vc$!6S=Ut!D zi{rrN(x6gHlN766=7D{RY|S&zAi>$LmjG_Z^F`nT^|!}~!6&f|k8sr~o1FpY zIq3e=yYU6=%5E*vXvS^3A#Qn~G@TomF%<`}#)2kjqZPwg4f!e%7)k4RrAXXDG zgQc^YM9E+A<9eTqE7}}xbgL(py6&eaR`fZQ1$==NT)qI4gRQIu!@jA7E|ey?wHKt4E#X8nq zO}(e3SWRb3FXt$Q)b0K+r)3Ci_eq*(s;7rW*jNFb3iTu;ctxWvhCntv>*E%0mv)Z9 zxGSqPaZOqNkk3*l+0W<8kFm7`*Ea8C9zDzxOgnP*4pv+)>{-99$RM#*rgjg9ldtBJ zO@$};hx+1MGIgZ~NE3Zthc*tLS@CKx-z!_>I`|1pYj9Pf*gcAQLxZ1mZnjIg&gYnV zrBUtd4=re{@JY&6?=a_rK$j~^Mk7C8NA-eIDptg;Fzs7CRg|YmYSXcp8e&Z91`xxRiX-iO6Nq^)L@0}J`&0@+CE9e=A~LvrJbp3@guHqoP;vq2 zGpoMY59#VD(X3$9$+Ur?W1mk4_r=DvS*myYIQO2}69eczhSU2d3UkFU|KlVPTM>Ws zK}uC%C*us(6vD~XIPzIMG}|yBheLJ$ReOVjFtz^B*^-|c8FV@Xq7i4IvM)PZ_0uuuenj4*2J*K&{jz>FPffpq>_2eN2k)pdhS_3 zFP`snFw($Xk&^py)|+*wg}RjYjNXx5_hI8DmP+Zuo%Lw0u~}AXGnJt)r1lIw?}DK? z=2ZpJgvy2+A;!I$+aU_tI+`Hm7CAT%<$1q~X+o>Y`S$XAJ=Sajg(=dEXQMJFwm~sG z)g!6a7bww697<04UDylERDvAVl+w8DL>8p2`4x9*Rdw8DUk^z329$1`qqE$=;H1+` z^LhsBT-I}aYUwgSu+0=7GxxjkeBsB233BL)OTPq0(uKLVz1#CfTbV5VZ6-ZkINpXP zl{I$$uT#J}5z^y@KWIYRuda#IFhL4U_6Lfle(o2!sRy)>M^)VNcE+Dfdjb?e{rch^ zd%>e2B15}h)JI9nvX4r_)OV0B(PS5o)e{n-lpfn`N@bO=ybUV~=a(-V=pYQ~Jd(%S zdGNbE5K=FdH-F4%b1QmF(p^EkI@{*5PxiuT8>jKD9Y;lhPID$2WNowjIC^mbn^8%z zk0xHhhu7goQm(PERm(Ut-!1K+qBC2U+o-2hfYUV7BP}*JN8Qf8iqGma&-a6^ytA5y zi9V-kPHCQnN@a5cHq-$uV@$_$K3!?jC33>X%#}nTh{TX=nTBTRIE)FRwFEP4fo`B%&jJYkf z4l-?%VfIJEC3B&{u?3{9JjuC#UDfecA3LJR_0P`}iTh=4wZs>nAAGBq+>Uaog+_Em zEf6SkNq(WAyr}tw`GDc^z{68kejm7$-e^K{oTv44)oOh^#_q?D-Vy6qu2V_h_m-G-whI^RfqWK z3uf6rK^xd%&HOF9+9|*>g|3$s@#g* zjn@PX*P*r%=~G8m;}Z>k@z``r-g|$D%^d};2h!uEG*Cd7`!GWF!KJ5B*u}kXtS4ru4~x#)Ak3e#e`|XzFQ3*V*diBvpK$*##UXu9F8k`& zx9y+Epdm8tUM|q)2_9w6H|XP_t8PNUvU5BFk+)$HAjflZo_Cn2W9gN;EiFl8KpOwP z^Vj!~qc0Eg>fh^O@&mDJHQ9}C#y#RzS*wn^0anvYEv13MqTx6dj$H(jb8V@VdF;7w zIcAPihlebIi|D=g@ljoyy|2Y$8sJ{oxB2t>@;+~p+4^ji-b2OU4?1e$=WSxeseF98 zV%>~0tT!gfyd-QWw|Ej<-(`7?T!Dg0;u-I?`YXqOi)HmW-~X#; zd2*jz&iCVZ*T3cGO2&^AK>GQ;($Lqhs^8BWH`gIBeF0_jT=Wf%rCWA)ZjwwF2_jfQxfy?^p_9y$YB>|aNBKswFY|eMK1J z0lwk-T{g6)Yes#Q-=rx(#}Q!GAQ8h9b2X5S6x(^X94Z}m_<%#;GgG}@QJe<}(zcsl zbg*O}N_~_;@rE4Zi7sV-U8BKY@Xm3UsieA+!P3^}fJQIR%U3D2zjpQtSaD(x>+mhS z?T@$#5nGJ`2X=cs71P1=Z5)IlVc?y2tj?D~Y3XJ+E^ElkZ>N2zhK2bt`yJe>2nRNF z?nNPIH|G-3Kw$SV8^XpTvHqGmdcycr>TE>GzvdWN^d7H`zJX22=I0c$UJA|sX6lo? z;_j&4jnz}7>qAwBP)|TGps`g+d`00opY}rlBPGukgTz6aLyeA&Yyx{$cYT86XB9}m z0j=0q{18R+qLi?~X7=r(3mfn3gq2~WAr#~rPs5#Rn~Ghk9<<7j%+OOTH}*_;{OmZl zus)peG2ghI$963$+i8I>z2G{!hT=9kEx#fii@hALb;P2K{EcTCn|N3G;4c&SC(rCg zt~Vk;#Es7u<+zkv{|es_ao$?T=@E6Zq)o7k2gHjdJ1<_iNkGU~VLf_-1W1@Vh?G7x zMCcLVD4pETYi>5~MNbx2+&JWOPb|zg{(ABaY~4`TA2h3T2gDsT)}7pbrydzs*GmvH zL9>{?iur~ZqTp&Z_|1V}&r(j4{;L!cacIg|Q;vpLPBjm2_&!vn z3xZ}o$`%`Nsj3@UebNdL!c~m_@m$H%ev8PC?UKzPt-`%;p4dc3*VipAHSlKkolRtf zo8WOFT&7yzM1SL%N&ydwOSd_#rV3O^Z(~-r-9M4Sg%eCj8=Gz;)>NotFJY1A)o$*< zvpw6;tMXvZXvso5tWT##HeDi~nx(8HsRZ&?of%&~^BfUWc$S4?5cg^WZoo+9a;oy! zaueo^vF-fUVJKGCR7MaUX^8Aw=JtXf$zhKiR$MyJeAoS7h9bOqeR>}T6Os}TkV2W7i}{f zFmFv@(A$Z^Y|-*v_M|pD_1zyTBk0ivHMyO1=$GQ`BR3{5<0*1macns)<%(i?*EPOC zS^nm!vAzV{S`}fGSfviP>3Yd@m+m-7sQ=W&vv2#j{VdSnWawn6)N$D$I@Y zZZU?fKS1kMs`v&g+<#LlgYT6vfGLf%o9!x}$&*^RYqInqt{m)dLEhLHCwyD}|7Z05 zLiPiAu?zCvw)yAxh0~c5Sp_2CyZ#>!Epa=`Pd}T{X8-p;U*G-5mcSn$&m$U-|9|oH z$MZ<}_5As-_wICRaZ-fN?U}?vfg{fiu>Jl^Kg}uCC@0`V+jIJk{~WEaIx-^DxKx-C zy_B>F;UpkFDp@^is@pBOw~Z@*(odxx)?sfIw!zdHU+*a){RS0Rv9p|z9hGE*X;ji- zLId*c491;gv%S-YYqZbn0Tkf5JPPK|UcnN`?cyfh^QRpT@$$Rb^J8sj&^#^d^+}av zwrdv@E8EuBbVYYWSETWCBbF62zXOOj_57U@@gfme zCL_;{8sJ?X){vs_lnv!atXK*=vWTngL==0&qm!^h1JBIWx=SFkcPk(4?c2k&MfT|X z4*@*?eDKCvZJ1$aC|3Mt@bTrjjBSDVlrk#Dv*Z3UI|^_Y6JfNMrmhv|>@b( zu%`Q><2-1b`2*CZr+bWr^Bp>)%C|m0JxCSlS5@{{kI^s??0LkDl&xrS-+tA1?i~M! z*rG+TSZDo^x6x#Xe? zQX-gx@8htIM0Cwh6gvoU*qX~KsJlV3`4Mj9JwM`N>lc?lo=}dt z*(lzAghP-CcwJbEm1dZyQkKfLls9K-cJHz|3k~GIEEGz7i&dyb zW7Dc@Rm=NORBoyoW;QLJ>1&^N7*Fgs_ocU86 zoy`k7$6o6~(eIy7^yky}SP#rtSx>&H0cj%T8GO$BimL(ZOWq)fRm^F1$jNu_2XHin z87+Ds+627uLECgrq9y+|)(cd&QkN`B_CShnU{?jHS%XcoBl%e-7hdk2IT-=S6zxZj z`91@YPYNHbEXMDmOgb#pbWhDug(HJ>iUn!mj z5&Zl8XKZEis85AHh?X%QkT}tqUzb`+llln*_|XSXt?BUIN_~r?pp1g9 z+Pw(d4TZ|5%_B#Qk%#hzZp=z3I)hr+0GZS=dvnubuo$MSG; zA)7Qxp>b-yoInHv5m>6k&sA?hpWmMRTcs3#LG%qDZ5io@=A+6^UvEBpJJZ`PU^j3n zw$mWz(W6%8(ObmAR1aL*Rv}CXbAn?X*{6n!PTvf!92BQ~(t)ZPa}Q~rp`j?2z=jDj zRvAb$@u>~$I6}6_VA9QunHhw#IcdBw@mgSdIx3+ZE1wQW_N%=h=hHUfjP|P3_qrvl ztmBlX9)XytMo?y~M3hqQ+KJbyCR2I{!N{fs741)FD$H2jH{m1V_GjtCWoZrSK3tHC z19^MS4#eh+K+rSw-Q7<0%OWu{Prlxn&u#_5Cd#s2(0a@xCuYIjWVcxC?DA9lMBa-a z;4HK6O032t4cfJhj%GMwf?OtwH(=ExD+=$~b@}G2M9NHHg`ioY^HP%1mm8+>B;~yM z{7^&!36vrtSROUx%T;MMhci8|QDE*(>Uqd$9IxI#Gg}f;w&KW& zW$RKy#Z;r!*y8Iqd6?hURv3DEE%KPzeY3Sn1P5-K zyX|Eg_3v66?tkYJiyUa>Q%swsG@LCD#K6>=S)tGdHJ}t??`$DXucg%&>@5O2S>9wt z6TKxK0+Z|h#t_9fMj52ym>J9Y(tyv^;`L`X%#zpye}%naj?bZhQnoW5L-^!Ct@1ka z#Wmq-p6hz_KTB7VxaXpOZ0X7_axki7JDZ(*F>CNF$f74v!?=dbFJ)iBNh=Bb{23d{ zb!+-QlGCTwwnW1u+$*cSBsHiSi}otPpdBZjqHS8eCT5LG^ZH+_?lVSxAECv%_*MPp zy|3uqa^<)r%1VbEKCZVnzr|=LH$8<)SfEXxpwnhV)#5Fcl&WdrOSprwB|z3w73N@D$Sg2(roF-w4Tq~OS2bI_v}e)TORW?_Oq@M7WV3^?i&?xuyQ>p5UsS;pta}$ zajrw$N~}OHe8T60dMyE%deZBhvD0t@67HjBcROkEhJ?*g=#v_Xby@+|TvBDM7ao&W z|IJHV@NsUwTOmc&<*6=jK`^*l+r187)J(bUL0?{kXdVf zNGceK2kVg0jlBiYf)@%+45a(22hS0O#j}~U*pyZGS{**M%z5zh1*xa~fdBbOztYxd zr*qaga{UG*towd}9W)xJfb!Gt`lb-6QXRV8<5ZRoK`3eov|i#^BBMi+s{8p67Vq(cXDpJ7?3uND!PxAEfw0l zgoW*0M}>{H_SqN5(!CAf^7ZV&(pLqI`CN6yHrHgvwOInu0^Os0C} zciG3tM;K&_1(dox$Iesw|4ycAR}cSIY%;-6GAT`Cae4|36y}EHG$op#Ff0EofMR1j z(dXoWxkzZf)w}ENNWS%|Z&moH%5d8jA|(%JVdUHb@+|Ae-q*F6^n^EZ%xj{;SUiqv z6?UnAKdO+YN;A%+1-n!!$)^*n{XXu9dZb#Ky2?q2XwEX@9bl3z7UAr)iSK!>N=XBz zTRQ4TqTMz}8E_^3iu%g2Xvj_o|^NP-MzfQE92mI-Wx2RTA zkB4}#NS86eC>!~&7D}kkT|b=O^Am7Ud|=ZXB3cU>JIF#~C8K0^?%xz`!>$_dUlOD* z)Y>UdzzyH2jQA={YC)D{nsWU$>-AN*M}3a zGekpkDYTy!e163cn&H(vQ>;mZF#h1w0Q4`N@`L*{+w1CjL$3)1w_V-Hxfu97Zxsxn z#he16J>vF!AIvIlo)-xv8KuQvPNli@PWma&Ok%+X3N#4t%@k^Cu!e@Cl9-&=XW_tFwnYw2JnpfVD zw~a*hTuoEMVH4lw6oWrusfPT^+qD*32O-aGvSg--#5|FpJ;Hu%{uidocc~J(J{5A$ zutyJO$WV(Qx214cI)(<0y`<6|{`jL&ResdArg$thwQG-uw?xE$aO@X{SjPcXki>41 z3FtE2S82|tAOs7+pZ-9J_UN^e5#4fB1&q^h5l1!~3p4)=9!bkGme@N+=sWU1MWxO_Tq&z2YOSgVj%rETeoPhhKwRN{0b@^)l z%{5puHGyT}jSe$vEA3hTZe7DSr?M}i@gbq!>|xh3XE`125E>4D29EDE1MS-{$W|I) zuQyZ#dg7GCwxQhgJ>J~+zQ>eRHg^rfA0o=tpKk2^GNEg-*|ep?xINQ_`#ikTPC%!t*Pt@W~G76!9E@}JrC@z@Tl zi&d$e#DjuT!+=#(OlrsW%yNV#l5}{S-3I%U->2^+kG=Z&2#?+h0aox!rS2o&PQ!m) z>I*u4zQmGU0=-rKPJ zWnh~B8eqU&C@mQ;J>_=}k9*5ZP($YT5wr%5&(B;e!)t}Y^~8^S9dDtE4F18ku((>jz<7hoAxBbruW265fYyaS&rzpT4#e{S7wvX9G-O`a9%9Ad!upVG9 zGypX1PN;`v20JTpw=|4Phu=S03tIHKsAxOUeXC&<7vUzp<7|=2nh{Gk^<9;$UCtsd zqw|Kdm-$~wfnn-#HpL`|XNHq{@zl+YA@_K6n_VpIlaASE`ivEfs39e4TJUe!Fwpsp zP*CFx)UM&^B>!q~xw{$eID0?^OTisEVFVkTGwx3g;^1piUcSAL{x~JUrP=PWerTlG zpG_lRW6ESs2RVU%^e)LT@}?IqYZi8)vNN#b`L(mkmn+kOMGedQL}kt-8@^Y#vbK04>V zS9a%Q1XH*+3A&Qq&)BOVkFSvyGpWP{sWB|z(u7nH02m9D#SG-G&+@*Mm z^$1L1R8eY5$NrR zb##yYTCz~m_>98@O&M!l!5Gw=K68xdk&%sO?t%^P z&Zok3_h&SmHU;!w*^1SYtOQmTisREa>)?uq?BzyW%d}pwUn+jtRf&IOw)oxu*pFz< z1(4q_7!SXrv`GN7w*>QRP6LGsuP(Y;bzR zOOqd%l@etau19bGbTnKUT2@8rqP=*CY1-;x@kxuTViN~cE&TE*2dDuf{0GIOGNlkz z70z+oW2ypw3IPi0T*;ow5;wS2i_Z(Kn?nZX#P;+)Sx)*bws12{QUY4G{4z+kQjt+C zzG7>^kR(xgm~39^!T$xNEL-qK-BtW6tV;Tr6`l<<*?Ln_{`zf_{gB*7JH&gs4>OO7 zMs}I-P0_d1ki0t#e=+l)9t(?$r2IMhpJN-)FOAiQvG@P&jjpm*5Sukx(rhp66C~kq zDUY{PjIMiWKjJTl;iDzo5t|9-c&-CKJNuT_+$M1{I=xu&>TuO-tGB~gVZL+q1^BqyzMZl_jBFViJCo*Qr zPZ#!Iop~r1!}3JTQ*4@Amfepi&b%X;mY@P{uy8@D+Rjecc>J^KY9mg(MjCJL(OHPp zG$M%|ywHH~FMu(c(DT3~@hdMO*W~KP+HhvKE_o87rm8U_pz4`0@zUs$M+$n6Fy6K; zIBKvRx+$oa0!x;9sXq{hTCa7bLKb8hnUAY)$4X~XmqVt_be@J zz(>`$$3JG@&oE9&>JP!7F;ll!QRyv5O}(a6J3e}87+NEc^P6_*Y?SJ770U+bl!8ehV2_>(-o zb`rHvIh*VijbHr?D{e->s1aHw1Byoqj-Nk4`_)!jbDc&KMT(Dssj4n_41H-X1{Hvn z?GID0=$f+g(J9<)tu>Q21L@MJCuS7} zH{#T~LptT>p-z1nV%|Vz^D52%j&=K6FZ_^r{Qt&k{ck}3-wpof0c`l+ul{2E)UYcm zouu@ivh(yDQyfV51=q8ex)Cj{Ry*qKZ&3|3!x-*#7q7NCdp++`^>c_6KMK|I(2wvC z5N8cPzNAXdJ!Q91)iA&p><6{H^9x_%yj^}=EiBCy*i@yh(iQ<|ze5K+Hsm?Eoe1{m zWGx`yT{Go(e-*_ELAnY6cTICC7DgNE_Hv=AS~?wjlu5`l1c&eQi`~O2uuO+QZM)JW z;vr%{Qe|Y2{c^!Y%4u42fWM5TCzmQ3fB%$RV^)Wp=}FDG5;}LUSky zK#(ym&kcUkqYpKdS}CG9E{JDk%-Xwt$!QZfWXM=GQrBNvO3*25o?~zTxJf=y#_+JK zjfaqyimGQTeATboA6MsbB@sG|(-IRLkH?ngG)-lm?~pSj5p&uzRI#e+iR&lAk$&ik z&(#~(9vrOzIx7NoGR0-QISvpAYsIXo$LsvPJ;7$vhL`l#;iIqU>l)f5{vX=DDk{!q z+ZOjUPUG(G?jC|eAh^3bA-KB)cemiyxVyVM1b271?6c3l<361KyxsNEPd#dUqx-9> zDQiut344SmUr9M&M0lTe<@TQ}Jv5Ml0E!YhNd)|$9WX4dw60DmW8R&(cr(8?GvkjM z8b#%;RoUwuPSwLmN0){1tVi4_hv2sRYI)d`-`sSHVPLaj&-H>8BA2O|Mf;S0AChpmWBq)qYs`yQ(Z%$k4o zTlf_LU*UN*zGZ-oZhPCYUwMLByEOD;*njFFHcn!Hb;4727Ahs+%{R+GNvvw(sJH+=Rg|<-NZ1Tz&=Q< zHyXc#BcP}PhyD95-`)ku46S1x_Fs0G{S>R2>Rp)d8}X%`7fRjfSgm=%g_W^T@e36z|i;?rXM z5~bMfmZra?N#I1NN+q77-uAJ)sb4yyF=@3ZHse1B`xR7F)izBiveoC_6bd|GSns`};CSfVUR;@{o-6K^+e|mJ- zPr3UOj%T2^6(@lW9^P3zMR}!JWS?=?Sa+U0>grbTSSn+;k@Qr};#)_-5{sxZr-=hG z=9DvYaK|oI&E;C*^ZLS4(M`wSn=?PBa+gRKL(Mz}^A@ds5_KeI8r~)%U>UQQ&X)fQ z3*p9bweyjF?=;<=KOGNn|FY;pFj!;57iVq=mQis!f{X@#5Ip6nuz?bZz(w>{Iac}o zTOj8CNZy(KN#X4Do_JHuhj+ZTdx}W&x$w!|U|`$8rKA4S8T6>r7aY)R`_<3eMF1)mWEtJ!Z+pzT;^rx?N3Wfe!?C6IM;sjBm-C?r{seo#~T5-OQoZP3#IS z-%F^KnP{u36Ar&KI_QL5N;L2I1=y%h4wO(?V>kI2G#9i~+uSKB*z?($V6~s`6^;E) z;3s7xUQ7$ay;(#or28tjk1@0{C-&)K;Z0kT4oug3g(UiPI5;R`d1fZjt;6Xs@XmPK zP_CVpCOc_q7+ZY3cZn91bi=kb4*!K+DMv0_$z770e|C*Su{a?S<_z2XNRtrpalR~2 z(+nw2Eh{A8;Mgwv)g_YCCbRrAeLEfIys;q6nDIYc00N;CrdQ3|`sX;$`zJ9umDRAz zuIts>4QP>NOr#x{mS~!|6U0h&b2zu%I6G91{fOofKYO;4mfQR97bY8?3P!G;%a<`> zD~hB2b*L?CAd4;7K3{FqA1|FEbEgxl^YwnQSMj()`qUev2r2_hWa6NMaG$Y|)iR21 zW!LephcH~GiL_p4Vw7o2{`CXYr<1jNEprXN-jIvW?6?=({qf8MU<|&8*syiETlE<$ zsW!*GEVoO-w52&a(DA$U*9QPdhlN0^5~J`um!Mo-{^Idt`32d1G1C3{+s*Qif}6U!`giqA#f`vE zcf%{aUDbI}{pg@>`@;wF5@q8Al641CsPZo@XXGfp8$RFPk?lGr27dOYI|K}D!2Qv4 zIks&5OGlneq7WOZO^r$HD>n7(q;H+bOSFZ(b@_^qA<0CeM%!cu-|0?U`2jK5unXBt zYD`^8J>R=5n|Z=AhGw?T(hDJd-7U}SAlxZ3X(UN?a9g|zKcI*=_#b#0>zdPN?hwo# zI*F>I)R_PkLa?Dgs?GV4E?#keJA~YN=}EQJh99}VS34h#E-eGxhSAs)3wph_hhpev zPm$`??#b$U+aP)!wq_2RkN!9pJ6f1uSNUQS`Fhh{Ums9zfG-UkvyoA2^9#NCNx~4e6TlNxy2iqXaM2aGw({7;PRS9_ zP)lSIw08au;k=a7duFi>|8}>D|FAwY3auw_DOU57Nt31gRPPl*A6*k&6nm6KXYKdY zw&6ix1S5h)+!S~sk7;gxaq1?t^~(MrwYF@8r71mC(8I_rG6X1hzlSl{afs12zkZ7(Rb@od=Rq%La_` z1@pL7OVbqwAO=PpkN@Z7nj_HQh$Xu9bvI^dJs@*Htga{*4#1F`;Hc3>zD zw}j#Z>;X+0QezpR1r(Me_?UjXE%H}Rf6Qd(a2R9%&iM3O%Mkh5Gt##wE^Z|}w}mLX z@IGERFatVLfyE>P%gOzS8J2} zz0rfe7vZt$koM^nSAQBiu~?0OUQ$UjLN*(J_~8sMDf$C`=AQO&foJdW2O3SeAB638 zAj^yfI%shi;*0G3)+DK?^)G@ERZBV%_}I($gdh?|=_OA|4S2`tU+jEp~7Pi!X*Ih z1nP+7#+gV|ED{G!cxm;xnXyLZjOWZ1DlCQL;%ySC{S^A7HPbeFV-4C#>tYX!i%m#+ z)<{syvxEpuG7=`7i}=@NQqmlXzlIKw-QEFHJ^xfYFK{4XbAx}XD=#Q5;`-`;sz*V8 z1{BR7|5Tnt-6sG24q+|g%-AKSE8az*!@qL6t~LF|0)X#m9x($aY-P&o(&z}FtZ%-u zg?N0$26|g?70y=7!`i}F&p$u0lHS{7I=ptQV^p;ljFnj=n7;oiazG~5r6JnhOLtWf zrBFxyfYL7u#Dku*v$%QcB4U>Qsue8&x72n&B7R3oeBBhpbC=S+IMsff8aBqPAAtv4 z?=cXT4L-*jd+cZ_YiZgna9yBThYI}`1i!uSrb7GG40GI#vJ!K;C$Uj?;#!|eqTl5l z3tX$t14gfUb^SUb7|SK050^Wgo!b`AZcjE(`3g+aSxJCy)V>4nt5_alG`pGK<X(FSS|{zk6LvfwD>&eScykgpjkXGY{O+%(C>bBffDBWw=#X3P&r`Qdu+pF zmG6q4@?1sI5b{}++Pj(z8tW31ub@|>5c8bDqN_cZ*v935bf!q9b>b|_NIxpg+-IEH zhR^EaqX_Dw)5RF7@U%S{;=8%3tnJgE*n)#(cH6`Qj+_@*$sTaX;!r`%QBhRSimNT@ z!%5K>MbwG*Djv9qe*(^yOeS$8+mRNT=;G^eDjTQrMn~w-St0uRXS@y0PySdZOJG&& zs8-O-*^z4b(HvKv>Yr6CPLMC%OLAfaKnc>HFt~Jj_K!T?C%v!Or_k+v+Yfxc#r+{AgV{J zy}pJDcqg?O=i?E3)RuHNx}Nw$ZvD=q!3)Eac#l0$oxi}ZJ6>TgAh~ML^mEz3v?SHJ zdbTZtz4{V}prUaj|3>}iC*f(M3ZH;MWz|4SvXhe}6N4n2kEBcW^5;40fzw-8!Z>Ji z5FZ>MHXdabpg%->#N6NxR{b+k{W%tlYv&KX@1K4i$h6M1de)Ln4<{HY`mbob(Yb`B z`#^&N)za(>F&m?0M+sZ5!T~h;Kty_eU#O)K!1MC(dID$RlffDOLf-T@A|l$;Rk=9U z@Mrn%?Rlma3G9rf21HsTglw8>ACBY9hKVU1-=>1lUU~j&EQ5hG{^s!nxAdI3sZw$9wA-@ zluV^KmN6&KM?oFjp_`$5dQo#wF1TQ}Fk!1;DWltznf#lV7o^ znIX){T-m;plmk|C`Q6PbuK}>CrsptPZ8NiO?`afs_#=}~W9~u&m|4C)kiqJfkuVG+ z6XvYx#C_{nW`@c8qP4bE4K0fJUlnlzQ0_Kb07DL5B=YloPN{!K%E=Ub>A$34CZdVoaJwCsCsbBZ+5X zb`tHf+|~LTv#FCKKI$TZN*oOo65<9r?b4 zk`0v&c=Do~B|ONu?c*^x)fiP4F!qXiDv~TlNY$9Iq?&69u3ASId|U-rl$P9hp>qSSmpbNsYNeRGkbKxicub0+fQ&OpJ*vHe>6 zA)QBheL7h$I0bSB+tjqG`Q%)~)txDVZxkt~*up(#-b94DwwDW(oEmFpI=yXAJ%fDm zO%(j7W}7cvYS$ROHb0-1AdVY1M|*8b9#C-WXbE!zeZbH|xOBnNCdGp(e%vS+jO!7# z1^Kmje1ysM6}kP4*L%6tf-8pE{{$M2*Xu~BBi=d$P&>--NlwmNQdn^;gGV~;ESM`P zD?M}FbIS5cM@Yw&}rEi$UA2~#PAW)0!a}sB1{x<-EZODtzTbC z$Cme6@5CbX{B@8rG>`cJtBy_k%ZFY1R$r=JUN##dDIKl1%S3upq<5f-i-q7?vALJU zX&&=OV@T{uLeL;V)~3u6#vFXEn`n;X*aeU>&_kI0R+gwnDKrWe{*8Bev#bl^$JQMi z>6DI;jdMz?&s}GSlz<+l7sy5?k~0C&qrJWir7J`RJ>mB9c0)0k5|73P1ZVcHxfEuM zvgrYeK@K-YLpp(3Vx4aV&+~$uvtEzlT?YFFvUDw(`{Liy&_Y)CZ_rifJ>)=0>4*ur zb}FbR2bo9DP2_Qs9frww75$t9_20*4;OXju&4K(DBx{Bh67iImo*}P}nm$Sirixh z+0cE;XKg7TbGG5v2v;4*ket`ry>H$n?c!dsX&hM5|KS3LuUXniTbhETQU;Fq*9nbN zRtSHsQvRW^Kleop*Ego|t$D7G4y85Qf^+%adn$qGx0DjlXtc9G_rmMvkgbA3fNkl& z8w22F+p6 zP|XAbNdDDFGD-o^IGH6n^bfij`JwjYmtHgepgL9-Y@pf=W}7}9X%dF67t9r<{{z7X zCvh`ag1POPoOoeyGZL9_g-P15-b9R5DZ937%Rd`!sVX2%a+K_2r zU;q|cq3}=;x{T;HBCK0?oNaYx8-J^7r97e{DJKbki6(6>R^}8`;c8xY0V!13aOh`r za+6$0+Lodw`H-;`Q(Dz5ygRdUldp=3If;IdgD11-Fx;6*50&c|G0lW?=ma|TT5P@ zdIFDmPvuAY;1#+bF=fW%#FE%x3whp!{iy=Z8pGJF(V_foMJ+TK-(9dUGp(} z^2mDTUv>t4!ItJU^Mxz4pDn}D3MhYqe2bINX1(D_GiuS5S5D9Zrj6oEdGy=^W%$6S zlSIs-qOe!RCh*Uy&RU=r%tkDf(Yv>dQx#%j?`jW?>%}TU2??jZQ+%QygtMw!CFVSG zg~(L0Z7U9acT&}%VyF#=jB6lajMAJ)IzjNjT3y`&#uP`XgleBCeC*P@CaZsVtuRyl zrGzj75hJe$Wy+bjOw)59d42^+`)^lMa2^tV*DDFPKx_vHscg1-NGxwC! z#I&?p?i*qtOV7!bcD^`_ZtUEiz$tdew(lQj%RykCcUTZvpG5z0Y{aP$S^5K>{2@RElq=2dQ8J2i4jj8LwAx#A>qnBp=D8W;6pd{NFKsQ zz`9z3tTZ@6xw=3|S|o-)$bITcDYqy`O%7H5W)&#d+yN*Cb%sDmLt{r;7^C2K`g@KcHIs{r>|)5O#B1DgRo#ztLYk%SZa-VX3sSmJ2YKEh>{r z{uO`l?M-Z~XU9Y0Va5j>qp|Kh-)@@8IGE3C5X`~)gq^F?vT}#lEy7oBfMI(dtj2vW z2AgXI)Wq#{!2|&cKE`l|K~b1^?J&DvH5p!8S_RW;^k&)J19zzA-F^0gp*dn5gtev< zDdlvhA`ZVdjKw z9Air3%GBT9?}UU!w}loFB96B0Annr6!@ZI5Wr$9%M1)SUVRT&lflAnjp}ARkIfWyJ5A!N8 z8LrY70EV{&92YiBpY^Y077j&cHK|qRIbix^^EMW7OMm{D>bG_g-Y1%_{l;W%6*XLf z?XQ#AxuLi?%h1;RYoGfdaR;l1TgGZ*`VM(Tx|tB-5(wYU>5)*l&vN*?qxqi0921Er zp_(dKgIm!BbB=KtkcwB)mlp8d+nm(}S>jd|$Fra(lyh z^&8Gj^rW-|;e&qXcxvQw(7;^KCQRC-@eW`edWjTAa@j$cf72(ygvw0?L#6+o_LS?- z^U!JFy5?4|m)B`fHf%z$`VammF0h&%xW$k(rc|_|eXj3Zleur@qw-3^tpsdGX%La| zrh1LwOTi0Sv{cfC`7Nv*dg%mN_2611#;P6gDBo50ij2`F7^6BNtH03mvv<652+ygj zG=H@h7|0n|x6u4V(a}$lz0q*n62u-^=xhnQl31 z&l!t-y5eSLB#EK9)7ubmEs1_cRn7$irC=PJE9F`NQVM!cRIZ227r8FA@hDZmD>bn^ zg8;t0imwa{#@XdW(unXXT~D|;=SL7Ek?B74&AgKoryh(o+g?C}A0OD&eyR|dmB!-B z$(9tjmRJxpAk(xDZE`L!I-GULcJ$s5o<_ExsVTZ9O@5BM{+?Z5YvT5kJAf5;JAp>Q zbV!X17vyV?W!LMGI z(o>JxGVZT)E7*K(IE8SN6u@?J`wxiB&hyUDX?A)ZMCy^#YKffhT*U~P})2R31V1W z6<^`2f6q8bF@svZQzHboJ_+)o<9cH!mZul`ovc_msn7TytmFo*|OvKPiazamE$@W+CTWmqyDhpCtd{2iYR#v4`1l}6|B{kJ(>!JU1PPE7N zc8j1IPC^GdLeWLa#7_gmG|P*$pGi59A%koI%;V*g*-?94_(%tp%9kan52N4bsz#!@ zh*692aV7!1Dmj8whv=F{0F;wd66}dTxr`ItCLt}<6yta|{I)4_7kPoq__@AM!m4gv zXeafEnq+&J+`8OUiVlPNv&~@fdD}msi5liJ!&kmZYISaQ>kJL)goIq4ZVRciNif{D zDR$Dc^^vA*U#}S=GN6;taYkYetXB?#8S?Q#P@4=m;V~}`?=ogdYq!9|DROHV;vLgF zK_SoJsQa1hL|2uWSKF9EHM(SKLqU~%gg~WW6xA44Yx2tMfN0rF4-(RF9*gegV?loLE;s%w<|r%a6!ppV5_ztEsaQ-n?L>N0^WXK^ zQN0kT`o592fhdFAiQ+O4ZCa2VtJ@~-t;`hsQZ|~#>A?9EZmTLMa z)@0;s=vOLiw~5yrq#;&y{?_c$-4c}PU*uS2kCb%r1c~$v?os0Ycr=%|?inn~kIg== zwnEfftidh$y}qb9ZX>b{`zmiQB2}zC9Zlx;Wi*m&?EAF|S0hqe<2IZPy$x{Y|Kx4vkVzG%c0*ic5dgx`HB z-;sM_YJUuWUY>gb;#LMZuv}HRO;D86V`S?KtOdog=4L5;$|ZD(3|z5q?@0MXgChJ$ z**C#|!v}_#P_P<(F&-meH&K9VJABIN41Sh-wku5?{X5LfbrVuu;bx8A;L?U>h1;{3 z7E`?c2>AsWZP0RAo4`VFlM(e?G$WfFsw8yzC>p)wiO|HAvSxW$f`RG}p8Cy;$1U)Q z{Hli|pid{*(1lf5xn&7Gy)njq+NcS8Z_6NL&Qtzu!FpyKjbziIe=GnEr$&*5Evt3} zfG%_XP&YtIj28EED#Xo0&mpa%6OM_x)`4l;@QS!&tKgEY%fb>erVmX~i+fTPz^Bc> zsSoxts5G;0)xT48&kD4vV)IadmJ=r~KFZ}LKNDGuw=b{6bNw<-W#n?5lW_V=Z?>(9 zZYooa5e(F1?;AcJ(pp5Y8_7!0O^me_7(dQ=Fa=GLPA{kOZWuYw1ZkLmk-#3I`=+UO zqX%JKuGAwZMh@5`)MsDj%8J0nZ@7IAX=>=+9siQP?723RvBdh2kx;<&v)k zgC{8f_SFR-7T^Ei_D>OHw?vX88R3L-5rMhklbPv}vLJSppq9Y=t8cHRsb%gzfbSQt>SMP8o58-E*t5y&{YoOdLl_Yq zg_lK8%AE1a355ZX+OpG=3lgGY&t`>7z(Pe_%)g%j!KDM_Qvf0$31Zv0rCHl}>l7IV z-h-jjDNu48CE^*bRC>D%+ewdeEr zWld>szDme#%v>U7aRnz;9M*&g9e2fRWR0~_UesO(DdA2b3eZr!+`#8 zt!1qwG?PAuT$VQ!o8_xlojA*-1Hp1X@GqbvhUCrL{vuAe=z+*jNCJQ}~i zY+7}Ph*q98tg+}aY-EKI6lBRhhDq`fRbQMriJiPEmaBqZMJDiLir?@z*GRfGU*Wok z9qUd~R5lZjI3Zv`CSQR7N)jwa!>|zbcpB)i-**cO+w}0kTR-f9>kQz|V(7b^+J-o6 zhTAP@I*Q_nvOr5w>;!NMwXgsz+g}{HV3{Rna5uYgU-1wX9rtpdJ{KO)Pf*53B(eQW zjRrE3HtoP@k_qrN1yLmT-K*=gC9bSF$$pXTv=D{Yy92$wasL(ebwJc(PC`|ym=hPt zbF2x&gAqSVX2qRjcJhK)Zp(daPTze7$$0wn z8o(PZBkI?oPuh?`z|L0%)vCy1z`JAW3ks0o?Rm{XV}N21_5+E{xME=FpcHvHA=06Lr-GD+Pva@i21D^IO8x1i}Nr5*df%dESeUc&hI`H^dm)XWC@*la0tEU zs*p&TBaHNX3lX86bSaA%vM}FV^rn}gT;h2vN3lE_DBmCD+Z(pUt#`8>NgMM=_R$yH z%FmBmj|ncodZn$k;64u(&5E32qe8jg-KTH^hF(R~90I4to?we->S}vCD7<#H1So%& z7R#E*%ZOmCugyR?rjzWbtNF;nZ|p)5?o*!uU#g5w!U-&Vg6BYGIFV5A00dvG?259-FL1Z0poda$)D!C-_&Wn5t2+ zGqJ-j5eiCR{ra0b`sF1gC8+-{oNXM@my|pCFn(X=5gwt+uJzG@B2#zReAV(JEGTys{Oa&}k*#8HJwe>P7}*o9I!;ec2y|=S!GaiC^Am2a1oK`G z=O;Qbp|%f5u@x!QjB0~qoWG%xOT2`*#b>wB@s6LE_qp1bQJas=-C*a;H;PTifmrYZ zkPzThbO~G=2DSJGc8-50qZr+N>m7}OG|V87{{~??XuAe(op_zwEYf5@sQc#DeY^;M z^#tn!^fbmR6uZIu2>sN+-?O=pTgm1HuVyrf`pd#8hM}E6Qb99))9_G zex-i4_H$3Z9fPJPfRltg1J2gvQhS29|_cerlhE1_;8eScdSu1$3R7_Y&ma&UQxu5x%=4R-pls z!$ce*fEE|8LjqQNy}qGmDO;kXP6w6icSum(9aP;)2&visICmRL3q1Ei?OS*N1pYOZs;qi zxuf|H5S3o(Rkzy(i_`xo#0#X?{J@upYaUGr!D_><4Qh zx#HJQm`AvKuax2#q@$hRTs&6!+Eh2Q*IZ*0PegY#rxC&S?bc;)@5B9^foJ^S>RMR; zFgWV|<%a*M13!+h9X1ccg0H@h&+d)j2&+a9jw_<$p+_b9rK`V0gXb|)(WyY*2|6my zu_$-4hO+B5H{Vt!ucP!t<%meX{uT{L#cQoXMM@)68dOS=N!JkIGe)l-o${s?aRb6r zp_H6Ogm{xXM9!qCagZ4Nwb$Q&h^X`Vd^0XyI$Nq)`;1_*jwxx)V7c_b`%=T)oX1-C zuD2Izq&{f%?GS;1EFC;t z9~p)DTVADeA$D!{Omi$D%UQJ%Rd8-yzE52g060wArAJp}eZjKfsq< zTaUklN+orkrv{VWUms9?I=$+@M=Jdsm?wlfb*}I-?+`mn-2T#JwJ&*LV=Nn_blhjH zkk-k4U1W*1p=IxR?$qVX9Os~9BHfVu#On+-?MDQQJ39=Rh+KnRl3xAg`A#y4;hjR0 zo$d~_{FcEKUCF=i%IT(J$mHe?A!%N4Su;E%_}2F?^Ode2iHQ?_c7DoJq1Yug%ajIz zj$dmqI{_2^6N^Q3EIYw$I#c3Q<aR;=m4WugL7#>*Gs zQ~Yy84$CTx~bNnw; zR%I0xoY2RWUi&krk`C@#DWYz_`E&SmLSBSFpNsgLnaTUiFQNOoQ@*g3g=eCV1*?!K zSf9r#S$U$5{ntss=h8YReq7_5hmM>4cvyMn|5jh^P`TGZQh(%`RWFu<9Wdf}aV3GO zNATb#s+mZzg#c}~C3&P~_{bg?5X9~861X~>Vn1Rf1mt>`Df)YVG6N=UR92D`0gGtx zxT_QbOt!pDY^MQl91OU-9u{`O+6o!FCQfv$xt=45WO2V(>C|m9#&yn$C>^ai<%9ES zef(74dDWx#cIhhT=V$UqFi<~R6E*$b6mYxhQ0nN4F4hzpA&?d70SgO0^ou_mQn zmIi5_W+(-6k}>(6JtIZRuwKH!@6DHG&kT4oY!js< zai#me$ZKHBI_KeXNgei;Al0=Kzzr858lsg3&2k`#8c@eetj}#J3&P>yY`pXskQ{Dz zzo6Zle>+9p^Vg=bfLzWd5hD$vo9_KCzXtV(q8-hEm%CUN)-|r}p+sy(3HH>#mI`39 zhHdDyzEQ7!P#|)oTGAxtH0UBTS3kplbdOyVy5WzmOhW+wYZ?!Vj%Tq0F%^(X5RfH- zx{y-e4sX)fFgvF^^Y_H?fWnwO6!XdherCv?#mgFFO{@Aw5_ai+B@OgtBY)pY&bOVq zXV79(Ca@HLg(YiaTr4z5Q59po-4$FPGVz##m0Tnwg0&k!jVhS-IYdd=+Tci-LFRMn z6SWKwU_s1F7E9ca9KX@o_(K3waQ&k3Nc^5x0qihL`uuh(DJ4yfGc2pMA0Vxip2qKd zC?N$hOS;8o)~0~rQ}VX^jc#u`}B?-FJLDLgF~6(4rddfe6s zgB1Kw^#7DV#Vr96Vx08!W<_|%33pQnRiKrNW)br$s+qR>}&=O0^7VaC`B>IJG42Kfb-W`z&$PchU?}_Qe&rH31YZFN7gN0 zxTMQBb=bQY+u}Vl$7iWBji^?gH?nxTXAzi7y41O{s`iw6#be+E7nTGKkK0jV#e9%y ze%@*l>;PchnGXo~H@<7iWzp<}pmzAxJuVNiLmJUOgDR}rqrR`+5U|qhb%?iq_FQQD zQQ^zobPu&F>HOD?OY-EC;I6(8LC5f$6tmOg zw~kRLx(1qUW5vCN%$rS9*BvgPq3^) z5*^%aE?rL`hbOo-xL13F(2c8ZCH(uP;V&(Yc@+f6)k!{b?F$pNk=zjRncBxp~Hp`TR=Di6r$dTC%z-%mzat#8U*S|&^0s9gGMF_nN-?hhPlCH@q2 zY)K?d8&We<0(6BT%}-wCc6^N0lqUdk>qeTv0xLj84szOzW*mBr-Q%5{1~w<;*M z%3U%>__4o*9&3cW3eWjJBODkhWx4ggLd23Lk@tCq!G_me4C);P&Q z;dr$DxIN3~fP3yZx^li~wL0z2F)}ho^SUO#Xf&s<@%b!^CWj8aSQKCBLI%F?jL+BQ!U~vXg;9;O1e4^TN;5_pL&82RA^g6muwx`aq{0T z8{Y~vMyj_d<2$ZOxH_xiI?0Tc$~z|j0vd>a6CTMhk94P6 zrE?2&+j1b&g^SG?l$gFJ=F4EMJD^OE@)loPO1NTf1Tt;f5COPJa6%gA%y<_XxUKE) zv9{#QYIgl;NFX*<+ER=@WeN9 z6~74|QxGEsJ<0X#M?CX{1u|==8x$2rt(GzJl0o4ql!4h6UiC9k55ldgHjOBWr)hbK z-ep3GFION=a*t3Ln9!GlfyPFRJ_qY&erJvo55^>IzwF1q=E$of?RK4lr2rolj#}`H zl-)}^)<0`#s<~=sLecf|jD0Q+=|ZlRbiX4J)lqCCLilzf$p@ONJaE9b8*4m7CuP$ zyv}#=(H-yB9{=w%WvvNY#|uHx87p!T2+o4v-k7Jqr$EH-oc4>W|6pV2$Om$1U*Yw3 z1ce_dCgbTls_kh}Xpaa#HY(DQCj>Eo3+u-?H~nWb$J4)XNB6$TLyr$k-}|e#;0u-H zs{YpPTPH$@Ivvt(chgU1>~4HbUxqm~;QW+0bFDXzFi;!2!|Jp9;Nf|VVjPpEStD#g z8fmjJR0hO5JT5D*!`x+4j6ozEP<`pQjByZ;MD~>BNE*B1;oXE^;v5OV zg5BEAX5;>nix|k}1GmIl7~oDiG4zIDGM2bC^7qsYq3KNAhO+ZfLO21|TQ&77EE8Ao z>ai*xWwc$#ai8Q!c_L1mud?aH;p*Hzoo|V=!{{6-Cej$eGq&|8G)vsG=M;;p_Ni&3 z471g4k~|~pk9fZN*B=XWP!+=GJ;mT!u9u8$1l)yBhyhc?ho#mm?)+K0K9#|Rgs~5l{3)Tkv8*a8(pK<;hnBlyF{wCTPJ+t}&?zHIEo}rD`OvVi2^LOBIy|9v z6$N#MS#G?IYf!ObO_&58{os8)xH=ulT`XPO7 z0-t_BrlZ?g<>+GMxwjPLqQ_A_H`GZ2`?jJdWsUMk8rFr=I{BaUcOFfRbi9v*r=g946g z{1x#7jre!Z0j*MzS=ftR7G86*$R+Ja$xdkD()vp0CG(bJ^DePdqsK?*N!nhx_74Uo zeyAn?8HPUBlJV#51zVX#Ce_$kBxi8PT^?c8RD&Fe3_gUTM0$dOk$p2sk%YpV+aCtf z#luS#nBw>)c4>wx-m<)&p2RC6>5I!@qm%Ylb$cbT6S@daV+XOW8Gd7dEWzN6o z%bOj2(++N>`EwB{ZXH$AXoI<(i4M6Ekdo06-(B?kXb1&$^5U1mVjCMJkOMH`Q}-0E?4#_nvM8g8{cDY5)#7YTCx zU7(b>`Ck6#-q4^{yVdcPF{RYoqBCJx$wQ*ruZL5JYvK=(SZf=_mapZC6q2)hoLTkg z?>n3=ANvcmZLlXR7mX%j_2zV=Q9f-Oe`urAoYMMmR74>Ym?6JCEOw-`flK7Usu-uTFEagmBy4<^kOQeQg?=C} z%%Bdn+*f_`${T0>z@Bl`UUWhh>`Wpkc*II-aF`5pyy~nxACX%+e#5|~!Yup=7z81a zJHiQ>@DJ9&d&aLnVQ0hqa*lstO!C9s3mN46B!afsZ76AkEZrZg15K33FVX*k1e*1n$R zr#{(Dy2kNe=p7ST{-};Cdfcj7ZOc3s6d1V@?$cqlVVneg;!qi(9fBmn=W#dv8KRQD z)YU~ci)f+U_L9~<^iVQ?mVDyV6jnS7bqXwu-7V2#wWe3W(+Oa73OGxUL=@l7FJwqsKbG>Vsvlzm6*j7@TohQnq%+R>(yN_{lK_S}dab*oJCOlZL-VJi5_iYr zryb{}2%o$XWtvit897xCVRu-oRK3x;+g{yV2wx z%-i?ZZ@0(6O&81KDzTWdxby1GH??ll{ie5Ob))uXw}$DpF_TC%H0CYQr}jodEb12# z(#K=t`}eXq!Nu1(^^e1$(qI1zXm9lY*YcZa&PtapUNMJU(Am6~D-TIPMm(mg&f8-) zKB3wt!)7M0&cl_NMBB%e{BEjq&(-bWB^@ptWSGv{P8bU&`SKaNyiidGs&oCR{J*V0MtW?p` zJuLKMlBp{;VEuOGMS@Gc^J@LEaP&a1?sD{(PF-ycJFA25KNAACkr!Tm)xfsPN3(w^ zqM4g5?Cy6u`RXay}ayA1h2U2o6J?wBJYM7Cm=DEpA@rHY4(SMxcp zD$vU7>?Hbc^Le^|KjMyL-`HP1utIcOV}B80{Fd8aMyxP>%K<`p8Dq9G)psL(@1LP< z@5lXlDqwx1RNj&fWW0{Ncq%1`3mHbu4#KU<|A())3~RI9)^>3zE=7t%ad&qp?i7l< zySo$IrMMO??ruSgy9IZ5r@)uF*L>IB`&e^*KY;uQkb@)-_ZZ{6&LLD7{JxG&ybxb0 zfVvz!Bo+h5o<;Ee0JiOHr`c_#FDc{4lk?W+@n%FU{C`Eb82G~?6Q5G z-MI(P?TvY(7sY}jDnW)`G`keW`nsT58G=u^0l{Lkg<*nfERDN1?6HRo#dO!YC) z(QLSGldp8-?PCQYmRJ30MX=h~UT}`n4XQ3Hcl?tb=Mdo_ob0bs*kDJ13bH=;>D$$9 zs(h7fL$Kmhu;G`q&98HFY|x3RI{R zq_Vyu5_>)HwOZ9DZYjVpv7H%ng}a22h_nr^zyxknDRkN_wvB>wVkg5vca56I_F%-i zt2U|k?CQj8V;#nJl(FnRIndMco|W?NdJ0vv=FkS*a^d6`;_=k(-O)x9yU!-)vHbJ{ z67Ap3z`vr2Rmbag&~_eX;C5d;jy6<62LAq3b4sy^+YkgyQCsfG5N?R(5X@f0BHob4MDD}Z^&WGF4EarlfF1-FFZdPTt--d2J))I7uu{iOZ?rr` z7fplml?n{yvhL#%XV3qgeQ6M9b=7Zp8&0>;O_=}tcQN{x5j2>2-7VR5F&4XR`O)Hj zC=5Fgm3QB#n6@5Lp#oL+4I@*j!9&1U)*q=UuKRu z55o3&v_eW-uC_`DD?{z#YmOO5dSB|WoHW~Gu#R~GsA zU;w(iM#wl(AWz%VcapophzPS8G%?@q2rhOnSI1t|7WZug(?U)Xl9bLNfo{?{Y6jDK z)Do`EY2OxwjH4k!o~0rQyI9ditfkLdNMckWs z0o$5@x`0J8M;U6bikC2et;_L1V#L#@ge7i5G3yp$)mQ9EF`B1XpF#eU%dpnk)zbzp zIFjPv^?Ka<=znG*6SnzMoCkVl<#Ky!e%;{qCK9H4ny9;+{zHFgFfUxK>v_C!4z&%K zQ#${vR;^6;&}EL|krxYiGQSL*IFS42(kStndZzvtS(GI;_7tNqa>Tt_00nEjl3%+K z(gA>-kEsSc45ObTiI~_iW(9+b1`xJZZY=hY+WbAt95&Rv%mzPvh-=ILeif%}csP2q zyG6zynd~0RgR-r z9;usqlM8nj8UhOkJRuP`@!Kibc#+lyZJYXZxMvKhmU16^$rRE?l_M$f@%9lJZdh~7 z*#P;`13xsnHScB&KkfG`@bJf(ab~+B(SyUT+C&mvhKWPZX3MC>Yd2RxWVujfm}?)YyLeV(D+jaAA15 z19$Bj^sC+K8(^1ZLt3hg6sEJ+e~WGl5xX>ez-Wvi`hO{FoRy)6rGL!TxtfOMoz?Gh z^z?(~W^UGp7%<%o7xj0~`oh-0#q?&>>Bz<&7U|nDRGYQa@q?R#m1HaO2)XGG?Hik- zg7+YWr@N6qn|k0kOMjB8SxDvM<%umOSK8v=h9rDr$UFdZ(cAkqa{bo(Yxr6!!#i4y zA1_}>?PJ$M?3fRAGbjkpH0lgA_IC@Nzo5IUx3hH>B;)srInpwYKIW(!x&uvUzH5Hr znIRunj0D&OhAx$<33Wyt5FEi!wC5W;#tP`Y#cun$^<~vc(tR!vMSRKmY}v9~juC^NNEoz%lrOSe>S=^%?ZC?24S1vir-0i1zQgn7zxVO~*k>R; zXh&IOwZFf3dTWqg(UoN*w~uUh+QpuVHQ{2$8|W_45tx_oST!=0wQGL)+L^C;(F;&Z zF&o32T%FkN(*;M;zh#6v8N2X$_cq-Irpu96S1@#B9fYMJFk*U!xeh(^1CBMA#pyB&oEt~pW_pPZ|FQpFWPDTtUJe|$#BYa=^fIeM zRnmX%#_Bzg((lgnV<*&eZwyh4-hHW^W9@=|q*ddMBD#>?oT!W>28j#}+()UmN?UgS z1k0Bq0(qj3GttQpOjCZgis&FtancDZ4t7C?yYokPM7%l-Rq*29)lGNWNw!MN_xV~p z%hhhakwD85J8@ypRfAW2+5RQ)qx zCx~ySv9-=gu+#YN27@+pxK=%Rbzo3Sp-cELCcM%@=3)3Zy8Z2DLM6sxK1Y^p6%%)FN@Iky9~ge4Kq&dV zaFzzHz57{Rn53AK*jWB~L&Kh^80UL0Wbl=?GF4Y6@R(5-40pcdau;`@Qqqgw0j~>ihF9h8$9ynJOH(pdtE|G11pA}% zN|wc;!AL3j_iN4-9*Rbq2|}?#9BpSq@_SKEH8lDJ`d8@#8EzWifWil(2d0k0fnfVlQNIz?R)}&^h&6euJr&}2` zP))X4q6B_UsnUL`**Oh}t%75qWL*5dhp0%&(XN?-L5*F(8tC8dL30w0tS(fLkLY5|AaDhljipsi3@$Sd$*EenbDpA>iM_Eaqo#xpu&W$yKBj`y$ZUMx zi;SOkaUO^A2_Qe&3P#v{m=;+OkBxdHW+Hc@ouyM%yd-s9aX178F$=u&UMaQHc!K;cy*7vaAG%0hR~)p7 z{+@B&`Yhk02*NJ;Oa$wC?nf>RX5?_kSrc~b6I>?a6AL@uKUOgJ@^ia6UGMfhOy&CB zCCgy4{uh(*A3jGrU~IlZk%5?C>hJi2kHtefj(;78gj{|cTw?3V7%080`}nfha)Tzm zJX0fs^L9dRNAr{M87@;f0nbfoe-A$S0cN>{L}!FKa_KuC?4vA*-}lZ2)2iQ-lm1wI zyw)^kE~MqX++4nO1o+;+0{#(q{Lim~J3b##Di7LZSAy-6k8SZECra<<27iC9o=}~2 zJUwkKk-T(uy;~Vt?t}zfA9j1)X4!Xq+^ihl#e19mTCcoBN6QN(LGcHny%$ftJsPNh zo<{Tjn%6lf8wkYh7PsAMlJE(*&Jk_?Mf$%y2)rf9paeVNj~2E7E3fw*hqu|OuFI@$ z8_BNx=Cn$wv!+ zp6}8Em>uEnzk0e8MDvgN?`GMR+Km|B(;u%?7H%X<-67Ol2+4w)Qb$QFq7`wSmEs6i zyyg<=yYo-Q9foJCb~A^Ws>Ybce;hLc`-(Q9fCkYjh*Tv`a9_xVH+>Qi>&WL}dC5<< z+nf-VF;k@rH*-UoX~@t+3c9t)%+hxK&47kF#-7KA)YFE|J&(PRgGyVz0OV_ly$4(h zQfl$M1nC~?@NQ^PL<2Sfyl<9~sJf9eaFpyn}r z@Yb{TXec3aiE^A0NWbxDguwZmjnKADS>zV8V`3(=DK3G_ak~gY`K_40mX2R=**)PM zdHJ?g^oglqkL5N`v8GcyQ38aSQVE4hR8p#|yjJ<0i>0T@P|5>l9s*f+W~CeSL>eVV zVp|_5=mu9d44HdyQZ630DYhtOkGhrSSJaUF6B6OMG~+CcUnC>h(0DTHbnhLs`4dGz z%0tqtcF|@WXNNL|eKg}Zmj&`VA%4lwfKCba?83Rb<+l1BO%Pmvph{}W`Da98c>cY#h_j! zflP%HoXIRUOF52uERj%Y`l28N48fX={#65~wpw9F+V+au*Zz; z#I-GOV7cT-H-C0rRPI<*^c}%Z^+IRbm+k~zA^{!qTWbAtl=4kzE9tC0+x%VRpwU;N1rSgL zqr4=cj^4B%csNh{nO`@WfOttRNO|{PSE;Fhznb8-mN=gCfwF=C>-It?aCNp7Ij=hQ@-5DLUbp#r%q7=CU_gV`}zF{7Q zIn=<42YTL)lR(MV>GaX>s3!Gw?P*7s5GN--B7 ze&D$ebh2V3()oNt;^a835IXlE^-nJVTJA5A&yCLw@>hO>6;TF@K7a&g(JwiJU8k|5 zAWR{L>Znv^=p7?!Xw0>>>+iwNar!EfZX&L3V!dYo?DzQ_iV$3XEcE?5sT3{9L?Gos z1r{RiItKJf6IT}U`fSgKq5-cVhX>$HTr-8P{|7NWL*~*O z07e|rsYY091jkMfQKAflCRNJ&>1)d%BS#46$Z8AYs)Pk!ZUSJyd(4J%2s`tCrnNU8 zkaR!sW62r740ygsK}tF@=LXwl2$PNtLn>G;+44=qAlGGg)dH0VcV?HfKwAA}Nl2xH zdCQz5R#b`y3va>@t#Da#T>x@I53+3JIsiTH0Gum%P3N0%P~pwhfm|~C5mWLap+Oi> zsYG~4W!RHN^t{t$|8d)}F@ux6Ef{ml`{O$HhHM$f>7YNBBL0oBx8z0fdXzrUQ`xh1 zZ%hCAvNn20#o|Cq0XImC5%_R*VK1_qrOOS(y;NMOh%G%5+* z%q7HPzH{Irmg%^F3(;kLe1mts5Y4Z)hF?z7CFy3hn2|TzSsbCz9bR7yEc7Vkelima z5{quv+~)x)V(!^8#Aup-q6$AhLV#X^z-9?iXoh>zTP@r}ZPw(%$A%s$gye9_7_;h2~6=|bfFA%uz)>J>2+_wYEWvWeSO^I%YN zE$v0?A3{8BjGN?VoK!ZX}+Rd5RVeM|4F{3Udc4P@h8wmdKlTq ziFRW1jK6sv&EvE$l^S|3_vr1Ebh{yl-wP*KwUqfCwW1Ry;?FCIISw~d^)K*Ysv4vF zpLVh^KQk&(7GL|V$o3@er<$K|D-T(cJxEiiKVQFf7vtvnpOt=Gb3ZS=Za!kYpq)Z` zFOs~{f0Su!t^de$;B5Z1-#7C|e8ubYqCdC@N+q~0>& zSpby%-^8GHE1la7cj}1gs+8mP`qtSD*OX^7OT{`~85#t#UT^VB=};1kcyE!T`5vV^ zkQyGX`i|=&q{^`i=7}cKG^-C8;Ib(GYhho$xS@BE7*vWp#_b?CluO(SrlO#v=o-g_ zFNXnsi=$+b)b`vch@hexw9PakP)_jp)mINt+}IM^u87xtu1*cO?skvVhHbLpx!_iC z=;POqY<3MwzzoK1Y0W6JE)T_vN%CYlmJl)19Gp)t_o?>LHQ7ie+D$n~E}?J|;NYK; z!)2JL6Wjf!9Z9vTmvTl5_^^QP8QOfLI@P*UCEaV(oXs@cqo?%nIdy;ChNzVXQnycg zZ4-AEV54fNm#Y;@W37F4ot{)A*;f&{H8G~AB(hzDX)AX^QH6m?{Bv*@wUV%SKFfc(5O6_72c=;c zO$uN)&%*f;D(bhdWVzC3ruh$rnrsW}% zAio8Z9Q|z&HAtwf;M?Gm8nGfnr`Rh4Qkn(>@^`srsaPb$QqEg(ZJ>-I5G<-bhowin zo)16UV>-#QZJ9xXRB%j_eGt$$Q6*QfX1B>FN(rmy6*D>$VS{+GrVGrw)0&I=7fzPs zDmOX~PAh_-jFL8j14V`s(xYQC23ztDsnN8ek|2z3n=r(Y4ogrG^wB|ozy7B0%v|L) zCMQNbC-I452dIWpDO2m7cP^i%k(0IryaZC5B6^O;#gzFM2+AOZ{&;didOVdt8J7{j zaBza&exXCJKlg||5!M_F&Afr~0fWyy8h3tOosoC3sCv2c0sogt)M?OZwMc77g_+n- zAs)};6Oe?~i|%?s#T54ct_%F(E7z)s6w3d^)G0Lozf+~JpMwAQ8PN~l&8>F-;D0+l zc3!cbd~P~vcc%xI;z1!2g=P) z{sEE+h+WyaV=RPgM+a6dXzgQN!VOGMw6@9ovTI$?>_)8RSsleau; zVyE;5IH1Vvna8YqH)>CMH?*dL;xxuEnL84yTUnj~fsLR<+ z)Dox{t#0pa92y9!}(s9 z%)v4rRBjArNt4nw$oDG^h-LXYXvwX2wmElXgEbmxJ%<{DR`pa-(;`xWt2Eh0s1PRc zr+XiE5>o#4GUA1$`8&}Ef{FOCLlsxQIzeA}NkbY&_o)?wc2EWhso--p#v_$9x%(Y2ci48c@x0%ZE6XsO)~`h^ucr|E|SOLs`jMG2Dc3pJm`P>mt8f zLN0a-qOZTik)F2**b79!TGt1n(pc(0+&Z$PzGv}BV{lkFMddH*shN4sGBn||{aJ}6 zILB0P_V#I$4vkiRk^x65bIjHM;27$VVnN@A zNG7a%3q=dI4x*s^w{f-gJ)yUkTj38`A%nch4)98EHs*Z{;5S$-WvJsvE@_wH2%+*! zY0Ls!SXI_N3X+4PtISV0+KU^AexM4INEHD_rU6IccUGxK<*@#4f5Fx zUA6LuFW(t?LR0d`b^RU7kn2Ige+*EERLw>2o{Zx~0!QX9_S9$DmZPMu5^I+A8G7!J z0%;!oB=R(3E84VJU&CuRXI0iNNBw%RGw*Zd%NKDuA#^tA&C^JrC2HJ7k5cxT5NaF* zj^J%|ibGtWS!`S^_al2d^KsrYumV2UqHrHL6EH&+k|29vj{~lYU_J!)@YEk9<|~Y zu>6eXO99X(MFW0Df-C+#{=2%aeE(+`^3Kb2Tao1NMBOeGJSY*R2P9BktrgXlRk@qpZN>{@8nEiFh#6V3s8Kzz&q&6?d@hipPekb|!n z8cEy(qHw4Ei``c=UbSIn@rjxP>cg;0n1K*B^RoQHSmf!yLX<;kB!D;T?O*4P7t01R zgu7gE#uhH#uuQsCK5Ecb!Nd80!wd`tn1CysN=br#4+pWSO1zLFm7a7^V5aceiYgJ`we3g)KmvgcN8W-scZK8=Pp`3OfJUn@Q*dBBxDcYtxBYvD!;MmddA1R zZ2EpsL7c~;mZ>*KxH8v4Dq?)|CB-L4KFGxljprjaa3Hj8iYK)u-OlCDz$*kn`Ev~4 ztI0&o;V=^gyz5-W2eFdr^;Nvgt$DW)ouo2Jw*wO5)n4jndsM1Ph$y@J09tIn7)WwS0yD zUwc9|zoRR|k{fQd;eocMGmqjhf-oyms46bBw+?9=)j4(}4wCH?YZRadZ zb*V%LT=k*gvfC3vUKMynzlk8_{h$ag!zGgEbz*Nd$hmT(SZ3B_?aUv+L>eX%`_1=Z z>r5rKbDye@VS{mKN?6S!AC15*Duy0P#iNoVHFQhDXBN`HB~Jo%eP)V)s~8Py)BW?e z1a69Q;OHr4d%;}vQSdBcuSBTok0)7+%xP=33nw$@lfRVq^u8MeiBM#|CGa5+RQ($C zRWH9-ZFE9k6cW&DMWw^Zb<-?C$p@z#=t}tq{IbD)M+1;XKD6womW;4=v})xZu_8^Z z-jY1V%3 zt>n5{L`9P1N37TddSqN4`WQa&V4q=RbM2k1sm?T#)XRADFH|5E0*#2Mb&a9~xy6KO zQMwA5^c`GZ+!QnB+X({f6H-@-ryoEH-A&h2Us=VO%C90zLSjBBHP*cqa$lk|7dXfP z8&4NN7u2j7-_AW31Y!%v!1;!*0TjiMqf=`9Hp+O1S>pVS$EK^aoMnOfYY0QkuP!Pw z3$Z6}&wLS@!AI$)V*PD-x6-M8U#VlC;*DC5sr2%2_TBzvXH+&f*#oT_ih@upCk=i0aX5 zcL`5vir17nI3)2~0+YeBK=-%Bz$$dEKs@OQ>m-NISk*AmQ+{V!XBlVjf;YbJu*7@(kys*wHSl zQ{f>ppuE+E60MF0qgZxE!&r%O(y69gdT zKP|BT5fAd%jUQ*mqaUKA4pt&~RTe zEe-jGX8|wRV35c`ozR`ao%?6tD*E)d&c6SOB>^WGE`Vy*{lVM%fK1Bt>{Vlm95x2i z@MrS(NDKtI1?q*FJ+dOWm>V;*haBjebVhC3moFyC+f=ZsiFkn>(a1|2{1rH&4*Z)W zYNgu;HVqD#2zkD@6w&tn_~tT40%cp=R61rkqlHl=i%3`O3 z_lPCzRLfW$OUA*0a?n);7iv5$AMmLgZYGWO$^S)u6)9L)5M zbGUDXgxzl3lB{q=r5Lu|0>RX?oxuvjYg<(@1h|&r1S^K6e4M|P{m1USWvubwUE^AHc}t(E=3Lw53KDdv5UDTN$jO^-#<_J~!D_31>-( zS@PuCd?Hii3q3BIDuY@(7Fbh0=w7^D**RLT-CShbIPRB=Hx*F(Eo)R4aljz8%J1E_ z$c^mN=RQ_5wG|n9PN~8N5z!Fh!B;Y>ZWcqNyru=jUF&&~FkZFeUhB0zb!rL;6<*YL zpJ?{}*!8y{qL!#wnMetKBVoxLHLdqXt&JQa{COf)qLlfNOwZYLO>Q_=CG00tMh*?AV4CwviVY$#xu-5?WcOAIVIMU+jz5jFNIfu(5ehbA<4S? zXQCYDJuh_Z6O}`K_ZAuD?CTd)sPFI^-MLaw+4?@(R$~nvcIy3hX&E<(+F+mH1tP_2 zrWDMAy=4e86ze&POG#W2Ez_)?C>iiY8l;O^!z1VLKB<7 zSOJ>Y8o~3-3R*L;e!^RoL~N2ilE83yP?o8H>C@@dy@}Mc*7pO%5fx1O=P$`si9V3m zV)mx_ELI7PSNsIE(FcS=XEFNaKf^B}C2}wzGA}u+4M7#0JrUm9^%bE#S(uV;m0kAt zz&C(^>| z%J0~%5r~CZcOEeH6$(7KG9xfir(3>v;Z7UMY6|gw%_q_!^h2rz)r)73?oQTc1*!au z$bXPs7|aY9bXv7!F&R_x6k(IeisGXw%^*s8qmK3Gq(1Rb9~n=7b{foGNU3d@8~|*u5Q_%KKoq-5+pFLX&ZD5%9tN?p3O>PlN5Bz@ zm~1RIL|#sVr0akfN;gOc)fyL4#e&cE#+w^(`ip;56;=_oMK90uwIt)--IOgzkwMm! z$C^GW{GJsWo!eP$jUl;g%@m%9`X%hbJXT92#VT%-A*!91^>x^hrTAAN99FRN9-|}Y zTfL>&HnoYvaMGWeZ1eNt^%O;aYpRciK*l+{+KDvCL_`A)CW8LC1*9TPQ6pKpAD7<; z#k1ryIO0}1*SZy8mzTGPd{L_q#O=(?Q+E4I!*n7V*d8=QXj_(+XO|4o+Gqtj8sV&{ zu!`|^VL(D_%|iFN)AGV*9oo0TNT7qr^~|LVPEr`XQVA=CjI4nWE3~fi3~+)++u?K4 zt#VRrQ|Xpr8IpYo0ES&FGtYV#tR^O!9W7kB7x{r@5kTZPh;`W~MnjX6%BD)E`}DgD zs$-h+sukAKs|qeh!G)AK`O0n4X;Wd@RDrUftP?z83-%waR|xa$elGt>iw{oi(JMh! z7kMVI91Mn3)H zs)*WfJ#Q*1Uo9{p-;vY))ilRb^cATrNS0E7i_10%9~iAqSJgl#pIeeD>B29q3f*Ah zIm{aeZ;l%Q;lPxUM}C&R1RnxJP0C5~$X|4B;e+o?o>mlkI3Dl?z2Q|jRPd>Jf^|{R zAwU2_n0>96tEUw$gBl3Q+s-hYH=Z@5Bz%3k` z8f!L8U>>+lwJyW{K9jKGB#=J2l@r^USdQB+(s~19cq_rh|3T~7S55-KU2kdo`GK}} zAZ3F2RQeAxrmCf;8IxKP{(!bRgF`JHwttr=sdKEY?FM5V-7HFv0fQg@w6@eoc=L+f z#vh}xgLt7WQZt<_PbooY2d_T7pE8Jp35phSmA>nwPSm_tzXB(2Wr?|n^o2E!Ro~dA z|9acoA`YLdo*gB%MH<`Cb`{&=YOj#3E&gg2H)!2H+VaKa)3?HC5+{F)+l= zA*|@%72)ut&s~2S8e?FC8F^#7XvuTd2Ts&E+Hgy@d96u$BOSbe8!d05M+mJnWRkH_ z@C025qPPf&6KOz?#1+H`zv;`q0~^|{h98rRG;11JMETDdqLp2*K-qF<)ca2gICGRn zMJzJU*is=z3k|@|SaH}l8T|IJUJAw5PR9hwZXNIW+F^#cA=uOGjFcw35A z&#d#87=-LDrdVr+mh2+%@Y|oK^>Eq4{Ta9%BpG=CvpZ=JSsP9gPobgAe=)Z!k>Ic5 z2(G7U?FWym_H_6i0#R0L?v8KMqP^MiG3ab>SNeioOf(6PknQ(-PfI)=ivcOeEPe>vL5-gb}s?D(6Q zlf=QO$!-WeD;`&`6ajImQ_#M_u0#sHs1+KA=ev5n9a@PvFHDv@`9R!mN}_0f>V#8J zuG}DEKtT@f!@D<&V+J-SXSlRusghj3{@nt&vw+H>>~Vl4bcSl+dVqru0M(#10YL4rI- z8?tiDXBKbbK2sjMas1wb-U0Og^L&8UlwVdQp6z)5rQp1#7Jyr%L~RF!DO6>vJ};V% zn&zH~7?*J^8o4Y5;zzA1K~+mMWw5tghR6LcO=LHI?u+%yRr2WzwS7RKUuk~xrtWX= zXX>{{J?!u6x_WxqR-C{8Q(;xey=?LCpYb5k(A>n4)vda_r{{3E!|$d!p(*s7XU^Qo z(fzUPBlN<)mDl|w)zj_xJU-u-jOPDT>Q0mQo)gej#}{yS@cKZ~wqKF=QpMwaZqB-d zWZ(AMr*q-;Z+z$fUl%@=)GGaZ$Jbe8Y0ppp0I@VUhqhO}GyWK!lZ$61*1x4EizjJ9 z*CeiP({6rm79CzsYfHkn;E##_j~Mg6Z+6rE_i8;KV@uZ_lD%)GsQlH#)zpJKSs`nfpYGyWW5^CtA1h5 z=F5@E%kAsqe?=k!9yi}FWy|+hZq>pS>$rIo_1|Ig5iks!pWm?-&Jaj%%HjJSTcVu^ z45mLz;NLIr;AT8qIVsk~&NHFdgZYJMwM)cx@G>hb&YTrt7~2Z?09P-tciq!;zmC-U zyhLK0H+;F(F-0E2$@_NSFNd>t82xwKHsIX@VyEx^&{>5DT}kg5YkB!!#Ehj4bj##J z4#WVKOWyt{UV$r;?aQw~JFC5oiL;OJKK;>A-BvMmVRUZDrO~Ud)8hU>&*WXN?Gh(e z?s#0k3eUaIU%!Ka&7x;L4@L`G=RiB(^GF?%_pv}8msjD+tPrQ~k9$k+7QH31!=C4a zq)gdQr)e{W2-|AuWu1J@*My|GIqxFI{?WMus>dVd{!r+=xFS#Kg{)c~^DVGFp5ABA zAIU9gD5~b6_nUCbjcz+<_XBq?F0$_KY9p*j)cxIh$adWV53}G%GuySl*~Q(ty{;i2 z&~R(8_+%`TfQoP*4Sg`?em)f9<3VWckCvJ#k_OrWMtAXAr2EDg@ zd&cWHFf4O8O&ZYYd6-+(J}bFe`zo%6U!zBOVGFsl@&~@S{Mo9(?+O3{qL>mw?I_SI z@s5lb#?03sYfOs$)~G5ndDv!0%zJulO(rGa(c`V)GB6rSZ)1Oj4^%+iq;GI+(Z~16 z&%ifa5(}`ga^07aE{=Jwcol~DS;V}St?Q3n%Xm++IT{B=eyHnkzMdjBPfEx{El}QY zCuz^eEJeRC?*jo^UTo_gwVKEKWDue6us8b!0eeiw7-*0Z$AAJp=*abZG>G=M9zW-0 zzkM}K?t^gmb=h^OG9QM(KuW-V_uL;p8oCYibpJs6Dmd<4@G)R~jDCWvJ?6W{S9>Md z%e9tHR3>)lX0|7Ue*RP+4cj^s;9Cq&FIt#Hpm*fMPfFzv$x26P_UB#aI&O|0xQj!Y zoBhV&ioXg+9%v<3ox${Xj2i_HaeZ}TLeA#BJrAda-xlyT9S^ZHqxnHH zlg%mJ2a$XEvUNV@r|eV8ZE(YP+CdwMmA(Eb)Z3i6*%BF?ES}Lvm>uC++`@9dbs*PP z1{ZO0Mx7oNGlsI+KeTnYaR_H`zW=Khx2OwH7Rj05B^f5BYvgT>lE+73n;Jh!fi}5@ zd1YWa&pMk<@U7$iW+W?9-->%s1@WRqTc~~-4fo=R{)6gAz$)o6PXKZ^2u_D9_PJkJ zL+~2hBQbs_E0O1ILW8xVE zf!&M|MbT4gwp&~{y;$JI=eSgw{7db`E@eCh>iQT2;8hGxXuKHAQ{BW7&Wuey!f{H3p(1!B^9er| z{4Om7w|ZaLR}KVmPMs?L6e<5WCpG$qcaxZ{c{-^u^z`HBuA z)?wDqN@+=?0E?-B7=0>Crl;P;EFR}yz7Kr0C+Gk(CW`uP-*!aWAUQF_p7@xRG#E&; zl0>Qw$_*1JjKvt8=z58P=G@250{nyCv?zmdOVQ}kb<*L|-(GW2j3yP2 zcZH32|K3-ju`wTCEn^37NYQ+Mv?yyjt`~)`F|Xuq3cghX?whZ&-i-bD1BRqyr{04 z5{Vtt#vCrUbXJY}xCw<@adx1|A5SyeVS(}%$1(6hI3e52L#~}t1pAW%GgMp*qSEir zFc=;FkhaNq7EzokPoc*m_l)J_zz6Tp{(UE`cIn?gPRU713rxpF-G0idCii|Rvk2;N z#3E?=1%To2PBdg1!jBbayq)c z98caeiB9`L0IDX{gU1u0 zh}9+Ec-WO{)3TKtQyKYt@*@r_>Do}|+p-9^^(R81HhfZ;_{OfJr=xF66LjXbSc(}$ zUB4pPgGIhbOK#DvfzQ$)nBR7o+_fv)!91n_Z~BbgNE4v?10MTnh*}_yqN)$p>F*_% zPCPR>@rKTcB%7u4hhVN;p5O9O;h*Wyy;mdArFc)0@T^i`&)r4zQJC8`ffdKYcIG7r z#%Wi_N!qSNCGHdaS8EY!Ax>9@V5}PL($hLp7JM^GWK^Gm(r*MzRi+Qd#w@joq&H?d znF&T#uKw#?<>1J9A%miVO<5JDw(j~GmaUts^}`o;rp!+0rEPOYc;g}DBcvKsw?r^_ zLrMjgkVmi|T$=pi}HJ#DQ$*w~ur*mcT& z8EJZLG3drLPjHABxTH7Tr9W+-bxCHAy&X_%?4L#^BAy>4IMymyb{xo^`G_XoIhFIKwnLrdBKeg*|pEAmto zI)AQ_QxrfQ75ASe2h>N$Idom5zip3B@>ON`ZWODxVDJa+-2NYJF|?g;BjRkBbQXnO zN~6^*oNN}YxzY8ySoPH^sL}fKt__J3w)^Vw=@+&(hfbKy+u0VuP`jNf+}IPU|D-hc z)VqGcM%Xo{_-%iT-MPel^wiZow+QCCb~+&JQaX(dv?(g>txN_P7`o}FVSzdE@VWwT z^Y$-mgW#FN9a^jbW!$B3$p@&+fwJy8?t&gy|18YzKdJq$+js801}$~9mi~B98*Du! ziXtIJpQ5d~H3rFMqS#fg`37nIxP#Nnj;7c(na|NMdF{E^_|-0sA!h0{|glJcTdPbXJgvoF> zHO=gqhm^`Gt0N3>Tvo(&gVVcsZvW7txeeQ|z#>MZ<#cC;xRQR3d!@)w+5}@kjYY*4 z$hholv<$F&8>MG}?m;xTeQm>^<-H%{CFx$^((!8AyvEOt91~#goKKzrGPQee%Z5X; zs?4&M5=wG*I%bR>zvrW&6I5Tmgi(EU8WUAJZBBau_1A8;UZigpDy3Ii3`6QHuPght z0Q=_6B@BJhQ-;a(?-XZ8NDFP5O%x36QPCw_^!KSD6S*z$$$x^zWIYeA5GJNHChvTv zKiiwb!E)nNPZToTLgMKF)72_(n^u{VJBCRC?=jB5$3?7VGfbddK^Ywx-?{`TYG z<+VJWZ*}YI;5RiXtL|7K#zV^z#2}a_i)P}e^Ti@9`Lv4%wPuXzV6>QijH@NB&YD1X zS;>9@!PNZ#BaXGbUj6AMHk#51T7l7)@!q1~pkWg3Op~@UnV2%v_N_jdh*MhoNt(NT z`xA~>OGA=WcGI>G#Nct|zH*QE%mUcTR)*L3Q>K-*?E6^gvbT!qH^@Y*Tkvc)>>*ee}y#R)~%vF2b#JTxG?#(aia$;)^^lKwzhc zCMb9GrPqdEynD57gH;-644r>1tS10M0@Llr+k4?g@#1-rm#z$x9M=)U+|{s)pF4TO z6o|b|elVDwHmfrHVkW3uxo84-)p9lC z05TY0m8Ds<4x!gow*3*_(Au#r`lmTTvjQ=iZ(n!XC%L6&s2}Hw;aumn50lX(JOohnU5aqM#c*@47}*{>0c-?^$3QqY#{7T^=bs z?M&7bzWXU!|0KH5MA;1EDYAqAuJHZV;J(D->on4Z7F3OBfs9@V%@T6+r*MIOs9=X< zAfd`@e2OK-&0+c8;z0p6T63qdO|M^B@f8IYt}uFNwUcaF+7o#T7ZX-mx06&h{>|dL zi#{VunJ#BdEHtP1y@Q~qHKBG|Z+{=fa`tzV4XR?vd`1lXT!shgwof*@ zm7(kKYzMiLlr$4EpVe~pRv+y;ngY8jZ%-pMq`Ye%mW}rlhn|Q9z|x6@2x?PPERsVY zc{weB`sm!y9Sbz(mH!wzHmn7|d1gz0d%R}wH$M;xhS5J!q=eiBxZl-^y=y~s6FvpE zw+3u61VF@IT@3fV&QJ2a-s`8(hU9ma;<99&x*v{(9f@Kvohj=I(-B3$sSI6w)5oV<*^_#OKuQJy}zI9*J{{4_T{nv*fyA z62NtgkFh47ofDF|AfO%usW0zr!imh^FAxzy?`u+kGsa%t-ds^0+&r5R#gO0Mq{`5z zC_#<*2EQ{G4S{Zb1kJ2IPk6^3Rb95(p{1G>yR?t8r{&yp-$tub z4r~5#rz`HtLz)qJncFUg_4NH@fkiG;p{? zbl~?kdr<);x+?RypjJlMpSfxhgSBG!6WWb%1#NnmMD!{LC;$OH&XuXkaXgM@w_I&P zc`J%+{zWnUNg28ek#;U*&Jucb2?qk498=L+$<`v&A(f*GNKN=$S~cpY#T>s}f{t>m z)({5vMvx`BVY8z22A`m!Gpo(0g&=*HE1NZU$=$cJs9kei%th;ZLPlJm*Wz#IT*DBD z70yneKgTjPb=pv-Z7ZT>t8I4AJ4@Zua&9qkn;ZIFhtmxmgI&fP@QP6DNq((%cc11a zI8HLQ{onpgD2$)Z@^p02>i)U`G^j1`s~k&kx&{^fWq;a^Lf;1u>?rU?bM%v}ql0P< zt&;5didBPNp#9R)^v5%GFIs<-aoGgSDg`ej9!B5!wpuEI!?RT7_JUrD!t^G>F8wb` z_61G$1&+eGg(oIO0GVO2WKyPtS}_Y5&d*Jxfv4mEM=unT1y}PdK0zCyaDwJW%?ioV zBR2m$k4hQvX~taWP_f1Bndf+nIkuElTgJ&^G&_u%HY3voU*p z3kgdGl=#2o;-^;O^+@OVMydkvk>+;-njH>JP&vgeHVm)4t%Qtcpxme~kq;1j%hns` zg-rZVwq+5ixed@H`4H+72W|k}61Xz=);E{tTDB>De{|=wqlOwCTB0w{)4*)6gcpFb zlHu1Ti3ihLFGR8f?z6?OO}j+wKfi9<2Qg-tyODha$11^%nUILKi=*G<`21# zZ;u?M`#oS=3il1%@$+zRyZ?5XBsh#*>buV1;#d!zC!4s>I|pJssf_zC!ph!_Qx!`; z7liWk{4mN451xNLy8mIi{{W36`ijA8nmUF}ivR(e%Axx{(pG8k+MM)6^Kr4P<#p?uC>qVMDeZlkW(H`|Ybl{` zkn)6T-p;=7M4=3wY_C-|66*vW2~b-8Xx1%u7Xx5T0e!mHb8@76_)#ZjA1hZmTQRZ)PS{pD&um+c{nlp6O(M5_DlpDD$VNK z|3ptGkNW$7YlC@Gjn!tsbq=75kyD^_eQF(!0g?x%ErC3KE?)i0)r)u>y*xEE-DRhS zX^i(ntt5#dF~q?nNwgX>&j#qNK^#7jyM+;fa0GDtR0NMMkR>tB7jbaH6crPr^IHOn z>o{VQo8Sv85H1~B7?|D{k;weg*FJ!>G6A=JGEQC`v}dFgQOO?G+LQb#6k2SmsUg#N z{6tUQjb1$h$6!^4`$(}kvQ1FupQ!GufQ=k(Boi)`S@~)XIN^-&;A9IdrEg;t6dZ=W z(BKsY2{QexgAw>pK!p)Jy+IEsXu)#+jxH9F~j0~o1C#ZHXBI$4wwj_7+ z~f}wdwAruPT^8`g`}9XI6*o*D`l4^r{p^FQhq8UJC41uNgFts&_flh{#+;d z#JJ-i;jGq&N)U?w^G+q2-_m}DOYJMwCtrDadP6MWSAs-m(fTlQ)KGRqy~kzU4yK@f zcV8JKs5odIR{1lsr~z$9vq&g5CKqfHs|fk8h`?No&p1D>>m(z5F;>KjP$cXUX*%R? zqPA%LFflfk7_(;*fA~&L!_OUJ@_;p}o^k|H@LM0{xO^Mh3a_kLagH;L!jH6Eh4cS2 z>0>Z7ZKcqnziLs;e%{C~)p7`X@pL#Y9AE=-wmtB9 z$=accN_mpIasW^~iJm3c93t6r9fS zLo4tlzN*ZI|K(YAbtbW0qLf$z`JVOvc?~SnpQ-;VR&em-9^t=*#)BteM-xP_bY(f_ z09YLTGeosD$#gu08p7hJ{-_P#9sV7R(Vmk2Ahzt;;!^0d#}D}f=3*B|-!0_$vdL$FT_ zS2a>5_)6bP*n+~U$E3npYZKevc%1)w5?I}KZ-IL^mc)xL|M@@N<)rm|Hud z@WcsYOVeO0zCUiOxIr^cZ6!)wW=C3C_^V&CGtPtvGv1;XM|G_6>yB(>2@3AxYDF{u z#Tw-ReontWd!cD5-sWN33e&&x6@XzY^9=029$Xs`f^p7lg!u`y z+eH+w7zX$e$2}G0lSt!d8u%DkV5r^HDWIs@Ul6+@;M-4?_2Nj7eW^dPsTNC=MdO~| zxCS1cWc_z9Kq&yX+>^X{qDE{kzJIWQY66(ZBV^BYim?eF=^Vik3&mbIYYY+PT%ohg z_Ll!765s}8-=A=ccn7F?MP<%3&sx`)d%(A-g2jFNCJqW@=NwA|VCt%+n$@sZH%dX}uYpx{Kzk}Wy z^!?lfD`3sIfDFQ$(o*wZR~;#qGVMdN0If38LM}$Ic~xH4nUZ`lg2>Ch?c@TndASeUQJ15WcfZpY-Hvb|9F|r4&C`P?ikt- zu;p;J&8j;#h`T6pT(a43-TuNPDvPhzwIyC!GvTaSJ43J6HVUX35B{^#Vn4T-q~)Wg z)3J(=S;z=}{^;CdH2o!f{ez~UMAHPhQ&G#_UTxI0Qi7$-Y)%TQz_YvW*KG@ERUqm? zdn~~~G_cCBg;**E$2OeGV*EtYOL*=BF~iMuUv|Z}VrcdYd3%O$z21X%)-s=A^5n#r z>gRv#HkNIg`DA`6u;5jU_?^lBSxBJe^-FJ>3z|UFKuoc@c;MQZK0AmEcI?6)owyH; z)=uwn#d*=61c!9*Wwoyt5Df?iBegp(8Xyg5Z5k?bYaUbpuQLM>mZ9nZyvin(0IF@L z6zrh9mu6vYDCKayu%p68`Y*4MS%dv;Ho2~>Lq%O}h(aj?Q@+bi%LvgQIrxQTeS(iJ z)vi@1q+`FiYjgrtj)n!jS6Z2;L7Z`|Vh4FTFI-eD4_&2zNtMq6anY~^>WW(2J~J}F+NweFmqGr5&*CAUP(#=k)zZ95BA9x0VLTsbzK7txG*uM;tCf_d ziT)lEln%{$`}y^2E)K#S%sEHYe)eWWSg-33LY(%HRL4LeKl>@DI&I&{nnOt$C0ys4 z$>aoUUH5C3k_d#|RmGmKcqYJ(qJHl$h3bN0;BXEM#$Q~D#a@lcP(6v--)#|=#b|S$ z-J=)qIR^Z(2{#Ekz9=md7x?z^B(&RfVeo+y_?Z~1pzPLnkxr%ElPS*cKD)29R@qp5 zF*;lZFcaFKe!jl>2mn~hZe>%?mBwW>j*zjFK>P{b><(9)W$%H}g~O0N0C1?%+Y)e+ zdX4Bg^mjD-U3x4hm!ZR4TNHCS<2w~08+UA42C$8ZFX+psVT|2KOY-%y`C7LhPbY!P z&>1Oo@asf+5UT?IN|~`3zn<*dqGH4`J!>hL%@?+A1jLgkr>0+8%^H$o$KDjp)I*6~ zqV}gW_X~jadiR-j+IszBi#+tQk%sJ?KZrn6XrjB>8m3;*ck^S#RlMOle!&x0@5$J; z;9aapo003>HdAf<^1HO%3%bSUPU>2yDgDPS>{^SKzarlucgUmHv-(H9M>Ou21ze=XUd}EeUemIb z(~b^X!Y||`xoy{sy=f`f<20Yzyq#LUzK$&2LvTz^oLKH{%>hMDw;Lb-m>Aztr(5+V zQ#7mw{=9uJ@{W@Z$I0o&m+Gu;M$D!6^a;xL$P*Z}U2{)BGv``^m#Tr6aX3eljXEp% z>1E+fcaHDuZYn`jcs$|LEHIx=ZwRkvX4@}qVquzU5{azL=1bGo?sKvWEy zGs7TcIzjgZEAR*Z%m=1Wjhl|YBI-pK^i|R|$wc;-Y3aATqtkV$!h9-Z?$;3-u@3$a zN7KK+td#<%oxuRqmvzWjGmiB?%UmqN9xj|{MCN`n;vYTB+GFF7M+T6g`%maE|9x3E z=!R@sVyNR?clDKm!E%>khW`k7lTz8p(8fw6rJv{;`ec!6Jxn_p1e~tw5y{K!p@9TJsL4#Kw72`qztc^?BA%KFJoi3M;AomWp$_^sILau5l;i{lmXx@%i?axwC6 zQ3N=IL?!8pMaHqBzm?g@+T$`5<+3EjDh@}Z#kb!>@IqrOGL9L#GO^%(Hak;^#A6?{=a{0;CO}*pd3K@*&Y0k@c*}v-2df9?0`X}<>FwHVzl5RyQP=0|5FzcaT}dhvV! zdWG{S0p}P!37Y7Wce*uRAW)qf`;E%S)_Qs5ju%I@!nUj=BBvn(kOtuOtvdn#C5(WD z4n>1-u&RW&BlMBvrO!bJFxk5glJy+Cn;y{M5IWTc4>FjEgd3q4rJQ2UapEFJDAv3s zb@pAspOVU*9NV`=lvMM9T?`AH77s|pg4@|1to^g!de{NjpXLA1tzagcA;llVL(&ShAD5Qdp;}k&O zVRpP8$h)dTmjBYZg8XUrdhsZm{oPvp_Eogh84+h!ex99%ZJ4o02tpz<3JqxaKYQYV z{57Rm1VbbyTr208Rc|W8Wd zpLHh%|=!$Y<{_a|aT=wj1IdeX707y zZg)5kL6)%lUj|b9iIsDY`NGW}irvNd@VX&iPxcPOSx5|azo-QfHWIQ?`I2Ox{K5o# zQ6HI(53iiwsor!<6cM24hj(n9Io=QT7?oAu(REb^)K8)4znoOos+>8irOh8;TSf*W z6y=(+j?bK;nSZ>-;9tNvn8z5CwOvE80of3hQk&3k(Ol%KBxXDRo^S9YFUGqc;1tT+ zg`wiPe=fq|ojt9WwpP#GW>=S2C^Z+eTjh2DJRD=MxgH!Vu)+LVD~7q7qgcIAxVuI-8v=$a9w@DQ%N4E$Q~Vv&ad`sganT{~>UQ zp>HEzIA0im8fE(s6}R^vkG}^hYfMFsDh7U*r8Fs7xmqXVBxa&el-U@cfDb!(Y-1&7 zJFd+9#8>*uW?nVBYFjAmk0YOSSw^%Dad*L~Sb1+y7&ps7_h03qjxXW{?38+kVo0)O zLY$gxo7MM+!1|RV{!C_kCuD{L41^3 z%JZLJR*q;+y(20_?k-n}-uZ2bHxw-zLM~p#A@CP(8{KX#9W6Ruw}q>U-zpEA`|ocz zUm4ynLn+Qy462^4v*b<`Ph0uc8X9)crS|GA z)_ofL^HbZz%y!?BwN=U=g(<_W&(sKjvGOwQQk4|1M

c$21syGK_6pB(OBh!{3rliZ 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≥7J)9&r?_<_u!H#8HR7>!UfB^e%ew*#G-M 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 literal 0 HcmV?d00001