From 070071ff25f39ae39d66190e302c153158e87cbd Mon Sep 17 00:00:00 2001 From: Deepak Cherian Date: Thu, 1 Aug 2024 20:03:17 -0600 Subject: [PATCH 01/10] Add cohorts snapshot tests with syrupy --- ci/environment.yml | 1 + ci/minimal-requirements.yml | 1 + ci/no-dask.yml | 1 + ci/no-numba.yml | 1 + ci/no-xarray.yml | 2 + ci/upstream-dev-env.yml | 1 + flox/core.py | 10 +- tests/__snapshots__/test_cohorts.ambr | 22307 ++++++++++++++++++++++++ tests/test_cohorts.py | 27 + 9 files changed, 22347 insertions(+), 4 deletions(-) create mode 100644 tests/__snapshots__/test_cohorts.ambr create mode 100644 tests/test_cohorts.py diff --git a/ci/environment.yml b/ci/environment.yml index 5a6b09df2..82995d079 100644 --- a/ci/environment.yml +++ b/ci/environment.yml @@ -18,6 +18,7 @@ dependencies: - pytest-cov - pytest-pretty - pytest-xdist + - syrupy - xarray - pre-commit - numpy_groupies>=0.9.19 diff --git a/ci/minimal-requirements.yml b/ci/minimal-requirements.yml index fa5eae251..5074292ac 100644 --- a/ci/minimal-requirements.yml +++ b/ci/minimal-requirements.yml @@ -9,6 +9,7 @@ dependencies: - pytest-cov - pytest-pretty - pytest-xdist + - syrupy - numpy==1.22 - scipy==1.9.0 - numpy_groupies==0.9.19 diff --git a/ci/no-dask.yml b/ci/no-dask.yml index 27cdb59a9..1f05c63a9 100644 --- a/ci/no-dask.yml +++ b/ci/no-dask.yml @@ -13,6 +13,7 @@ dependencies: - pytest-cov - pytest-pretty - pytest-xdist + - syrupy - xarray - numpydoc - pre-commit diff --git a/ci/no-numba.yml b/ci/no-numba.yml index be3cec4a0..8039b20f7 100644 --- a/ci/no-numba.yml +++ b/ci/no-numba.yml @@ -18,6 +18,7 @@ dependencies: - pytest-cov - pytest-pretty - pytest-xdist + - syrupy - xarray - pre-commit - numpy_groupies>=0.9.19 diff --git a/ci/no-xarray.yml b/ci/no-xarray.yml index 2dfac3ae5..030796507 100644 --- a/ci/no-xarray.yml +++ b/ci/no-xarray.yml @@ -3,6 +3,7 @@ channels: - conda-forge dependencies: - codecov + - syrupy - pandas - numpy>=1.22 - scipy @@ -11,6 +12,7 @@ dependencies: - pytest-cov - pytest-pretty - pytest-xdist + - syrupy - dask-core - numpydoc - pre-commit diff --git a/ci/upstream-dev-env.yml b/ci/upstream-dev-env.yml index 856bbafda..4020dd840 100644 --- a/ci/upstream-dev-env.yml +++ b/ci/upstream-dev-env.yml @@ -11,6 +11,7 @@ dependencies: # - scipy - pytest-pretty - pytest-xdist + - syrupy - pip # for cftime - cython>=0.29.20 diff --git a/flox/core.py b/flox/core.py index 8eaf54b74..a36ce24f5 100644 --- a/flox/core.py +++ b/flox/core.py @@ -394,7 +394,9 @@ def find_group_cohorts( chunks_per_label = chunks_per_label[present_labels_mask] label_chunks = { - present_labels[idx]: bitmask.indices[slice(bitmask.indptr[idx], bitmask.indptr[idx + 1])] + present_labels[idx].item(): bitmask.indices[ + slice(bitmask.indptr[idx], bitmask.indptr[idx + 1]) + ] for idx in range(bitmask.shape[LABEL_AXIS]) } @@ -485,7 +487,7 @@ def invert(x) -> tuple[np.ndarray, ...]: # Iterate over labels, beginning with those with most chunks logger.debug("find_group_cohorts: merging cohorts") - order = np.argsort(containment.sum(axis=LABEL_AXIS))[::-1] + order = np.argsort(containment.sum(axis=LABEL_AXIS), kind="stable")[::-1] merged_cohorts = {} merged_keys = set() # TODO: we can optimize this to loop over chunk_cohorts instead @@ -495,11 +497,11 @@ def invert(x) -> tuple[np.ndarray, ...]: slice(containment.indptr[rowidx], containment.indptr[rowidx + 1]) ] cohort_ = present_labels[cohidx] - cohort = [elem for elem in cohort_ if elem not in merged_keys] + cohort = [elem.item() for elem in cohort_ if elem not in merged_keys] if not cohort: continue merged_keys.update(cohort) - allchunks = (label_chunks[member] for member in cohort) + allchunks = (label_chunks[member].tolist() for member in cohort) chunk = tuple(set(itertools.chain(*allchunks))) merged_cohorts[chunk] = cohort diff --git a/tests/__snapshots__/test_cohorts.ambr b/tests/__snapshots__/test_cohorts.ambr new file mode 100644 index 000000000..a1c3899a9 --- /dev/null +++ b/tests/__snapshots__/test_cohorts.ambr @@ -0,0 +1,22307 @@ +# serializer version: 1 +# name: test_snapshot_cohorts[ERA5DayOfYear] + dict({ + tuple( + 0, + 365, + 183, + ): list([ + 0, + ]), + tuple( + 0, + 366, + 183, + ): list([ + 1, + ]), + tuple( + 8, + 373, + 191, + ): list([ + 16, + ]), + tuple( + 8, + 374, + 191, + ): list([ + 17, + ]), + tuple( + 16, + 381, + 199, + ): list([ + 32, + ]), + tuple( + 16, + 382, + 199, + ): list([ + 33, + ]), + tuple( + 24, + 389, + 207, + ): list([ + 48, + ]), + tuple( + 24, + 390, + 207, + ): list([ + 49, + ]), + tuple( + 32, + 397, + 215, + ): list([ + 64, + ]), + tuple( + 32, + 398, + 215, + ): list([ + 65, + ]), + tuple( + 40, + 405, + 223, + ): list([ + 80, + ]), + tuple( + 40, + 406, + 223, + ): list([ + 81, + ]), + tuple( + 48, + 413, + 231, + ): list([ + 96, + ]), + tuple( + 48, + 414, + 231, + ): list([ + 97, + ]), + tuple( + 56, + 421, + 239, + ): list([ + 112, + ]), + tuple( + 56, + 422, + 239, + ): list([ + 113, + ]), + tuple( + 64, + 429, + 247, + ): list([ + 128, + ]), + tuple( + 64, + 430, + 247, + ): list([ + 129, + ]), + tuple( + 72, + 437, + 255, + ): list([ + 144, + ]), + tuple( + 72, + 438, + 255, + ): list([ + 145, + ]), + tuple( + 80, + 445, + 263, + ): list([ + 160, + ]), + tuple( + 80, + 446, + 263, + ): list([ + 161, + ]), + tuple( + 88, + 453, + 271, + ): list([ + 176, + ]), + tuple( + 88, + 454, + 271, + ): list([ + 177, + ]), + tuple( + 96, + 461, + 279, + ): list([ + 192, + ]), + tuple( + 96, + 462, + 279, + ): list([ + 193, + ]), + tuple( + 104, + 469, + 287, + ): list([ + 208, + ]), + tuple( + 104, + 470, + 287, + ): list([ + 209, + ]), + tuple( + 112, + 477, + 295, + ): list([ + 224, + ]), + tuple( + 112, + 478, + 295, + ): list([ + 225, + ]), + tuple( + 120, + 485, + 303, + ): list([ + 240, + ]), + tuple( + 120, + 486, + 303, + ): list([ + 241, + ]), + tuple( + 128, + 493, + 311, + ): list([ + 256, + ]), + tuple( + 128, + 494, + 311, + ): list([ + 257, + ]), + tuple( + 136, + 501, + 319, + ): list([ + 272, + ]), + tuple( + 136, + 502, + 319, + ): list([ + 273, + ]), + tuple( + 144, + 509, + 327, + ): list([ + 288, + ]), + tuple( + 144, + 510, + 327, + ): list([ + 289, + ]), + tuple( + 152, + 517, + 335, + ): list([ + 304, + ]), + tuple( + 152, + 518, + 335, + ): list([ + 305, + ]), + tuple( + 160, + 525, + 343, + ): list([ + 320, + ]), + tuple( + 160, + 526, + 343, + ): list([ + 321, + ]), + tuple( + 168, + 533, + 351, + ): list([ + 336, + ]), + tuple( + 168, + 534, + 351, + ): list([ + 337, + ]), + tuple( + 176, + 541, + 359, + ): list([ + 352, + ]), + tuple( + 176, + 542, + 359, + ): list([ + 353, + ]), + tuple( + 184, + 1, + 366, + ): list([ + 2, + ]), + tuple( + 184, + 1, + 367, + ): list([ + 3, + ]), + tuple( + 185, + 2, + 367, + ): list([ + 4, + ]), + tuple( + 192, + 9, + 374, + ): list([ + 18, + ]), + tuple( + 192, + 9, + 375, + ): list([ + 19, + ]), + tuple( + 193, + 10, + 375, + ): list([ + 20, + ]), + tuple( + 200, + 17, + 382, + ): list([ + 34, + ]), + tuple( + 200, + 17, + 383, + ): list([ + 35, + ]), + tuple( + 201, + 18, + 383, + ): list([ + 36, + ]), + tuple( + 208, + 25, + 390, + ): list([ + 50, + ]), + tuple( + 208, + 25, + 391, + ): list([ + 51, + ]), + tuple( + 209, + 26, + 391, + ): list([ + 52, + ]), + tuple( + 216, + 33, + 398, + ): list([ + 66, + ]), + tuple( + 216, + 33, + 399, + ): list([ + 67, + ]), + tuple( + 217, + 34, + 399, + ): list([ + 68, + ]), + tuple( + 224, + 41, + 406, + ): list([ + 82, + ]), + tuple( + 224, + 41, + 407, + ): list([ + 83, + ]), + tuple( + 225, + 42, + 407, + ): list([ + 84, + ]), + tuple( + 232, + 49, + 414, + ): list([ + 98, + ]), + tuple( + 232, + 49, + 415, + ): list([ + 99, + ]), + tuple( + 233, + 50, + 415, + ): list([ + 100, + ]), + tuple( + 240, + 57, + 422, + ): list([ + 114, + ]), + tuple( + 240, + 57, + 423, + ): list([ + 115, + ]), + tuple( + 241, + 58, + 423, + ): list([ + 116, + ]), + tuple( + 248, + 65, + 430, + ): list([ + 130, + ]), + tuple( + 248, + 65, + 431, + ): list([ + 131, + ]), + tuple( + 249, + 66, + 431, + ): list([ + 132, + ]), + tuple( + 256, + 73, + 438, + ): list([ + 146, + ]), + tuple( + 256, + 73, + 439, + ): list([ + 147, + ]), + tuple( + 257, + 74, + 439, + ): list([ + 148, + ]), + tuple( + 264, + 81, + 446, + ): list([ + 162, + ]), + tuple( + 264, + 81, + 447, + ): list([ + 163, + ]), + tuple( + 265, + 82, + 447, + ): list([ + 164, + ]), + tuple( + 272, + 89, + 454, + ): list([ + 178, + ]), + tuple( + 272, + 89, + 455, + ): list([ + 179, + ]), + tuple( + 273, + 90, + 455, + ): list([ + 180, + ]), + tuple( + 280, + 97, + 462, + ): list([ + 194, + ]), + tuple( + 280, + 97, + 463, + ): list([ + 195, + ]), + tuple( + 281, + 98, + 463, + ): list([ + 196, + ]), + tuple( + 288, + 105, + 470, + ): list([ + 210, + ]), + tuple( + 288, + 105, + 471, + ): list([ + 211, + ]), + tuple( + 289, + 106, + 471, + ): list([ + 212, + ]), + tuple( + 296, + 113, + 478, + ): list([ + 226, + ]), + tuple( + 296, + 113, + 479, + ): list([ + 227, + ]), + tuple( + 297, + 114, + 479, + ): list([ + 228, + ]), + tuple( + 304, + 121, + 486, + ): list([ + 242, + ]), + tuple( + 304, + 121, + 487, + ): list([ + 243, + ]), + tuple( + 305, + 122, + 487, + ): list([ + 244, + ]), + tuple( + 312, + 129, + 494, + ): list([ + 258, + ]), + tuple( + 312, + 129, + 495, + ): list([ + 259, + ]), + tuple( + 313, + 130, + 495, + ): list([ + 260, + ]), + tuple( + 320, + 137, + 502, + ): list([ + 274, + ]), + tuple( + 320, + 137, + 503, + ): list([ + 275, + ]), + tuple( + 321, + 138, + 503, + ): list([ + 276, + ]), + tuple( + 328, + 145, + 510, + ): list([ + 290, + ]), + tuple( + 328, + 145, + 511, + ): list([ + 291, + ]), + tuple( + 329, + 146, + 511, + ): list([ + 292, + ]), + tuple( + 336, + 153, + 518, + ): list([ + 306, + ]), + tuple( + 336, + 153, + 519, + ): list([ + 307, + ]), + tuple( + 337, + 154, + 519, + ): list([ + 308, + ]), + tuple( + 344, + 161, + 526, + ): list([ + 322, + ]), + tuple( + 344, + 161, + 527, + ): list([ + 323, + ]), + tuple( + 345, + 162, + 527, + ): list([ + 324, + ]), + tuple( + 352, + 169, + 534, + ): list([ + 338, + ]), + tuple( + 352, + 169, + 535, + ): list([ + 339, + ]), + tuple( + 353, + 170, + 535, + ): list([ + 340, + ]), + tuple( + 360, + 177, + 542, + ): list([ + 354, + ]), + tuple( + 360, + 177, + 543, + ): list([ + 355, + ]), + tuple( + 361, + 178, + 543, + ): list([ + 356, + ]), + tuple( + 368, + 185, + 2, + ): list([ + 5, + ]), + tuple( + 368, + 186, + 3, + ): list([ + 6, + ]), + tuple( + 369, + 186, + 3, + ): list([ + 7, + ]), + tuple( + 369, + 187, + 4, + ): list([ + 8, + ]), + tuple( + 370, + 187, + 4, + ): list([ + 9, + ]), + tuple( + 370, + 188, + 5, + ): list([ + 10, + ]), + tuple( + 371, + 188, + 5, + ): list([ + 11, + ]), + tuple( + 371, + 189, + 6, + ): list([ + 12, + ]), + tuple( + 372, + 189, + 6, + ): list([ + 13, + ]), + tuple( + 372, + 190, + 7, + ): list([ + 14, + ]), + tuple( + 373, + 190, + 7, + ): list([ + 15, + ]), + tuple( + 376, + 193, + 10, + ): list([ + 21, + ]), + tuple( + 376, + 194, + 11, + ): list([ + 22, + ]), + tuple( + 377, + 194, + 11, + ): list([ + 23, + ]), + tuple( + 377, + 195, + 12, + ): list([ + 24, + ]), + tuple( + 378, + 195, + 12, + ): list([ + 25, + ]), + tuple( + 378, + 196, + 13, + ): list([ + 26, + ]), + tuple( + 379, + 196, + 13, + ): list([ + 27, + ]), + tuple( + 379, + 197, + 14, + ): list([ + 28, + ]), + tuple( + 380, + 197, + 14, + ): list([ + 29, + ]), + tuple( + 380, + 198, + 15, + ): list([ + 30, + ]), + tuple( + 381, + 198, + 15, + ): list([ + 31, + ]), + tuple( + 384, + 201, + 18, + ): list([ + 37, + ]), + tuple( + 384, + 202, + 19, + ): list([ + 38, + ]), + tuple( + 385, + 202, + 19, + ): list([ + 39, + ]), + tuple( + 385, + 203, + 20, + ): list([ + 40, + ]), + tuple( + 386, + 203, + 20, + ): list([ + 41, + ]), + tuple( + 386, + 204, + 21, + ): list([ + 42, + ]), + tuple( + 387, + 204, + 21, + ): list([ + 43, + ]), + tuple( + 387, + 205, + 22, + ): list([ + 44, + ]), + tuple( + 388, + 205, + 22, + ): list([ + 45, + ]), + tuple( + 388, + 206, + 23, + ): list([ + 46, + ]), + tuple( + 389, + 206, + 23, + ): list([ + 47, + ]), + tuple( + 392, + 209, + 26, + ): list([ + 53, + ]), + tuple( + 392, + 210, + 27, + ): list([ + 54, + ]), + tuple( + 393, + 210, + 27, + ): list([ + 55, + ]), + tuple( + 393, + 211, + 28, + ): list([ + 56, + ]), + tuple( + 394, + 211, + 28, + ): list([ + 57, + ]), + tuple( + 394, + 212, + 29, + ): list([ + 58, + ]), + tuple( + 395, + 212, + 29, + ): list([ + 59, + ]), + tuple( + 395, + 213, + 30, + ): list([ + 60, + ]), + tuple( + 396, + 213, + 30, + ): list([ + 61, + ]), + tuple( + 396, + 214, + 31, + ): list([ + 62, + ]), + tuple( + 397, + 214, + 31, + ): list([ + 63, + ]), + tuple( + 400, + 217, + 34, + ): list([ + 69, + ]), + tuple( + 400, + 218, + 35, + ): list([ + 70, + ]), + tuple( + 401, + 218, + 35, + ): list([ + 71, + ]), + tuple( + 401, + 219, + 36, + ): list([ + 72, + ]), + tuple( + 402, + 219, + 36, + ): list([ + 73, + ]), + tuple( + 402, + 220, + 37, + ): list([ + 74, + ]), + tuple( + 403, + 220, + 37, + ): list([ + 75, + ]), + tuple( + 403, + 221, + 38, + ): list([ + 76, + ]), + tuple( + 404, + 221, + 38, + ): list([ + 77, + ]), + tuple( + 404, + 222, + 39, + ): list([ + 78, + ]), + tuple( + 405, + 222, + 39, + ): list([ + 79, + ]), + tuple( + 408, + 225, + 42, + ): list([ + 85, + ]), + tuple( + 408, + 226, + 43, + ): list([ + 86, + ]), + tuple( + 409, + 226, + 43, + ): list([ + 87, + ]), + tuple( + 409, + 227, + 44, + ): list([ + 88, + ]), + tuple( + 410, + 227, + 44, + ): list([ + 89, + ]), + tuple( + 410, + 228, + 45, + ): list([ + 90, + ]), + tuple( + 411, + 228, + 45, + ): list([ + 91, + ]), + tuple( + 411, + 229, + 46, + ): list([ + 92, + ]), + tuple( + 412, + 229, + 46, + ): list([ + 93, + ]), + tuple( + 412, + 230, + 47, + ): list([ + 94, + ]), + tuple( + 413, + 230, + 47, + ): list([ + 95, + ]), + tuple( + 416, + 233, + 50, + ): list([ + 101, + ]), + tuple( + 416, + 234, + 51, + ): list([ + 102, + ]), + tuple( + 417, + 234, + 51, + ): list([ + 103, + ]), + tuple( + 417, + 235, + 52, + ): list([ + 104, + ]), + tuple( + 418, + 235, + 52, + ): list([ + 105, + ]), + tuple( + 418, + 236, + 53, + ): list([ + 106, + ]), + tuple( + 419, + 236, + 53, + ): list([ + 107, + ]), + tuple( + 419, + 237, + 54, + ): list([ + 108, + ]), + tuple( + 420, + 237, + 54, + ): list([ + 109, + ]), + tuple( + 420, + 238, + 55, + ): list([ + 110, + ]), + tuple( + 421, + 238, + 55, + ): list([ + 111, + ]), + tuple( + 424, + 241, + 58, + ): list([ + 117, + ]), + tuple( + 424, + 242, + 59, + ): list([ + 118, + ]), + tuple( + 425, + 242, + 59, + ): list([ + 119, + ]), + tuple( + 425, + 243, + 60, + ): list([ + 120, + ]), + tuple( + 426, + 243, + 60, + ): list([ + 121, + ]), + tuple( + 426, + 244, + 61, + ): list([ + 122, + ]), + tuple( + 427, + 244, + 61, + ): list([ + 123, + ]), + tuple( + 427, + 245, + 62, + ): list([ + 124, + ]), + tuple( + 428, + 245, + 62, + ): list([ + 125, + ]), + tuple( + 428, + 246, + 63, + ): list([ + 126, + ]), + tuple( + 429, + 246, + 63, + ): list([ + 127, + ]), + tuple( + 432, + 249, + 66, + ): list([ + 133, + ]), + tuple( + 432, + 250, + 67, + ): list([ + 134, + ]), + tuple( + 433, + 250, + 67, + ): list([ + 135, + ]), + tuple( + 433, + 251, + 68, + ): list([ + 136, + ]), + tuple( + 434, + 251, + 68, + ): list([ + 137, + ]), + tuple( + 434, + 252, + 69, + ): list([ + 138, + ]), + tuple( + 435, + 252, + 69, + ): list([ + 139, + ]), + tuple( + 435, + 253, + 70, + ): list([ + 140, + ]), + tuple( + 436, + 253, + 70, + ): list([ + 141, + ]), + tuple( + 436, + 254, + 71, + ): list([ + 142, + ]), + tuple( + 437, + 254, + 71, + ): list([ + 143, + ]), + tuple( + 440, + 257, + 74, + ): list([ + 149, + ]), + tuple( + 440, + 258, + 75, + ): list([ + 150, + ]), + tuple( + 441, + 258, + 75, + ): list([ + 151, + ]), + tuple( + 441, + 259, + 76, + ): list([ + 152, + ]), + tuple( + 442, + 259, + 76, + ): list([ + 153, + ]), + tuple( + 442, + 260, + 77, + ): list([ + 154, + ]), + tuple( + 443, + 260, + 77, + ): list([ + 155, + ]), + tuple( + 443, + 261, + 78, + ): list([ + 156, + ]), + tuple( + 444, + 261, + 78, + ): list([ + 157, + ]), + tuple( + 444, + 262, + 79, + ): list([ + 158, + ]), + tuple( + 445, + 262, + 79, + ): list([ + 159, + ]), + tuple( + 448, + 265, + 82, + ): list([ + 165, + ]), + tuple( + 448, + 266, + 83, + ): list([ + 166, + ]), + tuple( + 449, + 266, + 83, + ): list([ + 167, + ]), + tuple( + 449, + 267, + 84, + ): list([ + 168, + ]), + tuple( + 450, + 267, + 84, + ): list([ + 169, + ]), + tuple( + 450, + 268, + 85, + ): list([ + 170, + ]), + tuple( + 451, + 268, + 85, + ): list([ + 171, + ]), + tuple( + 451, + 269, + 86, + ): list([ + 172, + ]), + tuple( + 452, + 269, + 86, + ): list([ + 173, + ]), + tuple( + 452, + 270, + 87, + ): list([ + 174, + ]), + tuple( + 453, + 270, + 87, + ): list([ + 175, + ]), + tuple( + 456, + 273, + 90, + ): list([ + 181, + ]), + tuple( + 456, + 274, + 91, + ): list([ + 182, + ]), + tuple( + 457, + 274, + 91, + ): list([ + 183, + ]), + tuple( + 457, + 275, + 92, + ): list([ + 184, + ]), + tuple( + 458, + 275, + 92, + ): list([ + 185, + ]), + tuple( + 458, + 276, + 93, + ): list([ + 186, + ]), + tuple( + 459, + 276, + 93, + ): list([ + 187, + ]), + tuple( + 459, + 277, + 94, + ): list([ + 188, + ]), + tuple( + 460, + 277, + 94, + ): list([ + 189, + ]), + tuple( + 460, + 278, + 95, + ): list([ + 190, + ]), + tuple( + 461, + 278, + 95, + ): list([ + 191, + ]), + tuple( + 464, + 281, + 98, + ): list([ + 197, + ]), + tuple( + 464, + 282, + 99, + ): list([ + 198, + ]), + tuple( + 465, + 282, + 99, + ): list([ + 199, + ]), + tuple( + 465, + 283, + 100, + ): list([ + 200, + ]), + tuple( + 466, + 283, + 100, + ): list([ + 201, + ]), + tuple( + 466, + 284, + 101, + ): list([ + 202, + ]), + tuple( + 467, + 284, + 101, + ): list([ + 203, + ]), + tuple( + 467, + 285, + 102, + ): list([ + 204, + ]), + tuple( + 468, + 285, + 102, + ): list([ + 205, + ]), + tuple( + 468, + 286, + 103, + ): list([ + 206, + ]), + tuple( + 469, + 286, + 103, + ): list([ + 207, + ]), + tuple( + 472, + 289, + 106, + ): list([ + 213, + ]), + tuple( + 472, + 290, + 107, + ): list([ + 214, + ]), + tuple( + 473, + 290, + 107, + ): list([ + 215, + ]), + tuple( + 473, + 291, + 108, + ): list([ + 216, + ]), + tuple( + 474, + 291, + 108, + ): list([ + 217, + ]), + tuple( + 474, + 292, + 109, + ): list([ + 218, + ]), + tuple( + 475, + 292, + 109, + ): list([ + 219, + ]), + tuple( + 475, + 293, + 110, + ): list([ + 220, + ]), + tuple( + 476, + 293, + 110, + ): list([ + 221, + ]), + tuple( + 476, + 294, + 111, + ): list([ + 222, + ]), + tuple( + 477, + 294, + 111, + ): list([ + 223, + ]), + tuple( + 480, + 297, + 114, + ): list([ + 229, + ]), + tuple( + 480, + 298, + 115, + ): list([ + 230, + ]), + tuple( + 481, + 298, + 115, + ): list([ + 231, + ]), + tuple( + 481, + 299, + 116, + ): list([ + 232, + ]), + tuple( + 482, + 299, + 116, + ): list([ + 233, + ]), + tuple( + 482, + 300, + 117, + ): list([ + 234, + ]), + tuple( + 483, + 300, + 117, + ): list([ + 235, + ]), + tuple( + 483, + 301, + 118, + ): list([ + 236, + ]), + tuple( + 484, + 301, + 118, + ): list([ + 237, + ]), + tuple( + 484, + 302, + 119, + ): list([ + 238, + ]), + tuple( + 485, + 302, + 119, + ): list([ + 239, + ]), + tuple( + 488, + 305, + 122, + ): list([ + 245, + ]), + tuple( + 488, + 306, + 123, + ): list([ + 246, + ]), + tuple( + 489, + 306, + 123, + ): list([ + 247, + ]), + tuple( + 489, + 307, + 124, + ): list([ + 248, + ]), + tuple( + 490, + 307, + 124, + ): list([ + 249, + ]), + tuple( + 490, + 308, + 125, + ): list([ + 250, + ]), + tuple( + 491, + 308, + 125, + ): list([ + 251, + ]), + tuple( + 491, + 309, + 126, + ): list([ + 252, + ]), + tuple( + 492, + 309, + 126, + ): list([ + 253, + ]), + tuple( + 492, + 310, + 127, + ): list([ + 254, + ]), + tuple( + 493, + 310, + 127, + ): list([ + 255, + ]), + tuple( + 496, + 313, + 130, + ): list([ + 261, + ]), + tuple( + 496, + 314, + 131, + ): list([ + 262, + ]), + tuple( + 497, + 314, + 131, + ): list([ + 263, + ]), + tuple( + 497, + 315, + 132, + ): list([ + 264, + ]), + tuple( + 498, + 315, + 132, + ): list([ + 265, + ]), + tuple( + 498, + 316, + 133, + ): list([ + 266, + ]), + tuple( + 499, + 316, + 133, + ): list([ + 267, + ]), + tuple( + 499, + 317, + 134, + ): list([ + 268, + ]), + tuple( + 500, + 317, + 134, + ): list([ + 269, + ]), + tuple( + 500, + 318, + 135, + ): list([ + 270, + ]), + tuple( + 501, + 318, + 135, + ): list([ + 271, + ]), + tuple( + 504, + 321, + 138, + ): list([ + 277, + ]), + tuple( + 504, + 322, + 139, + ): list([ + 278, + ]), + tuple( + 505, + 322, + 139, + ): list([ + 279, + ]), + tuple( + 505, + 323, + 140, + ): list([ + 280, + ]), + tuple( + 506, + 323, + 140, + ): list([ + 281, + ]), + tuple( + 506, + 324, + 141, + ): list([ + 282, + ]), + tuple( + 507, + 324, + 141, + ): list([ + 283, + ]), + tuple( + 507, + 325, + 142, + ): list([ + 284, + ]), + tuple( + 508, + 325, + 142, + ): list([ + 285, + ]), + tuple( + 508, + 326, + 143, + ): list([ + 286, + ]), + tuple( + 509, + 326, + 143, + ): list([ + 287, + ]), + tuple( + 512, + 329, + 146, + ): list([ + 293, + ]), + tuple( + 512, + 330, + 147, + ): list([ + 294, + ]), + tuple( + 513, + 330, + 147, + ): list([ + 295, + ]), + tuple( + 513, + 331, + 148, + ): list([ + 296, + ]), + tuple( + 514, + 331, + 148, + ): list([ + 297, + ]), + tuple( + 514, + 332, + 149, + ): list([ + 298, + ]), + tuple( + 515, + 332, + 149, + ): list([ + 299, + ]), + tuple( + 515, + 333, + 150, + ): list([ + 300, + ]), + tuple( + 516, + 333, + 150, + ): list([ + 301, + ]), + tuple( + 516, + 334, + 151, + ): list([ + 302, + ]), + tuple( + 517, + 334, + 151, + ): list([ + 303, + ]), + tuple( + 520, + 337, + 154, + ): list([ + 309, + ]), + tuple( + 520, + 338, + 155, + ): list([ + 310, + ]), + tuple( + 521, + 338, + 155, + ): list([ + 311, + ]), + tuple( + 521, + 339, + 156, + ): list([ + 312, + ]), + tuple( + 522, + 339, + 156, + ): list([ + 313, + ]), + tuple( + 522, + 340, + 157, + ): list([ + 314, + ]), + tuple( + 523, + 340, + 157, + ): list([ + 315, + ]), + tuple( + 523, + 341, + 158, + ): list([ + 316, + ]), + tuple( + 524, + 341, + 158, + ): list([ + 317, + ]), + tuple( + 524, + 342, + 159, + ): list([ + 318, + ]), + tuple( + 525, + 342, + 159, + ): list([ + 319, + ]), + tuple( + 528, + 345, + 162, + ): list([ + 325, + ]), + tuple( + 528, + 346, + 163, + ): list([ + 326, + ]), + tuple( + 529, + 346, + 163, + ): list([ + 327, + ]), + tuple( + 529, + 347, + 164, + ): list([ + 328, + ]), + tuple( + 530, + 347, + 164, + ): list([ + 329, + ]), + tuple( + 530, + 348, + 165, + ): list([ + 330, + ]), + tuple( + 531, + 348, + 165, + ): list([ + 331, + ]), + tuple( + 531, + 349, + 166, + ): list([ + 332, + ]), + tuple( + 532, + 349, + 166, + ): list([ + 333, + ]), + tuple( + 532, + 350, + 167, + ): list([ + 334, + ]), + tuple( + 533, + 350, + 167, + ): list([ + 335, + ]), + tuple( + 536, + 353, + 170, + ): list([ + 341, + ]), + tuple( + 536, + 354, + 171, + ): list([ + 342, + ]), + tuple( + 537, + 354, + 171, + ): list([ + 343, + ]), + tuple( + 537, + 355, + 172, + ): list([ + 344, + ]), + tuple( + 538, + 355, + 172, + ): list([ + 345, + ]), + tuple( + 538, + 356, + 173, + ): list([ + 346, + ]), + tuple( + 539, + 356, + 173, + ): list([ + 347, + ]), + tuple( + 539, + 357, + 174, + ): list([ + 348, + ]), + tuple( + 540, + 357, + 174, + ): list([ + 349, + ]), + tuple( + 540, + 358, + 175, + ): list([ + 350, + ]), + tuple( + 541, + 358, + 175, + ): list([ + 351, + ]), + tuple( + 544, + 361, + 178, + ): list([ + 357, + ]), + tuple( + 544, + 362, + 179, + ): list([ + 358, + ]), + tuple( + 545, + 362, + 179, + ): list([ + 359, + ]), + tuple( + 545, + 363, + 180, + ): list([ + 360, + ]), + tuple( + 546, + 363, + 180, + ): list([ + 361, + ]), + tuple( + 546, + 364, + 181, + ): list([ + 362, + ]), + tuple( + 547, + 364, + 181, + ): list([ + 363, + ]), + tuple( + 547, + 365, + 182, + ): list([ + 364, + 365, + ]), + }) +# --- +# name: test_snapshot_cohorts[ERA5Google] + dict({ + tuple( + np.int64(0), + np.int64(1), + np.int64(2), + np.int64(3), + np.int64(124), + np.int64(125), + np.int64(126), + np.int64(127), + np.int64(236), + np.int64(237), + np.int64(238), + np.int64(239), + np.int64(360), + np.int64(361), + np.int64(362), + np.int64(363), + np.int64(480), + np.int64(481), + np.int64(482), + np.int64(483), + np.int64(604), + np.int64(605), + np.int64(606), + np.int64(607), + np.int64(724), + np.int64(725), + np.int64(726), + np.int64(727), + np.int64(848), + np.int64(849), + np.int64(850), + np.int64(851), + ): list([ + 0, + ]), + tuple( + np.int64(4), + np.int64(5), + np.int64(6), + np.int64(7), + np.int64(128), + np.int64(129), + np.int64(130), + np.int64(131), + np.int64(240), + np.int64(241), + np.int64(242), + np.int64(243), + np.int64(364), + np.int64(365), + np.int64(366), + np.int64(367), + np.int64(484), + np.int64(485), + np.int64(486), + np.int64(487), + np.int64(608), + np.int64(609), + np.int64(610), + np.int64(611), + np.int64(728), + np.int64(729), + np.int64(730), + np.int64(731), + np.int64(852), + np.int64(853), + np.int64(854), + np.int64(855), + ): list([ + 1, + ]), + tuple( + np.int64(8), + np.int64(9), + np.int64(10), + np.int64(11), + np.int64(132), + np.int64(133), + np.int64(134), + np.int64(135), + np.int64(244), + np.int64(245), + np.int64(246), + np.int64(247), + np.int64(368), + np.int64(369), + np.int64(370), + np.int64(371), + np.int64(488), + np.int64(489), + np.int64(490), + np.int64(491), + np.int64(612), + np.int64(613), + np.int64(614), + np.int64(615), + np.int64(732), + np.int64(733), + np.int64(734), + np.int64(735), + np.int64(856), + np.int64(857), + np.int64(858), + np.int64(859), + ): list([ + 2, + ]), + tuple( + np.int64(12), + np.int64(13), + np.int64(14), + np.int64(15), + np.int64(136), + np.int64(137), + np.int64(138), + np.int64(139), + np.int64(248), + np.int64(249), + np.int64(250), + np.int64(251), + np.int64(372), + np.int64(373), + np.int64(374), + np.int64(375), + np.int64(492), + np.int64(493), + np.int64(494), + np.int64(495), + np.int64(616), + np.int64(617), + np.int64(618), + np.int64(619), + np.int64(736), + np.int64(737), + np.int64(738), + np.int64(739), + np.int64(860), + np.int64(861), + np.int64(862), + np.int64(863), + ): list([ + 3, + ]), + tuple( + np.int64(16), + np.int64(17), + np.int64(18), + np.int64(19), + np.int64(140), + np.int64(141), + np.int64(142), + np.int64(143), + np.int64(252), + np.int64(253), + np.int64(254), + np.int64(255), + np.int64(376), + np.int64(377), + np.int64(378), + np.int64(379), + np.int64(496), + np.int64(497), + np.int64(498), + np.int64(499), + np.int64(620), + np.int64(621), + np.int64(622), + np.int64(623), + np.int64(740), + np.int64(741), + np.int64(742), + np.int64(743), + np.int64(864), + np.int64(865), + np.int64(866), + np.int64(867), + ): list([ + 4, + ]), + tuple( + np.int64(20), + np.int64(21), + np.int64(22), + np.int64(23), + np.int64(144), + np.int64(145), + np.int64(146), + np.int64(147), + np.int64(256), + np.int64(257), + np.int64(258), + np.int64(259), + np.int64(380), + np.int64(381), + np.int64(382), + np.int64(383), + np.int64(500), + np.int64(501), + np.int64(502), + np.int64(503), + np.int64(624), + np.int64(625), + np.int64(626), + np.int64(627), + np.int64(744), + np.int64(745), + np.int64(746), + np.int64(747), + np.int64(868), + np.int64(869), + np.int64(870), + np.int64(871), + ): list([ + 5, + ]), + tuple( + np.int64(24), + np.int64(25), + np.int64(26), + np.int64(27), + np.int64(148), + np.int64(149), + np.int64(150), + np.int64(151), + np.int64(260), + np.int64(261), + np.int64(262), + np.int64(263), + np.int64(384), + np.int64(385), + np.int64(386), + np.int64(387), + np.int64(504), + np.int64(505), + np.int64(506), + np.int64(507), + np.int64(628), + np.int64(629), + np.int64(630), + np.int64(631), + np.int64(748), + np.int64(749), + np.int64(750), + np.int64(751), + np.int64(872), + np.int64(873), + np.int64(874), + np.int64(875), + ): list([ + 6, + ]), + tuple( + np.int64(28), + np.int64(29), + np.int64(30), + np.int64(31), + np.int64(152), + np.int64(153), + np.int64(154), + np.int64(155), + np.int64(264), + np.int64(265), + np.int64(266), + np.int64(267), + np.int64(388), + np.int64(389), + np.int64(390), + np.int64(391), + np.int64(508), + np.int64(509), + np.int64(510), + np.int64(511), + np.int64(632), + np.int64(633), + np.int64(634), + np.int64(635), + np.int64(752), + np.int64(753), + np.int64(754), + np.int64(755), + np.int64(876), + np.int64(877), + np.int64(878), + np.int64(879), + ): list([ + 7, + ]), + tuple( + np.int64(32), + np.int64(33), + np.int64(34), + np.int64(35), + np.int64(156), + np.int64(157), + np.int64(158), + np.int64(159), + np.int64(268), + np.int64(269), + np.int64(270), + np.int64(271), + np.int64(392), + np.int64(393), + np.int64(394), + np.int64(395), + np.int64(512), + np.int64(513), + np.int64(514), + np.int64(515), + np.int64(636), + np.int64(637), + np.int64(638), + np.int64(639), + np.int64(756), + np.int64(757), + np.int64(758), + np.int64(759), + np.int64(880), + np.int64(881), + np.int64(882), + np.int64(883), + ): list([ + 8, + ]), + tuple( + np.int64(36), + np.int64(37), + np.int64(38), + np.int64(39), + np.int64(160), + np.int64(161), + np.int64(162), + np.int64(163), + np.int64(272), + np.int64(273), + np.int64(274), + np.int64(275), + np.int64(396), + np.int64(397), + np.int64(398), + np.int64(399), + np.int64(516), + np.int64(517), + np.int64(518), + np.int64(519), + np.int64(640), + np.int64(641), + np.int64(642), + np.int64(643), + np.int64(760), + np.int64(761), + np.int64(762), + np.int64(763), + np.int64(884), + np.int64(885), + np.int64(886), + np.int64(887), + ): list([ + 9, + ]), + tuple( + np.int64(40), + np.int64(41), + np.int64(42), + np.int64(43), + np.int64(164), + np.int64(165), + np.int64(166), + np.int64(167), + np.int64(276), + np.int64(277), + np.int64(278), + np.int64(279), + np.int64(400), + np.int64(401), + np.int64(402), + np.int64(403), + np.int64(520), + np.int64(521), + np.int64(522), + np.int64(523), + np.int64(644), + np.int64(645), + np.int64(646), + np.int64(647), + np.int64(764), + np.int64(765), + np.int64(766), + np.int64(767), + np.int64(888), + np.int64(889), + np.int64(890), + np.int64(891), + ): list([ + 10, + ]), + tuple( + np.int64(44), + np.int64(45), + np.int64(46), + np.int64(47), + np.int64(168), + np.int64(169), + np.int64(170), + np.int64(171), + np.int64(280), + np.int64(281), + np.int64(282), + np.int64(283), + np.int64(404), + np.int64(405), + np.int64(406), + np.int64(407), + np.int64(524), + np.int64(525), + np.int64(526), + np.int64(527), + np.int64(648), + np.int64(649), + np.int64(650), + np.int64(651), + np.int64(768), + np.int64(769), + np.int64(770), + np.int64(771), + np.int64(892), + np.int64(893), + np.int64(894), + np.int64(895), + ): list([ + 11, + ]), + tuple( + np.int64(48), + np.int64(49), + np.int64(50), + np.int64(51), + np.int64(172), + np.int64(173), + np.int64(174), + np.int64(175), + np.int64(284), + np.int64(285), + np.int64(286), + np.int64(287), + np.int64(408), + np.int64(409), + np.int64(410), + np.int64(411), + np.int64(528), + np.int64(529), + np.int64(530), + np.int64(531), + np.int64(652), + np.int64(653), + np.int64(654), + np.int64(655), + np.int64(772), + np.int64(773), + np.int64(774), + np.int64(775), + np.int64(896), + np.int64(897), + np.int64(898), + np.int64(899), + ): list([ + 12, + ]), + tuple( + np.int64(52), + np.int64(53), + np.int64(54), + np.int64(55), + np.int64(176), + np.int64(177), + np.int64(178), + np.int64(179), + np.int64(288), + np.int64(289), + np.int64(290), + np.int64(291), + np.int64(412), + np.int64(413), + np.int64(414), + np.int64(415), + np.int64(532), + np.int64(533), + np.int64(534), + np.int64(535), + np.int64(656), + np.int64(657), + np.int64(658), + np.int64(659), + np.int64(776), + np.int64(777), + np.int64(778), + np.int64(779), + ): list([ + 13, + ]), + tuple( + np.int64(56), + np.int64(57), + np.int64(58), + np.int64(59), + np.int64(180), + np.int64(181), + np.int64(182), + np.int64(183), + np.int64(292), + np.int64(293), + np.int64(294), + np.int64(295), + np.int64(416), + np.int64(417), + np.int64(418), + np.int64(419), + np.int64(536), + np.int64(537), + np.int64(538), + np.int64(539), + np.int64(660), + np.int64(661), + np.int64(662), + np.int64(663), + np.int64(780), + np.int64(781), + np.int64(782), + np.int64(783), + ): list([ + 14, + ]), + tuple( + np.int64(60), + np.int64(61), + np.int64(62), + np.int64(63), + np.int64(184), + np.int64(185), + np.int64(186), + np.int64(187), + np.int64(296), + np.int64(297), + np.int64(298), + np.int64(299), + np.int64(420), + np.int64(421), + np.int64(422), + np.int64(423), + np.int64(540), + np.int64(541), + np.int64(542), + np.int64(543), + np.int64(664), + np.int64(665), + np.int64(666), + np.int64(667), + np.int64(784), + np.int64(785), + np.int64(786), + np.int64(787), + ): list([ + 15, + ]), + tuple( + np.int64(64), + np.int64(65), + np.int64(66), + np.int64(67), + np.int64(188), + np.int64(189), + np.int64(190), + np.int64(191), + np.int64(300), + np.int64(301), + np.int64(302), + np.int64(303), + np.int64(424), + np.int64(425), + np.int64(426), + np.int64(427), + np.int64(544), + np.int64(545), + np.int64(546), + np.int64(547), + np.int64(668), + np.int64(669), + np.int64(670), + np.int64(671), + np.int64(788), + np.int64(789), + np.int64(790), + np.int64(791), + ): list([ + 16, + ]), + tuple( + np.int64(68), + np.int64(69), + np.int64(70), + np.int64(71), + np.int64(192), + np.int64(193), + np.int64(194), + np.int64(195), + np.int64(304), + np.int64(305), + np.int64(306), + np.int64(307), + np.int64(428), + np.int64(429), + np.int64(430), + np.int64(431), + np.int64(548), + np.int64(549), + np.int64(550), + np.int64(551), + np.int64(672), + np.int64(673), + np.int64(674), + np.int64(675), + np.int64(792), + np.int64(793), + np.int64(794), + np.int64(795), + ): list([ + 17, + ]), + tuple( + np.int64(72), + np.int64(73), + np.int64(74), + np.int64(75), + np.int64(196), + np.int64(197), + np.int64(198), + np.int64(199), + np.int64(308), + np.int64(309), + np.int64(310), + np.int64(311), + np.int64(432), + np.int64(433), + np.int64(434), + np.int64(435), + np.int64(552), + np.int64(553), + np.int64(554), + np.int64(555), + np.int64(676), + np.int64(677), + np.int64(678), + np.int64(679), + np.int64(796), + np.int64(797), + np.int64(798), + np.int64(799), + ): list([ + 18, + ]), + tuple( + np.int64(76), + np.int64(77), + np.int64(78), + np.int64(79), + np.int64(200), + np.int64(201), + np.int64(202), + np.int64(203), + np.int64(312), + np.int64(313), + np.int64(314), + np.int64(315), + np.int64(436), + np.int64(437), + np.int64(438), + np.int64(439), + np.int64(556), + np.int64(557), + np.int64(558), + np.int64(559), + np.int64(680), + np.int64(681), + np.int64(682), + np.int64(683), + np.int64(800), + np.int64(801), + np.int64(802), + np.int64(803), + ): list([ + 19, + ]), + tuple( + np.int64(80), + np.int64(81), + np.int64(82), + np.int64(83), + np.int64(204), + np.int64(205), + np.int64(206), + np.int64(207), + np.int64(316), + np.int64(317), + np.int64(318), + np.int64(319), + np.int64(440), + np.int64(441), + np.int64(442), + np.int64(443), + np.int64(560), + np.int64(561), + np.int64(562), + np.int64(563), + np.int64(684), + np.int64(685), + np.int64(686), + np.int64(687), + np.int64(804), + np.int64(805), + np.int64(806), + np.int64(807), + ): list([ + 20, + ]), + tuple( + np.int64(84), + np.int64(85), + np.int64(86), + np.int64(87), + np.int64(208), + np.int64(209), + np.int64(210), + np.int64(211), + np.int64(320), + np.int64(321), + np.int64(322), + np.int64(323), + np.int64(444), + np.int64(445), + np.int64(446), + np.int64(447), + np.int64(564), + np.int64(565), + np.int64(566), + np.int64(567), + np.int64(688), + np.int64(689), + np.int64(690), + np.int64(691), + np.int64(808), + np.int64(809), + np.int64(810), + np.int64(811), + ): list([ + 21, + ]), + tuple( + np.int64(88), + np.int64(89), + np.int64(90), + np.int64(91), + np.int64(212), + np.int64(213), + np.int64(214), + np.int64(215), + np.int64(324), + np.int64(325), + np.int64(326), + np.int64(327), + np.int64(448), + np.int64(449), + np.int64(450), + np.int64(451), + np.int64(568), + np.int64(569), + np.int64(570), + np.int64(571), + np.int64(692), + np.int64(693), + np.int64(694), + np.int64(695), + np.int64(812), + np.int64(813), + np.int64(814), + np.int64(815), + ): list([ + 22, + ]), + tuple( + np.int64(92), + np.int64(93), + np.int64(94), + np.int64(95), + np.int64(216), + np.int64(217), + np.int64(218), + np.int64(219), + np.int64(328), + np.int64(329), + np.int64(330), + np.int64(331), + np.int64(452), + np.int64(453), + np.int64(454), + np.int64(455), + np.int64(572), + np.int64(573), + np.int64(574), + np.int64(575), + np.int64(696), + np.int64(697), + np.int64(698), + np.int64(699), + np.int64(816), + np.int64(817), + np.int64(818), + np.int64(819), + ): list([ + 23, + ]), + tuple( + np.int64(96), + np.int64(97), + np.int64(98), + np.int64(99), + np.int64(220), + np.int64(221), + np.int64(222), + np.int64(223), + np.int64(332), + np.int64(333), + np.int64(334), + np.int64(335), + np.int64(456), + np.int64(457), + np.int64(458), + np.int64(459), + np.int64(576), + np.int64(577), + np.int64(578), + np.int64(579), + np.int64(700), + np.int64(701), + np.int64(702), + np.int64(703), + np.int64(820), + np.int64(821), + np.int64(822), + np.int64(823), + ): list([ + 24, + ]), + tuple( + np.int64(100), + np.int64(101), + np.int64(102), + np.int64(103), + np.int64(224), + np.int64(225), + np.int64(226), + np.int64(227), + np.int64(336), + np.int64(337), + np.int64(338), + np.int64(339), + np.int64(460), + np.int64(461), + np.int64(462), + np.int64(463), + np.int64(580), + np.int64(581), + np.int64(582), + np.int64(583), + np.int64(704), + np.int64(705), + np.int64(706), + np.int64(707), + np.int64(824), + np.int64(825), + np.int64(826), + np.int64(827), + ): list([ + 25, + ]), + tuple( + np.int64(104), + np.int64(105), + np.int64(106), + np.int64(107), + np.int64(228), + np.int64(229), + np.int64(230), + np.int64(231), + np.int64(340), + np.int64(341), + np.int64(342), + np.int64(343), + np.int64(464), + np.int64(465), + np.int64(466), + np.int64(467), + np.int64(584), + np.int64(585), + np.int64(586), + np.int64(587), + np.int64(708), + np.int64(709), + np.int64(710), + np.int64(711), + np.int64(828), + np.int64(829), + np.int64(830), + np.int64(831), + ): list([ + 26, + ]), + tuple( + np.int64(108), + np.int64(109), + np.int64(110), + np.int64(111), + np.int64(232), + np.int64(233), + np.int64(234), + np.int64(235), + np.int64(344), + np.int64(345), + np.int64(346), + np.int64(347), + np.int64(468), + np.int64(469), + np.int64(470), + np.int64(471), + np.int64(588), + np.int64(589), + np.int64(590), + np.int64(591), + np.int64(712), + np.int64(713), + np.int64(714), + np.int64(715), + np.int64(832), + np.int64(833), + np.int64(834), + np.int64(835), + ): list([ + 27, + ]), + tuple( + np.int64(112), + np.int64(113), + np.int64(114), + np.int64(115), + np.int64(348), + np.int64(349), + np.int64(350), + np.int64(351), + np.int64(472), + np.int64(473), + np.int64(474), + np.int64(475), + np.int64(592), + np.int64(593), + np.int64(594), + np.int64(595), + np.int64(716), + np.int64(717), + np.int64(718), + np.int64(719), + np.int64(836), + np.int64(837), + np.int64(838), + np.int64(839), + ): list([ + 28, + ]), + tuple( + np.int64(116), + np.int64(117), + np.int64(118), + np.int64(119), + np.int64(352), + np.int64(353), + np.int64(354), + np.int64(355), + np.int64(476), + np.int64(477), + np.int64(478), + np.int64(479), + np.int64(596), + np.int64(597), + np.int64(598), + np.int64(599), + np.int64(720), + np.int64(721), + np.int64(722), + np.int64(723), + np.int64(840), + np.int64(841), + np.int64(842), + np.int64(843), + ): list([ + 29, + ]), + tuple( + np.int64(120), + np.int64(121), + np.int64(122), + np.int64(123), + np.int64(356), + np.int64(357), + np.int64(358), + np.int64(359), + np.int64(600), + np.int64(601), + np.int64(602), + np.int64(603), + np.int64(844), + np.int64(845), + np.int64(846), + np.int64(847), + ): list([ + 30, + ]), + }) +# --- +# name: test_snapshot_cohorts[ERA5MonthHourRechunked] + dict({ + tuple( + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + ): list([ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + ]), + tuple( + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 240, + 241, + 242, + 243, + ): list([ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + ]), + tuple( + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 516, + 517, + 518, + 519, + 520, + 521, + 522, + 523, + 524, + 525, + 526, + 527, + 528, + 529, + 530, + 531, + 532, + 319, + 320, + 321, + 322, + 323, + 324, + 325, + 326, + 327, + 328, + 329, + 330, + 331, + 332, + 333, + 334, + 335, + 122, + 123, + 124, + 125, + 126, + 127, + ): list([ + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + ]), + tuple( + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 532, + 533, + 534, + 535, + 536, + 537, + 538, + 539, + 540, + 541, + 542, + 543, + 544, + 545, + 546, + 547, + 335, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + 350, + ): list([ + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + ]), + tuple( + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 547, + 548, + 549, + 550, + 551, + 552, + 553, + 554, + 555, + 556, + 557, + 558, + 559, + 560, + 561, + 562, + 168, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + ): list([ + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + ]), + tuple( + 183, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 562, + 563, + 564, + 565, + 566, + 567, + 568, + 569, + 570, + 571, + 572, + 573, + 574, + 575, + 576, + 577, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + ): list([ + 240, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 253, + 254, + 255, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + ]), + tuple( + 256, + 257, + 258, + 61, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 440, + 441, + 442, + 443, + 444, + 445, + 446, + 447, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 253, + 254, + 255, + ): list([ + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + ]), + tuple( + 258, + 259, + 260, + 261, + 262, + 263, + 264, + 265, + 266, + 267, + 268, + 269, + 270, + 271, + 272, + 273, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 455, + 456, + 457, + 458, + 459, + 460, + 461, + 462, + 463, + 464, + 465, + 466, + 467, + 468, + 469, + 470, + 76, + ): list([ + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + ]), + tuple( + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 280, + 281, + 282, + 283, + 284, + 285, + 286, + 287, + 288, + 289, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 470, + 471, + 472, + 473, + 474, + 475, + 476, + 477, + 478, + 479, + 480, + 481, + 482, + 483, + 484, + 485, + 486, + ): list([ + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + ]), + tuple( + 289, + 290, + 291, + 292, + 293, + 294, + 295, + 296, + 297, + 298, + 299, + 300, + 301, + 302, + 303, + 304, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 486, + 487, + 488, + 489, + 490, + 491, + 492, + 493, + 494, + 495, + 496, + 497, + 498, + 499, + 500, + 501, + ): list([ + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + ]), + tuple( + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 577, + 578, + 579, + 580, + 581, + 582, + 583, + 584, + 585, + 586, + 587, + 588, + 589, + 590, + 591, + 592, + 593, + 380, + 381, + 382, + 383, + ): list([ + 264, + 265, + 266, + 267, + 268, + 269, + 270, + 271, + 272, + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 280, + 281, + 282, + 283, + 284, + 285, + 286, + ]), + tuple( + 512, + 513, + 514, + 515, + 516, + 505, + 304, + 305, + 306, + 307, + 308, + 309, + 310, + 311, + 312, + 313, + 314, + 315, + 316, + 317, + 318, + 319, + 506, + 507, + 503, + 122, + 504, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 501, + 502, + 508, + 509, + 510, + 511, + ): list([ + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + ]), + }) +# --- +# name: test_snapshot_cohorts[ERA5MonthHour] + dict({ + tuple( + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + ): list([ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + ]), + tuple( + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 304, + 305, + 306, + 307, + 308, + 309, + 310, + 311, + 312, + 313, + 314, + 315, + 316, + 317, + 318, + 319, + 487, + 488, + 489, + 490, + 491, + 492, + 493, + 494, + 495, + 496, + 497, + 498, + 499, + 500, + 501, + 122, + 123, + 124, + 125, + 126, + 127, + ): list([ + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + ]), + tuple( + 256, + 257, + 258, + 425, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 253, + 254, + 255, + ): list([ + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + ]), + tuple( + 258, + 259, + 260, + 261, + 262, + 263, + 264, + 265, + 266, + 267, + 268, + 269, + 270, + 271, + 272, + 273, + 441, + 442, + 443, + 444, + 445, + 446, + 447, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + ): list([ + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + ]), + tuple( + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 280, + 281, + 282, + 283, + 284, + 285, + 286, + 287, + 288, + 456, + 457, + 458, + 459, + 460, + 461, + 462, + 463, + 464, + 465, + 466, + 467, + 468, + 469, + 470, + 471, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + ): list([ + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + ]), + tuple( + 289, + 290, + 291, + 292, + 293, + 294, + 295, + 296, + 297, + 298, + 299, + 300, + 301, + 302, + 303, + 304, + 471, + 472, + 473, + 474, + 475, + 476, + 477, + 478, + 479, + 480, + 481, + 482, + 483, + 484, + 485, + 486, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + ): list([ + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + ]), + tuple( + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 381, + 382, + 383, + ): list([ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + ]), + tuple( + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + ): list([ + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + ]), + tuple( + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 240, + 241, + 242, + ): list([ + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + ]), + tuple( + 512, + 513, + 514, + 515, + 516, + 517, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 319, + 320, + 321, + 322, + 323, + 324, + 325, + 326, + 327, + 328, + 329, + 330, + 331, + 332, + 333, + 334, + 502, + 503, + 504, + 505, + 506, + 507, + 508, + 509, + 510, + 511, + ): list([ + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + ]), + tuple( + 517, + 518, + 519, + 520, + 521, + 522, + 523, + 524, + 525, + 526, + 527, + 528, + 529, + 530, + 531, + 532, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 335, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + ): list([ + 240, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 253, + 254, + 255, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + ]), + tuple( + 532, + 533, + 534, + 535, + 536, + 537, + 538, + 539, + 540, + 541, + 542, + 543, + 544, + 545, + 546, + 547, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + ): list([ + 264, + 265, + 266, + 267, + 268, + 269, + 270, + 271, + 272, + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 280, + 281, + 282, + 283, + 284, + 285, + 286, + ]), + }) +# --- +# name: test_snapshot_cohorts[NWMMidwest] + dict({ + tuple( + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 26, + 27, + 39, + 52, + 65, + ): list([ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 25, + 26, + 27, + 29, + ]), + tuple( + 2, + 3, + 5, + 6, + 10, + 12, + 14, + 15, + 52, + 26, + 27, + ): list([ + 24, + 28, + ]), + tuple( + 2, + 4, + 6, + 14, + 15, + 26, + 27, + ): list([ + 30, + ]), + tuple( + 3, + 4, + 5, + 7, + 39, + 40, + 8, + 9, + 14, + 15, + 16, + 26, + 27, + 28, + ): list([ + 32, + 33, + 35, + 36, + 37, + 38, + 40, + 46, + 51, + ]), + tuple( + 3, + 4, + 6, + 15, + 16, + 17, + 27, + ): list([ + 41, + ]), + tuple( + 3, + 6, + 7, + 14, + 15, + 26, + 27, + ): list([ + 31, + ]), + tuple( + 4, + 5, + 6, + 8, + 40, + 9, + 15, + 17, + 18, + 27, + 28, + ): list([ + 49, + 53, + 56, + 57, + ]), + tuple( + 4, + 10, + 11, + 15, + 17, + 52, + 53, + ): list([ + 45, + ]), + tuple( + 5, + 6, + 7, + 10, + 11, + 12, + 15, + 16, + 52, + 53, + 27, + 28, + ): list([ + 43, + 47, + 50, + ]), + tuple( + 6, + 7, + 40, + 9, + 41, + 8, + 16, + 17, + 19, + 20, + 21, + 27, + 28, + ): list([ + 44, + 54, + 55, + 58, + 60, + 63, + 66, + 69, + 72, + 80, + ]), + tuple( + 6, + 10, + 11, + 19, + 53, + 28, + ): list([ + 62, + ]), + tuple( + 6, + 39, + 40, + 9, + 15, + 16, + 27, + ): list([ + 39, + ]), + tuple( + 7, + 8, + 40, + 11, + 15, + 16, + 17, + 52, + 53, + ): list([ + 48, + ]), + tuple( + 7, + 40, + 9, + 10, + 8, + 41, + 11, + 16, + 17, + 18, + 53, + 28, + 29, + ): list([ + 59, + 61, + 64, + 65, + 67, + ]), + tuple( + 8, + 41, + 10, + 11, + 17, + 21, + 53, + 54, + ): list([ + 79, + ]), + tuple( + 8, + 41, + 21, + ): list([ + 75, + ]), + tuple( + 9, + 10, + 41, + 22, + 23, + 54, + ): list([ + 87, + ]), + tuple( + 9, + 41, + 17, + 18, + 22, + 30, + ): list([ + 84, + ]), + tuple( + 9, + 41, + 42, + 19, + 21, + 22, + 29, + ): list([ + 82, + 86, + 106, + ]), + tuple( + 10, + 11, + 54, + 23, + 24, + ): list([ + 93, + ]), + tuple( + 10, + 12, + 18, + 19, + 20, + 53, + 54, + 28, + 29, + ): list([ + 76, + 85, + ]), + tuple( + 11, + 19, + 54, + 24, + 29, + 30, + ): list([ + 99, + ]), + tuple( + 16, + 3, + 15, + ): list([ + 34, + ]), + tuple( + 17, + 18, + 30, + 31, + ): list([ + 92, + ]), + tuple( + 24, + 54, + 31, + ): list([ + 111, + ]), + tuple( + 25, + 67, + 54, + ): list([ + 120, + ]), + tuple( + 32, + 33, + 34, + 35, + 44, + 45, + 55, + 24, + 25, + 56, + ): list([ + 143, + 145, + 149, + 154, + 156, + 160, + 163, + 164, + 166, + 169, + 170, + 175, + 183, + 190, + ]), + tuple( + 32, + 33, + 34, + 36, + 37, + 45, + 46, + 47, + 57, + ): list([ + 165, + 172, + 173, + 178, + 179, + 180, + 185, + ]), + tuple( + 32, + 33, + 34, + 44, + 23, + 55, + 24, + 56, + ): list([ + 121, + 140, + 144, + 151, + 153, + 155, + ]), + tuple( + 32, + 33, + 41, + 42, + 23, + 55, + 54, + 22, + 24, + 25, + 31, + ): list([ + 101, + 113, + 116, + 124, + 125, + 129, + 130, + 131, + ]), + tuple( + 32, + 33, + 42, + 19, + 20, + 22, + 30, + 31, + ): list([ + 110, + 122, + 159, + ]), + tuple( + 32, + 33, + 45, + ): list([ + 150, + 158, + ]), + tuple( + 32, + 33, + 55, + 24, + 31, + ): list([ + 137, + ]), + tuple( + 32, + 41, + 42, + 43, + 19, + 20, + 21, + 22, + 23, + 54, + 24, + 29, + 30, + 31, + ): list([ + 77, + 90, + 94, + 95, + 98, + 100, + 104, + 107, + 108, + 109, + 112, + 115, + 117, + ]), + tuple( + 32, + 42, + 43, + 20, + 21, + 31, + ): list([ + 123, + ]), + tuple( + 32, + 43, + 22, + ): list([ + 139, + ]), + tuple( + 33, + 34, + 35, + 42, + 43, + 44, + 20, + 21, + 22, + ): list([ + 119, + 128, + 132, + 138, + 141, + 147, + 152, + ]), + tuple( + 33, + 43, + 44, + 20, + 30, + 31, + ): list([ + 118, + 126, + 135, + 142, + ]), + tuple( + 34, + 46, + 47, + ): list([ + 187, + 193, + ]), + tuple( + 35, + 36, + 37, + 38, + 44, + 45, + 46, + 57, + 58, + 59, + ): list([ + 168, + 177, + 186, + 191, + 195, + 199, + 203, + 204, + 213, + ]), + tuple( + 35, + 36, + 43, + 44, + 22, + 23, + 56, + 57, + ): list([ + 146, + 157, + 162, + ]), + tuple( + 35, + 36, + 46, + 48, + 49, + 59, + ): list([ + 200, + 205, + 212, + 219, + ]), + tuple( + 35, + 37, + 44, + 24, + 57, + 56, + ): list([ + 171, + 176, + 192, + 198, + ]), + tuple( + 35, + 38, + 45, + 56, + 25, + 57, + ): list([ + 181, + ]), + tuple( + 36, + 37, + 23, + 24, + 57, + 56, + ): list([ + 167, + ]), + tuple( + 36, + 37, + 38, + 46, + 47, + 48, + 57, + 58, + ): list([ + 188, + 201, + 208, + 211, + 217, + 223, + ]), + tuple( + 36, + 37, + 47, + 58, + 59, + ): list([ + 197, + 206, + 210, + 216, + 221, + ]), + tuple( + 36, + 37, + 49, + 50, + 59, + ): list([ + 224, + 230, + 234, + ]), + tuple( + 37, + 49, + 58, + 59, + 60, + ): list([ + 225, + ]), + tuple( + 38, + 71, + 72, + 58, + 59, + ): list([ + 218, + 226, + 231, + 237, + ]), + tuple( + 38, + 72, + 73, + 51, + 59, + 60, + ): list([ + 245, + 252, + 260, + 267, + ]), + tuple( + 39, + 40, + 9, + 10, + 52, + 53, + ): list([ + 42, + ]), + tuple( + 40, + 9, + 10, + 41, + 53, + 54, + ): list([ + 74, + ]), + tuple( + 40, + 9, + 41, + 12, + 18, + 19, + 53, + 28, + 29, + ): list([ + 68, + ]), + tuple( + 40, + 9, + 41, + 16, + 17, + 18, + 29, + 30, + ): list([ + 71, + 78, + ]), + tuple( + 41, + 10, + 18, + 19, + 21, + 54, + 23, + 29, + 30, + ): list([ + 73, + 89, + 91, + ]), + tuple( + 41, + 11, + 18, + 20, + 53, + 54, + 21, + 24, + 29, + 30, + ): list([ + 81, + 83, + 96, + ]), + tuple( + 41, + 18, + 22, + 30, + 31, + ): list([ + 97, + 103, + ]), + tuple( + 42, + 43, + 20, + 21, + 54, + 24, + ): list([ + 114, + ]), + tuple( + 42, + 43, + 23, + 22, + 55, + 24, + 56, + ): list([ + 127, + 136, + ]), + tuple( + 43, + 23, + 21, + 55, + 24, + ): list([ + 133, + ]), + tuple( + 46, + 47, + 48, + 49, + 50, + 59, + 60, + ): list([ + 194, + 202, + 209, + 214, + 215, + 220, + 222, + 227, + 228, + 229, + 232, + 233, + 235, + 236, + 241, + 243, + ]), + tuple( + 48, + 49, + 50, + 61, + 62, + 63, + ): list([ + 253, + 254, + 255, + 258, + 259, + 261, + 263, + 264, + 265, + 266, + 269, + 270, + 271, + 274, + 275, + 276, + 279, + 280, + 283, + 284, + 287, + 290, + ]), + tuple( + 48, + 49, + 61, + ): list([ + 242, + 249, + ]), + tuple( + 49, + 50, + 59, + 60, + ): list([ + 238, + 239, + 244, + 246, + 247, + 250, + 251, + 257, + ]), + tuple( + 49, + 51, + 59, + 60, + 61, + ): list([ + 248, + 256, + 262, + ]), + tuple( + 57, + 36, + 37, + ): list([ + 182, + 189, + ]), + tuple( + 59, + 51, + 38, + ): list([ + 240, + ]), + tuple( + 64, + 74, + 75, + 51, + 61, + 62, + ): list([ + 268, + 272, + 273, + 277, + 278, + 281, + ]), + tuple( + 64, + 75, + 76, + 62, + 63, + ): list([ + 282, + 285, + 286, + 288, + 289, + 291, + 292, + 293, + 294, + ]), + tuple( + 64, + 77, + ): list([ + 295, + 296, + ]), + tuple( + 65, + 66, + 12, + 52, + 53, + ): list([ + 52, + 70, + ]), + tuple( + 66, + 67, + 12, + 53, + 54, + ): list([ + 88, + ]), + tuple( + 67, + 42, + 12, + 19, + 21, + 54, + 25, + 30, + ): list([ + 102, + 105, + ]), + tuple( + 68, + 69, + 55, + 56, + 25, + ): list([ + 134, + 148, + 161, + ]), + tuple( + 69, + 38, + 70, + 56, + 25, + 57, + ): list([ + 174, + 184, + 196, + 207, + ]), + }) +# --- +# name: test_snapshot_cohorts[OISST] + dict({ + tuple( + 0, + 255, + 912, + 145, + 401, + 657, + 1168, + 1424, + 1022, + 146, + 913, + 767, + 1169, + 1278, + 1314, + 547, + 36, + 292, + 803, + 1059, + 1315, + 548, + 693, + 182, + 438, + 949, + 1205, + 694, + 839, + 72, + 328, + 584, + 1095, + 1351, + 73, + 840, + 985, + 474, + 218, + 730, + 1241, + 219, + 986, + 475, + 1242, + 1387, + 620, + 109, + 365, + 876, + 1132, + 621, + 1388, + 766, + 511, + ): list([ + 241, + 242, + 243, + 244, + 245, + ]), + tuple( + 0, + 255, + 1424, + 657, + 146, + 402, + 767, + 913, + 1169, + 1023, + 803, + 36, + 292, + 548, + 1059, + 1315, + 949, + 182, + 438, + 694, + 1205, + 1351, + 584, + 73, + 329, + 840, + 1096, + 730, + 475, + 219, + 986, + 1242, + 876, + 109, + 365, + 621, + 1132, + 1388, + 1278, + 511, + ): list([ + 246, + ]), + tuple( + 0, + 256, + 512, + 913, + 146, + 402, + 658, + 1169, + 1425, + 1023, + 1059, + 292, + 37, + 548, + 804, + 1279, + 1315, + 694, + 439, + 183, + 950, + 1206, + 840, + 73, + 329, + 585, + 1096, + 1352, + 986, + 475, + 219, + 731, + 1242, + 1132, + 365, + 110, + 621, + 877, + 1388, + 767, + ): list([ + 250, + ]), + tuple( + 0, + 256, + 512, + 913, + 146, + 402, + 658, + 1169, + 1425, + 1023, + 1279, + 548, + 37, + 293, + 804, + 1060, + 1315, + 694, + 439, + 183, + 950, + 1206, + 840, + 73, + 329, + 585, + 1096, + 1352, + 986, + 475, + 219, + 731, + 1242, + 1388, + 621, + 110, + 366, + 877, + 1133, + 767, + ): list([ + 251, + ]), + tuple( + 0, + 256, + 512, + 1169, + 402, + 147, + 658, + 914, + 1425, + 1023, + 1279, + 548, + 37, + 293, + 804, + 1060, + 1315, + 694, + 439, + 183, + 950, + 1206, + 840, + 73, + 329, + 585, + 1096, + 1352, + 1242, + 475, + 220, + 731, + 987, + 1388, + 621, + 110, + 366, + 877, + 1133, + 767, + ): list([ + 252, + ]), + tuple( + 0, + 256, + 913, + 146, + 402, + 658, + 767, + 1169, + 1425, + 1023, + 1059, + 292, + 37, + 548, + 804, + 1315, + 1205, + 438, + 183, + 694, + 950, + 840, + 73, + 329, + 585, + 1096, + 1352, + 986, + 475, + 219, + 731, + 1242, + 1132, + 365, + 110, + 621, + 877, + 1388, + 1278, + 511, + ): list([ + 249, + ]), + tuple( + 0, + 256, + 1424, + 657, + 146, + 402, + 767, + 913, + 1169, + 1023, + 803, + 36, + 292, + 548, + 1059, + 1315, + 1205, + 438, + 183, + 694, + 950, + 1351, + 584, + 73, + 329, + 840, + 1096, + 730, + 475, + 219, + 986, + 1242, + 1132, + 109, + 365, + 621, + 877, + 1388, + 1278, + 511, + ): list([ + 247, + ]), + tuple( + 0, + 256, + 1424, + 657, + 146, + 402, + 767, + 913, + 1169, + 1023, + 1059, + 292, + 37, + 548, + 804, + 1315, + 1205, + 438, + 183, + 694, + 950, + 1351, + 584, + 73, + 329, + 840, + 1096, + 986, + 475, + 219, + 731, + 1242, + 1132, + 365, + 110, + 621, + 877, + 1388, + 1278, + 511, + ): list([ + 248, + ]), + tuple( + 128, + 383, + 529, + 18, + 274, + 785, + 1041, + 1297, + 895, + 1406, + 931, + 164, + 420, + 676, + 1187, + 1443, + 1077, + 310, + 55, + 566, + 822, + 1333, + 1223, + 456, + 201, + 712, + 968, + 858, + 347, + 603, + 91, + 1114, + 1370, + 1004, + 237, + 493, + 749, + 1260, + 1150, + 639, + ): list([ + 64, + ]), + tuple( + 128, + 383, + 785, + 18, + 274, + 530, + 1041, + 1297, + 895, + 1151, + 931, + 164, + 420, + 676, + 1187, + 1443, + 1077, + 310, + 55, + 566, + 822, + 1333, + 712, + 201, + 457, + 968, + 1224, + 858, + 347, + 603, + 91, + 1114, + 1370, + 1004, + 237, + 493, + 749, + 1260, + 1406, + 639, + ): list([ + 65, + ]), + tuple( + 128, + 383, + 1296, + 529, + 18, + 274, + 785, + 1041, + 895, + 1406, + 675, + 164, + 420, + 931, + 1187, + 1442, + 821, + 54, + 310, + 566, + 1077, + 1333, + 1223, + 456, + 201, + 712, + 968, + 1369, + 602, + 347, + 91, + 858, + 1114, + 748, + 237, + 493, + 1004, + 1260, + 1150, + 639, + ): list([ + 62, + ]), + tuple( + 128, + 383, + 1296, + 529, + 18, + 274, + 785, + 1041, + 895, + 1406, + 675, + 164, + 420, + 931, + 1187, + 1443, + 1077, + 310, + 55, + 566, + 822, + 1333, + 1223, + 456, + 201, + 712, + 968, + 1369, + 602, + 347, + 91, + 858, + 1114, + 1004, + 237, + 493, + 749, + 1260, + 1150, + 639, + ): list([ + 63, + ]), + tuple( + 128, + 384, + 640, + 1041, + 274, + 19, + 530, + 786, + 1297, + 1151, + 1187, + 420, + 165, + 676, + 932, + 1407, + 1443, + 822, + 567, + 55, + 311, + 1078, + 1334, + 968, + 201, + 457, + 713, + 1224, + 1114, + 603, + 347, + 92, + 859, + 1370, + 1260, + 493, + 238, + 749, + 1005, + 895, + ): list([ + 69, + ]), + tuple( + 128, + 384, + 640, + 1041, + 274, + 19, + 530, + 786, + 1297, + 1151, + 1443, + 676, + 165, + 421, + 932, + 1188, + 1407, + 822, + 567, + 55, + 311, + 1078, + 1334, + 968, + 201, + 457, + 713, + 1224, + 1114, + 603, + 347, + 92, + 859, + 1370, + 749, + 238, + 494, + 1005, + 1261, + 895, + ): list([ + 70, + ]), + tuple( + 128, + 384, + 640, + 1297, + 530, + 19, + 275, + 786, + 1042, + 1151, + 1443, + 676, + 165, + 421, + 932, + 1188, + 1407, + 822, + 567, + 55, + 311, + 1078, + 1334, + 968, + 201, + 457, + 713, + 1224, + 1370, + 603, + 348, + 92, + 859, + 1115, + 749, + 238, + 494, + 1005, + 1261, + 895, + ): list([ + 71, + ]), + tuple( + 128, + 384, + 785, + 18, + 274, + 530, + 1041, + 1297, + 895, + 1151, + 931, + 164, + 420, + 676, + 1187, + 1443, + 1333, + 566, + 55, + 311, + 822, + 1078, + 712, + 201, + 457, + 968, + 1224, + 858, + 347, + 603, + 91, + 1114, + 1370, + 1260, + 237, + 493, + 749, + 1005, + 1406, + 639, + ): list([ + 66, + ]), + tuple( + 128, + 384, + 785, + 18, + 274, + 530, + 1041, + 1297, + 895, + 1151, + 1187, + 420, + 165, + 676, + 932, + 1443, + 1333, + 566, + 55, + 311, + 822, + 1078, + 712, + 201, + 457, + 968, + 1224, + 1114, + 347, + 603, + 91, + 859, + 1370, + 1260, + 493, + 238, + 749, + 1005, + 1406, + 639, + ): list([ + 67, + ]), + tuple( + 128, + 384, + 1041, + 274, + 19, + 530, + 786, + 1297, + 895, + 1151, + 1187, + 420, + 165, + 676, + 932, + 1443, + 1333, + 566, + 55, + 311, + 822, + 1078, + 968, + 201, + 457, + 713, + 1224, + 1114, + 603, + 347, + 92, + 859, + 1370, + 1260, + 493, + 238, + 749, + 1005, + 1406, + 639, + ): list([ + 68, + ]), + tuple( + 255, + 912, + 145, + 401, + 657, + 1168, + 1424, + 1022, + 1278, + 1058, + 291, + 36, + 547, + 803, + 1314, + 693, + 182, + 438, + 949, + 1205, + 839, + 72, + 328, + 584, + 1095, + 1351, + 985, + 474, + 218, + 730, + 1241, + 1131, + 364, + 109, + 620, + 876, + 1387, + 766, + 511, + ): list([ + 240, + ]), + tuple( + 256, + 1, + 512, + 768, + 1024, + 1425, + 658, + 147, + 403, + 914, + 1170, + 804, + 37, + 293, + 549, + 1060, + 1316, + 950, + 439, + 183, + 695, + 1206, + 1352, + 585, + 74, + 330, + 841, + 1097, + 731, + 476, + 220, + 987, + 1243, + 877, + 110, + 366, + 622, + 1133, + 1389, + 1279, + ): list([ + 256, + ]), + tuple( + 256, + 1, + 512, + 768, + 1169, + 402, + 147, + 658, + 914, + 1425, + 1279, + 548, + 37, + 293, + 804, + 1060, + 1315, + 694, + 439, + 183, + 950, + 1206, + 1096, + 329, + 74, + 585, + 841, + 1352, + 1242, + 475, + 220, + 731, + 987, + 1388, + 621, + 110, + 366, + 877, + 1133, + 1023, + ): list([ + 253, + ]), + tuple( + 256, + 1, + 512, + 768, + 1169, + 402, + 147, + 658, + 914, + 1425, + 1279, + 548, + 37, + 293, + 804, + 1060, + 1316, + 950, + 439, + 183, + 695, + 1206, + 1096, + 329, + 74, + 585, + 841, + 1352, + 1242, + 475, + 220, + 731, + 987, + 877, + 110, + 366, + 622, + 1133, + 1389, + 1023, + ): list([ + 254, + ]), + tuple( + 256, + 1, + 512, + 768, + 1425, + 402, + 147, + 658, + 914, + 1170, + 1279, + 804, + 37, + 293, + 549, + 1060, + 1316, + 950, + 439, + 183, + 695, + 1206, + 1096, + 329, + 74, + 585, + 841, + 1352, + 731, + 476, + 220, + 987, + 1243, + 877, + 110, + 366, + 622, + 1133, + 1389, + 1023, + ): list([ + 255, + ]), + tuple( + 382, + 528, + 17, + 273, + 784, + 894, + 1040, + 1296, + 1405, + 930, + 163, + 419, + 675, + 1186, + 1442, + 1076, + 309, + 54, + 565, + 821, + 1332, + 1222, + 455, + 200, + 711, + 967, + 857, + 346, + 602, + 90, + 1113, + 1369, + 1003, + 236, + 492, + 748, + 1259, + 1149, + 638, + 127, + ): list([ + 54, + ]), + tuple( + 382, + 784, + 17, + 273, + 529, + 894, + 1040, + 1296, + 1150, + 930, + 163, + 419, + 675, + 1186, + 1442, + 1076, + 309, + 54, + 565, + 821, + 1332, + 711, + 200, + 456, + 967, + 1223, + 857, + 346, + 602, + 90, + 1113, + 1369, + 1003, + 236, + 492, + 748, + 1259, + 1405, + 638, + 127, + ): list([ + 55, + ]), + tuple( + 382, + 1295, + 528, + 17, + 273, + 784, + 894, + 1040, + 1405, + 674, + 163, + 419, + 930, + 1186, + 1442, + 1076, + 309, + 54, + 565, + 821, + 1332, + 1222, + 455, + 200, + 711, + 967, + 1368, + 601, + 346, + 90, + 857, + 1113, + 1003, + 236, + 492, + 748, + 1259, + 1149, + 638, + 127, + ): list([ + 53, + ]), + tuple( + 382, + 1295, + 528, + 17, + 273, + 784, + 894, + 1040, + 1405, + 1441, + 674, + 163, + 419, + 930, + 1186, + 820, + 53, + 309, + 565, + 1076, + 1332, + 1222, + 455, + 200, + 711, + 967, + 1368, + 601, + 346, + 90, + 857, + 1113, + 747, + 236, + 492, + 1003, + 1259, + 1149, + 638, + 127, + ): list([ + 52, + ]), + tuple( + 384, + 129, + 640, + 896, + 530, + 19, + 275, + 786, + 1042, + 1298, + 932, + 165, + 421, + 677, + 1188, + 1407, + 1444, + 1078, + 567, + 311, + 56, + 823, + 1334, + 1224, + 457, + 202, + 713, + 969, + 859, + 348, + 92, + 604, + 1115, + 1371, + 1005, + 238, + 494, + 750, + 1261, + 1151, + ): list([ + 74, + ]), + tuple( + 384, + 129, + 640, + 896, + 1152, + 786, + 19, + 275, + 531, + 1042, + 1298, + 932, + 165, + 421, + 677, + 1188, + 1444, + 1078, + 567, + 311, + 56, + 823, + 1334, + 713, + 202, + 458, + 969, + 1225, + 859, + 348, + 92, + 604, + 1115, + 1371, + 1005, + 238, + 494, + 750, + 1261, + 1407, + ): list([ + 75, + ]), + tuple( + 384, + 129, + 640, + 896, + 1297, + 530, + 19, + 275, + 786, + 1042, + 676, + 165, + 421, + 932, + 1188, + 1407, + 1444, + 1078, + 567, + 311, + 56, + 823, + 1334, + 1224, + 457, + 202, + 713, + 969, + 1370, + 603, + 348, + 92, + 859, + 1115, + 1005, + 238, + 494, + 750, + 1261, + 1151, + ): list([ + 73, + ]), + tuple( + 384, + 129, + 640, + 896, + 1297, + 530, + 19, + 275, + 786, + 1042, + 1443, + 676, + 165, + 421, + 932, + 1188, + 1407, + 822, + 567, + 55, + 311, + 1078, + 1334, + 1224, + 457, + 202, + 713, + 969, + 1370, + 603, + 348, + 92, + 859, + 1115, + 749, + 238, + 494, + 1005, + 1261, + 1151, + ): list([ + 72, + ]), + tuple( + 512, + 1, + 257, + 768, + 1024, + 914, + 147, + 403, + 659, + 1170, + 1426, + 1060, + 293, + 38, + 549, + 805, + 1316, + 1206, + 439, + 184, + 695, + 951, + 841, + 74, + 330, + 586, + 1097, + 1353, + 987, + 476, + 220, + 732, + 1243, + 1133, + 366, + 111, + 622, + 878, + 1389, + 1279, + ): list([ + 259, + ]), + tuple( + 512, + 1, + 257, + 768, + 1024, + 1425, + 658, + 147, + 403, + 914, + 1170, + 804, + 37, + 293, + 549, + 1060, + 1316, + 1206, + 439, + 184, + 695, + 951, + 1352, + 585, + 74, + 330, + 841, + 1097, + 731, + 476, + 220, + 987, + 1243, + 1133, + 110, + 366, + 622, + 878, + 1389, + 1279, + ): list([ + 257, + ]), + tuple( + 512, + 1, + 257, + 768, + 1024, + 1425, + 658, + 147, + 403, + 914, + 1170, + 1060, + 293, + 38, + 549, + 805, + 1316, + 1206, + 439, + 184, + 695, + 951, + 1352, + 585, + 74, + 330, + 841, + 1097, + 987, + 476, + 220, + 732, + 1243, + 1133, + 366, + 111, + 622, + 878, + 1389, + 1279, + ): list([ + 258, + ]), + tuple( + 638, + 1039, + 272, + 17, + 528, + 784, + 1295, + 1149, + 1405, + 1185, + 418, + 163, + 674, + 930, + 1441, + 820, + 53, + 309, + 565, + 1076, + 1332, + 966, + 199, + 455, + 711, + 1222, + 1112, + 601, + 345, + 90, + 857, + 1368, + 1258, + 491, + 236, + 747, + 1003, + 126, + 893, + 382, + ): list([ + 49, + ]), + tuple( + 638, + 1039, + 272, + 17, + 528, + 784, + 1295, + 1149, + 1405, + 1441, + 674, + 163, + 419, + 930, + 1186, + 820, + 53, + 309, + 565, + 1076, + 1332, + 966, + 199, + 455, + 711, + 1222, + 1112, + 601, + 345, + 90, + 857, + 1368, + 747, + 236, + 492, + 1003, + 1259, + 126, + 893, + 382, + ): list([ + 50, + ]), + tuple( + 638, + 1295, + 528, + 17, + 273, + 784, + 1040, + 1149, + 1405, + 1441, + 674, + 163, + 419, + 930, + 1186, + 820, + 53, + 309, + 565, + 1076, + 1332, + 966, + 199, + 455, + 711, + 1222, + 1368, + 601, + 346, + 90, + 857, + 1113, + 747, + 236, + 492, + 1003, + 1259, + 126, + 893, + 382, + ): list([ + 51, + ]), + tuple( + 639, + 1040, + 273, + 18, + 529, + 785, + 1296, + 1150, + 1186, + 419, + 164, + 675, + 931, + 1406, + 1442, + 821, + 54, + 310, + 566, + 1077, + 1333, + 967, + 200, + 456, + 712, + 1223, + 1113, + 602, + 346, + 91, + 858, + 1369, + 1259, + 492, + 237, + 748, + 1004, + 127, + 894, + 383, + ): list([ + 59, + ]), + tuple( + 639, + 1040, + 273, + 18, + 529, + 785, + 1296, + 1150, + 1406, + 675, + 164, + 420, + 931, + 1187, + 1442, + 821, + 54, + 310, + 566, + 1077, + 1333, + 967, + 200, + 456, + 712, + 1223, + 1113, + 602, + 346, + 91, + 858, + 1369, + 748, + 237, + 493, + 1004, + 1260, + 127, + 894, + 383, + ): list([ + 60, + ]), + tuple( + 639, + 1296, + 529, + 18, + 274, + 785, + 1041, + 1150, + 1406, + 675, + 164, + 420, + 931, + 1187, + 1442, + 821, + 54, + 310, + 566, + 1077, + 1333, + 967, + 200, + 456, + 712, + 1223, + 1369, + 602, + 347, + 91, + 858, + 1114, + 748, + 237, + 493, + 1004, + 1260, + 127, + 894, + 383, + ): list([ + 61, + ]), + tuple( + 640, + 129, + 385, + 896, + 1152, + 786, + 19, + 275, + 531, + 1042, + 1298, + 932, + 165, + 421, + 677, + 1188, + 1444, + 1334, + 567, + 312, + 56, + 823, + 1079, + 713, + 202, + 458, + 969, + 1225, + 859, + 348, + 92, + 604, + 1115, + 1371, + 1261, + 238, + 494, + 750, + 1006, + 1407, + ): list([ + 76, + ]), + tuple( + 640, + 129, + 385, + 896, + 1152, + 786, + 19, + 275, + 531, + 1042, + 1298, + 1188, + 421, + 166, + 677, + 933, + 1444, + 1334, + 567, + 312, + 56, + 823, + 1079, + 713, + 202, + 458, + 969, + 1225, + 1115, + 348, + 92, + 604, + 860, + 1371, + 1261, + 494, + 239, + 750, + 1006, + 1407, + ): list([ + 77, + ]), + tuple( + 640, + 129, + 385, + 896, + 1152, + 1042, + 275, + 20, + 531, + 787, + 1298, + 1188, + 421, + 166, + 677, + 933, + 1444, + 1334, + 567, + 312, + 56, + 823, + 1079, + 969, + 202, + 458, + 714, + 1225, + 1115, + 348, + 93, + 604, + 860, + 1371, + 1261, + 494, + 239, + 750, + 1006, + 1407, + ): list([ + 78, + ]), + tuple( + 764, + 1019, + 909, + 142, + 398, + 654, + 1165, + 1275, + 1421, + 143, + 910, + 1166, + 1311, + 544, + 33, + 289, + 800, + 1056, + 1312, + 545, + 690, + 179, + 435, + 946, + 1202, + 691, + 836, + 69, + 325, + 581, + 1092, + 1348, + 70, + 837, + 982, + 471, + 215, + 727, + 1238, + 216, + 983, + 472, + 1239, + 1384, + 617, + 106, + 362, + 873, + 1129, + 618, + 1385, + 252, + 763, + 508, + ): list([ + 211, + 212, + 213, + 214, + 215, + ]), + tuple( + 764, + 1020, + 910, + 143, + 399, + 655, + 1166, + 1422, + 1056, + 289, + 34, + 545, + 801, + 1312, + 1202, + 435, + 180, + 691, + 947, + 837, + 70, + 326, + 582, + 1093, + 1349, + 983, + 472, + 216, + 728, + 1239, + 1129, + 362, + 107, + 618, + 874, + 1385, + 1275, + 508, + 253, + ): list([ + 219, + ]), + tuple( + 764, + 1020, + 1421, + 654, + 143, + 399, + 910, + 1166, + 800, + 33, + 289, + 545, + 1056, + 1312, + 946, + 179, + 435, + 691, + 1202, + 1348, + 581, + 70, + 326, + 837, + 1093, + 727, + 472, + 216, + 983, + 1239, + 873, + 106, + 362, + 618, + 1129, + 1385, + 252, + 1275, + 508, + ): list([ + 216, + ]), + tuple( + 764, + 1020, + 1421, + 654, + 143, + 399, + 910, + 1166, + 800, + 33, + 289, + 545, + 1056, + 1312, + 1202, + 435, + 180, + 691, + 947, + 1348, + 581, + 70, + 326, + 837, + 1093, + 727, + 472, + 216, + 983, + 1239, + 1129, + 106, + 362, + 618, + 874, + 1385, + 1275, + 508, + 253, + ): list([ + 217, + ]), + tuple( + 764, + 1020, + 1421, + 654, + 143, + 399, + 910, + 1166, + 1056, + 289, + 34, + 545, + 801, + 1312, + 1202, + 435, + 180, + 691, + 947, + 1348, + 581, + 70, + 326, + 837, + 1093, + 983, + 472, + 216, + 728, + 1239, + 1129, + 362, + 107, + 618, + 874, + 1385, + 1275, + 508, + 253, + ): list([ + 218, + ]), + tuple( + 765, + 911, + 144, + 400, + 656, + 1021, + 1167, + 1423, + 1057, + 290, + 35, + 546, + 802, + 1313, + 1203, + 436, + 181, + 692, + 948, + 838, + 71, + 327, + 583, + 1094, + 1350, + 984, + 473, + 217, + 729, + 1240, + 1130, + 363, + 108, + 619, + 875, + 1386, + 1276, + 509, + 254, + ): list([ + 229, + ]), + tuple( + 765, + 1020, + 910, + 143, + 399, + 655, + 1166, + 1422, + 1276, + 144, + 911, + 1167, + 1312, + 545, + 34, + 290, + 801, + 1057, + 1313, + 546, + 691, + 180, + 436, + 947, + 1203, + 692, + 837, + 70, + 326, + 582, + 1093, + 1349, + 71, + 838, + 983, + 472, + 216, + 728, + 1239, + 217, + 984, + 473, + 1240, + 1385, + 618, + 107, + 363, + 874, + 1130, + 619, + 1386, + 253, + 764, + 509, + ): list([ + 221, + 222, + 223, + 224, + 225, + ]), + tuple( + 765, + 1422, + 655, + 144, + 400, + 911, + 1021, + 1167, + 801, + 34, + 290, + 546, + 1057, + 1313, + 947, + 180, + 436, + 692, + 1203, + 1349, + 582, + 71, + 327, + 838, + 1094, + 728, + 473, + 217, + 984, + 1240, + 874, + 107, + 363, + 619, + 1130, + 1386, + 253, + 1276, + 509, + ): list([ + 226, + ]), + tuple( + 765, + 1422, + 655, + 144, + 400, + 911, + 1021, + 1167, + 801, + 34, + 290, + 546, + 1057, + 1313, + 1203, + 436, + 181, + 692, + 948, + 1349, + 582, + 71, + 327, + 838, + 1094, + 728, + 473, + 217, + 984, + 1240, + 1130, + 107, + 363, + 619, + 875, + 1386, + 1276, + 509, + 254, + ): list([ + 227, + ]), + tuple( + 765, + 1422, + 655, + 144, + 400, + 911, + 1021, + 1167, + 1057, + 290, + 35, + 546, + 802, + 1313, + 1203, + 436, + 181, + 692, + 948, + 1349, + 582, + 71, + 327, + 838, + 1094, + 984, + 473, + 217, + 729, + 1240, + 1130, + 363, + 108, + 619, + 875, + 1386, + 1276, + 509, + 254, + ): list([ + 228, + ]), + tuple( + 766, + 911, + 144, + 400, + 656, + 1021, + 1167, + 1423, + 145, + 912, + 1168, + 1277, + 1313, + 546, + 35, + 291, + 802, + 1058, + 1314, + 547, + 692, + 181, + 437, + 948, + 1204, + 693, + 838, + 71, + 327, + 583, + 1094, + 1350, + 72, + 839, + 984, + 473, + 217, + 729, + 1240, + 218, + 985, + 474, + 1241, + 1386, + 619, + 108, + 364, + 875, + 1131, + 620, + 1387, + 254, + 765, + 510, + ): list([ + 231, + 232, + 233, + 234, + 235, + ]), + tuple( + 766, + 912, + 145, + 401, + 657, + 1168, + 1424, + 1022, + 1058, + 291, + 36, + 547, + 803, + 1314, + 1204, + 437, + 182, + 693, + 949, + 839, + 72, + 328, + 584, + 1095, + 1351, + 985, + 474, + 218, + 730, + 1241, + 1131, + 364, + 109, + 620, + 876, + 1387, + 1277, + 510, + 255, + ): list([ + 239, + ]), + tuple( + 766, + 1423, + 656, + 145, + 401, + 912, + 1168, + 1022, + 802, + 35, + 291, + 547, + 1058, + 1314, + 948, + 181, + 437, + 693, + 1204, + 1350, + 583, + 72, + 328, + 839, + 1095, + 729, + 474, + 218, + 985, + 1241, + 875, + 108, + 364, + 620, + 1131, + 1387, + 254, + 1277, + 510, + ): list([ + 236, + ]), + tuple( + 766, + 1423, + 656, + 145, + 401, + 912, + 1168, + 1022, + 802, + 35, + 291, + 547, + 1058, + 1314, + 1204, + 437, + 182, + 693, + 949, + 1350, + 583, + 72, + 328, + 839, + 1095, + 729, + 474, + 218, + 985, + 1241, + 1131, + 108, + 364, + 620, + 876, + 1387, + 1277, + 510, + 255, + ): list([ + 237, + ]), + tuple( + 766, + 1423, + 656, + 145, + 401, + 912, + 1168, + 1022, + 1058, + 291, + 36, + 547, + 803, + 1314, + 1204, + 437, + 182, + 693, + 949, + 1350, + 583, + 72, + 328, + 839, + 1095, + 985, + 474, + 218, + 730, + 1241, + 1131, + 364, + 109, + 620, + 876, + 1387, + 1277, + 510, + 255, + ): list([ + 238, + ]), + tuple( + 768, + 1, + 257, + 513, + 1024, + 1280, + 914, + 147, + 403, + 659, + 1170, + 1426, + 1060, + 293, + 38, + 549, + 805, + 1316, + 695, + 440, + 184, + 951, + 1207, + 841, + 74, + 330, + 586, + 1097, + 1353, + 987, + 476, + 220, + 732, + 1243, + 1133, + 366, + 111, + 622, + 878, + 1389, + ): list([ + 260, + ]), + tuple( + 768, + 1, + 257, + 513, + 1024, + 1280, + 914, + 147, + 403, + 659, + 1170, + 1426, + 1316, + 549, + 38, + 294, + 805, + 1061, + 695, + 440, + 184, + 951, + 1207, + 841, + 74, + 330, + 586, + 1097, + 1353, + 987, + 476, + 220, + 732, + 1243, + 1389, + 622, + 111, + 367, + 878, + 1134, + ): list([ + 261, + ]), + tuple( + 768, + 1, + 257, + 513, + 1024, + 1280, + 1170, + 403, + 148, + 659, + 915, + 1426, + 1316, + 549, + 38, + 294, + 805, + 1061, + 695, + 440, + 184, + 951, + 1207, + 841, + 74, + 330, + 586, + 1097, + 1353, + 1243, + 476, + 221, + 732, + 988, + 1389, + 622, + 111, + 367, + 878, + 1134, + ): list([ + 262, + ]), + tuple( + 769, + 2, + 258, + 514, + 1025, + 1281, + 915, + 148, + 404, + 660, + 1171, + 1427, + 1061, + 294, + 39, + 550, + 806, + 1317, + 696, + 441, + 185, + 952, + 1208, + 842, + 75, + 331, + 587, + 1098, + 1354, + 988, + 477, + 221, + 733, + 1244, + 1134, + 367, + 112, + 623, + 879, + 1390, + ): list([ + 270, + ]), + tuple( + 769, + 2, + 258, + 514, + 1025, + 1281, + 915, + 148, + 404, + 660, + 1171, + 1427, + 1317, + 550, + 39, + 295, + 806, + 1062, + 696, + 441, + 185, + 952, + 1208, + 842, + 75, + 331, + 587, + 1098, + 1354, + 988, + 477, + 221, + 733, + 1244, + 1390, + 623, + 112, + 368, + 879, + 1135, + ): list([ + 271, + ]), + tuple( + 769, + 2, + 258, + 514, + 1025, + 1281, + 1171, + 404, + 149, + 660, + 916, + 1427, + 1317, + 550, + 39, + 295, + 806, + 1062, + 696, + 441, + 185, + 952, + 1208, + 842, + 75, + 331, + 587, + 1098, + 1354, + 1244, + 477, + 222, + 733, + 989, + 1390, + 623, + 112, + 368, + 879, + 1135, + ): list([ + 272, + ]), + tuple( + 770, + 3, + 259, + 515, + 1026, + 1282, + 916, + 149, + 405, + 661, + 1172, + 1428, + 1062, + 295, + 40, + 551, + 807, + 1318, + 697, + 442, + 186, + 953, + 1209, + 843, + 76, + 332, + 588, + 1099, + 1355, + 989, + 478, + 222, + 734, + 1245, + 1135, + 368, + 113, + 624, + 880, + 1391, + ): list([ + 280, + ]), + tuple( + 770, + 3, + 259, + 515, + 1026, + 1282, + 916, + 149, + 405, + 661, + 1172, + 1428, + 1318, + 551, + 40, + 296, + 807, + 1063, + 697, + 442, + 186, + 953, + 1209, + 843, + 76, + 332, + 588, + 1099, + 1355, + 989, + 478, + 222, + 734, + 1245, + 1391, + 624, + 113, + 369, + 880, + 1136, + ): list([ + 281, + ]), + tuple( + 770, + 3, + 259, + 515, + 1026, + 1282, + 1172, + 405, + 150, + 661, + 917, + 1428, + 1318, + 551, + 40, + 296, + 807, + 1063, + 697, + 442, + 186, + 953, + 1209, + 843, + 76, + 332, + 588, + 1099, + 1355, + 1245, + 478, + 223, + 734, + 990, + 1391, + 624, + 113, + 369, + 880, + 1136, + ): list([ + 282, + ]), + tuple( + 771, + 4, + 260, + 516, + 1027, + 1283, + 917, + 150, + 406, + 662, + 1173, + 1429, + 1063, + 296, + 41, + 552, + 808, + 1319, + 698, + 443, + 187, + 954, + 1210, + 844, + 77, + 333, + 589, + 1100, + 1356, + 990, + 479, + 223, + 735, + 1246, + 1136, + 369, + 114, + 625, + 881, + 1392, + ): list([ + 290, + ]), + tuple( + 771, + 4, + 260, + 516, + 1027, + 1283, + 917, + 150, + 406, + 662, + 1173, + 1429, + 1319, + 552, + 41, + 297, + 808, + 1064, + 698, + 443, + 187, + 954, + 1210, + 844, + 77, + 333, + 589, + 1100, + 1356, + 990, + 479, + 223, + 735, + 1246, + 1392, + 625, + 114, + 370, + 881, + 1137, + ): list([ + 291, + ]), + tuple( + 771, + 4, + 260, + 516, + 1027, + 1283, + 1173, + 406, + 151, + 662, + 918, + 1429, + 1319, + 552, + 41, + 297, + 808, + 1064, + 698, + 443, + 187, + 954, + 1210, + 844, + 77, + 333, + 589, + 1100, + 1356, + 1246, + 479, + 224, + 735, + 991, + 1392, + 625, + 114, + 370, + 881, + 1137, + ): list([ + 292, + ]), + tuple( + 772, + 5, + 261, + 517, + 1028, + 1284, + 918, + 407, + 663, + 151, + 1174, + 1430, + 1064, + 297, + 42, + 553, + 809, + 1320, + 699, + 444, + 188, + 955, + 1211, + 845, + 78, + 334, + 590, + 1101, + 1357, + 991, + 224, + 480, + 736, + 1247, + 1137, + 370, + 115, + 626, + 882, + 1393, + ): list([ + 300, + ]), + tuple( + 772, + 5, + 261, + 517, + 1028, + 1284, + 918, + 407, + 663, + 151, + 1174, + 1430, + 1320, + 553, + 42, + 298, + 809, + 1065, + 699, + 444, + 188, + 955, + 1211, + 845, + 78, + 334, + 590, + 1101, + 1357, + 991, + 224, + 480, + 736, + 1247, + 1393, + 626, + 115, + 371, + 882, + 1138, + ): list([ + 301, + ]), + tuple( + 772, + 5, + 261, + 517, + 1028, + 1284, + 1174, + 663, + 407, + 152, + 919, + 1430, + 1320, + 553, + 42, + 298, + 809, + 1065, + 699, + 444, + 188, + 955, + 1211, + 845, + 78, + 334, + 590, + 1101, + 1357, + 1247, + 480, + 225, + 736, + 992, + 1393, + 626, + 115, + 371, + 882, + 1138, + ): list([ + 302, + ]), + tuple( + 773, + 6, + 262, + 518, + 1029, + 1285, + 919, + 408, + 664, + 152, + 1175, + 1431, + 1065, + 298, + 43, + 554, + 810, + 1321, + 700, + 189, + 445, + 956, + 1212, + 846, + 79, + 335, + 591, + 1102, + 1358, + 992, + 225, + 481, + 737, + 1248, + 1138, + 371, + 116, + 627, + 883, + 1394, + ): list([ + 310, + ]), + tuple( + 773, + 6, + 262, + 518, + 1029, + 1285, + 919, + 408, + 664, + 152, + 1175, + 1431, + 1321, + 554, + 43, + 299, + 810, + 1066, + 700, + 189, + 445, + 956, + 1212, + 846, + 79, + 335, + 591, + 1102, + 1358, + 992, + 225, + 481, + 737, + 1248, + 1394, + 627, + 116, + 372, + 883, + 1139, + ): list([ + 311, + ]), + tuple( + 773, + 6, + 262, + 518, + 1029, + 1285, + 1175, + 664, + 408, + 153, + 920, + 1431, + 1321, + 554, + 43, + 299, + 810, + 1066, + 700, + 189, + 445, + 956, + 1212, + 846, + 79, + 335, + 591, + 1102, + 1358, + 1248, + 481, + 226, + 737, + 993, + 1394, + 627, + 116, + 372, + 883, + 1139, + ): list([ + 312, + ]), + tuple( + 774, + 7, + 263, + 519, + 1030, + 1286, + 920, + 409, + 665, + 153, + 1176, + 1432, + 1066, + 299, + 44, + 555, + 811, + 1322, + 701, + 446, + 190, + 957, + 1213, + 847, + 80, + 336, + 592, + 1103, + 1359, + 993, + 226, + 482, + 738, + 1249, + 1139, + 372, + 117, + 628, + 884, + 1395, + ): list([ + 320, + ]), + tuple( + 774, + 7, + 263, + 519, + 1030, + 1286, + 920, + 409, + 665, + 153, + 1176, + 1432, + 1322, + 555, + 44, + 300, + 811, + 1067, + 701, + 446, + 190, + 957, + 1213, + 847, + 80, + 336, + 592, + 1103, + 1359, + 993, + 226, + 482, + 738, + 1249, + 1395, + 628, + 117, + 373, + 884, + 1140, + ): list([ + 321, + ]), + tuple( + 774, + 7, + 263, + 519, + 1030, + 1286, + 1176, + 665, + 409, + 154, + 921, + 1432, + 1322, + 555, + 44, + 300, + 811, + 1067, + 701, + 446, + 190, + 957, + 1213, + 847, + 80, + 336, + 592, + 1103, + 1359, + 1249, + 482, + 227, + 738, + 994, + 1395, + 628, + 117, + 373, + 884, + 1140, + ): list([ + 322, + ]), + tuple( + 775, + 8, + 264, + 520, + 1031, + 1287, + 921, + 410, + 666, + 154, + 1177, + 1433, + 1067, + 300, + 45, + 556, + 812, + 1323, + 702, + 447, + 191, + 958, + 1214, + 848, + 81, + 337, + 593, + 1104, + 1360, + 994, + 227, + 483, + 739, + 1250, + 1140, + 373, + 118, + 629, + 885, + 1396, + ): list([ + 330, + ]), + tuple( + 775, + 8, + 264, + 520, + 1031, + 1287, + 921, + 410, + 666, + 154, + 1177, + 1433, + 1323, + 556, + 45, + 301, + 812, + 1068, + 702, + 447, + 191, + 958, + 1214, + 848, + 81, + 337, + 593, + 1104, + 1360, + 994, + 227, + 483, + 739, + 1250, + 1396, + 629, + 118, + 374, + 885, + 1141, + ): list([ + 331, + ]), + tuple( + 775, + 8, + 264, + 520, + 1031, + 1287, + 1177, + 666, + 410, + 155, + 922, + 1433, + 1323, + 556, + 45, + 301, + 812, + 1068, + 702, + 447, + 191, + 958, + 1214, + 848, + 81, + 337, + 593, + 1104, + 1360, + 1250, + 483, + 228, + 739, + 995, + 1396, + 629, + 118, + 374, + 885, + 1141, + ): list([ + 332, + ]), + tuple( + 776, + 9, + 265, + 521, + 1032, + 1288, + 922, + 411, + 155, + 667, + 1178, + 1434, + 1068, + 301, + 46, + 557, + 813, + 1324, + 703, + 192, + 448, + 959, + 1215, + 849, + 82, + 338, + 594, + 1105, + 1361, + 995, + 228, + 484, + 740, + 1251, + 1141, + 374, + 119, + 630, + 886, + 1397, + ): list([ + 340, + ]), + tuple( + 776, + 9, + 265, + 521, + 1032, + 1288, + 922, + 411, + 155, + 667, + 1178, + 1434, + 1324, + 557, + 46, + 302, + 813, + 1069, + 703, + 192, + 448, + 959, + 1215, + 849, + 82, + 338, + 594, + 1105, + 1361, + 375, + 995, + 228, + 484, + 740, + 1251, + 1397, + 630, + 119, + 886, + 1142, + ): list([ + 341, + ]), + tuple( + 776, + 9, + 265, + 521, + 1032, + 1288, + 1178, + 667, + 411, + 156, + 923, + 1434, + 1324, + 557, + 46, + 302, + 813, + 1069, + 703, + 192, + 448, + 959, + 1215, + 849, + 82, + 338, + 594, + 1105, + 1361, + 375, + 1251, + 484, + 229, + 740, + 996, + 1397, + 630, + 119, + 886, + 1142, + ): list([ + 342, + ]), + tuple( + 777, + 10, + 266, + 522, + 1033, + 1289, + 923, + 668, + 412, + 156, + 1179, + 1435, + 1069, + 302, + 47, + 558, + 814, + 1325, + 704, + 193, + 449, + 960, + 1216, + 850, + 83, + 339, + 595, + 1106, + 1362, + 375, + 996, + 229, + 485, + 741, + 1252, + 887, + 1142, + 631, + 120, + 1398, + ): list([ + 350, + ]), + tuple( + 777, + 10, + 266, + 522, + 1033, + 1289, + 923, + 668, + 412, + 156, + 1179, + 1435, + 1325, + 558, + 47, + 303, + 814, + 1070, + 704, + 193, + 449, + 960, + 1216, + 850, + 83, + 339, + 595, + 1106, + 1143, + 1362, + 120, + 996, + 229, + 485, + 741, + 1252, + 887, + 1398, + 631, + 376, + ): list([ + 351, + ]), + tuple( + 777, + 10, + 266, + 522, + 1033, + 1289, + 1179, + 668, + 412, + 157, + 924, + 1435, + 1325, + 558, + 47, + 303, + 814, + 1070, + 704, + 193, + 449, + 960, + 1216, + 850, + 83, + 339, + 595, + 1106, + 1143, + 1362, + 120, + 1252, + 485, + 230, + 741, + 997, + 887, + 1398, + 631, + 376, + ): list([ + 352, + ]), + tuple( + 778, + 11, + 267, + 523, + 1034, + 1290, + 924, + 669, + 157, + 413, + 1180, + 1436, + 1070, + 303, + 48, + 559, + 815, + 1326, + 705, + 194, + 450, + 961, + 1217, + 851, + 84, + 340, + 596, + 1107, + 1363, + 376, + 997, + 230, + 486, + 742, + 1253, + 888, + 1143, + 632, + 121, + 1399, + ): list([ + 360, + ]), + tuple( + 778, + 11, + 267, + 523, + 1034, + 1290, + 924, + 669, + 157, + 413, + 1180, + 1436, + 1326, + 559, + 48, + 304, + 815, + 1071, + 705, + 194, + 450, + 961, + 1217, + 851, + 84, + 340, + 596, + 1107, + 1363, + 121, + 997, + 230, + 486, + 742, + 1253, + 888, + 1399, + 632, + 377, + 1144, + ): list([ + 361, + ]), + tuple( + 784, + 17, + 273, + 529, + 894, + 1040, + 1296, + 1150, + 930, + 163, + 419, + 675, + 1186, + 1442, + 1332, + 565, + 54, + 310, + 821, + 1077, + 711, + 200, + 456, + 967, + 1223, + 857, + 346, + 602, + 90, + 1113, + 1369, + 1259, + 236, + 492, + 748, + 1004, + 127, + 1405, + 638, + 383, + ): list([ + 56, + ]), + tuple( + 784, + 17, + 273, + 529, + 894, + 1040, + 1296, + 1150, + 1186, + 419, + 164, + 675, + 931, + 1442, + 1332, + 565, + 54, + 310, + 821, + 1077, + 711, + 200, + 456, + 967, + 1223, + 1113, + 346, + 602, + 90, + 858, + 1369, + 1259, + 492, + 237, + 748, + 1004, + 127, + 1405, + 638, + 383, + ): list([ + 57, + ]), + tuple( + 891, + 525, + 14, + 270, + 781, + 1037, + 1293, + 1402, + 927, + 160, + 416, + 672, + 1183, + 1439, + 1073, + 306, + 51, + 562, + 818, + 1329, + 1219, + 452, + 197, + 708, + 964, + 854, + 599, + 87, + 343, + 1110, + 1366, + 1000, + 233, + 489, + 745, + 1256, + 379, + 1146, + 635, + 124, + ): list([ + 24, + ]), + tuple( + 891, + 1147, + 781, + 14, + 270, + 526, + 1037, + 1293, + 927, + 160, + 416, + 672, + 1183, + 1439, + 1073, + 306, + 51, + 562, + 818, + 1329, + 708, + 197, + 453, + 964, + 1220, + 854, + 599, + 87, + 343, + 1110, + 1366, + 1000, + 233, + 489, + 745, + 1256, + 379, + 1402, + 635, + 124, + ): list([ + 25, + ]), + tuple( + 891, + 1147, + 781, + 14, + 270, + 526, + 1037, + 1293, + 927, + 160, + 416, + 672, + 1183, + 1439, + 1329, + 562, + 51, + 307, + 818, + 1074, + 708, + 197, + 453, + 964, + 1220, + 854, + 599, + 87, + 343, + 1110, + 1366, + 1256, + 233, + 489, + 745, + 1001, + 124, + 1402, + 635, + 380, + ): list([ + 26, + ]), + tuple( + 891, + 1147, + 781, + 14, + 270, + 526, + 1037, + 1293, + 1183, + 416, + 161, + 672, + 928, + 1439, + 1329, + 562, + 51, + 307, + 818, + 1074, + 708, + 197, + 453, + 964, + 1220, + 1110, + 599, + 87, + 343, + 855, + 1366, + 1256, + 489, + 234, + 745, + 1001, + 124, + 1402, + 635, + 380, + ): list([ + 27, + ]), + tuple( + 891, + 1147, + 1037, + 270, + 15, + 526, + 782, + 1293, + 1183, + 416, + 161, + 672, + 928, + 1439, + 1329, + 562, + 51, + 307, + 818, + 1074, + 964, + 197, + 453, + 709, + 1220, + 1110, + 599, + 343, + 88, + 855, + 1366, + 1256, + 489, + 234, + 745, + 1001, + 124, + 1402, + 635, + 380, + ): list([ + 28, + ]), + tuple( + 891, + 1292, + 525, + 14, + 270, + 781, + 1037, + 1402, + 671, + 160, + 416, + 927, + 1183, + 1439, + 1073, + 306, + 51, + 562, + 818, + 1329, + 1219, + 452, + 197, + 708, + 964, + 1365, + 598, + 87, + 343, + 854, + 1110, + 1000, + 233, + 489, + 745, + 1256, + 379, + 1146, + 635, + 124, + ): list([ + 23, + ]), + tuple( + 891, + 1292, + 525, + 14, + 270, + 781, + 1037, + 1402, + 1438, + 671, + 160, + 416, + 927, + 1183, + 817, + 50, + 306, + 562, + 1073, + 1329, + 1219, + 452, + 197, + 708, + 964, + 1365, + 598, + 87, + 343, + 854, + 1110, + 744, + 233, + 489, + 1000, + 1256, + 379, + 1146, + 635, + 124, + ): list([ + 22, + ]), + tuple( + 892, + 526, + 15, + 271, + 782, + 1038, + 1294, + 1403, + 928, + 161, + 417, + 673, + 1184, + 1440, + 1074, + 307, + 52, + 563, + 819, + 1330, + 1220, + 453, + 198, + 709, + 965, + 855, + 344, + 600, + 88, + 1111, + 1367, + 1001, + 234, + 490, + 746, + 1257, + 380, + 1147, + 636, + 125, + ): list([ + 34, + ]), + tuple( + 892, + 782, + 15, + 271, + 527, + 1038, + 1148, + 1294, + 928, + 161, + 417, + 673, + 1184, + 1440, + 1074, + 307, + 52, + 563, + 819, + 1330, + 709, + 198, + 454, + 965, + 1221, + 855, + 344, + 600, + 88, + 1111, + 1367, + 1001, + 234, + 490, + 746, + 1257, + 380, + 1403, + 636, + 125, + ): list([ + 35, + ]), + tuple( + 892, + 782, + 15, + 271, + 527, + 1038, + 1148, + 1294, + 928, + 161, + 417, + 673, + 1184, + 1440, + 1330, + 563, + 52, + 308, + 819, + 1075, + 709, + 198, + 454, + 965, + 1221, + 855, + 344, + 600, + 88, + 1111, + 1367, + 1257, + 234, + 490, + 746, + 1002, + 125, + 1403, + 636, + 381, + ): list([ + 36, + ]), + tuple( + 892, + 782, + 15, + 271, + 527, + 1038, + 1148, + 1294, + 1184, + 417, + 162, + 673, + 929, + 1440, + 1330, + 563, + 52, + 308, + 819, + 1075, + 709, + 198, + 454, + 965, + 1221, + 1111, + 344, + 600, + 88, + 856, + 1367, + 1257, + 490, + 235, + 746, + 1002, + 125, + 1403, + 636, + 381, + ): list([ + 37, + ]), + tuple( + 892, + 1038, + 271, + 16, + 527, + 783, + 1148, + 1294, + 1184, + 417, + 162, + 673, + 929, + 1440, + 1330, + 563, + 52, + 308, + 819, + 1075, + 965, + 198, + 454, + 710, + 1221, + 1111, + 600, + 344, + 89, + 856, + 1367, + 1257, + 490, + 235, + 746, + 1002, + 125, + 1403, + 636, + 381, + ): list([ + 38, + ]), + tuple( + 892, + 1293, + 526, + 15, + 271, + 782, + 1038, + 1403, + 672, + 161, + 417, + 928, + 1184, + 1440, + 1074, + 307, + 52, + 563, + 819, + 1330, + 1220, + 453, + 198, + 709, + 965, + 1366, + 599, + 344, + 88, + 855, + 1111, + 1001, + 234, + 490, + 746, + 1257, + 380, + 1147, + 636, + 125, + ): list([ + 33, + ]), + tuple( + 892, + 1293, + 526, + 15, + 271, + 782, + 1038, + 1403, + 1439, + 672, + 161, + 417, + 928, + 1184, + 818, + 51, + 307, + 563, + 1074, + 1330, + 1220, + 453, + 198, + 709, + 965, + 1366, + 599, + 344, + 88, + 855, + 1111, + 745, + 234, + 490, + 1001, + 1257, + 380, + 1147, + 636, + 125, + ): list([ + 32, + ]), + tuple( + 893, + 527, + 16, + 272, + 783, + 1039, + 1295, + 1404, + 929, + 162, + 418, + 674, + 1185, + 1441, + 1075, + 308, + 53, + 564, + 820, + 1331, + 1221, + 454, + 199, + 710, + 966, + 856, + 345, + 601, + 89, + 1112, + 1368, + 1002, + 235, + 491, + 747, + 1258, + 381, + 1148, + 637, + 126, + ): list([ + 44, + ]), + tuple( + 893, + 783, + 16, + 272, + 528, + 1039, + 1295, + 1149, + 929, + 162, + 418, + 674, + 1185, + 1441, + 1075, + 308, + 53, + 564, + 820, + 1331, + 710, + 199, + 455, + 966, + 1222, + 856, + 345, + 601, + 89, + 1112, + 1368, + 1002, + 235, + 491, + 747, + 1258, + 381, + 1404, + 637, + 126, + ): list([ + 45, + ]), + tuple( + 893, + 783, + 16, + 272, + 528, + 1039, + 1295, + 1149, + 929, + 162, + 418, + 674, + 1185, + 1441, + 1331, + 564, + 53, + 309, + 820, + 1076, + 710, + 199, + 455, + 966, + 1222, + 856, + 345, + 601, + 89, + 1112, + 1368, + 1258, + 235, + 491, + 747, + 1003, + 126, + 1404, + 637, + 382, + ): list([ + 46, + ]), + tuple( + 893, + 783, + 16, + 272, + 528, + 1039, + 1295, + 1149, + 1185, + 418, + 163, + 674, + 930, + 1441, + 1331, + 564, + 53, + 309, + 820, + 1076, + 710, + 199, + 455, + 966, + 1222, + 1112, + 345, + 601, + 89, + 857, + 1368, + 1258, + 491, + 236, + 747, + 1003, + 126, + 1404, + 637, + 382, + ): list([ + 47, + ]), + tuple( + 893, + 1039, + 272, + 17, + 528, + 784, + 1295, + 1149, + 1185, + 418, + 163, + 674, + 930, + 1441, + 1331, + 564, + 53, + 309, + 820, + 1076, + 966, + 199, + 455, + 711, + 1222, + 1112, + 601, + 345, + 90, + 857, + 1368, + 1258, + 491, + 236, + 747, + 1003, + 126, + 1404, + 637, + 382, + ): list([ + 48, + ]), + tuple( + 893, + 1294, + 527, + 16, + 272, + 783, + 1039, + 1404, + 673, + 162, + 418, + 929, + 1185, + 1441, + 1075, + 308, + 53, + 564, + 820, + 1331, + 1221, + 454, + 199, + 710, + 966, + 1367, + 600, + 345, + 89, + 856, + 1112, + 1002, + 235, + 491, + 747, + 1258, + 381, + 1148, + 637, + 126, + ): list([ + 43, + ]), + tuple( + 893, + 1294, + 527, + 16, + 272, + 783, + 1039, + 1404, + 1440, + 673, + 162, + 418, + 929, + 1185, + 819, + 52, + 308, + 564, + 1075, + 1331, + 1221, + 454, + 199, + 710, + 966, + 1367, + 600, + 345, + 89, + 856, + 1112, + 746, + 235, + 491, + 1002, + 1258, + 381, + 1148, + 637, + 126, + ): list([ + 42, + ]), + tuple( + 896, + 129, + 385, + 641, + 1152, + 1408, + 1042, + 275, + 20, + 531, + 787, + 1298, + 1188, + 421, + 166, + 677, + 933, + 1444, + 823, + 312, + 568, + 56, + 1079, + 1335, + 969, + 202, + 458, + 714, + 1225, + 1115, + 348, + 93, + 604, + 860, + 1371, + 1261, + 494, + 239, + 750, + 1006, + ): list([ + 79, + ]), + tuple( + 896, + 129, + 385, + 641, + 1152, + 1408, + 1042, + 275, + 20, + 531, + 787, + 1298, + 1444, + 677, + 166, + 422, + 933, + 1189, + 823, + 312, + 568, + 56, + 1079, + 1335, + 969, + 202, + 458, + 714, + 1225, + 1115, + 348, + 93, + 604, + 860, + 1371, + 750, + 239, + 495, + 1006, + 1262, + ): list([ + 80, + ]), + tuple( + 896, + 129, + 385, + 641, + 1152, + 1408, + 1298, + 531, + 20, + 276, + 787, + 1043, + 1444, + 677, + 166, + 422, + 933, + 1189, + 823, + 312, + 568, + 56, + 1079, + 1335, + 969, + 202, + 458, + 714, + 1225, + 1371, + 604, + 349, + 93, + 860, + 1116, + 750, + 239, + 495, + 1006, + 1262, + ): list([ + 81, + ]), + tuple( + 897, + 130, + 386, + 642, + 1153, + 1409, + 1043, + 276, + 21, + 532, + 788, + 1299, + 1189, + 422, + 167, + 678, + 934, + 1445, + 824, + 313, + 569, + 57, + 1080, + 1336, + 970, + 203, + 459, + 715, + 1226, + 1116, + 605, + 349, + 94, + 861, + 1372, + 1262, + 495, + 240, + 751, + 1007, + ): list([ + 89, + ]), + tuple( + 897, + 130, + 386, + 642, + 1153, + 1409, + 1043, + 276, + 21, + 532, + 788, + 1299, + 1445, + 678, + 167, + 423, + 934, + 1190, + 824, + 313, + 569, + 57, + 1080, + 1336, + 970, + 203, + 459, + 715, + 1226, + 1116, + 605, + 349, + 94, + 861, + 1372, + 751, + 240, + 496, + 1007, + 1263, + ): list([ + 90, + ]), + tuple( + 897, + 130, + 386, + 642, + 1153, + 1409, + 1299, + 532, + 21, + 277, + 788, + 1044, + 1445, + 678, + 167, + 423, + 934, + 1190, + 824, + 313, + 569, + 57, + 1080, + 1336, + 970, + 203, + 459, + 715, + 1226, + 1372, + 605, + 350, + 94, + 861, + 1117, + 751, + 240, + 496, + 1007, + 1263, + ): list([ + 91, + ]), + tuple( + 898, + 131, + 387, + 643, + 1154, + 1410, + 1044, + 277, + 22, + 533, + 789, + 1300, + 1190, + 423, + 168, + 679, + 935, + 1446, + 825, + 314, + 570, + 58, + 1081, + 1337, + 971, + 204, + 460, + 716, + 1227, + 1117, + 606, + 350, + 95, + 862, + 1373, + 1263, + 496, + 241, + 752, + 1008, + ): list([ + 99, + ]), + tuple( + 898, + 131, + 387, + 643, + 1154, + 1410, + 1044, + 277, + 22, + 533, + 789, + 1300, + 1446, + 679, + 168, + 424, + 935, + 1191, + 825, + 314, + 570, + 58, + 1081, + 1337, + 971, + 204, + 460, + 716, + 1227, + 1117, + 606, + 350, + 95, + 862, + 1373, + 752, + 241, + 497, + 1008, + 1264, + ): list([ + 100, + ]), + tuple( + 898, + 131, + 387, + 643, + 1154, + 1410, + 1300, + 533, + 22, + 278, + 789, + 1045, + 1446, + 679, + 168, + 424, + 935, + 1191, + 825, + 314, + 570, + 58, + 1081, + 1337, + 971, + 204, + 460, + 716, + 1227, + 1373, + 606, + 351, + 95, + 862, + 1118, + 752, + 241, + 497, + 1008, + 1264, + ): list([ + 101, + ]), + tuple( + 899, + 132, + 388, + 644, + 1155, + 1411, + 1045, + 278, + 23, + 534, + 790, + 1301, + 1191, + 424, + 169, + 680, + 936, + 1447, + 826, + 315, + 571, + 59, + 1082, + 1338, + 972, + 205, + 461, + 717, + 1228, + 1118, + 607, + 96, + 351, + 863, + 1374, + 1264, + 497, + 242, + 753, + 1009, + ): list([ + 109, + ]), + tuple( + 899, + 132, + 388, + 644, + 1155, + 1411, + 1045, + 278, + 23, + 534, + 790, + 1301, + 1447, + 680, + 169, + 425, + 936, + 1192, + 826, + 315, + 571, + 59, + 1082, + 1338, + 972, + 205, + 461, + 717, + 1228, + 1118, + 607, + 96, + 351, + 863, + 1374, + 753, + 242, + 498, + 1009, + 1265, + ): list([ + 110, + ]), + tuple( + 899, + 132, + 388, + 644, + 1155, + 1411, + 1301, + 534, + 23, + 279, + 790, + 1046, + 1447, + 680, + 169, + 425, + 936, + 1192, + 826, + 315, + 571, + 59, + 1082, + 1338, + 972, + 205, + 461, + 717, + 1228, + 1374, + 607, + 96, + 352, + 863, + 1119, + 753, + 242, + 498, + 1009, + 1265, + ): list([ + 111, + ]), + tuple( + 900, + 133, + 389, + 645, + 1156, + 1412, + 1046, + 535, + 279, + 24, + 791, + 1302, + 1192, + 425, + 170, + 681, + 937, + 1448, + 827, + 316, + 60, + 572, + 1083, + 1339, + 973, + 206, + 462, + 718, + 1229, + 1119, + 352, + 97, + 608, + 864, + 1375, + 1265, + 498, + 243, + 754, + 1010, + ): list([ + 119, + ]), + tuple( + 900, + 133, + 389, + 645, + 1156, + 1412, + 1046, + 535, + 279, + 24, + 791, + 1302, + 1448, + 681, + 170, + 426, + 937, + 1193, + 827, + 316, + 60, + 572, + 1083, + 1339, + 973, + 206, + 462, + 718, + 1229, + 1119, + 352, + 97, + 608, + 864, + 1375, + 754, + 243, + 499, + 1010, + 1266, + ): list([ + 120, + ]), + tuple( + 900, + 133, + 389, + 645, + 1156, + 1412, + 1302, + 535, + 280, + 24, + 791, + 1047, + 1448, + 681, + 170, + 426, + 937, + 1193, + 827, + 316, + 60, + 572, + 1083, + 1339, + 973, + 206, + 462, + 718, + 1229, + 1375, + 608, + 97, + 353, + 864, + 1120, + 754, + 243, + 499, + 1010, + 1266, + ): list([ + 121, + ]), + tuple( + 901, + 134, + 390, + 646, + 1157, + 1413, + 1047, + 536, + 280, + 25, + 792, + 1303, + 1193, + 426, + 171, + 682, + 938, + 1449, + 828, + 573, + 317, + 61, + 1084, + 1340, + 974, + 207, + 463, + 719, + 1230, + 1120, + 353, + 98, + 609, + 865, + 1376, + 1266, + 499, + 244, + 755, + 1011, + ): list([ + 129, + ]), + tuple( + 901, + 134, + 390, + 646, + 1157, + 1413, + 1047, + 536, + 280, + 25, + 792, + 1303, + 1449, + 682, + 171, + 427, + 938, + 1194, + 828, + 573, + 317, + 61, + 1084, + 1340, + 974, + 207, + 463, + 719, + 1230, + 1120, + 353, + 98, + 609, + 865, + 1376, + 755, + 244, + 500, + 1011, + 1267, + ): list([ + 130, + ]), + tuple( + 901, + 134, + 390, + 646, + 1157, + 1413, + 1303, + 536, + 281, + 25, + 792, + 1048, + 1449, + 682, + 171, + 427, + 938, + 1194, + 828, + 573, + 317, + 61, + 1084, + 1340, + 974, + 207, + 463, + 719, + 1230, + 1376, + 609, + 98, + 354, + 865, + 1121, + 755, + 244, + 500, + 1011, + 1267, + ): list([ + 131, + ]), + tuple( + 902, + 135, + 391, + 647, + 1158, + 1414, + 1048, + 537, + 281, + 26, + 793, + 1304, + 1194, + 427, + 172, + 683, + 939, + 1450, + 829, + 318, + 574, + 62, + 1085, + 1341, + 975, + 208, + 464, + 720, + 1231, + 1121, + 354, + 99, + 610, + 866, + 1377, + 1267, + 500, + 245, + 756, + 1012, + ): list([ + 139, + ]), + tuple( + 902, + 135, + 391, + 647, + 1158, + 1414, + 1048, + 537, + 281, + 26, + 793, + 1304, + 1450, + 683, + 172, + 428, + 939, + 1195, + 829, + 318, + 574, + 62, + 1085, + 1341, + 975, + 208, + 464, + 720, + 1231, + 1121, + 354, + 99, + 610, + 866, + 1377, + 756, + 245, + 501, + 1012, + 1268, + ): list([ + 140, + ]), + tuple( + 902, + 135, + 391, + 647, + 1158, + 1414, + 1304, + 537, + 282, + 26, + 793, + 1049, + 1450, + 683, + 172, + 428, + 939, + 1195, + 829, + 318, + 574, + 62, + 1085, + 1341, + 975, + 208, + 464, + 720, + 1231, + 1377, + 610, + 99, + 355, + 866, + 1122, + 756, + 245, + 501, + 1012, + 1268, + ): list([ + 141, + ]), + tuple( + 903, + 136, + 392, + 648, + 1159, + 1415, + 1049, + 538, + 282, + 27, + 794, + 1305, + 1195, + 428, + 173, + 684, + 940, + 1451, + 830, + 319, + 575, + 63, + 1086, + 1342, + 976, + 209, + 465, + 721, + 1232, + 1122, + 355, + 100, + 611, + 867, + 1378, + 1268, + 501, + 246, + 757, + 1013, + ): list([ + 149, + ]), + tuple( + 903, + 136, + 392, + 648, + 1159, + 1415, + 1049, + 538, + 282, + 27, + 794, + 1305, + 1451, + 684, + 173, + 429, + 940, + 1196, + 830, + 319, + 575, + 63, + 1086, + 1342, + 976, + 209, + 465, + 721, + 1232, + 1122, + 355, + 100, + 611, + 867, + 1378, + 757, + 246, + 502, + 1013, + 1269, + ): list([ + 150, + ]), + tuple( + 903, + 136, + 392, + 648, + 1159, + 1415, + 1305, + 538, + 283, + 27, + 794, + 1050, + 1451, + 684, + 173, + 429, + 940, + 1196, + 830, + 319, + 575, + 63, + 1086, + 1342, + 976, + 209, + 465, + 721, + 1232, + 1378, + 611, + 100, + 356, + 867, + 1123, + 757, + 246, + 502, + 1013, + 1269, + ): list([ + 151, + ]), + tuple( + 904, + 137, + 393, + 649, + 1160, + 1416, + 138, + 905, + 1050, + 539, + 283, + 28, + 795, + 1306, + 284, + 1051, + 1307, + 1452, + 685, + 174, + 430, + 941, + 1197, + 1453, + 686, + 831, + 64, + 320, + 576, + 1087, + 1343, + 65, + 832, + 977, + 210, + 466, + 722, + 1233, + 211, + 978, + 247, + 1123, + 356, + 101, + 612, + 868, + 1379, + 357, + 1124, + 759, + 613, + 1380, + 758, + 503, + 1014, + 1270, + ): list([ + 160, + 161, + 162, + 163, + 164, + ]), + tuple( + 904, + 137, + 393, + 649, + 1160, + 1416, + 1050, + 539, + 283, + 28, + 795, + 1306, + 1196, + 429, + 174, + 685, + 941, + 1452, + 831, + 64, + 320, + 576, + 1087, + 1343, + 977, + 210, + 466, + 722, + 1233, + 1123, + 356, + 101, + 612, + 868, + 1379, + 1269, + 502, + 247, + 758, + 1014, + ): list([ + 159, + ]), + tuple( + 905, + 138, + 394, + 650, + 1161, + 1417, + 139, + 906, + 1162, + 1307, + 540, + 285, + 29, + 796, + 1052, + 1308, + 541, + 686, + 175, + 431, + 942, + 1198, + 687, + 832, + 65, + 321, + 577, + 1088, + 1344, + 66, + 833, + 978, + 211, + 467, + 723, + 1234, + 212, + 979, + 468, + 1235, + 248, + 1380, + 613, + 102, + 358, + 869, + 1125, + 614, + 1381, + 760, + 1015, + 759, + 504, + 1271, + ): list([ + 171, + 172, + 173, + 174, + 175, + ]), + tuple( + 905, + 138, + 394, + 650, + 1161, + 1417, + 1051, + 540, + 284, + 29, + 796, + 1307, + 686, + 175, + 431, + 942, + 1198, + 832, + 65, + 321, + 577, + 1088, + 1344, + 978, + 211, + 467, + 723, + 1234, + 248, + 1124, + 357, + 102, + 613, + 869, + 1380, + 1015, + 759, + 504, + 1271, + ): list([ + 170, + ]), + tuple( + 905, + 138, + 394, + 650, + 1161, + 1417, + 1051, + 540, + 284, + 29, + 796, + 1307, + 1197, + 430, + 175, + 686, + 942, + 832, + 65, + 321, + 577, + 1088, + 1344, + 978, + 211, + 467, + 723, + 1234, + 1124, + 357, + 102, + 613, + 869, + 1380, + 759, + 1015, + 1270, + 503, + 248, + ): list([ + 169, + ]), + tuple( + 906, + 139, + 395, + 651, + 1162, + 1418, + 1052, + 541, + 285, + 30, + 797, + 1308, + 1198, + 431, + 176, + 687, + 943, + 833, + 66, + 322, + 578, + 1089, + 1345, + 979, + 212, + 468, + 724, + 1235, + 1016, + 1125, + 358, + 103, + 614, + 870, + 1381, + 760, + 1271, + 504, + 249, + ): list([ + 179, + ]), + tuple( + 907, + 140, + 396, + 652, + 1163, + 1419, + 1053, + 542, + 286, + 31, + 798, + 1309, + 1199, + 432, + 177, + 688, + 944, + 834, + 67, + 323, + 579, + 1090, + 1346, + 980, + 213, + 469, + 725, + 1236, + 1126, + 359, + 104, + 615, + 871, + 1382, + 761, + 1272, + 505, + 250, + 1017, + ): list([ + 189, + ]), + tuple( + 911, + 144, + 400, + 656, + 1021, + 1167, + 1423, + 1277, + 1057, + 290, + 35, + 546, + 802, + 1313, + 692, + 181, + 437, + 948, + 1204, + 838, + 71, + 327, + 583, + 1094, + 1350, + 984, + 473, + 217, + 729, + 1240, + 1130, + 363, + 108, + 619, + 875, + 1386, + 254, + 765, + 510, + ): list([ + 230, + ]), + tuple( + 1018, + 908, + 141, + 397, + 653, + 1164, + 1420, + 1054, + 543, + 32, + 287, + 799, + 1310, + 1200, + 433, + 178, + 689, + 945, + 835, + 68, + 324, + 580, + 1091, + 1347, + 981, + 214, + 470, + 726, + 1237, + 762, + 1127, + 360, + 105, + 616, + 872, + 1383, + 1273, + 506, + 251, + ): list([ + 199, + ]), + tuple( + 1018, + 1274, + 908, + 141, + 397, + 653, + 1164, + 1420, + 142, + 909, + 1165, + 1310, + 543, + 32, + 288, + 799, + 1055, + 1311, + 544, + 689, + 178, + 434, + 945, + 1201, + 690, + 835, + 68, + 324, + 580, + 1091, + 1347, + 69, + 836, + 981, + 214, + 470, + 726, + 1237, + 215, + 982, + 471, + 1238, + 1383, + 616, + 105, + 361, + 872, + 1128, + 617, + 1384, + 251, + 762, + 507, + 763, + ): list([ + 201, + 202, + 203, + 204, + 205, + ]), + tuple( + 1018, + 1274, + 908, + 141, + 397, + 653, + 1164, + 1420, + 1054, + 543, + 32, + 287, + 799, + 1310, + 689, + 178, + 434, + 945, + 1201, + 835, + 68, + 324, + 580, + 1091, + 1347, + 981, + 214, + 470, + 726, + 1237, + 1127, + 360, + 105, + 616, + 872, + 1383, + 251, + 762, + 507, + ): list([ + 200, + ]), + tuple( + 1018, + 1419, + 652, + 141, + 397, + 908, + 1164, + 798, + 287, + 543, + 31, + 1054, + 1310, + 944, + 177, + 433, + 689, + 1200, + 1346, + 579, + 68, + 324, + 835, + 1091, + 725, + 214, + 470, + 981, + 1237, + 762, + 871, + 104, + 360, + 616, + 250, + 1127, + 1383, + 1273, + 506, + ): list([ + 196, + ]), + tuple( + 1018, + 1419, + 652, + 141, + 397, + 908, + 1164, + 798, + 287, + 543, + 31, + 1054, + 1310, + 1200, + 433, + 178, + 689, + 945, + 1346, + 579, + 68, + 324, + 835, + 1091, + 725, + 214, + 470, + 981, + 1237, + 762, + 1127, + 104, + 360, + 616, + 872, + 1383, + 1273, + 506, + 251, + ): list([ + 197, + ]), + tuple( + 1018, + 1419, + 652, + 141, + 397, + 908, + 1164, + 1054, + 543, + 32, + 287, + 799, + 1310, + 1200, + 433, + 178, + 689, + 945, + 1346, + 579, + 68, + 324, + 835, + 1091, + 981, + 214, + 470, + 726, + 1237, + 762, + 1127, + 360, + 105, + 616, + 872, + 1383, + 1273, + 506, + 251, + ): list([ + 198, + ]), + tuple( + 1019, + 909, + 142, + 398, + 654, + 1165, + 1275, + 1421, + 1055, + 288, + 33, + 544, + 800, + 1311, + 690, + 179, + 435, + 946, + 1202, + 836, + 69, + 325, + 581, + 1092, + 1348, + 982, + 471, + 215, + 727, + 1238, + 1128, + 361, + 106, + 617, + 873, + 1384, + 252, + 763, + 508, + ): list([ + 210, + ]), + tuple( + 1019, + 909, + 142, + 398, + 654, + 1165, + 1421, + 1055, + 288, + 33, + 544, + 800, + 1311, + 1201, + 434, + 179, + 690, + 946, + 836, + 69, + 325, + 581, + 1092, + 1348, + 982, + 471, + 215, + 727, + 1238, + 1128, + 361, + 106, + 617, + 873, + 1384, + 1274, + 507, + 252, + 763, + ): list([ + 209, + ]), + tuple( + 1019, + 1420, + 653, + 142, + 398, + 909, + 1165, + 799, + 32, + 288, + 544, + 1055, + 1311, + 945, + 178, + 434, + 690, + 1201, + 1347, + 580, + 69, + 325, + 836, + 1092, + 726, + 471, + 215, + 982, + 1238, + 872, + 105, + 361, + 617, + 1128, + 1384, + 251, + 1274, + 507, + 763, + ): list([ + 206, + ]), + tuple( + 1019, + 1420, + 653, + 142, + 398, + 909, + 1165, + 799, + 32, + 288, + 544, + 1055, + 1311, + 1201, + 434, + 179, + 690, + 946, + 1347, + 580, + 69, + 325, + 836, + 1092, + 726, + 471, + 215, + 982, + 1238, + 1128, + 105, + 361, + 617, + 873, + 1384, + 1274, + 507, + 252, + 763, + ): list([ + 207, + ]), + tuple( + 1019, + 1420, + 653, + 142, + 398, + 909, + 1165, + 1055, + 288, + 33, + 544, + 800, + 1311, + 1201, + 434, + 179, + 690, + 946, + 1347, + 580, + 69, + 325, + 836, + 1092, + 982, + 471, + 215, + 727, + 1238, + 1128, + 361, + 106, + 617, + 873, + 1384, + 1274, + 507, + 252, + 763, + ): list([ + 208, + ]), + tuple( + 1020, + 910, + 143, + 399, + 655, + 1166, + 1422, + 1276, + 1056, + 289, + 34, + 545, + 801, + 1312, + 691, + 180, + 436, + 947, + 1203, + 837, + 70, + 326, + 582, + 1093, + 1349, + 983, + 472, + 216, + 728, + 1239, + 1129, + 362, + 107, + 618, + 874, + 1385, + 253, + 764, + 509, + ): list([ + 220, + ]), + tuple( + 1024, + 257, + 2, + 513, + 769, + 1280, + 1170, + 403, + 148, + 659, + 915, + 1426, + 549, + 38, + 294, + 805, + 1061, + 1317, + 951, + 440, + 184, + 696, + 1207, + 1097, + 330, + 75, + 586, + 842, + 1353, + 1243, + 476, + 221, + 732, + 988, + 878, + 111, + 367, + 623, + 1134, + 1390, + ): list([ + 264, + ]), + tuple( + 1024, + 257, + 2, + 513, + 769, + 1280, + 1170, + 403, + 148, + 659, + 915, + 1426, + 1316, + 549, + 38, + 294, + 805, + 1061, + 695, + 440, + 184, + 951, + 1207, + 1097, + 330, + 75, + 586, + 842, + 1353, + 1243, + 476, + 221, + 732, + 988, + 1389, + 622, + 111, + 367, + 878, + 1134, + ): list([ + 263, + ]), + tuple( + 1024, + 257, + 2, + 513, + 769, + 1280, + 1426, + 403, + 148, + 659, + 915, + 1171, + 805, + 38, + 294, + 550, + 1061, + 1317, + 951, + 440, + 184, + 696, + 1207, + 1097, + 330, + 75, + 586, + 842, + 1353, + 732, + 477, + 221, + 988, + 1244, + 878, + 111, + 367, + 623, + 1134, + 1390, + ): list([ + 265, + ]), + tuple( + 1025, + 258, + 3, + 514, + 770, + 1281, + 1171, + 404, + 149, + 660, + 916, + 1427, + 550, + 39, + 295, + 806, + 1062, + 1318, + 952, + 441, + 185, + 697, + 1208, + 1098, + 331, + 76, + 587, + 843, + 1354, + 1244, + 477, + 222, + 733, + 989, + 879, + 112, + 368, + 624, + 1135, + 1391, + ): list([ + 274, + ]), + tuple( + 1025, + 258, + 3, + 514, + 770, + 1281, + 1171, + 404, + 149, + 660, + 916, + 1427, + 1317, + 550, + 39, + 295, + 806, + 1062, + 696, + 441, + 185, + 952, + 1208, + 1098, + 331, + 76, + 587, + 843, + 1354, + 1244, + 477, + 222, + 733, + 989, + 1390, + 623, + 112, + 368, + 879, + 1135, + ): list([ + 273, + ]), + tuple( + 1025, + 258, + 3, + 514, + 770, + 1281, + 1427, + 404, + 149, + 660, + 916, + 1172, + 806, + 39, + 295, + 551, + 1062, + 1318, + 952, + 441, + 185, + 697, + 1208, + 1098, + 331, + 76, + 587, + 843, + 1354, + 733, + 478, + 222, + 989, + 1245, + 879, + 112, + 368, + 624, + 1135, + 1391, + ): list([ + 275, + ]), + tuple( + 1026, + 259, + 4, + 515, + 771, + 1282, + 1172, + 405, + 150, + 661, + 917, + 1428, + 551, + 40, + 296, + 807, + 1063, + 1319, + 953, + 442, + 186, + 698, + 1209, + 1099, + 332, + 77, + 588, + 844, + 1355, + 1245, + 478, + 223, + 734, + 990, + 880, + 113, + 369, + 625, + 1136, + 1392, + ): list([ + 284, + ]), + tuple( + 1026, + 259, + 4, + 515, + 771, + 1282, + 1172, + 405, + 150, + 661, + 917, + 1428, + 1318, + 551, + 40, + 296, + 807, + 1063, + 697, + 442, + 186, + 953, + 1209, + 1099, + 332, + 77, + 588, + 844, + 1355, + 1245, + 478, + 223, + 734, + 990, + 1391, + 624, + 113, + 369, + 880, + 1136, + ): list([ + 283, + ]), + tuple( + 1026, + 259, + 4, + 515, + 771, + 1282, + 1428, + 405, + 150, + 661, + 917, + 1173, + 807, + 40, + 296, + 552, + 1063, + 1319, + 953, + 442, + 186, + 698, + 1209, + 1099, + 332, + 77, + 588, + 844, + 1355, + 734, + 479, + 223, + 990, + 1246, + 880, + 113, + 369, + 625, + 1136, + 1392, + ): list([ + 285, + ]), + tuple( + 1027, + 260, + 5, + 516, + 772, + 1283, + 1173, + 406, + 151, + 662, + 918, + 1429, + 552, + 41, + 297, + 808, + 1064, + 1320, + 954, + 443, + 187, + 699, + 1210, + 1100, + 333, + 78, + 589, + 845, + 1356, + 1246, + 479, + 224, + 735, + 991, + 881, + 114, + 370, + 626, + 1137, + 1393, + ): list([ + 294, + ]), + tuple( + 1027, + 260, + 5, + 516, + 772, + 1283, + 1173, + 406, + 151, + 662, + 918, + 1429, + 1319, + 552, + 41, + 297, + 808, + 1064, + 698, + 443, + 187, + 954, + 1210, + 1100, + 333, + 78, + 589, + 845, + 1356, + 1246, + 479, + 224, + 735, + 991, + 1392, + 625, + 114, + 370, + 881, + 1137, + ): list([ + 293, + ]), + tuple( + 1027, + 260, + 5, + 516, + 772, + 1283, + 1429, + 406, + 151, + 662, + 918, + 1174, + 808, + 41, + 297, + 553, + 1064, + 1320, + 954, + 443, + 187, + 699, + 1210, + 1100, + 333, + 78, + 589, + 845, + 1356, + 735, + 224, + 480, + 991, + 1247, + 881, + 114, + 370, + 626, + 1137, + 1393, + ): list([ + 295, + ]), + tuple( + 1028, + 261, + 6, + 517, + 773, + 1284, + 1174, + 663, + 407, + 152, + 919, + 1430, + 553, + 42, + 298, + 809, + 1065, + 1321, + 955, + 444, + 188, + 700, + 1211, + 1101, + 334, + 79, + 590, + 846, + 1357, + 1247, + 480, + 225, + 736, + 992, + 882, + 115, + 371, + 627, + 1138, + 1394, + ): list([ + 304, + ]), + tuple( + 1028, + 261, + 6, + 517, + 773, + 1284, + 1174, + 663, + 407, + 152, + 919, + 1430, + 1320, + 553, + 42, + 298, + 809, + 1065, + 699, + 444, + 188, + 955, + 1211, + 1101, + 334, + 79, + 590, + 846, + 1357, + 1247, + 480, + 225, + 736, + 992, + 1393, + 626, + 115, + 371, + 882, + 1138, + ): list([ + 303, + ]), + tuple( + 1028, + 261, + 6, + 517, + 773, + 1284, + 1430, + 663, + 407, + 152, + 919, + 1175, + 809, + 42, + 298, + 554, + 1065, + 1321, + 955, + 444, + 188, + 700, + 1211, + 1101, + 334, + 79, + 590, + 846, + 1357, + 736, + 225, + 481, + 992, + 1248, + 882, + 115, + 371, + 627, + 1138, + 1394, + ): list([ + 305, + ]), + tuple( + 1029, + 262, + 7, + 518, + 774, + 1285, + 1175, + 664, + 408, + 153, + 920, + 1431, + 554, + 43, + 299, + 810, + 1066, + 1322, + 956, + 189, + 445, + 701, + 1212, + 1102, + 335, + 80, + 591, + 847, + 1358, + 1248, + 481, + 226, + 737, + 993, + 883, + 116, + 372, + 628, + 1139, + 1395, + ): list([ + 314, + ]), + tuple( + 1029, + 262, + 7, + 518, + 774, + 1285, + 1175, + 664, + 408, + 153, + 920, + 1431, + 1321, + 554, + 43, + 299, + 810, + 1066, + 700, + 189, + 445, + 956, + 1212, + 1102, + 335, + 80, + 591, + 847, + 1358, + 1248, + 481, + 226, + 737, + 993, + 1394, + 627, + 116, + 372, + 883, + 1139, + ): list([ + 313, + ]), + tuple( + 1029, + 262, + 7, + 518, + 774, + 1285, + 1431, + 664, + 408, + 153, + 920, + 1176, + 810, + 43, + 299, + 555, + 1066, + 1322, + 956, + 189, + 445, + 701, + 1212, + 1102, + 335, + 80, + 591, + 847, + 1358, + 737, + 226, + 482, + 993, + 1249, + 883, + 116, + 372, + 628, + 1139, + 1395, + ): list([ + 315, + ]), + tuple( + 1030, + 263, + 8, + 519, + 775, + 1286, + 1176, + 665, + 409, + 154, + 921, + 1432, + 555, + 44, + 300, + 811, + 1067, + 1323, + 957, + 446, + 190, + 702, + 1213, + 1103, + 336, + 81, + 592, + 848, + 1359, + 1249, + 482, + 227, + 738, + 994, + 884, + 117, + 373, + 629, + 1140, + 1396, + ): list([ + 324, + ]), + tuple( + 1030, + 263, + 8, + 519, + 775, + 1286, + 1176, + 665, + 409, + 154, + 921, + 1432, + 1322, + 555, + 44, + 300, + 811, + 1067, + 701, + 446, + 190, + 957, + 1213, + 1103, + 336, + 81, + 592, + 848, + 1359, + 1249, + 482, + 227, + 738, + 994, + 1395, + 628, + 117, + 373, + 884, + 1140, + ): list([ + 323, + ]), + tuple( + 1030, + 263, + 8, + 519, + 775, + 1286, + 1432, + 665, + 409, + 154, + 921, + 1177, + 811, + 44, + 300, + 556, + 1067, + 1323, + 957, + 446, + 190, + 702, + 1213, + 1103, + 336, + 81, + 592, + 848, + 1359, + 738, + 227, + 483, + 994, + 1250, + 884, + 117, + 373, + 629, + 1140, + 1396, + ): list([ + 325, + ]), + tuple( + 1031, + 264, + 9, + 520, + 776, + 1287, + 1177, + 666, + 410, + 155, + 922, + 1433, + 556, + 45, + 301, + 812, + 1068, + 1324, + 958, + 447, + 191, + 703, + 1214, + 1104, + 337, + 82, + 593, + 849, + 1360, + 1250, + 483, + 228, + 739, + 995, + 885, + 118, + 374, + 630, + 1141, + 1397, + ): list([ + 334, + ]), + tuple( + 1031, + 264, + 9, + 520, + 776, + 1287, + 1177, + 666, + 410, + 155, + 922, + 1433, + 1323, + 556, + 45, + 301, + 812, + 1068, + 702, + 447, + 191, + 958, + 1214, + 1104, + 337, + 82, + 593, + 849, + 1360, + 1250, + 483, + 228, + 739, + 995, + 1396, + 629, + 118, + 374, + 885, + 1141, + ): list([ + 333, + ]), + tuple( + 1031, + 264, + 9, + 520, + 776, + 1287, + 1433, + 666, + 410, + 155, + 922, + 1178, + 812, + 45, + 301, + 557, + 1068, + 1324, + 958, + 447, + 191, + 703, + 1214, + 1104, + 337, + 82, + 593, + 849, + 1360, + 739, + 228, + 484, + 995, + 1251, + 885, + 118, + 374, + 630, + 1141, + 1397, + ): list([ + 335, + ]), + tuple( + 1032, + 265, + 10, + 521, + 777, + 1288, + 1178, + 667, + 411, + 156, + 923, + 1434, + 557, + 46, + 302, + 813, + 1069, + 1325, + 959, + 192, + 448, + 704, + 1215, + 1105, + 338, + 83, + 594, + 850, + 1361, + 119, + 375, + 1251, + 484, + 229, + 740, + 996, + 886, + 631, + 1142, + 1398, + ): list([ + 344, + ]), + tuple( + 1032, + 265, + 10, + 521, + 777, + 1288, + 1178, + 667, + 411, + 156, + 923, + 1434, + 1324, + 557, + 46, + 302, + 813, + 1069, + 703, + 192, + 448, + 959, + 1215, + 1105, + 338, + 83, + 594, + 850, + 1361, + 375, + 1251, + 484, + 229, + 740, + 996, + 1397, + 630, + 119, + 886, + 1142, + ): list([ + 343, + ]), + tuple( + 1032, + 265, + 10, + 521, + 777, + 1288, + 1434, + 667, + 411, + 156, + 923, + 1179, + 813, + 46, + 302, + 558, + 1069, + 1325, + 959, + 192, + 448, + 704, + 1215, + 1105, + 338, + 83, + 594, + 850, + 1361, + 119, + 375, + 740, + 229, + 485, + 996, + 1252, + 886, + 631, + 1142, + 1398, + ): list([ + 345, + ]), + tuple( + 1033, + 266, + 11, + 522, + 778, + 1289, + 1179, + 668, + 412, + 157, + 924, + 1435, + 558, + 47, + 303, + 814, + 1070, + 1326, + 960, + 193, + 449, + 705, + 1216, + 1106, + 339, + 84, + 595, + 851, + 1143, + 1362, + 120, + 1252, + 485, + 230, + 741, + 997, + 632, + 887, + 376, + 1399, + ): list([ + 354, + ]), + tuple( + 1033, + 266, + 11, + 522, + 778, + 1289, + 1179, + 668, + 412, + 157, + 924, + 1435, + 1325, + 558, + 47, + 303, + 814, + 1070, + 704, + 193, + 449, + 960, + 1216, + 1106, + 339, + 84, + 595, + 851, + 1143, + 1362, + 120, + 1252, + 485, + 230, + 741, + 997, + 887, + 1398, + 631, + 376, + ): list([ + 353, + ]), + tuple( + 1033, + 266, + 11, + 522, + 778, + 1289, + 1435, + 668, + 412, + 157, + 924, + 1180, + 814, + 47, + 303, + 559, + 1070, + 1326, + 960, + 193, + 449, + 705, + 1216, + 1106, + 339, + 84, + 595, + 851, + 1143, + 1362, + 120, + 741, + 230, + 486, + 997, + 1253, + 632, + 887, + 376, + 1399, + ): list([ + 355, + ]), + tuple( + 1038, + 271, + 16, + 527, + 783, + 1148, + 1294, + 1404, + 1184, + 417, + 162, + 673, + 929, + 1440, + 819, + 52, + 308, + 564, + 1075, + 1331, + 965, + 198, + 454, + 710, + 1221, + 1111, + 600, + 344, + 89, + 856, + 1367, + 1257, + 490, + 235, + 746, + 1002, + 381, + 125, + 892, + 637, + ): list([ + 39, + ]), + tuple( + 1038, + 271, + 16, + 527, + 783, + 1148, + 1294, + 1404, + 1440, + 673, + 162, + 418, + 929, + 1185, + 819, + 52, + 308, + 564, + 1075, + 1331, + 965, + 198, + 454, + 710, + 1221, + 1111, + 600, + 344, + 89, + 856, + 1367, + 746, + 235, + 491, + 1002, + 1258, + 381, + 125, + 892, + 637, + ): list([ + 40, + ]), + tuple( + 1040, + 273, + 18, + 529, + 785, + 894, + 1296, + 1150, + 1186, + 419, + 164, + 675, + 931, + 1442, + 1332, + 565, + 54, + 310, + 821, + 1077, + 967, + 200, + 456, + 712, + 1223, + 1113, + 602, + 346, + 91, + 858, + 1369, + 1259, + 492, + 237, + 748, + 1004, + 127, + 1405, + 638, + 383, + ): list([ + 58, + ]), + tuple( + 1145, + 779, + 12, + 268, + 524, + 1035, + 1291, + 925, + 414, + 670, + 158, + 1181, + 1437, + 1071, + 304, + 49, + 560, + 816, + 1327, + 706, + 195, + 451, + 962, + 1218, + 852, + 85, + 341, + 597, + 1108, + 1364, + 889, + 998, + 231, + 487, + 377, + 743, + 1254, + 1400, + 633, + 122, + ): list([ + 5, + ]), + tuple( + 1145, + 779, + 12, + 268, + 524, + 1035, + 1291, + 925, + 414, + 670, + 158, + 1181, + 1437, + 1327, + 560, + 49, + 305, + 816, + 1072, + 706, + 195, + 451, + 962, + 1218, + 852, + 85, + 341, + 597, + 1108, + 1364, + 889, + 122, + 231, + 487, + 743, + 999, + 1254, + 1400, + 633, + 378, + ): list([ + 6, + ]), + tuple( + 1145, + 779, + 12, + 268, + 524, + 1035, + 1291, + 1181, + 670, + 414, + 159, + 926, + 1437, + 1327, + 560, + 49, + 305, + 816, + 1072, + 706, + 195, + 451, + 962, + 1218, + 1108, + 85, + 341, + 597, + 853, + 1364, + 889, + 122, + 487, + 232, + 743, + 999, + 1254, + 1400, + 633, + 378, + ): list([ + 7, + ]), + tuple( + 1145, + 1035, + 268, + 13, + 524, + 780, + 1291, + 1181, + 670, + 414, + 159, + 926, + 1437, + 1327, + 560, + 49, + 305, + 816, + 1072, + 962, + 195, + 451, + 707, + 1218, + 1108, + 341, + 86, + 597, + 853, + 1364, + 889, + 122, + 487, + 232, + 743, + 999, + 1254, + 1400, + 633, + 378, + ): list([ + 8, + ]), + tuple( + 1145, + 1401, + 1035, + 268, + 13, + 524, + 780, + 1291, + 1181, + 670, + 414, + 159, + 926, + 1437, + 816, + 49, + 305, + 561, + 1072, + 1328, + 962, + 195, + 451, + 707, + 1218, + 1108, + 341, + 86, + 597, + 853, + 1364, + 122, + 487, + 232, + 743, + 999, + 1254, + 634, + 889, + 378, + ): list([ + 9, + ]), + tuple( + 1145, + 1401, + 1035, + 268, + 13, + 524, + 780, + 1291, + 1437, + 670, + 415, + 159, + 926, + 1182, + 816, + 49, + 305, + 561, + 1072, + 1328, + 962, + 195, + 451, + 707, + 1218, + 1108, + 341, + 86, + 597, + 853, + 1364, + 122, + 743, + 232, + 488, + 999, + 1255, + 634, + 889, + 378, + ): list([ + 10, + ]), + tuple( + 1145, + 1401, + 1291, + 524, + 13, + 269, + 780, + 1036, + 1437, + 670, + 415, + 159, + 926, + 1182, + 816, + 49, + 305, + 561, + 1072, + 1328, + 962, + 195, + 451, + 707, + 1218, + 1364, + 597, + 86, + 342, + 853, + 1109, + 122, + 743, + 232, + 488, + 999, + 1255, + 634, + 889, + 378, + ): list([ + 11, + ]), + tuple( + 1146, + 780, + 13, + 269, + 525, + 1036, + 1292, + 926, + 415, + 671, + 159, + 1182, + 1438, + 1072, + 305, + 50, + 561, + 817, + 1328, + 707, + 196, + 452, + 963, + 1219, + 853, + 86, + 342, + 598, + 1109, + 1365, + 999, + 232, + 488, + 744, + 1255, + 378, + 1401, + 634, + 123, + 890, + ): list([ + 15, + ]), + tuple( + 1146, + 780, + 13, + 269, + 525, + 1036, + 1292, + 926, + 415, + 671, + 159, + 1182, + 1438, + 1328, + 561, + 50, + 306, + 817, + 1073, + 707, + 196, + 452, + 963, + 1219, + 853, + 86, + 342, + 598, + 1109, + 1365, + 1255, + 232, + 488, + 744, + 123, + 1000, + 1401, + 634, + 379, + 890, + ): list([ + 16, + ]), + tuple( + 1146, + 780, + 13, + 269, + 525, + 1036, + 1292, + 1182, + 671, + 160, + 415, + 927, + 1438, + 1328, + 561, + 50, + 306, + 817, + 1073, + 707, + 196, + 452, + 963, + 1219, + 1109, + 86, + 342, + 598, + 854, + 1365, + 1255, + 488, + 233, + 744, + 123, + 1000, + 1401, + 634, + 379, + 890, + ): list([ + 17, + ]), + tuple( + 1146, + 1036, + 269, + 14, + 525, + 781, + 1292, + 1182, + 671, + 160, + 415, + 927, + 1438, + 1328, + 561, + 50, + 306, + 817, + 1073, + 963, + 196, + 452, + 708, + 1219, + 1109, + 342, + 87, + 598, + 854, + 1365, + 1255, + 488, + 233, + 744, + 123, + 1000, + 1401, + 634, + 379, + 890, + ): list([ + 18, + ]), + tuple( + 1146, + 1036, + 269, + 14, + 525, + 781, + 1292, + 1402, + 1182, + 671, + 160, + 415, + 927, + 1438, + 817, + 50, + 306, + 562, + 1073, + 1329, + 963, + 196, + 452, + 708, + 1219, + 1109, + 342, + 87, + 598, + 854, + 1365, + 1255, + 488, + 233, + 744, + 123, + 1000, + 379, + 890, + 635, + ): list([ + 19, + ]), + tuple( + 1146, + 1036, + 269, + 14, + 525, + 781, + 1292, + 1402, + 1438, + 671, + 160, + 416, + 927, + 1183, + 817, + 50, + 306, + 562, + 1073, + 1329, + 963, + 196, + 452, + 708, + 1219, + 1109, + 342, + 87, + 598, + 854, + 1365, + 744, + 233, + 489, + 123, + 1000, + 1256, + 379, + 890, + 635, + ): list([ + 20, + ]), + tuple( + 1146, + 1292, + 525, + 14, + 270, + 781, + 1037, + 1402, + 1438, + 671, + 160, + 416, + 927, + 1183, + 817, + 50, + 306, + 562, + 1073, + 1329, + 963, + 196, + 452, + 708, + 1219, + 1365, + 598, + 87, + 343, + 854, + 1110, + 744, + 233, + 489, + 123, + 1000, + 1256, + 379, + 890, + 635, + ): list([ + 21, + ]), + tuple( + 1147, + 1037, + 270, + 15, + 526, + 782, + 1293, + 1403, + 1183, + 416, + 161, + 672, + 928, + 1439, + 818, + 51, + 307, + 563, + 1074, + 1330, + 964, + 197, + 453, + 709, + 1220, + 1110, + 599, + 343, + 88, + 855, + 1366, + 1256, + 489, + 234, + 745, + 1001, + 124, + 380, + 891, + 636, + ): list([ + 29, + ]), + tuple( + 1147, + 1037, + 270, + 15, + 526, + 782, + 1293, + 1403, + 1439, + 672, + 161, + 417, + 928, + 1184, + 818, + 51, + 307, + 563, + 1074, + 1330, + 964, + 197, + 453, + 709, + 1220, + 1110, + 599, + 343, + 88, + 855, + 1366, + 745, + 234, + 490, + 1001, + 1257, + 124, + 380, + 891, + 636, + ): list([ + 30, + ]), + tuple( + 1147, + 1293, + 526, + 15, + 271, + 782, + 1038, + 1403, + 1439, + 672, + 161, + 417, + 928, + 1184, + 818, + 51, + 307, + 563, + 1074, + 1330, + 964, + 197, + 453, + 709, + 1220, + 1366, + 599, + 344, + 88, + 855, + 1111, + 745, + 234, + 490, + 1001, + 1257, + 124, + 380, + 891, + 636, + ): list([ + 31, + ]), + tuple( + 1152, + 385, + 130, + 641, + 897, + 1408, + 531, + 20, + 276, + 787, + 1043, + 1299, + 933, + 166, + 422, + 678, + 1189, + 1445, + 1079, + 568, + 312, + 57, + 824, + 1335, + 1225, + 458, + 203, + 714, + 970, + 860, + 605, + 349, + 93, + 1116, + 1372, + 1006, + 239, + 495, + 751, + 1262, + ): list([ + 84, + ]), + tuple( + 1152, + 385, + 130, + 641, + 897, + 1408, + 1298, + 531, + 20, + 276, + 787, + 1043, + 677, + 166, + 422, + 933, + 1189, + 1445, + 1079, + 568, + 312, + 57, + 824, + 1335, + 1225, + 458, + 203, + 714, + 970, + 1371, + 604, + 349, + 93, + 860, + 1116, + 1006, + 239, + 495, + 751, + 1262, + ): list([ + 83, + ]), + tuple( + 1152, + 385, + 130, + 641, + 897, + 1408, + 1298, + 531, + 20, + 276, + 787, + 1043, + 1444, + 677, + 166, + 422, + 933, + 1189, + 823, + 312, + 568, + 56, + 1079, + 1335, + 1225, + 458, + 203, + 714, + 970, + 1371, + 604, + 349, + 93, + 860, + 1116, + 750, + 239, + 495, + 1006, + 1262, + ): list([ + 82, + ]), + tuple( + 1153, + 386, + 131, + 642, + 898, + 1409, + 532, + 21, + 277, + 788, + 1044, + 1300, + 934, + 167, + 423, + 679, + 1190, + 1446, + 1080, + 569, + 313, + 58, + 825, + 1336, + 1226, + 459, + 204, + 715, + 971, + 861, + 350, + 606, + 94, + 1117, + 1373, + 1007, + 240, + 496, + 752, + 1263, + ): list([ + 94, + ]), + tuple( + 1153, + 386, + 131, + 642, + 898, + 1409, + 1299, + 532, + 21, + 277, + 788, + 1044, + 678, + 167, + 423, + 934, + 1190, + 1446, + 1080, + 569, + 313, + 58, + 825, + 1336, + 1226, + 459, + 204, + 715, + 971, + 1372, + 605, + 350, + 94, + 861, + 1117, + 1007, + 240, + 496, + 752, + 1263, + ): list([ + 93, + ]), + tuple( + 1153, + 386, + 131, + 642, + 898, + 1409, + 1299, + 532, + 21, + 277, + 788, + 1044, + 1445, + 678, + 167, + 423, + 934, + 1190, + 824, + 313, + 569, + 57, + 1080, + 1336, + 1226, + 459, + 204, + 715, + 971, + 1372, + 605, + 350, + 94, + 861, + 1117, + 751, + 240, + 496, + 1007, + 1263, + ): list([ + 92, + ]), + tuple( + 1154, + 387, + 132, + 643, + 899, + 1410, + 533, + 22, + 278, + 789, + 1045, + 1301, + 935, + 168, + 424, + 680, + 1191, + 1447, + 1081, + 570, + 314, + 59, + 826, + 1337, + 1227, + 460, + 205, + 716, + 972, + 862, + 351, + 607, + 95, + 1118, + 1374, + 1008, + 241, + 497, + 753, + 1264, + ): list([ + 104, + ]), + tuple( + 1154, + 387, + 132, + 643, + 899, + 1410, + 1300, + 533, + 22, + 278, + 789, + 1045, + 679, + 168, + 424, + 935, + 1191, + 1447, + 1081, + 570, + 314, + 59, + 826, + 1337, + 1227, + 460, + 205, + 716, + 972, + 1373, + 606, + 351, + 95, + 862, + 1118, + 1008, + 241, + 497, + 753, + 1264, + ): list([ + 103, + ]), + tuple( + 1154, + 387, + 132, + 643, + 899, + 1410, + 1300, + 533, + 22, + 278, + 789, + 1045, + 1446, + 679, + 168, + 424, + 935, + 1191, + 825, + 314, + 570, + 58, + 1081, + 1337, + 1227, + 460, + 205, + 716, + 972, + 1373, + 606, + 351, + 95, + 862, + 1118, + 752, + 241, + 497, + 1008, + 1264, + ): list([ + 102, + ]), + tuple( + 1155, + 388, + 133, + 644, + 900, + 1411, + 534, + 279, + 23, + 790, + 1046, + 1302, + 936, + 169, + 425, + 681, + 1192, + 1448, + 1082, + 571, + 315, + 60, + 827, + 1338, + 1228, + 461, + 206, + 717, + 973, + 863, + 96, + 352, + 608, + 1119, + 1375, + 1009, + 242, + 498, + 754, + 1265, + ): list([ + 114, + ]), + tuple( + 1155, + 388, + 133, + 644, + 900, + 1411, + 1301, + 534, + 23, + 279, + 790, + 1046, + 1447, + 680, + 169, + 425, + 936, + 1192, + 826, + 315, + 571, + 59, + 1082, + 1338, + 1228, + 461, + 206, + 717, + 973, + 1374, + 607, + 96, + 352, + 863, + 1119, + 753, + 242, + 498, + 1009, + 1265, + ): list([ + 112, + ]), + tuple( + 1155, + 388, + 133, + 644, + 900, + 1411, + 1301, + 534, + 279, + 23, + 790, + 1046, + 680, + 169, + 425, + 936, + 1192, + 1448, + 1082, + 571, + 315, + 60, + 827, + 1338, + 1228, + 461, + 206, + 717, + 973, + 1374, + 607, + 96, + 352, + 863, + 1119, + 1009, + 242, + 498, + 754, + 1265, + ): list([ + 113, + ]), + tuple( + 1156, + 389, + 134, + 645, + 901, + 1412, + 535, + 280, + 24, + 791, + 1047, + 1303, + 937, + 170, + 426, + 682, + 1193, + 1449, + 1083, + 316, + 61, + 572, + 828, + 1339, + 1229, + 462, + 207, + 718, + 974, + 864, + 97, + 353, + 609, + 1120, + 1376, + 1010, + 243, + 499, + 755, + 1266, + ): list([ + 124, + ]), + tuple( + 1156, + 389, + 134, + 645, + 901, + 1412, + 1302, + 535, + 280, + 24, + 791, + 1047, + 681, + 170, + 426, + 937, + 1193, + 1449, + 1083, + 316, + 61, + 572, + 828, + 1339, + 1229, + 462, + 207, + 718, + 974, + 1375, + 608, + 97, + 353, + 864, + 1120, + 1010, + 243, + 499, + 755, + 1266, + ): list([ + 123, + ]), + tuple( + 1156, + 389, + 134, + 645, + 901, + 1412, + 1302, + 535, + 280, + 24, + 791, + 1047, + 1448, + 681, + 170, + 426, + 937, + 1193, + 827, + 316, + 60, + 572, + 1083, + 1339, + 1229, + 462, + 207, + 718, + 974, + 1375, + 608, + 97, + 353, + 864, + 1120, + 754, + 243, + 499, + 1010, + 1266, + ): list([ + 122, + ]), + tuple( + 1157, + 390, + 135, + 646, + 902, + 1413, + 536, + 281, + 25, + 792, + 1048, + 1304, + 938, + 171, + 427, + 683, + 1194, + 1450, + 1084, + 573, + 317, + 62, + 829, + 1340, + 1230, + 463, + 208, + 719, + 975, + 865, + 98, + 354, + 610, + 1121, + 1377, + 1011, + 244, + 500, + 756, + 1267, + ): list([ + 134, + ]), + tuple( + 1157, + 390, + 135, + 646, + 902, + 1413, + 1303, + 536, + 281, + 25, + 792, + 1048, + 682, + 171, + 427, + 938, + 1194, + 1450, + 1084, + 573, + 317, + 62, + 829, + 1340, + 1230, + 463, + 208, + 719, + 975, + 1376, + 609, + 98, + 354, + 865, + 1121, + 1011, + 244, + 500, + 756, + 1267, + ): list([ + 133, + ]), + tuple( + 1157, + 390, + 135, + 646, + 902, + 1413, + 1303, + 536, + 281, + 25, + 792, + 1048, + 1449, + 682, + 171, + 427, + 938, + 1194, + 828, + 573, + 317, + 61, + 1084, + 1340, + 1230, + 463, + 208, + 719, + 975, + 1376, + 609, + 98, + 354, + 865, + 1121, + 755, + 244, + 500, + 1011, + 1267, + ): list([ + 132, + ]), + tuple( + 1158, + 391, + 136, + 647, + 903, + 1414, + 537, + 282, + 26, + 793, + 1049, + 1305, + 939, + 172, + 428, + 684, + 1195, + 1451, + 1085, + 574, + 318, + 63, + 830, + 1341, + 1231, + 464, + 209, + 720, + 976, + 866, + 99, + 355, + 611, + 1122, + 1378, + 1012, + 245, + 501, + 757, + 1268, + ): list([ + 144, + ]), + tuple( + 1158, + 391, + 136, + 647, + 903, + 1414, + 1304, + 537, + 282, + 26, + 793, + 1049, + 683, + 172, + 428, + 939, + 1195, + 1451, + 1085, + 574, + 318, + 63, + 830, + 1341, + 1231, + 464, + 209, + 720, + 976, + 1377, + 610, + 99, + 355, + 866, + 1122, + 1012, + 245, + 501, + 757, + 1268, + ): list([ + 143, + ]), + tuple( + 1158, + 391, + 136, + 647, + 903, + 1414, + 1304, + 537, + 282, + 26, + 793, + 1049, + 1450, + 683, + 172, + 428, + 939, + 1195, + 829, + 318, + 574, + 62, + 1085, + 1341, + 1231, + 464, + 209, + 720, + 976, + 1377, + 610, + 99, + 355, + 866, + 1122, + 756, + 245, + 501, + 1012, + 1268, + ): list([ + 142, + ]), + tuple( + 1159, + 392, + 137, + 648, + 904, + 1415, + 538, + 283, + 27, + 794, + 1050, + 1306, + 940, + 173, + 429, + 685, + 1196, + 1452, + 1086, + 575, + 64, + 319, + 831, + 1342, + 1232, + 465, + 210, + 721, + 977, + 867, + 100, + 356, + 612, + 1123, + 1379, + 1013, + 246, + 502, + 758, + 1269, + ): list([ + 154, + ]), + tuple( + 1159, + 392, + 137, + 648, + 904, + 1415, + 1305, + 538, + 283, + 27, + 794, + 1050, + 684, + 173, + 429, + 940, + 1196, + 1452, + 1086, + 575, + 64, + 319, + 831, + 1342, + 1232, + 465, + 210, + 721, + 977, + 1378, + 611, + 100, + 356, + 867, + 1123, + 1013, + 246, + 502, + 758, + 1269, + ): list([ + 153, + ]), + tuple( + 1159, + 392, + 137, + 648, + 904, + 1415, + 1305, + 538, + 283, + 27, + 794, + 1050, + 1451, + 684, + 173, + 429, + 940, + 1196, + 830, + 319, + 575, + 63, + 1086, + 1342, + 1232, + 465, + 210, + 721, + 977, + 1378, + 611, + 100, + 356, + 867, + 1123, + 757, + 246, + 502, + 1013, + 1269, + ): list([ + 152, + ]), + tuple( + 1272, + 906, + 139, + 395, + 651, + 1162, + 1418, + 140, + 907, + 1163, + 1308, + 541, + 30, + 286, + 797, + 1053, + 1309, + 542, + 687, + 176, + 432, + 943, + 1199, + 688, + 833, + 66, + 322, + 578, + 1089, + 1345, + 67, + 834, + 979, + 212, + 468, + 724, + 1235, + 213, + 1016, + 980, + 469, + 1236, + 249, + 614, + 103, + 359, + 870, + 1126, + 1381, + 615, + 1382, + 761, + 760, + 505, + ): list([ + 181, + 182, + 183, + 184, + 185, + ]), + tuple( + 1272, + 906, + 139, + 395, + 651, + 1162, + 1418, + 1052, + 541, + 285, + 30, + 797, + 1308, + 687, + 176, + 432, + 943, + 1199, + 833, + 66, + 322, + 578, + 1089, + 1345, + 979, + 212, + 468, + 724, + 1235, + 1016, + 249, + 358, + 103, + 614, + 870, + 1125, + 1381, + 760, + 505, + ): list([ + 180, + ]), + tuple( + 1273, + 907, + 140, + 396, + 652, + 1163, + 1419, + 141, + 908, + 1164, + 1309, + 542, + 287, + 31, + 798, + 1054, + 1310, + 543, + 688, + 177, + 433, + 944, + 1200, + 689, + 834, + 67, + 323, + 579, + 1090, + 1346, + 68, + 835, + 980, + 213, + 469, + 725, + 1236, + 214, + 981, + 470, + 1237, + 762, + 1382, + 615, + 104, + 360, + 250, + 871, + 1127, + 616, + 1383, + 761, + 506, + 1017, + ): list([ + 191, + 192, + 193, + 194, + 195, + ]), + tuple( + 1273, + 907, + 140, + 396, + 652, + 1163, + 1419, + 1053, + 542, + 286, + 31, + 798, + 1309, + 688, + 177, + 433, + 944, + 1200, + 834, + 67, + 323, + 579, + 1090, + 1346, + 980, + 213, + 469, + 725, + 1236, + 1126, + 359, + 104, + 615, + 250, + 871, + 1382, + 761, + 506, + 1017, + ): list([ + 190, + ]), + tuple( + 1280, + 257, + 2, + 513, + 769, + 1025, + 1426, + 659, + 148, + 404, + 915, + 1171, + 805, + 38, + 294, + 550, + 1061, + 1317, + 951, + 440, + 184, + 696, + 1207, + 1353, + 586, + 75, + 331, + 842, + 1098, + 732, + 477, + 221, + 988, + 1244, + 878, + 111, + 367, + 623, + 1134, + 1390, + ): list([ + 266, + ]), + tuple( + 1280, + 513, + 2, + 258, + 769, + 1025, + 915, + 148, + 404, + 660, + 1171, + 1427, + 1061, + 294, + 39, + 550, + 806, + 1317, + 1207, + 440, + 185, + 696, + 952, + 842, + 75, + 331, + 587, + 1098, + 1354, + 988, + 477, + 221, + 733, + 1244, + 1134, + 367, + 112, + 623, + 879, + 1390, + ): list([ + 269, + ]), + tuple( + 1280, + 513, + 2, + 258, + 769, + 1025, + 1426, + 659, + 148, + 404, + 915, + 1171, + 805, + 38, + 294, + 550, + 1061, + 1317, + 1207, + 440, + 185, + 696, + 952, + 1353, + 586, + 75, + 331, + 842, + 1098, + 732, + 477, + 221, + 988, + 1244, + 1134, + 111, + 367, + 623, + 879, + 1390, + ): list([ + 267, + ]), + tuple( + 1280, + 513, + 2, + 258, + 769, + 1025, + 1426, + 659, + 148, + 404, + 915, + 1171, + 1061, + 294, + 39, + 550, + 806, + 1317, + 1207, + 440, + 185, + 696, + 952, + 1353, + 586, + 75, + 331, + 842, + 1098, + 988, + 477, + 221, + 733, + 1244, + 1134, + 367, + 112, + 623, + 879, + 1390, + ): list([ + 268, + ]), + tuple( + 1281, + 258, + 3, + 514, + 770, + 1026, + 1427, + 660, + 149, + 405, + 916, + 1172, + 806, + 39, + 295, + 551, + 1062, + 1318, + 952, + 441, + 185, + 697, + 1208, + 1354, + 587, + 76, + 332, + 843, + 1099, + 733, + 478, + 222, + 989, + 1245, + 879, + 112, + 368, + 624, + 1135, + 1391, + ): list([ + 276, + ]), + tuple( + 1281, + 514, + 3, + 259, + 770, + 1026, + 916, + 149, + 405, + 661, + 1172, + 1428, + 1062, + 295, + 40, + 551, + 807, + 1318, + 1208, + 441, + 186, + 697, + 953, + 843, + 76, + 332, + 588, + 1099, + 1355, + 989, + 478, + 222, + 734, + 1245, + 1135, + 368, + 113, + 624, + 880, + 1391, + ): list([ + 279, + ]), + tuple( + 1281, + 514, + 3, + 259, + 770, + 1026, + 1427, + 660, + 149, + 405, + 916, + 1172, + 806, + 39, + 295, + 551, + 1062, + 1318, + 1208, + 441, + 186, + 697, + 953, + 1354, + 587, + 76, + 332, + 843, + 1099, + 733, + 478, + 222, + 989, + 1245, + 1135, + 112, + 368, + 624, + 880, + 1391, + ): list([ + 277, + ]), + tuple( + 1281, + 514, + 3, + 259, + 770, + 1026, + 1427, + 660, + 149, + 405, + 916, + 1172, + 1062, + 295, + 40, + 551, + 807, + 1318, + 1208, + 441, + 186, + 697, + 953, + 1354, + 587, + 76, + 332, + 843, + 1099, + 989, + 478, + 222, + 734, + 1245, + 1135, + 368, + 113, + 624, + 880, + 1391, + ): list([ + 278, + ]), + tuple( + 1282, + 259, + 4, + 515, + 771, + 1027, + 1428, + 661, + 150, + 406, + 917, + 1173, + 807, + 40, + 296, + 552, + 1063, + 1319, + 953, + 442, + 186, + 698, + 1209, + 1355, + 588, + 77, + 333, + 844, + 1100, + 734, + 479, + 223, + 990, + 1246, + 880, + 113, + 369, + 625, + 1136, + 1392, + ): list([ + 286, + ]), + tuple( + 1282, + 515, + 4, + 260, + 771, + 1027, + 917, + 150, + 406, + 662, + 1173, + 1429, + 1063, + 296, + 41, + 552, + 808, + 1319, + 1209, + 442, + 187, + 698, + 954, + 844, + 77, + 333, + 589, + 1100, + 1356, + 990, + 479, + 223, + 735, + 1246, + 1136, + 369, + 114, + 625, + 881, + 1392, + ): list([ + 289, + ]), + tuple( + 1282, + 515, + 4, + 260, + 771, + 1027, + 1428, + 661, + 150, + 406, + 917, + 1173, + 807, + 40, + 296, + 552, + 1063, + 1319, + 1209, + 442, + 187, + 698, + 954, + 1355, + 588, + 77, + 333, + 844, + 1100, + 734, + 479, + 223, + 990, + 1246, + 1136, + 113, + 369, + 625, + 881, + 1392, + ): list([ + 287, + ]), + tuple( + 1282, + 515, + 4, + 260, + 771, + 1027, + 1428, + 661, + 150, + 406, + 917, + 1173, + 1063, + 296, + 41, + 552, + 808, + 1319, + 1209, + 442, + 187, + 698, + 954, + 1355, + 588, + 77, + 333, + 844, + 1100, + 990, + 479, + 223, + 735, + 1246, + 1136, + 369, + 114, + 625, + 881, + 1392, + ): list([ + 288, + ]), + tuple( + 1283, + 260, + 5, + 516, + 772, + 1028, + 1429, + 662, + 407, + 151, + 918, + 1174, + 808, + 41, + 297, + 553, + 1064, + 1320, + 954, + 443, + 187, + 699, + 1210, + 1356, + 589, + 78, + 334, + 845, + 1101, + 735, + 224, + 480, + 991, + 1247, + 881, + 114, + 370, + 626, + 1137, + 1393, + ): list([ + 296, + ]), + tuple( + 1283, + 516, + 5, + 261, + 772, + 1028, + 918, + 407, + 663, + 151, + 1174, + 1430, + 1064, + 297, + 42, + 553, + 809, + 1320, + 1210, + 443, + 188, + 699, + 955, + 845, + 78, + 334, + 590, + 1101, + 1357, + 991, + 224, + 480, + 736, + 1247, + 1137, + 370, + 115, + 626, + 882, + 1393, + ): list([ + 299, + ]), + tuple( + 1283, + 516, + 5, + 261, + 772, + 1028, + 1429, + 662, + 407, + 151, + 918, + 1174, + 808, + 41, + 297, + 553, + 1064, + 1320, + 1210, + 443, + 188, + 699, + 955, + 1356, + 589, + 78, + 334, + 845, + 1101, + 735, + 224, + 480, + 991, + 1247, + 1137, + 114, + 370, + 626, + 882, + 1393, + ): list([ + 297, + ]), + tuple( + 1283, + 516, + 5, + 261, + 772, + 1028, + 1429, + 662, + 407, + 151, + 918, + 1174, + 1064, + 297, + 42, + 553, + 809, + 1320, + 1210, + 443, + 188, + 699, + 955, + 1356, + 589, + 78, + 334, + 845, + 1101, + 991, + 224, + 480, + 736, + 1247, + 1137, + 370, + 115, + 626, + 882, + 1393, + ): list([ + 298, + ]), + tuple( + 1284, + 261, + 6, + 517, + 773, + 1029, + 1430, + 663, + 408, + 152, + 919, + 1175, + 809, + 42, + 298, + 554, + 1065, + 1321, + 955, + 444, + 188, + 700, + 1211, + 1357, + 590, + 79, + 335, + 846, + 1102, + 736, + 225, + 481, + 992, + 1248, + 882, + 115, + 371, + 627, + 1138, + 1394, + ): list([ + 306, + ]), + tuple( + 1284, + 517, + 6, + 262, + 773, + 1029, + 919, + 408, + 664, + 152, + 1175, + 1431, + 1065, + 298, + 43, + 554, + 810, + 1321, + 1211, + 444, + 189, + 700, + 956, + 846, + 79, + 335, + 591, + 1102, + 1358, + 992, + 225, + 481, + 737, + 1248, + 1138, + 371, + 116, + 627, + 883, + 1394, + ): list([ + 309, + ]), + tuple( + 1284, + 517, + 6, + 262, + 773, + 1029, + 1430, + 663, + 408, + 152, + 919, + 1175, + 809, + 42, + 298, + 554, + 1065, + 1321, + 1211, + 444, + 189, + 700, + 956, + 1357, + 590, + 79, + 335, + 846, + 1102, + 736, + 225, + 481, + 992, + 1248, + 1138, + 115, + 371, + 627, + 883, + 1394, + ): list([ + 307, + ]), + tuple( + 1284, + 517, + 6, + 262, + 773, + 1029, + 1430, + 663, + 408, + 152, + 919, + 1175, + 1065, + 298, + 43, + 554, + 810, + 1321, + 1211, + 444, + 189, + 700, + 956, + 1357, + 590, + 79, + 335, + 846, + 1102, + 992, + 225, + 481, + 737, + 1248, + 1138, + 371, + 116, + 627, + 883, + 1394, + ): list([ + 308, + ]), + tuple( + 1285, + 262, + 7, + 518, + 774, + 1030, + 1431, + 664, + 409, + 153, + 920, + 1176, + 810, + 43, + 299, + 555, + 1066, + 1322, + 956, + 189, + 445, + 701, + 1212, + 1358, + 591, + 80, + 336, + 847, + 1103, + 737, + 226, + 482, + 993, + 1249, + 883, + 116, + 372, + 628, + 1139, + 1395, + ): list([ + 316, + ]), + tuple( + 1285, + 518, + 7, + 263, + 774, + 1030, + 920, + 409, + 665, + 153, + 1176, + 1432, + 1066, + 299, + 44, + 555, + 811, + 1322, + 1212, + 445, + 190, + 701, + 957, + 847, + 80, + 336, + 592, + 1103, + 1359, + 993, + 226, + 482, + 738, + 1249, + 1139, + 372, + 117, + 628, + 884, + 1395, + ): list([ + 319, + ]), + tuple( + 1285, + 518, + 7, + 263, + 774, + 1030, + 1431, + 664, + 409, + 153, + 920, + 1176, + 810, + 43, + 299, + 555, + 1066, + 1322, + 1212, + 445, + 190, + 701, + 957, + 1358, + 591, + 80, + 336, + 847, + 1103, + 737, + 226, + 482, + 993, + 1249, + 1139, + 116, + 372, + 628, + 884, + 1395, + ): list([ + 317, + ]), + tuple( + 1285, + 518, + 7, + 263, + 774, + 1030, + 1431, + 664, + 409, + 153, + 920, + 1176, + 1066, + 299, + 44, + 555, + 811, + 1322, + 1212, + 445, + 190, + 701, + 957, + 1358, + 591, + 80, + 336, + 847, + 1103, + 993, + 226, + 482, + 738, + 1249, + 1139, + 372, + 117, + 628, + 884, + 1395, + ): list([ + 318, + ]), + tuple( + 1286, + 263, + 8, + 519, + 775, + 1031, + 1432, + 665, + 410, + 154, + 921, + 1177, + 811, + 44, + 300, + 556, + 1067, + 1323, + 957, + 446, + 190, + 702, + 1213, + 1359, + 592, + 81, + 337, + 848, + 1104, + 738, + 227, + 483, + 994, + 1250, + 884, + 117, + 373, + 629, + 1140, + 1396, + ): list([ + 326, + ]), + tuple( + 1286, + 519, + 8, + 264, + 775, + 1031, + 921, + 410, + 666, + 154, + 1177, + 1433, + 1067, + 300, + 45, + 556, + 812, + 1323, + 1213, + 446, + 191, + 702, + 958, + 848, + 81, + 337, + 593, + 1104, + 1360, + 994, + 227, + 483, + 739, + 1250, + 1140, + 373, + 118, + 629, + 885, + 1396, + ): list([ + 329, + ]), + tuple( + 1286, + 519, + 8, + 264, + 775, + 1031, + 1432, + 665, + 410, + 154, + 921, + 1177, + 811, + 44, + 300, + 556, + 1067, + 1323, + 1213, + 446, + 191, + 702, + 958, + 1359, + 592, + 81, + 337, + 848, + 1104, + 738, + 227, + 483, + 994, + 1250, + 1140, + 117, + 373, + 629, + 885, + 1396, + ): list([ + 327, + ]), + tuple( + 1286, + 519, + 8, + 264, + 775, + 1031, + 1432, + 665, + 410, + 154, + 921, + 1177, + 1067, + 300, + 45, + 556, + 812, + 1323, + 1213, + 446, + 191, + 702, + 958, + 1359, + 592, + 81, + 337, + 848, + 1104, + 994, + 227, + 483, + 739, + 1250, + 1140, + 373, + 118, + 629, + 885, + 1396, + ): list([ + 328, + ]), + tuple( + 1287, + 264, + 9, + 520, + 776, + 1032, + 1433, + 666, + 411, + 155, + 922, + 1178, + 812, + 45, + 301, + 557, + 1068, + 1324, + 958, + 447, + 191, + 703, + 1214, + 1360, + 593, + 82, + 338, + 849, + 1105, + 739, + 228, + 484, + 995, + 1251, + 885, + 118, + 374, + 630, + 1141, + 1397, + ): list([ + 336, + ]), + tuple( + 1287, + 520, + 9, + 265, + 776, + 1032, + 922, + 411, + 155, + 667, + 1178, + 1434, + 1068, + 301, + 46, + 557, + 813, + 1324, + 1214, + 447, + 192, + 703, + 959, + 849, + 82, + 338, + 594, + 1105, + 1361, + 995, + 228, + 484, + 740, + 1251, + 1141, + 374, + 119, + 630, + 886, + 1397, + ): list([ + 339, + ]), + tuple( + 1287, + 520, + 9, + 265, + 776, + 1032, + 1433, + 666, + 411, + 155, + 922, + 1178, + 812, + 45, + 301, + 557, + 1068, + 1324, + 1214, + 447, + 192, + 703, + 959, + 1360, + 593, + 82, + 338, + 849, + 1105, + 739, + 228, + 484, + 995, + 1251, + 1141, + 118, + 374, + 630, + 886, + 1397, + ): list([ + 337, + ]), + tuple( + 1287, + 520, + 9, + 265, + 776, + 1032, + 1433, + 666, + 411, + 155, + 922, + 1178, + 1068, + 301, + 46, + 557, + 813, + 1324, + 1214, + 447, + 192, + 703, + 959, + 1360, + 593, + 82, + 338, + 849, + 1105, + 995, + 228, + 484, + 740, + 1251, + 1141, + 374, + 119, + 630, + 886, + 1397, + ): list([ + 338, + ]), + tuple( + 1288, + 265, + 10, + 521, + 777, + 1033, + 1434, + 667, + 412, + 156, + 923, + 1179, + 813, + 46, + 302, + 558, + 1069, + 1325, + 959, + 192, + 448, + 704, + 1215, + 1361, + 594, + 83, + 339, + 850, + 1106, + 119, + 375, + 740, + 229, + 485, + 996, + 1252, + 886, + 631, + 1142, + 1398, + ): list([ + 346, + ]), + tuple( + 1288, + 521, + 10, + 266, + 777, + 1033, + 923, + 668, + 412, + 156, + 1179, + 1435, + 1069, + 302, + 47, + 558, + 814, + 1325, + 1215, + 448, + 193, + 704, + 960, + 850, + 83, + 339, + 595, + 1106, + 1362, + 375, + 996, + 229, + 485, + 741, + 1252, + 887, + 1142, + 631, + 120, + 1398, + ): list([ + 349, + ]), + tuple( + 1288, + 521, + 10, + 266, + 777, + 1033, + 1434, + 667, + 412, + 156, + 923, + 1179, + 813, + 46, + 302, + 558, + 1069, + 1325, + 1215, + 448, + 193, + 704, + 960, + 1361, + 594, + 83, + 339, + 850, + 1106, + 119, + 375, + 740, + 229, + 485, + 996, + 1252, + 887, + 1142, + 631, + 1398, + ): list([ + 347, + ]), + tuple( + 1288, + 521, + 10, + 266, + 777, + 1033, + 1434, + 667, + 412, + 156, + 923, + 1179, + 1069, + 302, + 47, + 558, + 814, + 1325, + 1215, + 448, + 193, + 704, + 960, + 1361, + 594, + 83, + 339, + 850, + 1106, + 375, + 996, + 229, + 485, + 741, + 1252, + 887, + 1142, + 631, + 120, + 1398, + ): list([ + 348, + ]), + tuple( + 1289, + 266, + 11, + 522, + 778, + 1034, + 1435, + 668, + 157, + 413, + 924, + 1180, + 814, + 47, + 303, + 559, + 1070, + 1326, + 960, + 193, + 449, + 705, + 1216, + 1362, + 595, + 84, + 340, + 851, + 1107, + 1143, + 120, + 741, + 230, + 486, + 997, + 1253, + 632, + 887, + 376, + 1399, + ): list([ + 356, + ]), + tuple( + 1289, + 522, + 11, + 267, + 778, + 1034, + 924, + 669, + 157, + 413, + 1180, + 1436, + 1070, + 303, + 48, + 559, + 815, + 1326, + 1216, + 449, + 194, + 705, + 961, + 851, + 84, + 340, + 596, + 1107, + 1363, + 376, + 997, + 230, + 486, + 742, + 1253, + 888, + 1143, + 632, + 121, + 1399, + ): list([ + 359, + ]), + tuple( + 1289, + 522, + 11, + 267, + 778, + 1034, + 1435, + 668, + 157, + 413, + 924, + 1180, + 814, + 47, + 303, + 559, + 1070, + 1326, + 1216, + 449, + 194, + 705, + 961, + 1362, + 595, + 84, + 340, + 851, + 1107, + 120, + 741, + 230, + 486, + 997, + 1253, + 632, + 888, + 1143, + 376, + 1399, + ): list([ + 357, + ]), + tuple( + 1289, + 522, + 11, + 267, + 778, + 1034, + 1435, + 668, + 157, + 413, + 924, + 1180, + 1070, + 303, + 48, + 559, + 815, + 1326, + 1216, + 449, + 194, + 705, + 961, + 1362, + 595, + 84, + 340, + 851, + 1107, + 376, + 997, + 230, + 486, + 742, + 1253, + 888, + 1143, + 632, + 121, + 1399, + ): list([ + 358, + ]), + tuple( + 1294, + 527, + 16, + 272, + 783, + 1039, + 1148, + 1404, + 1440, + 673, + 162, + 418, + 929, + 1185, + 819, + 52, + 308, + 564, + 1075, + 1331, + 965, + 198, + 454, + 710, + 1221, + 1367, + 600, + 345, + 89, + 856, + 1112, + 746, + 235, + 491, + 1002, + 1258, + 381, + 125, + 892, + 637, + ): list([ + 41, + ]), + tuple( + 1400, + 523, + 12, + 268, + 779, + 1035, + 1291, + 925, + 414, + 670, + 158, + 1181, + 1437, + 1071, + 304, + 49, + 560, + 816, + 1327, + 1217, + 450, + 195, + 706, + 962, + 852, + 85, + 341, + 597, + 1108, + 1364, + 889, + 998, + 231, + 487, + 377, + 743, + 1254, + 1144, + 633, + 122, + ): list([ + 4, + ]), + tuple( + 1400, + 1034, + 267, + 12, + 523, + 779, + 1290, + 268, + 1035, + 11, + 778, + 1436, + 669, + 414, + 158, + 925, + 1181, + 413, + 1180, + 1326, + 815, + 48, + 304, + 560, + 1071, + 1327, + 559, + 961, + 194, + 450, + 706, + 1217, + 705, + 1107, + 340, + 85, + 596, + 852, + 1363, + 341, + 1108, + 84, + 851, + 121, + 1253, + 742, + 231, + 487, + 998, + 1254, + 486, + 632, + 633, + 1399, + 888, + 377, + 1144, + ): list([ + 0, + 1, + 362, + 363, + 364, + 365, + ]), + tuple( + 1400, + 1290, + 523, + 12, + 268, + 779, + 1035, + 669, + 414, + 158, + 925, + 1181, + 1437, + 1071, + 304, + 49, + 560, + 816, + 1327, + 1217, + 450, + 195, + 706, + 962, + 1363, + 596, + 85, + 341, + 852, + 1108, + 889, + 998, + 231, + 487, + 377, + 743, + 1254, + 1144, + 633, + 122, + ): list([ + 3, + ]), + tuple( + 1400, + 1290, + 523, + 12, + 268, + 779, + 1035, + 1436, + 669, + 414, + 158, + 925, + 1181, + 815, + 48, + 304, + 560, + 1071, + 1327, + 1217, + 450, + 195, + 706, + 962, + 1363, + 596, + 85, + 341, + 852, + 1108, + 889, + 742, + 231, + 487, + 377, + 998, + 1254, + 1144, + 633, + 122, + ): list([ + 2, + ]), + tuple( + 1401, + 524, + 13, + 269, + 780, + 1036, + 1292, + 926, + 415, + 671, + 159, + 1182, + 1438, + 1072, + 305, + 50, + 561, + 817, + 1328, + 1218, + 451, + 196, + 707, + 963, + 853, + 86, + 342, + 598, + 1109, + 1365, + 999, + 232, + 488, + 744, + 1255, + 378, + 1145, + 634, + 123, + 890, + ): list([ + 14, + ]), + tuple( + 1401, + 1291, + 524, + 13, + 269, + 780, + 1036, + 670, + 415, + 159, + 926, + 1182, + 1438, + 1072, + 305, + 50, + 561, + 817, + 1328, + 1218, + 451, + 196, + 707, + 963, + 1364, + 597, + 86, + 342, + 853, + 1109, + 999, + 232, + 488, + 744, + 1255, + 378, + 1145, + 634, + 123, + 890, + ): list([ + 13, + ]), + tuple( + 1401, + 1291, + 524, + 13, + 269, + 780, + 1036, + 1437, + 670, + 415, + 159, + 926, + 1182, + 816, + 49, + 305, + 561, + 1072, + 1328, + 1218, + 451, + 196, + 707, + 963, + 1364, + 597, + 86, + 342, + 853, + 1109, + 743, + 232, + 488, + 999, + 1255, + 378, + 1145, + 634, + 123, + 890, + ): list([ + 12, + ]), + tuple( + 1408, + 385, + 130, + 641, + 897, + 1153, + 787, + 20, + 276, + 532, + 1043, + 1299, + 933, + 166, + 422, + 678, + 1189, + 1445, + 1079, + 568, + 312, + 57, + 824, + 1335, + 714, + 203, + 459, + 970, + 1226, + 860, + 605, + 349, + 93, + 1116, + 1372, + 1006, + 239, + 495, + 751, + 1262, + ): list([ + 85, + ]), + tuple( + 1408, + 641, + 130, + 386, + 897, + 1153, + 787, + 20, + 276, + 532, + 1043, + 1299, + 933, + 166, + 422, + 678, + 1189, + 1445, + 1335, + 568, + 313, + 57, + 824, + 1080, + 714, + 203, + 459, + 970, + 1226, + 860, + 605, + 349, + 93, + 1116, + 1372, + 1262, + 239, + 495, + 751, + 1007, + ): list([ + 86, + ]), + tuple( + 1408, + 641, + 130, + 386, + 897, + 1153, + 787, + 20, + 276, + 532, + 1043, + 1299, + 1189, + 422, + 167, + 678, + 934, + 1445, + 1335, + 568, + 313, + 57, + 824, + 1080, + 714, + 203, + 459, + 970, + 1226, + 1116, + 605, + 349, + 93, + 861, + 1372, + 1262, + 495, + 240, + 751, + 1007, + ): list([ + 87, + ]), + tuple( + 1408, + 641, + 130, + 386, + 897, + 1153, + 1043, + 276, + 21, + 532, + 788, + 1299, + 1189, + 422, + 167, + 678, + 934, + 1445, + 1335, + 568, + 313, + 57, + 824, + 1080, + 970, + 203, + 459, + 715, + 1226, + 1116, + 605, + 349, + 94, + 861, + 1372, + 1262, + 495, + 240, + 751, + 1007, + ): list([ + 88, + ]), + tuple( + 1409, + 386, + 131, + 642, + 898, + 1154, + 788, + 21, + 277, + 533, + 1044, + 1300, + 934, + 167, + 423, + 679, + 1190, + 1446, + 1080, + 569, + 313, + 58, + 825, + 1336, + 715, + 204, + 460, + 971, + 1227, + 861, + 350, + 606, + 94, + 1117, + 1373, + 1007, + 240, + 496, + 752, + 1263, + ): list([ + 95, + ]), + tuple( + 1409, + 642, + 131, + 387, + 898, + 1154, + 788, + 21, + 277, + 533, + 1044, + 1300, + 934, + 167, + 423, + 679, + 1190, + 1446, + 1336, + 569, + 314, + 58, + 825, + 1081, + 715, + 204, + 460, + 971, + 1227, + 861, + 350, + 606, + 94, + 1117, + 1373, + 1263, + 240, + 496, + 752, + 1008, + ): list([ + 96, + ]), + tuple( + 1409, + 642, + 131, + 387, + 898, + 1154, + 788, + 21, + 277, + 533, + 1044, + 1300, + 1190, + 423, + 168, + 679, + 935, + 1446, + 1336, + 569, + 314, + 58, + 825, + 1081, + 715, + 204, + 460, + 971, + 1227, + 1117, + 350, + 606, + 94, + 862, + 1373, + 1263, + 496, + 241, + 752, + 1008, + ): list([ + 97, + ]), + tuple( + 1409, + 642, + 131, + 387, + 898, + 1154, + 1044, + 277, + 22, + 533, + 789, + 1300, + 1190, + 423, + 168, + 679, + 935, + 1446, + 1336, + 569, + 314, + 58, + 825, + 1081, + 971, + 204, + 460, + 716, + 1227, + 1117, + 606, + 350, + 95, + 862, + 1373, + 1263, + 496, + 241, + 752, + 1008, + ): list([ + 98, + ]), + tuple( + 1410, + 387, + 132, + 643, + 899, + 1155, + 789, + 22, + 278, + 534, + 1045, + 1301, + 935, + 168, + 424, + 680, + 1191, + 1447, + 1081, + 570, + 314, + 59, + 826, + 1337, + 716, + 205, + 461, + 972, + 1228, + 862, + 351, + 607, + 95, + 1118, + 1374, + 1008, + 241, + 497, + 753, + 1264, + ): list([ + 105, + ]), + tuple( + 1410, + 643, + 132, + 388, + 899, + 1155, + 789, + 22, + 278, + 534, + 1045, + 1301, + 935, + 168, + 424, + 680, + 1191, + 1447, + 1337, + 570, + 315, + 59, + 826, + 1082, + 716, + 205, + 461, + 972, + 1228, + 862, + 351, + 607, + 95, + 1118, + 1374, + 1264, + 241, + 497, + 753, + 1009, + ): list([ + 106, + ]), + tuple( + 1410, + 643, + 132, + 388, + 899, + 1155, + 789, + 22, + 278, + 534, + 1045, + 1301, + 1191, + 424, + 169, + 680, + 936, + 1447, + 1337, + 570, + 315, + 59, + 826, + 1082, + 716, + 205, + 461, + 972, + 1228, + 1118, + 351, + 607, + 95, + 863, + 1374, + 1264, + 497, + 242, + 753, + 1009, + ): list([ + 107, + ]), + tuple( + 1410, + 643, + 132, + 388, + 899, + 1155, + 1045, + 278, + 23, + 534, + 790, + 1301, + 1191, + 424, + 169, + 680, + 936, + 1447, + 1337, + 570, + 315, + 59, + 826, + 1082, + 972, + 205, + 461, + 717, + 1228, + 1118, + 607, + 96, + 351, + 863, + 1374, + 1264, + 497, + 242, + 753, + 1009, + ): list([ + 108, + ]), + tuple( + 1411, + 388, + 133, + 644, + 900, + 1156, + 790, + 535, + 279, + 23, + 1046, + 1302, + 936, + 169, + 425, + 681, + 1192, + 1448, + 1082, + 571, + 315, + 60, + 827, + 1338, + 717, + 206, + 462, + 973, + 1229, + 863, + 96, + 352, + 608, + 1119, + 1375, + 1009, + 242, + 498, + 754, + 1265, + ): list([ + 115, + ]), + tuple( + 1411, + 644, + 133, + 389, + 900, + 1156, + 790, + 535, + 279, + 23, + 1046, + 1302, + 936, + 169, + 425, + 681, + 1192, + 1448, + 1338, + 571, + 316, + 60, + 827, + 1083, + 717, + 206, + 462, + 973, + 1229, + 863, + 96, + 352, + 608, + 1119, + 1375, + 1265, + 242, + 498, + 754, + 1010, + ): list([ + 116, + ]), + tuple( + 1411, + 644, + 133, + 389, + 900, + 1156, + 790, + 535, + 279, + 23, + 1046, + 1302, + 1192, + 425, + 170, + 681, + 937, + 1448, + 1338, + 571, + 316, + 60, + 827, + 1083, + 717, + 206, + 462, + 973, + 1229, + 1119, + 96, + 352, + 608, + 864, + 1375, + 1265, + 498, + 243, + 754, + 1010, + ): list([ + 117, + ]), + tuple( + 1411, + 644, + 133, + 389, + 900, + 1156, + 1046, + 535, + 279, + 24, + 791, + 1302, + 1192, + 425, + 170, + 681, + 937, + 1448, + 1338, + 571, + 316, + 60, + 827, + 1083, + 973, + 206, + 462, + 718, + 1229, + 1119, + 352, + 97, + 608, + 864, + 1375, + 1265, + 498, + 243, + 754, + 1010, + ): list([ + 118, + ]), + tuple( + 1412, + 389, + 134, + 645, + 901, + 1157, + 791, + 280, + 536, + 24, + 1047, + 1303, + 937, + 170, + 426, + 682, + 1193, + 1449, + 1083, + 316, + 61, + 572, + 828, + 1339, + 718, + 207, + 463, + 974, + 1230, + 864, + 97, + 353, + 609, + 1120, + 1376, + 1010, + 243, + 499, + 755, + 1266, + ): list([ + 125, + ]), + tuple( + 1412, + 645, + 134, + 390, + 901, + 1157, + 791, + 280, + 536, + 24, + 1047, + 1303, + 937, + 170, + 426, + 682, + 1193, + 1449, + 1339, + 572, + 317, + 61, + 828, + 1084, + 718, + 207, + 463, + 974, + 1230, + 864, + 97, + 353, + 609, + 1120, + 1376, + 1266, + 243, + 499, + 755, + 1011, + ): list([ + 126, + ]), + tuple( + 1412, + 645, + 134, + 390, + 901, + 1157, + 791, + 280, + 536, + 24, + 1047, + 1303, + 1193, + 426, + 171, + 682, + 938, + 1449, + 1339, + 572, + 317, + 61, + 828, + 1084, + 718, + 207, + 463, + 974, + 1230, + 1120, + 97, + 353, + 609, + 865, + 1376, + 1266, + 499, + 244, + 755, + 1011, + ): list([ + 127, + ]), + tuple( + 1412, + 645, + 134, + 390, + 901, + 1157, + 1047, + 536, + 280, + 25, + 792, + 1303, + 1193, + 426, + 171, + 682, + 938, + 1449, + 1339, + 572, + 317, + 61, + 828, + 1084, + 974, + 207, + 463, + 719, + 1230, + 1120, + 353, + 98, + 609, + 865, + 1376, + 1266, + 499, + 244, + 755, + 1011, + ): list([ + 128, + ]), + tuple( + 1413, + 390, + 135, + 646, + 902, + 1158, + 792, + 281, + 537, + 25, + 1048, + 1304, + 938, + 171, + 427, + 683, + 1194, + 1450, + 1084, + 573, + 317, + 62, + 829, + 1340, + 719, + 208, + 464, + 975, + 1231, + 865, + 98, + 354, + 610, + 1121, + 1377, + 1011, + 244, + 500, + 756, + 1267, + ): list([ + 135, + ]), + tuple( + 1413, + 646, + 135, + 391, + 902, + 1158, + 792, + 281, + 537, + 25, + 1048, + 1304, + 938, + 171, + 427, + 683, + 1194, + 1450, + 1340, + 573, + 318, + 62, + 829, + 1085, + 719, + 208, + 464, + 975, + 1231, + 865, + 98, + 354, + 610, + 1121, + 1377, + 1267, + 244, + 500, + 756, + 1012, + ): list([ + 136, + ]), + tuple( + 1413, + 646, + 135, + 391, + 902, + 1158, + 792, + 281, + 537, + 25, + 1048, + 1304, + 1194, + 427, + 172, + 683, + 939, + 1450, + 1340, + 573, + 318, + 62, + 829, + 1085, + 719, + 208, + 464, + 975, + 1231, + 1121, + 98, + 354, + 610, + 866, + 1377, + 1267, + 500, + 245, + 756, + 1012, + ): list([ + 137, + ]), + tuple( + 1413, + 646, + 135, + 391, + 902, + 1158, + 1048, + 537, + 281, + 26, + 793, + 1304, + 1194, + 427, + 172, + 683, + 939, + 1450, + 1340, + 573, + 318, + 62, + 829, + 1085, + 975, + 208, + 464, + 720, + 1231, + 1121, + 354, + 99, + 610, + 866, + 1377, + 1267, + 500, + 245, + 756, + 1012, + ): list([ + 138, + ]), + tuple( + 1414, + 391, + 136, + 647, + 903, + 1159, + 793, + 282, + 538, + 26, + 1049, + 1305, + 939, + 172, + 428, + 684, + 1195, + 1451, + 1085, + 574, + 318, + 63, + 830, + 1341, + 720, + 209, + 465, + 976, + 1232, + 866, + 99, + 355, + 611, + 1122, + 1378, + 1012, + 245, + 501, + 757, + 1268, + ): list([ + 145, + ]), + tuple( + 1414, + 647, + 136, + 392, + 903, + 1159, + 793, + 282, + 538, + 26, + 1049, + 1305, + 939, + 172, + 428, + 684, + 1195, + 1451, + 1341, + 574, + 319, + 63, + 830, + 1086, + 720, + 209, + 465, + 976, + 1232, + 866, + 99, + 355, + 611, + 1122, + 1378, + 1268, + 245, + 501, + 757, + 1013, + ): list([ + 146, + ]), + tuple( + 1414, + 647, + 136, + 392, + 903, + 1159, + 793, + 282, + 538, + 26, + 1049, + 1305, + 1195, + 428, + 173, + 684, + 940, + 1451, + 1341, + 574, + 319, + 63, + 830, + 1086, + 720, + 209, + 465, + 976, + 1232, + 1122, + 99, + 355, + 611, + 867, + 1378, + 1268, + 501, + 246, + 757, + 1013, + ): list([ + 147, + ]), + tuple( + 1414, + 647, + 136, + 392, + 903, + 1159, + 1049, + 538, + 282, + 27, + 794, + 1305, + 1195, + 428, + 173, + 684, + 940, + 1451, + 1341, + 574, + 319, + 63, + 830, + 1086, + 976, + 209, + 465, + 721, + 1232, + 1122, + 355, + 100, + 611, + 867, + 1378, + 1268, + 501, + 246, + 757, + 1013, + ): list([ + 148, + ]), + tuple( + 1415, + 392, + 137, + 648, + 904, + 1160, + 794, + 283, + 539, + 27, + 1050, + 1306, + 940, + 173, + 429, + 685, + 1196, + 1452, + 1086, + 575, + 64, + 319, + 831, + 1342, + 721, + 210, + 466, + 977, + 1233, + 867, + 100, + 356, + 612, + 1123, + 1379, + 1013, + 246, + 502, + 758, + 1269, + ): list([ + 155, + ]), + tuple( + 1415, + 648, + 137, + 393, + 904, + 1160, + 794, + 283, + 539, + 27, + 1050, + 1306, + 940, + 173, + 429, + 685, + 1196, + 1452, + 1342, + 575, + 64, + 320, + 831, + 1087, + 721, + 210, + 466, + 977, + 1233, + 867, + 100, + 356, + 612, + 1123, + 1379, + 1269, + 246, + 502, + 758, + 1014, + ): list([ + 156, + ]), + tuple( + 1415, + 648, + 137, + 393, + 904, + 1160, + 794, + 283, + 539, + 27, + 1050, + 1306, + 1196, + 429, + 174, + 685, + 941, + 1452, + 1342, + 575, + 64, + 320, + 831, + 1087, + 721, + 210, + 466, + 977, + 1233, + 1123, + 100, + 356, + 612, + 868, + 1379, + 1269, + 502, + 247, + 758, + 1014, + ): list([ + 157, + ]), + tuple( + 1415, + 648, + 137, + 393, + 904, + 1160, + 1050, + 539, + 283, + 28, + 795, + 1306, + 1196, + 429, + 174, + 685, + 941, + 1452, + 1342, + 575, + 64, + 320, + 831, + 1087, + 977, + 210, + 466, + 722, + 1233, + 1123, + 356, + 101, + 612, + 868, + 1379, + 1269, + 502, + 247, + 758, + 1014, + ): list([ + 158, + ]), + tuple( + 1416, + 393, + 138, + 649, + 905, + 1161, + 795, + 284, + 28, + 540, + 1051, + 1307, + 941, + 174, + 430, + 686, + 1197, + 1087, + 320, + 65, + 576, + 832, + 1343, + 722, + 211, + 467, + 978, + 1234, + 247, + 868, + 101, + 357, + 613, + 1124, + 1380, + 759, + 1014, + 503, + 1270, + ): list([ + 165, + ]), + tuple( + 1416, + 649, + 138, + 394, + 905, + 1161, + 795, + 284, + 28, + 540, + 1051, + 1307, + 941, + 174, + 430, + 686, + 1197, + 1343, + 576, + 65, + 321, + 832, + 1088, + 722, + 211, + 467, + 978, + 1234, + 247, + 868, + 101, + 357, + 613, + 1124, + 1380, + 759, + 1015, + 1270, + 503, + ): list([ + 166, + ]), + tuple( + 1416, + 649, + 138, + 394, + 905, + 1161, + 795, + 284, + 28, + 540, + 1051, + 1307, + 1197, + 430, + 175, + 686, + 942, + 1343, + 576, + 65, + 321, + 832, + 1088, + 722, + 211, + 467, + 978, + 1234, + 1124, + 101, + 357, + 613, + 869, + 1380, + 759, + 1015, + 1270, + 503, + 248, + ): list([ + 167, + ]), + tuple( + 1416, + 649, + 138, + 394, + 905, + 1161, + 1051, + 540, + 284, + 29, + 796, + 1307, + 1197, + 430, + 175, + 686, + 942, + 1343, + 576, + 65, + 321, + 832, + 1088, + 978, + 211, + 467, + 723, + 1234, + 1124, + 357, + 102, + 613, + 869, + 1380, + 759, + 1015, + 1270, + 503, + 248, + ): list([ + 168, + ]), + tuple( + 1417, + 650, + 139, + 395, + 906, + 1162, + 796, + 541, + 285, + 29, + 1052, + 1308, + 942, + 175, + 431, + 687, + 1198, + 1344, + 577, + 66, + 322, + 833, + 1089, + 723, + 212, + 468, + 979, + 1235, + 1016, + 248, + 869, + 102, + 358, + 614, + 1125, + 1381, + 760, + 1271, + 504, + ): list([ + 176, + ]), + tuple( + 1417, + 650, + 139, + 395, + 906, + 1162, + 796, + 541, + 285, + 29, + 1052, + 1308, + 1198, + 431, + 176, + 687, + 943, + 1344, + 577, + 66, + 322, + 833, + 1089, + 723, + 212, + 468, + 979, + 1235, + 1016, + 1125, + 102, + 358, + 614, + 870, + 1381, + 760, + 1271, + 504, + 249, + ): list([ + 177, + ]), + tuple( + 1417, + 650, + 139, + 395, + 906, + 1162, + 1052, + 541, + 285, + 30, + 797, + 1308, + 1198, + 431, + 176, + 687, + 943, + 1344, + 577, + 66, + 322, + 833, + 1089, + 979, + 212, + 468, + 724, + 1235, + 1016, + 1125, + 358, + 103, + 614, + 870, + 1381, + 760, + 1271, + 504, + 249, + ): list([ + 178, + ]), + tuple( + 1418, + 651, + 140, + 396, + 907, + 1163, + 797, + 542, + 30, + 286, + 1053, + 1309, + 943, + 176, + 432, + 688, + 1199, + 1345, + 578, + 67, + 323, + 834, + 1090, + 724, + 213, + 469, + 980, + 1236, + 249, + 870, + 103, + 359, + 615, + 1126, + 1382, + 761, + 1272, + 505, + 1017, + ): list([ + 186, + ]), + tuple( + 1418, + 651, + 140, + 396, + 907, + 1163, + 797, + 542, + 30, + 286, + 1053, + 1309, + 1199, + 432, + 177, + 688, + 944, + 1345, + 578, + 67, + 323, + 834, + 1090, + 724, + 213, + 469, + 980, + 1236, + 1126, + 103, + 359, + 615, + 871, + 1382, + 761, + 1272, + 505, + 250, + 1017, + ): list([ + 187, + ]), + tuple( + 1418, + 651, + 140, + 396, + 907, + 1163, + 1053, + 542, + 286, + 31, + 798, + 1309, + 1199, + 432, + 177, + 688, + 944, + 1345, + 578, + 67, + 323, + 834, + 1090, + 980, + 213, + 469, + 725, + 1236, + 1126, + 359, + 104, + 615, + 871, + 1382, + 761, + 1272, + 505, + 250, + 1017, + ): list([ + 188, + ]), + }) +# --- +# name: test_snapshot_cohorts[PerfectBlockwiseResampling] + dict({ + tuple( + np.int64(0), + ): list([ + 0, + 1, + ]), + tuple( + np.int64(1), + ): list([ + 2, + 3, + ]), + tuple( + np.int64(2), + ): list([ + 4, + 5, + ]), + tuple( + np.int64(3), + ): list([ + 6, + 7, + ]), + tuple( + np.int64(4), + ): list([ + 8, + 9, + ]), + tuple( + np.int64(5), + ): list([ + 10, + 11, + ]), + tuple( + np.int64(6), + ): list([ + 12, + 13, + ]), + tuple( + np.int64(7), + ): list([ + 14, + 15, + ]), + tuple( + np.int64(8), + ): list([ + 16, + 17, + ]), + tuple( + np.int64(9), + ): list([ + 18, + 19, + ]), + tuple( + np.int64(10), + ): list([ + 20, + 21, + ]), + tuple( + np.int64(11), + ): list([ + 22, + 23, + ]), + tuple( + np.int64(12), + ): list([ + 24, + 25, + ]), + tuple( + np.int64(13), + ): list([ + 26, + 27, + ]), + tuple( + np.int64(14), + ): list([ + 28, + 29, + ]), + tuple( + np.int64(15), + ): list([ + 30, + 31, + ]), + tuple( + np.int64(16), + ): list([ + 32, + 33, + ]), + tuple( + np.int64(17), + ): list([ + 34, + 35, + ]), + tuple( + np.int64(18), + ): list([ + 36, + 37, + ]), + tuple( + np.int64(19), + ): list([ + 38, + 39, + ]), + tuple( + np.int64(20), + ): list([ + 40, + 41, + ]), + tuple( + np.int64(21), + ): list([ + 42, + 43, + ]), + tuple( + np.int64(22), + ): list([ + 44, + 45, + ]), + tuple( + np.int64(23), + ): list([ + 46, + 47, + ]), + tuple( + np.int64(24), + ): list([ + 48, + 49, + ]), + tuple( + np.int64(25), + ): list([ + 50, + 51, + ]), + tuple( + np.int64(26), + ): list([ + 52, + 53, + ]), + tuple( + np.int64(27), + ): list([ + 54, + 55, + ]), + tuple( + np.int64(28), + ): list([ + 56, + 57, + ]), + tuple( + np.int64(29), + ): list([ + 58, + 59, + ]), + tuple( + np.int64(30), + ): list([ + 60, + 61, + ]), + tuple( + np.int64(31), + ): list([ + 62, + 63, + ]), + tuple( + np.int64(32), + ): list([ + 64, + 65, + ]), + tuple( + np.int64(33), + ): list([ + 66, + 67, + ]), + tuple( + np.int64(34), + ): list([ + 68, + 69, + ]), + tuple( + np.int64(35), + ): list([ + 70, + 71, + ]), + tuple( + np.int64(36), + ): list([ + 72, + 73, + ]), + tuple( + np.int64(37), + ): list([ + 74, + 75, + ]), + tuple( + np.int64(38), + ): list([ + 76, + 77, + ]), + tuple( + np.int64(39), + ): list([ + 78, + 79, + ]), + tuple( + np.int64(40), + ): list([ + 80, + 81, + ]), + tuple( + np.int64(41), + ): list([ + 82, + 83, + ]), + tuple( + np.int64(42), + ): list([ + 84, + 85, + ]), + tuple( + np.int64(43), + ): list([ + 86, + 87, + ]), + tuple( + np.int64(44), + ): list([ + 88, + 89, + ]), + tuple( + np.int64(45), + ): list([ + 90, + 91, + ]), + tuple( + np.int64(46), + ): list([ + 92, + 93, + ]), + tuple( + np.int64(47), + ): list([ + 94, + 95, + ]), + tuple( + np.int64(48), + ): list([ + 96, + 97, + ]), + tuple( + np.int64(49), + ): list([ + 98, + 99, + ]), + tuple( + np.int64(50), + ): list([ + 100, + 101, + ]), + tuple( + np.int64(51), + ): list([ + 102, + 103, + ]), + tuple( + np.int64(52), + ): list([ + 104, + 105, + ]), + tuple( + np.int64(53), + ): list([ + 106, + 107, + ]), + tuple( + np.int64(54), + ): list([ + 108, + 109, + ]), + tuple( + np.int64(55), + ): list([ + 110, + 111, + ]), + tuple( + np.int64(56), + ): list([ + 112, + 113, + ]), + tuple( + np.int64(57), + ): list([ + 114, + 115, + ]), + tuple( + np.int64(58), + ): list([ + 116, + 117, + ]), + tuple( + np.int64(59), + ): list([ + 118, + 119, + ]), + tuple( + np.int64(60), + ): list([ + 120, + 121, + ]), + tuple( + np.int64(61), + ): list([ + 122, + 123, + ]), + tuple( + np.int64(62), + ): list([ + 124, + 125, + ]), + tuple( + np.int64(63), + ): list([ + 126, + 127, + ]), + tuple( + np.int64(64), + ): list([ + 128, + 129, + ]), + tuple( + np.int64(65), + ): list([ + 130, + 131, + ]), + tuple( + np.int64(66), + ): list([ + 132, + 133, + ]), + tuple( + np.int64(67), + ): list([ + 134, + 135, + ]), + tuple( + np.int64(68), + ): list([ + 136, + 137, + ]), + tuple( + np.int64(69), + ): list([ + 138, + 139, + ]), + tuple( + np.int64(70), + ): list([ + 140, + 141, + ]), + tuple( + np.int64(71), + ): list([ + 142, + 143, + ]), + tuple( + np.int64(72), + ): list([ + 144, + 145, + ]), + tuple( + np.int64(73), + ): list([ + 146, + 147, + ]), + tuple( + np.int64(74), + ): list([ + 148, + 149, + ]), + tuple( + np.int64(75), + ): list([ + 150, + 151, + ]), + tuple( + np.int64(76), + ): list([ + 152, + 153, + ]), + tuple( + np.int64(77), + ): list([ + 154, + 155, + ]), + tuple( + np.int64(78), + ): list([ + 156, + 157, + ]), + tuple( + np.int64(79), + ): list([ + 158, + 159, + ]), + tuple( + np.int64(80), + ): list([ + 160, + 161, + ]), + tuple( + np.int64(81), + ): list([ + 162, + 163, + ]), + tuple( + np.int64(82), + ): list([ + 164, + 165, + ]), + tuple( + np.int64(83), + ): list([ + 166, + 167, + ]), + tuple( + np.int64(84), + ): list([ + 168, + 169, + ]), + tuple( + np.int64(85), + ): list([ + 170, + 171, + ]), + tuple( + np.int64(86), + ): list([ + 172, + 173, + ]), + tuple( + np.int64(87), + ): list([ + 174, + 175, + ]), + tuple( + np.int64(88), + ): list([ + 176, + 177, + ]), + tuple( + np.int64(89), + ): list([ + 178, + 179, + ]), + tuple( + np.int64(90), + ): list([ + 180, + 181, + ]), + tuple( + np.int64(91), + ): list([ + 182, + 183, + ]), + tuple( + np.int64(92), + ): list([ + 184, + 185, + ]), + tuple( + np.int64(93), + ): list([ + 186, + 187, + ]), + tuple( + np.int64(94), + ): list([ + 188, + 189, + ]), + tuple( + np.int64(95), + ): list([ + 190, + 191, + ]), + tuple( + np.int64(96), + ): list([ + 192, + 193, + ]), + tuple( + np.int64(97), + ): list([ + 194, + 195, + ]), + tuple( + np.int64(98), + ): list([ + 196, + 197, + ]), + tuple( + np.int64(99), + ): list([ + 198, + 199, + ]), + tuple( + np.int64(100), + ): list([ + 200, + 201, + ]), + tuple( + np.int64(101), + ): list([ + 202, + 203, + ]), + tuple( + np.int64(102), + ): list([ + 204, + 205, + ]), + tuple( + np.int64(103), + ): list([ + 206, + 207, + ]), + tuple( + np.int64(104), + ): list([ + 208, + 209, + ]), + tuple( + np.int64(105), + ): list([ + 210, + 211, + ]), + tuple( + np.int64(106), + ): list([ + 212, + 213, + ]), + tuple( + np.int64(107), + ): list([ + 214, + 215, + ]), + tuple( + np.int64(108), + ): list([ + 216, + 217, + ]), + tuple( + np.int64(109), + ): list([ + 218, + 219, + ]), + tuple( + np.int64(110), + ): list([ + 220, + 221, + ]), + tuple( + np.int64(111), + ): list([ + 222, + 223, + ]), + tuple( + np.int64(112), + ): list([ + 224, + 225, + ]), + tuple( + np.int64(113), + ): list([ + 226, + 227, + ]), + tuple( + np.int64(114), + ): list([ + 228, + 229, + ]), + tuple( + np.int64(115), + ): list([ + 230, + 231, + ]), + tuple( + np.int64(116), + ): list([ + 232, + 233, + ]), + tuple( + np.int64(117), + ): list([ + 234, + 235, + ]), + tuple( + np.int64(118), + ): list([ + 236, + 237, + ]), + tuple( + np.int64(119), + ): list([ + 238, + 239, + ]), + tuple( + np.int64(120), + ): list([ + 240, + 241, + ]), + tuple( + np.int64(121), + ): list([ + 242, + 243, + ]), + tuple( + np.int64(122), + ): list([ + 244, + 245, + ]), + tuple( + np.int64(123), + ): list([ + 246, + 247, + ]), + tuple( + np.int64(124), + ): list([ + 248, + 249, + ]), + tuple( + np.int64(125), + ): list([ + 250, + 251, + ]), + tuple( + np.int64(126), + ): list([ + 252, + 253, + ]), + tuple( + np.int64(127), + ): list([ + 254, + 255, + ]), + tuple( + np.int64(128), + ): list([ + 256, + 257, + ]), + tuple( + np.int64(129), + ): list([ + 258, + 259, + ]), + tuple( + np.int64(130), + ): list([ + 260, + 261, + ]), + tuple( + np.int64(131), + ): list([ + 262, + 263, + ]), + tuple( + np.int64(132), + ): list([ + 264, + 265, + ]), + tuple( + np.int64(133), + ): list([ + 266, + 267, + ]), + tuple( + np.int64(134), + ): list([ + 268, + 269, + ]), + tuple( + np.int64(135), + ): list([ + 270, + 271, + ]), + tuple( + np.int64(136), + ): list([ + 272, + 273, + ]), + tuple( + np.int64(137), + ): list([ + 274, + 275, + ]), + tuple( + np.int64(138), + ): list([ + 276, + 277, + ]), + tuple( + np.int64(139), + ): list([ + 278, + 279, + ]), + tuple( + np.int64(140), + ): list([ + 280, + 281, + ]), + tuple( + np.int64(141), + ): list([ + 282, + 283, + ]), + tuple( + np.int64(142), + ): list([ + 284, + 285, + ]), + tuple( + np.int64(143), + ): list([ + 286, + 287, + ]), + tuple( + np.int64(144), + ): list([ + 288, + 289, + ]), + tuple( + np.int64(145), + ): list([ + 290, + 291, + ]), + tuple( + np.int64(146), + ): list([ + 292, + ]), + }) +# --- +# name: test_snapshot_cohorts[PerfectMonthly] + dict({ + tuple( + np.int64(0), + np.int64(3), + np.int64(6), + np.int64(9), + np.int64(12), + np.int64(15), + np.int64(18), + np.int64(21), + np.int64(24), + np.int64(27), + np.int64(30), + np.int64(33), + np.int64(36), + np.int64(39), + np.int64(42), + np.int64(45), + np.int64(48), + np.int64(51), + np.int64(54), + np.int64(57), + np.int64(60), + np.int64(63), + np.int64(66), + np.int64(69), + np.int64(72), + np.int64(75), + np.int64(78), + np.int64(81), + np.int64(84), + np.int64(87), + np.int64(90), + np.int64(93), + np.int64(96), + np.int64(99), + np.int64(102), + np.int64(105), + np.int64(108), + np.int64(111), + np.int64(114), + np.int64(117), + np.int64(120), + np.int64(123), + np.int64(126), + np.int64(129), + np.int64(132), + np.int64(135), + np.int64(138), + np.int64(141), + np.int64(144), + np.int64(147), + np.int64(150), + np.int64(153), + np.int64(156), + np.int64(159), + np.int64(162), + np.int64(165), + np.int64(168), + np.int64(171), + ): list([ + 0, + 1, + 2, + 3, + ]), + tuple( + np.int64(1), + np.int64(4), + np.int64(7), + np.int64(10), + np.int64(13), + np.int64(16), + np.int64(19), + np.int64(22), + np.int64(25), + np.int64(28), + np.int64(31), + np.int64(34), + np.int64(37), + np.int64(40), + np.int64(43), + np.int64(46), + np.int64(49), + np.int64(52), + np.int64(55), + np.int64(58), + np.int64(61), + np.int64(64), + np.int64(67), + np.int64(70), + np.int64(73), + np.int64(76), + np.int64(79), + np.int64(82), + np.int64(85), + np.int64(88), + np.int64(91), + np.int64(94), + np.int64(97), + np.int64(100), + np.int64(103), + np.int64(106), + np.int64(109), + np.int64(112), + np.int64(115), + np.int64(118), + np.int64(121), + np.int64(124), + np.int64(127), + np.int64(130), + np.int64(133), + np.int64(136), + np.int64(139), + np.int64(142), + np.int64(145), + np.int64(148), + np.int64(151), + np.int64(154), + np.int64(157), + np.int64(160), + np.int64(163), + np.int64(166), + np.int64(169), + np.int64(172), + ): list([ + 4, + 5, + 6, + 7, + ]), + tuple( + np.int64(2), + np.int64(5), + np.int64(8), + np.int64(11), + np.int64(14), + np.int64(17), + np.int64(20), + np.int64(23), + np.int64(26), + np.int64(29), + np.int64(32), + np.int64(35), + np.int64(38), + np.int64(41), + np.int64(44), + np.int64(47), + np.int64(50), + np.int64(53), + np.int64(56), + np.int64(59), + np.int64(62), + np.int64(65), + np.int64(68), + np.int64(71), + np.int64(74), + np.int64(77), + np.int64(80), + np.int64(83), + np.int64(86), + np.int64(89), + np.int64(92), + np.int64(95), + np.int64(98), + np.int64(101), + np.int64(104), + np.int64(107), + np.int64(110), + np.int64(113), + np.int64(116), + np.int64(119), + np.int64(122), + np.int64(125), + np.int64(128), + np.int64(131), + np.int64(134), + np.int64(137), + np.int64(140), + np.int64(143), + np.int64(146), + np.int64(149), + np.int64(152), + np.int64(155), + np.int64(158), + np.int64(161), + np.int64(164), + np.int64(167), + np.int64(170), + np.int64(173), + ): list([ + 8, + 9, + 10, + 11, + ]), + }) +# --- +# name: test_snapshot_cohorts[RandomBigArray] + dict({ + }) +# --- +# name: test_snapshot_cohorts[SingleChunk] + dict({ + tuple( + 0, + ): list([ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 240, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 253, + 254, + 255, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 264, + 265, + 266, + 267, + 268, + 269, + 270, + 271, + 272, + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 280, + 281, + 282, + 283, + 284, + 285, + 286, + 287, + 288, + 289, + 290, + 291, + 292, + ]), + }) +# --- diff --git a/tests/test_cohorts.py b/tests/test_cohorts.py new file mode 100644 index 000000000..2e5526308 --- /dev/null +++ b/tests/test_cohorts.py @@ -0,0 +1,27 @@ +# Snapshot tests for cohorts detection + +import pytest + +from asv_bench.benchmarks import cohorts + + +@pytest.mark.parametrize( + "testcase", + [ + cohorts.ERA5DayOfYear, + cohorts.ERA5Google, + cohorts.ERA5MonthHour, + cohorts.ERA5MonthHourRechunked, + cohorts.OISST, + cohorts.PerfectBlockwiseResampling, + cohorts.PerfectMonthly, + cohorts.RandomBigArray, + cohorts.SingleChunk, + cohorts.NWMMidwest, + ], +) +def test_snapshot_cohorts(testcase, snapshot): + problem = testcase() + problem.setup() + chunks_cohorts = problem.chunks_cohorts() + assert chunks_cohorts == snapshot From d3a7c8e5c780073af689e9c682ee5c1b853bf035 Mon Sep 17 00:00:00 2001 From: Deepak Cherian Date: Thu, 1 Aug 2024 20:35:35 -0600 Subject: [PATCH 02/10] Fix. --- tests/test_cohorts.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/test_cohorts.py b/tests/test_cohorts.py index 2e5526308..ed2992a7d 100644 --- a/tests/test_cohorts.py +++ b/tests/test_cohorts.py @@ -4,7 +4,10 @@ from asv_bench.benchmarks import cohorts +from . import requires_dask + +@requires_dask @pytest.mark.parametrize( "testcase", [ From bd0e064c2fc1ef12a34edb4e39b6e91b57577932 Mon Sep 17 00:00:00 2001 From: Deepak Cherian Date: Thu, 1 Aug 2024 20:48:00 -0600 Subject: [PATCH 03/10] fix again --- tests/test_cohorts.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/tests/test_cohorts.py b/tests/test_cohorts.py index ed2992a7d..c4c50cd99 100644 --- a/tests/test_cohorts.py +++ b/tests/test_cohorts.py @@ -2,12 +2,11 @@ import pytest -from asv_bench.benchmarks import cohorts +pytest.importorskip("dask") -from . import requires_dask +from asv_bench.benchmarks import cohorts -@requires_dask @pytest.mark.parametrize( "testcase", [ From 9be7225a14dad0f96d3e55c95f7e75cffc19fddb Mon Sep 17 00:00:00 2001 From: Deepak Cherian Date: Thu, 1 Aug 2024 20:50:59 -0600 Subject: [PATCH 04/10] Rework CI --- .github/workflows/ci.yaml | 52 +++++++-------------------------------- 1 file changed, 9 insertions(+), 43 deletions(-) diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index f3633fc68..cfbf7f82f 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -25,10 +25,18 @@ jobs: fail-fast: false matrix: os: ["ubuntu-latest"] + env: ["environment"] python-version: ["3.9", "3.12"] include: - os: "windows-latest" + env: "environment" python-version: "3.12" + - os: "ubuntu-latest" + env: "no-dask" # "no-xarray", "no-numba" + python-version: "3.12" + - os: "ubuntu-latest" + env: "minimal-requirements" + python-version: "3.9" steps: - uses: actions/checkout@v4 with: @@ -39,7 +47,7 @@ jobs: - name: Set up conda environment uses: mamba-org/setup-micromamba@v1 with: - environment-file: ci/environment.yml + environment-file: ci/${{ matrix.env }}.yml environment-name: flox-tests init-shell: bash cache-environment: true @@ -81,48 +89,6 @@ jobs: path: .hypothesis/ key: cache-hypothesis-${{ runner.os }}-${{ matrix.python-version }}-${{ github.run_id }} - optional-deps: - name: ${{ matrix.env }} - runs-on: "ubuntu-latest" - defaults: - run: - shell: bash -l {0} - strategy: - fail-fast: false - matrix: - python-version: ["3.12"] - env: ["no-dask"] # "no-xarray", "no-numba" - include: - - env: "minimal-requirements" - python-version: "3.9" - steps: - - uses: actions/checkout@v4 - with: - fetch-depth: 0 # Fetch all history for all branches and tags. - - name: Set up conda environment - uses: mamba-org/setup-micromamba@v1 - with: - environment-file: ci/${{ matrix.env }}.yml - environment-name: flox-tests - init-shell: bash - cache-environment: true - create-args: | - python=${{ matrix.python-version }} - - name: Install flox - run: | - python -m pip install --no-deps -e . - - name: Run tests - run: | - python -m pytest -n auto --cov=./ --cov-report=xml - - name: Upload code coverage to Codecov - uses: codecov/codecov-action@v4.5.0 - with: - file: ./coverage.xml - flags: unittests - env_vars: RUNNER_OS - name: codecov-umbrella - fail_ci_if_error: false - xarray-groupby: name: xarray-groupby runs-on: ubuntu-latest From 7664e5e44a05e0d2c2190024300332b12a18141e Mon Sep 17 00:00:00 2001 From: Deepak Cherian Date: Thu, 1 Aug 2024 20:51:06 -0600 Subject: [PATCH 05/10] [revery] --- .github/workflows/ci.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index cfbf7f82f..0c230f49a 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -70,7 +70,7 @@ jobs: - name: Run Tests id: status run: | - pytest --durations=20 --durations-min=0.5 -n auto --cov=./ --cov-report=xml --hypothesis-profile ci + pytest --durations=20 --durations-min=0.5 -n auto --cov=./ --cov-report=xml --hypothesis-profile ci tests/test_cohorts.py - name: Upload code coverage to Codecov uses: codecov/codecov-action@v4.5.0 with: From a869031433ddf4b5124972dc0f4670d6f5e725bc Mon Sep 17 00:00:00 2001 From: Deepak Cherian Date: Thu, 1 Aug 2024 20:52:19 -0600 Subject: [PATCH 06/10] improve --- .github/workflows/ci.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index 0c230f49a..26f7ca24c 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -16,7 +16,7 @@ concurrency: jobs: test: - name: Test (${{ matrix.python-version }}, ${{ matrix.os }}) + name: Test (${{matrix.env}}, ${{ matrix.python-version }}, ${{ matrix.os }}) runs-on: ${{ matrix.os }} defaults: run: From 283e9be27354b086d9cacfdcbfcfaa781a925087 Mon Sep 17 00:00:00 2001 From: Deepak Cherian Date: Thu, 1 Aug 2024 20:56:37 -0600 Subject: [PATCH 07/10] fix mypy? --- .github/workflows/ci-additional.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci-additional.yaml b/.github/workflows/ci-additional.yaml index 5478c2c57..a248b7c21 100644 --- a/.github/workflows/ci-additional.yaml +++ b/.github/workflows/ci-additional.yaml @@ -128,7 +128,7 @@ jobs: - name: Run mypy run: | - python -m mypy --install-types --non-interactive --cobertura-xml-report mypy_report + python -m mypy --install-types --non-interactive --cache-dir=.mypy_cache/ --cobertura-xml-report mypy_report - name: Upload mypy coverage to Codecov uses: codecov/codecov-action@v4.5.0 From da852a5a48593047c5587200e37e2e18649877bf Mon Sep 17 00:00:00 2001 From: Deepak Cherian Date: Thu, 1 Aug 2024 20:58:24 -0600 Subject: [PATCH 08/10] Revert "[revery]" This reverts commit 7664e5e44a05e0d2c2190024300332b12a18141e. --- .github/workflows/ci.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index 26f7ca24c..04799a78e 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -70,7 +70,7 @@ jobs: - name: Run Tests id: status run: | - pytest --durations=20 --durations-min=0.5 -n auto --cov=./ --cov-report=xml --hypothesis-profile ci tests/test_cohorts.py + pytest --durations=20 --durations-min=0.5 -n auto --cov=./ --cov-report=xml --hypothesis-profile ci - name: Upload code coverage to Codecov uses: codecov/codecov-action@v4.5.0 with: From c8af39de66a7a3908498dce58a40f140c114712b Mon Sep 17 00:00:00 2001 From: Deepak Cherian Date: Thu, 1 Aug 2024 21:02:51 -0600 Subject: [PATCH 09/10] Try again --- .github/workflows/ci-additional.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/ci-additional.yaml b/.github/workflows/ci-additional.yaml index a248b7c21..21baff867 100644 --- a/.github/workflows/ci-additional.yaml +++ b/.github/workflows/ci-additional.yaml @@ -128,6 +128,7 @@ jobs: - name: Run mypy run: | + mkdir .mypy_cache python -m mypy --install-types --non-interactive --cache-dir=.mypy_cache/ --cobertura-xml-report mypy_report - name: Upload mypy coverage to Codecov From f2b79190945a27a8c599b72bb256b10996d0b9a1 Mon Sep 17 00:00:00 2001 From: Deepak Cherian Date: Thu, 1 Aug 2024 21:11:56 -0600 Subject: [PATCH 10/10] fix mypy --- asv_bench/__init__.py | 0 tests/strategies.py | 2 +- 2 files changed, 1 insertion(+), 1 deletion(-) create mode 100644 asv_bench/__init__.py diff --git a/asv_bench/__init__.py b/asv_bench/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/strategies.py b/tests/strategies.py index fcee1c8e2..a2f95da1f 100644 --- a/tests/strategies.py +++ b/tests/strategies.py @@ -101,7 +101,7 @@ def by_arrays( ) -> st.SearchStrategy[np.ndarray[Any, Any]]: if elements is None: elements = {} - elements.setdefault("alphabet", st.characters(exclude_categories=("C",))) + elements.setdefault("alphabet", st.characters(exclude_categories=["C"])) return st.one_of( npst.arrays( dtype=npst.integer_dtypes(endianness="=") | npst.unicode_string_dtypes(endianness="="),