diff --git a/research/bit-dyadic-ternary-catalyst/CERTIFICATE.json b/research/bit-dyadic-ternary-catalyst/CERTIFICATE.json new file mode 100644 index 0000000000..9992e331db --- /dev/null +++ b/research/bit-dyadic-ternary-catalyst/CERTIFICATE.json @@ -0,0 +1,13828 @@ +{ + "schema_version": 1, + "scope": "three identical identity targets; ternary outer products divided by two; arbitrary finite restored dirty registers", + "frame_denominator": 2, + "target_scaled": [ + 2, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 2 + ], + "alphabet": [ + [ + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1 + ], + [ + -1, + -1, + -1, + -1, + -1, + -1, + 0, + 0, + 0 + ], + [ + -1, + -1, + -1, + -1, + -1, + -1, + 1, + 1, + 1 + ], + [ + -1, + -1, + -1, + 0, + 0, + 0, + -1, + -1, + -1 + ], + [ + -1, + -1, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + -1, + -1, + 0, + 0, + 0, + 1, + 1, + 1 + ], + [ + -1, + -1, + -1, + 1, + 1, + 1, + -1, + -1, + -1 + ], + [ + -1, + -1, + -1, + 1, + 1, + 1, + 0, + 0, + 0 + ], + [ + -1, + -1, + -1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + -1, + -1, + 0, + -1, + -1, + 0, + -1, + -1, + 0 + ], + [ + -1, + -1, + 0, + -1, + -1, + 0, + 0, + 0, + 0 + ], + [ + -1, + -1, + 0, + -1, + -1, + 0, + 1, + 1, + 0 + ], + [ + -1, + -1, + 0, + 0, + 0, + 0, + -1, + -1, + 0 + ], + [ + -1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + -1, + 0, + 0, + 0, + 0, + 1, + 1, + 0 + ], + [ + -1, + -1, + 0, + 1, + 1, + 0, + -1, + -1, + 0 + ], + [ + -1, + -1, + 0, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + -1, + 0, + 1, + 1, + 0, + 1, + 1, + 0 + ], + [ + -1, + -1, + 1, + -1, + -1, + 1, + -1, + -1, + 1 + ], + [ + -1, + -1, + 1, + -1, + -1, + 1, + 0, + 0, + 0 + ], + [ + -1, + -1, + 1, + -1, + -1, + 1, + 1, + 1, + -1 + ], + [ + -1, + -1, + 1, + 0, + 0, + 0, + -1, + -1, + 1 + ], + [ + -1, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + -1, + 1, + 0, + 0, + 0, + 1, + 1, + -1 + ], + [ + -1, + -1, + 1, + 1, + 1, + -1, + -1, + -1, + 1 + ], + [ + -1, + -1, + 1, + 1, + 1, + -1, + 0, + 0, + 0 + ], + [ + -1, + -1, + 1, + 1, + 1, + -1, + 1, + 1, + -1 + ], + [ + -1, + 0, + -1, + -1, + 0, + -1, + -1, + 0, + -1 + ], + [ + -1, + 0, + -1, + -1, + 0, + -1, + 0, + 0, + 0 + ], + [ + -1, + 0, + -1, + -1, + 0, + -1, + 1, + 0, + 1 + ], + [ + -1, + 0, + -1, + 0, + 0, + 0, + -1, + 0, + -1 + ], + [ + -1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + -1, + 0, + 0, + 0, + 1, + 0, + 1 + ], + [ + -1, + 0, + -1, + 1, + 0, + 1, + -1, + 0, + -1 + ], + [ + -1, + 0, + -1, + 1, + 0, + 1, + 0, + 0, + 0 + ], + [ + -1, + 0, + -1, + 1, + 0, + 1, + 1, + 0, + 1 + ], + [ + -1, + 0, + 0, + -1, + 0, + 0, + -1, + 0, + 0 + ], + [ + -1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + -1, + 0, + 0, + 1, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0 + ], + [ + -1, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0 + ], + [ + -1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0 + ], + [ + -1, + 0, + 1, + -1, + 0, + 1, + -1, + 0, + 1 + ], + [ + -1, + 0, + 1, + -1, + 0, + 1, + 0, + 0, + 0 + ], + [ + -1, + 0, + 1, + -1, + 0, + 1, + 1, + 0, + -1 + ], + [ + -1, + 0, + 1, + 0, + 0, + 0, + -1, + 0, + 1 + ], + [ + -1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + -1, + 0, + 1, + 1, + 0, + -1, + -1, + 0, + 1 + ], + [ + -1, + 0, + 1, + 1, + 0, + -1, + 0, + 0, + 0 + ], + [ + -1, + 0, + 1, + 1, + 0, + -1, + 1, + 0, + -1 + ], + [ + -1, + 1, + -1, + -1, + 1, + -1, + -1, + 1, + -1 + ], + [ + -1, + 1, + -1, + -1, + 1, + -1, + 0, + 0, + 0 + ], + [ + -1, + 1, + -1, + -1, + 1, + -1, + 1, + -1, + 1 + ], + [ + -1, + 1, + -1, + 0, + 0, + 0, + -1, + 1, + -1 + ], + [ + -1, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + -1, + 0, + 0, + 0, + 1, + -1, + 1 + ], + [ + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1 + ], + [ + -1, + 1, + -1, + 1, + -1, + 1, + 0, + 0, + 0 + ], + [ + -1, + 1, + -1, + 1, + -1, + 1, + 1, + -1, + 1 + ], + [ + -1, + 1, + 0, + -1, + 1, + 0, + -1, + 1, + 0 + ], + [ + -1, + 1, + 0, + -1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 0, + -1, + 1, + 0, + 1, + -1, + 0 + ], + [ + -1, + 1, + 0, + 0, + 0, + 0, + -1, + 1, + 0 + ], + [ + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 0, + 0, + 0, + 0, + 1, + -1, + 0 + ], + [ + -1, + 1, + 0, + 1, + -1, + 0, + -1, + 1, + 0 + ], + [ + -1, + 1, + 0, + 1, + -1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 0, + 1, + -1, + 0, + 1, + -1, + 0 + ], + [ + -1, + 1, + 1, + -1, + 1, + 1, + -1, + 1, + 1 + ], + [ + -1, + 1, + 1, + -1, + 1, + 1, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + -1, + 1, + 1, + 1, + -1, + -1 + ], + [ + -1, + 1, + 1, + 0, + 0, + 0, + -1, + 1, + 1 + ], + [ + -1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 0, + 0, + 1, + -1, + -1 + ], + [ + -1, + 1, + 1, + 1, + -1, + -1, + -1, + 1, + 1 + ], + [ + -1, + 1, + 1, + 1, + -1, + -1, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 1, + -1, + -1, + 1, + -1, + -1 + ], + [ + 0, + -1, + -1, + 0, + -1, + -1, + 0, + -1, + -1 + ], + [ + 0, + -1, + -1, + 0, + -1, + -1, + 0, + 0, + 0 + ], + [ + 0, + -1, + -1, + 0, + -1, + -1, + 0, + 1, + 1 + ], + [ + 0, + -1, + -1, + 0, + 0, + 0, + 0, + -1, + -1 + ], + [ + 0, + -1, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + -1, + -1, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + 0, + -1, + -1, + 0, + 1, + 1, + 0, + -1, + -1 + ], + [ + 0, + -1, + -1, + 0, + 1, + 1, + 0, + 0, + 0 + ], + [ + 0, + -1, + -1, + 0, + 1, + 1, + 0, + 1, + 1 + ], + [ + 0, + -1, + 0, + 0, + -1, + 0, + 0, + -1, + 0 + ], + [ + 0, + -1, + 0, + 0, + -1, + 0, + 0, + 0, + 0 + ], + [ + 0, + -1, + 0, + 0, + -1, + 0, + 0, + 1, + 0 + ], + [ + 0, + -1, + 0, + 0, + 0, + 0, + 0, + -1, + 0 + ], + [ + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + -1, + 0, + 0, + 1, + 0, + 0, + -1, + 0 + ], + [ + 0, + -1, + 0, + 0, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + -1, + 0, + 0, + 1, + 0, + 0, + 1, + 0 + ], + [ + 0, + -1, + 1, + 0, + -1, + 1, + 0, + -1, + 1 + ], + [ + 0, + -1, + 1, + 0, + -1, + 1, + 0, + 0, + 0 + ], + [ + 0, + -1, + 1, + 0, + -1, + 1, + 0, + 1, + -1 + ], + [ + 0, + -1, + 1, + 0, + 0, + 0, + 0, + -1, + 1 + ], + [ + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 1, + -1 + ], + [ + 0, + -1, + 1, + 0, + 1, + -1, + 0, + -1, + 1 + ], + [ + 0, + -1, + 1, + 0, + 1, + -1, + 0, + 0, + 0 + ], + [ + 0, + -1, + 1, + 0, + 1, + -1, + 0, + 1, + -1 + ], + [ + 0, + 0, + -1, + 0, + 0, + -1, + 0, + 0, + -1 + ], + [ + 0, + 0, + -1, + 0, + 0, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + -1, + 0, + 0, + -1, + 0, + 0, + 1 + ], + [ + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + -1, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + -1, + 0, + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + -1, + 0, + 0, + 1, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + -1, + -1, + -1, + -1, + -1, + -1 + ], + [ + 0, + 0, + 0, + -1, + -1, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + -1, + -1, + -1, + 1, + 1, + 1 + ], + [ + 0, + 0, + 0, + -1, + -1, + 0, + -1, + -1, + 0 + ], + [ + 0, + 0, + 0, + -1, + -1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + -1, + -1, + 0, + 1, + 1, + 0 + ], + [ + 0, + 0, + 0, + -1, + -1, + 1, + -1, + -1, + 1 + ], + [ + 0, + 0, + 0, + -1, + -1, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + -1, + -1, + 1, + 1, + 1, + -1 + ], + [ + 0, + 0, + 0, + -1, + 0, + -1, + -1, + 0, + -1 + ], + [ + 0, + 0, + 0, + -1, + 0, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + -1, + 0, + -1, + 1, + 0, + 1 + ], + [ + 0, + 0, + 0, + -1, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + -1, + 0, + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + -1, + 0, + 1, + -1, + 0, + 1 + ], + [ + 0, + 0, + 0, + -1, + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + -1, + 0, + 1, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + -1, + 1, + -1, + -1, + 1, + -1 + ], + [ + 0, + 0, + 0, + -1, + 1, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + -1, + 1, + -1, + 1, + -1, + 1 + ], + [ + 0, + 0, + 0, + -1, + 1, + 0, + -1, + 1, + 0 + ], + [ + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + -1, + 1, + 0, + 1, + -1, + 0 + ], + [ + 0, + 0, + 0, + -1, + 1, + 1, + -1, + 1, + 1 + ], + [ + 0, + 0, + 0, + -1, + 1, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + -1, + 1, + 1, + 1, + -1, + -1 + ], + [ + 0, + 0, + 0, + 0, + -1, + -1, + 0, + -1, + -1 + ], + [ + 0, + 0, + 0, + 0, + -1, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + -1, + -1, + 0, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + -1, + 0, + 0, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + -1, + 1, + 0, + -1, + 1 + ], + [ + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 1, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 1, + -1, + 0, + -1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 1, + -1 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 1, + 0, + -1, + -1 + ], + [ + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 1, + 1 + ], + [ + 0, + 0, + 0, + 1, + -1, + -1, + -1, + 1, + 1 + ], + [ + 0, + 0, + 0, + 1, + -1, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + -1, + -1, + 1, + -1, + -1 + ], + [ + 0, + 0, + 0, + 1, + -1, + 0, + -1, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + -1, + 0, + 1, + -1, + 0 + ], + [ + 0, + 0, + 0, + 1, + -1, + 1, + -1, + 1, + -1 + ], + [ + 0, + 0, + 0, + 1, + -1, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + -1, + 1, + 1, + -1, + 1 + ], + [ + 0, + 0, + 0, + 1, + 0, + -1, + -1, + 0, + 1 + ], + [ + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + -1, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 1, + -1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 1, + 1, + 0, + 1 + ], + [ + 0, + 0, + 0, + 1, + 1, + -1, + -1, + -1, + 1 + ], + [ + 0, + 0, + 0, + 1, + 1, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 1, + -1, + 1, + 1, + -1 + ], + [ + 0, + 0, + 0, + 1, + 1, + 0, + -1, + -1, + 0 + ], + [ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 1, + 0, + 1, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1, + 1, + 1, + -1, + -1, + -1 + ], + [ + 0, + 0, + 0, + 1, + 1, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 1 + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 1 + ], + [ + 0, + 1, + -1, + 0, + -1, + 1, + 0, + -1, + 1 + ], + [ + 0, + 1, + -1, + 0, + -1, + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + -1, + 0, + -1, + 1, + 0, + 1, + -1 + ], + [ + 0, + 1, + -1, + 0, + 0, + 0, + 0, + -1, + 1 + ], + [ + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 1, + -1 + ], + [ + 0, + 1, + -1, + 0, + 1, + -1, + 0, + -1, + 1 + ], + [ + 0, + 1, + -1, + 0, + 1, + -1, + 0, + 0, + 0 + ], + [ + 0, + 1, + -1, + 0, + 1, + -1, + 0, + 1, + -1 + ], + [ + 0, + 1, + 0, + 0, + -1, + 0, + 0, + -1, + 0 + ], + [ + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 1, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + -1, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + -1, + 0 + ], + [ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 1, + 0 + ], + [ + 0, + 1, + 1, + 0, + -1, + -1, + 0, + -1, + -1 + ], + [ + 0, + 1, + 1, + 0, + -1, + -1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 1, + 0, + -1, + -1, + 0, + 1, + 1 + ], + [ + 0, + 1, + 1, + 0, + 0, + 0, + 0, + -1, + -1 + ], + [ + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + 0, + 1, + 1, + 0, + 1, + 1, + 0, + -1, + -1 + ], + [ + 0, + 1, + 1, + 0, + 1, + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1 + ], + [ + 1, + -1, + -1, + -1, + 1, + 1, + -1, + 1, + 1 + ], + [ + 1, + -1, + -1, + -1, + 1, + 1, + 0, + 0, + 0 + ], + [ + 1, + -1, + -1, + -1, + 1, + 1, + 1, + -1, + -1 + ], + [ + 1, + -1, + -1, + 0, + 0, + 0, + -1, + 1, + 1 + ], + [ + 1, + -1, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + -1, + -1, + 0, + 0, + 0, + 1, + -1, + -1 + ], + [ + 1, + -1, + -1, + 1, + -1, + -1, + -1, + 1, + 1 + ], + [ + 1, + -1, + -1, + 1, + -1, + -1, + 0, + 0, + 0 + ], + [ + 1, + -1, + -1, + 1, + -1, + -1, + 1, + -1, + -1 + ], + [ + 1, + -1, + 0, + -1, + 1, + 0, + -1, + 1, + 0 + ], + [ + 1, + -1, + 0, + -1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 1, + -1, + 0, + -1, + 1, + 0, + 1, + -1, + 0 + ], + [ + 1, + -1, + 0, + 0, + 0, + 0, + -1, + 1, + 0 + ], + [ + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + -1, + 0, + 0, + 0, + 0, + 1, + -1, + 0 + ], + [ + 1, + -1, + 0, + 1, + -1, + 0, + -1, + 1, + 0 + ], + [ + 1, + -1, + 0, + 1, + -1, + 0, + 0, + 0, + 0 + ], + [ + 1, + -1, + 0, + 1, + -1, + 0, + 1, + -1, + 0 + ], + [ + 1, + -1, + 1, + -1, + 1, + -1, + -1, + 1, + -1 + ], + [ + 1, + -1, + 1, + -1, + 1, + -1, + 0, + 0, + 0 + ], + [ + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1 + ], + [ + 1, + -1, + 1, + 0, + 0, + 0, + -1, + 1, + -1 + ], + [ + 1, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + -1, + 1, + 0, + 0, + 0, + 1, + -1, + 1 + ], + [ + 1, + -1, + 1, + 1, + -1, + 1, + -1, + 1, + -1 + ], + [ + 1, + -1, + 1, + 1, + -1, + 1, + 0, + 0, + 0 + ], + [ + 1, + -1, + 1, + 1, + -1, + 1, + 1, + -1, + 1 + ], + [ + 1, + 0, + -1, + -1, + 0, + 1, + -1, + 0, + 1 + ], + [ + 1, + 0, + -1, + -1, + 0, + 1, + 0, + 0, + 0 + ], + [ + 1, + 0, + -1, + -1, + 0, + 1, + 1, + 0, + -1 + ], + [ + 1, + 0, + -1, + 0, + 0, + 0, + -1, + 0, + 1 + ], + [ + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + -1, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 1, + 0, + -1, + 1, + 0, + -1, + -1, + 0, + 1 + ], + [ + 1, + 0, + -1, + 1, + 0, + -1, + 0, + 0, + 0 + ], + [ + 1, + 0, + -1, + 1, + 0, + -1, + 1, + 0, + -1 + ], + [ + 1, + 0, + 0, + -1, + 0, + 0, + -1, + 0, + 0 + ], + [ + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + -1, + 0, + 0, + 1, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0 + ], + [ + 1, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0 + ], + [ + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0 + ], + [ + 1, + 0, + 1, + -1, + 0, + -1, + -1, + 0, + -1 + ], + [ + 1, + 0, + 1, + -1, + 0, + -1, + 0, + 0, + 0 + ], + [ + 1, + 0, + 1, + -1, + 0, + -1, + 1, + 0, + 1 + ], + [ + 1, + 0, + 1, + 0, + 0, + 0, + -1, + 0, + -1 + ], + [ + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 1 + ], + [ + 1, + 0, + 1, + 1, + 0, + 1, + -1, + 0, + -1 + ], + [ + 1, + 0, + 1, + 1, + 0, + 1, + 0, + 0, + 0 + ], + [ + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 0, + 1 + ], + [ + 1, + 1, + -1, + -1, + -1, + 1, + -1, + -1, + 1 + ], + [ + 1, + 1, + -1, + -1, + -1, + 1, + 0, + 0, + 0 + ], + [ + 1, + 1, + -1, + -1, + -1, + 1, + 1, + 1, + -1 + ], + [ + 1, + 1, + -1, + 0, + 0, + 0, + -1, + -1, + 1 + ], + [ + 1, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + -1, + 0, + 0, + 0, + 1, + 1, + -1 + ], + [ + 1, + 1, + -1, + 1, + 1, + -1, + -1, + -1, + 1 + ], + [ + 1, + 1, + -1, + 1, + 1, + -1, + 0, + 0, + 0 + ], + [ + 1, + 1, + -1, + 1, + 1, + -1, + 1, + 1, + -1 + ], + [ + 1, + 1, + 0, + -1, + -1, + 0, + -1, + -1, + 0 + ], + [ + 1, + 1, + 0, + -1, + -1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 0, + -1, + -1, + 0, + 1, + 1, + 0 + ], + [ + 1, + 1, + 0, + 0, + 0, + 0, + -1, + -1, + 0 + ], + [ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 0 + ], + [ + 1, + 1, + 0, + 1, + 1, + 0, + -1, + -1, + 0 + ], + [ + 1, + 1, + 0, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 0 + ], + [ + 1, + 1, + 1, + -1, + -1, + -1, + -1, + -1, + -1 + ], + [ + 1, + 1, + 1, + -1, + -1, + -1, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + -1, + -1, + -1, + 1, + 1, + 1 + ], + [ + 1, + 1, + 1, + 0, + 0, + 0, + -1, + -1, + -1 + ], + [ + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + -1 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ] + ], + "decompositions_three": [ + [ + 89, + 304, + 326 + ], + [ + 105, + 284, + 328 + ], + [ + 137, + 260, + 336 + ], + [ + 141, + 280, + 318 + ], + [ + 212, + 258, + 334 + ], + [ + 220, + 276, + 314 + ], + [ + 236, + 266, + 310 + ], + [ + 256, + 268, + 290 + ] + ], + "decompositions_four": [ + [ + 4, + 276, + 314, + 337 + ], + [ + 5, + 276, + 314, + 336 + ], + [ + 7, + 276, + 314, + 334 + ], + [ + 8, + 276, + 314, + 333 + ], + [ + 8, + 293, + 304, + 326 + ], + [ + 10, + 267, + 317, + 337 + ], + [ + 15, + 284, + 304, + 328 + ], + [ + 16, + 267, + 314, + 334 + ], + [ + 16, + 284, + 304, + 327 + ], + [ + 17, + 284, + 304, + 326 + ], + [ + 21, + 258, + 318, + 334 + ], + [ + 22, + 258, + 317, + 334 + ], + [ + 24, + 258, + 315, + 334 + ], + [ + 24, + 284, + 295, + 328 + ], + [ + 25, + 258, + 314, + 334 + ], + [ + 29, + 266, + 310, + 326 + ], + [ + 30, + 277, + 287, + 337 + ], + [ + 32, + 266, + 307, + 326 + ], + [ + 32, + 276, + 287, + 336 + ], + [ + 35, + 266, + 304, + 326 + ], + [ + 36, + 268, + 290, + 337 + ], + [ + 38, + 266, + 310, + 317 + ], + [ + 42, + 277, + 284, + 328 + ], + [ + 44, + 257, + 304, + 326 + ], + [ + 45, + 268, + 290, + 328 + ], + [ + 48, + 258, + 307, + 318 + ], + [ + 48, + 268, + 287, + 328 + ], + [ + 50, + 257, + 307, + 317 + ], + [ + 51, + 268, + 284, + 328 + ], + [ + 55, + 260, + 280, + 336 + ], + [ + 56, + 260, + 279, + 336 + ], + [ + 56, + 266, + 299, + 310 + ], + [ + 58, + 260, + 277, + 336 + ], + [ + 59, + 260, + 276, + 336 + ], + [ + 63, + 268, + 290, + 310 + ], + [ + 64, + 260, + 280, + 327 + ], + [ + 64, + 267, + 290, + 310 + ], + [ + 65, + 266, + 290, + 310 + ], + [ + 70, + 257, + 277, + 327 + ], + [ + 72, + 261, + 280, + 318 + ], + [ + 72, + 268, + 290, + 301 + ], + [ + 73, + 260, + 280, + 318 + ], + [ + 75, + 258, + 280, + 318 + ], + [ + 76, + 257, + 280, + 318 + ], + [ + 83, + 256, + 268, + 326 + ], + [ + 85, + 185, + 293, + 337 + ], + [ + 85, + 193, + 304, + 326 + ], + [ + 86, + 137, + 296, + 336 + ], + [ + 86, + 139, + 307, + 326 + ], + [ + 86, + 185, + 294, + 336 + ], + [ + 86, + 192, + 304, + 326 + ], + [ + 86, + 233, + 276, + 336 + ], + [ + 86, + 253, + 268, + 326 + ], + [ + 87, + 256, + 290, + 304 + ], + [ + 88, + 106, + 314, + 334 + ], + [ + 88, + 161, + 304, + 327 + ], + [ + 88, + 172, + 304, + 326 + ], + [ + 88, + 185, + 296, + 334 + ], + [ + 88, + 212, + 294, + 334 + ], + [ + 88, + 255, + 290, + 304 + ], + [ + 89, + 96, + 326, + 331 + ], + [ + 89, + 105, + 315, + 333 + ], + [ + 89, + 105, + 320, + 328 + ], + [ + 89, + 105, + 321, + 327 + ], + [ + 89, + 105, + 322, + 326 + ], + [ + 89, + 105, + 323, + 325 + ], + [ + 89, + 105, + 324, + 324 + ], + [ + 89, + 110, + 304, + 335 + ], + [ + 89, + 127, + 307, + 326 + ], + [ + 89, + 128, + 306, + 326 + ], + [ + 89, + 137, + 299, + 333 + ], + [ + 89, + 157, + 304, + 327 + ], + [ + 89, + 167, + 303, + 327 + ], + [ + 89, + 178, + 303, + 326 + ], + [ + 89, + 185, + 297, + 333 + ], + [ + 89, + 185, + 306, + 324 + ], + [ + 89, + 186, + 307, + 323 + ], + [ + 89, + 212, + 295, + 333 + ], + [ + 89, + 215, + 304, + 324 + ], + [ + 89, + 216, + 304, + 323 + ], + [ + 89, + 223, + 295, + 326 + ], + [ + 89, + 227, + 304, + 317 + ], + [ + 89, + 236, + 279, + 333 + ], + [ + 89, + 236, + 302, + 310 + ], + [ + 89, + 236, + 303, + 309 + ], + [ + 89, + 236, + 304, + 308 + ], + [ + 89, + 236, + 305, + 307 + ], + [ + 89, + 236, + 306, + 306 + ], + [ + 89, + 241, + 277, + 326 + ], + [ + 89, + 245, + 299, + 304 + ], + [ + 89, + 250, + 268, + 326 + ], + [ + 89, + 254, + 290, + 304 + ], + [ + 90, + 236, + 266, + 337 + ], + [ + 92, + 256, + 268, + 317 + ], + [ + 93, + 136, + 287, + 337 + ], + [ + 93, + 141, + 307, + 318 + ], + [ + 95, + 137, + 287, + 336 + ], + [ + 95, + 142, + 307, + 317 + ], + [ + 96, + 98, + 314, + 334 + ], + [ + 96, + 110, + 293, + 337 + ], + [ + 96, + 127, + 287, + 337 + ], + [ + 96, + 142, + 290, + 334 + ], + [ + 96, + 189, + 287, + 334 + ], + [ + 96, + 213, + 284, + 334 + ], + [ + 96, + 223, + 284, + 328 + ], + [ + 96, + 245, + 260, + 334 + ], + [ + 96, + 247, + 287, + 307 + ], + [ + 96, + 256, + 290, + 295 + ], + [ + 97, + 97, + 314, + 334 + ], + [ + 97, + 128, + 287, + 336 + ], + [ + 97, + 132, + 307, + 318 + ], + [ + 97, + 188, + 287, + 334 + ], + [ + 97, + 190, + 307, + 314 + ], + [ + 97, + 212, + 285, + 334 + ], + [ + 97, + 220, + 303, + 314 + ], + [ + 97, + 246, + 287, + 307 + ], + [ + 98, + 105, + 311, + 328 + ], + [ + 98, + 116, + 304, + 326 + ], + [ + 98, + 133, + 307, + 317 + ], + [ + 98, + 136, + 310, + 314 + ], + [ + 98, + 189, + 307, + 314 + ], + [ + 98, + 219, + 304, + 314 + ], + [ + 98, + 229, + 295, + 317 + ], + [ + 98, + 236, + 293, + 310 + ], + [ + 98, + 245, + 287, + 307 + ], + [ + 98, + 247, + 280, + 314 + ], + [ + 99, + 236, + 266, + 328 + ], + [ + 102, + 139, + 287, + 328 + ], + [ + 102, + 141, + 298, + 318 + ], + [ + 102, + 186, + 284, + 328 + ], + [ + 102, + 193, + 294, + 318 + ], + [ + 102, + 233, + 266, + 328 + ], + [ + 102, + 253, + 258, + 318 + ], + [ + 103, + 185, + 284, + 328 + ], + [ + 103, + 193, + 295, + 317 + ], + [ + 105, + 108, + 284, + 337 + ], + [ + 105, + 116, + 293, + 328 + ], + [ + 105, + 132, + 288, + 328 + ], + [ + 105, + 133, + 287, + 328 + ], + [ + 105, + 141, + 301, + 315 + ], + [ + 105, + 161, + 285, + 328 + ], + [ + 105, + 172, + 285, + 327 + ], + [ + 105, + 180, + 284, + 327 + ], + [ + 105, + 192, + 287, + 325 + ], + [ + 105, + 193, + 288, + 324 + ], + [ + 105, + 193, + 297, + 315 + ], + [ + 105, + 216, + 284, + 325 + ], + [ + 105, + 217, + 284, + 324 + ], + [ + 105, + 220, + 293, + 315 + ], + [ + 105, + 229, + 284, + 319 + ], + [ + 105, + 230, + 266, + 328 + ], + [ + 105, + 238, + 284, + 310 + ], + [ + 105, + 239, + 257, + 328 + ], + [ + 105, + 247, + 284, + 301 + ], + [ + 105, + 256, + 261, + 315 + ], + [ + 105, + 256, + 284, + 292 + ], + [ + 105, + 256, + 285, + 291 + ], + [ + 105, + 256, + 286, + 290 + ], + [ + 105, + 256, + 287, + 289 + ], + [ + 105, + 256, + 288, + 288 + ], + [ + 106, + 167, + 284, + 328 + ], + [ + 106, + 178, + 284, + 327 + ], + [ + 106, + 193, + 298, + 314 + ], + [ + 106, + 220, + 294, + 314 + ], + [ + 106, + 237, + 284, + 310 + ], + [ + 107, + 236, + 284, + 310 + ], + [ + 109, + 141, + 280, + 327 + ], + [ + 109, + 158, + 267, + 337 + ], + [ + 110, + 116, + 276, + 336 + ], + [ + 110, + 157, + 267, + 337 + ], + [ + 110, + 164, + 268, + 336 + ], + [ + 110, + 169, + 267, + 336 + ], + [ + 110, + 175, + 266, + 336 + ], + [ + 110, + 223, + 258, + 336 + ], + [ + 110, + 229, + 267, + 327 + ], + [ + 110, + 245, + 266, + 310 + ], + [ + 110, + 256, + 268, + 299 + ], + [ + 113, + 113, + 276, + 336 + ], + [ + 113, + 137, + 269, + 336 + ], + [ + 113, + 138, + 280, + 327 + ], + [ + 113, + 155, + 267, + 336 + ], + [ + 113, + 184, + 276, + 327 + ], + [ + 113, + 215, + 267, + 334 + ], + [ + 113, + 220, + 276, + 323 + ], + [ + 113, + 226, + 267, + 327 + ], + [ + 114, + 256, + 277, + 290 + ], + [ + 115, + 164, + 277, + 327 + ], + [ + 115, + 212, + 267, + 334 + ], + [ + 116, + 158, + 276, + 328 + ], + [ + 116, + 163, + 277, + 327 + ], + [ + 116, + 169, + 276, + 327 + ], + [ + 116, + 181, + 276, + 326 + ], + [ + 116, + 223, + 267, + 327 + ], + [ + 116, + 229, + 276, + 318 + ], + [ + 116, + 236, + 275, + 310 + ], + [ + 116, + 247, + 277, + 299 + ], + [ + 118, + 212, + 258, + 337 + ], + [ + 119, + 212, + 258, + 336 + ], + [ + 123, + 220, + 276, + 318 + ], + [ + 124, + 220, + 276, + 317 + ], + [ + 128, + 188, + 260, + 336 + ], + [ + 128, + 193, + 270, + 326 + ], + [ + 128, + 203, + 258, + 336 + ], + [ + 128, + 211, + 266, + 326 + ], + [ + 129, + 185, + 261, + 337 + ], + [ + 129, + 193, + 280, + 318 + ], + [ + 131, + 185, + 260, + 336 + ], + [ + 131, + 193, + 279, + 317 + ], + [ + 132, + 185, + 270, + 328 + ], + [ + 132, + 190, + 280, + 318 + ], + [ + 132, + 203, + 268, + 328 + ], + [ + 132, + 211, + 276, + 318 + ], + [ + 135, + 220, + 280, + 314 + ], + [ + 136, + 141, + 283, + 318 + ], + [ + 136, + 142, + 290, + 310 + ], + [ + 136, + 158, + 261, + 337 + ], + [ + 136, + 175, + 260, + 336 + ], + [ + 136, + 189, + 287, + 310 + ], + [ + 136, + 213, + 284, + 310 + ], + [ + 136, + 219, + 287, + 307 + ], + [ + 136, + 220, + 279, + 314 + ], + [ + 136, + 245, + 260, + 310 + ], + [ + 137, + 141, + 264, + 336 + ], + [ + 137, + 141, + 273, + 327 + ], + [ + 137, + 141, + 282, + 318 + ], + [ + 137, + 141, + 291, + 309 + ], + [ + 137, + 141, + 299, + 301 + ], + [ + 137, + 141, + 300, + 300 + ], + [ + 137, + 142, + 263, + 336 + ], + [ + 137, + 156, + 260, + 337 + ], + [ + 137, + 164, + 261, + 336 + ], + [ + 137, + 181, + 260, + 335 + ], + [ + 137, + 184, + 269, + 327 + ], + [ + 137, + 190, + 287, + 309 + ], + [ + 137, + 193, + 296, + 300 + ], + [ + 137, + 193, + 297, + 299 + ], + [ + 137, + 194, + 258, + 336 + ], + [ + 137, + 195, + 257, + 336 + ], + [ + 137, + 218, + 260, + 334 + ], + [ + 137, + 219, + 260, + 333 + ], + [ + 137, + 220, + 260, + 332 + ], + [ + 137, + 220, + 269, + 323 + ], + [ + 137, + 220, + 278, + 314 + ], + [ + 137, + 220, + 287, + 305 + ], + [ + 137, + 220, + 293, + 299 + ], + [ + 137, + 220, + 296, + 296 + ], + [ + 137, + 228, + 260, + 327 + ], + [ + 137, + 246, + 260, + 309 + ], + [ + 137, + 255, + 260, + 300 + ], + [ + 137, + 256, + 261, + 299 + ], + [ + 138, + 140, + 290, + 310 + ], + [ + 138, + 184, + 280, + 318 + ], + [ + 138, + 185, + 288, + 310 + ], + [ + 138, + 217, + 280, + 314 + ], + [ + 138, + 236, + 270, + 310 + ], + [ + 139, + 139, + 290, + 310 + ], + [ + 139, + 186, + 287, + 310 + ], + [ + 139, + 192, + 290, + 307 + ], + [ + 139, + 216, + 287, + 307 + ], + [ + 139, + 236, + 269, + 310 + ], + [ + 139, + 256, + 271, + 290 + ], + [ + 140, + 155, + 260, + 336 + ], + [ + 140, + 193, + 290, + 306 + ], + [ + 140, + 215, + 260, + 334 + ], + [ + 140, + 226, + 260, + 327 + ], + [ + 140, + 256, + 270, + 290 + ], + [ + 141, + 155, + 271, + 327 + ], + [ + 141, + 158, + 280, + 319 + ], + [ + 141, + 175, + 279, + 318 + ], + [ + 141, + 179, + 280, + 317 + ], + [ + 141, + 185, + 297, + 301 + ], + [ + 141, + 185, + 298, + 300 + ], + [ + 141, + 188, + 291, + 307 + ], + [ + 141, + 201, + 277, + 318 + ], + [ + 141, + 202, + 276, + 318 + ], + [ + 141, + 212, + 262, + 334 + ], + [ + 141, + 212, + 271, + 325 + ], + [ + 141, + 212, + 280, + 316 + ], + [ + 141, + 212, + 289, + 307 + ], + [ + 141, + 212, + 295, + 301 + ], + [ + 141, + 212, + 298, + 298 + ], + [ + 141, + 213, + 280, + 315 + ], + [ + 141, + 214, + 280, + 314 + ], + [ + 141, + 226, + 271, + 318 + ], + [ + 141, + 236, + 279, + 301 + ], + [ + 141, + 237, + 280, + 300 + ], + [ + 141, + 246, + 280, + 291 + ], + [ + 142, + 164, + 280, + 318 + ], + [ + 142, + 181, + 279, + 317 + ], + [ + 142, + 189, + 290, + 307 + ], + [ + 142, + 212, + 261, + 334 + ], + [ + 142, + 213, + 287, + 307 + ], + [ + 142, + 219, + 290, + 304 + ], + [ + 142, + 247, + 280, + 290 + ], + [ + 143, + 212, + 260, + 334 + ], + [ + 144, + 185, + 257, + 337 + ], + [ + 146, + 185, + 258, + 336 + ], + [ + 146, + 193, + 268, + 326 + ], + [ + 150, + 185, + 266, + 328 + ], + [ + 150, + 193, + 276, + 318 + ], + [ + 152, + 193, + 277, + 317 + ], + [ + 155, + 155, + 258, + 336 + ], + [ + 155, + 184, + 267, + 327 + ], + [ + 155, + 215, + 258, + 334 + ], + [ + 155, + 220, + 267, + 323 + ], + [ + 155, + 226, + 258, + 327 + ], + [ + 158, + 164, + 268, + 328 + ], + [ + 158, + 169, + 267, + 328 + ], + [ + 158, + 175, + 266, + 328 + ], + [ + 158, + 181, + 267, + 327 + ], + [ + 158, + 213, + 258, + 334 + ], + [ + 158, + 220, + 276, + 315 + ], + [ + 158, + 223, + 258, + 328 + ], + [ + 161, + 161, + 268, + 328 + ], + [ + 161, + 167, + 267, + 328 + ], + [ + 161, + 172, + 268, + 327 + ], + [ + 161, + 178, + 267, + 327 + ], + [ + 161, + 237, + 267, + 310 + ], + [ + 161, + 256, + 268, + 291 + ], + [ + 162, + 220, + 277, + 314 + ], + [ + 163, + 236, + 267, + 310 + ], + [ + 164, + 169, + 268, + 327 + ], + [ + 164, + 175, + 267, + 327 + ], + [ + 164, + 181, + 268, + 326 + ], + [ + 164, + 212, + 259, + 334 + ], + [ + 164, + 219, + 277, + 315 + ], + [ + 164, + 229, + 268, + 318 + ], + [ + 167, + 167, + 266, + 328 + ], + [ + 167, + 172, + 267, + 327 + ], + [ + 167, + 178, + 266, + 327 + ], + [ + 167, + 237, + 266, + 310 + ], + [ + 167, + 256, + 267, + 291 + ], + [ + 169, + 169, + 267, + 327 + ], + [ + 169, + 175, + 266, + 327 + ], + [ + 169, + 181, + 267, + 326 + ], + [ + 169, + 223, + 258, + 327 + ], + [ + 169, + 229, + 267, + 318 + ], + [ + 172, + 172, + 268, + 326 + ], + [ + 172, + 178, + 267, + 326 + ], + [ + 172, + 236, + 267, + 309 + ], + [ + 172, + 255, + 268, + 290 + ], + [ + 173, + 212, + 257, + 334 + ], + [ + 174, + 223, + 257, + 327 + ], + [ + 174, + 256, + 267, + 290 + ], + [ + 175, + 181, + 266, + 326 + ], + [ + 175, + 213, + 257, + 333 + ], + [ + 175, + 220, + 275, + 314 + ], + [ + 175, + 222, + 257, + 327 + ], + [ + 175, + 229, + 266, + 318 + ], + [ + 178, + 178, + 266, + 326 + ], + [ + 178, + 236, + 266, + 309 + ], + [ + 178, + 255, + 267, + 290 + ], + [ + 180, + 229, + 267, + 317 + ], + [ + 181, + 212, + 258, + 333 + ], + [ + 181, + 219, + 276, + 314 + ], + [ + 181, + 223, + 258, + 326 + ], + [ + 181, + 228, + 267, + 317 + ], + [ + 184, + 184, + 276, + 318 + ], + [ + 184, + 212, + 267, + 325 + ], + [ + 184, + 217, + 276, + 314 + ], + [ + 184, + 226, + 267, + 318 + ], + [ + 185, + 187, + 284, + 310 + ], + [ + 185, + 191, + 260, + 334 + ], + [ + 185, + 193, + 261, + 333 + ], + [ + 185, + 193, + 270, + 324 + ], + [ + 185, + 193, + 279, + 315 + ], + [ + 185, + 193, + 288, + 306 + ], + [ + 185, + 193, + 293, + 301 + ], + [ + 185, + 193, + 294, + 300 + ], + [ + 185, + 193, + 295, + 299 + ], + [ + 185, + 193, + 296, + 298 + ], + [ + 185, + 193, + 297, + 297 + ], + [ + 185, + 206, + 258, + 334 + ], + [ + 185, + 208, + 257, + 333 + ], + [ + 185, + 211, + 266, + 324 + ], + [ + 185, + 217, + 284, + 306 + ], + [ + 185, + 220, + 293, + 297 + ], + [ + 185, + 220, + 294, + 296 + ], + [ + 185, + 234, + 266, + 310 + ], + [ + 185, + 252, + 257, + 301 + ], + [ + 185, + 253, + 258, + 300 + ], + [ + 185, + 255, + 260, + 298 + ], + [ + 185, + 256, + 261, + 297 + ], + [ + 185, + 256, + 270, + 288 + ], + [ + 186, + 186, + 284, + 310 + ], + [ + 186, + 192, + 287, + 307 + ], + [ + 186, + 216, + 284, + 307 + ], + [ + 186, + 233, + 266, + 310 + ], + [ + 186, + 256, + 271, + 287 + ], + [ + 187, + 193, + 280, + 314 + ], + [ + 188, + 188, + 260, + 334 + ], + [ + 188, + 190, + 287, + 307 + ], + [ + 188, + 203, + 258, + 334 + ], + [ + 188, + 220, + 287, + 303 + ], + [ + 188, + 246, + 260, + 307 + ], + [ + 189, + 189, + 287, + 307 + ], + [ + 189, + 213, + 284, + 307 + ], + [ + 189, + 219, + 287, + 304 + ], + [ + 189, + 245, + 260, + 307 + ], + [ + 189, + 247, + 280, + 287 + ], + [ + 190, + 190, + 280, + 314 + ], + [ + 190, + 211, + 276, + 314 + ], + [ + 190, + 212, + 285, + 307 + ], + [ + 190, + 246, + 280, + 287 + ], + [ + 191, + 193, + 290, + 304 + ], + [ + 192, + 192, + 290, + 304 + ], + [ + 192, + 216, + 287, + 304 + ], + [ + 192, + 236, + 269, + 307 + ], + [ + 192, + 253, + 268, + 290 + ], + [ + 193, + 203, + 268, + 324 + ], + [ + 193, + 206, + 277, + 315 + ], + [ + 193, + 208, + 276, + 314 + ], + [ + 193, + 212, + 294, + 298 + ], + [ + 193, + 212, + 295, + 297 + ], + [ + 193, + 215, + 288, + 304 + ], + [ + 193, + 233, + 276, + 300 + ], + [ + 193, + 234, + 277, + 299 + ], + [ + 193, + 236, + 270, + 306 + ], + [ + 193, + 236, + 279, + 297 + ], + [ + 193, + 237, + 280, + 296 + ], + [ + 193, + 252, + 268, + 290 + ], + [ + 203, + 246, + 258, + 307 + ], + [ + 203, + 256, + 268, + 288 + ], + [ + 204, + 245, + 257, + 307 + ], + [ + 204, + 256, + 268, + 287 + ], + [ + 210, + 236, + 266, + 307 + ], + [ + 210, + 247, + 277, + 287 + ], + [ + 211, + 236, + 266, + 306 + ], + [ + 211, + 246, + 276, + 287 + ], + [ + 212, + 219, + 258, + 331 + ], + [ + 212, + 220, + 258, + 330 + ], + [ + 212, + 220, + 267, + 321 + ], + [ + 212, + 220, + 276, + 312 + ], + [ + 212, + 220, + 285, + 303 + ], + [ + 212, + 220, + 293, + 295 + ], + [ + 212, + 220, + 294, + 294 + ], + [ + 212, + 226, + 258, + 325 + ], + [ + 212, + 244, + 258, + 307 + ], + [ + 212, + 253, + 258, + 298 + ], + [ + 212, + 256, + 261, + 295 + ], + [ + 213, + 219, + 284, + 304 + ], + [ + 213, + 220, + 276, + 311 + ], + [ + 213, + 242, + 257, + 307 + ], + [ + 213, + 247, + 280, + 284 + ], + [ + 215, + 217, + 284, + 304 + ], + [ + 216, + 216, + 284, + 304 + ], + [ + 216, + 233, + 266, + 307 + ], + [ + 216, + 253, + 268, + 287 + ], + [ + 217, + 226, + 267, + 314 + ], + [ + 219, + 244, + 277, + 287 + ], + [ + 219, + 245, + 260, + 304 + ], + [ + 220, + 222, + 267, + 314 + ], + [ + 220, + 233, + 276, + 296 + ], + [ + 220, + 236, + 279, + 293 + ], + [ + 220, + 242, + 276, + 287 + ], + [ + 221, + 236, + 257, + 310 + ], + [ + 223, + 229, + 258, + 318 + ], + [ + 223, + 245, + 257, + 301 + ], + [ + 223, + 256, + 259, + 290 + ], + [ + 226, + 226, + 258, + 318 + ], + [ + 229, + 236, + 266, + 301 + ], + [ + 229, + 247, + 268, + 290 + ], + [ + 236, + 247, + 266, + 283 + ], + [ + 236, + 256, + 261, + 279 + ], + [ + 236, + 256, + 266, + 274 + ], + [ + 236, + 256, + 267, + 273 + ], + [ + 236, + 256, + 268, + 272 + ], + [ + 236, + 256, + 269, + 271 + ], + [ + 236, + 256, + 270, + 270 + ], + [ + 237, + 255, + 260, + 280 + ], + [ + 245, + 247, + 260, + 280 + ], + [ + 245, + 256, + 263, + 268 + ], + [ + 246, + 246, + 260, + 280 + ] + ], + "complements_five": [ + [ + 89, + 277, + 293, + 317, + 337 + ], + [ + 96, + 257, + 304, + 317, + 337 + ], + [ + 98, + 277, + 284, + 317, + 337 + ], + [ + 105, + 257, + 295, + 317, + 337 + ], + [ + 110, + 257, + 277, + 326, + 337 + ], + [ + 116, + 266, + 277, + 317, + 337 + ], + [ + 136, + 257, + 280, + 317, + 337 + ], + [ + 137, + 257, + 279, + 317, + 337 + ], + [ + 141, + 261, + 277, + 317, + 337 + ], + [ + 142, + 260, + 277, + 317, + 337 + ], + [ + 158, + 257, + 277, + 318, + 337 + ], + [ + 164, + 258, + 277, + 317, + 337 + ], + [ + 175, + 257, + 276, + 317, + 337 + ], + [ + 181, + 257, + 277, + 317, + 336 + ], + [ + 212, + 257, + 277, + 315, + 337 + ], + [ + 213, + 257, + 277, + 314, + 337 + ], + [ + 219, + 257, + 277, + 317, + 334 + ], + [ + 220, + 257, + 277, + 317, + 333 + ], + [ + 223, + 257, + 268, + 317, + 337 + ], + [ + 229, + 257, + 277, + 317, + 328 + ], + [ + 236, + 257, + 277, + 299, + 337 + ], + [ + 245, + 257, + 277, + 290, + 337 + ], + [ + 247, + 257, + 277, + 310, + 317 + ], + [ + 256, + 257, + 277, + 301, + 317 + ] + ], + "candidates_seven": [ + [ + 89, + 257, + 277, + 304, + 317, + 326, + 337 + ], + [ + 105, + 257, + 277, + 284, + 317, + 328, + 337 + ], + [ + 137, + 257, + 260, + 277, + 317, + 336, + 337 + ], + [ + 141, + 257, + 277, + 280, + 317, + 318, + 337 + ], + [ + 212, + 257, + 258, + 277, + 317, + 334, + 337 + ], + [ + 220, + 257, + 276, + 277, + 314, + 317, + 337 + ], + [ + 236, + 257, + 266, + 277, + 310, + 317, + 337 + ], + [ + 256, + 257, + 268, + 277, + 290, + 317, + 337 + ] + ], + "candidates_eight": [ + [ + 4, + 257, + 276, + 277, + 314, + 317, + 337, + 337 + ], + [ + 5, + 257, + 276, + 277, + 314, + 317, + 336, + 337 + ], + [ + 7, + 257, + 276, + 277, + 314, + 317, + 334, + 337 + ], + [ + 8, + 257, + 276, + 277, + 314, + 317, + 333, + 337 + ], + [ + 8, + 257, + 277, + 293, + 304, + 317, + 326, + 337 + ], + [ + 10, + 257, + 267, + 277, + 317, + 317, + 337, + 337 + ], + [ + 15, + 257, + 277, + 284, + 304, + 317, + 328, + 337 + ], + [ + 16, + 257, + 267, + 277, + 314, + 317, + 334, + 337 + ], + [ + 16, + 257, + 277, + 284, + 304, + 317, + 327, + 337 + ], + [ + 17, + 257, + 277, + 284, + 304, + 317, + 326, + 337 + ], + [ + 21, + 257, + 258, + 277, + 317, + 318, + 334, + 337 + ], + [ + 22, + 257, + 258, + 277, + 317, + 317, + 334, + 337 + ], + [ + 24, + 257, + 258, + 277, + 315, + 317, + 334, + 337 + ], + [ + 24, + 257, + 277, + 284, + 295, + 317, + 328, + 337 + ], + [ + 25, + 257, + 258, + 277, + 314, + 317, + 334, + 337 + ], + [ + 29, + 257, + 266, + 277, + 310, + 317, + 326, + 337 + ], + [ + 30, + 257, + 277, + 277, + 287, + 317, + 337, + 337 + ], + [ + 32, + 257, + 266, + 277, + 307, + 317, + 326, + 337 + ], + [ + 32, + 257, + 276, + 277, + 287, + 317, + 336, + 337 + ], + [ + 35, + 257, + 266, + 277, + 304, + 317, + 326, + 337 + ], + [ + 36, + 257, + 268, + 277, + 290, + 317, + 337, + 337 + ], + [ + 38, + 257, + 266, + 277, + 310, + 317, + 317, + 337 + ], + [ + 42, + 257, + 277, + 277, + 284, + 317, + 328, + 337 + ], + [ + 44, + 257, + 257, + 277, + 304, + 317, + 326, + 337 + ], + [ + 45, + 257, + 268, + 277, + 290, + 317, + 328, + 337 + ], + [ + 48, + 257, + 258, + 277, + 307, + 317, + 318, + 337 + ], + [ + 48, + 257, + 268, + 277, + 287, + 317, + 328, + 337 + ], + [ + 50, + 257, + 257, + 277, + 307, + 317, + 317, + 337 + ], + [ + 51, + 257, + 268, + 277, + 284, + 317, + 328, + 337 + ], + [ + 55, + 257, + 260, + 277, + 280, + 317, + 336, + 337 + ], + [ + 56, + 257, + 260, + 277, + 279, + 317, + 336, + 337 + ], + [ + 56, + 257, + 266, + 277, + 299, + 310, + 317, + 337 + ], + [ + 58, + 257, + 260, + 277, + 277, + 317, + 336, + 337 + ], + [ + 59, + 257, + 260, + 276, + 277, + 317, + 336, + 337 + ], + [ + 63, + 257, + 268, + 277, + 290, + 310, + 317, + 337 + ], + [ + 64, + 257, + 260, + 277, + 280, + 317, + 327, + 337 + ], + [ + 64, + 257, + 267, + 277, + 290, + 310, + 317, + 337 + ], + [ + 65, + 257, + 266, + 277, + 290, + 310, + 317, + 337 + ], + [ + 70, + 257, + 257, + 277, + 277, + 317, + 327, + 337 + ], + [ + 72, + 257, + 261, + 277, + 280, + 317, + 318, + 337 + ], + [ + 72, + 257, + 268, + 277, + 290, + 301, + 317, + 337 + ], + [ + 73, + 257, + 260, + 277, + 280, + 317, + 318, + 337 + ], + [ + 75, + 257, + 258, + 277, + 280, + 317, + 318, + 337 + ], + [ + 76, + 257, + 257, + 277, + 280, + 317, + 318, + 337 + ], + [ + 83, + 256, + 257, + 268, + 277, + 317, + 326, + 337 + ], + [ + 85, + 185, + 257, + 277, + 293, + 317, + 337, + 337 + ], + [ + 85, + 193, + 257, + 277, + 304, + 317, + 326, + 337 + ], + [ + 86, + 137, + 257, + 277, + 296, + 317, + 336, + 337 + ], + [ + 86, + 139, + 257, + 277, + 307, + 317, + 326, + 337 + ], + [ + 86, + 185, + 257, + 277, + 294, + 317, + 336, + 337 + ], + [ + 86, + 192, + 257, + 277, + 304, + 317, + 326, + 337 + ], + [ + 86, + 233, + 257, + 276, + 277, + 317, + 336, + 337 + ], + [ + 86, + 253, + 257, + 268, + 277, + 317, + 326, + 337 + ], + [ + 87, + 256, + 257, + 277, + 290, + 304, + 317, + 337 + ], + [ + 88, + 106, + 257, + 277, + 314, + 317, + 334, + 337 + ], + [ + 88, + 161, + 257, + 277, + 304, + 317, + 327, + 337 + ], + [ + 88, + 172, + 257, + 277, + 304, + 317, + 326, + 337 + ], + [ + 88, + 185, + 257, + 277, + 296, + 317, + 334, + 337 + ], + [ + 88, + 212, + 257, + 277, + 294, + 317, + 334, + 337 + ], + [ + 88, + 255, + 257, + 277, + 290, + 304, + 317, + 337 + ], + [ + 89, + 89, + 277, + 293, + 304, + 317, + 326, + 337 + ], + [ + 89, + 96, + 257, + 277, + 317, + 326, + 331, + 337 + ], + [ + 89, + 96, + 257, + 304, + 304, + 317, + 326, + 337 + ], + [ + 89, + 98, + 277, + 284, + 304, + 317, + 326, + 337 + ], + [ + 89, + 105, + 257, + 277, + 315, + 317, + 333, + 337 + ], + [ + 89, + 105, + 257, + 277, + 317, + 320, + 328, + 337 + ], + [ + 89, + 105, + 257, + 277, + 317, + 321, + 327, + 337 + ], + [ + 89, + 105, + 257, + 277, + 317, + 322, + 326, + 337 + ], + [ + 89, + 105, + 257, + 277, + 317, + 323, + 325, + 337 + ], + [ + 89, + 105, + 257, + 277, + 317, + 324, + 324, + 337 + ], + [ + 89, + 105, + 257, + 295, + 304, + 317, + 326, + 337 + ], + [ + 89, + 105, + 277, + 284, + 293, + 317, + 328, + 337 + ], + [ + 89, + 110, + 257, + 277, + 304, + 317, + 335, + 337 + ], + [ + 89, + 110, + 257, + 277, + 304, + 326, + 326, + 337 + ], + [ + 89, + 116, + 266, + 277, + 304, + 317, + 326, + 337 + ], + [ + 89, + 127, + 257, + 277, + 307, + 317, + 326, + 337 + ], + [ + 89, + 128, + 257, + 277, + 306, + 317, + 326, + 337 + ], + [ + 89, + 136, + 257, + 280, + 304, + 317, + 326, + 337 + ], + [ + 89, + 137, + 257, + 277, + 299, + 317, + 333, + 337 + ], + [ + 89, + 137, + 257, + 279, + 304, + 317, + 326, + 337 + ], + [ + 89, + 137, + 260, + 277, + 293, + 317, + 336, + 337 + ], + [ + 89, + 141, + 261, + 277, + 304, + 317, + 326, + 337 + ], + [ + 89, + 141, + 277, + 280, + 293, + 317, + 318, + 337 + ], + [ + 89, + 142, + 260, + 277, + 304, + 317, + 326, + 337 + ], + [ + 89, + 157, + 257, + 277, + 304, + 317, + 327, + 337 + ], + [ + 89, + 158, + 257, + 277, + 304, + 318, + 326, + 337 + ], + [ + 89, + 164, + 258, + 277, + 304, + 317, + 326, + 337 + ], + [ + 89, + 167, + 257, + 277, + 303, + 317, + 327, + 337 + ], + [ + 89, + 175, + 257, + 276, + 304, + 317, + 326, + 337 + ], + [ + 89, + 178, + 257, + 277, + 303, + 317, + 326, + 337 + ], + [ + 89, + 181, + 257, + 277, + 304, + 317, + 326, + 336 + ], + [ + 89, + 185, + 257, + 277, + 297, + 317, + 333, + 337 + ], + [ + 89, + 185, + 257, + 277, + 306, + 317, + 324, + 337 + ], + [ + 89, + 186, + 257, + 277, + 307, + 317, + 323, + 337 + ], + [ + 89, + 212, + 257, + 277, + 295, + 317, + 333, + 337 + ], + [ + 89, + 212, + 257, + 277, + 304, + 315, + 326, + 337 + ], + [ + 89, + 212, + 258, + 277, + 293, + 317, + 334, + 337 + ], + [ + 89, + 213, + 257, + 277, + 304, + 314, + 326, + 337 + ], + [ + 89, + 215, + 257, + 277, + 304, + 317, + 324, + 337 + ], + [ + 89, + 216, + 257, + 277, + 304, + 317, + 323, + 337 + ], + [ + 89, + 219, + 257, + 277, + 304, + 317, + 326, + 334 + ], + [ + 89, + 220, + 257, + 277, + 304, + 317, + 326, + 333 + ], + [ + 89, + 220, + 276, + 277, + 293, + 314, + 317, + 337 + ], + [ + 89, + 223, + 257, + 268, + 304, + 317, + 326, + 337 + ], + [ + 89, + 223, + 257, + 277, + 295, + 317, + 326, + 337 + ], + [ + 89, + 227, + 257, + 277, + 304, + 317, + 317, + 337 + ], + [ + 89, + 229, + 257, + 277, + 304, + 317, + 326, + 328 + ], + [ + 89, + 236, + 257, + 277, + 279, + 317, + 333, + 337 + ], + [ + 89, + 236, + 257, + 277, + 299, + 304, + 326, + 337 + ], + [ + 89, + 236, + 257, + 277, + 302, + 310, + 317, + 337 + ], + [ + 89, + 236, + 257, + 277, + 303, + 309, + 317, + 337 + ], + [ + 89, + 236, + 257, + 277, + 304, + 308, + 317, + 337 + ], + [ + 89, + 236, + 257, + 277, + 305, + 307, + 317, + 337 + ], + [ + 89, + 236, + 257, + 277, + 306, + 306, + 317, + 337 + ], + [ + 89, + 236, + 266, + 277, + 293, + 310, + 317, + 337 + ], + [ + 89, + 241, + 257, + 277, + 277, + 317, + 326, + 337 + ], + [ + 89, + 245, + 257, + 277, + 290, + 304, + 326, + 337 + ], + [ + 89, + 245, + 257, + 277, + 299, + 304, + 317, + 337 + ], + [ + 89, + 247, + 257, + 277, + 304, + 310, + 317, + 326 + ], + [ + 89, + 250, + 257, + 268, + 277, + 317, + 326, + 337 + ], + [ + 89, + 254, + 257, + 277, + 290, + 304, + 317, + 337 + ], + [ + 89, + 256, + 257, + 277, + 301, + 304, + 317, + 326 + ], + [ + 89, + 256, + 268, + 277, + 290, + 293, + 317, + 337 + ], + [ + 90, + 236, + 257, + 266, + 277, + 317, + 337, + 337 + ], + [ + 92, + 256, + 257, + 268, + 277, + 317, + 317, + 337 + ], + [ + 93, + 136, + 257, + 277, + 287, + 317, + 337, + 337 + ], + [ + 93, + 141, + 257, + 277, + 307, + 317, + 318, + 337 + ], + [ + 95, + 137, + 257, + 277, + 287, + 317, + 336, + 337 + ], + [ + 95, + 142, + 257, + 277, + 307, + 317, + 317, + 337 + ], + [ + 96, + 98, + 257, + 277, + 314, + 317, + 334, + 337 + ], + [ + 96, + 105, + 257, + 284, + 304, + 317, + 328, + 337 + ], + [ + 96, + 110, + 257, + 277, + 293, + 317, + 337, + 337 + ], + [ + 96, + 127, + 257, + 277, + 287, + 317, + 337, + 337 + ], + [ + 96, + 137, + 257, + 260, + 304, + 317, + 336, + 337 + ], + [ + 96, + 141, + 257, + 280, + 304, + 317, + 318, + 337 + ], + [ + 96, + 142, + 257, + 277, + 290, + 317, + 334, + 337 + ], + [ + 96, + 189, + 257, + 277, + 287, + 317, + 334, + 337 + ], + [ + 96, + 212, + 257, + 258, + 304, + 317, + 334, + 337 + ], + [ + 96, + 213, + 257, + 277, + 284, + 317, + 334, + 337 + ], + [ + 96, + 220, + 257, + 276, + 304, + 314, + 317, + 337 + ], + [ + 96, + 223, + 257, + 277, + 284, + 317, + 328, + 337 + ], + [ + 96, + 236, + 257, + 266, + 304, + 310, + 317, + 337 + ], + [ + 96, + 245, + 257, + 260, + 277, + 317, + 334, + 337 + ], + [ + 96, + 247, + 257, + 277, + 287, + 307, + 317, + 337 + ], + [ + 96, + 256, + 257, + 268, + 290, + 304, + 317, + 337 + ], + [ + 96, + 256, + 257, + 277, + 290, + 295, + 317, + 337 + ], + [ + 97, + 97, + 257, + 277, + 314, + 317, + 334, + 337 + ], + [ + 97, + 128, + 257, + 277, + 287, + 317, + 336, + 337 + ], + [ + 97, + 132, + 257, + 277, + 307, + 317, + 318, + 337 + ], + [ + 97, + 188, + 257, + 277, + 287, + 317, + 334, + 337 + ], + [ + 97, + 190, + 257, + 277, + 307, + 314, + 317, + 337 + ], + [ + 97, + 212, + 257, + 277, + 285, + 317, + 334, + 337 + ], + [ + 97, + 220, + 257, + 277, + 303, + 314, + 317, + 337 + ], + [ + 97, + 246, + 257, + 277, + 287, + 307, + 317, + 337 + ], + [ + 98, + 105, + 257, + 277, + 311, + 317, + 328, + 337 + ], + [ + 98, + 105, + 277, + 284, + 284, + 317, + 328, + 337 + ], + [ + 98, + 116, + 257, + 277, + 304, + 317, + 326, + 337 + ], + [ + 98, + 133, + 257, + 277, + 307, + 317, + 317, + 337 + ], + [ + 98, + 136, + 257, + 277, + 310, + 314, + 317, + 337 + ], + [ + 98, + 137, + 260, + 277, + 284, + 317, + 336, + 337 + ], + [ + 98, + 141, + 277, + 280, + 284, + 317, + 318, + 337 + ], + [ + 98, + 189, + 257, + 277, + 307, + 314, + 317, + 337 + ], + [ + 98, + 212, + 258, + 277, + 284, + 317, + 334, + 337 + ], + [ + 98, + 219, + 257, + 277, + 304, + 314, + 317, + 337 + ], + [ + 98, + 220, + 276, + 277, + 284, + 314, + 317, + 337 + ], + [ + 98, + 229, + 257, + 277, + 295, + 317, + 317, + 337 + ], + [ + 98, + 236, + 257, + 277, + 293, + 310, + 317, + 337 + ], + [ + 98, + 236, + 266, + 277, + 284, + 310, + 317, + 337 + ], + [ + 98, + 245, + 257, + 277, + 287, + 307, + 317, + 337 + ], + [ + 98, + 247, + 257, + 277, + 280, + 314, + 317, + 337 + ], + [ + 98, + 256, + 268, + 277, + 284, + 290, + 317, + 337 + ], + [ + 99, + 236, + 257, + 266, + 277, + 317, + 328, + 337 + ], + [ + 102, + 139, + 257, + 277, + 287, + 317, + 328, + 337 + ], + [ + 102, + 141, + 257, + 277, + 298, + 317, + 318, + 337 + ], + [ + 102, + 186, + 257, + 277, + 284, + 317, + 328, + 337 + ], + [ + 102, + 193, + 257, + 277, + 294, + 317, + 318, + 337 + ], + [ + 102, + 233, + 257, + 266, + 277, + 317, + 328, + 337 + ], + [ + 102, + 253, + 257, + 258, + 277, + 317, + 318, + 337 + ], + [ + 103, + 185, + 257, + 277, + 284, + 317, + 328, + 337 + ], + [ + 103, + 193, + 257, + 277, + 295, + 317, + 317, + 337 + ], + [ + 105, + 105, + 257, + 284, + 295, + 317, + 328, + 337 + ], + [ + 105, + 108, + 257, + 277, + 284, + 317, + 337, + 337 + ], + [ + 105, + 110, + 257, + 277, + 284, + 326, + 328, + 337 + ], + [ + 105, + 116, + 257, + 277, + 293, + 317, + 328, + 337 + ], + [ + 105, + 116, + 266, + 277, + 284, + 317, + 328, + 337 + ], + [ + 105, + 132, + 257, + 277, + 288, + 317, + 328, + 337 + ], + [ + 105, + 133, + 257, + 277, + 287, + 317, + 328, + 337 + ], + [ + 105, + 136, + 257, + 280, + 284, + 317, + 328, + 337 + ], + [ + 105, + 137, + 257, + 260, + 295, + 317, + 336, + 337 + ], + [ + 105, + 137, + 257, + 279, + 284, + 317, + 328, + 337 + ], + [ + 105, + 141, + 257, + 277, + 301, + 315, + 317, + 337 + ], + [ + 105, + 141, + 257, + 280, + 295, + 317, + 318, + 337 + ], + [ + 105, + 141, + 261, + 277, + 284, + 317, + 328, + 337 + ], + [ + 105, + 142, + 260, + 277, + 284, + 317, + 328, + 337 + ], + [ + 105, + 158, + 257, + 277, + 284, + 318, + 328, + 337 + ], + [ + 105, + 161, + 257, + 277, + 285, + 317, + 328, + 337 + ], + [ + 105, + 164, + 258, + 277, + 284, + 317, + 328, + 337 + ], + [ + 105, + 172, + 257, + 277, + 285, + 317, + 327, + 337 + ], + [ + 105, + 175, + 257, + 276, + 284, + 317, + 328, + 337 + ], + [ + 105, + 180, + 257, + 277, + 284, + 317, + 327, + 337 + ], + [ + 105, + 181, + 257, + 277, + 284, + 317, + 328, + 336 + ], + [ + 105, + 192, + 257, + 277, + 287, + 317, + 325, + 337 + ], + [ + 105, + 193, + 257, + 277, + 288, + 317, + 324, + 337 + ], + [ + 105, + 193, + 257, + 277, + 297, + 315, + 317, + 337 + ], + [ + 105, + 212, + 257, + 258, + 295, + 317, + 334, + 337 + ], + [ + 105, + 212, + 257, + 277, + 284, + 315, + 328, + 337 + ], + [ + 105, + 213, + 257, + 277, + 284, + 314, + 328, + 337 + ], + [ + 105, + 216, + 257, + 277, + 284, + 317, + 325, + 337 + ], + [ + 105, + 217, + 257, + 277, + 284, + 317, + 324, + 337 + ], + [ + 105, + 219, + 257, + 277, + 284, + 317, + 328, + 334 + ], + [ + 105, + 220, + 257, + 276, + 295, + 314, + 317, + 337 + ], + [ + 105, + 220, + 257, + 277, + 284, + 317, + 328, + 333 + ], + [ + 105, + 220, + 257, + 277, + 293, + 315, + 317, + 337 + ], + [ + 105, + 223, + 257, + 268, + 284, + 317, + 328, + 337 + ], + [ + 105, + 229, + 257, + 277, + 284, + 317, + 319, + 337 + ], + [ + 105, + 229, + 257, + 277, + 284, + 317, + 328, + 328 + ], + [ + 105, + 230, + 257, + 266, + 277, + 317, + 328, + 337 + ], + [ + 105, + 236, + 257, + 266, + 295, + 310, + 317, + 337 + ], + [ + 105, + 236, + 257, + 277, + 284, + 299, + 328, + 337 + ], + [ + 105, + 238, + 257, + 277, + 284, + 310, + 317, + 337 + ], + [ + 105, + 239, + 257, + 257, + 277, + 317, + 328, + 337 + ], + [ + 105, + 245, + 257, + 277, + 284, + 290, + 328, + 337 + ], + [ + 105, + 247, + 257, + 277, + 284, + 301, + 317, + 337 + ], + [ + 105, + 247, + 257, + 277, + 284, + 310, + 317, + 328 + ], + [ + 105, + 256, + 257, + 261, + 277, + 315, + 317, + 337 + ], + [ + 105, + 256, + 257, + 268, + 290, + 295, + 317, + 337 + ], + [ + 105, + 256, + 257, + 277, + 284, + 292, + 317, + 337 + ], + [ + 105, + 256, + 257, + 277, + 284, + 301, + 317, + 328 + ], + [ + 105, + 256, + 257, + 277, + 285, + 291, + 317, + 337 + ], + [ + 105, + 256, + 257, + 277, + 286, + 290, + 317, + 337 + ], + [ + 105, + 256, + 257, + 277, + 287, + 289, + 317, + 337 + ], + [ + 105, + 256, + 257, + 277, + 288, + 288, + 317, + 337 + ], + [ + 106, + 167, + 257, + 277, + 284, + 317, + 328, + 337 + ], + [ + 106, + 178, + 257, + 277, + 284, + 317, + 327, + 337 + ], + [ + 106, + 193, + 257, + 277, + 298, + 314, + 317, + 337 + ], + [ + 106, + 220, + 257, + 277, + 294, + 314, + 317, + 337 + ], + [ + 106, + 237, + 257, + 277, + 284, + 310, + 317, + 337 + ], + [ + 107, + 236, + 257, + 277, + 284, + 310, + 317, + 337 + ], + [ + 109, + 141, + 257, + 277, + 280, + 317, + 327, + 337 + ], + [ + 109, + 158, + 257, + 267, + 277, + 317, + 337, + 337 + ], + [ + 110, + 116, + 257, + 276, + 277, + 317, + 336, + 337 + ], + [ + 110, + 137, + 257, + 260, + 277, + 326, + 336, + 337 + ], + [ + 110, + 141, + 257, + 277, + 280, + 318, + 326, + 337 + ], + [ + 110, + 157, + 257, + 267, + 277, + 317, + 337, + 337 + ], + [ + 110, + 164, + 257, + 268, + 277, + 317, + 336, + 337 + ], + [ + 110, + 169, + 257, + 267, + 277, + 317, + 336, + 337 + ], + [ + 110, + 175, + 257, + 266, + 277, + 317, + 336, + 337 + ], + [ + 110, + 212, + 257, + 258, + 277, + 326, + 334, + 337 + ], + [ + 110, + 220, + 257, + 276, + 277, + 314, + 326, + 337 + ], + [ + 110, + 223, + 257, + 258, + 277, + 317, + 336, + 337 + ], + [ + 110, + 229, + 257, + 267, + 277, + 317, + 327, + 337 + ], + [ + 110, + 236, + 257, + 266, + 277, + 310, + 326, + 337 + ], + [ + 110, + 245, + 257, + 266, + 277, + 310, + 317, + 337 + ], + [ + 110, + 256, + 257, + 268, + 277, + 290, + 326, + 337 + ], + [ + 110, + 256, + 257, + 268, + 277, + 299, + 317, + 337 + ], + [ + 113, + 113, + 257, + 276, + 277, + 317, + 336, + 337 + ], + [ + 113, + 137, + 257, + 269, + 277, + 317, + 336, + 337 + ], + [ + 113, + 138, + 257, + 277, + 280, + 317, + 327, + 337 + ], + [ + 113, + 155, + 257, + 267, + 277, + 317, + 336, + 337 + ], + [ + 113, + 184, + 257, + 276, + 277, + 317, + 327, + 337 + ], + [ + 113, + 215, + 257, + 267, + 277, + 317, + 334, + 337 + ], + [ + 113, + 220, + 257, + 276, + 277, + 317, + 323, + 337 + ], + [ + 113, + 226, + 257, + 267, + 277, + 317, + 327, + 337 + ], + [ + 114, + 256, + 257, + 277, + 277, + 290, + 317, + 337 + ], + [ + 115, + 164, + 257, + 277, + 277, + 317, + 327, + 337 + ], + [ + 115, + 212, + 257, + 267, + 277, + 317, + 334, + 337 + ], + [ + 116, + 137, + 260, + 266, + 277, + 317, + 336, + 337 + ], + [ + 116, + 141, + 266, + 277, + 280, + 317, + 318, + 337 + ], + [ + 116, + 158, + 257, + 276, + 277, + 317, + 328, + 337 + ], + [ + 116, + 163, + 257, + 277, + 277, + 317, + 327, + 337 + ], + [ + 116, + 169, + 257, + 276, + 277, + 317, + 327, + 337 + ], + [ + 116, + 181, + 257, + 276, + 277, + 317, + 326, + 337 + ], + [ + 116, + 212, + 258, + 266, + 277, + 317, + 334, + 337 + ], + [ + 116, + 220, + 266, + 276, + 277, + 314, + 317, + 337 + ], + [ + 116, + 223, + 257, + 267, + 277, + 317, + 327, + 337 + ], + [ + 116, + 229, + 257, + 276, + 277, + 317, + 318, + 337 + ], + [ + 116, + 236, + 257, + 275, + 277, + 310, + 317, + 337 + ], + [ + 116, + 236, + 266, + 266, + 277, + 310, + 317, + 337 + ], + [ + 116, + 247, + 257, + 277, + 277, + 299, + 317, + 337 + ], + [ + 116, + 256, + 266, + 268, + 277, + 290, + 317, + 337 + ], + [ + 118, + 212, + 257, + 258, + 277, + 317, + 337, + 337 + ], + [ + 119, + 212, + 257, + 258, + 277, + 317, + 336, + 337 + ], + [ + 123, + 220, + 257, + 276, + 277, + 317, + 318, + 337 + ], + [ + 124, + 220, + 257, + 276, + 277, + 317, + 317, + 337 + ], + [ + 128, + 188, + 257, + 260, + 277, + 317, + 336, + 337 + ], + [ + 128, + 193, + 257, + 270, + 277, + 317, + 326, + 337 + ], + [ + 128, + 203, + 257, + 258, + 277, + 317, + 336, + 337 + ], + [ + 128, + 211, + 257, + 266, + 277, + 317, + 326, + 337 + ], + [ + 129, + 185, + 257, + 261, + 277, + 317, + 337, + 337 + ], + [ + 129, + 193, + 257, + 277, + 280, + 317, + 318, + 337 + ], + [ + 131, + 185, + 257, + 260, + 277, + 317, + 336, + 337 + ], + [ + 131, + 193, + 257, + 277, + 279, + 317, + 317, + 337 + ], + [ + 132, + 185, + 257, + 270, + 277, + 317, + 328, + 337 + ], + [ + 132, + 190, + 257, + 277, + 280, + 317, + 318, + 337 + ], + [ + 132, + 203, + 257, + 268, + 277, + 317, + 328, + 337 + ], + [ + 132, + 211, + 257, + 276, + 277, + 317, + 318, + 337 + ], + [ + 135, + 220, + 257, + 277, + 280, + 314, + 317, + 337 + ], + [ + 136, + 137, + 257, + 260, + 280, + 317, + 336, + 337 + ], + [ + 136, + 141, + 257, + 277, + 283, + 317, + 318, + 337 + ], + [ + 136, + 141, + 257, + 280, + 280, + 317, + 318, + 337 + ], + [ + 136, + 142, + 257, + 277, + 290, + 310, + 317, + 337 + ], + [ + 136, + 158, + 257, + 261, + 277, + 317, + 337, + 337 + ], + [ + 136, + 175, + 257, + 260, + 277, + 317, + 336, + 337 + ], + [ + 136, + 189, + 257, + 277, + 287, + 310, + 317, + 337 + ], + [ + 136, + 212, + 257, + 258, + 280, + 317, + 334, + 337 + ], + [ + 136, + 213, + 257, + 277, + 284, + 310, + 317, + 337 + ], + [ + 136, + 219, + 257, + 277, + 287, + 307, + 317, + 337 + ], + [ + 136, + 220, + 257, + 276, + 280, + 314, + 317, + 337 + ], + [ + 136, + 220, + 257, + 277, + 279, + 314, + 317, + 337 + ], + [ + 136, + 236, + 257, + 266, + 280, + 310, + 317, + 337 + ], + [ + 136, + 245, + 257, + 260, + 277, + 310, + 317, + 337 + ], + [ + 136, + 256, + 257, + 268, + 280, + 290, + 317, + 337 + ], + [ + 137, + 137, + 257, + 260, + 279, + 317, + 336, + 337 + ], + [ + 137, + 141, + 257, + 264, + 277, + 317, + 336, + 337 + ], + [ + 137, + 141, + 257, + 273, + 277, + 317, + 327, + 337 + ], + [ + 137, + 141, + 257, + 277, + 282, + 317, + 318, + 337 + ], + [ + 137, + 141, + 257, + 277, + 291, + 309, + 317, + 337 + ], + [ + 137, + 141, + 257, + 277, + 299, + 301, + 317, + 337 + ], + [ + 137, + 141, + 257, + 277, + 300, + 300, + 317, + 337 + ], + [ + 137, + 141, + 257, + 279, + 280, + 317, + 318, + 337 + ], + [ + 137, + 141, + 260, + 261, + 277, + 317, + 336, + 337 + ], + [ + 137, + 142, + 257, + 263, + 277, + 317, + 336, + 337 + ], + [ + 137, + 142, + 260, + 260, + 277, + 317, + 336, + 337 + ], + [ + 137, + 156, + 257, + 260, + 277, + 317, + 337, + 337 + ], + [ + 137, + 158, + 257, + 260, + 277, + 318, + 336, + 337 + ], + [ + 137, + 164, + 257, + 261, + 277, + 317, + 336, + 337 + ], + [ + 137, + 164, + 258, + 260, + 277, + 317, + 336, + 337 + ], + [ + 137, + 175, + 257, + 260, + 276, + 317, + 336, + 337 + ], + [ + 137, + 181, + 257, + 260, + 277, + 317, + 335, + 337 + ], + [ + 137, + 181, + 257, + 260, + 277, + 317, + 336, + 336 + ], + [ + 137, + 184, + 257, + 269, + 277, + 317, + 327, + 337 + ], + [ + 137, + 190, + 257, + 277, + 287, + 309, + 317, + 337 + ], + [ + 137, + 193, + 257, + 277, + 296, + 300, + 317, + 337 + ], + [ + 137, + 193, + 257, + 277, + 297, + 299, + 317, + 337 + ], + [ + 137, + 194, + 257, + 258, + 277, + 317, + 336, + 337 + ], + [ + 137, + 195, + 257, + 257, + 277, + 317, + 336, + 337 + ], + [ + 137, + 212, + 257, + 258, + 279, + 317, + 334, + 337 + ], + [ + 137, + 212, + 257, + 260, + 277, + 315, + 336, + 337 + ], + [ + 137, + 213, + 257, + 260, + 277, + 314, + 336, + 337 + ], + [ + 137, + 218, + 257, + 260, + 277, + 317, + 334, + 337 + ], + [ + 137, + 219, + 257, + 260, + 277, + 317, + 333, + 337 + ], + [ + 137, + 219, + 257, + 260, + 277, + 317, + 334, + 336 + ], + [ + 137, + 220, + 257, + 260, + 277, + 317, + 332, + 337 + ], + [ + 137, + 220, + 257, + 260, + 277, + 317, + 333, + 336 + ], + [ + 137, + 220, + 257, + 269, + 277, + 317, + 323, + 337 + ], + [ + 137, + 220, + 257, + 276, + 279, + 314, + 317, + 337 + ], + [ + 137, + 220, + 257, + 277, + 278, + 314, + 317, + 337 + ], + [ + 137, + 220, + 257, + 277, + 287, + 305, + 317, + 337 + ], + [ + 137, + 220, + 257, + 277, + 293, + 299, + 317, + 337 + ], + [ + 137, + 220, + 257, + 277, + 296, + 296, + 317, + 337 + ], + [ + 137, + 223, + 257, + 260, + 268, + 317, + 336, + 337 + ], + [ + 137, + 228, + 257, + 260, + 277, + 317, + 327, + 337 + ], + [ + 137, + 229, + 257, + 260, + 277, + 317, + 328, + 336 + ], + [ + 137, + 236, + 257, + 260, + 277, + 299, + 336, + 337 + ], + [ + 137, + 236, + 257, + 266, + 279, + 310, + 317, + 337 + ], + [ + 137, + 245, + 257, + 260, + 277, + 290, + 336, + 337 + ], + [ + 137, + 246, + 257, + 260, + 277, + 309, + 317, + 337 + ], + [ + 137, + 247, + 257, + 260, + 277, + 310, + 317, + 336 + ], + [ + 137, + 255, + 257, + 260, + 277, + 300, + 317, + 337 + ], + [ + 137, + 256, + 257, + 260, + 277, + 301, + 317, + 336 + ], + [ + 137, + 256, + 257, + 261, + 277, + 299, + 317, + 337 + ], + [ + 137, + 256, + 257, + 268, + 279, + 290, + 317, + 337 + ], + [ + 138, + 140, + 257, + 277, + 290, + 310, + 317, + 337 + ], + [ + 138, + 184, + 257, + 277, + 280, + 317, + 318, + 337 + ], + [ + 138, + 185, + 257, + 277, + 288, + 310, + 317, + 337 + ], + [ + 138, + 217, + 257, + 277, + 280, + 314, + 317, + 337 + ], + [ + 138, + 236, + 257, + 270, + 277, + 310, + 317, + 337 + ], + [ + 139, + 139, + 257, + 277, + 290, + 310, + 317, + 337 + ], + [ + 139, + 186, + 257, + 277, + 287, + 310, + 317, + 337 + ], + [ + 139, + 192, + 257, + 277, + 290, + 307, + 317, + 337 + ], + [ + 139, + 216, + 257, + 277, + 287, + 307, + 317, + 337 + ], + [ + 139, + 236, + 257, + 269, + 277, + 310, + 317, + 337 + ], + [ + 139, + 256, + 257, + 271, + 277, + 290, + 317, + 337 + ], + [ + 140, + 155, + 257, + 260, + 277, + 317, + 336, + 337 + ], + [ + 140, + 193, + 257, + 277, + 290, + 306, + 317, + 337 + ], + [ + 140, + 215, + 257, + 260, + 277, + 317, + 334, + 337 + ], + [ + 140, + 226, + 257, + 260, + 277, + 317, + 327, + 337 + ], + [ + 140, + 256, + 257, + 270, + 277, + 290, + 317, + 337 + ], + [ + 141, + 141, + 261, + 277, + 280, + 317, + 318, + 337 + ], + [ + 141, + 142, + 260, + 277, + 280, + 317, + 318, + 337 + ], + [ + 141, + 155, + 257, + 271, + 277, + 317, + 327, + 337 + ], + [ + 141, + 158, + 257, + 277, + 280, + 317, + 319, + 337 + ], + [ + 141, + 158, + 257, + 277, + 280, + 318, + 318, + 337 + ], + [ + 141, + 164, + 258, + 277, + 280, + 317, + 318, + 337 + ], + [ + 141, + 175, + 257, + 276, + 280, + 317, + 318, + 337 + ], + [ + 141, + 175, + 257, + 277, + 279, + 317, + 318, + 337 + ], + [ + 141, + 179, + 257, + 277, + 280, + 317, + 317, + 337 + ], + [ + 141, + 181, + 257, + 277, + 280, + 317, + 318, + 336 + ], + [ + 141, + 185, + 257, + 277, + 297, + 301, + 317, + 337 + ], + [ + 141, + 185, + 257, + 277, + 298, + 300, + 317, + 337 + ], + [ + 141, + 188, + 257, + 277, + 291, + 307, + 317, + 337 + ], + [ + 141, + 201, + 257, + 277, + 277, + 317, + 318, + 337 + ], + [ + 141, + 202, + 257, + 276, + 277, + 317, + 318, + 337 + ], + [ + 141, + 212, + 257, + 262, + 277, + 317, + 334, + 337 + ], + [ + 141, + 212, + 257, + 271, + 277, + 317, + 325, + 337 + ], + [ + 141, + 212, + 257, + 277, + 280, + 315, + 318, + 337 + ], + [ + 141, + 212, + 257, + 277, + 280, + 316, + 317, + 337 + ], + [ + 141, + 212, + 257, + 277, + 289, + 307, + 317, + 337 + ], + [ + 141, + 212, + 257, + 277, + 295, + 301, + 317, + 337 + ], + [ + 141, + 212, + 257, + 277, + 298, + 298, + 317, + 337 + ], + [ + 141, + 212, + 258, + 261, + 277, + 317, + 334, + 337 + ], + [ + 141, + 213, + 257, + 277, + 280, + 314, + 318, + 337 + ], + [ + 141, + 213, + 257, + 277, + 280, + 315, + 317, + 337 + ], + [ + 141, + 214, + 257, + 277, + 280, + 314, + 317, + 337 + ], + [ + 141, + 219, + 257, + 277, + 280, + 317, + 318, + 334 + ], + [ + 141, + 220, + 257, + 277, + 280, + 317, + 318, + 333 + ], + [ + 141, + 220, + 261, + 276, + 277, + 314, + 317, + 337 + ], + [ + 141, + 223, + 257, + 268, + 280, + 317, + 318, + 337 + ], + [ + 141, + 226, + 257, + 271, + 277, + 317, + 318, + 337 + ], + [ + 141, + 229, + 257, + 277, + 280, + 317, + 318, + 328 + ], + [ + 141, + 236, + 257, + 277, + 279, + 301, + 317, + 337 + ], + [ + 141, + 236, + 257, + 277, + 280, + 299, + 318, + 337 + ], + [ + 141, + 236, + 261, + 266, + 277, + 310, + 317, + 337 + ], + [ + 141, + 237, + 257, + 277, + 280, + 300, + 317, + 337 + ], + [ + 141, + 245, + 257, + 277, + 280, + 290, + 318, + 337 + ], + [ + 141, + 246, + 257, + 277, + 280, + 291, + 317, + 337 + ], + [ + 141, + 247, + 257, + 277, + 280, + 310, + 317, + 318 + ], + [ + 141, + 256, + 257, + 277, + 280, + 301, + 317, + 318 + ], + [ + 141, + 256, + 261, + 268, + 277, + 290, + 317, + 337 + ], + [ + 142, + 164, + 257, + 277, + 280, + 317, + 318, + 337 + ], + [ + 142, + 181, + 257, + 277, + 279, + 317, + 317, + 337 + ], + [ + 142, + 189, + 257, + 277, + 290, + 307, + 317, + 337 + ], + [ + 142, + 212, + 257, + 261, + 277, + 317, + 334, + 337 + ], + [ + 142, + 212, + 258, + 260, + 277, + 317, + 334, + 337 + ], + [ + 142, + 213, + 257, + 277, + 287, + 307, + 317, + 337 + ], + [ + 142, + 219, + 257, + 277, + 290, + 304, + 317, + 337 + ], + [ + 142, + 220, + 260, + 276, + 277, + 314, + 317, + 337 + ], + [ + 142, + 236, + 260, + 266, + 277, + 310, + 317, + 337 + ], + [ + 142, + 247, + 257, + 277, + 280, + 290, + 317, + 337 + ], + [ + 142, + 256, + 260, + 268, + 277, + 290, + 317, + 337 + ], + [ + 143, + 212, + 257, + 260, + 277, + 317, + 334, + 337 + ], + [ + 144, + 185, + 257, + 257, + 277, + 317, + 337, + 337 + ], + [ + 146, + 185, + 257, + 258, + 277, + 317, + 336, + 337 + ], + [ + 146, + 193, + 257, + 268, + 277, + 317, + 326, + 337 + ], + [ + 150, + 185, + 257, + 266, + 277, + 317, + 328, + 337 + ], + [ + 150, + 193, + 257, + 276, + 277, + 317, + 318, + 337 + ], + [ + 152, + 193, + 257, + 277, + 277, + 317, + 317, + 337 + ], + [ + 155, + 155, + 257, + 258, + 277, + 317, + 336, + 337 + ], + [ + 155, + 184, + 257, + 267, + 277, + 317, + 327, + 337 + ], + [ + 155, + 215, + 257, + 258, + 277, + 317, + 334, + 337 + ], + [ + 155, + 220, + 257, + 267, + 277, + 317, + 323, + 337 + ], + [ + 155, + 226, + 257, + 258, + 277, + 317, + 327, + 337 + ], + [ + 158, + 164, + 257, + 268, + 277, + 317, + 328, + 337 + ], + [ + 158, + 169, + 257, + 267, + 277, + 317, + 328, + 337 + ], + [ + 158, + 175, + 257, + 266, + 277, + 317, + 328, + 337 + ], + [ + 158, + 181, + 257, + 267, + 277, + 317, + 327, + 337 + ], + [ + 158, + 212, + 257, + 258, + 277, + 318, + 334, + 337 + ], + [ + 158, + 213, + 257, + 258, + 277, + 317, + 334, + 337 + ], + [ + 158, + 220, + 257, + 276, + 277, + 314, + 318, + 337 + ], + [ + 158, + 220, + 257, + 276, + 277, + 315, + 317, + 337 + ], + [ + 158, + 223, + 257, + 258, + 277, + 317, + 328, + 337 + ], + [ + 158, + 236, + 257, + 266, + 277, + 310, + 318, + 337 + ], + [ + 158, + 256, + 257, + 268, + 277, + 290, + 318, + 337 + ], + [ + 161, + 161, + 257, + 268, + 277, + 317, + 328, + 337 + ], + [ + 161, + 167, + 257, + 267, + 277, + 317, + 328, + 337 + ], + [ + 161, + 172, + 257, + 268, + 277, + 317, + 327, + 337 + ], + [ + 161, + 178, + 257, + 267, + 277, + 317, + 327, + 337 + ], + [ + 161, + 237, + 257, + 267, + 277, + 310, + 317, + 337 + ], + [ + 161, + 256, + 257, + 268, + 277, + 291, + 317, + 337 + ], + [ + 162, + 220, + 257, + 277, + 277, + 314, + 317, + 337 + ], + [ + 163, + 236, + 257, + 267, + 277, + 310, + 317, + 337 + ], + [ + 164, + 169, + 257, + 268, + 277, + 317, + 327, + 337 + ], + [ + 164, + 175, + 257, + 267, + 277, + 317, + 327, + 337 + ], + [ + 164, + 181, + 257, + 268, + 277, + 317, + 326, + 337 + ], + [ + 164, + 212, + 257, + 259, + 277, + 317, + 334, + 337 + ], + [ + 164, + 212, + 258, + 258, + 277, + 317, + 334, + 337 + ], + [ + 164, + 219, + 257, + 277, + 277, + 315, + 317, + 337 + ], + [ + 164, + 220, + 258, + 276, + 277, + 314, + 317, + 337 + ], + [ + 164, + 229, + 257, + 268, + 277, + 317, + 318, + 337 + ], + [ + 164, + 236, + 258, + 266, + 277, + 310, + 317, + 337 + ], + [ + 164, + 256, + 258, + 268, + 277, + 290, + 317, + 337 + ], + [ + 167, + 167, + 257, + 266, + 277, + 317, + 328, + 337 + ], + [ + 167, + 172, + 257, + 267, + 277, + 317, + 327, + 337 + ], + [ + 167, + 178, + 257, + 266, + 277, + 317, + 327, + 337 + ], + [ + 167, + 237, + 257, + 266, + 277, + 310, + 317, + 337 + ], + [ + 167, + 256, + 257, + 267, + 277, + 291, + 317, + 337 + ], + [ + 169, + 169, + 257, + 267, + 277, + 317, + 327, + 337 + ], + [ + 169, + 175, + 257, + 266, + 277, + 317, + 327, + 337 + ], + [ + 169, + 181, + 257, + 267, + 277, + 317, + 326, + 337 + ], + [ + 169, + 223, + 257, + 258, + 277, + 317, + 327, + 337 + ], + [ + 169, + 229, + 257, + 267, + 277, + 317, + 318, + 337 + ], + [ + 172, + 172, + 257, + 268, + 277, + 317, + 326, + 337 + ], + [ + 172, + 178, + 257, + 267, + 277, + 317, + 326, + 337 + ], + [ + 172, + 236, + 257, + 267, + 277, + 309, + 317, + 337 + ], + [ + 172, + 255, + 257, + 268, + 277, + 290, + 317, + 337 + ], + [ + 173, + 212, + 257, + 257, + 277, + 317, + 334, + 337 + ], + [ + 174, + 223, + 257, + 257, + 277, + 317, + 327, + 337 + ], + [ + 174, + 256, + 257, + 267, + 277, + 290, + 317, + 337 + ], + [ + 175, + 181, + 257, + 266, + 277, + 317, + 326, + 337 + ], + [ + 175, + 212, + 257, + 258, + 276, + 317, + 334, + 337 + ], + [ + 175, + 213, + 257, + 257, + 277, + 317, + 333, + 337 + ], + [ + 175, + 220, + 257, + 275, + 277, + 314, + 317, + 337 + ], + [ + 175, + 220, + 257, + 276, + 276, + 314, + 317, + 337 + ], + [ + 175, + 222, + 257, + 257, + 277, + 317, + 327, + 337 + ], + [ + 175, + 229, + 257, + 266, + 277, + 317, + 318, + 337 + ], + [ + 175, + 236, + 257, + 266, + 276, + 310, + 317, + 337 + ], + [ + 175, + 256, + 257, + 268, + 276, + 290, + 317, + 337 + ], + [ + 178, + 178, + 257, + 266, + 277, + 317, + 326, + 337 + ], + [ + 178, + 236, + 257, + 266, + 277, + 309, + 317, + 337 + ], + [ + 178, + 255, + 257, + 267, + 277, + 290, + 317, + 337 + ], + [ + 180, + 229, + 257, + 267, + 277, + 317, + 317, + 337 + ], + [ + 181, + 212, + 257, + 258, + 277, + 317, + 333, + 337 + ], + [ + 181, + 212, + 257, + 258, + 277, + 317, + 334, + 336 + ], + [ + 181, + 219, + 257, + 276, + 277, + 314, + 317, + 337 + ], + [ + 181, + 220, + 257, + 276, + 277, + 314, + 317, + 336 + ], + [ + 181, + 223, + 257, + 258, + 277, + 317, + 326, + 337 + ], + [ + 181, + 228, + 257, + 267, + 277, + 317, + 317, + 337 + ], + [ + 181, + 236, + 257, + 266, + 277, + 310, + 317, + 336 + ], + [ + 181, + 256, + 257, + 268, + 277, + 290, + 317, + 336 + ], + [ + 184, + 184, + 257, + 276, + 277, + 317, + 318, + 337 + ], + [ + 184, + 212, + 257, + 267, + 277, + 317, + 325, + 337 + ], + [ + 184, + 217, + 257, + 276, + 277, + 314, + 317, + 337 + ], + [ + 184, + 226, + 257, + 267, + 277, + 317, + 318, + 337 + ], + [ + 185, + 187, + 257, + 277, + 284, + 310, + 317, + 337 + ], + [ + 185, + 191, + 257, + 260, + 277, + 317, + 334, + 337 + ], + [ + 185, + 193, + 257, + 261, + 277, + 317, + 333, + 337 + ], + [ + 185, + 193, + 257, + 270, + 277, + 317, + 324, + 337 + ], + [ + 185, + 193, + 257, + 277, + 279, + 315, + 317, + 337 + ], + [ + 185, + 193, + 257, + 277, + 288, + 306, + 317, + 337 + ], + [ + 185, + 193, + 257, + 277, + 293, + 301, + 317, + 337 + ], + [ + 185, + 193, + 257, + 277, + 294, + 300, + 317, + 337 + ], + [ + 185, + 193, + 257, + 277, + 295, + 299, + 317, + 337 + ], + [ + 185, + 193, + 257, + 277, + 296, + 298, + 317, + 337 + ], + [ + 185, + 193, + 257, + 277, + 297, + 297, + 317, + 337 + ], + [ + 185, + 206, + 257, + 258, + 277, + 317, + 334, + 337 + ], + [ + 185, + 208, + 257, + 257, + 277, + 317, + 333, + 337 + ], + [ + 185, + 211, + 257, + 266, + 277, + 317, + 324, + 337 + ], + [ + 185, + 217, + 257, + 277, + 284, + 306, + 317, + 337 + ], + [ + 185, + 220, + 257, + 277, + 293, + 297, + 317, + 337 + ], + [ + 185, + 220, + 257, + 277, + 294, + 296, + 317, + 337 + ], + [ + 185, + 234, + 257, + 266, + 277, + 310, + 317, + 337 + ], + [ + 185, + 252, + 257, + 257, + 277, + 301, + 317, + 337 + ], + [ + 185, + 253, + 257, + 258, + 277, + 300, + 317, + 337 + ], + [ + 185, + 255, + 257, + 260, + 277, + 298, + 317, + 337 + ], + [ + 185, + 256, + 257, + 261, + 277, + 297, + 317, + 337 + ], + [ + 185, + 256, + 257, + 270, + 277, + 288, + 317, + 337 + ], + [ + 186, + 186, + 257, + 277, + 284, + 310, + 317, + 337 + ], + [ + 186, + 192, + 257, + 277, + 287, + 307, + 317, + 337 + ], + [ + 186, + 216, + 257, + 277, + 284, + 307, + 317, + 337 + ], + [ + 186, + 233, + 257, + 266, + 277, + 310, + 317, + 337 + ], + [ + 186, + 256, + 257, + 271, + 277, + 287, + 317, + 337 + ], + [ + 187, + 193, + 257, + 277, + 280, + 314, + 317, + 337 + ], + [ + 188, + 188, + 257, + 260, + 277, + 317, + 334, + 337 + ], + [ + 188, + 190, + 257, + 277, + 287, + 307, + 317, + 337 + ], + [ + 188, + 203, + 257, + 258, + 277, + 317, + 334, + 337 + ], + [ + 188, + 220, + 257, + 277, + 287, + 303, + 317, + 337 + ], + [ + 188, + 246, + 257, + 260, + 277, + 307, + 317, + 337 + ], + [ + 189, + 189, + 257, + 277, + 287, + 307, + 317, + 337 + ], + [ + 189, + 213, + 257, + 277, + 284, + 307, + 317, + 337 + ], + [ + 189, + 219, + 257, + 277, + 287, + 304, + 317, + 337 + ], + [ + 189, + 245, + 257, + 260, + 277, + 307, + 317, + 337 + ], + [ + 189, + 247, + 257, + 277, + 280, + 287, + 317, + 337 + ], + [ + 190, + 190, + 257, + 277, + 280, + 314, + 317, + 337 + ], + [ + 190, + 211, + 257, + 276, + 277, + 314, + 317, + 337 + ], + [ + 190, + 212, + 257, + 277, + 285, + 307, + 317, + 337 + ], + [ + 190, + 246, + 257, + 277, + 280, + 287, + 317, + 337 + ], + [ + 191, + 193, + 257, + 277, + 290, + 304, + 317, + 337 + ], + [ + 192, + 192, + 257, + 277, + 290, + 304, + 317, + 337 + ], + [ + 192, + 216, + 257, + 277, + 287, + 304, + 317, + 337 + ], + [ + 192, + 236, + 257, + 269, + 277, + 307, + 317, + 337 + ], + [ + 192, + 253, + 257, + 268, + 277, + 290, + 317, + 337 + ], + [ + 193, + 203, + 257, + 268, + 277, + 317, + 324, + 337 + ], + [ + 193, + 206, + 257, + 277, + 277, + 315, + 317, + 337 + ], + [ + 193, + 208, + 257, + 276, + 277, + 314, + 317, + 337 + ], + [ + 193, + 212, + 257, + 277, + 294, + 298, + 317, + 337 + ], + [ + 193, + 212, + 257, + 277, + 295, + 297, + 317, + 337 + ], + [ + 193, + 215, + 257, + 277, + 288, + 304, + 317, + 337 + ], + [ + 193, + 233, + 257, + 276, + 277, + 300, + 317, + 337 + ], + [ + 193, + 234, + 257, + 277, + 277, + 299, + 317, + 337 + ], + [ + 193, + 236, + 257, + 270, + 277, + 306, + 317, + 337 + ], + [ + 193, + 236, + 257, + 277, + 279, + 297, + 317, + 337 + ], + [ + 193, + 237, + 257, + 277, + 280, + 296, + 317, + 337 + ], + [ + 193, + 252, + 257, + 268, + 277, + 290, + 317, + 337 + ], + [ + 203, + 246, + 257, + 258, + 277, + 307, + 317, + 337 + ], + [ + 203, + 256, + 257, + 268, + 277, + 288, + 317, + 337 + ], + [ + 204, + 245, + 257, + 257, + 277, + 307, + 317, + 337 + ], + [ + 204, + 256, + 257, + 268, + 277, + 287, + 317, + 337 + ], + [ + 210, + 236, + 257, + 266, + 277, + 307, + 317, + 337 + ], + [ + 210, + 247, + 257, + 277, + 277, + 287, + 317, + 337 + ], + [ + 211, + 236, + 257, + 266, + 277, + 306, + 317, + 337 + ], + [ + 211, + 246, + 257, + 276, + 277, + 287, + 317, + 337 + ], + [ + 212, + 212, + 257, + 258, + 277, + 315, + 334, + 337 + ], + [ + 212, + 213, + 257, + 258, + 277, + 314, + 334, + 337 + ], + [ + 212, + 219, + 257, + 258, + 277, + 317, + 331, + 337 + ], + [ + 212, + 219, + 257, + 258, + 277, + 317, + 334, + 334 + ], + [ + 212, + 220, + 257, + 258, + 277, + 317, + 330, + 337 + ], + [ + 212, + 220, + 257, + 258, + 277, + 317, + 333, + 334 + ], + [ + 212, + 220, + 257, + 267, + 277, + 317, + 321, + 337 + ], + [ + 212, + 220, + 257, + 276, + 277, + 312, + 317, + 337 + ], + [ + 212, + 220, + 257, + 276, + 277, + 314, + 315, + 337 + ], + [ + 212, + 220, + 257, + 277, + 285, + 303, + 317, + 337 + ], + [ + 212, + 220, + 257, + 277, + 293, + 295, + 317, + 337 + ], + [ + 212, + 220, + 257, + 277, + 294, + 294, + 317, + 337 + ], + [ + 212, + 223, + 257, + 258, + 268, + 317, + 334, + 337 + ], + [ + 212, + 226, + 257, + 258, + 277, + 317, + 325, + 337 + ], + [ + 212, + 229, + 257, + 258, + 277, + 317, + 328, + 334 + ], + [ + 212, + 236, + 257, + 258, + 277, + 299, + 334, + 337 + ], + [ + 212, + 236, + 257, + 266, + 277, + 310, + 315, + 337 + ], + [ + 212, + 244, + 257, + 258, + 277, + 307, + 317, + 337 + ], + [ + 212, + 245, + 257, + 258, + 277, + 290, + 334, + 337 + ], + [ + 212, + 247, + 257, + 258, + 277, + 310, + 317, + 334 + ], + [ + 212, + 253, + 257, + 258, + 277, + 298, + 317, + 337 + ], + [ + 212, + 256, + 257, + 258, + 277, + 301, + 317, + 334 + ], + [ + 212, + 256, + 257, + 261, + 277, + 295, + 317, + 337 + ], + [ + 212, + 256, + 257, + 268, + 277, + 290, + 315, + 337 + ], + [ + 213, + 219, + 257, + 277, + 284, + 304, + 317, + 337 + ], + [ + 213, + 220, + 257, + 276, + 277, + 311, + 317, + 337 + ], + [ + 213, + 220, + 257, + 276, + 277, + 314, + 314, + 337 + ], + [ + 213, + 236, + 257, + 266, + 277, + 310, + 314, + 337 + ], + [ + 213, + 242, + 257, + 257, + 277, + 307, + 317, + 337 + ], + [ + 213, + 247, + 257, + 277, + 280, + 284, + 317, + 337 + ], + [ + 213, + 256, + 257, + 268, + 277, + 290, + 314, + 337 + ], + [ + 215, + 217, + 257, + 277, + 284, + 304, + 317, + 337 + ], + [ + 216, + 216, + 257, + 277, + 284, + 304, + 317, + 337 + ], + [ + 216, + 233, + 257, + 266, + 277, + 307, + 317, + 337 + ], + [ + 216, + 253, + 257, + 268, + 277, + 287, + 317, + 337 + ], + [ + 217, + 226, + 257, + 267, + 277, + 314, + 317, + 337 + ], + [ + 219, + 220, + 257, + 276, + 277, + 314, + 317, + 334 + ], + [ + 219, + 236, + 257, + 266, + 277, + 310, + 317, + 334 + ], + [ + 219, + 244, + 257, + 277, + 277, + 287, + 317, + 337 + ], + [ + 219, + 245, + 257, + 260, + 277, + 304, + 317, + 337 + ], + [ + 219, + 256, + 257, + 268, + 277, + 290, + 317, + 334 + ], + [ + 220, + 220, + 257, + 276, + 277, + 314, + 317, + 333 + ], + [ + 220, + 222, + 257, + 267, + 277, + 314, + 317, + 337 + ], + [ + 220, + 223, + 257, + 268, + 276, + 314, + 317, + 337 + ], + [ + 220, + 229, + 257, + 276, + 277, + 314, + 317, + 328 + ], + [ + 220, + 233, + 257, + 276, + 277, + 296, + 317, + 337 + ], + [ + 220, + 236, + 257, + 266, + 277, + 310, + 317, + 333 + ], + [ + 220, + 236, + 257, + 276, + 277, + 299, + 314, + 337 + ], + [ + 220, + 236, + 257, + 277, + 279, + 293, + 317, + 337 + ], + [ + 220, + 242, + 257, + 276, + 277, + 287, + 317, + 337 + ], + [ + 220, + 245, + 257, + 276, + 277, + 290, + 314, + 337 + ], + [ + 220, + 247, + 257, + 276, + 277, + 310, + 314, + 317 + ], + [ + 220, + 256, + 257, + 268, + 277, + 290, + 317, + 333 + ], + [ + 220, + 256, + 257, + 276, + 277, + 301, + 314, + 317 + ], + [ + 221, + 236, + 257, + 257, + 277, + 310, + 317, + 337 + ], + [ + 223, + 229, + 257, + 258, + 277, + 317, + 318, + 337 + ], + [ + 223, + 236, + 257, + 266, + 268, + 310, + 317, + 337 + ], + [ + 223, + 245, + 257, + 257, + 277, + 301, + 317, + 337 + ], + [ + 223, + 256, + 257, + 259, + 277, + 290, + 317, + 337 + ], + [ + 223, + 256, + 257, + 268, + 268, + 290, + 317, + 337 + ], + [ + 226, + 226, + 257, + 258, + 277, + 317, + 318, + 337 + ], + [ + 229, + 236, + 257, + 266, + 277, + 301, + 317, + 337 + ], + [ + 229, + 236, + 257, + 266, + 277, + 310, + 317, + 328 + ], + [ + 229, + 247, + 257, + 268, + 277, + 290, + 317, + 337 + ], + [ + 229, + 256, + 257, + 268, + 277, + 290, + 317, + 328 + ], + [ + 236, + 236, + 257, + 266, + 277, + 299, + 310, + 337 + ], + [ + 236, + 245, + 257, + 266, + 277, + 290, + 310, + 337 + ], + [ + 236, + 247, + 257, + 266, + 277, + 283, + 317, + 337 + ], + [ + 236, + 247, + 257, + 266, + 277, + 310, + 310, + 317 + ], + [ + 236, + 256, + 257, + 261, + 277, + 279, + 317, + 337 + ], + [ + 236, + 256, + 257, + 266, + 274, + 277, + 317, + 337 + ], + [ + 236, + 256, + 257, + 266, + 277, + 301, + 310, + 317 + ], + [ + 236, + 256, + 257, + 267, + 273, + 277, + 317, + 337 + ], + [ + 236, + 256, + 257, + 268, + 272, + 277, + 317, + 337 + ], + [ + 236, + 256, + 257, + 268, + 277, + 290, + 299, + 337 + ], + [ + 236, + 256, + 257, + 269, + 271, + 277, + 317, + 337 + ], + [ + 236, + 256, + 257, + 270, + 270, + 277, + 317, + 337 + ], + [ + 237, + 255, + 257, + 260, + 277, + 280, + 317, + 337 + ], + [ + 245, + 247, + 257, + 260, + 277, + 280, + 317, + 337 + ], + [ + 245, + 256, + 257, + 263, + 268, + 277, + 317, + 337 + ], + [ + 245, + 256, + 257, + 268, + 277, + 290, + 290, + 337 + ], + [ + 246, + 246, + 257, + 260, + 277, + 280, + 317, + 337 + ], + [ + 247, + 256, + 257, + 268, + 277, + 290, + 310, + 317 + ], + [ + 256, + 256, + 257, + 268, + 277, + 290, + 301, + 317 + ] + ], + "subset_census_seven": { + "1": 8 + }, + "subset_census_eight": { + "1": 579, + "2": 80, + "4": 6 + }, + "rank_survivors_eight": [ + [ + 10, + 257, + 267, + 277, + 317, + 317, + 337, + 337 + ], + [ + 30, + 257, + 277, + 277, + 287, + 317, + 337, + 337 + ], + [ + 50, + 257, + 257, + 277, + 307, + 317, + 317, + 337 + ], + [ + 70, + 257, + 257, + 277, + 277, + 317, + 327, + 337 + ], + [ + 144, + 185, + 257, + 257, + 277, + 317, + 337, + 337 + ], + [ + 152, + 193, + 257, + 277, + 277, + 317, + 317, + 337 + ] + ], + "character_obstructions": [ + { + "frames": [ + 10, + 257, + 267, + 277, + 317, + 317, + 337, + 337 + ], + "functional": [ + "-1/2", + "-1/2", + "-1/2", + "0", + "0", + "1/2", + "0", + "0", + "1" + ], + "frame_values": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "target_value": 1 + }, + { + "frames": [ + 30, + 257, + 277, + 277, + 287, + 317, + 337, + 337 + ], + "functional": [ + "-1/2", + "-1/2", + "-1/2", + "0", + "1", + "1/2", + "0", + "0", + "0" + ], + "frame_values": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "target_value": 1 + }, + { + "frames": [ + 50, + 257, + 257, + 277, + 307, + 317, + 317, + 337 + ], + "functional": [ + "-1/2", + "-1/2", + "1/2", + "0", + "1", + "-1/2", + "0", + "0", + "0" + ], + "frame_values": [ + 1, + 0, + 0, + 2, + 0, + 0, + 0, + 0 + ], + "target_value": 1 + }, + { + "frames": [ + 70, + 257, + 257, + 277, + 277, + 317, + 327, + 337 + ], + "functional": [ + "-1/2", + "1/2", + "-1/2", + "0", + "0", + "-1/2", + "0", + "0", + "1" + ], + "frame_values": [ + 1, + 0, + 0, + 0, + 0, + 2, + 0, + 0 + ], + "target_value": 1 + }, + { + "frames": [ + 144, + 185, + 257, + 257, + 277, + 317, + 337, + 337 + ], + "functional": [ + "1", + "-1/2", + "1/2", + "0", + "-1/2", + "-1/2", + "0", + "0", + "0" + ], + "frame_values": [ + 1, + 0, + 0, + 0, + 2, + 0, + 0, + 0 + ], + "target_value": 1 + }, + { + "frames": [ + 152, + 193, + 257, + 277, + 277, + 317, + 317, + 337 + ], + "functional": [ + "1", + "-1/2", + "-1/2", + "0", + "-1/2", + "1/2", + "0", + "0", + "0" + ], + "frame_values": [ + 1, + 0, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "target_value": 1 + } + ], + "nine_call_witness": [ + { + "frame_id": 89, + "role": 0 + }, + { + "frame_id": 304, + "role": 0 + }, + { + "frame_id": 326, + "role": 0 + }, + { + "frame_id": 89, + "role": 1 + }, + { + "frame_id": 304, + "role": 1 + }, + { + "frame_id": 326, + "role": 1 + }, + { + "frame_id": 89, + "role": 2 + }, + { + "frame_id": 304, + "role": 2 + }, + { + "frame_id": 326, + "role": 2 + } + ] +} diff --git a/research/bit-dyadic-ternary-catalyst/README.md b/research/bit-dyadic-ternary-catalyst/README.md new file mode 100644 index 0000000000..f01f6b348f --- /dev/null +++ b/research/bit-dyadic-ternary-catalyst/README.md @@ -0,0 +1,343 @@ +# Nine calls in a dyadic ternary model, even with dirty catalysts + +**Result.** Three identical dimension-three interchanges need exactly nine +paid calls in the finite frame alphabet below, even with any finite number +of additional registers that contain arbitrary data and must be restored. +This is a scoped computer-assisted obstruction. It does not improve the +selected supplier or establish a lower bound for general rational frames, +nonabelian address actions, or integer multiplication. + +The changed premise relative to the three-register result is genuine: the +scalar register space can have any finite dimension. The restriction that +makes this investigation finite is the explicit dyadic ternary frame +alphabet. All factor orders and repetitions in that alphabet are covered; +there is no bounded search over scalar projectors. + +## Exact model and theorem + +Let `R >= 3` be any finite register count. In the group algebra over +`F_2` of the additive group `M_3(Q)`, write `[A][B] = [A+B]`. A paid factor is + +\[ + D_N([A])=I_R+([A]-1)N, + \qquad N\in M_R(\mathbb F_2),\quad N^2=N,\quad\operatorname{rank}N=1. +\] + +The frame alphabet is + +\[ + \mathcal A=\{uv^T/2: + u,v\in\{-1,0,1\}^3\setminus\{0\}\}. +\] + +There are 26 nonzero ternary vectors. Two pairs give the same nonzero +outer product exactly when they differ by simultaneous negation, so the +alphabet has `26^2 / 2 = 338` frames. The required endpoint is + +\[ + \prod_{j=1}^{k}D_{N_j}([A_j]) + =\operatorname{diag}([I_3],[I_3],[I_3],1,\ldots,1). \tag{1} +\] + +Equality means equality of every formal group-algebra coefficient. In +particular, all incoming data in registers 4 through `R` are arbitrary, +all of those registers are restored, and they have no residual influence +on the three outputs. A clean-workspace-only identity is insufficient. +Arbitrary free address transformations between the factors are not part +of this alphabet. + +**Theorem.** Equation (1) has no solution with `k <= 8`, for any finite +`R >= 3`. It has a solution with `k = 9` for every such `R`. + +The lower bound uses exact finite enumeration of frame multisets and +explicit rational character witnesses. It does not enumerate the +projectors, limit the number of dirty registers, or assume a common +invariant subspace for those projectors. + +## 1. Determinant and target-coefficient conditions + +Scale every group exponent by two. This is an isomorphism of the additive +rational matrix group. Set `B_j = 2 A_j`, and set `T = 2 I_3`. Thus each +`B_j` is a rank-one matrix with entries in `{-1,0,1}`, and the three +nontrivial target entries are `[T]`. + +A rank-one idempotent can be written `N = xy^T` with `y^T x = 1`. The +determinant lemma gives + +\[ + \det D_N([B])=1+([B]-1)y^Tx=[B]. +\] + +Taking determinants of (1) therefore requires + +\[ + \sum_{j=1}^k B_j=3T=6I_3. \tag{2} +\] + +Next expand each factor as `(I_R-N_j) + [B_j]N_j`. A positional subset +`S` contributes the monomial `[sum_{j in S} B_j]` and an ordered scalar +matrix product: choose `N_j` at positions in `S` and `I_R-N_j` at the +other positions. Every nonempty such product has rank at most one, +because it contains a rank-one factor. The constant factors need not +have rank one; this does not change the product bound. + +The coefficient of `[T]` on the right of (1) is + +\[ + P=\operatorname{diag}(1,1,1,0,\ldots,0), + \qquad\operatorname{rank}P=3. +\] + +Consequently, there must be at least three **positional** subsets whose +frame sum is `T`. Repeated frame values occupy different positions and +are counted separately. Cancellations or zero subset products can only +make this necessary condition weaker. Its use does not depend on the +factor order or the register dimension. + +## 2. Why the finite census is complete + +A subset summing to `T` has at least three members: a sum of fewer than +three rank-one rational matrices cannot have rank three. By (2), its +complement sums to `2T = 4I_3`. Each diagonal entry of a frame is at most +one, so this complement has at least four members. + +Thus `k <= 6` is impossible. For seven calls the only possible split is +`3 + 4`; for eight calls it is `3 + 5` or `4 + 4`. No other subset size +has been omitted. + +A four-frame complement summing to `4I_3` has every diagonal entry of +every frame equal to one. Writing a frame as `uv^T` forces `u = v` with +all three entries in `{+1,-1}`. Up to simultaneous negation of `u` and `v`, there are +four possibilities: + +\[ + H_{s,t}=(1,s,t)^T(1,s,t),\qquad s,t\in\{-1,1\}. +\] + +The three off-diagonal sum equations and the equation for the total +number of frames force one copy of each `H_{s,t}`. Denote this unique +four-frame multiset by `H`. + +For a five-frame complement, each diagonal is a sum of five numbers in +`{-1,0,1}` equal to four. Its terms are four ones and one zero. Hence all +five frames have nonnegative diagonals, and their total trace is twelve. +This is a necessary restriction, not a symmetry assumption. There are +145 frames with nonnegative diagonals. Exhaustive exact enumeration on +that set finds all five-frame complements. + +The verifier generates the alphabet from the vector definition, uses +integer matrix sums, and enumerates multisets with replacement. Its +decomposition counts are: + +| Exact sum | Number of frames | Number of multisets | +|---|---:|---:| +| `T` | 3 | 8 | +| `T` | 4 | 473 | +| `2T` | 4 | 1, namely `H` | +| `2T` | 5 | 24 | + +For seven calls, union each three-frame decomposition of `T` with `H`. +This gives eight candidate multisets; each has exactly one positional +subset summing to `T`, so all eight fail the coefficient-rank condition. + +For eight calls, take the union of the `3 + 5` candidates and the +`4 + H` candidates and deduplicate equal full multisets. There are 665. +These are all eight-frame multisets satisfying (2) and admitting at +least one target subset. They are not asserted to be all multisets +satisfying (2) alone; a multiset without a target subset already fails +(1). + +| Positional subsets summing to `T` | Eight-frame multisets | +|---:|---:| +| 1 | 579 | +| 2 | 80 | +| 4 | 6 | + +The first 659 are excluded by rank. The remaining six are excluded below. +The certificate retains the decompositions, candidates, subset counts, +and exact witnesses; the verifier regenerates the census rather than +accepting these displayed counts as a proof. + +## 3. A parity character excludes each survivor + +Here is one representative, written using `e_1,e_2,e_3`: + +\[ + \{- (e_1+e_2)(e_1+e_2)^T, + H_{-1,-1}, + (e_1-e_2)(e_1-e_2)^T, + H_{-1,1}, + H_{1,-1},H_{1,-1},H_{1,1},H_{1,1}\}. \tag{3} +\] + +Its six full-sign frames and two sparse frames have total `6I_3`. +For a matrix `B = (b_ij)`, define the rational linear functional + +\[ + \ell(B)=\frac{-b_{11}-b_{12}-b_{13}+b_{23}+2b_{33}}2. +\] + +On the eight listed frames its values are, in the displayed order, + +\[ + (1,2,0,0,0,0,0,0),\qquad \ell(T)=1. \tag{4} +\] + +The six surviving multisets form the orbit of (3) under simultaneous +signed coordinate permutations `B -> P B P^T`; the finite orbit has six +elements. The certificate also supplies and checks a direct rational +functional for every survivor, so the exclusion need not rely on an +unchecked symmetry reduction. + +The domain of the character matters. Let `L` be the additive subgroup +generated by the paid frames of the particular word. A surviving word +has a subset summing to `T`, so `T` already belongs to `L`. All values +of `ell` on the generators are integers, so `ell` maps `L` to `Z`. +Reduction modulo two therefore defines a well-defined homomorphism + +\[ + L\longrightarrow C_2,\qquad B\longmapsto g^{\ell(B)\bmod2}. +\] + +Restrict the asserted identity first to `F_2[L]`, then apply the induced +group-algebra map to `F_2[C_2]`. We do **not** claim a nontrivial +homomorphism from the full divisible group `M_3(Q)` to `C_2`. + +By (4), seven paid factors map to the identity and one maps to + +\[ + I_R+(g-1)N. +\] + +The target maps to `diag(g,g,g,1,...,1)`. Comparing coefficients of the +formal basis element `g` gives `N = P`, contradicting ranks one and +three. The order of the eight factors is immaterial after this map. +Although `F_2[C_2]` has zero divisors, the argument only compares its +two formal coefficients; it does not take matrix rank over that ring +or assume it has a fraction field. + +This excludes the six remaining frame multisets for every finite `R`. + +## 4. An alphabet-valid nine-call identity + +Let + +\[ + B_1=\begin{pmatrix}0&-1&-1\\0&1&1\\0&1&1\end{pmatrix},\quad + B_2=\begin{pmatrix}1&0&1\\-1&0&-1\\1&0&1\end{pmatrix},\quad + B_3=\begin{pmatrix}1&1&0\\1&1&0\\-1&-1&0\end{pmatrix}. +\] + +Each is an outer product of nonzero ternary vectors and +`B_1+B_2+B_3 = 2I_3`. Thus `A_i=B_i/2` belongs to the stated alphabet +and `A_1+A_2+A_3=I_3`. For each of the three active scalar coordinate +projectors `E_ww`, apply the three factors with these frames. Their +product is `D_{E_ww}([I_3])`. The nine factors together give (1), while +every additional register is untouched. This is a formal identity, +not a test at one finite address size. + +## Paid budget and scope of the negative result + +The proposed eight-call mechanism had the optimistic recursive bill + +\[ + M_8(a)=\frac{8}{3}(1/3)^{1-a}=\frac89\,3^a. +\] + +It would have had room for a positive saving if all required recursive +calls, including frame changes and restoration, fitted within those +eight calls. The theorem rules out that core identity in this alphabet. +The nine-call minimum instead has + +\[ + M_9(a)=3^a\ge1\quad(a\ge0), +\] + +with equality only at zero saving. Additional nonnegative hosting, +transport, or restoration charges cannot repair this failed budget. +The normalization uses the three requested interchanges: restored +spectators do not become extra completed output roles. The calculation +does not assume that their physical storage or access is free. + +This rejects the stated mechanism, even under its favorable bill. It +does not bound quarter-denominator frames, larger vector entries, +different target frames, nonabelian operations, or a different recursive +contract. There is no new kappa or selected-frontier claim. + +## Reproduction and evidence + +From the repository root: + +```sh +python3 -I -O -B research/bit-dyadic-ternary-catalyst/verify.py +python3 -I -B research/bit-dyadic-ternary-catalyst/independent.py +python3.12 -X utf8 -B scripts/research_package.py --package research/bit-dyadic-ternary-catalyst +``` + +The default command is read-only. It regenerates the finite census, +checks the stored certificate, verifies all character evaluations and +the nine-call witness, and runs deliberate failure controls. Explicit +`--write` regenerates this package's `CERTIFICATE.json`. + +The independent implementation uses ordered depth-first enumeration with +coordinate bounds, rather than the primary meet-in-the-middle census. It +compares every decomposition and candidate multiset, reconstructs the six +characters independently, and verifies positional subset counts again using +binomial multiplicities. It refuses `-O`, which would disable its assertions. +Both implementations use Python 3.12 and the standard library only. +Local validation used CPython 3.12.14 on Windows. The registered replay and +source bindings passed; the primary verifier rejected eight deliberately +corrupted certificates and the independent checker rejected two. + +The proof uses exact integer and rational arithmetic. Numerical moment +estimates, finite cyclic-address simulations, and a full selected-supplier +cold replay are not acceptance evidence for this local theorem. The +selected construction and its inherited obligations are unchanged. + +## Predecessors and contribution + +- [Ali Romman's PR #468](https://github.com/CrocSwap/integer-mult-bounds/pull/468), + retained in `research/bit-three-register-lower-bound/README.md`, proves + the unrestricted-rational-frame nine-call lower bound for its specified + three-register model. It explicitly leaves additional registers outside + its scope. +- That work builds on eumemic's [PR #288](https://github.com/CrocSwap/integer-mult-bounds/pull/288), + pinned at `475a088b5862f75f0b10596cfd6842d19531a5ec`, and huxint's + [PR #203](https://github.com/CrocSwap/integer-mult-bounds/pull/203), pinned + at `d2873e20750d0949d2ad75cbc4cd82b5b1a74e84`. +- woklerx's [PR #1456](https://github.com/CrocSwap/integer-mult-bounds/pull/1456) + already investigates arbitrary-register obstructions with at most one + rational frame relation, at head + `83b6ad2ace819a96128131a3600ee914a66dd0dd`. This package does not claim that restriction, + the general projection method, or parity characters as new techniques. +- Cinna Davis's [PR #1541](https://github.com/CrocSwap/integer-mult-bounds/pull/1541) + (head `194724d87505ec2517fdca1c1884da12398f4c33`) concerns a different + finite nonabelian group model. This package retains + additive rational matrix exponents. + +The contribution here is the complete 338-frame dyadic ternary census, +its arbitrary-register exclusion, and exact reproducible witnesses for +the six surviving multisets. Coordination is recorded in +[discussion #1594](https://github.com/CrocSwap/integer-mult-bounds/discussions/1594). +Prepared for Tuafo with substantial OpenAI Codex assistance: GPT-6 Astra +at maximum reasoning for derivation, separate implementations and proof +review, with root integration. Separate AI checks are not independent human +review or proof-assistant formalization. Apache-2.0. + +## Open next questions + +1. **Can a larger explicit dyadic alphabet escape the obstruction?** A + feasible first step is to add frames `uv^T/4` to the present alphabet, + or allow a bounded larger vector alphabet, then derive the determinant + and coefficient-rank restrictions, + and price the complete favorable bill before any census. The blocker is + that the present `3 + 5` / `4 + 4` reduction and six-survivor list no + longer apply automatically. Merely changing the denominator need not + create a feasible identity. +2. **Is there an alphabet-independent extra-register obstruction at eight + calls?** The present character witnesses suggest a precise question but + do not prove it. A first step is to classify which frame-relation + lattices admit a character seeing fewer than three paid factors while + seeing all three targets. Rational frames outside this finite alphabet + are the blocker; the known at-most-one-relation scope must be credited + rather than repeated. diff --git a/research/bit-dyadic-ternary-catalyst/SOURCES.json b/research/bit-dyadic-ternary-catalyst/SOURCES.json new file mode 100644 index 0000000000..fc3cb5c7db --- /dev/null +++ b/research/bit-dyadic-ternary-catalyst/SOURCES.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "base_commit": "ddb4371c16a5a5de9e363afa8c0d6d7c27429e3c", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "c05fafaa25ba95b2d5af86b1800427198e3d20eb", + "sha256": "89b5928bc92c81e2647b6d702a7ad85a6795b8f44e2eb267b2ff3145d8f2b2ce" + }, + { + "path": "research/bit-three-register-lower-bound/README.md", + "usage": "input", + "git_blob": "25e41c370c101a33a6deb978de08b03ed7539b79", + "sha256": "c12b33ef388deece0cbf891505a2ce2c0779a0c3a6cf1f0f7f7039bab59cbebd" + } + ] +} diff --git a/research/bit-dyadic-ternary-catalyst/TASK.json b/research/bit-dyadic-ternary-catalyst/TASK.json new file mode 100644 index 0000000000..3f7cd3b5f0 --- /dev/null +++ b/research/bit-dyadic-ternary-catalyst/TASK.json @@ -0,0 +1,107 @@ +{ + "schema_version": 1, + "task_id": "bit-new-register-model", + "priority_revision": 2, + "base_commit": "ddb4371c16a5a5de9e363afa8c0d6d7c27429e3c", + "original_card": { + "id": "bit-new-register-model", + "question": "Can an explicitly larger or nonabelian register model escape the scoped three-register obstruction?", + "starting_points": [ + "research/bit-three-register-lower-bound/README.md", + "certificates/selected-result.json" + ], + "methods": [ + "Construct the smallest exact identity in a newly specified legal operation alphabet.", + "Derive a target-specific relaxation bound for that same explicit alphabet." + ], + "acceptance_gate": "Name the changed hypothesis, all counted roles and a uniform identity; finite column tests alone do not certify it.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read Model section 1 of the three-register bound and identify the exact excluded free operations.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write a complete operation alphabet outside one named premise and price a baseline before searching identities.", + "bottleneck_link": "A small-width completed saving changes the bit primitive; a finite-address identity alone is insufficient.", + "allowed_variations": [ + "Choose a fixed larger register count or a specified nonabelian operation family." + ], + "scope_change_triggers": [ + "Remaining inside the already-excluded three-register abelian model." + ], + "overlap_terms": [ + "three-register", + "nonabelian", + "group algebra" + ] + }, + "scope_status": "refined", + "actual_scope": "Determine the exact minimum paid rank-one calls for three repeated I3 targets in the 338-frame alphabet A=u v^T/2 (nonzero ternary 3-vectors), allowing arbitrary finite restored dirty registers, repetitions and all call orders.", + "scope_change_reason": "Enlarge the scalar register count beyond the three-register predecessor, while restricting rational frames to an explicit half-integral finite alphabet and fixing all three targets. The initial four-register search reduces to conditions independent of register count.", + "bottleneck_link": "An eight-call construction would have optimistic moment (8/9)*3^a before extra charges for three width-three outputs. The nine-call obstruction rejects this concrete catalytic route; it does not restrict other frame alphabets or the selected supplier.", + "budget_minutes": 60, + "stop_rule": "Complete exact determinant/coefficient census through eight calls, independently check its finite premises and parity witnesses, exhibit a nine-call formal word, and stop without enlarging the alphabet.", + "outcome": "completed", + "evidence": "README.md proves the reduction; CERTIFICATE.json records the exact census and six additive-character witnesses; verify.py and independent.py replay the finite claims without importing each other. Final validation details are in the PR.", + "author": "Tuafo", + "ai_assistance": "Prepared for Tuafo with substantial OpenAI Codex assistance: GPT-6 Astra at maximum reasoning for candidate derivation, independent proof review, independent implementation and review; root integration. Separate AI checks do not constitute independent human review.", + "open_questions": [ + { + "question": "Does allowing additional quarter-integral rank-one frames admit eight calls for the same three targets and restored dirty helpers?", + "why_it_matters": "It changes the finite alphabet that the nine-call obstruction actually excludes, while retaining the paid-call target.", + "first_step": "Specify the larger frame set and derive determinant and target-coefficient necessary conditions before any scalar-projector search; measure the candidate count and look for separating additive characters.", + "blocked_by": "The present finite census and parity certificates cover only A=u v^T/2 with ternary vectors; no larger-alphabet search or physical implementation is supplied." + }, + { + "question": "Can the determinant/coefficient/character elimination be made symbolic for an unbounded dyadic alphabet?", + "why_it_matters": "A symbolic result could avoid repeated bounded searches and clarify which arithmetic hypothesis must change.", + "first_step": "Classify why the six surviving multisets admit an integer-valued parity functional and find a candidate outside that separable class.", + "blocked_by": "No general separation theorem is proved here; absence of a parity witness would not establish a circuit." + } + ], + "coordination": { + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1594", + "initial_released_scope": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1581", + "nearest_context": [ + { + "pr": 468, + "role": "Three-register rational-frame obstruction; pinned source README is a live input." + }, + { + "pr": 1456, + "head": "83b6ad2ace819a96128131a3600ee914a66dd0dd", + "role": "Already proves at-most-one-relation obstruction for arbitrary register counts; not claimed as a new result here." + }, + { + "pr": 1541, + "role": "Three coordinate swaps in finite nonabelian GL2(F2); different address group and paid alphabet.", + "head": "194724d87505ec2517fdca1c1884da12398f4c33" + } + ], + "overlap_limit": "Open PR titles/bodies (including drafts), Discussion bodies/comments/replies, top-level local package notes and ledger; excludes arbitrary code diffs and unindexed closed work. Relevant PR1456/1541 heads agree with the refreshed snapshot.", + "submission_overlap": { + "searched_at": "2026-10-14T03:50:45.820069+00:00", + "open_prs": { + "count": 731, + "fetched_at": "2026-10-14T03:49:23.734551+00:00", + "complete_pagination": true + }, + "discussions": { + "count": 244, + "fetched_at": "2026-10-14T03:50:45.693807+00:00", + "complete_pagination": true + }, + "terms": [ + "dyadic ternary", + "338-frame", + "catalytic half" + ], + "semantic_followup": "Inspected neighboring ternary, half-integral, half-integer, rank-one, register and frame scopes in the refreshed bodies; no matching finite-alphabet census found. This is not a novelty certificate.", + "warnings": [] + } + } +} diff --git a/research/bit-dyadic-ternary-catalyst/VERIFY.json b/research/bit-dyadic-ternary-catalyst/VERIFY.json new file mode 100644 index 0000000000..d3778de660 --- /dev/null +++ b/research/bit-dyadic-ternary-catalyst/VERIFY.json @@ -0,0 +1,29 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/bit-three-register-lower-bound/README.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Complete finite-alphabet census, target coefficient ranks, six exact parity characters, formal nine-call upper witness and semantic failure controls." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/independent.py" + ], + "timeout_seconds": 120, + "checks": "Code-disjoint exact frame/decomposition census and character checks; compare proof-relevant certificate fields." + } + ] +} diff --git a/research/bit-dyadic-ternary-catalyst/independent.py b/research/bit-dyadic-ternary-catalyst/independent.py new file mode 100644 index 0000000000..201ff4ebc9 --- /dev/null +++ b/research/bit-dyadic-ternary-catalyst/independent.py @@ -0,0 +1,317 @@ +#!/usr/bin/env python3 +"""Independent finite census for the dyadic ternary rank-one alphabet. + +Uses ordered depth-first tuple enumeration, coordinate bounds, and final-frame +lookup. Does not import the primary verifier. Every repeated occurrence remains +a separate position for coefficient-subset counts. Standard library only. +""" +from __future__ import annotations + +import argparse +from collections import Counter +from fractions import Fraction +from hashlib import sha256 +from itertools import product +from math import comb +from pathlib import Path +import json +import platform +import time + +if not __debug__: + raise RuntimeError("Run this independent verifier without -O: its proof checks use assertions.") + +ZERO = (0,) * 9 +T = (2, 0, 0, 0, 2, 0, 0, 0, 2) +C = tuple(2 * v for v in T) +TOTAL = tuple(3 * v for v in T) + + +def alphabet(): + vectors = [v for v in product((-1, 0, 1), repeat=3) if any(v)] + return tuple(sorted({tuple(x * y for x in u for y in v) + for u in vectors for v in vectors})) + + +def add(a, b): + return tuple(x + y for x, y in zip(a, b)) + + +def sum_frames(ids, frames): + return tuple(sum(frames[i][j] for i in ids) for j in range(9)) + + +def decompositions(frames, size, target): + """All nondecreasing index tuples summing to target, repetitions allowed. + + If one selected frame f leaves size-1 entries in [-1,1], then each + target[j]-f[j] must lie in [-(size-1),size-1]. This initial filter is + necessary. Recursion uses the same bound at every node. The final frame + is determined uniquely by the residual matrix, so a dictionary lookup + completes each branch without any symmetry or sign-orbit reduction. + """ + allowed = [i for i, f in enumerate(frames) + if all(abs(target[j] - f[j]) <= size - 1 for j in range(9))] + lookup = {frames[i]: i for i in allowed} + output = [] + counts = Counter() + + def descend(start, remaining, residual, chosen): + counts['nodes'] += 1 + if remaining == 1: + last = lookup.get(residual) + if last is not None and last >= start: + output.append(chosen + (last,)) + return + bound = remaining - 1 + for idx in allowed: + if idx < start: + continue + counts['trials'] += 1 + f = frames[idx] + # Test diagonal coordinates first; these reject most branches. + d0 = residual[0] - f[0] + d4 = residual[4] - f[4] + d8 = residual[8] - f[8] + if abs(d0) > bound or abs(d4) > bound or abs(d8) > bound: + continue + next_residual = (d0, residual[1] - f[1], residual[2] - f[2], + residual[3] - f[3], d4, residual[5] - f[5], + residual[6] - f[6], residual[7] - f[7], d8) + if any(abs(next_residual[j]) > bound for j in (1, 2, 3, 5, 6, 7)): + continue + descend(idx, remaining - 1, next_residual, chosen + (idx,)) + + descend(0, size, target, ()) + assert output == sorted(set(output)) + assert all(sum_frames(ids, frames) == target for ids in output) + return output, {'allowed_frames': len(allowed), **dict(counts)} + + +def positional_masks(ids, frames, target=T): + """Exhaust all 2^k positional subsets by recurrence from the least bit.""" + sums = [ZERO] * (1 << len(ids)) + matches = [] + for mask in range(1, 1 << len(ids)): + bit = mask & -mask + pos = bit.bit_length() - 1 + sums[mask] = add(sums[mask ^ bit], frames[ids[pos]]) + if sums[mask] == target: + matches.append(mask) + return matches + + +def weighted_subsets(ids, frames, target=T): + """Independent multiplicity count via submultisets and binomial weights.""" + counts = sorted(Counter(ids).items()) + total = 0 + matching = [] + for multiplicities in product(*(range(n + 1) for _, n in counts)): + sub = tuple(i for (i, _), m in zip(counts, multiplicities) for _ in range(m)) + if sum_frames(sub, frames) == target: + weight = 1 + for (_, n), m in zip(counts, multiplicities): + weight *= comb(n, m) + total += weight + matching.append({'multiplicities': list(multiplicities), 'positional_weight': weight}) + return total, matching + + +def candidates(left, right): + return sorted({tuple(sorted(a + b)) for a in left for b in right}) + + +def analyze(items, frames): + hist = Counter() + rows = [] + for ids in items: + assert sum_frames(ids, frames) == TOTAL + masks = positional_masks(ids, frames) + weighted, submultisets = weighted_subsets(ids, frames) + assert len(masks) == weighted, (ids, masks, submultisets) + assert masks + hist[len(masks)] += 1 + common = (1 << len(ids)) - 1 + for mask in masks: + common &= mask + rows.append({'frames': list(ids), 'target_masks': masks, + 'common_positions_mask': common, + 'target_submultisets': submultisets}) + return {str(k): hist[k] for k in sorted(hist)}, rows + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode('utf8') + + +def run(): + start = time.perf_counter() + frames = alphabet() + assert len(frames) == 338 + # Positive fixture: each coordinate matrix occurs and has exact rank one. + for j in (0, 4, 8): + assert tuple(int(k == j) for k in range(9)) in frames + lists, diagnostics = {}, {} + for name, n, target in [('target3', 3, T), ('target4', 4, T), + ('complement4', 4, C), ('complement5', 5, C)]: + lists[name], diagnostics[name] = decompositions(frames, n, target) + seven = candidates(lists['target3'], lists['complement4']) + eight = sorted(set(candidates(lists['target3'], lists['complement5'])) | + set(candidates(lists['target4'], lists['complement4']))) + hist7, rows7 = analyze(seven, frames) + hist8, rows8 = analyze(eight, frames) + survivors = [row for row in rows8 if len(row['target_masks']) >= 3] + result = { + 'schema': 'independent-dyadic-ternary-census-v1', + 'method': 'ordered tuple DFS with coordinate bounds and terminal lookup; independent positional and binomial-multiplicity subset counts', + 'frames': [list(f) for f in frames], + 'decompositions': {key: [list(x) for x in value] for key, value in lists.items()}, + 'counts': {key: len(value) for key, value in lists.items()}, + 'seven': {'count': len(seven), 'target_subset_census': hist7, 'candidates': rows7}, + 'eight': {'count': len(eight), 'target_subset_census': hist8, 'candidates': rows8}, + 'survivors': survivors, + } + assert result['counts'] == {'target3': 8, 'target4': 473, 'complement4': 1, 'complement5': 24} + assert len(seven) == 8 and hist7 == {'1': 8} + assert len(eight) == 665 and hist8 == {'1': 579, '2': 80, '4': 6} + assert len(survivors) == 6 + result['independently_constructed_characters'] = [construct_character(tuple(r['frames']), frames) for r in survivors] + result['self_checks'] = self_checks(frames) + return result, {'python': platform.python_version(), 'seconds': time.perf_counter()-start, + 'diagnostics': diagnostics, 'proof_data_sha256': sha256(canonical(result)).hexdigest()} + + +def dot(functional, matrix): + return sum((a * b for a, b in zip(functional, matrix)), Fraction(0)) + + +def solve_linear(rows, values): + """Exact reduced row elimination; free variables are set to zero.""" + mat = [[Fraction(v) for v in row] + [Fraction(value)] + for row, value in zip(rows, values)] + pivots = [] + for col in range(9): + pivot = next((r for r in range(len(pivots), len(mat)) if mat[r][col]), None) + if pivot is None: + continue + row = len(pivots) + mat[row], mat[pivot] = mat[pivot], mat[row] + scale = mat[row][col] + mat[row] = [v / scale for v in mat[row]] + for r in range(len(mat)): + if r != row and mat[r][col]: + scale = mat[r][col] + mat[r] = [x - scale * y for x, y in zip(mat[r], mat[row])] + pivots.append(col) + if any(not any(row[:9]) and row[9] for row in mat): + return None + solution = [Fraction(0)] * 9 + for row, col in enumerate(pivots): + solution[col] = mat[row][9] + assert all(dot(solution, row) == value for row, value in zip(rows, values)) + return solution + + +def construct_character(ids, frames): + """Find a fresh exact character without reading a predecessor functional.""" + rows = [frames[i] for i in ids] + [T] + for odd in range(len(ids)): + for even in range(len(ids)): + if odd == even: + continue + values = [0] * len(ids) + values[odd], values[even] = 1, 2 + functional = solve_linear(rows, values + [1]) + if functional is not None: + return {'frames': list(ids), 'functional': [str(v) for v in functional], + 'frame_values': values, 'target_value': 1} + raise AssertionError('No singleton-odd character found') + + +def self_checks(frames): + # Repeated occurrences of the same matrix really are separate subsets. + unit = (1, 0, 0, 0, 0, 0, 0, 0, 0) + other = (0, 0, 0, 0, 1, 0, 0, 0, 0) + i, j = frames.index(unit), frames.index(other) + assert positional_masks((i, i, j), frames, unit) == [1, 2] + assert weighted_subsets((i, i, j), frames, unit)[0] == 2 + assert decompositions(frames, 1, unit)[0] == [(i,)] + impossible = tuple(3 * v for v in unit) + assert decompositions(frames, 2, impossible)[0] == [] + assert solve_linear([ZERO], [1]) is None + return ['duplicate positional multiplicity', 'one-frame positive fixture', + 'coordinate-bound impossible fixture', 'inconsistent exact linear system'] + + +def validate_certificate_data(result, other): + assert other['schema_version'] == 1 + assert other['frame_denominator'] == 2 + assert other['target_scaled'] == list(T) + assert other['alphabet'] == result['frames'] + mappings = {'target3': 'decompositions_three', 'target4': 'decompositions_four', + 'complement5': 'complements_five'} + for ours, theirs in mappings.items(): + assert sorted(result['decompositions'][ours]) == sorted(other[theirs]), theirs + for number in ('seven', 'eight'): + assert sorted(r['frames'] for r in result[number]['candidates']) == sorted(other['candidates_' + number]) + assert result[number]['target_subset_census'] == other['subset_census_' + number] + survivors = sorted(r['frames'] for r in result['survivors']) + assert survivors == sorted(other['rank_survivors_eight']) + characters = other['character_obstructions'] + assert sorted(c['frames'] for c in characters) == survivors + frames = result['frames'] + for character in characters: + functional = [Fraction(v) for v in character['functional']] + assert len(functional) == 9 + actual = [dot(functional, frames[i]) for i in character['frames']] + assert all(v.denominator == 1 for v in actual) + assert actual == character['frame_values'] + assert sum(int(v) % 2 for v in actual) == 1 + assert dot(functional, T) == character['target_value'] == 1 + # Each role is an independent diagonal action. Its exponents must sum to T. + witness = other['nine_call_witness'] + assert len(witness) == 9 + assert all(isinstance(w['frame_id'], int) and 0 <= w['frame_id'] < len(frames) + and w['role'] in (0, 1, 2) for w in witness) + for role in range(3): + assert sum_frames([w['frame_id'] for w in witness if w['role'] == role], frames) == T + + +def compare_certificate(result, filename): + payload = Path(filename).read_bytes() + other = json.loads(payload) + validate_certificate_data(result, other) + rejected = [] + for mutation in ('missing_decomposition', 'zero_character'): + corrupt = json.loads(payload) + if mutation == 'missing_decomposition': + corrupt['decompositions_four'].pop() + else: + corrupt['character_obstructions'][0]['functional'] = ['0'] * 9 + try: + validate_certificate_data(result, corrupt) + except AssertionError: + rejected.append(mutation) + else: + raise AssertionError('Corrupt certificate accepted: ' + mutation) + return {'file': str(filename), 'sha256': sha256(payload).hexdigest(), + 'status': 'all census lists, exact parity characters, and nine-call witness agree', + 'rejected_controls': rejected} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--output', type=Path) + parser.add_argument('--certificate', type=Path, default=Path(__file__).with_name('CERTIFICATE.json')) + args = parser.parse_args() + result, receipt = run() + receipt['certificate_comparison'] = compare_certificate(result, args.certificate) + if args.output: + args.output.write_text(json.dumps({'proof_data': result, 'receipt': receipt}, indent=2) + '\n', encoding='utf8') + print(json.dumps({'counts': result['counts'], 'seven': result['seven']['target_subset_census'], + 'eight': result['eight']['target_subset_census'], 'survivors': len(result['survivors']), + **receipt}, indent=2)) + + +if __name__ == '__main__': + main() diff --git a/research/bit-dyadic-ternary-catalyst/verify.py b/research/bit-dyadic-ternary-catalyst/verify.py new file mode 100644 index 0000000000..8430b1bd1f --- /dev/null +++ b/research/bit-dyadic-ternary-catalyst/verify.py @@ -0,0 +1,331 @@ +#!/usr/bin/env python3 +"""Exact finite-alphabet census and parity-character certificates. + +Default execution is read-only. --write explicitly regenerates CERTIFICATE.json. +All address arithmetic is integral or rational; binary arithmetic applies only +to scalar register matrices and to integral-valued characters. +""" + +import argparse +from collections import Counter, defaultdict +from copy import deepcopy +from fractions import Fraction +from itertools import product +import json +from pathlib import Path + + +HERE = Path(__file__).resolve().parent +ZERO = (0,) * 9 +TARGET = (2, 0, 0, 0, 2, 0, 0, 0, 2) +FOUR_I = tuple(2 * x for x in TARGET) +DIAGONAL = (0, 4, 8) +SCOPE = "three identical identity targets; ternary outer products divided by two; arbitrary finite restored dirty registers" + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def add(a, b): + return tuple(x + y for x, y in zip(a, b)) + + +def subtract(a, b): + return tuple(x - y for x, y in zip(a, b)) + + +def trace(a): + return sum(a[i] for i in DIAGONAL) + + +def alphabet(): + vectors = [v for v in product((-1, 0, 1), repeat=3) if any(v)] + return sorted({tuple(u[i] * v[j] for i in range(3) for j in range(3)) + for u in vectors for v in vectors}) + + +def target_masks(word, frames): + """Preserve positional multiplicities, including equal frame occurrences.""" + sums = [ZERO] + for frame_id in word: + sums += [add(value, frames[frame_id]) for value in sums] + return [mask for mask, value in enumerate(sums) if value == TARGET] + + +def census(): + frames = alphabet() + pairs = defaultdict(list) + for i, left in enumerate(frames): + for j in range(i, len(frames)): + pairs[add(left, frames[j])].append((i, j)) + + triples, quadruples = set(), set() + for i, frame in enumerate(frames): + for j, k in pairs.get(subtract(TARGET, frame), ()): + if i <= j: + triples.add((i, j, k)) + for pair_sum, left_pairs in pairs.items(): + for i, j in left_pairs: + for k, ell in pairs.get(subtract(TARGET, pair_sum), ()): + if j <= k: + quadruples.add((i, j, k, ell)) + + # Five terms summing to 4I have four +1 and one 0 at each diagonal + # coordinate. Thus every diagonal is nonnegative and total trace is 12. + nonnegative = [i for i, frame in enumerate(frames) + if all(frame[d] >= 0 for d in DIAGONAL)] + nonnegative_pairs = defaultdict(list) + for pos, i in enumerate(nonnegative): + for j in nonnegative[pos:]: + if trace(frames[i]) + trace(frames[j]) >= 3: + nonnegative_pairs[add(frames[i], frames[j])].append((i, j)) + complements = set() + for pos_i, i in enumerate(nonnegative): + for pos_j in range(pos_i, len(nonnegative)): + j = nonnegative[pos_j] + for k in nonnegative[pos_j:]: + if trace(frames[i]) + trace(frames[j]) + trace(frames[k]) < 6: + continue + triple_sum = add(add(frames[i], frames[j]), frames[k]) + for ell, m in nonnegative_pairs.get(subtract(FOUR_I, triple_sum), ()): + if k <= ell: + complements.add((i, j, k, ell, m)) + + # Four terms summing to 4I must all have diagonal (1,1,1). + hadamard = tuple(i for i, frame in enumerate(frames) + if all(frame[d] == 1 for d in DIAGONAL)) + require(len(hadamard) == 4, "full-diagonal alphabet is not four frames") + total = ZERO + for i in hadamard: + total = add(total, frames[i]) + require(total == FOUR_I, "four full-diagonal frames do not sum to 4I") + # Check the claimed unique multiset, with repetitions allowed, directly. + full_complements = set() + for i in hadamard: + for j in hadamard: + for k in hadamard: + for ell in hadamard: + if i <= j <= k <= ell and add(add(frames[i], frames[j]), + add(frames[k], frames[ell])) == FOUR_I: + full_complements.add((i, j, k, ell)) + require(full_complements == {hadamard}, "four-frame complement uniqueness failed") + + words7 = sorted({tuple(sorted(t + hadamard)) for t in triples}) + words8 = {tuple(sorted(t + c)) for t in triples for c in complements} + words8.update(tuple(sorted(q + hadamard)) for q in quadruples) + words8 = sorted(words8) + counts7 = Counter(len(target_masks(w, frames)) for w in words7) + counts8 = Counter(len(target_masks(w, frames)) for w in words8) + survivors = [w for w in words8 if len(target_masks(w, frames)) >= 3] + require(all(len(target_masks(w, frames)) < 3 for w in words7), + "seven-call candidate survives coefficient-rank bound") + return { + "alphabet": frames, + "decompositions_three": sorted(triples), + "decompositions_four": sorted(quadruples), + "complements_five": sorted(complements), + "candidates_seven": words7, + "candidates_eight": words8, + "subset_census_seven": {str(k): v for k, v in sorted(counts7.items())}, + "subset_census_eight": {str(k): v for k, v in sorted(counts8.items())}, + "rank_survivors_eight": survivors, + } + + +def solve_rational(rows, rhs): + matrix = [[Fraction(x) for x in row] + [Fraction(value)] + for row, value in zip(rows, rhs)] + pivot_row, columns = 0, [] + for col in range(9): + next_row = next((r for r in range(pivot_row, len(matrix)) if matrix[r][col]), None) + if next_row is None: + continue + matrix[pivot_row], matrix[next_row] = matrix[next_row], matrix[pivot_row] + scale = matrix[pivot_row][col] + matrix[pivot_row] = [x / scale for x in matrix[pivot_row]] + for r in range(len(matrix)): + if r != pivot_row and matrix[r][col]: + scale = matrix[r][col] + matrix[r] = [x - scale * y for x, y in zip(matrix[r], matrix[pivot_row])] + columns.append(col) + pivot_row += 1 + if any(not any(row[:9]) and row[9] for row in matrix): + return None + answer = [Fraction(0)] * 9 + for r, col in enumerate(columns): + answer[col] = matrix[r][9] + return answer + + +def make_character(word, frames): + masks = target_masks(word, frames) + mandatory = set.intersection(*(set(j for j in range(8) if mask >> j & 1) + for mask in masks)) + for odd in sorted(mandatory): + for even in sorted(set(range(8)) - mandatory): + values = [int(j == odd) + 2 * int(j == even) for j in range(8)] + functional = solve_rational([frames[i] for i in word], values) + if functional is not None: + return {"frames": list(word), + "functional": [str(x) for x in functional], + "frame_values": values, "target_value": 1} + raise ValueError("no one-call character found for surviving multiset") + + +def check_character(record, frames): + functional = [Fraction(x) for x in record["functional"]] + require(len(functional) == 9, "character covector must have nine entries") + values = [sum(a * b for a, b in zip(functional, frames[i])) + for i in record["frames"]] + require(all(v.denominator == 1 for v in values), "character is not integral on every frame") + require(values == record["frame_values"], "character frame values changed") + target_value = sum(a * b for a, b in zip(functional, TARGET)) + require(target_value.denominator == 1 and target_value % 2 == 1, + "character target must be an odd integer") + require(target_value == record["target_value"], "character target value changed") + require(sum(int(v) % 2 for v in values) == 1, "character does not leave exactly one call") + + +def multiply_binary(a, b, roles): + result = 0 + row_mask = (1 << roles) - 1 + for i in range(roles): + row = 0 + for k in range(roles): + if a >> (i * roles + k) & 1: + row ^= (b >> (k * roles)) & row_mask + result |= row << (i * roles) + return result + + +def formal_word(word, frames, roles): + identity = sum(1 << (i * roles + i) for i in range(roles)) + result = {ZERO: identity} + for call in word: + role = call["role"] + require(0 <= role < roles, "witness projector outside register range") + frame_id = call["frame_id"] + require(0 <= frame_id < len(frames), "witness frame outside alphabet") + projector = 1 << (role * roles + role) + constant = identity ^ projector + next_result = defaultdict(int) + for exponent, coefficient in result.items(): + next_result[exponent] ^= multiply_binary(coefficient, constant, roles) + next_result[add(exponent, frames[frame_id])] ^= multiply_binary(coefficient, projector, roles) + result = {exponent: coefficient for exponent, coefficient in next_result.items() if coefficient} + return result + + +def check_witness(word, frames): + require(len(word) == 9, "attaining witness must have nine calls") + # Formal matrix coefficients cover arbitrary data and dirty inputs. Extra + # coordinates are identity blocks; three sizes also exercise this handling. + for roles in (3, 4, 6): + active = sum(1 << (i * roles + i) for i in range(3)) + dirty = sum(1 << (i * roles + i) for i in range(3, roles)) + expected = {TARGET: active} + if dirty: + expected[ZERO] = dirty + require(formal_word(word, frames, roles) == expected, + "nine-call formal identity or dirty restoration failed") + + +def json_value(value): + return json.loads(json.dumps(value)) + + +def make_certificate(data): + frames = data["alphabet"] + triple = data["decompositions_three"][0] + certificate = {"schema_version": 1, "scope": SCOPE, + "frame_denominator": 2, "target_scaled": list(TARGET), **json_value(data)} + certificate["character_obstructions"] = [make_character(word, frames) + for word in data["rank_survivors_eight"]] + certificate["nine_call_witness"] = [{"frame_id": i, "role": role} + for role in range(3) for i in triple] + return certificate + + +def check_certificate(certificate, data): + require(certificate.get("schema_version") == 1, "wrong certificate schema") + require(certificate.get("scope") == SCOPE, "wrong scope") + require(certificate.get("frame_denominator") == 2, "wrong frame denominator") + require(certificate.get("target_scaled") == list(TARGET), "wrong scaled target") + for key, value in data.items(): + require(certificate.get(key) == json_value(value), "census mismatch: " + key) + frames = data["alphabet"] + records = certificate["character_obstructions"] + require([r["frames"] for r in records] == json_value(data["rank_survivors_eight"]), + "missing, extra or reordered character obstruction") + for record in records: + check_character(record, frames) + check_witness(certificate["nine_call_witness"], frames) + + +def controls(certificate, data): + mutations = [] + changed = deepcopy(certificate) + changed["character_obstructions"][0]["functional"] = [ + str(2 * Fraction(x)) for x in changed["character_obstructions"][0]["functional"]] + changed["character_obstructions"][0]["frame_values"] = [ + 2 * x for x in changed["character_obstructions"][0]["frame_values"]] + changed["character_obstructions"][0]["target_value"] *= 2 + mutations.append(("changed character", changed)) + changed = deepcopy(certificate) + changed["character_obstructions"][0]["functional"] = [ + str(Fraction(x) / 2) for x in changed["character_obstructions"][0]["functional"]] + mutations.append(("nonintegral character", changed)) + changed = deepcopy(certificate) + changed["candidates_eight"].pop() + mutations.append(("deleted candidate", changed)) + changed = deepcopy(certificate) + changed["alphabet"].append(changed["alphabet"][-1]) + mutations.append(("duplicate alphabet frame", changed)) + changed = deepcopy(certificate) + changed["target_scaled"][8] = 0 + mutations.append(("changed target", changed)) + changed = deepcopy(certificate) + changed["frame_denominator"] = 1 + mutations.append(("wrong denominator", changed)) + changed = deepcopy(certificate) + changed["nine_call_witness"].pop() + mutations.append(("omitted witness call", changed)) + changed = deepcopy(certificate) + changed["nine_call_witness"][0]["role"] = 1 + mutations.append(("wrong witness projector", changed)) + for name, changed in mutations: + try: + check_certificate(changed, data) + except ValueError: + continue + raise ValueError("negative control accepted: " + name) + return len(mutations) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write", action="store_true", help="explicitly regenerate CERTIFICATE.json") + args = parser.parse_args() + data = census() + path = HERE / "CERTIFICATE.json" + if args.write: + certificate = make_certificate(data) + else: + certificate = json.loads(path.read_text(encoding="utf-8")) + check_certificate(certificate, data) + require(certificate == make_certificate(data), "certificate is not the canonical complete replay") + control_count = controls(certificate, data) + if args.write: + path.write_text(json.dumps(certificate, indent=2) + "\n", encoding="utf-8", newline="\n") + print("PASS_DYADIC_TERNARY_CATALYST" + f" alphabet={len(data['alphabet'])} candidates7={len(data['candidates_seven'])}" + f" candidates8={len(data['candidates_eight'])}" + f" rank_survivors8={len(data['rank_survivors_eight'])}" + f" character_obstructions={len(certificate['character_obstructions'])}" + f" minimum_calls=9 arbitrary_dirty_registers=yes controls={control_count}") + + +if __name__ == "__main__": + main()