schemagen: cache non-object $defs entries to avoid duplicate types

Extend the existing per-definition cache (`self._building`) to enum,
array, and scalar $defs, not just object definitions. This ensures
that multiple $refs to the same non-object definition reuse the same
C++ type instead of generating Role, Role2, Role3, etc.

- Cache the built (type, nullable) tuple under defname for enum,
  scalar, and array definitions.
- Pre-register array definitions before recursing into items so $ref
  cycles resolve to the same TArr instance.
- Store object definitions as (TObj, nullable) tuples so nullable object
  $defs also preserve their nullability when referenced.

Add a regression test for issue #17 covering reused enum and array-of-enum
$defs.

.gitignore

@@ -1,2 +1,6 @@
 build
 .cache
+contrib/schemagen/gen.h
+contrib/schemagen/big.h
+contrib/schemagen/test_gen
+contrib/schemagen/test_big

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.10)
 project(
   weaseljson
   VERSION 0.0.1
@@ -119,7 +119,10 @@ add_custom_command(
   OUTPUT ${CMAKE_BINARY_DIR}/${PROJECT_NAME}.o
   COMMAND ${LD_EXE} -r $<TARGET_OBJECTS:${PROJECT_NAME}-object> -o
           ${CMAKE_BINARY_DIR}/${PROJECT_NAME}.o
-  DEPENDS ${PROJECT_NAME}-object
+  # Depend on the target (for ordering / the Make generator) and on the object
+  # files themselves, so the bundle is rebuilt when the objects' contents change
+  # (a bare target dependency is only order-only under Ninja).
+  DEPENDS ${PROJECT_NAME}-object $<TARGET_OBJECTS:${PROJECT_NAME}-object>
   COMMAND_EXPAND_LISTS)
 
 add_library(${PROJECT_NAME} SHARED ${CMAKE_BINARY_DIR}/${PROJECT_NAME}.o)
@@ -160,6 +163,15 @@ target_link_libraries(mytest PRIVATE ${PROJECT_NAME} doctest nanobench simdjson)
 target_compile_options(mytest PRIVATE ${TEST_FLAGS})
 doctest_discover_tests(mytest WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
 
+find_package(Python3 COMPONENTS Interpreter)
+if(Python3_Interpreter_FOUND)
+  add_test(NAME python_bindings
+           COMMAND ${Python3_EXECUTABLE}
+                   ${CMAKE_CURRENT_SOURCE_DIR}/test_python_bindings.py)
+endif()
+
+add_subdirectory(contrib/schemagen)
+
 include(CMakePushCheckState)
 include(CheckCXXCompilerFlag)
 cmake_push_check_state()
@@ -173,6 +185,17 @@ if(HAS_LIB_FUZZER)
   target_link_libraries(fuzz PRIVATE simdjson)
   target_compile_options(fuzz PRIVATE -fsanitize=fuzzer ${TEST_FLAGS})
   target_link_options(fuzz PRIVATE -fsanitize=fuzzer)
+else()
+  add_executable(fuzz src/fuzz.cpp src/lib.cpp src/fuzz_driver.cpp)
+  target_include_directories(fuzz PRIVATE include)
+  target_link_libraries(fuzz PRIVATE simdjson)
+  target_compile_options(fuzz PRIVATE ${TEST_FLAGS})
+endif()
+
+# Replay the checked-in corpus through the fuzz target as a regression test.
+file(GLOB corpus_files ${CMAKE_CURRENT_SOURCE_DIR}/corpus/*)
+if(corpus_files)
+  add_test(NAME fuzz_corpus COMMAND fuzz ${corpus_files})
 endif()
 
 add_executable(validate src/validate.cpp)

contrib/schemagen/CMakeLists.txt

@@ -0,0 +1,105 @@
+# Tests for contrib/schemagen
+
+if(NOT Python3_Interpreter_FOUND)
+  return()
+endif()
+
+add_test(
+  NAME schemagen_python_tests
+  COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test_schemagen.py
+  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
+
+set(SCHEMAGEN_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/weaseljson_schemagen.py)
+set(EXAMPLE_SCHEMA ${CMAKE_CURRENT_SOURCE_DIR}/example.schema.json)
+set(GEN_H ${CMAKE_CURRENT_BINARY_DIR}/gen.h)
+set(BIG_SCHEMA ${CMAKE_CURRENT_SOURCE_DIR}/big.schema.json)
+set(BIG_H ${CMAKE_CURRENT_BINARY_DIR}/big.h)
+
+add_custom_command(
+  OUTPUT ${GEN_H}
+  COMMAND ${Python3_EXECUTABLE} ${SCHEMAGEN_SCRIPT} ${EXAMPLE_SCHEMA} -o
+          ${GEN_H} --namespace weasel_schema
+  DEPENDS ${SCHEMAGEN_SCRIPT} ${EXAMPLE_SCHEMA}
+  COMMENT "Generating gen.h from example.schema.json")
+
+add_custom_command(
+  OUTPUT ${BIG_H}
+  COMMAND ${Python3_EXECUTABLE} ${SCHEMAGEN_SCRIPT} ${BIG_SCHEMA} -o ${BIG_H}
+          --namespace big_schema
+  DEPENDS ${SCHEMAGEN_SCRIPT} ${BIG_SCHEMA}
+  COMMENT "Generating big.h from big.schema.json")
+
+add_custom_target(schemagen_gen_h DEPENDS ${GEN_H})
+add_custom_target(schemagen_big_h DEPENDS ${BIG_H})
+
+add_executable(schemagen_example ${CMAKE_CURRENT_SOURCE_DIR}/test_gen.cpp)
+target_include_directories(schemagen_example
+                           PRIVATE include ${CMAKE_CURRENT_BINARY_DIR})
+target_link_libraries(schemagen_example PRIVATE ${PROJECT_NAME})
+target_compile_options(schemagen_example PRIVATE -Wno-switch-enum)
+add_dependencies(schemagen_example schemagen_gen_h)
+
+add_executable(schemagen_big ${CMAKE_CURRENT_SOURCE_DIR}/test_big.cpp)
+target_include_directories(schemagen_big PRIVATE include
+                                                 ${CMAKE_CURRENT_BINARY_DIR})
+target_link_libraries(schemagen_big PRIVATE ${PROJECT_NAME})
+target_compile_options(schemagen_big PRIVATE -Wno-switch-enum)
+add_dependencies(schemagen_big schemagen_big_h)
+
+set(NULLABLE_OBJECT_SCHEMA
+    ${CMAKE_CURRENT_SOURCE_DIR}/nullable_object.schema.json)
+set(NULLABLE_STRING_SCHEMA
+    ${CMAKE_CURRENT_SOURCE_DIR}/nullable_string.schema.json)
+set(NULLABLE_ARRAY_SCHEMA
+    ${CMAKE_CURRENT_SOURCE_DIR}/nullable_array.schema.json)
+set(NULLABLE_OBJECT_H ${CMAKE_CURRENT_BINARY_DIR}/nullable_object.h)
+set(NULLABLE_STRING_H ${CMAKE_CURRENT_BINARY_DIR}/nullable_string.h)
+set(NULLABLE_ARRAY_H ${CMAKE_CURRENT_BINARY_DIR}/nullable_array.h)
+
+add_custom_command(
+  OUTPUT ${NULLABLE_OBJECT_H}
+  COMMAND ${Python3_EXECUTABLE} ${SCHEMAGEN_SCRIPT} ${NULLABLE_OBJECT_SCHEMA} -o
+          ${NULLABLE_OBJECT_H} --namespace nullable_object
+  DEPENDS ${SCHEMAGEN_SCRIPT} ${NULLABLE_OBJECT_SCHEMA}
+  COMMENT "Generating nullable_object.h")
+
+add_custom_command(
+  OUTPUT ${NULLABLE_STRING_H}
+  COMMAND ${Python3_EXECUTABLE} ${SCHEMAGEN_SCRIPT} ${NULLABLE_STRING_SCHEMA} -o
+          ${NULLABLE_STRING_H} --namespace nullable_string
+  DEPENDS ${SCHEMAGEN_SCRIPT} ${NULLABLE_STRING_SCHEMA}
+  COMMENT "Generating nullable_string.h")
+
+add_custom_command(
+  OUTPUT ${NULLABLE_ARRAY_H}
+  COMMAND ${Python3_EXECUTABLE} ${SCHEMAGEN_SCRIPT} ${NULLABLE_ARRAY_SCHEMA} -o
+          ${NULLABLE_ARRAY_H} --namespace nullable_array
+  DEPENDS ${SCHEMAGEN_SCRIPT} ${NULLABLE_ARRAY_SCHEMA}
+  COMMENT "Generating nullable_array.h")
+
+add_custom_target(
+  schemagen_nullable_h DEPENDS ${NULLABLE_OBJECT_H} ${NULLABLE_STRING_H}
+                               ${NULLABLE_ARRAY_H})
+
+add_executable(schemagen_nullable_root
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_nullable_root.cpp)
+target_include_directories(schemagen_nullable_root
+                           PRIVATE include ${CMAKE_CURRENT_BINARY_DIR})
+target_link_libraries(schemagen_nullable_root PRIVATE ${PROJECT_NAME})
+target_compile_options(schemagen_nullable_root PRIVATE -Wno-switch-enum)
+add_dependencies(schemagen_nullable_root schemagen_nullable_h)
+
+add_test(
+  NAME schemagen_example
+  COMMAND schemagen_example
+  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+add_test(
+  NAME schemagen_big
+  COMMAND schemagen_big
+  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+add_test(
+  NAME schemagen_nullable_root
+  COMMAND schemagen_nullable_root
+  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})

contrib/schemagen/README.md

@@ -0,0 +1,100 @@
+# weaseljson schemagen
+
+Generates a C++ type and a streaming **builder** parser from a JSON Schema,
+on top of weaseljson.
+
+The builder copies incoming bytes straight into their final destinations in the
+result struct as they arrive (no intermediate DOM). When parsing completes you
+`take()` ownership of the result.
+
+```sh
+python3 weaseljson_schemagen.py schema.json -o parsed.h --namespace myschema
+```
+
+## Usage
+
+```cpp
+#include "parsed.h"
+using namespace myschema;
+
+RootBuilder b;
+WeaselJsonStatus s = b.feed(buf, len);   // call repeatedly with chunks; buf may
+                                         // be modified in place (unescaping)
+if (s == WeaselJson_AGAIN) s = b.finish();
+if (s == WeaselJson_OK) {
+  Root value = b.take();                 // ownership of the parsed result
+}
+```
+
+`feed`/`finish` return the usual `WeaselJsonStatus`; `WeaselJson_OK` means the
+document is both valid JSON and schema-valid, and `WeaselJson_REJECT` covers
+both malformed JSON and schema violations. The builder holds interior pointers
+into the result, so it is non-movable.
+
+## Schema -> C++ mapping
+
+| JSON Schema                                   | C++                                    |
+|-----------------------------------------------|----------------------------------------|
+| `object` with `properties`                    | `struct`                               |
+| required property                             | value member                           |
+| non-required property                         | `std::optional<T>`                     |
+| `["T", "null"]` (nullable)                    | `std::optional<T>` (accepts `null`)    |
+| `string` / `integer` / `number` / `boolean`   | `std::string` / `int64_t` / `double` / `bool` |
+| `enum` of strings                             | `enum class : int`                     |
+| `array` with `items`                          | `std::vector<T>`                       |
+| `$ref` to `$defs`/`definitions`               | the referenced named struct            |
+| recursive `$ref`                              | `std::unique_ptr<T>` (cycle broken)    |
+| `additionalProperties: false`                 | unknown keys rejected                  |
+| `additionalProperties` absent / `true`        | not supported (rejected at generation) |
+
+## Schema violations (rejected at parse time)
+
+- missing required property (top-level or nested)
+- wrong JSON type for a property / array element
+- `null` for a non-nullable slot
+- value not in a string `enum`
+- a number not representable in the target type (e.g. `1.5` for an `integer`)
+- duplicate object keys
+- unknown key in any object
+
+## Not supported (rejected at generation time, no fallback)
+
+`oneOf` / `anyOf` / `allOf` / `not` / `if`-`then`-`else`,
+`patternProperties`, `additionalProperties` with a schema (typed map),
+`additionalProperties: true`, `prefixItems` (tuples), `const`,
+`dependentSchemas`/`dependentRequired`, union `type` lists other than
+`["T", "null"]`, non-string enums, and remote (`$ref` to other documents).
+
+## Notes
+
+- Strings (the bulk payload) are appended directly into their destination
+  `std::string`, even when split across `feed` calls. Numbers are accumulated in
+  a small scratch buffer and converted on completion, since an `int64_t`/`double`
+  cannot hold partial digits.
+- `test_gen.cpp` generates from `example.schema.json` and exercises the parser
+  byte-by-byte (covering chunked strings/numbers), plus the rejection cases.
+
+## Testing
+
+The schemagen tests are registered with CTest and run as part of the default
+`ctest` invocation from the build directory:
+
+```sh
+cmake -S . -B build
+make -C build -j "$(nproc)"
+cd build
+ctest --output-on-failure
+```
+
+For local development you can also use the convenience script:
+
+```sh
+cd contrib/schemagen
+./run_tests.sh
+```
+
+Both regenerate the example parser (`gen.h`) and a regression parser with 40
+required properties (`big.h`), compile `test_gen.cpp` and `test_big.cpp`, and run
+them. `test_big.cpp` specifically covers issue #3: it checks that a 40-property
+object accepts all fields, rejects a missing field at index 32, and rejects
+duplicate keys around the 32-bit boundary.

contrib/schemagen/big.schema.json

@@ -0,0 +1,168 @@
+{
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "p0": {
+      "type": "string"
+    },
+    "p1": {
+      "type": "string"
+    },
+    "p2": {
+      "type": "string"
+    },
+    "p3": {
+      "type": "string"
+    },
+    "p4": {
+      "type": "string"
+    },
+    "p5": {
+      "type": "string"
+    },
+    "p6": {
+      "type": "string"
+    },
+    "p7": {
+      "type": "string"
+    },
+    "p8": {
+      "type": "string"
+    },
+    "p9": {
+      "type": "string"
+    },
+    "p10": {
+      "type": "string"
+    },
+    "p11": {
+      "type": "string"
+    },
+    "p12": {
+      "type": "string"
+    },
+    "p13": {
+      "type": "string"
+    },
+    "p14": {
+      "type": "string"
+    },
+    "p15": {
+      "type": "string"
+    },
+    "p16": {
+      "type": "string"
+    },
+    "p17": {
+      "type": "string"
+    },
+    "p18": {
+      "type": "string"
+    },
+    "p19": {
+      "type": "string"
+    },
+    "p20": {
+      "type": "string"
+    },
+    "p21": {
+      "type": "string"
+    },
+    "p22": {
+      "type": "string"
+    },
+    "p23": {
+      "type": "string"
+    },
+    "p24": {
+      "type": "string"
+    },
+    "p25": {
+      "type": "string"
+    },
+    "p26": {
+      "type": "string"
+    },
+    "p27": {
+      "type": "string"
+    },
+    "p28": {
+      "type": "string"
+    },
+    "p29": {
+      "type": "string"
+    },
+    "p30": {
+      "type": "string"
+    },
+    "p31": {
+      "type": "string"
+    },
+    "p32": {
+      "type": "string"
+    },
+    "p33": {
+      "type": "string"
+    },
+    "p34": {
+      "type": "string"
+    },
+    "p35": {
+      "type": "string"
+    },
+    "p36": {
+      "type": "string"
+    },
+    "p37": {
+      "type": "string"
+    },
+    "p38": {
+      "type": "string"
+    },
+    "p39": {
+      "type": "string"
+    }
+  },
+  "required": [
+    "p0",
+    "p1",
+    "p2",
+    "p3",
+    "p4",
+    "p5",
+    "p6",
+    "p7",
+    "p8",
+    "p9",
+    "p10",
+    "p11",
+    "p12",
+    "p13",
+    "p14",
+    "p15",
+    "p16",
+    "p17",
+    "p18",
+    "p19",
+    "p20",
+    "p21",
+    "p22",
+    "p23",
+    "p24",
+    "p25",
+    "p26",
+    "p27",
+    "p28",
+    "p29",
+    "p30",
+    "p31",
+    "p32",
+    "p33",
+    "p34",
+    "p35",
+    "p36",
+    "p37",
+    "p38",
+    "p39"
+  ]
+}

contrib/schemagen/example.schema.json

@@ -0,0 +1,117 @@
+{
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "name",
+    "age"
+  ],
+  "properties": {
+    "name": {
+      "type": "string"
+    },
+    "age": {
+      "type": "integer"
+    },
+    "height": {
+      "type": "number"
+    },
+    "active": {
+      "type": "boolean"
+    },
+    "nickname": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "role": {
+      "enum": [
+        "admin",
+        "user",
+        "guest"
+      ]
+    },
+    "hobbies": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "address": {
+      "type": "object",
+      "required": [
+        "city"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "city": {
+          "type": "string"
+        },
+        "zip": {
+          "type": "integer"
+        }
+      }
+    },
+    "friends": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": [
+          "name"
+        ],
+        "properties": {
+          "name": {
+            "type": "string"
+          },
+          "age": {
+            "type": "integer"
+          }
+        }
+      }
+    },
+    "tree": {
+      "$ref": "#/$defs/Node"
+    },
+    "nullable_hobbies": {
+      "type": "array",
+      "items": {
+        "type": [
+          "string",
+          "null"
+        ]
+      }
+    },
+    "nullable_scores": {
+      "type": "array",
+      "items": {
+        "type": [
+          "integer",
+          "null"
+        ]
+      }
+    }
+  },
+  "$defs": {
+    "Node": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "value"
+      ],
+      "properties": {
+        "value": {
+          "type": "integer"
+        },
+        "next": {
+          "$ref": "#/$defs/Node"
+        },
+        "children": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/Node"
+          }
+        }
+      }
+    }
+  }
+}

contrib/schemagen/nullable_array.schema.json

@@ -0,0 +1,9 @@
+{
+  "type": [
+    "array",
+    "null"
+  ],
+  "items": {
+    "type": "integer"
+  }
+}

contrib/schemagen/nullable_object.schema.json

@@ -0,0 +1,15 @@
+{
+  "type": [
+    "object",
+    "null"
+  ],
+  "additionalProperties": false,
+  "required": [
+    "x"
+  ],
+  "properties": {
+    "x": {
+      "type": "string"
+    }
+  }
+}

contrib/schemagen/nullable_string.schema.json

@@ -0,0 +1,6 @@
+{
+  "type": [
+    "string",
+    "null"
+  ]
+}

contrib/schemagen/run_tests.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+# Build and run the schemagen regression tests.
+# Expects weaseljson to be built at ../../build (the default CMake build dir).
+set -euo pipefail
+
+cd "$(dirname "$0")"
+
+python3 weaseljson_schemagen.py example.schema.json -o gen.h --namespace weasel_schema
+python3 weaseljson_schemagen.py big.schema.json -o big.h --namespace big_schema
+
+g++ -std=c++20 -I../../include -I. test_gen.cpp \
+    -L../../build -lweaseljson \
+    -Wl,-rpath,'$ORIGIN'/../../build \
+    -o test_gen
+
+g++ -std=c++20 -I../../include -I. test_big.cpp \
+    -L../../build -lweaseljson \
+    -Wl,-rpath,'$ORIGIN'/../../build \
+    -o test_big
+
+./test_gen
+./test_big

contrib/schemagen/test_big.cpp

@@ -0,0 +1,140 @@
+// Regression test for issue #3: objects with more than 32 properties.
+#include <cassert>
+#include <cstdio>
+#include <string>
+
+#include "big.h"
+
+using namespace big_schema;
+
+static WeaselJsonStatus parseStrided(RootBuilder &b, std::string in) {
+  for (size_t i = 0; i < in.size(); ++i) {
+    char c = in[i];
+    WeaselJsonStatus s = b.feed(&c, 1);
+    if (s != WeaselJson_AGAIN)
+      return s;
+  }
+  return b.finish();
+}
+
+static int failures = 0;
+#define CHECK(cond)                                                            \
+  do {                                                                         \
+    if (!(cond)) {                                                             \
+      printf("FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond);                   \
+      ++failures;                                                              \
+    }                                                                          \
+  } while (0)
+
+static void expectReject(const std::string &json, const char *what) {
+  RootBuilder b;
+  WeaselJsonStatus s = parseStrided(b, json);
+  if (s == WeaselJson_REJECT) {
+    printf("ok   reject: %s\n", what);
+  } else {
+    printf("FAIL expected reject (%s) got status %d for: %s\n", what, s,
+           json.c_str());
+    ++failures;
+  }
+}
+
+static std::string all40() {
+  std::string json = "{";
+  for (int i = 0; i < 40; ++i) {
+    if (i)
+      json += ",";
+    json += "\"p" + std::to_string(i) + "\":\"v" + std::to_string(i) + "\"";
+  }
+  json += "}";
+  return json;
+}
+
+int main() {
+  // All 40 required fields present -> accepted, values land in right slots.
+  {
+    RootBuilder b;
+    std::string json = all40();
+    WeaselJsonStatus s = parseStrided(b, json);
+    CHECK(s == WeaselJson_OK);
+    if (s == WeaselJson_OK) {
+      Root r = b.take();
+      CHECK(r.p0 == "v0");
+      CHECK(r.p31 == "v31");
+      CHECK(r.p32 == "v32");
+      CHECK(r.p39 == "v39");
+      printf("ok   all 40 required fields accepted\n");
+    }
+  }
+
+  // Missing field p32 (index 32) must be detected, not aliased to bit 0.
+  {
+    std::string json = all40();
+    // Remove the p32 entry: find its substring and erase it.
+    std::string entry = "\"p32\":\"v32\"";
+    size_t pos = json.find(entry);
+    assert(pos != std::string::npos);
+    // Remove the trailing comma before it if present, or the leading comma
+    // after it.
+    if (pos > 0 && json[pos - 1] == ',') {
+      json.erase(pos - 1, entry.size() + 1);
+    } else if (pos + entry.size() < json.size() &&
+               json[pos + entry.size()] == ',') {
+      json.erase(pos, entry.size() + 1);
+    } else {
+      json.erase(pos, entry.size());
+    }
+    expectReject(json, "missing required field p32 (index 32)");
+  }
+
+  // Missing p0 still rejected.
+  {
+    std::string json = all40();
+    std::string entry = "\"p0\":\"v0\"";
+    size_t pos = json.find(entry);
+    assert(pos != std::string::npos);
+    if (json[pos + entry.size()] == ',') {
+      json.erase(pos, entry.size() + 1);
+    } else {
+      json.erase(pos, entry.size());
+    }
+    expectReject(json, "missing required field p0");
+  }
+
+  // Duplicate keys p0 and p32 must both be detected.
+  {
+    std::string json = all40();
+    // Insert p32 again right after the existing p32 entry.
+    std::string entry = "\"p32\":\"v32\"";
+    size_t pos = json.find(entry);
+    assert(pos != std::string::npos);
+    json.insert(pos + entry.size(), ",\"p32\":\"dup\"");
+    expectReject(json, "duplicate key p32 (index 32)");
+  }
+
+  // Duplicate keys p0 and p31 cover boundary bits.
+  {
+    std::string json = all40();
+    std::string entry = "\"p0\":\"v0\"";
+    size_t pos = json.find(entry);
+    assert(pos != std::string::npos);
+    json.insert(pos + entry.size(), ",\"p0\":\"dup\"");
+    expectReject(json, "duplicate key p0");
+  }
+
+  // Duplicate p31/p32 around the 32-bit boundary.
+  {
+    std::string json = all40();
+    std::string entry = "\"p31\":\"v31\"";
+    size_t pos = json.find(entry);
+    assert(pos != std::string::npos);
+    json.insert(pos + entry.size(), ",\"p31\":\"dup\"");
+    expectReject(json, "duplicate key p31");
+  }
+
+  if (failures == 0) {
+    printf("\nALL TESTS PASSED\n");
+    return 0;
+  }
+  printf("\n%d FAILURE(S)\n", failures);
+  return 1;
+}

contrib/schemagen/test_gen.cpp

@@ -0,0 +1,195 @@
+// Test harness for the generated example.schema.json parser.
+// Feeds input one byte at a time to exercise chunked string/number paths.
+#include <cassert>
+#include <cstdio>
+#include <string>
+
+#include "gen.h"
+
+using namespace weasel_schema;
+
+// Feed `in` one byte at a time. Returns final status.
+static WeaselJsonStatus parseStrided(RootBuilder &b, std::string in) {
+  for (size_t i = 0; i < in.size(); ++i) {
+    char c = in[i];
+    WeaselJsonStatus s = b.feed(&c, 1);
+    if (s != WeaselJson_AGAIN)
+      return s;
+  }
+  return b.finish();
+}
+
+static int failures = 0;
+#define CHECK(cond)                                                            \
+  do {                                                                         \
+    if (!(cond)) {                                                             \
+      printf("FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond);                   \
+      ++failures;                                                              \
+    }                                                                          \
+  } while (0)
+
+static void expectReject(const std::string &json, const char *what) {
+  RootBuilder b;
+  WeaselJsonStatus s = parseStrided(b, json);
+  if (s == WeaselJson_REJECT) {
+    printf("ok   reject: %s\n", what);
+  } else {
+    printf("FAIL expected reject (%s) got status %d for: %s\n", what, s,
+           json.c_str());
+    ++failures;
+  }
+}
+
+int main() {
+  // ---- happy path, full feature coverage, byte-strided ----
+  {
+    std::string json = R"({
+      "name": "Ada É",
+      "age": 36,
+      "height": 1.75,
+      "active": true,
+      "nickname": null,
+      "role": "admin",
+      "hobbies": ["math", "lace"],
+      "address": { "city": "London", "zip": 12345 },
+      "friends": [
+        { "name": "Bob" },
+        { "name": "Cay", "age": 40 }
+      ],
+      "tree": {
+        "value": 1,
+        "children": [ { "value": 2 }, { "value": 3 } ],
+        "next": { "value": 99 }
+      },
+      "extra_unknown": { "ignored": [1, 2, {"x": "y"}] }
+    })";
+    // Root is strict (additionalProperties:false), so "extra_unknown" must
+    // make it reject. Verify that, then test a clean version.
+    expectReject(json, "unknown key in strict root");
+  }
+
+  {
+    std::string json = R"({
+      "name": "Ada É",
+      "age": 36,
+      "height": 1.75,
+      "active": true,
+      "nickname": null,
+      "role": "admin",
+      "hobbies": ["math", "lace"],
+      "address": { "city": "London", "zip": 12345 },
+      "friends": [
+        { "name": "Bob" },
+        { "name": "Cay", "age": 40 }
+      ],
+      "tree": {
+        "value": 1,
+        "children": [ { "value": 2 }, { "value": 3 } ],
+        "next": { "value": 99 }
+      },
+      "nullable_hobbies": [null, "math", null, "lace", null],
+      "nullable_scores": [null, 10, null, 20, null]
+    })";
+    RootBuilder b;
+    WeaselJsonStatus s = parseStrided(b, json);
+    CHECK(s == WeaselJson_OK);
+    if (s == WeaselJson_OK) {
+      Root r = b.take();
+      CHECK(r.name == "Ada \xC3\x89"); // É -> UTF-8
+      CHECK(r.age == 36);
+      CHECK(r.height > 1.74 && r.height < 1.76);
+      CHECK(r.active.has_value() && *r.active == true);
+      CHECK(!r.nickname.has_value()); // explicit null
+      CHECK(r.role.has_value() && *r.role == Role::admin);
+      CHECK(r.hobbies.has_value() && r.hobbies->size() == 2);
+      CHECK(r.hobbies && (*r.hobbies)[0] == "math" &&
+            (*r.hobbies)[1] == "lace");
+      CHECK(r.address.has_value() && r.address->city == "London");
+      CHECK(r.address && r.address->zip.has_value() &&
+            *r.address->zip == 12345);
+      CHECK(r.friends.has_value() && r.friends->size() == 2);
+      CHECK(r.friends && (*r.friends)[0].name == "Bob");
+      CHECK(r.friends && !(*r.friends)[0].age.has_value());
+      CHECK(r.friends && (*r.friends)[1].age.has_value() &&
+            *(*r.friends)[1].age == 40);
+      CHECK(r.tree.has_value() && r.tree->value == 1);
+      CHECK(r.tree && r.tree->children.has_value() &&
+            r.tree->children->size() == 2);
+      CHECK(r.tree && r.tree->children && (*r.tree->children)[0].value == 2);
+      CHECK(r.tree && r.tree->children && (*r.tree->children)[1].value == 3);
+      CHECK(r.tree && r.tree->next && r.tree->next->value == 99);
+      CHECK(r.nullable_hobbies.has_value() && r.nullable_hobbies->size() == 5);
+      CHECK(r.nullable_hobbies && !(*r.nullable_hobbies)[0] &&
+            (*r.nullable_hobbies)[1] && *(*r.nullable_hobbies)[1] == "math" &&
+            !(*r.nullable_hobbies)[2] && (*r.nullable_hobbies)[3] &&
+            *(*r.nullable_hobbies)[3] == "lace" && !(*r.nullable_hobbies)[4]);
+      CHECK(r.nullable_scores.has_value() && r.nullable_scores->size() == 5);
+      CHECK(r.nullable_scores && !(*r.nullable_scores)[0] &&
+            (*r.nullable_scores)[1] && *(*r.nullable_scores)[1] == 10 &&
+            !(*r.nullable_scores)[2] && (*r.nullable_scores)[3] &&
+            *(*r.nullable_scores)[3] == 20 && !(*r.nullable_scores)[4]);
+      printf("ok   happy path (byte-strided)\n");
+    }
+  }
+
+  // ---- whole-buffer feed (not strided) ----
+  {
+    std::string json = R"({"name":"x","age":7})";
+    RootBuilder b;
+    WeaselJsonStatus s = b.feed(json.data(), (int)json.size());
+    if (s == WeaselJson_AGAIN)
+      s = b.finish();
+    CHECK(s == WeaselJson_OK);
+    Root r = b.take();
+    CHECK(r.name == "x" && r.age == 7);
+    CHECK(!r.role.has_value() && !r.hobbies.has_value());
+    printf("ok   minimal object\n");
+  }
+
+  // ---- integer accepts any number with no fractional part (JSON Schema) ----
+  {
+    struct {
+      const char *json;
+      int64_t age;
+    } cases[] = {
+        {R"({"name":"x","age":4e1})", 40},
+        {R"({"name":"x","age":2.0})", 2},
+        {R"({"name":"x","age":-1.5e1})", -15},
+        {R"({"name":"x","age":0e0})", 0},
+    };
+    for (auto &c : cases) {
+      RootBuilder b;
+      WeaselJsonStatus s = parseStrided(b, c.json);
+      CHECK(s == WeaselJson_OK);
+      if (s == WeaselJson_OK) {
+        Root r = b.take();
+        CHECK(r.age == c.age);
+      }
+    }
+    printf("ok   integer in exponent/decimal form\n");
+  }
+  // a fractional or out-of-range value is still rejected for an integer slot
+  expectReject(R"({"name":"x","age":2.5e0})", "non-integral exponent form");
+  expectReject(R"({"name":"x","age":1e30})", "integer out of int64 range");
+
+  // ---- schema-violation rejections ----
+  expectReject(R"({"name":"x"})", "missing required field 'age'");
+  expectReject(R"({"name":"x","age":"notnum"})", "wrong type (string for int)");
+  expectReject(R"({"name":"x","age":1,"role":"boss"})", "bad enum value");
+  expectReject(R"({"name":"x","age":1,"name":"y"})", "duplicate key");
+  expectReject(R"({"name":"x","age":1,"active":null})",
+               "null for non-nullable");
+  expectReject(R"({"name":"x","age":1,"age":2})", "duplicate required key");
+  expectReject(R"({"name":"x","age":1.5})", "fractional for integer");
+  expectReject(R"({"name":"x","age":1,"address":{"zip":5}})",
+               "missing required nested 'city'");
+  expectReject(R"([1,2,3])", "array where object expected (root)");
+  expectReject(R"({"name":"x","age":1,)", "truncated / invalid json");
+
+  if (failures == 0) {
+    printf("\nALL TESTS PASSED\n");
+    return 0;
+  }
+  printf("\n%d FAILURE(S)\n", failures);
+  return 1;
+}

contrib/schemagen/test_nullable_root.cpp

@@ -0,0 +1,158 @@
+// Regression test for issue #13: nullable root types.
+#include <cassert>
+#include <cstdio>
+#include <string>
+
+#include "nullable_array.h"
+#include "nullable_object.h"
+#include "nullable_string.h"
+
+static int failures = 0;
+#define CHECK(cond)                                                            \
+  do {                                                                         \
+    if (!(cond)) {                                                             \
+      printf("FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond);                   \
+      ++failures;                                                              \
+    }                                                                          \
+  } while (0)
+
+static WeaselJsonStatus parseStrided(nullable_object::RootBuilder &b,
+                                     std::string in) {
+  for (size_t i = 0; i < in.size(); ++i) {
+    char c = in[i];
+    WeaselJsonStatus s = b.feed(&c, 1);
+    if (s != WeaselJson_AGAIN)
+      return s;
+  }
+  return b.finish();
+}
+
+static WeaselJsonStatus parseStrided(nullable_string::RootBuilder &b,
+                                     std::string in) {
+  for (size_t i = 0; i < in.size(); ++i) {
+    char c = in[i];
+    WeaselJsonStatus s = b.feed(&c, 1);
+    if (s != WeaselJson_AGAIN)
+      return s;
+  }
+  return b.finish();
+}
+
+static WeaselJsonStatus parseStrided(nullable_array::RootBuilder &b,
+                                     std::string in) {
+  for (size_t i = 0; i < in.size(); ++i) {
+    char c = in[i];
+    WeaselJsonStatus s = b.feed(&c, 1);
+    if (s != WeaselJson_AGAIN)
+      return s;
+  }
+  return b.finish();
+}
+
+static void expectReject(nullable_object::RootBuilder &b, std::string in,
+                         const char *what) {
+  WeaselJsonStatus s = parseStrided(b, in);
+  if (s == WeaselJson_REJECT) {
+    printf("ok   reject: %s\n", what);
+  } else {
+    printf("FAIL expected reject (%s) got status %d for: %s\n", what, s,
+           in.c_str());
+    ++failures;
+  }
+}
+
+int main() {
+  // ---- nullable root object: valid document ----
+  {
+    nullable_object::RootBuilder b;
+    WeaselJsonStatus s = parseStrided(b, R"({"x":"hello"})");
+    CHECK(s == WeaselJson_OK);
+    if (s == WeaselJson_OK) {
+      nullable_object::Root r = b.take();
+      CHECK(r.has_value());
+      CHECK(r->x == "hello");
+      printf("ok   nullable root object accepts object\n");
+    }
+  }
+
+  // ---- nullable root object: null document ----
+  {
+    nullable_object::RootBuilder b;
+    WeaselJsonStatus s = parseStrided(b, "null");
+    CHECK(s == WeaselJson_OK);
+    if (s == WeaselJson_OK) {
+      nullable_object::Root r = b.take();
+      CHECK(!r.has_value());
+      printf("ok   nullable root object accepts null\n");
+    }
+  }
+
+  // ---- nullable root object: schema checks still run ----
+  {
+    nullable_object::RootBuilder b;
+    expectReject(b, R"({"x":"hello","extra":1})",
+                 "unknown key in strict nullable root object");
+  }
+  {
+    nullable_object::RootBuilder b;
+    expectReject(b, R"({})", "missing required field in nullable root object");
+  }
+
+  // ---- nullable root string: valid value ----
+  {
+    nullable_string::RootBuilder b;
+    WeaselJsonStatus s = parseStrided(b, R"("hello")");
+    CHECK(s == WeaselJson_OK);
+    if (s == WeaselJson_OK) {
+      nullable_string::Root r = b.take();
+      CHECK(r.has_value());
+      CHECK(*r == "hello");
+      printf("ok   nullable root string accepts string\n");
+    }
+  }
+
+  // ---- nullable root string: null value ----
+  {
+    nullable_string::RootBuilder b;
+    WeaselJsonStatus s = parseStrided(b, "null");
+    CHECK(s == WeaselJson_OK);
+    if (s == WeaselJson_OK) {
+      nullable_string::Root r = b.take();
+      CHECK(!r.has_value());
+      printf("ok   nullable root string accepts null\n");
+    }
+  }
+
+  // ---- nullable root array: valid value ----
+  {
+    nullable_array::RootBuilder b;
+    WeaselJsonStatus s = parseStrided(b, "[1,2,3]");
+    CHECK(s == WeaselJson_OK);
+    if (s == WeaselJson_OK) {
+      nullable_array::Root r = b.take();
+      CHECK(r.has_value());
+      CHECK(r->size() == 3);
+      CHECK((*r)[0] == 1 && (*r)[1] == 2 && (*r)[2] == 3);
+      printf("ok   nullable root array accepts array\n");
+    }
+  }
+
+  // ---- nullable root array: null value ----
+  {
+    nullable_array::RootBuilder b;
+    WeaselJsonStatus s = parseStrided(b, "null");
+    CHECK(s == WeaselJson_OK);
+    if (s == WeaselJson_OK) {
+      nullable_array::Root r = b.take();
+      CHECK(!r.has_value());
+      printf("ok   nullable root array accepts null\n");
+    }
+  }
+
+  if (failures == 0) {
+    printf("\nALL TESTS PASSED\n");
+    return 0;
+  }
+  printf("\n%d FAILURE(S)\n", failures);
+  return 1;
+}

contrib/schemagen/test_schemagen.py

@@ -0,0 +1,473 @@
+#!/usr/bin/env python3
+"""Tests for weaseljson_schemagen.py."""
+
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import textwrap
+import unittest
+
+SCRIPT = os.path.join(os.path.dirname(__file__), "weaseljson_schemagen.py")
+
+
+class SchemagenEnumTest(unittest.TestCase):
+    def run_schemagen(self, schema, args=None):
+        """Run schemagen on a schema dict. Returns (returncode, stdout, stderr)."""
+        with tempfile.NamedTemporaryFile("w", suffix=".json", delete=False) as fp:
+            json.dump(schema, fp)
+            schema_path = fp.name
+        try:
+            cmd = [sys.executable, SCRIPT, schema_path]
+            if args:
+                cmd.extend(args)
+            result = subprocess.run(cmd, capture_output=True, text=True, check=False)
+            return result.returncode, result.stdout, result.stderr
+        finally:
+            os.unlink(schema_path)
+
+    def test_colliding_enum_values_deduplicate(self):
+        schema = {
+            "type": "object",
+            "properties": {"role": {"enum": ["foo-bar", "foo_bar"]}},
+        }
+        rc, stdout, stderr = self.run_schemagen(schema)
+        self.assertEqual(rc, 0, msg=stderr)
+        self.assertIn("enum class Role : int { foo_bar, foo_bar_1 };", stdout)
+        self.assertIn(
+            'static constexpr const char *Role_names[] = { "foo-bar", "foo_bar" };',
+            stdout,
+        )
+
+    def test_distinct_enum_values_generate(self):
+        schema = {
+            "type": "object",
+            "properties": {"role": {"enum": ["admin", "user", "guest"]}},
+        }
+        rc, stdout, stderr = self.run_schemagen(schema)
+        self.assertEqual(rc, 0, msg=stderr)
+        self.assertIn("enum class Role : int { admin, user, guest };", stdout)
+
+
+class SchemagenKeywordTest(unittest.TestCase):
+    def run_schemagen(self, schema, args=None):
+        """Run schemagen on a schema dict. Returns (returncode, stdout, stderr)."""
+        with tempfile.NamedTemporaryFile("w", suffix=".json", delete=False) as fp:
+            json.dump(schema, fp)
+            schema_path = fp.name
+        try:
+            cmd = [sys.executable, SCRIPT, schema_path]
+            if args:
+                cmd.extend(args)
+            result = subprocess.run(cmd, capture_output=True, text=True, check=False)
+            return result.returncode, result.stdout, result.stderr
+        finally:
+            os.unlink(schema_path)
+
+    def test_cpp20_keywords_are_sanitized(self):
+        """C++20 keywords used as JSON property names must be suffixed."""
+        keywords = [
+            "concept",
+            "consteval",
+            "constinit",
+            "co_await",
+            "co_return",
+            "co_yield",
+            "requires",
+            "module",
+            "import",
+        ]
+        schema = {"type": "object", "properties": {}}
+        for kw in keywords:
+            schema["properties"][kw] = {"type": "string"}
+        rc, stdout, stderr = self.run_schemagen(schema)
+        self.assertEqual(rc, 0, msg=stderr)
+        for kw in keywords:
+            self.assertIn(f"std::optional<std::string> {kw}_;", stdout)
+            self.assertNotIn(f"std::optional<std::string> {kw};", stdout)
+
+
+class SchemagenCollisionTest(unittest.TestCase):
+    """Regression tests for issue #21: generated Root alias / Kind enum collisions."""
+
+    def setUp(self):
+        self.repo_root = os.path.dirname(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        )
+        self.include_dir = os.path.join(self.repo_root, "include")
+        self.compiler = shutil.which("c++")
+
+    def generate_and_compile(self, schema):
+        """Run schemagen on schema and syntax-check the resulting header."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            schema_path = os.path.join(tmpdir, "schema.json")
+            with open(schema_path, "w") as fp:
+                json.dump(schema, fp)
+            header_path = os.path.join(tmpdir, "gen.h")
+            cmd = [
+                sys.executable,
+                SCRIPT,
+                schema_path,
+                "-o",
+                header_path,
+                "--namespace",
+                "test_schema",
+            ]
+            result = subprocess.run(cmd, capture_output=True, text=True, check=False)
+            self.assertEqual(result.returncode, 0, msg=result.stderr)
+
+            if self.compiler:
+                cpp_path = os.path.join(tmpdir, "test.cpp")
+                with open(cpp_path, "w") as fp:
+                    fp.write(
+                        '#include "gen.h"\n'
+                        "int main() {\n"
+                        "  test_schema::RootBuilder b;\n"
+                        "  test_schema::Root r = b.take();\n"
+                        "  (void)r;\n"
+                        "}\n"
+                    )
+                comp = subprocess.run(
+                    [
+                        self.compiler,
+                        "-std=c++20",
+                        "-fsyntax-only",
+                        "-I",
+                        self.include_dir,
+                        "-I",
+                        tmpdir,
+                        cpp_path,
+                    ],
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                )
+                self.assertEqual(comp.returncode, 0, msg=comp.stderr)
+
+            with open(header_path) as fp:
+                return fp.read()
+
+    def test_root_alias_does_not_collide_with_user_type(self):
+        schema = {
+            "type": "array",
+            "items": {"$ref": "#/$defs/Root"},
+            "$defs": {"Root": {"enum": ["a", "b"]}},
+        }
+        out = self.generate_and_compile(schema)
+        self.assertIn("enum class Root1 : int { a, b };", out)
+        self.assertIn("using Root = std::vector<Root1>;", out)
+        self.assertNotIn("using Root = std::vector<Root>;", out)
+
+    def test_kind_enum_does_not_duplicate_arr0(self):
+        schema = {
+            "type": "object",
+            "properties": {
+                "arr": {"type": "array", "items": {"type": "string"}},
+                "obj": {"$ref": "#/$defs/Arr0"},
+            },
+            "$defs": {"Arr0": {"type": "object", "properties": {}}},
+        }
+        out = self.generate_and_compile(schema)
+        self.assertIn("struct Arr0", out)
+        m = re.search(r"enum class Kind : uint8_t \{([^}]+)\}", out)
+        self.assertIsNotNone(m)
+        enumerators = [e.strip() for e in m.group(1).split(",")]
+        self.assertIn("Arr0", enumerators)
+        self.assertIn("Arr1", enumerators)
+        self.assertEqual(len(enumerators), len(set(enumerators)))
+
+    def test_skip_user_type_is_allowed(self):
+        schema = {
+            "type": "array",
+            "items": {"$ref": "#/$defs/Skip"},
+            "$defs": {"Skip": {"type": "object", "properties": {}}},
+        }
+        out = self.generate_and_compile(schema)
+        self.assertIn("struct Skip", out)
+        self.assertNotIn("struct Skip1", out)
+        m = re.search(r"enum class Kind : uint8_t \{([^}]+)\}", out)
+        self.assertIsNotNone(m)
+        enumerators = [e.strip() for e in m.group(1).split(",")]
+        self.assertIn("Skip", enumerators)
+        self.assertIn("Arr0", enumerators)
+        self.assertEqual(len(enumerators), len(set(enumerators)))
+
+    def test_non_object_defs_reused_across_refs(self):
+        """Regression test for issue #17: enum and array $defs must be reused."""
+        schema = {
+            "type": "object",
+            "properties": {
+                "role1": {"$ref": "#/$defs/Role"},
+                "role2": {"$ref": "#/$defs/Role"},
+                "roles1": {"$ref": "#/$defs/Roles"},
+                "roles2": {"$ref": "#/$defs/Roles"},
+            },
+            "$defs": {
+                "Role": {"enum": ["admin", "user"]},
+                "Roles": {"type": "array", "items": {"$ref": "#/$defs/Role"}},
+            },
+        }
+        out = self.generate_and_compile(schema)
+        # Exactly one Role enum is generated.
+        self.assertIn("enum class Role : int { admin, user };", out)
+        self.assertNotIn("enum class Role1 : int", out)
+        self.assertNotIn("enum class Role2 : int", out)
+        # The array of enum is represented by a single kind.
+        m = re.search(r"enum class Kind : uint8_t \{([^}]+)\}", out)
+        self.assertIsNotNone(m)
+        enumerators = [e.strip() for e in m.group(1).split(",")]
+        self.assertEqual(enumerators.count("Arr0"), 1)
+        # All four fields use the same C++ types.
+        self.assertIn("std::optional<Role> role1;", out)
+        self.assertIn("std::optional<Role> role2;", out)
+        self.assertIn("std::optional<std::vector<Role>> roles1;", out)
+        self.assertIn("std::optional<std::vector<Role>> roles2;", out)
+
+
+class SchemagenAdditionalPropertiesTest(unittest.TestCase):
+    def run_schemagen(self, schema, args=None):
+        """Run schemagen on a schema dict. Returns (returncode, stdout, stderr)."""
+        with tempfile.NamedTemporaryFile("w", suffix=".json", delete=False) as fp:
+            json.dump(schema, fp)
+            schema_path = fp.name
+        try:
+            cmd = [sys.executable, SCRIPT, schema_path]
+            if args:
+                cmd.extend(args)
+            result = subprocess.run(cmd, capture_output=True, text=True, check=False)
+            return result.returncode, result.stdout, result.stderr
+        finally:
+            os.unlink(schema_path)
+
+    def test_additional_properties_true_rejected(self):
+        schema = {
+            "type": "object",
+            "additionalProperties": True,
+            "properties": {"name": {"type": "string"}},
+        }
+        rc, stdout, stderr = self.run_schemagen(schema)
+        self.assertNotEqual(rc, 0)
+        self.assertIn("additionalProperties: true is not supported", stderr)
+
+    def test_additional_properties_absent_defaults_to_strict(self):
+        schema = {
+            "type": "object",
+            "properties": {"name": {"type": "string"}},
+        }
+        rc, stdout, stderr = self.run_schemagen(schema)
+        self.assertEqual(rc, 0, msg=stderr)
+        # The generated parser should reject unknown keys. Verify the key-matching
+        # helper returns -1 for an unknown key and cbKeyData rejects it.
+        self.assertIn("int matchKey(Kind k, std::string_view key) const {", stdout)
+        self.assertNotIn("bool isStrict(Kind k) const", stdout)
+
+    def test_additional_properties_false_accepted(self):
+        schema = {
+            "type": "object",
+            "additionalProperties": False,
+            "properties": {"name": {"type": "string"}},
+        }
+        rc, stdout, stderr = self.run_schemagen(schema)
+        self.assertEqual(rc, 0, msg=stderr)
+
+
+class SchemagenIntegerBoundaryTest(unittest.TestCase):
+    """Regression tests for issue #19: integer slot parsing near int64 boundaries."""
+
+    def setUp(self):
+        self.repo_root = os.path.dirname(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        )
+        self.include_dir = os.path.join(self.repo_root, "include")
+        self.lib_src = os.path.join(self.repo_root, "src", "lib.cpp")
+        self.compiler = shutil.which("c++")
+
+    def _compile_harness(self, tmpdir, schema, harness):
+        schema_path = os.path.join(tmpdir, "schema.json")
+        with open(schema_path, "w") as fp:
+            json.dump(schema, fp)
+        header_path = os.path.join(tmpdir, "gen.h")
+        result = subprocess.run(
+            [
+                sys.executable,
+                SCRIPT,
+                schema_path,
+                "-o",
+                header_path,
+                "--namespace",
+                "test_schema",
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        self.assertEqual(result.returncode, 0, msg=result.stderr)
+
+        lib_obj = os.path.join(tmpdir, "lib.o")
+        comp_lib = subprocess.run(
+            [
+                self.compiler,
+                "-std=c++20",
+                "-I",
+                self.include_dir,
+                "-I",
+                os.path.join(self.repo_root, "third_party", "include"),
+                "-I",
+                os.path.join(self.repo_root, "third_party", "valgrind"),
+                "-c",
+                self.lib_src,
+                "-o",
+                lib_obj,
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        self.assertEqual(comp_lib.returncode, 0, msg=comp_lib.stderr)
+
+        cpp_path = os.path.join(tmpdir, "test.cpp")
+        with open(cpp_path, "w") as fp:
+            fp.write(harness)
+
+        exe_path = os.path.join(tmpdir, "test")
+        comp = subprocess.run(
+            [
+                self.compiler,
+                "-std=c++20",
+                "-I",
+                self.include_dir,
+                "-I",
+                tmpdir,
+                lib_obj,
+                cpp_path,
+                "-o",
+                exe_path,
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        self.assertEqual(comp.returncode, 0, msg=comp.stderr)
+        run = subprocess.run([exe_path], capture_output=True, text=True, check=False)
+        self.assertEqual(run.returncode, 0, msg=run.stdout + run.stderr)
+
+    def _build_cases_array(self, name, entries):
+        lines = [
+            f"  struct {name}Case {{ const char *s; WeaselJsonStatus expected; long long v; }};"
+        ]
+        lines.append(f"  {name}Case {name}_cases[] = {{")
+        for s, exp, v in entries:
+            val = f"{v}LL" if isinstance(v, int) else v
+            lines.append(f'    {{ R"({s})", {exp}, {val} }},')
+        lines.append("  };")
+        return "\n".join(lines)
+
+    def test_integer_boundary_root(self):
+        if not self.compiler:
+            self.skipTest("C++ compiler not available")
+        cases = [
+            ("9223372036854775807.0", "WeaselJson_OK", 9223372036854775807),
+            ("9223372036854775807", "WeaselJson_OK", 9223372036854775807),
+            ("9223372036854775806.0", "WeaselJson_OK", 9223372036854775806),
+            ("9223372036854775808", "WeaselJson_REJECT", 0),
+            ("-9223372036854775808", "WeaselJson_OK", "-9223372036854775807LL - 1"),
+            ("-9223372036854775808.0", "WeaselJson_OK", "-9223372036854775807LL - 1"),
+            ("-9223372036854775809", "WeaselJson_REJECT", 0),
+            ("1e3", "WeaselJson_OK", 1000),
+            ("2.0", "WeaselJson_OK", 2),
+            ("0.001", "WeaselJson_REJECT", 0),
+            ("1e-3", "WeaselJson_REJECT", 0),
+            ("1000e-3", "WeaselJson_OK", 1),
+            ("100.0e-2", "WeaselJson_OK", 1),
+            ("123.0", "WeaselJson_OK", 123),
+            ("9e18", "WeaselJson_OK", 9000000000000000000),
+            ("10e18", "WeaselJson_REJECT", 0),
+        ]
+        cases_src = self._build_cases_array("root", cases)
+        harness = textwrap.dedent(
+            f"""
+            #include "gen.h"
+            #include <cstdio>
+            #include <cstring>
+            {cases_src}
+            int main() {{
+              for (const auto \u0026c : root_cases) {{
+                test_schema::RootBuilder b;
+                char buf[512];
+                std::strncpy(buf, c.s, sizeof(buf) - 1);
+                buf[sizeof(buf) - 1] = '\\0';
+                WeaselJsonStatus st = b.feed(buf, std::strlen(buf));
+                st = b.finish();
+                if (st != c.expected) {{
+                  std::printf("root case %s expected %d got %d\\n", c.s, c.expected, st);
+                  return 1;
+                }}
+                if (st == WeaselJson_OK \u0026\u0026 b.take() != c.v) {{
+                  std::printf("root case %s value mismatch\\n", c.s);
+                  return 2;
+                }}
+              }}
+              return 0;
+            }}
+            """
+        )
+        with tempfile.TemporaryDirectory() as tmpdir:
+            self._compile_harness(tmpdir, {"type": "integer"}, harness)
+
+    def test_integer_boundary_object_field(self):
+        if not self.compiler:
+            self.skipTest("C++ compiler not available")
+        cases = [
+            ('{"age":9223372036854775807.0}', "WeaselJson_OK", 9223372036854775807),
+            ('{"age":-9223372036854775809}', "WeaselJson_REJECT", 0),
+            ('{"age":1e3}', "WeaselJson_OK", 1000),
+            ('{"age":2.0}', "WeaselJson_OK", 2),
+            ('{"age":0.001}', "WeaselJson_REJECT", 0),
+            (
+                '{"age":-9223372036854775808.0}',
+                "WeaselJson_OK",
+                "-9223372036854775807LL - 1",
+            ),
+        ]
+        cases_src = self._build_cases_array("object", cases)
+        harness = textwrap.dedent(
+            f"""
+            #include "gen.h"
+            #include <cstdio>
+            #include <cstring>
+            {cases_src}
+            int main() {{
+              for (const auto \u0026c : object_cases) {{
+                test_schema::RootBuilder b;
+                char buf[512];
+                std::strncpy(buf, c.s, sizeof(buf) - 1);
+                buf[sizeof(buf) - 1] = '\\0';
+                WeaselJsonStatus st = b.feed(buf, std::strlen(buf));
+                st = b.finish();
+                if (st != c.expected) {{
+                  std::printf("object case %s expected %d got %d\\n", c.s, c.expected, st);
+                  return 3;
+                }}
+                if (st == WeaselJson_OK \u0026\u0026 b.take().age != c.v) {{
+                  std::printf("object case %s value mismatch\\n", c.s);
+                  return 4;
+                }}
+              }}
+              return 0;
+            }}
+            """
+        )
+        schema = {
+            "type": "object",
+            "properties": {"age": {"type": "integer"}},
+            "required": ["age"],
+        }
+        with tempfile.TemporaryDirectory() as tmpdir:
+            self._compile_harness(tmpdir, schema, harness)
+
+
+if __name__ == "__main__":
+    unittest.main()

corpus/0517a9ccfd4caa0fbb1865dd3d4eb837c2bffca4

@@ -0,0 +1 @@
+-8111111111111.ｻ

corpus/0c47d4a0c89a58a5e45cb9203cd888cb956ff396

@@ -0,0 +1,4 @@
+[4,[5,[5,[4,[6,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,0,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[4,[[5,[5,[415,4,[5,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[0,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,0,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[4,[[5,[5,[415,4,[5,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[0,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5415,4,[5,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[0,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[5,[5,[4,[7,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4444444444444444444444444444444444444444444444444444444444444444444444444444,[5,[5,[5.75,775,[5,7,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,333333333
+,0,333333333
+,0,3333,null,0,null,null,[1,[1,null,null,null,[0,null,null,0,null,null,null,[0,null,8333334
+,0,0,333,[5,[5,[[5,[5,[41,

corpus/1c5e3966ee05f257c7696e938e235ace88d9baae

@@ -0,0 +1,63 @@
+[[[{},{},	[[[{},{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-411.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},8,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	"8[[-418,udafa\udfa2fffa\udafa\udffa2ffa\udafa\udffadffa[[[[[[[[ tru2

corpus/2008472c8c7ea0f419157ac6e0cb72286e267e69

@@ -0,0 +1 @@
+{"x":[{"id": "xxx"}],"x":[{"i":[{"id": ""}],"x":[{"i": "xxx"}],"x":[],"x":[{"id": "x"}],"":[{"id": "xxx"}],"x":[{"id": "xx"}],"x":[{"idd": "xx"}],"x":[{"id": "x"}],"x":[{"iid": "xxxxxxx"}],"x":[{"i":[{"id": "xxxxxxx"}],"x":[{"i":[{"id": "xxxxxxxxx"}],"x":[{"id": "xx"}],"x":[{"idd": "xx"}],"xd": "xxxx"}],"x":[{"id":"xx"}],"x":[{"idd": "xx"}],"":[{"id": ""}],"x":[{"i":[{"id": "xxx"}],"x":[{"id": "xx"}],"": "xx"}],"x":[{"id": "xxxxxxxx"}],"x":[{"id": "xx"}],"x":[{"idd": "xx"}],"x":[{"i": ""}],"x":[{"i": "xxx"}],"x":[{"id": "xx"}],"x":[{"idd": "xx"}],"x":[{"id": "xxxxxxxx"}],"x":[{"id": "xx"}],"x":[{"idx":[{"id": "xx"}],"x":[{"idd": "xx"}],"xd": "xxxx"}],"x":[{"id":"xx"}],"x":[{"idd": "xx"}],"":[{"id": ""}],"x":[{"i":[{"id": "xxx"}],"x":[{"id": "xx"}],"": "xx"}],"x":[{"id": "xxxxxxxx"}],"x":[{"id": ""}],"x":[{"idd": "xx"}],"x":[{"id": "x"],"x":[d""}

corpus/33f44df9b823eb7672117b74522016093a4f35b9

@@ -0,0 +1,67 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[
+
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[
+
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[
+
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[S[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[8
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+4␍"p
6

corpus/55cc2473a0060908ea5aa142d485311d9fd08a05

@@ -0,0 +1,124 @@
+[[[{},{},	[[[{},{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},6,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[[	
+[[-418,[8,[[[
+[[-41,[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+["[-Ò418,

corpus/58f4f27c5fb5a4a5c3d7885e24bdd199dd67f3e7

@@ -0,0 +1,52 @@
+[4,[5,[5,[4,[6,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[␍[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-41,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,0,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[4,[[5,[5,[415,4,[5,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[0,[[null,[415,[4,[5,[[5,[4,[[415,4,[5,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[0,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,¥Ã,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[{ "min":1.0e+9, ""[[{},{}:0 -1.0e028 },[[false,	[[false,	[[[{},8,

corpus/5d561d3b1e73757f911f13aa27ab9b15e5ad540b

@@ -0,0 +1,89 @@
+[[[{},{},	[[[{},{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-2222222222222222222222232222222222222222222222222222222222222222222222222222222222222222222222222222241.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[0,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,8,[8,[8,[[[[[-41.8,[7E-5,7E-5,3E8,[
+[[-418,[8111,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[0,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,8,[8,[8,[[[[[-41.8,[7E-5,7E-5,3E8,[	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+},	[[[{},{},[[false,	[[false,	[[[{},4,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,34e55,33522333,33e5,3,[[[
+[[-2222222222222222222222232222222222222222222222222222222222222222222222222222222222222222222222222222241.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[0,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,8,[8,[8,[[[[[-41.8,[7E-5,7E-5,3E8,[
+[[-418,[8111,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[0,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[9999,9990999998,9919999999,999099999,8,991999999,999909,8,991999999,99909999,9998,[8,[8, -4e55,33

corpus/6573e6056d5b7cf5abe96fa79dfb67dc40f186d7

@@ -0,0 +1,77 @@
+[[[{},{},	[[[{},{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[0.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[8,
+[[-41.8,[-41.8,[8,[8,8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,␍9777E-1,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[83,6663,66666666,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[[[[[[-41.8,[83,6663,66666666,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[[	
+[[-418,[8,[[[
+[[-41,[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+["[-Ò418,

corpus/671ebb182feaab57ade99264b24562beca604ac4

@@ -0,0 +1 @@
+7	9:

corpus/72d1a95c760d71897e8cfd2f9c6aa58519a0ab32

@@ -0,0 +1,37 @@
+[5,[5,[4,[6,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,0,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[4,[[5,[5,[415,4,[5,[5,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[																																																																								null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[4,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,4,[6,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,0,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,4,5,[[5,5,[4,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[4,[[5,[5,[415,4,[5,[5,[5,55,5,[[5,[4,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-73,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[4,[6,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,0,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[4,[[5,[5,[415,4,[5,[5,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[																																																																								null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,4,[6,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,0,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,4,5,[[5,5,[4,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[4,[[5,[5,[415,4,[5,[5,[5,55,5,[[5,[4,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-3,[8,[[41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[6,[[[[	[[[	
+[[-418,[8,[[[
+
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,0,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,4,5,[[5,5,[5,[41.8,[8,íííííííííííííííííííííííí…

corpus/7490a286bfa7c7c5dda38f2af122e2463c4deda5

@@ -0,0 +1,71 @@
+[[[{},{},	[[[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[0.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[["\uDA9D\uDDDDux\uDA9D\uDDDdux\uDA9D\uDDA9D\uDA9D\DDDD[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[[	
+[[-418,[8,[[[
+[[-41,[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1Dux9D\uDA9D\uDDDDDD*x\uDA9D\uDDDd.8,[uxux\uDA3,[8,[[[[9D\uDDDdDDDux\uDA9D\	[uDDD[[	dí¤Ý¤Ò-ËŠ\u18,DA9D\uDDdDDA0

corpus/749f02112903770a8107c67b3aa68718c651013f

@@ -0,0 +1,91 @@
+[[[{},{},	[[[{},{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[[[22222222222241.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[[[[{},{},	[[[{},{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,28,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},9,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[	[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},2,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-3,[8,[[41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[
+[[-41,{},[[false,	[[false,	[[[{},666663333333338,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-3,[8,[[41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[0,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,8,[8,[8,[[[[[-41.8,[7E-5,7E-5,3E8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[0,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,8,[8,[8,[[[[[-41.8,[7E-5,7E-5,3E8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,59,	[[ls[{},8,[99,999099999,8,99199999,9999909,8,991999999,99909999,999099999,8,99999990-449999,{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[
+[[-418,[":},
+{},5,[3® -4e55,33

corpus/7f3b543f163a8d7210590fc5f3e2cad2661de07c

@@ -0,0 +1,141 @@
+[[[{},{},	[[[{},{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[[8,[[[[[[-41.8,[8,[	{""	
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙
+
+
+
+[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},6,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[[	
+[[-418,[8,[[[
+[[-41,[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+["[-Ň418,

corpus/8855fa2204d6f0467f6afc0d5502a67946670577

@@ -0,0 +1,62 @@
+[[[{},{},	[[[{},{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},3,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[␍[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[8,[8,[8,
+[[-41.8,[-41.8,{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[											[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-20,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-417.777E-8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[			 { "$i":     9,				 "max":     8,					 "x":							2.0e+28,[[false,	[[false,	"8[[-418,[8,[4,[5,[5,[4,[6   8, "man": -3.8,  "max":							8,	 "max":     8,					 "man":   ,[ššššššššššš5,5, 5,[5,max

corpus/89b49d92ee8f2d8b00eff817407127add1db5f23

@@ -0,0 +1,209 @@
+[[[{},{},	[[[{},{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[[[	[[[	[[-41.8,[3,[82,[[[[	[[[	
+[[-418,[8,[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222241.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-418,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[0,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.80,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-40.8,[8,[8,[[1.8,[3,[0,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,8,[8,[8,[[[[[-41.8,[7E-5,7E-5,3E8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[0,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,8,[8,[8,[[[[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,8,[8,[8,[[[[[-41.8,[7E-5,7E-5,3E8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-20.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[
+
+
+
+
+
+
+
+
+
+
+	-41.8,[6,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[78,[
+[[-48,[8,8,[8,[8,[[[[[-41.8,[7E-5,7E-5,3E8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-20.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[
+
+
+
+
+
+
+
+
+
+
+	-41.8,[6,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[6,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[78,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,"\@d83d\u34e55,335223334e55,33e5,334e55,3e5,3999099999,8,999999909993339\ud

corpus/8cf544346a19e29f9c63eb5b1571b26ea1bfcb4c

@@ -0,0 +1 @@
+{ "miN": -1.0e+28, "man": -128, "max": 8, "man": -1.0e+28, "max":{"i": {  " ":{  "i[":{ "i[":  {  " #":{  "i[d":{  "":  {  "":{  "#" 1rs.

corpus/920e4c25ed31f5891ba641b7528225fad8fbb8d2

@@ -0,0 +1,98 @@
+[[[{},{},	[[[{},{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[0.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[[8,[[[[[[-41.8,[8,[6,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,[[0.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[["Lafa\ufa2dudu\udafa\ufa2f	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[[	
+[[-418,[8,[[[
+[[-41,[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+["[-Ò418,

corpus/9b2fc26744a4f566b15b1689d5b03a51abdcfba7

@@ -0,0 +1,75 @@
+[[],[[[],[],[[],[	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[␍[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[␍[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[8,[[[[[[[[[[[[[[[[[[[[[[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[8,[[[[[[[[[[[[[[[Q[[[[[[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙se,	[[

corpus/a1befd00d4d5737562e541fbfb02ed52e26cf014

@@ -0,0 +1,100 @@
+[[[{},{},	[[[{},{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,␍9777E-1,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[83,6663,66666666,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[4,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+
+
+-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,␍9777E-1,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[83,6663,66666666,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[4,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	"ffa2ffa\udafa\udffad@fa\uda!a\udff41.8,[8,[8,[[[
+[8{},[-[

corpus/a55402343c1a748e392af78adc6dd4da7c561a3b

@@ -0,0 +1,61 @@
+[[[{},{},	[[[{},{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,28,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},9,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[	[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-418,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},2,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},2,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},8,[-41.8,[8,[8,[[[[
+[[-41,{},[[false,	[[false,	[[[{},666663333333338,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-3,[8,[[41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,		[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},9,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[n˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙alfase,	[[ls[{},

corpus/a66e88a75729c3d4fecc340e462fc0c56e2ce75b

@@ -0,0 +1,52 @@
+[						[ 		[false,							     			[								[ 					[ 			[false,					-5,7.777E-5,[5,7.5,7.75,775,775,[5,7E-575,77.75,7757E-5,[5,7.5,7.75,[5,7E-575,77.75,775,[5,7E-575,775.75,775,[5,7E-575,5,7.5,7.75,[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[7,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{}			,{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-3,[8,[[41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[87.7,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.7,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[7,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{}			,{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-3,[8,[[41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[5,7E-5,7.7,[[ 			[false,		[   	[ 			[false,	 [ 		false,						[  		[ 						[ 			[false	,		[   [ 			[false,				[false,		[    false,							[false,		[   	[ 			[false,			[false,	 			[  		[ 		[fal7

corpus/a9cd5b5878073e7aa5aab93cd6ad770759433e37

@@ -0,0 +1,54 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[
+
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[
+
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[
+
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[{},{},	[[[{},{},[[[[{},{},	[[[{},{},[5,[[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[95,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,4,[5,[5,[4,[6,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[4,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,4,[5,[5,[4,[6,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[4,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[{"x":[{"id": "xx"}],"x":[{"d":"x"}],"":"xx"}],,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,4,[5,[5,[4,[6,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[4,[5,[[null,5,[5,[5,[[5,[5,[415,[4,
+[[[[[false,	[[f[
+
+
+
+
+
+
+
+4
+"p{ },,[5[
+[
+[{ },[[[
6[
+
+][-41,[-,[5[,[5,[41,

corpus/b07b65d947d408887f148392536ce8aa9406a3d1

@@ -0,0 +1,128 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[
+
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[
+
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[
+
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[{},{},	[[[{},{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[[[[[	[[[	
+[[-418,[8,[[[
+8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[	[[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[[[[[[[[[[[[[[[[[[[[[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[-41.8,[8,[8,[[[[[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[[[[[[[[[[[[[[[[[[[[[[[[[[f[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418[[[[[[[[[,[8,[[[
+[[-41.8,[8[[[[[[[[[[[[[˙˙˙˙˙˙˙*[[[[[[
+
+
+
+{"":
+
+
+5
+
+
+
+
+
+
+
+
+
+
+
+
+
+,[8,
+[[-41.8,[-41.8,[8,[8,
+
+
+
+
+[[[[[false,	[[f[
+
+
+
+
+
+
+
+4
+"p{ },[
+[
+[{ },[[[
6[
+
+][-41,[-[

corpus/b395997c325728be7667c752af204b08b35d4bb5

@@ -0,0 +1,145 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[
+
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[
+
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[
+
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[
+
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[{},{},	[[[{},{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[	[[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[[[[[[[[[[[[[[[[[[[[[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[-41.8,[8,[8,[[[[[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[[[[[[[[[[[[[[[[[[[[[[[[[[f[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418[[[[[[[[[,[8,[[[
+[[-41.8,[8[[[[[[[[[[[[[˙˙˙˙˙˙˙*[[[[[[
+
+
+
+{"":
+
+
+5
+
+
+
+
+
+
+
+
+
+
+
+
+
+,[8,
+[[-41.8,[-41.8,[8,[8,
+
+
+
+
+[[[[[false,	[[f[
+
+
+
+
+
+
+
+4
+"p{ },[
+[
+[{ },[[[
6[
+
+][-41,[-[

corpus/b3c3156b5c594680199da3a5ad28bfcd49b163bc

@@ -0,0 +1,56 @@
+4
+
+
+
+
+
+␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍
+
+
+
+
+
+
+
+
+
+␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍iAse␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍
+
+␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍
+␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍
+
+
+
+
+
+
+
+
+
+␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍
+
+
+
+
+
+
+
+
+
+␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍
+
+
+
+
+
+
+
+
+
+␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍
+
+␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍␍
+
+
+
+

corpus/c32e725bc6a51ac702b3a1b56ee3c5f833127f70

@@ -0,0 +1,4 @@
+[4,[5,[5,[4,[6,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,0,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[4,[[5,[5,[415,4,[5,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[0,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[243,[[5,[5,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[6,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,0,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[4,[[5,[5,[415,4,[5,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[0,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[7,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4444444444444444444444444444444444444444444444444444444444444444444444444444,[5,[5,[5.75,775,[5,7,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,333333333
+,0,333333333
+,0,3333,null,0,null,null,[1,[1,null,null,null,[0,null,null,0,null,null,null,[0,null,8333334
+,0,0,333,[5,[5,[[5,[5,[41,

corpus/d66d12c91cc03bc6e69bbd74d1c396da51266d5b

@@ -0,0 +1,89 @@
+[[[{},{},	[[[{},{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,8,[[1.8,[3,[8,[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[8,[
+[[-418,[8,[[[[{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,1.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},6,[-41.8,[8,[8.8,[8,[[[{},{},	[[["\uD0D80\uD60Du0\uDD8D\uDDD80D?0\u[{},{},[[falF0DDuse,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-410^^^^^^^^^^^^^^,^^^^^^^^^^^^^8,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,É[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[[	
+[[-418,[8,[[[
+[[-41,[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+["[-Ò418,

corpus/d8a917256920c3f03a1468f0a41d830bf75cd2f2

@@ -0,0 +1,79 @@
+[[[{},{},	[[[{},{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+
+
+-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,␍9777E-1,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[83,6663,66666666,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[4,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[{"x":[{"id": "xxxxxxxxxxxxxxxxXx"}],"x":[{"i":[{"id":"xxx"}],"x":[{"d": "vxxxx[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+
+
+-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[se,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	"i": [[["{},{},[[false,	{[false,_	"ffa2ffa\udafa\udffad@fa\uda!a\udff41.8,[8,[8,[[[
+[8{},[-[

corpus/dbe5885ae01dabd4b2b1aee501787929ccba4c8f

@@ -0,0 +1,41 @@
+
+␍ [[0,0,[
+12011111111112111111110,5,[
+
+[[],[],[{">>>>>>>>>>>>>>>)>>>>>>;":[{"":[[{"":[{"":[{"":[{"":[{"":[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,0,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[4,[[5,[5,[415,4,[5,[5,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[																																																																								null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[4,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,4,[6,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,0,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,4,5,[[5,5,[4,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[4,[[5,[5,[415,4,[5,[5,[5,55,5,[[5,[4,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-73,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[4,[6,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,0,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[4,[[5,[5,[415,4,[5,[5,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[																																																																								null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,5,[5,[415,4,[5,[5,[5,55,5,[[5,[4,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-3,[8,[[41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[6,[[[[	[[[	
+[[-418,[8,[[[
+
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[5,[5,5,[5,{"":[{"":[{"":[{"":[{"":[{"":[{"":[{"":[{"":[{"":[{"":[{"":[{"":[{"":[{"":[{"":[{"":[{"":[f

corpus/fc80c272a8fe70f5ed3fa7fa753c72a633bd4285

@@ -0,0 +1,61 @@
+[[[{},{},	[[[{},{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8.8,[8,[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[-418,[8,[[[
+[[-41.8,[8,[8,␍9777E-1,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[11111111111111055,
+-612111111110,0,[
+[true,[[[	[[[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8                                                                                        ,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41,{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[7,[[[[41.8,[8,[8,[[[[	[[[	[[-41.8,[3,[8,[[[[	[[[	
+[[-418,[8,[[[
+[[-41.8,[8,[8,
+[[-41.8,[-41.8,[8,[8,[[[[[-41.8,[8,[
+[[-418,[8,[[[[[[-41.8,[8,[8,[[[[	[[[	
+[[-41,{},[[[[{},{},	[[[{},{},[[false,	[[false,	[[[{},8,[-41.8,[8,[8,[[[[[-20.8,[8,[8,[[1.8,[3,[	"8[[-418,udafaadu\b2fffa\udafa\ud[-[

corpus/ffcd969ec9f4ce7ca1cdc2a66b17b9b720ce1805

@@ -0,0 +1 @@
+[4,[5,[5,[4,[6,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[0,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,0,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[4,[[5,[5,[415,4,[5,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[0,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[7,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4444444444444444444444444444444444444444444444444444444444444444444444444444,[5,[5,[5.75,775,[5,7,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[[null,[415,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[413,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,[5,[5,[415,[4,[5,[5,[4,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[5,[4,5,[5,5,[[[5,5,[5,[5,[5,[[null,5,[5,[5,[[5,[5,[415,[4,[5,[5,[3,[5,[5,[5,5,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,0,[[5,[4,[5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,4,5,[[5,5,[5,[5,[[null,[415,[4,[5,[[5,[4,[5,[5,[5,5,[5,[4,[[5,[5,[415,4,[5,[5,[5,55,5,[[5,[4,[5,[5,[5,5,[5,[5,[[5,[5,[415,[4,[5,[5,[[0,[[nu

include/weaseljson.h

@@ -50,7 +50,8 @@ enum WeaselJsonFlags {
 /** Create a parser. Increasing stack size increases memory usage but also
  * increases the depth of nested json accepted. `callbacks` and `userdata` must
  * outlive the returned parser. Returns null if there's insufficient available
- * memory */
+ * memory, or if `stackSize` is negative or too small to hold a minimal
+ * document. */
 WeaselJsonParser *WeaselJsonParser_create(int stackSize,
                                           const WeaselJsonCallbacks *callbacks,
                                           void *userdata, int flags);
@@ -63,7 +64,8 @@ void WeaselJsonParser_destroy(WeaselJsonParser *parser);
 
 /** Incrementally parse `len` more bytes starting at `buf`. `buf` may be
  * modified. Call with `len` 0 to indicate end of data. `buf` may be null if
- * `len` is 0 */
+ * `len` is 0. `len` must not be negative; a negative length is treated as a
+ * rejected input. */
 WeaselJsonStatus WeaselJsonParser_parse(WeaselJsonParser *parser, char *buf,
                                         int len);
 

src/fuzz.cpp

@@ -35,7 +35,7 @@ std::pair<std::string, WeaselJsonStatus> runBatch(std::string copy) {
   SerializeState state;
   auto c = serializeCallbacks();
   std::unique_ptr<WeaselJsonParser, decltype(&WeaselJsonParser_destroy)> parser{
-      WeaselJsonParser_create(1024, &c, &state,
+      WeaselJsonParser_create(1 << 20, &c, &state,
                               copy.size() % 2 == 0 ? WeaselJsonRaw : 0),
       WeaselJsonParser_destroy};
   auto s = WeaselJsonParser_parse(parser.get(), copy.data(), copy.size());

src/fuzz_driver.cpp

@@ -0,0 +1,19 @@
+#include <cstddef>
+#include <cstdint>
+#include <fstream>
+#include <sstream>
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
+
+int main(int argc, char **argv) {
+  auto doTest = [&]() {
+    for (int i = 1; i < argc; ++i) {
+      std::ifstream t(argv[i], std::ios::binary);
+      std::stringstream buffer;
+      buffer << t.rdbuf();
+      auto str = buffer.str();
+      LLVMFuzzerTestOneInput((const uint8_t *)str.data(), str.size());
+    }
+  };
+  doTest();
+}

src/lib.cpp

@@ -10,12 +10,21 @@ extern "C" {
 __attribute__((visibility("default"))) WeaselJsonParser *
 WeaselJsonParser_create(int stackSize, const WeaselJsonCallbacks *callbacks,
                         void *userdata, int flags) {
-  auto *buf = malloc(sizeof(Parser3) + stackSize * sizeof(*Parser3::stackPtr));
+  if (stackSize < 0) { // avoid (size_t)stackSize wrapping to a huge allocation
+    return nullptr;
+  }
+  auto *buf =
+      malloc(sizeof(Parser3) + (size_t)stackSize * sizeof(*Parser3::stackPtr));
   if (buf == nullptr) {
     return nullptr;
   }
-  return (WeaselJsonParser *)new (buf)
+  auto *parser = new (buf) Parser3{callbacks, userdata, stackSize, flags};
-      Parser3{callbacks, userdata, stackSize, flags};
+  if (parser->empty()) { // stack too small to hold reset()'s bootstrap symbols
+    parser->~Parser3();
+    free(buf);
+    return nullptr;
+  }
+  return (WeaselJsonParser *)parser;
 }
 
 __attribute__((visibility("default"))) void

src/musttail.h

@@ -6,6 +6,7 @@
 
 #if __has_attribute(musttail)
 #define MUSTTAIL __attribute__((musttail))
+#define HAS_MUSTTAIL
 #else
 #define MUSTTAIL
 #endif

src/parser3.h

@@ -17,20 +17,29 @@
 
 namespace parser3 {
 
-// Calling a continuation with buf == bufEnd means end of input
+// The internal result of a parse step: a WeaselJsonStatus value, or kBounce.
-typedef PRESERVE_NONE WeaselJsonStatus (*Continuation)(struct Parser3 *,
+// It's a plain int (not WeaselJsonStatus) so the no-musttail trampoline's
-                                                       char *buf, char *bufEnd);
+// out-of-range sentinel never forms an out-of-range enum value (that would be
+// UB, since the public WeaselJsonStatus has no fixed underlying type). parse()
+// converts back to WeaselJsonStatus at the boundary, where it is always 0..3.
+using ContinuationStatus = int;
+[[maybe_unused]] inline constexpr ContinuationStatus kBounce = -1;
 
-inline PRESERVE_NONE WeaselJsonStatus n_object2(Parser3 *self, char *buf,
+// Calling a continuation with buf == bufEnd means end of input
-                                                char *bufEnd);
+typedef PRESERVE_NONE ContinuationStatus (*Continuation)(struct Parser3 *,
-inline PRESERVE_NONE WeaselJsonStatus n_array2(Parser3 *self, char *buf,
+                                                         char *buf,
-                                               char *bufEnd);
+                                                         char *bufEnd);
-inline PRESERVE_NONE WeaselJsonStatus n_string2(Parser3 *self, char *buf,
+
-                                                char *bufEnd);
+inline PRESERVE_NONE ContinuationStatus n_object2(Parser3 *self, char *buf,
-inline PRESERVE_NONE WeaselJsonStatus n_string(Parser3 *self, char *buf,
+                                                  char *bufEnd);
-                                               char *bufEnd);
+inline PRESERVE_NONE ContinuationStatus n_array2(Parser3 *self, char *buf,
-inline PRESERVE_NONE WeaselJsonStatus n_number(Parser3 *self, char *buf,
+                                                 char *bufEnd);
-                                               char *bufEnd);
+inline PRESERVE_NONE ContinuationStatus n_string2(Parser3 *self, char *buf,
+                                                  char *bufEnd);
+inline PRESERVE_NONE ContinuationStatus n_string(Parser3 *self, char *buf,
+                                                 char *bufEnd);
+inline PRESERVE_NONE ContinuationStatus n_number(Parser3 *self, char *buf,
+                                                 char *bufEnd);
 
 // These appear in the stack of the pushdown
 // automata
@@ -121,14 +130,21 @@ struct Parser3 {
     return *(stackPtr - 1);
   }
 
-  static PRESERVE_NONE WeaselJsonStatus keepGoing(Parser3 *self, char *buf,
+  static PRESERVE_NONE ContinuationStatus keepGoing(Parser3 *self, char *buf,
-                                                  char *bufEnd);
+                                                    char *bufEnd);
 
   Symbol *stack() const { return (Symbol *)(this + 1); }
 
   void reset() {
     stackPtr = stack();
     std::ignore = push({N_VALUE, N_WHITESPACE, T_EOF});
+    inKey = false;
+    rejected = false;
+    utf8Codepoint = 0;
+    utf16Surrogate = 0;
+    minCodepoint = 0;
+    numDfa.reset();
+    strDfa.reset();
   }
 
   // Used for flushing pending data with on_*_data callbacks
@@ -146,9 +162,27 @@ struct Parser3 {
   NumDfa numDfa;
   Utf8Dfa strDfa;
   bool inKey = false;
+  bool rejected = false;
+
+#ifndef HAS_MUSTTAIL
+  char *stashBufForTrampoline;
+#endif
 };
 
-inline PRESERVE_NONE WeaselJsonStatus skipWhitespace(char *&buf, char *bufEnd) {
+// Transfer control to continuation `fn`, whose Symbol must already be on top of
+// the stack. With musttail this is a direct tail call (fast path). Without it,
+// a direct call would recurse on the C stack (e.g. n_value -> n_array2 ->
+// n_value for nested arrays, or n_string2 -> n_string2 for runs of escapes) and
+// overflow on deep input; instead we bounce to the parse() trampoline, which
+// re-dispatches continuations[top()] == fn without growing the stack.
+#ifdef HAS_MUSTTAIL
+#define TAILCALL(fn) MUSTTAIL return fn(self, buf, bufEnd)
+#else
+#define TAILCALL(fn) return Parser3::keepGoing(self, buf, bufEnd)
+#endif
+
+inline PRESERVE_NONE ContinuationStatus skipWhitespace(char *&buf,
+                                                       char *bufEnd) {
   constexpr int kStride = 4;
   for (;;) {
     if (bufEnd - buf < kStride) [[unlikely]] {
@@ -167,8 +201,8 @@ inline PRESERVE_NONE WeaselJsonStatus skipWhitespace(char *&buf, char *bufEnd) {
   }
 }
 
-inline PRESERVE_NONE WeaselJsonStatus n_whitespace(Parser3 *self, char *buf,
+inline PRESERVE_NONE ContinuationStatus n_whitespace(Parser3 *self, char *buf,
-                                                   char *bufEnd) {
+                                                     char *bufEnd) {
   if (buf == bufEnd) {
     self->pop();
     MUSTTAIL return Parser3::keepGoing(self, buf, bufEnd);
@@ -180,8 +214,8 @@ inline PRESERVE_NONE WeaselJsonStatus n_whitespace(Parser3 *self, char *buf,
   MUSTTAIL return Parser3::keepGoing(self, buf, bufEnd);
 }
 
-inline PRESERVE_NONE WeaselJsonStatus n_number(Parser3 *self, char *buf,
+inline PRESERVE_NONE ContinuationStatus n_number(Parser3 *self, char *buf,
-                                               char *bufEnd) {
+                                                 char *bufEnd) {
   if (buf != bufEnd) {
     buf = (char *)self->numDfa.scan(buf, bufEnd);
     if (buf == bufEnd) {
@@ -200,9 +234,9 @@ inline PRESERVE_NONE WeaselJsonStatus n_number(Parser3 *self, char *buf,
 // Advance buf until double quote, backslash, invalid utf8, or codepoint <
 // 0x20
 template <class V>
-inline PRESERVE_NONE WeaselJsonStatus scan_string_impl(Parser3 *self,
+inline PRESERVE_NONE ContinuationStatus scan_string_impl(Parser3 *self,
-                                                       char *&buf,
+                                                         char *&buf,
-                                                       char *bufEnd) {
+                                                         char *bufEnd) {
   const auto before = buf;
 
   // Advance buf past characters that transition the accept state to itself
@@ -249,34 +283,34 @@ inline PRESERVE_NONE WeaselJsonStatus scan_string_impl(Parser3 *self,
 
 #ifdef __x86_64__
 constexpr int kLanes = 32;
-template WeaselJsonStatus
+template ContinuationStatus
 scan_string_impl<simd<int8_t, kLanes, sse::Simd_x86_SSE>>(Parser3 *, char *&,
                                                           char *);
 
-template __attribute__((target("avx2"))) WeaselJsonStatus
+template __attribute__((target("avx2"))) ContinuationStatus
 scan_string_impl<simd<int8_t, kLanes, sse::Simd_x86_AVX2>>(Parser3 *, char *&,
                                                            char *);
 
-__attribute__((target("default"))) inline PRESERVE_NONE WeaselJsonStatus
+__attribute__((target("default"))) inline PRESERVE_NONE ContinuationStatus
 scan_string(Parser3 *self, char *&buf, char *bufEnd) {
   MUSTTAIL return scan_string_impl<simd<int8_t, kLanes, sse::Simd_x86_SSE>>(
       self, buf, bufEnd);
 }
 
-__attribute__((target("avx2"))) inline PRESERVE_NONE WeaselJsonStatus
+__attribute__((target("avx2"))) inline PRESERVE_NONE ContinuationStatus
 scan_string(Parser3 *self, char *&buf, char *bufEnd) {
   MUSTTAIL return scan_string_impl<simd<int8_t, kLanes, sse::Simd_x86_AVX2>>(
       self, buf, bufEnd);
 }
 #else
-inline PRESERVE_NONE WeaselJsonStatus scan_string(Parser3 *self, char *&buf,
+inline PRESERVE_NONE ContinuationStatus scan_string(Parser3 *self, char *&buf,
-                                                  char *bufEnd) {
+                                                    char *bufEnd) {
   MUSTTAIL return scan_string_impl<simd<int8_t, 32>>(self, buf, bufEnd);
 }
 #endif
 
-inline PRESERVE_NONE WeaselJsonStatus n_value(Parser3 *self, char *buf,
+inline PRESERVE_NONE ContinuationStatus n_value(Parser3 *self, char *buf,
-                                              char *bufEnd) {
+                                                char *bufEnd) {
   if (buf == bufEnd) [[unlikely]] {
     return WeaselJson_REJECT;
   }
@@ -292,7 +326,7 @@ inline PRESERVE_NONE WeaselJsonStatus n_value(Parser3 *self, char *buf,
     if (buf == bufEnd) {
       return WeaselJson_AGAIN;
     }
-    MUSTTAIL return n_object2(self, buf, bufEnd);
+    TAILCALL(n_object2);
   case '[':
     self->callbacks->on_begin_array(self->userdata);
     ++buf;
@@ -301,7 +335,7 @@ inline PRESERVE_NONE WeaselJsonStatus n_value(Parser3 *self, char *buf,
     if (buf == bufEnd) {
       return WeaselJson_AGAIN;
     }
-    MUSTTAIL return n_array2(self, buf, bufEnd);
+    TAILCALL(n_array2);
   case '"':
     ++buf;
     self->dataBegin = self->writeBuf = buf;
@@ -311,7 +345,7 @@ inline PRESERVE_NONE WeaselJsonStatus n_value(Parser3 *self, char *buf,
     if (buf == bufEnd) {
       return WeaselJson_AGAIN;
     }
-    MUSTTAIL return n_string2(self, buf, bufEnd);
+    TAILCALL(n_string2);
   case '0':
   case '1':
   case '2':
@@ -330,7 +364,7 @@ inline PRESERVE_NONE WeaselJsonStatus n_value(Parser3 *self, char *buf,
     if (buf == bufEnd) {
       return WeaselJson_AGAIN;
     }
-    MUSTTAIL return n_number(self, buf, bufEnd);
+    TAILCALL(n_number);
   case 't':
     ++buf;
     self->pop();
@@ -388,8 +422,8 @@ inline PRESERVE_NONE WeaselJsonStatus n_value(Parser3 *self, char *buf,
   MUSTTAIL return Parser3::keepGoing(self, buf, bufEnd);
 }
 
-inline PRESERVE_NONE WeaselJsonStatus n_object2(Parser3 *self, char *buf,
+inline PRESERVE_NONE ContinuationStatus n_object2(Parser3 *self, char *buf,
-                                                char *bufEnd) {
+                                                  char *bufEnd) {
   if (buf == bufEnd) [[unlikely]] {
     return WeaselJson_REJECT;
   }
@@ -418,14 +452,14 @@ inline PRESERVE_NONE WeaselJsonStatus n_object2(Parser3 *self, char *buf,
     if (buf == bufEnd) {
       return WeaselJson_AGAIN;
     }
-    MUSTTAIL return n_string2(self, buf, bufEnd);
+    TAILCALL(n_string2);
   default:
     [[unlikely]] return WeaselJson_REJECT;
   }
 }
 
-inline PRESERVE_NONE WeaselJsonStatus n_object3(Parser3 *self, char *buf,
+inline PRESERVE_NONE ContinuationStatus n_object3(Parser3 *self, char *buf,
-                                                char *bufEnd) {
+                                                  char *bufEnd) {
   if (buf == bufEnd) [[unlikely]] {
     return WeaselJson_REJECT;
   }
@@ -464,14 +498,14 @@ inline PRESERVE_NONE WeaselJsonStatus n_object3(Parser3 *self, char *buf,
     if (buf == bufEnd) {
       return WeaselJson_AGAIN;
     }
-    MUSTTAIL return n_string2(self, buf, bufEnd);
+    TAILCALL(n_string2);
   default:
     [[unlikely]] return WeaselJson_REJECT;
   }
 }
 
-inline PRESERVE_NONE WeaselJsonStatus n_array2(Parser3 *self, char *buf,
+inline PRESERVE_NONE ContinuationStatus n_array2(Parser3 *self, char *buf,
-                                               char *bufEnd) {
+                                                 char *bufEnd) {
   if (buf == bufEnd) [[unlikely]] {
     return WeaselJson_REJECT;
   }
@@ -492,12 +526,12 @@ inline PRESERVE_NONE WeaselJsonStatus n_array2(Parser3 *self, char *buf,
     if (auto s = self->push({N_VALUE, N_ARRAY3})) {
       return s;
     }
-    MUSTTAIL return n_value(self, buf, bufEnd);
+    TAILCALL(n_value);
   }
 }
 
-inline PRESERVE_NONE WeaselJsonStatus n_array3(Parser3 *self, char *buf,
+inline PRESERVE_NONE ContinuationStatus n_array3(Parser3 *self, char *buf,
-                                               char *bufEnd) {
+                                                 char *bufEnd) {
   if (buf == bufEnd) [[unlikely]] {
     return WeaselJson_REJECT;
   }
@@ -522,14 +556,14 @@ inline PRESERVE_NONE WeaselJsonStatus n_array3(Parser3 *self, char *buf,
     if (buf == bufEnd) {
       return WeaselJson_AGAIN;
     }
-    MUSTTAIL return n_value(self, buf, bufEnd);
+    TAILCALL(n_value);
   default:
     [[unlikely]] return WeaselJson_REJECT;
   }
 }
 
-inline PRESERVE_NONE WeaselJsonStatus n_string(Parser3 *self, char *buf,
+inline PRESERVE_NONE ContinuationStatus n_string(Parser3 *self, char *buf,
-                                               char *bufEnd) {
+                                                 char *bufEnd) {
   if (buf == bufEnd) [[unlikely]] {
     return WeaselJson_REJECT;
   }
@@ -547,7 +581,7 @@ inline PRESERVE_NONE WeaselJsonStatus n_string(Parser3 *self, char *buf,
   if (buf == bufEnd) {
     return WeaselJson_AGAIN;
   }
-  MUSTTAIL return n_string2(self, buf, bufEnd);
+  TAILCALL(n_string2);
 }
 
 inline int32_t read4_hex(const char *buf) {
@@ -555,8 +589,8 @@ inline int32_t read4_hex(const char *buf) {
          tables.hex[uint8_t(buf[2])] << 4 | tables.hex[uint8_t(buf[3])] << 0;
 }
 
-inline PRESERVE_NONE WeaselJsonStatus n_string2(Parser3 *self, char *buf,
+inline PRESERVE_NONE ContinuationStatus n_string2(Parser3 *self, char *buf,
-                                                char *bufEnd) {
+                                                  char *bufEnd) {
   if (buf == bufEnd) [[unlikely]] {
     return WeaselJson_REJECT;
   }
@@ -650,16 +684,15 @@ inline PRESERVE_NONE WeaselJsonStatus n_string2(Parser3 *self, char *buf,
         self->flushString(false, buf);
         return WeaselJson_AGAIN;
       }
-      MUSTTAIL return n_string2(self, buf, bufEnd);
+      TAILCALL(n_string2);
     }
   default:
     [[unlikely]] return WeaselJson_REJECT;
   }
 }
 
-inline PRESERVE_NONE WeaselJsonStatus n_string_following_escape(Parser3 *self,
+inline PRESERVE_NONE ContinuationStatus
-                                                                char *buf,
+n_string_following_escape(Parser3 *self, char *buf, char *bufEnd) {
-                                                                char *bufEnd) {
   if (buf == bufEnd) [[unlikely]] {
     return WeaselJson_REJECT;
   }
@@ -697,8 +730,8 @@ inline PRESERVE_NONE WeaselJsonStatus n_string_following_escape(Parser3 *self,
   MUSTTAIL return Parser3::keepGoing(self, buf, bufEnd);
 }
 
-inline PRESERVE_NONE WeaselJsonStatus t_hex(Parser3 *self, char *buf,
+inline PRESERVE_NONE ContinuationStatus t_hex(Parser3 *self, char *buf,
-                                            char *bufEnd) {
+                                              char *bufEnd) {
   if (buf == bufEnd) [[unlikely]] {
     return WeaselJson_REJECT;
   }
@@ -717,8 +750,8 @@ inline PRESERVE_NONE WeaselJsonStatus t_hex(Parser3 *self, char *buf,
   MUSTTAIL return Parser3::keepGoing(self, buf, bufEnd);
 }
 
-inline PRESERVE_NONE WeaselJsonStatus t_hex2(Parser3 *self, char *buf,
+inline PRESERVE_NONE ContinuationStatus t_hex2(Parser3 *self, char *buf,
-                                             char *bufEnd) {
+                                               char *bufEnd) {
   if (buf == bufEnd) [[unlikely]] {
     return WeaselJson_REJECT;
   }
@@ -806,8 +839,8 @@ inline PRESERVE_NONE WeaselJsonStatus t_hex2(Parser3 *self, char *buf,
   MUSTTAIL return Parser3::keepGoing(self, buf, bufEnd);
 }
 
-inline PRESERVE_NONE WeaselJsonStatus t_hex3(Parser3 *self, char *buf,
+inline PRESERVE_NONE ContinuationStatus t_hex3(Parser3 *self, char *buf,
-                                             char *bufEnd) {
+                                               char *bufEnd) {
   if (buf == bufEnd) [[unlikely]] {
     return WeaselJson_REJECT;
   }
@@ -868,9 +901,9 @@ inline PRESERVE_NONE WeaselJsonStatus t_hex3(Parser3 *self, char *buf,
 }
 
 template <char kChar>
-inline PRESERVE_NONE WeaselJsonStatus singleCharInString(Parser3 *self,
+inline PRESERVE_NONE ContinuationStatus singleCharInString(Parser3 *self,
-                                                         char *buf,
+                                                           char *buf,
-                                                         char *bufEnd) {
+                                                           char *bufEnd) {
   if (buf == bufEnd) [[unlikely]] {
     return WeaselJson_REJECT;
   }
@@ -887,8 +920,8 @@ inline PRESERVE_NONE WeaselJsonStatus singleCharInString(Parser3 *self,
   }
 }
 
-inline PRESERVE_NONE WeaselJsonStatus n_true(Parser3 *self, char *buf,
+inline PRESERVE_NONE ContinuationStatus n_true(Parser3 *self, char *buf,
-                                             char *bufEnd) {
+                                               char *bufEnd) {
   if (buf == bufEnd) [[unlikely]] {
     return WeaselJson_REJECT;
   }
@@ -905,8 +938,8 @@ inline PRESERVE_NONE WeaselJsonStatus n_true(Parser3 *self, char *buf,
   }
 }
 
-inline PRESERVE_NONE WeaselJsonStatus n_false(Parser3 *self, char *buf,
+inline PRESERVE_NONE ContinuationStatus n_false(Parser3 *self, char *buf,
-                                              char *bufEnd) {
+                                                char *bufEnd) {
   if (buf == bufEnd) [[unlikely]] {
     return WeaselJson_REJECT;
   }
@@ -923,8 +956,8 @@ inline PRESERVE_NONE WeaselJsonStatus n_false(Parser3 *self, char *buf,
   }
 }
 
-inline PRESERVE_NONE WeaselJsonStatus n_null(Parser3 *self, char *buf,
+inline PRESERVE_NONE ContinuationStatus n_null(Parser3 *self, char *buf,
-                                             char *bufEnd) {
+                                               char *bufEnd) {
   if (buf == bufEnd) [[unlikely]] {
     return WeaselJson_REJECT;
   }
@@ -942,8 +975,8 @@ inline PRESERVE_NONE WeaselJsonStatus n_null(Parser3 *self, char *buf,
 }
 
 template <char kChar>
-inline PRESERVE_NONE WeaselJsonStatus singleChar(Parser3 *self, char *buf,
+inline PRESERVE_NONE ContinuationStatus singleChar(Parser3 *self, char *buf,
-                                                 char *bufEnd) {
+                                                   char *bufEnd) {
   if (buf == bufEnd) [[unlikely]] {
     return WeaselJson_REJECT;
   }
@@ -959,8 +992,8 @@ inline PRESERVE_NONE WeaselJsonStatus singleChar(Parser3 *self, char *buf,
   }
 }
 
-inline PRESERVE_NONE WeaselJsonStatus t_colon(Parser3 *self, char *buf,
+inline PRESERVE_NONE ContinuationStatus t_colon(Parser3 *self, char *buf,
-                                              char *bufEnd) {
+                                                char *bufEnd) {
   if (buf == bufEnd) [[unlikely]] {
     return WeaselJson_REJECT;
   }
@@ -981,8 +1014,8 @@ inline PRESERVE_NONE WeaselJsonStatus t_colon(Parser3 *self, char *buf,
   }
 }
 
-inline PRESERVE_NONE WeaselJsonStatus t_eof(Parser3 *, char *buf,
+inline PRESERVE_NONE ContinuationStatus t_eof(Parser3 *, char *buf,
-                                            char *bufEnd) {
+                                              char *bufEnd) {
   if (buf != bufEnd) [[unlikely]] {
     return WeaselJson_REJECT;
   }
@@ -993,7 +1026,8 @@ constexpr inline struct ContinuationTable {
   constexpr ContinuationTable() {
     // Defaults
     for (int i = 0; i < N_SYMBOL_COUNT; ++i) {
-      continuations[i] = +[](struct Parser3 *, char *, char *) PRESERVE_NONE {
+      continuations[i] = +[](struct Parser3 *, char *, char *)
+                              PRESERVE_NONE -> ContinuationStatus {
         printf("unimplemented\n");
         return WeaselJson_REJECT;
       };
@@ -1029,13 +1063,51 @@ constexpr inline struct ContinuationTable {
 
 inline WeaselJsonStatus Parser3::parse(char *buf, int len) {
   this->dataBegin = this->writeBuf = buf;
-  return symbolTables.continuations[top()](this, buf, buf + len);
+
+  if (this->rejected) [[unlikely]] {
+    return WeaselJson_REJECT;
+  }
+
+  if (len < 0) [[unlikely]] {
+    this->rejected = true;
+    return WeaselJson_REJECT;
+  }
+
+#ifdef HAS_MUSTTAIL
+  // The continuation returns a value in 0..3 here (kBounce is only used by the
+  // no-musttail trampoline below), so the conversion back to the enum is in
+  // range.
+  ContinuationStatus status =
+      symbolTables.continuations[top()](this, buf, buf + len);
+  if (status == WeaselJson_REJECT) {
+    this->rejected = true;
+  }
+  return WeaselJsonStatus(status);
+#else
+  this->stashBufForTrampoline = buf;
+  ContinuationStatus result;
+  while ((result = symbolTables.continuations[top()](
+              this, stashBufForTrampoline, buf + len)) == kBounce)
+    ;
+  if (result == WeaselJson_REJECT) {
+    this->rejected = true;
+  }
+  return WeaselJsonStatus(result);
+#endif
 }
 
-inline PRESERVE_NONE WeaselJsonStatus Parser3::keepGoing(Parser3 *self,
+inline PRESERVE_NONE ContinuationStatus Parser3::keepGoing(Parser3 *self,
-                                                         char *buf,
+                                                           char *buf,
-                                                         char *bufEnd) {
+                                                           char *bufEnd) {
+#ifdef HAS_MUSTTAIL
   MUSTTAIL return symbolTables.continuations[self->top()](self, buf, bufEnd);
+#else
+  self->stashBufForTrampoline = buf;
+  (void)bufEnd;
+  return kBounce;
+#endif
 }
 
+#undef TAILCALL
+
 } // namespace parser3

src/test.cpp

@@ -202,8 +202,107 @@ TEST_CASE("parser3") {
   }
 }
 
+TEST_CASE("rejected state is sticky") {
+  auto c = noopCallbacks();
+  auto *parser = WeaselJsonParser_create(1024, &c, nullptr, 0);
+  REQUIRE(parser != nullptr);
+
+  // Feed a valid prefix, then an invalid byte. The parser must reject.
+  std::string chunk1 = "1";
+  REQUIRE(WeaselJsonParser_parse(parser, chunk1.data(), chunk1.size()) ==
+          WeaselJson_AGAIN);
+  std::string chunk2 = "x";
+  REQUIRE(WeaselJsonParser_parse(parser, chunk2.data(), chunk2.size()) ==
+          WeaselJson_REJECT);
+
+  // After a reject, every later call must also reject, including the EOF
+  // finish call that would otherwise return OK.
+  REQUIRE(WeaselJsonParser_parse(parser, nullptr, 0) == WeaselJson_REJECT);
+
+  // Further data chunks must also stay rejected.
+  std::string chunk3 = " ";
+  REQUIRE(WeaselJsonParser_parse(parser, chunk3.data(), chunk3.size()) ==
+          WeaselJson_REJECT);
+
+  WeaselJsonParser_destroy(parser);
+}
+
+TEST_CASE("create rejects too-small stack") {
+  auto c = noopCallbacks();
+  // The parser needs room for the bootstrap symbols pushed by reset(); a stack
+  // that's too small (or negative) must yield null rather than an unusable
+  // parser that crashes on the first parse() (out-of-bounds read of the empty
+  // stack).
+  for (int stackSize : {-1, 0, 1, 2}) {
+    REQUIRE(WeaselJsonParser_create(stackSize, &c, nullptr, 0) == nullptr);
+  }
+  // A just-big-enough stack still works for a minimal document.
+  auto *parser = WeaselJsonParser_create(3, &c, nullptr, 0);
+  REQUIRE(parser != nullptr);
+  std::string copy = "1";
+  REQUIRE(WeaselJsonParser_parse(parser, copy.data(), copy.size()) ==
+          WeaselJson_AGAIN);
+  REQUIRE(WeaselJsonParser_parse(parser, nullptr, 0) == WeaselJson_OK);
+  WeaselJsonParser_destroy(parser);
+}
+
+TEST_CASE("parse rejects negative length") {
+  auto c = noopCallbacks();
+  auto *parser = WeaselJsonParser_create(1024, &c, nullptr, 0);
+  REQUIRE(parser != nullptr);
+
+  // A negative length must not cause pointer arithmetic UB. It should be
+  // rejected, and the rejected state should remain sticky.
+  char buf[10] = "hello";
+  REQUIRE(WeaselJsonParser_parse(parser, buf, -1) == WeaselJson_REJECT);
+  REQUIRE(WeaselJsonParser_parse(parser, nullptr, 0) == WeaselJson_REJECT);
+
+  WeaselJsonParser_destroy(parser);
+}
+
 TEST_CASE("streaming") { testStreaming(json); }
 
+TEST_CASE("reset clears inKey and transient state") {
+  struct State {
+    std::string stringData;
+    std::string keyData;
+  } state;
+  auto c = noopCallbacks();
+  c.on_string_data = +[](void *p, const char *buf, int len, int /*done*/) {
+    ((State *)p)->stringData.append(buf, len);
+  };
+  c.on_key_data = +[](void *p, const char *buf, int len, int /*done*/) {
+    ((State *)p)->keyData.append(buf, len);
+  };
+
+  auto *parser = WeaselJsonParser_create(1024, &c, &state, 0);
+  REQUIRE(parser != nullptr);
+
+  {
+    std::string chunk = "{\"ab";
+    REQUIRE(WeaselJsonParser_parse(parser, chunk.data(), chunk.size()) ==
+            WeaselJson_AGAIN);
+  }
+
+  // Reset mid-key: the next top-level string must be delivered as a string,
+  // not appended to the aborted key.
+  WeaselJsonParser_reset(parser);
+  state.stringData.clear();
+  state.keyData.clear();
+
+  {
+    std::string chunk = "\"hello\"";
+    REQUIRE(WeaselJsonParser_parse(parser, chunk.data(), chunk.size()) ==
+            WeaselJson_AGAIN);
+  }
+  REQUIRE(WeaselJsonParser_parse(parser, nullptr, 0) == WeaselJson_OK);
+
+  CHECK(state.stringData == "hello");
+  CHECK(state.keyData.empty());
+
+  WeaselJsonParser_destroy(parser);
+}
+
 void doTestUnescapingUtf8(std::string const &escaped,
                           std::string const &expected, int stride, int flags) {
   CAPTURE(escaped);

test_python_bindings.py

@@ -0,0 +1,102 @@
+import json
+
+import weaseljson
+
+
+class Recorder(weaseljson.WeaselJsonCallbacksBase):
+    def __init__(self):
+        self.keys = []
+        self.strings = []
+        self.numbers = []
+        self.events = []
+        self._current = bytearray()
+
+    def _flush(self, target, data, done):
+        self._current.extend(data)
+        if done:
+            target.append(bytes(self._current))
+            self._current = bytearray()
+
+    def on_begin_object(self):
+        self.events.append("begin_object")
+
+    def on_end_object(self):
+        self.events.append("end_object")
+
+    def on_begin_array(self):
+        self.events.append("begin_array")
+
+    def on_end_array(self):
+        self.events.append("end_array")
+
+    def on_key_data(self, data, done):
+        self._flush(self.keys, data, done)
+
+    def on_string_data(self, data, done):
+        self._flush(self.strings, data, done)
+
+    def on_number_data(self, data, done):
+        self._flush(self.numbers, data, done)
+
+    def on_true_literal(self):
+        self.events.append("true")
+
+    def on_false_literal(self):
+        self.events.append("false")
+
+    def on_null_literal(self):
+        self.events.append("null")
+
+
+def parse_all(parser, data):
+    for i in range(len(data)):
+        status = parser.parse(data[i : i + 1])
+        if status != weaseljson.WeaselJsonStatus.AGAIN:
+            return status
+    return parser.parse(b"")
+
+
+def test_object_keys_routed_correctly():
+    recorder = Recorder()
+    with weaseljson.WeaselJsonParser(recorder) as parser:
+        status = parse_all(
+            parser, json.dumps({"hello": "world", "foo": "bar"}).encode()
+        )
+
+    assert status == weaseljson.WeaselJsonStatus.OK, status
+    assert recorder.keys == [b"hello", b"foo"], recorder.keys
+    assert recorder.strings == [b"world", b"bar"], recorder.strings
+
+
+def test_mixed_values():
+    recorder = Recorder()
+    with weaseljson.WeaselJsonParser(recorder) as parser:
+        status = parse_all(
+            parser,
+            json.dumps({"answer": 42, "yes": True, "no": False, "nil": None}).encode(),
+        )
+
+    assert status == weaseljson.WeaselJsonStatus.OK, status
+    assert recorder.keys == [b"answer", b"yes", b"no", b"nil"], recorder.keys
+    assert recorder.numbers == [b"42"], recorder.numbers
+    assert recorder.events.count("true") == 1
+    assert recorder.events.count("false") == 1
+    assert recorder.events.count("null") == 1
+
+
+def test_create_rejects_too_small_stack():
+    for stack_size in (-1, 0, 1, 2):
+        try:
+            parser = weaseljson.WeaselJsonParser(Recorder(), stackSize=stack_size)
+        except ValueError:
+            continue
+        # If creation unexpectedly succeeds, close it cleanly and fail the test.
+        parser.close()
+        raise AssertionError(f"expected ValueError for stackSize={stack_size}")
+
+
+if __name__ == "__main__":
+    test_object_keys_routed_correctly()
+    test_mixed_values()
+    test_create_rejects_too_small_stack()
+    print("python bindings ok")

weaseljson.py

@@ -15,6 +15,7 @@ class WeaselJsonCallbacks(ctypes.Structure):
         ("on_begin_object", event_callback),
         ("on_end_object", event_callback),
         ("on_string_data", data_callback),
+        ("on_key_data", data_callback),
         ("on_begin_array", event_callback),
         ("on_end_array", event_callback),
         ("on_number_data", data_callback),
@@ -41,6 +42,9 @@ class WeaselJsonCallbacksBase:
     def on_string_data(self, data, done):
         pass
 
+    def on_key_data(self, data, done):
+        pass
+
     def on_begin_array(self):
         pass
 
@@ -113,12 +117,24 @@ class WeaselJsonParser:
             self.voidp_callbacks,
             0,
         )
+        if self.p is None:
+            raise ValueError(
+                "WeaselJsonParser_create returned NULL; "
+                "check stackSize (must be positive and large enough) "
+                "and available memory"
+            )
+
+    def _check_open(self):
+        if self.p is None:
+            raise RuntimeError("parser has been closed or creation failed")
 
     def parse(self, data: bytes) -> WeaselJsonStatus:
+        self._check_open()
         buf = (ctypes.c_ubyte * len(data)).from_buffer(bytearray(data))
         return self._lib.WeaselJsonParser_parse(self.p, buf, len(data))
 
     def reset(self):
+        self._check_open()
         self._lib.WeaselJsonParser_reset(self.p)
 
     def __enter__(self):
@@ -151,6 +167,12 @@ def on_string_data(p, buf, len, done):
     self.on_string_data(bytes(ctypes.string_at(buf, len)), bool(done))
 
 
+@ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_int, ctypes.c_int)
+def on_key_data(p, buf, len, done):
+    self = ctypes.cast(p, ctypes.POINTER(ctypes.py_object)).contents.value
+    self.on_key_data(bytes(ctypes.string_at(buf, len)), bool(done))
+
+
 @ctypes.CFUNCTYPE(None, ctypes.c_void_p)
 def on_begin_array(p):
     self = ctypes.cast(p, ctypes.POINTER(ctypes.py_object)).contents.value
@@ -191,6 +213,7 @@ c_callbacks = WeaselJsonCallbacks(
     on_begin_object,
     on_end_object,
     on_string_data,
+    on_key_data,
     on_begin_array,
     on_end_array,
     on_number_data,
@@ -206,14 +229,15 @@ class MyCallbacks(WeaselJsonCallbacksBase):
         print(data)
 
 
-with WeaselJsonParser(MyCallbacks()) as parser:
+if __name__ == "__main__":
-    raw = json.dumps({"hello": "world", "foo": 42}).encode()
+    with WeaselJsonParser(MyCallbacks()) as parser:
-    i = 0
+        raw = json.dumps({"hello": "world", "foo": 42}).encode()
-    stride = 1
+        i = 0
-    while True:
+        stride = 1
-        slice = raw[i : i + stride]
+        while True:
-        s = parser.parse(slice)
+            slice = raw[i : i + stride]
-        if s != WeaselJsonStatus.AGAIN:
+            s = parser.parse(slice)
-            break
+            if s != WeaselJsonStatus.AGAIN:
-        i += stride
+                break
-    print(s)
+            i += stride
+        print(s)