Upload folder using huggingface_hub

ICPC/nwerc2022_A/data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1e1b74bb39283545bc56ef173c41b542756db2623c949b79bfa7618c1aedb4b3
+size 34128131

ICPC/nwerc2022_A/init.yml

@@ -0,0 +1,485 @@
+archive: data.zip
+test_cases:
+- in: 001-all_small_perms.in
+  out: 001-all_small_perms.ans
+  points: 1
+- in: 002-all_small_perms.in
+  out: 002-all_small_perms.ans
+  points: 1
+- in: 003-all_small_perms.in
+  out: 003-all_small_perms.ans
+  points: 1
+- in: 004-all_small_perms.in
+  out: 004-all_small_perms.ans
+  points: 1
+- in: 005-all_small_perms.in
+  out: 005-all_small_perms.ans
+  points: 1
+- in: 006-all_small_perms.in
+  out: 006-all_small_perms.ans
+  points: 1
+- in: 007-all_small_perms.in
+  out: 007-all_small_perms.ans
+  points: 1
+- in: 008-all_small_perms.in
+  out: 008-all_small_perms.ans
+  points: 1
+- in: 009-all_small_perms.in
+  out: 009-all_small_perms.ans
+  points: 1
+- in: 010-all_small_perms.in
+  out: 010-all_small_perms.ans
+  points: 1
+- in: 011-all_small_perms.in
+  out: 011-all_small_perms.ans
+  points: 1
+- in: 012-all_small_perms.in
+  out: 012-all_small_perms.ans
+  points: 1
+- in: 013-all_small_perms.in
+  out: 013-all_small_perms.ans
+  points: 1
+- in: 014-all_small_perms.in
+  out: 014-all_small_perms.ans
+  points: 1
+- in: 015-all_small_perms.in
+  out: 015-all_small_perms.ans
+  points: 1
+- in: 016-all_small_perms.in
+  out: 016-all_small_perms.ans
+  points: 1
+- in: 017-all_small_perms.in
+  out: 017-all_small_perms.ans
+  points: 1
+- in: 018-all_small_perms.in
+  out: 018-all_small_perms.ans
+  points: 1
+- in: 019-all_small_perms.in
+  out: 019-all_small_perms.ans
+  points: 1
+- in: 020-all_small_perms.in
+  out: 020-all_small_perms.ans
+  points: 1
+- in: 021-all_small_perms.in
+  out: 021-all_small_perms.ans
+  points: 1
+- in: 022-all_small_perms.in
+  out: 022-all_small_perms.ans
+  points: 1
+- in: 023-all_small_perms.in
+  out: 023-all_small_perms.ans
+  points: 1
+- in: 024-all_small_perms.in
+  out: 024-all_small_perms.ans
+  points: 1
+- in: 025-all_small_perms.in
+  out: 025-all_small_perms.ans
+  points: 1
+- in: 026-all_small_perms.in
+  out: 026-all_small_perms.ans
+  points: 1
+- in: 027-all_small_perms.in
+  out: 027-all_small_perms.ans
+  points: 1
+- in: 028-all_small_perms.in
+  out: 028-all_small_perms.ans
+  points: 1
+- in: 029-all_small_perms.in
+  out: 029-all_small_perms.ans
+  points: 1
+- in: 030-all_small_perms.in
+  out: 030-all_small_perms.ans
+  points: 1
+- in: 031-all_small_perms.in
+  out: 031-all_small_perms.ans
+  points: 1
+- in: 032-all_small_perms.in
+  out: 032-all_small_perms.ans
+  points: 1
+- in: 033-minimal.in
+  out: 033-minimal.ans
+  points: 1
+- in: 034-minimal.in
+  out: 034-minimal.ans
+  points: 1
+- in: 035-minimal.in
+  out: 035-minimal.ans
+  points: 1
+- in: 036-minimal.in
+  out: 036-minimal.ans
+  points: 1
+- in: 037-random_small.in
+  out: 037-random_small.ans
+  points: 1
+- in: 038-random_small.in
+  out: 038-random_small.ans
+  points: 1
+- in: 039-random_small.in
+  out: 039-random_small.ans
+  points: 1
+- in: 040-random_small.in
+  out: 040-random_small.ans
+  points: 1
+- in: 041-random_small.in
+  out: 041-random_small.ans
+  points: 1
+- in: 042-random_small.in
+  out: 042-random_small.ans
+  points: 1
+- in: 043-random_small.in
+  out: 043-random_small.ans
+  points: 1
+- in: 044-random_small.in
+  out: 044-random_small.ans
+  points: 1
+- in: 045-random_small.in
+  out: 045-random_small.ans
+  points: 1
+- in: 046-random_large.in
+  out: 046-random_large.ans
+  points: 1
+- in: 047-random_large.in
+  out: 047-random_large.ans
+  points: 1
+- in: 048-random_large.in
+  out: 048-random_large.ans
+  points: 1
+- in: 049-random_large.in
+  out: 049-random_large.ans
+  points: 1
+- in: 050-random_large.in
+  out: 050-random_large.ans
+  points: 1
+- in: 051-random_large.in
+  out: 051-random_large.ans
+  points: 1
+- in: 052-random_large.in
+  out: 052-random_large.ans
+  points: 1
+- in: 053-random_large.in
+  out: 053-random_large.ans
+  points: 1
+- in: 054-random_large.in
+  out: 054-random_large.ans
+  points: 1
+- in: 055-random_large.in
+  out: 055-random_large.ans
+  points: 1
+- in: 056-random_large.in
+  out: 056-random_large.ans
+  points: 1
+- in: 057-random_large.in
+  out: 057-random_large.ans
+  points: 1
+- in: 058-random_large.in
+  out: 058-random_large.ans
+  points: 1
+- in: 059-random_large.in
+  out: 059-random_large.ans
+  points: 1
+- in: 060-random_large.in
+  out: 060-random_large.ans
+  points: 1
+- in: 061-binary.in
+  out: 061-binary.ans
+  points: 1
+- in: 062-binary.in
+  out: 062-binary.ans
+  points: 1
+- in: 063-same.in
+  out: 063-same.ans
+  points: 1
+- in: 064-same.in
+  out: 064-same.ans
+  points: 1
+- in: 065-increasing.in
+  out: 065-increasing.ans
+  points: 1
+- in: 066-increasing.in
+  out: 066-increasing.ans
+  points: 1
+- in: 067-decreasing.in
+  out: 067-decreasing.ans
+  points: 1
+- in: 068-decreasing.in
+  out: 068-decreasing.ans
+  points: 1
+- in: 069-small.in
+  out: 069-small.ans
+  points: 1
+- in: 070-small.in
+  out: 070-small.ans
+  points: 1
+- in: 071-small.in
+  out: 071-small.ans
+  points: 1
+- in: 072-small.in
+  out: 072-small.ans
+  points: 1
+- in: 073-small.in
+  out: 073-small.ans
+  points: 1
+- in: 074-small.in
+  out: 074-small.ans
+  points: 1
+- in: 075-small.in
+  out: 075-small.ans
+  points: 1
+- in: 076-small.in
+  out: 076-small.ans
+  points: 1
+- in: 077-small.in
+  out: 077-small.ans
+  points: 1
+- in: 078-small.in
+  out: 078-small.ans
+  points: 1
+- in: 079-small.in
+  out: 079-small.ans
+  points: 1
+- in: 080-small.in
+  out: 080-small.ans
+  points: 1
+- in: 081-small.in
+  out: 081-small.ans
+  points: 1
+- in: 082-small.in
+  out: 082-small.ans
+  points: 1
+- in: 083-small.in
+  out: 083-small.ans
+  points: 1
+- in: 084-small.in
+  out: 084-small.ans
+  points: 1
+- in: 085-small.in
+  out: 085-small.ans
+  points: 1
+- in: 086-small.in
+  out: 086-small.ans
+  points: 1
+- in: 087-small.in
+  out: 087-small.ans
+  points: 1
+- in: 088-binary.in
+  out: 088-binary.ans
+  points: 1
+- in: 089-binary.in
+  out: 089-binary.ans
+  points: 1
+- in: 090-binary.in
+  out: 090-binary.ans
+  points: 1
+- in: 091-binary.in
+  out: 091-binary.ans
+  points: 1
+- in: 092-binary.in
+  out: 092-binary.ans
+  points: 1
+- in: 093-binary.in
+  out: 093-binary.ans
+  points: 1
+- in: 094-one-off.in
+  out: 094-one-off.ans
+  points: 1
+- in: 095-max-dist.in
+  out: 095-max-dist.ans
+  points: 1
+- in: 096-even-cross.in
+  out: 096-even-cross.ans
+  points: 1
+- in: 097-odd-cross.in
+  out: 097-odd-cross.ans
+  points: 1
+- in: 098-max-ans-front-even.in
+  out: 098-max-ans-front-even.ans
+  points: 1
+- in: 099-max-ans-front-odd.in
+  out: 099-max-ans-front-odd.ans
+  points: 1
+- in: 100-max-ans-back-odd.in
+  out: 100-max-ans-back-odd.ans
+  points: 1
+- in: 101-max-ans-back-even.in
+  out: 101-max-ans-back-even.ans
+  points: 1
+- in: 102-slow_descent_small.in
+  out: 102-slow_descent_small.ans
+  points: 1
+- in: 103-slow_descent.in
+  out: 103-slow_descent.ans
+  points: 1
+- in: 104-slow_descent.in
+  out: 104-slow_descent.ans
+  points: 1
+- in: 105-slow_descent.in
+  out: 105-slow_descent.ans
+  points: 1
+- in: 106-slow_descent.in
+  out: 106-slow_descent.ans
+  points: 1
+- in: 107-slow_descent.in
+  out: 107-slow_descent.ans
+  points: 1
+- in: 108-slow_descent.in
+  out: 108-slow_descent.ans
+  points: 1
+- in: 109-slow_descent.in
+  out: 109-slow_descent.ans
+  points: 1
+- in: 110-repeated_slow_descent_small.in
+  out: 110-repeated_slow_descent_small.ans
+  points: 1
+- in: 111-repeated_slow_descent.in
+  out: 111-repeated_slow_descent.ans
+  points: 1
+- in: 112-repeated_slow_descent.in
+  out: 112-repeated_slow_descent.ans
+  points: 1
+- in: 113-repeated_slow_descent.in
+  out: 113-repeated_slow_descent.ans
+  points: 1
+- in: 114-repeated_slow_descent.in
+  out: 114-repeated_slow_descent.ans
+  points: 1
+- in: 115-repeated_slow_descent.in
+  out: 115-repeated_slow_descent.ans
+  points: 1
+- in: 116-repeated_slow_descent.in
+  out: 116-repeated_slow_descent.ans
+  points: 1
+- in: 117-doubling.in
+  out: 117-doubling.ans
+  points: 1
+- in: 118-doubling.in
+  out: 118-doubling.ans
+  points: 1
+- in: 119-doubling.in
+  out: 119-doubling.ans
+  points: 1
+- in: 120-doubling.in
+  out: 120-doubling.ans
+  points: 1
+- in: 121-doubling.in
+  out: 121-doubling.ans
+  points: 1
+- in: 122-doubling.in
+  out: 122-doubling.ans
+  points: 1
+- in: 123-doubling.in
+  out: 123-doubling.ans
+  points: 1
+- in: 124-doubling.in
+  out: 124-doubling.ans
+  points: 1
+- in: 125-doubling.in
+  out: 125-doubling.ans
+  points: 1
+- in: 126-doubling.in
+  out: 126-doubling.ans
+  points: 1
+- in: 127-doubling.in
+  out: 127-doubling.ans
+  points: 1
+- in: 128-doubling.in
+  out: 128-doubling.ans
+  points: 1
+- in: 129-doubling.in
+  out: 129-doubling.ans
+  points: 1
+- in: 130-doubling.in
+  out: 130-doubling.ans
+  points: 1
+- in: 131-doubling.in
+  out: 131-doubling.ans
+  points: 1
+- in: 132-doubling.in
+  out: 132-doubling.ans
+  points: 1
+- in: 133-doubling.in
+  out: 133-doubling.ans
+  points: 1
+- in: 134-doubling.in
+  out: 134-doubling.ans
+  points: 1
+- in: 135-doubling.in
+  out: 135-doubling.ans
+  points: 1
+- in: 136-doubling.in
+  out: 136-doubling.ans
+  points: 1
+- in: 137-doubling.in
+  out: 137-doubling.ans
+  points: 1
+- in: 138-doubling.in
+  out: 138-doubling.ans
+  points: 1
+- in: 139-doubling.in
+  out: 139-doubling.ans
+  points: 1
+- in: 140-doubling.in
+  out: 140-doubling.ans
+  points: 1
+- in: 141-doubling.in
+  out: 141-doubling.ans
+  points: 1
+- in: 142-doubling.in
+  out: 142-doubling.ans
+  points: 1
+- in: 143-doubling.in
+  out: 143-doubling.ans
+  points: 1
+- in: 144-doubling.in
+  out: 144-doubling.ans
+  points: 1
+- in: 145-doubling.in
+  out: 145-doubling.ans
+  points: 1
+- in: 146-doubling.in
+  out: 146-doubling.ans
+  points: 1
+- in: 147-doubling.in
+  out: 147-doubling.ans
+  points: 1
+- in: 148-doubling.in
+  out: 148-doubling.ans
+  points: 1
+- in: 149-doubling-backoff.in
+  out: 149-doubling-backoff.ans
+  points: 1
+- in: 150-doubling-backoff.in
+  out: 150-doubling-backoff.ans
+  points: 1
+- in: 151-doubling-backoff.in
+  out: 151-doubling-backoff.ans
+  points: 1
+- in: 152-doubling-backoff.in
+  out: 152-doubling-backoff.ans
+  points: 1
+- in: 153-doubling-backoff.in
+  out: 153-doubling-backoff.ans
+  points: 1
+- in: 154-doubling-backoff.in
+  out: 154-doubling-backoff.ans
+  points: 1
+- in: 155-doubling-backoff.in
+  out: 155-doubling-backoff.ans
+  points: 1
+- in: 156-doubling-backoff.in
+  out: 156-doubling-backoff.ans
+  points: 1
+- in: 157-doubling-backoff.in
+  out: 157-doubling-backoff.ans
+  points: 1
+- in: 158-doubling-backoff.in
+  out: 158-doubling-backoff.ans
+  points: 1
+- in: 159-doubling-backoff.in
+  out: 159-doubling-backoff.ans
+  points: 1
+- in: 160-doubling-backoff.in
+  out: 160-doubling-backoff.ans
+  points: 1
+- in: 161-doubling-backoff.in
+  out: 161-doubling-backoff.ans
+  points: 1

ICPC/nwerc2022_B/data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0de8718ad75e9b155afd5c28e97b0008d643a918fa2fd1ab338fb538b9924db6
+size 6051

ICPC/nwerc2022_B/init.yml

@@ -0,0 +1,84 @@
+archive: data.zip
+checker:
+  args:
+    precision: 6
+  name: floats
+test_cases:
+- in: 01-min.in
+  out: 01-min.ans
+  points: 1
+- in: 02-max.in
+  out: 02-max.ans
+  points: 1
+- in: 03-max_diff.in
+  out: 03-max_diff.ans
+  points: 1
+- in: 04-max_diff.in
+  out: 04-max_diff.ans
+  points: 1
+- in: 05-close.in
+  out: 05-close.ans
+  points: 1
+- in: 06-close.in
+  out: 06-close.ans
+  points: 1
+- in: 07-close.in
+  out: 07-close.ans
+  points: 1
+- in: 08-close.in
+  out: 08-close.ans
+  points: 1
+- in: 09-close.in
+  out: 09-close.ans
+  points: 1
+- in: 10-close.in
+  out: 10-close.ans
+  points: 1
+- in: 11-manual.in
+  out: 11-manual.ans
+  points: 1
+- in: 12-manual.in
+  out: 12-manual.ans
+  points: 1
+- in: 13-manual.in
+  out: 13-manual.ans
+  points: 1
+- in: 14-manual.in
+  out: 14-manual.ans
+  points: 1
+- in: 15-manual.in
+  out: 15-manual.ans
+  points: 1
+- in: 16-manual.in
+  out: 16-manual.ans
+  points: 1
+- in: 17-manual.in
+  out: 17-manual.ans
+  points: 1
+- in: 18-random.in
+  out: 18-random.ans
+  points: 1
+- in: 19-random.in
+  out: 19-random.ans
+  points: 1
+- in: 20-random.in
+  out: 20-random.ans
+  points: 1
+- in: 21-random.in
+  out: 21-random.ans
+  points: 1
+- in: 22-random.in
+  out: 22-random.ans
+  points: 1
+- in: 23-random.in
+  out: 23-random.ans
+  points: 1
+- in: 24-random.in
+  out: 24-random.ans
+  points: 1
+- in: 25-random.in
+  out: 25-random.ans
+  points: 1
+- in: 26-random.in
+  out: 26-random.ans
+  points: 1

ICPC/nwerc2022_C/data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9fcc1c2ccef8d81e0db764f9628bf1e0dafa1d3edeb69ef2261170ac1d7201ab
+size 7287

ICPC/nwerc2022_C/init.yml

@@ -0,0 +1,102 @@
+archive: data.zip
+checker:
+  args:
+    precision: 6
+  name: floats
+test_cases:
+- in: 01-min-1.in
+  out: 01-min-1.ans
+  points: 1
+- in: 02-min-2.in
+  out: 02-min-2.ans
+  points: 1
+- in: 03-min-3.in
+  out: 03-min-3.ans
+  points: 1
+- in: 04-min-4.in
+  out: 04-min-4.ans
+  points: 1
+- in: 05-max.in
+  out: 05-max.ans
+  points: 1
+- in: 06-small.in
+  out: 06-small.ans
+  points: 1
+- in: 07-exact.in
+  out: 07-exact.ans
+  points: 1
+- in: 08-exact.in
+  out: 08-exact.ans
+  points: 1
+- in: 09-exact.in
+  out: 09-exact.ans
+  points: 1
+- in: 10-exact.in
+  out: 10-exact.ans
+  points: 1
+- in: 11-random.in
+  out: 11-random.ans
+  points: 1
+- in: 12-random.in
+  out: 12-random.ans
+  points: 1
+- in: 13-random.in
+  out: 13-random.ans
+  points: 1
+- in: 14-random.in
+  out: 14-random.ans
+  points: 1
+- in: 15-random.in
+  out: 15-random.ans
+  points: 1
+- in: 16-random.in
+  out: 16-random.ans
+  points: 1
+- in: 17-random.in
+  out: 17-random.ans
+  points: 1
+- in: 18-random.in
+  out: 18-random.ans
+  points: 1
+- in: 19-random.in
+  out: 19-random.ans
+  points: 1
+- in: 20-random.in
+  out: 20-random.ans
+  points: 1
+- in: 21-random.in
+  out: 21-random.ans
+  points: 1
+- in: 22-random.in
+  out: 22-random.ans
+  points: 1
+- in: 23-random.in
+  out: 23-random.ans
+  points: 1
+- in: 24-random.in
+  out: 24-random.ans
+  points: 1
+- in: 25-random.in
+  out: 25-random.ans
+  points: 1
+- in: 26-random.in
+  out: 26-random.ans
+  points: 1
+- in: 27-random.in
+  out: 27-random.ans
+  points: 1
+- in: 28-random.in
+  out: 28-random.ans
+  points: 1
+- in: 29-random.in
+  out: 29-random.ans
+  points: 1
+- in: 30-random.in
+  out: 30-random.ans
+  points: 1
+- in: 31-random.in
+  out: 31-random.ans
+  points: 1
+- in: 32-random.in
+  out: 32-random.ans
+  points: 1

ICPC/nwerc2022_D/data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:067de4df9a960214b3dccb34facbd8b4a88d0d2a08b2635fdc3eff1dae29feea
+size 347341

ICPC/nwerc2022_D/init.yml

@@ -0,0 +1,222 @@
+archive: data.zip
+checker:
+  args:
+    precision: 6
+  name: floats
+test_cases:
+- in: 01-small-X.in
+  out: 01-small-X.ans
+  points: 1
+- in: 02-small-O.in
+  out: 02-small-O.ans
+  points: 1
+- in: 03-small.in
+  out: 03-small.ans
+  points: 1
+- in: 04-small.in
+  out: 04-small.ans
+  points: 1
+- in: 05-small.in
+  out: 05-small.ans
+  points: 1
+- in: 06-row.in
+  out: 06-row.ans
+  points: 1
+- in: 07-col.in
+  out: 07-col.ans
+  points: 1
+- in: 08-medium.in
+  out: 08-medium.ans
+  points: 1
+- in: 09-medium.in
+  out: 09-medium.ans
+  points: 1
+- in: 10-medium.in
+  out: 10-medium.ans
+  points: 1
+- in: 11-large-x.in
+  out: 11-large-x.ans
+  points: 1
+- in: 12-large-few-o.in
+  out: 12-large-few-o.ans
+  points: 1
+- in: 13-large-few-o.in
+  out: 13-large-few-o.ans
+  points: 1
+- in: 14-large-few-o.in
+  out: 14-large-few-o.ans
+  points: 1
+- in: 15-large-equal.in
+  out: 15-large-equal.ans
+  points: 1
+- in: 16-large-many-o.in
+  out: 16-large-many-o.ans
+  points: 1
+- in: 17-large-many-o.in
+  out: 17-large-many-o.ans
+  points: 1
+- in: 18-large-many-o.in
+  out: 18-large-many-o.ans
+  points: 1
+- in: 19-large-o.in
+  out: 19-large-o.ans
+  points: 1
+- in: 20-tall.in
+  out: 20-tall.ans
+  points: 1
+- in: 21-tall.in
+  out: 21-tall.ans
+  points: 1
+- in: 22-tall.in
+  out: 22-tall.ans
+  points: 1
+- in: 23-tall.in
+  out: 23-tall.ans
+  points: 1
+- in: 24-wide.in
+  out: 24-wide.ans
+  points: 1
+- in: 25-wide.in
+  out: 25-wide.ans
+  points: 1
+- in: 26-wide.in
+  out: 26-wide.ans
+  points: 1
+- in: 27-wide.in
+  out: 27-wide.ans
+  points: 1
+- in: 28-large.in
+  out: 28-large.ans
+  points: 1
+- in: 29-large-o.in
+  out: 29-large-o.ans
+  points: 1
+- in: 30-large-x.in
+  out: 30-large-x.ans
+  points: 1
+- in: 31-large-few-o.in
+  out: 31-large-few-o.ans
+  points: 1
+- in: 32-large-many-o.in
+  out: 32-large-many-o.ans
+  points: 1
+- in: 33-max.in
+  out: 33-max.ans
+  points: 1
+- in: 34-max-o.in
+  out: 34-max-o.ans
+  points: 1
+- in: 35-max-x.in
+  out: 35-max-x.ans
+  points: 1
+- in: 36-max-few-o.in
+  out: 36-max-few-o.ans
+  points: 1
+- in: 37-max-many-o.in
+  out: 37-max-many-o.ans
+  points: 1
+- in: 38-diag.in
+  out: 38-diag.ans
+  points: 1
+- in: 39-diag.in
+  out: 39-diag.ans
+  points: 1
+- in: 40-diag.in
+  out: 40-diag.ans
+  points: 1
+- in: 41-diag.in
+  out: 41-diag.ans
+  points: 1
+- in: 42-diag-small.in
+  out: 42-diag-small.ans
+  points: 1
+- in: 43-diag-small.in
+  out: 43-diag-small.ans
+  points: 1
+- in: 44-diag-small.in
+  out: 44-diag-small.ans
+  points: 1
+- in: 45-diag-small.in
+  out: 45-diag-small.ans
+  points: 1
+- in: 46-diag-400.in
+  out: 46-diag-400.ans
+  points: 1
+- in: 47-diag-400.in
+  out: 47-diag-400.ans
+  points: 1
+- in: 48-diag-400.in
+  out: 48-diag-400.ans
+  points: 1
+- in: 49-diag-400.in
+  out: 49-diag-400.ans
+  points: 1
+- in: 50-diag-700.in
+  out: 50-diag-700.ans
+  points: 1
+- in: 51-diag-700.in
+  out: 51-diag-700.ans
+  points: 1
+- in: 52-diag-700.in
+  out: 52-diag-700.ans
+  points: 1
+- in: 53-diag-700.in
+  out: 53-diag-700.ans
+  points: 1
+- in: 54-manual.in
+  out: 54-manual.ans
+  points: 1
+- in: 55-manual.in
+  out: 55-manual.ans
+  points: 1
+- in: 56-manual.in
+  out: 56-manual.ans
+  points: 1
+- in: 57-manual.in
+  out: 57-manual.ans
+  points: 1
+- in: 58-manual.in
+  out: 58-manual.ans
+  points: 1
+- in: 59-manual.in
+  out: 59-manual.ans
+  points: 1
+- in: 60-diag.in
+  out: 60-diag.ans
+  points: 1
+- in: 61-diag.in
+  out: 61-diag.ans
+  points: 1
+- in: 62-diag.in
+  out: 62-diag.ans
+  points: 1
+- in: 63-diag.in
+  out: 63-diag.ans
+  points: 1
+- in: 64-diag.in
+  out: 64-diag.ans
+  points: 1
+- in: 65-corner1.in
+  out: 65-corner1.ans
+  points: 1
+- in: 66-corner2.in
+  out: 66-corner2.ans
+  points: 1
+- in: 67-sidel.in
+  out: 67-sidel.ans
+  points: 1
+- in: 68-sider.in
+  out: 68-sider.ans
+  points: 1
+- in: 69-sideu.in
+  out: 69-sideu.ans
+  points: 1
+- in: 70-sided.in
+  out: 70-sided.ans
+  points: 1
+- in: 71-moon1.in
+  out: 71-moon1.ans
+  points: 1
+- in: 72-moon2.in
+  out: 72-moon2.ans
+  points: 1

ICPC/nwerc2022_E/data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:931f1f2c289de53af9c2c4f82799bb43e88e4985ec051891224c306ffe111a88
+size 115467

ICPC/nwerc2022_E/init.yml

@@ -0,0 +1,319 @@
+archive: data.zip
+checker:
+  args:
+    files:
+    - output_validators/output_validator/output_validator.cpp
+    - output_validators/output_validator/validation.h
+    lang: CPP17
+    type: default
+  name: bridged
+test_cases:
+- in: 001-kill-denominator.in
+  out: 001-kill-denominator.ans
+  points: 1
+- in: 002-kill-denominator.in
+  out: 002-kill-denominator.ans
+  points: 1
+- in: 003-kill-denominator.in
+  out: 003-kill-denominator.ans
+  points: 1
+- in: 004-minimal-input.in
+  out: 004-minimal-input.ans
+  points: 1
+- in: 005-minimal-ab.in
+  out: 005-minimal-ab.ans
+  points: 1
+- in: 006-maximal-input.in
+  out: 006-maximal-input.ans
+  points: 1
+- in: 007-maximal-input.in
+  out: 007-maximal-input.ans
+  points: 1
+- in: 008-maximal-ab.in
+  out: 008-maximal-ab.ans
+  points: 1
+- in: 009-maximal-not-int.in
+  out: 009-maximal-not-int.ans
+  points: 1
+- in: 010-maximal-not-int.in
+  out: 010-maximal-not-int.ans
+  points: 1
+- in: 011-manual-tricky.in
+  out: 011-manual-tricky.ans
+  points: 1
+- in: 012-manual-tricky.in
+  out: 012-manual-tricky.ans
+  points: 1
+- in: 013-manual-tricky.in
+  out: 013-manual-tricky.ans
+  points: 1
+- in: 014-just-impossible.in
+  out: 014-just-impossible.ans
+  points: 1
+- in: 015-just-impossible.in
+  out: 015-just-impossible.ans
+  points: 1
+- in: 016-just-impossible.in
+  out: 016-just-impossible.ans
+  points: 1
+- in: 017-manual-half.in
+  out: 017-manual-half.ans
+  points: 1
+- in: 018-manual-half.in
+  out: 018-manual-half.ans
+  points: 1
+- in: 019-manual-half.in
+  out: 019-manual-half.ans
+  points: 1
+- in: 020-manual-two.in
+  out: 020-manual-two.ans
+  points: 1
+- in: 021-manual-two.in
+  out: 021-manual-two.ans
+  points: 1
+- in: 022-manual-two.in
+  out: 022-manual-two.ans
+  points: 1
+- in: 023-manual-two.in
+  out: 023-manual-two.ans
+  points: 1
+- in: 024-manual-two.in
+  out: 024-manual-two.ans
+  points: 1
+- in: 025-manual-two.in
+  out: 025-manual-two.ans
+  points: 1
+- in: 026-manual-two.in
+  out: 026-manual-two.ans
+  points: 1
+- in: 027-manual-three.in
+  out: 027-manual-three.ans
+  points: 1
+- in: 028-manual-three.in
+  out: 028-manual-three.ans
+  points: 1
+- in: 029-manual-three.in
+  out: 029-manual-three.ans
+  points: 1
+- in: 030-manual-three.in
+  out: 030-manual-three.ans
+  points: 1
+- in: 031-manual-three.in
+  out: 031-manual-three.ans
+  points: 1
+- in: 032-manual-triangular.in
+  out: 032-manual-triangular.ans
+  points: 1
+- in: 033-manual-triangular.in
+  out: 033-manual-triangular.ans
+  points: 1
+- in: 034-manual-triangular.in
+  out: 034-manual-triangular.ans
+  points: 1
+- in: 035-manual-triangular.in
+  out: 035-manual-triangular.ans
+  points: 1
+- in: 036-manual-triangular.in
+  out: 036-manual-triangular.ans
+  points: 1
+- in: 037-manual-triangular.in
+  out: 037-manual-triangular.ans
+  points: 1
+- in: 038-manual-triangular.in
+  out: 038-manual-triangular.ans
+  points: 1
+- in: 039-manual-triangular.in
+  out: 039-manual-triangular.ans
+  points: 1
+- in: 040-manual-triangular.in
+  out: 040-manual-triangular.ans
+  points: 1
+- in: 041-manual-triangular.in
+  out: 041-manual-triangular.ans
+  points: 1
+- in: 042-manual-triangular.in
+  out: 042-manual-triangular.ans
+  points: 1
+- in: 043-manual-triangular.in
+  out: 043-manual-triangular.ans
+  points: 1
+- in: 044-manual-triangular.in
+  out: 044-manual-triangular.ans
+  points: 1
+- in: 045-manual-triangular.in
+  out: 045-manual-triangular.ans
+  points: 1
+- in: 046-manual-triangular.in
+  out: 046-manual-triangular.ans
+  points: 1
+- in: 047-manual-triangular.in
+  out: 047-manual-triangular.ans
+  points: 1
+- in: 048-manual-triangular.in
+  out: 048-manual-triangular.ans
+  points: 1
+- in: 049-manual-triangular.in
+  out: 049-manual-triangular.ans
+  points: 1
+- in: 050-manual-triangular.in
+  out: 050-manual-triangular.ans
+  points: 1
+- in: 051-manual-triangular.in
+  out: 051-manual-triangular.ans
+  points: 1
+- in: 052-manual-power.in
+  out: 052-manual-power.ans
+  points: 1
+- in: 053-manual-power.in
+  out: 053-manual-power.ans
+  points: 1
+- in: 054-manual-power.in
+  out: 054-manual-power.ans
+  points: 1
+- in: 055-impossible.in
+  out: 055-impossible.ans
+  points: 1
+- in: 056-impossible.in
+  out: 056-impossible.ans
+  points: 1
+- in: 057-impossible.in
+  out: 057-impossible.ans
+  points: 1
+- in: 058-impossible.in
+  out: 058-impossible.ans
+  points: 1
+- in: 059-impossible.in
+  out: 059-impossible.ans
+  points: 1
+- in: 060-impossible.in
+  out: 060-impossible.ans
+  points: 1
+- in: 061-impossible.in
+  out: 061-impossible.ans
+  points: 1
+- in: 062-impossible.in
+  out: 062-impossible.ans
+  points: 1
+- in: 063-impossible.in
+  out: 063-impossible.ans
+  points: 1
+- in: 064-impossible.in
+  out: 064-impossible.ans
+  points: 1
+- in: 065-just-possible.in
+  out: 065-just-possible.ans
+  points: 1
+- in: 066-just-possible.in
+  out: 066-just-possible.ans
+  points: 1
+- in: 067-just-possible.in
+  out: 067-just-possible.ans
+  points: 1
+- in: 068-just-possible.in
+  out: 068-just-possible.ans
+  points: 1
+- in: 069-just-possible.in
+  out: 069-just-possible.ans
+  points: 1
+- in: 070-just-possible.in
+  out: 070-just-possible.ans
+  points: 1
+- in: 071-just-possible.in
+  out: 071-just-possible.ans
+  points: 1
+- in: 072-just-possible.in
+  out: 072-just-possible.ans
+  points: 1
+- in: 073-just-possible.in
+  out: 073-just-possible.ans
+  points: 1
+- in: 074-just-possible.in
+  out: 074-just-possible.ans
+  points: 1
+- in: 075-random.in
+  out: 075-random.ans
+  points: 1
+- in: 076-random.in
+  out: 076-random.ans
+  points: 1
+- in: 077-random.in
+  out: 077-random.ans
+  points: 1
+- in: 078-random.in
+  out: 078-random.ans
+  points: 1
+- in: 079-random.in
+  out: 079-random.ans
+  points: 1
+- in: 080-random.in
+  out: 080-random.ans
+  points: 1
+- in: 081-random.in
+  out: 081-random.ans
+  points: 1
+- in: 082-random.in
+  out: 082-random.ans
+  points: 1
+- in: 083-random.in
+  out: 083-random.ans
+  points: 1
+- in: 084-random.in
+  out: 084-random.ans
+  points: 1
+- in: 085-random.in
+  out: 085-random.ans
+  points: 1
+- in: 086-random.in
+  out: 086-random.ans
+  points: 1
+- in: 087-random.in
+  out: 087-random.ans
+  points: 1
+- in: 088-random.in
+  out: 088-random.ans
+  points: 1
+- in: 089-random.in
+  out: 089-random.ans
+  points: 1
+- in: 090-random.in
+  out: 090-random.ans
+  points: 1
+- in: 091-random.in
+  out: 091-random.ans
+  points: 1
+- in: 092-random.in
+  out: 092-random.ans
+  points: 1
+- in: 093-random.in
+  out: 093-random.ans
+  points: 1
+- in: 094-large.in
+  out: 094-large.ans
+  points: 1
+- in: 095-large.in
+  out: 095-large.ans
+  points: 1
+- in: 096-large.in
+  out: 096-large.ans
+  points: 1
+- in: 097-large.in
+  out: 097-large.ans
+  points: 1
+- in: 098-large.in
+  out: 098-large.ans
+  points: 1
+- in: 099-large.in
+  out: 099-large.ans
+  points: 1
+- in: 100-large.in
+  out: 100-large.ans
+  points: 1
+- in: 101-large.in
+  out: 101-large.ans
+  points: 1
+- in: 102-large.in
+  out: 102-large.ans
+  points: 1
+- in: 103-large.in
+  out: 103-large.ans
+  points: 1

ICPC/nwerc2022_E/output_validators/output_validator/output_validator.cpp

@@ -0,0 +1,86 @@
+
+#include<cstdlib>
+int qwerty_getcode(int code) {
+    return code == 42? 0: 1;
+}
+namespace std {
+    void qwerty_exit(int code){
+        exit(qwerty_getcode(code));
+    }
+} using std::qwerty_exit;
+#define exit qwerty_exit
+#define main qwerty_main
+#include "validation.h"
+using std::vector;
+using std::string;
+
+// Output: a list of `n` page flips from `i` to `j`.
+
+int main(int argc, char **argv) {
+    // Set up the input and answer streams.
+    std::ifstream in(argv[1]);
+    std::ifstream ans(argv[2]); // Only for custom checker.
+    OutputValidator v(argc, argv);
+
+    long long a,b;
+    char c;
+    in >> a >> c >> b;
+    string s;
+    ans >> s;
+    if (s == "impossible"){
+        v.test_string("impossible");
+        v.newline();
+    }
+    else {
+        long long n = v.read_integer("n",1,1e6);
+        v.space();
+        long long m = v.read_integer("m",1,1e6);
+        v.newline();
+        vector<vector<long long>> graph(n+1,vector<long long>{});
+        for (long long i=0;i<m;i++){
+            long long x = v.read_integer("x", 1, n);
+            v.space();
+            long long y = v.read_integer("x", 1, n);
+            v.newline();
+            graph[x].push_back(y);
+            graph[y].push_back(x);
+        }
+        long long total = 0;
+        vector<bool> visited(n+1);
+        vector<long long> queue_out, queue_in;
+        long long distance = 0;
+        queue_out.push_back(1);
+        while (queue_out.size() > 0){
+            for (long long i : queue_out){
+                if (visited[i])
+                    continue;
+                total += distance;
+                visited[i] = true;
+                for (long long j : graph[i])
+                    queue_in.push_back(j);
+            }
+            queue_out = queue_in;
+            queue_in = {};
+            distance += 1;
+        }
+        for (long long i=1;i<=n;i++) v.check(visited[i], "Graph not connected, vertex ", i, " unreachable");
+        std::cerr << total << '/' << n << std::endl;
+        v.check(a*n == total*b, "Wrong average distance, got ", total, "/", n, ", wanted ", a, "/", b);
+    }
+}
+
+#undef main
+#include<cstdio>
+#include<vector>
+#include<string>
+#include<filesystem>
+int main(int argc, char **argv) {
+	namespace fs = std::filesystem;
+    freopen(argv[2], "r", stdin);
+    char judge_out[] = "/dev";
+    std::vector<char*> new_argv = {
+		argv[0], argv[1], argv[3],
+		judge_out,
+	};
+	return qwerty_getcode(qwerty_main((int)new_argv.size(), new_argv.data()));
+}

ICPC/nwerc2022_E/output_validators/output_validator/validation.h

@@ -0,0 +1,1520 @@
+#pragma once
+// A header library to safely parse team input.
+// It does not support floating points or big integers.
+// Author: Ragnar Groot Koerkamp
+
+// The easiest way to use this is to symlink it from a validator directory,
+// so that it will be picked up when creating a contest zip.
+
+// The default checking behaviour is lenient for both white space and case.
+// When validating .in and .ans files, the case_sensitive and
+// space_change_sensitive flags should be passed. When validating team output,
+// the flags in problem.yaml should be used.
+
+// Compile with -Duse_source_location to enable
+// std::experimental::source_location. This is needed for constraints checking.
+
+#include <algorithm>
+#include <array>
+#include <bitset>
+#include <cassert>
+#include <charconv>
+#include <cstring>
+#include <fstream>
+#include <functional>
+#include <iomanip>
+#include <iostream>
+#include <limits>
+#include <map>
+#include <optional>
+#include <random>
+#include <set>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+#include <variant>
+#include <vector>
+
+#ifdef use_source_location
+#include <experimental/source_location>
+constexpr bool has_source_location = true;
+using std::experimental::source_location;
+namespace std {
+bool operator<(const source_location& l, const source_location& r) {
+	return l.line() < r.line();
+}
+} // namespace std
+namespace std::experimental::fundamentals_v2 {
+bool operator<(const source_location& l, const source_location& r) {
+	return l.line() < r.line();
+}
+} // namespace std::experimental::fundamentals_v2
+#else
+constexpr bool has_source_location = false;
+struct source_location {
+	static source_location current() { return {}; }
+	[[nodiscard]] int line() const { return 0; }               // NOLINT
+	[[nodiscard]] std::string file_name() const { return ""; } // NOLINT
+};
+inline bool operator<(const source_location& l, const source_location& r) {
+	return l.line() < r.line();
+}
+#endif
+
+inline std::string location_to_string(source_location loc) {
+	return std::string(loc.file_name()) + ":" + std::to_string(loc.line());
+}
+
+const std::string_view case_sensitive_flag       = "case_sensitive";
+const std::string_view ws_sensitive_flag         = "space_change_sensitive";
+const std::string_view constraints_file_flag     = "--constraints_file";
+const std::string_view generate_flag             = "--generate";
+const std::string_view generate_binary_substring = "generat";
+
+inline struct ArbitraryTag {
+	static constexpr bool unique     = false;
+	static constexpr bool strict     = false;
+	static constexpr bool increasing = false;
+	static constexpr bool decreasing = false;
+} Arbitrary;
+inline struct UniqueTag : ArbitraryTag {
+	static constexpr bool unique     = true;
+	static constexpr bool strict     = false;
+	static constexpr bool increasing = false;
+	static constexpr bool decreasing = false;
+} Unique;
+inline struct IncreasingTag : ArbitraryTag { static constexpr bool increasing = true; } Increasing;
+inline struct DecreasingTag : ArbitraryTag { static constexpr bool decreasing = true; } Decreasing;
+inline struct StrictlyIncreasingTag : ArbitraryTag {
+	static constexpr bool strict     = true;
+	static constexpr bool increasing = true;
+} StrictlyIncreasing;
+inline struct StrictlyDecreasingTag : ArbitraryTag {
+	static constexpr bool strict     = true;
+	static constexpr bool decreasing = true;
+} StrictlyDecreasing;
+
+template <typename... T>
+struct Merge : T... {
+	static constexpr bool unique     = (T::unique || ...);
+	static constexpr bool strict     = (T::strict || ...);
+	static constexpr bool increasing = (T::increasing || ...);
+	static constexpr bool decreasing = (T::decreasing || ...);
+};
+
+template <typename T1, typename T2,
+          std::enable_if_t<
+              std::is_base_of_v<ArbitraryTag, T1> and std::is_base_of_v<ArbitraryTag, T2>, int> = 0>
+auto operator|(T1 /*unused*/, T2 /*unused*/) {
+	return Merge<T1, T2>();
+}
+
+enum Separator { Space, Newline };
+
+// this contains some specific code which emulates c++20 features
+namespace cpp20 {
+
+constexpr int countl_zero(unsigned long long x) {
+	int res = 64;
+	for(int i = 32; i > 0; i >>= 1) {
+		if((x >> i) > 0) {
+			res -= i;
+			x >>= i;
+		}
+	}
+	if(x > 0) res--;
+	return res;
+}
+
+int popcount(unsigned long long x) {
+	return static_cast<int>(std::bitset<64>(x).count());
+}
+
+constexpr long double PI = 3.141592653589793238462643383279502884l;
+
+} // namespace cpp20
+
+namespace Random {
+
+constexpr unsigned int default_seed = 3141592653; // some digits of PI
+
+unsigned long long bits64(std::mt19937_64& rng) {
+	static_assert(std::mt19937_64::max() == 0xFFFF'FFFF'FFFF'FFFFull);
+	static_assert(std::mt19937_64::min() == 0ull);
+	return rng();
+}
+
+// generates a uniform real in [0, 1)
+long double real64(std::mt19937_64& rng) {
+	// a long double can represent more than 2^64 values in the range [0, 1)...
+	// another problem is that real64() < 1.0/3.0 is technically biased.
+	long double res = bits64(rng) / 0x1.0p64l;
+	res += bits64(rng) / 0x1.0p128l;
+	assert(res < 1.0l);
+	return res;
+}
+
+bool bit(std::mt19937_64& rng) {
+	return cpp20::popcount(bits64(rng)) & 1;
+}
+
+} // namespace Random
+
+template <typename T>
+constexpr bool is_number_v = std::is_same_v<T, long long> or std::is_same_v<T, long double>;
+
+namespace Generators {
+
+template <typename T>
+struct ConstGenerator {
+	static_assert(is_number_v<T> or std::is_same_v<T, char> or std::is_same_v<T, std::string>);
+	static constexpr std::string_view name = "const";
+	using Args                             = std::tuple<T>;
+
+	const T const_;
+
+	explicit ConstGenerator(T val) : const_(std::move(val)) {}
+
+	// For char and string, the constant store has a different type than the min and max length
+	// passed in.
+	template <typename U>
+	T operator()(U low, U high, std::mt19937_64& rng) const {
+		return std::clamp(const_, low, high);
+	}
+};
+
+struct MinGenerator {
+	static constexpr std::string_view name = "min";
+	using Args                             = std::tuple<>;
+
+	explicit MinGenerator() = default;
+
+	template <typename T>
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		static_assert(is_number_v<T>);
+		return low;
+	}
+};
+
+struct MaxGenerator {
+	static constexpr std::string_view name = "max";
+	using Args                             = std::tuple<>;
+
+	explicit MaxGenerator() = default;
+
+	template <typename T>
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		static_assert(is_number_v<T>);
+		return high;
+	}
+};
+
+struct UniformGenerator {
+	static constexpr std::string_view name = "uniform";
+	using Args                             = std::tuple<>;
+
+	explicit UniformGenerator() = default;
+
+	template <typename T>
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		static_assert(is_number_v<T>);
+		if(low == high) return low;
+
+		if constexpr(std::is_same_v<T, long long>) {
+			assert(low < high);
+			// Since C++20 we can assume Two's Complement but any sane system used it before anyway.
+			// Rejection sampling is not as fast as possible but definitely unbiased.
+			auto ul    = static_cast<unsigned long long>(low);
+			auto uh    = static_cast<unsigned long long>(high);
+			int shifts = cpp20::countl_zero(uh - ul);
+			unsigned long long res;
+			do {
+				res = Random::bits64(rng) >> shifts;
+			} while(res > uh - ul);
+			return static_cast<long long>(res + ul);
+		} else {
+			assert(low < high);
+			return low + Random::real64(rng) * (high - low);
+		}
+	}
+};
+
+template <typename T>
+struct RangeGenerator {
+	static_assert(is_number_v<T>);
+	static constexpr std::string_view name = "range";
+	using Args                             = std::tuple<T, T>;
+
+	const T low_, high_;
+
+	explicit RangeGenerator(T low, T high) : low_(low), high_(high) {}
+
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		return UniformGenerator()(std::max(low, low_), std::min(high, high_), rng);
+	}
+};
+
+template <typename T>
+struct StepRangeGenerator {
+	static_assert(is_number_v<T>);
+	static constexpr std::string_view name = "steprange";
+	using Args                             = std::tuple<T, T, T>;
+
+	const T low_, high_, step_;
+
+	explicit StepRangeGenerator(T low, T high, T step) : low_(low), high_(high), step_(step) {}
+
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		// round up low to the first multiple of step_.
+		T start;
+		if(low <= low_) {
+			start = low_;
+		} else {
+			// first multiple of low_+k*step_ >= low
+			start = low_ + (long long)((low - low_) / step_) * step_;
+			if(start < low) start += step_;
+			assert(low <= start && start < low + step_);
+		}
+		long long maxsteps = (std::min(high, high_) - start) / step_;
+		long long steps    = UniformGenerator()(0ll, maxsteps, rng);
+		return start + steps * step_;
+	}
+};
+
+struct NormalDistributionGenerator {
+	static constexpr std::string_view name = "normal";
+	using T                                = long double;
+	using Args                             = std::tuple<T, T>;
+
+	const T mean_, stddev_;
+
+	explicit NormalDistributionGenerator(T mean, T stddev) : mean_(mean), stddev_(stddev) {
+		assert(stddev_ >= 0);
+	}
+
+	// NOTE: Currently this retries instead of clamping to the interval.
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		assert(low < high);
+		T v;
+		while(true) {
+			T u1 = Random::real64(rng);
+			T u2 = Random::real64(rng);
+			// Box-Muller-Methode
+			// https://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform
+			v = std::sqrt(-2.0l * std::log(u1)) * std::cos(2.0l * cpp20::PI * u2);
+			v = std::sqrt(stddev_) * v + mean_;
+			if(v >= low && v < high) return v;
+			v = std::sqrt(-2.0l * std::log(u1)) * std::sin(2.0l * cpp20::PI * u2);
+			v = std::sqrt(stddev_) * v + mean_;
+			if(v >= low && v < high) return v;
+		}
+		return v;
+	}
+};
+
+struct ExponentialDistributionGenerator {
+	static constexpr std::string_view name = "exponential";
+	using T                                = long double;
+	using Args                             = std::tuple<T>;
+
+	T lambda_;
+
+	explicit ExponentialDistributionGenerator(T lambda) : lambda_(lambda) { assert(lambda_ > 0); }
+
+	// NOTE: Currently this retries instead of clamping to the interval.
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		assert(low < high);
+		T v;
+		while(true) {
+			v = low - std::log(Random::real64(rng)) / lambda_;
+			if(v < high) return v;
+		}
+	}
+};
+
+struct GeometricDistributionGenerator {
+	static constexpr std::string_view name = "geometric";
+	using T                                = long long;
+	using Args                             = std::tuple<long double>;
+
+	double p_;
+
+	explicit GeometricDistributionGenerator(double p) : p_(p) {
+		assert(p_ > 0);
+		assert(p_ < 1);
+	}
+
+	// NOTE: Currently this retries instead of clamping to the interval.
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		assert(low <= high);
+		T v;
+		while(true) {
+			// https://en.wikipedia.org/wiki/Geometric_distribution
+			// "The exponential distribution is the continuous analogue of the geometric
+			// distribution[...]"
+			v = low + std::floor(std::log(Random::real64(rng)) / std::log1p(-p_));
+			if(v <= high) return v;
+		}
+	}
+};
+
+struct BinomialDistributionGenerator {
+	static constexpr std::string_view name = "binomial";
+	using T                                = long long;
+	using Args                             = std::tuple<long long, long double>;
+
+	long long n_;
+	double p_;
+
+	explicit BinomialDistributionGenerator(long long n, double p) : n_(n), p_(p) {
+		assert(p_ >= 0);
+		assert(p_ <= 1);
+		std::cerr << "Warning: Large n (" << n_ << ") is slow for BinomialDistributionGenerator!"
+		          << std::endl;
+	}
+
+	// NOTE: Currently this retries instead of clamping to the interval.
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		assert(low <= high);
+		// this will be slow for large n
+		// (a faster implementation requires efficient poisson sampling)
+		while(true) {
+			T v = 0;
+			for(long long i = 0; i < n_; i++) {
+				v += Random::real64(rng) < p_ ? 1 : 0;
+			}
+			if(v >= low && v <= high) return v;
+		}
+	}
+};
+
+template <typename T>
+struct ChoiceGenerator {
+	using GeneratorType = std::conditional_t<
+	    std::is_same_v<T, long long>,
+	    std::variant<ConstGenerator<T>, MinGenerator, MaxGenerator, UniformGenerator,
+	                 RangeGenerator<T>, StepRangeGenerator<T>, GeometricDistributionGenerator,
+	                 BinomialDistributionGenerator>,
+	    std::variant<ConstGenerator<T>, MinGenerator, MaxGenerator, UniformGenerator,
+	                 RangeGenerator<T>, StepRangeGenerator<T>, NormalDistributionGenerator,
+	                 ExponentialDistributionGenerator>>;
+
+	std::vector<std::pair<GeneratorType, double>> generators_;
+	double total_weight_;
+
+	template <typename>
+	struct Pack {};
+
+	template <typename A>
+	static A parse_number(std::string_view s) {
+		static_assert(is_number_v<A>);
+		if constexpr(std::is_same_v<A, long long>)
+			return stoll(std::string(s));
+		else
+			return stold(std::string(s));
+	}
+
+	template <typename A>
+	static A parse_argument(std::string_view& s) {
+		auto end = s.find_first_of(",)");
+		assert(end != std::string_view::npos);
+		auto v = parse_number<A>(s.substr(0, end));
+		s.remove_prefix(end);
+		// Pop the trailing , or )
+		s.remove_prefix(1);
+		return v;
+	}
+
+	template <typename... As>
+	static std::tuple<As...> parse_arguments(std::string_view& s,
+	                                         Pack<std::tuple<As...>> /*unused*/) {
+		std::tuple<As...> args{parse_argument<As>(s)...};
+		return args;
+	}
+
+	// Try parsing one generator type from the start of s.
+	template <typename G>
+	static void parse_generator(std::string_view& s, std::optional<GeneratorType>& out) {
+		if(out) return;
+		if(s.substr(0, G::name.size()) != G::name) return;
+
+		// Drop the name.
+		s.remove_prefix(G::name.size());
+		if constexpr(std::tuple_size_v<typename G::Args> == 0) {
+			out.emplace(std::in_place_type_t<G>{});
+			return;
+		}
+
+		// Drop the (
+		assert(not s.empty() and s.front() == '(');
+		s.remove_prefix(1);
+
+		auto args = parse_arguments(s, Pack<typename G::Args>{});
+		// Construct the resulting generator in-place in the variant..
+		std::apply([&](const auto&... _args) { out.emplace(std::in_place_type_t<G>{}, _args...); },
+		           args);
+	}
+
+	template <typename... Gs>
+	static std::optional<GeneratorType> parse_generators(std::string_view& s,
+	                                                     Pack<std::variant<Gs...>> /*unused*/) {
+		std::optional<GeneratorType> out;
+		(parse_generator<Gs>(s, out), ...);
+		return out;
+	}
+
+	explicit ChoiceGenerator(std::string_view s) : total_weight_(0) {
+		// PARSE
+		while(not s.empty()) {
+			auto generator = parse_generators(s, Pack<GeneratorType>{});
+			if(!generator) {
+				// Check for range syntax:
+				auto comma = s.find_first_of(",:");
+				if(comma == std::string::npos) comma = s.size();
+				auto dots = s.find("..");
+				if(dots != std::string_view::npos and dots < comma) {
+					auto start = s.substr(0, dots);
+					auto end   = s.substr(dots + 2, comma - dots - 2);
+
+					generator.emplace(std::in_place_type_t<RangeGenerator<T>>{},
+					                  parse_number<T>(start), parse_number<T>(end));
+					s.remove_prefix(comma);
+				}
+
+				// Fall back to constant.
+				if(!generator) {
+					generator.emplace(std::in_place_type_t<ConstGenerator<T>>{},
+					                  parse_number<T>(s.substr(0, comma)));
+					s.remove_prefix(comma);
+				}
+			}
+
+			// Parse weight if given.
+			double weight = 1;
+			if(not s.empty() and s.front() == ':') {
+				s.remove_prefix(1);
+				auto comma = s.find(',');
+				if(comma == std::string_view::npos) comma = s.size();
+				weight = parse_number<long double>(s.substr(0, comma));
+				s.remove_prefix(comma);
+			}
+
+			// should now be at , or end
+			assert(s.empty() or s.front() == ',');
+			if(not s.empty()) s.remove_prefix(1);
+			generators_.emplace_back(std::move(*generator), weight);
+			total_weight_ += weight;
+		}
+	}
+
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		Generators::UniformGenerator uniform;
+		double x = uniform.operator()<long double>(0, total_weight_, rng);
+		for(size_t i = 0; i < generators_.size(); ++i) {
+			x -= generators_[i].second;
+			if(x <= 0)
+				return std::visit([&](auto& g) { return g(low, high, rng); }, generators_[i].first);
+		}
+		assert(false);
+	}
+};
+
+struct ParamGenerator {
+	std::variant<std::string_view, ChoiceGenerator<long long>, ChoiceGenerator<long double>>
+	    generator;
+	explicit ParamGenerator(std::string_view s) : generator(s) {}
+
+	template <typename T>
+	T operator()(T low, T high, std::mt19937_64& rng) {
+		static_assert(is_number_v<T>);
+		if(std::holds_alternative<std::string_view>(generator)) {
+			generator = ChoiceGenerator<T>(std::get<std::string_view>(generator));
+		}
+		return std::get<ChoiceGenerator<T>>(generator)(low, high, rng);
+	}
+};
+
+} // namespace Generators
+
+using Generators::ParamGenerator;
+
+namespace Random {
+template <class RandomIt>
+void shuffle(RandomIt first, RandomIt last, std::mt19937_64& rng) {
+	Generators::UniformGenerator uniform;
+	long long n = last - first;
+	for(long long i = n - 1; i > 0; i--) {
+		std::swap(first[i], first[uniform(0ll, i, rng)]);
+	}
+}
+
+template <class T>
+void shuffle(std::pair<T, T>& in, std::mt19937_64& rng) {
+	if(bit(rng)) std::swap(in.first, in.second);
+}
+
+template <class RandomIt>
+auto& select(RandomIt first, RandomIt last, std::mt19937_64& rng) {
+	assert(first != last);
+	Generators::UniformGenerator uniform;
+	long long n = last - first;
+	return first[uniform(0ll, n - 1, rng)];
+}
+
+template <class T>
+const T& select(const std::pair<T, T>& in, std::mt19937_64& rng) {
+	return bit(rng) ? in.first : in.second;
+}
+
+template <class T>
+T& select(std::pair<T, T>& in, std::mt19937_64& rng) {
+	return bit(rng) ? in.first : in.second;
+}
+
+} // namespace Random
+
+class Validator {
+  protected:
+	Validator(bool ws_, bool case_, std::istream& in_, std::string constraints_file_path_ = "",
+	          std::optional<unsigned int> seed                        = std::nullopt,
+	          std::unordered_map<std::string, ParamGenerator> params_ = {})
+	    : in(in_), ws(ws_), case_sensitive(case_),
+	      constraints_file_path(std::move(constraints_file_path_)), gen(seed.has_value()),
+	      rng(seed.value_or(Random::default_seed)), params(std::move(params_)) {
+
+		std::ios_base::sync_with_stdio(false);
+		in.tie(nullptr);
+
+		if(gen) return;
+		if(ws)
+			in >> std::noskipws;
+		else
+			in >> std::skipws;
+
+		if(!constraints_file_path.empty()) {
+			assert(has_source_location); // NOLINT
+		}
+	}
+
+  public:
+	// No copying, no moving.
+	Validator(const Validator&) = delete;
+	Validator(Validator&&)      = delete;
+	void operator=(const Validator&) = delete;
+	void operator=(Validator&&) = delete;
+
+	// At the end of the scope, check whether the EOF has been reached.
+	// If so, return AC. Otherwise, return WA.
+	~Validator() {
+		eof();
+		write_constraints();
+		AC();
+	}
+
+	void space() {
+		if(gen) {
+			out << ' ';
+			return;
+		}
+
+		if(ws) {
+			char c;
+			in >> c;
+			check(!in.eof(), "Expected space, found EOF.");
+			if(c != ' ')
+				expected("space", std::string("\"") +
+				                      ((c == '\n' or c == '\r') ? std::string("newline")
+				                                                : std::string(1, c)) +
+				                      "\"");
+		}
+	}
+
+	void newline() {
+		if(gen) {
+			out << '\n';
+			return;
+		}
+
+		if(ws) {
+			char c;
+			in >> c;
+			check(!in.eof(), "Expected newline, found EOF.");
+			if(c != '\n') {
+				if(c == '\r')
+					expected("newline", "DOS line ending (\\r)");
+				else
+					expected("newline", std::string("\"") + c + "\"");
+			}
+		}
+	}
+
+  private:
+	void separator(Separator s) {
+		switch(s) {
+		case Separator::Space: space(); break;
+		case Separator::Newline: newline(); break;
+		}
+	}
+
+	template <typename T>
+	auto& seen() {
+		static std::map<source_location, std::set<T>> seen;
+		return seen;
+	}
+	template <typename T>
+	auto& last_seen() {
+		static std::map<source_location, T> last_seen;
+		return last_seen;
+	}
+	template <typename T>
+	auto& integers_seen() {
+		static std::map<source_location, std::tuple<std::set<T>, std::vector<T>, bool>>
+		    integers_seen;
+		return integers_seen;
+	}
+	template <typename T>
+	void reset(source_location loc) {
+		seen<T>().erase(loc);
+		last_seen<T>().erase(loc);
+		integers_seen<T>().erase(loc);
+	}
+
+	template <typename T, typename Tag>
+	void check_number(const std::string& name, T low, T high, T v, Tag /*unused*/,
+	                  source_location loc) {
+		static_assert(is_number_v<T>);
+		if(v < low or v > high) {
+			std::string type_name;
+			if constexpr(std::is_integral_v<T>) {
+				type_name = "integer";
+			}
+			if constexpr(std::is_floating_point_v<T>) {
+				type_name = "float";
+			}
+			expected(name + ": " + type_name + " between " + std::to_string(low) + " and " +
+			             std::to_string(high),
+			         std::to_string(v));
+		}
+		log_constraint(name, low, high, v, loc);
+		if constexpr(Tag::unique) {
+			auto [it, inserted] = seen<T>()[loc].emplace(v);
+			check(inserted, name, ": Value ", v, " seen twice, but must be unique!");
+		} else {
+			auto [it, inserted] = last_seen<T>().emplace(loc, v);
+			if(inserted) return;
+
+			auto last  = it->second;
+			it->second = v;
+
+			if constexpr(Tag::increasing)
+				check(v >= last, name, " is not increasing: value ", v, " follows ", last);
+			if constexpr(Tag::decreasing)
+				check(v <= last, name, " is not decreasing: value ", v, " follows ", last);
+			if constexpr(Tag::strict)
+				check(v != last, name, " is not strict: value ", v, " equals ", last);
+		}
+	}
+
+	template <typename Tag>
+	void check_string(const std::string& name, int low, int high, const std::string& v,
+	                  Tag /*unused*/, source_location loc) {
+		using T = std::string;
+		if((int) v.size() < low or (int) v.size() > high) {
+			expected(name + ": " + "string with" + " length between " + std::to_string(low) +
+			             " and " + std::to_string(high),
+			         v);
+		}
+		log_constraint(name, low, high, static_cast<int>(v.size()), loc);
+		if constexpr(Tag::unique) {
+			// static map<source_location, set<T>> seen;
+			auto [it, inserted] = seen<T>()[loc].emplace(v);
+			check(inserted, name, ": Value ", v, " seen twice, but must be unique!");
+		} else if(Tag::increasing or Tag::decreasing) {
+			// static map<source_location, T> last_seen;
+			auto [it, inserted] = last_seen<T>().emplace(loc, v);
+			if(inserted) return;
+
+			auto last  = it->second;
+			it->second = v;
+
+			if constexpr(Tag::increasing)
+				check(v >= last, name, " is not increasing: value ", v, " follows ", last);
+			if constexpr(Tag::decreasing)
+				check(v <= last, name, " is not decreasing: value ", v, " follows ", last);
+			if constexpr(Tag::strict)
+				check(v != last, name, " is not strict: value ", v, " equals ", last);
+		}
+	}
+
+	// Generate a random integer in [low, high] or float in [low, high).
+	template <typename T>
+	T uniform_number(T low, T high) {
+		assert(low <= high);
+		Generators::UniformGenerator uniform;
+		if constexpr(std::is_integral<T>::value)
+			return uniform.operator()<long long>(low, high, rng);
+		else
+			return uniform.operator()<long double>(low, high, rng);
+	}
+
+	template <typename T, typename Tag>
+	T gen_number(const std::string& name, T low, T high, Tag /*unused*/, source_location loc) {
+		static_assert(is_number_v<T>);
+		T v;
+
+		if constexpr(Tag::unique) {
+			assert(params.find(name) == params.end() &&
+			       "Parameters are not supported for unique values.");
+			if constexpr(std::is_integral<T>::value) {
+				auto& [seen_here, remaining_here, use_remaining] = integers_seen<T>()[loc];
+
+				if(use_remaining) {
+					check(!remaining_here.empty(), name, ": no unique values left");
+					v = remaining_here.back();
+					remaining_here.pop_back();
+				} else {
+					do {
+						v = uniform_number(low, high);
+					} while(!seen_here.insert(v).second);
+
+					struct CountIterator {
+						T v;
+						T& operator*() { return v; }
+						T& operator++() { return ++v; }
+						T operator++(int) { return v++; }
+						bool operator!=(CountIterator r) { return v != r.v; }
+					};
+
+					if(seen_here.size() > (high - low) / 2) {
+						use_remaining = true;
+						set_difference(CountIterator{low}, CountIterator{high + 1},
+						               seen_here.begin(), seen_here.end(),
+						               std::back_inserter(remaining_here));
+					}
+				}
+			} else {
+				// For floats, just regenerate numbers until success.
+				auto& seen_here = seen<T>()[loc];
+				do {
+					v = uniform_number(low, high);
+				} while(!seen_here.insert(v).second);
+			}
+
+		} else {
+			assert(not Tag::increasing && "Generating increasing sequences is not yet supported!");
+			assert(not Tag::decreasing && "Generating decreasing sequences is not yet supported!");
+			assert((std::is_same<Tag, ArbitraryTag>::value) &&
+			       "Only Unique and Arbitrary are supported!");
+
+			if(params.find(name) != params.end()) {
+				v = params.at(name).operator()<T>(low, high, rng);
+				// This will be checked during input validation of the generated case.
+				// assert(low <= v and v <= high);
+			} else {
+				v = uniform_number<T>(low, high);
+			}
+		}
+
+		return v;
+	}
+
+	std::string gen_string(const std::string& name, long long low, long long high,
+	                       std::string_view chars) {
+		assert(!chars.empty());
+
+		int len;
+		if(params.find(name + ".length") != params.end())
+			len = params.at(name + ".length").operator()<long long>(low, high, rng);
+		else
+			len = uniform_number(low, high);
+		std::string s(len, ' ');
+		for(auto& x : s) x = chars[uniform_number<int>(0, chars.size() - 1)];
+
+		out << s;
+		return s;
+	}
+
+  public:
+	template <typename Tag = ArbitraryTag>
+	long long gen_integer(const std::string& name, long long low, long long high, Tag tag = Tag{},
+	                      source_location loc = source_location::current()) {
+		return gen_number(name, low, high, tag, loc);
+	}
+
+	template <typename Tag = ArbitraryTag>
+	long double gen_float(const std::string& name, long double low, long double high,
+	                      Tag tag = Tag{}, source_location loc = source_location::current()) {
+		return gen_number(name, low, high, tag, loc);
+	}
+
+  private:
+	template <typename T, typename Tag>
+	std::vector<T> gen_numbers(const std::string& name, int count, T low, T high, Tag /*unused*/,
+	                           source_location loc) {
+		static_assert(is_number_v<T>);
+		std::vector<T> v;
+		v.reserve(count);
+		if constexpr(std::is_same_v<Tag, ArbitraryTag>) {
+			if(params.find(name) != params.end()) {
+				auto& generator = params.at(name);
+				for(int i = 0; i < count; ++i) {
+					auto val = generator.operator()<T>(low, high, rng);
+					assert(low <= val and val <= high);
+					v.push_back(val);
+				}
+			} else {
+				for(int i = 0; i < count; ++i) {
+					v.push_back(uniform_number<T>(low, high));
+				}
+			}
+		} else if constexpr(Tag::unique) {
+			assert(params.find(name) == params.end() &&
+			       "Parameters are not supported for unique values.");
+			std::set<T> seen_here;
+			if constexpr(std::is_integral_v<T>) {
+				if(2 * count < high - low) {
+					for(int i = 0; i < count; ++i) {
+						// If density < 1/2: retry.
+						T w;
+						do {
+							w = uniform_number(low, high);
+						} while(!seen_here.insert(w).second);
+						v.push_back(w);
+					}
+				} else {
+					// If density >= 1/2, crop a random permutation.
+					v.resize(high - low + 1);
+					iota(begin(v), end(v), low);
+					Random::shuffle(begin(v), end(v), rng);
+					v.resize(count);
+				}
+			} else {
+				for(int i = 0; i < count; ++i) {
+					// For floats, just regenerate numbers until success.
+					T w;
+					do {
+						w = uniform_number(low, high);
+					} while(!seen_here.insert(w).second);
+					v.push_back(w);
+				}
+			}
+		} else {
+			static_assert(Tag::increasing or Tag::decreasing);
+
+			constexpr bool integral_strict = Tag::strict and std::is_integral<T>::value;
+			if(integral_strict) {
+				assert(params.find(name) == params.end() &&
+				       "Parameters are not supported for strict integer values.");
+				high = high - count + 1;
+			}
+
+			if(params.find(name) != params.end()) {
+				auto& generator = params.at(name);
+				for(int i = 0; i < count; ++i) {
+					auto val = generator.operator()<T>(low, high, rng);
+					assert(low <= val and val <= high);
+					v.push_back(val);
+				}
+			} else {
+				for(int i = 0; i < count; ++i) {
+					v.push_back(uniform_number<T>(low, high));
+				}
+			}
+
+			sort(begin(v), end(v));
+
+			if(integral_strict) {
+				for(int i = 0; i < count; ++i) v[i] += i;
+			}
+
+			if(Tag::decreasing) reverse(begin(v), end(v));
+		}
+
+		return v;
+	}
+
+  public:
+	template <typename Tag = ArbitraryTag>
+	std::vector<long long> gen_integers(const std::string& name, int count, long long low,
+	                                    long long high, Tag tag = Tag{},
+	                                    source_location loc = source_location::current()) {
+		return gen_numbers(name, count, low, high, tag, loc);
+	}
+
+	template <typename Tag = ArbitraryTag>
+	std::vector<long double> gen_floats(const std::string& name, int count, long double low,
+	                                    long double high, Tag tag = Tag{},
+	                                    source_location loc = source_location::current()) {
+		return gen_numbers(name, count, low, high, tag, loc);
+	}
+
+  private:
+	template <typename T, typename Tag>
+	T read_number(const std::string& name, T low, T high, Tag tag, source_location loc) {
+		if(gen) {
+			auto v = gen_number(name, low, high, tag, loc);
+			out << std::setprecision(10) << std::fixed << v;
+			return v;
+		}
+
+		const auto v = [&] {
+			if constexpr(std::is_integral<T>::value)
+				return read_integer(name);
+			else
+				return read_float(name);
+		}();
+
+		check_number(name, low, high, v, tag, loc);
+		return v;
+	}
+
+	// Read a vector of numbers, separated by spaces and ended by a newline.
+	template <typename T, typename Tag>
+	std::vector<T> read_numbers(const std::string& name, int count, T low, T high, Tag tag,
+	                            Separator sep, source_location loc) {
+		if(gen) {
+			auto v = gen_numbers(name, count, low, high, tag, loc);
+
+			out << std::setprecision(10) << std::fixed;
+			for(int i = 0; i < count; ++i) {
+				out << v[i];
+				if(i < count - 1) separator(sep);
+			}
+			newline();
+
+			return v;
+		}
+		reset<T>(loc);
+		std::vector<T> v(count);
+		for(int i = 0; i < count; ++i) {
+			if constexpr(std::is_integral<T>::value)
+				v[i] = read_integer(name);
+			else
+				v[i] = read_float(name);
+			check_number(name, low, high, v[i], tag, loc);
+			if(i < count - 1) separator(sep);
+		}
+		newline();
+		return v;
+	}
+
+  public:
+	template <typename Tag = ArbitraryTag>
+	long long read_integer(const std::string& name, long long low, long long high, Tag tag = Tag{},
+	                       source_location loc = source_location::current()) {
+		return read_number(name, low, high, tag, loc);
+	}
+	template <typename Tag = ArbitraryTag>
+	std::vector<long long> read_integers(const std::string& name, int count, long long low,
+	                                     long long high, Tag tag = Tag{}, Separator sep = Space,
+	                                     source_location loc = source_location::current()) {
+		return read_numbers(name, count, low, high, tag, sep, loc);
+	}
+
+	template <typename Tag = ArbitraryTag>
+	long double read_float(const std::string& name, long double low, long double high,
+	                       Tag tag = Tag{}, source_location loc = source_location::current()) {
+		return read_number(name, low, high, tag, loc);
+	}
+	template <typename Tag = ArbitraryTag>
+	std::vector<long double> read_floats(const std::string& name, int count, long double low,
+	                                     long double high, Tag tag = Tag{}, Separator sep = Space,
+	                                     source_location loc = source_location::current()) {
+		return read_numbers(name, count, low, high, tag, sep, loc);
+	}
+
+	// Read a vector of strings, separated by spaces and ended by a newline.
+	template <typename Tag = ArbitraryTag>
+	std::vector<std::string> read_strings(const std::string& name, int count, int min, int max,
+	                                      const std::string_view chars = "", Tag tag = Tag(),
+	                                      Separator sep       = Space,
+	                                      source_location loc = source_location::current()) {
+		reset<std::string>(loc);
+		if(gen) return gen_strings(name, count, min, max, chars, tag, sep, loc);
+		assert(!gen);
+		std::vector<std::string> v(count);
+		for(int i = 0; i < count; ++i) {
+			v[i] = read_string(name, min, max, chars, tag, loc);
+			if(i < count - 1) separator(sep);
+		}
+		newline();
+		return v;
+	}
+
+	template <typename Tag>
+	std::vector<std::string> gen_strings(const std::string& name, int count, int min, int max,
+	                                     const std::string_view chars, Tag /*unused*/,
+	                                     Separator sep, source_location loc) {
+		assert(!chars.empty());
+
+		std::vector<std::string> v(count);
+		if constexpr(std::is_same<Tag, ArbitraryTag>::value) {
+			for(int i = 0; i < count; ++i) {
+				std::string s(uniform_number(min, max), ' ');
+				for(auto& x : s) x = chars[uniform_number<int>(0, chars.size() - 1)];
+				v.push_back(s);
+				out << s;
+				if(i < count - 1) separator(sep);
+			}
+		} else if constexpr(Tag::unique) {
+			std::set<std::string> seen_here;
+			for(int i = 0; i < count; ++i) {
+				// Just regenerate strings until success.
+				std::string s;
+				do {
+					s = std::string(uniform_number(min, max), ' ');
+					for(auto& x : s) x = chars[uniform_number<int>(0, chars.size() - 1)];
+				} while(!seen_here.insert(s).second);
+				v.push_back(s);
+				out << s;
+				if(i < count - 1) separator(sep);
+			}
+		} else {
+			static_assert(Tag::increasing or Tag::decreasing);
+
+			assert(false && "Generating increasing/decreasing lists of strings is not "
+			                "supported!");
+		}
+
+		newline();
+
+		return v;
+	}
+
+	// Check the next character.
+	bool peek(char c, const std::string& name = "") {
+		if(gen) {
+			// TODO
+			// if(not name.empty() and params.contains(name)) {
+			// return c == params.at(name).operator()<char>(0, 0, rng);
+			//}
+			return Random::bit(rng);
+		}
+		if(!ws) in >> std::ws;
+		if(case_sensitive) return in.peek() == std::char_traits<char>::to_int_type(c);
+		return tolower(in.peek()) == tolower(std::char_traits<char>::to_int_type(c));
+	}
+
+	// Read a string and make sure it equals `expected`.
+	// Takes by value because it needs to lowercase its arguments.
+	std::string test_strings(std::vector<std::string> expected, const std::string& name = "") {
+		if(gen) {
+			int index = 0;
+			// TODO
+			// if(not name.empty() and params.contains(name)) {
+			// auto s = params.at(name).operator()<std::string>(0, 0, rng);
+			// index  = std::find(expected.begin(), expected.end(), s) - expected.begin();
+			// assert(0 <= index and index < expected.size());
+			//} else {
+			index = expected.size() == 1 ? 0 : uniform_number<int>(0, expected.size() - 1);
+			//}
+			out << expected[index];
+			return expected[index];
+		}
+		std::string s = get_string();
+		lowercase(s);
+
+		for(std::string e : expected)
+			if(s == lowercase(e)) return s;
+
+		std::string error;
+		for(const auto& e : expected) {
+			if(not error.empty()) error += "|";
+			error += e;
+		}
+		WA("Expected string \"", error, "\", but found ", s);
+	}
+
+	// Read a string and make sure it equals `expected`.
+	std::string test_string(std::string expected, const std::string& name = "") {
+		return test_strings({std::move(expected)}, name);
+	}
+
+	// Read an arbitrary string of a given length.
+	template <typename Tag = ArbitraryTag>
+	std::string read_string(const std::string& name, long long min, long long max,
+	                        const std::string_view chars = "", Tag tag = Tag(),
+	                        source_location loc = source_location::current()) {
+		if(gen) {
+			return gen_string(name, min, max, chars);
+		}
+		std::string s = get_string();
+		std::array<bool, 256> ok_char{};
+		if(!chars.empty()) {
+			for(auto c : chars) ok_char[c] = true;
+			for(auto c : s)
+				check(ok_char[c], name, ": expected characters in ", chars, " but found character ",
+				      c, " in ", s);
+		}
+		check_string(name, min, max, s, tag, loc);
+		return s;
+	}
+
+	// Read an arbitrary line of a given length.
+	std::string read_line(const std::string& name, long long min, long long max,
+	                      const std::string_view chars = "",
+	                      source_location loc          = source_location::current()) {
+		if(gen) {
+			// TODO: Params for lines.
+			assert(!chars.empty());
+
+			std::string s(uniform_number(min, max), ' ');
+			for(auto& x : s) x = chars[uniform_number<int>(0, chars.size() - 1)];
+
+			out << s << '\n';
+			return s;
+		}
+
+		if(ws) {
+			char next = in.peek();
+			if(min > 0 and isspace(next))
+				expected("non empty line", next == '\n' ? "newline" : "whitespace");
+			if(in.eof()) expected("line", "EOF");
+		}
+		std::string s;
+		if(!getline(in, s)) expected("line", "nothing");
+		long long size = s.size();
+		if(size < min || size > max)
+			expected(name + ": line of length between " + std::to_string(min) + " and " +
+			             std::to_string(max),
+			         s);
+		std::array<bool, 256> ok_char{};
+		if(!chars.empty()) {
+			for(auto c : chars) ok_char[c] = true;
+			for(auto c : s)
+				check(ok_char[c], name, ": expected characters in ", chars, " but found character ",
+				      c, " in ", s);
+		}
+		log_constraint(name, min, max, size, loc);
+		return s;
+	}
+
+	// Return ACCEPTED verdict.
+	void eof_and_AC() {
+		eof();
+		AC();
+	}
+
+  private:
+	std::function<void()> WA_handler = [] {};
+
+  public:
+	void set_WA_handler(std::function<void()> f) { WA_handler = std::move(f); }
+
+	// Return WA with the given reason.
+	template <typename... Ts>
+	[[noreturn]] void WA(const Ts&... ts) {
+		static_assert(sizeof...(Ts) > 0);
+
+		WA_handler();
+
+		auto pos = get_file_pos();
+		std::cerr << pos.first << ":" << pos.second << ": ";
+
+		WA_impl(ts...);
+	}
+
+	// Check that the condition is true.
+	template <typename... Ts>
+	void check(bool b, const Ts&... ts) {
+		static_assert(sizeof...(Ts) > 0, "Provide a non-empty error message.");
+
+		if(!b) WA(ts...);
+	}
+
+	// Log some value in a range.
+	template <typename T>
+	void log_constraint(const std::string& name, T low, T high, T v,
+	                    source_location loc = source_location::current()) {
+		// Do not log when line number is unknown/default/unsupported.
+		if(loc.line() == 0 or constraints_file_path.empty()) return;
+
+		// All integer types get bounds as long long, all floating point types as long_double.
+		using U = Bounds<std::conditional_t<std::is_integral_v<T>, long long, long double>>;
+
+		auto [it, inserted] = bounds.emplace(loc, U(name, v, v, low, high));
+		assert(std::holds_alternative<U>(it->second));
+		auto& done = std::get<U>(it->second);
+		if(inserted) {
+			assert(!name.empty() && "Variable names must not be empty.");
+			assert(name.find(' ') == std::string::npos && "Variable name must not contain spaces.");
+		} else {
+			assert(name == done.name && "Variable name must be constant.");
+		}
+		if(v < done.min) {
+			done.min = v;
+			done.low = low;
+		}
+		if(v > done.max) {
+			done.max  = v;
+			done.high = high;
+		}
+		done.has_min |= v == low;
+		done.has_max |= v == high;
+	}
+
+  private:
+	long long read_integer(const std::string& name) {
+		assert(!gen);
+		std::string s = get_string("integer");
+		if(s.empty()) {
+			WA(name, ": Want integer, found nothing");
+		}
+		long long v;
+		auto begin = s.c_str(), end = begin + s.size();
+		auto [ptr, ec] = std::from_chars(begin, end, v);
+		if(ec == std::errc::result_out_of_range){
+			WA(name, ": Number " + s + " does not fit in a long long!");
+		} else if(ptr != end) {
+			WA(name, ": Parsing " + s + " as long long failed! Did not process all characters");
+		} else if (ec != std::errc{}) {
+			WA(name, ": Parsing " + s + " as long long failed!");
+		}
+		// Check for leading zero.
+		if(v == 0) {
+			if(s.size() != 1) WA(name, ": Parsed 0, but has leading 0 or minus sign: ", s);
+		}
+		if(v > 0) {
+			if(s[0] == '0') WA(name, ": Parsed ", v, ", but has leading 0: ", s);
+		}
+		if(v < 0) {
+			if(s.size() <= 1) WA(name, ": Parsed ", v, ", but string is: ", s);
+			if(s[1] == '0') WA(name, ": Parsed ", v, ", but has leading 0: ", s);
+		}
+		return v;
+	}
+
+	long double read_float(const std::string& name) {
+		assert(!gen);
+		std::string s = get_string("long double");
+		long double v;
+		try {
+			size_t chars_processed;
+			v = stold(s, &chars_processed);
+			if(chars_processed != s.size())
+				WA(name, ": Parsing ", s,
+				   " as long double failed! Did not process all characters.");
+		} catch(const std::out_of_range& e) {
+			WA(name, ": Number " + s + " does not fit in a long double!");
+		} catch(const std::invalid_argument& e) {
+			WA("Parsing " + s + " as long double failed!");
+		}
+		return v;
+	}
+
+	[[noreturn]] void expected(const std::string& exp = "", const std::string& s = "") {
+		assert(!gen && "Expected is not supported for generators.");
+		if(!s.empty())
+			WA("Expected ", exp, ", found ", s);
+		else
+			WA(exp);
+	}
+
+	template <typename T>
+	[[noreturn]] void WA_impl(T t) {
+		std::cerr << t << std::endl;
+		exit(ret_WA);
+	}
+
+	std::pair<int, int> get_file_pos() {
+		int line = 1, col = 0;
+		in.clear();
+		auto originalPos = in.tellg();
+		if(originalPos < 0) return {-1, -1};
+		in.seekg(0);
+		char c;
+		while((in.tellg() < originalPos) && in.get(c)) {
+			if(c == '\n')
+				++line, col = 0;
+			else
+				++col;
+		}
+		return {line, col};
+	}
+
+	template <typename T, typename... Ts>
+	[[noreturn]] void WA_impl(T t, Ts... ts) {
+		std::cerr << t;
+		WA_impl(ts...);
+	}
+
+	std::string get_string(const std::string& wanted = "string") {
+		assert(!gen && "get_string is not supported for generators.");
+		if(ws) {
+			char next = in.peek();
+			if(isspace(next)) expected(wanted, next == '\n' ? "newline" : "whitespace");
+			if(in.eof()) expected(wanted, "EOF");
+		}
+
+		std::string s;
+		if(in >> s) {
+			return s;
+		}
+		expected(wanted, "nothing");
+	}
+
+	// Return ACCEPTED verdict.
+	void AC() const {
+		if(gen) {
+			// nothing
+			return;
+		}
+
+		exit(ret_AC);
+	}
+
+	void eof() {
+		if(gen) {
+			out.flush();
+			fclose(stdout);
+			return;
+		}
+		if(in.eof()) return;
+		// Sometimes EOF hasn't been triggered yet.
+		if(!ws) in >> std::ws;
+		char c = in.get();
+		if(c == std::char_traits<char>::eof()) return;
+		std::string got = std::string("\"") + char(c) + '"';
+		if(c == '\n') got = "newline";
+		expected("EOF", got);
+	}
+
+	// Convert a string to lowercase is matching is not case sensitive.
+	std::string& lowercase(std::string& s) const {
+		if(case_sensitive) return s;
+		transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return std::tolower(c); });
+		return s;
+	}
+
+	// Keep track of the min/max value read at every call site.
+	template <typename T>
+	struct Bounds {
+		Bounds(std::string name_, T min_, T max_, T low_, T high_)
+		    : name(std::move(name_)), min(min_), max(max_), low(low_), high(high_) {} // NOLINT
+		std::string name;
+		T min, max;  // Smallest / largest value observed
+		T low, high; // Bounds
+		bool has_min = false, has_max = false;
+	};
+
+	std::map<source_location, std::variant<Bounds<long long>, Bounds<long double>>> bounds;
+
+	void write_constraints() {
+		if(constraints_file_path.empty()) return;
+
+		std::ofstream os(constraints_file_path);
+
+		for(const auto& [location, bound] : bounds) {
+			os << location_to_string(location) << " ";
+			std::visit(
+			    [&](const auto& b) {
+				    os << b.name << " " << b.has_min << " " << b.has_max << " " << b.min << " "
+				       << b.max << " " << b.low << " " << b.high << std::endl;
+			    },
+			    bound);
+		}
+	}
+
+	static const int ret_AC = 42, ret_WA = 43;
+	std::istream& in  = std::cin;
+	std::ostream& out = std::cout;
+
+  public:
+	const bool ws             = true;
+	const bool case_sensitive = true;
+	const std::string constraints_file_path;
+	const bool gen = false;
+
+	std::mt19937_64 rng;
+
+  private:
+	std::unordered_map<std::string, ParamGenerator> params;
+
+  public:
+	std::string_view get_param(std::string_view name, std::string_view default_) {
+		auto it = params.find(std::string(name));
+		if(it == params.end()) return default_;
+		return std::get<std::string_view>(it->second.generator);
+	}
+
+  protected:
+	static std::string get_constraints_file(int argc, char** argv) {
+		for(int i = 1; i < argc; ++i) {
+			if(argv[i] == constraints_file_flag) {
+				if(i + 1 < argc) return argv[i + 1];
+				std::cerr << constraints_file_flag << " should be followed by a file path!";
+				exit(1);
+			}
+		}
+		return {};
+	}
+};
+
+class Generator : public Validator {
+  public:
+	explicit Generator(unsigned int seed)
+	    : Validator(true, true, std::cin, /*constraints_file_path_=*/"", seed) {}
+};
+
+class InputValidator : public Validator {
+  public:
+	// An InputValidator is always both whitespace and case sensitive.
+	explicit InputValidator(int argc = 0, char** argv = nullptr)
+	    : Validator(true, true, std::cin, get_constraints_file(argc, argv), get_seed(argc, argv),
+	                get_params(argc, argv)) {}
+
+  private:
+	static std::optional<unsigned int> get_seed(int argc, char** argv) {
+		for(int i = 1; i < argc - 1; ++i) {
+			if(argv[i] == generate_flag) {
+				return std::stol(argv[i + 1]);
+			}
+		}
+		// If no --generate is given, but `generat` is a substring of the binary path,
+		// use the first argument as seed.
+		if(std::string(argv[0]).find(generate_binary_substring) != std::string::npos) {
+			return std::stol(argv[1]);
+		}
+		return std::nullopt;
+	}
+
+	static std::unordered_map<std::string, ParamGenerator> get_params(int argc, char** argv) {
+		std::unordered_map<std::string, ParamGenerator> params;
+		for(int i = 1; i < argc - 1; ++i) {
+			if(std::strlen(argv[i]) == 0 or argv[i][0] != '-') continue;
+			if(argv[i] == generate_flag) {
+				continue;
+			}
+			std::string_view name(argv[i] + 1);
+			std::string_view value(argv[i + 1]);
+			params.insert({std::string(name), ParamGenerator(value)});
+		}
+		return params;
+	}
+};
+
+class OutputValidator : public Validator {
+  public:
+	// An OutputValidator can be run in different modes.
+	explicit OutputValidator(int argc, char** argv, std::istream& in_ = std::cin)
+	    : Validator(is_ws_sensitive(argc, argv), is_case_sensitive(argc, argv), in_,
+	                get_constraints_file(argc, argv)) {}
+
+  private:
+	static bool is_ws_sensitive(int argc, char** argv) {
+		for(int i = 1; i < argc; ++i) {
+			if(argv[i] == ws_sensitive_flag) return true;
+		}
+		return false;
+	}
+
+	static bool is_case_sensitive(int argc, char** argv) {
+		for(int i = 1; i < argc; ++i) {
+			if(argv[i] == case_sensitive_flag) return true;
+		}
+		return false;
+	}
+};

ICPC/nwerc2022_F/data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ecf0c3b63e72a3e39274bb80c7b227c503eccad52366caf3dd56a9e414081285
+size 295421524

ICPC/nwerc2022_F/init.yml

@@ -0,0 +1,665 @@
+archive: data.zip
+test_cases:
+- in: 001-precision.in
+  out: 001-precision.ans
+  points: 1
+- in: 002-precision.in
+  out: 002-precision.ans
+  points: 1
+- in: 003-precision.in
+  out: 003-precision.ans
+  points: 1
+- in: 004-precision.in
+  out: 004-precision.ans
+  points: 1
+- in: 005-gen_jorke1.in
+  out: 005-gen_jorke1.ans
+  points: 1
+- in: 006-gen_jorke1.in
+  out: 006-gen_jorke1.ans
+  points: 1
+- in: 007-gen_jorke1.in
+  out: 007-gen_jorke1.ans
+  points: 1
+- in: 008-gen_jorke1.in
+  out: 008-gen_jorke1.ans
+  points: 1
+- in: 009-gen_jorke1.in
+  out: 009-gen_jorke1.ans
+  points: 1
+- in: 010-gen_jorke1.in
+  out: 010-gen_jorke1.ans
+  points: 1
+- in: 011-gen_jorke2.in
+  out: 011-gen_jorke2.ans
+  points: 1
+- in: 012-gen_jorke2.in
+  out: 012-gen_jorke2.ans
+  points: 1
+- in: 013-gen_jorke2.in
+  out: 013-gen_jorke2.ans
+  points: 1
+- in: 014-gen_jorke2.in
+  out: 014-gen_jorke2.ans
+  points: 1
+- in: 015-gen_jorke2.in
+  out: 015-gen_jorke2.ans
+  points: 1
+- in: 016-gen_jorke2.in
+  out: 016-gen_jorke2.ans
+  points: 1
+- in: 017-side_boxes_hor.in
+  out: 017-side_boxes_hor.ans
+  points: 1
+- in: 018-side_boxes_hor.in
+  out: 018-side_boxes_hor.ans
+  points: 1
+- in: 019-side_boxes_hor.in
+  out: 019-side_boxes_hor.ans
+  points: 1
+- in: 020-side_boxes_hor.in
+  out: 020-side_boxes_hor.ans
+  points: 1
+- in: 021-side_boxes_hor.in
+  out: 021-side_boxes_hor.ans
+  points: 1
+- in: 022-side_boxes_hor.in
+  out: 022-side_boxes_hor.ans
+  points: 1
+- in: 023-side_boxes_ver.in
+  out: 023-side_boxes_ver.ans
+  points: 1
+- in: 024-side_boxes_ver.in
+  out: 024-side_boxes_ver.ans
+  points: 1
+- in: 025-side_boxes_ver.in
+  out: 025-side_boxes_ver.ans
+  points: 1
+- in: 026-side_boxes_ver.in
+  out: 026-side_boxes_ver.ans
+  points: 1
+- in: 027-side_boxes_ver.in
+  out: 027-side_boxes_ver.ans
+  points: 1
+- in: 028-side_boxes_ver.in
+  out: 028-side_boxes_ver.ans
+  points: 1
+- in: 029-worstcase_200000_00.in
+  out: 029-worstcase_200000_00.ans
+  points: 1
+- in: 030-worstcase_200000_00.in
+  out: 030-worstcase_200000_00.ans
+  points: 1
+- in: 031-worstcase_200000_10.in
+  out: 031-worstcase_200000_10.ans
+  points: 1
+- in: 032-worstcase_200000_10.in
+  out: 032-worstcase_200000_10.ans
+  points: 1
+- in: 033-worstcase_200000_01.in
+  out: 033-worstcase_200000_01.ans
+  points: 1
+- in: 034-worstcase_200000_01.in
+  out: 034-worstcase_200000_01.ans
+  points: 1
+- in: 035-worstcase_200000_11.in
+  out: 035-worstcase_200000_11.ans
+  points: 1
+- in: 036-worstcase_200000_11.in
+  out: 036-worstcase_200000_11.ans
+  points: 1
+- in: 037-doomsday_manual.in
+  out: 037-doomsday_manual.ans
+  points: 1
+- in: 038-doomsday_manual.in
+  out: 038-doomsday_manual.ans
+  points: 1
+- in: 039-doomsday_manual.in
+  out: 039-doomsday_manual.ans
+  points: 1
+- in: 040-doomsday_precision.in
+  out: 040-doomsday_precision.ans
+  points: 1
+- in: 041-doomsday_precision.in
+  out: 041-doomsday_precision.ans
+  points: 1
+- in: 042-manual.in
+  out: 042-manual.ans
+  points: 1
+- in: 043-manual.in
+  out: 043-manual.ans
+  points: 1
+- in: 044-manual.in
+  out: 044-manual.ans
+  points: 1
+- in: 045-manual.in
+  out: 045-manual.ans
+  points: 1
+- in: 046-manual.in
+  out: 046-manual.ans
+  points: 1
+- in: 047-manual.in
+  out: 047-manual.ans
+  points: 1
+- in: 048-manual.in
+  out: 048-manual.ans
+  points: 1
+- in: 049-manual.in
+  out: 049-manual.ans
+  points: 1
+- in: 050-manual.in
+  out: 050-manual.ans
+  points: 1
+- in: 051-manual.in
+  out: 051-manual.ans
+  points: 1
+- in: 052-manual.in
+  out: 052-manual.ans
+  points: 1
+- in: 053-manual.in
+  out: 053-manual.ans
+  points: 1
+- in: 054-manual.in
+  out: 054-manual.ans
+  points: 1
+- in: 055-manual.in
+  out: 055-manual.ans
+  points: 1
+- in: 056-manual.in
+  out: 056-manual.ans
+  points: 1
+- in: 057-manual.in
+  out: 057-manual.ans
+  points: 1
+- in: 058-manual.in
+  out: 058-manual.ans
+  points: 1
+- in: 059-manual.in
+  out: 059-manual.ans
+  points: 1
+- in: 060-manual.in
+  out: 060-manual.ans
+  points: 1
+- in: 061-manual.in
+  out: 061-manual.ans
+  points: 1
+- in: 062-manual.in
+  out: 062-manual.ans
+  points: 1
+- in: 063-manual.in
+  out: 063-manual.ans
+  points: 1
+- in: 064-manual.in
+  out: 064-manual.ans
+  points: 1
+- in: 065-minimal-low.in
+  out: 065-minimal-low.ans
+  points: 1
+- in: 066-minimal-high.in
+  out: 066-minimal-high.ans
+  points: 1
+- in: 067-minimal-low-high.in
+  out: 067-minimal-low-high.ans
+  points: 1
+- in: 068-gen1.in
+  out: 068-gen1.ans
+  points: 1
+- in: 069-gen1.in
+  out: 069-gen1.ans
+  points: 1
+- in: 070-gen1.in
+  out: 070-gen1.ans
+  points: 1
+- in: 071-gen1.in
+  out: 071-gen1.ans
+  points: 1
+- in: 072-gen2.in
+  out: 072-gen2.ans
+  points: 1
+- in: 073-gen2.in
+  out: 073-gen2.ans
+  points: 1
+- in: 074-gen2.in
+  out: 074-gen2.ans
+  points: 1
+- in: 075-gen2.in
+  out: 075-gen2.ans
+  points: 1
+- in: 076-gen3.in
+  out: 076-gen3.ans
+  points: 1
+- in: 077-gen4.in
+  out: 077-gen4.ans
+  points: 1
+- in: 078-gen5.in
+  out: 078-gen5.ans
+  points: 1
+- in: 079-gen6.in
+  out: 079-gen6.ans
+  points: 1
+- in: 080-gen6.in
+  out: 080-gen6.ans
+  points: 1
+- in: 081-gen7.in
+  out: 081-gen7.ans
+  points: 1
+- in: 082-gen7.in
+  out: 082-gen7.ans
+  points: 1
+- in: 083-gen7.in
+  out: 083-gen7.ans
+  points: 1
+- in: 084-parabola_gen_5.in
+  out: 084-parabola_gen_5.ans
+  points: 1
+- in: 085-parabola_gen_20.in
+  out: 085-parabola_gen_20.ans
+  points: 1
+- in: 086-parabola_gen_1000.in
+  out: 086-parabola_gen_1000.ans
+  points: 1
+- in: 087-parabola_gen_200000.in
+  out: 087-parabola_gen_200000.ans
+  points: 1
+- in: 088-parabola_gen_200000.in
+  out: 088-parabola_gen_200000.ans
+  points: 1
+- in: 089-parabola_gen_200000.in
+  out: 089-parabola_gen_200000.ans
+  points: 1
+- in: 090-parpar_gen_5.in
+  out: 090-parpar_gen_5.ans
+  points: 1
+- in: 091-parpar_gen_20.in
+  out: 091-parpar_gen_20.ans
+  points: 1
+- in: 092-parpar_gen_1000.in
+  out: 092-parpar_gen_1000.ans
+  points: 1
+- in: 093-parpar_gen_5000.in
+  out: 093-parpar_gen_5000.ans
+  points: 1
+- in: 094-parpar_gen_10000.in
+  out: 094-parpar_gen_10000.ans
+  points: 1
+- in: 095-parpar_gen_200000.in
+  out: 095-parpar_gen_200000.ans
+  points: 1
+- in: 096-parpar_gen_200000.in
+  out: 096-parpar_gen_200000.ans
+  points: 1
+- in: 097-parpar_gen_200000.in
+  out: 097-parpar_gen_200000.ans
+  points: 1
+- in: 098-pardis_5.in
+  out: 098-pardis_5.ans
+  points: 1
+- in: 099-pardis_20.in
+  out: 099-pardis_20.ans
+  points: 1
+- in: 100-pardis_1000.in
+  out: 100-pardis_1000.ans
+  points: 1
+- in: 101-pardis_5000.in
+  out: 101-pardis_5000.ans
+  points: 1
+- in: 102-pardis_10000.in
+  out: 102-pardis_10000.ans
+  points: 1
+- in: 103-pardis_200000.in
+  out: 103-pardis_200000.ans
+  points: 1
+- in: 104-pardis_200000.in
+  out: 104-pardis_200000.ans
+  points: 1
+- in: 105-partan_5.in
+  out: 105-partan_5.ans
+  points: 1
+- in: 106-partan_20.in
+  out: 106-partan_20.ans
+  points: 1
+- in: 107-partan_5000.in
+  out: 107-partan_5000.ans
+  points: 1
+- in: 108-partan_10000.in
+  out: 108-partan_10000.ans
+  points: 1
+- in: 109-partan_10000.in
+  out: 109-partan_10000.ans
+  points: 1
+- in: 110-partan_200000.in
+  out: 110-partan_200000.ans
+  points: 1
+- in: 111-partan_200000.in
+  out: 111-partan_200000.ans
+  points: 1
+- in: 112-partan_200000.in
+  out: 112-partan_200000.ans
+  points: 1
+- in: 113-partan_200000.in
+  out: 113-partan_200000.ans
+  points: 1
+- in: 114-worstcase_5_00.in
+  out: 114-worstcase_5_00.ans
+  points: 1
+- in: 115-worstcase_20_00.in
+  out: 115-worstcase_20_00.ans
+  points: 1
+- in: 116-worstcase_1000_00.in
+  out: 116-worstcase_1000_00.ans
+  points: 1
+- in: 117-worstcase_5000_00.in
+  out: 117-worstcase_5000_00.ans
+  points: 1
+- in: 118-worstcase_10000_00.in
+  out: 118-worstcase_10000_00.ans
+  points: 1
+- in: 119-worstcase_200000_00.in
+  out: 119-worstcase_200000_00.ans
+  points: 1
+- in: 120-worstcase_200000_00.in
+  out: 120-worstcase_200000_00.ans
+  points: 1
+- in: 121-worstcase_200000_00.in
+  out: 121-worstcase_200000_00.ans
+  points: 1
+- in: 122-worstcase_5_10.in
+  out: 122-worstcase_5_10.ans
+  points: 1
+- in: 123-worstcase_20_10.in
+  out: 123-worstcase_20_10.ans
+  points: 1
+- in: 124-worstcase_1000_10.in
+  out: 124-worstcase_1000_10.ans
+  points: 1
+- in: 125-worstcase_5000_10.in
+  out: 125-worstcase_5000_10.ans
+  points: 1
+- in: 126-worstcase_10000_10.in
+  out: 126-worstcase_10000_10.ans
+  points: 1
+- in: 127-worstcase_200000_10.in
+  out: 127-worstcase_200000_10.ans
+  points: 1
+- in: 128-worstcase_200000_10.in
+  out: 128-worstcase_200000_10.ans
+  points: 1
+- in: 129-worstcase_200000_10.in
+  out: 129-worstcase_200000_10.ans
+  points: 1
+- in: 130-worstcase_200000_10.in
+  out: 130-worstcase_200000_10.ans
+  points: 1
+- in: 131-worstcase_200000_10.in
+  out: 131-worstcase_200000_10.ans
+  points: 1
+- in: 132-worstcase_200000_10.in
+  out: 132-worstcase_200000_10.ans
+  points: 1
+- in: 133-worstcase_20_01.in
+  out: 133-worstcase_20_01.ans
+  points: 1
+- in: 134-worstcase_20_11.in
+  out: 134-worstcase_20_11.ans
+  points: 1
+- in: 135-box_5_0.in
+  out: 135-box_5_0.ans
+  points: 1
+- in: 136-box_7_0.in
+  out: 136-box_7_0.ans
+  points: 1
+- in: 137-box_10_0.in
+  out: 137-box_10_0.ans
+  points: 1
+- in: 138-box_10_0.in
+  out: 138-box_10_0.ans
+  points: 1
+- in: 139-box_7_0.in
+  out: 139-box_7_0.ans
+  points: 1
+- in: 140-box_7_0.in
+  out: 140-box_7_0.ans
+  points: 1
+- in: 141-box_7_0.in
+  out: 141-box_7_0.ans
+  points: 1
+- in: 142-box_5_5.in
+  out: 142-box_5_5.ans
+  points: 1
+- in: 143-box_5_5.in
+  out: 143-box_5_5.ans
+  points: 1
+- in: 144-box_5_5.in
+  out: 144-box_5_5.ans
+  points: 1
+- in: 145-box_5_5.in
+  out: 145-box_5_5.ans
+  points: 1
+- in: 146-box_7_5.in
+  out: 146-box_7_5.ans
+  points: 1
+- in: 147-box_5_7.in
+  out: 147-box_5_7.ans
+  points: 1
+- in: 148-box_7_7.in
+  out: 148-box_7_7.ans
+  points: 1
+- in: 149-box_7_7.in
+  out: 149-box_7_7.ans
+  points: 1
+- in: 150-box_3_10.in
+  out: 150-box_3_10.ans
+  points: 1
+- in: 151-box_3_10.in
+  out: 151-box_3_10.ans
+  points: 1
+- in: 152-box_3_10.in
+  out: 152-box_3_10.ans
+  points: 1
+- in: 153-prime_line.in
+  out: 153-prime_line.ans
+  points: 1
+- in: 154-prime_line.in
+  out: 154-prime_line.ans
+  points: 1
+- in: 155-prime_line.in
+  out: 155-prime_line.ans
+  points: 1
+- in: 156-manual_break_nils.in
+  out: 156-manual_break_nils.ans
+  points: 1
+- in: 157-side_boxes_hor.in
+  out: 157-side_boxes_hor.ans
+  points: 1
+- in: 158-side_boxes_hor.in
+  out: 158-side_boxes_hor.ans
+  points: 1
+- in: 159-side_boxes_ver.in
+  out: 159-side_boxes_ver.ans
+  points: 1
+- in: 160-gen_jorke3.in
+  out: 160-gen_jorke3.ans
+  points: 1
+- in: 161-gen_jorke3.in
+  out: 161-gen_jorke3.ans
+  points: 1
+- in: 162-gen_jorke3.in
+  out: 162-gen_jorke3.ans
+  points: 1
+- in: 163-gen_jorke3.in
+  out: 163-gen_jorke3.ans
+  points: 1
+- in: 164-gen_jorke3.in
+  out: 164-gen_jorke3.ans
+  points: 1
+- in: 165-gen_jorke3.in
+  out: 165-gen_jorke3.ans
+  points: 1
+- in: 166-gen_jorke3.in
+  out: 166-gen_jorke3.ans
+  points: 1
+- in: 167-gen_jorke3.in
+  out: 167-gen_jorke3.ans
+  points: 1
+- in: 168-gen_jorke3.in
+  out: 168-gen_jorke3.ans
+  points: 1
+- in: 169-gen_jorke3.in
+  out: 169-gen_jorke3.ans
+  points: 1
+- in: 170-gen_jorke3.in
+  out: 170-gen_jorke3.ans
+  points: 1
+- in: 171-gen_jorke3.in
+  out: 171-gen_jorke3.ans
+  points: 1
+- in: 172-gen_jorke3.in
+  out: 172-gen_jorke3.ans
+  points: 1
+- in: 173-gen_jorke3.in
+  out: 173-gen_jorke3.ans
+  points: 1
+- in: 174-gen_jorke3.in
+  out: 174-gen_jorke3.ans
+  points: 1
+- in: 175-gen_jorke3.in
+  out: 175-gen_jorke3.ans
+  points: 1
+- in: 176-gen_jorke3.in
+  out: 176-gen_jorke3.ans
+  points: 1
+- in: 177-gen_jorke3.in
+  out: 177-gen_jorke3.ans
+  points: 1
+- in: 178-long_box.in
+  out: 178-long_box.ans
+  points: 1
+- in: 179-long_box.in
+  out: 179-long_box.ans
+  points: 1
+- in: 180-long_box.in
+  out: 180-long_box.ans
+  points: 1
+- in: 181-long_box.in
+  out: 181-long_box.ans
+  points: 1
+- in: 182-long_box.in
+  out: 182-long_box.ans
+  points: 1
+- in: 183-long_box.in
+  out: 183-long_box.ans
+  points: 1
+- in: 184-long_box.in
+  out: 184-long_box.ans
+  points: 1
+- in: 185-long_box.in
+  out: 185-long_box.ans
+  points: 1
+- in: 186-long_box.in
+  out: 186-long_box.ans
+  points: 1
+- in: 187-long_box.in
+  out: 187-long_box.ans
+  points: 1
+- in: 188-long_box.in
+  out: 188-long_box.ans
+  points: 1
+- in: 189-long_box.in
+  out: 189-long_box.ans
+  points: 1
+- in: 190-gen_ragnar_markus.in
+  out: 190-gen_ragnar_markus.ans
+  points: 1
+- in: 191-gen_ragnar_markus.in
+  out: 191-gen_ragnar_markus.ans
+  points: 1
+- in: 192-gen_ragnar_markus.in
+  out: 192-gen_ragnar_markus.ans
+  points: 1
+- in: 193-gen_ragnar_markus.in
+  out: 193-gen_ragnar_markus.ans
+  points: 1
+- in: 194-gen_ragnar_markus.in
+  out: 194-gen_ragnar_markus.ans
+  points: 1
+- in: 195-gen_ragnar_markus.in
+  out: 195-gen_ragnar_markus.ans
+  points: 1
+- in: 196-gen_ragnar_markus.in
+  out: 196-gen_ragnar_markus.ans
+  points: 1
+- in: 197-gen_ragnar_markus.in
+  out: 197-gen_ragnar_markus.ans
+  points: 1
+- in: 198-gen_ragnar_markus.in
+  out: 198-gen_ragnar_markus.ans
+  points: 1
+- in: 199-gen_ragnar_markus.in
+  out: 199-gen_ragnar_markus.ans
+  points: 1
+- in: 200-gen_ragnar_markus.in
+  out: 200-gen_ragnar_markus.ans
+  points: 1
+- in: 201-gen_ragnar_markus.in
+  out: 201-gen_ragnar_markus.ans
+  points: 1
+- in: 202-gen_ragnar_markus.in
+  out: 202-gen_ragnar_markus.ans
+  points: 1
+- in: 203-gen_ragnar_markus.in
+  out: 203-gen_ragnar_markus.ans
+  points: 1
+- in: 204-gen_ragnar_markus.in
+  out: 204-gen_ragnar_markus.ans
+  points: 1
+- in: 205-gen_ragnar_markus.in
+  out: 205-gen_ragnar_markus.ans
+  points: 1
+- in: 206-gen_ragnar_markus.in
+  out: 206-gen_ragnar_markus.ans
+  points: 1
+- in: 207-gen_ragnar_markus.in
+  out: 207-gen_ragnar_markus.ans
+  points: 1
+- in: 208-gen_ragnar_markus.in
+  out: 208-gen_ragnar_markus.ans
+  points: 1
+- in: 209-gen_jorke3_fuzzed.in
+  out: 209-gen_jorke3_fuzzed.ans
+  points: 1
+- in: 210-gen_jorke3_fuzzed.in
+  out: 210-gen_jorke3_fuzzed.ans
+  points: 1
+- in: 211-gen_jorke3_fuzzed.in
+  out: 211-gen_jorke3_fuzzed.ans
+  points: 1
+- in: 212-gen_jorke3_fuzzed.in
+  out: 212-gen_jorke3_fuzzed.ans
+  points: 1
+- in: 213-gen_jorke3_fuzzed.in
+  out: 213-gen_jorke3_fuzzed.ans
+  points: 1
+- in: 214-gen_jorke3_fuzzed.in
+  out: 214-gen_jorke3_fuzzed.ans
+  points: 1
+- in: 215-gen_jorke3_fuzzed.in
+  out: 215-gen_jorke3_fuzzed.ans
+  points: 1
+- in: 216-gen_jorke3_fuzzed.in
+  out: 216-gen_jorke3_fuzzed.ans
+  points: 1
+- in: 217-gen_jorke3_fuzzed.in
+  out: 217-gen_jorke3_fuzzed.ans
+  points: 1
+- in: 218-gen8.in
+  out: 218-gen8.ans
+  points: 1
+- in: 219-gen8.in
+  out: 219-gen8.ans
+  points: 1
+- in: 220-gen8.in
+  out: 220-gen8.ans
+  points: 1
+- in: 221-gen8.in
+  out: 221-gen8.ans
+  points: 1

ICPC/nwerc2022_G/data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f2f5f0bbf09389c282827ce78c294db9ceaa8b89348714372d3cb13a0610d74
+size 101977

ICPC/nwerc2022_G/init.yml

@@ -0,0 +1,624 @@
+archive: data.zip
+interactive:
+  files:
+  - output_validators/validate/validate.cpp
+  - output_validators/validate/validate.h
+  lang: CPP17
+  type: default
+test_cases:
+- in: 001-period.in
+  out: 001-period.ans
+  points: 1
+- in: 002-period.in
+  out: 002-period.ans
+  points: 1
+- in: 003-period.in
+  out: 003-period.ans
+  points: 1
+- in: 004-period.in
+  out: 004-period.ans
+  points: 1
+- in: 005-period.in
+  out: 005-period.ans
+  points: 1
+- in: 006-period.in
+  out: 006-period.ans
+  points: 1
+- in: 007-period.in
+  out: 007-period.ans
+  points: 1
+- in: 008-period.in
+  out: 008-period.ans
+  points: 1
+- in: 009-period.in
+  out: 009-period.ans
+  points: 1
+- in: 010-period.in
+  out: 010-period.ans
+  points: 1
+- in: 011-period.in
+  out: 011-period.ans
+  points: 1
+- in: 012-period.in
+  out: 012-period.ans
+  points: 1
+- in: 013-debruijn.in
+  out: 013-debruijn.ans
+  points: 1
+- in: 014-debruijn.in
+  out: 014-debruijn.ans
+  points: 1
+- in: 015-debruijn.in
+  out: 015-debruijn.ans
+  points: 1
+- in: 016-debruijn.in
+  out: 016-debruijn.ans
+  points: 1
+- in: 017-debruijn.in
+  out: 017-debruijn.ans
+  points: 1
+- in: 018-debruijn.in
+  out: 018-debruijn.ans
+  points: 1
+- in: 019-debruijn.in
+  out: 019-debruijn.ans
+  points: 1
+- in: 020-debruijn.in
+  out: 020-debruijn.ans
+  points: 1
+- in: 021-debruijn.in
+  out: 021-debruijn.ans
+  points: 1
+- in: 022-debruijn.in
+  out: 022-debruijn.ans
+  points: 1
+- in: 023-debruijn.in
+  out: 023-debruijn.ans
+  points: 1
+- in: 024-debruijn.in
+  out: 024-debruijn.ans
+  points: 1
+- in: 025-constants.in
+  out: 025-constants.ans
+  points: 1
+- in: 026-constants.in
+  out: 026-constants.ans
+  points: 1
+- in: 027-constants.in
+  out: 027-constants.ans
+  points: 1
+- in: 028-constants.in
+  out: 028-constants.ans
+  points: 1
+- in: 029-ones.in
+  out: 029-ones.ans
+  points: 1
+- in: 030-ones.in
+  out: 030-ones.ans
+  points: 1
+- in: 031-ones.in
+  out: 031-ones.ans
+  points: 1
+- in: 032-ones.in
+  out: 032-ones.ans
+  points: 1
+- in: 033-ones.in
+  out: 033-ones.ans
+  points: 1
+- in: 034-ones.in
+  out: 034-ones.ans
+  points: 1
+- in: 035-ones.in
+  out: 035-ones.ans
+  points: 1
+- in: 036-ones.in
+  out: 036-ones.ans
+  points: 1
+- in: 037-ones.in
+  out: 037-ones.ans
+  points: 1
+- in: 038-ones.in
+  out: 038-ones.ans
+  points: 1
+- in: 039-ones.in
+  out: 039-ones.ans
+  points: 1
+- in: 040-ones.in
+  out: 040-ones.ans
+  points: 1
+- in: 041-ones.in
+  out: 041-ones.ans
+  points: 1
+- in: 042-ones.in
+  out: 042-ones.ans
+  points: 1
+- in: 043-ones.in
+  out: 043-ones.ans
+  points: 1
+- in: 044-zeroes.in
+  out: 044-zeroes.ans
+  points: 1
+- in: 045-zeroes.in
+  out: 045-zeroes.ans
+  points: 1
+- in: 046-zeroes.in
+  out: 046-zeroes.ans
+  points: 1
+- in: 047-zeroes.in
+  out: 047-zeroes.ans
+  points: 1
+- in: 048-zeroes.in
+  out: 048-zeroes.ans
+  points: 1
+- in: 049-zeroes.in
+  out: 049-zeroes.ans
+  points: 1
+- in: 050-zeroes.in
+  out: 050-zeroes.ans
+  points: 1
+- in: 051-zeroes.in
+  out: 051-zeroes.ans
+  points: 1
+- in: 052-zeroes.in
+  out: 052-zeroes.ans
+  points: 1
+- in: 053-zeroes.in
+  out: 053-zeroes.ans
+  points: 1
+- in: 054-zeroes.in
+  out: 054-zeroes.ans
+  points: 1
+- in: 055-zeroes.in
+  out: 055-zeroes.ans
+  points: 1
+- in: 056-zeroes.in
+  out: 056-zeroes.ans
+  points: 1
+- in: 057-zeroes.in
+  out: 057-zeroes.ans
+  points: 1
+- in: 058-zeroes.in
+  out: 058-zeroes.ans
+  points: 1
+- in: 059-uniform_random.in
+  out: 059-uniform_random.ans
+  points: 1
+- in: 060-uniform_random.in
+  out: 060-uniform_random.ans
+  points: 1
+- in: 061-uniform_random.in
+  out: 061-uniform_random.ans
+  points: 1
+- in: 062-uniform_random.in
+  out: 062-uniform_random.ans
+  points: 1
+- in: 063-uniform_random.in
+  out: 063-uniform_random.ans
+  points: 1
+- in: 064-uniform_random.in
+  out: 064-uniform_random.ans
+  points: 1
+- in: 065-uniform_random.in
+  out: 065-uniform_random.ans
+  points: 1
+- in: 066-uniform_random.in
+  out: 066-uniform_random.ans
+  points: 1
+- in: 067-uniform_random.in
+  out: 067-uniform_random.ans
+  points: 1
+- in: 068-uniform_random.in
+  out: 068-uniform_random.ans
+  points: 1
+- in: 069-uniform_random.in
+  out: 069-uniform_random.ans
+  points: 1
+- in: 070-uniform_random.in
+  out: 070-uniform_random.ans
+  points: 1
+- in: 071-uniform_random.in
+  out: 071-uniform_random.ans
+  points: 1
+- in: 072-uniform_random.in
+  out: 072-uniform_random.ans
+  points: 1
+- in: 073-uniform_random.in
+  out: 073-uniform_random.ans
+  points: 1
+- in: 074-uniform_random.in
+  out: 074-uniform_random.ans
+  points: 1
+- in: 075-uniform_random.in
+  out: 075-uniform_random.ans
+  points: 1
+- in: 076-uniform_random.in
+  out: 076-uniform_random.ans
+  points: 1
+- in: 077-uniform_random.in
+  out: 077-uniform_random.ans
+  points: 1
+- in: 078-uniform_random.in
+  out: 078-uniform_random.ans
+  points: 1
+- in: 079-uniform_random.in
+  out: 079-uniform_random.ans
+  points: 1
+- in: 080-uniform_random.in
+  out: 080-uniform_random.ans
+  points: 1
+- in: 081-uniform_random.in
+  out: 081-uniform_random.ans
+  points: 1
+- in: 082-uniform_random.in
+  out: 082-uniform_random.ans
+  points: 1
+- in: 083-uniform_random.in
+  out: 083-uniform_random.ans
+  points: 1
+- in: 084-uniform_random.in
+  out: 084-uniform_random.ans
+  points: 1
+- in: 085-uniform_random.in
+  out: 085-uniform_random.ans
+  points: 1
+- in: 086-uniform_random.in
+  out: 086-uniform_random.ans
+  points: 1
+- in: 087-uniform_random.in
+  out: 087-uniform_random.ans
+  points: 1
+- in: 088-biased_one.in
+  out: 088-biased_one.ans
+  points: 1
+- in: 089-biased_one.in
+  out: 089-biased_one.ans
+  points: 1
+- in: 090-biased_one.in
+  out: 090-biased_one.ans
+  points: 1
+- in: 091-biased_one.in
+  out: 091-biased_one.ans
+  points: 1
+- in: 092-biased_one.in
+  out: 092-biased_one.ans
+  points: 1
+- in: 093-biased_one.in
+  out: 093-biased_one.ans
+  points: 1
+- in: 094-biased_one.in
+  out: 094-biased_one.ans
+  points: 1
+- in: 095-biased_one.in
+  out: 095-biased_one.ans
+  points: 1
+- in: 096-biased_one.in
+  out: 096-biased_one.ans
+  points: 1
+- in: 097-biased_one.in
+  out: 097-biased_one.ans
+  points: 1
+- in: 098-biased_one.in
+  out: 098-biased_one.ans
+  points: 1
+- in: 099-biased_one.in
+  out: 099-biased_one.ans
+  points: 1
+- in: 100-biased_one.in
+  out: 100-biased_one.ans
+  points: 1
+- in: 101-biased_one.in
+  out: 101-biased_one.ans
+  points: 1
+- in: 102-biased_one.in
+  out: 102-biased_one.ans
+  points: 1
+- in: 103-biased_one.in
+  out: 103-biased_one.ans
+  points: 1
+- in: 104-biased_one.in
+  out: 104-biased_one.ans
+  points: 1
+- in: 105-biased_one.in
+  out: 105-biased_one.ans
+  points: 1
+- in: 106-biased_one.in
+  out: 106-biased_one.ans
+  points: 1
+- in: 107-biased_one.in
+  out: 107-biased_one.ans
+  points: 1
+- in: 108-biased_one.in
+  out: 108-biased_one.ans
+  points: 1
+- in: 109-biased_one.in
+  out: 109-biased_one.ans
+  points: 1
+- in: 110-biased_one.in
+  out: 110-biased_one.ans
+  points: 1
+- in: 111-biased_one.in
+  out: 111-biased_one.ans
+  points: 1
+- in: 112-biased_one.in
+  out: 112-biased_one.ans
+  points: 1
+- in: 113-biased_one.in
+  out: 113-biased_one.ans
+  points: 1
+- in: 114-biased_one.in
+  out: 114-biased_one.ans
+  points: 1
+- in: 115-biased_one.in
+  out: 115-biased_one.ans
+  points: 1
+- in: 116-biased_one.in
+  out: 116-biased_one.ans
+  points: 1
+- in: 117-biased_one.in
+  out: 117-biased_one.ans
+  points: 1
+- in: 118-biased_one.in
+  out: 118-biased_one.ans
+  points: 1
+- in: 119-biased_one.in
+  out: 119-biased_one.ans
+  points: 1
+- in: 120-biased_one.in
+  out: 120-biased_one.ans
+  points: 1
+- in: 121-biased_one.in
+  out: 121-biased_one.ans
+  points: 1
+- in: 122-biased_one.in
+  out: 122-biased_one.ans
+  points: 1
+- in: 123-biased_one.in
+  out: 123-biased_one.ans
+  points: 1
+- in: 124-biased_one.in
+  out: 124-biased_one.ans
+  points: 1
+- in: 125-biased_one.in
+  out: 125-biased_one.ans
+  points: 1
+- in: 126-biased_one.in
+  out: 126-biased_one.ans
+  points: 1
+- in: 127-biased_one.in
+  out: 127-biased_one.ans
+  points: 1
+- in: 128-biased_one.in
+  out: 128-biased_one.ans
+  points: 1
+- in: 129-biased_one.in
+  out: 129-biased_one.ans
+  points: 1
+- in: 130-biased_one.in
+  out: 130-biased_one.ans
+  points: 1
+- in: 131-biased_one.in
+  out: 131-biased_one.ans
+  points: 1
+- in: 132-biased_one.in
+  out: 132-biased_one.ans
+  points: 1
+- in: 133-biased_one.in
+  out: 133-biased_one.ans
+  points: 1
+- in: 134-biased_one.in
+  out: 134-biased_one.ans
+  points: 1
+- in: 135-biased_one.in
+  out: 135-biased_one.ans
+  points: 1
+- in: 136-biased_one.in
+  out: 136-biased_one.ans
+  points: 1
+- in: 137-biased_one.in
+  out: 137-biased_one.ans
+  points: 1
+- in: 138-biased_one.in
+  out: 138-biased_one.ans
+  points: 1
+- in: 139-biased_one.in
+  out: 139-biased_one.ans
+  points: 1
+- in: 140-biased_one.in
+  out: 140-biased_one.ans
+  points: 1
+- in: 141-biased_one.in
+  out: 141-biased_one.ans
+  points: 1
+- in: 142-biased_one.in
+  out: 142-biased_one.ans
+  points: 1
+- in: 143-biased_one.in
+  out: 143-biased_one.ans
+  points: 1
+- in: 144-biased_one.in
+  out: 144-biased_one.ans
+  points: 1
+- in: 145-biased_one.in
+  out: 145-biased_one.ans
+  points: 1
+- in: 146-biased_zero.in
+  out: 146-biased_zero.ans
+  points: 1
+- in: 147-biased_zero.in
+  out: 147-biased_zero.ans
+  points: 1
+- in: 148-biased_zero.in
+  out: 148-biased_zero.ans
+  points: 1
+- in: 149-biased_zero.in
+  out: 149-biased_zero.ans
+  points: 1
+- in: 150-biased_zero.in
+  out: 150-biased_zero.ans
+  points: 1
+- in: 151-biased_zero.in
+  out: 151-biased_zero.ans
+  points: 1
+- in: 152-biased_zero.in
+  out: 152-biased_zero.ans
+  points: 1
+- in: 153-biased_zero.in
+  out: 153-biased_zero.ans
+  points: 1
+- in: 154-biased_zero.in
+  out: 154-biased_zero.ans
+  points: 1
+- in: 155-biased_zero.in
+  out: 155-biased_zero.ans
+  points: 1
+- in: 156-biased_zero.in
+  out: 156-biased_zero.ans
+  points: 1
+- in: 157-biased_zero.in
+  out: 157-biased_zero.ans
+  points: 1
+- in: 158-biased_zero.in
+  out: 158-biased_zero.ans
+  points: 1
+- in: 159-biased_zero.in
+  out: 159-biased_zero.ans
+  points: 1
+- in: 160-biased_zero.in
+  out: 160-biased_zero.ans
+  points: 1
+- in: 161-biased_zero.in
+  out: 161-biased_zero.ans
+  points: 1
+- in: 162-biased_zero.in
+  out: 162-biased_zero.ans
+  points: 1
+- in: 163-biased_zero.in
+  out: 163-biased_zero.ans
+  points: 1
+- in: 164-biased_zero.in
+  out: 164-biased_zero.ans
+  points: 1
+- in: 165-biased_zero.in
+  out: 165-biased_zero.ans
+  points: 1
+- in: 166-biased_zero.in
+  out: 166-biased_zero.ans
+  points: 1
+- in: 167-biased_zero.in
+  out: 167-biased_zero.ans
+  points: 1
+- in: 168-biased_zero.in
+  out: 168-biased_zero.ans
+  points: 1
+- in: 169-biased_zero.in
+  out: 169-biased_zero.ans
+  points: 1
+- in: 170-biased_zero.in
+  out: 170-biased_zero.ans
+  points: 1
+- in: 171-biased_zero.in
+  out: 171-biased_zero.ans
+  points: 1
+- in: 172-biased_zero.in
+  out: 172-biased_zero.ans
+  points: 1
+- in: 173-biased_zero.in
+  out: 173-biased_zero.ans
+  points: 1
+- in: 174-biased_zero.in
+  out: 174-biased_zero.ans
+  points: 1
+- in: 175-biased_zero.in
+  out: 175-biased_zero.ans
+  points: 1
+- in: 176-biased_zero.in
+  out: 176-biased_zero.ans
+  points: 1
+- in: 177-biased_zero.in
+  out: 177-biased_zero.ans
+  points: 1
+- in: 178-biased_zero.in
+  out: 178-biased_zero.ans
+  points: 1
+- in: 179-biased_zero.in
+  out: 179-biased_zero.ans
+  points: 1
+- in: 180-biased_zero.in
+  out: 180-biased_zero.ans
+  points: 1
+- in: 181-biased_zero.in
+  out: 181-biased_zero.ans
+  points: 1
+- in: 182-biased_zero.in
+  out: 182-biased_zero.ans
+  points: 1
+- in: 183-biased_zero.in
+  out: 183-biased_zero.ans
+  points: 1
+- in: 184-biased_zero.in
+  out: 184-biased_zero.ans
+  points: 1
+- in: 185-biased_zero.in
+  out: 185-biased_zero.ans
+  points: 1
+- in: 186-biased_zero.in
+  out: 186-biased_zero.ans
+  points: 1
+- in: 187-biased_zero.in
+  out: 187-biased_zero.ans
+  points: 1
+- in: 188-biased_zero.in
+  out: 188-biased_zero.ans
+  points: 1
+- in: 189-biased_zero.in
+  out: 189-biased_zero.ans
+  points: 1
+- in: 190-biased_zero.in
+  out: 190-biased_zero.ans
+  points: 1
+- in: 191-biased_zero.in
+  out: 191-biased_zero.ans
+  points: 1
+- in: 192-biased_zero.in
+  out: 192-biased_zero.ans
+  points: 1
+- in: 193-biased_zero.in
+  out: 193-biased_zero.ans
+  points: 1
+- in: 194-biased_zero.in
+  out: 194-biased_zero.ans
+  points: 1
+- in: 195-biased_zero.in
+  out: 195-biased_zero.ans
+  points: 1
+- in: 196-biased_zero.in
+  out: 196-biased_zero.ans
+  points: 1
+- in: 197-biased_zero.in
+  out: 197-biased_zero.ans
+  points: 1
+- in: 198-biased_zero.in
+  out: 198-biased_zero.ans
+  points: 1
+- in: 199-biased_zero.in
+  out: 199-biased_zero.ans
+  points: 1
+- in: 200-biased_zero.in
+  out: 200-biased_zero.ans
+  points: 1
+- in: 201-biased_zero.in
+  out: 201-biased_zero.ans
+  points: 1
+- in: 202-biased_zero.in
+  out: 202-biased_zero.ans
+  points: 1
+- in: 203-biased_zero.in
+  out: 203-biased_zero.ans
+  points: 1
+- in: 204-biased_zero.in
+  out: 204-biased_zero.ans
+  points: 1
+- in: 205-biased_zero.in
+  out: 205-biased_zero.ans
+  points: 1
+unbuffered: false

ICPC/nwerc2022_G/output_validators/validate/validate.cpp

@@ -0,0 +1,120 @@
+
+#include<cstdlib>
+int qwerty_getcode(int code) {
+    return code == 42? 0: 1;
+}
+namespace std {
+    void qwerty_exit(int code){
+        exit(qwerty_getcode(code));
+    }
+} using std::qwerty_exit;
+#define exit qwerty_exit
+#define main qwerty_main
+#include <climits>
+#include <set>
+#include <vector>
+
+#include "validate.h"
+using namespace std;
+
+void to_lower(std::string& s) {
+    for (char& c : s) c |= 0x20;
+}
+
+int main(int argc, char **argv) {
+    init_io(argc,argv);
+
+    int n;
+    judge_in >> n;
+
+    int position = 0;
+    vector<int> state(n);
+    for (int i = 0; i < n; i++) {
+        char c;
+        judge_in >> c;
+        state[i] = c - '0';
+    }
+
+    cout << state[position] << endl;
+
+    int max_queries = 3*n + 500;
+    int lim_queries = 5*n + 1000;
+    int queries_used = 0;
+    while (true) {
+        string response;
+        if (!(author_out >> response)) {
+            wrong_answer("Wrong answer: failed to read response. Queries used: %d\n", queries_used);
+        }
+
+        if (response == "?") {
+            queries_used++;
+
+            string query;
+            if (!(author_out >> query)) {
+                wrong_answer("Wrong answer: failed to read query. Queries used: %d\n", queries_used);
+            }
+            to_lower(query);
+
+            if (query == "left") {
+                position = (position + n - 1) % n;
+            } else if (query == "right") {
+                position = (position + 1) % n;
+            } else if (query == "flip") {
+                state[position] = 1 - state[position];
+            } else {
+                wrong_answer("Wrong answer: invalid query type. Queries used: %d\n", queries_used);
+            }
+
+            cout << state[position] << endl;
+        } else if (response == "!") {
+            int guess;
+            if (!(author_out >> guess)) {
+                wrong_answer("Wrong answer: failed to read guess. Queries used: %d\n", queries_used);
+            }
+
+            string junk;
+            if (author_out >> junk) {
+                wrong_answer("Wrong answer: trailing output after guess.\n");
+            }
+
+            if (guess == n) {
+                if (queries_used > max_queries) {
+                    wrong_answer("Wrong answer: correct guess, but used too many queries. Queries used: %d (%d too many)\n", queries_used, queries_used-max_queries);
+                }
+                break;
+            } else {
+                wrong_answer("Wrong answer: incorrect guess %d (ans: %d). Queries used: %d\n", guess, n, queries_used);
+            }
+        } else {
+            wrong_answer("Wrong answer: invalid response type. Queries used: %d\n", queries_used);
+        }
+        if (queries_used > lim_queries) {
+            wrong_answer("Wrong answer: used too many queries. Queries used: %d (%d too many, terminated)\n", queries_used, queries_used-max_queries);
+        }
+    }
+
+    string junk;
+    if (author_out >> junk) {
+        wrong_answer("Wrong answer: trailing output.\n");
+    }
+
+    judge_message("Queries used: %d.\n", queries_used);
+
+    accept();
+}
+
+
+#undef main
+#include<cstdio>
+#include<vector>
+#include<string>
+#include<filesystem>
+int main(int argc, char **argv) {
+	namespace fs = std::filesystem;
+    char judge_out[] = "/dev";
+    std::vector<char*> new_argv = {
+		argv[0], argv[1], argv[2],
+		judge_out,
+	};
+	return qwerty_getcode(qwerty_main((int)new_argv.size(), new_argv.data()));
+}

ICPC/nwerc2022_G/output_validators/validate/validate.h

@@ -0,0 +1,154 @@
+/* Utility functions for writing output validators for the Kattis
+ * problem format.
+ *
+ * The primary functions and variables available are the following.
+ * In many cases, the only functions needed are "init_io",
+ * "wrong_answer", and "accept".
+ *
+ * - init_io(argc, argv):
+ *        initialization
+ *
+ * - judge_in, judge_ans, author_out:
+ *        std::istream objects for judge input file, judge answer
+ *        file, and submission output file.
+ *
+ * - accept():
+ *        exit and give Accepted!
+ *
+ * - accept_with_score(double score):
+ *        exit with Accepted and give a score (for scoring problems)
+ *
+ * - judge_message(std::string msg, ...):
+ *        printf-style function for emitting a judge message (a
+ *        message that gets displayed to a privileged user with access
+ *        to secret data etc).
+ *
+ * - wrong_answer(std::string msg, ...):
+ *        printf-style function for exitting and giving Wrong Answer,
+ *        and emitting a judge message (which would typically explain
+ *        the cause of the Wrong Answer)
+ *
+ * - judge_error(std::string msg, ...):
+ *        printf-style function for exitting and giving Judge Error,
+ *        and emitting a judge message (which would typically explain
+ *        the cause of the Judge Error)
+ *
+ * - author_message(std::string msg, ...):
+ *        printf-style function for emitting an author message (a
+ *        message that gets displayed to the author of the
+ *        submission).  (Use with caution, and be careful not to let
+ *        it leak information!)
+ *
+ */
+#pragma once
+
+#include <sys/stat.h>
+#include <cassert>
+#include <cstdarg>
+#include <cstdlib>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+
+typedef void (*feedback_function)(const std::string &, ...);
+
+const int EXITCODE_AC = 42;
+const int EXITCODE_WA = 43;
+const std::string FILENAME_AUTHOR_MESSAGE = "teammessage.txt";
+const std::string FILENAME_JUDGE_MESSAGE = "null";
+const std::string FILENAME_JUDGE_ERROR = "judgeerror.txt";
+const std::string FILENAME_SCORE = "score.txt";
+
+#define USAGE "%s: judge_in judge_ans feedback_dir < author_out\n"
+
+std::ifstream judge_in, judge_ans;
+std::istream author_out(std::cin.rdbuf());
+
+char *feedbackdir = NULL;
+
+void vreport_feedback(const std::string &category,
+		const std::string &msg,
+		va_list pvar) {
+	std::ostringstream fname;
+	if (feedbackdir)
+		fname << feedbackdir << '/';
+	fname << category;
+	FILE *f = fopen(fname.str().c_str(), "a");
+	assert(f);
+	vfprintf(f, msg.c_str(), pvar);
+	fclose(f);
+}
+
+void report_feedback(const std::string &category, const std::string &msg, ...) {
+	va_list pvar;
+	va_start(pvar, msg);
+	vreport_feedback(category, msg, pvar);
+}
+
+void author_message(const std::string &msg, ...) {
+	va_list pvar;
+	va_start(pvar, msg);
+	vreport_feedback(FILENAME_AUTHOR_MESSAGE, msg, pvar);
+}
+
+void judge_message(const std::string &msg, ...) {
+	va_list pvar;
+	va_start(pvar, msg);
+	vreport_feedback(FILENAME_JUDGE_MESSAGE, msg, pvar);
+}
+
+void wrong_answer(const std::string &msg, ...) {
+	va_list pvar;
+	va_start(pvar, msg);
+	vreport_feedback(FILENAME_JUDGE_MESSAGE, msg, pvar);
+	exit(EXITCODE_WA);
+}
+
+void judge_error(const std::string &msg, ...) {
+	va_list pvar;
+	va_start(pvar, msg);
+	vreport_feedback(FILENAME_JUDGE_ERROR, msg, pvar);
+	assert(0);
+}
+
+void accept() {
+	exit(EXITCODE_AC);
+}
+
+void accept_with_score(double scorevalue) {
+	report_feedback(FILENAME_SCORE, "%.9le", scorevalue);
+	exit(EXITCODE_AC);
+}
+
+
+bool is_directory(const char *path) {
+if(std::string(path) == std::string("/dev")) return 1;
+	struct stat entry;
+	return stat(path, &entry) == 0 && S_ISDIR(entry.st_mode);
+}
+
+void init_io(int argc, char **argv) {
+	if(argc < 4) {
+		fprintf(stderr, USAGE, argv[0]);
+		judge_error("Usage: %s judgein judgeans feedbackdir [opts] < userout", argv[0]);
+	}
+
+	// Set up feedbackdir first, as that allows us to produce feedback
+	// files for errors in the other parameters.
+	if (!is_directory(argv[3])) {
+		judge_error("%s: %s is not a directory\n", argv[0], argv[3]);
+	}
+	feedbackdir = argv[3];
+
+	judge_in.open(argv[1], std::ios_base::in);
+	if (judge_in.fail()) {
+		judge_error("%s: failed to open %s\n", argv[0], argv[1]);
+	}
+
+	judge_ans.open(argv[2], std::ios_base::in);
+	if (judge_ans.fail()) {
+		judge_error("%s: failed to open %s\n", argv[0], argv[2]);
+	}
+
+	author_out.rdbuf(std::cin.rdbuf());
+}

ICPC/nwerc2022_H/data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:67e095af096b197afd21937619a0a8bff678c8b5c9bf747d261b0de61c8d6229
+size 32405712

ICPC/nwerc2022_H/init.yml

@@ -0,0 +1,251 @@
+archive: data.zip
+test_cases:
+- in: 01-path-tree.in
+  out: 01-path-tree.ans
+  points: 1
+- in: 02-path-tree.in
+  out: 02-path-tree.ans
+  points: 1
+- in: 03-path-tree.in
+  out: 03-path-tree.ans
+  points: 1
+- in: 04-complete.in
+  out: 04-complete.ans
+  points: 1
+- in: 05-complete.in
+  out: 05-complete.ans
+  points: 1
+- in: 06-fibonacci_path_on_leaf.in
+  out: 06-fibonacci_path_on_leaf.ans
+  points: 1
+- in: 07-fibonacci_path_on_leaf.in
+  out: 07-fibonacci_path_on_leaf.ans
+  points: 1
+- in: 08-fibonacci_random.in
+  out: 08-fibonacci_random.ans
+  points: 1
+- in: 09-fibonacci_random.in
+  out: 09-fibonacci_random.ans
+  points: 1
+- in: 10-copath.in
+  out: 10-copath.ans
+  points: 1
+- in: 11-copath.in
+  out: 11-copath.ans
+  points: 1
+- in: 12-copath.in
+  out: 12-copath.ans
+  points: 1
+- in: 13-binary.in
+  out: 13-binary.ans
+  points: 1
+- in: 14-binary.in
+  out: 14-binary.ans
+  points: 1
+- in: 15-random2.in
+  out: 15-random2.ans
+  points: 1
+- in: 16-random2.in
+  out: 16-random2.ans
+  points: 1
+- in: 17-random2.in
+  out: 17-random2.ans
+  points: 1
+- in: 18-random2.in
+  out: 18-random2.ans
+  points: 1
+- in: 19-random2.in
+  out: 19-random2.ans
+  points: 1
+- in: 20-fibonacci_path_on_leaf.in
+  out: 20-fibonacci_path_on_leaf.ans
+  points: 1
+- in: 21-fibonacci_path_on_leaf.in
+  out: 21-fibonacci_path_on_leaf.ans
+  points: 1
+- in: 22-fibonacci_path_on_leaf.in
+  out: 22-fibonacci_path_on_leaf.ans
+  points: 1
+- in: 23-fibonacci_path_on_leaf.in
+  out: 23-fibonacci_path_on_leaf.ans
+  points: 1
+- in: 24-fibonacci_path_on_leaf.in
+  out: 24-fibonacci_path_on_leaf.ans
+  points: 1
+- in: 25-fibonacci_path_on_leaf.in
+  out: 25-fibonacci_path_on_leaf.ans
+  points: 1
+- in: 26-fibonacci_path_on_leaf.in
+  out: 26-fibonacci_path_on_leaf.ans
+  points: 1
+- in: 27-fibonacci_path_on_leaf.in
+  out: 27-fibonacci_path_on_leaf.ans
+  points: 1
+- in: 28-fibonacci_path_on_leaf.in
+  out: 28-fibonacci_path_on_leaf.ans
+  points: 1
+- in: 29-fibonacci_path_on_leaf.in
+  out: 29-fibonacci_path_on_leaf.ans
+  points: 1
+- in: 30-fibonacci_path_on_leaf.in
+  out: 30-fibonacci_path_on_leaf.ans
+  points: 1
+- in: 31-fibonacci_path_on_leaf.in
+  out: 31-fibonacci_path_on_leaf.ans
+  points: 1
+- in: 32-fibonacci_random.in
+  out: 32-fibonacci_random.ans
+  points: 1
+- in: 33-fibonacci_random.in
+  out: 33-fibonacci_random.ans
+  points: 1
+- in: 34-fibonacci_random.in
+  out: 34-fibonacci_random.ans
+  points: 1
+- in: 35-fibonacci_random.in
+  out: 35-fibonacci_random.ans
+  points: 1
+- in: 36-fibonacci_random.in
+  out: 36-fibonacci_random.ans
+  points: 1
+- in: 37-fibonacci_random.in
+  out: 37-fibonacci_random.ans
+  points: 1
+- in: 38-fibonacci_random.in
+  out: 38-fibonacci_random.ans
+  points: 1
+- in: 39-fibonacci_random.in
+  out: 39-fibonacci_random.ans
+  points: 1
+- in: 40-fibonacci_random.in
+  out: 40-fibonacci_random.ans
+  points: 1
+- in: 41-fibonacci_random.in
+  out: 41-fibonacci_random.ans
+  points: 1
+- in: 42-fibonacci_random.in
+  out: 42-fibonacci_random.ans
+  points: 1
+- in: 43-fibonacci.in
+  out: 43-fibonacci.ans
+  points: 1
+- in: 44-path.in
+  out: 44-path.ans
+  points: 1
+- in: 45-path.in
+  out: 45-path.ans
+  points: 1
+- in: 46-copath-small.in
+  out: 46-copath-small.ans
+  points: 1
+- in: 47-copath-small.in
+  out: 47-copath-small.ans
+  points: 1
+- in: 48-random.in
+  out: 48-random.ans
+  points: 1
+- in: 49-random.in
+  out: 49-random.ans
+  points: 1
+- in: 50-random.in
+  out: 50-random.ans
+  points: 1
+- in: 51-random.in
+  out: 51-random.ans
+  points: 1
+- in: 52-random.in
+  out: 52-random.ans
+  points: 1
+- in: 53-random.in
+  out: 53-random.ans
+  points: 1
+- in: 54-random.in
+  out: 54-random.ans
+  points: 1
+- in: 55-random.in
+  out: 55-random.ans
+  points: 1
+- in: 56-random.in
+  out: 56-random.ans
+  points: 1
+- in: 57-random.in
+  out: 57-random.ans
+  points: 1
+- in: 58-random.in
+  out: 58-random.ans
+  points: 1
+- in: 59-random.in
+  out: 59-random.ans
+  points: 1
+- in: 60-random.in
+  out: 60-random.ans
+  points: 1
+- in: 61-random.in
+  out: 61-random.ans
+  points: 1
+- in: 62-random.in
+  out: 62-random.ans
+  points: 1
+- in: 63-random.in
+  out: 63-random.ans
+  points: 1
+- in: 64-random.in
+  out: 64-random.ans
+  points: 1
+- in: 65-random.in
+  out: 65-random.ans
+  points: 1
+- in: 66-random.in
+  out: 66-random.ans
+  points: 1
+- in: 67-random.in
+  out: 67-random.ans
+  points: 1
+- in: 68-random.in
+  out: 68-random.ans
+  points: 1
+- in: 69-random2-small.in
+  out: 69-random2-small.ans
+  points: 1
+- in: 70-random2-small.in
+  out: 70-random2-small.ans
+  points: 1
+- in: 71-random2-small.in
+  out: 71-random2-small.ans
+  points: 1
+- in: 72-random2-small.in
+  out: 72-random2-small.ans
+  points: 1
+- in: 73-random2-small.in
+  out: 73-random2-small.ans
+  points: 1
+- in: 74-random2-small.in
+  out: 74-random2-small.ans
+  points: 1
+- in: 75-random2-small.in
+  out: 75-random2-small.ans
+  points: 1
+- in: 76-random2-small.in
+  out: 76-random2-small.ans
+  points: 1
+- in: 77-binary.in
+  out: 77-binary.ans
+  points: 1
+- in: 78-binary.in
+  out: 78-binary.ans
+  points: 1
+- in: 79-binary.in
+  out: 79-binary.ans
+  points: 1
+- in: 80-binary.in
+  out: 80-binary.ans
+  points: 1
+- in: 81-binary.in
+  out: 81-binary.ans
+  points: 1
+- in: 82-binary.in
+  out: 82-binary.ans
+  points: 1
+- in: 83-binary.in
+  out: 83-binary.ans
+  points: 1

ICPC/nwerc2022_I/data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:72281fe73c0859d81835dd0bdc762a728a8b3dcf6197dd1ae3f461d2304eef18
+size 5549755

ICPC/nwerc2022_I/init.yml

@@ -0,0 +1,223 @@
+archive: data.zip
+checker:
+  args:
+    files:
+    - output_validators/output_validator/output_validator.cpp
+    - output_validators/output_validator/validation.h
+    lang: CPP17
+    type: default
+  name: bridged
+test_cases:
+- in: 01-length-one-num.in
+  out: 01-length-one-num.ans
+  points: 1
+- in: 02-length-one-fizz.in
+  out: 02-length-one-fizz.ans
+  points: 1
+- in: 03-length-one-buzz.in
+  out: 03-length-one-buzz.ans
+  points: 1
+- in: 04-length-one-fizzbuzz.in
+  out: 04-length-one-fizzbuzz.ans
+  points: 1
+- in: 05-random-small.in
+  out: 05-random-small.ans
+  points: 1
+- in: 06-random-small.in
+  out: 06-random-small.ans
+  points: 1
+- in: 07-random-small.in
+  out: 07-random-small.ans
+  points: 1
+- in: 08-random-small.in
+  out: 08-random-small.ans
+  points: 1
+- in: 09-random-small.in
+  out: 09-random-small.ans
+  points: 1
+- in: 10-random-small.in
+  out: 10-random-small.ans
+  points: 1
+- in: 11-random-small.in
+  out: 11-random-small.ans
+  points: 1
+- in: 12-random-small.in
+  out: 12-random-small.ans
+  points: 1
+- in: 13-random-small.in
+  out: 13-random-small.ans
+  points: 1
+- in: 14-random-small.in
+  out: 14-random-small.ans
+  points: 1
+- in: 15-random-small.in
+  out: 15-random-small.ans
+  points: 1
+- in: 16-random-small.in
+  out: 16-random-small.ans
+  points: 1
+- in: 17-random-small.in
+  out: 17-random-small.ans
+  points: 1
+- in: 18-random-small.in
+  out: 18-random-small.ans
+  points: 1
+- in: 19-random-small.in
+  out: 19-random-small.ans
+  points: 1
+- in: 20-random-small.in
+  out: 20-random-small.ans
+  points: 1
+- in: 21-random-small.in
+  out: 21-random-small.ans
+  points: 1
+- in: 22-random-small.in
+  out: 22-random-small.ans
+  points: 1
+- in: 23-random-small.in
+  out: 23-random-small.ans
+  points: 1
+- in: 24-random-small.in
+  out: 24-random-small.ans
+  points: 1
+- in: 25-random-small-fuzz.in
+  out: 25-random-small-fuzz.ans
+  points: 1
+- in: 26-random-small-fuzz.in
+  out: 26-random-small-fuzz.ans
+  points: 1
+- in: 27-random-max.in
+  out: 27-random-max.ans
+  points: 1
+- in: 28-random-max.in
+  out: 28-random-max.ans
+  points: 1
+- in: 29-random-max.in
+  out: 29-random-max.ans
+  points: 1
+- in: 30-random-max.in
+  out: 30-random-max.ans
+  points: 1
+- in: 31-random-max.in
+  out: 31-random-max.ans
+  points: 1
+- in: 32-random.in
+  out: 32-random.ans
+  points: 1
+- in: 33-random.in
+  out: 33-random.ans
+  points: 1
+- in: 34-random.in
+  out: 34-random.ans
+  points: 1
+- in: 35-random.in
+  out: 35-random.ans
+  points: 1
+- in: 36-random.in
+  out: 36-random.ans
+  points: 1
+- in: 37-random.in
+  out: 37-random.ans
+  points: 1
+- in: 38-random.in
+  out: 38-random.ans
+  points: 1
+- in: 39-random.in
+  out: 39-random.ans
+  points: 1
+- in: 40-random.in
+  out: 40-random.ans
+  points: 1
+- in: 41-random.in
+  out: 41-random.ans
+  points: 1
+- in: 42-just-max.in
+  out: 42-just-max.ans
+  points: 1
+- in: 43-max-no-fizz-no-buzz.in
+  out: 43-max-no-fizz-no-buzz.ans
+  points: 1
+- in: 44-one-fizzbuzz.in
+  out: 44-one-fizzbuzz.ans
+  points: 1
+- in: 45-two-fizzbuzz.in
+  out: 45-two-fizzbuzz.ans
+  points: 1
+- in: 46-many-fizzbuzz.in
+  out: 46-many-fizzbuzz.ans
+  points: 1
+- in: 47-no-fizz-no-buzz.in
+  out: 47-no-fizz-no-buzz.ans
+  points: 1
+- in: 48-no-fizz-one-buzz.in
+  out: 48-no-fizz-one-buzz.ans
+  points: 1
+- in: 49-no-fizz-two-buzz.in
+  out: 49-no-fizz-two-buzz.ans
+  points: 1
+- in: 50-no-fizz-many-buzz.in
+  out: 50-no-fizz-many-buzz.ans
+  points: 1
+- in: 51-no-fizz-all-buzz.in
+  out: 51-no-fizz-all-buzz.ans
+  points: 1
+- in: 52-one-fizz-no-buzz.in
+  out: 52-one-fizz-no-buzz.ans
+  points: 1
+- in: 53-one-fizz-one-buzz.in
+  out: 53-one-fizz-one-buzz.ans
+  points: 1
+- in: 54-one-fizz-two-buzz.in
+  out: 54-one-fizz-two-buzz.ans
+  points: 1
+- in: 55-one-fizz-many-buzz.in
+  out: 55-one-fizz-many-buzz.ans
+  points: 1
+- in: 56-one-fizz-all-buzz.in
+  out: 56-one-fizz-all-buzz.ans
+  points: 1
+- in: 57-two-fizz-no-buzz.in
+  out: 57-two-fizz-no-buzz.ans
+  points: 1
+- in: 58-two-fizz-one-buzz.in
+  out: 58-two-fizz-one-buzz.ans
+  points: 1
+- in: 59-two-fizz-two-buzz.in
+  out: 59-two-fizz-two-buzz.ans
+  points: 1
+- in: 60-two-fizz-many-buzz.in
+  out: 60-two-fizz-many-buzz.ans
+  points: 1
+- in: 61-two-fizz-all-buzz.in
+  out: 61-two-fizz-all-buzz.ans
+  points: 1
+- in: 62-many-fizz-no-buzz.in
+  out: 62-many-fizz-no-buzz.ans
+  points: 1
+- in: 63-many-fizz-one-buzz.in
+  out: 63-many-fizz-one-buzz.ans
+  points: 1
+- in: 64-many-fizz-two-buzz.in
+  out: 64-many-fizz-two-buzz.ans
+  points: 1
+- in: 65-many-fizz-many-buzz.in
+  out: 65-many-fizz-many-buzz.ans
+  points: 1
+- in: 66-many-fizz-all-buzz.in
+  out: 66-many-fizz-all-buzz.ans
+  points: 1
+- in: 67-all-fizz-no-buzz.in
+  out: 67-all-fizz-no-buzz.ans
+  points: 1
+- in: 68-all-fizz-one-buzz.in
+  out: 68-all-fizz-one-buzz.ans
+  points: 1
+- in: 69-all-fizz-two-buzz.in
+  out: 69-all-fizz-two-buzz.ans
+  points: 1
+- in: 70-all-fizz-many-buzz.in
+  out: 70-all-fizz-many-buzz.ans
+  points: 1
+- in: 71-all-fizz-all-buzz.in
+  out: 71-all-fizz-all-buzz.ans
+  points: 1

ICPC/nwerc2022_I/output_validators/output_validator/output_validator.cpp

@@ -0,0 +1,54 @@
+
+#include<cstdlib>
+int qwerty_getcode(int code) {
+    return code == 42? 0: 1;
+}
+namespace std {
+    void qwerty_exit(int code){
+        exit(qwerty_getcode(code));
+    }
+} using std::qwerty_exit;
+#define exit qwerty_exit
+#define main qwerty_main
+#include "validation.h"
+
+int main(int argc, char **argv) {
+    std::ifstream in(argv[1]);
+    OutputValidator v(argc, argv);
+
+    int c, d;
+    in >> c >> d;
+
+    std::vector<std::string> items(d-c+1);
+    for (auto &s: items) in >> s;
+
+    int a = v.read_integer("a", 1, 1'000'000);
+    v.space();
+    int b = v.read_integer("b", 1, 1'000'000);
+    v.newline();
+
+    for (int i = c; i <= d; i++) {
+        std::string str;
+        if (i%a == 0) str += "Fizz";
+        if (i%b == 0) str += "Buzz";
+        if (str.empty()) str += std::to_string(i);
+        
+        v.check(str == items[i-c], "Mismatch at position ", i, ": expected ", items[i-c], ", got ", str);
+    }
+}
+
+#undef main
+#include<cstdio>
+#include<vector>
+#include<string>
+#include<filesystem>
+int main(int argc, char **argv) {
+	namespace fs = std::filesystem;
+    freopen(argv[2], "r", stdin);
+    char judge_out[] = "/dev";
+    std::vector<char*> new_argv = {
+		argv[0], argv[1], argv[3],
+		judge_out,
+	};
+	return qwerty_getcode(qwerty_main((int)new_argv.size(), new_argv.data()));
+}

ICPC/nwerc2022_I/output_validators/output_validator/validation.h

@@ -0,0 +1,1520 @@
+#pragma once
+// A header library to safely parse team input.
+// It does not support floating points or big integers.
+// Author: Ragnar Groot Koerkamp
+
+// The easiest way to use this is to symlink it from a validator directory,
+// so that it will be picked up when creating a contest zip.
+
+// The default checking behaviour is lenient for both white space and case.
+// When validating .in and .ans files, the case_sensitive and
+// space_change_sensitive flags should be passed. When validating team output,
+// the flags in problem.yaml should be used.
+
+// Compile with -Duse_source_location to enable
+// std::experimental::source_location. This is needed for constraints checking.
+
+#include <algorithm>
+#include <array>
+#include <bitset>
+#include <cassert>
+#include <charconv>
+#include <cstring>
+#include <fstream>
+#include <functional>
+#include <iomanip>
+#include <iostream>
+#include <limits>
+#include <map>
+#include <optional>
+#include <random>
+#include <set>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+#include <variant>
+#include <vector>
+
+#ifdef use_source_location
+#include <experimental/source_location>
+constexpr bool has_source_location = true;
+using std::experimental::source_location;
+namespace std {
+bool operator<(const source_location& l, const source_location& r) {
+	return l.line() < r.line();
+}
+} // namespace std
+namespace std::experimental::fundamentals_v2 {
+bool operator<(const source_location& l, const source_location& r) {
+	return l.line() < r.line();
+}
+} // namespace std::experimental::fundamentals_v2
+#else
+constexpr bool has_source_location = false;
+struct source_location {
+	static source_location current() { return {}; }
+	[[nodiscard]] int line() const { return 0; }               // NOLINT
+	[[nodiscard]] std::string file_name() const { return ""; } // NOLINT
+};
+inline bool operator<(const source_location& l, const source_location& r) {
+	return l.line() < r.line();
+}
+#endif
+
+inline std::string location_to_string(source_location loc) {
+	return std::string(loc.file_name()) + ":" + std::to_string(loc.line());
+}
+
+const std::string_view case_sensitive_flag       = "case_sensitive";
+const std::string_view ws_sensitive_flag         = "space_change_sensitive";
+const std::string_view constraints_file_flag     = "--constraints_file";
+const std::string_view generate_flag             = "--generate";
+const std::string_view generate_binary_substring = "generat";
+
+inline struct ArbitraryTag {
+	static constexpr bool unique     = false;
+	static constexpr bool strict     = false;
+	static constexpr bool increasing = false;
+	static constexpr bool decreasing = false;
+} Arbitrary;
+inline struct UniqueTag : ArbitraryTag {
+	static constexpr bool unique     = true;
+	static constexpr bool strict     = false;
+	static constexpr bool increasing = false;
+	static constexpr bool decreasing = false;
+} Unique;
+inline struct IncreasingTag : ArbitraryTag { static constexpr bool increasing = true; } Increasing;
+inline struct DecreasingTag : ArbitraryTag { static constexpr bool decreasing = true; } Decreasing;
+inline struct StrictlyIncreasingTag : ArbitraryTag {
+	static constexpr bool strict     = true;
+	static constexpr bool increasing = true;
+} StrictlyIncreasing;
+inline struct StrictlyDecreasingTag : ArbitraryTag {
+	static constexpr bool strict     = true;
+	static constexpr bool decreasing = true;
+} StrictlyDecreasing;
+
+template <typename... T>
+struct Merge : T... {
+	static constexpr bool unique     = (T::unique || ...);
+	static constexpr bool strict     = (T::strict || ...);
+	static constexpr bool increasing = (T::increasing || ...);
+	static constexpr bool decreasing = (T::decreasing || ...);
+};
+
+template <typename T1, typename T2,
+          std::enable_if_t<
+              std::is_base_of_v<ArbitraryTag, T1> and std::is_base_of_v<ArbitraryTag, T2>, int> = 0>
+auto operator|(T1 /*unused*/, T2 /*unused*/) {
+	return Merge<T1, T2>();
+}
+
+enum Separator { Space, Newline };
+
+// this contains some specific code which emulates c++20 features
+namespace cpp20 {
+
+constexpr int countl_zero(unsigned long long x) {
+	int res = 64;
+	for(int i = 32; i > 0; i >>= 1) {
+		if((x >> i) > 0) {
+			res -= i;
+			x >>= i;
+		}
+	}
+	if(x > 0) res--;
+	return res;
+}
+
+int popcount(unsigned long long x) {
+	return static_cast<int>(std::bitset<64>(x).count());
+}
+
+constexpr long double PI = 3.141592653589793238462643383279502884l;
+
+} // namespace cpp20
+
+namespace Random {
+
+constexpr unsigned int default_seed = 3141592653; // some digits of PI
+
+unsigned long long bits64(std::mt19937_64& rng) {
+	static_assert(std::mt19937_64::max() == 0xFFFF'FFFF'FFFF'FFFFull);
+	static_assert(std::mt19937_64::min() == 0ull);
+	return rng();
+}
+
+// generates a uniform real in [0, 1)
+long double real64(std::mt19937_64& rng) {
+	// a long double can represent more than 2^64 values in the range [0, 1)...
+	// another problem is that real64() < 1.0/3.0 is technically biased.
+	long double res = bits64(rng) / 0x1.0p64l;
+	res += bits64(rng) / 0x1.0p128l;
+	assert(res < 1.0l);
+	return res;
+}
+
+bool bit(std::mt19937_64& rng) {
+	return cpp20::popcount(bits64(rng)) & 1;
+}
+
+} // namespace Random
+
+template <typename T>
+constexpr bool is_number_v = std::is_same_v<T, long long> or std::is_same_v<T, long double>;
+
+namespace Generators {
+
+template <typename T>
+struct ConstGenerator {
+	static_assert(is_number_v<T> or std::is_same_v<T, char> or std::is_same_v<T, std::string>);
+	static constexpr std::string_view name = "const";
+	using Args                             = std::tuple<T>;
+
+	const T const_;
+
+	explicit ConstGenerator(T val) : const_(std::move(val)) {}
+
+	// For char and string, the constant store has a different type than the min and max length
+	// passed in.
+	template <typename U>
+	T operator()(U low, U high, std::mt19937_64& rng) const {
+		return std::clamp(const_, low, high);
+	}
+};
+
+struct MinGenerator {
+	static constexpr std::string_view name = "min";
+	using Args                             = std::tuple<>;
+
+	explicit MinGenerator() = default;
+
+	template <typename T>
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		static_assert(is_number_v<T>);
+		return low;
+	}
+};
+
+struct MaxGenerator {
+	static constexpr std::string_view name = "max";
+	using Args                             = std::tuple<>;
+
+	explicit MaxGenerator() = default;
+
+	template <typename T>
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		static_assert(is_number_v<T>);
+		return high;
+	}
+};
+
+struct UniformGenerator {
+	static constexpr std::string_view name = "uniform";
+	using Args                             = std::tuple<>;
+
+	explicit UniformGenerator() = default;
+
+	template <typename T>
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		static_assert(is_number_v<T>);
+		if(low == high) return low;
+
+		if constexpr(std::is_same_v<T, long long>) {
+			assert(low < high);
+			// Since C++20 we can assume Two's Complement but any sane system used it before anyway.
+			// Rejection sampling is not as fast as possible but definitely unbiased.
+			auto ul    = static_cast<unsigned long long>(low);
+			auto uh    = static_cast<unsigned long long>(high);
+			int shifts = cpp20::countl_zero(uh - ul);
+			unsigned long long res;
+			do {
+				res = Random::bits64(rng) >> shifts;
+			} while(res > uh - ul);
+			return static_cast<long long>(res + ul);
+		} else {
+			assert(low < high);
+			return low + Random::real64(rng) * (high - low);
+		}
+	}
+};
+
+template <typename T>
+struct RangeGenerator {
+	static_assert(is_number_v<T>);
+	static constexpr std::string_view name = "range";
+	using Args                             = std::tuple<T, T>;
+
+	const T low_, high_;
+
+	explicit RangeGenerator(T low, T high) : low_(low), high_(high) {}
+
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		return UniformGenerator()(std::max(low, low_), std::min(high, high_), rng);
+	}
+};
+
+template <typename T>
+struct StepRangeGenerator {
+	static_assert(is_number_v<T>);
+	static constexpr std::string_view name = "steprange";
+	using Args                             = std::tuple<T, T, T>;
+
+	const T low_, high_, step_;
+
+	explicit StepRangeGenerator(T low, T high, T step) : low_(low), high_(high), step_(step) {}
+
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		// round up low to the first multiple of step_.
+		T start;
+		if(low <= low_) {
+			start = low_;
+		} else {
+			// first multiple of low_+k*step_ >= low
+			start = low_ + (long long)((low - low_) / step_) * step_;
+			if(start < low) start += step_;
+			assert(low <= start && start < low + step_);
+		}
+		long long maxsteps = (std::min(high, high_) - start) / step_;
+		long long steps    = UniformGenerator()(0ll, maxsteps, rng);
+		return start + steps * step_;
+	}
+};
+
+struct NormalDistributionGenerator {
+	static constexpr std::string_view name = "normal";
+	using T                                = long double;
+	using Args                             = std::tuple<T, T>;
+
+	const T mean_, stddev_;
+
+	explicit NormalDistributionGenerator(T mean, T stddev) : mean_(mean), stddev_(stddev) {
+		assert(stddev_ >= 0);
+	}
+
+	// NOTE: Currently this retries instead of clamping to the interval.
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		assert(low < high);
+		T v;
+		while(true) {
+			T u1 = Random::real64(rng);
+			T u2 = Random::real64(rng);
+			// Box-Muller-Methode
+			// https://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform
+			v = std::sqrt(-2.0l * std::log(u1)) * std::cos(2.0l * cpp20::PI * u2);
+			v = std::sqrt(stddev_) * v + mean_;
+			if(v >= low && v < high) return v;
+			v = std::sqrt(-2.0l * std::log(u1)) * std::sin(2.0l * cpp20::PI * u2);
+			v = std::sqrt(stddev_) * v + mean_;
+			if(v >= low && v < high) return v;
+		}
+		return v;
+	}
+};
+
+struct ExponentialDistributionGenerator {
+	static constexpr std::string_view name = "exponential";
+	using T                                = long double;
+	using Args                             = std::tuple<T>;
+
+	T lambda_;
+
+	explicit ExponentialDistributionGenerator(T lambda) : lambda_(lambda) { assert(lambda_ > 0); }
+
+	// NOTE: Currently this retries instead of clamping to the interval.
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		assert(low < high);
+		T v;
+		while(true) {
+			v = low - std::log(Random::real64(rng)) / lambda_;
+			if(v < high) return v;
+		}
+	}
+};
+
+struct GeometricDistributionGenerator {
+	static constexpr std::string_view name = "geometric";
+	using T                                = long long;
+	using Args                             = std::tuple<long double>;
+
+	double p_;
+
+	explicit GeometricDistributionGenerator(double p) : p_(p) {
+		assert(p_ > 0);
+		assert(p_ < 1);
+	}
+
+	// NOTE: Currently this retries instead of clamping to the interval.
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		assert(low <= high);
+		T v;
+		while(true) {
+			// https://en.wikipedia.org/wiki/Geometric_distribution
+			// "The exponential distribution is the continuous analogue of the geometric
+			// distribution[...]"
+			v = low + std::floor(std::log(Random::real64(rng)) / std::log1p(-p_));
+			if(v <= high) return v;
+		}
+	}
+};
+
+struct BinomialDistributionGenerator {
+	static constexpr std::string_view name = "binomial";
+	using T                                = long long;
+	using Args                             = std::tuple<long long, long double>;
+
+	long long n_;
+	double p_;
+
+	explicit BinomialDistributionGenerator(long long n, double p) : n_(n), p_(p) {
+		assert(p_ >= 0);
+		assert(p_ <= 1);
+		std::cerr << "Warning: Large n (" << n_ << ") is slow for BinomialDistributionGenerator!"
+		          << std::endl;
+	}
+
+	// NOTE: Currently this retries instead of clamping to the interval.
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		assert(low <= high);
+		// this will be slow for large n
+		// (a faster implementation requires efficient poisson sampling)
+		while(true) {
+			T v = 0;
+			for(long long i = 0; i < n_; i++) {
+				v += Random::real64(rng) < p_ ? 1 : 0;
+			}
+			if(v >= low && v <= high) return v;
+		}
+	}
+};
+
+template <typename T>
+struct ChoiceGenerator {
+	using GeneratorType = std::conditional_t<
+	    std::is_same_v<T, long long>,
+	    std::variant<ConstGenerator<T>, MinGenerator, MaxGenerator, UniformGenerator,
+	                 RangeGenerator<T>, StepRangeGenerator<T>, GeometricDistributionGenerator,
+	                 BinomialDistributionGenerator>,
+	    std::variant<ConstGenerator<T>, MinGenerator, MaxGenerator, UniformGenerator,
+	                 RangeGenerator<T>, StepRangeGenerator<T>, NormalDistributionGenerator,
+	                 ExponentialDistributionGenerator>>;
+
+	std::vector<std::pair<GeneratorType, double>> generators_;
+	double total_weight_;
+
+	template <typename>
+	struct Pack {};
+
+	template <typename A>
+	static A parse_number(std::string_view s) {
+		static_assert(is_number_v<A>);
+		if constexpr(std::is_same_v<A, long long>)
+			return stoll(std::string(s));
+		else
+			return stold(std::string(s));
+	}
+
+	template <typename A>
+	static A parse_argument(std::string_view& s) {
+		auto end = s.find_first_of(",)");
+		assert(end != std::string_view::npos);
+		auto v = parse_number<A>(s.substr(0, end));
+		s.remove_prefix(end);
+		// Pop the trailing , or )
+		s.remove_prefix(1);
+		return v;
+	}
+
+	template <typename... As>
+	static std::tuple<As...> parse_arguments(std::string_view& s,
+	                                         Pack<std::tuple<As...>> /*unused*/) {
+		std::tuple<As...> args{parse_argument<As>(s)...};
+		return args;
+	}
+
+	// Try parsing one generator type from the start of s.
+	template <typename G>
+	static void parse_generator(std::string_view& s, std::optional<GeneratorType>& out) {
+		if(out) return;
+		if(s.substr(0, G::name.size()) != G::name) return;
+
+		// Drop the name.
+		s.remove_prefix(G::name.size());
+		if constexpr(std::tuple_size_v<typename G::Args> == 0) {
+			out.emplace(std::in_place_type_t<G>{});
+			return;
+		}
+
+		// Drop the (
+		assert(not s.empty() and s.front() == '(');
+		s.remove_prefix(1);
+
+		auto args = parse_arguments(s, Pack<typename G::Args>{});
+		// Construct the resulting generator in-place in the variant..
+		std::apply([&](const auto&... _args) { out.emplace(std::in_place_type_t<G>{}, _args...); },
+		           args);
+	}
+
+	template <typename... Gs>
+	static std::optional<GeneratorType> parse_generators(std::string_view& s,
+	                                                     Pack<std::variant<Gs...>> /*unused*/) {
+		std::optional<GeneratorType> out;
+		(parse_generator<Gs>(s, out), ...);
+		return out;
+	}
+
+	explicit ChoiceGenerator(std::string_view s) : total_weight_(0) {
+		// PARSE
+		while(not s.empty()) {
+			auto generator = parse_generators(s, Pack<GeneratorType>{});
+			if(!generator) {
+				// Check for range syntax:
+				auto comma = s.find_first_of(",:");
+				if(comma == std::string::npos) comma = s.size();
+				auto dots = s.find("..");
+				if(dots != std::string_view::npos and dots < comma) {
+					auto start = s.substr(0, dots);
+					auto end   = s.substr(dots + 2, comma - dots - 2);
+
+					generator.emplace(std::in_place_type_t<RangeGenerator<T>>{},
+					                  parse_number<T>(start), parse_number<T>(end));
+					s.remove_prefix(comma);
+				}
+
+				// Fall back to constant.
+				if(!generator) {
+					generator.emplace(std::in_place_type_t<ConstGenerator<T>>{},
+					                  parse_number<T>(s.substr(0, comma)));
+					s.remove_prefix(comma);
+				}
+			}
+
+			// Parse weight if given.
+			double weight = 1;
+			if(not s.empty() and s.front() == ':') {
+				s.remove_prefix(1);
+				auto comma = s.find(',');
+				if(comma == std::string_view::npos) comma = s.size();
+				weight = parse_number<long double>(s.substr(0, comma));
+				s.remove_prefix(comma);
+			}
+
+			// should now be at , or end
+			assert(s.empty() or s.front() == ',');
+			if(not s.empty()) s.remove_prefix(1);
+			generators_.emplace_back(std::move(*generator), weight);
+			total_weight_ += weight;
+		}
+	}
+
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		Generators::UniformGenerator uniform;
+		double x = uniform.operator()<long double>(0, total_weight_, rng);
+		for(size_t i = 0; i < generators_.size(); ++i) {
+			x -= generators_[i].second;
+			if(x <= 0)
+				return std::visit([&](auto& g) { return g(low, high, rng); }, generators_[i].first);
+		}
+		assert(false);
+	}
+};
+
+struct ParamGenerator {
+	std::variant<std::string_view, ChoiceGenerator<long long>, ChoiceGenerator<long double>>
+	    generator;
+	explicit ParamGenerator(std::string_view s) : generator(s) {}
+
+	template <typename T>
+	T operator()(T low, T high, std::mt19937_64& rng) {
+		static_assert(is_number_v<T>);
+		if(std::holds_alternative<std::string_view>(generator)) {
+			generator = ChoiceGenerator<T>(std::get<std::string_view>(generator));
+		}
+		return std::get<ChoiceGenerator<T>>(generator)(low, high, rng);
+	}
+};
+
+} // namespace Generators
+
+using Generators::ParamGenerator;
+
+namespace Random {
+template <class RandomIt>
+void shuffle(RandomIt first, RandomIt last, std::mt19937_64& rng) {
+	Generators::UniformGenerator uniform;
+	long long n = last - first;
+	for(long long i = n - 1; i > 0; i--) {
+		std::swap(first[i], first[uniform(0ll, i, rng)]);
+	}
+}
+
+template <class T>
+void shuffle(std::pair<T, T>& in, std::mt19937_64& rng) {
+	if(bit(rng)) std::swap(in.first, in.second);
+}
+
+template <class RandomIt>
+auto& select(RandomIt first, RandomIt last, std::mt19937_64& rng) {
+	assert(first != last);
+	Generators::UniformGenerator uniform;
+	long long n = last - first;
+	return first[uniform(0ll, n - 1, rng)];
+}
+
+template <class T>
+const T& select(const std::pair<T, T>& in, std::mt19937_64& rng) {
+	return bit(rng) ? in.first : in.second;
+}
+
+template <class T>
+T& select(std::pair<T, T>& in, std::mt19937_64& rng) {
+	return bit(rng) ? in.first : in.second;
+}
+
+} // namespace Random
+
+class Validator {
+  protected:
+	Validator(bool ws_, bool case_, std::istream& in_, std::string constraints_file_path_ = "",
+	          std::optional<unsigned int> seed                        = std::nullopt,
+	          std::unordered_map<std::string, ParamGenerator> params_ = {})
+	    : in(in_), ws(ws_), case_sensitive(case_),
+	      constraints_file_path(std::move(constraints_file_path_)), gen(seed.has_value()),
+	      rng(seed.value_or(Random::default_seed)), params(std::move(params_)) {
+
+		std::ios_base::sync_with_stdio(false);
+		in.tie(nullptr);
+
+		if(gen) return;
+		if(ws)
+			in >> std::noskipws;
+		else
+			in >> std::skipws;
+
+		if(!constraints_file_path.empty()) {
+			assert(has_source_location); // NOLINT
+		}
+	}
+
+  public:
+	// No copying, no moving.
+	Validator(const Validator&) = delete;
+	Validator(Validator&&)      = delete;
+	void operator=(const Validator&) = delete;
+	void operator=(Validator&&) = delete;
+
+	// At the end of the scope, check whether the EOF has been reached.
+	// If so, return AC. Otherwise, return WA.
+	~Validator() {
+		eof();
+		write_constraints();
+		AC();
+	}
+
+	void space() {
+		if(gen) {
+			out << ' ';
+			return;
+		}
+
+		if(ws) {
+			char c;
+			in >> c;
+			check(!in.eof(), "Expected space, found EOF.");
+			if(c != ' ')
+				expected("space", std::string("\"") +
+				                      ((c == '\n' or c == '\r') ? std::string("newline")
+				                                                : std::string(1, c)) +
+				                      "\"");
+		}
+	}
+
+	void newline() {
+		if(gen) {
+			out << '\n';
+			return;
+		}
+
+		if(ws) {
+			char c;
+			in >> c;
+			check(!in.eof(), "Expected newline, found EOF.");
+			if(c != '\n') {
+				if(c == '\r')
+					expected("newline", "DOS line ending (\\r)");
+				else
+					expected("newline", std::string("\"") + c + "\"");
+			}
+		}
+	}
+
+  private:
+	void separator(Separator s) {
+		switch(s) {
+		case Separator::Space: space(); break;
+		case Separator::Newline: newline(); break;
+		}
+	}
+
+	template <typename T>
+	auto& seen() {
+		static std::map<source_location, std::set<T>> seen;
+		return seen;
+	}
+	template <typename T>
+	auto& last_seen() {
+		static std::map<source_location, T> last_seen;
+		return last_seen;
+	}
+	template <typename T>
+	auto& integers_seen() {
+		static std::map<source_location, std::tuple<std::set<T>, std::vector<T>, bool>>
+		    integers_seen;
+		return integers_seen;
+	}
+	template <typename T>
+	void reset(source_location loc) {
+		seen<T>().erase(loc);
+		last_seen<T>().erase(loc);
+		integers_seen<T>().erase(loc);
+	}
+
+	template <typename T, typename Tag>
+	void check_number(const std::string& name, T low, T high, T v, Tag /*unused*/,
+	                  source_location loc) {
+		static_assert(is_number_v<T>);
+		if(v < low or v > high) {
+			std::string type_name;
+			if constexpr(std::is_integral_v<T>) {
+				type_name = "integer";
+			}
+			if constexpr(std::is_floating_point_v<T>) {
+				type_name = "float";
+			}
+			expected(name + ": " + type_name + " between " + std::to_string(low) + " and " +
+			             std::to_string(high),
+			         std::to_string(v));
+		}
+		log_constraint(name, low, high, v, loc);
+		if constexpr(Tag::unique) {
+			auto [it, inserted] = seen<T>()[loc].emplace(v);
+			check(inserted, name, ": Value ", v, " seen twice, but must be unique!");
+		} else {
+			auto [it, inserted] = last_seen<T>().emplace(loc, v);
+			if(inserted) return;
+
+			auto last  = it->second;
+			it->second = v;
+
+			if constexpr(Tag::increasing)
+				check(v >= last, name, " is not increasing: value ", v, " follows ", last);
+			if constexpr(Tag::decreasing)
+				check(v <= last, name, " is not decreasing: value ", v, " follows ", last);
+			if constexpr(Tag::strict)
+				check(v != last, name, " is not strict: value ", v, " equals ", last);
+		}
+	}
+
+	template <typename Tag>
+	void check_string(const std::string& name, int low, int high, const std::string& v,
+	                  Tag /*unused*/, source_location loc) {
+		using T = std::string;
+		if((int) v.size() < low or (int) v.size() > high) {
+			expected(name + ": " + "string with" + " length between " + std::to_string(low) +
+			             " and " + std::to_string(high),
+			         v);
+		}
+		log_constraint(name, low, high, static_cast<int>(v.size()), loc);
+		if constexpr(Tag::unique) {
+			// static map<source_location, set<T>> seen;
+			auto [it, inserted] = seen<T>()[loc].emplace(v);
+			check(inserted, name, ": Value ", v, " seen twice, but must be unique!");
+		} else if(Tag::increasing or Tag::decreasing) {
+			// static map<source_location, T> last_seen;
+			auto [it, inserted] = last_seen<T>().emplace(loc, v);
+			if(inserted) return;
+
+			auto last  = it->second;
+			it->second = v;
+
+			if constexpr(Tag::increasing)
+				check(v >= last, name, " is not increasing: value ", v, " follows ", last);
+			if constexpr(Tag::decreasing)
+				check(v <= last, name, " is not decreasing: value ", v, " follows ", last);
+			if constexpr(Tag::strict)
+				check(v != last, name, " is not strict: value ", v, " equals ", last);
+		}
+	}
+
+	// Generate a random integer in [low, high] or float in [low, high).
+	template <typename T>
+	T uniform_number(T low, T high) {
+		assert(low <= high);
+		Generators::UniformGenerator uniform;
+		if constexpr(std::is_integral<T>::value)
+			return uniform.operator()<long long>(low, high, rng);
+		else
+			return uniform.operator()<long double>(low, high, rng);
+	}
+
+	template <typename T, typename Tag>
+	T gen_number(const std::string& name, T low, T high, Tag /*unused*/, source_location loc) {
+		static_assert(is_number_v<T>);
+		T v;
+
+		if constexpr(Tag::unique) {
+			assert(params.find(name) == params.end() &&
+			       "Parameters are not supported for unique values.");
+			if constexpr(std::is_integral<T>::value) {
+				auto& [seen_here, remaining_here, use_remaining] = integers_seen<T>()[loc];
+
+				if(use_remaining) {
+					check(!remaining_here.empty(), name, ": no unique values left");
+					v = remaining_here.back();
+					remaining_here.pop_back();
+				} else {
+					do {
+						v = uniform_number(low, high);
+					} while(!seen_here.insert(v).second);
+
+					struct CountIterator {
+						T v;
+						T& operator*() { return v; }
+						T& operator++() { return ++v; }
+						T operator++(int) { return v++; }
+						bool operator!=(CountIterator r) { return v != r.v; }
+					};
+
+					if(seen_here.size() > (high - low) / 2) {
+						use_remaining = true;
+						set_difference(CountIterator{low}, CountIterator{high + 1},
+						               seen_here.begin(), seen_here.end(),
+						               std::back_inserter(remaining_here));
+					}
+				}
+			} else {
+				// For floats, just regenerate numbers until success.
+				auto& seen_here = seen<T>()[loc];
+				do {
+					v = uniform_number(low, high);
+				} while(!seen_here.insert(v).second);
+			}
+
+		} else {
+			assert(not Tag::increasing && "Generating increasing sequences is not yet supported!");
+			assert(not Tag::decreasing && "Generating decreasing sequences is not yet supported!");
+			assert((std::is_same<Tag, ArbitraryTag>::value) &&
+			       "Only Unique and Arbitrary are supported!");
+
+			if(params.find(name) != params.end()) {
+				v = params.at(name).operator()<T>(low, high, rng);
+				// This will be checked during input validation of the generated case.
+				// assert(low <= v and v <= high);
+			} else {
+				v = uniform_number<T>(low, high);
+			}
+		}
+
+		return v;
+	}
+
+	std::string gen_string(const std::string& name, long long low, long long high,
+	                       std::string_view chars) {
+		assert(!chars.empty());
+
+		int len;
+		if(params.find(name + ".length") != params.end())
+			len = params.at(name + ".length").operator()<long long>(low, high, rng);
+		else
+			len = uniform_number(low, high);
+		std::string s(len, ' ');
+		for(auto& x : s) x = chars[uniform_number<int>(0, chars.size() - 1)];
+
+		out << s;
+		return s;
+	}
+
+  public:
+	template <typename Tag = ArbitraryTag>
+	long long gen_integer(const std::string& name, long long low, long long high, Tag tag = Tag{},
+	                      source_location loc = source_location::current()) {
+		return gen_number(name, low, high, tag, loc);
+	}
+
+	template <typename Tag = ArbitraryTag>
+	long double gen_float(const std::string& name, long double low, long double high,
+	                      Tag tag = Tag{}, source_location loc = source_location::current()) {
+		return gen_number(name, low, high, tag, loc);
+	}
+
+  private:
+	template <typename T, typename Tag>
+	std::vector<T> gen_numbers(const std::string& name, int count, T low, T high, Tag /*unused*/,
+	                           source_location loc) {
+		static_assert(is_number_v<T>);
+		std::vector<T> v;
+		v.reserve(count);
+		if constexpr(std::is_same_v<Tag, ArbitraryTag>) {
+			if(params.find(name) != params.end()) {
+				auto& generator = params.at(name);
+				for(int i = 0; i < count; ++i) {
+					auto val = generator.operator()<T>(low, high, rng);
+					assert(low <= val and val <= high);
+					v.push_back(val);
+				}
+			} else {
+				for(int i = 0; i < count; ++i) {
+					v.push_back(uniform_number<T>(low, high));
+				}
+			}
+		} else if constexpr(Tag::unique) {
+			assert(params.find(name) == params.end() &&
+			       "Parameters are not supported for unique values.");
+			std::set<T> seen_here;
+			if constexpr(std::is_integral_v<T>) {
+				if(2 * count < high - low) {
+					for(int i = 0; i < count; ++i) {
+						// If density < 1/2: retry.
+						T w;
+						do {
+							w = uniform_number(low, high);
+						} while(!seen_here.insert(w).second);
+						v.push_back(w);
+					}
+				} else {
+					// If density >= 1/2, crop a random permutation.
+					v.resize(high - low + 1);
+					iota(begin(v), end(v), low);
+					Random::shuffle(begin(v), end(v), rng);
+					v.resize(count);
+				}
+			} else {
+				for(int i = 0; i < count; ++i) {
+					// For floats, just regenerate numbers until success.
+					T w;
+					do {
+						w = uniform_number(low, high);
+					} while(!seen_here.insert(w).second);
+					v.push_back(w);
+				}
+			}
+		} else {
+			static_assert(Tag::increasing or Tag::decreasing);
+
+			constexpr bool integral_strict = Tag::strict and std::is_integral<T>::value;
+			if(integral_strict) {
+				assert(params.find(name) == params.end() &&
+				       "Parameters are not supported for strict integer values.");
+				high = high - count + 1;
+			}
+
+			if(params.find(name) != params.end()) {
+				auto& generator = params.at(name);
+				for(int i = 0; i < count; ++i) {
+					auto val = generator.operator()<T>(low, high, rng);
+					assert(low <= val and val <= high);
+					v.push_back(val);
+				}
+			} else {
+				for(int i = 0; i < count; ++i) {
+					v.push_back(uniform_number<T>(low, high));
+				}
+			}
+
+			sort(begin(v), end(v));
+
+			if(integral_strict) {
+				for(int i = 0; i < count; ++i) v[i] += i;
+			}
+
+			if(Tag::decreasing) reverse(begin(v), end(v));
+		}
+
+		return v;
+	}
+
+  public:
+	template <typename Tag = ArbitraryTag>
+	std::vector<long long> gen_integers(const std::string& name, int count, long long low,
+	                                    long long high, Tag tag = Tag{},
+	                                    source_location loc = source_location::current()) {
+		return gen_numbers(name, count, low, high, tag, loc);
+	}
+
+	template <typename Tag = ArbitraryTag>
+	std::vector<long double> gen_floats(const std::string& name, int count, long double low,
+	                                    long double high, Tag tag = Tag{},
+	                                    source_location loc = source_location::current()) {
+		return gen_numbers(name, count, low, high, tag, loc);
+	}
+
+  private:
+	template <typename T, typename Tag>
+	T read_number(const std::string& name, T low, T high, Tag tag, source_location loc) {
+		if(gen) {
+			auto v = gen_number(name, low, high, tag, loc);
+			out << std::setprecision(10) << std::fixed << v;
+			return v;
+		}
+
+		const auto v = [&] {
+			if constexpr(std::is_integral<T>::value)
+				return read_integer(name);
+			else
+				return read_float(name);
+		}();
+
+		check_number(name, low, high, v, tag, loc);
+		return v;
+	}
+
+	// Read a vector of numbers, separated by spaces and ended by a newline.
+	template <typename T, typename Tag>
+	std::vector<T> read_numbers(const std::string& name, int count, T low, T high, Tag tag,
+	                            Separator sep, source_location loc) {
+		if(gen) {
+			auto v = gen_numbers(name, count, low, high, tag, loc);
+
+			out << std::setprecision(10) << std::fixed;
+			for(int i = 0; i < count; ++i) {
+				out << v[i];
+				if(i < count - 1) separator(sep);
+			}
+			newline();
+
+			return v;
+		}
+		reset<T>(loc);
+		std::vector<T> v(count);
+		for(int i = 0; i < count; ++i) {
+			if constexpr(std::is_integral<T>::value)
+				v[i] = read_integer(name);
+			else
+				v[i] = read_float(name);
+			check_number(name, low, high, v[i], tag, loc);
+			if(i < count - 1) separator(sep);
+		}
+		newline();
+		return v;
+	}
+
+  public:
+	template <typename Tag = ArbitraryTag>
+	long long read_integer(const std::string& name, long long low, long long high, Tag tag = Tag{},
+	                       source_location loc = source_location::current()) {
+		return read_number(name, low, high, tag, loc);
+	}
+	template <typename Tag = ArbitraryTag>
+	std::vector<long long> read_integers(const std::string& name, int count, long long low,
+	                                     long long high, Tag tag = Tag{}, Separator sep = Space,
+	                                     source_location loc = source_location::current()) {
+		return read_numbers(name, count, low, high, tag, sep, loc);
+	}
+
+	template <typename Tag = ArbitraryTag>
+	long double read_float(const std::string& name, long double low, long double high,
+	                       Tag tag = Tag{}, source_location loc = source_location::current()) {
+		return read_number(name, low, high, tag, loc);
+	}
+	template <typename Tag = ArbitraryTag>
+	std::vector<long double> read_floats(const std::string& name, int count, long double low,
+	                                     long double high, Tag tag = Tag{}, Separator sep = Space,
+	                                     source_location loc = source_location::current()) {
+		return read_numbers(name, count, low, high, tag, sep, loc);
+	}
+
+	// Read a vector of strings, separated by spaces and ended by a newline.
+	template <typename Tag = ArbitraryTag>
+	std::vector<std::string> read_strings(const std::string& name, int count, int min, int max,
+	                                      const std::string_view chars = "", Tag tag = Tag(),
+	                                      Separator sep       = Space,
+	                                      source_location loc = source_location::current()) {
+		reset<std::string>(loc);
+		if(gen) return gen_strings(name, count, min, max, chars, tag, sep, loc);
+		assert(!gen);
+		std::vector<std::string> v(count);
+		for(int i = 0; i < count; ++i) {
+			v[i] = read_string(name, min, max, chars, tag, loc);
+			if(i < count - 1) separator(sep);
+		}
+		newline();
+		return v;
+	}
+
+	template <typename Tag>
+	std::vector<std::string> gen_strings(const std::string& name, int count, int min, int max,
+	                                     const std::string_view chars, Tag /*unused*/,
+	                                     Separator sep, source_location loc) {
+		assert(!chars.empty());
+
+		std::vector<std::string> v(count);
+		if constexpr(std::is_same<Tag, ArbitraryTag>::value) {
+			for(int i = 0; i < count; ++i) {
+				std::string s(uniform_number(min, max), ' ');
+				for(auto& x : s) x = chars[uniform_number<int>(0, chars.size() - 1)];
+				v.push_back(s);
+				out << s;
+				if(i < count - 1) separator(sep);
+			}
+		} else if constexpr(Tag::unique) {
+			std::set<std::string> seen_here;
+			for(int i = 0; i < count; ++i) {
+				// Just regenerate strings until success.
+				std::string s;
+				do {
+					s = std::string(uniform_number(min, max), ' ');
+					for(auto& x : s) x = chars[uniform_number<int>(0, chars.size() - 1)];
+				} while(!seen_here.insert(s).second);
+				v.push_back(s);
+				out << s;
+				if(i < count - 1) separator(sep);
+			}
+		} else {
+			static_assert(Tag::increasing or Tag::decreasing);
+
+			assert(false && "Generating increasing/decreasing lists of strings is not "
+			                "supported!");
+		}
+
+		newline();
+
+		return v;
+	}
+
+	// Check the next character.
+	bool peek(char c, const std::string& name = "") {
+		if(gen) {
+			// TODO
+			// if(not name.empty() and params.contains(name)) {
+			// return c == params.at(name).operator()<char>(0, 0, rng);
+			//}
+			return Random::bit(rng);
+		}
+		if(!ws) in >> std::ws;
+		if(case_sensitive) return in.peek() == std::char_traits<char>::to_int_type(c);
+		return tolower(in.peek()) == tolower(std::char_traits<char>::to_int_type(c));
+	}
+
+	// Read a string and make sure it equals `expected`.
+	// Takes by value because it needs to lowercase its arguments.
+	std::string test_strings(std::vector<std::string> expected, const std::string& name = "") {
+		if(gen) {
+			int index = 0;
+			// TODO
+			// if(not name.empty() and params.contains(name)) {
+			// auto s = params.at(name).operator()<std::string>(0, 0, rng);
+			// index  = std::find(expected.begin(), expected.end(), s) - expected.begin();
+			// assert(0 <= index and index < expected.size());
+			//} else {
+			index = expected.size() == 1 ? 0 : uniform_number<int>(0, expected.size() - 1);
+			//}
+			out << expected[index];
+			return expected[index];
+		}
+		std::string s = get_string();
+		lowercase(s);
+
+		for(std::string e : expected)
+			if(s == lowercase(e)) return s;
+
+		std::string error;
+		for(const auto& e : expected) {
+			if(not error.empty()) error += "|";
+			error += e;
+		}
+		WA("Expected string \"", error, "\", but found ", s);
+	}
+
+	// Read a string and make sure it equals `expected`.
+	std::string test_string(std::string expected, const std::string& name = "") {
+		return test_strings({std::move(expected)}, name);
+	}
+
+	// Read an arbitrary string of a given length.
+	template <typename Tag = ArbitraryTag>
+	std::string read_string(const std::string& name, long long min, long long max,
+	                        const std::string_view chars = "", Tag tag = Tag(),
+	                        source_location loc = source_location::current()) {
+		if(gen) {
+			return gen_string(name, min, max, chars);
+		}
+		std::string s = get_string();
+		std::array<bool, 256> ok_char{};
+		if(!chars.empty()) {
+			for(auto c : chars) ok_char[c] = true;
+			for(auto c : s)
+				check(ok_char[c], name, ": expected characters in ", chars, " but found character ",
+				      c, " in ", s);
+		}
+		check_string(name, min, max, s, tag, loc);
+		return s;
+	}
+
+	// Read an arbitrary line of a given length.
+	std::string read_line(const std::string& name, long long min, long long max,
+	                      const std::string_view chars = "",
+	                      source_location loc          = source_location::current()) {
+		if(gen) {
+			// TODO: Params for lines.
+			assert(!chars.empty());
+
+			std::string s(uniform_number(min, max), ' ');
+			for(auto& x : s) x = chars[uniform_number<int>(0, chars.size() - 1)];
+
+			out << s << '\n';
+			return s;
+		}
+
+		if(ws) {
+			char next = in.peek();
+			if(min > 0 and isspace(next))
+				expected("non empty line", next == '\n' ? "newline" : "whitespace");
+			if(in.eof()) expected("line", "EOF");
+		}
+		std::string s;
+		if(!getline(in, s)) expected("line", "nothing");
+		long long size = s.size();
+		if(size < min || size > max)
+			expected(name + ": line of length between " + std::to_string(min) + " and " +
+			             std::to_string(max),
+			         s);
+		std::array<bool, 256> ok_char{};
+		if(!chars.empty()) {
+			for(auto c : chars) ok_char[c] = true;
+			for(auto c : s)
+				check(ok_char[c], name, ": expected characters in ", chars, " but found character ",
+				      c, " in ", s);
+		}
+		log_constraint(name, min, max, size, loc);
+		return s;
+	}
+
+	// Return ACCEPTED verdict.
+	void eof_and_AC() {
+		eof();
+		AC();
+	}
+
+  private:
+	std::function<void()> WA_handler = [] {};
+
+  public:
+	void set_WA_handler(std::function<void()> f) { WA_handler = std::move(f); }
+
+	// Return WA with the given reason.
+	template <typename... Ts>
+	[[noreturn]] void WA(const Ts&... ts) {
+		static_assert(sizeof...(Ts) > 0);
+
+		WA_handler();
+
+		auto pos = get_file_pos();
+		std::cerr << pos.first << ":" << pos.second << ": ";
+
+		WA_impl(ts...);
+	}
+
+	// Check that the condition is true.
+	template <typename... Ts>
+	void check(bool b, const Ts&... ts) {
+		static_assert(sizeof...(Ts) > 0, "Provide a non-empty error message.");
+
+		if(!b) WA(ts...);
+	}
+
+	// Log some value in a range.
+	template <typename T>
+	void log_constraint(const std::string& name, T low, T high, T v,
+	                    source_location loc = source_location::current()) {
+		// Do not log when line number is unknown/default/unsupported.
+		if(loc.line() == 0 or constraints_file_path.empty()) return;
+
+		// All integer types get bounds as long long, all floating point types as long_double.
+		using U = Bounds<std::conditional_t<std::is_integral_v<T>, long long, long double>>;
+
+		auto [it, inserted] = bounds.emplace(loc, U(name, v, v, low, high));
+		assert(std::holds_alternative<U>(it->second));
+		auto& done = std::get<U>(it->second);
+		if(inserted) {
+			assert(!name.empty() && "Variable names must not be empty.");
+			assert(name.find(' ') == std::string::npos && "Variable name must not contain spaces.");
+		} else {
+			assert(name == done.name && "Variable name must be constant.");
+		}
+		if(v < done.min) {
+			done.min = v;
+			done.low = low;
+		}
+		if(v > done.max) {
+			done.max  = v;
+			done.high = high;
+		}
+		done.has_min |= v == low;
+		done.has_max |= v == high;
+	}
+
+  private:
+	long long read_integer(const std::string& name) {
+		assert(!gen);
+		std::string s = get_string("integer");
+		if(s.empty()) {
+			WA(name, ": Want integer, found nothing");
+		}
+		long long v;
+		auto begin = s.c_str(), end = begin + s.size();
+		auto [ptr, ec] = std::from_chars(begin, end, v);
+		if(ec == std::errc::result_out_of_range){
+			WA(name, ": Number " + s + " does not fit in a long long!");
+		} else if(ptr != end) {
+			WA(name, ": Parsing " + s + " as long long failed! Did not process all characters");
+		} else if (ec != std::errc{}) {
+			WA(name, ": Parsing " + s + " as long long failed!");
+		}
+		// Check for leading zero.
+		if(v == 0) {
+			if(s.size() != 1) WA(name, ": Parsed 0, but has leading 0 or minus sign: ", s);
+		}
+		if(v > 0) {
+			if(s[0] == '0') WA(name, ": Parsed ", v, ", but has leading 0: ", s);
+		}
+		if(v < 0) {
+			if(s.size() <= 1) WA(name, ": Parsed ", v, ", but string is: ", s);
+			if(s[1] == '0') WA(name, ": Parsed ", v, ", but has leading 0: ", s);
+		}
+		return v;
+	}
+
+	long double read_float(const std::string& name) {
+		assert(!gen);
+		std::string s = get_string("long double");
+		long double v;
+		try {
+			size_t chars_processed;
+			v = stold(s, &chars_processed);
+			if(chars_processed != s.size())
+				WA(name, ": Parsing ", s,
+				   " as long double failed! Did not process all characters.");
+		} catch(const std::out_of_range& e) {
+			WA(name, ": Number " + s + " does not fit in a long double!");
+		} catch(const std::invalid_argument& e) {
+			WA("Parsing " + s + " as long double failed!");
+		}
+		return v;
+	}
+
+	[[noreturn]] void expected(const std::string& exp = "", const std::string& s = "") {
+		assert(!gen && "Expected is not supported for generators.");
+		if(!s.empty())
+			WA("Expected ", exp, ", found ", s);
+		else
+			WA(exp);
+	}
+
+	template <typename T>
+	[[noreturn]] void WA_impl(T t) {
+		std::cerr << t << std::endl;
+		exit(ret_WA);
+	}
+
+	std::pair<int, int> get_file_pos() {
+		int line = 1, col = 0;
+		in.clear();
+		auto originalPos = in.tellg();
+		if(originalPos < 0) return {-1, -1};
+		in.seekg(0);
+		char c;
+		while((in.tellg() < originalPos) && in.get(c)) {
+			if(c == '\n')
+				++line, col = 0;
+			else
+				++col;
+		}
+		return {line, col};
+	}
+
+	template <typename T, typename... Ts>
+	[[noreturn]] void WA_impl(T t, Ts... ts) {
+		std::cerr << t;
+		WA_impl(ts...);
+	}
+
+	std::string get_string(const std::string& wanted = "string") {
+		assert(!gen && "get_string is not supported for generators.");
+		if(ws) {
+			char next = in.peek();
+			if(isspace(next)) expected(wanted, next == '\n' ? "newline" : "whitespace");
+			if(in.eof()) expected(wanted, "EOF");
+		}
+
+		std::string s;
+		if(in >> s) {
+			return s;
+		}
+		expected(wanted, "nothing");
+	}
+
+	// Return ACCEPTED verdict.
+	void AC() const {
+		if(gen) {
+			// nothing
+			return;
+		}
+
+		exit(ret_AC);
+	}
+
+	void eof() {
+		if(gen) {
+			out.flush();
+			fclose(stdout);
+			return;
+		}
+		if(in.eof()) return;
+		// Sometimes EOF hasn't been triggered yet.
+		if(!ws) in >> std::ws;
+		char c = in.get();
+		if(c == std::char_traits<char>::eof()) return;
+		std::string got = std::string("\"") + char(c) + '"';
+		if(c == '\n') got = "newline";
+		expected("EOF", got);
+	}
+
+	// Convert a string to lowercase is matching is not case sensitive.
+	std::string& lowercase(std::string& s) const {
+		if(case_sensitive) return s;
+		transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return std::tolower(c); });
+		return s;
+	}
+
+	// Keep track of the min/max value read at every call site.
+	template <typename T>
+	struct Bounds {
+		Bounds(std::string name_, T min_, T max_, T low_, T high_)
+		    : name(std::move(name_)), min(min_), max(max_), low(low_), high(high_) {} // NOLINT
+		std::string name;
+		T min, max;  // Smallest / largest value observed
+		T low, high; // Bounds
+		bool has_min = false, has_max = false;
+	};
+
+	std::map<source_location, std::variant<Bounds<long long>, Bounds<long double>>> bounds;
+
+	void write_constraints() {
+		if(constraints_file_path.empty()) return;
+
+		std::ofstream os(constraints_file_path);
+
+		for(const auto& [location, bound] : bounds) {
+			os << location_to_string(location) << " ";
+			std::visit(
+			    [&](const auto& b) {
+				    os << b.name << " " << b.has_min << " " << b.has_max << " " << b.min << " "
+				       << b.max << " " << b.low << " " << b.high << std::endl;
+			    },
+			    bound);
+		}
+	}
+
+	static const int ret_AC = 42, ret_WA = 43;
+	std::istream& in  = std::cin;
+	std::ostream& out = std::cout;
+
+  public:
+	const bool ws             = true;
+	const bool case_sensitive = true;
+	const std::string constraints_file_path;
+	const bool gen = false;
+
+	std::mt19937_64 rng;
+
+  private:
+	std::unordered_map<std::string, ParamGenerator> params;
+
+  public:
+	std::string_view get_param(std::string_view name, std::string_view default_) {
+		auto it = params.find(std::string(name));
+		if(it == params.end()) return default_;
+		return std::get<std::string_view>(it->second.generator);
+	}
+
+  protected:
+	static std::string get_constraints_file(int argc, char** argv) {
+		for(int i = 1; i < argc; ++i) {
+			if(argv[i] == constraints_file_flag) {
+				if(i + 1 < argc) return argv[i + 1];
+				std::cerr << constraints_file_flag << " should be followed by a file path!";
+				exit(1);
+			}
+		}
+		return {};
+	}
+};
+
+class Generator : public Validator {
+  public:
+	explicit Generator(unsigned int seed)
+	    : Validator(true, true, std::cin, /*constraints_file_path_=*/"", seed) {}
+};
+
+class InputValidator : public Validator {
+  public:
+	// An InputValidator is always both whitespace and case sensitive.
+	explicit InputValidator(int argc = 0, char** argv = nullptr)
+	    : Validator(true, true, std::cin, get_constraints_file(argc, argv), get_seed(argc, argv),
+	                get_params(argc, argv)) {}
+
+  private:
+	static std::optional<unsigned int> get_seed(int argc, char** argv) {
+		for(int i = 1; i < argc - 1; ++i) {
+			if(argv[i] == generate_flag) {
+				return std::stol(argv[i + 1]);
+			}
+		}
+		// If no --generate is given, but `generat` is a substring of the binary path,
+		// use the first argument as seed.
+		if(std::string(argv[0]).find(generate_binary_substring) != std::string::npos) {
+			return std::stol(argv[1]);
+		}
+		return std::nullopt;
+	}
+
+	static std::unordered_map<std::string, ParamGenerator> get_params(int argc, char** argv) {
+		std::unordered_map<std::string, ParamGenerator> params;
+		for(int i = 1; i < argc - 1; ++i) {
+			if(std::strlen(argv[i]) == 0 or argv[i][0] != '-') continue;
+			if(argv[i] == generate_flag) {
+				continue;
+			}
+			std::string_view name(argv[i] + 1);
+			std::string_view value(argv[i + 1]);
+			params.insert({std::string(name), ParamGenerator(value)});
+		}
+		return params;
+	}
+};
+
+class OutputValidator : public Validator {
+  public:
+	// An OutputValidator can be run in different modes.
+	explicit OutputValidator(int argc, char** argv, std::istream& in_ = std::cin)
+	    : Validator(is_ws_sensitive(argc, argv), is_case_sensitive(argc, argv), in_,
+	                get_constraints_file(argc, argv)) {}
+
+  private:
+	static bool is_ws_sensitive(int argc, char** argv) {
+		for(int i = 1; i < argc; ++i) {
+			if(argv[i] == ws_sensitive_flag) return true;
+		}
+		return false;
+	}
+
+	static bool is_case_sensitive(int argc, char** argv) {
+		for(int i = 1; i < argc; ++i) {
+			if(argv[i] == case_sensitive_flag) return true;
+		}
+		return false;
+	}
+};

ICPC/nwerc2022_J/data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3e980aaccf3b6013c6279a2daa2da2569b5deecf8006b706234b2af05ccb1401
+size 77274230

ICPC/nwerc2022_J/init.yml

@@ -0,0 +1,377 @@
+archive: data.zip
+test_cases:
+- in: 001-tower_overlapping.in
+  out: 001-tower_overlapping.ans
+  points: 1
+- in: 002-tower_overlapping.in
+  out: 002-tower_overlapping.ans
+  points: 1
+- in: 003-tower_overlapping.in
+  out: 003-tower_overlapping.ans
+  points: 1
+- in: 004-tower_overlapping.in
+  out: 004-tower_overlapping.ans
+  points: 1
+- in: 005-tower_overlapping.in
+  out: 005-tower_overlapping.ans
+  points: 1
+- in: 006-manual.in
+  out: 006-manual.ans
+  points: 1
+- in: 007-manual.in
+  out: 007-manual.ans
+  points: 1
+- in: 008-manual.in
+  out: 008-manual.ans
+  points: 1
+- in: 009-manual.in
+  out: 009-manual.ans
+  points: 1
+- in: 010-manual.in
+  out: 010-manual.ans
+  points: 1
+- in: 011-fuzz-small.in
+  out: 011-fuzz-small.ans
+  points: 1
+- in: 012-fuzz-small.in
+  out: 012-fuzz-small.ans
+  points: 1
+- in: 013-fuzz-small.in
+  out: 013-fuzz-small.ans
+  points: 1
+- in: 014-fuzz-small.in
+  out: 014-fuzz-small.ans
+  points: 1
+- in: 015-fuzz.in
+  out: 015-fuzz.ans
+  points: 1
+- in: 016-fuzz.in
+  out: 016-fuzz.ans
+  points: 1
+- in: 017-fuzz.in
+  out: 017-fuzz.ans
+  points: 1
+- in: 018-fuzz.in
+  out: 018-fuzz.ans
+  points: 1
+- in: 019-fuzz.in
+  out: 019-fuzz.ans
+  points: 1
+- in: 020-fuzz.in
+  out: 020-fuzz.ans
+  points: 1
+- in: 021-fuzz.in
+  out: 021-fuzz.ans
+  points: 1
+- in: 022-max-left.in
+  out: 022-max-left.ans
+  points: 1
+- in: 023-max-right.in
+  out: 023-max-right.ans
+  points: 1
+- in: 024-max-left-shufle.in
+  out: 024-max-left-shufle.ans
+  points: 1
+- in: 025-bipartite.in
+  out: 025-bipartite.ans
+  points: 1
+- in: 026-bipartite.in
+  out: 026-bipartite.ans
+  points: 1
+- in: 027-bipartite.in
+  out: 027-bipartite.ans
+  points: 1
+- in: 028-bipartite.in
+  out: 028-bipartite.ans
+  points: 1
+- in: 029-bipartite.in
+  out: 029-bipartite.ans
+  points: 1
+- in: 030-tower.in
+  out: 030-tower.ans
+  points: 1
+- in: 031-random.in
+  out: 031-random.ans
+  points: 1
+- in: 032-random.in
+  out: 032-random.ans
+  points: 1
+- in: 033-random.in
+  out: 033-random.ans
+  points: 1
+- in: 034-random.in
+  out: 034-random.ans
+  points: 1
+- in: 035-random-few-ends.in
+  out: 035-random-few-ends.ans
+  points: 1
+- in: 036-random-few-ends.in
+  out: 036-random-few-ends.ans
+  points: 1
+- in: 037-random-few-ends.in
+  out: 037-random-few-ends.ans
+  points: 1
+- in: 038-random-few-ends.in
+  out: 038-random-few-ends.ans
+  points: 1
+- in: 039-random-many-ends.in
+  out: 039-random-many-ends.ans
+  points: 1
+- in: 040-random-many-ends.in
+  out: 040-random-many-ends.ans
+  points: 1
+- in: 041-random-many-ends.in
+  out: 041-random-many-ends.ans
+  points: 1
+- in: 042-random-many-ends.in
+  out: 042-random-many-ends.ans
+  points: 1
+- in: 043-random-many-ends.in
+  out: 043-random-many-ends.ans
+  points: 1
+- in: 044-random-many-ends.in
+  out: 044-random-many-ends.ans
+  points: 1
+- in: 045-random-small.in
+  out: 045-random-small.ans
+  points: 1
+- in: 046-random-small.in
+  out: 046-random-small.ans
+  points: 1
+- in: 047-random-small.in
+  out: 047-random-small.ans
+  points: 1
+- in: 048-random-small.in
+  out: 048-random-small.ans
+  points: 1
+- in: 049-small.in
+  out: 049-small.ans
+  points: 1
+- in: 050-small.in
+  out: 050-small.ans
+  points: 1
+- in: 051-small.in
+  out: 051-small.ans
+  points: 1
+- in: 052-small.in
+  out: 052-small.ans
+  points: 1
+- in: 053-small.in
+  out: 053-small.ans
+  points: 1
+- in: 054-tower.in
+  out: 054-tower.ans
+  points: 1
+- in: 055-tower.in
+  out: 055-tower.ans
+  points: 1
+- in: 056-overlapping.in
+  out: 056-overlapping.ans
+  points: 1
+- in: 057-overlapping.in
+  out: 057-overlapping.ans
+  points: 1
+- in: 058-complete.in
+  out: 058-complete.ans
+  points: 1
+- in: 059-complete.in
+  out: 059-complete.ans
+  points: 1
+- in: 060-complete.in
+  out: 060-complete.ans
+  points: 1
+- in: 061-complete.in
+  out: 061-complete.ans
+  points: 1
+- in: 062-complete.in
+  out: 062-complete.ans
+  points: 1
+- in: 063-dense.in
+  out: 063-dense.ans
+  points: 1
+- in: 064-dense.in
+  out: 064-dense.ans
+  points: 1
+- in: 065-dense.in
+  out: 065-dense.ans
+  points: 1
+- in: 066-dense.in
+  out: 066-dense.ans
+  points: 1
+- in: 067-dense.in
+  out: 067-dense.ans
+  points: 1
+- in: 068-dense.in
+  out: 068-dense.ans
+  points: 1
+- in: 069-dense.in
+  out: 069-dense.ans
+  points: 1
+- in: 070-dense.in
+  out: 070-dense.ans
+  points: 1
+- in: 071-dense.in
+  out: 071-dense.ans
+  points: 1
+- in: 072-dense-maxn.in
+  out: 072-dense-maxn.ans
+  points: 1
+- in: 073-dense-maxn.in
+  out: 073-dense-maxn.ans
+  points: 1
+- in: 074-dense-maxn.in
+  out: 074-dense-maxn.ans
+  points: 1
+- in: 075-dense-maxn.in
+  out: 075-dense-maxn.ans
+  points: 1
+- in: 076-dense-maxn.in
+  out: 076-dense-maxn.ans
+  points: 1
+- in: 077-dense-maxn.in
+  out: 077-dense-maxn.ans
+  points: 1
+- in: 078-dense-maxn.in
+  out: 078-dense-maxn.ans
+  points: 1
+- in: 079-dense-maxn.in
+  out: 079-dense-maxn.ans
+  points: 1
+- in: 080-dense-maxn.in
+  out: 080-dense-maxn.ans
+  points: 1
+- in: 081-dense-maxn.in
+  out: 081-dense-maxn.ans
+  points: 1
+- in: 082-tree.in
+  out: 082-tree.ans
+  points: 1
+- in: 083-tree.in
+  out: 083-tree.ans
+  points: 1
+- in: 084-tree.in
+  out: 084-tree.ans
+  points: 1
+- in: 085-tree.in
+  out: 085-tree.ans
+  points: 1
+- in: 086-tree.in
+  out: 086-tree.ans
+  points: 1
+- in: 087-tree.in
+  out: 087-tree.ans
+  points: 1
+- in: 088-tree-binary.in
+  out: 088-tree-binary.ans
+  points: 1
+- in: 089-tree-binary.in
+  out: 089-tree-binary.ans
+  points: 1
+- in: 090-tree-binary.in
+  out: 090-tree-binary.ans
+  points: 1
+- in: 091-tree-binary.in
+  out: 091-tree-binary.ans
+  points: 1
+- in: 092-tree-binary.in
+  out: 092-tree-binary.ans
+  points: 1
+- in: 093-tree-binary.in
+  out: 093-tree-binary.ans
+  points: 1
+- in: 094-tree-binary.in
+  out: 094-tree-binary.ans
+  points: 1
+- in: 095-tree-binary-deep.in
+  out: 095-tree-binary-deep.ans
+  points: 1
+- in: 096-tree-binary-deep.in
+  out: 096-tree-binary-deep.ans
+  points: 1
+- in: 097-tree-binary-deep.in
+  out: 097-tree-binary-deep.ans
+  points: 1
+- in: 098-tree-binary-deep.in
+  out: 098-tree-binary-deep.ans
+  points: 1
+- in: 099-tree-binary-deep.in
+  out: 099-tree-binary-deep.ans
+  points: 1
+- in: 100-tree-binary-deep.in
+  out: 100-tree-binary-deep.ans
+  points: 1
+- in: 101-tree-random.in
+  out: 101-tree-random.ans
+  points: 1
+- in: 102-tree-random.in
+  out: 102-tree-random.ans
+  points: 1
+- in: 103-tree-random.in
+  out: 103-tree-random.ans
+  points: 1
+- in: 104-tree-random.in
+  out: 104-tree-random.ans
+  points: 1
+- in: 105-tree-random.in
+  out: 105-tree-random.ans
+  points: 1
+- in: 106-tree-random.in
+  out: 106-tree-random.ans
+  points: 1
+- in: 107-tree-large.in
+  out: 107-tree-large.ans
+  points: 1
+- in: 108-tree-large.in
+  out: 108-tree-large.ans
+  points: 1
+- in: 109-tree-large.in
+  out: 109-tree-large.ans
+  points: 1
+- in: 110-tree-pathy.in
+  out: 110-tree-pathy.ans
+  points: 1
+- in: 111-tree-pathy.in
+  out: 111-tree-pathy.ans
+  points: 1
+- in: 112-tree-pathy.in
+  out: 112-tree-pathy.ans
+  points: 1
+- in: 113-tree-pathy.in
+  out: 113-tree-pathy.ans
+  points: 1
+- in: 114-tree-pathy.in
+  out: 114-tree-pathy.ans
+  points: 1
+- in: 115-tree-pathy.in
+  out: 115-tree-pathy.ans
+  points: 1
+- in: 116-tree-pathy.in
+  out: 116-tree-pathy.ans
+  points: 1
+- in: 117-tree-pathy-deep.in
+  out: 117-tree-pathy-deep.ans
+  points: 1
+- in: 118-tree-pathy-deep.in
+  out: 118-tree-pathy-deep.ans
+  points: 1
+- in: 119-tree-pathy-deep.in
+  out: 119-tree-pathy-deep.ans
+  points: 1
+- in: 120-tree-pathy-deep.in
+  out: 120-tree-pathy-deep.ans
+  points: 1
+- in: 121-tree-pathy-deep.in
+  out: 121-tree-pathy-deep.ans
+  points: 1
+- in: 122-tree-pathy-deep.in
+  out: 122-tree-pathy-deep.ans
+  points: 1
+- in: 123-tree-pathy-deep.in
+  out: 123-tree-pathy-deep.ans
+  points: 1
+- in: 124-tree-pathy-deep.in
+  out: 124-tree-pathy-deep.ans
+  points: 1
+- in: 125-tree-pathy-deep.in
+  out: 125-tree-pathy-deep.ans
+  points: 1

ICPC/nwerc2022_K/data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:598d142a779315a78464d1ea3b333ae881c6f035fa8b7ae0169df2ca7e46e22d
+size 19948886

ICPC/nwerc2022_K/init.yml

@@ -0,0 +1,491 @@
+archive: data.zip
+test_cases:
+- in: 001-2multiedges_selfloops.in
+  out: 001-2multiedges_selfloops.ans
+  points: 1
+- in: 002-2multiedges.in
+  out: 002-2multiedges.ans
+  points: 1
+- in: 003-2selfloops_degree3.in
+  out: 003-2selfloops_degree3.ans
+  points: 1
+- in: 004-3selfloops_degree3.in
+  out: 004-3selfloops_degree3.ans
+  points: 1
+- in: 005-cycle_and_edge.in
+  out: 005-cycle_and_edge.ans
+  points: 1
+- in: 006-cycle_and_selfloop.in
+  out: 006-cycle_and_selfloop.ans
+  points: 1
+- in: 007-cycle_and_vertex.in
+  out: 007-cycle_and_vertex.ans
+  points: 1
+- in: 008-multiedge_on_cycle.in
+  out: 008-multiedge_on_cycle.ans
+  points: 1
+- in: 009-selfloop_edge_cycle.in
+  out: 009-selfloop_edge_cycle.ans
+  points: 1
+- in: 010-selfloops_on_cycle.in
+  out: 010-selfloops_on_cycle.ans
+  points: 1
+- in: 011-two_cycles.in
+  out: 011-two_cycles.ans
+  points: 1
+- in: 012-two_paths.in
+  out: 012-two_paths.ans
+  points: 1
+- in: 013-matching.in
+  out: 013-matching.ans
+  points: 1
+- in: 014-random.in
+  out: 014-random.ans
+  points: 1
+- in: 015-random.in
+  out: 015-random.ans
+  points: 1
+- in: 016-random.in
+  out: 016-random.ans
+  points: 1
+- in: 017-random.in
+  out: 017-random.ans
+  points: 1
+- in: 018-random.in
+  out: 018-random.ans
+  points: 1
+- in: 019-random.in
+  out: 019-random.ans
+  points: 1
+- in: 020-random.in
+  out: 020-random.ans
+  points: 1
+- in: 021-random.in
+  out: 021-random.ans
+  points: 1
+- in: 022-random.in
+  out: 022-random.ans
+  points: 1
+- in: 023-random.in
+  out: 023-random.ans
+  points: 1
+- in: 024-random-possible.in
+  out: 024-random-possible.ans
+  points: 1
+- in: 025-random-possible.in
+  out: 025-random-possible.ans
+  points: 1
+- in: 026-random-possible.in
+  out: 026-random-possible.ans
+  points: 1
+- in: 027-random-possible.in
+  out: 027-random-possible.ans
+  points: 1
+- in: 028-random-possible.in
+  out: 028-random-possible.ans
+  points: 1
+- in: 029-random-possible.in
+  out: 029-random-possible.ans
+  points: 1
+- in: 030-random-possible.in
+  out: 030-random-possible.ans
+  points: 1
+- in: 031-random-possible.in
+  out: 031-random-possible.ans
+  points: 1
+- in: 032-random-possible.in
+  out: 032-random-possible.ans
+  points: 1
+- in: 033-random-possible.in
+  out: 033-random-possible.ans
+  points: 1
+- in: 034-long-cycle.in
+  out: 034-long-cycle.ans
+  points: 1
+- in: 035-two-long-cycles.in
+  out: 035-two-long-cycles.ans
+  points: 1
+- in: 036-long-chain.in
+  out: 036-long-chain.ans
+  points: 1
+- in: 037-two-long-chains.in
+  out: 037-two-long-chains.ans
+  points: 1
+- in: 038-long-cycle-and-chain.in
+  out: 038-long-cycle-and-chain.ans
+  points: 1
+- in: 039-long-cycle-and-two-chains.in
+  out: 039-long-cycle-and-two-chains.ans
+  points: 1
+- in: 040-long-cycle-and-edge.in
+  out: 040-long-cycle-and-edge.ans
+  points: 1
+- in: 041-long-chain-and-edge.in
+  out: 041-long-chain-and-edge.ans
+  points: 1
+- in: 042-long-cycle-decorated.in
+  out: 042-long-cycle-decorated.ans
+  points: 1
+- in: 043-two-long-cycles-decorated.in
+  out: 043-two-long-cycles-decorated.ans
+  points: 1
+- in: 044-long-chain-decorated.in
+  out: 044-long-chain-decorated.ans
+  points: 1
+- in: 045-two-long-chains-decorated.in
+  out: 045-two-long-chains-decorated.ans
+  points: 1
+- in: 046-long-cycle-and-node.in
+  out: 046-long-cycle-and-node.ans
+  points: 1
+- in: 047-long-cycle-and-selfloop.in
+  out: 047-long-cycle-and-selfloop.ans
+  points: 1
+- in: 048-many-2-chains.in
+  out: 048-many-2-chains.ans
+  points: 1
+- in: 049-many-selfloops.in
+  out: 049-many-selfloops.ans
+  points: 1
+- in: 050-many-5-chains.in
+  out: 050-many-5-chains.ans
+  points: 1
+- in: 051-long-cycle-and-clique.in
+  out: 051-long-cycle-and-clique.ans
+  points: 1
+- in: 052-two-long-cycles-and-clique.in
+  out: 052-two-long-cycles-and-clique.ans
+  points: 1
+- in: 053-long-chain-and-clique.in
+  out: 053-long-chain-and-clique.ans
+  points: 1
+- in: 054-two-long-chains-and-clique.in
+  out: 054-two-long-chains-and-clique.ans
+  points: 1
+- in: 055-many-2-chains-and-clique.in
+  out: 055-many-2-chains-and-clique.ans
+  points: 1
+- in: 056-many-selfloops-and-clique.in
+  out: 056-many-selfloops-and-clique.ans
+  points: 1
+- in: 057-many-5-chains-and-clique.in
+  out: 057-many-5-chains-and-clique.ans
+  points: 1
+- in: 058-large-clique.in
+  out: 058-large-clique.ans
+  points: 1
+- in: 059-large-clique.in
+  out: 059-large-clique.ans
+  points: 1
+- in: 060-large-clique-decorated.in
+  out: 060-large-clique-decorated.ans
+  points: 1
+- in: 061-large-clique-decorated.in
+  out: 061-large-clique-decorated.ans
+  points: 1
+- in: 062-peter.in
+  out: 062-peter.ans
+  points: 1
+- in: 063-peter.in
+  out: 063-peter.ans
+  points: 1
+- in: 064-random-mutated.in
+  out: 064-random-mutated.ans
+  points: 1
+- in: 065-random-mutated.in
+  out: 065-random-mutated.ans
+  points: 1
+- in: 066-random-mutated.in
+  out: 066-random-mutated.ans
+  points: 1
+- in: 067-random-mutated.in
+  out: 067-random-mutated.ans
+  points: 1
+- in: 068-random-mutated.in
+  out: 068-random-mutated.ans
+  points: 1
+- in: 069-random-mutated.in
+  out: 069-random-mutated.ans
+  points: 1
+- in: 070-random-mutated.in
+  out: 070-random-mutated.ans
+  points: 1
+- in: 071-random-mutated.in
+  out: 071-random-mutated.ans
+  points: 1
+- in: 072-random-mutated.in
+  out: 072-random-mutated.ans
+  points: 1
+- in: 073-random-mutated.in
+  out: 073-random-mutated.ans
+  points: 1
+- in: 074-random-mutated.in
+  out: 074-random-mutated.ans
+  points: 1
+- in: 075-random-mutated.in
+  out: 075-random-mutated.ans
+  points: 1
+- in: 076-random-mutated.in
+  out: 076-random-mutated.ans
+  points: 1
+- in: 077-random-mutated.in
+  out: 077-random-mutated.ans
+  points: 1
+- in: 078-random-mutated.in
+  out: 078-random-mutated.ans
+  points: 1
+- in: 079-random-mutated.in
+  out: 079-random-mutated.ans
+  points: 1
+- in: 080-random-mutated.in
+  out: 080-random-mutated.ans
+  points: 1
+- in: 081-random-mutated.in
+  out: 081-random-mutated.ans
+  points: 1
+- in: 082-random-mutated.in
+  out: 082-random-mutated.ans
+  points: 1
+- in: 083-random-mutated.in
+  out: 083-random-mutated.ans
+  points: 1
+- in: 084-random-mutated.in
+  out: 084-random-mutated.ans
+  points: 1
+- in: 085-random-mutated.in
+  out: 085-random-mutated.ans
+  points: 1
+- in: 086-random-mutated.in
+  out: 086-random-mutated.ans
+  points: 1
+- in: 087-random-mutated.in
+  out: 087-random-mutated.ans
+  points: 1
+- in: 088-random-mutated.in
+  out: 088-random-mutated.ans
+  points: 1
+- in: 089-random-mutated.in
+  out: 089-random-mutated.ans
+  points: 1
+- in: 090-random-mutated.in
+  out: 090-random-mutated.ans
+  points: 1
+- in: 091-random-mutated.in
+  out: 091-random-mutated.ans
+  points: 1
+- in: 092-random-mutated.in
+  out: 092-random-mutated.ans
+  points: 1
+- in: 093-random-mutated.in
+  out: 093-random-mutated.ans
+  points: 1
+- in: 094-random-mutated.in
+  out: 094-random-mutated.ans
+  points: 1
+- in: 095-random-mutated.in
+  out: 095-random-mutated.ans
+  points: 1
+- in: 096-random-mutated.in
+  out: 096-random-mutated.ans
+  points: 1
+- in: 097-random-mutated.in
+  out: 097-random-mutated.ans
+  points: 1
+- in: 098-random-mutated.in
+  out: 098-random-mutated.ans
+  points: 1
+- in: 099-random-mutated.in
+  out: 099-random-mutated.ans
+  points: 1
+- in: 100-random-mutated.in
+  out: 100-random-mutated.ans
+  points: 1
+- in: 101-random-mutated.in
+  out: 101-random-mutated.ans
+  points: 1
+- in: 102-random-mutated.in
+  out: 102-random-mutated.ans
+  points: 1
+- in: 103-random-mutated.in
+  out: 103-random-mutated.ans
+  points: 1
+- in: 104-random-mutated.in
+  out: 104-random-mutated.ans
+  points: 1
+- in: 105-random-mutated.in
+  out: 105-random-mutated.ans
+  points: 1
+- in: 106-random-mutated.in
+  out: 106-random-mutated.ans
+  points: 1
+- in: 107-random-mutated.in
+  out: 107-random-mutated.ans
+  points: 1
+- in: 108-random-mutated.in
+  out: 108-random-mutated.ans
+  points: 1
+- in: 109-random-mutated.in
+  out: 109-random-mutated.ans
+  points: 1
+- in: 110-random-mutated.in
+  out: 110-random-mutated.ans
+  points: 1
+- in: 111-random-mutated.in
+  out: 111-random-mutated.ans
+  points: 1
+- in: 112-random-mutated.in
+  out: 112-random-mutated.ans
+  points: 1
+- in: 113-random-mutated.in
+  out: 113-random-mutated.ans
+  points: 1
+- in: 114-random-mutated.in
+  out: 114-random-mutated.ans
+  points: 1
+- in: 115-random-mutated.in
+  out: 115-random-mutated.ans
+  points: 1
+- in: 116-random-mutated.in
+  out: 116-random-mutated.ans
+  points: 1
+- in: 117-random-mutated.in
+  out: 117-random-mutated.ans
+  points: 1
+- in: 118-random-mutated.in
+  out: 118-random-mutated.ans
+  points: 1
+- in: 119-random-mutated.in
+  out: 119-random-mutated.ans
+  points: 1
+- in: 120-random-mutated.in
+  out: 120-random-mutated.ans
+  points: 1
+- in: 121-random-mutated.in
+  out: 121-random-mutated.ans
+  points: 1
+- in: 122-random-mutated.in
+  out: 122-random-mutated.ans
+  points: 1
+- in: 123-random-mutated.in
+  out: 123-random-mutated.ans
+  points: 1
+- in: 124-random-mutated.in
+  out: 124-random-mutated.ans
+  points: 1
+- in: 125-random-mutated.in
+  out: 125-random-mutated.ans
+  points: 1
+- in: 126-random-mutated.in
+  out: 126-random-mutated.ans
+  points: 1
+- in: 127-random-mutated.in
+  out: 127-random-mutated.ans
+  points: 1
+- in: 128-random-mutated.in
+  out: 128-random-mutated.ans
+  points: 1
+- in: 129-random-mutated.in
+  out: 129-random-mutated.ans
+  points: 1
+- in: 130-random-mutated.in
+  out: 130-random-mutated.ans
+  points: 1
+- in: 131-random-mutated.in
+  out: 131-random-mutated.ans
+  points: 1
+- in: 132-random-mutated.in
+  out: 132-random-mutated.ans
+  points: 1
+- in: 133-random-mutated.in
+  out: 133-random-mutated.ans
+  points: 1
+- in: 134-random-mutated.in
+  out: 134-random-mutated.ans
+  points: 1
+- in: 135-random-mutated.in
+  out: 135-random-mutated.ans
+  points: 1
+- in: 136-random-mutated.in
+  out: 136-random-mutated.ans
+  points: 1
+- in: 137-random-mutated.in
+  out: 137-random-mutated.ans
+  points: 1
+- in: 138-random-mutated.in
+  out: 138-random-mutated.ans
+  points: 1
+- in: 139-random-mutated.in
+  out: 139-random-mutated.ans
+  points: 1
+- in: 140-random-mutated.in
+  out: 140-random-mutated.ans
+  points: 1
+- in: 141-random-mutated.in
+  out: 141-random-mutated.ans
+  points: 1
+- in: 142-random-mutated.in
+  out: 142-random-mutated.ans
+  points: 1
+- in: 143-random-mutated.in
+  out: 143-random-mutated.ans
+  points: 1
+- in: 144-random-mutated.in
+  out: 144-random-mutated.ans
+  points: 1
+- in: 145-random-mutated.in
+  out: 145-random-mutated.ans
+  points: 1
+- in: 146-random-mutated.in
+  out: 146-random-mutated.ans
+  points: 1
+- in: 147-random-mutated.in
+  out: 147-random-mutated.ans
+  points: 1
+- in: 148-random-mutated.in
+  out: 148-random-mutated.ans
+  points: 1
+- in: 149-random-mutated.in
+  out: 149-random-mutated.ans
+  points: 1
+- in: 150-random-mutated.in
+  out: 150-random-mutated.ans
+  points: 1
+- in: 151-random-mutated.in
+  out: 151-random-mutated.ans
+  points: 1
+- in: 152-random-mutated.in
+  out: 152-random-mutated.ans
+  points: 1
+- in: 153-random-mutated.in
+  out: 153-random-mutated.ans
+  points: 1
+- in: 154-random-mutated.in
+  out: 154-random-mutated.ans
+  points: 1
+- in: 155-random-mutated.in
+  out: 155-random-mutated.ans
+  points: 1
+- in: 156-random-mutated.in
+  out: 156-random-mutated.ans
+  points: 1
+- in: 157-random-mutated.in
+  out: 157-random-mutated.ans
+  points: 1
+- in: 158-random-mutated.in
+  out: 158-random-mutated.ans
+  points: 1
+- in: 159-random-mutated.in
+  out: 159-random-mutated.ans
+  points: 1
+- in: 160-random-mutated.in
+  out: 160-random-mutated.ans
+  points: 1
+- in: 161-random-mutated.in
+  out: 161-random-mutated.ans
+  points: 1
+- in: 162-random-mutated.in
+  out: 162-random-mutated.ans
+  points: 1
+- in: 163-random-mutated.in
+  out: 163-random-mutated.ans
+  points: 1

ICPC/nwerc2022_L/data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99155e33e1631315454d4789cc8de5c8534227e940264de6ce0dbbcfef1fa4e4
+size 1388307

ICPC/nwerc2022_L/init.yml

@@ -0,0 +1,496 @@
+archive: data.zip
+checker:
+  args:
+    files:
+    - output_validators/validate/output-validator.cc
+    - output_validators/validate/validation.h
+    lang: CPP17
+    type: default
+  name: bridged
+test_cases:
+- in: 001-anti-two-step.in
+  out: 001-anti-two-step.ans
+  points: 1
+- in: 002-anti-two-step.in
+  out: 002-anti-two-step.ans
+  points: 1
+- in: 003-anti-two-step.in
+  out: 003-anti-two-step.ans
+  points: 1
+- in: 004-anti-two-step.in
+  out: 004-anti-two-step.ans
+  points: 1
+- in: 005-slack.in
+  out: 005-slack.ans
+  points: 1
+- in: 006-slack.in
+  out: 006-slack.ans
+  points: 1
+- in: 007-slack.in
+  out: 007-slack.ans
+  points: 1
+- in: 008-multi-triangle.in
+  out: 008-multi-triangle.ans
+  points: 1
+- in: 009-multi-triangle.in
+  out: 009-multi-triangle.ans
+  points: 1
+- in: 010-multi-triangle.in
+  out: 010-multi-triangle.ans
+  points: 1
+- in: 011-spanning-tree.in
+  out: 011-spanning-tree.ans
+  points: 1
+- in: 012-spanning-tree.in
+  out: 012-spanning-tree.ans
+  points: 1
+- in: 013-spanning-tree.in
+  out: 013-spanning-tree.ans
+  points: 1
+- in: 014-random.in
+  out: 014-random.ans
+  points: 1
+- in: 015-random.in
+  out: 015-random.ans
+  points: 1
+- in: 016-random.in
+  out: 016-random.ans
+  points: 1
+- in: 017-random.in
+  out: 017-random.ans
+  points: 1
+- in: 018-random.in
+  out: 018-random.ans
+  points: 1
+- in: 019-random.in
+  out: 019-random.ans
+  points: 1
+- in: 020-random.in
+  out: 020-random.ans
+  points: 1
+- in: 021-random.in
+  out: 021-random.ans
+  points: 1
+- in: 022-random.in
+  out: 022-random.ans
+  points: 1
+- in: 023-random.in
+  out: 023-random.ans
+  points: 1
+- in: 024-random.in
+  out: 024-random.ans
+  points: 1
+- in: 025-random.in
+  out: 025-random.ans
+  points: 1
+- in: 026-random.in
+  out: 026-random.ans
+  points: 1
+- in: 027-random.in
+  out: 027-random.ans
+  points: 1
+- in: 028-random.in
+  out: 028-random.ans
+  points: 1
+- in: 029-random.in
+  out: 029-random.ans
+  points: 1
+- in: 030-random-no-green.in
+  out: 030-random-no-green.ans
+  points: 1
+- in: 031-random-no-green.in
+  out: 031-random-no-green.ans
+  points: 1
+- in: 032-random-no-green.in
+  out: 032-random-no-green.ans
+  points: 1
+- in: 033-random-no-green.in
+  out: 033-random-no-green.ans
+  points: 1
+- in: 034-random-no-green.in
+  out: 034-random-no-green.ans
+  points: 1
+- in: 035-random-no-green.in
+  out: 035-random-no-green.ans
+  points: 1
+- in: 036-random-no-green.in
+  out: 036-random-no-green.ans
+  points: 1
+- in: 037-random-no-green.in
+  out: 037-random-no-green.ans
+  points: 1
+- in: 038-random-no-green.in
+  out: 038-random-no-green.ans
+  points: 1
+- in: 039-random-no-green.in
+  out: 039-random-no-green.ans
+  points: 1
+- in: 040-random-no-green.in
+  out: 040-random-no-green.ans
+  points: 1
+- in: 041-random-no-green.in
+  out: 041-random-no-green.ans
+  points: 1
+- in: 042-random-no-green.in
+  out: 042-random-no-green.ans
+  points: 1
+- in: 043-random-no-green.in
+  out: 043-random-no-green.ans
+  points: 1
+- in: 044-separate-greens.in
+  out: 044-separate-greens.ans
+  points: 1
+- in: 045-all-black.in
+  out: 045-all-black.ans
+  points: 1
+- in: 046-all-black.in
+  out: 046-all-black.ans
+  points: 1
+- in: 047-all-black.in
+  out: 047-all-black.ans
+  points: 1
+- in: 048-all-black.in
+  out: 048-all-black.ans
+  points: 1
+- in: 049-all-black.in
+  out: 049-all-black.ans
+  points: 1
+- in: 050-all-black.in
+  out: 050-all-black.ans
+  points: 1
+- in: 051-manual.in
+  out: 051-manual.ans
+  points: 1
+- in: 052-manual.in
+  out: 052-manual.ans
+  points: 1
+- in: 053-manual.in
+  out: 053-manual.ans
+  points: 1
+- in: 054-manual.in
+  out: 054-manual.ans
+  points: 1
+- in: 055-manual.in
+  out: 055-manual.ans
+  points: 1
+- in: 056-manual.in
+  out: 056-manual.ans
+  points: 1
+- in: 057-english.in
+  out: 057-english.ans
+  points: 1
+- in: 058-english.in
+  out: 058-english.ans
+  points: 1
+- in: 059-all-yellow.in
+  out: 059-all-yellow.ans
+  points: 1
+- in: 060-all-yellow.in
+  out: 060-all-yellow.ans
+  points: 1
+- in: 061-all-yellow.in
+  out: 061-all-yellow.ans
+  points: 1
+- in: 062-all-yellow.in
+  out: 062-all-yellow.ans
+  points: 1
+- in: 063-all-yellow.in
+  out: 063-all-yellow.ans
+  points: 1
+- in: 064-all-yellow.in
+  out: 064-all-yellow.ans
+  points: 1
+- in: 065-all-yellow.in
+  out: 065-all-yellow.ans
+  points: 1
+- in: 066-all-yellow.in
+  out: 066-all-yellow.ans
+  points: 1
+- in: 067-all-yellow.in
+  out: 067-all-yellow.ans
+  points: 1
+- in: 068-all-yellow.in
+  out: 068-all-yellow.ans
+  points: 1
+- in: 069-all-yellow.in
+  out: 069-all-yellow.ans
+  points: 1
+- in: 070-all-yellow.in
+  out: 070-all-yellow.ans
+  points: 1
+- in: 071-all-yellow.in
+  out: 071-all-yellow.ans
+  points: 1
+- in: 072-all-yellow.in
+  out: 072-all-yellow.ans
+  points: 1
+- in: 073-all-yellow.in
+  out: 073-all-yellow.ans
+  points: 1
+- in: 074-black-and-green.in
+  out: 074-black-and-green.ans
+  points: 1
+- in: 075-black-and-green.in
+  out: 075-black-and-green.ans
+  points: 1
+- in: 076-black-and-green.in
+  out: 076-black-and-green.ans
+  points: 1
+- in: 077-black-and-green.in
+  out: 077-black-and-green.ans
+  points: 1
+- in: 078-black-and-green.in
+  out: 078-black-and-green.ans
+  points: 1
+- in: 079-black-and-green.in
+  out: 079-black-and-green.ans
+  points: 1
+- in: 080-black-and-green.in
+  out: 080-black-and-green.ans
+  points: 1
+- in: 081-black-and-green.in
+  out: 081-black-and-green.ans
+  points: 1
+- in: 082-black-and-green.in
+  out: 082-black-and-green.ans
+  points: 1
+- in: 083-black-and-green.in
+  out: 083-black-and-green.ans
+  points: 1
+- in: 084-rotate.in
+  out: 084-rotate.ans
+  points: 1
+- in: 085-split.in
+  out: 085-split.ans
+  points: 1
+- in: 086-split.in
+  out: 086-split.ans
+  points: 1
+- in: 087-split.in
+  out: 087-split.ans
+  points: 1
+- in: 088-incremental.in
+  out: 088-incremental.ans
+  points: 1
+- in: 089-incremental.in
+  out: 089-incremental.ans
+  points: 1
+- in: 090-incremental.in
+  out: 090-incremental.ans
+  points: 1
+- in: 091-incremental.in
+  out: 091-incremental.ans
+  points: 1
+- in: 092-incremental.in
+  out: 092-incremental.ans
+  points: 1
+- in: 093-incremental.in
+  out: 093-incremental.ans
+  points: 1
+- in: 094-incremental.in
+  out: 094-incremental.ans
+  points: 1
+- in: 095-fuzz.in
+  out: 095-fuzz.ans
+  points: 1
+- in: 096-slack.in
+  out: 096-slack.ans
+  points: 1
+- in: 097-slack.in
+  out: 097-slack.ans
+  points: 1
+- in: 098-slack.in
+  out: 098-slack.ans
+  points: 1
+- in: 099-slack.in
+  out: 099-slack.ans
+  points: 1
+- in: 100-triangle.in
+  out: 100-triangle.ans
+  points: 1
+- in: 101-fuzz.in
+  out: 101-fuzz.ans
+  points: 1
+- in: 102-fuzz.in
+  out: 102-fuzz.ans
+  points: 1
+- in: 103-fuzz.in
+  out: 103-fuzz.ans
+  points: 1
+- in: 104-fuzz.in
+  out: 104-fuzz.ans
+  points: 1
+- in: 105-fuzz.in
+  out: 105-fuzz.ans
+  points: 1
+- in: 106-fuzz.in
+  out: 106-fuzz.ans
+  points: 1
+- in: 107-fuzz.in
+  out: 107-fuzz.ans
+  points: 1
+- in: 108-fuzz.in
+  out: 108-fuzz.ans
+  points: 1
+- in: 109-fuzz.in
+  out: 109-fuzz.ans
+  points: 1
+- in: 110-fuzz.in
+  out: 110-fuzz.ans
+  points: 1
+- in: 111-fuzz.in
+  out: 111-fuzz.ans
+  points: 1
+- in: 112-fuzz.in
+  out: 112-fuzz.ans
+  points: 1
+- in: 113-fuzz.in
+  out: 113-fuzz.ans
+  points: 1
+- in: 114-fuzz.in
+  out: 114-fuzz.ans
+  points: 1
+- in: 115-fuzz.in
+  out: 115-fuzz.ans
+  points: 1
+- in: 116-fuzz.in
+  out: 116-fuzz.ans
+  points: 1
+- in: 117-fuzz.in
+  out: 117-fuzz.ans
+  points: 1
+- in: 118-fuzz.in
+  out: 118-fuzz.ans
+  points: 1
+- in: 119-fuzz.in
+  out: 119-fuzz.ans
+  points: 1
+- in: 120-fuzz.in
+  out: 120-fuzz.ans
+  points: 1
+- in: 121-fuzz.in
+  out: 121-fuzz.ans
+  points: 1
+- in: 122-fuzz.in
+  out: 122-fuzz.ans
+  points: 1
+- in: 123-fuzz.in
+  out: 123-fuzz.ans
+  points: 1
+- in: 124-fuzz.in
+  out: 124-fuzz.ans
+  points: 1
+- in: 125-fuzz.in
+  out: 125-fuzz.ans
+  points: 1
+- in: 126-fuzz.in
+  out: 126-fuzz.ans
+  points: 1
+- in: 127-fuzz.in
+  out: 127-fuzz.ans
+  points: 1
+- in: 128-fuzz.in
+  out: 128-fuzz.ans
+  points: 1
+- in: 129-fuzz.in
+  out: 129-fuzz.ans
+  points: 1
+- in: 130-fuzz.in
+  out: 130-fuzz.ans
+  points: 1
+- in: 131-fuzz.in
+  out: 131-fuzz.ans
+  points: 1
+- in: 132-fuzz.in
+  out: 132-fuzz.ans
+  points: 1
+- in: 133-fuzz.in
+  out: 133-fuzz.ans
+  points: 1
+- in: 134-fuzz.in
+  out: 134-fuzz.ans
+  points: 1
+- in: 135-fuzz.in
+  out: 135-fuzz.ans
+  points: 1
+- in: 136-fuzz.in
+  out: 136-fuzz.ans
+  points: 1
+- in: 137-fuzz.in
+  out: 137-fuzz.ans
+  points: 1
+- in: 138-fuzz.in
+  out: 138-fuzz.ans
+  points: 1
+- in: 139-fuzz.in
+  out: 139-fuzz.ans
+  points: 1
+- in: 140-fuzz.in
+  out: 140-fuzz.ans
+  points: 1
+- in: 141-fuzz.in
+  out: 141-fuzz.ans
+  points: 1
+- in: 142-fuzz.in
+  out: 142-fuzz.ans
+  points: 1
+- in: 143-fuzz.in
+  out: 143-fuzz.ans
+  points: 1
+- in: 144-fuzz.in
+  out: 144-fuzz.ans
+  points: 1
+- in: 145-fuzz.in
+  out: 145-fuzz.ans
+  points: 1
+- in: 146-fuzz.in
+  out: 146-fuzz.ans
+  points: 1
+- in: 147-fuzz.in
+  out: 147-fuzz.ans
+  points: 1
+- in: 148-fuzz.in
+  out: 148-fuzz.ans
+  points: 1
+- in: 149-fuzz.in
+  out: 149-fuzz.ans
+  points: 1
+- in: 150-fuzz.in
+  out: 150-fuzz.ans
+  points: 1
+- in: 151-fuzz.in
+  out: 151-fuzz.ans
+  points: 1
+- in: 152-fuzz.in
+  out: 152-fuzz.ans
+  points: 1
+- in: 153-fuzz.in
+  out: 153-fuzz.ans
+  points: 1
+- in: 154-fuzz.in
+  out: 154-fuzz.ans
+  points: 1
+- in: 155-fuzz.in
+  out: 155-fuzz.ans
+  points: 1
+- in: 156-fuzz.in
+  out: 156-fuzz.ans
+  points: 1
+- in: 157-fuzz.in
+  out: 157-fuzz.ans
+  points: 1
+- in: 158-anti-two-step.in
+  out: 158-anti-two-step.ans
+  points: 1
+- in: 159-anti-two-step.in
+  out: 159-anti-two-step.ans
+  points: 1
+- in: 160-anti-two-step.in
+  out: 160-anti-two-step.ans
+  points: 1
+- in: 161-anti-two-step.in
+  out: 161-anti-two-step.ans
+  points: 1
+- in: 162-anti-two-step.in
+  out: 162-anti-two-step.ans
+  points: 1

ICPC/nwerc2022_L/output_validators/validate/output-validator.cc

@@ -0,0 +1,86 @@
+
+#include<cstdlib>
+int qwerty_getcode(int code) {
+    return code == 42? 0: 1;
+}
+namespace std {
+    void qwerty_exit(int code){
+        exit(qwerty_getcode(code));
+    }
+} using std::qwerty_exit;
+#define exit qwerty_exit
+#define main qwerty_main
+#include <iostream>
+#include <cassert>
+#include "validation.h"
+
+std::string wordle_query(std::string query, std::string answer) {
+    int n = std::size(query);
+    std::string res(n, 'B');
+
+    std::array<int,26> count = {};
+    for (char c: answer) count[c-'a']++;
+
+    // place green tiles
+    for (int i = 0; i < n; i++) {
+        if (query[i] == answer[i]) {
+            res[i] = 'G';
+            count[query[i]-'a']--;
+        } 
+    }
+
+    // place yellow tiles
+    for (int i = 0; i < n; i++) {
+        if (res[i] != 'G' && count[query[i]-'a'] > 0) {
+            count[query[i]-'a']--;
+            res[i] = 'Y';
+        }
+    }
+
+    return res;
+}
+
+int main(int argc, char **argv) {
+    std::ifstream in(argv[1]);
+    OutputValidator v(argc, argv);
+
+    int m, n;
+    in >> m >> n;
+
+    std::vector<std::string> words(m-1), colors(m-1);
+    for (int i = 0; i < m-1; i++) {
+        in >> words[i] >> colors[i];
+    }
+    
+    std::string all_letters = std::string(26, 'a') + std::string(26, 'A');
+    for (int i = 0; i < 26; i++) {
+        all_letters[i] += i;
+        all_letters[26+i] += i;
+    }
+    
+    // TODO: extend validation.h with case insensitivity?
+    std::string answer = v.read_string("word", n, n, all_letters);
+    for (char& c : answer) c |= 0x20;
+    v.newline();
+
+    for (int i = 0; i < m-1; i++) {
+        v.check(wordle_query(words[i], answer) == colors[i],
+                "Wrong answer: does not fit word ", i);
+    }
+}
+
+#undef main
+#include<cstdio>
+#include<vector>
+#include<string>
+#include<filesystem>
+int main(int argc, char **argv) {
+	namespace fs = std::filesystem;
+    freopen(argv[2], "r", stdin);
+    char judge_out[] = "/dev";
+    std::vector<char*> new_argv = {
+		argv[0], argv[1], argv[3],
+		judge_out,
+	};
+	return qwerty_getcode(qwerty_main((int)new_argv.size(), new_argv.data()));
+}

ICPC/nwerc2022_L/output_validators/validate/validation.h

@@ -0,0 +1,1520 @@
+#pragma once
+// A header library to safely parse team input.
+// It does not support floating points or big integers.
+// Author: Ragnar Groot Koerkamp
+
+// The easiest way to use this is to symlink it from a validator directory,
+// so that it will be picked up when creating a contest zip.
+
+// The default checking behaviour is lenient for both white space and case.
+// When validating .in and .ans files, the case_sensitive and
+// space_change_sensitive flags should be passed. When validating team output,
+// the flags in problem.yaml should be used.
+
+// Compile with -Duse_source_location to enable
+// std::experimental::source_location. This is needed for constraints checking.
+
+#include <algorithm>
+#include <array>
+#include <bitset>
+#include <cassert>
+#include <charconv>
+#include <cstring>
+#include <fstream>
+#include <functional>
+#include <iomanip>
+#include <iostream>
+#include <limits>
+#include <map>
+#include <optional>
+#include <random>
+#include <set>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+#include <variant>
+#include <vector>
+
+#ifdef use_source_location
+#include <experimental/source_location>
+constexpr bool has_source_location = true;
+using std::experimental::source_location;
+namespace std {
+bool operator<(const source_location& l, const source_location& r) {
+	return l.line() < r.line();
+}
+} // namespace std
+namespace std::experimental::fundamentals_v2 {
+bool operator<(const source_location& l, const source_location& r) {
+	return l.line() < r.line();
+}
+} // namespace std::experimental::fundamentals_v2
+#else
+constexpr bool has_source_location = false;
+struct source_location {
+	static source_location current() { return {}; }
+	[[nodiscard]] int line() const { return 0; }               // NOLINT
+	[[nodiscard]] std::string file_name() const { return ""; } // NOLINT
+};
+inline bool operator<(const source_location& l, const source_location& r) {
+	return l.line() < r.line();
+}
+#endif
+
+inline std::string location_to_string(source_location loc) {
+	return std::string(loc.file_name()) + ":" + std::to_string(loc.line());
+}
+
+const std::string_view case_sensitive_flag       = "case_sensitive";
+const std::string_view ws_sensitive_flag         = "space_change_sensitive";
+const std::string_view constraints_file_flag     = "--constraints_file";
+const std::string_view generate_flag             = "--generate";
+const std::string_view generate_binary_substring = "generat";
+
+inline struct ArbitraryTag {
+	static constexpr bool unique     = false;
+	static constexpr bool strict     = false;
+	static constexpr bool increasing = false;
+	static constexpr bool decreasing = false;
+} Arbitrary;
+inline struct UniqueTag : ArbitraryTag {
+	static constexpr bool unique     = true;
+	static constexpr bool strict     = false;
+	static constexpr bool increasing = false;
+	static constexpr bool decreasing = false;
+} Unique;
+inline struct IncreasingTag : ArbitraryTag { static constexpr bool increasing = true; } Increasing;
+inline struct DecreasingTag : ArbitraryTag { static constexpr bool decreasing = true; } Decreasing;
+inline struct StrictlyIncreasingTag : ArbitraryTag {
+	static constexpr bool strict     = true;
+	static constexpr bool increasing = true;
+} StrictlyIncreasing;
+inline struct StrictlyDecreasingTag : ArbitraryTag {
+	static constexpr bool strict     = true;
+	static constexpr bool decreasing = true;
+} StrictlyDecreasing;
+
+template <typename... T>
+struct Merge : T... {
+	static constexpr bool unique     = (T::unique || ...);
+	static constexpr bool strict     = (T::strict || ...);
+	static constexpr bool increasing = (T::increasing || ...);
+	static constexpr bool decreasing = (T::decreasing || ...);
+};
+
+template <typename T1, typename T2,
+          std::enable_if_t<
+              std::is_base_of_v<ArbitraryTag, T1> and std::is_base_of_v<ArbitraryTag, T2>, int> = 0>
+auto operator|(T1 /*unused*/, T2 /*unused*/) {
+	return Merge<T1, T2>();
+}
+
+enum Separator { Space, Newline };
+
+// this contains some specific code which emulates c++20 features
+namespace cpp20 {
+
+constexpr int countl_zero(unsigned long long x) {
+	int res = 64;
+	for(int i = 32; i > 0; i >>= 1) {
+		if((x >> i) > 0) {
+			res -= i;
+			x >>= i;
+		}
+	}
+	if(x > 0) res--;
+	return res;
+}
+
+int popcount(unsigned long long x) {
+	return static_cast<int>(std::bitset<64>(x).count());
+}
+
+constexpr long double PI = 3.141592653589793238462643383279502884l;
+
+} // namespace cpp20
+
+namespace Random {
+
+constexpr unsigned int default_seed = 3141592653; // some digits of PI
+
+unsigned long long bits64(std::mt19937_64& rng) {
+	static_assert(std::mt19937_64::max() == 0xFFFF'FFFF'FFFF'FFFFull);
+	static_assert(std::mt19937_64::min() == 0ull);
+	return rng();
+}
+
+// generates a uniform real in [0, 1)
+long double real64(std::mt19937_64& rng) {
+	// a long double can represent more than 2^64 values in the range [0, 1)...
+	// another problem is that real64() < 1.0/3.0 is technically biased.
+	long double res = bits64(rng) / 0x1.0p64l;
+	res += bits64(rng) / 0x1.0p128l;
+	assert(res < 1.0l);
+	return res;
+}
+
+bool bit(std::mt19937_64& rng) {
+	return cpp20::popcount(bits64(rng)) & 1;
+}
+
+} // namespace Random
+
+template <typename T>
+constexpr bool is_number_v = std::is_same_v<T, long long> or std::is_same_v<T, long double>;
+
+namespace Generators {
+
+template <typename T>
+struct ConstGenerator {
+	static_assert(is_number_v<T> or std::is_same_v<T, char> or std::is_same_v<T, std::string>);
+	static constexpr std::string_view name = "const";
+	using Args                             = std::tuple<T>;
+
+	const T const_;
+
+	explicit ConstGenerator(T val) : const_(std::move(val)) {}
+
+	// For char and string, the constant store has a different type than the min and max length
+	// passed in.
+	template <typename U>
+	T operator()(U low, U high, std::mt19937_64& rng) const {
+		return std::clamp(const_, low, high);
+	}
+};
+
+struct MinGenerator {
+	static constexpr std::string_view name = "min";
+	using Args                             = std::tuple<>;
+
+	explicit MinGenerator() = default;
+
+	template <typename T>
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		static_assert(is_number_v<T>);
+		return low;
+	}
+};
+
+struct MaxGenerator {
+	static constexpr std::string_view name = "max";
+	using Args                             = std::tuple<>;
+
+	explicit MaxGenerator() = default;
+
+	template <typename T>
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		static_assert(is_number_v<T>);
+		return high;
+	}
+};
+
+struct UniformGenerator {
+	static constexpr std::string_view name = "uniform";
+	using Args                             = std::tuple<>;
+
+	explicit UniformGenerator() = default;
+
+	template <typename T>
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		static_assert(is_number_v<T>);
+		if(low == high) return low;
+
+		if constexpr(std::is_same_v<T, long long>) {
+			assert(low < high);
+			// Since C++20 we can assume Two's Complement but any sane system used it before anyway.
+			// Rejection sampling is not as fast as possible but definitely unbiased.
+			auto ul    = static_cast<unsigned long long>(low);
+			auto uh    = static_cast<unsigned long long>(high);
+			int shifts = cpp20::countl_zero(uh - ul);
+			unsigned long long res;
+			do {
+				res = Random::bits64(rng) >> shifts;
+			} while(res > uh - ul);
+			return static_cast<long long>(res + ul);
+		} else {
+			assert(low < high);
+			return low + Random::real64(rng) * (high - low);
+		}
+	}
+};
+
+template <typename T>
+struct RangeGenerator {
+	static_assert(is_number_v<T>);
+	static constexpr std::string_view name = "range";
+	using Args                             = std::tuple<T, T>;
+
+	const T low_, high_;
+
+	explicit RangeGenerator(T low, T high) : low_(low), high_(high) {}
+
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		return UniformGenerator()(std::max(low, low_), std::min(high, high_), rng);
+	}
+};
+
+template <typename T>
+struct StepRangeGenerator {
+	static_assert(is_number_v<T>);
+	static constexpr std::string_view name = "steprange";
+	using Args                             = std::tuple<T, T, T>;
+
+	const T low_, high_, step_;
+
+	explicit StepRangeGenerator(T low, T high, T step) : low_(low), high_(high), step_(step) {}
+
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		// round up low to the first multiple of step_.
+		T start;
+		if(low <= low_) {
+			start = low_;
+		} else {
+			// first multiple of low_+k*step_ >= low
+			start = low_ + (long long)((low - low_) / step_) * step_;
+			if(start < low) start += step_;
+			assert(low <= start && start < low + step_);
+		}
+		long long maxsteps = (std::min(high, high_) - start) / step_;
+		long long steps    = UniformGenerator()(0ll, maxsteps, rng);
+		return start + steps * step_;
+	}
+};
+
+struct NormalDistributionGenerator {
+	static constexpr std::string_view name = "normal";
+	using T                                = long double;
+	using Args                             = std::tuple<T, T>;
+
+	const T mean_, stddev_;
+
+	explicit NormalDistributionGenerator(T mean, T stddev) : mean_(mean), stddev_(stddev) {
+		assert(stddev_ >= 0);
+	}
+
+	// NOTE: Currently this retries instead of clamping to the interval.
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		assert(low < high);
+		T v;
+		while(true) {
+			T u1 = Random::real64(rng);
+			T u2 = Random::real64(rng);
+			// Box-Muller-Methode
+			// https://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform
+			v = std::sqrt(-2.0l * std::log(u1)) * std::cos(2.0l * cpp20::PI * u2);
+			v = std::sqrt(stddev_) * v + mean_;
+			if(v >= low && v < high) return v;
+			v = std::sqrt(-2.0l * std::log(u1)) * std::sin(2.0l * cpp20::PI * u2);
+			v = std::sqrt(stddev_) * v + mean_;
+			if(v >= low && v < high) return v;
+		}
+		return v;
+	}
+};
+
+struct ExponentialDistributionGenerator {
+	static constexpr std::string_view name = "exponential";
+	using T                                = long double;
+	using Args                             = std::tuple<T>;
+
+	T lambda_;
+
+	explicit ExponentialDistributionGenerator(T lambda) : lambda_(lambda) { assert(lambda_ > 0); }
+
+	// NOTE: Currently this retries instead of clamping to the interval.
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		assert(low < high);
+		T v;
+		while(true) {
+			v = low - std::log(Random::real64(rng)) / lambda_;
+			if(v < high) return v;
+		}
+	}
+};
+
+struct GeometricDistributionGenerator {
+	static constexpr std::string_view name = "geometric";
+	using T                                = long long;
+	using Args                             = std::tuple<long double>;
+
+	double p_;
+
+	explicit GeometricDistributionGenerator(double p) : p_(p) {
+		assert(p_ > 0);
+		assert(p_ < 1);
+	}
+
+	// NOTE: Currently this retries instead of clamping to the interval.
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		assert(low <= high);
+		T v;
+		while(true) {
+			// https://en.wikipedia.org/wiki/Geometric_distribution
+			// "The exponential distribution is the continuous analogue of the geometric
+			// distribution[...]"
+			v = low + std::floor(std::log(Random::real64(rng)) / std::log1p(-p_));
+			if(v <= high) return v;
+		}
+	}
+};
+
+struct BinomialDistributionGenerator {
+	static constexpr std::string_view name = "binomial";
+	using T                                = long long;
+	using Args                             = std::tuple<long long, long double>;
+
+	long long n_;
+	double p_;
+
+	explicit BinomialDistributionGenerator(long long n, double p) : n_(n), p_(p) {
+		assert(p_ >= 0);
+		assert(p_ <= 1);
+		std::cerr << "Warning: Large n (" << n_ << ") is slow for BinomialDistributionGenerator!"
+		          << std::endl;
+	}
+
+	// NOTE: Currently this retries instead of clamping to the interval.
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		assert(low <= high);
+		// this will be slow for large n
+		// (a faster implementation requires efficient poisson sampling)
+		while(true) {
+			T v = 0;
+			for(long long i = 0; i < n_; i++) {
+				v += Random::real64(rng) < p_ ? 1 : 0;
+			}
+			if(v >= low && v <= high) return v;
+		}
+	}
+};
+
+template <typename T>
+struct ChoiceGenerator {
+	using GeneratorType = std::conditional_t<
+	    std::is_same_v<T, long long>,
+	    std::variant<ConstGenerator<T>, MinGenerator, MaxGenerator, UniformGenerator,
+	                 RangeGenerator<T>, StepRangeGenerator<T>, GeometricDistributionGenerator,
+	                 BinomialDistributionGenerator>,
+	    std::variant<ConstGenerator<T>, MinGenerator, MaxGenerator, UniformGenerator,
+	                 RangeGenerator<T>, StepRangeGenerator<T>, NormalDistributionGenerator,
+	                 ExponentialDistributionGenerator>>;
+
+	std::vector<std::pair<GeneratorType, double>> generators_;
+	double total_weight_;
+
+	template <typename>
+	struct Pack {};
+
+	template <typename A>
+	static A parse_number(std::string_view s) {
+		static_assert(is_number_v<A>);
+		if constexpr(std::is_same_v<A, long long>)
+			return stoll(std::string(s));
+		else
+			return stold(std::string(s));
+	}
+
+	template <typename A>
+	static A parse_argument(std::string_view& s) {
+		auto end = s.find_first_of(",)");
+		assert(end != std::string_view::npos);
+		auto v = parse_number<A>(s.substr(0, end));
+		s.remove_prefix(end);
+		// Pop the trailing , or )
+		s.remove_prefix(1);
+		return v;
+	}
+
+	template <typename... As>
+	static std::tuple<As...> parse_arguments(std::string_view& s,
+	                                         Pack<std::tuple<As...>> /*unused*/) {
+		std::tuple<As...> args{parse_argument<As>(s)...};
+		return args;
+	}
+
+	// Try parsing one generator type from the start of s.
+	template <typename G>
+	static void parse_generator(std::string_view& s, std::optional<GeneratorType>& out) {
+		if(out) return;
+		if(s.substr(0, G::name.size()) != G::name) return;
+
+		// Drop the name.
+		s.remove_prefix(G::name.size());
+		if constexpr(std::tuple_size_v<typename G::Args> == 0) {
+			out.emplace(std::in_place_type_t<G>{});
+			return;
+		}
+
+		// Drop the (
+		assert(not s.empty() and s.front() == '(');
+		s.remove_prefix(1);
+
+		auto args = parse_arguments(s, Pack<typename G::Args>{});
+		// Construct the resulting generator in-place in the variant..
+		std::apply([&](const auto&... _args) { out.emplace(std::in_place_type_t<G>{}, _args...); },
+		           args);
+	}
+
+	template <typename... Gs>
+	static std::optional<GeneratorType> parse_generators(std::string_view& s,
+	                                                     Pack<std::variant<Gs...>> /*unused*/) {
+		std::optional<GeneratorType> out;
+		(parse_generator<Gs>(s, out), ...);
+		return out;
+	}
+
+	explicit ChoiceGenerator(std::string_view s) : total_weight_(0) {
+		// PARSE
+		while(not s.empty()) {
+			auto generator = parse_generators(s, Pack<GeneratorType>{});
+			if(!generator) {
+				// Check for range syntax:
+				auto comma = s.find_first_of(",:");
+				if(comma == std::string::npos) comma = s.size();
+				auto dots = s.find("..");
+				if(dots != std::string_view::npos and dots < comma) {
+					auto start = s.substr(0, dots);
+					auto end   = s.substr(dots + 2, comma - dots - 2);
+
+					generator.emplace(std::in_place_type_t<RangeGenerator<T>>{},
+					                  parse_number<T>(start), parse_number<T>(end));
+					s.remove_prefix(comma);
+				}
+
+				// Fall back to constant.
+				if(!generator) {
+					generator.emplace(std::in_place_type_t<ConstGenerator<T>>{},
+					                  parse_number<T>(s.substr(0, comma)));
+					s.remove_prefix(comma);
+				}
+			}
+
+			// Parse weight if given.
+			double weight = 1;
+			if(not s.empty() and s.front() == ':') {
+				s.remove_prefix(1);
+				auto comma = s.find(',');
+				if(comma == std::string_view::npos) comma = s.size();
+				weight = parse_number<long double>(s.substr(0, comma));
+				s.remove_prefix(comma);
+			}
+
+			// should now be at , or end
+			assert(s.empty() or s.front() == ',');
+			if(not s.empty()) s.remove_prefix(1);
+			generators_.emplace_back(std::move(*generator), weight);
+			total_weight_ += weight;
+		}
+	}
+
+	T operator()(T low, T high, std::mt19937_64& rng) const {
+		Generators::UniformGenerator uniform;
+		double x = uniform.operator()<long double>(0, total_weight_, rng);
+		for(size_t i = 0; i < generators_.size(); ++i) {
+			x -= generators_[i].second;
+			if(x <= 0)
+				return std::visit([&](auto& g) { return g(low, high, rng); }, generators_[i].first);
+		}
+		assert(false);
+	}
+};
+
+struct ParamGenerator {
+	std::variant<std::string_view, ChoiceGenerator<long long>, ChoiceGenerator<long double>>
+	    generator;
+	explicit ParamGenerator(std::string_view s) : generator(s) {}
+
+	template <typename T>
+	T operator()(T low, T high, std::mt19937_64& rng) {
+		static_assert(is_number_v<T>);
+		if(std::holds_alternative<std::string_view>(generator)) {
+			generator = ChoiceGenerator<T>(std::get<std::string_view>(generator));
+		}
+		return std::get<ChoiceGenerator<T>>(generator)(low, high, rng);
+	}
+};
+
+} // namespace Generators
+
+using Generators::ParamGenerator;
+
+namespace Random {
+template <class RandomIt>
+void shuffle(RandomIt first, RandomIt last, std::mt19937_64& rng) {
+	Generators::UniformGenerator uniform;
+	long long n = last - first;
+	for(long long i = n - 1; i > 0; i--) {
+		std::swap(first[i], first[uniform(0ll, i, rng)]);
+	}
+}
+
+template <class T>
+void shuffle(std::pair<T, T>& in, std::mt19937_64& rng) {
+	if(bit(rng)) std::swap(in.first, in.second);
+}
+
+template <class RandomIt>
+auto& select(RandomIt first, RandomIt last, std::mt19937_64& rng) {
+	assert(first != last);
+	Generators::UniformGenerator uniform;
+	long long n = last - first;
+	return first[uniform(0ll, n - 1, rng)];
+}
+
+template <class T>
+const T& select(const std::pair<T, T>& in, std::mt19937_64& rng) {
+	return bit(rng) ? in.first : in.second;
+}
+
+template <class T>
+T& select(std::pair<T, T>& in, std::mt19937_64& rng) {
+	return bit(rng) ? in.first : in.second;
+}
+
+} // namespace Random
+
+class Validator {
+  protected:
+	Validator(bool ws_, bool case_, std::istream& in_, std::string constraints_file_path_ = "",
+	          std::optional<unsigned int> seed                        = std::nullopt,
+	          std::unordered_map<std::string, ParamGenerator> params_ = {})
+	    : in(in_), ws(ws_), case_sensitive(case_),
+	      constraints_file_path(std::move(constraints_file_path_)), gen(seed.has_value()),
+	      rng(seed.value_or(Random::default_seed)), params(std::move(params_)) {
+
+		std::ios_base::sync_with_stdio(false);
+		in.tie(nullptr);
+
+		if(gen) return;
+		if(ws)
+			in >> std::noskipws;
+		else
+			in >> std::skipws;
+
+		if(!constraints_file_path.empty()) {
+			assert(has_source_location); // NOLINT
+		}
+	}
+
+  public:
+	// No copying, no moving.
+	Validator(const Validator&) = delete;
+	Validator(Validator&&)      = delete;
+	void operator=(const Validator&) = delete;
+	void operator=(Validator&&) = delete;
+
+	// At the end of the scope, check whether the EOF has been reached.
+	// If so, return AC. Otherwise, return WA.
+	~Validator() {
+		eof();
+		write_constraints();
+		AC();
+	}
+
+	void space() {
+		if(gen) {
+			out << ' ';
+			return;
+		}
+
+		if(ws) {
+			char c;
+			in >> c;
+			check(!in.eof(), "Expected space, found EOF.");
+			if(c != ' ')
+				expected("space", std::string("\"") +
+				                      ((c == '\n' or c == '\r') ? std::string("newline")
+				                                                : std::string(1, c)) +
+				                      "\"");
+		}
+	}
+
+	void newline() {
+		if(gen) {
+			out << '\n';
+			return;
+		}
+
+		if(ws) {
+			char c;
+			in >> c;
+			check(!in.eof(), "Expected newline, found EOF.");
+			if(c != '\n') {
+				if(c == '\r')
+					expected("newline", "DOS line ending (\\r)");
+				else
+					expected("newline", std::string("\"") + c + "\"");
+			}
+		}
+	}
+
+  private:
+	void separator(Separator s) {
+		switch(s) {
+		case Separator::Space: space(); break;
+		case Separator::Newline: newline(); break;
+		}
+	}
+
+	template <typename T>
+	auto& seen() {
+		static std::map<source_location, std::set<T>> seen;
+		return seen;
+	}
+	template <typename T>
+	auto& last_seen() {
+		static std::map<source_location, T> last_seen;
+		return last_seen;
+	}
+	template <typename T>
+	auto& integers_seen() {
+		static std::map<source_location, std::tuple<std::set<T>, std::vector<T>, bool>>
+		    integers_seen;
+		return integers_seen;
+	}
+	template <typename T>
+	void reset(source_location loc) {
+		seen<T>().erase(loc);
+		last_seen<T>().erase(loc);
+		integers_seen<T>().erase(loc);
+	}
+
+	template <typename T, typename Tag>
+	void check_number(const std::string& name, T low, T high, T v, Tag /*unused*/,
+	                  source_location loc) {
+		static_assert(is_number_v<T>);
+		if(v < low or v > high) {
+			std::string type_name;
+			if constexpr(std::is_integral_v<T>) {
+				type_name = "integer";
+			}
+			if constexpr(std::is_floating_point_v<T>) {
+				type_name = "float";
+			}
+			expected(name + ": " + type_name + " between " + std::to_string(low) + " and " +
+			             std::to_string(high),
+			         std::to_string(v));
+		}
+		log_constraint(name, low, high, v, loc);
+		if constexpr(Tag::unique) {
+			auto [it, inserted] = seen<T>()[loc].emplace(v);
+			check(inserted, name, ": Value ", v, " seen twice, but must be unique!");
+		} else {
+			auto [it, inserted] = last_seen<T>().emplace(loc, v);
+			if(inserted) return;
+
+			auto last  = it->second;
+			it->second = v;
+
+			if constexpr(Tag::increasing)
+				check(v >= last, name, " is not increasing: value ", v, " follows ", last);
+			if constexpr(Tag::decreasing)
+				check(v <= last, name, " is not decreasing: value ", v, " follows ", last);
+			if constexpr(Tag::strict)
+				check(v != last, name, " is not strict: value ", v, " equals ", last);
+		}
+	}
+
+	template <typename Tag>
+	void check_string(const std::string& name, int low, int high, const std::string& v,
+	                  Tag /*unused*/, source_location loc) {
+		using T = std::string;
+		if((int) v.size() < low or (int) v.size() > high) {
+			expected(name + ": " + "string with" + " length between " + std::to_string(low) +
+			             " and " + std::to_string(high),
+			         v);
+		}
+		log_constraint(name, low, high, static_cast<int>(v.size()), loc);
+		if constexpr(Tag::unique) {
+			// static map<source_location, set<T>> seen;
+			auto [it, inserted] = seen<T>()[loc].emplace(v);
+			check(inserted, name, ": Value ", v, " seen twice, but must be unique!");
+		} else if(Tag::increasing or Tag::decreasing) {
+			// static map<source_location, T> last_seen;
+			auto [it, inserted] = last_seen<T>().emplace(loc, v);
+			if(inserted) return;
+
+			auto last  = it->second;
+			it->second = v;
+
+			if constexpr(Tag::increasing)
+				check(v >= last, name, " is not increasing: value ", v, " follows ", last);
+			if constexpr(Tag::decreasing)
+				check(v <= last, name, " is not decreasing: value ", v, " follows ", last);
+			if constexpr(Tag::strict)
+				check(v != last, name, " is not strict: value ", v, " equals ", last);
+		}
+	}
+
+	// Generate a random integer in [low, high] or float in [low, high).
+	template <typename T>
+	T uniform_number(T low, T high) {
+		assert(low <= high);
+		Generators::UniformGenerator uniform;
+		if constexpr(std::is_integral<T>::value)
+			return uniform.operator()<long long>(low, high, rng);
+		else
+			return uniform.operator()<long double>(low, high, rng);
+	}
+
+	template <typename T, typename Tag>
+	T gen_number(const std::string& name, T low, T high, Tag /*unused*/, source_location loc) {
+		static_assert(is_number_v<T>);
+		T v;
+
+		if constexpr(Tag::unique) {
+			assert(params.find(name) == params.end() &&
+			       "Parameters are not supported for unique values.");
+			if constexpr(std::is_integral<T>::value) {
+				auto& [seen_here, remaining_here, use_remaining] = integers_seen<T>()[loc];
+
+				if(use_remaining) {
+					check(!remaining_here.empty(), name, ": no unique values left");
+					v = remaining_here.back();
+					remaining_here.pop_back();
+				} else {
+					do {
+						v = uniform_number(low, high);
+					} while(!seen_here.insert(v).second);
+
+					struct CountIterator {
+						T v;
+						T& operator*() { return v; }
+						T& operator++() { return ++v; }
+						T operator++(int) { return v++; }
+						bool operator!=(CountIterator r) { return v != r.v; }
+					};
+
+					if(seen_here.size() > (high - low) / 2) {
+						use_remaining = true;
+						set_difference(CountIterator{low}, CountIterator{high + 1},
+						               seen_here.begin(), seen_here.end(),
+						               std::back_inserter(remaining_here));
+					}
+				}
+			} else {
+				// For floats, just regenerate numbers until success.
+				auto& seen_here = seen<T>()[loc];
+				do {
+					v = uniform_number(low, high);
+				} while(!seen_here.insert(v).second);
+			}
+
+		} else {
+			assert(not Tag::increasing && "Generating increasing sequences is not yet supported!");
+			assert(not Tag::decreasing && "Generating decreasing sequences is not yet supported!");
+			assert((std::is_same<Tag, ArbitraryTag>::value) &&
+			       "Only Unique and Arbitrary are supported!");
+
+			if(params.find(name) != params.end()) {
+				v = params.at(name).operator()<T>(low, high, rng);
+				// This will be checked during input validation of the generated case.
+				// assert(low <= v and v <= high);
+			} else {
+				v = uniform_number<T>(low, high);
+			}
+		}
+
+		return v;
+	}
+
+	std::string gen_string(const std::string& name, long long low, long long high,
+	                       std::string_view chars) {
+		assert(!chars.empty());
+
+		int len;
+		if(params.find(name + ".length") != params.end())
+			len = params.at(name + ".length").operator()<long long>(low, high, rng);
+		else
+			len = uniform_number(low, high);
+		std::string s(len, ' ');
+		for(auto& x : s) x = chars[uniform_number<int>(0, chars.size() - 1)];
+
+		out << s;
+		return s;
+	}
+
+  public:
+	template <typename Tag = ArbitraryTag>
+	long long gen_integer(const std::string& name, long long low, long long high, Tag tag = Tag{},
+	                      source_location loc = source_location::current()) {
+		return gen_number(name, low, high, tag, loc);
+	}
+
+	template <typename Tag = ArbitraryTag>
+	long double gen_float(const std::string& name, long double low, long double high,
+	                      Tag tag = Tag{}, source_location loc = source_location::current()) {
+		return gen_number(name, low, high, tag, loc);
+	}
+
+  private:
+	template <typename T, typename Tag>
+	std::vector<T> gen_numbers(const std::string& name, int count, T low, T high, Tag /*unused*/,
+	                           source_location loc) {
+		static_assert(is_number_v<T>);
+		std::vector<T> v;
+		v.reserve(count);
+		if constexpr(std::is_same_v<Tag, ArbitraryTag>) {
+			if(params.find(name) != params.end()) {
+				auto& generator = params.at(name);
+				for(int i = 0; i < count; ++i) {
+					auto val = generator.operator()<T>(low, high, rng);
+					assert(low <= val and val <= high);
+					v.push_back(val);
+				}
+			} else {
+				for(int i = 0; i < count; ++i) {
+					v.push_back(uniform_number<T>(low, high));
+				}
+			}
+		} else if constexpr(Tag::unique) {
+			assert(params.find(name) == params.end() &&
+			       "Parameters are not supported for unique values.");
+			std::set<T> seen_here;
+			if constexpr(std::is_integral_v<T>) {
+				if(2 * count < high - low) {
+					for(int i = 0; i < count; ++i) {
+						// If density < 1/2: retry.
+						T w;
+						do {
+							w = uniform_number(low, high);
+						} while(!seen_here.insert(w).second);
+						v.push_back(w);
+					}
+				} else {
+					// If density >= 1/2, crop a random permutation.
+					v.resize(high - low + 1);
+					iota(begin(v), end(v), low);
+					Random::shuffle(begin(v), end(v), rng);
+					v.resize(count);
+				}
+			} else {
+				for(int i = 0; i < count; ++i) {
+					// For floats, just regenerate numbers until success.
+					T w;
+					do {
+						w = uniform_number(low, high);
+					} while(!seen_here.insert(w).second);
+					v.push_back(w);
+				}
+			}
+		} else {
+			static_assert(Tag::increasing or Tag::decreasing);
+
+			constexpr bool integral_strict = Tag::strict and std::is_integral<T>::value;
+			if(integral_strict) {
+				assert(params.find(name) == params.end() &&
+				       "Parameters are not supported for strict integer values.");
+				high = high - count + 1;
+			}
+
+			if(params.find(name) != params.end()) {
+				auto& generator = params.at(name);
+				for(int i = 0; i < count; ++i) {
+					auto val = generator.operator()<T>(low, high, rng);
+					assert(low <= val and val <= high);
+					v.push_back(val);
+				}
+			} else {
+				for(int i = 0; i < count; ++i) {
+					v.push_back(uniform_number<T>(low, high));
+				}
+			}
+
+			sort(begin(v), end(v));
+
+			if(integral_strict) {
+				for(int i = 0; i < count; ++i) v[i] += i;
+			}
+
+			if(Tag::decreasing) reverse(begin(v), end(v));
+		}
+
+		return v;
+	}
+
+  public:
+	template <typename Tag = ArbitraryTag>
+	std::vector<long long> gen_integers(const std::string& name, int count, long long low,
+	                                    long long high, Tag tag = Tag{},
+	                                    source_location loc = source_location::current()) {
+		return gen_numbers(name, count, low, high, tag, loc);
+	}
+
+	template <typename Tag = ArbitraryTag>
+	std::vector<long double> gen_floats(const std::string& name, int count, long double low,
+	                                    long double high, Tag tag = Tag{},
+	                                    source_location loc = source_location::current()) {
+		return gen_numbers(name, count, low, high, tag, loc);
+	}
+
+  private:
+	template <typename T, typename Tag>
+	T read_number(const std::string& name, T low, T high, Tag tag, source_location loc) {
+		if(gen) {
+			auto v = gen_number(name, low, high, tag, loc);
+			out << std::setprecision(10) << std::fixed << v;
+			return v;
+		}
+
+		const auto v = [&] {
+			if constexpr(std::is_integral<T>::value)
+				return read_integer(name);
+			else
+				return read_float(name);
+		}();
+
+		check_number(name, low, high, v, tag, loc);
+		return v;
+	}
+
+	// Read a vector of numbers, separated by spaces and ended by a newline.
+	template <typename T, typename Tag>
+	std::vector<T> read_numbers(const std::string& name, int count, T low, T high, Tag tag,
+	                            Separator sep, source_location loc) {
+		if(gen) {
+			auto v = gen_numbers(name, count, low, high, tag, loc);
+
+			out << std::setprecision(10) << std::fixed;
+			for(int i = 0; i < count; ++i) {
+				out << v[i];
+				if(i < count - 1) separator(sep);
+			}
+			newline();
+
+			return v;
+		}
+		reset<T>(loc);
+		std::vector<T> v(count);
+		for(int i = 0; i < count; ++i) {
+			if constexpr(std::is_integral<T>::value)
+				v[i] = read_integer(name);
+			else
+				v[i] = read_float(name);
+			check_number(name, low, high, v[i], tag, loc);
+			if(i < count - 1) separator(sep);
+		}
+		newline();
+		return v;
+	}
+
+  public:
+	template <typename Tag = ArbitraryTag>
+	long long read_integer(const std::string& name, long long low, long long high, Tag tag = Tag{},
+	                       source_location loc = source_location::current()) {
+		return read_number(name, low, high, tag, loc);
+	}
+	template <typename Tag = ArbitraryTag>
+	std::vector<long long> read_integers(const std::string& name, int count, long long low,
+	                                     long long high, Tag tag = Tag{}, Separator sep = Space,
+	                                     source_location loc = source_location::current()) {
+		return read_numbers(name, count, low, high, tag, sep, loc);
+	}
+
+	template <typename Tag = ArbitraryTag>
+	long double read_float(const std::string& name, long double low, long double high,
+	                       Tag tag = Tag{}, source_location loc = source_location::current()) {
+		return read_number(name, low, high, tag, loc);
+	}
+	template <typename Tag = ArbitraryTag>
+	std::vector<long double> read_floats(const std::string& name, int count, long double low,
+	                                     long double high, Tag tag = Tag{}, Separator sep = Space,
+	                                     source_location loc = source_location::current()) {
+		return read_numbers(name, count, low, high, tag, sep, loc);
+	}
+
+	// Read a vector of strings, separated by spaces and ended by a newline.
+	template <typename Tag = ArbitraryTag>
+	std::vector<std::string> read_strings(const std::string& name, int count, int min, int max,
+	                                      const std::string_view chars = "", Tag tag = Tag(),
+	                                      Separator sep       = Space,
+	                                      source_location loc = source_location::current()) {
+		reset<std::string>(loc);
+		if(gen) return gen_strings(name, count, min, max, chars, tag, sep, loc);
+		assert(!gen);
+		std::vector<std::string> v(count);
+		for(int i = 0; i < count; ++i) {
+			v[i] = read_string(name, min, max, chars, tag, loc);
+			if(i < count - 1) separator(sep);
+		}
+		newline();
+		return v;
+	}
+
+	template <typename Tag>
+	std::vector<std::string> gen_strings(const std::string& name, int count, int min, int max,
+	                                     const std::string_view chars, Tag /*unused*/,
+	                                     Separator sep, source_location loc) {
+		assert(!chars.empty());
+
+		std::vector<std::string> v(count);
+		if constexpr(std::is_same<Tag, ArbitraryTag>::value) {
+			for(int i = 0; i < count; ++i) {
+				std::string s(uniform_number(min, max), ' ');
+				for(auto& x : s) x = chars[uniform_number<int>(0, chars.size() - 1)];
+				v.push_back(s);
+				out << s;
+				if(i < count - 1) separator(sep);
+			}
+		} else if constexpr(Tag::unique) {
+			std::set<std::string> seen_here;
+			for(int i = 0; i < count; ++i) {
+				// Just regenerate strings until success.
+				std::string s;
+				do {
+					s = std::string(uniform_number(min, max), ' ');
+					for(auto& x : s) x = chars[uniform_number<int>(0, chars.size() - 1)];
+				} while(!seen_here.insert(s).second);
+				v.push_back(s);
+				out << s;
+				if(i < count - 1) separator(sep);
+			}
+		} else {
+			static_assert(Tag::increasing or Tag::decreasing);
+
+			assert(false && "Generating increasing/decreasing lists of strings is not "
+			                "supported!");
+		}
+
+		newline();
+
+		return v;
+	}
+
+	// Check the next character.
+	bool peek(char c, const std::string& name = "") {
+		if(gen) {
+			// TODO
+			// if(not name.empty() and params.contains(name)) {
+			// return c == params.at(name).operator()<char>(0, 0, rng);
+			//}
+			return Random::bit(rng);
+		}
+		if(!ws) in >> std::ws;
+		if(case_sensitive) return in.peek() == std::char_traits<char>::to_int_type(c);
+		return tolower(in.peek()) == tolower(std::char_traits<char>::to_int_type(c));
+	}
+
+	// Read a string and make sure it equals `expected`.
+	// Takes by value because it needs to lowercase its arguments.
+	std::string test_strings(std::vector<std::string> expected, const std::string& name = "") {
+		if(gen) {
+			int index = 0;
+			// TODO
+			// if(not name.empty() and params.contains(name)) {
+			// auto s = params.at(name).operator()<std::string>(0, 0, rng);
+			// index  = std::find(expected.begin(), expected.end(), s) - expected.begin();
+			// assert(0 <= index and index < expected.size());
+			//} else {
+			index = expected.size() == 1 ? 0 : uniform_number<int>(0, expected.size() - 1);
+			//}
+			out << expected[index];
+			return expected[index];
+		}
+		std::string s = get_string();
+		lowercase(s);
+
+		for(std::string e : expected)
+			if(s == lowercase(e)) return s;
+
+		std::string error;
+		for(const auto& e : expected) {
+			if(not error.empty()) error += "|";
+			error += e;
+		}
+		WA("Expected string \"", error, "\", but found ", s);
+	}
+
+	// Read a string and make sure it equals `expected`.
+	std::string test_string(std::string expected, const std::string& name = "") {
+		return test_strings({std::move(expected)}, name);
+	}
+
+	// Read an arbitrary string of a given length.
+	template <typename Tag = ArbitraryTag>
+	std::string read_string(const std::string& name, long long min, long long max,
+	                        const std::string_view chars = "", Tag tag = Tag(),
+	                        source_location loc = source_location::current()) {
+		if(gen) {
+			return gen_string(name, min, max, chars);
+		}
+		std::string s = get_string();
+		std::array<bool, 256> ok_char{};
+		if(!chars.empty()) {
+			for(auto c : chars) ok_char[c] = true;
+			for(auto c : s)
+				check(ok_char[c], name, ": expected characters in ", chars, " but found character ",
+				      c, " in ", s);
+		}
+		check_string(name, min, max, s, tag, loc);
+		return s;
+	}
+
+	// Read an arbitrary line of a given length.
+	std::string read_line(const std::string& name, long long min, long long max,
+	                      const std::string_view chars = "",
+	                      source_location loc          = source_location::current()) {
+		if(gen) {
+			// TODO: Params for lines.
+			assert(!chars.empty());
+
+			std::string s(uniform_number(min, max), ' ');
+			for(auto& x : s) x = chars[uniform_number<int>(0, chars.size() - 1)];
+
+			out << s << '\n';
+			return s;
+		}
+
+		if(ws) {
+			char next = in.peek();
+			if(min > 0 and isspace(next))
+				expected("non empty line", next == '\n' ? "newline" : "whitespace");
+			if(in.eof()) expected("line", "EOF");
+		}
+		std::string s;
+		if(!getline(in, s)) expected("line", "nothing");
+		long long size = s.size();
+		if(size < min || size > max)
+			expected(name + ": line of length between " + std::to_string(min) + " and " +
+			             std::to_string(max),
+			         s);
+		std::array<bool, 256> ok_char{};
+		if(!chars.empty()) {
+			for(auto c : chars) ok_char[c] = true;
+			for(auto c : s)
+				check(ok_char[c], name, ": expected characters in ", chars, " but found character ",
+				      c, " in ", s);
+		}
+		log_constraint(name, min, max, size, loc);
+		return s;
+	}
+
+	// Return ACCEPTED verdict.
+	void eof_and_AC() {
+		eof();
+		AC();
+	}
+
+  private:
+	std::function<void()> WA_handler = [] {};
+
+  public:
+	void set_WA_handler(std::function<void()> f) { WA_handler = std::move(f); }
+
+	// Return WA with the given reason.
+	template <typename... Ts>
+	[[noreturn]] void WA(const Ts&... ts) {
+		static_assert(sizeof...(Ts) > 0);
+
+		WA_handler();
+
+		auto pos = get_file_pos();
+		std::cerr << pos.first << ":" << pos.second << ": ";
+
+		WA_impl(ts...);
+	}
+
+	// Check that the condition is true.
+	template <typename... Ts>
+	void check(bool b, const Ts&... ts) {
+		static_assert(sizeof...(Ts) > 0, "Provide a non-empty error message.");
+
+		if(!b) WA(ts...);
+	}
+
+	// Log some value in a range.
+	template <typename T>
+	void log_constraint(const std::string& name, T low, T high, T v,
+	                    source_location loc = source_location::current()) {
+		// Do not log when line number is unknown/default/unsupported.
+		if(loc.line() == 0 or constraints_file_path.empty()) return;
+
+		// All integer types get bounds as long long, all floating point types as long_double.
+		using U = Bounds<std::conditional_t<std::is_integral_v<T>, long long, long double>>;
+
+		auto [it, inserted] = bounds.emplace(loc, U(name, v, v, low, high));
+		assert(std::holds_alternative<U>(it->second));
+		auto& done = std::get<U>(it->second);
+		if(inserted) {
+			assert(!name.empty() && "Variable names must not be empty.");
+			assert(name.find(' ') == std::string::npos && "Variable name must not contain spaces.");
+		} else {
+			assert(name == done.name && "Variable name must be constant.");
+		}
+		if(v < done.min) {
+			done.min = v;
+			done.low = low;
+		}
+		if(v > done.max) {
+			done.max  = v;
+			done.high = high;
+		}
+		done.has_min |= v == low;
+		done.has_max |= v == high;
+	}
+
+  private:
+	long long read_integer(const std::string& name) {
+		assert(!gen);
+		std::string s = get_string("integer");
+		if(s.empty()) {
+			WA(name, ": Want integer, found nothing");
+		}
+		long long v;
+		auto begin = s.c_str(), end = begin + s.size();
+		auto [ptr, ec] = std::from_chars(begin, end, v);
+		if(ec == std::errc::result_out_of_range){
+			WA(name, ": Number " + s + " does not fit in a long long!");
+		} else if(ptr != end) {
+			WA(name, ": Parsing " + s + " as long long failed! Did not process all characters");
+		} else if (ec != std::errc{}) {
+			WA(name, ": Parsing " + s + " as long long failed!");
+		}
+		// Check for leading zero.
+		if(v == 0) {
+			if(s.size() != 1) WA(name, ": Parsed 0, but has leading 0 or minus sign: ", s);
+		}
+		if(v > 0) {
+			if(s[0] == '0') WA(name, ": Parsed ", v, ", but has leading 0: ", s);
+		}
+		if(v < 0) {
+			if(s.size() <= 1) WA(name, ": Parsed ", v, ", but string is: ", s);
+			if(s[1] == '0') WA(name, ": Parsed ", v, ", but has leading 0: ", s);
+		}
+		return v;
+	}
+
+	long double read_float(const std::string& name) {
+		assert(!gen);
+		std::string s = get_string("long double");
+		long double v;
+		try {
+			size_t chars_processed;
+			v = stold(s, &chars_processed);
+			if(chars_processed != s.size())
+				WA(name, ": Parsing ", s,
+				   " as long double failed! Did not process all characters.");
+		} catch(const std::out_of_range& e) {
+			WA(name, ": Number " + s + " does not fit in a long double!");
+		} catch(const std::invalid_argument& e) {
+			WA("Parsing " + s + " as long double failed!");
+		}
+		return v;
+	}
+
+	[[noreturn]] void expected(const std::string& exp = "", const std::string& s = "") {
+		assert(!gen && "Expected is not supported for generators.");
+		if(!s.empty())
+			WA("Expected ", exp, ", found ", s);
+		else
+			WA(exp);
+	}
+
+	template <typename T>
+	[[noreturn]] void WA_impl(T t) {
+		std::cerr << t << std::endl;
+		exit(ret_WA);
+	}
+
+	std::pair<int, int> get_file_pos() {
+		int line = 1, col = 0;
+		in.clear();
+		auto originalPos = in.tellg();
+		if(originalPos < 0) return {-1, -1};
+		in.seekg(0);
+		char c;
+		while((in.tellg() < originalPos) && in.get(c)) {
+			if(c == '\n')
+				++line, col = 0;
+			else
+				++col;
+		}
+		return {line, col};
+	}
+
+	template <typename T, typename... Ts>
+	[[noreturn]] void WA_impl(T t, Ts... ts) {
+		std::cerr << t;
+		WA_impl(ts...);
+	}
+
+	std::string get_string(const std::string& wanted = "string") {
+		assert(!gen && "get_string is not supported for generators.");
+		if(ws) {
+			char next = in.peek();
+			if(isspace(next)) expected(wanted, next == '\n' ? "newline" : "whitespace");
+			if(in.eof()) expected(wanted, "EOF");
+		}
+
+		std::string s;
+		if(in >> s) {
+			return s;
+		}
+		expected(wanted, "nothing");
+	}
+
+	// Return ACCEPTED verdict.
+	void AC() const {
+		if(gen) {
+			// nothing
+			return;
+		}
+
+		exit(ret_AC);
+	}
+
+	void eof() {
+		if(gen) {
+			out.flush();
+			fclose(stdout);
+			return;
+		}
+		if(in.eof()) return;
+		// Sometimes EOF hasn't been triggered yet.
+		if(!ws) in >> std::ws;
+		char c = in.get();
+		if(c == std::char_traits<char>::eof()) return;
+		std::string got = std::string("\"") + char(c) + '"';
+		if(c == '\n') got = "newline";
+		expected("EOF", got);
+	}
+
+	// Convert a string to lowercase is matching is not case sensitive.
+	std::string& lowercase(std::string& s) const {
+		if(case_sensitive) return s;
+		transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return std::tolower(c); });
+		return s;
+	}
+
+	// Keep track of the min/max value read at every call site.
+	template <typename T>
+	struct Bounds {
+		Bounds(std::string name_, T min_, T max_, T low_, T high_)
+		    : name(std::move(name_)), min(min_), max(max_), low(low_), high(high_) {} // NOLINT
+		std::string name;
+		T min, max;  // Smallest / largest value observed
+		T low, high; // Bounds
+		bool has_min = false, has_max = false;
+	};
+
+	std::map<source_location, std::variant<Bounds<long long>, Bounds<long double>>> bounds;
+
+	void write_constraints() {
+		if(constraints_file_path.empty()) return;
+
+		std::ofstream os(constraints_file_path);
+
+		for(const auto& [location, bound] : bounds) {
+			os << location_to_string(location) << " ";
+			std::visit(
+			    [&](const auto& b) {
+				    os << b.name << " " << b.has_min << " " << b.has_max << " " << b.min << " "
+				       << b.max << " " << b.low << " " << b.high << std::endl;
+			    },
+			    bound);
+		}
+	}
+
+	static const int ret_AC = 42, ret_WA = 43;
+	std::istream& in  = std::cin;
+	std::ostream& out = std::cout;
+
+  public:
+	const bool ws             = true;
+	const bool case_sensitive = true;
+	const std::string constraints_file_path;
+	const bool gen = false;
+
+	std::mt19937_64 rng;
+
+  private:
+	std::unordered_map<std::string, ParamGenerator> params;
+
+  public:
+	std::string_view get_param(std::string_view name, std::string_view default_) {
+		auto it = params.find(std::string(name));
+		if(it == params.end()) return default_;
+		return std::get<std::string_view>(it->second.generator);
+	}
+
+  protected:
+	static std::string get_constraints_file(int argc, char** argv) {
+		for(int i = 1; i < argc; ++i) {
+			if(argv[i] == constraints_file_flag) {
+				if(i + 1 < argc) return argv[i + 1];
+				std::cerr << constraints_file_flag << " should be followed by a file path!";
+				exit(1);
+			}
+		}
+		return {};
+	}
+};
+
+class Generator : public Validator {
+  public:
+	explicit Generator(unsigned int seed)
+	    : Validator(true, true, std::cin, /*constraints_file_path_=*/"", seed) {}
+};
+
+class InputValidator : public Validator {
+  public:
+	// An InputValidator is always both whitespace and case sensitive.
+	explicit InputValidator(int argc = 0, char** argv = nullptr)
+	    : Validator(true, true, std::cin, get_constraints_file(argc, argv), get_seed(argc, argv),
+	                get_params(argc, argv)) {}
+
+  private:
+	static std::optional<unsigned int> get_seed(int argc, char** argv) {
+		for(int i = 1; i < argc - 1; ++i) {
+			if(argv[i] == generate_flag) {
+				return std::stol(argv[i + 1]);
+			}
+		}
+		// If no --generate is given, but `generat` is a substring of the binary path,
+		// use the first argument as seed.
+		if(std::string(argv[0]).find(generate_binary_substring) != std::string::npos) {
+			return std::stol(argv[1]);
+		}
+		return std::nullopt;
+	}
+
+	static std::unordered_map<std::string, ParamGenerator> get_params(int argc, char** argv) {
+		std::unordered_map<std::string, ParamGenerator> params;
+		for(int i = 1; i < argc - 1; ++i) {
+			if(std::strlen(argv[i]) == 0 or argv[i][0] != '-') continue;
+			if(argv[i] == generate_flag) {
+				continue;
+			}
+			std::string_view name(argv[i] + 1);
+			std::string_view value(argv[i + 1]);
+			params.insert({std::string(name), ParamGenerator(value)});
+		}
+		return params;
+	}
+};
+
+class OutputValidator : public Validator {
+  public:
+	// An OutputValidator can be run in different modes.
+	explicit OutputValidator(int argc, char** argv, std::istream& in_ = std::cin)
+	    : Validator(is_ws_sensitive(argc, argv), is_case_sensitive(argc, argv), in_,
+	                get_constraints_file(argc, argv)) {}
+
+  private:
+	static bool is_ws_sensitive(int argc, char** argv) {
+		for(int i = 1; i < argc; ++i) {
+			if(argv[i] == ws_sensitive_flag) return true;
+		}
+		return false;
+	}
+
+	static bool is_case_sensitive(int argc, char** argv) {
+		for(int i = 1; i < argc; ++i) {
+			if(argv[i] == case_sensitive_flag) return true;
+		}
+		return false;
+	}
+};

ICPC/nwerc2023_A/data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb24aeac8306c68202fc2dde976466ba81c12dfeb111cd2df644468ba06ce0c3
+size 26893358

ICPC/nwerc2023_A/init.yml

@@ -0,0 +1,350 @@
+archive: data.zip
+test_cases:
+- in: 001-one_plug.in
+  out: 001-one_plug.ans
+  points: 1
+- in: 002-one_socket.in
+  out: 002-one_socket.ans
+  points: 1
+- in: 003-much_free.in
+  out: 003-much_free.ans
+  points: 1
+- in: 004-much_free.in
+  out: 004-much_free.ans
+  points: 1
+- in: 005-two_max_length.in
+  out: 005-two_max_length.ans
+  points: 1
+- in: 006-greedy_edge_case_small.in
+  out: 006-greedy_edge_case_small.ans
+  points: 1
+- in: 007-greedy_edge_case_small.in
+  out: 007-greedy_edge_case_small.ans
+  points: 1
+- in: 008-tight-pack.in
+  out: 008-tight-pack.ans
+  points: 1
+- in: 009-many_gaps.in
+  out: 009-many_gaps.ans
+  points: 1
+- in: 010-greedy_edge_case.in
+  out: 010-greedy_edge_case.ans
+  points: 1
+- in: 011-greedy_edge_case.in
+  out: 011-greedy_edge_case.ans
+  points: 1
+- in: 012-almost_max_constraints.in
+  out: 012-almost_max_constraints.ans
+  points: 1
+- in: 013-almost_max_constraints.in
+  out: 013-almost_max_constraints.ans
+  points: 1
+- in: 014-random.in
+  out: 014-random.ans
+  points: 1
+- in: 015-random.in
+  out: 015-random.ans
+  points: 1
+- in: 016-random.in
+  out: 016-random.ans
+  points: 1
+- in: 017-random.in
+  out: 017-random.ans
+  points: 1
+- in: 018-random.in
+  out: 018-random.ans
+  points: 1
+- in: 019-random.in
+  out: 019-random.ans
+  points: 1
+- in: 020-random.in
+  out: 020-random.ans
+  points: 1
+- in: 021-random.in
+  out: 021-random.ans
+  points: 1
+- in: 022-max_constraints.in
+  out: 022-max_constraints.ans
+  points: 1
+- in: 023-almost_max_constraints.in
+  out: 023-almost_max_constraints.ans
+  points: 1
+- in: 024-almost_max_constraints.in
+  out: 024-almost_max_constraints.ans
+  points: 1
+- in: 025-almost_max_constraints.in
+  out: 025-almost_max_constraints.ans
+  points: 1
+- in: 026-greedy_edge_case.in
+  out: 026-greedy_edge_case.ans
+  points: 1
+- in: 027-greedy_edge_case.in
+  out: 027-greedy_edge_case.ans
+  points: 1
+- in: 028-greedy_edge_case.in
+  out: 028-greedy_edge_case.ans
+  points: 1
+- in: 029-greedy_edge_case_small.in
+  out: 029-greedy_edge_case_small.ans
+  points: 1
+- in: 030-greedy_edge_case_small.in
+  out: 030-greedy_edge_case_small.ans
+  points: 1
+- in: 031-greedy_edge_case_small.in
+  out: 031-greedy_edge_case_small.ans
+  points: 1
+- in: 032-greedy_edge_case_small.in
+  out: 032-greedy_edge_case_small.ans
+  points: 1
+- in: 033-greedy_edge_case_small.in
+  out: 033-greedy_edge_case_small.ans
+  points: 1
+- in: 034-three_type_case.in
+  out: 034-three_type_case.ans
+  points: 1
+- in: 035-three_type_case.in
+  out: 035-three_type_case.ans
+  points: 1
+- in: 036-three_type_case.in
+  out: 036-three_type_case.ans
+  points: 1
+- in: 037-three_type_case.in
+  out: 037-three_type_case.ans
+  points: 1
+- in: 038-three_type_case.in
+  out: 038-three_type_case.ans
+  points: 1
+- in: 039-two_type_case.in
+  out: 039-two_type_case.ans
+  points: 1
+- in: 040-two_type_case.in
+  out: 040-two_type_case.ans
+  points: 1
+- in: 041-two_type_case.in
+  out: 041-two_type_case.ans
+  points: 1
+- in: 042-two_type_case.in
+  out: 042-two_type_case.ans
+  points: 1
+- in: 043-two_type_case.in
+  out: 043-two_type_case.ans
+  points: 1
+- in: 044-some_large_plugs.in
+  out: 044-some_large_plugs.ans
+  points: 1
+- in: 045-some_large_plugs.in
+  out: 045-some_large_plugs.ans
+  points: 1
+- in: 046-some_large_plugs.in
+  out: 046-some_large_plugs.ans
+  points: 1
+- in: 047-some_large_plugs.in
+  out: 047-some_large_plugs.ans
+  points: 1
+- in: 048-some_large_plugs.in
+  out: 048-some_large_plugs.ans
+  points: 1
+- in: 049-some_large_plugs.in
+  out: 049-some_large_plugs.ans
+  points: 1
+- in: 050-some_large_plugs.in
+  out: 050-some_large_plugs.ans
+  points: 1
+- in: 051-some_large_plugs.in
+  out: 051-some_large_plugs.ans
+  points: 1
+- in: 052-some_large_plugs.in
+  out: 052-some_large_plugs.ans
+  points: 1
+- in: 053-some_large_plugs.in
+  out: 053-some_large_plugs.ans
+  points: 1
+- in: 054-some_large_plugs.in
+  out: 054-some_large_plugs.ans
+  points: 1
+- in: 055-some_large_plugs.in
+  out: 055-some_large_plugs.ans
+  points: 1
+- in: 056-some_large_plugs.in
+  out: 056-some_large_plugs.ans
+  points: 1
+- in: 057-some_modulo_class.in
+  out: 057-some_modulo_class.ans
+  points: 1
+- in: 058-some_modulo_class.in
+  out: 058-some_modulo_class.ans
+  points: 1
+- in: 059-some_modulo_class.in
+  out: 059-some_modulo_class.ans
+  points: 1
+- in: 060-some_modulo_class.in
+  out: 060-some_modulo_class.ans
+  points: 1
+- in: 061-some_modulo_class.in
+  out: 061-some_modulo_class.ans
+  points: 1
+- in: 062-some_modulo_class.in
+  out: 062-some_modulo_class.ans
+  points: 1
+- in: 063-some_modulo_class.in
+  out: 063-some_modulo_class.ans
+  points: 1
+- in: 064-some_modulo_class.in
+  out: 064-some_modulo_class.ans
+  points: 1
+- in: 065-some_modulo_class.in
+  out: 065-some_modulo_class.ans
+  points: 1
+- in: 066-some_modulo_class.in
+  out: 066-some_modulo_class.ans
+  points: 1
+- in: 067-some_modulo_class.in
+  out: 067-some_modulo_class.ans
+  points: 1
+- in: 068-some_modulo_class.in
+  out: 068-some_modulo_class.ans
+  points: 1
+- in: 069-some_modulo_class.in
+  out: 069-some_modulo_class.ans
+  points: 1
+- in: 070-some_modulo_class.in
+  out: 070-some_modulo_class.ans
+  points: 1
+- in: 071-some_modulo_class.in
+  out: 071-some_modulo_class.ans
+  points: 1
+- in: 072-some_modulo_class.in
+  out: 072-some_modulo_class.ans
+  points: 1
+- in: 073-some_modulo_class.in
+  out: 073-some_modulo_class.ans
+  points: 1
+- in: 074-some_modulo_class.in
+  out: 074-some_modulo_class.ans
+  points: 1
+- in: 075-some_modulo_class.in
+  out: 075-some_modulo_class.ans
+  points: 1
+- in: 076-some_modulo_class.in
+  out: 076-some_modulo_class.ans
+  points: 1
+- in: 077-some_modulo_class.in
+  out: 077-some_modulo_class.ans
+  points: 1
+- in: 078-some_modulo_class.in
+  out: 078-some_modulo_class.ans
+  points: 1
+- in: 079-some_modulo_class.in
+  out: 079-some_modulo_class.ans
+  points: 1
+- in: 080-some_modulo_class.in
+  out: 080-some_modulo_class.ans
+  points: 1
+- in: 081-some_modulo_class.in
+  out: 081-some_modulo_class.ans
+  points: 1
+- in: 082-some_modulo_class.in
+  out: 082-some_modulo_class.ans
+  points: 1
+- in: 083-some_modulo_class.in
+  out: 083-some_modulo_class.ans
+  points: 1
+- in: 084-some_modulo_class.in
+  out: 084-some_modulo_class.ans
+  points: 1
+- in: 085-some_modulo_class.in
+  out: 085-some_modulo_class.ans
+  points: 1
+- in: 086-some_modulo_class.in
+  out: 086-some_modulo_class.ans
+  points: 1
+- in: 087-some_modulo_class.in
+  out: 087-some_modulo_class.ans
+  points: 1
+- in: 088-some_modulo_class.in
+  out: 088-some_modulo_class.ans
+  points: 1
+- in: 089-some_modulo_class.in
+  out: 089-some_modulo_class.ans
+  points: 1
+- in: 090-some_modulo_class.in
+  out: 090-some_modulo_class.ans
+  points: 1
+- in: 091-some_modulo_class.in
+  out: 091-some_modulo_class.ans
+  points: 1
+- in: 092-some_modulo_class.in
+  out: 092-some_modulo_class.ans
+  points: 1
+- in: 093-some_modulo_class.in
+  out: 093-some_modulo_class.ans
+  points: 1
+- in: 094-some_modulo_class.in
+  out: 094-some_modulo_class.ans
+  points: 1
+- in: 095-some_modulo_class.in
+  out: 095-some_modulo_class.ans
+  points: 1
+- in: 096-some_modulo_class.in
+  out: 096-some_modulo_class.ans
+  points: 1
+- in: 097-some_modulo_class.in
+  out: 097-some_modulo_class.ans
+  points: 1
+- in: 098-some_modulo_class.in
+  out: 098-some_modulo_class.ans
+  points: 1
+- in: 099-some_modulo_class.in
+  out: 099-some_modulo_class.ans
+  points: 1
+- in: 100-some_modulo_class.in
+  out: 100-some_modulo_class.ans
+  points: 1
+- in: 101-some_modulo_class.in
+  out: 101-some_modulo_class.ans
+  points: 1
+- in: 102-some_modulo_class.in
+  out: 102-some_modulo_class.ans
+  points: 1
+- in: 103-some_modulo_class.in
+  out: 103-some_modulo_class.ans
+  points: 1
+- in: 104-some_modulo_class.in
+  out: 104-some_modulo_class.ans
+  points: 1
+- in: 105-some_modulo_class.in
+  out: 105-some_modulo_class.ans
+  points: 1
+- in: 106-some_modulo_class.in
+  out: 106-some_modulo_class.ans
+  points: 1
+- in: 107-some_modulo_class.in
+  out: 107-some_modulo_class.ans
+  points: 1
+- in: 108-some_modulo_class.in
+  out: 108-some_modulo_class.ans
+  points: 1
+- in: 109-some_modulo_class.in
+  out: 109-some_modulo_class.ans
+  points: 1
+- in: 110-some_modulo_class.in
+  out: 110-some_modulo_class.ans
+  points: 1
+- in: 111-some_modulo_class.in
+  out: 111-some_modulo_class.ans
+  points: 1
+- in: 112-some_modulo_class.in
+  out: 112-some_modulo_class.ans
+  points: 1
+- in: 113-some_modulo_class.in
+  out: 113-some_modulo_class.ans
+  points: 1
+- in: 114-some_modulo_class.in
+  out: 114-some_modulo_class.ans
+  points: 1
+- in: 115-some_modulo_class.in
+  out: 115-some_modulo_class.ans
+  points: 1
+- in: 116-some_modulo_class.in
+  out: 116-some_modulo_class.ans
+  points: 1

ICPC/nwerc2023_B/data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec6dceb011ea9328d261a0dfbff0d804afec39333cb02894d8054f26e978da0d
+size 22766975

ICPC/nwerc2023_B/init.yml

@@ -0,0 +1,406 @@
+archive: data.zip
+checker:
+  args:
+    files:
+    - output_validators/output_validator/validate.h
+    - output_validators/output_validator/outputValidator.cpp
+    lang: CPP17
+    type: default
+  name: bridged
+test_cases:
+- in: 001-earlyBreak.in
+  out: 001-earlyBreak.ans
+  points: 1
+- in: 002-manual_impossible.in
+  out: 002-manual_impossible.ans
+  points: 1
+- in: 003-manual_impossible.in
+  out: 003-manual_impossible.ans
+  points: 1
+- in: 004-ones_twos.in
+  out: 004-ones_twos.ans
+  points: 1
+- in: 005-ones_twos.in
+  out: 005-ones_twos.ans
+  points: 1
+- in: 006-ones_twos.in
+  out: 006-ones_twos.ans
+  points: 1
+- in: 007-residue.in
+  out: 007-residue.ans
+  points: 1
+- in: 008-residue.in
+  out: 008-residue.ans
+  points: 1
+- in: 009-residue.in
+  out: 009-residue.ans
+  points: 1
+- in: 010-residue.in
+  out: 010-residue.ans
+  points: 1
+- in: 011-residue.in
+  out: 011-residue.ans
+  points: 1
+- in: 012-residue.in
+  out: 012-residue.ans
+  points: 1
+- in: 013-residue.in
+  out: 013-residue.ans
+  points: 1
+- in: 014-residue.in
+  out: 014-residue.ans
+  points: 1
+- in: 015-residue.in
+  out: 015-residue.ans
+  points: 1
+- in: 016-residue.in
+  out: 016-residue.ans
+  points: 1
+- in: 017-residue.in
+  out: 017-residue.ans
+  points: 1
+- in: 018-residue.in
+  out: 018-residue.ans
+  points: 1
+- in: 019-residue.in
+  out: 019-residue.ans
+  points: 1
+- in: 020-random.in
+  out: 020-random.ans
+  points: 1
+- in: 021-random.in
+  out: 021-random.ans
+  points: 1
+- in: 022-random.in
+  out: 022-random.ans
+  points: 1
+- in: 023-random.in
+  out: 023-random.ans
+  points: 1
+- in: 024-random.in
+  out: 024-random.ans
+  points: 1
+- in: 025-useAll.in
+  out: 025-useAll.ans
+  points: 1
+- in: 026-useAll.in
+  out: 026-useAll.ans
+  points: 1
+- in: 027-useAll.in
+  out: 027-useAll.ans
+  points: 1
+- in: 028-unique.in
+  out: 028-unique.ans
+  points: 1
+- in: 029-unique.in
+  out: 029-unique.ans
+  points: 1
+- in: 030-unique.in
+  out: 030-unique.ans
+  points: 1
+- in: 031-unique.in
+  out: 031-unique.ans
+  points: 1
+- in: 032-unique.in
+  out: 032-unique.ans
+  points: 1
+- in: 033-unique.in
+  out: 033-unique.ans
+  points: 1
+- in: 034-many.in
+  out: 034-many.ans
+  points: 1
+- in: 035-residue.in
+  out: 035-residue.ans
+  points: 1
+- in: 036-residue.in
+  out: 036-residue.ans
+  points: 1
+- in: 037-residue.in
+  out: 037-residue.ans
+  points: 1
+- in: 038-residue.in
+  out: 038-residue.ans
+  points: 1
+- in: 039-residue.in
+  out: 039-residue.ans
+  points: 1
+- in: 040-residue.in
+  out: 040-residue.ans
+  points: 1
+- in: 041-residue.in
+  out: 041-residue.ans
+  points: 1
+- in: 042-residue.in
+  out: 042-residue.ans
+  points: 1
+- in: 043-residue.in
+  out: 043-residue.ans
+  points: 1
+- in: 044-residue.in
+  out: 044-residue.ans
+  points: 1
+- in: 045-residue.in
+  out: 045-residue.ans
+  points: 1
+- in: 046-residue.in
+  out: 046-residue.ans
+  points: 1
+- in: 047-residue.in
+  out: 047-residue.ans
+  points: 1
+- in: 048-manual_possible.in
+  out: 048-manual_possible.ans
+  points: 1
+- in: 049-manual_possible.in
+  out: 049-manual_possible.ans
+  points: 1
+- in: 050-manual_possible.in
+  out: 050-manual_possible.ans
+  points: 1
+- in: 051-manual_possible.in
+  out: 051-manual_possible.ans
+  points: 1
+- in: 052-manual_possible.in
+  out: 052-manual_possible.ans
+  points: 1
+- in: 053-manual_possible.in
+  out: 053-manual_possible.ans
+  points: 1
+- in: 054-manual_possible.in
+  out: 054-manual_possible.ans
+  points: 1
+- in: 055-manual_possible.in
+  out: 055-manual_possible.ans
+  points: 1
+- in: 056-manual_possible.in
+  out: 056-manual_possible.ans
+  points: 1
+- in: 057-manual_possible.in
+  out: 057-manual_possible.ans
+  points: 1
+- in: 058-manual_possible.in
+  out: 058-manual_possible.ans
+  points: 1
+- in: 059-manual_impossible.in
+  out: 059-manual_impossible.ans
+  points: 1
+- in: 060-manual_impossible.in
+  out: 060-manual_impossible.ans
+  points: 1
+- in: 061-manual_impossible.in
+  out: 061-manual_impossible.ans
+  points: 1
+- in: 062-random.in
+  out: 062-random.ans
+  points: 1
+- in: 063-random.in
+  out: 063-random.ans
+  points: 1
+- in: 064-random.in
+  out: 064-random.ans
+  points: 1
+- in: 065-random.in
+  out: 065-random.ans
+  points: 1
+- in: 066-random.in
+  out: 066-random.ans
+  points: 1
+- in: 067-random.in
+  out: 067-random.ans
+  points: 1
+- in: 068-random.in
+  out: 068-random.ans
+  points: 1
+- in: 069-random.in
+  out: 069-random.ans
+  points: 1
+- in: 070-random.in
+  out: 070-random.ans
+  points: 1
+- in: 071-random.in
+  out: 071-random.ans
+  points: 1
+- in: 072-range.in
+  out: 072-range.ans
+  points: 1
+- in: 073-range.in
+  out: 073-range.ans
+  points: 1
+- in: 074-range.in
+  out: 074-range.ans
+  points: 1
+- in: 075-range.in
+  out: 075-range.ans
+  points: 1
+- in: 076-range.in
+  out: 076-range.ans
+  points: 1
+- in: 077-range.in
+  out: 077-range.ans
+  points: 1
+- in: 078-range.in
+  out: 078-range.ans
+  points: 1
+- in: 079-range.in
+  out: 079-range.ans
+  points: 1
+- in: 080-range.in
+  out: 080-range.ans
+  points: 1
+- in: 081-range.in
+  out: 081-range.ans
+  points: 1
+- in: 082-range.in
+  out: 082-range.ans
+  points: 1
+- in: 083-range.in
+  out: 083-range.ans
+  points: 1
+- in: 084-many_same.in
+  out: 084-many_same.ans
+  points: 1
+- in: 085-many_same.in
+  out: 085-many_same.ans
+  points: 1
+- in: 086-many_same.in
+  out: 086-many_same.ans
+  points: 1
+- in: 087-many_same.in
+  out: 087-many_same.ans
+  points: 1
+- in: 088-many_same.in
+  out: 088-many_same.ans
+  points: 1
+- in: 089-many_same.in
+  out: 089-many_same.ans
+  points: 1
+- in: 090-many_same.in
+  out: 090-many_same.ans
+  points: 1
+- in: 091-many_same.in
+  out: 091-many_same.ans
+  points: 1
+- in: 092-many_same.in
+  out: 092-many_same.ans
+  points: 1
+- in: 093-many_same.in
+  out: 093-many_same.ans
+  points: 1
+- in: 094-many_same.in
+  out: 094-many_same.ans
+  points: 1
+- in: 095-many_same.in
+  out: 095-many_same.ans
+  points: 1
+- in: 096-many_same.in
+  out: 096-many_same.ans
+  points: 1
+- in: 097-powers_of_two.in
+  out: 097-powers_of_two.ans
+  points: 1
+- in: 098-powers_of_two.in
+  out: 098-powers_of_two.ans
+  points: 1
+- in: 099-powers_of_two.in
+  out: 099-powers_of_two.ans
+  points: 1
+- in: 100-powers_of_two.in
+  out: 100-powers_of_two.ans
+  points: 1
+- in: 101-powers_of_three.in
+  out: 101-powers_of_three.ans
+  points: 1
+- in: 102-powers_of_three.in
+  out: 102-powers_of_three.ans
+  points: 1
+- in: 103-diviors.in
+  out: 103-diviors.ans
+  points: 1
+- in: 104-max.in
+  out: 104-max.ans
+  points: 1
+- in: 105-max.in
+  out: 105-max.ans
+  points: 1
+- in: 106-max.in
+  out: 106-max.ans
+  points: 1
+- in: 107-max.in
+  out: 107-max.ans
+  points: 1
+- in: 108-min.in
+  out: 108-min.ans
+  points: 1
+- in: 109-min.in
+  out: 109-min.ans
+  points: 1
+- in: 110-min.in
+  out: 110-min.ans
+  points: 1
+- in: 111-min.in
+  out: 111-min.ans
+  points: 1
+- in: 112-min.in
+  out: 112-min.ans
+  points: 1
+- in: 113-min.in
+  out: 113-min.ans
+  points: 1
+- in: 114-small.in
+  out: 114-small.ans
+  points: 1
+- in: 115-small.in
+  out: 115-small.ans
+  points: 1
+- in: 116-small.in
+  out: 116-small.ans
+  points: 1
+- in: 117-small.in
+  out: 117-small.ans
+  points: 1
+- in: 118-small.in
+  out: 118-small.ans
+  points: 1
+- in: 119-small.in
+  out: 119-small.ans
+  points: 1
+- in: 120-small.in
+  out: 120-small.ans
+  points: 1
+- in: 121-small.in
+  out: 121-small.ans
+  points: 1
+- in: 122-small.in
+  out: 122-small.ans
+  points: 1
+- in: 123-small.in
+  out: 123-small.ans
+  points: 1
+- in: 124-small.in
+  out: 124-small.ans
+  points: 1
+- in: 125-small.in
+  out: 125-small.ans
+  points: 1
+- in: 126-small.in
+  out: 126-small.ans
+  points: 1
+- in: 127-small.in
+  out: 127-small.ans
+  points: 1
+- in: 128-small.in
+  out: 128-small.ans
+  points: 1
+- in: 129-small.in
+  out: 129-small.ans
+  points: 1
+- in: 130-small.in
+  out: 130-small.ans
+  points: 1
+- in: 131-small.in
+  out: 131-small.ans
+  points: 1
+- in: 132-small.in
+  out: 132-small.ans
+  points: 1

ICPC/nwerc2023_B/output_validators/output_validator/outputValidator.cpp

@@ -0,0 +1,104 @@
+
+#include<cstdlib>
+int qwerty_getcode(int code) {
+    return code == 42? 0: 1;
+}
+namespace std {
+    void qwerty_exit(int code){
+        exit(qwerty_getcode(code));
+    }
+} using std::qwerty_exit;
+#define exit qwerty_exit
+#define main qwerty_main
+#include "validate.h"
+
+int main(int argc, char **argv) {
+	OutputValidator::init(argc, argv);					// initialize streams, rng and parse arguments
+	using namespace OutputValidator;
+
+	Integer n = testIn.integer();
+	Integer w = testIn.integer();
+	auto ws = testIn.integers(n);
+	std::sort(ws.begin(), ws.end());
+	ws.push_back(LARGE);
+
+	auto check = [&](std::vector<std::vector<Integer>> wall, std::string_view sol, Verdict v){
+		for (auto& row : wall) {
+			Integer sum = 0;
+			for (Integer& brick : row) {
+				if (*std::lower_bound(ws.begin(), ws.end(), brick) != brick) {
+					juryOut << sol << " solution contains invalid brick: " << brick << v;
+				}
+				brick += sum;
+				sum = brick;
+			}
+			if (sum != w) {
+				juryOut << sol << " solution has invalid row length: " << sum << v;
+			}
+			row.pop_back();
+		}
+		Integer a = 0;
+		Integer b = 0;
+		while(a < wall[0].size() && b < wall[1].size()) {
+			if(wall[0][a] < wall[1][b])
+				a++;
+			else if(wall[0][a] > wall[1][b])
+				b++;
+			else
+				juryOut << sol << " solution is unstable at x=" << wall[0][a] << v;
+		}
+	};
+
+	auto jury = juryAns.string(std::regex("(impossible|possible)", std::regex::icase));
+	auto team = teamAns.string(std::regex("(impossible|possible)", std::regex::icase));
+	if (caseSensitive) {
+		if(jury != "possible" && jury != "impossible") juryOut << "wrong case" << FAIL;
+		if(team != "possible" && team != "impossible") juryOut << "wrong case" << WA;
+	}
+	toLower(jury);
+	toLower(team);
+	teamAns.newline();
+
+	if(jury == "possible") {
+		Integer rows = 2; //juryAns.integer(1, 11);
+		std::vector<std::vector<Integer>> wall(rows);
+		for (auto& row : wall) {
+			Integer k = juryAns.integer(1, w+1);
+			row = juryAns.integers(1, w+1, k);
+		}
+		check(wall, "jury", FAIL);
+	}
+	if(team == "possible") {
+		Integer rows = 2; //teamAns.integer(1, 11);
+		std::vector<std::vector<Integer>> wall(rows);
+		for (auto& row : wall) {
+			Integer k = teamAns.integer(1, w+1);
+			teamAns.newline();
+			row = teamAns.integers(1, w+1, k);
+			teamAns.newline();
+		}
+		check(wall, "team", WA);
+	}
+
+	if(jury == "possible" && team == "impossible") juryOut << "team found no solution but jury did" << WA;
+	if(team == "possible" && jury == "impossible") juryOut << "jury found no solution but team did" << FAIL;
+
+	teamAns.eof();
+	return AC;
+}
+
+#undef main
+#include<cstdio>
+#include<vector>
+#include<string>
+#include<filesystem>
+int main(int argc, char **argv) {
+	namespace fs = std::filesystem;
+    freopen(argv[2], "r", stdin);
+    char judge_out[] = "/dev";
+    std::vector<char*> new_argv = {
+		argv[0], argv[1], argv[3],
+		judge_out,
+	};
+	return qwerty_getcode(qwerty_main((int)new_argv.size(), new_argv.data()));
+}

ICPC/nwerc2023_B/output_validators/output_validator/validate.h

@@ -0,0 +1,2662 @@
+//============================================================================//
+// validate.h                                                                 //
+//============================================================================//
+// This header can be used to safely parse team output tokenwise. We support: //
+// - string tokens (get converted to lowercase)                               //
+// - integer tokens in [-2^63, 2^63)                                          //
+// - float tokens (relative and absolute error of 10^6 is allowed by default) //
+// Tokens need to be separated by whitespace (any amount). The following      //
+// command line flags allow stricter checking:                                //
+// - caseSensitive: string tokens don't get converted to lowercase            //
+// - space_change_sensitive: tokens need to be separated by the corect        //
+//   amount of whitespaces                                                    //
+// - FLOAT_{RELATIVE|ABSOLUTE}_TOLERANCE: allowed relative/absolute error     //
+//                                                                            //
+// This header can also be used to safely verify input files. In this case    //
+// tokens are case sensitive and all whitespaces have to be checked. Also     //
+// whitespaces are not interchangeable.                                       //
+//                                                                            //
+// This header can be used to generate random numbers in a deterministic and  //
+// reproducable fashion. (The randomness is consistent across compilers and   //
+// machines)                                                                  //
+//============================================================================//
+// version 2.3.2                                                              //
+// https://github.com/mzuenni/icpc-header                                     //
+//============================================================================//
+
+#ifndef VALIDATE_H
+#define VALIDATE_H
+
+#include <algorithm>
+#include <array>
+#include <bitset>
+#include <cctype>
+#include <cmath>
+#include <charconv>
+#include <complex>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <functional>
+#include <iomanip>
+#include <iostream>
+#include <limits>
+#include <map>
+#include <numeric>
+#include <optional>
+#include <queue>
+#include <random>
+#include <regex>
+#include <set>
+#include <string>
+#include <string_view>
+#include <typeinfo>
+#include <typeindex>
+#include <type_traits>
+#include <utility>
+#include <variant>
+#include <vector>
+
+
+//============================================================================//
+// Basic definitions and constants                                            //
+//============================================================================//
+// default types
+using Integer = std::int64_t;
+using Real = long double;
+
+// derived types
+using UInteger = std::make_unsigned<Integer>::type;
+constexpr Integer operator ""_int(unsigned long long int value) {return static_cast<Integer>(value);}
+constexpr UInteger operator ""_uint(unsigned long long int value) {return static_cast<UInteger>(value);}
+constexpr Real operator ""_real(unsigned long long int value) {return static_cast<Real>(value);}
+constexpr Real operator ""_real(long double value) {return static_cast<Real>(value);}
+
+// settings which can be overwritten before the include!
+//#define DOUBLE_FALLBACK
+namespace Settings {
+	namespace details {
+		using RandomEngine                              = std::mt19937_64;
+		constexpr Integer LARGE                         = 0x3FFF'FFFF'FFFF'FFFF;
+		constexpr bool DEFAULT_CASE_LOWER               = true;
+		constexpr int DEFAULT_PRECISION                 = 6;
+		constexpr Real DEFAULT_EPS                      = 1e-6_real;
+
+		[[noreturn]] void exitVerdict(int exitCode) {
+			//throw exitCode;
+			//quick_exit(exitCode);
+			std::exit(exitCode);
+		}
+	}
+	using namespace details;
+}
+// make settings publically available
+using Settings::RandomEngine;
+using Settings::LARGE;
+using Settings::DEFAULT_CASE_LOWER;
+using Settings::DEFAULT_PRECISION;
+using Settings::DEFAULT_EPS;
+using Settings::exitVerdict;
+
+// useful constants
+constexpr std::string_view LETTER                       = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+constexpr std::string_view UPPER                        = LETTER.substr(0, 26);
+constexpr std::string_view LOWER                        = LETTER.substr(26);
+constexpr std::string_view VOWEL                        = "AEIOUaeiou";
+constexpr std::string_view UPPER_VOWELS                 = VOWEL.substr(0, 5);
+constexpr std::string_view LOWER_VOWELS                 = VOWEL.substr(5);
+constexpr std::string_view CONSONANT                    = "BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz";
+constexpr std::string_view UPPER_CONSONANT              = CONSONANT.substr(0, 26 - 5);
+constexpr std::string_view LOWER_CONSONANT              = CONSONANT.substr(26 - 5);
+constexpr std::string_view ALPHA_NUMERIC                = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+constexpr std::string_view UPPER_ALPHA_NUMERIC          = ALPHA_NUMERIC.substr(0, 10 + 26);
+constexpr std::string_view LOWER_ALPHA_NUMERIC          = "0123456789abcdefghijklmnopqrstuvwxyz";
+constexpr std::string_view DIGITS                       = ALPHA_NUMERIC.substr(0, 10);
+constexpr std::string_view BRACKETS                     = "()[]{}<>";
+constexpr char NEWLINE                                  = '\n';
+constexpr char SPACE                                    = ' ';
+constexpr char NOSEP                                    = '\0';
+constexpr Real PI                                       = 3.1415926535897932384626433832795028_real;
+
+
+//============================================================================//
+// internal definitions and constants                                         //
+//============================================================================//
+constexpr UInteger DEFAULT_SEED                         = 3141592653589793238_uint;
+constexpr std::string_view CASE_SENSITIVE               = "case_sensitive";
+constexpr std::string_view SPACE_SENSITIVE              = "space_change_sensitive";
+constexpr std::string_view FLOAT_ABSOLUTE_TOLERANCE     = "float_absolute_tolerance";
+constexpr std::string_view FLOAT_RELATIVE_TOLERANCE     = "float_relative_tolerance";
+constexpr std::string_view FLOAT_TOLERANCE              = "float_tolerance";
+constexpr std::string_view JUDGE_MESSAGE                = "null";
+constexpr char DEFAULT_SEPARATOR                        = SPACE;
+constexpr std::string_view EMPTY_COMMAND                = "";
+constexpr std::string_view COMMAND_PREFIX               = "--";
+constexpr std::string_view CONSTRAINT_COMMAND           = "--constraints_file";
+constexpr std::string_view SEED_COMMAND                 = "--seed";
+constexpr auto REGEX_OPTIONS                            = std::regex::nosubs | std::regex::optimize;
+inline const std::regex INTEGER_REGEX("0|-?[1-9][0-9]*", REGEX_OPTIONS);
+inline const std::regex REAL_REGEX("-?(0|([1-9][0-9]*))(\\.[0-9]*)?([eE][+-]?(0|([1-9][0-9]*)))?", REGEX_OPTIONS);
+inline const std::regex STRICT_REAL_REGEX("-?(0|([1-9][0-9]*))\\.?[0-9]*", REGEX_OPTIONS);
+
+static_assert(2'000'000'000'000'000'000_int < LARGE / 2, "LARGE too small");
+static_assert(LARGE <= std::numeric_limits<Integer>::max() / 2, "LARGE too big");
+
+static_assert(-1 == 0xFFFF'FFFF'FFFF'FFFF_int, "Two's complement for signed numbers is required" );
+static_assert(std::is_convertible_v<Integer, UInteger>, "Incompatible Integer and UInteger types?!");
+static_assert(std::is_convertible_v<UInteger, Integer>, "Incompatible Integer and UInteger types?!");
+static_assert(sizeof(Integer) == sizeof(UInteger), "Incompatible Integer and UInteger types?!");
+
+template<typename T = std::logic_error>
+constexpr void judgeAssert(bool asserted, std::string_view message) {
+	if (!asserted) throw T(message.data());
+}
+
+
+//============================================================================//
+// SFINAE                                                                     //
+//============================================================================//
+namespace details {
+	template<typename T, typename = void>
+	struct IsContainer : std::false_type {};
+
+	template<typename T>
+	struct IsContainer<T, std::void_t<decltype(std::begin(std::declval<std::add_lvalue_reference_t<T>>()))>> : std::true_type {
+		using iterator_type = decltype(std::begin(std::declval<std::add_lvalue_reference_t<T>>()));
+		using value_type = std::remove_reference_t<decltype(*std::begin(std::declval<std::add_lvalue_reference_t<T>>()))>;
+	};
+
+	template<typename T>
+	struct IsStdArray : std::false_type {};
+
+	template<typename T, std::size_t N>
+	struct IsStdArray<std::array<T, N>> : std::true_type {};
+
+	template<typename T, typename = void>
+	struct IsTupleLike : std::false_type {};
+
+	template<typename T>
+	struct IsTupleLike<T, std::void_t<decltype(sizeof(std::tuple_size<T>))>> : std::true_type {};
+
+	template<typename T, typename = void>
+	struct HasOstreamOperator : std::false_type {};
+
+	template<typename T>
+	struct HasOstreamOperator<T, std::void_t<decltype(std::declval<std::ostream>() << std::declval<T>())>> : std::true_type {};
+}
+
+
+//============================================================================//
+// Verdicts                                                                   //
+//============================================================================//
+struct Verdict final {
+	int exitCode;
+
+	constexpr explicit Verdict(int exitCode_ = 1) : exitCode(exitCode_) {}
+
+	constexpr operator int() const {
+		return exitCode;
+	}
+
+	[[noreturn]] void exit() const {
+		exitVerdict(exitCode);
+	}
+
+	friend void operator<<(std::ostream& os, const Verdict& v) {
+		os << std::endl;
+		v.exit();
+	}
+};
+
+// default verdicts (we do not support scoring)
+constexpr Verdict AC(42);
+constexpr Verdict WA(43);
+constexpr Verdict PE = WA;
+constexpr Verdict FAIL(1);
+
+
+//============================================================================//
+// Output streams                                                             //
+//============================================================================//
+class NullStream final : public std::ostream {
+	class NullBuffer final : public std::streambuf {
+	protected:
+		std::streamsize xsputn(const char* /**/, std::streamsize n) override {
+			return n;
+		}
+		int overflow(int c = std::char_traits<char>::eof()) override {
+			return std::char_traits<char>::not_eof(c);
+		}
+	} nullBuffer;
+public:
+	NullStream() : std::ostream(&nullBuffer) {}
+};
+
+namespace details {
+	NullStream nullStream;
+}
+
+class OutputStream final {
+	std::unique_ptr<std::ofstream> managed;
+	std::ostream* os;
+
+	void init() {
+		*os << std::boolalpha;
+		*os << std::fixed;
+		*os << std::setprecision(DEFAULT_PRECISION);
+	}
+
+public:
+	OutputStream() : os(&details::nullStream) {}
+	OutputStream(std::ostream& os_) : os(&os_) {init();}
+	explicit OutputStream(const std::filesystem::path& path) : managed(std::make_unique<std::ofstream>(path)), os(managed.get()) {
+		judgeAssert<std::runtime_error>(managed->good(), "OutputStream: Could not open File: " + path.string());
+		init();
+	}
+
+	OutputStream(OutputStream&& other) = default;
+	OutputStream& operator=(OutputStream&& other) = default;
+
+	OutputStream(const OutputStream&) = delete;
+	OutputStream& operator=(const OutputStream&) = delete;
+
+
+	template<typename L, typename R>
+	OutputStream& operator<<(const std::pair<L, R>& t) {
+		return *this << t.first << DEFAULT_SEPARATOR << t.second;
+	}
+
+	template<typename... Args>
+	OutputStream& operator<<(const std::tuple<Args...>& t) {
+		return join(t, std::index_sequence_for<Args...>(), DEFAULT_SEPARATOR);
+	}
+
+	template<typename T>
+	OutputStream& operator<<(const T& x) {
+		if constexpr ((std::is_array_v<T> and !std::is_same_v<std::decay_t<T>, char*>) or
+		              (details::IsContainer<T>{} and !details::HasOstreamOperator<T>{})) {
+			return join(std::begin(x), std::end(x), DEFAULT_SEPARATOR);
+		} else {
+			*os << x;
+			return *this;
+		}
+	}
+
+	OutputStream& operator<<(std::ostream& (*manip)(std::ostream&)) {
+		*os << manip;
+		return *this;
+	}
+
+	template<typename Tuple, std::size_t... Is>
+	OutputStream& join(const Tuple& t, std::index_sequence<Is...> /**/, char separator) {
+		static_assert(std::tuple_size_v<Tuple> == sizeof...(Is));
+		if (separator != NOSEP) ((*os << (Is == 0 ? std::string_view() : std::string_view(&separator, 1)), *this << std::get<Is>(t)), ...);
+		else ((*this << std::get<Is>(t)), ...);
+		return *this;
+	}
+
+	template<typename T>
+	OutputStream& join(T first, T last, char separator) {
+		for (auto it = first; it != last; it++) {
+			if (it != first and separator != NOSEP) *os << separator;
+			*this << *it;
+		}
+		return *this;
+	}
+};
+
+namespace ValidateBase {
+	// define this early so everyone can use it!
+	OutputStream juryErr(std::cerr);
+	OutputStream juryOut(std::cout);
+}
+
+// allow printing colletions as:
+// join(begin(), end(), [sep])
+namespace details {
+	template<typename C>
+	class TempWriter final {
+		C callable;
+	public:
+		constexpr explicit TempWriter(const C& callable_) : callable(callable_) {}
+
+		TempWriter(const TempWriter&) = delete;
+		TempWriter(TempWriter&&) = delete;
+		TempWriter& operator=(const TempWriter&) = delete;
+		TempWriter& operator=(TempWriter&&) = delete;
+
+		std::string asString() const {
+			std::ostringstream os;
+			OutputStream tmp(os);
+			tmp << *this;
+			return os.str();
+		}
+
+		explicit operator std::string() const {
+			return asString();
+		}
+
+		friend OutputStream& operator<<(OutputStream& os, const TempWriter<C>& writer) {
+			writer.callable(os);
+			return os;
+		}
+
+		friend OutputStream& operator<<(std::ostream& os, const TempWriter<C>& writer) = delete; //news OutputStream
+	};
+
+	struct JoinListCapture {
+		std::function<void(OutputStream&, char separator)> callable;
+
+		template<typename... Args>
+		JoinListCapture(Args&&... args)
+			: callable([t = std::forward_as_tuple(args...)](OutputStream& os, char separator) {
+			os.join(t, std::index_sequence_for<Args...>(), separator);
+		}) {}
+	};
+}
+
+template<typename T>
+constexpr auto join(T first, T last, char separator = DEFAULT_SEPARATOR) {
+	return details::TempWriter([=](OutputStream& os) {
+		os.join(first, last, separator);
+	});
+}
+
+template<typename CR,
+         typename = std::enable_if_t<details::IsContainer<CR>{}>,
+         typename = std::enable_if_t<!details::IsStdArray<std::remove_cv_t<std::remove_reference_t<CR>>>{}>>
+constexpr auto join(CR&& c, char separator = DEFAULT_SEPARATOR) {
+	if constexpr(std::is_rvalue_reference_v<CR&&>) {
+		if constexpr (std::is_array_v<CR>) {
+			return details::TempWriter([c, separator](OutputStream& os) {
+				os.join(std::begin(c), std::end(c), separator);
+			});
+		} else {
+			return details::TempWriter([c = std::move(c), separator](OutputStream& os) {
+				os.join(std::begin(c), std::end(c), separator);
+			});
+		}
+	} else {
+		return join(std::begin(c), std::end(c), separator);
+	}
+}
+
+template<typename CR, std::size_t N = std::tuple_size<std::decay_t<CR>>::value>
+constexpr auto join(CR&& c, char separator = DEFAULT_SEPARATOR) {
+	if constexpr(std::is_rvalue_reference_v<CR&&>) {
+		return details::TempWriter([c = std::move(c), separator](OutputStream& os) {
+			os.join(c, std::make_index_sequence<N>{}, separator);
+		});
+	} else {
+		return details::TempWriter([&c, separator](OutputStream& os) {
+			os.join(c, std::make_index_sequence<N>{}, separator);
+		});
+	}
+}
+
+template<typename T, std::size_t N,
+         typename = std::enable_if_t<std::is_same_v<std::remove_cv_t<T>, char>>>
+constexpr auto join(T (&c)[N], char separator = DEFAULT_SEPARATOR) {
+	static_assert(N > 0, "c-strings should be null terminated!");
+	return join(std::begin(c), std::prev(std::end(c)), separator);
+}
+
+template<typename T, std::size_t N,
+         typename = std::enable_if_t<std::is_same_v<std::remove_cv_t<T>, char>>>
+constexpr auto join(T (&&c)[N], char separator = DEFAULT_SEPARATOR) {
+	static_assert(N > 0, "c-strings should be null terminated!");
+	return details::TempWriter([c, separator](OutputStream& os) {
+		os.join(std::begin(c), std::prev(std::end(c)), separator);
+	});
+}
+
+template<typename T,
+         typename = std::enable_if_t<!std::is_array<T>{}>,
+         typename = std::enable_if_t<!details::IsContainer<T>{}>,
+         typename = std::enable_if_t<!details::IsTupleLike<T>{}>>
+constexpr auto join(const T& t, char separator = DEFAULT_SEPARATOR) = delete;
+
+auto join(details::JoinListCapture c, char separator = DEFAULT_SEPARATOR) {
+	return details::TempWriter([c = std::move(c), separator](OutputStream& os) {
+		c.callable(os, separator);
+	});
+}
+
+
+//============================================================================//
+// Basic datastructures                                                       //
+//============================================================================//
+// make usage of std::priority_queue easier...
+namespace details {
+	template<typename T, typename Compare = std::less<T>>
+	struct invertCompare {
+		constexpr bool operator()(const T &lhs, const T &rhs) const {
+			return Compare{}(rhs, lhs);
+		}
+	};
+}
+template<typename T, typename Compare = std::less<T>>
+using MinPQ = std::priority_queue<T, std::vector<T>, details::invertCompare<T, Compare>>;
+template<typename T, typename Compare = std::less<T>>
+using MaxPQ = std::priority_queue<T, std::vector<T>, Compare>;
+
+template<typename C, typename K>
+bool contains(const C& container, const K& key) {
+	return container.find(key) != container.end();
+}
+
+template<typename C1, typename C2>
+void append(C1& c1, const C2& c2) {
+	static_assert(std::is_same_v<typename details::IsContainer<C1>::value_type,
+	                             typename details::IsContainer<C2>::value_type>, "cannot append container of different value type!");
+	if (static_cast<const void*>(&c1) != static_cast<const void*>(&c2)) {
+		for (auto&& e : c2) c1.emplace(c1.end(), e);
+	} else {
+		C2 tmp = c2;
+		for (auto&& e : tmp) c1.emplace(c1.end(), e);
+	}
+}
+
+template<typename C1, std::size_t N>
+void append(C1& c1, const typename C1::value_type(&c2)[N]) {
+	for (auto&& e : c2) c1.emplace(c1.end(), e);
+}
+
+struct shorter {
+	template<typename U, typename V>
+	bool operator()(const U& a, const V& b) const {
+		return std::size(a) < std::size(b);
+	}
+};
+
+struct longer {
+	template<typename U, typename V>
+	bool operator()(const U& a, const V& b) const {
+		return std::size(b) < std::size(a);
+	}
+};
+
+namespace details {
+	template<typename T, typename = void>
+	struct Flatten {using value_type = T;};
+
+	template<typename T>
+	struct Flatten<T, std::enable_if_t<IsContainer<T>{}>> : Flatten<typename IsContainer<T>::value_type> {};
+
+	template<typename CR, typename V>
+	void flatAppend(CR&& c, std::vector<V>& res) {
+		using C = std::remove_reference_t<CR>;
+		if constexpr(std::is_same_v<C, V>) {
+			res.emplace_back(std::forward<CR>(c));
+		} else if constexpr (!IsContainer<C>{}) {
+			static_assert(IsContainer<C>{}, "invalid base type for flatten()!");
+		} else {
+			if constexpr (std::is_rvalue_reference_v<CR&&>) {
+				for (auto&& v : c) flatAppend(std::move(v), res);
+			} else {
+				for (auto&& v : c) flatAppend(v, res);
+			}
+		}
+	}
+}
+
+template<typename R, typename CR>
+auto flatten(CR&& c) {
+	std::vector<R> res;
+	details::flatAppend(std::forward<CR>(c), res);
+	return res;
+}
+
+template<typename CR>
+auto flatten(CR&& c) {
+	using C = std::remove_reference_t<CR>;
+	return flatten<typename details::Flatten<C>::value_type, CR>(std::forward<CR>(c));
+}
+
+template<typename T>
+struct boolean {
+	bool value;
+	std::optional<T> reason;
+
+	constexpr boolean(bool value_) : value(value_) {}
+	constexpr boolean(bool value_, const T& reason_) : value(value_), reason(reason_) {}
+
+	constexpr operator bool() const {
+		return value;
+	}
+
+	constexpr bool hasReason() const {
+		return reason.has_value();
+	}
+};
+
+
+//============================================================================//
+// Utility                                                                    //
+//============================================================================//
+// for sequences
+template<typename RandomIt,
+         typename = std::enable_if_t<std::is_integral_v<typename std::iterator_traits<RandomIt>::value_type>>>
+auto isPerm(RandomIt first, RandomIt last, typename std::iterator_traits<RandomIt>::value_type offset = 0) {
+	using T = typename std::iterator_traits<RandomIt>::value_type;
+	auto count = std::distance(first, last);
+	std::vector<bool> seen(count, false);
+	for (; first != last; first++) {
+		const T& x = *first;
+		if (x < offset or x - offset >= count or seen[x - offset]) {
+			return boolean<T>(false, x);
+		}
+		seen[x - offset] = true;
+	}
+	return boolean<T>(true);
+}
+template<typename C, typename std::enable_if_t<std::is_integral_v<typename details::IsContainer<C>::value_type>, bool> = true>
+auto isPerm(const C& c, typename details::IsContainer<C>::value_type offset = 0) {
+	return isPerm(std::begin(c), std::end(c), offset);
+}
+
+template<typename itA, typename itB>
+auto isPerm(itA firstA, itA lastA, itB firstB, itB lastB) {
+	using T = typename std::iterator_traits<itA>::value_type;
+	std::vector<typename std::iterator_traits<itA>::value_type> a(firstA, lastA);
+	std::vector<typename std::iterator_traits<itB>::value_type> b(firstB, lastB);
+	if (a.size() != b.size()) return boolean<T>(false);
+	std::sort(a.begin(), a.end());
+	std::sort(b.begin(), b.end());
+	for (std::size_t i = 0; i < a.size(); i++) {
+		if (a[i] != b[i]) return boolean<T>(false, a[i]);
+	}
+	return boolean<T>(true);
+}
+template<typename C1,
+         typename C2,
+         typename = std::enable_if_t<details::IsContainer<C1>{}>,
+         typename = std::enable_if_t<details::IsContainer<C2>{}>>
+auto isPerm(const C1& c1, const C2& c2) {
+	return isPerm(std::begin(c1), std::end(c1), std::begin(c2), std::end(c2));
+}
+
+template<typename RandomIt, typename BinaryPredicate>
+constexpr boolean<Integer> anyAdjacent(RandomIt first, RandomIt last, BinaryPredicate p) {
+	if (first != last) {
+		for (Integer i = 1; std::next(first) != last; first++, i++) {
+			if (p(*first, *std::next(first))) {
+				return boolean<Integer>(true, i);
+			}
+		}
+	}
+	return boolean<Integer>(false);
+}
+template<typename C, typename BinaryPredicate>
+constexpr boolean<Integer> anyAdjacent(const C& c, BinaryPredicate p) {
+	return anyAdjacent(std::begin(c), std::end(c), p);
+}
+
+template<typename RandomIt, typename BinaryPredicate>
+constexpr boolean<Integer> noneAdjacent(RandomIt first, RandomIt last, BinaryPredicate p) {
+	auto res = anyAdjacent(first, last, p);
+	res.value = !res.value;
+	return res;
+}
+template<typename C, typename BinaryPredicate>
+constexpr boolean<Integer> noneAdjacent(const C& c, BinaryPredicate p) {
+	return noneAdjacent(std::begin(c), std::end(c), p);
+}
+
+template<typename RandomIt, typename BinaryPredicate>
+constexpr boolean<Integer> allAdjacent(RandomIt first, RandomIt last, BinaryPredicate p) {
+	return noneAdjacent(first, last, std::not_fn(p));
+}
+template<typename C, typename BinaryPredicate>
+constexpr boolean<Integer> allAdjacent(const C& c, BinaryPredicate p) {
+	return noneAdjacent(std::begin(c), std::end(c), p);
+}
+
+template<typename RandomIt>
+constexpr boolean<Integer> areIncreasing(RandomIt first, RandomIt last) {
+	using T = typename std::iterator_traits<RandomIt>::value_type;
+	return allAdjacent(first, last, std::less<T>());
+}
+template<typename C>
+constexpr boolean<Integer> areIncreasing(const C& c) {
+	return areIncreasing(std::begin(c), std::end(c));
+}
+
+template<typename RandomIt>
+constexpr boolean<Integer> areNonDecreasing(RandomIt first, RandomIt last) {
+	using T = typename std::iterator_traits<RandomIt>::value_type;
+	return allAdjacent(first, last, std::less_equal<T>());
+}
+template<typename C>
+constexpr boolean<Integer> areNonDecreasing(const C& c) {
+	return areNonDecreasing(std::begin(c), std::end(c));
+}
+
+template<typename RandomIt>
+constexpr boolean<Integer> areDecreasing(RandomIt first, RandomIt last) {
+	using T = typename std::iterator_traits<RandomIt>::value_type;
+	return allAdjacent(first, last, std::greater<T>());
+}
+template<typename C>
+constexpr boolean<Integer> areDecreasing(const C& c) {
+	return areDecreasing(std::begin(c), std::end(c));
+}
+
+template<typename RandomIt>
+constexpr boolean<Integer> areNonIncreasing(RandomIt first, RandomIt last) {
+	using T = typename std::iterator_traits<RandomIt>::value_type;
+	return allAdjacent(first, last, std::greater_equal<T>());
+}
+template<typename C>
+constexpr boolean<Integer> areNonIncreasing(const C& c) {
+	return areNonIncreasing(std::begin(c), std::end(c));
+}
+
+template<typename RandomIt>
+constexpr auto areDistinct(RandomIt first, RandomIt last) {
+	using T = typename std::iterator_traits<RandomIt>::value_type;
+	std::vector<T> tmp(first, last);
+	std::sort(tmp.begin(), tmp.end());
+	auto [b, v] = anyAdjacent(tmp, std::equal_to<T>());
+	if (v) return boolean<T>(!b, tmp[*v]);
+	return boolean<T>(!b);
+}
+template<typename C>
+constexpr auto areDistinct(const C& c) {
+	return areDistinct(std::begin(c), std::end(c));
+}
+
+
+// for strings (cctype functions are not safe to use with char...)
+constexpr bool isLower(char c) {
+	return c >= 'a' and c <= 'z';
+}
+
+constexpr bool isUpper(char c) {
+	return c >= 'A' and c <= 'Z';
+}
+
+constexpr bool isLetter(char c) {
+	return isLower(c) or isUpper(c);
+}
+
+constexpr bool isDigit(char c) {
+	return c >= '0' and c <= '9';
+}
+
+constexpr char toLower(char c) {
+	if (isUpper(c)) c += 'a' - 'A';
+	return c;
+}
+
+constexpr bool isVowel(char c) {
+	c = toLower(c);
+	for (char x : LOWER_VOWELS) {
+		if (c == x) return true;
+	}
+	return false;
+}
+
+constexpr bool isConsonant(char c) {
+	return isLetter(c) and !isVowel(c);
+}
+
+constexpr char toUpper(char c) {
+	if (isLower(c)) c -= 'a' - 'A';
+	return c;
+}
+
+constexpr char toDefaultCase(char c) {
+	if constexpr (DEFAULT_CASE_LOWER) return toLower(c);
+	return toUpper(c);
+}
+
+void toLower(std::string& s) {
+	for (char& c : s) c = toLower(c);
+}
+
+void toUpper(std::string& s) {
+	for (char& c : s) c = toUpper(c);
+}
+
+void toDefaultCase(std::string& s) {
+	if constexpr (DEFAULT_CASE_LOWER) return toLower(s);
+	return toUpper(s);
+}
+
+constexpr bool isLower(std::string_view s) {
+	for (char c : s) if (!isLower(c)) return false;
+	return true;
+}
+
+constexpr boolean<char> isUpper(std::string_view s) {
+	for (char c : s) if (!isUpper(c)) return boolean<char>(false, c);
+	return boolean<char>(true);
+}
+
+constexpr boolean<char> isLetter(std::string_view s) {
+	for (char c : s) if (!isLetter(c)) return boolean<char>(false, c);
+	return boolean<char>(true);
+}
+
+constexpr boolean<char> isDigit(std::string_view s) {
+	for (char c : s) if (!isDigit(c)) return boolean<char>(false, c);
+	return boolean<char>(true);
+}
+
+constexpr boolean<char> isVowel(std::string_view s) {
+	for (char c : s) if (!isVowel(c)) return boolean<char>(false, c);
+	return boolean<char>(true);
+}
+
+constexpr boolean<char> isConsonant(std::string_view s) {
+	for (char c : s) if (!isConsonant(c)) return boolean<char>(false, c);
+	return boolean<char>(true);
+}
+
+std::vector<Integer> thueMorse(Integer lower, Integer upper) {
+	judgeAssert<std::invalid_argument>(lower < upper, "thueMorse(): Lower must be less than upper!");
+	std::vector<Integer> res(upper - lower);
+	for (Integer i = lower; i < upper; i++) {
+		res[i] = std::bitset<64>(i).count() % 2;
+	}
+	return res;
+}
+
+std::vector<Integer> thueMorse(Integer upper) {
+	return thueMorse(0, upper);
+}
+
+// allow using std::pair and std::complex similiar
+// (may be useful for geometric problem)
+template<typename T>
+constexpr auto& getX(T& point) {
+	return std::get<0>(point);
+}
+template<typename T>
+constexpr auto& getY(T& point) {
+	return std::get<1>(point);
+}
+template<typename T>
+constexpr auto& getZ(T& point) {
+	return std::get<2>(point);
+}
+template<typename T>
+constexpr auto getX(const T& point) {
+	return std::get<0>(point);
+}
+template<typename T>
+constexpr auto getY(const T& point) {
+	return std::get<1>(point);
+}
+template<typename T>
+constexpr auto getZ(const T& point) {
+	return std::get<2>(point);
+}
+
+template<typename T>
+constexpr auto& getX(std::complex<T>& point) {
+	return reinterpret_cast<T(&)[2]>(point)[0];
+}
+template<typename T>
+constexpr auto& getY(std::complex<T>& point) {
+	return reinterpret_cast<T(&)[2]>(point)[1];
+}
+template<typename T>
+constexpr auto getX(const std::complex<T>& point) {
+	return reinterpret_cast<const T(&)[2]>(point)[0];
+}
+template<typename T>
+constexpr auto getY(const std::complex<T>& point) {
+	return reinterpret_cast<const T(&)[2]>(point)[1];
+}
+
+template<typename T>
+constexpr std::pair<T,T> convert(const std::complex<T>& t) {
+	return {getX(t), getY(t)};
+}
+
+template<typename L, typename R>
+constexpr std::complex<typename std::common_type<L, R>::type>
+convert(const std::pair<L,R>& t) {
+	return {getX(t), getY(t)};
+}
+
+
+namespace details {
+	// Test two numbers for equality, accounting for +/-INF, NaN and precision.
+	// Real expected is considered the reference value for relative error.
+	bool floatEqual(Real given, Real expected, Real floatAbsTol, Real floatRelTol) {
+		judgeAssert<std::domain_error>(floatAbsTol >= 0.0_real, "floatEqual(): floatAbsTol must be positive!");
+		judgeAssert<std::domain_error>(floatRelTol >= 0.0_real, "floatEqual(): floatRelTol must be positive!");
+		// Finite values are compared with some tolerance
+		if (std::isfinite(given) and std::isfinite(expected)) {
+			Real absDiff = std::abs(given-expected);
+			Real relDiff = std::abs((given-expected)/expected);
+			return absDiff <= floatAbsTol or relDiff <= floatRelTol;
+		}
+		// NaN is equal to NaN (-NaN is also equal NaN)
+		if (std::isnan(given) and std::isnan(expected)) {
+			return true;
+		}
+		// Infinite values are equal if their sign matches
+		if (std::isinf(given) and std::isinf(expected)) {
+			return std::signbit(given) == std::signbit(expected);
+		}
+		// Values in different classes are always different.
+		return false;
+	}
+
+	constexpr boolean<std::size_t> stringEqual(std::string_view a, std::string_view b, bool caseSensitive) {
+		std::size_t i = 0;
+		for (; i < a.size() and i < b.size(); i++) {
+			char aa = a[i];
+			char bb = b[i];
+			if (!caseSensitive) {
+				aa = toDefaultCase(aa);
+				bb = toDefaultCase(bb);
+			}
+			if (aa != bb) {
+				return boolean<std::size_t>(false, i);
+			}
+		}
+		if (a.size() != b.size()) {
+			return boolean<std::size_t>(false, i);
+		} else {
+			return boolean<std::size_t>(true);
+		}
+	}
+
+	constexpr bool isToken(std::string_view a) {
+		for (char c : a) {
+			if (c == ' ') return false;
+			if (c == '\n') return false;
+			if (c == '\r') return false;
+			if (c == '\t') return false;
+			if (c == '\f') return false;
+			if (c == '\v') return false;
+		}
+		return true;
+	}
+
+	template<typename T>
+	bool parse(std::string_view s, T& res) {
+		const char* begin = s.data();
+		const char* end = s.data() + s.size();
+		auto [ptr, ec] = std::from_chars(begin, end, res);
+		return ptr == end and ec == std::errc();
+	}
+	#ifdef DOUBLE_FALLBACK
+	template<>
+	bool parse(std::string_view s, Real& res) {
+		try {
+			std::size_t pos = 0;
+			res = std::stold(std::string(s), &pos);
+			return pos == s.size();
+		} catch(...) {
+			return false;
+		}
+	}
+	#endif
+
+}
+
+
+//============================================================================//
+// Math                                                                       //
+//============================================================================//
+namespace details {
+	constexpr std::array<Integer, 32> TRIAL_PRIMES = {
+		 2,  3,  5,  7, 11, 13, 17, 19, 23,  29,  31,  37,  41,  43,  47,  53,
+		59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131,
+	};
+	constexpr std::array<UInteger, 7> MILLER_RABIN_WITNESS = {2, 325, 9375, 28178, 450775, 9780504, 1795265022};
+
+	// these operations are safe as long as the value would fit in Integer
+	constexpr UInteger mulMod(UInteger lhs, UInteger rhs, UInteger mod) {
+		UInteger res = 0;
+		while (rhs > 0) {
+			if (rhs & 1) res = (lhs + res) % mod;
+			lhs = (lhs + lhs) % mod;
+			rhs /= 2;
+		}
+		return res;
+	}
+
+	constexpr UInteger powMod(UInteger base, UInteger exp, UInteger mod) {
+		UInteger res = 1;
+		if (mod <= 0x1'0000'0000) {
+			while (exp > 0) {
+				if (exp & 1) res = (base * res) % mod;
+				base = (base * base) % mod;
+				exp /= 2;
+			}
+		} else {
+			while (exp > 0) {
+				if (exp & 1) res = mulMod(base, res, mod);
+				base = mulMod(base, base, mod);
+				exp /= 2;
+			}
+		}
+		return res;
+	}
+
+	constexpr Integer extendedEuclid(Integer a, Integer b, Integer& x, Integer& y) {
+		if (a == 0) {
+			x = 0;
+			y = 1;
+			return b;
+		} else {
+			Integer x1 = 0;
+			Integer y1 = 0;
+			Integer d = extendedEuclid(b % a, a, x1, y1);
+			x = y1 - (b / a) * x1;
+			y = x1;
+			return d;
+		}
+	}
+}
+
+constexpr Integer applyMod(Integer x, Integer mod) {
+	x %= mod;
+	if (x < 0) x += mod;
+	return x;
+}
+
+constexpr Integer mulMod(Integer lhs, Integer rhs, Integer mod) {
+	judgeAssert<std::domain_error>(mod > 0, "mulMod(): mod must be positive!");
+	UInteger ul = static_cast<UInteger>(applyMod(lhs, mod));
+	UInteger ur = static_cast<UInteger>(applyMod(rhs, mod));
+	UInteger um = static_cast<UInteger>(mod);
+	return static_cast<Integer>(details::mulMod(ul, ur, um));
+}
+
+constexpr Integer powMod(Integer base, Integer exp, Integer mod) {
+	judgeAssert<std::domain_error>(mod > 0, "powMod(): mod must be positive!");
+	judgeAssert<std::domain_error>(exp >= 0, "powMod(): exp must be non negative!");
+	UInteger ub = static_cast<UInteger>(applyMod(base, mod));
+	UInteger ue = static_cast<UInteger>(exp);
+	UInteger um = static_cast<UInteger>(mod);
+	return static_cast<Integer>(details::powMod(ub, ue, um));
+}
+
+constexpr Integer multInv(Integer n, Integer mod) {
+	judgeAssert<std::domain_error>(mod > 0, "multInv(): mod must be positive!");
+	Integer x = 0;
+	Integer y = 0;
+	Integer g = details::extendedEuclid(n, mod, x, y);
+	if (g != 1) return -1;
+	else return applyMod(x, mod);
+}
+
+constexpr bool isPrime(Integer n) {
+	for (Integer p : details::TRIAL_PRIMES) {
+		if (n <= p or n % p == 0) {
+			return n == p;
+		}
+	}
+	if (details::powMod(details::TRIAL_PRIMES.back() + 1, n - 1, n) != 1) {
+		return false;
+	}
+	UInteger un = static_cast<UInteger>(n);
+	UInteger d = un - 1;
+	UInteger j = 0;
+	while (d % 2 == 0) {
+		d /= 2;
+		j++;
+	}
+	for (UInteger a : details::MILLER_RABIN_WITNESS) {
+		if (a % un == 0) continue;
+		UInteger v = details::powMod(a, d, un);
+		if (v == 1 or v == un - 1) continue;
+		for (UInteger i = 1; i < j; i++) {
+			v = details::mulMod(v, v, un);
+			if (v == un - 1 or v <= 1) break;
+		}
+		if (v != un - 1) return false;
+	}
+	return true;
+}
+
+std::vector<Integer> primes(Integer lower, Integer upper) {
+	judgeAssert<std::invalid_argument>(lower < upper, "primes(): Lower must be less than upper!");
+	lower = std::max<Integer>(2, lower);
+	upper = std::max<Integer>(2, upper);
+	Integer count = upper - lower;
+	Integer cache = (count + 1) / 2;
+
+	std::vector<bool> notPrime(cache), notPrimeSegment(cache);
+	for (Integer i = 3; i < count; i += 2) {
+		if (!notPrime[i / 2]) {
+			for (Integer j = i * i; j < count; j += 2 * i) {
+				notPrime[j / 2] = true;
+			}
+			Integer lowest = lower - (lower % (2*i)) + i;
+			if (lowest < lower) lowest += 2*i;
+			for (Integer j = std::max(i * i, lowest); j < upper; j += 2 * i) {
+				notPrimeSegment[(j - lower) / 2] = true;
+			}
+		}
+	}
+	std::vector<Integer> res;
+	if (lower <= 2 and 2 < upper) res.emplace_back(2);
+	for (Integer i = lower | 1; i < upper; i += 2) {
+		if (!notPrimeSegment[(i - lower) / 2] and (i < count*count or isPrime(i))) {
+			res.emplace_back(i);
+		}
+	}
+	return res;
+}
+
+std::vector<Integer> primes(Integer upper) {
+	return primes(0, upper);
+}
+
+template<typename T>
+constexpr Integer sign(T x) {
+	return (T(0) < x) - (x < T(0));
+}
+
+
+//============================================================================//
+// Geometry (this is just for utility stuff...)                               //
+//============================================================================//
+namespace details {
+	template<typename Point>
+	constexpr Integer cross(Point a, Point b) {
+		return getX(a) * getY(b) - getY(a) * getX(b);
+	}
+	template<typename Point>
+	constexpr Integer cross(Point p, Point a, Point b) {
+		getX(a) -= getX(p);
+		getY(a) -= getY(p);
+		getX(b) -= getX(p);
+		getY(b) -= getY(p);
+		return cross(a, b);
+	}
+
+	template<typename Point>
+	constexpr bool left(Point p) {
+		return getX(p) == 0 ? getY(p) < 0 : getX(p) < 0;
+	}
+
+	template<typename Point>
+	void cyclicSort(std::vector<Point>& in) {
+		std::sort(in.begin(), in.end(), [](const Point& a, const Point& b){
+			return left(a) != left(b) ? left(a) > left(b) : cross(a, b) > 0;
+		});
+	}
+}
+
+
+template<typename RandomIt>
+constexpr bool areConvex(RandomIt first, RandomIt last) {
+	std::size_t n = 0;
+	for (auto it = first; it != last; it++) {
+		n++;
+		judgeAssert(std::abs(getX(*it)) <= 0x3FFF'FFFF, "areConvex(): coordinates too large!");
+		judgeAssert(std::abs(getY(*it)) <= 0x3FFF'FFFF, "areConvex(): coordinates too large!");
+	}
+	if (n < 3) return false;
+	bool hasArea = false;
+	for (std::size_t i = 0; i < n; i++) {
+		if (first[i] == first[(i+1) % n]) return false;
+		if (details::cross(first[0], first[i], first[(i+1) % n]) < 0) return false;
+		if (details::cross(first[i], first[(i+1) % n], first[(i+2) % n]) < 0) return false;
+		hasArea |= details::cross(first[i], first[(i+1) % n], first[(i+2) % n]) != 0;
+	}
+	return hasArea;
+}
+template<typename C>
+constexpr bool areConvex(const C& c) {
+	return areConvex(std::begin(c), std::end(c));
+}
+
+template<typename RandomIt>
+constexpr bool areStrictlyConvex(RandomIt first, RandomIt last) {
+	if (!areConvex(first, last)) return false;
+	std::size_t n = std::distance(first, last);
+	for (std::size_t i = 0; i < n; i++) {
+		if (details::cross(first[i], first[(i+1) % n], first[(i+2) % n]) == 0) return false;
+	}
+	return true;
+}
+template<typename C>
+constexpr bool areStrictlyConvex(const C& c) {
+	return areStrictlyConvex(std::begin(c), std::end(c));
+}
+
+//============================================================================//
+// Random                                                                     //
+//============================================================================//
+namespace Random {
+	// You should not rely on the implementation in details!
+	// Especially you should never use randomNumberGenerator on your own. There is no function in
+	// c++ which uses a random engine and is not implementation defined.
+	namespace details {
+		constexpr Real PI = 3.141592653589793238462643383279502884_real;
+		constexpr Integer PRIME_TRIALS = 4*1600;
+
+		RandomEngine randomNumberGenerator(DEFAULT_SEED);
+		static_assert(RandomEngine::max() == 0xFFFF'FFFF'FFFF'FFFF_uint, "Random Engine should produce 64bit of randomness");
+		static_assert(RandomEngine::min() == 0_uint, "Random Engine should produce 64bit of randomness");
+
+		constexpr UInteger bitMask(UInteger x) {
+			static_assert(sizeof(UInteger) == 8, "bitMask requires 8byte UInteger!");
+			x |= x >> 1;
+			x |= x >> 2;
+			x |= x >> 4;
+			x |= x >> 8;
+			x |= x >> 16;
+			x |= x >> 32;
+			return x;
+		}
+	}
+
+	void seed(UInteger seed) {
+		details::randomNumberGenerator.seed(seed);
+	}
+
+	//========================================================================//
+	// Distributions and generators                                           //
+	//========================================================================//
+	bool bit() {// in {0, 1}
+		return std::bitset<64>(details::randomNumberGenerator()).count() & 1;
+	}
+
+	Integer integer() {// in [-2^63, 2^63)
+		return static_cast<Integer>(details::randomNumberGenerator());
+	}
+	Integer integer(Integer lower, Integer upper) {// in [lower, upper)
+		judgeAssert<std::invalid_argument>(lower < upper, "Random::integer(): Lower must be less than upper!");
+		UInteger ul = static_cast<UInteger>(lower);
+		UInteger uu = static_cast<UInteger>(upper);
+		UInteger mask = details::bitMask(uu - ul - 1_uint);
+		UInteger res;
+		do {
+			res = details::randomNumberGenerator() & mask;
+		} while (res >= uu - ul);
+		return static_cast<Integer>(res + ul);
+	}
+	Integer integer(Integer upper) {// in [0, upper)
+		return integer(0, upper);
+	}
+
+	Real real() {// in [0, 1)
+		while (true) {
+			Real res = details::randomNumberGenerator() / 0x1.0p64_real;
+			res += details::randomNumberGenerator() / 0x1.0p128_real;
+			if (0.0_real <= res and res < 1.0_real) return res;
+		}
+	}
+	Real real(Real upper) {// in [0, upper)
+		judgeAssert<std::domain_error>(std::isfinite(upper), "Random::real(): Upper must be finite!");
+		judgeAssert<std::invalid_argument>(upper > 0.0_real, "Random::real(): Upper must be greater than zero!");
+		while (true) {
+			Real res = real() * upper;
+			if (0.0_real <= res and res < upper) return res;
+		}
+	}
+	Real real(Real lower, Real upper) {// in [lower, upper)
+		judgeAssert<std::domain_error>(std::isfinite(lower), "Random::real(): Lower must be finite!");
+		judgeAssert<std::domain_error>(std::isfinite(upper), "Random::real(): Upper must be finite!");
+		judgeAssert<std::invalid_argument>(lower < upper, "Random::real(): Lower must be less than upper!");
+		while (true) {
+			Real x = real();
+			Real res = lower * (1.0_real - x) + upper * x;
+			if (lower <= res and res < upper) return res;
+		}
+	}
+
+	Real normal(Real mean, Real stddev) {// theoretically in (-inf, inf)
+		judgeAssert<std::domain_error>(stddev >= 0.0_real, "Random::normal(): Standard deviation must be non negative!");
+		Real u1 = real();
+		Real u2 = real();
+		Real res = std::sqrt(-2.0_real * std::log(u1)) * std::cos(2.0_real * details::PI * u2);
+		return std::sqrt(stddev) * res + mean;
+	}
+	Real normal(Real lower, Real upper, Real mean, Real stddev) {// in [lower, upper)
+		judgeAssert<std::domain_error>(!std::isnan(lower), "Random::normal(): Lower must not be NaN!");
+		judgeAssert<std::domain_error>(!std::isnan(upper), "Random::normal(): Upper must not be NaN!");
+		judgeAssert<std::invalid_argument>(lower < upper, "Random::normal(): Lower must be less than upper!");
+		judgeAssert<std::domain_error>(stddev >= 0.0_real, "Random::normal(): Standard deviation must be non negative!");
+		Real res;
+		while (true) {
+			Real u1 = real();
+			Real u2 = real();
+			// Box-Muller-Methode
+			// https://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform
+			res = std::sqrt(-2.0_real * std::log(u1)) * std::cos(2.0_real * details::PI * u2);
+			res = std::sqrt(stddev) * res + mean;
+			if (lower <= res and res < upper) return res;
+			res = std::sqrt(-2.0_real * std::log(u1)) * std::sin(2.0_real * details::PI * u2);
+			res = std::sqrt(stddev) * res + mean;
+			if (lower <= res and res < upper) return res;
+		}
+	}
+
+	Real exponential(Real lambda) {// theoretically in [0, inf)
+		judgeAssert<std::domain_error>(lambda > 0.0_real, "Random::lambda(): lambda must be positive!");
+		return -std::log(real()) / lambda;
+	}
+	Real exponential(Real lower, Real upper, Real lambda) {// in [lower, upper)
+		judgeAssert<std::domain_error>(std::isfinite(lower), "Random::exponential(): Lower must be finite!");
+		judgeAssert<std::domain_error>(!std::isnan(upper), "Random::exponential(): Upper must not be NaN!");
+		judgeAssert<std::invalid_argument>(lower < upper, "Random::exponential(): Lower must be less than upper!");
+		judgeAssert<std::domain_error>(lambda > 0.0_real, "Random::exponential(): Lambda must be positive!");
+		while (true) {
+			Real res = lower - std::log(real()) / lambda;
+			if (res < upper) return res;
+		}
+	}
+
+	Integer geometric(Real p) {// theoretically in [0, inf)
+		judgeAssert<std::domain_error>(0.0_real <= p and p < 1.0_real, "Random::geometric(): p must be in [0,1)!");
+		return std::llround(std::floor(std::log(real()) / std::log1p(-p)));
+	}
+	Integer geometric(Integer lower, Integer upper, Real p) {// in [lower, upper)
+		judgeAssert<std::invalid_argument>(lower < upper, "Random::geometric(): Lower must be less than upper!");
+		judgeAssert<std::domain_error>(0.0_real <= p and p < 1.0_real, "Random::geometric(): p must be in [0,1)!");
+		while (true) {
+			// https://en.wikipedia.org/wiki/Geometric_distribution
+			// "The exponential distribution is the continuous analogue of the geometric distribution[...]"
+			Integer res = lower + std::llround(std::floor(std::log(real()) / std::log1p(-p)));
+			if (res < upper) return res;
+		}
+	}
+
+	Integer binomial(Integer n, Real p) {// in [0, n]
+		judgeAssert<std::domain_error>(n >= 0, "Random::binomial(): n must be non negative!");
+		judgeAssert<std::domain_error>(0.0_real <= p and p <= 1.0_real, "Random::binomial(): p must be in [0,1)!");
+		bool swap = p > 0.5_real;
+		p = std::min(p, 1.0_real - p);
+		if (p*n < 10.0_real) {
+			// BG: Geometric method
+			// https://dl.acm.org/doi/pdf/10.1145/42372.42381
+			Integer res = 0;
+			Integer y = 0;
+			Real lg = std::log1p(-p);
+			if (lg >= 0) return swap ? n : 0;
+			do {
+				y += std::llround(std::floor(std::log(real()) / lg)) + 1;
+				if (y > n) return swap ? n - res : res;
+				res++;
+			} while (true);
+		} else {
+			// BTRS algorithm
+			// https://epub.wu.ac.at/1242/1/document.pdf
+			// note that the original paper has an error
+			// the break condition at the end has to be log(v) < h[...]
+			Real q = 1.0_real - p;
+			Real spq = std::sqrt(n * p * q);
+			Real b = 1.15_real + 2.53_real * spq;
+			Real a = -0.0873_real + 0.0248_real * b + 0.01_real * p;
+			Real c = n * p + 0.5_real;
+			Real vr = 0.92_real - 4.2_real / b;
+
+			bool initialized = false;
+			Real alpha, lpq, m, h;
+			do {
+				Real u = real() - 0.5_real;
+				Real us = 0.5_real - std::abs(u);
+				Integer res = std::llround(std::floor((2.0_real * a / us + b) * u + c));
+				if (res < 0 or res > n) continue;
+
+				Real v = real();
+				if (us >= 0.07_real and v <= vr) {
+					return swap ? n - res : res;
+				}
+
+				if (!initialized) {
+					alpha = (2.83_real + 5.1_real / b) * spq;
+					lpq = std::log(p / q);
+					m = std::llround(std::floor((n + 1) * p));
+					h = std::lgamma(m + 1) + std::lgamma(n - m + 1);
+					initialized = true;
+				}
+				v *= alpha / (a / (us * us) + b);
+				if (std::log(v) <= h - std::lgamma(res + 1) - std::lgamma(n - res + 1) + (res - m) * lpq) {
+					return swap ? n - res : res;
+				}
+			} while (true);
+		}
+	}
+	Integer binomial(Integer lower, Integer upper, Integer n, Real p) {// in [lower, upper)
+		judgeAssert<std::invalid_argument>(lower < upper, "Random::binomial(): n Lower must be less than upper!");
+		while (true) {
+			Integer res = binomial(n, p);
+			if (lower <= res and res < upper) return res;
+		}
+	}
+
+	Integer maximum(Integer lower, Integer upper, Integer n) {// in [lower, upper)
+		judgeAssert<std::invalid_argument>(n > 0, "Random::maximum(): n musst be positive!");
+		judgeAssert<std::invalid_argument>(lower < upper, "Random::maximum(): Lower must be less than upper!");
+		if (n < 5) {
+			Integer res = lower;
+			for (Integer i = 0; i < n; i++) res = std::max(res, integer(lower, upper));
+			return res;
+		} else {// such large n seem unlikely
+			UInteger ul = static_cast<UInteger>(lower);
+			UInteger uu = static_cast<UInteger>(upper);
+			UInteger res = (uu - ul) * std::exp2(std::log2(real()) / n);
+			return std::min(upper - 1, static_cast<Integer>(res + ul));
+		}
+	}
+	Integer maximum(Integer upper, Integer n) {
+		return maximum(0, upper, n);
+	}
+
+	Integer minimum(Integer lower, Integer upper, Integer n) {// in [lower, upper)
+		return upper - 1 - maximum(0, upper - lower, n);
+	}
+	Integer minimum(Integer upper, Integer n) {
+		return minimum(0, upper, n);
+	}
+
+	Integer prime(Integer lower, Integer upper) {// in [lower, upper)
+		judgeAssert<std::invalid_argument>(lower < upper, "Random::prime(): Lower must be less than upper!");
+		Integer sampleL = lower <= 2 ? 0 : (lower / 2);
+		Integer sampleU = upper / 2;
+		if (sampleL < sampleU) {
+			for (Integer i = 0; i < details::PRIME_TRIALS and i < 4 * (upper - lower); i++) {
+				Integer res = std::max<Integer>(2, 2*integer(sampleL, sampleU) | 1);
+				if (isPrime(res)) return res;
+			}
+		}
+		judgeAssert<std::domain_error>(false, "Random::prime(): range contains no primes?");
+		return -1;
+	}
+	Integer prime(Integer upper) {// in [0, upper)
+		return prime(0, upper);
+	}
+
+
+	//========================================================================//
+	// utility                                                                //
+	//========================================================================//
+	template<typename RandomIt>
+	typename std::iterator_traits<RandomIt>::reference
+	select(RandomIt first, RandomIt last) {
+		judgeAssert<std::invalid_argument>(first < last, "Random::select(): Lower must be less than upper!");
+		return first[integer(0, last - first)];
+	}
+
+	template<typename C>
+	typename ::details::IsContainer<C>::value_type select(const C& c) {
+		return select(std::begin(c), std::end(c));
+	}
+
+	template<typename C>
+	typename C::reference select(C& c) {
+		return select(std::begin(c), std::end(c));
+	}
+
+	template<typename T, std::size_t N>
+	T select(const T(&c)[N]) {
+		return select(std::begin(c), std::end(c));
+	}
+
+	template<typename T, std::size_t N>
+	T& select(T(&c)[N]) {
+		return select(std::begin(c), std::end(c));
+	}
+
+	template<typename T>
+	T select(const std::pair<T, T>& t) {
+		return bit() ? getX(t) : getY(t);
+	}
+
+	template<typename T>
+	T select(const std::complex<T>& t) {
+		return bit() ? getX(t) : getY(t);
+	}
+
+	template<typename RandomIt>
+	void shuffle(RandomIt first, RandomIt last) {
+		using std::swap;
+		auto n = last - first;
+		for (auto i = n-1; i > 0; i--) {
+			swap(first[i], first[integer(0, i+1)]);
+		}
+	}
+
+	template<typename C>
+	void shuffle(C& c) {
+		return shuffle(std::begin(c), std::end(c));
+	}
+
+	template<typename T>
+	void shuffle(std::pair<T, T>& t) {
+		using std::swap;
+		if (bit()) swap(getX(t), getY(t));
+	}
+
+	template<typename T>
+	void shuffle(std::complex<T>& t) {
+		using std::swap;
+		if (bit()) swap(getX(t), getY(t));
+	}
+
+	template<typename RandomIt>
+	Integer rotate(RandomIt first, RandomIt last) {
+		Integer rotation = integer(0, last - first);
+		std::rotate(first, first + rotation, last);
+		return rotation;
+	}
+
+	template<typename C>
+	Integer rotate(C& c) {
+		return rotate(std::begin(c), std::end(c));
+	}
+
+	//========================================================================//
+	// sequences                                                              //
+	//========================================================================//
+	std::vector<Integer> distinct(Integer count, Integer lower, Integer upper) {
+		judgeAssert<std::invalid_argument>(count >= 0, "Random::distinct(): Count must be non negative!");
+		judgeAssert<std::invalid_argument>(lower + count <= upper, "Random::distinct(): Lower must be less than upper + count!");
+		std::map<Integer, Integer> used;
+		std::vector<Integer> res;
+		for (Integer i = 0; i < count; i++) {
+			Integer x = integer(lower, upper - i);
+			auto it = used.find(x);
+			if (it != used.end()) res.emplace_back(it->second);
+			else res.emplace_back(x);
+			it = used.find(upper - i - 1);
+			if (it != used.end()) used[x] = it->second;
+			else used[x] = upper - i - 1;
+		}
+		return res;
+	}
+	std::vector<Integer> distinct(Integer count, Integer upper) {
+		return distinct(count, 0, upper);
+	}
+
+	std::vector<Integer> perm(Integer count, Integer offset = 0) {
+		return distinct(count, offset, offset+count);
+	}
+
+	std::vector<Integer> perm(const std::vector<Integer>& cycles, Integer offset = 0) {
+		auto p = perm(std::accumulate(cycles.begin(), cycles.end(), 0_int));
+		std::vector<Integer> res(p.size());
+		Integer tmp = 0;
+		for (std::size_t i = 0; i < cycles.size(); tmp += cycles[i], i++) {
+			judgeAssert<std::invalid_argument>(cycles[i] > 0, "Random::perm(): Cycle lengths must be positive!");
+			for (Integer j = tmp; j + 1 < tmp + cycles[i]; j++) {
+				res[p[j]] = p[j + 1] + offset;
+			}
+			res[p[tmp + cycles[i] - 1]] = p[tmp] + offset;
+		}
+		return res;
+	}
+
+	std::vector<Integer> perm(std::initializer_list<Integer> cycles, Integer offset = 0) {
+		return perm(std::vector<Integer>(cycles), offset);
+	}
+
+	std::vector<Integer> multiple(Integer count, Integer lower, Integer upper) {
+		std::vector<Integer> res(count);
+		for (Integer& x : res) x = integer(lower, upper);
+		return res;
+	}
+	std::vector<Integer> multiple(Integer count, Integer upper) {
+		return multiple(count, 0, upper);
+	}
+
+	std::vector<Integer> increasing(Integer count, Integer lower, Integer upper) {
+		std::vector<Integer> res = distinct(count, lower, upper);
+		std::sort(res.begin(), res.end(), std::less<Integer>());
+		return res;
+	}
+	std::vector<Integer> increasing(Integer count, Integer upper) {
+		return increasing(count, 0, upper);
+	}
+
+	std::vector<Integer> decreasing(Integer count, Integer lower, Integer upper) {
+		std::vector<Integer> res = distinct(count, lower, upper);
+		std::sort(res.begin(), res.end(), std::greater<Integer>());
+		return res;
+	}
+	std::vector<Integer> decreasing(Integer count, Integer upper) {
+		return decreasing(count, 0, upper);
+	}
+
+	std::vector<Integer> nonDecreasing(Integer count, Integer lower, Integer upper) {
+		std::vector<Integer> res = multiple(count, lower, upper);
+		std::sort(res.begin(), res.end(), std::less<Integer>());
+		return res;
+	}
+	std::vector<Integer> nonDecreasing(Integer count, Integer upper) {
+		return nonDecreasing(count, 0, upper);
+	}
+
+	std::vector<Integer> nonIncreasing(Integer count, Integer lower, Integer upper) {
+		std::vector<Integer> res = multiple(count, lower, upper);
+		std::sort(res.begin(), res.end(), std::greater<Integer>());
+		return res;
+	}
+	std::vector<Integer> nonIncreasing(Integer count, Integer upper) {
+		return nonIncreasing(count, 0, upper);
+	}
+
+	std::vector<Integer> partition(Integer n, Integer k, Integer min = 1) {
+		judgeAssert<std::invalid_argument>(n > 0, "Random::partition(): n must be positive!");
+		judgeAssert<std::invalid_argument>(k > 0, "Random::partition(): k must be positive!");
+		judgeAssert<std::invalid_argument>(min <= 0 or k <= n / min, "Random::partition(): k too large!");
+		n -= (min - 1) * k;
+		std::vector<Integer> res = increasing(k-1, 1, n);
+		res.emplace_back(n);
+		for (Integer i = 0, last = 0; i < k; i++) {
+			res[i] -= last;
+			last += res[i];
+			res[i] += min - 1;
+		}
+		return res;
+	}
+
+	std::string bracketSequence(Integer n, char open = '(', char close = ')') {//proper bracket sequence of length 2*n
+		judgeAssert<std::invalid_argument>(0 <= n and n <= 0x7FFF'FFFF, "Random::bracketSequence(): n out of range!");
+		std::string res(2 * n, open);
+		for (Integer i = 0, diff = 0; i < 2 * n; i++) {
+			Integer opened = (i + diff) / 2;
+			if (integer((2 * n - i) * (diff + 1)) < (n - opened) * (diff + 2)) {
+				diff++;
+			} else {
+				res[i] = close;
+				diff--;
+			}
+		}
+		return res;
+	}
+
+	//========================================================================//
+	// geometry                                                               //
+	//========================================================================//
+	template<typename Point = std::pair<Integer, Integer>>
+	std::vector<Point> convex(Integer n, Integer dim) {
+		judgeAssert<std::invalid_argument>(dim <= 0x3FFF'FFFF, "Random::convex(): dim too large!");
+		judgeAssert<std::invalid_argument>(dim > 0, "Random::convex(): dim must be positive!");
+		judgeAssert<std::invalid_argument>(n <= 8*dim - 8, "Random::convex(): dim too small!");
+		judgeAssert<std::invalid_argument>(n >= 3, "Random::convex(): n too small!");
+
+		while (true) {
+			Integer left = 1 + binomial(n - 2, 0.5);
+			Integer down = 1 + binomial(n - 2, 0.5);
+			auto x = partition(2 * dim - 2, left, 0);
+			auto y = partition(2 * dim - 2, down, 0);
+			for (auto& z : x) z = -z;
+			for (auto& z : y) z = -z;
+			append(x, partition(2 * dim - 2, n - left, 0));
+			append(y, partition(2 * dim - 2, n - down, 0));
+			auto itX = std::partition(x.begin(), x.end(), [](Integer z){return z == 0;});
+			auto itY = std::partition(y.begin(), y.end(), [](Integer z){return z != 0;});
+			if (std::distance(x.begin(), itX) + std::distance(itY, y.end()) > n) continue;
+			shuffle(itX, x.end());
+			if (itX != x.begin()) shuffle(y.begin(), itY);
+
+			std::vector<Point> dirs(n);
+			for (Integer i = 0; i < n; i++) {
+				dirs[i] = {x[i], y[i]};
+			}
+			::details::cyclicSort(dirs);
+
+			std::vector<Point> res = {{0, 0}};
+			Integer maxX = 0;
+			Integer maxY = 0;
+			for (auto dir : dirs) {
+				Point tmp = res.back();
+				getX(tmp) += getX(dir);
+				getY(tmp) += getY(dir);
+				maxX = std::max(maxX, getX(tmp));
+				maxY = std::max(maxY, getY(tmp));
+				res.emplace_back(tmp);
+			}
+			res.pop_back();
+			for (auto& point : res) {
+				getX(point) += dim - 1 - maxX;
+				getY(point) += dim - 1 - maxY;
+			}
+			return res;
+		}
+	}
+
+	template<typename Point = std::pair<Integer, Integer>>
+	std::vector<Point> nonCollinearPoints(Integer n, Integer dim) {
+		judgeAssert<std::invalid_argument>(dim <= 0x1FFF'FFFF, "Random::nonCollinearPoints(): dim too large!");
+		judgeAssert<std::invalid_argument>(n >= 0, "Random::nonCollinearPoints(): dim must be non negative!");
+		judgeAssert<std::invalid_argument>(dim > n, "Random::nonCollinearPoints(): dim too small!");
+		Integer p = prime(dim - 1, 2*dim + 2);
+		Integer rotA = 0;
+		Integer rotB = 0;
+		while (rotA == 0 && rotB == 0) {
+			rotA = integer(0, p);
+			rotB = integer(0, p);
+		}
+		std::array<Integer, 3> abc = {
+			integer(1, p),
+			integer(0, p),
+			integer(0, p),
+		};
+		Integer dx = integer(-dim + 1, dim - p);
+		Integer dy = integer(-dim + 1, dim - p);
+
+		auto xs = distinct(n, p);
+		std::vector<Point> res;
+		for (auto tmpX : xs) {
+			Integer tmpY = 0;
+			for (Integer add : abc[0]) {
+				tmpY *= tmpX;
+				tmpY += add;
+				tmpY %= p;
+			}
+
+			Integer x = applyMod(tmpX * rotA - tmpY * rotB, p);
+			Integer y = applyMod(tmpX * rotB + tmpY * rotA, p);
+
+			res.emplace_back(x + dx, y + dy);
+		}
+		return res;
+	}
+
+} // namespace Random
+
+
+//============================================================================//
+// args parser                                                                //
+//============================================================================//
+class ParamaterBase {
+	friend class Command;
+	friend struct Paramater;
+
+	std::optional<std::string_view> token;
+
+	template<typename T>
+	T parse(std::string_view s) const {
+		T res = {};
+		judgeAssert<std::invalid_argument>(details::parse<T>(s, res), "Command: Could not parse args");
+		return res;
+	}
+
+	ParamaterBase() = default;
+	explicit ParamaterBase(std::string_view token_) : token(token_) {}
+
+public:
+	std::string asString() const {
+		return std::string(token.value());
+	}
+
+	std::string asString(std::string_view defaultValue) const {
+		return std::string(token.value_or(defaultValue));
+	}
+
+	Integer asInteger() const {
+		return parse<Integer>(token.value());
+	}
+
+	Integer asInteger(Integer defaultValue) const {
+		return token ? asInteger() : defaultValue;
+	}
+
+	Real asReal() const {
+		return parse<Real>(token.value());
+	}
+
+	Real asReal(Real defaultValue) const {
+		return token ? asReal() : defaultValue;
+	}
+};
+
+struct Paramater final : private ParamaterBase {
+	using ParamaterBase::ParamaterBase;
+	using ParamaterBase::asString;
+	using ParamaterBase::asInteger;
+	using ParamaterBase::asReal;
+
+	bool exists() const {
+		return token.has_value();
+	}
+
+	explicit operator bool() const {
+		return exists();
+	}
+};
+
+class Command final : private ParamaterBase {
+	const std::vector<std::string>& raw;
+	const Integer first, count;
+	const bool found;
+public:
+	explicit Command(const std::vector<std::string>& raw_) : raw(raw_), first(0), count(0), found(false) {}
+	explicit Command(const std::vector<std::string>& raw_, Integer first_, Integer count_)
+	                 : ParamaterBase(count_ == 0 ? ParamaterBase() : ParamaterBase(raw_[first_])),
+	                   raw(raw_), first(first_), count(count_), found(true) {
+		judgeAssert<std::invalid_argument>(count >= 0, "Command: Invalid command in args!");
+	}
+
+	bool exists() const {
+		return found;
+	}
+
+	explicit operator bool() const {
+		return exists();
+	}
+
+	Integer parameterCount() const {
+		return count;
+	}
+
+	Paramater operator[](Integer i) const {
+		if (i >= 0 and i < count) return Paramater(raw[first + i]);
+		return Paramater();
+	}
+
+	using ParamaterBase::asString;
+	using ParamaterBase::asInteger;
+	using ParamaterBase::asReal;
+
+	std::vector<std::string> asStrings() const {
+		std::vector<std::string> res;
+		std::transform(raw.begin() + first,
+		               raw.begin() + first + count,
+		               std::back_inserter(res), [](const std::string& value) {
+			return std::string(value);
+		});
+		return res;
+	}
+
+	std::vector<Integer> asIntegers() const {
+		std::vector<Integer> res;
+		std::transform(raw.begin() + first,
+		               raw.begin() + first + count,
+		               std::back_inserter(res), [this](const std::string& value) {
+			return parse<Integer>(value);
+		});
+		return res;
+	}
+
+	std::vector<Real> asReals() const {
+		std::vector<Real> res;
+		std::transform(raw.begin() + first,
+		               raw.begin() + first + count,
+		               std::back_inserter(res), [this](const std::string& value) {
+			return parse<Real>(value);
+		});
+		return res;
+	}
+
+};
+
+class CommandParser final {
+	std::vector<std::string> raw;
+	std::map<std::string_view, std::pair<Integer, Integer>> commands;
+	std::map<std::string_view, Integer> tokens;
+
+	static bool isCommand(std::string_view s) {
+		return s.size() > 2 and s.substr(0, 2) == COMMAND_PREFIX;
+	}
+	void addCommand(std::string_view command, Integer first, Integer count = 0) {
+		judgeAssert<std::invalid_argument>(commands.count(command) == 0, "Command: Duplcated command in args!");
+		commands.emplace(command, std::pair<Integer, Integer>{first, count});
+	}
+
+public:
+	CommandParser() = default;
+	explicit CommandParser(int argc, char** argv) {
+		raw.assign(argc, {});
+		std::string_view command = EMPTY_COMMAND;
+		Integer first = 0;
+		Integer count = 0;
+		for (int i = 0; i < argc; i++) {
+			raw[i] = std::string(argv[i]);
+			tokens.emplace(raw[i], i+1);
+			if (isCommand(raw[i])) {
+				addCommand(command, first, count);
+				command = raw[i];
+				first = i+1;
+				count = 0;
+			} else {
+				count++;
+			}
+		}
+		addCommand(command, first, count);
+	}
+	CommandParser(CommandParser&&) = default;
+	CommandParser& operator=(CommandParser&&) = default;
+
+	CommandParser(const CommandParser&) = delete;
+	CommandParser& operator=(const CommandParser&) = delete;
+
+	std::string_view operator[](Integer t) const {
+		judgeAssert<std::out_of_range>(t >= 0 and t < static_cast<Integer>(raw.size()), "Command: Index out of args!");
+		return raw[t];
+	}
+	Command operator[](std::string_view command) const & {
+		judgeAssert<std::invalid_argument>(details::isToken(command), "Command: must not contain a space!");
+		auto it = commands.find(command);
+		if (it == commands.end()) return Command(raw);
+		return Command(raw, it->second.first, it->second.second);
+	}
+	Command getRaw(std::string_view command) const & {
+		judgeAssert<std::invalid_argument>(details::isToken(command), "Command: must not contain a space!");
+		auto it = tokens.find(command);
+		if (it == tokens.end()) return Command(raw);
+		return Command(raw, it->second, raw.size() - it->second);
+	}
+	Command getRaw() const & {
+		return Command(raw, 0, raw.size());
+	}
+};
+
+
+//============================================================================//
+// Constraints                                                                //
+//============================================================================//
+template<typename T>
+class Bounds final {
+	bool hadMin, hadMax;	// was value==lower/upper at some point
+	T min, max;				// range of seen values
+	T lower, upper;			// bounds for value
+public:
+	constexpr explicit Bounds(T lower_, T upper_, T value_) :
+	                          hadMin(false), hadMax(false),
+	                          min(value_), max(value_),
+	                          lower(lower_), upper(upper_) {
+		update(lower_, upper_, value_);
+	}
+
+	void update(T lower_, T upper_, T value_) {
+		if constexpr (std::is_same_v<T, Real>) {
+			hadMin |= details::floatEqual(value_, lower_, DEFAULT_EPS, DEFAULT_EPS);
+			hadMax |= details::floatEqual(value_, upper_, DEFAULT_EPS, DEFAULT_EPS);
+		} else {
+			hadMin |= value_ == lower_;
+			hadMax |= value_ == upper_;
+		}
+		min = std::min(min, value_);
+		max = std::max(max, value_);
+		lower = std::min(lower, lower_);
+		upper = std::max(upper, upper_);
+	}
+
+	friend std::ostream& operator<<(std::ostream& os, const Bounds<T>& bounds) {
+		os << bounds.hadMin << " " << bounds.hadMax << " ";
+		os << bounds.min << " " << bounds.max << " ";
+		return os << bounds.lower << " " << bounds.upper;
+	}
+
+};
+
+namespace details {
+	//using typeIndex = std::type_index;
+	using typeIndex = void*;
+
+	template<typename T>
+	typeIndex getTypeIndex() {
+		//return std::type_index(type id(T));
+		static T* uniqueTypeIndex = nullptr;
+		return &uniqueTypeIndex;
+	}
+}
+
+class Constraint final {
+	friend class ConstraintsLogger;
+	std::variant<
+		std::monostate,		// uninitialized
+		Bounds<Integer>,	// Integer or container bound
+		Bounds<Real>		// Real bound
+	> bound;
+	std::optional<details::typeIndex> type;
+
+	template<typename T, typename X = T>
+	void update(T lower, T upper, T value) {
+		if constexpr(std::is_integral_v<T>) {
+			upper--; // for BAPCtools the range is closed but we use half open ranges!
+		}
+		if (!type) {
+			type = details::getTypeIndex<X>();
+			bound = Bounds<T>(lower, upper, value);
+		}
+		judgeAssert<std::logic_error>(type == details::getTypeIndex<X>(), "Constraint: type must not change!");
+		std::get<Bounds<T>>(bound).update(lower, upper, value);
+	}
+public:
+	Constraint() = default;
+	Constraint(Constraint&&) = default;
+	Constraint& operator=(Constraint&&) = default;
+
+	Constraint(const Constraint&) = delete;
+	Constraint& operator=(const Constraint&) = delete;
+
+	template<typename V, typename std::enable_if_t<std::is_integral_v<V>, bool> = true>
+	void log(Integer lower, Integer upper, V value) {
+		update<Integer>(lower, upper, value);
+	}
+
+	template<typename V, typename std::enable_if_t<std::is_floating_point_v<V>, bool> = true>
+	void log(Real lower, Real upper, V value) {
+		update<Real>(lower, upper, value);
+	}
+
+	template<typename C, typename std::enable_if_t<!std::is_arithmetic_v<C>, bool> = true>
+	void log(Integer lower, Integer upper, const C& container) {
+		update<Integer, C>(lower, upper, static_cast<Integer>(std::size(container)));
+	}
+};
+
+class ConstraintsLogger final {
+	std::optional<std::string> fileName;
+	std::map<std::string, std::size_t> byName;
+	std::vector<std::unique_ptr<Constraint>> constraints;
+public:
+	ConstraintsLogger() = default;
+	explicit ConstraintsLogger(std::string_view fileName_) : fileName(fileName_) {}
+
+	ConstraintsLogger(ConstraintsLogger&&) = default;
+	ConstraintsLogger& operator=(ConstraintsLogger&&) = default;
+
+	ConstraintsLogger(const ConstraintsLogger&) = delete;
+	ConstraintsLogger& operator=(const ConstraintsLogger&) = delete;
+
+	Constraint& operator[](const std::string& name) & {
+		judgeAssert<std::invalid_argument>(details::isToken(name), "Constraint: name must not contain a space!");
+		auto res = byName.try_emplace(name, constraints.size());
+		if (res.second) constraints.emplace_back(std::make_unique<Constraint>());
+		return *(constraints[res.first->second]);
+	}
+
+	void write() const {
+		if (!fileName) return;
+		std::ofstream os(*fileName);
+		os << std::noboolalpha;
+		os << std::fixed;
+		os << std::setprecision(DEFAULT_PRECISION);
+		for (const auto& [name, id] : byName) {
+			const Constraint& c = *(constraints[id]);
+			if (c.type) {
+				os << "LocationNotSupported:" << name << " " << name << " ";
+				if (c.bound.index() == 1) os << std::get<1>(c.bound);
+				if (c.bound.index() == 2) os << std::get<2>(c.bound);
+				os << std::endl;
+			}
+		}
+	}
+
+	~ConstraintsLogger() noexcept {
+		write();
+	}
+};
+
+//============================================================================//
+// custom input stream                                                        //
+//============================================================================//
+class InputStream final {
+	std::unique_ptr<std::ifstream> managed;
+	std::istream* in;
+	bool spaceSensitive, caseSensitive;
+	Verdict onFail;
+	Real floatAbsTol;
+	Real floatRelTol;
+
+	void init() {
+		if (spaceSensitive) *in >> std::noskipws;
+		else *in >> std::skipws;
+	}
+
+	void checkIn() {
+		judgeAssert<std::runtime_error>(in != nullptr, "InputStream: not initialized!");
+	}
+
+public:
+	InputStream() = default;
+	explicit InputStream(const std::filesystem::path& path,
+	                     bool spaceSensitive_,
+	                     bool caseSensitive_,
+	                     Verdict onFail_,
+	                     Real floatAbsTol_ = DEFAULT_EPS,
+	                     Real floatRelTol_ = DEFAULT_EPS) :
+	                     managed(std::make_unique<std::ifstream>(path)),
+	                     in(managed.get()),
+	                     spaceSensitive(spaceSensitive_),
+	                     caseSensitive(caseSensitive_),
+	                     onFail(onFail_),
+	                     floatAbsTol(floatAbsTol_),
+	                     floatRelTol(floatRelTol_) {
+		judgeAssert<std::runtime_error>(managed->good(), "InputStream: Could not open File: " + path.string());
+		init();
+	}
+	explicit InputStream(std::istream& in_,
+	                     bool spaceSensitive_,
+	                     bool caseSensitive_,
+	                     Verdict onFail_,
+	                     Real floatAbsTol_ = DEFAULT_EPS,
+	                     Real floatRelTol_ = DEFAULT_EPS) :
+	                     managed(),
+	                     in(&in_),
+	                     spaceSensitive(spaceSensitive_),
+	                     caseSensitive(caseSensitive_),
+	                     onFail(onFail_),
+	                     floatAbsTol(floatAbsTol_),
+	                     floatRelTol(floatRelTol_) {
+		init();
+	}
+
+	InputStream(InputStream&& other) = default;
+	InputStream& operator=(InputStream&& other) = default;
+
+	InputStream(const InputStream&) = delete;
+	InputStream& operator=(const InputStream&) = delete;
+
+	void eof() {
+		checkIn();
+		if (!spaceSensitive) *in >> std::ws;
+		if (in->peek() != std::char_traits<char>::eof()) {
+			in->get();
+			ValidateBase::juryOut << "Missing EOF!";
+			fail();
+		}
+	}
+
+	void noteof() {
+		checkIn();
+		if (!spaceSensitive) *in >> std::ws;
+		if (in->peek() == std::char_traits<char>::eof()) {
+			ValidateBase::juryOut << "Unexpected EOF!" << onFail;
+		}
+	}
+
+	void space() {
+		if (spaceSensitive) {
+			noteof();
+			if (in->get() != std::char_traits<char>::to_int_type(SPACE)) {
+				ValidateBase::juryOut << "Missing space!";
+				fail();
+			}
+		}
+	}
+
+	void newline() {
+		if (spaceSensitive) {
+			noteof();
+			if (in->get() != std::char_traits<char>::to_int_type(NEWLINE)) {
+				ValidateBase::juryOut << "Missing newline!";
+				fail();
+			}
+		}
+	}
+
+private:
+	void check(const std::string& token, const std::regex& pattern) {
+		if (!std::regex_match(token, pattern)) {
+			ValidateBase::juryOut << "Token \"" << token << "\" does not match pattern!";
+			fail();
+		}
+	}
+
+	std::function<void()> checkSeparator(char separator) {
+		if (separator == SPACE) return [this](){space();};
+		if (separator == NEWLINE) return [this](){newline();};
+		judgeAssert<std::invalid_argument>(false, "InputStream: Separator must be ' '  or '\\n'!");
+		return {};
+	}
+
+	template<typename T>
+	T parse(const std::string& s) {
+		T res = {};
+		if (!details::parse<T>(s, res)) {
+			ValidateBase::juryOut << "Could not parse token \"" << s << "\"!";
+			fail();
+		}
+		return res;
+	}
+
+public:
+	std::string string() {
+		noteof();
+		if (spaceSensitive and !std::isgraph(in->peek())) {
+			in->get();
+			ValidateBase::juryOut << "Invalid whitespace!";
+			fail();
+		}
+		std::string res;
+		*in >> res;
+		if (res.empty()) {
+			ValidateBase::juryOut << "Unexpected EOF!" << onFail;
+		}
+		if (!caseSensitive) toDefaultCase(res);
+		return res;
+	}
+
+	std::string string(Integer lower, Integer upper) {
+		std::string t = string();
+		Integer length = static_cast<Integer>(t.size());
+		if (length < lower or length >= upper) {
+			ValidateBase::juryOut << "String length " << length << " out of range [" << lower << ", " << upper << ")!";
+			fail();
+		}
+		return t;
+	}
+
+	std::string string(Integer lower, Integer upper, Constraint& constraint) {
+		std::string res = string(lower, upper);
+		constraint.log(lower, upper, res);
+		return res;
+	}
+
+	std::string string(const std::regex& pattern) {
+		std::string t = string();
+		check(t, pattern);
+		return t;
+	}
+
+	std::string string(const std::regex& pattern, Integer lower, Integer upper) {
+		std::string t = string(lower, upper);
+		check(t, pattern);
+		return t;
+	}
+
+	std::string string(const std::regex& pattern, Integer lower, Integer upper, Constraint& constraint) {
+		std::string res = string(pattern, lower, upper);
+		constraint.log(lower, upper, res);
+		return res;
+	}
+
+	template<typename... Args>
+	std::vector<std::string> strings(Args... args, Integer count, char separator) {
+		auto sepCall = checkSeparator(separator);
+		std::vector<std::string> res(count);
+		for (Integer i = 0; i < count; i++) {
+			res[i] = string(args...);
+			if (i + 1 < count) sepCall();
+		}
+		return res;
+	}
+
+	std::vector<std::string> strings(Integer count, char separator = DEFAULT_SEPARATOR) {
+		return strings<>(count, separator);
+	}
+
+	std::vector<std::string> strings(Integer lower, Integer upper,
+	                                 Integer count, char separator = DEFAULT_SEPARATOR) {
+		return strings<Integer, Integer>(lower, upper, count, separator);
+	}
+
+	std::vector<std::string> strings(Integer lower, Integer upper, Constraint& constraint,
+	                                 Integer count, char separator = DEFAULT_SEPARATOR) {
+		return strings<Integer, Integer, Constraint&>(lower, upper, constraint, count, separator);
+	}
+
+	std::vector<std::string> strings(const std::regex& pattern,
+	                                 Integer count, char separator = DEFAULT_SEPARATOR) {
+		return strings<const std::regex&>(pattern, count, separator);
+	}
+
+	std::vector<std::string> strings(const std::regex& pattern, Integer lower, Integer upper,
+	                                 Integer count, char separator = DEFAULT_SEPARATOR) {
+		return strings<const std::regex&, Integer, Integer>(pattern, lower, upper, count, separator);
+	}
+
+	std::vector<std::string> strings(const std::regex& pattern, Integer lower, Integer upper, Constraint& constraint,
+	                                 Integer count, char separator = DEFAULT_SEPARATOR) {
+		return strings<const std::regex&, Integer, Integer, Constraint&>(pattern, lower, upper, constraint, count, separator);
+	}
+
+	Integer integer() {
+		return parse<Integer>(string(INTEGER_REGEX));
+	}
+
+	Integer integer(Integer lower, Integer upper) {
+		Integer res = integer();
+		if (res < lower or res >= upper) {
+			ValidateBase::juryOut << "Integer " << res << " out of range [" << lower << ", " << upper << ")!";
+			fail();
+		}
+		return res;
+	}
+
+	Integer integer(Integer lower, Integer upper, Constraint& constraint) {
+		Integer res = integer(lower, upper);
+		constraint.log(lower, upper, res);
+		return res;
+	}
+
+	template<typename... Args>
+	std::vector<Integer> integers(Args... args, Integer count, char separator) {
+		auto sepCall = checkSeparator(separator);
+		std::vector<Integer> res(count);
+		for (Integer i = 0; i < count; i++) {
+			res[i] = integer(args...);
+			if (i + 1 < count) sepCall();
+		}
+		return res;
+	}
+
+	std::vector<Integer> integers(Integer count, char separator = DEFAULT_SEPARATOR) {
+		return integers<>(count, separator);
+	}
+
+	std::vector<Integer> integers(Integer lower, Integer upper,
+	                              Integer count, char separator = DEFAULT_SEPARATOR) {
+		return integers<Integer, Integer>(lower, upper, count, separator);
+	}
+
+	std::vector<Integer> integers(Integer lower, Integer upper, Constraint& constraint,
+	                              Integer count, char separator = DEFAULT_SEPARATOR) {
+		return integers<Integer, Integer, Constraint&>(lower, upper, constraint, count, separator);
+	}
+
+	// this does not allow NaN or Inf!
+	// However, those should never be desired.
+	Real real() {
+		return parse<Real>(string(REAL_REGEX));
+	}
+
+	Real real(Real lower, Real upper) {// uses eps
+		Real res = real();
+		if (details::floatEqual(res, lower, floatAbsTol, floatRelTol)) return res;
+		if (details::floatEqual(res, upper, floatAbsTol, floatRelTol)) return res;
+		if (std::isnan(res) or !(res >= lower) or !(res < upper)) {
+			ValidateBase::juryOut << "Real " << res << " out of range [" << lower << ", " << upper << ")!";
+			fail();
+		}
+		return res;
+	}
+
+	Real real(Real lower, Real upper, Constraint& constraint) {
+		Real res = real(lower, upper);
+		constraint.log(lower, upper, res);
+		return res;
+	}
+
+	template<typename... Args>
+	std::vector<Real> reals(Args... args, Integer count, char separator) {
+		auto sepCall = checkSeparator(separator);
+		std::vector<Real> res(count);
+		for (Integer i = 0; i < count; i++) {
+			res[i] = real(args...);
+			if (i + 1 < count) sepCall();
+		}
+		return res;
+	}
+
+	std::vector<Real> reals(Integer count, char separator = DEFAULT_SEPARATOR) {
+		return reals<>(count, separator);
+	}
+
+	std::vector<Real> reals(Real lower, Real upper,
+	                        Integer count, char separator = DEFAULT_SEPARATOR) {
+		return reals<Real, Real>(lower, upper, count, separator);
+	}
+
+	std::vector<Real> reals(Real lower, Real upper, Constraint& constraint,
+	                        Integer count, char separator = DEFAULT_SEPARATOR) {
+		return reals<Real, Real, Constraint&>(lower, upper, constraint, count, separator);
+	}
+
+	Real realStrict(Real lower, Real upper, Integer minDecimals, Integer maxDecimals) {// does not use eps
+		std::string t = string(STRICT_REAL_REGEX);
+		auto dot = t.find('.');
+		Integer decimals = dot == std::string::npos ? 0 : t.size() - dot - 1;
+		if (decimals < minDecimals or decimals >= maxDecimals) {
+			ValidateBase::juryOut << "Real " << t << " has wrong amount of decimals!";
+			fail();
+			return 0;
+		}
+		try {
+			Real res = parse<Real>(t);
+			if (std::isnan(res) or !(res >= lower) or !(res < upper)) {
+				ValidateBase::juryOut << "Real " << res << " out of range [" << lower << ", " << upper << ")!";
+				fail();
+			}
+			return res;
+		} catch(...) {
+			ValidateBase::juryOut << "Could not parse token \"" << t << "\" as real!";
+			fail();
+			return 0;
+		}
+	}
+
+	Real realStrict(Real lower, Real upper, Integer minDecimals, Integer maxDecimals, Constraint& constraint) {
+		Real res = realStrict(lower, upper, minDecimals, maxDecimals);
+		constraint.log(lower, upper, res);
+		return res;
+	}
+
+	template<typename... Args>
+	std::vector<Real> realsStrict(Args... args, Integer count, char separator) {
+		auto sepCall = checkSeparator(separator);
+		std::vector<Real> res(count);
+		for (Integer i = 0; i < count; i++) {
+			res[i] = realStrict(args...);
+			if (i + 1 < count) sepCall();
+		}
+		return res;
+	}
+
+	std::vector<Real> realsStrict(Real lower, Real upper, Integer minDecimals, Integer maxDecimals,
+	                              Integer count, char separator = DEFAULT_SEPARATOR) {
+		return realsStrict<Real, Real, Integer, Integer>(lower, upper, minDecimals, maxDecimals, count, separator);
+	}
+
+	std::vector<Real> realsStrict(Real lower, Real upper, Integer minDecimals, Integer maxDecimals, Constraint& constraint,
+	                              Integer count, char separator = DEFAULT_SEPARATOR) {
+		return realsStrict<Real, Real, Integer, Integer, Constraint&>(lower, upper, minDecimals, maxDecimals, constraint, count, separator);
+	}
+
+	void expectString(std::string_view expected) {
+		judgeAssert<std::invalid_argument>(details::isToken(expected), "InputStream: expected must not contain a space!");
+		std::string seen = string();
+		auto [eq, pos] = details::stringEqual(seen, expected, caseSensitive);
+		if (!eq) {
+			if (seen.size() > 80) {
+				seen = seen.substr(0, 75) + "[...]";
+			}
+			ValidateBase::juryOut << "Expected \"" << expected << "\" but got \"" << seen << "\"!";
+			if (pos and *pos > 5) {
+				ValidateBase::juryOut << " (different at position: " << *pos+1 << ")";
+			}
+			fail();
+		}
+	}
+
+	void expectInt(Integer expected) {
+		Integer seen = integer();
+		if (seen != expected) {
+			ValidateBase::juryOut << "Expected " << expected << " but got " << seen << "!";
+			fail();
+		}
+	}
+
+	void expectReal(Real expected) {
+		Real seen = real();
+		if (details::floatEqual(seen, expected, floatAbsTol, floatRelTol)) {
+			ValidateBase::juryOut << "Expected " << expected << " but got " << seen << "!";
+			if (std::isfinite(seen) and std::isfinite(expected)) {
+				Real absDiff = std::abs(seen-expected);
+				Real relDiff = std::abs((seen-expected)/expected);
+				ValidateBase::juryOut << " (abs: " << absDiff << ", rel: " << relDiff << ")";
+			}
+			fail();
+		}
+	}
+private:
+	void fail() {
+		//try to find input position...
+		in->clear();
+		auto originalPos = in->tellg();
+		in->seekg(0);
+		if (originalPos != std::streamoff(-1) and *in) {
+			Integer line = 1;
+			std::size_t l = 0, r = 0;
+			std::string buffer;
+			bool extend = true;
+			while (*in and in->tellg() < originalPos) {
+				l = r = buffer.size();
+				if (std::isgraph(in->peek())) {
+					std::string tmp;
+					*in >> tmp;
+					buffer += tmp;
+				} else if (in->peek() == std::char_traits<char>::to_int_type(NEWLINE)) {
+					line++;
+					in->get();
+					if (in->tellg() < originalPos) {
+						buffer.clear();
+					} else {
+						buffer += ' ';
+						extend = false;
+					}
+				} else {
+					buffer += std::char_traits<char>::to_char_type(in->get());
+				}
+				if (*in and in->tellg() >= originalPos) {
+					r = buffer.size();
+				}
+			}
+			if (l != r) {
+				ValidateBase::juryOut << " Line: " << line << ", Char: " << l << '\n';
+				if (extend) {
+					char tmp;
+					while ((buffer.size() < 80 or buffer.size() < r + 80) and in->get(tmp) and tmp != NEWLINE) {
+						buffer += tmp;
+					}
+				}
+				if (r > 60 and l > 20) {
+					Integer offset = std::min(l - 20, r - 60);
+					l -= offset;
+					r -= offset;
+					buffer = "[...]" + buffer.substr(offset + 5);
+				}
+				if (buffer.size() > 80) {
+					buffer = buffer.substr(0, 75);
+					buffer += "[...]";
+					r = std::min(r, buffer.size());
+				}
+				ValidateBase::juryOut << buffer << '\n';
+				ValidateBase::juryOut << std::string(l, ' ') << '^' << std::string(r - l - 1, '~');
+			}
+		}
+		ValidateBase::juryOut << onFail;
+	}
+};
+
+
+//============================================================================//
+// state guard                                                                //
+//============================================================================//
+namespace details {
+	bool initialized(bool set = false) {
+		static bool value = false;
+		return std::exchange(value, value |= set);
+	}
+
+	struct InitGuard final {
+		~InitGuard() {
+			if (std::uncaught_exceptions() == 0) {
+				judgeAssert<std::logic_error>(initialized(), "validate.h: init(argc, argv) was never called!");
+			}
+		}
+	} initGuard;
+}
+
+
+//============================================================================//
+// Settings                                                                   //
+//============================================================================//
+template<typename T>
+class SettingBase {
+	template<typename U>
+	friend class Setting;
+	friend class SettingCaseSensitive;
+
+	T value;
+
+	SettingBase(T value_) : value(value_) {}
+
+public:
+	SettingBase(SettingBase<T>&& other) = delete;
+	SettingBase(const SettingBase<T>&) = delete;
+	SettingBase<T>& operator=(SettingBase<T>&& other) = delete;
+	SettingBase<T>& operator=(const SettingBase<T>&) = delete;
+
+	operator T() const {
+		return value;
+	}
+
+	SettingBase<T>& operator=(T value_) {
+		judgeAssert<std::logic_error>(!details::initialized(), "validate.h: Cannot change setting after init(argc, argv) was called!");
+		value = value_;
+		return *this;
+	}
+};
+
+template<typename T>
+class Setting final : public SettingBase<T> {
+public:
+	Setting(T value) : SettingBase<T>(value) {}
+	using SettingBase<T>::operator T;
+	using SettingBase<T>::operator=;
+};
+
+class SettingCaseSensitive final : public SettingBase<bool> {
+public:
+	SettingCaseSensitive(bool value) : SettingBase<bool>(value) {}
+	using SettingBase<bool>::operator bool;
+	using SettingBase<bool>::operator=;
+
+	std::regex regex(std::string_view s, std::regex_constants::syntax_option_type f = std::regex_constants::ECMAScript) const {
+		if (!value) f |= std::regex_constants::icase;
+		return std::regex(s.data(), s.size(), f);
+	}
+};
+
+
+//============================================================================//
+// Validators and stuff                                                       //
+//============================================================================//
+namespace ValidateBase {
+	//OutputStream juryOut(std::cout); //already defined earlier
+	//OutputStream juryErr(std::cerr);
+	CommandParser arguments;
+	//you may change these values before calling::init() but not afterwards!
+	Setting<Real> floatAbsTol(DEFAULT_EPS);
+	Setting<Real> floatRelTol(DEFAULT_EPS);
+	Setting<bool> spaceSensitive(false);
+	SettingCaseSensitive caseSensitive(false);
+
+	// Real r2 is considered the reference value for relative error.
+	bool floatEqual(Real given,
+	                Real expected,
+	                Real floatAbsTol_ = floatAbsTol,
+	                Real floatRelTol_ = floatRelTol) {
+		return details::floatEqual(given, expected, floatAbsTol_, floatRelTol_);
+	}
+
+	bool floatLess(Real given,
+	               Real expected,
+	               Real floatAbsTol_ = floatAbsTol,
+	               Real floatRelTol_ = floatRelTol) {
+		return given <= expected or floatEqual(given, expected, floatAbsTol_, floatRelTol_);
+	}
+
+	bool floatGreater(Real given,
+	                  Real expected,
+	                  Real floatAbsTol_ = floatAbsTol,
+	                  Real floatRelTol_ = floatRelTol) {
+		return given >= expected or floatEqual(given, expected, floatAbsTol_, floatRelTol_);
+	}
+
+	constexpr boolean<std::size_t> stringEqual(std::string_view a, std::string_view b, bool caseSensitive_ = caseSensitive) {
+		return details::stringEqual(a, b, caseSensitive_);
+	}
+
+	namespace details {
+		void init(int argc, char** argv) {
+			judgeAssert<std::logic_error>(!::details::initialized(), "validate.h: init(argc, argv) was called twice!");
+
+			//std::ios_base::sync_with_stdio(false);
+			//cin.tie(nullptr);
+
+			arguments = CommandParser(argc, argv);
+			if (auto seed = arguments[SEED_COMMAND]) Random::seed(seed.asInteger());
+			// parse default flags manually, since they dont use '--' prefix
+			auto eps = arguments.getRaw(FLOAT_TOLERANCE);
+			floatAbsTol = eps.asReal(floatAbsTol);
+			floatRelTol = eps.asReal(floatRelTol);
+			floatAbsTol = arguments.getRaw(FLOAT_ABSOLUTE_TOLERANCE).asReal(floatAbsTol);
+			floatRelTol = arguments.getRaw(FLOAT_RELATIVE_TOLERANCE).asReal(floatRelTol);
+
+			if (arguments.getRaw(SPACE_SENSITIVE)) spaceSensitive = true;
+			if (arguments.getRaw(CASE_SENSITIVE)) caseSensitive = true;
+
+			::details::initialized(true);
+		}
+	}
+
+} // namespace ValidateBase
+
+namespace ConstraintsBase {
+	ConstraintsLogger constraint;
+
+	void initConstraints() {
+		if (auto file = ValidateBase::arguments[CONSTRAINT_COMMAND]) {
+			constraint = ConstraintsLogger(file.asString());
+		}
+	}
+
+} // namespace ConstraintsBase
+
+//called as ./validator [arguments] < inputfile
+namespace InputValidator {
+	using namespace ValidateBase;
+	using namespace ConstraintsBase;
+
+	InputStream testIn;
+
+	void init(int argc, char** argv) {
+		spaceSensitive = true;
+		caseSensitive = true;
+
+		ValidateBase::details::init(argc, argv);
+		juryOut = OutputStream(std::cout);
+
+		testIn = InputStream(std::cin, spaceSensitive, caseSensitive, WA, floatAbsTol, floatRelTol);
+		initConstraints();
+	}
+
+} // namespace InputValidator
+
+//called as ./validator input judgeanswer feedbackdir < teamoutput
+namespace OutputValidator {
+	using namespace ValidateBase;
+	using namespace ConstraintsBase;
+
+	InputStream testIn;
+	InputStream juryAns;
+	InputStream teamAns;
+
+	void init(int argc, char** argv) {
+		ValidateBase::details::init(argc, argv);
+		juryOut = OutputStream(std::filesystem::path(arguments[3]) / JUDGE_MESSAGE);
+
+		testIn = InputStream(std::filesystem::path(arguments[1]), false, caseSensitive, FAIL);
+		juryAns = InputStream(std::filesystem::path(arguments[2]), false, caseSensitive, FAIL);
+		teamAns = InputStream(std::cin, spaceSensitive, caseSensitive, WA);
+		initConstraints();
+	}
+
+} // namespace OutputValidator
+
+//called as ./interactor input judgeanswer feedbackdir <> teamoutput
+namespace Interactor {
+	using namespace ValidateBase;
+
+	OutputStream toTeam;
+	InputStream testIn;
+	InputStream fromTeam;
+
+	void init(int argc, char** argv) {
+		ValidateBase::details::init(argc, argv);
+		juryOut = OutputStream(std::filesystem::path(arguments[3]) / JUDGE_MESSAGE);
+		toTeam = OutputStream(std::cout);
+
+		testIn = InputStream(std::filesystem::path(arguments[1]), false, caseSensitive, FAIL);
+		fromTeam = InputStream(std::cin, spaceSensitive, caseSensitive, WA);
+	}
+
+} // namespace Interactor
+
+//called as ./generator [arguments]
+namespace Generator {
+	using namespace ValidateBase;
+
+	OutputStream testOut;
+
+	void init(int argc, char** argv) {
+		ValidateBase::details::init(argc, argv);
+		juryOut = OutputStream(std::cerr);
+		testOut = OutputStream(std::cout);
+	}
+
+} // namespace Generator
+
+#endif

ICPC/nwerc2023_C/data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:649797f71211929574b32c8992a4bad824163cfa41c8f121fe22b710fff88829
+size 48190763

ICPC/nwerc2023_C/init.yml

@@ -0,0 +1,137 @@
+archive: data.zip
+test_cases:
+- in: 01-query-biggest.in
+  out: 01-query-biggest.ans
+  points: 1
+- in: 02-random.in
+  out: 02-random.ans
+  points: 1
+- in: 03-random_even.in
+  out: 03-random_even.ans
+  points: 1
+- in: 04-random_occupied.in
+  out: 04-random_occupied.ans
+  points: 1
+- in: 05-distinct_primes.in
+  out: 05-distinct_primes.ans
+  points: 1
+- in: 06-big_prime.in
+  out: 06-big_prime.ans
+  points: 1
+- in: 07-small_prime.in
+  out: 07-small_prime.ans
+  points: 1
+- in: 08-semiprime.in
+  out: 08-semiprime.ans
+  points: 1
+- in: 09-composite.in
+  out: 09-composite.ans
+  points: 1
+- in: 10-random.in
+  out: 10-random.ans
+  points: 1
+- in: 11-random.in
+  out: 11-random.ans
+  points: 1
+- in: 12-random.in
+  out: 12-random.ans
+  points: 1
+- in: 13-random.in
+  out: 13-random.ans
+  points: 1
+- in: 14-random.in
+  out: 14-random.ans
+  points: 1
+- in: 15-random_even.in
+  out: 15-random_even.ans
+  points: 1
+- in: 16-random_even.in
+  out: 16-random_even.ans
+  points: 1
+- in: 17-random_even.in
+  out: 17-random_even.ans
+  points: 1
+- in: 18-random_even.in
+  out: 18-random_even.ans
+  points: 1
+- in: 19-random_even.in
+  out: 19-random_even.ans
+  points: 1
+- in: 20-random_occupied.in
+  out: 20-random_occupied.ans
+  points: 1
+- in: 21-random_occupied.in
+  out: 21-random_occupied.ans
+  points: 1
+- in: 22-distinct_primes.in
+  out: 22-distinct_primes.ans
+  points: 1
+- in: 23-distinct_primes.in
+  out: 23-distinct_primes.ans
+  points: 1
+- in: 24-power_of_two.in
+  out: 24-power_of_two.ans
+  points: 1
+- in: 25-follow.in
+  out: 25-follow.ans
+  points: 1
+- in: 26-follow.in
+  out: 26-follow.ans
+  points: 1
+- in: 27-random.in
+  out: 27-random.ans
+  points: 1
+- in: 28-random.in
+  out: 28-random.ans
+  points: 1
+- in: 29-big_prime.in
+  out: 29-big_prime.ans
+  points: 1
+- in: 30-big_prime.in
+  out: 30-big_prime.ans
+  points: 1
+- in: 31-small_prime.in
+  out: 31-small_prime.ans
+  points: 1
+- in: 32-semiprime.in
+  out: 32-semiprime.ans
+  points: 1
+- in: 33-semiprime.in
+  out: 33-semiprime.ans
+  points: 1
+- in: 34-composite.in
+  out: 34-composite.ans
+  points: 1
+- in: 35-query_all.in
+  out: 35-query_all.ans
+  points: 1
+- in: 36-query_all.in
+  out: 36-query_all.ans
+  points: 1
+- in: 37-query_all.in
+  out: 37-query_all.ans
+  points: 1
+- in: 38-query_all.in
+  out: 38-query_all.ans
+  points: 1
+- in: 39-query_all.in
+  out: 39-query_all.ans
+  points: 1
+- in: 40-query_all.in
+  out: 40-query_all.ans
+  points: 1
+- in: 41-manual.in
+  out: 41-manual.ans
+  points: 1
+- in: 42-manual.in
+  out: 42-manual.ans
+  points: 1
+- in: 43-manual.in
+  out: 43-manual.ans
+  points: 1
+- in: 44-manual.in
+  out: 44-manual.ans
+  points: 1
+- in: 45-manual.in
+  out: 45-manual.ans
+  points: 1

ICPC/nwerc2023_D/data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aab1e5aeb5b1c01da996d45dca2f863a670ae6b3937726d223786ed3d892f8f7
+size 21922

ICPC/nwerc2023_D/init.yml

@@ -0,0 +1,255 @@
+archive: data.zip
+checker:
+  args:
+    precision: 6
+  name: floats
+test_cases:
+- in: 01-rand_min.in
+  out: 01-rand_min.ans
+  points: 1
+- in: 02-rand_almost_max.in
+  out: 02-rand_almost_max.ans
+  points: 1
+- in: 03-rand_almost_max.in
+  out: 03-rand_almost_max.ans
+  points: 1
+- in: 04-rand_almost_max.in
+  out: 04-rand_almost_max.ans
+  points: 1
+- in: 05-rand_max.in
+  out: 05-rand_max.ans
+  points: 1
+- in: 06-rand_worst.in
+  out: 06-rand_worst.ans
+  points: 1
+- in: 07-rand_worst.in
+  out: 07-rand_worst.ans
+  points: 1
+- in: 08-rand_worst_rows.in
+  out: 08-rand_worst_rows.ans
+  points: 1
+- in: 09-rand_worst_rows.in
+  out: 09-rand_worst_rows.ans
+  points: 1
+- in: 10-rand_worst_cols.in
+  out: 10-rand_worst_cols.ans
+  points: 1
+- in: 11-rand_worst_cols.in
+  out: 11-rand_worst_cols.ans
+  points: 1
+- in: 12-all_empty.in
+  out: 12-all_empty.ans
+  points: 1
+- in: 13-all_empty.in
+  out: 13-all_empty.ans
+  points: 1
+- in: 14-all_empty.in
+  out: 14-all_empty.ans
+  points: 1
+- in: 15-all_empty.in
+  out: 15-all_empty.ans
+  points: 1
+- in: 16-all_empty.in
+  out: 16-all_empty.ans
+  points: 1
+- in: 17-all_empty.in
+  out: 17-all_empty.ans
+  points: 1
+- in: 18-all_empty.in
+  out: 18-all_empty.ans
+  points: 1
+- in: 19-all_empty.in
+  out: 19-all_empty.ans
+  points: 1
+- in: 20-all_empty.in
+  out: 20-all_empty.ans
+  points: 1
+- in: 21-all_empty.in
+  out: 21-all_empty.ans
+  points: 1
+- in: 22-all_empty.in
+  out: 22-all_empty.ans
+  points: 1
+- in: 23-all_empty.in
+  out: 23-all_empty.ans
+  points: 1
+- in: 24-all_full.in
+  out: 24-all_full.ans
+  points: 1
+- in: 25-all_full.in
+  out: 25-all_full.ans
+  points: 1
+- in: 26-all_full.in
+  out: 26-all_full.ans
+  points: 1
+- in: 27-all_full.in
+  out: 27-all_full.ans
+  points: 1
+- in: 28-all_full.in
+  out: 28-all_full.ans
+  points: 1
+- in: 29-all_full.in
+  out: 29-all_full.ans
+  points: 1
+- in: 30-all_full.in
+  out: 30-all_full.ans
+  points: 1
+- in: 31-all_full.in
+  out: 31-all_full.ans
+  points: 1
+- in: 32-all_full.in
+  out: 32-all_full.ans
+  points: 1
+- in: 33-all_full.in
+  out: 33-all_full.ans
+  points: 1
+- in: 34-all_full.in
+  out: 34-all_full.ans
+  points: 1
+- in: 35-all_full.in
+  out: 35-all_full.ans
+  points: 1
+- in: 36-exact_fit.in
+  out: 36-exact_fit.ans
+  points: 1
+- in: 37-exact_fit.in
+  out: 37-exact_fit.ans
+  points: 1
+- in: 38-exact_fit.in
+  out: 38-exact_fit.ans
+  points: 1
+- in: 39-exact_fit.in
+  out: 39-exact_fit.ans
+  points: 1
+- in: 40-exact_fit.in
+  out: 40-exact_fit.ans
+  points: 1
+- in: 41-exact_fit.in
+  out: 41-exact_fit.ans
+  points: 1
+- in: 42-exact_fit.in
+  out: 42-exact_fit.ans
+  points: 1
+- in: 43-exact_fit.in
+  out: 43-exact_fit.ans
+  points: 1
+- in: 44-exact_fit.in
+  out: 44-exact_fit.ans
+  points: 1
+- in: 45-exact_fit.in
+  out: 45-exact_fit.ans
+  points: 1
+- in: 46-exact_fit.in
+  out: 46-exact_fit.ans
+  points: 1
+- in: 47-exact_fit_shuffled.in
+  out: 47-exact_fit_shuffled.ans
+  points: 1
+- in: 48-exact_fit_shuffled.in
+  out: 48-exact_fit_shuffled.ans
+  points: 1
+- in: 49-exact_fit_shuffled.in
+  out: 49-exact_fit_shuffled.ans
+  points: 1
+- in: 50-exact_fit_shuffled.in
+  out: 50-exact_fit_shuffled.ans
+  points: 1
+- in: 51-exact_fit_shuffled.in
+  out: 51-exact_fit_shuffled.ans
+  points: 1
+- in: 52-exact_fit_shuffled.in
+  out: 52-exact_fit_shuffled.ans
+  points: 1
+- in: 53-exact_fit_shuffled.in
+  out: 53-exact_fit_shuffled.ans
+  points: 1
+- in: 54-exact_fit_shuffled.in
+  out: 54-exact_fit_shuffled.ans
+  points: 1
+- in: 55-exact_fit_shuffled.in
+  out: 55-exact_fit_shuffled.ans
+  points: 1
+- in: 56-exact_fit_shuffled.in
+  out: 56-exact_fit_shuffled.ans
+  points: 1
+- in: 57-exact_fit_shuffled.in
+  out: 57-exact_fit_shuffled.ans
+  points: 1
+- in: 58-corners.in
+  out: 58-corners.ans
+  points: 1
+- in: 59-corners.in
+  out: 59-corners.ans
+  points: 1
+- in: 60-corners.in
+  out: 60-corners.ans
+  points: 1
+- in: 61-corners.in
+  out: 61-corners.ans
+  points: 1
+- in: 62-corners.in
+  out: 62-corners.ans
+  points: 1
+- in: 63-4corners.in
+  out: 63-4corners.ans
+  points: 1
+- in: 64-4corners.in
+  out: 64-4corners.ans
+  points: 1
+- in: 65-4corners.in
+  out: 65-4corners.ans
+  points: 1
+- in: 66-4corners.in
+  out: 66-4corners.ans
+  points: 1
+- in: 67-4corners.in
+  out: 67-4corners.ans
+  points: 1
+- in: 68-4corners.in
+  out: 68-4corners.ans
+  points: 1
+- in: 69-4corners.in
+  out: 69-4corners.ans
+  points: 1
+- in: 70-4corners.in
+  out: 70-4corners.ans
+  points: 1
+- in: 71-4corners.in
+  out: 71-4corners.ans
+  points: 1
+- in: 72-corner.in
+  out: 72-corner.ans
+  points: 1
+- in: 73-corner.in
+  out: 73-corner.ans
+  points: 1
+- in: 74-corner.in
+  out: 74-corner.ans
+  points: 1
+- in: 75-corner.in
+  out: 75-corner.ans
+  points: 1
+- in: 76-corner.in
+  out: 76-corner.ans
+  points: 1
+- in: 77-corner.in
+  out: 77-corner.ans
+  points: 1
+- in: 78-corner.in
+  out: 78-corner.ans
+  points: 1
+- in: 79-corner.in
+  out: 79-corner.ans
+  points: 1
+- in: 80-corner.in
+  out: 80-corner.ans
+  points: 1
+- in: 81-corner.in
+  out: 81-corner.ans
+  points: 1
+- in: 82-corner.in
+  out: 82-corner.ans
+  points: 1
+- in: 83-corner.in
+  out: 83-corner.ans
+  points: 1

ICPC/nwerc2023_E/data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2d2d6977cbb540127a2425e6d396e1aa9dcea3c85eb53900366b6d8f16d04079
+size 242919

ICPC/nwerc2023_E/init.yml

@@ -0,0 +1,404 @@
+archive: data.zip
+test_cases:
+- in: 001-twos.in
+  out: 001-twos.ans
+  points: 1
+- in: 002-rivals.in
+  out: 002-rivals.ans
+  points: 1
+- in: 003-tree2.in
+  out: 003-tree2.ans
+  points: 1
+- in: 004-tiny.in
+  out: 004-tiny.ans
+  points: 1
+- in: 005-tiny.in
+  out: 005-tiny.ans
+  points: 1
+- in: 006-tiny.in
+  out: 006-tiny.ans
+  points: 1
+- in: 007-tiny.in
+  out: 007-tiny.ans
+  points: 1
+- in: 008-tiny.in
+  out: 008-tiny.ans
+  points: 1
+- in: 009-tiny.in
+  out: 009-tiny.ans
+  points: 1
+- in: 010-tiny.in
+  out: 010-tiny.ans
+  points: 1
+- in: 011-tiny.in
+  out: 011-tiny.ans
+  points: 1
+- in: 012-tiny.in
+  out: 012-tiny.ans
+  points: 1
+- in: 013-wrong_base.in
+  out: 013-wrong_base.ans
+  points: 1
+- in: 014-wrong_base.in
+  out: 014-wrong_base.ans
+  points: 1
+- in: 015-random.in
+  out: 015-random.ans
+  points: 1
+- in: 016-random.in
+  out: 016-random.ans
+  points: 1
+- in: 017-random.in
+  out: 017-random.ans
+  points: 1
+- in: 018-random.in
+  out: 018-random.ans
+  points: 1
+- in: 019-random.in
+  out: 019-random.ans
+  points: 1
+- in: 020-random.in
+  out: 020-random.ans
+  points: 1
+- in: 021-random.in
+  out: 021-random.ans
+  points: 1
+- in: 022-random.in
+  out: 022-random.ans
+  points: 1
+- in: 023-chain.in
+  out: 023-chain.ans
+  points: 1
+- in: 024-chain.in
+  out: 024-chain.ans
+  points: 1
+- in: 025-chain.in
+  out: 025-chain.ans
+  points: 1
+- in: 026-chain.in
+  out: 026-chain.ans
+  points: 1
+- in: 027-chain.in
+  out: 027-chain.ans
+  points: 1
+- in: 028-max_output.in
+  out: 028-max_output.ans
+  points: 1
+- in: 029-rivals.in
+  out: 029-rivals.ans
+  points: 1
+- in: 030-rivals.in
+  out: 030-rivals.ans
+  points: 1
+- in: 031-rivals.in
+  out: 031-rivals.ans
+  points: 1
+- in: 032-rivals.in
+  out: 032-rivals.ans
+  points: 1
+- in: 033-rivals.in
+  out: 033-rivals.ans
+  points: 1
+- in: 034-rivals.in
+  out: 034-rivals.ans
+  points: 1
+- in: 035-rivals.in
+  out: 035-rivals.ans
+  points: 1
+- in: 036-rivals.in
+  out: 036-rivals.ans
+  points: 1
+- in: 037-long_lists.in
+  out: 037-long_lists.ans
+  points: 1
+- in: 038-long_lists.in
+  out: 038-long_lists.ans
+  points: 1
+- in: 039-long_lists.in
+  out: 039-long_lists.ans
+  points: 1
+- in: 040-long_lists.in
+  out: 040-long_lists.ans
+  points: 1
+- in: 041-long_lists.in
+  out: 041-long_lists.ans
+  points: 1
+- in: 042-one_long_list.in
+  out: 042-one_long_list.ans
+  points: 1
+- in: 043-tree.in
+  out: 043-tree.ans
+  points: 1
+- in: 044-tree.in
+  out: 044-tree.ans
+  points: 1
+- in: 045-tree.in
+  out: 045-tree.ans
+  points: 1
+- in: 046-tree.in
+  out: 046-tree.ans
+  points: 1
+- in: 047-tree.in
+  out: 047-tree.ans
+  points: 1
+- in: 048-tree.in
+  out: 048-tree.ans
+  points: 1
+- in: 049-tree.in
+  out: 049-tree.ans
+  points: 1
+- in: 050-almost_isomorphic.in
+  out: 050-almost_isomorphic.ans
+  points: 1
+- in: 051-almost_isomorphic.in
+  out: 051-almost_isomorphic.ans
+  points: 1
+- in: 052-almost_isomorphic.in
+  out: 052-almost_isomorphic.ans
+  points: 1
+- in: 053-almost_isomorphic.in
+  out: 053-almost_isomorphic.ans
+  points: 1
+- in: 054-almost_isomorphic.in
+  out: 054-almost_isomorphic.ans
+  points: 1
+- in: 055-almost_isomorphic.in
+  out: 055-almost_isomorphic.ans
+  points: 1
+- in: 056-almost_isomorphic.in
+  out: 056-almost_isomorphic.ans
+  points: 1
+- in: 057-triangles.in
+  out: 057-triangles.ans
+  points: 1
+- in: 058-triangles.in
+  out: 058-triangles.ans
+  points: 1
+- in: 059-triangles.in
+  out: 059-triangles.ans
+  points: 1
+- in: 060-triangles.in
+  out: 060-triangles.ans
+  points: 1
+- in: 061-triangles.in
+  out: 061-triangles.ans
+  points: 1
+- in: 062-triangles.in
+  out: 062-triangles.ans
+  points: 1
+- in: 063-triangles.in
+  out: 063-triangles.ans
+  points: 1
+- in: 064-triangles.in
+  out: 064-triangles.ans
+  points: 1
+- in: 065-triangles.in
+  out: 065-triangles.ans
+  points: 1
+- in: 066-triangles.in
+  out: 066-triangles.ans
+  points: 1
+- in: 067-tree2.in
+  out: 067-tree2.ans
+  points: 1
+- in: 068-tree2.in
+  out: 068-tree2.ans
+  points: 1
+- in: 069-tree2.in
+  out: 069-tree2.ans
+  points: 1
+- in: 070-tree2.in
+  out: 070-tree2.ans
+  points: 1
+- in: 071-tree2.in
+  out: 071-tree2.ans
+  points: 1
+- in: 072-tree2.in
+  out: 072-tree2.ans
+  points: 1
+- in: 073-tree2.in
+  out: 073-tree2.ans
+  points: 1
+- in: 074-tree2.in
+  out: 074-tree2.ans
+  points: 1
+- in: 075-one_query.in
+  out: 075-one_query.ans
+  points: 1
+- in: 076-anti_ragnar.in
+  out: 076-anti_ragnar.ans
+  points: 1
+- in: 077-fibonacci.in
+  out: 077-fibonacci.ans
+  points: 1
+- in: 078-flipflop-1s.in
+  out: 078-flipflop-1s.ans
+  points: 1
+- in: 079-flipflop-1s.in
+  out: 079-flipflop-1s.ans
+  points: 1
+- in: 080-flipflop-1s.in
+  out: 080-flipflop-1s.ans
+  points: 1
+- in: 081-flipflop-2s.in
+  out: 081-flipflop-2s.ans
+  points: 1
+- in: 082-flipflop-2s.in
+  out: 082-flipflop-2s.ans
+  points: 1
+- in: 083-flipflop-2s.in
+  out: 083-flipflop-2s.ans
+  points: 1
+- in: 084-flipflop-2s.in
+  out: 084-flipflop-2s.ans
+  points: 1
+- in: 085-flipflop-2s.in
+  out: 085-flipflop-2s.ans
+  points: 1
+- in: 086-flipflop-2s.in
+  out: 086-flipflop-2s.ans
+  points: 1
+- in: 087-flipflop-3s.in
+  out: 087-flipflop-3s.ans
+  points: 1
+- in: 088-flipflop-3s.in
+  out: 088-flipflop-3s.ans
+  points: 1
+- in: 089-flipflop-3s.in
+  out: 089-flipflop-3s.ans
+  points: 1
+- in: 090-flipflop-3s.in
+  out: 090-flipflop-3s.ans
+  points: 1
+- in: 091-flipflop-3s.in
+  out: 091-flipflop-3s.ans
+  points: 1
+- in: 092-flipflop-3s.in
+  out: 092-flipflop-3s.ans
+  points: 1
+- in: 093-flipflop-4s.in
+  out: 093-flipflop-4s.ans
+  points: 1
+- in: 094-flipflop-4s.in
+  out: 094-flipflop-4s.ans
+  points: 1
+- in: 095-flipflop-4s.in
+  out: 095-flipflop-4s.ans
+  points: 1
+- in: 096-flipflop-4s.in
+  out: 096-flipflop-4s.ans
+  points: 1
+- in: 097-flipflop-4s.in
+  out: 097-flipflop-4s.ans
+  points: 1
+- in: 098-flipflop-4s.in
+  out: 098-flipflop-4s.ans
+  points: 1
+- in: 099-flipflop-9s.in
+  out: 099-flipflop-9s.ans
+  points: 1
+- in: 100-flipflop-9s.in
+  out: 100-flipflop-9s.ans
+  points: 1
+- in: 101-flipflop-9s.in
+  out: 101-flipflop-9s.ans
+  points: 1
+- in: 102-flipflop-9s.in
+  out: 102-flipflop-9s.ans
+  points: 1
+- in: 103-flipflop-9s.in
+  out: 103-flipflop-9s.ans
+  points: 1
+- in: 104-flipflop-9s.in
+  out: 104-flipflop-9s.ans
+  points: 1
+- in: 105-flipflop-id-1s.in
+  out: 105-flipflop-id-1s.ans
+  points: 1
+- in: 106-flipflop-id-1s.in
+  out: 106-flipflop-id-1s.ans
+  points: 1
+- in: 107-flipflop-id-1s.in
+  out: 107-flipflop-id-1s.ans
+  points: 1
+- in: 108-flipflop-id-2s.in
+  out: 108-flipflop-id-2s.ans
+  points: 1
+- in: 109-flipflop-id-2s.in
+  out: 109-flipflop-id-2s.ans
+  points: 1
+- in: 110-flipflop-id-2s.in
+  out: 110-flipflop-id-2s.ans
+  points: 1
+- in: 111-flipflop-id-3s.in
+  out: 111-flipflop-id-3s.ans
+  points: 1
+- in: 112-flipflop-id-3s.in
+  out: 112-flipflop-id-3s.ans
+  points: 1
+- in: 113-flipflop-id-3s.in
+  out: 113-flipflop-id-3s.ans
+  points: 1
+- in: 114-flipflop-id-4s.in
+  out: 114-flipflop-id-4s.ans
+  points: 1
+- in: 115-flipflop-id-4s.in
+  out: 115-flipflop-id-4s.ans
+  points: 1
+- in: 116-flipflop-id-4s.in
+  out: 116-flipflop-id-4s.ans
+  points: 1
+- in: 117-flipflop-id-9s.in
+  out: 117-flipflop-id-9s.ans
+  points: 1
+- in: 118-flipflop-id-9s.in
+  out: 118-flipflop-id-9s.ans
+  points: 1
+- in: 119-flipflop-id-9s.in
+  out: 119-flipflop-id-9s.ans
+  points: 1
+- in: 120-flipflop-id-1s-p.in
+  out: 120-flipflop-id-1s-p.ans
+  points: 1
+- in: 121-flipflop-id-1s-p.in
+  out: 121-flipflop-id-1s-p.ans
+  points: 1
+- in: 122-flipflop-id-1s-p.in
+  out: 122-flipflop-id-1s-p.ans
+  points: 1
+- in: 123-flipflop-id-2s-p.in
+  out: 123-flipflop-id-2s-p.ans
+  points: 1
+- in: 124-flipflop-id-2s-p.in
+  out: 124-flipflop-id-2s-p.ans
+  points: 1
+- in: 125-flipflop-id-2s-p.in
+  out: 125-flipflop-id-2s-p.ans
+  points: 1
+- in: 126-flipflop-id-3s-p.in
+  out: 126-flipflop-id-3s-p.ans
+  points: 1
+- in: 127-flipflop-id-3s-p.in
+  out: 127-flipflop-id-3s-p.ans
+  points: 1
+- in: 128-flipflop-id-3s-p.in
+  out: 128-flipflop-id-3s-p.ans
+  points: 1
+- in: 129-flipflop-id-4s-p.in
+  out: 129-flipflop-id-4s-p.ans
+  points: 1
+- in: 130-flipflop-id-4s-p.in
+  out: 130-flipflop-id-4s-p.ans
+  points: 1
+- in: 131-flipflop-id-4s-p.in
+  out: 131-flipflop-id-4s-p.ans
+  points: 1
+- in: 132-flipflop-id-9s-p.in
+  out: 132-flipflop-id-9s-p.ans
+  points: 1
+- in: 133-flipflop-id-9s-p.in
+  out: 133-flipflop-id-9s-p.ans
+  points: 1
+- in: 134-flipflop-id-9s-p.in
+  out: 134-flipflop-id-9s-p.ans
+  points: 1

ICPC/nwerc2023_F/data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:578c303741e521844c78cdfa125ff3dd0e48444b3f99282cddd941cfc59844ad
+size 19220

ICPC/nwerc2023_F/init.yml

@@ -0,0 +1,223 @@
+archive: data.zip
+checker:
+  args:
+    files:
+    - output_validators/output_validator/validate.h
+    - output_validators/output_validator/outputValidator.cpp
+    lang: CPP17
+    type: default
+  name: bridged
+test_cases:
+- in: 01-manual-many-subsets.in
+  out: 01-manual-many-subsets.ans
+  points: 1
+- in: 02-possible.in
+  out: 02-possible.ans
+  points: 1
+- in: 03-impossible.in
+  out: 03-impossible.ans
+  points: 1
+- in: 04-manual.in
+  out: 04-manual.ans
+  points: 1
+- in: 05-manual.in
+  out: 05-manual.ans
+  points: 1
+- in: 06-manual.in
+  out: 06-manual.ans
+  points: 1
+- in: 07-manual.in
+  out: 07-manual.ans
+  points: 1
+- in: 08-manual.in
+  out: 08-manual.ans
+  points: 1
+- in: 09-manual.in
+  out: 09-manual.ans
+  points: 1
+- in: 10-manual.in
+  out: 10-manual.ans
+  points: 1
+- in: 11-manual.in
+  out: 11-manual.ans
+  points: 1
+- in: 12-manual.in
+  out: 12-manual.ans
+  points: 1
+- in: 13-manual.in
+  out: 13-manual.ans
+  points: 1
+- in: 14-manual.in
+  out: 14-manual.ans
+  points: 1
+- in: 15-manual.in
+  out: 15-manual.ans
+  points: 1
+- in: 16-manual.in
+  out: 16-manual.ans
+  points: 1
+- in: 17-overflow.in
+  out: 17-overflow.ans
+  points: 1
+- in: 18-overflow.in
+  out: 18-overflow.ans
+  points: 1
+- in: 19-manual.in
+  out: 19-manual.ans
+  points: 1
+- in: 20-manual.in
+  out: 20-manual.ans
+  points: 1
+- in: 21-manual.in
+  out: 21-manual.ans
+  points: 1
+- in: 22-manual.in
+  out: 22-manual.ans
+  points: 1
+- in: 23-manual.in
+  out: 23-manual.ans
+  points: 1
+- in: 24-manual.in
+  out: 24-manual.ans
+  points: 1
+- in: 25-manual.in
+  out: 25-manual.ans
+  points: 1
+- in: 26-manual.in
+  out: 26-manual.ans
+  points: 1
+- in: 27-manual.in
+  out: 27-manual.ans
+  points: 1
+- in: 28-manual.in
+  out: 28-manual.ans
+  points: 1
+- in: 29-manual.in
+  out: 29-manual.ans
+  points: 1
+- in: 30-manual.in
+  out: 30-manual.ans
+  points: 1
+- in: 31-manual.in
+  out: 31-manual.ans
+  points: 1
+- in: 32-manual.in
+  out: 32-manual.ans
+  points: 1
+- in: 33-need_gcd.in
+  out: 33-need_gcd.ans
+  points: 1
+- in: 34-need_gcd.in
+  out: 34-need_gcd.ans
+  points: 1
+- in: 35-possible.in
+  out: 35-possible.ans
+  points: 1
+- in: 36-possible.in
+  out: 36-possible.ans
+  points: 1
+- in: 37-possible.in
+  out: 37-possible.ans
+  points: 1
+- in: 38-possible.in
+  out: 38-possible.ans
+  points: 1
+- in: 39-possible.in
+  out: 39-possible.ans
+  points: 1
+- in: 40-possible.in
+  out: 40-possible.ans
+  points: 1
+- in: 41-possible.in
+  out: 41-possible.ans
+  points: 1
+- in: 42-possible.in
+  out: 42-possible.ans
+  points: 1
+- in: 43-possible.in
+  out: 43-possible.ans
+  points: 1
+- in: 44-possible.in
+  out: 44-possible.ans
+  points: 1
+- in: 45-possible.in
+  out: 45-possible.ans
+  points: 1
+- in: 46-possible.in
+  out: 46-possible.ans
+  points: 1
+- in: 47-impossible.in
+  out: 47-impossible.ans
+  points: 1
+- in: 48-impossible.in
+  out: 48-impossible.ans
+  points: 1
+- in: 49-impossible.in
+  out: 49-impossible.ans
+  points: 1
+- in: 50-impossible.in
+  out: 50-impossible.ans
+  points: 1
+- in: 51-impossible.in
+  out: 51-impossible.ans
+  points: 1
+- in: 52-impossible.in
+  out: 52-impossible.ans
+  points: 1
+- in: 53-impossible.in
+  out: 53-impossible.ans
+  points: 1
+- in: 54-impossible.in
+  out: 54-impossible.ans
+  points: 1
+- in: 55-impossible.in
+  out: 55-impossible.ans
+  points: 1
+- in: 56-impossible.in
+  out: 56-impossible.ans
+  points: 1
+- in: 57-impossible.in
+  out: 57-impossible.ans
+  points: 1
+- in: 58-impossible.in
+  out: 58-impossible.ans
+  points: 1
+- in: 59-manual-many-subsets.in
+  out: 59-manual-many-subsets.ans
+  points: 1
+- in: 60-manual-many-subsets.in
+  out: 60-manual-many-subsets.ans
+  points: 1
+- in: 61-manual-many-subsets.in
+  out: 61-manual-many-subsets.ans
+  points: 1
+- in: 62-manual-many-subsets.in
+  out: 62-manual-many-subsets.ans
+  points: 1
+- in: 63-manual-many-subsets.in
+  out: 63-manual-many-subsets.ans
+  points: 1
+- in: 64-manual-many-subsets.in
+  out: 64-manual-many-subsets.ans
+  points: 1
+- in: 65-manual-many-subsets.in
+  out: 65-manual-many-subsets.ans
+  points: 1
+- in: 66-manual-many-subsets.in
+  out: 66-manual-many-subsets.ans
+  points: 1
+- in: 67-manual-many-subsets.in
+  out: 67-manual-many-subsets.ans
+  points: 1
+- in: 68-manual-many-subsets.in
+  out: 68-manual-many-subsets.ans
+  points: 1
+- in: 69-manual-many-subsets.in
+  out: 69-manual-many-subsets.ans
+  points: 1
+- in: 70-manual-many-subsets.in
+  out: 70-manual-many-subsets.ans
+  points: 1
+- in: 71-manual-many-subsets.in
+  out: 71-manual-many-subsets.ans
+  points: 1

ICPC/nwerc2023_F/output_validators/output_validator/outputValidator.cpp

@@ -0,0 +1,84 @@
+
+#include<cstdlib>
+int qwerty_getcode(int code) {
+    return code == 42? 0: 1;
+}
+namespace std {
+    void qwerty_exit(int code){
+        exit(qwerty_getcode(code));
+    }
+} using std::qwerty_exit;
+#define exit qwerty_exit
+#define main qwerty_main
+#include "validate.h"
+
+std::pair<bool, std::string> isSubsequence(std::string_view x, std::string_view of) {
+	std::size_t i = 0;
+	std::string remain;
+	for (std::size_t j = 0; j < of.size(); j++) {
+		if (i < x.size() && x[i] == of[j]) i++;
+		else remain.push_back(of[j]);
+	}
+	std::sort(remain.begin(), remain.end());
+	return {i == x.size(), remain};
+}
+
+int main(int argc, char **argv) {
+	OutputValidator::init(argc, argv);
+	using namespace OutputValidator;
+
+	if (stringEqual(juryAns.string(), "impossible")) {
+		teamAns.expectString("impossible");
+		teamAns.newline();
+		teamAns.eof();
+		juryOut << "OK impossible" << AC;
+	} else {
+		teamAns.expectString("possible");
+		teamAns.newline();
+		std::string a = testIn.string();
+		std::string b = testIn.string();
+		Integer c = testIn.integer();
+		Integer d = testIn.integer();
+
+		std::string a2 = teamAns.string(INTEGER_REGEX);
+		teamAns.space();
+		std::string b2 = teamAns.string(INTEGER_REGEX);
+		teamAns.newline();
+
+		auto [ba, ra] = isSubsequence(a2, a);
+		auto [bb, rb] = isSubsequence(b2, b);
+
+		if (!ba) juryOut << "a' not generated by cancelling digits!" << WA;
+		if (!bb) juryOut << "b' not generated by cancelling digits!" << WA;
+		if (ra != rb) juryOut << ra << " != " << rb << ": cancelled digits are not the same" << WA;
+
+		Integer a3 = std::stoll(a2);
+		Integer b3 = std::stoll(b2);
+		if (a3 == 0 || b3 == 0 ||
+			mulMod(c, b3, 1'000'000'007) != mulMod(a3, d, 1'000'000'007) || //product of mods is larger than 10^18*10^18
+			mulMod(c, b3, 1'000'000'009) != mulMod(a3, d, 1'000'000'009) ||
+			mulMod(c, b3, 1'000'000'021) != mulMod(a3, d, 1'000'000'021) ||
+			mulMod(c, b3, 1'000'000'033) != mulMod(a3, d, 1'000'000'033)) {
+			juryOut << a << "/" << b << " != " << c << "/" << d << WA;
+		}
+
+		teamAns.eof();
+		juryOut << "OK possible" << AC;
+	}
+}
+
+#undef main
+#include<cstdio>
+#include<vector>
+#include<string>
+#include<filesystem>
+int main(int argc, char **argv) {
+	namespace fs = std::filesystem;
+    freopen(argv[2], "r", stdin);
+    char judge_out[] = "/dev";
+    std::vector<char*> new_argv = {
+		argv[0], argv[1], argv[3],
+		judge_out,
+	};
+	return qwerty_getcode(qwerty_main((int)new_argv.size(), new_argv.data()));
+}

ICPC/nwerc2023_F/output_validators/output_validator/validate.h

@@ -0,0 +1,2662 @@
+//============================================================================//
+// validate.h                                                                 //
+//============================================================================//
+// This header can be used to safely parse team output tokenwise. We support: //
+// - string tokens (get converted to lowercase)                               //
+// - integer tokens in [-2^63, 2^63)                                          //
+// - float tokens (relative and absolute error of 10^6 is allowed by default) //
+// Tokens need to be separated by whitespace (any amount). The following      //
+// command line flags allow stricter checking:                                //
+// - caseSensitive: string tokens don't get converted to lowercase            //
+// - space_change_sensitive: tokens need to be separated by the corect        //
+//   amount of whitespaces                                                    //
+// - FLOAT_{RELATIVE|ABSOLUTE}_TOLERANCE: allowed relative/absolute error     //
+//                                                                            //
+// This header can also be used to safely verify input files. In this case    //
+// tokens are case sensitive and all whitespaces have to be checked. Also     //
+// whitespaces are not interchangeable.                                       //
+//                                                                            //
+// This header can be used to generate random numbers in a deterministic and  //
+// reproducable fashion. (The randomness is consistent across compilers and   //
+// machines)                                                                  //
+//============================================================================//
+// version 2.3.2                                                              //
+// https://github.com/mzuenni/icpc-header                                     //
+//============================================================================//
+
+#ifndef VALIDATE_H
+#define VALIDATE_H
+
+#include <algorithm>
+#include <array>
+#include <bitset>
+#include <cctype>
+#include <cmath>
+#include <charconv>
+#include <complex>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <functional>
+#include <iomanip>
+#include <iostream>
+#include <limits>
+#include <map>
+#include <numeric>
+#include <optional>
+#include <queue>
+#include <random>
+#include <regex>
+#include <set>
+#include <string>
+#include <string_view>
+#include <typeinfo>
+#include <typeindex>
+#include <type_traits>
+#include <utility>
+#include <variant>
+#include <vector>
+
+
+//============================================================================//
+// Basic definitions and constants                                            //
+//============================================================================//
+// default types
+using Integer = std::int64_t;
+using Real = long double;
+
+// derived types
+using UInteger = std::make_unsigned<Integer>::type;
+constexpr Integer operator ""_int(unsigned long long int value) {return static_cast<Integer>(value);}
+constexpr UInteger operator ""_uint(unsigned long long int value) {return static_cast<UInteger>(value);}
+constexpr Real operator ""_real(unsigned long long int value) {return static_cast<Real>(value);}
+constexpr Real operator ""_real(long double value) {return static_cast<Real>(value);}
+
+// settings which can be overwritten before the include!
+//#define DOUBLE_FALLBACK
+namespace Settings {
+	namespace details {
+		using RandomEngine                              = std::mt19937_64;
+		constexpr Integer LARGE                         = 0x3FFF'FFFF'FFFF'FFFF;
+		constexpr bool DEFAULT_CASE_LOWER               = true;
+		constexpr int DEFAULT_PRECISION                 = 6;
+		constexpr Real DEFAULT_EPS                      = 1e-6_real;
+
+		[[noreturn]] void exitVerdict(int exitCode) {
+			//throw exitCode;
+			//quick_exit(exitCode);
+			std::exit(exitCode);
+		}
+	}
+	using namespace details;
+}
+// make settings publically available
+using Settings::RandomEngine;
+using Settings::LARGE;
+using Settings::DEFAULT_CASE_LOWER;
+using Settings::DEFAULT_PRECISION;
+using Settings::DEFAULT_EPS;
+using Settings::exitVerdict;
+
+// useful constants
+constexpr std::string_view LETTER                       = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+constexpr std::string_view UPPER                        = LETTER.substr(0, 26);
+constexpr std::string_view LOWER                        = LETTER.substr(26);
+constexpr std::string_view VOWEL                        = "AEIOUaeiou";
+constexpr std::string_view UPPER_VOWELS                 = VOWEL.substr(0, 5);
+constexpr std::string_view LOWER_VOWELS                 = VOWEL.substr(5);
+constexpr std::string_view CONSONANT                    = "BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz";
+constexpr std::string_view UPPER_CONSONANT              = CONSONANT.substr(0, 26 - 5);
+constexpr std::string_view LOWER_CONSONANT              = CONSONANT.substr(26 - 5);
+constexpr std::string_view ALPHA_NUMERIC                = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+constexpr std::string_view UPPER_ALPHA_NUMERIC          = ALPHA_NUMERIC.substr(0, 10 + 26);
+constexpr std::string_view LOWER_ALPHA_NUMERIC          = "0123456789abcdefghijklmnopqrstuvwxyz";
+constexpr std::string_view DIGITS                       = ALPHA_NUMERIC.substr(0, 10);
+constexpr std::string_view BRACKETS                     = "()[]{}<>";
+constexpr char NEWLINE                                  = '\n';
+constexpr char SPACE                                    = ' ';
+constexpr char NOSEP                                    = '\0';
+constexpr Real PI                                       = 3.1415926535897932384626433832795028_real;
+
+
+//============================================================================//
+// internal definitions and constants                                         //
+//============================================================================//
+constexpr UInteger DEFAULT_SEED                         = 3141592653589793238_uint;
+constexpr std::string_view CASE_SENSITIVE               = "case_sensitive";
+constexpr std::string_view SPACE_SENSITIVE              = "space_change_sensitive";
+constexpr std::string_view FLOAT_ABSOLUTE_TOLERANCE     = "float_absolute_tolerance";
+constexpr std::string_view FLOAT_RELATIVE_TOLERANCE     = "float_relative_tolerance";
+constexpr std::string_view FLOAT_TOLERANCE              = "float_tolerance";
+constexpr std::string_view JUDGE_MESSAGE                = "null";
+constexpr char DEFAULT_SEPARATOR                        = SPACE;
+constexpr std::string_view EMPTY_COMMAND                = "";
+constexpr std::string_view COMMAND_PREFIX               = "--";
+constexpr std::string_view CONSTRAINT_COMMAND           = "--constraints_file";
+constexpr std::string_view SEED_COMMAND                 = "--seed";
+constexpr auto REGEX_OPTIONS                            = std::regex::nosubs | std::regex::optimize;
+inline const std::regex INTEGER_REGEX("0|-?[1-9][0-9]*", REGEX_OPTIONS);
+inline const std::regex REAL_REGEX("-?(0|([1-9][0-9]*))(\\.[0-9]*)?([eE][+-]?(0|([1-9][0-9]*)))?", REGEX_OPTIONS);
+inline const std::regex STRICT_REAL_REGEX("-?(0|([1-9][0-9]*))\\.?[0-9]*", REGEX_OPTIONS);
+
+static_assert(2'000'000'000'000'000'000_int < LARGE / 2, "LARGE too small");
+static_assert(LARGE <= std::numeric_limits<Integer>::max() / 2, "LARGE too big");
+
+static_assert(-1 == 0xFFFF'FFFF'FFFF'FFFF_int, "Two's complement for signed numbers is required" );
+static_assert(std::is_convertible_v<Integer, UInteger>, "Incompatible Integer and UInteger types?!");
+static_assert(std::is_convertible_v<UInteger, Integer>, "Incompatible Integer and UInteger types?!");
+static_assert(sizeof(Integer) == sizeof(UInteger), "Incompatible Integer and UInteger types?!");
+
+template<typename T = std::logic_error>
+constexpr void judgeAssert(bool asserted, std::string_view message) {
+	if (!asserted) throw T(message.data());
+}
+
+
+//============================================================================//
+// SFINAE                                                                     //
+//============================================================================//
+namespace details {
+	template<typename T, typename = void>
+	struct IsContainer : std::false_type {};
+
+	template<typename T>
+	struct IsContainer<T, std::void_t<decltype(std::begin(std::declval<std::add_lvalue_reference_t<T>>()))>> : std::true_type {
+		using iterator_type = decltype(std::begin(std::declval<std::add_lvalue_reference_t<T>>()));
+		using value_type = std::remove_reference_t<decltype(*std::begin(std::declval<std::add_lvalue_reference_t<T>>()))>;
+	};
+
+	template<typename T>
+	struct IsStdArray : std::false_type {};
+
+	template<typename T, std::size_t N>
+	struct IsStdArray<std::array<T, N>> : std::true_type {};
+
+	template<typename T, typename = void>
+	struct IsTupleLike : std::false_type {};
+
+	template<typename T>
+	struct IsTupleLike<T, std::void_t<decltype(sizeof(std::tuple_size<T>))>> : std::true_type {};
+
+	template<typename T, typename = void>
+	struct HasOstreamOperator : std::false_type {};
+
+	template<typename T>
+	struct HasOstreamOperator<T, std::void_t<decltype(std::declval<std::ostream>() << std::declval<T>())>> : std::true_type {};
+}
+
+
+//============================================================================//
+// Verdicts                                                                   //
+//============================================================================//
+struct Verdict final {
+	int exitCode;
+
+	constexpr explicit Verdict(int exitCode_ = 1) : exitCode(exitCode_) {}
+
+	constexpr operator int() const {
+		return exitCode;
+	}
+
+	[[noreturn]] void exit() const {
+		exitVerdict(exitCode);
+	}
+
+	friend void operator<<(std::ostream& os, const Verdict& v) {
+		os << std::endl;
+		v.exit();
+	}
+};
+
+// default verdicts (we do not support scoring)
+constexpr Verdict AC(42);
+constexpr Verdict WA(43);
+constexpr Verdict PE = WA;
+constexpr Verdict FAIL(1);
+
+
+//============================================================================//
+// Output streams                                                             //
+//============================================================================//
+class NullStream final : public std::ostream {
+	class NullBuffer final : public std::streambuf {
+	protected:
+		std::streamsize xsputn(const char* /**/, std::streamsize n) override {
+			return n;
+		}
+		int overflow(int c = std::char_traits<char>::eof()) override {
+			return std::char_traits<char>::not_eof(c);
+		}
+	} nullBuffer;
+public:
+	NullStream() : std::ostream(&nullBuffer) {}
+};
+
+namespace details {
+	NullStream nullStream;
+}
+
+class OutputStream final {
+	std::unique_ptr<std::ofstream> managed;
+	std::ostream* os;
+
+	void init() {
+		*os << std::boolalpha;
+		*os << std::fixed;
+		*os << std::setprecision(DEFAULT_PRECISION);
+	}
+
+public:
+	OutputStream() : os(&details::nullStream) {}
+	OutputStream(std::ostream& os_) : os(&os_) {init();}
+	explicit OutputStream(const std::filesystem::path& path) : managed(std::make_unique<std::ofstream>(path)), os(managed.get()) {
+		judgeAssert<std::runtime_error>(managed->good(), "OutputStream: Could not open File: " + path.string());
+		init();
+	}
+
+	OutputStream(OutputStream&& other) = default;
+	OutputStream& operator=(OutputStream&& other) = default;
+
+	OutputStream(const OutputStream&) = delete;
+	OutputStream& operator=(const OutputStream&) = delete;
+
+
+	template<typename L, typename R>
+	OutputStream& operator<<(const std::pair<L, R>& t) {
+		return *this << t.first << DEFAULT_SEPARATOR << t.second;
+	}
+
+	template<typename... Args>
+	OutputStream& operator<<(const std::tuple<Args...>& t) {
+		return join(t, std::index_sequence_for<Args...>(), DEFAULT_SEPARATOR);
+	}
+
+	template<typename T>
+	OutputStream& operator<<(const T& x) {
+		if constexpr ((std::is_array_v<T> and !std::is_same_v<std::decay_t<T>, char*>) or
+		              (details::IsContainer<T>{} and !details::HasOstreamOperator<T>{})) {
+			return join(std::begin(x), std::end(x), DEFAULT_SEPARATOR);
+		} else {
+			*os << x;
+			return *this;
+		}
+	}
+
+	OutputStream& operator<<(std::ostream& (*manip)(std::ostream&)) {
+		*os << manip;
+		return *this;
+	}
+
+	template<typename Tuple, std::size_t... Is>
+	OutputStream& join(const Tuple& t, std::index_sequence<Is...> /**/, char separator) {
+		static_assert(std::tuple_size_v<Tuple> == sizeof...(Is));
+		if (separator != NOSEP) ((*os << (Is == 0 ? std::string_view() : std::string_view(&separator, 1)), *this << std::get<Is>(t)), ...);
+		else ((*this << std::get<Is>(t)), ...);
+		return *this;
+	}
+
+	template<typename T>
+	OutputStream& join(T first, T last, char separator) {
+		for (auto it = first; it != last; it++) {
+			if (it != first and separator != NOSEP) *os << separator;
+			*this << *it;
+		}
+		return *this;
+	}
+};
+
+namespace ValidateBase {
+	// define this early so everyone can use it!
+	OutputStream juryErr(std::cerr);
+	OutputStream juryOut(std::cout);
+}
+
+// allow printing colletions as:
+// join(begin(), end(), [sep])
+namespace details {
+	template<typename C>
+	class TempWriter final {
+		C callable;
+	public:
+		constexpr explicit TempWriter(const C& callable_) : callable(callable_) {}
+
+		TempWriter(const TempWriter&) = delete;
+		TempWriter(TempWriter&&) = delete;
+		TempWriter& operator=(const TempWriter&) = delete;
+		TempWriter& operator=(TempWriter&&) = delete;
+
+		std::string asString() const {
+			std::ostringstream os;
+			OutputStream tmp(os);
+			tmp << *this;
+			return os.str();
+		}
+
+		explicit operator std::string() const {
+			return asString();
+		}
+
+		friend OutputStream& operator<<(OutputStream& os, const TempWriter<C>& writer) {
+			writer.callable(os);
+			return os;
+		}
+
+		friend OutputStream& operator<<(std::ostream& os, const TempWriter<C>& writer) = delete; //news OutputStream
+	};
+
+	struct JoinListCapture {
+		std::function<void(OutputStream&, char separator)> callable;
+
+		template<typename... Args>
+		JoinListCapture(Args&&... args)
+			: callable([t = std::forward_as_tuple(args...)](OutputStream& os, char separator) {
+			os.join(t, std::index_sequence_for<Args...>(), separator);
+		}) {}
+	};
+}
+
+template<typename T>
+constexpr auto join(T first, T last, char separator = DEFAULT_SEPARATOR) {
+	return details::TempWriter([=](OutputStream& os) {
+		os.join(first, last, separator);
+	});
+}
+
+template<typename CR,
+         typename = std::enable_if_t<details::IsContainer<CR>{}>,
+         typename = std::enable_if_t<!details::IsStdArray<std::remove_cv_t<std::remove_reference_t<CR>>>{}>>
+constexpr auto join(CR&& c, char separator = DEFAULT_SEPARATOR) {
+	if constexpr(std::is_rvalue_reference_v<CR&&>) {
+		if constexpr (std::is_array_v<CR>) {
+			return details::TempWriter([c, separator](OutputStream& os) {
+				os.join(std::begin(c), std::end(c), separator);
+			});
+		} else {
+			return details::TempWriter([c = std::move(c), separator](OutputStream& os) {
+				os.join(std::begin(c), std::end(c), separator);
+			});
+		}
+	} else {
+		return join(std::begin(c), std::end(c), separator);
+	}
+}
+
+template<typename CR, std::size_t N = std::tuple_size<std::decay_t<CR>>::value>
+constexpr auto join(CR&& c, char separator = DEFAULT_SEPARATOR) {
+	if constexpr(std::is_rvalue_reference_v<CR&&>) {
+		return details::TempWriter([c = std::move(c), separator](OutputStream& os) {
+			os.join(c, std::make_index_sequence<N>{}, separator);
+		});
+	} else {
+		return details::TempWriter([&c, separator](OutputStream& os) {
+			os.join(c, std::make_index_sequence<N>{}, separator);
+		});
+	}
+}
+
+template<typename T, std::size_t N,
+         typename = std::enable_if_t<std::is_same_v<std::remove_cv_t<T>, char>>>
+constexpr auto join(T (&c)[N], char separator = DEFAULT_SEPARATOR) {
+	static_assert(N > 0, "c-strings should be null terminated!");
+	return join(std::begin(c), std::prev(std::end(c)), separator);
+}
+
+template<typename T, std::size_t N,
+         typename = std::enable_if_t<std::is_same_v<std::remove_cv_t<T>, char>>>
+constexpr auto join(T (&&c)[N], char separator = DEFAULT_SEPARATOR) {
+	static_assert(N > 0, "c-strings should be null terminated!");
+	return details::TempWriter([c, separator](OutputStream& os) {
+		os.join(std::begin(c), std::prev(std::end(c)), separator);
+	});
+}
+
+template<typename T,
+         typename = std::enable_if_t<!std::is_array<T>{}>,
+         typename = std::enable_if_t<!details::IsContainer<T>{}>,
+         typename = std::enable_if_t<!details::IsTupleLike<T>{}>>
+constexpr auto join(const T& t, char separator = DEFAULT_SEPARATOR) = delete;
+
+auto join(details::JoinListCapture c, char separator = DEFAULT_SEPARATOR) {
+	return details::TempWriter([c = std::move(c), separator](OutputStream& os) {
+		c.callable(os, separator);
+	});
+}
+
+
+//============================================================================//
+// Basic datastructures                                                       //
+//============================================================================//
+// make usage of std::priority_queue easier...
+namespace details {
+	template<typename T, typename Compare = std::less<T>>
+	struct invertCompare {
+		constexpr bool operator()(const T &lhs, const T &rhs) const {
+			return Compare{}(rhs, lhs);
+		}
+	};
+}
+template<typename T, typename Compare = std::less<T>>
+using MinPQ = std::priority_queue<T, std::vector<T>, details::invertCompare<T, Compare>>;
+template<typename T, typename Compare = std::less<T>>
+using MaxPQ = std::priority_queue<T, std::vector<T>, Compare>;
+
+template<typename C, typename K>
+bool contains(const C& container, const K& key) {
+	return container.find(key) != container.end();
+}
+
+template<typename C1, typename C2>
+void append(C1& c1, const C2& c2) {
+	static_assert(std::is_same_v<typename details::IsContainer<C1>::value_type,
+	                             typename details::IsContainer<C2>::value_type>, "cannot append container of different value type!");
+	if (static_cast<const void*>(&c1) != static_cast<const void*>(&c2)) {
+		for (auto&& e : c2) c1.emplace(c1.end(), e);
+	} else {
+		C2 tmp = c2;
+		for (auto&& e : tmp) c1.emplace(c1.end(), e);
+	}
+}
+
+template<typename C1, std::size_t N>
+void append(C1& c1, const typename C1::value_type(&c2)[N]) {
+	for (auto&& e : c2) c1.emplace(c1.end(), e);
+}
+
+struct shorter {
+	template<typename U, typename V>
+	bool operator()(const U& a, const V& b) const {
+		return std::size(a) < std::size(b);
+	}
+};
+
+struct longer {
+	template<typename U, typename V>
+	bool operator()(const U& a, const V& b) const {
+		return std::size(b) < std::size(a);
+	}
+};
+
+namespace details {
+	template<typename T, typename = void>
+	struct Flatten {using value_type = T;};
+
+	template<typename T>
+	struct Flatten<T, std::enable_if_t<IsContainer<T>{}>> : Flatten<typename IsContainer<T>::value_type> {};
+
+	template<typename CR, typename V>
+	void flatAppend(CR&& c, std::vector<V>& res) {
+		using C = std::remove_reference_t<CR>;
+		if constexpr(std::is_same_v<C, V>) {
+			res.emplace_back(std::forward<CR>(c));
+		} else if constexpr (!IsContainer<C>{}) {
+			static_assert(IsContainer<C>{}, "invalid base type for flatten()!");
+		} else {
+			if constexpr (std::is_rvalue_reference_v<CR&&>) {
+				for (auto&& v : c) flatAppend(std::move(v), res);
+			} else {
+				for (auto&& v : c) flatAppend(v, res);
+			}
+		}
+	}
+}
+
+template<typename R, typename CR>
+auto flatten(CR&& c) {
+	std::vector<R> res;
+	details::flatAppend(std::forward<CR>(c), res);
+	return res;
+}
+
+template<typename CR>
+auto flatten(CR&& c) {
+	using C = std::remove_reference_t<CR>;
+	return flatten<typename details::Flatten<C>::value_type, CR>(std::forward<CR>(c));
+}
+
+template<typename T>
+struct boolean {
+	bool value;
+	std::optional<T> reason;
+
+	constexpr boolean(bool value_) : value(value_) {}
+	constexpr boolean(bool value_, const T& reason_) : value(value_), reason(reason_) {}
+
+	constexpr operator bool() const {
+		return value;
+	}
+
+	constexpr bool hasReason() const {
+		return reason.has_value();
+	}
+};
+
+
+//============================================================================//
+// Utility                                                                    //
+//============================================================================//
+// for sequences
+template<typename RandomIt,
+         typename = std::enable_if_t<std::is_integral_v<typename std::iterator_traits<RandomIt>::value_type>>>
+auto isPerm(RandomIt first, RandomIt last, typename std::iterator_traits<RandomIt>::value_type offset = 0) {
+	using T = typename std::iterator_traits<RandomIt>::value_type;
+	auto count = std::distance(first, last);
+	std::vector<bool> seen(count, false);
+	for (; first != last; first++) {
+		const T& x = *first;
+		if (x < offset or x - offset >= count or seen[x - offset]) {
+			return boolean<T>(false, x);
+		}
+		seen[x - offset] = true;
+	}
+	return boolean<T>(true);
+}
+template<typename C, typename std::enable_if_t<std::is_integral_v<typename details::IsContainer<C>::value_type>, bool> = true>
+auto isPerm(const C& c, typename details::IsContainer<C>::value_type offset = 0) {
+	return isPerm(std::begin(c), std::end(c), offset);
+}
+
+template<typename itA, typename itB>
+auto isPerm(itA firstA, itA lastA, itB firstB, itB lastB) {
+	using T = typename std::iterator_traits<itA>::value_type;
+	std::vector<typename std::iterator_traits<itA>::value_type> a(firstA, lastA);
+	std::vector<typename std::iterator_traits<itB>::value_type> b(firstB, lastB);
+	if (a.size() != b.size()) return boolean<T>(false);
+	std::sort(a.begin(), a.end());
+	std::sort(b.begin(), b.end());
+	for (std::size_t i = 0; i < a.size(); i++) {
+		if (a[i] != b[i]) return boolean<T>(false, a[i]);
+	}
+	return boolean<T>(true);
+}
+template<typename C1,
+         typename C2,
+         typename = std::enable_if_t<details::IsContainer<C1>{}>,
+         typename = std::enable_if_t<details::IsContainer<C2>{}>>
+auto isPerm(const C1& c1, const C2& c2) {
+	return isPerm(std::begin(c1), std::end(c1), std::begin(c2), std::end(c2));
+}
+
+template<typename RandomIt, typename BinaryPredicate>
+constexpr boolean<Integer> anyAdjacent(RandomIt first, RandomIt last, BinaryPredicate p) {
+	if (first != last) {
+		for (Integer i = 1; std::next(first) != last; first++, i++) {
+			if (p(*first, *std::next(first))) {
+				return boolean<Integer>(true, i);
+			}
+		}
+	}
+	return boolean<Integer>(false);
+}
+template<typename C, typename BinaryPredicate>
+constexpr boolean<Integer> anyAdjacent(const C& c, BinaryPredicate p) {
+	return anyAdjacent(std::begin(c), std::end(c), p);
+}
+
+template<typename RandomIt, typename BinaryPredicate>
+constexpr boolean<Integer> noneAdjacent(RandomIt first, RandomIt last, BinaryPredicate p) {
+	auto res = anyAdjacent(first, last, p);
+	res.value = !res.value;
+	return res;
+}
+template<typename C, typename BinaryPredicate>
+constexpr boolean<Integer> noneAdjacent(const C& c, BinaryPredicate p) {
+	return noneAdjacent(std::begin(c), std::end(c), p);
+}
+
+template<typename RandomIt, typename BinaryPredicate>
+constexpr boolean<Integer> allAdjacent(RandomIt first, RandomIt last, BinaryPredicate p) {
+	return noneAdjacent(first, last, std::not_fn(p));
+}
+template<typename C, typename BinaryPredicate>
+constexpr boolean<Integer> allAdjacent(const C& c, BinaryPredicate p) {
+	return noneAdjacent(std::begin(c), std::end(c), p);
+}
+
+template<typename RandomIt>
+constexpr boolean<Integer> areIncreasing(RandomIt first, RandomIt last) {
+	using T = typename std::iterator_traits<RandomIt>::value_type;
+	return allAdjacent(first, last, std::less<T>());
+}
+template<typename C>
+constexpr boolean<Integer> areIncreasing(const C& c) {
+	return areIncreasing(std::begin(c), std::end(c));
+}
+
+template<typename RandomIt>
+constexpr boolean<Integer> areNonDecreasing(RandomIt first, RandomIt last) {
+	using T = typename std::iterator_traits<RandomIt>::value_type;
+	return allAdjacent(first, last, std::less_equal<T>());
+}
+template<typename C>
+constexpr boolean<Integer> areNonDecreasing(const C& c) {
+	return areNonDecreasing(std::begin(c), std::end(c));
+}
+
+template<typename RandomIt>
+constexpr boolean<Integer> areDecreasing(RandomIt first, RandomIt last) {
+	using T = typename std::iterator_traits<RandomIt>::value_type;
+	return allAdjacent(first, last, std::greater<T>());
+}
+template<typename C>
+constexpr boolean<Integer> areDecreasing(const C& c) {
+	return areDecreasing(std::begin(c), std::end(c));
+}
+
+template<typename RandomIt>
+constexpr boolean<Integer> areNonIncreasing(RandomIt first, RandomIt last) {
+	using T = typename std::iterator_traits<RandomIt>::value_type;
+	return allAdjacent(first, last, std::greater_equal<T>());
+}
+template<typename C>
+constexpr boolean<Integer> areNonIncreasing(const C& c) {
+	return areNonIncreasing(std::begin(c), std::end(c));
+}
+
+template<typename RandomIt>
+constexpr auto areDistinct(RandomIt first, RandomIt last) {
+	using T = typename std::iterator_traits<RandomIt>::value_type;
+	std::vector<T> tmp(first, last);
+	std::sort(tmp.begin(), tmp.end());
+	auto [b, v] = anyAdjacent(tmp, std::equal_to<T>());
+	if (v) return boolean<T>(!b, tmp[*v]);
+	return boolean<T>(!b);
+}
+template<typename C>
+constexpr auto areDistinct(const C& c) {
+	return areDistinct(std::begin(c), std::end(c));
+}
+
+
+// for strings (cctype functions are not safe to use with char...)
+constexpr bool isLower(char c) {
+	return c >= 'a' and c <= 'z';
+}
+
+constexpr bool isUpper(char c) {
+	return c >= 'A' and c <= 'Z';
+}
+
+constexpr bool isLetter(char c) {
+	return isLower(c) or isUpper(c);
+}
+
+constexpr bool isDigit(char c) {
+	return c >= '0' and c <= '9';
+}
+
+constexpr char toLower(char c) {
+	if (isUpper(c)) c += 'a' - 'A';
+	return c;
+}
+
+constexpr bool isVowel(char c) {
+	c = toLower(c);
+	for (char x : LOWER_VOWELS) {
+		if (c == x) return true;
+	}
+	return false;
+}
+
+constexpr bool isConsonant(char c) {
+	return isLetter(c) and !isVowel(c);
+}
+
+constexpr char toUpper(char c) {
+	if (isLower(c)) c -= 'a' - 'A';
+	return c;
+}
+
+constexpr char toDefaultCase(char c) {
+	if constexpr (DEFAULT_CASE_LOWER) return toLower(c);
+	return toUpper(c);
+}
+
+void toLower(std::string& s) {
+	for (char& c : s) c = toLower(c);
+}
+
+void toUpper(std::string& s) {
+	for (char& c : s) c = toUpper(c);
+}
+
+void toDefaultCase(std::string& s) {
+	if constexpr (DEFAULT_CASE_LOWER) return toLower(s);
+	return toUpper(s);
+}
+
+constexpr bool isLower(std::string_view s) {
+	for (char c : s) if (!isLower(c)) return false;
+	return true;
+}
+
+constexpr boolean<char> isUpper(std::string_view s) {
+	for (char c : s) if (!isUpper(c)) return boolean<char>(false, c);
+	return boolean<char>(true);
+}
+
+constexpr boolean<char> isLetter(std::string_view s) {
+	for (char c : s) if (!isLetter(c)) return boolean<char>(false, c);
+	return boolean<char>(true);
+}
+
+constexpr boolean<char> isDigit(std::string_view s) {
+	for (char c : s) if (!isDigit(c)) return boolean<char>(false, c);
+	return boolean<char>(true);
+}
+
+constexpr boolean<char> isVowel(std::string_view s) {
+	for (char c : s) if (!isVowel(c)) return boolean<char>(false, c);
+	return boolean<char>(true);
+}
+
+constexpr boolean<char> isConsonant(std::string_view s) {
+	for (char c : s) if (!isConsonant(c)) return boolean<char>(false, c);
+	return boolean<char>(true);
+}
+
+std::vector<Integer> thueMorse(Integer lower, Integer upper) {
+	judgeAssert<std::invalid_argument>(lower < upper, "thueMorse(): Lower must be less than upper!");
+	std::vector<Integer> res(upper - lower);
+	for (Integer i = lower; i < upper; i++) {
+		res[i] = std::bitset<64>(i).count() % 2;
+	}
+	return res;
+}
+
+std::vector<Integer> thueMorse(Integer upper) {
+	return thueMorse(0, upper);
+}
+
+// allow using std::pair and std::complex similiar
+// (may be useful for geometric problem)
+template<typename T>
+constexpr auto& getX(T& point) {
+	return std::get<0>(point);
+}
+template<typename T>
+constexpr auto& getY(T& point) {
+	return std::get<1>(point);
+}
+template<typename T>
+constexpr auto& getZ(T& point) {
+	return std::get<2>(point);
+}
+template<typename T>
+constexpr auto getX(const T& point) {
+	return std::get<0>(point);
+}
+template<typename T>
+constexpr auto getY(const T& point) {
+	return std::get<1>(point);
+}
+template<typename T>
+constexpr auto getZ(const T& point) {
+	return std::get<2>(point);
+}
+
+template<typename T>
+constexpr auto& getX(std::complex<T>& point) {
+	return reinterpret_cast<T(&)[2]>(point)[0];
+}
+template<typename T>
+constexpr auto& getY(std::complex<T>& point) {
+	return reinterpret_cast<T(&)[2]>(point)[1];
+}
+template<typename T>
+constexpr auto getX(const std::complex<T>& point) {
+	return reinterpret_cast<const T(&)[2]>(point)[0];
+}
+template<typename T>
+constexpr auto getY(const std::complex<T>& point) {
+	return reinterpret_cast<const T(&)[2]>(point)[1];
+}
+
+template<typename T>
+constexpr std::pair<T,T> convert(const std::complex<T>& t) {
+	return {getX(t), getY(t)};
+}
+
+template<typename L, typename R>
+constexpr std::complex<typename std::common_type<L, R>::type>
+convert(const std::pair<L,R>& t) {
+	return {getX(t), getY(t)};
+}
+
+
+namespace details {
+	// Test two numbers for equality, accounting for +/-INF, NaN and precision.
+	// Real expected is considered the reference value for relative error.
+	bool floatEqual(Real given, Real expected, Real floatAbsTol, Real floatRelTol) {
+		judgeAssert<std::domain_error>(floatAbsTol >= 0.0_real, "floatEqual(): floatAbsTol must be positive!");
+		judgeAssert<std::domain_error>(floatRelTol >= 0.0_real, "floatEqual(): floatRelTol must be positive!");
+		// Finite values are compared with some tolerance
+		if (std::isfinite(given) and std::isfinite(expected)) {
+			Real absDiff = std::abs(given-expected);
+			Real relDiff = std::abs((given-expected)/expected);
+			return absDiff <= floatAbsTol or relDiff <= floatRelTol;
+		}
+		// NaN is equal to NaN (-NaN is also equal NaN)
+		if (std::isnan(given) and std::isnan(expected)) {
+			return true;
+		}
+		// Infinite values are equal if their sign matches
+		if (std::isinf(given) and std::isinf(expected)) {
+			return std::signbit(given) == std::signbit(expected);
+		}
+		// Values in different classes are always different.
+		return false;
+	}
+
+	constexpr boolean<std::size_t> stringEqual(std::string_view a, std::string_view b, bool caseSensitive) {
+		std::size_t i = 0;
+		for (; i < a.size() and i < b.size(); i++) {
+			char aa = a[i];
+			char bb = b[i];
+			if (!caseSensitive) {
+				aa = toDefaultCase(aa);
+				bb = toDefaultCase(bb);
+			}
+			if (aa != bb) {
+				return boolean<std::size_t>(false, i);
+			}
+		}
+		if (a.size() != b.size()) {
+			return boolean<std::size_t>(false, i);
+		} else {
+			return boolean<std::size_t>(true);
+		}
+	}
+
+	constexpr bool isToken(std::string_view a) {
+		for (char c : a) {
+			if (c == ' ') return false;
+			if (c == '\n') return false;
+			if (c == '\r') return false;
+			if (c == '\t') return false;
+			if (c == '\f') return false;
+			if (c == '\v') return false;
+		}
+		return true;
+	}
+
+	template<typename T>
+	bool parse(std::string_view s, T& res) {
+		const char* begin = s.data();
+		const char* end = s.data() + s.size();
+		auto [ptr, ec] = std::from_chars(begin, end, res);
+		return ptr == end and ec == std::errc();
+	}
+	#ifdef DOUBLE_FALLBACK
+	template<>
+	bool parse(std::string_view s, Real& res) {
+		try {
+			std::size_t pos = 0;
+			res = std::stold(std::string(s), &pos);
+			return pos == s.size();
+		} catch(...) {
+			return false;
+		}
+	}
+	#endif
+
+}
+
+
+//============================================================================//
+// Math                                                                       //
+//============================================================================//
+namespace details {
+	constexpr std::array<Integer, 32> TRIAL_PRIMES = {
+		 2,  3,  5,  7, 11, 13, 17, 19, 23,  29,  31,  37,  41,  43,  47,  53,
+		59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131,
+	};
+	constexpr std::array<UInteger, 7> MILLER_RABIN_WITNESS = {2, 325, 9375, 28178, 450775, 9780504, 1795265022};
+
+	// these operations are safe as long as the value would fit in Integer
+	constexpr UInteger mulMod(UInteger lhs, UInteger rhs, UInteger mod) {
+		UInteger res = 0;
+		while (rhs > 0) {
+			if (rhs & 1) res = (lhs + res) % mod;
+			lhs = (lhs + lhs) % mod;
+			rhs /= 2;
+		}
+		return res;
+	}
+
+	constexpr UInteger powMod(UInteger base, UInteger exp, UInteger mod) {
+		UInteger res = 1;
+		if (mod <= 0x1'0000'0000) {
+			while (exp > 0) {
+				if (exp & 1) res = (base * res) % mod;
+				base = (base * base) % mod;
+				exp /= 2;
+			}
+		} else {
+			while (exp > 0) {
+				if (exp & 1) res = mulMod(base, res, mod);
+				base = mulMod(base, base, mod);
+				exp /= 2;
+			}
+		}
+		return res;
+	}
+
+	constexpr Integer extendedEuclid(Integer a, Integer b, Integer& x, Integer& y) {
+		if (a == 0) {
+			x = 0;
+			y = 1;
+			return b;
+		} else {
+			Integer x1 = 0;
+			Integer y1 = 0;
+			Integer d = extendedEuclid(b % a, a, x1, y1);
+			x = y1 - (b / a) * x1;
+			y = x1;
+			return d;
+		}
+	}
+}
+
+constexpr Integer applyMod(Integer x, Integer mod) {
+	x %= mod;
+	if (x < 0) x += mod;
+	return x;
+}
+
+constexpr Integer mulMod(Integer lhs, Integer rhs, Integer mod) {
+	judgeAssert<std::domain_error>(mod > 0, "mulMod(): mod must be positive!");
+	UInteger ul = static_cast<UInteger>(applyMod(lhs, mod));
+	UInteger ur = static_cast<UInteger>(applyMod(rhs, mod));
+	UInteger um = static_cast<UInteger>(mod);
+	return static_cast<Integer>(details::mulMod(ul, ur, um));
+}
+
+constexpr Integer powMod(Integer base, Integer exp, Integer mod) {
+	judgeAssert<std::domain_error>(mod > 0, "powMod(): mod must be positive!");
+	judgeAssert<std::domain_error>(exp >= 0, "powMod(): exp must be non negative!");
+	UInteger ub = static_cast<UInteger>(applyMod(base, mod));
+	UInteger ue = static_cast<UInteger>(exp);
+	UInteger um = static_cast<UInteger>(mod);
+	return static_cast<Integer>(details::powMod(ub, ue, um));
+}
+
+constexpr Integer multInv(Integer n, Integer mod) {
+	judgeAssert<std::domain_error>(mod > 0, "multInv(): mod must be positive!");
+	Integer x = 0;
+	Integer y = 0;
+	Integer g = details::extendedEuclid(n, mod, x, y);
+	if (g != 1) return -1;
+	else return applyMod(x, mod);
+}
+
+constexpr bool isPrime(Integer n) {
+	for (Integer p : details::TRIAL_PRIMES) {
+		if (n <= p or n % p == 0) {
+			return n == p;
+		}
+	}
+	if (details::powMod(details::TRIAL_PRIMES.back() + 1, n - 1, n) != 1) {
+		return false;
+	}
+	UInteger un = static_cast<UInteger>(n);
+	UInteger d = un - 1;
+	UInteger j = 0;
+	while (d % 2 == 0) {
+		d /= 2;
+		j++;
+	}
+	for (UInteger a : details::MILLER_RABIN_WITNESS) {
+		if (a % un == 0) continue;
+		UInteger v = details::powMod(a, d, un);
+		if (v == 1 or v == un - 1) continue;
+		for (UInteger i = 1; i < j; i++) {
+			v = details::mulMod(v, v, un);
+			if (v == un - 1 or v <= 1) break;
+		}
+		if (v != un - 1) return false;
+	}
+	return true;
+}
+
+std::vector<Integer> primes(Integer lower, Integer upper) {
+	judgeAssert<std::invalid_argument>(lower < upper, "primes(): Lower must be less than upper!");
+	lower = std::max<Integer>(2, lower);
+	upper = std::max<Integer>(2, upper);
+	Integer count = upper - lower;
+	Integer cache = (count + 1) / 2;
+
+	std::vector<bool> notPrime(cache), notPrimeSegment(cache);
+	for (Integer i = 3; i < count; i += 2) {
+		if (!notPrime[i / 2]) {
+			for (Integer j = i * i; j < count; j += 2 * i) {
+				notPrime[j / 2] = true;
+			}
+			Integer lowest = lower - (lower % (2*i)) + i;
+			if (lowest < lower) lowest += 2*i;
+			for (Integer j = std::max(i * i, lowest); j < upper; j += 2 * i) {
+				notPrimeSegment[(j - lower) / 2] = true;
+			}
+		}
+	}
+	std::vector<Integer> res;
+	if (lower <= 2 and 2 < upper) res.emplace_back(2);
+	for (Integer i = lower | 1; i < upper; i += 2) {
+		if (!notPrimeSegment[(i - lower) / 2] and (i < count*count or isPrime(i))) {
+			res.emplace_back(i);
+		}
+	}
+	return res;
+}
+
+std::vector<Integer> primes(Integer upper) {
+	return primes(0, upper);
+}
+
+template<typename T>
+constexpr Integer sign(T x) {
+	return (T(0) < x) - (x < T(0));
+}
+
+
+//============================================================================//
+// Geometry (this is just for utility stuff...)                               //
+//============================================================================//
+namespace details {
+	template<typename Point>
+	constexpr Integer cross(Point a, Point b) {
+		return getX(a) * getY(b) - getY(a) * getX(b);
+	}
+	template<typename Point>
+	constexpr Integer cross(Point p, Point a, Point b) {
+		getX(a) -= getX(p);
+		getY(a) -= getY(p);
+		getX(b) -= getX(p);
+		getY(b) -= getY(p);
+		return cross(a, b);
+	}
+
+	template<typename Point>
+	constexpr bool left(Point p) {
+		return getX(p) == 0 ? getY(p) < 0 : getX(p) < 0;
+	}
+
+	template<typename Point>
+	void cyclicSort(std::vector<Point>& in) {
+		std::sort(in.begin(), in.end(), [](const Point& a, const Point& b){
+			return left(a) != left(b) ? left(a) > left(b) : cross(a, b) > 0;
+		});
+	}
+}
+
+
+template<typename RandomIt>
+constexpr bool areConvex(RandomIt first, RandomIt last) {
+	std::size_t n = 0;
+	for (auto it = first; it != last; it++) {
+		n++;
+		judgeAssert(std::abs(getX(*it)) <= 0x3FFF'FFFF, "areConvex(): coordinates too large!");
+		judgeAssert(std::abs(getY(*it)) <= 0x3FFF'FFFF, "areConvex(): coordinates too large!");
+	}
+	if (n < 3) return false;
+	bool hasArea = false;
+	for (std::size_t i = 0; i < n; i++) {
+		if (first[i] == first[(i+1) % n]) return false;
+		if (details::cross(first[0], first[i], first[(i+1) % n]) < 0) return false;
+		if (details::cross(first[i], first[(i+1) % n], first[(i+2) % n]) < 0) return false;
+		hasArea |= details::cross(first[i], first[(i+1) % n], first[(i+2) % n]) != 0;
+	}
+	return hasArea;
+}
+template<typename C>
+constexpr bool areConvex(const C& c) {
+	return areConvex(std::begin(c), std::end(c));
+}
+
+template<typename RandomIt>
+constexpr bool areStrictlyConvex(RandomIt first, RandomIt last) {
+	if (!areConvex(first, last)) return false;
+	std::size_t n = std::distance(first, last);
+	for (std::size_t i = 0; i < n; i++) {
+		if (details::cross(first[i], first[(i+1) % n], first[(i+2) % n]) == 0) return false;
+	}
+	return true;
+}
+template<typename C>
+constexpr bool areStrictlyConvex(const C& c) {
+	return areStrictlyConvex(std::begin(c), std::end(c));
+}
+
+//============================================================================//
+// Random                                                                     //
+//============================================================================//
+namespace Random {
+	// You should not rely on the implementation in details!
+	// Especially you should never use randomNumberGenerator on your own. There is no function in
+	// c++ which uses a random engine and is not implementation defined.
+	namespace details {
+		constexpr Real PI = 3.141592653589793238462643383279502884_real;
+		constexpr Integer PRIME_TRIALS = 4*1600;
+
+		RandomEngine randomNumberGenerator(DEFAULT_SEED);
+		static_assert(RandomEngine::max() == 0xFFFF'FFFF'FFFF'FFFF_uint, "Random Engine should produce 64bit of randomness");
+		static_assert(RandomEngine::min() == 0_uint, "Random Engine should produce 64bit of randomness");
+
+		constexpr UInteger bitMask(UInteger x) {
+			static_assert(sizeof(UInteger) == 8, "bitMask requires 8byte UInteger!");
+			x |= x >> 1;
+			x |= x >> 2;
+			x |= x >> 4;
+			x |= x >> 8;
+			x |= x >> 16;
+			x |= x >> 32;
+			return x;
+		}
+	}
+
+	void seed(UInteger seed) {
+		details::randomNumberGenerator.seed(seed);
+	}
+
+	//========================================================================//
+	// Distributions and generators                                           //
+	//========================================================================//
+	bool bit() {// in {0, 1}
+		return std::bitset<64>(details::randomNumberGenerator()).count() & 1;
+	}
+
+	Integer integer() {// in [-2^63, 2^63)
+		return static_cast<Integer>(details::randomNumberGenerator());
+	}
+	Integer integer(Integer lower, Integer upper) {// in [lower, upper)
+		judgeAssert<std::invalid_argument>(lower < upper, "Random::integer(): Lower must be less than upper!");
+		UInteger ul = static_cast<UInteger>(lower);
+		UInteger uu = static_cast<UInteger>(upper);
+		UInteger mask = details::bitMask(uu - ul - 1_uint);
+		UInteger res;
+		do {
+			res = details::randomNumberGenerator() & mask;
+		} while (res >= uu - ul);
+		return static_cast<Integer>(res + ul);
+	}
+	Integer integer(Integer upper) {// in [0, upper)
+		return integer(0, upper);
+	}
+
+	Real real() {// in [0, 1)
+		while (true) {
+			Real res = details::randomNumberGenerator() / 0x1.0p64_real;
+			res += details::randomNumberGenerator() / 0x1.0p128_real;
+			if (0.0_real <= res and res < 1.0_real) return res;
+		}
+	}
+	Real real(Real upper) {// in [0, upper)
+		judgeAssert<std::domain_error>(std::isfinite(upper), "Random::real(): Upper must be finite!");
+		judgeAssert<std::invalid_argument>(upper > 0.0_real, "Random::real(): Upper must be greater than zero!");
+		while (true) {
+			Real res = real() * upper;
+			if (0.0_real <= res and res < upper) return res;
+		}
+	}
+	Real real(Real lower, Real upper) {// in [lower, upper)
+		judgeAssert<std::domain_error>(std::isfinite(lower), "Random::real(): Lower must be finite!");
+		judgeAssert<std::domain_error>(std::isfinite(upper), "Random::real(): Upper must be finite!");
+		judgeAssert<std::invalid_argument>(lower < upper, "Random::real(): Lower must be less than upper!");
+		while (true) {
+			Real x = real();
+			Real res = lower * (1.0_real - x) + upper * x;
+			if (lower <= res and res < upper) return res;
+		}
+	}
+
+	Real normal(Real mean, Real stddev) {// theoretically in (-inf, inf)
+		judgeAssert<std::domain_error>(stddev >= 0.0_real, "Random::normal(): Standard deviation must be non negative!");
+		Real u1 = real();
+		Real u2 = real();
+		Real res = std::sqrt(-2.0_real * std::log(u1)) * std::cos(2.0_real * details::PI * u2);
+		return std::sqrt(stddev) * res + mean;
+	}
+	Real normal(Real lower, Real upper, Real mean, Real stddev) {// in [lower, upper)
+		judgeAssert<std::domain_error>(!std::isnan(lower), "Random::normal(): Lower must not be NaN!");
+		judgeAssert<std::domain_error>(!std::isnan(upper), "Random::normal(): Upper must not be NaN!");
+		judgeAssert<std::invalid_argument>(lower < upper, "Random::normal(): Lower must be less than upper!");
+		judgeAssert<std::domain_error>(stddev >= 0.0_real, "Random::normal(): Standard deviation must be non negative!");
+		Real res;
+		while (true) {
+			Real u1 = real();
+			Real u2 = real();
+			// Box-Muller-Methode
+			// https://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform
+			res = std::sqrt(-2.0_real * std::log(u1)) * std::cos(2.0_real * details::PI * u2);
+			res = std::sqrt(stddev) * res + mean;
+			if (lower <= res and res < upper) return res;
+			res = std::sqrt(-2.0_real * std::log(u1)) * std::sin(2.0_real * details::PI * u2);
+			res = std::sqrt(stddev) * res + mean;
+			if (lower <= res and res < upper) return res;
+		}
+	}
+
+	Real exponential(Real lambda) {// theoretically in [0, inf)
+		judgeAssert<std::domain_error>(lambda > 0.0_real, "Random::lambda(): lambda must be positive!");
+		return -std::log(real()) / lambda;
+	}
+	Real exponential(Real lower, Real upper, Real lambda) {// in [lower, upper)
+		judgeAssert<std::domain_error>(std::isfinite(lower), "Random::exponential(): Lower must be finite!");
+		judgeAssert<std::domain_error>(!std::isnan(upper), "Random::exponential(): Upper must not be NaN!");
+		judgeAssert<std::invalid_argument>(lower < upper, "Random::exponential(): Lower must be less than upper!");
+		judgeAssert<std::domain_error>(lambda > 0.0_real, "Random::exponential(): Lambda must be positive!");
+		while (true) {
+			Real res = lower - std::log(real()) / lambda;
+			if (res < upper) return res;
+		}
+	}
+
+	Integer geometric(Real p) {// theoretically in [0, inf)
+		judgeAssert<std::domain_error>(0.0_real <= p and p < 1.0_real, "Random::geometric(): p must be in [0,1)!");
+		return std::llround(std::floor(std::log(real()) / std::log1p(-p)));
+	}
+	Integer geometric(Integer lower, Integer upper, Real p) {// in [lower, upper)
+		judgeAssert<std::invalid_argument>(lower < upper, "Random::geometric(): Lower must be less than upper!");
+		judgeAssert<std::domain_error>(0.0_real <= p and p < 1.0_real, "Random::geometric(): p must be in [0,1)!");
+		while (true) {
+			// https://en.wikipedia.org/wiki/Geometric_distribution
+			// "The exponential distribution is the continuous analogue of the geometric distribution[...]"
+			Integer res = lower + std::llround(std::floor(std::log(real()) / std::log1p(-p)));
+			if (res < upper) return res;
+		}
+	}
+
+	Integer binomial(Integer n, Real p) {// in [0, n]
+		judgeAssert<std::domain_error>(n >= 0, "Random::binomial(): n must be non negative!");
+		judgeAssert<std::domain_error>(0.0_real <= p and p <= 1.0_real, "Random::binomial(): p must be in [0,1)!");
+		bool swap = p > 0.5_real;
+		p = std::min(p, 1.0_real - p);
+		if (p*n < 10.0_real) {
+			// BG: Geometric method
+			// https://dl.acm.org/doi/pdf/10.1145/42372.42381
+			Integer res = 0;
+			Integer y = 0;
+			Real lg = std::log1p(-p);
+			if (lg >= 0) return swap ? n : 0;
+			do {
+				y += std::llround(std::floor(std::log(real()) / lg)) + 1;
+				if (y > n) return swap ? n - res : res;
+				res++;
+			} while (true);
+		} else {
+			// BTRS algorithm
+			// https://epub.wu.ac.at/1242/1/document.pdf
+			// note that the original paper has an error
+			// the break condition at the end has to be log(v) < h[...]
+			Real q = 1.0_real - p;
+			Real spq = std::sqrt(n * p * q);
+			Real b = 1.15_real + 2.53_real * spq;
+			Real a = -0.0873_real + 0.0248_real * b + 0.01_real * p;
+			Real c = n * p + 0.5_real;
+			Real vr = 0.92_real - 4.2_real / b;
+
+			bool initialized = false;
+			Real alpha, lpq, m, h;
+			do {
+				Real u = real() - 0.5_real;
+				Real us = 0.5_real - std::abs(u);
+				Integer res = std::llround(std::floor((2.0_real * a / us + b) * u + c));
+				if (res < 0 or res > n) continue;
+
+				Real v = real();
+				if (us >= 0.07_real and v <= vr) {
+					return swap ? n - res : res;
+				}
+
+				if (!initialized) {
+					alpha = (2.83_real + 5.1_real / b) * spq;
+					lpq = std::log(p / q);
+					m = std::llround(std::floor((n + 1) * p));
+					h = std::lgamma(m + 1) + std::lgamma(n - m + 1);
+					initialized = true;
+				}
+				v *= alpha / (a / (us * us) + b);
+				if (std::log(v) <= h - std::lgamma(res + 1) - std::lgamma(n - res + 1) + (res - m) * lpq) {
+					return swap ? n - res : res;
+				}
+			} while (true);
+		}
+	}
+	Integer binomial(Integer lower, Integer upper, Integer n, Real p) {// in [lower, upper)
+		judgeAssert<std::invalid_argument>(lower < upper, "Random::binomial(): n Lower must be less than upper!");
+		while (true) {
+			Integer res = binomial(n, p);
+			if (lower <= res and res < upper) return res;
+		}
+	}
+
+	Integer maximum(Integer lower, Integer upper, Integer n) {// in [lower, upper)
+		judgeAssert<std::invalid_argument>(n > 0, "Random::maximum(): n musst be positive!");
+		judgeAssert<std::invalid_argument>(lower < upper, "Random::maximum(): Lower must be less than upper!");
+		if (n < 5) {
+			Integer res = lower;
+			for (Integer i = 0; i < n; i++) res = std::max(res, integer(lower, upper));
+			return res;
+		} else {// such large n seem unlikely
+			UInteger ul = static_cast<UInteger>(lower);
+			UInteger uu = static_cast<UInteger>(upper);
+			UInteger res = (uu - ul) * std::exp2(std::log2(real()) / n);
+			return std::min(upper - 1, static_cast<Integer>(res + ul));
+		}
+	}
+	Integer maximum(Integer upper, Integer n) {
+		return maximum(0, upper, n);
+	}
+
+	Integer minimum(Integer lower, Integer upper, Integer n) {// in [lower, upper)
+		return upper - 1 - maximum(0, upper - lower, n);
+	}
+	Integer minimum(Integer upper, Integer n) {
+		return minimum(0, upper, n);
+	}
+
+	Integer prime(Integer lower, Integer upper) {// in [lower, upper)
+		judgeAssert<std::invalid_argument>(lower < upper, "Random::prime(): Lower must be less than upper!");
+		Integer sampleL = lower <= 2 ? 0 : (lower / 2);
+		Integer sampleU = upper / 2;
+		if (sampleL < sampleU) {
+			for (Integer i = 0; i < details::PRIME_TRIALS and i < 4 * (upper - lower); i++) {
+				Integer res = std::max<Integer>(2, 2*integer(sampleL, sampleU) | 1);
+				if (isPrime(res)) return res;
+			}
+		}
+		judgeAssert<std::domain_error>(false, "Random::prime(): range contains no primes?");
+		return -1;
+	}
+	Integer prime(Integer upper) {// in [0, upper)
+		return prime(0, upper);
+	}
+
+
+	//========================================================================//
+	// utility                                                                //
+	//========================================================================//
+	template<typename RandomIt>
+	typename std::iterator_traits<RandomIt>::reference
+	select(RandomIt first, RandomIt last) {
+		judgeAssert<std::invalid_argument>(first < last, "Random::select(): Lower must be less than upper!");
+		return first[integer(0, last - first)];
+	}
+
+	template<typename C>
+	typename ::details::IsContainer<C>::value_type select(const C& c) {
+		return select(std::begin(c), std::end(c));
+	}
+
+	template<typename C>
+	typename C::reference select(C& c) {
+		return select(std::begin(c), std::end(c));
+	}
+
+	template<typename T, std::size_t N>
+	T select(const T(&c)[N]) {
+		return select(std::begin(c), std::end(c));
+	}
+
+	template<typename T, std::size_t N>
+	T& select(T(&c)[N]) {
+		return select(std::begin(c), std::end(c));
+	}
+
+	template<typename T>
+	T select(const std::pair<T, T>& t) {
+		return bit() ? getX(t) : getY(t);
+	}
+
+	template<typename T>
+	T select(const std::complex<T>& t) {
+		return bit() ? getX(t) : getY(t);
+	}
+
+	template<typename RandomIt>
+	void shuffle(RandomIt first, RandomIt last) {
+		using std::swap;
+		auto n = last - first;
+		for (auto i = n-1; i > 0; i--) {
+			swap(first[i], first[integer(0, i+1)]);
+		}
+	}
+
+	template<typename C>
+	void shuffle(C& c) {
+		return shuffle(std::begin(c), std::end(c));
+	}
+
+	template<typename T>
+	void shuffle(std::pair<T, T>& t) {
+		using std::swap;
+		if (bit()) swap(getX(t), getY(t));
+	}
+
+	template<typename T>
+	void shuffle(std::complex<T>& t) {
+		using std::swap;
+		if (bit()) swap(getX(t), getY(t));
+	}
+
+	template<typename RandomIt>
+	Integer rotate(RandomIt first, RandomIt last) {
+		Integer rotation = integer(0, last - first);
+		std::rotate(first, first + rotation, last);
+		return rotation;
+	}
+
+	template<typename C>
+	Integer rotate(C& c) {
+		return rotate(std::begin(c), std::end(c));
+	}
+
+	//========================================================================//
+	// sequences                                                              //
+	//========================================================================//
+	std::vector<Integer> distinct(Integer count, Integer lower, Integer upper) {
+		judgeAssert<std::invalid_argument>(count >= 0, "Random::distinct(): Count must be non negative!");
+		judgeAssert<std::invalid_argument>(lower + count <= upper, "Random::distinct(): Lower must be less than upper + count!");
+		std::map<Integer, Integer> used;
+		std::vector<Integer> res;
+		for (Integer i = 0; i < count; i++) {
+			Integer x = integer(lower, upper - i);
+			auto it = used.find(x);
+			if (it != used.end()) res.emplace_back(it->second);
+			else res.emplace_back(x);
+			it = used.find(upper - i - 1);
+			if (it != used.end()) used[x] = it->second;
+			else used[x] = upper - i - 1;
+		}
+		return res;
+	}
+	std::vector<Integer> distinct(Integer count, Integer upper) {
+		return distinct(count, 0, upper);
+	}
+
+	std::vector<Integer> perm(Integer count, Integer offset = 0) {
+		return distinct(count, offset, offset+count);
+	}
+
+	std::vector<Integer> perm(const std::vector<Integer>& cycles, Integer offset = 0) {
+		auto p = perm(std::accumulate(cycles.begin(), cycles.end(), 0_int));
+		std::vector<Integer> res(p.size());
+		Integer tmp = 0;
+		for (std::size_t i = 0; i < cycles.size(); tmp += cycles[i], i++) {
+			judgeAssert<std::invalid_argument>(cycles[i] > 0, "Random::perm(): Cycle lengths must be positive!");
+			for (Integer j = tmp; j + 1 < tmp + cycles[i]; j++) {
+				res[p[j]] = p[j + 1] + offset;
+			}
+			res[p[tmp + cycles[i] - 1]] = p[tmp] + offset;
+		}
+		return res;
+	}
+
+	std::vector<Integer> perm(std::initializer_list<Integer> cycles, Integer offset = 0) {
+		return perm(std::vector<Integer>(cycles), offset);
+	}
+
+	std::vector<Integer> multiple(Integer count, Integer lower, Integer upper) {
+		std::vector<Integer> res(count);
+		for (Integer& x : res) x = integer(lower, upper);
+		return res;
+	}
+	std::vector<Integer> multiple(Integer count, Integer upper) {
+		return multiple(count, 0, upper);
+	}
+
+	std::vector<Integer> increasing(Integer count, Integer lower, Integer upper) {
+		std::vector<Integer> res = distinct(count, lower, upper);
+		std::sort(res.begin(), res.end(), std::less<Integer>());
+		return res;
+	}
+	std::vector<Integer> increasing(Integer count, Integer upper) {
+		return increasing(count, 0, upper);
+	}
+
+	std::vector<Integer> decreasing(Integer count, Integer lower, Integer upper) {
+		std::vector<Integer> res = distinct(count, lower, upper);
+		std::sort(res.begin(), res.end(), std::greater<Integer>());
+		return res;
+	}
+	std::vector<Integer> decreasing(Integer count, Integer upper) {
+		return decreasing(count, 0, upper);
+	}
+
+	std::vector<Integer> nonDecreasing(Integer count, Integer lower, Integer upper) {
+		std::vector<Integer> res = multiple(count, lower, upper);
+		std::sort(res.begin(), res.end(), std::less<Integer>());
+		return res;
+	}
+	std::vector<Integer> nonDecreasing(Integer count, Integer upper) {
+		return nonDecreasing(count, 0, upper);
+	}
+
+	std::vector<Integer> nonIncreasing(Integer count, Integer lower, Integer upper) {
+		std::vector<Integer> res = multiple(count, lower, upper);
+		std::sort(res.begin(), res.end(), std::greater<Integer>());
+		return res;
+	}
+	std::vector<Integer> nonIncreasing(Integer count, Integer upper) {
+		return nonIncreasing(count, 0, upper);
+	}
+
+	std::vector<Integer> partition(Integer n, Integer k, Integer min = 1) {
+		judgeAssert<std::invalid_argument>(n > 0, "Random::partition(): n must be positive!");
+		judgeAssert<std::invalid_argument>(k > 0, "Random::partition(): k must be positive!");
+		judgeAssert<std::invalid_argument>(min <= 0 or k <= n / min, "Random::partition(): k too large!");
+		n -= (min - 1) * k;
+		std::vector<Integer> res = increasing(k-1, 1, n);
+		res.emplace_back(n);
+		for (Integer i = 0, last = 0; i < k; i++) {
+			res[i] -= last;
+			last += res[i];
+			res[i] += min - 1;
+		}
+		return res;
+	}
+
+	std::string bracketSequence(Integer n, char open = '(', char close = ')') {//proper bracket sequence of length 2*n
+		judgeAssert<std::invalid_argument>(0 <= n and n <= 0x7FFF'FFFF, "Random::bracketSequence(): n out of range!");
+		std::string res(2 * n, open);
+		for (Integer i = 0, diff = 0; i < 2 * n; i++) {
+			Integer opened = (i + diff) / 2;
+			if (integer((2 * n - i) * (diff + 1)) < (n - opened) * (diff + 2)) {
+				diff++;
+			} else {
+				res[i] = close;
+				diff--;
+			}
+		}
+		return res;
+	}
+
+	//========================================================================//
+	// geometry                                                               //
+	//========================================================================//
+	template<typename Point = std::pair<Integer, Integer>>
+	std::vector<Point> convex(Integer n, Integer dim) {
+		judgeAssert<std::invalid_argument>(dim <= 0x3FFF'FFFF, "Random::convex(): dim too large!");
+		judgeAssert<std::invalid_argument>(dim > 0, "Random::convex(): dim must be positive!");
+		judgeAssert<std::invalid_argument>(n <= 8*dim - 8, "Random::convex(): dim too small!");
+		judgeAssert<std::invalid_argument>(n >= 3, "Random::convex(): n too small!");
+
+		while (true) {
+			Integer left = 1 + binomial(n - 2, 0.5);
+			Integer down = 1 + binomial(n - 2, 0.5);
+			auto x = partition(2 * dim - 2, left, 0);
+			auto y = partition(2 * dim - 2, down, 0);
+			for (auto& z : x) z = -z;
+			for (auto& z : y) z = -z;
+			append(x, partition(2 * dim - 2, n - left, 0));
+			append(y, partition(2 * dim - 2, n - down, 0));
+			auto itX = std::partition(x.begin(), x.end(), [](Integer z){return z == 0;});
+			auto itY = std::partition(y.begin(), y.end(), [](Integer z){return z != 0;});
+			if (std::distance(x.begin(), itX) + std::distance(itY, y.end()) > n) continue;
+			shuffle(itX, x.end());
+			if (itX != x.begin()) shuffle(y.begin(), itY);
+
+			std::vector<Point> dirs(n);
+			for (Integer i = 0; i < n; i++) {
+				dirs[i] = {x[i], y[i]};
+			}
+			::details::cyclicSort(dirs);
+
+			std::vector<Point> res = {{0, 0}};
+			Integer maxX = 0;
+			Integer maxY = 0;
+			for (auto dir : dirs) {
+				Point tmp = res.back();
+				getX(tmp) += getX(dir);
+				getY(tmp) += getY(dir);
+				maxX = std::max(maxX, getX(tmp));
+				maxY = std::max(maxY, getY(tmp));
+				res.emplace_back(tmp);
+			}
+			res.pop_back();
+			for (auto& point : res) {
+				getX(point) += dim - 1 - maxX;
+				getY(point) += dim - 1 - maxY;
+			}
+			return res;
+		}
+	}
+
+	template<typename Point = std::pair<Integer, Integer>>
+	std::vector<Point> nonCollinearPoints(Integer n, Integer dim) {
+		judgeAssert<std::invalid_argument>(dim <= 0x1FFF'FFFF, "Random::nonCollinearPoints(): dim too large!");
+		judgeAssert<std::invalid_argument>(n >= 0, "Random::nonCollinearPoints(): dim must be non negative!");
+		judgeAssert<std::invalid_argument>(dim > n, "Random::nonCollinearPoints(): dim too small!");
+		Integer p = prime(dim - 1, 2*dim + 2);
+		Integer rotA = 0;
+		Integer rotB = 0;
+		while (rotA == 0 && rotB == 0) {
+			rotA = integer(0, p);
+			rotB = integer(0, p);
+		}
+		std::array<Integer, 3> abc = {
+			integer(1, p),
+			integer(0, p),
+			integer(0, p),
+		};
+		Integer dx = integer(-dim + 1, dim - p);
+		Integer dy = integer(-dim + 1, dim - p);
+
+		auto xs = distinct(n, p);
+		std::vector<Point> res;
+		for (auto tmpX : xs) {
+			Integer tmpY = 0;
+			for (Integer add : abc[0]) {
+				tmpY *= tmpX;
+				tmpY += add;
+				tmpY %= p;
+			}
+
+			Integer x = applyMod(tmpX * rotA - tmpY * rotB, p);
+			Integer y = applyMod(tmpX * rotB + tmpY * rotA, p);
+
+			res.emplace_back(x + dx, y + dy);
+		}
+		return res;
+	}
+
+} // namespace Random
+
+
+//============================================================================//
+// args parser                                                                //
+//============================================================================//
+class ParamaterBase {
+	friend class Command;
+	friend struct Paramater;
+
+	std::optional<std::string_view> token;
+
+	template<typename T>
+	T parse(std::string_view s) const {
+		T res = {};
+		judgeAssert<std::invalid_argument>(details::parse<T>(s, res), "Command: Could not parse args");
+		return res;
+	}
+
+	ParamaterBase() = default;
+	explicit ParamaterBase(std::string_view token_) : token(token_) {}
+
+public:
+	std::string asString() const {
+		return std::string(token.value());
+	}
+
+	std::string asString(std::string_view defaultValue) const {
+		return std::string(token.value_or(defaultValue));
+	}
+
+	Integer asInteger() const {
+		return parse<Integer>(token.value());
+	}
+
+	Integer asInteger(Integer defaultValue) const {
+		return token ? asInteger() : defaultValue;
+	}
+
+	Real asReal() const {
+		return parse<Real>(token.value());
+	}
+
+	Real asReal(Real defaultValue) const {
+		return token ? asReal() : defaultValue;
+	}
+};
+
+struct Paramater final : private ParamaterBase {
+	using ParamaterBase::ParamaterBase;
+	using ParamaterBase::asString;
+	using ParamaterBase::asInteger;
+	using ParamaterBase::asReal;
+
+	bool exists() const {
+		return token.has_value();
+	}
+
+	explicit operator bool() const {
+		return exists();
+	}
+};
+
+class Command final : private ParamaterBase {
+	const std::vector<std::string>& raw;
+	const Integer first, count;
+	const bool found;
+public:
+	explicit Command(const std::vector<std::string>& raw_) : raw(raw_), first(0), count(0), found(false) {}
+	explicit Command(const std::vector<std::string>& raw_, Integer first_, Integer count_)
+	                 : ParamaterBase(count_ == 0 ? ParamaterBase() : ParamaterBase(raw_[first_])),
+	                   raw(raw_), first(first_), count(count_), found(true) {
+		judgeAssert<std::invalid_argument>(count >= 0, "Command: Invalid command in args!");
+	}
+
+	bool exists() const {
+		return found;
+	}
+
+	explicit operator bool() const {
+		return exists();
+	}
+
+	Integer parameterCount() const {
+		return count;
+	}
+
+	Paramater operator[](Integer i) const {
+		if (i >= 0 and i < count) return Paramater(raw[first + i]);
+		return Paramater();
+	}
+
+	using ParamaterBase::asString;
+	using ParamaterBase::asInteger;
+	using ParamaterBase::asReal;
+
+	std::vector<std::string> asStrings() const {
+		std::vector<std::string> res;
+		std::transform(raw.begin() + first,
+		               raw.begin() + first + count,
+		               std::back_inserter(res), [](const std::string& value) {
+			return std::string(value);
+		});
+		return res;
+	}
+
+	std::vector<Integer> asIntegers() const {
+		std::vector<Integer> res;
+		std::transform(raw.begin() + first,
+		               raw.begin() + first + count,
+		               std::back_inserter(res), [this](const std::string& value) {
+			return parse<Integer>(value);
+		});
+		return res;
+	}
+
+	std::vector<Real> asReals() const {
+		std::vector<Real> res;
+		std::transform(raw.begin() + first,
+		               raw.begin() + first + count,
+		               std::back_inserter(res), [this](const std::string& value) {
+			return parse<Real>(value);
+		});
+		return res;
+	}
+
+};
+
+class CommandParser final {
+	std::vector<std::string> raw;
+	std::map<std::string_view, std::pair<Integer, Integer>> commands;
+	std::map<std::string_view, Integer> tokens;
+
+	static bool isCommand(std::string_view s) {
+		return s.size() > 2 and s.substr(0, 2) == COMMAND_PREFIX;
+	}
+	void addCommand(std::string_view command, Integer first, Integer count = 0) {
+		judgeAssert<std::invalid_argument>(commands.count(command) == 0, "Command: Duplcated command in args!");
+		commands.emplace(command, std::pair<Integer, Integer>{first, count});
+	}
+
+public:
+	CommandParser() = default;
+	explicit CommandParser(int argc, char** argv) {
+		raw.assign(argc, {});
+		std::string_view command = EMPTY_COMMAND;
+		Integer first = 0;
+		Integer count = 0;
+		for (int i = 0; i < argc; i++) {
+			raw[i] = std::string(argv[i]);
+			tokens.emplace(raw[i], i+1);
+			if (isCommand(raw[i])) {
+				addCommand(command, first, count);
+				command = raw[i];
+				first = i+1;
+				count = 0;
+			} else {
+				count++;
+			}
+		}
+		addCommand(command, first, count);
+	}
+	CommandParser(CommandParser&&) = default;
+	CommandParser& operator=(CommandParser&&) = default;
+
+	CommandParser(const CommandParser&) = delete;
+	CommandParser& operator=(const CommandParser&) = delete;
+
+	std::string_view operator[](Integer t) const {
+		judgeAssert<std::out_of_range>(t >= 0 and t < static_cast<Integer>(raw.size()), "Command: Index out of args!");
+		return raw[t];
+	}
+	Command operator[](std::string_view command) const & {
+		judgeAssert<std::invalid_argument>(details::isToken(command), "Command: must not contain a space!");
+		auto it = commands.find(command);
+		if (it == commands.end()) return Command(raw);
+		return Command(raw, it->second.first, it->second.second);
+	}
+	Command getRaw(std::string_view command) const & {
+		judgeAssert<std::invalid_argument>(details::isToken(command), "Command: must not contain a space!");
+		auto it = tokens.find(command);
+		if (it == tokens.end()) return Command(raw);
+		return Command(raw, it->second, raw.size() - it->second);
+	}
+	Command getRaw() const & {
+		return Command(raw, 0, raw.size());
+	}
+};
+
+
+//============================================================================//
+// Constraints                                                                //
+//============================================================================//
+template<typename T>
+class Bounds final {
+	bool hadMin, hadMax;	// was value==lower/upper at some point
+	T min, max;				// range of seen values
+	T lower, upper;			// bounds for value
+public:
+	constexpr explicit Bounds(T lower_, T upper_, T value_) :
+	                          hadMin(false), hadMax(false),
+	                          min(value_), max(value_),
+	                          lower(lower_), upper(upper_) {
+		update(lower_, upper_, value_);
+	}
+
+	void update(T lower_, T upper_, T value_) {
+		if constexpr (std::is_same_v<T, Real>) {
+			hadMin |= details::floatEqual(value_, lower_, DEFAULT_EPS, DEFAULT_EPS);
+			hadMax |= details::floatEqual(value_, upper_, DEFAULT_EPS, DEFAULT_EPS);
+		} else {
+			hadMin |= value_ == lower_;
+			hadMax |= value_ == upper_;
+		}
+		min = std::min(min, value_);
+		max = std::max(max, value_);
+		lower = std::min(lower, lower_);
+		upper = std::max(upper, upper_);
+	}
+
+	friend std::ostream& operator<<(std::ostream& os, const Bounds<T>& bounds) {
+		os << bounds.hadMin << " " << bounds.hadMax << " ";
+		os << bounds.min << " " << bounds.max << " ";
+		return os << bounds.lower << " " << bounds.upper;
+	}
+
+};
+
+namespace details {
+	//using typeIndex = std::type_index;
+	using typeIndex = void*;
+
+	template<typename T>
+	typeIndex getTypeIndex() {
+		//return std::type_index(type id(T));
+		static T* uniqueTypeIndex = nullptr;
+		return &uniqueTypeIndex;
+	}
+}
+
+class Constraint final {
+	friend class ConstraintsLogger;
+	std::variant<
+		std::monostate,		// uninitialized
+		Bounds<Integer>,	// Integer or container bound
+		Bounds<Real>		// Real bound
+	> bound;
+	std::optional<details::typeIndex> type;
+
+	template<typename T, typename X = T>
+	void update(T lower, T upper, T value) {
+		if constexpr(std::is_integral_v<T>) {
+			upper--; // for BAPCtools the range is closed but we use half open ranges!
+		}
+		if (!type) {
+			type = details::getTypeIndex<X>();
+			bound = Bounds<T>(lower, upper, value);
+		}
+		judgeAssert<std::logic_error>(type == details::getTypeIndex<X>(), "Constraint: type must not change!");
+		std::get<Bounds<T>>(bound).update(lower, upper, value);
+	}
+public:
+	Constraint() = default;
+	Constraint(Constraint&&) = default;
+	Constraint& operator=(Constraint&&) = default;
+
+	Constraint(const Constraint&) = delete;
+	Constraint& operator=(const Constraint&) = delete;
+
+	template<typename V, typename std::enable_if_t<std::is_integral_v<V>, bool> = true>
+	void log(Integer lower, Integer upper, V value) {
+		update<Integer>(lower, upper, value);
+	}
+
+	template<typename V, typename std::enable_if_t<std::is_floating_point_v<V>, bool> = true>
+	void log(Real lower, Real upper, V value) {
+		update<Real>(lower, upper, value);
+	}
+
+	template<typename C, typename std::enable_if_t<!std::is_arithmetic_v<C>, bool> = true>
+	void log(Integer lower, Integer upper, const C& container) {
+		update<Integer, C>(lower, upper, static_cast<Integer>(std::size(container)));
+	}
+};
+
+class ConstraintsLogger final {
+	std::optional<std::string> fileName;
+	std::map<std::string, std::size_t> byName;
+	std::vector<std::unique_ptr<Constraint>> constraints;
+public:
+	ConstraintsLogger() = default;
+	explicit ConstraintsLogger(std::string_view fileName_) : fileName(fileName_) {}
+
+	ConstraintsLogger(ConstraintsLogger&&) = default;
+	ConstraintsLogger& operator=(ConstraintsLogger&&) = default;
+
+	ConstraintsLogger(const ConstraintsLogger&) = delete;
+	ConstraintsLogger& operator=(const ConstraintsLogger&) = delete;
+
+	Constraint& operator[](const std::string& name) & {
+		judgeAssert<std::invalid_argument>(details::isToken(name), "Constraint: name must not contain a space!");
+		auto res = byName.try_emplace(name, constraints.size());
+		if (res.second) constraints.emplace_back(std::make_unique<Constraint>());
+		return *(constraints[res.first->second]);
+	}
+
+	void write() const {
+		if (!fileName) return;
+		std::ofstream os(*fileName);
+		os << std::noboolalpha;
+		os << std::fixed;
+		os << std::setprecision(DEFAULT_PRECISION);
+		for (const auto& [name, id] : byName) {
+			const Constraint& c = *(constraints[id]);
+			if (c.type) {
+				os << "LocationNotSupported:" << name << " " << name << " ";
+				if (c.bound.index() == 1) os << std::get<1>(c.bound);
+				if (c.bound.index() == 2) os << std::get<2>(c.bound);
+				os << std::endl;
+			}
+		}
+	}
+
+	~ConstraintsLogger() noexcept {
+		write();
+	}
+};
+
+//============================================================================//
+// custom input stream                                                        //
+//============================================================================//
+class InputStream final {
+	std::unique_ptr<std::ifstream> managed;
+	std::istream* in;
+	bool spaceSensitive, caseSensitive;
+	Verdict onFail;
+	Real floatAbsTol;
+	Real floatRelTol;
+
+	void init() {
+		if (spaceSensitive) *in >> std::noskipws;
+		else *in >> std::skipws;
+	}
+
+	void checkIn() {
+		judgeAssert<std::runtime_error>(in != nullptr, "InputStream: not initialized!");
+	}
+
+public:
+	InputStream() = default;
+	explicit InputStream(const std::filesystem::path& path,
+	                     bool spaceSensitive_,
+	                     bool caseSensitive_,
+	                     Verdict onFail_,
+	                     Real floatAbsTol_ = DEFAULT_EPS,
+	                     Real floatRelTol_ = DEFAULT_EPS) :
+	                     managed(std::make_unique<std::ifstream>(path)),
+	                     in(managed.get()),
+	                     spaceSensitive(spaceSensitive_),
+	                     caseSensitive(caseSensitive_),
+	                     onFail(onFail_),
+	                     floatAbsTol(floatAbsTol_),
+	                     floatRelTol(floatRelTol_) {
+		judgeAssert<std::runtime_error>(managed->good(), "InputStream: Could not open File: " + path.string());
+		init();
+	}
+	explicit InputStream(std::istream& in_,
+	                     bool spaceSensitive_,
+	                     bool caseSensitive_,
+	                     Verdict onFail_,
+	                     Real floatAbsTol_ = DEFAULT_EPS,
+	                     Real floatRelTol_ = DEFAULT_EPS) :
+	                     managed(),
+	                     in(&in_),
+	                     spaceSensitive(spaceSensitive_),
+	                     caseSensitive(caseSensitive_),
+	                     onFail(onFail_),
+	                     floatAbsTol(floatAbsTol_),
+	                     floatRelTol(floatRelTol_) {
+		init();
+	}
+
+	InputStream(InputStream&& other) = default;
+	InputStream& operator=(InputStream&& other) = default;
+
+	InputStream(const InputStream&) = delete;
+	InputStream& operator=(const InputStream&) = delete;
+
+	void eof() {
+		checkIn();
+		if (!spaceSensitive) *in >> std::ws;
+		if (in->peek() != std::char_traits<char>::eof()) {
+			in->get();
+			ValidateBase::juryOut << "Missing EOF!";
+			fail();
+		}
+	}
+
+	void noteof() {
+		checkIn();
+		if (!spaceSensitive) *in >> std::ws;
+		if (in->peek() == std::char_traits<char>::eof()) {
+			ValidateBase::juryOut << "Unexpected EOF!" << onFail;
+		}
+	}
+
+	void space() {
+		if (spaceSensitive) {
+			noteof();
+			if (in->get() != std::char_traits<char>::to_int_type(SPACE)) {
+				ValidateBase::juryOut << "Missing space!";
+				fail();
+			}
+		}
+	}
+
+	void newline() {
+		if (spaceSensitive) {
+			noteof();
+			if (in->get() != std::char_traits<char>::to_int_type(NEWLINE)) {
+				ValidateBase::juryOut << "Missing newline!";
+				fail();
+			}
+		}
+	}
+
+private:
+	void check(const std::string& token, const std::regex& pattern) {
+		if (!std::regex_match(token, pattern)) {
+			ValidateBase::juryOut << "Token \"" << token << "\" does not match pattern!";
+			fail();
+		}
+	}
+
+	std::function<void()> checkSeparator(char separator) {
+		if (separator == SPACE) return [this](){space();};
+		if (separator == NEWLINE) return [this](){newline();};
+		judgeAssert<std::invalid_argument>(false, "InputStream: Separator must be ' '  or '\\n'!");
+		return {};
+	}
+
+	template<typename T>
+	T parse(const std::string& s) {
+		T res = {};
+		if (!details::parse<T>(s, res)) {
+			ValidateBase::juryOut << "Could not parse token \"" << s << "\"!";
+			fail();
+		}
+		return res;
+	}
+
+public:
+	std::string string() {
+		noteof();
+		if (spaceSensitive and !std::isgraph(in->peek())) {
+			in->get();
+			ValidateBase::juryOut << "Invalid whitespace!";
+			fail();
+		}
+		std::string res;
+		*in >> res;
+		if (res.empty()) {
+			ValidateBase::juryOut << "Unexpected EOF!" << onFail;
+		}
+		if (!caseSensitive) toDefaultCase(res);
+		return res;
+	}
+
+	std::string string(Integer lower, Integer upper) {
+		std::string t = string();
+		Integer length = static_cast<Integer>(t.size());
+		if (length < lower or length >= upper) {
+			ValidateBase::juryOut << "String length " << length << " out of range [" << lower << ", " << upper << ")!";
+			fail();
+		}
+		return t;
+	}
+
+	std::string string(Integer lower, Integer upper, Constraint& constraint) {
+		std::string res = string(lower, upper);
+		constraint.log(lower, upper, res);
+		return res;
+	}
+
+	std::string string(const std::regex& pattern) {
+		std::string t = string();
+		check(t, pattern);
+		return t;
+	}
+
+	std::string string(const std::regex& pattern, Integer lower, Integer upper) {
+		std::string t = string(lower, upper);
+		check(t, pattern);
+		return t;
+	}
+
+	std::string string(const std::regex& pattern, Integer lower, Integer upper, Constraint& constraint) {
+		std::string res = string(pattern, lower, upper);
+		constraint.log(lower, upper, res);
+		return res;
+	}
+
+	template<typename... Args>
+	std::vector<std::string> strings(Args... args, Integer count, char separator) {
+		auto sepCall = checkSeparator(separator);
+		std::vector<std::string> res(count);
+		for (Integer i = 0; i < count; i++) {
+			res[i] = string(args...);
+			if (i + 1 < count) sepCall();
+		}
+		return res;
+	}
+
+	std::vector<std::string> strings(Integer count, char separator = DEFAULT_SEPARATOR) {
+		return strings<>(count, separator);
+	}
+
+	std::vector<std::string> strings(Integer lower, Integer upper,
+	                                 Integer count, char separator = DEFAULT_SEPARATOR) {
+		return strings<Integer, Integer>(lower, upper, count, separator);
+	}
+
+	std::vector<std::string> strings(Integer lower, Integer upper, Constraint& constraint,
+	                                 Integer count, char separator = DEFAULT_SEPARATOR) {
+		return strings<Integer, Integer, Constraint&>(lower, upper, constraint, count, separator);
+	}
+
+	std::vector<std::string> strings(const std::regex& pattern,
+	                                 Integer count, char separator = DEFAULT_SEPARATOR) {
+		return strings<const std::regex&>(pattern, count, separator);
+	}
+
+	std::vector<std::string> strings(const std::regex& pattern, Integer lower, Integer upper,
+	                                 Integer count, char separator = DEFAULT_SEPARATOR) {
+		return strings<const std::regex&, Integer, Integer>(pattern, lower, upper, count, separator);
+	}
+
+	std::vector<std::string> strings(const std::regex& pattern, Integer lower, Integer upper, Constraint& constraint,
+	                                 Integer count, char separator = DEFAULT_SEPARATOR) {
+		return strings<const std::regex&, Integer, Integer, Constraint&>(pattern, lower, upper, constraint, count, separator);
+	}
+
+	Integer integer() {
+		return parse<Integer>(string(INTEGER_REGEX));
+	}
+
+	Integer integer(Integer lower, Integer upper) {
+		Integer res = integer();
+		if (res < lower or res >= upper) {
+			ValidateBase::juryOut << "Integer " << res << " out of range [" << lower << ", " << upper << ")!";
+			fail();
+		}
+		return res;
+	}
+
+	Integer integer(Integer lower, Integer upper, Constraint& constraint) {
+		Integer res = integer(lower, upper);
+		constraint.log(lower, upper, res);
+		return res;
+	}
+
+	template<typename... Args>
+	std::vector<Integer> integers(Args... args, Integer count, char separator) {
+		auto sepCall = checkSeparator(separator);
+		std::vector<Integer> res(count);
+		for (Integer i = 0; i < count; i++) {
+			res[i] = integer(args...);
+			if (i + 1 < count) sepCall();
+		}
+		return res;
+	}
+
+	std::vector<Integer> integers(Integer count, char separator = DEFAULT_SEPARATOR) {
+		return integers<>(count, separator);
+	}
+
+	std::vector<Integer> integers(Integer lower, Integer upper,
+	                              Integer count, char separator = DEFAULT_SEPARATOR) {
+		return integers<Integer, Integer>(lower, upper, count, separator);
+	}
+
+	std::vector<Integer> integers(Integer lower, Integer upper, Constraint& constraint,
+	                              Integer count, char separator = DEFAULT_SEPARATOR) {
+		return integers<Integer, Integer, Constraint&>(lower, upper, constraint, count, separator);
+	}
+
+	// this does not allow NaN or Inf!
+	// However, those should never be desired.
+	Real real() {
+		return parse<Real>(string(REAL_REGEX));
+	}
+
+	Real real(Real lower, Real upper) {// uses eps
+		Real res = real();
+		if (details::floatEqual(res, lower, floatAbsTol, floatRelTol)) return res;
+		if (details::floatEqual(res, upper, floatAbsTol, floatRelTol)) return res;
+		if (std::isnan(res) or !(res >= lower) or !(res < upper)) {
+			ValidateBase::juryOut << "Real " << res << " out of range [" << lower << ", " << upper << ")!";
+			fail();
+		}
+		return res;
+	}
+
+	Real real(Real lower, Real upper, Constraint& constraint) {
+		Real res = real(lower, upper);
+		constraint.log(lower, upper, res);
+		return res;
+	}
+
+	template<typename... Args>
+	std::vector<Real> reals(Args... args, Integer count, char separator) {
+		auto sepCall = checkSeparator(separator);
+		std::vector<Real> res(count);
+		for (Integer i = 0; i < count; i++) {
+			res[i] = real(args...);
+			if (i + 1 < count) sepCall();
+		}
+		return res;
+	}
+
+	std::vector<Real> reals(Integer count, char separator = DEFAULT_SEPARATOR) {
+		return reals<>(count, separator);
+	}
+
+	std::vector<Real> reals(Real lower, Real upper,
+	                        Integer count, char separator = DEFAULT_SEPARATOR) {
+		return reals<Real, Real>(lower, upper, count, separator);
+	}
+
+	std::vector<Real> reals(Real lower, Real upper, Constraint& constraint,
+	                        Integer count, char separator = DEFAULT_SEPARATOR) {
+		return reals<Real, Real, Constraint&>(lower, upper, constraint, count, separator);
+	}
+
+	Real realStrict(Real lower, Real upper, Integer minDecimals, Integer maxDecimals) {// does not use eps
+		std::string t = string(STRICT_REAL_REGEX);
+		auto dot = t.find('.');
+		Integer decimals = dot == std::string::npos ? 0 : t.size() - dot - 1;
+		if (decimals < minDecimals or decimals >= maxDecimals) {
+			ValidateBase::juryOut << "Real " << t << " has wrong amount of decimals!";
+			fail();
+			return 0;
+		}
+		try {
+			Real res = parse<Real>(t);
+			if (std::isnan(res) or !(res >= lower) or !(res < upper)) {
+				ValidateBase::juryOut << "Real " << res << " out of range [" << lower << ", " << upper << ")!";
+				fail();
+			}
+			return res;
+		} catch(...) {
+			ValidateBase::juryOut << "Could not parse token \"" << t << "\" as real!";
+			fail();
+			return 0;
+		}
+	}
+
+	Real realStrict(Real lower, Real upper, Integer minDecimals, Integer maxDecimals, Constraint& constraint) {
+		Real res = realStrict(lower, upper, minDecimals, maxDecimals);
+		constraint.log(lower, upper, res);
+		return res;
+	}
+
+	template<typename... Args>
+	std::vector<Real> realsStrict(Args... args, Integer count, char separator) {
+		auto sepCall = checkSeparator(separator);
+		std::vector<Real> res(count);
+		for (Integer i = 0; i < count; i++) {
+			res[i] = realStrict(args...);
+			if (i + 1 < count) sepCall();
+		}
+		return res;
+	}
+
+	std::vector<Real> realsStrict(Real lower, Real upper, Integer minDecimals, Integer maxDecimals,
+	                              Integer count, char separator = DEFAULT_SEPARATOR) {
+		return realsStrict<Real, Real, Integer, Integer>(lower, upper, minDecimals, maxDecimals, count, separator);
+	}
+
+	std::vector<Real> realsStrict(Real lower, Real upper, Integer minDecimals, Integer maxDecimals, Constraint& constraint,
+	                              Integer count, char separator = DEFAULT_SEPARATOR) {
+		return realsStrict<Real, Real, Integer, Integer, Constraint&>(lower, upper, minDecimals, maxDecimals, constraint, count, separator);
+	}
+
+	void expectString(std::string_view expected) {
+		judgeAssert<std::invalid_argument>(details::isToken(expected), "InputStream: expected must not contain a space!");
+		std::string seen = string();
+		auto [eq, pos] = details::stringEqual(seen, expected, caseSensitive);
+		if (!eq) {
+			if (seen.size() > 80) {
+				seen = seen.substr(0, 75) + "[...]";
+			}
+			ValidateBase::juryOut << "Expected \"" << expected << "\" but got \"" << seen << "\"!";
+			if (pos and *pos > 5) {
+				ValidateBase::juryOut << " (different at position: " << *pos+1 << ")";
+			}
+			fail();
+		}
+	}
+
+	void expectInt(Integer expected) {
+		Integer seen = integer();
+		if (seen != expected) {
+			ValidateBase::juryOut << "Expected " << expected << " but got " << seen << "!";
+			fail();
+		}
+	}
+
+	void expectReal(Real expected) {
+		Real seen = real();
+		if (details::floatEqual(seen, expected, floatAbsTol, floatRelTol)) {
+			ValidateBase::juryOut << "Expected " << expected << " but got " << seen << "!";
+			if (std::isfinite(seen) and std::isfinite(expected)) {
+				Real absDiff = std::abs(seen-expected);
+				Real relDiff = std::abs((seen-expected)/expected);
+				ValidateBase::juryOut << " (abs: " << absDiff << ", rel: " << relDiff << ")";
+			}
+			fail();
+		}
+	}
+private:
+	void fail() {
+		//try to find input position...
+		in->clear();
+		auto originalPos = in->tellg();
+		in->seekg(0);
+		if (originalPos != std::streamoff(-1) and *in) {
+			Integer line = 1;
+			std::size_t l = 0, r = 0;
+			std::string buffer;
+			bool extend = true;
+			while (*in and in->tellg() < originalPos) {
+				l = r = buffer.size();
+				if (std::isgraph(in->peek())) {
+					std::string tmp;
+					*in >> tmp;
+					buffer += tmp;
+				} else if (in->peek() == std::char_traits<char>::to_int_type(NEWLINE)) {
+					line++;
+					in->get();
+					if (in->tellg() < originalPos) {
+						buffer.clear();
+					} else {
+						buffer += ' ';
+						extend = false;
+					}
+				} else {
+					buffer += std::char_traits<char>::to_char_type(in->get());
+				}
+				if (*in and in->tellg() >= originalPos) {
+					r = buffer.size();
+				}
+			}
+			if (l != r) {
+				ValidateBase::juryOut << " Line: " << line << ", Char: " << l << '\n';
+				if (extend) {
+					char tmp;
+					while ((buffer.size() < 80 or buffer.size() < r + 80) and in->get(tmp) and tmp != NEWLINE) {
+						buffer += tmp;
+					}
+				}
+				if (r > 60 and l > 20) {
+					Integer offset = std::min(l - 20, r - 60);
+					l -= offset;
+					r -= offset;
+					buffer = "[...]" + buffer.substr(offset + 5);
+				}
+				if (buffer.size() > 80) {
+					buffer = buffer.substr(0, 75);
+					buffer += "[...]";
+					r = std::min(r, buffer.size());
+				}
+				ValidateBase::juryOut << buffer << '\n';
+				ValidateBase::juryOut << std::string(l, ' ') << '^' << std::string(r - l - 1, '~');
+			}
+		}
+		ValidateBase::juryOut << onFail;
+	}
+};
+
+
+//============================================================================//
+// state guard                                                                //
+//============================================================================//
+namespace details {
+	bool initialized(bool set = false) {
+		static bool value = false;
+		return std::exchange(value, value |= set);
+	}
+
+	struct InitGuard final {
+		~InitGuard() {
+			if (std::uncaught_exceptions() == 0) {
+				judgeAssert<std::logic_error>(initialized(), "validate.h: init(argc, argv) was never called!");
+			}
+		}
+	} initGuard;
+}
+
+
+//============================================================================//
+// Settings                                                                   //
+//============================================================================//
+template<typename T>
+class SettingBase {
+	template<typename U>
+	friend class Setting;
+	friend class SettingCaseSensitive;
+
+	T value;
+
+	SettingBase(T value_) : value(value_) {}
+
+public:
+	SettingBase(SettingBase<T>&& other) = delete;
+	SettingBase(const SettingBase<T>&) = delete;
+	SettingBase<T>& operator=(SettingBase<T>&& other) = delete;
+	SettingBase<T>& operator=(const SettingBase<T>&) = delete;
+
+	operator T() const {
+		return value;
+	}
+
+	SettingBase<T>& operator=(T value_) {
+		judgeAssert<std::logic_error>(!details::initialized(), "validate.h: Cannot change setting after init(argc, argv) was called!");
+		value = value_;
+		return *this;
+	}
+};
+
+template<typename T>
+class Setting final : public SettingBase<T> {
+public:
+	Setting(T value) : SettingBase<T>(value) {}
+	using SettingBase<T>::operator T;
+	using SettingBase<T>::operator=;
+};
+
+class SettingCaseSensitive final : public SettingBase<bool> {
+public:
+	SettingCaseSensitive(bool value) : SettingBase<bool>(value) {}
+	using SettingBase<bool>::operator bool;
+	using SettingBase<bool>::operator=;
+
+	std::regex regex(std::string_view s, std::regex_constants::syntax_option_type f = std::regex_constants::ECMAScript) const {
+		if (!value) f |= std::regex_constants::icase;
+		return std::regex(s.data(), s.size(), f);
+	}
+};
+
+
+//============================================================================//
+// Validators and stuff                                                       //
+//============================================================================//
+namespace ValidateBase {
+	//OutputStream juryOut(std::cout); //already defined earlier
+	//OutputStream juryErr(std::cerr);
+	CommandParser arguments;
+	//you may change these values before calling::init() but not afterwards!
+	Setting<Real> floatAbsTol(DEFAULT_EPS);
+	Setting<Real> floatRelTol(DEFAULT_EPS);
+	Setting<bool> spaceSensitive(false);
+	SettingCaseSensitive caseSensitive(false);
+
+	// Real r2 is considered the reference value for relative error.
+	bool floatEqual(Real given,
+	                Real expected,
+	                Real floatAbsTol_ = floatAbsTol,
+	                Real floatRelTol_ = floatRelTol) {
+		return details::floatEqual(given, expected, floatAbsTol_, floatRelTol_);
+	}
+
+	bool floatLess(Real given,
+	               Real expected,
+	               Real floatAbsTol_ = floatAbsTol,
+	               Real floatRelTol_ = floatRelTol) {
+		return given <= expected or floatEqual(given, expected, floatAbsTol_, floatRelTol_);
+	}
+
+	bool floatGreater(Real given,
+	                  Real expected,
+	                  Real floatAbsTol_ = floatAbsTol,
+	                  Real floatRelTol_ = floatRelTol) {
+		return given >= expected or floatEqual(given, expected, floatAbsTol_, floatRelTol_);
+	}
+
+	constexpr boolean<std::size_t> stringEqual(std::string_view a, std::string_view b, bool caseSensitive_ = caseSensitive) {
+		return details::stringEqual(a, b, caseSensitive_);
+	}
+
+	namespace details {
+		void init(int argc, char** argv) {
+			judgeAssert<std::logic_error>(!::details::initialized(), "validate.h: init(argc, argv) was called twice!");
+
+			//std::ios_base::sync_with_stdio(false);
+			//cin.tie(nullptr);
+
+			arguments = CommandParser(argc, argv);
+			if (auto seed = arguments[SEED_COMMAND]) Random::seed(seed.asInteger());
+			// parse default flags manually, since they dont use '--' prefix
+			auto eps = arguments.getRaw(FLOAT_TOLERANCE);
+			floatAbsTol = eps.asReal(floatAbsTol);
+			floatRelTol = eps.asReal(floatRelTol);
+			floatAbsTol = arguments.getRaw(FLOAT_ABSOLUTE_TOLERANCE).asReal(floatAbsTol);
+			floatRelTol = arguments.getRaw(FLOAT_RELATIVE_TOLERANCE).asReal(floatRelTol);
+
+			if (arguments.getRaw(SPACE_SENSITIVE)) spaceSensitive = true;
+			if (arguments.getRaw(CASE_SENSITIVE)) caseSensitive = true;
+
+			::details::initialized(true);
+		}
+	}
+
+} // namespace ValidateBase
+
+namespace ConstraintsBase {
+	ConstraintsLogger constraint;
+
+	void initConstraints() {
+		if (auto file = ValidateBase::arguments[CONSTRAINT_COMMAND]) {
+			constraint = ConstraintsLogger(file.asString());
+		}
+	}
+
+} // namespace ConstraintsBase
+
+//called as ./validator [arguments] < inputfile
+namespace InputValidator {
+	using namespace ValidateBase;
+	using namespace ConstraintsBase;
+
+	InputStream testIn;
+
+	void init(int argc, char** argv) {
+		spaceSensitive = true;
+		caseSensitive = true;
+
+		ValidateBase::details::init(argc, argv);
+		juryOut = OutputStream(std::cout);
+
+		testIn = InputStream(std::cin, spaceSensitive, caseSensitive, WA, floatAbsTol, floatRelTol);
+		initConstraints();
+	}
+
+} // namespace InputValidator
+
+//called as ./validator input judgeanswer feedbackdir < teamoutput
+namespace OutputValidator {
+	using namespace ValidateBase;
+	using namespace ConstraintsBase;
+
+	InputStream testIn;
+	InputStream juryAns;
+	InputStream teamAns;
+
+	void init(int argc, char** argv) {
+		ValidateBase::details::init(argc, argv);
+		juryOut = OutputStream(std::filesystem::path(arguments[3]) / JUDGE_MESSAGE);
+
+		testIn = InputStream(std::filesystem::path(arguments[1]), false, caseSensitive, FAIL);
+		juryAns = InputStream(std::filesystem::path(arguments[2]), false, caseSensitive, FAIL);
+		teamAns = InputStream(std::cin, spaceSensitive, caseSensitive, WA);
+		initConstraints();
+	}
+
+} // namespace OutputValidator
+
+//called as ./interactor input judgeanswer feedbackdir <> teamoutput
+namespace Interactor {
+	using namespace ValidateBase;
+
+	OutputStream toTeam;
+	InputStream testIn;
+	InputStream fromTeam;
+
+	void init(int argc, char** argv) {
+		ValidateBase::details::init(argc, argv);
+		juryOut = OutputStream(std::filesystem::path(arguments[3]) / JUDGE_MESSAGE);
+		toTeam = OutputStream(std::cout);
+
+		testIn = InputStream(std::filesystem::path(arguments[1]), false, caseSensitive, FAIL);
+		fromTeam = InputStream(std::cin, spaceSensitive, caseSensitive, WA);
+	}
+
+} // namespace Interactor
+
+//called as ./generator [arguments]
+namespace Generator {
+	using namespace ValidateBase;
+
+	OutputStream testOut;
+
+	void init(int argc, char** argv) {
+		ValidateBase::details::init(argc, argv);
+		juryOut = OutputStream(std::cerr);
+		testOut = OutputStream(std::cout);
+	}
+
+} // namespace Generator
+
+#endif

ICPC/nwerc2023_G/data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b249ebce9baacfa398b0ff98d8b596d8b9bf6bbe555580c7ef3ed1bd4d7bdd5c
+size 48440558

ICPC/nwerc2023_G/init.yml

@@ -0,0 +1,174 @@
+archive: data.zip
+checker:
+  args:
+    precision: 6
+  name: floats
+test_cases:
+- in: 01-cancellation.in
+  out: 01-cancellation.ans
+  points: 1
+- in: 02-min.in
+  out: 02-min.ans
+  points: 1
+- in: 03-max.in
+  out: 03-max.ans
+  points: 1
+- in: 04-max.in
+  out: 04-max.ans
+  points: 1
+- in: 05-max.in
+  out: 05-max.ans
+  points: 1
+- in: 06-max.in
+  out: 06-max.ans
+  points: 1
+- in: 07-max.in
+  out: 07-max.ans
+  points: 1
+- in: 08-tree.in
+  out: 08-tree.ans
+  points: 1
+- in: 09-tree.in
+  out: 09-tree.ans
+  points: 1
+- in: 10-near-tree.in
+  out: 10-near-tree.ans
+  points: 1
+- in: 11-near-tree.in
+  out: 11-near-tree.ans
+  points: 1
+- in: 12-complete.in
+  out: 12-complete.ans
+  points: 1
+- in: 13-boundary.in
+  out: 13-boundary.ans
+  points: 1
+- in: 14-clusters.in
+  out: 14-clusters.ans
+  points: 1
+- in: 15-sphere.in
+  out: 15-sphere.ans
+  points: 1
+- in: 16-random-special.in
+  out: 16-random-special.ans
+  points: 1
+- in: 17-random-special.in
+  out: 17-random-special.ans
+  points: 1
+- in: 18-random-special.in
+  out: 18-random-special.ans
+  points: 1
+- in: 19-random-special.in
+  out: 19-random-special.ans
+  points: 1
+- in: 20-random-special.in
+  out: 20-random-special.ans
+  points: 1
+- in: 21-random-special.in
+  out: 21-random-special.ans
+  points: 1
+- in: 22-random-special.in
+  out: 22-random-special.ans
+  points: 1
+- in: 23-random-special.in
+  out: 23-random-special.ans
+  points: 1
+- in: 24-random-special.in
+  out: 24-random-special.ans
+  points: 1
+- in: 25-random-special.in
+  out: 25-random-special.ans
+  points: 1
+- in: 26-random-small.in
+  out: 26-random-small.ans
+  points: 1
+- in: 27-random-small.in
+  out: 27-random-small.ans
+  points: 1
+- in: 28-random-small.in
+  out: 28-random-small.ans
+  points: 1
+- in: 29-random-small.in
+  out: 29-random-small.ans
+  points: 1
+- in: 30-random-small.in
+  out: 30-random-small.ans
+  points: 1
+- in: 31-random-small.in
+  out: 31-random-small.ans
+  points: 1
+- in: 32-random-small.in
+  out: 32-random-small.ans
+  points: 1
+- in: 33-random-small.in
+  out: 33-random-small.ans
+  points: 1
+- in: 34-random-small.in
+  out: 34-random-small.ans
+  points: 1
+- in: 35-random-small.in
+  out: 35-random-small.ans
+  points: 1
+- in: 36-random.in
+  out: 36-random.ans
+  points: 1
+- in: 37-random.in
+  out: 37-random.ans
+  points: 1
+- in: 38-random.in
+  out: 38-random.ans
+  points: 1
+- in: 39-random.in
+  out: 39-random.ans
+  points: 1
+- in: 40-random.in
+  out: 40-random.ans
+  points: 1
+- in: 41-random.in
+  out: 41-random.ans
+  points: 1
+- in: 42-random.in
+  out: 42-random.ans
+  points: 1
+- in: 43-random.in
+  out: 43-random.ans
+  points: 1
+- in: 44-random.in
+  out: 44-random.ans
+  points: 1
+- in: 45-random.in
+  out: 45-random.ans
+  points: 1
+- in: 46-random-small-coords.in
+  out: 46-random-small-coords.ans
+  points: 1
+- in: 47-random-small-coords.in
+  out: 47-random-small-coords.ans
+  points: 1
+- in: 48-random-small-coords.in
+  out: 48-random-small-coords.ans
+  points: 1
+- in: 49-random-small-coords.in
+  out: 49-random-small-coords.ans
+  points: 1
+- in: 50-random-small-coords.in
+  out: 50-random-small-coords.ans
+  points: 1
+- in: 51-always-last.in
+  out: 51-always-last.ans
+  points: 1
+- in: 52-anti-quadratic.in
+  out: 52-anti-quadratic.ans
+  points: 1
+- in: 53-anti-quadratic.in
+  out: 53-anti-quadratic.ans
+  points: 1
+- in: 54-anti-quadratic.in
+  out: 54-anti-quadratic.ans
+  points: 1
+- in: 55-anti-quadratic.in
+  out: 55-anti-quadratic.ans
+  points: 1
+- in: 56-anti-quadratic.in
+  out: 56-anti-quadratic.ans
+  points: 1