diff --git a/.sai.json b/.sai.json index 1365d5cb1..fbaab56bd 100644 --- a/.sai.json +++ b/.sai.json @@ -130,7 +130,7 @@ "platforms": "w10/x86_64-amd/msvc, w10/x86_64-amd/noptmsvc, freertos-linkit/arm32-m4-mt7697-usi/gcc, linux-ubuntu-2004/aarch64-a72-bcm2711-rpi4/gcc, w10/x86_64-amd/mingw32, w10/x86_64-amd/mingw64, netbsd/aarch64BE-bcm2837-a53/gcc, netbsd/x86_64-amd/gcc, w10/x86_64-amd/wmbedtlsmsvc" }, "fault-injection": { - "cmake": "-DLWS_WITH_SYS_FAULT_INJECTION=1 -DLWS_WITH_MINIMAL_EXAMPLES=1", + "cmake": "-DLWS_WITH_SYS_FAULT_INJECTION=1 -DLWS_WITH_MINIMAL_EXAMPLES=1 -DLWS_WITH_CBOR=1", "platforms": "w10/x86_64-amd/msvc" }, "esp32-heltec": { @@ -139,7 +139,7 @@ "platforms": "none, freertos-espidf/xl6-esp32/gcc" }, "esp32-wrover": { - "cmake": "-DLWS_IPV6=0", + "cmake": "-DLWS_IPV6=0 -DLWS_WITH_CBOR=1", "cpack": "esp-wrover-kit", "platforms": "none, freertos-espidf/xl6-esp32/gcc" }, diff --git a/CMakeLists.txt b/CMakeLists.txt index afdd5cac7..d92cd63c8 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -231,6 +231,8 @@ option(LWS_WITHOUT_BUILTIN_SHA1 "Don't build the lws sha-1 (eg, because openssl option(LWS_WITHOUT_DAEMONIZE "Don't build the daemonization api" ON) option(LWS_SSL_SERVER_WITH_ECDH_CERT "Include SSL server use ECDH certificate" OFF) option(LWS_WITH_LEJP "With the Lightweight JSON Parser" ON) +option(LWS_WITH_CBOR "With the Lightweight LECP CBOR Parser" OFF) +option(LWS_WITH_CBOR_FLOAT "Build floating point types if building CBOR LECP" ON) option(LWS_WITH_SQLITE3 "Require SQLITE3 support" OFF) option(LWS_WITH_STRUCT_JSON "Generic struct serialization to and from JSON" OFF) option(LWS_WITH_STRUCT_SQLITE3 "Generic struct serialization to and from SQLITE3" OFF) diff --git a/LICENSE b/LICENSE index 2135e3210..917f8dcf2 100644 --- a/LICENSE +++ b/LICENSE @@ -8,9 +8,10 @@ Original liberal license retained: - lib/misc/sha-1.c - 3-clause BSD license retained, link to original [BSD3] - win32port/zlib - ZLIB license (see zlib.h) [ZLIB] - - lib/tls/mbedtls/wrapper - Apache 2.0 (only built if linked against mbedtls) {APACHE2] + - lib/tls/mbedtls/wrapper - Apache 2.0 (only built if linked against mbedtls) [APACHE2] lib/tls/mbedtls/mbedtls-extensions.c - lib/misc/base64-decode.c - already MIT + - lib/misc/ieeehalfprecision.c - 2-clause BSD license retained [BSD2] Relicensed to MIT: @@ -55,6 +56,31 @@ https://opensource.org/licenses/MIT FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +## BSD2 + +``` + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the distribution + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. +``` ## BSD3 diff --git a/READMEs/README.cbor-lecp.md b/READMEs/README.cbor-lecp.md new file mode 100644 index 000000000..109dc0c8b --- /dev/null +++ b/READMEs/README.cbor-lecp.md @@ -0,0 +1,344 @@ +# RFC8949 CBOR Stream Parsing and Writing + +||| +|---|---|---| +|cmake| `LWS_WITH_CBOR`, `LWS_WITH_CBOR_FLOAT`| +|Header| ./include/libwebsockets/lws-lecp.h| +|api-test| ./minimal-examples/api-tests/api-test-lecp/| +|test app| ./test-apps/test-lecp.c -> libwebsockets-test-lecp| + +LECP is the RFC8949 CBOR stream parsing counterpart to LEJP for JSON. + +## Features + + - Completely immune to input fragmentation, give it any size blocks of CBOR as + they become available; 1 byte, or 100K at a time give identical parsing + results + - Input chunks discarded as they are parsed, whole CBOR never needed in memory + - Nonrecursive, fixed stack usage of a few dozen bytes + - No heap allocations at all, just requires ~500 byte context usually on + caller stack + - Creates callbacks to a user-provided handler as members are parsed out + - No payload size limit, supports huge / endless strings or blobs bigger than + system memory + - Collates utf-8 text and blob payloads into a 250-byte chunk buffer for ease + of access + - Write apis don't use any heap allocations or recursion either + - Write apis use an explicit context with its own lifecycle, and printf style + vaargs including sized blobs, C strings, double, int, unsigned long etc + - Completely immune to output fragmentation, supports huge strings and blobs + into small buffers, api returns to indicates unfinished if it needs to be + called again to continue; 1 byte or 100K output buffer give same results + - Write apis completely fill available buffer and if unfinished, continues + into same or different buffer when called again with same args; no + requirement for subsequent calls to be done sequentially or even from same + function + +## Type limits + +CBOR allows negative integers of up to 64 bits, these do not fit into a `uint64_t`. +LECP has a union for numbers that includes the types `uint64_t` and `int64_t`, +but it does not separately handle negative integers. Only -2^63.. 2^64 -1 can +be handled by the C types, the oversize negative numbers wrap and should be +avoided. + +## Floating point support + +Floats are handled using the IEEE memory format, it means they can be parsed +from the CBOR without needing any floating point support in the build. If +floating point is available, you can also enable `LWS_WITH_CBOR_FLOAT` and +a `float` and `double` types are available in the number item union. Otherwise +these are handled as `ctx->item.u.u32` and `ctx->item.u.u64` union members. + +Half-float (16-bit) is defined in CBOR and always handled as a `uint16_t` +number union member `ctx->item.u.hf`. + +## Callback reasons + +The user callback does not have to handle any callbacks, it only needs to +process the data for the ones it is interested in. + +|Callback reason|CBOR structure|Associated data| +|---|---|---| +|`LECPCB_CONSTRUCTED`|Created the parse context|| +|`LECPCB_DESTRUCTED`|Destroyed the parse context|| +|`LECPCB_COMPLETE`|The parsing completed OK|| +|`LECPCB_FAILED`|The parsing failed|| +|`LECPCB_VAL_TRUE`|boolean true|| +|`LECPCB_VAL_FALSE`|boolean false|| +|`LECPCB_VAL_NULL`|explicit NULL|| +|`LECPCB_VAL_NUM_INT`|signed integer|`ctx->item.u.i64`| +|`LECPCB_VAL_STR_START`|A UTF-8 string is starting|| +|`LECPCB_VAL_STR_CHUNK`|The next string chunk|`ctx->npos` bytes in `ctx->buf`| +|`LECPCB_VAL_STR_END`|The last string chunk|`ctx->npos` bytes in `ctx->buf`| +|`LECPCB_ARRAY_START`|An array is starting|| +|`LECPCB_ARRAY_END`|An array has ended|| +|`LECPCB_OBJECT_START`|A CBOR map is starting|| +|`LECPCB_OBJECT_END`|A CBOR map has ended|| +|`LECPCB_TAG_START`|The following data has a tag index|`ctx->item.u.u64`| +|`LECPCB_TAG_END`|The end of the data referenced by the last tag|| +|`LECPCB_VAL_NUM_UINT`|Unsigned integer|`ctx->item.u.u64`| +|`LECPCB_VAL_UNDEFINED`|CBOR undefined|| +|`LECPCB_VAL_FLOAT16`|half-float available as host-endian `uint16_t`|`ctx->item.u.hf`| +|`LECPCB_VAL_FLOAT32`|`float` (`uint32_t` if no float support) available|`ctx->item.u.f`| +|`LECPCB_VAL_FLOAT64`|`double` (`uint64_t` if no float support) available|`ctx->item.u.d`| +|`LECPCB_VAL_SIMPLE`|CBOR simple|`ctx->item.u.u64`| +|`LECPCB_VAL_BLOB_START`|A binary blob is starting|| +|`LECPCB_VAL_BLOB_CHUNK`|The next blob chunk|`ctx->npos` bytes in `ctx->buf`| +|`LECPCB_VAL_BLOB_END`|The last blob chunk|`ctx->npos` bytes in `ctx->buf`| +|`LECPCB_ARRAY_ITEM_START`|A logical item in an array is starting| +|`LCEPDB_ARRAY_ITEM_END`|A logical item in an array has completed| + +## CBOR indeterminite lengths + +Indeterminite lengths are supported, but are concealed in the parser as far as +possible, the CBOR lengths or its indeterminacy are not exposed in the callback +interface at all, just chunks of data that may be the start, the middle, or the +end. + +## Handling CBOR UTF-8 strings and blobs + +When a string or blob is parsed, an advisory callback of `LECPCB_VAL_STR_START` or +`LECPCB_VAL_BLOB_START` occurs first. The `_STR_` callbacks indicate the +content is a CBOR UTF-8 string, `_BLOB_` indicates it is binary data. + +Strings or blobs may have indeterminite length, but if so, they are composed +of logical chunks which must have known lengths. When the `_START` callback +occurs, the logical length either of the whole string, or of the sub-chunk if +indeterminite length, can be found in `ctx->item.u.u64`. + +Payload is collated into `ctx->buf[]`, the valid length is in `ctx->npos`. + +For short strings or blobs where the length is known, the whole payload is +delivered in a single `LECPCB_VAL_STR_END` or `LECPCB_VAL_BLOB_END` callback. + +For payloads larger than the size of `ctx->buf[]`, `LECPCB_VAL_STR_CHUNK` or +`LECPCB_VAL_BLOB_CHUNK` callbacks occur delivering each sequential bufferload. +If the CBOR indicates the total length, the last chunk is delievered in a +`LECPCB_VAL_STR_END` or `LECPCB_VAL_BLOB_END`. + +If the CBOR indicates the string end after the chunk, a zero-length `..._END` +callback is provided. + +## Handling CBOR tags + +CBOR tags are exposed as `LECPCB_TAG_START` and `LECPCB_TAG_END` pairs, at +the `_START` callback the tag index is available in `ctx->item.u.u64`. + +## CBOR maps + +You can check if you are on the "key" part of a map "key:value" pair using the +helper api `lecp_parse_map_is_key(ctx)`. + +## Parsing paths + +LECP maintains a "parsing path" in `ctx->path` that represents the context of +the callback events. As a convenience, at LECP context creation time, you can +pass in an array of path strings you want to match on, and have any match +checkable in the callback using `ctx->path_match`, it's 0 if no active match, +or the match index from your path array starting from 1 for the first entry. + +|CBOR element|Representation in path| +|---|---| +|CBOR Array|`[]`| +|CBOR Map|`.`| +|CBOR Map entry key string|`keystring`| + +## Accessing raw CBOR subtrees + +Some CBOR usages like COSE require access to selected raw CBOR from the input +stream. `lecp_parse_report_raw(ctx, on)` lets you turn on and off buffering of +raw CBOR and reporting it in the parse callback with `LECPCB_LITERAL_CBOR` +callbacks. The callbacks mean the temp buffer `ctx->cbor[]` has `ctx->cbor_pos` +bytes of raw CBOR available in it. Callbacks are triggered when the buffer +fills, or reporting is turned off and the buffer has something in it. + +By turning the reporting on and off according to the outer CBOR parsing state, +it's possible to get exactly the raw CBOR subtree that's needed. + +Capturing and reporting the raw CBOR does not change that the same CBOR is being +passed to the parser as usual as well. + +## Comparison with LEJP (JSON parser) + +LECP is based on the same principles as LEJP and shares most of the callbacks. +The major differences: + + - LEJP value callbacks all appear in `ctx->buf[]`, ie, floating-point is + provided to the callback in ascii form like `"1.0"`. CBOR provides a more + strict typing system, and the different type values are provided either in + `ctx->buf[]` for blobs or utf-8 text strtings, or the `item.u` union for + converted types, with additional callback reasons specific to each type. + + - CBOR "maps" use `_OBJECT_START` and `_END` parsing callbacks around the + key / value pairs. LEJP has a special callback type `PAIR_NAME` for the + key string / integer, but in LECP these are provided as generic callbacks + dependent on type, ie, generic string callbacks or integer ones, and the + value part is represented according to whatever comes. + + +# Writing CBOR + +CBOR is written into a `lws_lec_pctx_t` object that has been initialized to +point to an output buffer of a specified size, using printf type formatting. + +Output is paused if the buffer fills, and the write api may be called again +later with the same context object, to resume emitting to the same or different +buffer. + +This allows bufferloads of encoded CBOR to be produced on demand, it's designed +to fit usage in WRITEABLE callbacks and Secure Streams tx() callbacks where the +buffer size for one packet is already fixed. + +CBOR array and map lengths are deduced from the format string, as is whether to +use indeterminite length formatting or not. For indeterminite text or binary +strings, a container of < > + +|Format|Arg(s)|Meaning| +|---|---|---| +|`123`||unsigned literal number| +|`-123`||signed literal number| +|`%u`|`unsigned int`|number| +|`%lu`|`unsigned long int`|number| +|`%llu`|`unsigned long long int`|number| +|`%d`|`signed int`|number| +|`%ld`|`signed long int`|number| +|`%lld`|`signed long long int`|number| +|`%f`|`double`|floating point number| +|`123(...)`||literal tag and scope| +|`%t(...)`|`unsigned int`|tag and scope| +|`%lt(...)`|`unsigned long int`|tag and scope| +|`%llt(...)`|`unsigned long long int`|tag and scope| +|`[...]`||Array (fixed len if `]` in same format string)| +|`{...}`||Map (fixed len if `}` in same format string)| +|``||Container for indeterminite text string frags| +|``||Container for indeterminite binary string frags| +|`'string'`||Literal text of known length| +|`%s`|`const char *`|NUL-terminated string| +|`%.*s`|`int`, `const char *`|length-specified string| +|`%.*b`|`int`, `const uint8_t *`|length-specified binary| +|`:`||separator between Map items (a:b)| +|`,`||separator between Map pairs or array items| + +Backslash is used as an escape in `'...'` literal strings, so `'\\'` represents +a string consisting of a single backslash, and `'\''` a string consisting of a +single single-quote. + +For integers, various natural C types are available, but in all cases, the +number is represented in CBOR using the smallest valid way based on its value, +the long or long-long modifiers just apply to the expected C type in the args. + +For floats, the C argument is always expected to be a `double` type following +C type promotion, but again it is represented in CBOR using the smallest valid +way based on value, half-floats are used for NaN / Infinity and where possible +for values like 0.0 and -1.0. + +## Examples + +### Literal ints + +``` + uint8_t buf[128]; + lws_lec_pctx_t cbw; + + lws_lec_init(&cbw, buf, sizeof(buf)); + lws_lec_printf(ctx, "-1"); +``` +||| +|---|---| +|Return| `LWS_LECPCTX_RET_FINISHED`| +|`ctx->used`|1| +|`buf[]`|20| + +### Dynamic ints + +``` + uint8_t buf[128]; + lws_lec_pctx_t cbw; + int n = -1; /* could be long */ + + lws_lec_init(&cbw, buf, sizeof(buf)); + lws_lec_printf(ctx, "%d", n); /* use %ld for long */ +``` +||| +|---|---| +|Return| `LWS_LECPCTX_RET_FINISHED`| +|`ctx->used`|1| +|`buf[]`|20| + +### Maps, arrays and dynamic ints + +``` + ... + int args[3] = { 1, 2, 3 }; + + lws_lec_printf(ctx, "{'a':%d,'b':[%d,%d]}", args[0], args[1], args[2]); +``` + +||| +|---|---| +|Return| `LWS_LECPCTX_RET_FINISHED`| +|`ctx->used`|9| +|`buf[]`|A2 61 61 01 61 62 82 02 03| + +### String longer than the buffer + +Using `%s` and the same string as an arg gives same results + +``` + uint8_t buf[16]; + lws_lec_pctx_t cbw; + + lws_lec_init(&cbw, buf, sizeof(buf)); + lws_lec_printf(ctx, "'A literal string > one buf'"); + /* not required to be in same function context or same buf, + * but the string must remain the same */ + lws_lec_setbuf(&cbw, buf, sizeof(buf)); + lws_lec_printf(ctx, "'A literal string > one buf'"); +``` + +First call + +||| +|---|---| +|Return| `LWS_LECPCTX_RET_AGAIN`| +|`ctx->used`|16| +|`buf[]`|78 1A 41 20 6C 69 74 65 72 61 6C 20 73 74 72 69| + +Second call + +||| +|---|---| +|Return| `LWS_LECPCTX_RET_FINISHED`| +|`ctx->used`|12| +|`buf[]`|6E 67 20 3E 20 6F 6E 65 20 62 75 66| + +### Binary blob longer than the buffer + +``` + uint8_t buf[16], blob[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18 }; + lws_lec_pctx_t cbw; + + lws_lec_init(&cbw, buf, sizeof(buf)); + lws_lec_printf(ctx, "%.*b", (int)sizeof(blob), blob); + /* not required to be in same function context or same buf, + * but the length and blob must remain the same */ + lws_lec_setbuf(&cbw, buf, sizeof(buf)); + lws_lec_printf(ctx, "%.*b", (int)sizeof(blob), blob); +``` + +First call + +||| +|---|---| +|Return| `LWS_LECPCTX_RET_AGAIN`| +|`ctx->used`|16| +|`buf[]`|52 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F| + +Second call + +||| +|---|---| +|Return| `LWS_LECPCTX_RET_FINISHED`| +|`ctx->used`|3| +|`buf[]`|10 11 12| diff --git a/READMEs/README.json-lejp.md b/READMEs/README.json-lejp.md new file mode 100644 index 000000000..1471c17d2 --- /dev/null +++ b/READMEs/README.json-lejp.md @@ -0,0 +1,107 @@ +# LEJP JSON Stream Parser + +||| +|---|---|---| +|cmake| `LWS_WITH_LEJP`| +|Header| ./include/libwebsockets/lws-lejp.h| +|api-test| ./minimal-examples/api-tests/api-test-lejp/| +|test app| ./test-apps/test-lejp.c -> libwebsockets-test-lejp| + +LEJP is a lightweight JSON stream parser. + +The features are: + + - completely immune to input fragmentation, give it any size blocks of JSON as + they become available, 1 byte, or 100K at a time give identical parsing + results + - input chunks discarded as they are parsed, whole JSON never needed in memory + - nonrecursive, fixed stack usage of a few dozen bytes + - no heap allocations at all, just requires ~500 byte context usually on + caller stack + - creates callbacks to a user-provided handler as members are parsed out + - no payload size limit, supports huge / endless strings bigger than + system memory + - collates utf-8 text payloads into a 250-byte chunk buffer in the json parser + context object for ease of access + +## Type handling + +LEJP leaves all numbers in text form, they are signalled in different callbacks +according to int or float, but delivered as text strings in the first +`ctx->npos` chars of `ctx->buf`. + +For numeric types, you would typically use `atoi()` or similar to recover the +number as a host type. + +## Callback reasons + +The user callback does not have to handle any callbacks, it only needs to +process the data for the ones it is interested in. + +|Callback reason|JSON structure|Associated data| +|---|---|---| +|`LEJPCB_CONSTRUCTED`|Created the parse context|| +|`LEJPCB_DESTRUCTED`|Destroyed the parse context|| +|`LEJPCB_COMPLETE`|The parsing completed OK|| +|`LEJPCB_FAILED`|The parsing failed|| +|`LEJPCB_VAL_TRUE`|boolean true|| +|`LEJPCB_VAL_FALSE`|boolean false|| +|`LEJPCB_VAL_NULL`|explicit NULL|| +|`LEJPCB_PAIR_NAME`|The name part of a JSON `key: value` map pair|`ctx->buf`| +|`LEJPCB_VAL_STR_START`|A UTF-8 string is starting|| +|`LEJPCB_VAL_STR_CHUNK`|The next string chunk|`ctx->npos` bytes in `ctx->buf`| +|`LEJPCB_VAL_STR_END`|The last string chunk|`ctx->npos` bytes in `ctx->buf`| +|`LEJPCB_ARRAY_START`|An array is starting|| +|`LEJPCB_ARRAY_END`|An array has ended|| +|`LEJPCB_OBJECT_START`|A JSON object is starting|| +|`LEJPCB_OBJECT_END`|A JSON object has ended|| + +## Handling JSON UTF-8 strings + +When a string is parsed, an advisory callback of `LECPCB_VAL_STR_START` occurs +first. No payload is delivered with the START callback. + +Payload is collated into `ctx->buf[]`, the valid length is in `ctx->npos`. + +For short strings or blobs where the length is known, the whole payload is +delivered in a single `LECPCB_VAL_STR_END` callback. + +For payloads larger than the size of `ctx->buf[]`, `LECPCB_VAL_STR_CHUNK` +callbacks occur delivering each sequential bufferload. + +The last chunk (which may be zero length) is delievered by `LECPCB_VAL_STR_END`. + +## Parsing paths + +LEJP maintains a "parsing path" in `ctx->path` that represents the context of +the callback events. As a convenience, at LEJP context creation time, you can +pass in an array of path strings you want to match on, and have any match +checkable in the callback using `ctx->path_match`, it's 0 if no active match, +or the match index from your path array starting from 1 for the first entry. + +|CBOR element|Representation in path| +|---|---| +|JSON Array|`[]`| +|JSON Map|`.`| +|JSON Map entry key string|`keystring`| + + + +## Comparison with LECP (CBOR parser) + +LECP is based on the same principles as LEJP and shares most of the callbacks. +The major differences: + + - LEJP value callbacks all appear in `ctx->buf[]`, ie, floating-point is + provided to the callback in ascii form like `"1.0"`. CBOR provides a more + strict typing system, and the different type values are provided either in + `ctx->buf[]` for blobs or utf-8 text strtings, or the `item.u` union for + converted types, with additional callback reasons specific to each type. + + - CBOR "maps" use `_OBJECT_START` and `_END` parsing callbacks around the + key / value pairs. LEJP has a special callback type `PAIR_NAME` for the + key string / integer, but in LECP these are provided as generic callbacks + dependent on type, ie, generic string callbacks or integer ones, and the + value part is represented according to whatever comes. + + diff --git a/cmake/lws_config.h.in b/cmake/lws_config.h.in index b64f29e35..a5d3d9dd1 100644 --- a/cmake/lws_config.h.in +++ b/cmake/lws_config.h.in @@ -167,6 +167,8 @@ #cmakedefine LWS_WITH_HTTP_UNCOMMON_HEADERS #cmakedefine LWS_WITH_IPV6 #cmakedefine LWS_WITH_JOSE +#cmakedefine LWS_WITH_CBOR +#cmakedefine LWS_WITH_CBOR_FLOAT #cmakedefine LWS_WITH_LEJP #cmakedefine LWS_WITH_LIBEV #cmakedefine LWS_WITH_LIBEVENT diff --git a/include/libwebsockets.h b/include/libwebsockets.h index 306fd9016..37aec68da 100644 --- a/include/libwebsockets.h +++ b/include/libwebsockets.h @@ -617,6 +617,7 @@ struct lws; #include #endif #include +#include #include #include #include diff --git a/include/libwebsockets/lws-lecp.h b/include/libwebsockets/lws-lecp.h new file mode 100644 index 000000000..04de86add --- /dev/null +++ b/include/libwebsockets/lws-lecp.h @@ -0,0 +1,542 @@ +/* + * libwebsockets - small server side websockets and web server implementation + * + * Copyright (C) 2010 - 2021 Andy Green + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +/** \defgroup lecp CBOR parser + * ##CBOR parsing related functions + * \ingroup lwsapi + * + * LECP is an extremely lightweight CBOR stream parser included in lws. It + * is aligned in approach with the LEJP JSON stream parser, with some additional + * things needed for CBOR. + */ +//@{ + +#ifndef LECP_MAX_PARSING_STACK_DEPTH +#define LECP_MAX_PARSING_STACK_DEPTH 5 +#endif +#ifndef LECP_MAX_DEPTH +#define LECP_MAX_DEPTH 12 +#endif +#ifndef LECP_MAX_INDEX_DEPTH +#define LECP_MAX_INDEX_DEPTH 8 +#endif +#ifndef LECP_MAX_PATH +#define LECP_MAX_PATH 128 +#endif +#ifndef LECP_STRING_CHUNK +/* must be >= 30 to assemble floats */ +#define LECP_STRING_CHUNK 254 +#endif + +#define LECP_FLAG_CB_IS_VALUE 64 + +/* + * CBOR initial byte 3 x MSB bits are these + */ + +enum { + LWS_CBOR_MAJTYP_UINT = 0 << 5, + LWS_CBOR_MAJTYP_INT_NEG = 1 << 5, + LWS_CBOR_MAJTYP_BSTR = 2 << 5, + LWS_CBOR_MAJTYP_TSTR = 3 << 5, + LWS_CBOR_MAJTYP_ARRAY = 4 << 5, + LWS_CBOR_MAJTYP_MAP = 5 << 5, + LWS_CBOR_MAJTYP_TAG = 6 << 5, + LWS_CBOR_MAJTYP_FLOAT = 7 << 5, /* also BREAK */ + + LWS_CBOR_MAJTYP_MASK = 7 << 5, + + /* + * For the low 5 bits of the opcode, 0-23 are literals, unless it's + * FLOAT. + * + * 24 = 1 byte; 25 = 2..., 26 = 4... and 27 = 8 bytes following literal. + */ + LWS_CBOR_1 = 24, + LWS_CBOR_2 = 25, + LWS_CBOR_4 = 26, + LWS_CBOR_8 = 27, + + LWS_CBOR_RESERVED = 28, + + LWS_CBOR_SUBMASK = 0x1f, + + /* + * Major type 7 discriminators in low 5 bits + * 0 - 23 is SIMPLE implicit value (like, eg, LWS_CBOR_SWK_TRUE) + */ + LWS_CBOR_SWK_FALSE = 20, + LWS_CBOR_SWK_TRUE = 21, + LWS_CBOR_SWK_NULL = 22, + LWS_CBOR_SWK_UNDEFINED = 23, + + LWS_CBOR_M7_SUBTYP_SIMPLE_X8 = 24, /* simple with additional byte */ + LWS_CBOR_M7_SUBTYP_FLOAT16 = 25, + LWS_CBOR_M7_SUBTYP_FLOAT32 = 26, + LWS_CBOR_M7_SUBTYP_FLOAT64 = 27, + LWS_CBOR_M7_BREAK = 31, + +/* 28, 29, 30 are illegal. + * + * 31 is illegal for UINT, INT_NEG, and TAG; + * for BSTR, TSTR, ARRAY and MAP it means "indefinite length", ie, + * it's made up of an endless amount of determinite-length + * fragments terminated with a BREAK (FLOAT | 31) instead of the + * next determinite-length fragment. The second framing level + * means no need for escapes for BREAK in the data. + */ + + LWS_CBOR_INDETERMINITE = 31, + +/* + * Well-known tags + */ + + LWS_CBOR_WKTAG_DATETIME_STD = 0, /* text */ + LWS_CBOR_WKTAG_DATETIME_EPOCH = 1, /* int or float */ + LWS_CBOR_WKTAG_BIGNUM_UNSIGNED = 2, /* byte string */ + LWS_CBOR_WKTAG_BIGNUM_NEGATIVE = 3, /* byte string */ + LWS_CBOR_WKTAG_DECIMAL_FRAC = 4, /* array */ + LWS_CBOR_WKTAG_BIGFLOAT = 5, /* array */ + + LWS_CBOR_WKTAG_COSE_ENC0 = 16, + LWS_CBOR_WKTAG_COSE_MAC0 = 17, + LWS_CBOR_WKTAG_COSE_SIGN1 = 18, + + LWS_CBOR_WKTAG_TO_B64U = 21, /* any */ + LWS_CBOR_WKTAG_TO_B64 = 22, /* any */ + LWS_CBOR_WKTAG_TO_B16 = 23, /* any */ + LWS_CBOR_WKTAG_CBOR = 24, /* byte string */ + + LWS_CBOR_WKTAG_URI = 32, /* text string */ + LWS_CBOR_WKTAG_B64U = 33, /* text string */ + LWS_CBOR_WKTAG_B64 = 34, /* text string */ + LWS_CBOR_WKTAG_MIME = 36, /* text string */ + + LWS_CBOR_WKTAG_COSE_ENC = 96, + LWS_CBOR_WKTAG_COSE_MAC = 97, + LWS_CBOR_WKTAG_COSE_SIGN = 98, + + LWS_CBOR_WKTAG_SELFDESCCBOR = 55799 +}; + +enum lecp_callbacks { + LECPCB_CONSTRUCTED = 0, + LECPCB_DESTRUCTED = 1, + + LECPCB_COMPLETE = 3, + LECPCB_FAILED = 4, + + LECPCB_PAIR_NAME = 5, + + LECPCB_VAL_TRUE = LECP_FLAG_CB_IS_VALUE | 6, + LECPCB_VAL_FALSE = LECP_FLAG_CB_IS_VALUE | 7, + LECPCB_VAL_NULL = LECP_FLAG_CB_IS_VALUE | 8, + LECPCB_VAL_NUM_INT = LECP_FLAG_CB_IS_VALUE | 9, + LECPCB_VAL_RESERVED = LECP_FLAG_CB_IS_VALUE | 10, + LECPCB_VAL_STR_START = 11, /* notice handle separately */ + LECPCB_VAL_STR_CHUNK = LECP_FLAG_CB_IS_VALUE | 12, + LECPCB_VAL_STR_END = LECP_FLAG_CB_IS_VALUE | 13, + + LECPCB_ARRAY_START = 14, + LECPCB_ARRAY_END = 15, + + LECPCB_OBJECT_START = 16, + LECPCB_OBJECT_END = 17, + + LECPCB_TAG_START = 18, + LECPCB_TAG_END = 19, + + LECPCB_VAL_NUM_UINT = LECP_FLAG_CB_IS_VALUE | 20, + LECPCB_VAL_UNDEFINED = LECP_FLAG_CB_IS_VALUE | 21, + LECPCB_VAL_FLOAT16 = LECP_FLAG_CB_IS_VALUE | 22, + LECPCB_VAL_FLOAT32 = LECP_FLAG_CB_IS_VALUE | 23, + LECPCB_VAL_FLOAT64 = LECP_FLAG_CB_IS_VALUE | 24, + + LECPCB_VAL_SIMPLE = LECP_FLAG_CB_IS_VALUE | 25, + + LECPCB_VAL_BLOB_START = 26, /* notice handle separately */ + LECPCB_VAL_BLOB_CHUNK = LECP_FLAG_CB_IS_VALUE | 27, + LECPCB_VAL_BLOB_END = LECP_FLAG_CB_IS_VALUE | 28, + + LECPCB_ARRAY_ITEM_START = 29, + LECPCB_ARRAY_ITEM_END = 30, + + LECPCB_LITERAL_CBOR = 31, +}; + +enum lecp_reasons { + LECP_CONTINUE = -1, + LECP_REJECT_BAD_CODING = -2, + LECP_REJECT_UNKNOWN = -3, + LECP_REJECT_CALLBACK = -4, + LECP_STACK_OVERFLOW = -5, +}; + + +struct lecp_item { + union { + uint64_t u64; + int64_t i64; + + uint64_t u32; + + uint16_t hf; +#if defined(LWS_WITH_CBOR_FLOAT) + float f; + double d; +#else + uint32_t f; + uint64_t d; +#endif + } u; + uint8_t opcode; +}; + +struct lecp_ctx; +typedef signed char (*lecp_callback)(struct lecp_ctx *ctx, char reason); + +struct _lecp_stack { + char s; /* lejp_state stack*/ + uint8_t p; /* path length */ + char i; /* index array length */ + char indet; /* indeterminite */ + char intermediate; /* in middle of string */ + + char pop_iss; + uint64_t tag; + uint64_t collect_rem; + uint32_t ordinal; + uint8_t opcode; + uint8_t send_new_array_item; + uint8_t barrier; +}; + +struct _lecp_parsing_stack { + void *user; /* private to the stack level */ + lecp_callback cb; + const char * const *paths; + uint8_t count_paths; + uint8_t ppos; + uint8_t path_match; +}; + +struct lecp_ctx { + + /* sorted by type for most compact alignment + * + * pointers + */ + void *user; + uint8_t *collect_tgt; + + /* arrays */ + + struct _lecp_parsing_stack pst[LECP_MAX_PARSING_STACK_DEPTH]; + struct _lecp_stack st[LECP_MAX_DEPTH]; + uint16_t i[LECP_MAX_INDEX_DEPTH]; /* index array */ + uint16_t wild[LECP_MAX_INDEX_DEPTH]; /* index array */ + char path[LECP_MAX_PATH]; + uint8_t cbor[64]; /* literal cbor capture */ + + struct lecp_item item; + + + /* size_t */ + + size_t path_stride; /* 0 means default ptr size, else + * stride... allows paths to be + * provided composed inside a + * larger user struct instead of a + * duplicated array */ + size_t used_in; /* bytes of input consumed */ + + /* short */ + + uint16_t uni; + + /* char */ + + uint8_t npos; + uint8_t dcount; + uint8_t f; + uint8_t sp; /* stack head */ + uint8_t ipos; /* index stack depth */ + uint8_t count_paths; + uint8_t path_match; + uint8_t path_match_len; + uint8_t wildcount; + uint8_t pst_sp; /* parsing stack head */ + uint8_t outer_array; + uint8_t cbor_pos; + uint8_t literal_cbor_report; + char present; /* temp for cb reason to use */ + + uint8_t be; /* big endian */ + + /* at end so we can memset the rest of it */ + + char buf[LECP_STRING_CHUNK + 1]; +}; + +struct lws_lec_pctx; +typedef struct lws_lec_pctx lws_lec_pctx_t; + +enum lws_lec_pctx_ret { + LWS_LECPCTX_RET_FINISHED = 0, + LWS_LECPCTX_RET_AGAIN, /* call again to continue writing buffer */ + LWS_LECPCTX_RET_FAIL /* something broken, eg, format string */ +}; + +enum cbp_state { + CBPS_IDLE, + CBPS_PC1, + CBPS_PC2, + CBPS_PC3, + + CBPS_STRING_BODY, + + CBPS_NUM_LIT, + + CBPS_STRING_LIT, + + CBPS_CONTYPE, +}; + +typedef struct lws_lec_pctx { + uint8_t stack[16]; + uint8_t vaa[16]; + uint8_t indet[16]; + uint8_t scratch[24]; + uint8_t *start; /* the beginning of the out buf */ + uint8_t *buf; /* cur pos in output buf */ + uint8_t *end; /* the end of the output buf */ + + const uint8_t *ongoing_src; + uint64_t ongoing_len; + uint64_t ongoing_done; + + struct lecp_item item; + + size_t used; /* number of bytes valid from start */ + + int opaque[4]; /* ignored by lws, caller may use */ + + enum cbp_state state; + unsigned int fmt_pos; + uint8_t sp; + uint8_t scratch_len; + uint8_t escflag; + uint8_t _long; + uint8_t vaa_pos; + uint8_t dotstar; +} lws_lec_pctx_t; + +LWS_VISIBLE LWS_EXTERN void +lws_lec_int(lws_lec_pctx_t *ctx, uint8_t opcode, uint8_t indet, uint64_t num); + +LWS_VISIBLE LWS_EXTERN int +lws_lec_scratch(lws_lec_pctx_t *ctx); + +/* + * lws_lec_init() - prepare a cbor writing context + * + * \param ctx: the cbor writing context to prepare + * \param buf: the output buffer start + * \param len: the amount of the output buffer we can use + * + * Prepares a cbor writing context so that les_lec_printf can be used to + * write into it. + */ +LWS_VISIBLE LWS_EXTERN void +lws_lec_init(lws_lec_pctx_t *ctx, uint8_t *buf, size_t len); + +/* + * lws_lec_setbuf() - update the output buffer for an initialized cbor writing ctx + * + * \param ctx: the cbor writing context to prepare + * \param buf: the output buffer start + * \param len: the amount of the output buffer we can use + * + * Leaves the cbor writing context state as it is, but resets the output buffer + * it writes into as given in \p buf and \p len + */ +LWS_VISIBLE LWS_EXTERN void +lws_lec_setbuf(lws_lec_pctx_t *ctx, uint8_t *buf, size_t len); + +/* + * lws_lec_vsprintf() - write into a cbor writing context + * + * \param ctx: the cbor writing context to prepare + * \param format: a printf style argument map + * \param args: the va args + * + * CBOR-aware vsprintf which pauses output when it fills the output buffer. You + * can call it again with the same args and same lws_lex_pctx to resume filling + * + * Returns either LWS_LECPCTX_RET_FINISHED if we have nothing left over that we + * want to put in the buffer, or LWS_LECPCTX_RET_AGAIN if the function should + * be called again with the same arguments (perhaps into a different output + * buffer) to continue emitting output from where it left off. + * + * If LWS_LECPCTX_RET_AGAIN is returned, lws_lec_setbuf() must be used on the + * context to reset or change the output buffer before calling again. + * + * The number of bytes placed in the output buffer is available in ctx->used. + * + * \p format is a printf-type format string that is specialized for CBOR + * generation. It understands the following specifiers + * + * |`123`||unsigned literal number| + * |`-123`||signed literal number| + * |`%u`|`unsigned int`|number| + * |`%lu`|`unsigned long int`|number| + * |`%llu`|`unsigned long long int`|number| + * |`%d`|`signed int`|number| + * |`%ld`|`signed long int`|number| + * |`%lld`|`signed long long int`|number| + * |`%f`|`double`|floating point number| + * |`123(...)`||literal tag and scope| + * |`%t(...)`|`unsigned int`|tag and scope| + * |`%lt(...)`|`unsigned long int`|tag and scope| + * |`%llt(...)`|`unsigned long long int`|tag and scope| + * |`[...]`||Array (fixed len if `]` in same format string)| + * |`{...}`||Map (fixed len if `}` in same format string)| + * |``||Container for indeterminite text string frags| + * |``||Container for indeterminite binary string frags| + * |`'string'`||Literal text of known length| + * |`%s`|`const char *`|NUL-terminated string| + * |`%.*s`|`int`, `const char *`|length-specified string| + * |`%.*b`|`int`, `const uint8_t *`|length-specified binary| + * |`:`||separator between Map items (a:b)| + * |`,`||separator between Map pairs or array items| + * + * See READMEs/README.cbor-lecp.md for more details. + */ +LWS_VISIBLE LWS_EXTERN enum lws_lec_pctx_ret +lws_lec_vsprintf(lws_lec_pctx_t *ctx, const char *format, va_list args); + +/* + * lws_lec_printf() - write into a cbor writing context + * + * \param ctx: the cbor writing context to prepare + * \param format: a printf style argument map + * \param ...: format args + * + * See lws_lec_vsprintf() for format details. This is the most common way + * to format the CBOR output. + * + * See READMEs/README.cbor-lecp.md for more details. + */ +LWS_VISIBLE LWS_EXTERN enum lws_lec_pctx_ret +lws_lec_printf(lws_lec_pctx_t *ctx, const char *format, ...); + +/** + * lecp_construct() - Construct an LECP parser context + * + * \param ctx: the parser context object to be initialized + * \param cb: the user callback to receive the parsing events + * \param user: an opaque user pointer available at \p cb + * \param paths: an optional array of parsing paths + * \param paths_count: how many paths in \p paths + * + * Prepares an LECP parser context for parsing. + */ +LWS_VISIBLE LWS_EXTERN void +lecp_construct(struct lecp_ctx *ctx, lecp_callback cb, void *user, + const char * const *paths, unsigned char paths_count); + +/** + * lecp_destruct() - Destroys an LECP parser context + * + * \param ctx: the parser context object to be destroyed + */ +LWS_VISIBLE LWS_EXTERN void +lecp_destruct(struct lecp_ctx *ctx); + +/** + * lecp_parse() - parses a chunk of input CBOR + * + * \p ctx: the parsing context + * \p cbor: the start of the chunk of CBOR + * \p len: the number of bytes of CBOR available at \p cbor + * + * Returns LECP_CONTINUE if more input needed, one of enum lecp_reasons for a + * fatal error, else 0 for successful parsing completion. + * + * On success or _CONTINUE, ctx->used_in is set to the number of input bytes + * consumed. + */ +LWS_VISIBLE LWS_EXTERN int +lecp_parse(struct lecp_ctx *ctx, const uint8_t *cbor, size_t len); + +LWS_VISIBLE LWS_EXTERN void +lecp_change_callback(struct lecp_ctx *ctx, lecp_callback cb); + +LWS_VISIBLE LWS_EXTERN const char * +lecp_error_to_string(int e); + +/** + * lecp_parse_report_raw() - turn cbor raw reporting on and off + * + * \param ctx: the lecp context + * \param on: 0 to disable (defaults disabled), 1 to enable + * + * For cose_sign, it needs access to raw cbor subtrees for the hash input. + * This api causes LECPCB_LITERAL_CBOR parse callbacks when there are + * ctx->cbor_pos bytes of raw cbor available in ctx->cbor[]. the callbacks + * occur when the ctx->cbor[] buffer fills or if it holds anything when this + * spi is used to stop the reports. + * + * The same CBOR that is being captured continues to be passed for parsing. + */ +LWS_VISIBLE LWS_EXTERN void +lecp_parse_report_raw(struct lecp_ctx *ctx, int on); + +/** + * lecp_parse_map_is_key() - return nonzero if we're in a map and this is a key + * + * \param ctx: the lwcp context + * + * Checks if the current value is a key in a map, ie, that you are on a "key" in + * a list of "{key: value}" pairs. Zero means you're either not in a map or not + * on the key part, and nonzero means you are in a map and on a key part. + */ +LWS_VISIBLE LWS_EXTERN int +lecp_parse_map_is_key(struct lecp_ctx *ctx); + +LWS_VISIBLE LWS_EXTERN int +lecp_parse_subtree(struct lecp_ctx *ctx, const uint8_t *in, size_t len); + +/* + * Helpers for half-float + */ + +LWS_VISIBLE LWS_EXTERN void +lws_singles2halfp(uint16_t *hp, uint32_t x); + +LWS_VISIBLE LWS_EXTERN void +lws_halfp2singles(uint32_t *xp, uint16_t h); + +//@} diff --git a/include/libwebsockets/lws-lejp.h b/include/libwebsockets/lws-lejp.h index 6ea6d3dc2..f9f50270d 100644 --- a/include/libwebsockets/lws-lejp.h +++ b/include/libwebsockets/lws-lejp.h @@ -193,26 +193,26 @@ typedef signed char (*lejp_callback)(struct lejp_ctx *ctx, char reason); #endif enum num_flags { - LEJP_SEEN_MINUS = (1 << 0), - LEJP_SEEN_POINT = (1 << 1), - LEJP_SEEN_POST_POINT = (1 << 2), - LEJP_SEEN_EXP = (1 << 3) + LEJP_SEEN_MINUS = (1 << 0), + LEJP_SEEN_POINT = (1 << 1), + LEJP_SEEN_POST_POINT = (1 << 2), + LEJP_SEEN_EXP = (1 << 3) }; struct _lejp_stack { - char s; /* lejp_state stack*/ - char p; /* path length */ - char i; /* index array length */ - char b; /* user bitfield */ + char s; /* lejp_state stack*/ + char p; /* path length */ + char i; /* index array length */ + char b; /* user bitfield */ }; struct _lejp_parsing_stack { - void *user; /* private to the stack level */ - signed char (*callback)(struct lejp_ctx *ctx, char reason); - const char * const *paths; - uint8_t count_paths; - uint8_t ppos; - uint8_t path_match; + void *user; /* private to the stack level */ + signed char (*callback)(struct lejp_ctx *ctx, char reason); + const char * const *paths; + uint8_t count_paths; + uint8_t ppos; + uint8_t path_match; }; struct lejp_ctx { diff --git a/lib/misc/CMakeLists.txt b/lib/misc/CMakeLists.txt index fcdb2a5f7..337367aae 100644 --- a/lib/misc/CMakeLists.txt +++ b/lib/misc/CMakeLists.txt @@ -110,6 +110,12 @@ if (LWS_WITH_LEJP) list(APPEND SOURCES misc/lejp.c) endif() +if (LWS_WITH_CBOR) + list(APPEND SOURCES + misc/lecp.c + misc/ieeehalfprecision.c) +endif() + if (UNIX) if (NOT LWS_HAVE_GETIFADDRS) diff --git a/lib/misc/ieeehalfprecision.c b/lib/misc/ieeehalfprecision.c new file mode 100644 index 000000000..075eb1d18 --- /dev/null +++ b/lib/misc/ieeehalfprecision.c @@ -0,0 +1,228 @@ +/****************************************************************************** + * + * Filename: ieeehalfprecision.c + * Programmer: James Tursa + * Version: 1.0 + * Date: March 3, 2009 + * Copyright: (c) 2009 by James Tursa, All Rights Reserved + * + * This code uses the BSD License: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the distribution + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * This file contains C code to convert between IEEE double, single, and half + * precision floating point formats. The intended use is for standalone C code + * that does not rely on MATLAB mex.h. The bit pattern for the half precision + * floating point format is stored in a 16-bit unsigned int variable. The half + * precision bit pattern definition is: + * + * 1 bit sign bit + * 5 bits exponent, biased by 15 + * 10 bits mantissa, hidden leading bit, normalized to 1.0 + * + * Special floating point bit patterns recognized and supported: + * + * All exponent bits zero: + * - If all mantissa bits are zero, then number is zero (possibly signed) + * - Otherwise, number is a denormalized bit pattern + * + * All exponent bits set to 1: + * - If all mantissa bits are zero, then number is +Infinity or -Infinity + * - Otherwise, number is NaN (Not a Number) + * + * For the denormalized cases, note that 2^(-24) is the smallest number that can + * be represented in half precision exactly. 2^(-25) will convert to 2^(-24) + * because of the rounding algorithm used, and 2^(-26) is too small and + * underflows to zero. + * + ******************************************************************************/ + +/* + changes by K. Rogovin: + - changed macros UINT16_TYPE, etc to types from stdint.h + (i.e. UINT16_TYPE-->uint16_t, INT16_TYPE-->int16_t, etc) + + - removed double conversion routines. + + - changed run time checks of endianness to compile time macro. + + - removed return value from routines + + - changed source parameter type from * to const * + + - changed pointer types from void ot uint16_t and uint32_t + */ + +/* + * andy@warmcat.com: + * + * - clean style and indenting + * - convert to single operation + * - export as lws_ + */ + +#include +#include + +void +lws_singles2halfp(uint16_t *hp, uint32_t x) +{ + uint32_t xs, xe, xm; + uint16_t hs, he, hm; + int hes; + + if (!(x & 0x7FFFFFFFu)) { + /* Signed zero */ + *hp = (uint16_t)(x >> 16); + + return; + } + + xs = x & 0x80000000u; // Pick off sign bit + xe = x & 0x7F800000u; // Pick off exponent bits + xm = x & 0x007FFFFFu; // Pick off mantissa bits + + if (xe == 0) { // Denormal will underflow, return a signed zero + *hp = (uint16_t) (xs >> 16); + return; + } + + if (xe == 0x7F800000u) { // Inf or NaN (all the exponent bits are set) + if (!xm) { // If mantissa is zero ... + *hp = (uint16_t) ((xs >> 16) | 0x7C00u); // Signed Inf + return; + } + + *hp = (uint16_t) 0xFE00u; // NaN, only 1st mantissa bit set + + return; + } + + /* Normalized number */ + + hs = (uint16_t) (xs >> 16); // Sign bit + /* Exponent unbias the single, then bias the halfp */ + hes = ((int)(xe >> 23)) - 127 + 15; + + if (hes >= 0x1F) { // Overflow + *hp = (uint16_t) ((xs >> 16) | 0x7C00u); // Signed Inf + return; + } + + if (hes <= 0) { // Underflow + if ((14 - hes) > 24) + /* + * Mantissa shifted all the way off & no + * rounding possibility + */ + hm = (uint16_t) 0u; // Set mantissa to zero + else { + xm |= 0x00800000u; // Add the hidden leading bit + hm = (uint16_t) (xm >> (14 - hes)); // Mantissa + if ((xm >> (13 - hes)) & 1u) // Check for rounding + /* Round, might overflow into exp bit, + * but this is OK */ + hm = (uint16_t)(hm + 1u); + } + /* Combine sign bit and mantissa bits, biased exponent is 0 */ + *hp = hs | hm; + + return; + } + + he = (uint16_t)(hes << 10); // Exponent + hm = (uint16_t)(xm >> 13); // Mantissa + + if (xm & 0x00001000u) // Check for rounding + /* Round, might overflow to inf, this is OK */ + *hp = (uint16_t)((hs | he | hm) + (uint16_t)1u); + else + *hp = hs | he | hm; // No rounding +} + +void +lws_halfp2singles(uint32_t *xp, uint16_t h) +{ + uint16_t hs, he, hm; + uint32_t xs, xe, xm; + int32_t xes; + int e; + + if (!(h & 0x7FFFu)) { // Signed zero + *xp = ((uint32_t)h) << 16; // Return the signed zero + + return; + } + + hs = h & 0x8000u; // Pick off sign bit + he = h & 0x7C00u; // Pick off exponent bits + hm = h & 0x03FFu; // Pick off mantissa bits + + if (!he) { // Denormal will convert to normalized + e = -1; + + /* figure out how much extra to adjust the exponent */ + do { + e++; + hm = (uint16_t)(hm << 1); + /* Shift until leading bit overflows into exponent */ + } while (!(hm & 0x0400u)); + + xs = ((uint32_t) hs) << 16; // Sign bit + + /* Exponent unbias the halfp, then bias the single */ + xes = ((int32_t)(he >> 10)) - 15 + 127 - e; + xe = (uint32_t)(xes << 23); // Exponent + xm = ((uint32_t)(hm & 0x03FFu)) << 13; // Mantissa + + *xp = xs | xe | xm; + + return; + } + + if (he == 0x7C00u) { /* Inf or NaN (all the exponent bits are set) */ + if (!hm) { /* If mantissa is zero ... + * Signed Inf + */ + *xp = (((uint32_t)hs) << 16) | ((uint32_t)0x7F800000u); + + return; + } + + /* ... NaN, only 1st mantissa bit set */ + *xp = (uint32_t)0xFFC00000u; + + return; + } + + /* Normalized number */ + + xs = ((uint32_t)hs) << 16; // Sign bit + /* Exponent unbias the halfp, then bias the single */ + xes = ((int32_t)(he >> 10)) - 15 + 127; + xe = (uint32_t)(xes << 23); // Exponent + xm = ((uint32_t)hm) << 13; // Mantissa + + /* Combine sign bit, exponent bits, and mantissa bits */ + *xp = xs | xe | xm; +} diff --git a/lib/misc/lecp.c b/lib/misc/lecp.c new file mode 100644 index 000000000..4783241a4 --- /dev/null +++ b/lib/misc/lecp.c @@ -0,0 +1,1686 @@ +/* + * libwebsockets - small server side websockets and web server implementation + * + * Copyright (C) 2010 - 2021 Andy Green + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + * Stream parser for RFC8949 CBOR + */ + +#include "private-lib-core.h" +#include +#include + +#if defined(LWS_WITH_CBOR_FLOAT) +#include +#endif + +#define lwsl_lecp lwsl_debug + +static const char * const parser_errs[] = { + "", + "", + "Bad CBOR coding", + "Unknown", + "Parser callback errored (see earlier error)", + "Overflow" +}; + +enum lecp_states { + LECP_OPC, + LECP_COLLECT, + LECP_SIMPLEX8, + LECP_COLLATE, + LECP_ONLY_SAME +}; + +void +lecp_construct(struct lecp_ctx *ctx, lecp_callback cb, void *user, + const char * const *paths, unsigned char count_paths) +{ + uint16_t x = 0x1234; + + memset(ctx, 0, sizeof(*ctx) - sizeof(ctx->buf)); + + ctx->user = user; + ctx->pst[0].cb = cb; + ctx->pst[0].paths = paths; + ctx->pst[0].count_paths = count_paths; + ctx->be = *((uint8_t *)&x) == 0x12; + + ctx->st[0].s = LECP_OPC; + + ctx->pst[0].cb(ctx, LECPCB_CONSTRUCTED); +} + +void +lecp_destruct(struct lecp_ctx *ctx) +{ + /* no allocations... just let callback know what it happening */ + if (ctx->pst[0].cb) + ctx->pst[0].cb(ctx, LECPCB_DESTRUCTED); +} + +void +lecp_change_callback(struct lecp_ctx *ctx, lecp_callback cb) +{ + ctx->pst[0].cb(ctx, LECPCB_DESTRUCTED); + ctx->pst[0].cb = cb; + ctx->pst[0].cb(ctx, LECPCB_CONSTRUCTED); +} + + +const char * +lecp_error_to_string(int e) +{ + if (e > 0) + e = 0; + else + e = -e; + + if (e >= (int)LWS_ARRAY_SIZE(parser_errs)) + return "Unknown error"; + + return parser_errs[e]; +} + +static void +ex(struct lecp_ctx *ctx, void *_start, size_t len) +{ + struct _lecp_stack *st = &ctx->st[ctx->sp]; + uint8_t *start = (uint8_t *)_start; + + st->s = LECP_COLLECT; + st->collect_rem = (uint8_t)len; + + if (ctx->be) + ctx->collect_tgt = start; + else + ctx->collect_tgt = start + len - 1; +} + +static void +lecp_check_path_match(struct lecp_ctx *ctx) +{ + const char *p, *q; + size_t s = sizeof(char *); + int n; + + if (ctx->path_stride) + s = ctx->path_stride; + + /* we only need to check if a match is not active */ + for (n = 0; !ctx->path_match && + n < ctx->pst[ctx->pst_sp].count_paths; n++) { + ctx->wildcount = 0; + p = ctx->path; + + q = *((char **)(((char *)ctx->pst[ctx->pst_sp].paths) + + ((unsigned int)n * s))); + + while (*p && *q) { + if (*q != '*') { + if (*p != *q) + break; + p++; + q++; + continue; + } + ctx->wild[ctx->wildcount++] = + (uint16_t)lws_ptr_diff_size_t(p, ctx->path); + q++; + /* + * if * has something after it, match to . + * if ends with *, eat everything. + * This implies match sequences must be ordered like + * x.*.* + * x.* + * if both options are possible + */ + while (*p && (*p != '.' || !*q)) + p++; + } + if (*p || *q) + continue; + + ctx->path_match = (uint8_t)(n + 1); + ctx->path_match_len = ctx->pst[ctx->pst_sp].ppos; + return; + } + + if (!ctx->path_match) + ctx->wildcount = 0; +} + +int +lecp_push(struct lecp_ctx *ctx, char s_start, char s_end, char state) +{ + struct _lecp_stack *st = &ctx->st[ctx->sp]; + + if (ctx->sp + 1 == LWS_ARRAY_SIZE(ctx->st)) + return LECP_STACK_OVERFLOW; + + if (s_start && ctx->pst[ctx->pst_sp].cb(ctx, s_start)) + return LECP_REJECT_CALLBACK; + + lwsl_lecp("%s: pushing from sp %d, parent " + "(opc %d, indet %d, collect_rem %d)\n", + __func__, ctx->sp, st->opcode >> 5, st->indet, + (int)st->collect_rem); + + + st->pop_iss = s_end; /* issue this when we pop back here */ + ctx->st[ctx->sp + 1] = *st; + ctx->sp++; + st++; + + st->s = state; + st->collect_rem = 0; + st->intermediate = 0; + st->indet = 0; + st->ordinal = 0; + st->send_new_array_item = 0; + st->barrier = 0; + + return 0; +} + +int +lecp_pop(struct lecp_ctx *ctx) +{ + struct _lecp_stack *st; + + assert(ctx->sp); + ctx->sp--; + + st = &ctx->st[ctx->sp]; + + if (st->pop_iss == LECPCB_ARRAY_END) { + assert(ctx->ipos); + ctx->ipos--; + } + + ctx->pst[ctx->pst_sp].ppos = st->p; + ctx->path[st->p] = '\0'; + lecp_check_path_match(ctx); + + lwsl_lecp("%s: popping to sp %d, parent " + "(opc %d, indet %d, collect_rem %d)\n", + __func__, ctx->sp, st->opcode >> 5, st->indet, + (int)st->collect_rem); + + if (st->pop_iss && ctx->pst[ctx->pst_sp].cb(ctx, st->pop_iss)) + return LECP_REJECT_CALLBACK; + + return 0; +} + +static struct _lecp_stack * +lwcp_st_parent(struct lecp_ctx *ctx) +{ + assert(ctx->sp); + + return &ctx->st[ctx->sp - 1]; +} + +int +lwcp_completed(struct lecp_ctx *ctx, char indet) +{ + int r, il = ctx->ipos; + + ctx->st[ctx->sp].s = LECP_OPC; + + while (ctx->sp && !ctx->st[ctx->sp].barrier) { + struct _lecp_stack *parent = lwcp_st_parent(ctx); + + lwsl_lecp("%s: sp %d, parent " + "(opc %d, indet %d, collect_rem %d)\n", + __func__, ctx->sp, parent->opcode >> 5, parent->indet, + (int)parent->collect_rem); + + parent->ordinal++; + if (parent->opcode == LWS_CBOR_MAJTYP_ARRAY) { + assert(il); + il--; + ctx->i[il]++; + if (!parent->send_new_array_item) { + if (ctx->pst[ctx->pst_sp].cb(ctx, + LECPCB_ARRAY_ITEM_END)) + return LECP_REJECT_CALLBACK; + parent->send_new_array_item = 1; + } + } + + if (!indet && parent->indet) { + lwsl_lecp("%s: abandoning walk as parent needs indet\n", __func__); + break; + } + + if (!parent->indet && parent->collect_rem) { + parent->collect_rem--; + lwsl_lecp("%s: sp %d, parent (opc %d, indet %d, collect_rem -> %d)\n", + __func__, ctx->sp, parent->opcode >> 5, parent->indet, (int)parent->collect_rem); + + if (parent->collect_rem) { + /* more items to come */ + if (parent->opcode == LWS_CBOR_MAJTYP_ARRAY) + parent->send_new_array_item = 1; + break; + } + } + + lwsl_lecp("%s: parent (opc %d) collect_rem became zero\n", __func__, parent->opcode >> 5); + + ctx->st[ctx->sp - 1].s = LECP_OPC; + r = lecp_pop(ctx); + if (r) + return r; + indet = 0; + } + + return 0; +} + +static int +lwcp_is_indet_string(struct lecp_ctx *ctx) +{ + if (ctx->st[ctx->sp].indet) + return 1; + + if (!ctx->sp) + return 0; + + if (lwcp_st_parent(ctx)->opcode != LWS_CBOR_MAJTYP_BSTR && + lwcp_st_parent(ctx)->opcode != LWS_CBOR_MAJTYP_TSTR) + return 0; + + if (ctx->st[ctx->sp - 1].indet) + return 1; + + return 0; +} + +static int +report_raw_cbor(struct lecp_ctx *ctx) +{ + struct _lecp_parsing_stack *pst = &ctx->pst[ctx->pst_sp]; + + if (!ctx->cbor_pos) + return 0; + + if (pst->cb(ctx, LECPCB_LITERAL_CBOR)) + return 1; + + ctx->cbor_pos = 0; + + return 0; +} + +void +lecp_parse_report_raw(struct lecp_ctx *ctx, int on) +{ + ctx->literal_cbor_report = (uint8_t)on; + report_raw_cbor(ctx); +} + +int +lecp_parse_map_is_key(struct lecp_ctx *ctx) +{ + return lwcp_st_parent(ctx)->opcode == LWS_CBOR_MAJTYP_MAP && + !(lwcp_st_parent(ctx)->ordinal & 1); +} + +int +lecp_parse_subtree(struct lecp_ctx *ctx, const uint8_t *in, size_t len) +{ + struct _lecp_stack *st = &ctx->st[++ctx->sp]; + int n; + + st->s = 0; + st->collect_rem = 0; + st->intermediate = 0; + st->indet = 0; + st->ordinal = 0; + st->send_new_array_item = 0; + st->barrier = 1; + + n = lecp_parse(ctx, in, len); + ctx->sp--; + + return n; +} + +int +lecp_parse(struct lecp_ctx *ctx, const uint8_t *cbor, size_t len) +{ + size_t olen = len; + int ret; + + while (len--) { + struct _lecp_parsing_stack *pst = &ctx->pst[ctx->pst_sp]; + struct _lecp_stack *st = &ctx->st[ctx->sp]; + uint8_t c, sm, o; + char to; + + c = *cbor++; + + /* + * for, eg, cose_sign, we sometimes need to collect subtrees of + * raw CBOR. Report buffers of it via the callback if we filled + * the buffer, or we stopped collecting. + */ + + if (ctx->literal_cbor_report) { + ctx->cbor[ctx->cbor_pos++] = c; + if (ctx->cbor_pos == sizeof(ctx->cbor) && + report_raw_cbor(ctx)) + goto reject_callback; + } + + switch (st->s) { + /* + * We're getting the nex opcode + */ + case LECP_OPC: + st->opcode = ctx->item.opcode = c & LWS_CBOR_MAJTYP_MASK; + sm = c & LWS_CBOR_SUBMASK; + to = 0; + + lwsl_lecp("%s: %d: OPC %d|%d\n", __func__, ctx->sp, + c >> 5, sm); + + if (c != 0xff && ctx->sp && + ctx->st[ctx->sp - 1].send_new_array_item) { + ctx->st[ctx->sp - 1].send_new_array_item = 0; + if (ctx->pst[ctx->pst_sp].cb(ctx, + LECPCB_ARRAY_ITEM_START)) + goto reject_callback; + } + + switch (st->opcode) { + case LWS_CBOR_MAJTYP_UINT: + ctx->present = LECPCB_VAL_NUM_UINT; + if (sm < LWS_CBOR_1) { + ctx->item.u.i64 = (int64_t)sm; + goto issue; + } + goto i2; + + case LWS_CBOR_MAJTYP_INT_NEG: + ctx->present = LECPCB_VAL_NUM_INT; + if (sm < 24) { + ctx->item.u.i64 = (-1ll) - (int64_t)sm; + goto issue; + } +i2: + if (sm >= LWS_CBOR_RESERVED) + goto bad_coding; + ctx->item.u.u64 = 0; + o = (uint8_t)(1 << (sm - LWS_CBOR_1)); + ex(ctx, (uint8_t *)&ctx->item.u.u64, o); + break; + + case LWS_CBOR_MAJTYP_BSTR: + to = LECPCB_VAL_BLOB_END - LECPCB_VAL_STR_END; + + /* fallthru */ + + case LWS_CBOR_MAJTYP_TSTR: + /* + * The first thing is the string length, it's + * going to either be a byte count for the + * string or the indefinite length marker + * followed by determinite-length chunks of the + * same MAJTYP + */ + + ctx->npos = 0; + ctx->buf[0] = '\0'; + + if (!sm) { + if ((!ctx->sp || (ctx->sp && + !ctx->st[ctx->sp - 1].intermediate)) && + pst->cb(ctx, (char)(LECPCB_VAL_STR_START + to))) + goto reject_callback; + + if (pst->cb(ctx, (char)(LECPCB_VAL_STR_END + to))) + goto reject_callback; + lwcp_completed(ctx, 0); + break; + } + + if (sm < LWS_CBOR_1) { + ctx->item.u.u64 = (uint64_t)sm; + if ((!ctx->sp || (ctx->sp && + !ctx->st[ctx->sp - 1].intermediate)) && + pst->cb(ctx, (char)(LECPCB_VAL_STR_START + to))) + goto reject_callback; + + st->indet = 0; + st->collect_rem = sm; + st->s = LECP_COLLATE; + break; + } + + if (sm < LWS_CBOR_RESERVED) + goto i2; + + if (sm != LWS_CBOR_INDETERMINITE) + goto bad_coding; + + if ((!ctx->sp || (ctx->sp && + !ctx->st[ctx->sp - 1].intermediate)) && + pst->cb(ctx, (char)(LECPCB_VAL_STR_START + to))) + goto reject_callback; + + st->indet = 1; + + st->p = pst->ppos; + lecp_push(ctx, 0, (char)(LECPCB_VAL_STR_END + to), + LECP_ONLY_SAME); + break; + + case LWS_CBOR_MAJTYP_ARRAY: + ctx->npos = 0; + ctx->buf[0] = '\0'; + + if (pst->ppos + 3u >= sizeof(ctx->path)) + goto reject_overflow; + + st->p = pst->ppos; + ctx->path[pst->ppos++] = '['; + ctx->path[pst->ppos++] = ']'; + ctx->path[pst->ppos] = '\0'; + + lecp_check_path_match(ctx); + + if (ctx->ipos + 1u >= LWS_ARRAY_SIZE(ctx->i)) + goto reject_overflow; + + ctx->i[ctx->ipos++] = 0; + + if (pst->cb(ctx, LECPCB_ARRAY_START)) + goto reject_callback; + + if (!sm) { + if (pst->cb(ctx, LECPCB_ARRAY_END)) + goto reject_callback; + pst->ppos = st->p; + ctx->path[pst->ppos] = '\0'; + ctx->ipos--; + lecp_check_path_match(ctx); + lwcp_completed(ctx, 0); + break; + } + + ctx->st[ctx->sp].send_new_array_item = 1; + + if (sm < LWS_CBOR_1) { + st->indet = 0; + st->collect_rem = sm; + goto push_a; + } + + if (sm < LWS_CBOR_RESERVED) + goto i2; + + if (sm != LWS_CBOR_INDETERMINITE) + goto bad_coding; + + st->indet = 1; +push_a: + lecp_push(ctx, 0, LECPCB_ARRAY_END, LECP_OPC); + break; + + case LWS_CBOR_MAJTYP_MAP: + ctx->npos = 0; + ctx->buf[0] = '\0'; + + if (pst->ppos + 1u >= sizeof(ctx->path)) + goto reject_overflow; + + st->p = pst->ppos; + ctx->path[pst->ppos++] = '.'; + ctx->path[pst->ppos] = '\0'; + + lecp_check_path_match(ctx); + + if (pst->cb(ctx, LECPCB_OBJECT_START)) + goto reject_callback; + + if (!sm) { + if (pst->cb(ctx, LECPCB_OBJECT_END)) + goto reject_callback; + pst->ppos = st->p; + ctx->path[pst->ppos] = '\0'; + lecp_check_path_match(ctx); + lwcp_completed(ctx, 0); + break; + } + if (sm < LWS_CBOR_1) { + st->indet = 0; + st->collect_rem = (uint64_t)(sm * 2); + goto push_m; + } + + if (sm < LWS_CBOR_RESERVED) + goto i2; + + if (sm != LWS_CBOR_INDETERMINITE) + goto bad_coding; + + st->indet = 1; +push_m: + lecp_push(ctx, 0, LECPCB_OBJECT_END, LECP_OPC); + break; + + case LWS_CBOR_MAJTYP_TAG: + /* tag has one or another kind of int first */ + if (sm < LWS_CBOR_1) { + /* + * We have a literal tag number, push + * to decode the tag body + */ + ctx->item.u.u64 = st->tag = (uint64_t)sm; + goto start_tag_enclosure; + } + /* + * We have to do more stuff to get the tag + * number... + */ + goto i2; + + case LWS_CBOR_MAJTYP_FLOAT: + /* + * This can also be a bunch of specials as well + * as sizes of float... + */ + sm = c & LWS_CBOR_SUBMASK; + + switch (sm) { + case LWS_CBOR_SWK_FALSE: + ctx->present = LECPCB_VAL_FALSE; + goto issue; + + case LWS_CBOR_SWK_TRUE: + ctx->present = LECPCB_VAL_TRUE; + goto issue; + + case LWS_CBOR_SWK_NULL: + ctx->present = LECPCB_VAL_NULL; + goto issue; + + case LWS_CBOR_SWK_UNDEFINED: + ctx->present = LECPCB_VAL_UNDEFINED; + goto issue; + + case LWS_CBOR_M7_SUBTYP_SIMPLE_X8: + st->s = LECP_SIMPLEX8; + break; + + case LWS_CBOR_M7_SUBTYP_FLOAT16: + ctx->present = LECPCB_VAL_FLOAT16; + ex(ctx, &ctx->item.u.hf, 2); + break; + + case LWS_CBOR_M7_SUBTYP_FLOAT32: + ctx->present = LECPCB_VAL_FLOAT32; + ex(ctx, &ctx->item.u.f, 4); + break; + + case LWS_CBOR_M7_SUBTYP_FLOAT64: + ctx->present = LECPCB_VAL_FLOAT64; + ex(ctx, &ctx->item.u.d, 8); + break; + + case LWS_CBOR_M7_BREAK: + if (!ctx->sp || + !ctx->st[ctx->sp - 1].indet) + goto bad_coding; + + lwcp_completed(ctx, 1); + break; + + default: + /* handle as simple */ + ctx->item.u.u64 = (uint64_t)sm; + if (pst->cb(ctx, LECPCB_VAL_SIMPLE)) + goto reject_callback; + break; + } + break; + } + break; + + /* + * We're collecting int / float pieces + */ + case LECP_COLLECT: + if (ctx->be) + *ctx->collect_tgt++ = c; + else + *ctx->collect_tgt-- = c; + + if (--st->collect_rem) + break; + + /* + * We collected whatever it was... + */ + + ctx->npos = 0; + ctx->buf[0] = '\0'; + + switch (st->opcode) { + case LWS_CBOR_MAJTYP_BSTR: + case LWS_CBOR_MAJTYP_TSTR: + st->collect_rem = ctx->item.u.u64; + if ((!ctx->sp || (ctx->sp && + !ctx->st[ctx->sp - 1].intermediate)) && + pst->cb(ctx, (char)((st->opcode == + LWS_CBOR_MAJTYP_TSTR) ? + LECPCB_VAL_STR_START : + LECPCB_VAL_BLOB_START))) + goto reject_callback; + st->s = LECP_COLLATE; + break; + + case LWS_CBOR_MAJTYP_ARRAY: + st->collect_rem = ctx->item.u.u64; + lecp_push(ctx, 0, LECPCB_ARRAY_END, LECP_OPC); + break; + + case LWS_CBOR_MAJTYP_MAP: + st->collect_rem = ctx->item.u.u64 * 2; + lecp_push(ctx, 0, LECPCB_OBJECT_END, LECP_OPC); + break; + + case LWS_CBOR_MAJTYP_TAG: + st->tag = ctx->item.u.u64; + goto start_tag_enclosure; + + default: + /* + * ... then issue what we collected as a + * literal + */ + + if (st->opcode == LWS_CBOR_MAJTYP_INT_NEG) + ctx->item.u.i64 = (-1ll) - ctx->item.u.i64; + + goto issue; + } + break; + + case LECP_SIMPLEX8: + /* + * Extended SIMPLE byte for 7|24 opcode, no uses + * for it in RFC8949 + */ + if (c <= LWS_CBOR_INDETERMINITE) + /* + * Duplication of implicit simple values is + * denied by RFC8949 3.3 + */ + goto bad_coding; + + ctx->item.u.u64 = (uint64_t)c; + if (pst->cb(ctx, LECPCB_VAL_SIMPLE)) + goto reject_callback; + + lwcp_completed(ctx, 0); + break; + + case LECP_COLLATE: + /* + * let's grab b/t string content into the context + * buffer, and issue chunks from there + */ + + ctx->buf[ctx->npos++] = (char)c; + if (st->collect_rem) + st->collect_rem--; + + /* spill at chunk boundaries, or if we filled the buf */ + if (ctx->npos != sizeof(ctx->buf) - 1 && + st->collect_rem) + break; + + /* spill */ + ctx->buf[ctx->npos] = '\0'; + + /* if it's a map name, deal with the path */ + if (ctx->sp && lecp_parse_map_is_key(ctx)) { + if (lwcp_st_parent(ctx)->ordinal) + pst->ppos = st->p; + st->p = pst->ppos; + if (pst->ppos + ctx->npos > sizeof(ctx->path)) + goto reject_overflow; + memcpy(&ctx->path[pst->ppos], ctx->buf, + (size_t)(ctx->npos + 1)); + pst->ppos = (uint8_t)(pst->ppos + ctx->npos); + lecp_check_path_match(ctx); + } + + to = 0; + if (ctx->item.opcode == LWS_CBOR_MAJTYP_BSTR) + to = LECPCB_VAL_BLOB_END - LECPCB_VAL_STR_END; + + o = (uint8_t)(LECPCB_VAL_STR_END + to); + c = (st->collect_rem /* more to come at this layer */ || + /* we or direct parent is indeterminite */ + lwcp_is_indet_string(ctx)); + + if (ctx->sp) + ctx->st[ctx->sp - 1].intermediate = !!c; + if (c) + o--; + + if (pst->cb(ctx, (char)o)) + goto reject_callback; + ctx->npos = 0; + ctx->buf[0] = '\0'; + + if (ctx->sp && lwcp_st_parent(ctx)->indet) + st->s = LECP_OPC; + if (o == LECPCB_VAL_STR_END + to) + lwcp_completed(ctx, 0); + + break; + + case LECP_ONLY_SAME: + /* + * deterministic sized chunks same MAJTYP as parent + * level only (BSTR and TSTR frags inside interderminite + * BSTR or TSTR) + * + * Clean end when we see M7|31 + */ + if (!ctx->sp) { + /* + * We should only come here by pushing on stack + */ + assert(0); + return LECP_STACK_OVERFLOW; + } + + if (c == (LWS_CBOR_MAJTYP_FLOAT | LWS_CBOR_M7_BREAK)) { + /* if's the end of an interdetminite list */ + if (!ctx->sp || !ctx->st[ctx->sp - 1].indet) + /* + * Can't have a break without an + * indeterminite parent + */ + goto bad_coding; + + if (lwcp_completed(ctx, 1)) + goto reject_callback; + break; + } + + if (st->opcode != lwcp_st_parent(ctx)->opcode) + /* + * Fragments have to be of the same type as the + * outer opcode + */ + goto bad_coding; + + sm = c & LWS_CBOR_SUBMASK; + + if (sm == LWS_CBOR_INDETERMINITE) + /* indeterminite length frags not allowed */ + goto bad_coding; + + if (sm < LWS_CBOR_1) { + st->indet = 0; + st->collect_rem = (uint64_t)sm; + st->s = LECP_COLLATE; + break; + } + + if (sm >= LWS_CBOR_RESERVED) + goto bad_coding; + + goto i2; + + default: + assert(0); + return -1; + } + + continue; + +start_tag_enclosure: + st->p = pst->ppos; + ret = lecp_push(ctx, LECPCB_TAG_START, LECPCB_TAG_END, LECP_OPC); + if (ret) + return ret; + + continue; + +issue: + if (ctx->item.opcode == LWS_CBOR_MAJTYP_TAG) { + st->tag = ctx->item.u.u64; + goto start_tag_enclosure; + } + + /* we are just a number */ + + if (pst->cb(ctx, ctx->present)) + goto reject_callback; + + lwcp_completed(ctx, 0); + + } + + ctx->used_in = olen - len; + + if (!ctx->sp && ctx->st[0].s == LECP_OPC) + return 0; + + return LECP_CONTINUE; + +reject_overflow: + ret = LECP_STACK_OVERFLOW; + goto reject; + +bad_coding: + ret = LECP_REJECT_BAD_CODING; + goto reject; + +reject_callback: + ret = LECP_REJECT_CALLBACK; + +reject: + ctx->pst[ctx->pst_sp].cb(ctx, LECPCB_FAILED); + + return ret; +} + + + +void +lws_lec_init(lws_lec_pctx_t *ctx, uint8_t *buf, size_t len) +{ + memset(ctx, 0, sizeof(*ctx)); + ctx->start = ctx->buf = buf; + ctx->end = ctx->start + len; + ctx->fmt_pos = 0; +} + +void +lws_lec_setbuf(lws_lec_pctx_t *ctx, uint8_t *buf, size_t len) +{ + ctx->start = ctx->buf = buf; + ctx->end = ctx->start + len; + ctx->used = 0; + ctx->vaa_pos = 0; +} + +enum lws_lec_pctx_ret +lws_lec_printf(lws_lec_pctx_t *ctx, const char *format, ...) +{ + enum lws_lec_pctx_ret r; + va_list ap; + + va_start(ap, format); + r = lws_lec_vsprintf(ctx, format, ap); + va_end(ap); + + return r; +} + +/* + * Report how many next-level elements inbetween fmt[0] and the matching + * closure, eg, [] returns 0, [123] would return 1, [123,456] returns 2, and + * [123,{'a':[123,456]}] returns 2. Counts for { } maps are in pairs, ie, + * {'a':1, 'b': 2} returns 2 + * + * If there is no closure in the string it returns -1 + * + * We use this to figure out if we should use indeterminite lengths or specific + * lengths for items in the format string + */ + +#define bump(_r) count[sp]++ +//; lwsl_notice("%s: count[%d] -> %d\n", _r, sp, count[sp]) + +static int +format_scan(const char *fmt) +{ + char stack[12], literal = 0, numeric = 0; + int count[12], sp = 0, pc = 0, swallow = 0; + + literal = *fmt == '\''; + stack[sp] = *fmt++; + count[sp] = 0; + +// lwsl_notice("%s: start %s\n", __func__, fmt - 1); + + while (*fmt) { + +// lwsl_notice("%s: %c %d %d\n", __func__, *fmt, sp, literal); + + if (swallow) { + swallow--; + fmt++; + continue; + } + + if (numeric) { + if (*fmt >= '0' && *fmt <= '9') + fmt++; + numeric = 0; + if (*fmt != '(') + bump("a"); + } + + if (literal) { + if (*fmt == '\\' && fmt[1]) { + fmt += 2; + continue; + } + if (*fmt == '\'') { + literal = 0; + if (!sp && stack[sp] == '\'') + return count[sp]; + + if (sp) + sp--; + fmt++; + continue; + } + + bump("b"); + fmt++; + continue; + } + + if (*fmt == '\'') { + bump("c"); + sp++; + literal = 1; + fmt++; + continue; + } + + switch (pc) { + case 1: + if (*fmt == '.') { + pc++; + fmt++; + continue; + } + if (*fmt == 'l') { + pc++; + fmt++; + continue; + } + /* fallthru */ + case 2: + if (*fmt == '*') { + pc++; + fmt++; + continue; + } + if (*fmt == 'l') { + pc++; + fmt++; + continue; + } + /* fallthru */ + case 3: + bump("pc"); + pc = 0; + fmt++; + continue; + } + + switch (*fmt) { + + case '<': + swallow = 1; + /* fallthru */ + case '[': + case '(': + case '{': + if (sp == sizeof(stack)) + return -2; + + bump("d"); + sp++; + stack[sp] = *fmt; + count[sp] = 0; + break; + case ' ': + break; + case ',': + //count[sp]++; + break; + case ':': + if (stack[sp] != '{') + goto mismatch; + //count[sp]++; + break; + case '%': + pc = 1; + break; + case ']': + if (stack[sp] != '[') + goto mismatch; + goto pop; + case ')': + if (stack[sp] != '(') + goto mismatch; + goto pop; + case '}': + if (stack[sp] != '{') + goto mismatch; + goto pop; + case '>': + if (stack[sp] != '<') + goto mismatch; +pop: + if (sp) { + sp--; + break; + } + + if (stack[0] == '{') { + /* args have to come in pairs */ + if (count[0] & 1) { + lwsl_err("%s: odd map args %d %s\n", + __func__, count[0], fmt); + return -2; + } + // lwsl_notice("%s: return %d pairs\n", __func__, count[0] >> 1); + /* report how many pairs */ + return count[0] >> 1; + } + + // lwsl_notice("%s: return %d items\n", __func__, count[0]); + + return count[0]; + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + numeric = 1; + + break; + + default: + bump("e"); + break; + } + fmt++; + } + + return -1; + +mismatch: + lwsl_err("%s: format mismatch %c %c\n", __func__, stack[sp], *fmt); + + return -2; +} + +void +lws_lec_signed(lws_lec_pctx_t *ctx, int64_t num) +{ + if (num < 0) + lws_lec_int(ctx, LWS_CBOR_MAJTYP_INT_NEG, 0, + (uint64_t)(-1ll - num)); + else + lws_lec_int(ctx, LWS_CBOR_MAJTYP_UINT, 0, (uint64_t)num); +} + +void +lws_lec_int(lws_lec_pctx_t *ctx, uint8_t opcode, uint8_t indet, uint64_t num) +{ + uint8_t hint = 0; + unsigned int n; + + if (indet) { + ctx->scratch[ctx->scratch_len++] = (uint8_t)(opcode | + LWS_CBOR_INDETERMINITE); + return; + } + + if ((opcode & LWS_CBOR_MAJTYP_MASK) == LWS_CBOR_MAJTYP_FLOAT) { + hint = opcode & LWS_CBOR_SUBMASK; + switch (hint) { + case LWS_CBOR_M7_SUBTYP_FLOAT16: + num <<= 48; + break; + case LWS_CBOR_M7_SUBTYP_FLOAT32: + num <<= 32; + break; + } + } else { + + if (num < LWS_CBOR_1) { + ctx->scratch[ctx->scratch_len++] = (uint8_t)(opcode | num); + return; + } + + if (!(num & (uint64_t)(~0xffull))) { + hint = LWS_CBOR_1; + num <<= 56; + } else + if (!(num & (uint64_t)(~0xffffull))) { + hint = LWS_CBOR_2; + num <<= 48; + } else + if (!(num & (uint64_t)(~0xffffffffull))) { + hint = LWS_CBOR_4; + num <<= 32; + } + else + hint = LWS_CBOR_8; + } + + ctx->scratch[ctx->scratch_len++] = (uint8_t)(opcode | hint); + n = 1u << (hint - LWS_CBOR_1); + while (n--) { + ctx->scratch[ctx->scratch_len++] = (uint8_t)(num >> 56); + num <<= 8; + } +} + +enum { + NATTYPE_INT, + NATTYPE_LONG, + NATTYPE_LONG_LONG, + NATTYPE_PTR, + NATTYPE_DOUBLE, +}; + +int +lws_lec_scratch(lws_lec_pctx_t *ctx) +{ + size_t s; + + if (!ctx->scratch_len) + return 0; + + s = lws_ptr_diff_size_t(ctx->end, ctx->buf); + if (s > (size_t)ctx->scratch_len) + s = (size_t)ctx->scratch_len; + + memcpy(ctx->buf, ctx->scratch, s); + ctx->buf += s; + ctx->scratch_len = (uint8_t)(ctx->scratch_len - (uint8_t)s); + + return ctx->buf == ctx->end; +} + +enum lws_lec_pctx_ret +lws_lec_vsprintf(lws_lec_pctx_t *ctx, const char *fmt, va_list args) +{ + size_t fl = strlen(fmt); + uint64_t u64; + int64_t i64; +#if defined(LWS_WITH_CBOR_FLOAT) + double dbl; +#endif + size_t s; + char c; + int n; + + /* + * We might be being called after the first time, since we had to emit + * output buffer(s) before we could move on in the format string. For + * this case, reposition ourselves at the vaarg we got to from the last + * call. + */ + + for (n = 0; n < ctx->vaa_pos; n++) { + + switch (ctx->vaa[n]) { + case NATTYPE_INT: + (void)va_arg(args, int); + break; + case NATTYPE_LONG: + (void)va_arg(args, long); + break; + case NATTYPE_LONG_LONG: + (void)va_arg(args, long long); + break; + case NATTYPE_PTR: + (void)va_arg(args, const char *); + break; + case NATTYPE_DOUBLE: + (void)va_arg(args, double); + break; + } + if (ctx->state == CBPS_STRING_BODY) + /* + * when copying out text or binary strings, we reload + * the %s or %.*s pointer on subsequent calls, in case + * it was on the stack. The length and contents should + * not change between calls, but it's OK if the source + * address does. + */ + ctx->ongoing_src = va_arg(args, uint8_t *); + } + + while (ctx->buf != ctx->end) { + + /* + * We write small things into the context scratch array, then + * copy that into the output buffer fragmenting as needed. Next + * time we will finish emptying the scratch into the output + * buffer preferentially. + * + * Then we don't otherwise have to handle fragmentations in + * order to exactly fill the output buffer, simplifying + * everything else. + */ + + if (lws_lec_scratch(ctx)) + break; + + if (ctx->fmt_pos >= fl) { + if (ctx->state == CBPS_IDLE) + break; + c = 0; + } else + c = fmt[ctx->fmt_pos]; + + // lwsl_notice("%s: %d %d %c\n", __func__, ctx->state, ctx->sp, c); + + switch (ctx->state) { + case CBPS_IDLE: + ctx->scratch_len = 0; + switch (c) { + case '[': + n = format_scan(&fmt[ctx->fmt_pos]); + if (n == -2) + return LWS_LECPCTX_RET_FAIL; + lws_lec_int(ctx, LWS_CBOR_MAJTYP_ARRAY, n == -1, + (uint64_t)n); + goto stack_push; + case '{': + n = format_scan(&fmt[ctx->fmt_pos]); + if (n == -2) + return LWS_LECPCTX_RET_FAIL; + lws_lec_int(ctx, LWS_CBOR_MAJTYP_MAP, n == -1, + (uint64_t)n); + goto stack_push; + case '(': + /* must be preceded by a number */ + goto fail; + + case '<': /* state = CBPS_CONTYPE; + break; + + case ']': + if (!ctx->sp || ctx->stack[ctx->sp - 1] != '[') + return LWS_LECPCTX_RET_FAIL; + ctx->sp--; + break; + case '}': + if (!ctx->sp || ctx->stack[ctx->sp - 1] != '{') + return LWS_LECPCTX_RET_FAIL; + ctx->sp--; + break; + case ')': + if (!ctx->sp || ctx->stack[ctx->sp - 1] != '(') { + lwsl_notice("bad tag end %d %c\n", + ctx->sp, ctx->stack[ctx->sp - 1]); + goto fail; + } + ctx->sp--; + break; + case '>': + if (!ctx->sp || ctx->stack[ctx->sp - 1] != '<') + return LWS_LECPCTX_RET_FAIL; + ctx->scratch[ctx->scratch_len++] = + (uint8_t)(LWS_CBOR_MAJTYP_FLOAT | + LWS_CBOR_M7_BREAK); + ctx->sp--; + break; + case '\'': + n = format_scan(&fmt[ctx->fmt_pos]); + // lwsl_notice("%s: quote fs %d\n", __func__, n); + if (n < 0) + return LWS_LECPCTX_RET_FAIL; + lws_lec_int(ctx, LWS_CBOR_MAJTYP_TSTR, 0, + (uint64_t)n); + ctx->state = CBPS_STRING_LIT; + break; + case '%': + if (ctx->vaa_pos >= sizeof(ctx->vaa) - 1) { + lwsl_err("%s: too many %%\n", __func__); + goto fail; + } + ctx->_long = 0; + ctx->dotstar = 0; + ctx->state = CBPS_PC1; + break; + case ':': + break; + case ',': + break; + case '-': + ctx->item.opcode = LWS_CBOR_MAJTYP_INT_NEG; + ctx->item.u.i64 = 0; + ctx->state = CBPS_NUM_LIT; + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + ctx->item.opcode = LWS_CBOR_MAJTYP_UINT; + ctx->item.u.u64 = (uint64_t)(c - '0'); + ctx->state = CBPS_NUM_LIT; + break; + } + break; + case CBPS_PC1: + if (c == 'l') { + ctx->_long++; + ctx->state = CBPS_PC2; + break; + } + if (c == '.') { + ctx->dotstar++; + ctx->state = CBPS_PC2; + break; + } + /* fallthru */ + + case CBPS_PC2: + if (c == 'l') { + ctx->_long++; + ctx->state = CBPS_PC3; + break; + } + if (c == '*') { + ctx->dotstar++; + ctx->state = CBPS_PC3; + break; + } + /* fallthru */ + + case CBPS_PC3: + switch (c) { + case 'd': + switch (ctx->_long) { + case 0: + i64 = (int64_t)va_arg(args, int); + ctx->vaa[ctx->vaa_pos++] = NATTYPE_INT; + break; + case 1: + i64 = (int64_t)va_arg(args, long); + ctx->vaa[ctx->vaa_pos++] = NATTYPE_LONG; + break; + case 2: + i64 = (int64_t)va_arg(args, long long); + ctx->vaa[ctx->vaa_pos++] = NATTYPE_LONG_LONG; + break; + } + if (i64 < 0) + lws_lec_int(ctx, + LWS_CBOR_MAJTYP_INT_NEG, 0, + (uint64_t)(-1ll - i64)); + else + lws_lec_int(ctx, + LWS_CBOR_MAJTYP_UINT, 0, + (uint64_t)i64); + break; + case 'u': + switch (ctx->_long) { + case 0: + u64 = (uint64_t)va_arg(args, unsigned int); + ctx->vaa[ctx->vaa_pos++] = NATTYPE_INT; + break; + case 1: + u64 = (uint64_t)va_arg(args, unsigned long); + ctx->vaa[ctx->vaa_pos++] = NATTYPE_LONG; + break; + case 2: + u64 = (uint64_t)va_arg(args, unsigned long long); + ctx->vaa[ctx->vaa_pos++] = NATTYPE_LONG_LONG; + break; + } + lws_lec_int(ctx, LWS_CBOR_MAJTYP_UINT, 0, u64); + break; + case 's': /* text string */ + ctx->ongoing_done = 0; + if (ctx->dotstar == 2) { + ctx->ongoing_len = (uint64_t)va_arg(args, int); + ctx->vaa[ctx->vaa_pos++] = NATTYPE_INT; + } + /* vaa for ptr done at end of body copy */ + ctx->ongoing_src = va_arg(args, uint8_t *); + if (ctx->dotstar != 2) + ctx->ongoing_len = (uint64_t)strlen( + (const char *)ctx->ongoing_src); + lws_lec_int(ctx, LWS_CBOR_MAJTYP_TSTR, 0, ctx->ongoing_len); + ctx->state = CBPS_STRING_BODY; + ctx->fmt_pos++; + continue; + case 'b': /* binary string (%.*b only) */ + if (ctx->dotstar != 2) + goto fail; + ctx->vaa[ctx->vaa_pos++] = NATTYPE_INT; + ctx->ongoing_done = 0; + ctx->ongoing_len = (uint64_t)va_arg(args, int); + /* vaa for ptr done at end of body copy */ + ctx->ongoing_src = va_arg(args, uint8_t *); + lws_lec_int(ctx, LWS_CBOR_MAJTYP_BSTR, 0, ctx->ongoing_len); + ctx->state = CBPS_STRING_BODY; + ctx->fmt_pos++; + continue; + case 't': /* dynamic tag */ + switch (ctx->_long) { + case 0: + ctx->item.u.u64 = (uint64_t)va_arg(args, int); + ctx->vaa[ctx->vaa_pos++] = NATTYPE_INT; + break; + case 1: + ctx->item.u.u64 = (uint64_t)va_arg(args, long); + ctx->vaa[ctx->vaa_pos++] = NATTYPE_LONG; + break; + case 2: + ctx->item.u.u64 = (uint64_t)va_arg(args, long long); + ctx->vaa[ctx->vaa_pos++] = NATTYPE_LONG_LONG; + break; + } + ctx->item.opcode = LWS_CBOR_MAJTYP_UINT; + ctx->fmt_pos++; + if (ctx->fmt_pos >= fl) + continue; + c = fmt[ctx->fmt_pos]; + if (c != '(') + goto fail; + goto tag_body; +#if defined(LWS_WITH_CBOR_FLOAT) + case 'f': /* floating point double */ + dbl = va_arg(args, double); + + if (dbl == (float)dbl) { + uint16_t hf; + union { + uint32_t ui; + float f; + } u1, u2; + + u1.f = (float)dbl; + lws_singles2halfp(&hf, u1.ui); + lws_halfp2singles(&u2.ui, hf); + + if ((isinf(u1.f) && isinf(u2.f)) || + (isnan(u1.f) && isnan(u2.f)) || + u1.f == u2.f) { + lws_lec_int(ctx, + LWS_CBOR_MAJTYP_FLOAT | + LWS_CBOR_M7_SUBTYP_FLOAT16, + 0, hf); + break; + } + /* do it as 32-bit float */ + lws_lec_int(ctx, + LWS_CBOR_MAJTYP_FLOAT | + LWS_CBOR_M7_SUBTYP_FLOAT32, + 0, u1.ui); + break; + } + + /* do it as 64-bit double */ + + { + union { + uint64_t ui; + double f; + } u3; + + u3.f = dbl; + lws_lec_int(ctx, + LWS_CBOR_MAJTYP_FLOAT | + LWS_CBOR_M7_SUBTYP_FLOAT64, + 0, u3.ui); + } + break; +#else + case 'f': + lwsl_err("%s: no FP support\n", __func__); + goto fail; +#endif + } + ctx->state = CBPS_IDLE; + break; + + case CBPS_STRING_BODY: + s = lws_ptr_diff_size_t(ctx->end, ctx->buf); + if (s > (size_t)(ctx->ongoing_len - ctx->ongoing_done)) + s = (size_t)(ctx->ongoing_len - ctx->ongoing_done); + memcpy(ctx->buf, ctx->ongoing_src + ctx->ongoing_done, s); + ctx->buf += s; + ctx->ongoing_done += s; + if (ctx->ongoing_len == ctx->ongoing_done) { + /* vaa for ptr */ + ctx->vaa[ctx->vaa_pos++] = NATTYPE_PTR; + ctx->state = CBPS_IDLE; + } + continue; + + case CBPS_NUM_LIT: + if (c >= '0' && c <= '9') { + ctx->item.u.u64 = (ctx->item.u.u64 * 10) + + (uint64_t)(c - '0'); + break; + } + + if (ctx->item.opcode == LWS_CBOR_MAJTYP_INT_NEG) + ctx->item.u.i64--; + + if (c == '(') { /* tag qualifier */ +tag_body: + n = format_scan(&fmt[ctx->fmt_pos]); + if (n == -2) + goto fail; + /* + * inteterminite length not possible for tag, + * take it to mean that the closure is in a + * later format string + */ + + lws_lec_int(ctx, LWS_CBOR_MAJTYP_TAG, 0, + ctx->item.u.u64); + +stack_push: + if (ctx->sp >= sizeof(ctx->stack)) + return LWS_LECPCTX_RET_FAIL; + ctx->stack[ctx->sp] = (uint8_t)c; + ctx->indet[ctx->sp++] = (uint8_t)(n == -1); + // lwsl_notice("%s: pushed %c\n", __func__, c); + ctx->state = CBPS_IDLE; + break; + } + + lws_lec_int(ctx, ctx->item.opcode, 0, ctx->item.u.u64); + + ctx->state = CBPS_IDLE; + /* deal with the terminating char fresh */ + continue; + + case CBPS_STRING_LIT: + if (!ctx->escflag && c == '\\') { + ctx->escflag = 1; + break; + } + if (!ctx->escflag && c == '\'') { + ctx->state = CBPS_IDLE; + break; + } + + *ctx->buf++ = (uint8_t)c; + ctx->escflag = 0; + + break; + + case CBPS_CONTYPE: + if (c != 't' && c != 'b') + return LWS_LECPCTX_RET_FAIL; + + lws_lec_int(ctx, c == 't' ? LWS_CBOR_MAJTYP_TSTR : + LWS_CBOR_MAJTYP_BSTR, 1, 0); + c = '<'; + n = 0; + goto stack_push; + } + + ctx->fmt_pos++; + } + + ctx->used = lws_ptr_diff_size_t(ctx->buf, ctx->start); + // lwsl_notice("%s: ctx->used %d\n", __func__, (int)ctx->used); + + if (ctx->buf == ctx->end || ctx->scratch_len) + return LWS_LECPCTX_RET_AGAIN; + + ctx->fmt_pos = 0; + ctx->vaa_pos = 0; + + return LWS_LECPCTX_RET_FINISHED; + +fail: + lwsl_notice("%s: failed\n", __func__); + + ctx->fmt_pos = 0; + + return LWS_LECPCTX_RET_FAIL; +} diff --git a/lib/misc/lejp.c b/lib/misc/lejp.c index ee84734fc..893f0b28c 100644 --- a/lib/misc/lejp.c +++ b/lib/misc/lejp.c @@ -468,6 +468,9 @@ lejp_parse(struct lejp_ctx *ctx, const unsigned char *json, int len) /* push */ ctx->st[ctx->sp].s = LEJP_MP_ARRAY_END; c = LEJP_MP_VALUE; + if (ctx->pst[ctx->pst_sp].ppos + 3u >= + sizeof(ctx->path)) + goto reject; ctx->path[ctx->pst[ctx->pst_sp].ppos++] = '['; ctx->path[ctx->pst[ctx->pst_sp].ppos++] = ']'; ctx->path[ctx->pst[ctx->pst_sp].ppos] = '\0'; @@ -881,3 +884,4 @@ lejp_error_to_string(int e) return parser_errs[e]; } + diff --git a/minimal-examples/api-tests/api-test-lecp/CMakeLists.txt b/minimal-examples/api-tests/api-test-lecp/CMakeLists.txt new file mode 100644 index 000000000..b09ee02ee --- /dev/null +++ b/minimal-examples/api-tests/api-test-lecp/CMakeLists.txt @@ -0,0 +1,22 @@ +project(lws-api-test-lecp C) +cmake_minimum_required(VERSION 2.8.12) +find_package(libwebsockets CONFIG REQUIRED) +list(APPEND CMAKE_MODULE_PATH ${LWS_CMAKE_DIR}) +include(CheckCSourceCompiles) +include(LwsCheckRequirements) + +set(requirements 1) +require_lws_config(LWS_WITH_CBOR 1 requirements) + +if (requirements) + + add_executable(${PROJECT_NAME} main.c) + add_test(NAME api-test-lecp COMMAND lws-api-test-lecp) + + if (websockets_shared) + target_link_libraries(${PROJECT_NAME} websockets_shared ${LIBWEBSOCKETS_DEP_LIBS}) + add_dependencies(${PROJECT_NAME} websockets_shared) + else() + target_link_libraries(${PROJECT_NAME} websockets ${LIBWEBSOCKETS_DEP_LIBS}) + endif() +endif() diff --git a/minimal-examples/api-tests/api-test-lecp/README.md b/minimal-examples/api-tests/api-test-lecp/README.md new file mode 100644 index 000000000..ebe930d24 --- /dev/null +++ b/minimal-examples/api-tests/api-test-lecp/README.md @@ -0,0 +1,56 @@ +# lws api test lws_struct JSON + +Demonstrates how to use and performs selftests for lws_struct +JSON serialization and deserialization + +## build + +``` + $ cmake . && make +``` + +## usage + +Commandline option|Meaning +---|--- +-d |Debug verbosity in decimal, eg, -d15 + +``` + $ ./lws-api-test-lws_struct-json +[2019/03/30 22:09:09:2529] USER: LWS API selftest: lws_struct JSON +[2019/03/30 22:09:09:2625] NOTICE: main: ++++++++++++++++ test 1 +[2019/03/30 22:09:09:2812] NOTICE: builder.hostname = 'learn', timeout = 1800, targets (2) +[2019/03/30 22:09:09:2822] NOTICE: target.name 'target1' (target 0x543a830) +[2019/03/30 22:09:09:2824] NOTICE: target.name 'target2' (target 0x543a860) +[2019/03/30 22:09:09:2826] NOTICE: main: .... strarting serialization of test 1 +[2019/03/30 22:09:09:2899] NOTICE: ser says 1 +{"schema":"com-warmcat-sai-builder","hostname":"learn","nspawn_timeout":1800,"targets":[{"name":"target1"},{"name":"target2"}]} +[2019/03/30 22:09:09:2929] NOTICE: main: ++++++++++++++++ test 2 +[2019/03/30 22:09:09:2932] NOTICE: builder.hostname = 'learn', timeout = 0, targets (3) +[2019/03/30 22:09:09:2932] NOTICE: target.name 'target1' (target 0x543b060) +[2019/03/30 22:09:09:2933] NOTICE: target.name 'target2' (target 0x543b090) +[2019/03/30 22:09:09:2933] NOTICE: target.name 'target3' (target 0x543b0c0) +[2019/03/30 22:09:09:2934] NOTICE: main: .... strarting serialization of test 2 +[2019/03/30 22:09:09:2935] NOTICE: ser says 1 +{"schema":"com-warmcat-sai-builder","hostname":"learn","nspawn_timeout":0,"targets":[{"name":"target1"},{"name":"target2"},{"name":"target3"}]} +[2019/03/30 22:09:09:2940] NOTICE: main: ++++++++++++++++ test 3 +[2019/03/30 22:09:09:2959] NOTICE: builder.hostname = 'learn', timeout = 1800, targets (2) +[2019/03/30 22:09:09:2960] NOTICE: target.name 'target1' (target 0x543b450) +[2019/03/30 22:09:09:2961] NOTICE: child 0x543b480, target.child.somename 'abc' +[2019/03/30 22:09:09:2961] NOTICE: target.name 'target2' (target 0x543b490) +[2019/03/30 22:09:09:2962] NOTICE: main: .... strarting serialization of test 3 +[2019/03/30 22:09:09:2969] NOTICE: ser says 1 +{"schema":"com-warmcat-sai-builder","hostname":"learn","nspawn_timeout":1800,"targets":[{"name":"target1","child":{"somename":"abc"}},{"name":"target2"}]} +[2019/03/30 22:09:09:2970] NOTICE: main: ++++++++++++++++ test 4 +[2019/03/30 22:09:09:2971] NOTICE: builder.hostname = 'learn', timeout = 1800, targets (0) +[2019/03/30 22:09:09:2971] NOTICE: main: .... strarting serialization of test 4 +[2019/03/30 22:09:09:2973] NOTICE: ser says 1 +{"schema":"com-warmcat-sai-builder","hostname":"learn","nspawn_timeout":1800} +[2019/03/30 22:09:09:2974] NOTICE: main: ++++++++++++++++ test 5 +[2019/03/30 22:09:09:2978] NOTICE: builder.hostname = '', timeout = 0, targets (0) +[2019/03/30 22:09:09:2979] NOTICE: main: .... strarting serialization of test 5 +[2019/03/30 22:09:09:2980] NOTICE: ser says 1 +{"schema":"com-warmcat-sai-builder","hostname":"","nspawn_timeout":0} +[2019/03/30 22:09:09:2982] USER: Completed: PASS +``` + diff --git a/minimal-examples/api-tests/api-test-lecp/main.c b/minimal-examples/api-tests/api-test-lecp/main.c new file mode 100644 index 000000000..1e6654102 --- /dev/null +++ b/minimal-examples/api-tests/api-test-lecp/main.c @@ -0,0 +1,5019 @@ +/* + * lws-api-test-lecp + * + * Written in 2010-2021 by Andy Green + * + * This file is made available under the Creative Commons CC0 1.0 + * Universal Public Domain Dedication. + * + * unit tests for lecp + */ + +#include + +#if defined(LWS_WITH_CBOR_FLOAT) +#include +#endif + +#define VERBOSE + +#if defined(VERBOSE) +static const char * const reason_names[] = { + "LECPCB_CONSTRUCTED", + "LECPCB_DESTRUCTED", + "LECPCB_START", + "LECPCB_COMPLETE", + "LECPCB_FAILED", + "LECPCB_PAIR_NAME", + "LECPCB_VAL_TRUE", + "LECPCB_VAL_FALSE", + "LECPCB_VAL_NULL", + "LECPCB_VAL_NUM_INT", + "LECPCB_VAL_RESERVED", /* float in lejp */ + "LECPCB_VAL_STR_START", + "LECPCB_VAL_STR_CHUNK", + "LECPCB_VAL_STR_END", + "LECPCB_ARRAY_START", + "LECPCB_ARRAY_END", + "LECPCB_OBJECT_START", + "LECPCB_OBJECT_END", + "LECPCB_TAG_START", + "LECPCB_TAG_END", + "LECPCB_VAL_NUM_UINT", + "LECPCB_VAL_UNDEFINED", + "LECPCB_VAL_FLOAT16", + "LECPCB_VAL_FLOAT32", + "LECPCB_VAL_FLOAT64", + "LECPCB_VAL_SIMPLE", + "LECPCB_VAL_BLOB_START", + "LECPCB_VAL_BLOB_CHUNK", + "LECPCB_VAL_BLOB_END", + "LECPCB_ARRAY_ITEM_START", + "LECPCB_ARRAY_ITEM_END", +}; +#endif + +/* + * Based on the official CBOR test vectors from here + * + * https://github.com/cbor/test-vectors/blob/master/appendix_a.json + */ + +static const uint8_t + test1[] = { 0x00 }, + test2[] = { 0x01 }, + test3[] = { 0x0a }, + test4[] = { 0x17 }, + test5[] = { 0x18, 0x18 }, + test6[] = { 0x18, 0x19 }, + test7[] = { 0x18, 0x64 }, + test8[] = { 0x19, 0x03, 0xe8 }, + test9[] = { 0x1a, 0x00, 0x0f, 0x42, 0x40 }, + test10[] = { 0x1b, 0x00, 0x00, 0x00, + 0xe8, 0xd4, 0xa5, 0x10, 0x00 }, + test11[] = { 0x1b, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff }, + test12[] = { 0xc2, 0x49, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00 }, + test13[] = { 0x3b, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff }, + test14[] = { 0xc3, 0x49, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00 }, + test15[] = { 0x20 }, + test16[] = { 0x29 }, + test17[] = { 0x38, 0x63 }, + test18[] = { 0x39, 0x03, 0xe7 }, + test19[] = { 0xf9, 0x00, 0x00 }, + test20[] = { 0xf9, 0x80, 0x00 }, + test21[] = { 0xf9, 0x3c, 0x00 }, + test22[] = { 0xfb, 0x3f, 0xf1, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x9a }, + test23[] = { 0xf9, 0x3e, 0x00 }, + test24[] = { 0xf9, 0x7b, 0xff }, + test25[] = { 0xfa, 0x47, 0xc3, 0x50, 0x00 }, + test26[] = { 0xfa, 0x7f, 0x7f, 0xff, 0xff }, + test27[] = { 0xfb, 0x7e, 0x37, 0xe4, 0x3c, + 0x88, 0x00, 0x75, 0x9c }, + test28[] = { 0xf9, 0x00, 0x01 }, + test29[] = { 0xf9, 0x04, 0x00 }, + test30[] = { 0xf9, 0xc4, 0x00 }, + test31[] = { 0xfb, 0xc0, 0x10, 0x66, 0x66, + 0x66, 0x66, 0x66, 0x66 }, + test32[] = { 0xf9, 0x7c, 0x00 }, + test33[] = { 0xf9, 0x7e, 0x00 }, + test34[] = { 0xf9, 0xfc, 0x00 }, + test35[] = { 0xfa, 0x7f, 0x80, 0x00, 0x00 }, + test36[] = { 0xfa, 0x7f, 0xc0, 0x00, 0x00 }, + test37[] = { 0xfa, 0xff, 0x80, 0x00, 0x00 }, + test38[] = { 0xfb, 0x7f, 0xf0, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00 }, + test39[] = { 0xfb, 0x7f, 0xf8, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00 }, + test40[] = { 0xfb, 0xff, 0xf0, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00 }, + test41[] = { 0xf4 }, + test42[] = { 0xf5 }, + test43[] = { 0xf6 }, + test44[] = { 0xf7 }, + test45[] = { 0xf0 }, + test46[] = { 0xf8, 0x18 }, + test47[] = { 0xf8, 0xff }, + test48[] = { 0xc0, 0x74, 0x32, 0x30, 0x31, + 0x33, 0x2d, 0x30, 0x33, 0x2d, + 0x32, 0x31, 0x54, 0x32, 0x30, + 0x3a, 0x30, 0x34, 0x3a, 0x30, + 0x30, 0x5a }, + test49[] = { 0xc1, 0x1a, 0x51, 0x4b, 0x67, + 0xb0 }, + test50[] = { 0xc1, 0xfb, 0x41, 0xd4, 0x52, + 0xd9, 0xec, 0x20, 0x00, 0x00 }, + test51[] = { 0xd7, 0x44, 0x01, 0x02, 0x03, + 0x04 }, + test52[] = { 0xd8, 0x18, 0x45, 0x64, 0x49, + 0x45, 0x54, 0x46 }, + test53[] = { 0xd8, 0x20, 0x76, 0x68, 0x74, + 0x74, 0x70, 0x3a, 0x2f, 0x2f, + 0x77, 0x77, 0x77, 0x2e, 0x65, + 0x78, 0x61, 0x6d, 0x70, 0x6c, + 0x65, 0x2e, 0x63, 0x6f, 0x6d }, + test54[] = { 0x40 }, + test55[] = { 0x44, 0x01, 0x02, 0x03, 0x04 }, + test56[] = { 0x60 }, + test57[] = { 0x61, 0x61 }, + test58[] = { 0x64, 0x49, 0x45, 0x54, 0x46 }, + test59[] = { 0x62, 0x22, 0x5c }, + test60[] = { 0x62, 0xc3, 0xbc }, + test61[] = { 0x63, 0xe6, 0xb0, 0xb4 }, + test62[] = { 0x64, 0xf0, 0x90, 0x85, 0x91 }, + test63[] = { 0x80 }, + test64[] = { 0x83, 0x01, 0x02, 0x03 }, + test65[] = { 0x83, 0x01, 0x82, 0x02, 0x03, + 0x82, 0x04, 0x05 }, + test66[] = { 0x98, 0x19, 0x01, 0x02, 0x03, + 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0a, 0x0b, 0x0c, 0x0d, + 0x0e, 0x0f, 0x10, 0x11, 0x12, + 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x18, 0x18, 0x19 }, + test67[] = { 0xa0 }, + test68[] = { 0xa2, 0x01, 0x02, 0x03, 0x04 }, + test69[] = { 0xa2, 0x61, 0x61, 0x01, 0x61, + 0x62, 0x82, 0x02, 0x03 }, + test70[] = { 0x82, 0x61, 0x61, 0xa1, 0x61, + 0x62, 0x61, 0x63 }, + test71[] = { 0xa5, 0x61, 0x61, 0x61, 0x41, + 0x61, 0x62, 0x61, 0x42, 0x61, + 0x63, 0x61, 0x43, 0x61, 0x64, + 0x61, 0x44, 0x61, 0x65, 0x61, + 0x45 }, + test72[] = { 0x5f, 0x42, 0x01, 0x02, 0x43, + 0x03, 0x04, 0x05, 0xff }, + test73[] = { 0x7f, 0x65, 0x73, 0x74, 0x72, + 0x65, 0x61, 0x64, 0x6d, 0x69, + 0x6e, 0x67, 0xff }, + test74[] = { 0x9f, 0xff }, + test75[] = { 0x9f, 0x01, 0x82, 0x02, 0x03, + 0x9f, 0x04, 0x05, 0xff, 0xff }, + test76[] = { 0x9f, 0x01, 0x82, 0x02, 0x03, + 0x82, 0x04, 0x05, 0xff }, + test77[] = { 0x83, 0x01, 0x82, 0x02, 0x03, + 0x9f, 0x04, 0x05, 0xff }, + test78[] = { 0x83, 0x01, 0x9f, 0x02, 0x03, + 0xff, 0x82, 0x04, 0x05 }, + test79[] = { 0x9f, 0x01, 0x02, 0x03, 0x04, + 0x05, 0x06, 0x07, 0x08, 0x09, + 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, + 0x0f, 0x10, 0x11, 0x12, 0x13, + 0x14, 0x15, 0x16, 0x17, 0x18, + 0x18, 0x18, 0x19, 0xff }, + test80[] = { 0xbf, 0x61, 0x61, 0x01, 0x61, + 0x62, 0x9f, 0x02, 0x03, 0xff, + 0xff }, + test81[] = { 0x82, 0x61, 0x61, 0xbf, 0x61, + 0x62, 0x61, 0x63, 0xff }, + test82[] = { 0xbf, 0x63, 0x46, 0x75, 0x6e, + 0xf5, 0x63, 0x41, 0x6d, 0x74, + 0x21, 0xff }, + + /* some random COSE examples + * + * COSE hmac-01 test vector + */ + + test83[] = { 0xD8, 0x61, 0x85, 0x43, 0xA1, + 0x01, 0x05, 0xA0, 0x54, 0x54, + 0x68, 0x69, 0x73, 0x20, 0x69, + 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6F, 0x6E, 0x74, + 0x65, 0x6E, 0x74, 0x2E, 0x58, + 0x20, 0x2B, 0xDC, 0xC8, 0x9F, + 0x05, 0x82, 0x16, 0xB8, 0xA2, + 0x08, 0xDD, 0xC6, 0xD8, 0xB5, + 0x4A, 0xA9, 0x1F, 0x48, 0xBD, + 0x63, 0x48, 0x49, 0x86, 0x56, + 0x51, 0x05, 0xC9, 0xAD, 0x5A, + 0x66, 0x82, 0xF6, 0x81, 0x83, + 0x40, 0xA2, 0x01, 0x25, 0x04, + 0x4A, 0x6F, 0x75, 0x72, 0x2D, + 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x40 }, + /* + * COSE hmac-02 test vector + */ + test84[] = { 0xD8, 0x61, 0x85, 0x43, 0xA1, + 0x01, 0x06, 0xA0, 0x54, 0x54, + 0x68, 0x69, 0x73, 0x20, 0x69, + 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6F, 0x6E, 0x74, + 0x65, 0x6E, 0x74, 0x2E, 0x58, + 0x30, 0xB3, 0x09, 0x7F, 0x70, + 0x00, 0x9A, 0x11, 0x50, 0x74, + 0x09, 0x59, 0x8A, 0x83, 0xE1, + 0x5B, 0xBB, 0xBF, 0x19, 0x82, + 0xDC, 0xE2, 0x8E, 0x5A, 0xB6, + 0xD5, 0xA6, 0xAF, 0xF6, 0x89, + 0x7B, 0xD2, 0x4B, 0xB8, 0xB7, + 0x47, 0x96, 0x22, 0xC9, 0x40, + 0x1B, 0x24, 0x09, 0x0D, 0x45, + 0x82, 0x06, 0xD5, 0x87, 0x81, + 0x83, 0x40, 0xA2, 0x01, 0x25, + 0x04, 0x46, 0x73, 0x65, 0x63, + 0x2D, 0x34, 0x38, 0x40 }, + test85[] = { 0xD8, 0x61, 0x85, 0x43, 0xA1, + 0x01, 0x07, 0xA0, 0x54, 0x54, + 0x68, 0x69, 0x73, 0x20, 0x69, + 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6F, 0x6E, 0x74, + 0x65, 0x6E, 0x74, 0x2E, 0x58, + 0x40, 0xCD, 0x28, 0xA6, 0xB3, + 0xCF, 0xBB, 0xBF, 0x21, 0x48, + 0x51, 0xB9, 0x06, 0xE0, 0x50, + 0x05, 0x6C, 0xB4, 0x38, 0xA8, + 0xB8, 0x89, 0x05, 0xB8, 0xB7, + 0x46, 0x19, 0x77, 0x02, 0x27, + 0x11, 0xA9, 0xD8, 0xAC, 0x5D, + 0xBC, 0x54, 0xE2, 0x9A, 0x56, + 0xD9, 0x26, 0x04, 0x6B, 0x40, + 0xFC, 0x26, 0x07, 0xC2, 0x5B, + 0x34, 0x44, 0x54, 0xAA, 0x5F, + 0x68, 0xDE, 0x09, 0xA3, 0xE5, + 0x25, 0xD3, 0x86, 0x5A, 0x05, + 0x81, 0x83, 0x40, 0xA2, 0x01, + 0x25, 0x04, 0x46, 0x73, 0x65, + 0x63, 0x2D, 0x36, 0x34, 0x40 }, + test86[] = { 0xD8, 0x61, 0x85, 0x43, 0xA1, + 0x01, 0x05, 0xA0, 0x54, 0x54, + 0x68, 0x69, 0x73, 0x20, 0x69, + 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6F, 0x6E, 0x74, + 0x65, 0x6E, 0x74, 0x2E, 0x58, + 0x20, 0x2B, 0xDC, 0xC8, 0x9F, + 0x05, 0x82, 0x16, 0xB8, 0xA2, + 0x08, 0xDD, 0xC6, 0xD8, 0xB5, + 0x4A, 0xA9, 0x1F, 0x48, 0xBD, + 0x63, 0x48, 0x49, 0x86, 0x56, + 0x51, 0x05, 0xC9, 0xAD, 0x5A, + 0x66, 0x82, 0xF7, 0x81, 0x83, + 0x40, 0xA2, 0x01, 0x25, 0x04, + 0x4A, 0x6F, 0x75, 0x72, 0x2D, + 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x40 }, + test87[] = { 0xD8, 0x61, 0x85, 0x43, 0xA1, + 0x01, 0x04, 0xA0, 0x54, 0x54, + 0x68, 0x69, 0x73, 0x20, 0x69, + 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6F, 0x6E, 0x74, + 0x65, 0x6E, 0x74, 0x2E, 0x48, + 0x6F, 0x35, 0xCA, 0xB7, 0x79, + 0xF7, 0x78, 0x33, 0x81, 0x83, + 0x40, 0xA2, 0x01, 0x25, 0x04, + 0x4A, 0x6F, 0x75, 0x72, 0x2D, + 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x40 + + /* COSE HMAX Enc 01 vector */ + + }, test88[] = { 0xD1, 0x84, 0x43, 0xA1, 0x01, + 0x05, 0xA0, 0x54, 0x54, 0x68, + 0x69, 0x73, 0x20, 0x69, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6F, 0x6E, 0x74, 0x65, + 0x6E, 0x74, 0x2E, 0x58, 0x20, + 0xA1, 0xA8, 0x48, 0xD3, 0x47, + 0x1F, 0x9D, 0x61, 0xEE, 0x49, + 0x01, 0x8D, 0x24, 0x4C, 0x82, + 0x47, 0x72, 0xF2, 0x23, 0xAD, + 0x4F, 0x93, 0x52, 0x93, 0xF1, + 0x78, 0x9F, 0xC3, 0xA0, 0x8D, + 0x8C, 0x58 + }, test89[] = { 0xD1, 0x84, 0x43, 0xA1, 0x01, + 0x06, 0xA0, 0x54, 0x54, 0x68, + 0x69, 0x73, 0x20, 0x69, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6F, 0x6E, 0x74, 0x65, + 0x6E, 0x74, 0x2E, 0x58, 0x30, + 0x99, 0x8D, 0x26, 0xC6, 0x45, + 0x9A, 0xAE, 0xEC, 0xF4, 0x4E, + 0xD2, 0x0C, 0xE0, 0x0C, 0x8C, + 0xCE, 0xDF, 0x0A, 0x1F, 0x3D, + 0x22, 0xA9, 0x2F, 0xC0, 0x5D, + 0xB0, 0x8C, 0x5A, 0xEB, 0x1C, + 0xB5, 0x94, 0xCA, 0xAF, 0x5A, + 0x5C, 0x5E, 0x2E, 0x9D, 0x01, + 0xCC, 0xE7, 0xE7, 0x7A, 0x93, + 0xAA, 0x8C, 0x62 + }, test90[] = { 0xD1, 0x84, 0x43, 0xA1, 0x01, + 0x07, 0xA0, 0x54, 0x54, 0x68, + 0x69, 0x73, 0x20, 0x69, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6F, 0x6E, 0x74, 0x65, + 0x6E, 0x74, 0x2E, 0x58, 0x40, + 0x4A, 0x55, 0x5B, 0xF9, 0x71, + 0xF7, 0xC1, 0x89, 0x1D, 0x9D, + 0xDF, 0x30, 0x4A, 0x1A, 0x13, + 0x2E, 0x2D, 0x6F, 0x81, 0x74, + 0x49, 0x47, 0x4D, 0x81, 0x3E, + 0x6D, 0x04, 0xD6, 0x59, 0x62, + 0xBE, 0xD8, 0xBB, 0xA7, 0x0C, + 0x17, 0xE1, 0xF5, 0x30, 0x8F, + 0xA3, 0x99, 0x62, 0x95, 0x9A, + 0x4B, 0x9B, 0x8D, 0x7D, 0xA8, + 0xE6, 0xD8, 0x49, 0xB2, 0x09, + 0xDC, 0xD3, 0xE9, 0x8C, 0xC0, + 0xF1, 0x1E, 0xDD, 0xF2 + + }, test91[] = { 0xD1, 0x84, 0x43, 0xA1, 0x01, + 0x05, 0xA0, 0x54, 0x54, 0x68, + 0x69, 0x73, 0x20, 0x69, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6F, 0x6E, 0x74, 0x65, + 0x6E, 0x74, 0x2E, 0x58, 0x20, + 0xA1, 0xA8, 0x48, 0xD3, 0x47, + 0x1F, 0x9D, 0x61, 0xEE, 0x49, + 0x01, 0x8D, 0x24, 0x4C, 0x82, + 0x47, 0x72, 0xF2, 0x23, 0xAD, + 0x4F, 0x93, 0x52, 0x93, 0xF1, + 0x78, 0x9F, 0xC3, 0xA0, 0x8D, + 0x8C, 0x59 + + }, test92[] = { 0xD1, 0x84, 0x43, 0xA1, 0x01, + 0x04, 0xA0, 0x54, 0x54, 0x68, + 0x69, 0x73, 0x20, 0x69, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6F, 0x6E, 0x74, 0x65, + 0x6E, 0x74, 0x2E, 0x48, 0x11, + 0xF9, 0xE3, 0x57, 0x97, 0x5F, + 0xB8, 0x49 + + /* + * COSE countersign encrypt-01 + */ + + }, test93[] = { + 0xd0, 0x83, 0x43, 0xa1, 0x01, + 0x01, 0xa2, 0x05, 0x4c, 0x02, + 0xd1, 0xf7, 0xe6, 0xf2, 0x6c, + 0x43, 0xd4, 0x86, 0x8d, 0x87, + 0xce, 0x07, 0x83, 0x43, 0xa1, + 0x01, 0x27, 0xa1, 0x04, 0x42, + 0x31, 0x31, 0x58, 0x40, 0xe1, + 0x04, 0x39, 0x15, 0x4c, 0xc7, + 0x5c, 0x7a, 0x3a, 0x53, 0x91, + 0x49, 0x1f, 0x88, 0x65, 0x1e, + 0x02, 0x92, 0xfd, 0x0f, 0xe0, + 0xe0, 0x2c, 0xf7, 0x40, 0x54, + 0x7e, 0xaf, 0x66, 0x77, 0xb4, + 0xa4, 0x04, 0x0b, 0x8e, 0xca, + 0x16, 0xdb, 0x59, 0x28, 0x81, + 0x26, 0x2f, 0x77, 0xb1, 0x4c, + 0x1a, 0x08, 0x6c, 0x02, 0x26, + 0x8b, 0x17, 0x17, 0x1c, 0xa1, + 0x6b, 0xe4, 0xb8, 0x59, 0x5f, + 0x8c, 0x0a, 0x08, 0x58, 0x24, + 0x60, 0x97, 0x3a, 0x94, 0xbb, + 0x28, 0x98, 0x00, 0x9e, 0xe5, + 0x2e, 0xcf, 0xd9, 0xab, 0x1d, + 0xd2, 0x58, 0x67, 0x37, 0x4b, + 0x16, 0x2e, 0x2c, 0x03, 0x56, + 0x8b, 0x41, 0xf5, 0x7c, 0x3c, + 0xc1, 0x6f, 0x91, 0x66, 0x25, + 0x0a + /* + * COSE countersign encrypt-02 + */ + }, test94[] = { + 0xd0, 0x83, 0x43, 0xa1, 0x01, + 0x01, 0xa2, 0x05, 0x4c, 0x02, + 0xd1, 0xf7, 0xe6, 0xf2, 0x6c, + 0x43, 0xd4, 0x86, 0x8d, 0x87, + 0xce, 0x07, 0x82, 0x83, 0x43, + 0xa1, 0x01, 0x27, 0xa1, 0x04, + 0x42, 0x31, 0x31, 0x58, 0x40, + 0xe1, 0x04, 0x39, 0x15, 0x4c, + 0xc7, 0x5c, 0x7a, 0x3a, 0x53, + 0x91, 0x49, 0x1f, 0x88, 0x65, + 0x1e, 0x02, 0x92, 0xfd, 0x0f, + 0xe0, 0xe0, 0x2c, 0xf7, 0x40, + 0x54, 0x7e, 0xaf, 0x66, 0x77, + 0xb4, 0xa4, 0x04, 0x0b, 0x8e, + 0xca, 0x16, 0xdb, 0x59, 0x28, + 0x81, 0x26, 0x2f, 0x77, 0xb1, + 0x4c, 0x1a, 0x08, 0x6c, 0x02, + 0x26, 0x8b, 0x17, 0x17, 0x1c, + 0xa1, 0x6b, 0xe4, 0xb8, 0x59, + 0x5f, 0x8c, 0x0a, 0x08, 0x83, + 0x43, 0xa1, 0x01, 0x26, 0xa1, + 0x04, 0x42, 0x31, 0x31, 0x58, + 0x40, 0xfc, 0xa9, 0x8e, 0xca, + 0xc8, 0x0b, 0x5f, 0xeb, 0x3a, + 0xc7, 0xc1, 0x08, 0xb2, 0xb7, + 0x91, 0x10, 0xde, 0x88, 0x86, + 0x7b, 0xc0, 0x42, 0x6f, 0xc8, + 0x3c, 0x53, 0xcc, 0xd6, 0x78, + 0x96, 0x94, 0xed, 0xc5, 0xfe, + 0xe3, 0xc4, 0x0d, 0xe8, 0xe7, + 0xb4, 0x4f, 0xe8, 0xaa, 0xd3, + 0x67, 0xe0, 0x95, 0xc8, 0xfc, + 0x31, 0xb7, 0x9e, 0xe6, 0x66, + 0xdf, 0x9c, 0xf9, 0x09, 0x06, + 0xeb, 0x43, 0x75, 0x6c, 0x73, + 0x58, 0x24, 0x60, 0x97, 0x3a, + 0x94, 0xbb, 0x28, 0x98, 0x00, + 0x9e, 0xe5, 0x2e, 0xcf, 0xd9, + 0xab, 0x1d, 0xd2, 0x58, 0x67, + 0x37, 0x4b, 0x16, 0x2e, 0x2c, + 0x03, 0x56, 0x8b, 0x41, 0xf5, + 0x7c, 0x3c, 0xc1, 0x6f, 0x91, + 0x66, 0x25, 0x0a + + /* + * COSE countersign enveloped-01 + */ + }, test95[] = { + 0xd8, 0x60, 0x84, 0x43, 0xa1, + 0x01, 0x01, 0xa2, 0x05, 0x4c, + 0x02, 0xd1, 0xf7, 0xe6, 0xf2, + 0x6c, 0x43, 0xd4, 0x86, 0x8d, + 0x87, 0xce, 0x07, 0x83, 0x43, + 0xa1, 0x01, 0x27, 0xa1, 0x04, + 0x42, 0x31, 0x31, 0x58, 0x40, + 0x9a, 0x8e, 0xed, 0xe3, 0xb3, + 0xcb, 0x83, 0x7b, 0xa0, 0x0d, + 0xf0, 0x8f, 0xa2, 0x1b, 0x12, + 0x8b, 0x2d, 0x6d, 0x91, 0x62, + 0xa4, 0x29, 0x0a, 0x58, 0x2d, + 0x9f, 0x19, 0xbd, 0x0f, 0xb5, + 0x02, 0xf0, 0xf9, 0x2b, 0x9b, + 0xf4, 0x53, 0xa4, 0x05, 0x40, + 0x1f, 0x8b, 0x70, 0x55, 0xef, + 0x4e, 0x95, 0x8d, 0xf7, 0xf4, + 0xfb, 0xd7, 0xcf, 0xb4, 0xa0, + 0xc9, 0x71, 0x60, 0xf9, 0x47, + 0x2b, 0x0a, 0xa1, 0x04, 0x58, + 0x24, 0x60, 0x97, 0x3a, 0x94, + 0xbb, 0x28, 0x98, 0x00, 0x9e, + 0xe5, 0x2e, 0xcf, 0xd9, 0xab, + 0x1d, 0xd2, 0x58, 0x67, 0x37, + 0x4b, 0x35, 0x81, 0xf2, 0xc8, + 0x00, 0x39, 0x82, 0x63, 0x50, + 0xb9, 0x7a, 0xe2, 0x30, 0x0e, + 0x42, 0xfc, 0x81, 0x83, 0x40, + 0xa2, 0x01, 0x25, 0x04, 0x4a, + 0x6f, 0x75, 0x72, 0x2d, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74, + 0x40 + }, test96[] = { + 0xd8, 0x60, 0x84, 0x43, 0xa1, + 0x01, 0x01, 0xa2, 0x05, 0x4c, + 0x02, 0xd1, 0xf7, 0xe6, 0xf2, + 0x6c, 0x43, 0xd4, 0x86, 0x8d, + 0x87, 0xce, 0x07, 0x82, 0x83, + 0x43, 0xa1, 0x01, 0x27, 0xa1, + 0x04, 0x42, 0x31, 0x31, 0x58, + 0x40, 0x9a, 0x8e, 0xed, 0xe3, + 0xb3, 0xcb, 0x83, 0x7b, 0xa0, + 0x0d, 0xf0, 0x8f, 0xa2, 0x1b, + 0x12, 0x8b, 0x2d, 0x6d, 0x91, + 0x62, 0xa4, 0x29, 0x0a, 0x58, + 0x2d, 0x9f, 0x19, 0xbd, 0x0f, + 0xb5, 0x02, 0xf0, 0xf9, 0x2b, + 0x9b, 0xf4, 0x53, 0xa4, 0x05, + 0x40, 0x1f, 0x8b, 0x70, 0x55, + 0xef, 0x4e, 0x95, 0x8d, 0xf7, + 0xf4, 0xfb, 0xd7, 0xcf, 0xb4, + 0xa0, 0xc9, 0x71, 0x60, 0xf9, + 0x47, 0x2b, 0x0a, 0xa1, 0x04, + 0x83, 0x43, 0xa1, 0x01, 0x26, + 0xa1, 0x04, 0x42, 0x31, 0x31, + 0x58, 0x40, 0x24, 0x27, 0xcb, + 0x37, 0x56, 0x85, 0x0f, 0xbb, + 0x79, 0x05, 0x18, 0x07, 0xc8, + 0xb2, 0x3d, 0x2e, 0x6d, 0x16, + 0xa3, 0x22, 0x4f, 0x99, 0x01, + 0xb4, 0x73, 0x99, 0xcf, 0xc7, + 0xe3, 0xfa, 0xc4, 0xcc, 0x62, + 0x1d, 0xbb, 0xeb, 0x02, 0x02, + 0xa6, 0xd8, 0xbb, 0x25, 0x69, + 0x5c, 0x9d, 0xcc, 0x9c, 0x47, + 0x49, 0x20, 0xff, 0x57, 0x60, + 0x6d, 0x76, 0x4d, 0xea, 0x19, + 0x2f, 0xc8, 0x67, 0x41, 0x16, + 0xf2, 0x58, 0x24, 0x60, 0x97, + 0x3a, 0x94, 0xbb, 0x28, 0x98, + 0x00, 0x9e, 0xe5, 0x2e, 0xcf, + 0xd9, 0xab, 0x1d, 0xd2, 0x58, + 0x67, 0x37, 0x4b, 0x35, 0x81, + 0xf2, 0xc8, 0x00, 0x39, 0x82, + 0x63, 0x50, 0xb9, 0x7a, 0xe2, + 0x30, 0x0e, 0x42, 0xfc, 0x81, + 0x83, 0x40, 0xa2, 0x01, 0x25, + 0x04, 0x4a, 0x6f, 0x75, 0x72, + 0x2d, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x40 + + }, test97[] = { + 0xd8, 0x60, 0x84, 0x43, 0xa1, + 0x01, 0x01, 0xa1, 0x05, 0x4c, + 0x02, 0xd1, 0xf7, 0xe6, 0xf2, + 0x6c, 0x43, 0xd4, 0x86, 0x8d, + 0x87, 0xce, 0x58, 0x24, 0x60, + 0x97, 0x3a, 0x94, 0xbb, 0x28, + 0x98, 0x00, 0x9e, 0xe5, 0x2e, + 0xcf, 0xd9, 0xab, 0x1d, 0xd2, + 0x58, 0x67, 0x37, 0x4b, 0x35, + 0x81, 0xf2, 0xc8, 0x00, 0x39, + 0x82, 0x63, 0x50, 0xb9, 0x7a, + 0xe2, 0x30, 0x0e, 0x42, 0xfc, + 0x81, 0x83, 0x40, 0xa3, 0x01, + 0x25, 0x04, 0x4a, 0x6f, 0x75, + 0x72, 0x2d, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x07, 0x83, + 0x43, 0xa1, 0x01, 0x27, 0xa1, + 0x04, 0x42, 0x31, 0x31, 0x58, + 0x40, 0xcc, 0xb1, 0xf3, 0xfe, + 0xdf, 0xce, 0xa7, 0x2b, 0x9c, + 0x86, 0x79, 0x63, 0xe2, 0x52, + 0xb6, 0x65, 0x8a, 0xd0, 0x7f, + 0x3f, 0x5f, 0x15, 0xa3, 0x26, + 0xa3, 0xf5, 0x72, 0x54, 0xcc, + 0xb8, 0xd4, 0x8d, 0x60, 0x02, + 0x1d, 0x2f, 0x1f, 0x8a, 0x80, + 0x3b, 0x84, 0x4b, 0x78, 0x72, + 0x16, 0x6c, 0x6d, 0x45, 0x90, + 0x25, 0xd2, 0x1c, 0x8c, 0x84, + 0x62, 0xa2, 0x44, 0xba, 0x19, + 0x60, 0x4e, 0xc4, 0xd5, 0x0b, + 0x40 + }, test98[] = { + 0xd8, 0x61, 0x85, 0x43, 0xa1, + 0x01, 0x05, 0xa1, 0x07, 0x83, + 0x43, 0xa1, 0x01, 0x27, 0xa1, + 0x04, 0x42, 0x31, 0x31, 0x58, + 0x40, 0xb4, 0x92, 0x4b, 0x18, + 0xeb, 0x4e, 0x04, 0x73, 0x13, + 0xc7, 0x07, 0xb0, 0xed, 0xa4, + 0xab, 0x84, 0x43, 0x45, 0xf2, + 0xc4, 0x49, 0x87, 0xd6, 0xf9, + 0xeb, 0xcc, 0x77, 0x7e, 0xfd, + 0x40, 0x78, 0xcc, 0x0f, 0x4c, + 0x10, 0x8d, 0xef, 0x95, 0x9f, + 0x78, 0xf1, 0xed, 0xb2, 0x76, + 0x54, 0x25, 0x78, 0x5f, 0xcd, + 0x17, 0xd5, 0x12, 0xbe, 0x31, + 0xee, 0xb6, 0x6b, 0xef, 0xf1, + 0xe8, 0xfc, 0x27, 0x47, 0x07, + 0x54, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x69, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x2e, 0x58, 0x20, 0x2b, 0xdc, + 0xc8, 0x9f, 0x05, 0x82, 0x16, + 0xb8, 0xa2, 0x08, 0xdd, 0xc6, + 0xd8, 0xb5, 0x4a, 0xa9, 0x1f, + 0x48, 0xbd, 0x63, 0x48, 0x49, + 0x86, 0x56, 0x51, 0x05, 0xc9, + 0xad, 0x5a, 0x66, 0x82, 0xf6, + 0x81, 0x83, 0x40, 0xa2, 0x01, + 0x25, 0x04, 0x4a, 0x6f, 0x75, + 0x72, 0x2d, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x40 + }, test99[] = { + 0xd8, 0x61, 0x85, 0x43, 0xa1, + 0x01, 0x05, 0xa1, 0x07, 0x82, + 0x83, 0x43, 0xa1, 0x01, 0x27, + 0xa1, 0x04, 0x42, 0x31, 0x31, + 0x58, 0x40, 0xb4, 0x92, 0x4b, + 0x18, 0xeb, 0x4e, 0x04, 0x73, + 0x13, 0xc7, 0x07, 0xb0, 0xed, + 0xa4, 0xab, 0x84, 0x43, 0x45, + 0xf2, 0xc4, 0x49, 0x87, 0xd6, + 0xf9, 0xeb, 0xcc, 0x77, 0x7e, + 0xfd, 0x40, 0x78, 0xcc, 0x0f, + 0x4c, 0x10, 0x8d, 0xef, 0x95, + 0x9f, 0x78, 0xf1, 0xed, 0xb2, + 0x76, 0x54, 0x25, 0x78, 0x5f, + 0xcd, 0x17, 0xd5, 0x12, 0xbe, + 0x31, 0xee, 0xb6, 0x6b, 0xef, + 0xf1, 0xe8, 0xfc, 0x27, 0x47, + 0x07, 0x83, 0x43, 0xa1, 0x01, + 0x26, 0xa1, 0x04, 0x42, 0x31, + 0x31, 0x58, 0x40, 0x6a, 0xcd, + 0x94, 0xd3, 0xcc, 0xf7, 0x1d, + 0x19, 0x2e, 0x85, 0x28, 0x36, + 0x0b, 0xa7, 0xe3, 0x46, 0xda, + 0xc4, 0x64, 0xe9, 0xed, 0xca, + 0x4c, 0xfe, 0xb6, 0xce, 0xb6, + 0xbd, 0xe7, 0xba, 0xec, 0x9f, + 0xf2, 0x6c, 0xa6, 0xbd, 0xf7, + 0x3d, 0x0b, 0xe4, 0x1e, 0x36, + 0x12, 0x9d, 0xcf, 0xf7, 0x51, + 0xdd, 0x2b, 0x5a, 0xd5, 0xce, + 0x11, 0x6e, 0x8a, 0x96, 0x3a, + 0x27, 0x38, 0xa2, 0x99, 0x47, + 0x7a, 0x68, 0x54, 0x54, 0x68, + 0x69, 0x73, 0x20, 0x69, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x2e, 0x58, 0x20, + 0x2b, 0xdc, 0xc8, 0x9f, 0x05, + 0x82, 0x16, 0xb8, 0xa2, 0x08, + 0xdd, 0xc6, 0xd8, 0xb5, 0x4a, + 0xa9, 0x1f, 0x48, 0xbd, 0x63, + 0x48, 0x49, 0x86, 0x56, 0x51, + 0x05, 0xc9, 0xad, 0x5a, 0x66, + 0x82, 0xf6, 0x81, 0x83, 0x40, + 0xa2, 0x01, 0x25, 0x04, 0x4a, + 0x6f, 0x75, 0x72, 0x2d, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74, + 0x40 + }, test100[] = { + 0xd1, 0x84, 0x43, 0xa1, 0x01, + 0x05, 0xa1, 0x07, 0x83, 0x43, + 0xa1, 0x01, 0x27, 0xa1, 0x04, + 0x42, 0x31, 0x31, 0x58, 0x40, + 0xb4, 0x92, 0x4b, 0x18, 0xeb, + 0x4e, 0x04, 0x73, 0x13, 0xc7, + 0x07, 0xb0, 0xed, 0xa4, 0xab, + 0x84, 0x43, 0x45, 0xf2, 0xc4, + 0x49, 0x87, 0xd6, 0xf9, 0xeb, + 0xcc, 0x77, 0x7e, 0xfd, 0x40, + 0x78, 0xcc, 0x0f, 0x4c, 0x10, + 0x8d, 0xef, 0x95, 0x9f, 0x78, + 0xf1, 0xed, 0xb2, 0x76, 0x54, + 0x25, 0x78, 0x5f, 0xcd, 0x17, + 0xd5, 0x12, 0xbe, 0x31, 0xee, + 0xb6, 0x6b, 0xef, 0xf1, 0xe8, + 0xfc, 0x27, 0x47, 0x07, 0x54, + 0x54, 0x68, 0x69, 0x73, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x2e, + 0x58, 0x20, 0xa1, 0xa8, 0x48, + 0xd3, 0x47, 0x1f, 0x9d, 0x61, + 0xee, 0x49, 0x01, 0x8d, 0x24, + 0x4c, 0x82, 0x47, 0x72, 0xf2, + 0x23, 0xad, 0x4f, 0x93, 0x52, + 0x93, 0xf1, 0x78, 0x9f, 0xc3, + 0xa0, 0x8d, 0x8c, 0x58 + }, test101[] = { /* mac-02 */ + 0xd8, 0x61, 0x85, 0x43, 0xa1, + 0x01, 0x05, 0xa1, 0x07, 0x82, + 0x83, 0x43, 0xa1, 0x01, 0x27, + 0xa1, 0x04, 0x42, 0x31, 0x31, + 0x58, 0x40, 0xb4, 0x92, 0x4b, + 0x18, 0xeb, 0x4e, 0x04, 0x73, + 0x13, 0xc7, 0x07, 0xb0, 0xed, + 0xa4, 0xab, 0x84, 0x43, 0x45, + 0xf2, 0xc4, 0x49, 0x87, 0xd6, + 0xf9, 0xeb, 0xcc, 0x77, 0x7e, + 0xfd, 0x40, 0x78, 0xcc, 0x0f, + 0x4c, 0x10, 0x8d, 0xef, 0x95, + 0x9f, 0x78, 0xf1, 0xed, 0xb2, + 0x76, 0x54, 0x25, 0x78, 0x5f, + 0xcd, 0x17, 0xd5, 0x12, 0xbe, + 0x31, 0xee, 0xb6, 0x6b, 0xef, + 0xf1, 0xe8, 0xfc, 0x27, 0x47, + 0x07, 0x83, 0x43, 0xa1, 0x01, + 0x26, 0xa1, 0x04, 0x42, 0x31, + 0x31, 0x58, 0x40, 0x6a, 0xcd, + 0x94, 0xd3, 0xcc, 0xf7, 0x1d, + 0x19, 0x2e, 0x85, 0x28, 0x36, + 0x0b, 0xa7, 0xe3, 0x46, 0xda, + 0xc4, 0x64, 0xe9, 0xed, 0xca, + 0x4c, 0xfe, 0xb6, 0xce, 0xb6, + 0xbd, 0xe7, 0xba, 0xec, 0x9f, + 0xf2, 0x6c, 0xa6, 0xbd, 0xf7, + 0x3d, 0x0b, 0xe4, 0x1e, 0x36, + 0x12, 0x9d, 0xcf, 0xf7, 0x51, + 0xdd, 0x2b, 0x5a, 0xd5, 0xce, + 0x11, 0x6e, 0x8a, 0x96, 0x3a, + 0x27, 0x38, 0xa2, 0x99, 0x47, + 0x7a, 0x68, 0x54, 0x54, 0x68, + 0x69, 0x73, 0x20, 0x69, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x2e, 0x58, 0x20, + 0x2b, 0xdc, 0xc8, 0x9f, 0x05, + 0x82, 0x16, 0xb8, 0xa2, 0x08, + 0xdd, 0xc6, 0xd8, 0xb5, 0x4a, + 0xa9, 0x1f, 0x48, 0xbd, 0x63, + 0x48, 0x49, 0x86, 0x56, 0x51, + 0x05, 0xc9, 0xad, 0x5a, 0x66, + 0x82, 0xf6, 0x81, 0x83, 0x40, + 0xa2, 0x01, 0x25, 0x04, 0x4a, + 0x6f, 0x75, 0x72, 0x2d, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74, + 0x40 + }, test102[] = { /* mac0-01 */ + 0xd1, 0x84, 0x43, 0xa1, 0x01, + 0x05, 0xa1, 0x07, 0x83, 0x43, + 0xa1, 0x01, 0x27, 0xa1, 0x04, + 0x42, 0x31, 0x31, 0x58, 0x40, + 0xb4, 0x92, 0x4b, 0x18, 0xeb, + 0x4e, 0x04, 0x73, 0x13, 0xc7, + 0x07, 0xb0, 0xed, 0xa4, 0xab, + 0x84, 0x43, 0x45, 0xf2, 0xc4, + 0x49, 0x87, 0xd6, 0xf9, 0xeb, + 0xcc, 0x77, 0x7e, 0xfd, 0x40, + 0x78, 0xcc, 0x0f, 0x4c, 0x10, + 0x8d, 0xef, 0x95, 0x9f, 0x78, + 0xf1, 0xed, 0xb2, 0x76, 0x54, + 0x25, 0x78, 0x5f, 0xcd, 0x17, + 0xd5, 0x12, 0xbe, 0x31, 0xee, + 0xb6, 0x6b, 0xef, 0xf1, 0xe8, + 0xfc, 0x27, 0x47, 0x07, 0x54, + 0x54, 0x68, 0x69, 0x73, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x2e, + 0x58, 0x20, 0xa1, 0xa8, 0x48, + 0xd3, 0x47, 0x1f, 0x9d, 0x61, + 0xee, 0x49, 0x01, 0x8d, 0x24, + 0x4c, 0x82, 0x47, 0x72, 0xf2, + 0x23, 0xad, 0x4f, 0x93, 0x52, + 0x93, 0xf1, 0x78, 0x9f, 0xc3, + 0xa0, 0x8d, 0x8c, 0x58 + }, test103[] = { /* mac0-02 */ + 0xd1, 0x84, 0x43, 0xa1, 0x01, + 0x05, 0xa1, 0x07, 0x82, 0x83, + 0x43, 0xa1, 0x01, 0x27, 0xa1, + 0x04, 0x42, 0x31, 0x31, 0x58, + 0x40, 0xb4, 0x92, 0x4b, 0x18, + 0xeb, 0x4e, 0x04, 0x73, 0x13, + 0xc7, 0x07, 0xb0, 0xed, 0xa4, + 0xab, 0x84, 0x43, 0x45, 0xf2, + 0xc4, 0x49, 0x87, 0xd6, 0xf9, + 0xeb, 0xcc, 0x77, 0x7e, 0xfd, + 0x40, 0x78, 0xcc, 0x0f, 0x4c, + 0x10, 0x8d, 0xef, 0x95, 0x9f, + 0x78, 0xf1, 0xed, 0xb2, 0x76, + 0x54, 0x25, 0x78, 0x5f, 0xcd, + 0x17, 0xd5, 0x12, 0xbe, 0x31, + 0xee, 0xb6, 0x6b, 0xef, 0xf1, + 0xe8, 0xfc, 0x27, 0x47, 0x07, + 0x83, 0x43, 0xa1, 0x01, 0x26, + 0xa1, 0x04, 0x42, 0x31, 0x31, + 0x58, 0x40, 0x6a, 0xcd, 0x94, + 0xd3, 0xcc, 0xf7, 0x1d, 0x19, + 0x2e, 0x85, 0x28, 0x36, 0x0b, + 0xa7, 0xe3, 0x46, 0xda, 0xc4, + 0x64, 0xe9, 0xed, 0xca, 0x4c, + 0xfe, 0xb6, 0xce, 0xb6, 0xbd, + 0xe7, 0xba, 0xec, 0x9f, 0xf2, + 0x6c, 0xa6, 0xbd, 0xf7, 0x3d, + 0x0b, 0xe4, 0x1e, 0x36, 0x12, + 0x9d, 0xcf, 0xf7, 0x51, 0xdd, + 0x2b, 0x5a, 0xd5, 0xce, 0x11, + 0x6e, 0x8a, 0x96, 0x3a, 0x27, + 0x38, 0xa2, 0x99, 0x47, 0x7a, + 0x68, 0x54, 0x54, 0x68, 0x69, + 0x73, 0x20, 0x69, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x2e, 0x58, 0x20, 0xa1, + 0xa8, 0x48, 0xd3, 0x47, 0x1f, + 0x9d, 0x61, 0xee, 0x49, 0x01, + 0x8d, 0x24, 0x4c, 0x82, 0x47, + 0x72, 0xf2, 0x23, 0xad, 0x4f, + 0x93, 0x52, 0x93, 0xf1, 0x78, + 0x9f, 0xc3, 0xa0, 0x8d, 0x8c, + 0x58 + }, test104[] = { /* signed-01 */ + 0xd8, 0x62, 0x84, 0x43, 0xa1, + 0x03, 0x00, 0xa0, 0x54, 0x54, + 0x68, 0x69, 0x73, 0x20, 0x69, + 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x2e, 0x81, + 0x83, 0x43, 0xa1, 0x01, 0x27, + 0xa2, 0x07, 0x83, 0x43, 0xa1, + 0x01, 0x27, 0xa1, 0x04, 0x42, + 0x31, 0x31, 0x58, 0x40, 0x8e, + 0x1b, 0xe2, 0xf9, 0x45, 0x3d, + 0x26, 0x48, 0x12, 0xe5, 0x90, + 0x49, 0x91, 0x32, 0xbe, 0xf3, + 0xfb, 0xf9, 0xee, 0x9d, 0xb2, + 0x7c, 0x2c, 0x16, 0x87, 0x88, + 0xe3, 0xb7, 0xeb, 0xe5, 0x06, + 0xc0, 0x4f, 0xd3, 0xd1, 0x9f, + 0xaa, 0x9f, 0x51, 0x23, 0x2a, + 0xf5, 0xc9, 0x59, 0xe4, 0xef, + 0x47, 0x92, 0x88, 0x34, 0x64, + 0x7f, 0x56, 0xdf, 0xbe, 0x93, + 0x91, 0x12, 0x88, 0x4d, 0x08, + 0xef, 0x25, 0x05, 0x04, 0x42, + 0x31, 0x31, 0x58, 0x40, 0x77, + 0xf3, 0xea, 0xcd, 0x11, 0x85, + 0x2c, 0x4b, 0xf9, 0xcb, 0x1d, + 0x72, 0xfa, 0xbe, 0x6b, 0x26, + 0xfb, 0xa1, 0xd7, 0x60, 0x92, + 0xb2, 0xb5, 0xb7, 0xec, 0x83, + 0xb8, 0x35, 0x57, 0x65, 0x22, + 0x64, 0xe6, 0x96, 0x90, 0xdb, + 0xc1, 0x17, 0x2d, 0xdc, 0x0b, + 0xf8, 0x84, 0x11, 0xc0, 0xd2, + 0x5a, 0x50, 0x7f, 0xdb, 0x24, + 0x7a, 0x20, 0xc4, 0x0d, 0x5e, + 0x24, 0x5f, 0xab, 0xd3, 0xfc, + 0x9e, 0xc1, 0x06 + }, test105[] = { /* signed-02 */ + 0xd8, 0x62, 0x84, 0x43, 0xa1, + 0x03, 0x00, 0xa0, 0x54, 0x54, + 0x68, 0x69, 0x73, 0x20, 0x69, + 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x2e, 0x81, + 0x83, 0x43, 0xa1, 0x01, 0x27, + 0xa2, 0x07, 0x82, 0x83, 0x43, + 0xa1, 0x01, 0x27, 0xa1, 0x04, + 0x42, 0x31, 0x31, 0x58, 0x40, + 0x8e, 0x1b, 0xe2, 0xf9, 0x45, + 0x3d, 0x26, 0x48, 0x12, 0xe5, + 0x90, 0x49, 0x91, 0x32, 0xbe, + 0xf3, 0xfb, 0xf9, 0xee, 0x9d, + 0xb2, 0x7c, 0x2c, 0x16, 0x87, + 0x88, 0xe3, 0xb7, 0xeb, 0xe5, + 0x06, 0xc0, 0x4f, 0xd3, 0xd1, + 0x9f, 0xaa, 0x9f, 0x51, 0x23, + 0x2a, 0xf5, 0xc9, 0x59, 0xe4, + 0xef, 0x47, 0x92, 0x88, 0x34, + 0x64, 0x7f, 0x56, 0xdf, 0xbe, + 0x93, 0x91, 0x12, 0x88, 0x4d, + 0x08, 0xef, 0x25, 0x05, 0x83, + 0x43, 0xa1, 0x01, 0x26, 0xa1, + 0x04, 0x42, 0x31, 0x31, 0x58, + 0x40, 0xaf, 0x04, 0x9b, 0x80, + 0xd5, 0x2c, 0x36, 0x69, 0xb2, + 0x99, 0x70, 0xc1, 0x33, 0x54, + 0x37, 0x54, 0xf9, 0xcc, 0x60, + 0x8c, 0xe4, 0x11, 0x23, 0xae, + 0x1c, 0x82, 0x7e, 0x36, 0xb3, + 0x8c, 0xb8, 0x25, 0x98, 0x7f, + 0x01, 0xf2, 0x2b, 0xb8, 0xab, + 0x13, 0xe9, 0xc6, 0x62, 0x26, + 0xee, 0x23, 0x17, 0x8f, 0xfa, + 0x00, 0xa4, 0xfc, 0x22, 0x05, + 0x93, 0xb6, 0xe5, 0xac, 0x38, + 0x96, 0x00, 0x71, 0xc9, 0xc8, + 0x04, 0x42, 0x31, 0x31, 0x58, + 0x40, 0x77, 0xf3, 0xea, 0xcd, + 0x11, 0x85, 0x2c, 0x4b, 0xf9, + 0xcb, 0x1d, 0x72, 0xfa, 0xbe, + 0x6b, 0x26, 0xfb, 0xa1, 0xd7, + 0x60, 0x92, 0xb2, 0xb5, 0xb7, + 0xec, 0x83, 0xb8, 0x35, 0x57, + 0x65, 0x22, 0x64, 0xe6, 0x96, + 0x90, 0xdb, 0xc1, 0x17, 0x2d, + 0xdc, 0x0b, 0xf8, 0x84, 0x11, + 0xc0, 0xd2, 0x5a, 0x50, 0x7f, + 0xdb, 0x24, 0x7a, 0x20, 0xc4, + 0x0d, 0x5e, 0x24, 0x5f, 0xab, + 0xd3, 0xfc, 0x9e, 0xc1, 0x06 + }, test106[] = { /* signed-03 */ + 0xd8, 0x62, 0x84, 0x43, 0xa1, + 0x03, 0x00, 0xa1, 0x07, 0x83, + 0x43, 0xa1, 0x01, 0x27, 0xa1, + 0x04, 0x42, 0x31, 0x31, 0x58, + 0x40, 0xb7, 0xca, 0xcb, 0xa2, + 0x85, 0xc4, 0xcd, 0x3e, 0xd2, + 0xf0, 0x14, 0x6f, 0x41, 0x98, + 0x86, 0x14, 0x4c, 0xa6, 0x38, + 0xd0, 0x87, 0xde, 0x12, 0x3d, + 0x40, 0x01, 0x67, 0x30, 0x8a, + 0xce, 0xab, 0xc4, 0xb5, 0xe5, + 0xc6, 0xa4, 0x0c, 0x0d, 0xe0, + 0xb7, 0x11, 0x67, 0xa3, 0x91, + 0x75, 0xea, 0x56, 0xc1, 0xfe, + 0x96, 0xc8, 0x9e, 0x5e, 0x7d, + 0x30, 0xda, 0xf2, 0x43, 0x8a, + 0x45, 0x61, 0x59, 0xa2, 0x0a, + 0x54, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x69, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x2e, 0x81, 0x83, 0x43, 0xa1, + 0x01, 0x27, 0xa1, 0x04, 0x42, + 0x31, 0x31, 0x58, 0x40, 0x77, + 0xf3, 0xea, 0xcd, 0x11, 0x85, + 0x2c, 0x4b, 0xf9, 0xcb, 0x1d, + 0x72, 0xfa, 0xbe, 0x6b, 0x26, + 0xfb, 0xa1, 0xd7, 0x60, 0x92, + 0xb2, 0xb5, 0xb7, 0xec, 0x83, + 0xb8, 0x35, 0x57, 0x65, 0x22, + 0x64, 0xe6, 0x96, 0x90, 0xdb, + 0xc1, 0x17, 0x2d, 0xdc, 0x0b, + 0xf8, 0x84, 0x11, 0xc0, 0xd2, + 0x5a, 0x50, 0x7f, 0xdb, 0x24, + 0x7a, 0x20, 0xc4, 0x0d, 0x5e, + 0x24, 0x5f, 0xab, 0xd3, 0xfc, + 0x9e, 0xc1, 0x06 + }, test107[] = { /* signed1-01 */ + 0xd2, 0x84, 0x45, 0xa2, 0x01, + 0x27, 0x03, 0x00, 0xa2, 0x07, + 0x83, 0x43, 0xa1, 0x01, 0x27, + 0xa1, 0x04, 0x42, 0x31, 0x31, + 0x58, 0x40, 0x6d, 0xae, 0xd1, + 0x58, 0xaf, 0xe4, 0x03, 0x2e, + 0x8d, 0xd4, 0x77, 0xd3, 0xd2, + 0xb7, 0xf6, 0x67, 0xe7, 0x95, + 0x7a, 0xa8, 0x30, 0x2b, 0xb5, + 0xe5, 0x68, 0xb4, 0xdc, 0xbc, + 0xce, 0x3c, 0xf0, 0xed, 0x5a, + 0x90, 0xf8, 0x31, 0x35, 0x1c, + 0x85, 0xd6, 0x15, 0x5a, 0x42, + 0xa1, 0x7c, 0xa1, 0xf2, 0x5f, + 0x50, 0x1c, 0xc1, 0x3f, 0x67, + 0x10, 0x8a, 0xe5, 0x3b, 0xda, + 0x92, 0xdb, 0x88, 0x27, 0x2e, + 0x00, 0x04, 0x42, 0x31, 0x31, + 0x54, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x69, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x2e, 0x58, 0x40, 0x71, 0x42, + 0xfd, 0x2f, 0xf9, 0x6d, 0x56, + 0xdb, 0x85, 0xbe, 0xe9, 0x05, + 0xa7, 0x6b, 0xa1, 0xd0, 0xb7, + 0x32, 0x1a, 0x95, 0xc8, 0xc4, + 0xd3, 0x60, 0x7c, 0x57, 0x81, + 0x93, 0x2b, 0x7a, 0xfb, 0x87, + 0x11, 0x49, 0x7d, 0xfa, 0x75, + 0x1b, 0xf4, 0x0b, 0x58, 0xb3, + 0xbc, 0xc3, 0x23, 0x00, 0xb1, + 0x48, 0x7f, 0x3d, 0xb3, 0x40, + 0x85, 0xee, 0xf0, 0x13, 0xbf, + 0x08, 0xf4, 0xa4, 0x4d, 0x6f, + 0xef, 0x0d + }, test108[] = { /* signed1-02 */ + 0xd2, 0x84, 0x45, 0xa2, 0x01, + 0x27, 0x03, 0x00, 0xa2, 0x07, + 0x82, 0x83, 0x43, 0xa1, 0x01, + 0x27, 0xa1, 0x04, 0x42, 0x31, + 0x31, 0x58, 0x40, 0x6d, 0xae, + 0xd1, 0x58, 0xaf, 0xe4, 0x03, + 0x2e, 0x8d, 0xd4, 0x77, 0xd3, + 0xd2, 0xb7, 0xf6, 0x67, 0xe7, + 0x95, 0x7a, 0xa8, 0x30, 0x2b, + 0xb5, 0xe5, 0x68, 0xb4, 0xdc, + 0xbc, 0xce, 0x3c, 0xf0, 0xed, + 0x5a, 0x90, 0xf8, 0x31, 0x35, + 0x1c, 0x85, 0xd6, 0x15, 0x5a, + 0x42, 0xa1, 0x7c, 0xa1, 0xf2, + 0x5f, 0x50, 0x1c, 0xc1, 0x3f, + 0x67, 0x10, 0x8a, 0xe5, 0x3b, + 0xda, 0x92, 0xdb, 0x88, 0x27, + 0x2e, 0x00, 0x83, 0x43, 0xa1, + 0x01, 0x26, 0xa1, 0x04, 0x42, + 0x31, 0x31, 0x58, 0x40, 0x93, + 0x48, 0x7d, 0x09, 0x25, 0x6a, + 0x3e, 0xf4, 0x96, 0x37, 0x19, + 0xba, 0x5c, 0xf1, 0x01, 0xac, + 0xe2, 0xfc, 0x13, 0xd6, 0x31, + 0x4b, 0x49, 0x58, 0x21, 0x71, + 0xff, 0xa4, 0xa1, 0x31, 0x4d, + 0xc9, 0x3e, 0x4a, 0x4a, 0xdf, + 0xa4, 0x2a, 0x79, 0xe3, 0x1b, + 0x35, 0xd7, 0x30, 0x43, 0x58, + 0x58, 0x5b, 0x41, 0x79, 0x96, + 0x78, 0xce, 0x00, 0xca, 0x47, + 0xc3, 0xe0, 0x23, 0x86, 0x39, + 0x23, 0xf8, 0xc8, 0x04, 0x42, + 0x31, 0x31, 0x54, 0x54, 0x68, + 0x69, 0x73, 0x20, 0x69, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x2e, 0x58, 0x40, + 0x71, 0x42, 0xfd, 0x2f, 0xf9, + 0x6d, 0x56, 0xdb, 0x85, 0xbe, + 0xe9, 0x05, 0xa7, 0x6b, 0xa1, + 0xd0, 0xb7, 0x32, 0x1a, 0x95, + 0xc8, 0xc4, 0xd3, 0x60, 0x7c, + 0x57, 0x81, 0x93, 0x2b, 0x7a, + 0xfb, 0x87, 0x11, 0x49, 0x7d, + 0xfa, 0x75, 0x1b, 0xf4, 0x0b, + 0x58, 0xb3, 0xbc, 0xc3, 0x23, + 0x00, 0xb1, 0x48, 0x7f, 0x3d, + 0xb3, 0x40, 0x85, 0xee, 0xf0, + 0x13, 0xbf, 0x08, 0xf4, 0xa4, + 0x4d, 0x6f, 0xef, 0x0d + }; +; + +struct seq { + char reason; + struct lecp_item item; + const uint8_t *buf; + size_t buf_len; +}; + +static const uint8_t bm12[] = { + 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00 +}, bm48[] = { + 0x32, 0x30, 0x31, 0x33, + 0x2D, 0x30, 0x33, 0x2D, + 0x32, 0x31, 0x54, 0x32, + 0x30, 0x3A, 0x30, 0x34, + 0x3A, 0x30, 0x30, 0x5A +}, bm51[] = { + 0x01, 0x02, 0x03, 0x04 +}, bm52[] = { + 0x64, 0x49, 0x45, 0x54, + 0x46 +}, bm53[] = { + 0x68, 0x74, 0x74, 0x70, + 0x3A, 0x2F, 0x2F, 0x77, + 0x77, 0x77, 0x2E, 0x65, + 0x78, 0x61, 0x6D, 0x70, + 0x6C, 0x65, 0x2E, 0x63, + 0x6F, 0x6D +}, bm57[] = { + 0x61 +}, bm58[] = { + 0x49, 0x45, 0x54, 0x46 +}, bm59[] = { + 0x22, 0x5C +}, bm60[] = { + 0xc3, 0xbc +}, bm61[] = { + 0xe6, 0xb0, 0xb4 +}, bm62[] = { + 0xF0, 0x90, 0x85, 0x91 +}, bm72a[] = { + 0x01, 0x02 +}, bm72b[] = { + 0x03, 0x04, 0x05 +}, bm83a[] = { + 0xa1, 0x01, 0x05 +}, bm83b[] = { + 0x54, 0x68, 0x69, 0x73, + 0x20, 0x69, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6F, 0x6E, 0x74, + 0x65, 0x6E, 0x74, 0x2E +}, bm83c[] = { + 0x2B, 0xDC, 0xC8, 0x9F, + 0x05, 0x82, 0x16, 0xB8, + 0xA2, 0x08, 0xDD, 0xC6, + 0xD8, 0xB5, 0x4A, 0xA9, + 0x1F, 0x48, 0xBD, 0x63, + 0x48, 0x49, 0x86, 0x56, + 0x51, 0x05, 0xC9, 0xAD, + 0x5A, 0x66, 0x82, 0xF6 +}, bm83d[] = { + 0x6F, 0x75, 0x72, 0x2D, + 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74 +}, bm84a[] = { + 0xa1, 0x01, 0x06 +}, bm84b[] = { + 0x54, 0x68, 0x69, 0x73, + 0x20, 0x69, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6F, 0x6E, 0x74, + 0x65, 0x6E, 0x74, 0x2E +}, bm84c[] = { + 0xB3, 0x09, 0x7F, 0x70, + 0x00, 0x9A, 0x11, 0x50, + 0x74, 0x09, 0x59, 0x8A, + 0x83, 0xE1, 0x5B, 0xBB, + 0xBF, 0x19, 0x82, 0xDC, + 0xE2, 0x8E, 0x5A, 0xB6, + 0xD5, 0xA6, 0xAF, 0xF6, + 0x89, 0x7B, 0xD2, 0x4B, + 0xB8, 0xB7, 0x47, 0x96, + 0x22, 0xC9, 0x40, 0x1B, + 0x24, 0x09, 0x0D, 0x45, + 0x82, 0x06, 0xD5, 0x87 +}, bm84d[] = { + 0x73, 0x65, 0x63, 0x2D, + 0x34, 0x38 +}, bm85a[] = { + 0xa1, 0x01, 0x07 +}, bm85b[] = { + 0x54, 0x68, 0x69, 0x73, + 0x20, 0x69, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6F, 0x6E, 0x74, + 0x65, 0x6E, 0x74, 0x2E +}, bm85c[] = { + 0xCD, 0x28, 0xA6, 0xB3, + 0xCF, 0xBB, 0xBF, 0x21, + 0x48, 0x51, 0xB9, 0x06, + 0xE0, 0x50, 0x05, 0x6C, + 0xB4, 0x38, 0xA8, 0xB8, + 0x89, 0x05, 0xB8, 0xB7, + 0x46, 0x19, 0x77, 0x02, + 0x27, 0x11, 0xA9, 0xD8, + 0xAC, 0x5D, 0xBC, 0x54, + 0xE2, 0x9A, 0x56, 0xD9, + 0x26, 0x04, 0x6B, 0x40, + 0xFC, 0x26, 0x07, 0xC2, + 0x5B, 0x34, 0x44, 0x54, + 0xAA, 0x5F, 0x68, 0xDE, + 0x09, 0xA3, 0xE5, 0x25, + 0xD3, 0x86, 0x5A, 0x05 +}, bm85d[] = { + 0x73, 0x65, 0x63, 0x2D, + 0x36, 0x34 +}, bm86a[] = { + 0xa1, 0x01, 0x05 +}, bm86b[] = { + 0x54, 0x68, 0x69, 0x73, + 0x20, 0x69, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6F, 0x6E, 0x74, + 0x65, 0x6E, 0x74, 0x2E +}, bm86c[] = { + 0x2B, 0xDC, 0xC8, 0x9F, + 0x05, 0x82, 0x16, 0xB8, + 0xA2, 0x08, 0xDD, 0xC6, + 0xD8, 0xB5, 0x4A, 0xA9, + 0x1F, 0x48, 0xBD, 0x63, + 0x48, 0x49, 0x86, 0x56, + 0x51, 0x05, 0xC9, 0xAD, + 0x5A, 0x66, 0x82, 0xF7 +}, bm86d[] = { + 0x6F, 0x75, 0x72, 0x2D, + 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74 +}, bm87a[] = { + 0xa1, 0x01, 0x04 +}, bm87b[] = { + 0x54, 0x68, 0x69, 0x73, + 0x20, 0x69, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6F, 0x6E, 0x74, + 0x65, 0x6E, 0x74, 0x2E +}, bm87c[] = { + 0x6F, 0x35, 0xCA, 0xB7, + 0x79, 0xF7, 0x78, 0x33 +}, bm87d[] = { + 0x6F, 0x75, 0x72, 0x2D, + 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74 +}, bm88a[] = { + 0xa1, 0x01, 0x05 +}, bm88b[] = { + 0x54, 0x68, 0x69, 0x73, + 0x20, 0x69, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6F, 0x6E, 0x74, + 0x65, 0x6E, 0x74, 0x2E +}, bm88c[] = { + 0xA1, 0xA8, 0x48, 0xD3, + 0x47, 0x1F, 0x9D, 0x61, + 0xEE, 0x49, 0x01, 0x8D, + 0x24, 0x4C, 0x82, 0x47, + 0x72, 0xF2, 0x23, 0xAD, + 0x4F, 0x93, 0x52, 0x93, + 0xF1, 0x78, 0x9F, 0xC3, + 0xA0, 0x8D, 0x8C, 0x58 +}, bm89a[] = { + 0xa1, 0x01, 0x06 +}, bm89b[] = { + 0x54, 0x68, 0x69, 0x73, + 0x20, 0x69, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6F, 0x6E, 0x74, + 0x65, 0x6E, 0x74, 0x2E +}, bm89c[] = { + 0x99, 0x8D, 0x26, 0xC6, + 0x45, 0x9A, 0xAE, 0xEC, + 0xF4, 0x4E, 0xD2, 0x0C, + 0xE0, 0x0C, 0x8C, 0xCE, + 0xDF, 0x0A, 0x1F, 0x3D, + 0x22, 0xA9, 0x2F, 0xC0, + 0x5D, 0xB0, 0x8C, 0x5A, + 0xEB, 0x1C, 0xB5, 0x94, + 0xCA, 0xAF, 0x5A, 0x5C, + 0x5E, 0x2E, 0x9D, 0x01, + 0xCC, 0xE7, 0xE7, 0x7A, + 0x93, 0xAA, 0x8C, 0x62 +}, bm90a[] = { + 0xa1, 0x01, 0x07 +}, bm90b[] = { + 0x54, 0x68, 0x69, 0x73, + 0x20, 0x69, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6F, 0x6E, 0x74, + 0x65, 0x6E, 0x74, 0x2E +}, bm90c[] = { + 0x4A, 0x55, 0x5B, 0xF9, + 0x71, 0xF7, 0xC1, 0x89, + 0x1D, 0x9D, 0xDF, 0x30, + 0x4A, 0x1A, 0x13, 0x2E, + 0x2D, 0x6F, 0x81, 0x74, + 0x49, 0x47, 0x4D, 0x81, + 0x3E, 0x6D, 0x04, 0xD6, + 0x59, 0x62, 0xBE, 0xD8, + 0xBB, 0xA7, 0x0C, 0x17, + 0xE1, 0xF5, 0x30, 0x8F, + 0xA3, 0x99, 0x62, 0x95, + 0x9A, 0x4B, 0x9B, 0x8D, + 0x7D, 0xA8, 0xE6, 0xD8, + 0x49, 0xB2, 0x09, 0xDC, + 0xD3, 0xE9, 0x8C, 0xC0, + 0xF1, 0x1E, 0xDD, 0xF2 +}, bm91a[] = { + 0xa1, 0x01, 0x05 +}, bm91b[] = { + 0x54, 0x68, 0x69, 0x73, + 0x20, 0x69, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6F, 0x6E, 0x74, + 0x65, 0x6E, 0x74, 0x2E +}, bm91c[] = { + 0xA1, 0xA8, 0x48, 0xD3, + 0x47, 0x1F, 0x9D, 0x61, + 0xEE, 0x49, 0x01, 0x8D, + 0x24, 0x4C, 0x82, 0x47, + 0x72, 0xF2, 0x23, 0xAD, + 0x4F, 0x93, 0x52, 0x93, + 0xF1, 0x78, 0x9F, 0xC3, + 0xA0, 0x8D, 0x8C, 0x59 +}, bm92a[] = { + 0xa1, 0x01, 0x04 +}, bm92b[] = { + 0x54, 0x68, 0x69, 0x73, + 0x20, 0x69, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6F, 0x6E, 0x74, + 0x65, 0x6E, 0x74, 0x2E +}, bm92c[] = { + 0x11, 0xF9, 0xE3, 0x57, + 0x97, 0x5F, 0xB8, 0x49 +}, bm93a[] = { + 0xa1, 0x01, 0x01 +}, bm93b[] = { + 0x02, 0xd1, 0xf7, 0xe6, 0xf2, + 0x6c, 0x43, 0xd4, 0x86, 0x8d, + 0x87, 0xce +}, bm93c[] = { + 0xa1, 0x01, 0x27 +}, bm93d[] = { + 0x31, 0x31 +}, bm93e[] = { + 0xe1, 0x04, 0x39, 0x15, 0x4c, + 0xc7, 0x5c, 0x7a, 0x3a, 0x53, + 0x91, 0x49, 0x1f, 0x88, 0x65, + 0x1e, 0x02, 0x92, 0xfd, 0x0f, + 0xe0, 0xe0, 0x2c, 0xf7, 0x40, + 0x54, 0x7e, 0xaf, 0x66, 0x77, + 0xb4, 0xa4, 0x04, 0x0b, 0x8e, + 0xca, 0x16, 0xdb, 0x59, 0x28, + 0x81, 0x26, 0x2f, 0x77, 0xb1, + 0x4c, 0x1a, 0x08, 0x6c, 0x02, + 0x26, 0x8b, 0x17, 0x17, 0x1c, + 0xa1, 0x6b, 0xe4, 0xb8, 0x59, + 0x5f, 0x8c, 0x0a, 0x08 +}, bm93f[] = { + 0x60, 0x97, 0x3a, 0x94, 0xbb, + 0x28, 0x98, 0x00, 0x9e, 0xe5, + 0x2e, 0xcf, 0xd9, 0xab, 0x1d, + 0xd2, 0x58, 0x67, 0x37, 0x4b, + 0x16, 0x2e, 0x2c, 0x03, 0x56, + 0x8b, 0x41, 0xf5, 0x7c, 0x3c, + 0xc1, 0x6f, 0x91, 0x66, 0x25, + 0x0a + +}, bm94a[] = { + 0xa1, 0x01, 0x01 +}, bm94b[] = { + 0x02, 0xd1, 0xf7, 0xe6, 0xf2, + 0x6c, 0x43, 0xd4, 0x86, 0x8d, + 0x87, 0xce +}, bm94c[] = { + 0xa1, 0x01, 0x27 +}, bm94d[] = { + 0x31, 0x31 +}, bm94e[] = { + 0xe1, 0x04, 0x39, 0x15, 0x4c, + 0xc7, 0x5c, 0x7a, 0x3a, 0x53, + 0x91, 0x49, 0x1f, 0x88, 0x65, + 0x1e, 0x02, 0x92, 0xfd, 0x0f, + 0xe0, 0xe0, 0x2c, 0xf7, 0x40, + 0x54, 0x7e, 0xaf, 0x66, 0x77, + 0xb4, 0xa4, 0x04, 0x0b, 0x8e, + 0xca, 0x16, 0xdb, 0x59, 0x28, + 0x81, 0x26, 0x2f, 0x77, 0xb1, + 0x4c, 0x1a, 0x08, 0x6c, 0x02, + 0x26, 0x8b, 0x17, 0x17, 0x1c, + 0xa1, 0x6b, 0xe4, 0xb8, 0x59, + 0x5f, 0x8c, 0x0a, 0x08 +}, bm94f[] = { + 0xa1, 0x01, 0x26 +}, bm94g[] = { + 0x31, 0x31 +}, bm94h[] = { + 0xfc, 0xa9, 0x8e, 0xca, 0xc8, + 0x0b, 0x5f, 0xeb, 0x3a, 0xc7, + 0xc1, 0x08, 0xb2, 0xb7, 0x91, + 0x10, 0xde, 0x88, 0x86, 0x7b, + 0xc0, 0x42, 0x6f, 0xc8, 0x3c, + 0x53, 0xcc, 0xd6, 0x78, 0x96, + 0x94, 0xed, 0xc5, 0xfe, 0xe3, + 0xc4, 0x0d, 0xe8, 0xe7, 0xb4, + 0x4f, 0xe8, 0xaa, 0xd3, 0x67, + 0xe0, 0x95, 0xc8, 0xfc, 0x31, + 0xb7, 0x9e, 0xe6, 0x66, 0xdf, + 0x9c, 0xf9, 0x09, 0x06, 0xeb, + 0x43, 0x75, 0x6c, 0x73 +}, bm94i[] = { + 0x60, 0x97, 0x3a, 0x94, 0xbb, + 0x28, 0x98, 0x00, 0x9e, 0xe5, + 0x2e, 0xcf, 0xd9, 0xab, 0x1d, + 0xd2, 0x58, 0x67, 0x37, 0x4b, + 0x16, 0x2e, 0x2c, 0x03, 0x56, + 0x8b, 0x41, 0xf5, 0x7c, 0x3c, + 0xc1, 0x6f, 0x91, 0x66, 0x25, + 0x0a + +}, bm95a[] = { + 0xa1, 0x01, 0x01 +}, bm95b[] = { + 0x02, 0xd1, 0xf7, 0xe6, 0xf2, + 0x6c, 0x43, 0xd4, 0x86, 0x8d, + 0x87, 0xce +}, bm95c[] = { + 0xa1, 0x01, 0x27 +}, bm95d[] = { + 0x31, 0x31 +}, bm95e[] = { + 0x9a, 0x8e, 0xed, 0xe3, 0xb3, + 0xcb, 0x83, 0x7b, 0xa0, 0x0d, + 0xf0, 0x8f, 0xa2, 0x1b, 0x12, + 0x8b, 0x2d, 0x6d, 0x91, 0x62, + 0xa4, 0x29, 0x0a, 0x58, 0x2d, + 0x9f, 0x19, 0xbd, 0x0f, 0xb5, + 0x02, 0xf0, 0xf9, 0x2b, 0x9b, + 0xf4, 0x53, 0xa4, 0x05, 0x40, + 0x1f, 0x8b, 0x70, 0x55, 0xef, + 0x4e, 0x95, 0x8d, 0xf7, 0xf4, + 0xfb, 0xd7, 0xcf, 0xb4, 0xa0, + 0xc9, 0x71, 0x60, 0xf9, 0x47, + 0x2b, 0x0a, 0xa1, 0x04 +}, bm95f[] = { + 0x60, 0x97, 0x3a, 0x94, 0xbb, + 0x28, 0x98, 0x00, 0x9e, 0xe5, + 0x2e, 0xcf, 0xd9, 0xab, 0x1d, + 0xd2, 0x58, 0x67, 0x37, 0x4b, + 0x35, 0x81, 0xf2, 0xc8, 0x00, + 0x39, 0x82, 0x63, 0x50, 0xb9, + 0x7a, 0xe2, 0x30, 0x0E, 0x42, + 0xFC +}, bm95g[] = { + 0x6f, 0x75, 0x72, 0x2d, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74 + +}, bm96a[] = { + 0xa1, 0x01, 0x01 +}, bm96b[] = { + 0x02, 0xd1, 0xf7, 0xe6, 0xf2, + 0x6c, 0x43, 0xd4, 0x86, 0x8d, + 0x87, 0xce +}, bm96c[] = { + 0xa1, 0x01, 0x27 +}, bm96d[] = { + 0x31, 0x31 +}, bm96e[] = { + 0x9a, 0x8e, 0xed, 0xe3, 0xb3, + 0xcb, 0x83, 0x7b, 0xa0, 0x0d, + 0xf0, 0x8f, 0xa2, 0x1b, 0x12, + 0x8b, 0x2d, 0x6d, 0x91, 0x62, + 0xa4, 0x29, 0x0a, 0x58, 0x2d, + 0x9f, 0x19, 0xbd, 0x0f, 0xb5, + 0x02, 0xf0, 0xf9, 0x2b, 0x9b, + 0xf4, 0x53, 0xa4, 0x05, 0x40, + 0x1f, 0x8b, 0x70, 0x55, 0xef, + 0x4e, 0x95, 0x8d, 0xf7, 0xf4, + 0xfb, 0xd7, 0xcf, 0xb4, 0xa0, + 0xc9, 0x71, 0x60, 0xf9, 0x47, + 0x2b, 0x0a, 0xa1, 0x04 +}, bm96f[] = { + 0xa1, 0x01, 0x26 +}, bm96g[] = { + 0x31, 0x31 +}, bm96h[] = { + 0x24, 0x27, 0xcb, 0x37, 0x56, + 0x85, 0x0f, 0xbb, 0x79, 0x05, + 0x18, 0x07, 0xc8, 0xb2, 0x3d, + 0x2e, 0x6d, 0x16, 0xa3, 0x22, + 0x4f, 0x99, 0x01, 0xb4, 0x73, + 0x99, 0xcf, 0xc7, 0xe3, 0xfa, + 0xc4, 0xcc, 0x62, 0x1d, 0xbb, + 0xeb, 0x02, 0x02, 0xa6, 0xd8, + 0xbb, 0x25, 0x69, 0x5c, 0x9d, + 0xcc, 0x9c, 0x47, 0x49, 0x20, + 0xff, 0x57, 0x60, 0x6d, 0x76, + 0x4d, 0xea, 0x19, 0x2f, 0xc8, + 0x67, 0x41, 0x16, 0xf2 +}, bm96i[] = { + 0x60, 0x97, 0x3a, 0x94, 0xbb, + 0x28, 0x98, 0x00, 0x9e, 0xe5, + 0x2e, 0xcf, 0xd9, 0xab, 0x1d, + 0xd2, 0x58, 0x67, 0x37, 0x4b, + 0x35, 0x81, 0xf2, 0xc8, 0x00, + 0x39, 0x82, 0x63, 0x50, 0xb9, + 0x7a, 0xe2, 0x30, 0x0e, 0x42, + 0xfc +}, bm96j[] = { + 0x6f, 0x75, 0x72, 0x2d, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74 + +}, bm97a[] = { + 0xa1, 0x01, 0x01 +}, bm97b[] = { + 0x02, 0xd1, 0xf7, 0xe6, 0xf2, + 0x6c, 0x43, 0xd4, 0x86, 0x8d, + 0x87, 0xce +}, bm97c[] = { + 0x60, 0x97, 0x3a, 0x94, 0xbb, + 0x28, 0x98, 0x00, 0x9e, 0xe5, + 0x2e, 0xcf, 0xd9, 0xab, 0x1d, + 0xd2, 0x58, 0x67, 0x37, 0x4b, + 0x35, 0x81, 0xf2, 0xc8, 0x00, + 0x39, 0x82, 0x63, 0x50, 0xb9, + 0x7a, 0xe2, 0x30, 0x0e, 0x42, + 0xfc +}, bm97d[] = { + 0x6f, 0x75, 0x72, 0x2d, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74 +}, bm97e[] = { + 0xa1, 0x01, 0x27 +}, bm97f[] = { + 0x31, 0x31 +}, bm97g[] = { + 0xcc, 0xb1, 0xf3, 0xfe, 0xdf, + 0xce, 0xa7, 0x2b, 0x9c, 0x86, + 0x79, 0x63, 0xe2, 0x52, 0xb6, + 0x65, 0x8a, 0xd0, 0x7f, 0x3f, + 0x5f, 0x15, 0xa3, 0x26, 0xa3, + 0xf5, 0x72, 0x54, 0xcc, 0xb8, + 0xd4, 0x8d, 0x60, 0x02, 0x1d, + 0x2f, 0x1f, 0x8a, 0x80, 0x3b, + 0x84, 0x4b, 0x78, 0x72, 0x16, + 0x6c, 0x6d, 0x45, 0x90, 0x25, + 0xd2, 0x1c, 0x8c, 0x84, 0x62, + 0xa2, 0x44, 0xba, 0x19, 0x60, + 0x4e, 0xc4, 0xd5, 0x0b + +}, bm98a[] = { + 0xa1, 0x01, 0x05 +}, bm98b[] = { + 0xa1, 0x01, 0x27 +}, bm98c[] = { + 0x31, 0x31 +}, bm98d[] = { + 0xb4, 0x92, 0x4b, 0x18, 0xeb, + 0x4e, 0x04, 0x73, 0x13, 0xc7, + 0x07, 0xb0, 0xed, 0xa4, 0xab, + 0x84, 0x43, 0x45, 0xf2, 0xc4, + 0x49, 0x87, 0xd6, 0xf9, 0xeb, + 0xcc, 0x77, 0x7e, 0xfd, 0x40, + 0x78, 0xcc, 0x0f, 0x4c, 0x10, + 0x8d, 0xef, 0x95, 0x9f, 0x78, + 0xf1, 0xed, 0xb2, 0x76, 0x54, + 0x25, 0x78, 0x5f, 0xcd, 0x17, + 0xd5, 0x12, 0xbe, 0x31, 0xee, + 0xb6, 0x6b, 0xef, 0xf1, 0xe8, + 0xfc, 0x27, 0x47, 0x07 +}, bm98e[] = { + 0x54, 0x68, 0x69, 0x73, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x2e +}, bm98f[] = { + 0x2b, 0xdc, 0xc8, 0x9f, 0x05, + 0x82, 0x16, 0xb8, 0xa2, 0x08, + 0xdd, 0xc6, 0xd8, 0xb5, 0x4a, + 0xa9, 0x1f, 0x48, 0xbd, 0x63, + 0x48, 0x49, 0x86, 0x56, 0x51, + 0x05, 0xc9, 0xad, 0x5a, 0x66, + 0x82, 0xf6 +}, bm98g[] = { + 0x6f, 0x75, 0x72, 0x2d, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74 + +}, bm99a[] = { + 0xa1, 0x01, 0x05 +}, bm99b[] = { + 0xa1, 0x01, 0x27 +}, bm99c[] = { + 0x31, 0x31 +}, bm99d[] = { + 0xb4, 0x92, 0x4b, 0x18, 0xeb, + 0x4e, 0x04, 0x73, 0x13, 0xc7, + 0x07, 0xb0, 0xed, 0xa4, 0xab, + 0x84, 0x43, 0x45, 0xf2, 0xc4, + 0x49, 0x87, 0xd6, 0xf9, 0xeb, + 0xcc, 0x77, 0x7e, 0xfd, 0x40, + 0x78, 0xcc, 0x0f, 0x4c, 0x10, + 0x8d, 0xef, 0x95, 0x9f, 0x78, + 0xf1, 0xed, 0xb2, 0x76, 0x54, + 0x25, 0x78, 0x5f, 0xcd, 0x17, + 0xd5, 0x12, 0xbe, 0x31, 0xee, + 0xb6, 0x6b, 0xef, 0xf1, 0xe8, + 0xfc, 0x27, 0x47, 0x07 +}, bm99e[] = { + 0xa1, 0x01, 0x26 +}, bm99f[] = { + 0x31, 0x31 +}, bm99g[] = { + 0x6a, 0xcd, 0x94, 0xd3, 0xcc, + 0xf7, 0x1d, 0x19, 0x2e, 0x85, + 0x28, 0x36, 0x0b, 0xa7, 0xe3, + 0x46, 0xda, 0xc4, 0x64, 0xe9, + 0xed, 0xca, 0x4c, 0xfe, 0xb6, + 0xce, 0xb6, 0xbd, 0xe7, 0xba, + 0xec, 0x9f, 0xf2, 0x6c, 0xa6, + 0xbd, 0xf7, 0x3d, 0x0b, 0xe4, + 0x1e, 0x36, 0x12, 0x9d, 0xcf, + 0xf7, 0x51, 0xdd, 0x2b, 0x5a, + 0xd5, 0xce, 0x11, 0x6e, 0x8a, + 0x96, 0x3a, 0x27, 0x38, 0xa2, + 0x99, 0x47, 0x7a, 0x68 +}, bm99h[] = { + 0x54, 0x68, 0x69, 0x73, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x2e +}, bm99i[] = { + 0x2b, 0xdc, 0xc8, 0x9f, 0x05, + 0x82, 0x16, 0xb8, 0xa2, 0x08, + 0xdd, 0xc6, 0xd8, 0xb5, 0x4a, + 0xa9, 0x1f, 0x48, 0xbd, 0x63, + 0x48, 0x49, 0x86, 0x56, 0x51, + 0x05, 0xc9, 0xad, 0x5a, 0x66, + 0x82, 0xf6 +}, bm99j[] = { + 0x6f, 0x75, 0x72, 0x2d, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74 + +}, bm100a[] = { + 0xa1, 0x01, 0x05 +}, bm100b[] = { + 0xa1, 0x01, 0x27 +}, bm100c[] = { + 0x31, 0x31 +}, bm100d[] = { + 0xb4, 0x92, 0x4b, 0x18, 0xeb, + 0x4e, 0x04, 0x73, 0x13, 0xc7, + 0x07, 0xb0, 0xed, 0xa4, 0xab, + 0x84, 0x43, 0x45, 0xf2, 0xc4, + 0x49, 0x87, 0xd6, 0xf9, 0xeb, + 0xcc, 0x77, 0x7e, 0xfd, 0x40, + 0x78, 0xcc, 0x0f, 0x4c, 0x10, + 0x8d, 0xef, 0x95, 0x9f, 0x78, + 0xf1, 0xed, 0xb2, 0x76, 0x54, + 0x25, 0x78, 0x5f, 0xcd, 0x17, + 0xd5, 0x12, 0xbe, 0x31, 0xee, + 0xb6, 0x6b, 0xef, 0xf1, 0xe8, + 0xfc, 0x27, 0x47, 0x07 +}, bm100e[] = { + 0x54, 0x68, 0x69, 0x73, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x2e +}, bm100f[] = { + 0xa1, 0xa8, 0x48, 0xd3, 0x47, + 0x1f, 0x9d, 0x61, 0xee, 0x49, + 0x01, 0x8d, 0x24, 0x4c, 0x82, + 0x47, 0x72, 0xf2, 0x23, 0xad, + 0x4f, 0x93, 0x52, 0x93, 0xf1, + 0x78, 0x9f, 0xc3, 0xa0, 0x8d, + 0x8c, 0x58 + + +}, bm101a[] = { + 0xa1, 0x01, 0x05 +}, bm101b[] = { + 0xa1, 0x01, 0x27 +}, bm101c[] = { + 0x31, 0x31 +}, bm101d[] = { + 0xb4, 0x92, 0x4b, 0x18, 0xeb, + 0x4e, 0x04, 0x73, 0x13, 0xc7, + 0x07, 0xb0, 0xed, 0xa4, 0xab, + 0x84, 0x43, 0x45, 0xf2, 0xc4, + 0x49, 0x87, 0xd6, 0xf9, 0xeb, + 0xcc, 0x77, 0x7e, 0xfd, 0x40, + 0x78, 0xcc, 0x0f, 0x4c, 0x10, + 0x8d, 0xef, 0x95, 0x9f, 0x78, + 0xf1, 0xed, 0xb2, 0x76, 0x54, + 0x25, 0x78, 0x5f, 0xcd, 0x17, + 0xd5, 0x12, 0xbe, 0x31, 0xee, + 0xb6, 0x6b, 0xef, 0xf1, 0xe8, + 0xfc, 0x27, 0x47, 0x07 +}, bm101e[] = { + 0xa1, 0x01, 0x26 +}, bm101f[] = { + 0x31, 0x31 +}, bm101g[] = { + 0x6a, 0xcd, 0x94, 0xd3, 0xcc, + 0xf7, 0x1d, 0x19, 0x2e, 0x85, + 0x28, 0x36, 0x0b, 0xa7, 0xe3, + 0x46, 0xda, 0xc4, 0x64, 0xe9, + 0xed, 0xca, 0x4c, 0xfe, 0xb6, + 0xce, 0xb6, 0xbd, 0xe7, 0xba, + 0xec, 0x9f, 0xf2, 0x6c, 0xa6, + 0xbd, 0xf7, 0x3d, 0x0b, 0xe4, + 0x1e, 0x36, 0x12, 0x9d, 0xcf, + 0xf7, 0x51, 0xdd, 0x2b, 0x5a, + 0xd5, 0xce, 0x11, 0x6e, 0x8a, + 0x96, 0x3a, 0x27, 0x38, 0xa2, + 0x99, 0x47, 0x7a, 0x68 +}, bm101h[] = { + 0x54, 0x68, 0x69, 0x73, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x2e +}, bm101i[] = { + 0x2b, 0xdc, 0xc8, 0x9f, 0x05, + 0x82, 0x16, 0xb8, 0xa2, 0x08, + 0xdd, 0xc6, 0xd8, 0xb5, 0x4a, + 0xa9, 0x1f, 0x48, 0xbd, 0x63, + 0x48, 0x49, 0x86, 0x56, 0x51, + 0x05, 0xc9, 0xad, 0x5a, 0x66, + 0x82, 0xf6 +}, bm101j[] = { + 0x6f, 0x75, 0x72, 0x2d, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74 + +}, bm102a[] = { /* mac0-01 */ + 0xa1, 0x01, 0x05 +}, bm102b[] = { + 0xa1, 0x01, 0x27 +}, bm102c[] = { + 0x31, 0x31 +}, bm102d[] = { + 0xb4, 0x92, 0x4b, 0x18, 0xeb, + 0x4e, 0x04, 0x73, 0x13, 0xc7, + 0x07, 0xb0, 0xed, 0xa4, 0xab, + 0x84, 0x43, 0x45, 0xf2, 0xc4, + 0x49, 0x87, 0xd6, 0xf9, 0xeb, + 0xcc, 0x77, 0x7e, 0xfd, 0x40, + 0x78, 0xcc, 0x0f, 0x4c, 0x10, + 0x8d, 0xef, 0x95, 0x9f, 0x78, + 0xf1, 0xed, 0xb2, 0x76, 0x54, + 0x25, 0x78, 0x5f, 0xcd, 0x17, + 0xd5, 0x12, 0xbe, 0x31, 0xee, + 0xb6, 0x6b, 0xef, 0xf1, 0xe8, + 0xfc, 0x27, 0x47, 0x07 +}, bm102e[] = { + 0x54, 0x68, 0x69, 0x73, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x2e +}, bm102f[] = { + 0xa1, 0xa8, 0x48, 0xd3, 0x47, + 0x1f, 0x9d, 0x61, 0xee, 0x49, + 0x01, 0x8d, 0x24, 0x4c, 0x82, + 0x47, 0x72, 0xf2, 0x23, 0xad, + 0x4f, 0x93, 0x52, 0x93, 0xf1, + 0x78, 0x9f, 0xc3, 0xa0, 0x8d, + 0x8c, 0x58 + +}, bm103a[] = { + 0xa1, 0x01, 0x05 +}, bm103b[] = { + 0xa1, 0x01, 0x27 +}, bm103c[] = { + 0x31, 0x31 +}, bm103d[] = { + 0xb4, 0x92, 0x4b, 0x18, 0xeb, + 0x4e, 0x04, 0x73, 0x13, 0xc7, + 0x07, 0xb0, 0xed, 0xa4, 0xab, + 0x84, 0x43, 0x45, 0xf2, 0xc4, + 0x49, 0x87, 0xd6, 0xf9, 0xeb, + 0xcc, 0x77, 0x7e, 0xfd, 0x40, + 0x78, 0xcc, 0x0f, 0x4c, 0x10, + 0x8d, 0xef, 0x95, 0x9f, 0x78, + 0xf1, 0xed, 0xb2, 0x76, 0x54, + 0x25, 0x78, 0x5f, 0xcd, 0x17, + 0xd5, 0x12, 0xbe, 0x31, 0xee, + 0xb6, 0x6b, 0xef, 0xf1, 0xe8, + 0xfc, 0x27, 0x47, 0x07 +}, bm103e[] = { + 0xa1, 0x01, 0x26 +}, bm103f[] = { + 0x31, 0x31 +}, bm103g[] = { + 0x6a, 0xcd, 0x94, 0xd3, 0xcc, + 0xf7, 0x1d, 0x19, 0x2e, 0x85, + 0x28, 0x36, 0x0b, 0xa7, 0xe3, + 0x46, 0xda, 0xc4, 0x64, 0xe9, + 0xed, 0xca, 0x4c, 0xfe, 0xb6, + 0xce, 0xb6, 0xbd, 0xe7, 0xba, + 0xec, 0x9f, 0xf2, 0x6c, 0xa6, + 0xbd, 0xf7, 0x3d, 0x0b, 0xe4, + 0x1e, 0x36, 0x12, 0x9d, 0xcf, + 0xf7, 0x51, 0xdd, 0x2b, 0x5a, + 0xd5, 0xce, 0x11, 0x6e, 0x8a, + 0x96, 0x3a, 0x27, 0x38, 0xa2, + 0x99, 0x47, 0x7a, 0x68 +}, bm103h[] = { + 0x54, 0x68, 0x69, 0x73, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x2e +}, bm103i[] = { + 0xa1, 0xa8, 0x48, 0xd3, 0x47, + 0x1f, 0x9d, 0x61, 0xee, 0x49, + 0x01, 0x8d, 0x24, 0x4c, 0x82, + 0x47, 0x72, 0xf2, 0x23, 0xad, + 0x4f, 0x93, 0x52, 0x93, 0xf1, + 0x78, 0x9f, 0xc3, 0xa0, 0x8d, + 0x8c, 0x58 + +}, bm104a[] = { + 0xa1, 0x03, 0x00 +}, bm104b[] = { + 0x54, 0x68, 0x69, 0x73, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x2e +}, bm104c[] = { + 0xa1, 0x01, 0x27 +}, bm104d[] = { + 0xa1, 0x01, 0x27 +}, bm104e[] = { + 0x31, 0x31 +}, bm104f[] = { + 0x8e, 0x1b, 0xe2, 0xf9, 0x45, + 0x3d, 0x26, 0x48, 0x12, 0xe5, + 0x90, 0x49, 0x91, 0x32, 0xbe, + 0xf3, 0xfb, 0xf9, 0xee, 0x9d, + 0xb2, 0x7c, 0x2c, 0x16, 0x87, + 0x88, 0xe3, 0xb7, 0xeb, 0xe5, + 0x06, 0xc0, 0x4f, 0xd3, 0xd1, + 0x9f, 0xaa, 0x9f, 0x51, 0x23, + 0x2a, 0xf5, 0xc9, 0x59, 0xe4, + 0xef, 0x47, 0x92, 0x88, 0x34, + 0x64, 0x7f, 0x56, 0xdf, 0xbe, + 0x93, 0x91, 0x12, 0x88, 0x4d, + 0x08, 0xef, 0x25, 0x05 +}, bm104g[] = { + 0x31, 0x31 +}, bm104h[] = { + 0x77, 0xf3, 0xea, 0xcd, 0x11, + 0x85, 0x2c, 0x4b, 0xf9, 0xcb, + 0x1d, 0x72, 0xfa, 0xbe, 0x6b, + 0x26, 0xfb, 0xa1, 0xd7, 0x60, + 0x92, 0xb2, 0xb5, 0xb7, 0xec, + 0x83, 0xb8, 0x35, 0x57, 0x65, + 0x22, 0x64, 0xe6, 0x96, 0x90, + 0xdb, 0xc1, 0x17, 0x2d, 0xdc, + 0x0b, 0xf8, 0x84, 0x11, 0xc0, + 0xd2, 0x5a, 0x50, 0x7f, 0xdb, + 0x24, 0x7a, 0x20, 0xc4, 0x0d, + 0x5e, 0x24, 0x5f, 0xab, 0xd3, + 0xfc, 0x9e, 0xc1, 0x06 + +}, bm105a[] = { + 0xa1, 0x03, 0x00 +}, bm105b[] = { + 0x54, 0x68, 0x69, 0x73, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x2e +}, bm105c[] = { + 0xa1, 0x01, 0x27 +}, bm105d[] = { + 0xa1, 0x01, 0x27 +}, bm105e[] = { + 0x31, 0x31 +}, bm105f[] = { + 0x8e, 0x1b, 0xe2, 0xf9, 0x45, + 0x3d, 0x26, 0x48, 0x12, 0xe5, + 0x90, 0x49, 0x91, 0x32, 0xbe, + 0xf3, 0xfb, 0xf9, 0xee, 0x9d, + 0xb2, 0x7c, 0x2c, 0x16, 0x87, + 0x88, 0xe3, 0xb7, 0xeb, 0xe5, + 0x06, 0xc0, 0x4f, 0xd3, 0xd1, + 0x9f, 0xaa, 0x9f, 0x51, 0x23, + 0x2a, 0xf5, 0xc9, 0x59, 0xe4, + 0xef, 0x47, 0x92, 0x88, 0x34, + 0x64, 0x7f, 0x56, 0xdf, 0xbe, + 0x93, 0x91, 0x12, 0x88, 0x4d, + 0x08, 0xef, 0x25, 0x05 +}, bm105g[] = { + 0xa1, 0x01, 0x26 +}, bm105h[] = { + 0x31, 0x31 +}, bm105i[] = { + 0xaf, 0x04, 0x9b, 0x80, 0xd5, + 0x2c, 0x36, 0x69, 0xb2, 0x99, + 0x70, 0xc1, 0x33, 0x54, 0x37, + 0x54, 0xf9, 0xcc, 0x60, 0x8c, + 0xe4, 0x11, 0x23, 0xae, 0x1c, + 0x82, 0x7e, 0x36, 0xb3, 0x8c, + 0xb8, 0x25, 0x98, 0x7f, 0x01, + 0xf2, 0x2b, 0xb8, 0xab, 0x13, + 0xe9, 0xc6, 0x62, 0x26, 0xee, + 0x23, 0x17, 0x8f, 0xfa, 0x00, + 0xa4, 0xfc, 0x22, 0x05, 0x93, + 0xb6, 0xe5, 0xac, 0x38, 0x96, + 0x00, 0x71, 0xc9, 0xc8 +}, bm105j[] = { + 0x31, 0x31 +}, bm105k[] = { + 0x77, 0xf3, 0xea, 0xcd, 0x11, + 0x85, 0x2c, 0x4b, 0xf9, 0xcb, + 0x1d, 0x72, 0xfa, 0xbe, 0x6b, + 0x26, 0xfb, 0xa1, 0xd7, 0x60, + 0x92, 0xb2, 0xb5, 0xb7, 0xec, + 0x83, 0xb8, 0x35, 0x57, 0x65, + 0x22, 0x64, 0xe6, 0x96, 0x90, + 0xdb, 0xc1, 0x17, 0x2d, 0xdc, + 0x0b, 0xf8, 0x84, 0x11, 0xc0, + 0xd2, 0x5a, 0x50, 0x7f, 0xdb, + 0x24, 0x7a, 0x20, 0xc4, 0x0d, + 0x5e, 0x24, 0x5f, 0xab, 0xd3, + 0xfc, 0x9e, 0xc1, 0x06 + +}, bm106a[] = { + 0xa1, 0x03, 0x00 +}, bm106b[] = { + 0xa1, 0x01, 0x27 +}, bm106c[] = { + 0x31, 0x31 +}, bm106d[] = { + 0xb7, 0xca, 0xcb, 0xa2, 0x85, + 0xc4, 0xcd, 0x3e, 0xd2, 0xf0, + 0x14, 0x6f, 0x41, 0x98, 0x86, + 0x14, 0x4c, 0xa6, 0x38, 0xd0, + 0x87, 0xde, 0x12, 0x3d, 0x40, + 0x01, 0x67, 0x30, 0x8a, 0xce, + 0xab, 0xc4, 0xb5, 0xe5, 0xc6, + 0xa4, 0x0c, 0x0d, 0xe0, 0xb7, + 0x11, 0x67, 0xa3, 0x91, 0x75, + 0xea, 0x56, 0xc1, 0xfe, 0x96, + 0xc8, 0x9e, 0x5e, 0x7d, 0x30, + 0xda, 0xf2, 0x43, 0x8a, 0x45, + 0x61, 0x59, 0xa2, 0x0a +}, bm106e[] = { + 0x54, 0x68, 0x69, 0x73, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x2e +}, bm106f[] = { + 0xa1, 0x01, 0x27 +}, bm106g[] = { + 0x31, 0x31 +}, bm106h[] = { + 0x77, 0xf3, 0xea, 0xcd, 0x11, + 0x85, 0x2c, 0x4b, 0xf9, 0xcb, + 0x1d, 0x72, 0xfa, 0xbe, 0x6b, + 0x26, 0xfb, 0xa1, 0xd7, 0x60, + 0x92, 0xb2, 0xb5, 0xb7, 0xec, + 0x83, 0xb8, 0x35, 0x57, 0x65, + 0x22, 0x64, 0xe6, 0x96, 0x90, + 0xdb, 0xc1, 0x17, 0x2d, 0xdc, + 0x0b, 0xf8, 0x84, 0x11, 0xc0, + 0xd2, 0x5a, 0x50, 0x7f, 0xdb, + 0x24, 0x7a, 0x20, 0xc4, 0x0d, + 0x5e, 0x24, 0x5f, 0xab, 0xd3, + 0xfc, 0x9e, 0xc1, 0x06 + +}, bm107a[] = { + 0xa2, 0x01, 0x27, 0x03, 0x00 +}, bm107b[] = { + 0xa1, 0x01, 0x27, +}, bm107c[] = { + 0x31, 0x31 +}, bm107d[] = { + 0x6d, 0xae, 0xd1, 0x58, 0xaf, + 0xe4, 0x03, 0x2e, 0x8d, 0xd4, + 0x77, 0xd3, 0xd2, 0xb7, 0xf6, + 0x67, 0xe7, 0x95, 0x7a, 0xa8, + 0x30, 0x2b, 0xb5, 0xe5, 0x68, + 0xb4, 0xdc, 0xbc, 0xce, 0x3c, + 0xf0, 0xed, 0x5a, 0x90, 0xf8, + 0x31, 0x35, 0x1c, 0x85, 0xd6, + 0x15, 0x5a, 0x42, 0xa1, 0x7c, + 0xa1, 0xf2, 0x5f, 0x50, 0x1c, + 0xc1, 0x3f, 0x67, 0x10, 0x8a, + 0xe5, 0x3b, 0xda, 0x92, 0xdb, + 0x88, 0x27, 0x2e, 0x00 +}, bm107e[] = { + 0x31, 0x31 +}, bm107f[] = { + 0x54, 0x68, 0x69, 0x73, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x2e +}, bm107g[] = { + 0x71, 0x42, 0xfd, 0x2f, 0xf9, + 0x6d, 0x56, 0xdb, 0x85, 0xbe, + 0xe9, 0x05, 0xa7, 0x6b, 0xa1, + 0xd0, 0xb7, 0x32, 0x1a, 0x95, + 0xc8, 0xc4, 0xd3, 0x60, 0x7c, + 0x57, 0x81, 0x93, 0x2b, 0x7a, + 0xfb, 0x87, 0x11, 0x49, 0x7d, + 0xfa, 0x75, 0x1b, 0xf4, 0x0b, + 0x58, 0xb3, 0xbc, 0xc3, 0x23, + 0x00, 0xb1, 0x48, 0x7f, 0x3d, + 0xb3, 0x40, 0x85, 0xee, 0xf0, + 0x13, 0xbf, 0x08, 0xf4, 0xa4, + 0x4d, 0x6f, 0xef, 0x0d + +}, bm108a[] = { + 0xa2, 0x01, 0x27, 0x03, 0x00 +}, bm108b[] = { + 0xa1, 0x01, 0x27 +}, bm108c[] = { + 0x31, 0x31 +}, bm108d[] = { + 0x6d, 0xae, 0xd1, 0x58, 0xaf, + 0xe4, 0x03, 0x2e, 0x8d, 0xd4, + 0x77, 0xd3, 0xd2, 0xb7, 0xf6, + 0x67, 0xe7, 0x95, 0x7a, 0xa8, + 0x30, 0x2b, 0xb5, 0xe5, 0x68, + 0xb4, 0xdc, 0xbc, 0xce, 0x3c, + 0xf0, 0xed, 0x5a, 0x90, 0xf8, + 0x31, 0x35, 0x1c, 0x85, 0xd6, + 0x15, 0x5a, 0x42, 0xa1, 0x7c, + 0xa1, 0xf2, 0x5f, 0x50, 0x1c, + 0xc1, 0x3f, 0x67, 0x10, 0x8a, + 0xe5, 0x3b, 0xda, 0x92, 0xdb, + 0x88, 0x27, 0x2e, 0x00 +}, bm108e[] = { + 0xa1, 0x01, 0x26 +}, bm108f[] = { + 0x31, 0x31 +}, bm108g[] = { + 0x93, 0x48, 0x7d, 0x09, 0x25, + 0x6a, 0x3e, 0xf4, 0x96, 0x37, + 0x19, 0xba, 0x5c, 0xf1, 0x01, + 0xac, 0xe2, 0xfc, 0x13, 0xd6, + 0x31, 0x4b, 0x49, 0x58, 0x21, + 0x71, 0xff, 0xa4, 0xa1, 0x31, + 0x4d, 0xc9, 0x3e, 0x4a, 0x4a, + 0xdf, 0xa4, 0x2a, 0x79, 0xe3, + 0x1b, 0x35, 0xd7, 0x30, 0x43, + 0x58, 0x58, 0x5b, 0x41, 0x79, + 0x96, 0x78, 0xce, 0x00, 0xca, + 0x47, 0xc3, 0xe0, 0x23, 0x86, + 0x39, 0x23, 0xf8, 0xc8 +}, bm108h[] = { + 0x31, 0x31 +}, bm108i[] = { + 0x54, 0x68, 0x69, 0x73, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x2e +}, bm108j[] = { + 0x71, 0x42, 0xfd, 0x2f, 0xf9, + 0x6d, 0x56, 0xdb, 0x85, 0xbe, + 0xe9, 0x05, 0xa7, 0x6b, 0xa1, + 0xd0, 0xb7, 0x32, 0x1a, 0x95, + 0xc8, 0xc4, 0xd3, 0x60, 0x7c, + 0x57, 0x81, 0x93, 0x2b, 0x7a, + 0xfb, 0x87, 0x11, 0x49, 0x7d, + 0xfa, 0x75, 0x1b, 0xf4, 0x0b, + 0x58, 0xb3, 0xbc, 0xc3, 0x23, + 0x00, 0xb1, 0x48, 0x7f, 0x3d, + 0xb3, 0x40, 0x85, 0xee, 0xf0, + 0x13, 0xbf, 0x08, 0xf4, 0xa4, + 0x4d, 0x6f, 0xef, 0x0d +}; + +static const struct seq +seq1[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 0 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq2[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq3[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 10 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq4[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 23 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq5[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 24 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq6[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 25 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq7[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 100 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq8[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1000 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq9[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1000000 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq10[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1000000000000 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq11[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 18446744073709551615ull } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq12[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 0 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm12, .buf_len = sizeof(bm12)}, + { .reason = LECPCB_TAG_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq13[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = 0ull } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq14[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 3 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm12, .buf_len = sizeof(bm12)}, + { .reason = LECPCB_TAG_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq15[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -1ll } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq16[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -10ll } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq17[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -100ll } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq18[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -1000ll } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq19[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq20[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0x8000 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq21[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0x3c00 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq22[] = { + { .reason = LECPCB_CONSTRUCTED }, +#if defined(LWS_WITH_CBOR_FLOAT) + { .reason = LECPCB_VAL_FLOAT64, .item = { .u.d = 1.1 } }, +#else + { .reason = LECPCB_VAL_FLOAT64, .item = { .u.u64 = 0x3ff199999999999aull } }, +#endif + { .reason = LECPCB_DESTRUCTED }, +}, seq23[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0x3e00 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq24[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0x7bff } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq25[] = { + { .reason = LECPCB_CONSTRUCTED }, +#if defined(LWS_WITH_CBOR_FLOAT) + { .reason = LECPCB_VAL_FLOAT32, .item = { .u.f = 100000.0 } }, +#else + { .reason = LECPCB_VAL_FLOAT32, .item = { .u.f = 0x47c35000 } }, +#endif + { .reason = LECPCB_DESTRUCTED }, +}, seq26[] = { + { .reason = LECPCB_CONSTRUCTED }, +#if defined(LWS_WITH_CBOR_FLOAT) + { .reason = LECPCB_VAL_FLOAT32, .item = { .u.f = 3.4028234663852886e+38 } }, +#else + { .reason = LECPCB_VAL_FLOAT32, .item = { .u.f = 0x7f7fffff } }, +#endif + { .reason = LECPCB_DESTRUCTED }, +}, seq27[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_FLOAT64, .item = { .u.u64 = 0x7e37e43c8800759cull } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq28[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0x0001 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq29[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0x0400 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq30[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0xc400 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq31[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_FLOAT64, .item = { .u.u64 = 0xc010666666666666ull } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq32[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0x7c00 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq33[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0x7e00 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq34[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_FLOAT16, .item = { .u.hf = 0xfc00 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq35[] = { + { .reason = LECPCB_CONSTRUCTED }, +#if defined(LWS_WITH_CBOR_FLOAT) + { .reason = LECPCB_VAL_FLOAT32, .item = { .u.u32 = 0x7f800000 } }, +#else + { .reason = LECPCB_VAL_FLOAT32, .item = { .u.f = 0x7f800000 } }, +#endif + { .reason = LECPCB_DESTRUCTED }, +}, seq36[] = { + { .reason = LECPCB_CONSTRUCTED }, +#if defined(LWS_WITH_CBOR_FLOAT) + { .reason = LECPCB_VAL_FLOAT32, .item = { .u.f = NAN } }, +#else + { .reason = LECPCB_VAL_FLOAT32, .item = { .u.f = 0x7fc00000 } }, +#endif + { .reason = LECPCB_DESTRUCTED }, +}, seq37[] = { + { .reason = LECPCB_CONSTRUCTED }, +#if defined(LWS_WITH_CBOR_FLOAT) + { .reason = LECPCB_VAL_FLOAT32, .item = { .u.u32 = 0xff800000 } }, +#else + { .reason = LECPCB_VAL_FLOAT32, .item = { .u.f = 0xff800000 } }, +#endif + { .reason = LECPCB_DESTRUCTED }, +}, seq38[] = { + { .reason = LECPCB_CONSTRUCTED }, +#if defined(LWS_WITH_CBOR_FLOAT) + { .reason = LECPCB_VAL_FLOAT64, .item = { .u.u64 = 0x7ff0000000000000ull } }, +#else + { .reason = LECPCB_VAL_FLOAT64, .item = { .u.u64 = 0x7ff0000000000000ull } }, +#endif + { .reason = LECPCB_DESTRUCTED }, +}, seq39[] = { + { .reason = LECPCB_CONSTRUCTED }, +#if defined(LWS_WITH_CBOR_FLOAT) + { .reason = LECPCB_VAL_FLOAT64, .item = { .u.u64 = 0x7ff8000000000000ull } }, +#else + { .reason = LECPCB_VAL_FLOAT64, .item = { .u.u64 = 0x7ff8000000000000ull } }, +#endif + { .reason = LECPCB_DESTRUCTED }, +}, seq40[] = { + { .reason = LECPCB_CONSTRUCTED }, +#if defined(LWS_WITH_CBOR_FLOAT) + { .reason = LECPCB_VAL_FLOAT64, .item = { .u.u64 = 0xfff0000000000000ull } }, +#else + { .reason = LECPCB_VAL_FLOAT64, .item = { .u.u64 = 0xfff0000000000000ull } }, +#endif + { .reason = LECPCB_DESTRUCTED }, +}, seq41[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_FALSE }, + { .reason = LECPCB_DESTRUCTED }, +}, seq42[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_TRUE }, + { .reason = LECPCB_DESTRUCTED }, +}, seq43[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_NULL }, + { .reason = LECPCB_DESTRUCTED }, +}, seq44[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_UNDEFINED }, + { .reason = LECPCB_DESTRUCTED }, +}, seq45[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_SIMPLE, .item = { .u.u64 = 16 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq46[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_FAILED }, /* example disallowed by RFC! */ + { .reason = LECPCB_DESTRUCTED }, +}, seq47[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_SIMPLE, .item = { .u.u64 = 255 } }, + { .reason = LECPCB_DESTRUCTED }, +}, seq48[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 0 } }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = bm48, .buf_len = sizeof(bm48)}, + { .reason = LECPCB_TAG_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq49[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1363896240 } }, + { .reason = LECPCB_TAG_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq50[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_VAL_FLOAT64, .item = { .u.u64 = 0x41d452d9ec200000ull } }, + { .reason = LECPCB_TAG_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq51[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 23 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm51, .buf_len = sizeof(bm51)}, + { .reason = LECPCB_TAG_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq52[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 24 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm52, .buf_len = sizeof(bm52)}, + { .reason = LECPCB_TAG_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq53[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 32 } }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = bm53, .buf_len = sizeof(bm53)}, + { .reason = LECPCB_TAG_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq54[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm53, .buf_len = 0}, + { .reason = LECPCB_DESTRUCTED }, +}, seq55[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm51, .buf_len = sizeof(bm51)}, + { .reason = LECPCB_DESTRUCTED }, +}, seq56[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = bm53, .buf_len = 0}, + { .reason = LECPCB_DESTRUCTED }, +}, seq57[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = bm57, .buf_len = sizeof(bm57)}, + { .reason = LECPCB_DESTRUCTED }, +}, seq58[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = bm58, .buf_len = sizeof(bm58)}, + { .reason = LECPCB_DESTRUCTED }, +}, seq59[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = bm59, .buf_len = sizeof(bm59)}, + { .reason = LECPCB_DESTRUCTED }, +}, seq60[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = bm60, .buf_len = sizeof(bm60)}, + { .reason = LECPCB_DESTRUCTED }, +}, seq61[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = bm61, .buf_len = sizeof(bm61)}, + { .reason = LECPCB_DESTRUCTED }, +}, seq62[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = bm62, .buf_len = sizeof(bm62)}, + { .reason = LECPCB_DESTRUCTED }, +}, seq63[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq64[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq65[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_ARRAY_START, }, + + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq66[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 6 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 8 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 9 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 10 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 11 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 12 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 13 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 14 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 15 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 16 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 17 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 18 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 19 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 20 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 21 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 22 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 23 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 24 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 25 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq67[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq68[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq69[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"a", .buf_len = 1}, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"b", .buf_len = 1}, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq70[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"a", .buf_len = 1}, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"b", .buf_len = 1}, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"c", .buf_len = 1}, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq71[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"a", .buf_len = 1}, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"A", .buf_len = 1}, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"b", .buf_len = 1}, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"B", .buf_len = 1}, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"c", .buf_len = 1}, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"C", .buf_len = 1}, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"d", .buf_len = 1}, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"D", .buf_len = 1}, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"e", .buf_len = 1}, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"E", .buf_len = 1}, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq72[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_CHUNK, .buf = bm72a, .buf_len = sizeof(bm72a)}, + { .reason = LECPCB_VAL_BLOB_CHUNK, .buf = bm72b, .buf_len = sizeof(bm72b)}, + { .reason = LECPCB_VAL_BLOB_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq73[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_CHUNK, .buf = (const uint8_t *)"stream", .buf_len = 5}, + { .reason = LECPCB_VAL_STR_CHUNK, .buf = (const uint8_t *)"ming", .buf_len = 4}, + { .reason = LECPCB_VAL_STR_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq74[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq75[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq76[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq77[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq78[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq79[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 6 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 8 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 9 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 10 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 11 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 12 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 13 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 14 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 15 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 16 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 17 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 18 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 19 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 20 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 21 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 22 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 23 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 24 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 25 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq80[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"a", .buf_len = 1}, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"b", .buf_len = 1}, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 2 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 3 } }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq81[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"a", .buf_len = 1}, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"b", .buf_len = 1}, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"c", .buf_len = 1}, + { .reason = LECPCB_OBJECT_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END }, + { .reason = LECPCB_DESTRUCTED }, +}, seq82[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"Fun", .buf_len = 3}, + { .reason = LECPCB_VAL_TRUE }, + { .reason = LECPCB_VAL_STR_START, }, + { .reason = LECPCB_VAL_STR_END, .buf = (const uint8_t *)"Amt", .buf_len = 3}, + { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = (int64_t)-2ll } }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_DESTRUCTED }, + +}, seq83[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 97 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm83a, .buf_len = sizeof(bm83a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm83b, .buf_len = sizeof(bm83b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm83c, .buf_len = sizeof(bm83c) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm83a, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm83d, .buf_len = sizeof(bm83d) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm83a, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, + +}, seq84[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 97 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm84a, .buf_len = sizeof(bm84a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm84b, .buf_len = sizeof(bm84b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm84c, .buf_len = sizeof(bm84c) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm84a, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm84d, .buf_len = sizeof(bm84d) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm84a, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, + +}, seq85[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 97 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm85a, .buf_len = sizeof(bm85a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm85b, .buf_len = sizeof(bm85b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm85c, .buf_len = sizeof(bm85c) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm85a, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm85d, .buf_len = sizeof(bm85d) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm85a, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, + +}, seq86[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 97 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm86a, .buf_len = sizeof(bm86a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm86b, .buf_len = sizeof(bm86b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm86c, .buf_len = sizeof(bm86c) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm86a, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm86d, .buf_len = sizeof(bm86d) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm86a, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq87[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 97 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm87a, .buf_len = sizeof(bm87a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm87b, .buf_len = sizeof(bm87b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm87c, .buf_len = sizeof(bm87c) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm87a, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm87d, .buf_len = sizeof(bm87d) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm87a, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq88[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 17 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm88a, .buf_len = sizeof(bm88a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm88b, .buf_len = sizeof(bm88b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm88c, .buf_len = sizeof(bm88c) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq89[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 17 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm89a, .buf_len = sizeof(bm89a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm89b, .buf_len = sizeof(bm89b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm89c, .buf_len = sizeof(bm89c) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq90[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 17 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm90a, .buf_len = sizeof(bm90a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm90b, .buf_len = sizeof(bm90b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm90c, .buf_len = sizeof(bm90c) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq91[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 17 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm91a, .buf_len = sizeof(bm91a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm91b, .buf_len = sizeof(bm91b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm91c, .buf_len = sizeof(bm91c) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq92[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 17 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm92a, .buf_len = sizeof(bm92a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm92b, .buf_len = sizeof(bm92b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm92c, .buf_len = sizeof(bm92c) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq93[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 16 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm93a, .buf_len = sizeof(bm93a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm93b, .buf_len = sizeof(bm93b) }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm93c, .buf_len = sizeof(bm93c) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm93d, .buf_len = sizeof(bm93d) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm93e, .buf_len = sizeof(bm93e) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm93f, .buf_len = sizeof(bm93f) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq94[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 16 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm94a, .buf_len = sizeof(bm94a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm94b, .buf_len = sizeof(bm94b) }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm94c, .buf_len = sizeof(bm94c) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm94d, .buf_len = sizeof(bm94d) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm94e, .buf_len = sizeof(bm94e) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm94f, .buf_len = sizeof(bm94f) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm94g, .buf_len = sizeof(bm94g) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm94h, .buf_len = sizeof(bm94h) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm94i, .buf_len = sizeof(bm94i) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq95[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 96 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm95a, .buf_len = sizeof(bm95a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm95b, .buf_len = sizeof(bm95b) }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm95c, .buf_len = sizeof(bm95c) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm95d, .buf_len = sizeof(bm95d) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm95e, .buf_len = sizeof(bm95e) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm95f, .buf_len = sizeof(bm95f) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm95f, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm95g, .buf_len = sizeof(bm95g) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm95f, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq96[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 96 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm96a, .buf_len = sizeof(bm96a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm96b, .buf_len = sizeof(bm96b) }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm96c, .buf_len = sizeof(bm96c) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm96d, .buf_len = sizeof(bm96d) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm96e, .buf_len = sizeof(bm96e) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm96f, .buf_len = sizeof(bm96f) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm96g, .buf_len = sizeof(bm96g) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm96h, .buf_len = sizeof(bm96h) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm96i, .buf_len = sizeof(bm96i) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm96f, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm96j, .buf_len = sizeof(bm96j) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm96f, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq97[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 96 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm97a, .buf_len = sizeof(bm97a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 5 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm97b, .buf_len = sizeof(bm97b) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm97c, .buf_len = sizeof(bm97c) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm97f, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm97d, .buf_len = sizeof(bm97d) }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm97e, .buf_len = sizeof(bm97e) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm97f, .buf_len = sizeof(bm97f) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm97g, .buf_len = sizeof(bm97g) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm97e, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq98[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 97 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm98a, .buf_len = sizeof(bm98a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm98b, .buf_len = sizeof(bm98b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm98c, .buf_len = sizeof(bm98c) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm98d, .buf_len = sizeof(bm98d) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm98e, .buf_len = sizeof(bm98e) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm98f, .buf_len = sizeof(bm98f) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm98e, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm98g, .buf_len = sizeof(bm98g) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm98e, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, + +}, seq99[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 97 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm99a, .buf_len = sizeof(bm99a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm99b, .buf_len = sizeof(bm99b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm99c, .buf_len = sizeof(bm99c) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm99d, .buf_len = sizeof(bm99d) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm99e, .buf_len = sizeof(bm99e) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm99f, .buf_len = sizeof(bm99f) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm99g, .buf_len = sizeof(bm99g) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm99h, .buf_len = sizeof(bm99h) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm99i, .buf_len = sizeof(bm99i) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm99a, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm99j, .buf_len = sizeof(bm99j) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm98e, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, + +}, seq100[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 17 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm100a, .buf_len = sizeof(bm100a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm100b, .buf_len = sizeof(bm100b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm100c, .buf_len = sizeof(bm100c) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm100d, .buf_len = sizeof(bm100d) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm100e, .buf_len = sizeof(bm100e) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm100f, .buf_len = sizeof(bm100f) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, + +}, seq101[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 17 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm101a, .buf_len = sizeof(bm101a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm101b, .buf_len = sizeof(bm101b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm101c, .buf_len = sizeof(bm101c) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm101d, .buf_len = sizeof(bm101d) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm101e, .buf_len = sizeof(bm101e) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm101f, .buf_len = sizeof(bm101f) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm101g, .buf_len = sizeof(bm101g) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm101h, .buf_len = sizeof(bm101h) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm101i, .buf_len = sizeof(bm101i) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm101j, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 1 } }, + { .reason = LECPCB_VAL_NUM_INT, .item = { .u.i64 = -6 } }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm101j, .buf_len = sizeof(bm101j) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm101j, .buf_len = 0 }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq102[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 17 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm102a, .buf_len = sizeof(bm102a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm102b, .buf_len = sizeof(bm102b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm102c, .buf_len = sizeof(bm102c) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm102d, .buf_len = sizeof(bm102d) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm102e, .buf_len = sizeof(bm102e) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm102f, .buf_len = sizeof(bm102f) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq103[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 17 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm103a, .buf_len = sizeof(bm103a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm103b, .buf_len = sizeof(bm103b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm103c, .buf_len = sizeof(bm103c) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm103d, .buf_len = sizeof(bm103d) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm103e, .buf_len = sizeof(bm103e) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm103f, .buf_len = sizeof(bm103f) }, + + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm103g, .buf_len = sizeof(bm103g) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm103h, .buf_len = sizeof(bm103h) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm103i, .buf_len = sizeof(bm103i) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, + +}, seq104[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 98 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm104a, .buf_len = sizeof(bm104a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm104b, .buf_len = sizeof(bm104b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm104c, .buf_len = sizeof(bm104c) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm104d, .buf_len = sizeof(bm104d) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm104e, .buf_len = sizeof(bm104e) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm104f, .buf_len = sizeof(bm104f) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm104g, .buf_len = sizeof(bm104g) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm104h, .buf_len = sizeof(bm104h) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq105[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 98 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm105a, .buf_len = sizeof(bm105a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_OBJECT_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm105b, .buf_len = sizeof(bm105b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm105c, .buf_len = sizeof(bm105c) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm105d, .buf_len = sizeof(bm105d) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm105e, .buf_len = sizeof(bm105e) }, + { .reason = LECPCB_OBJECT_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm105f, .buf_len = sizeof(bm105f) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm105g, .buf_len = sizeof(bm105g) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm105h, .buf_len = sizeof(bm105h) }, + { .reason = LECPCB_OBJECT_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm105i, .buf_len = sizeof(bm105i) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm105j, .buf_len = sizeof(bm105j) }, + { .reason = LECPCB_OBJECT_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm105k, .buf_len = sizeof(bm105k) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq106[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 98 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm106a, .buf_len = sizeof(bm106a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm106b, .buf_len = sizeof(bm106b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm106c, .buf_len = sizeof(bm106c) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm106d, .buf_len = sizeof(bm106d) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm106e, .buf_len = sizeof(bm106e) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm106f, .buf_len = sizeof(bm106f) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm106g, .buf_len = sizeof(bm106g) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm106h, .buf_len = sizeof(bm106h) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq107[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 17 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm107a, .buf_len = sizeof(bm107a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm107b, .buf_len = sizeof(bm107b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm107c, .buf_len = sizeof(bm107c) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm107d, .buf_len = sizeof(bm107d) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm107e, .buf_len = sizeof(bm107e) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm107f, .buf_len = sizeof(bm107f) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm107g, .buf_len = sizeof(bm107g) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, +}, seq108[] = { + { .reason = LECPCB_CONSTRUCTED }, + { .reason = LECPCB_TAG_START, .item = { .u.u64 = 18 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm108a, .buf_len = sizeof(bm108a) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 7 } }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm108b, .buf_len = sizeof(bm108b) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm108c, .buf_len = sizeof(bm108c) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm108d, .buf_len = sizeof(bm108d) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_ARRAY_START, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm108e, .buf_len = sizeof(bm108e) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_OBJECT_START, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm108f, .buf_len = sizeof(bm108f) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm108g, .buf_len = sizeof(bm108g) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_VAL_NUM_UINT, .item = { .u.u64 = 4 } }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm108h, .buf_len = sizeof(bm108h) }, + { .reason = LECPCB_OBJECT_END }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm108i, .buf_len = sizeof(bm108i) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_ITEM_START, }, + { .reason = LECPCB_VAL_BLOB_START, }, + { .reason = LECPCB_VAL_BLOB_END, .buf = bm108j, .buf_len = sizeof(bm108j) }, + { .reason = LECPCB_ARRAY_ITEM_END, }, + { .reason = LECPCB_ARRAY_END, }, + { .reason = LECPCB_TAG_END, }, + { .reason = LECPCB_DESTRUCTED }, +}; + + +struct cbort { + const uint8_t *b; + size_t blen; + const struct seq *seq; + size_t seq_size; +}; + +static const struct cbort cbor_tests[] = { + { .b = test1, .blen = sizeof(test1), + .seq = seq1, .seq_size = LWS_ARRAY_SIZE(seq1) }, + { .b = test2, .blen = sizeof(test2), + .seq = seq2, .seq_size = LWS_ARRAY_SIZE(seq2) }, + { .b = test3, .blen = sizeof(test3), + .seq = seq3, .seq_size = LWS_ARRAY_SIZE(seq3) }, + { .b = test4, .blen = sizeof(test4), + .seq = seq4, .seq_size = LWS_ARRAY_SIZE(seq4) }, + { .b = test5, .blen = sizeof(test5), + .seq = seq5, .seq_size = LWS_ARRAY_SIZE(seq5) }, + { .b = test6, .blen = sizeof(test6), + .seq = seq6, .seq_size = LWS_ARRAY_SIZE(seq6) }, + { .b = test7, .blen = sizeof(test7), + .seq = seq7, .seq_size = LWS_ARRAY_SIZE(seq7) }, + { .b = test8, .blen = sizeof(test8), + .seq = seq8, .seq_size = LWS_ARRAY_SIZE(seq8) }, + { .b = test9, .blen = sizeof(test9), + .seq = seq9, .seq_size = LWS_ARRAY_SIZE(seq9) }, + { .b = test10, .blen = sizeof(test10), + .seq = seq10, .seq_size = LWS_ARRAY_SIZE(seq10) }, + { .b = test11, .blen = sizeof(test11), + .seq = seq11, .seq_size = LWS_ARRAY_SIZE(seq11) }, + { .b = test12, .blen = sizeof(test12), + .seq = seq12, .seq_size = LWS_ARRAY_SIZE(seq12) }, + { .b = test13, .blen = sizeof(test13), + .seq = seq13, .seq_size = LWS_ARRAY_SIZE(seq13) }, + { .b = test14, .blen = sizeof(test14), + .seq = seq14, .seq_size = LWS_ARRAY_SIZE(seq14) }, + { .b = test15, .blen = sizeof(test15), + .seq = seq15, .seq_size = LWS_ARRAY_SIZE(seq15) }, + { .b = test16, .blen = sizeof(test16), + .seq = seq16, .seq_size = LWS_ARRAY_SIZE(seq16) }, + { .b = test17, .blen = sizeof(test17), + .seq = seq17, .seq_size = LWS_ARRAY_SIZE(seq17) }, + { .b = test18, .blen = sizeof(test18), + .seq = seq18, .seq_size = LWS_ARRAY_SIZE(seq18) }, + { .b = test19, .blen = sizeof(test19), + .seq = seq19, .seq_size = LWS_ARRAY_SIZE(seq19) }, + { .b = test20, .blen = sizeof(test20), + .seq = seq20, .seq_size = LWS_ARRAY_SIZE(seq20) }, + { .b = test21, .blen = sizeof(test21), + .seq = seq21, .seq_size = LWS_ARRAY_SIZE(seq21) }, + { .b = test22, .blen = sizeof(test22), + .seq = seq22, .seq_size = LWS_ARRAY_SIZE(seq22) }, + { .b = test23, .blen = sizeof(test23), + .seq = seq23, .seq_size = LWS_ARRAY_SIZE(seq23) }, + { .b = test24, .blen = sizeof(test24), + .seq = seq24, .seq_size = LWS_ARRAY_SIZE(seq24) }, + { .b = test25, .blen = sizeof(test25), + .seq = seq25, .seq_size = LWS_ARRAY_SIZE(seq25) }, + { .b = test26, .blen = sizeof(test26), + .seq = seq26, .seq_size = LWS_ARRAY_SIZE(seq26) }, + { .b = test27, .blen = sizeof(test27), + .seq = seq27, .seq_size = LWS_ARRAY_SIZE(seq27) }, + { .b = test28, .blen = sizeof(test28), + .seq = seq28, .seq_size = LWS_ARRAY_SIZE(seq28) }, + { .b = test29, .blen = sizeof(test29), + .seq = seq29, .seq_size = LWS_ARRAY_SIZE(seq29) }, + { .b = test30, .blen = sizeof(test30), + .seq = seq30, .seq_size = LWS_ARRAY_SIZE(seq30) }, + { .b = test31, .blen = sizeof(test31), + .seq = seq31, .seq_size = LWS_ARRAY_SIZE(seq31) }, + { .b = test32, .blen = sizeof(test32), + .seq = seq32, .seq_size = LWS_ARRAY_SIZE(seq32) }, + { .b = test33, .blen = sizeof(test33), + .seq = seq33, .seq_size = LWS_ARRAY_SIZE(seq33) }, + { .b = test34, .blen = sizeof(test34), + .seq = seq34, .seq_size = LWS_ARRAY_SIZE(seq34) }, + { .b = test35, .blen = sizeof(test35), + .seq = seq35, .seq_size = LWS_ARRAY_SIZE(seq35) }, + { .b = test36, .blen = sizeof(test36), + .seq = seq36, .seq_size = LWS_ARRAY_SIZE(seq36) }, + { .b = test37, .blen = sizeof(test37), + .seq = seq37, .seq_size = LWS_ARRAY_SIZE(seq37) }, + { .b = test38, .blen = sizeof(test38), + .seq = seq38, .seq_size = LWS_ARRAY_SIZE(seq38) }, + { .b = test39, .blen = sizeof(test39), + .seq = seq39, .seq_size = LWS_ARRAY_SIZE(seq39) }, + { .b = test40, .blen = sizeof(test40), + .seq = seq40, .seq_size = LWS_ARRAY_SIZE(seq40) }, + { .b = test41, .blen = sizeof(test41), + .seq = seq41, .seq_size = LWS_ARRAY_SIZE(seq41) }, + { .b = test42, .blen = sizeof(test42), + .seq = seq42, .seq_size = LWS_ARRAY_SIZE(seq42) }, + { .b = test43, .blen = sizeof(test43), + .seq = seq43, .seq_size = LWS_ARRAY_SIZE(seq43) }, + { .b = test44, .blen = sizeof(test44), + .seq = seq44, .seq_size = LWS_ARRAY_SIZE(seq44) }, + { .b = test45, .blen = sizeof(test45), + .seq = seq45, .seq_size = LWS_ARRAY_SIZE(seq45) }, + { .b = test46, .blen = sizeof(test46), + .seq = seq46, .seq_size = LWS_ARRAY_SIZE(seq46) }, + { .b = test47, .blen = sizeof(test47), + .seq = seq47, .seq_size = LWS_ARRAY_SIZE(seq47) }, + { .b = test48, .blen = sizeof(test48), + .seq = seq48, .seq_size = LWS_ARRAY_SIZE(seq48) }, + { .b = test49, .blen = sizeof(test49), + .seq = seq49, .seq_size = LWS_ARRAY_SIZE(seq49) }, + { .b = test50, .blen = sizeof(test50), + .seq = seq50, .seq_size = LWS_ARRAY_SIZE(seq50) }, + { .b = test51, .blen = sizeof(test51), + .seq = seq51, .seq_size = LWS_ARRAY_SIZE(seq51) }, + { .b = test52, .blen = sizeof(test52), + .seq = seq52, .seq_size = LWS_ARRAY_SIZE(seq52) }, + { .b = test53, .blen = sizeof(test53), + .seq = seq53, .seq_size = LWS_ARRAY_SIZE(seq53) }, + { .b = test54, .blen = sizeof(test54), + .seq = seq54, .seq_size = LWS_ARRAY_SIZE(seq54) }, + { .b = test55, .blen = sizeof(test55), + .seq = seq55, .seq_size = LWS_ARRAY_SIZE(seq55) }, + { .b = test56, .blen = sizeof(test56), + .seq = seq56, .seq_size = LWS_ARRAY_SIZE(seq56) }, + { .b = test57, .blen = sizeof(test57), + .seq = seq57, .seq_size = LWS_ARRAY_SIZE(seq57) }, + { .b = test58, .blen = sizeof(test58), + .seq = seq58, .seq_size = LWS_ARRAY_SIZE(seq58) }, + { .b = test59, .blen = sizeof(test59), + .seq = seq59, .seq_size = LWS_ARRAY_SIZE(seq59) }, + { .b = test60, .blen = sizeof(test60), + .seq = seq60, .seq_size = LWS_ARRAY_SIZE(seq60) }, + { .b = test61, .blen = sizeof(test61), + .seq = seq61, .seq_size = LWS_ARRAY_SIZE(seq61) }, + { .b = test62, .blen = sizeof(test62), + .seq = seq62, .seq_size = LWS_ARRAY_SIZE(seq62) }, + { .b = test63, .blen = sizeof(test63), + .seq = seq63, .seq_size = LWS_ARRAY_SIZE(seq63) }, + { .b = test64, .blen = sizeof(test64), + .seq = seq64, .seq_size = LWS_ARRAY_SIZE(seq64) }, + { .b = test65, .blen = sizeof(test65), + .seq = seq65, .seq_size = LWS_ARRAY_SIZE(seq65) }, + { .b = test66, .blen = sizeof(test66), + .seq = seq66, .seq_size = LWS_ARRAY_SIZE(seq66) }, + { .b = test67, .blen = sizeof(test67), + .seq = seq67, .seq_size = LWS_ARRAY_SIZE(seq67) }, + { .b = test68, .blen = sizeof(test68), + .seq = seq68, .seq_size = LWS_ARRAY_SIZE(seq68) }, + { .b = test69, .blen = sizeof(test69), + .seq = seq69, .seq_size = LWS_ARRAY_SIZE(seq69) }, + { .b = test70, .blen = sizeof(test70), + .seq = seq70, .seq_size = LWS_ARRAY_SIZE(seq70) }, + { .b = test71, .blen = sizeof(test71), + .seq = seq71, .seq_size = LWS_ARRAY_SIZE(seq71) }, + { .b = test72, .blen = sizeof(test72), + .seq = seq72, .seq_size = LWS_ARRAY_SIZE(seq72) }, + { .b = test73, .blen = sizeof(test73), + .seq = seq73, .seq_size = LWS_ARRAY_SIZE(seq73) }, + { .b = test74, .blen = sizeof(test74), + .seq = seq74, .seq_size = LWS_ARRAY_SIZE(seq74) }, + { .b = test75, .blen = sizeof(test75), + .seq = seq75, .seq_size = LWS_ARRAY_SIZE(seq75) }, + { .b = test76, .blen = sizeof(test76), + .seq = seq76, .seq_size = LWS_ARRAY_SIZE(seq76) }, + { .b = test77, .blen = sizeof(test77), + .seq = seq77, .seq_size = LWS_ARRAY_SIZE(seq77) }, + { .b = test78, .blen = sizeof(test78), + .seq = seq78, .seq_size = LWS_ARRAY_SIZE(seq78) }, + { .b = test79, .blen = sizeof(test79), + .seq = seq79, .seq_size = LWS_ARRAY_SIZE(seq79) }, + { .b = test80, .blen = sizeof(test80), + .seq = seq80, .seq_size = LWS_ARRAY_SIZE(seq80) }, + { .b = test81, .blen = sizeof(test81), + .seq = seq81, .seq_size = LWS_ARRAY_SIZE(seq81) }, + { .b = test82, .blen = sizeof(test82), + .seq = seq82, .seq_size = LWS_ARRAY_SIZE(seq82) }, + + /* COSE-dervied test vectors */ + + { .b = test83, .blen = sizeof(test83), + .seq = seq83, .seq_size = LWS_ARRAY_SIZE(seq83) }, + { .b = test84, .blen = sizeof(test84), + .seq = seq84, .seq_size = LWS_ARRAY_SIZE(seq84) }, + { .b = test85, .blen = sizeof(test85), + .seq = seq85, .seq_size = LWS_ARRAY_SIZE(seq85) }, + { .b = test86, .blen = sizeof(test86), + .seq = seq86, .seq_size = LWS_ARRAY_SIZE(seq86) }, + { .b = test87, .blen = sizeof(test87), + .seq = seq87, .seq_size = LWS_ARRAY_SIZE(seq87) }, + { .b = test88, .blen = sizeof(test88), + .seq = seq88, .seq_size = LWS_ARRAY_SIZE(seq88) }, + { .b = test89, .blen = sizeof(test89), + .seq = seq89, .seq_size = LWS_ARRAY_SIZE(seq89) }, + { .b = test90, .blen = sizeof(test90), + .seq = seq90, .seq_size = LWS_ARRAY_SIZE(seq90) }, + { .b = test91, .blen = sizeof(test91), + .seq = seq91, .seq_size = LWS_ARRAY_SIZE(seq91) }, + { .b = test92, .blen = sizeof(test92), + .seq = seq92, .seq_size = LWS_ARRAY_SIZE(seq92) }, + { .b = test93, .blen = sizeof(test93), + .seq = seq93, .seq_size = LWS_ARRAY_SIZE(seq93) }, + { .b = test94, .blen = sizeof(test94), + .seq = seq94, .seq_size = LWS_ARRAY_SIZE(seq94) }, + { .b = test95, .blen = sizeof(test95), + .seq = seq95, .seq_size = LWS_ARRAY_SIZE(seq95) }, + { .b = test96, .blen = sizeof(test96), + .seq = seq96, .seq_size = LWS_ARRAY_SIZE(seq96) }, + { .b = test97, .blen = sizeof(test97), + .seq = seq97, .seq_size = LWS_ARRAY_SIZE(seq97) }, + { .b = test98, .blen = sizeof(test98), + .seq = seq98, .seq_size = LWS_ARRAY_SIZE(seq98) }, + { .b = test99, .blen = sizeof(test99), + .seq = seq99, .seq_size = LWS_ARRAY_SIZE(seq99) }, + { .b = test100, .blen = sizeof(test100), + .seq = seq100, .seq_size = LWS_ARRAY_SIZE(seq100) }, + { .b = test101, .blen = sizeof(test101), + .seq = seq101, .seq_size = LWS_ARRAY_SIZE(seq101) }, + { .b = test102, .blen = sizeof(test102), + .seq = seq102, .seq_size = LWS_ARRAY_SIZE(seq102) }, + { .b = test103, .blen = sizeof(test103), + .seq = seq103, .seq_size = LWS_ARRAY_SIZE(seq103) }, + { .b = test104, .blen = sizeof(test104), + .seq = seq104, .seq_size = LWS_ARRAY_SIZE(seq104) }, + { .b = test105, .blen = sizeof(test105), + .seq = seq105, .seq_size = LWS_ARRAY_SIZE(seq105) }, + { .b = test106, .blen = sizeof(test106), + .seq = seq106, .seq_size = LWS_ARRAY_SIZE(seq106) }, + { .b = test107, .blen = sizeof(test107), + .seq = seq107, .seq_size = LWS_ARRAY_SIZE(seq107) }, + { .b = test108, .blen = sizeof(test108), + .seq = seq108, .seq_size = LWS_ARRAY_SIZE(seq108) }, +}; + +static const uint8_t + w1[] = { 0x65, 0x68, 0x65, 0x6C, + 0x6C, 0x6F }, + w2[] = { 0xc2 }, + w3[] = { 0x82, 0x63, 0x61, 0x62, + 0x63, 0x63, 0x64, 0x65, + 0x66 }, + w4[] = { 0xA2, 0x63, 0x67, 0x68, + 0x69, 0x01, 0x63, 0x6A, + 0x6B, 0x6C, 0x02 }, + w5[] = { 0xD8, 0x7B, 0xA2, 0x63, + 0x67, 0x68, 0x69, 0x01, + 0x63, 0x6A, 0x6B, 0x6C, + 0x02 }, + w6[] = { 0xCC, 0xA2, 0x63, 0x67, + 0x68, 0x69, 0x01, 0x63, + 0x6A, 0x6B, 0x6C, 0x82, + 0x61, 0x61, 0x61, 0x62 }, + w7[] = { 0x20, }, + w8[] = { 0x0c, }, + w13[] = { 0x18, 0x34 }, + w14[] = { 0x19, 0x12, 0x34 }, + w15[] = { 0x1a, 0x12, 0x34, 0x56, 0x78 }, + w16[] = { 0x1b, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0 }, + w17[] = { 0x65, 0x68, 0x65, 0x6C, 0x6C, 0x6F }, + w18[] = { 0x25 }, + w19[] = { + 0xd8, 0x7b, 0x58, 0xb7, + 0xd8, 0x62, 0x84, 0x43, 0xa1, + 0x03, 0x00, 0xa1, 0x07, 0x83, + 0x43, 0xa1, 0x01, 0x27, 0xa1, + 0x04, 0x42, 0x31, 0x31, 0x58, + 0x40, 0xb7, 0xca, 0xcb, 0xa2, + 0x85, 0xc4, 0xcd, 0x3e, 0xd2, + 0xf0, 0x14, 0x6f, 0x41, 0x98, + 0x86, 0x14, 0x4c, 0xa6, 0x38, + 0xd0, 0x87, 0xde, 0x12, 0x3d, + 0x40, 0x01, 0x67, 0x30, 0x8a, + 0xce, 0xab, 0xc4, 0xb5, 0xe5, + 0xc6, 0xa4, 0x0c, 0x0d, 0xe0, + }, + w19a[] = { + 0xb7, 0x11, 0x67, 0xa3, 0x91, + 0x75, 0xea, 0x56, 0xc1, 0xfe, + 0x96, 0xc8, 0x9e, 0x5e, 0x7d, + 0x30, 0xda, 0xf2, 0x43, 0x8a, + 0x45, 0x61, 0x59, 0xa2, 0x0a, + 0x54, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x69, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x2e, 0x81, 0x83, 0x43, 0xa1, + 0x01, 0x27, 0xa1, 0x04, 0x42, + 0x31, 0x31, 0x58, 0x40, 0x77, + 0xf3, 0xea, 0xcd, 0x11,}, + w19b[] = { + 0x85, 0x2c, 0x4b, 0xf9, 0xcb, 0x1d, + 0x72, 0xfa, 0xbe, 0x6b, 0x26, + 0xfb, 0xa1, 0xd7, 0x60, 0x92, + 0xb2, 0xb5, 0xb7, 0xec, 0x83, + 0xb8, 0x35, 0x57, 0x65, 0x22, + 0x64, 0xe6, 0x96, 0x90, 0xdb, + 0xc1, 0x17, 0x2d, 0xdc, 0x0b, + 0xf8, 0x84, 0x11, 0xc0, 0xd2, + 0x5a, 0x50, 0x7f, 0xdb, 0x24, + 0x7a, 0x20, 0xc4, 0x0d, 0x5e, + 0x24, 0x5f, 0xab, 0xd3, 0xfc, + 0x9e, 0xc1, 0x06 }, + w22[] = { 0xD8, 0x7B, 0x19, 0x01, 0xC8 }, + w24[] = { 0xDB, 0x12, 0x34, 0x56, 0x78, 0x9A, + 0xBC, 0xED, 0xF0, 0x19, 0x01, 0xC8}, + w25[] = { 0xF9, 0x3C, 0x00 }, + w26[] = { 0xF9, 0x3E, 0x00 }, + w27[] = { 0xFB, 0x3F, 0xF1, 0xF7, 0xCE, 0xD9, 0x16, 0x87, 0x2B }, + w28[] = { 0xA2, 0x61, 0x61, 0x01, 0x61, 0x62, 0x82, 0x02, 0x03 }, + w29[] = { 0x7F, 0x65, 0x68, 0x65, 0x6C, 0x6C, 0x6F, 0xFF +} +; + +static const char * const tok[] = { + "something", +}; + +struct priv { + const struct cbort *cbt; + size_t idx; +}; + +static int pass; + +static signed char +test_cb(struct lecp_ctx *ctx, char reason) +{ + struct priv *priv = (struct priv *)ctx->user; + size_t i = priv->idx++; + +#if defined(VERBOSE) + lwsl_notice("%s: %s, ctx->path %s\n", __func__, + reason_names[(int)reason & 0x1f], ctx->path); +#endif + + // if (ctx->npos) + // lwsl_hexdump_notice(ctx->buf, ctx->npos); + + if (!priv->cbt->seq) + return 0; + + if (i >= priv->cbt->seq_size) { + lwsl_warn("%s: unexpected parse states\n", __func__); + return 1; + } + + if (priv->cbt->seq[i].reason != reason) { + lwsl_warn("%s: reason mismatch\n", __func__); + return 1; + } + + if (priv->cbt->seq[i].buf && + (priv->cbt->seq[i].buf_len != ctx->npos || + memcmp(priv->cbt->seq[i].buf, ctx->buf, ctx->npos))) { + lwsl_warn("%s: buf mismatch\n", __func__); + lwsl_hexdump_notice(ctx->buf, (size_t)ctx->npos); + return 1; + } + + switch (reason) { + case LECPCB_VAL_SIMPLE: + case LECPCB_VAL_NUM_UINT: + case LECPCB_VAL_NUM_INT: + if (ctx->item.u.u64 != priv->cbt->seq[i].item.u.u64) { + lwsl_warn("%s: number mismatch %llu %llu\n", __func__, + (unsigned long long)ctx->item.u.u64, + (unsigned long long)priv->cbt->seq[i].item.u.u64); + return 1; + } + break; + + case LECPCB_VAL_FLOAT16: + if (ctx->item.u.hf != priv->cbt->seq[i].item.u.hf) { + lwsl_warn("%s: number mismatch %llu %llu\n", __func__, + (unsigned long long)ctx->item.u.hf, + (unsigned long long)priv->cbt->seq[i].item.u.hf); + return 1; + } + break; + case LECPCB_VAL_FLOAT32: +#if defined(LWS_WITH_CBOR_FLOAT) + if (!isfinite(ctx->item.u.f) && + !isfinite(priv->cbt->seq[i].item.u.f)) + break; + if (isnan(ctx->item.u.f) && + isnan(priv->cbt->seq[i].item.u.f)) + break; +#endif + if (ctx->item.u.f != priv->cbt->seq[i].item.u.f) { +#if defined(LWS_WITH_CBOR_FLOAT) + lwsl_warn("%s: number mismatch %f %f\n", __func__, + ctx->item.u.f, + priv->cbt->seq[i].item.u.f); +#else + lwsl_warn("%s: f32 number mismatch %llu %llu\n", __func__, + (unsigned long long)ctx->item.u.f, + (unsigned long long)priv->cbt->seq[i].item.u.f); +#endif + return 1; + } + break; + case LECPCB_VAL_FLOAT64: +#if defined(LWS_WITH_CBOR_FLOAT) + if (!isfinite(ctx->item.u.d) && + !isfinite(priv->cbt->seq[i].item.u.d)) + break; + if (isnan(ctx->item.u.d) && + isnan(priv->cbt->seq[i].item.u.d)) + break; +#endif + if (ctx->item.u.d != priv->cbt->seq[i].item.u.d) { +#if defined(LWS_WITH_CBOR_FLOAT) + lwsl_warn("%s: f64 number mismatch %f %f\n", __func__, + ctx->item.u.d, + priv->cbt->seq[i].item.u.d); +#else + lwsl_warn("%s: number mismatch %llu %llu\n", __func__, + (unsigned long long)ctx->item.u.d, + (unsigned long long)priv->cbt->seq[i].item.u.d); +#endif + return 1; + } + break; + + case LECPCB_DESTRUCTED: + pass++; + break; + } + + return 0; +} + +int main(int argc, const char **argv) +{ + int n, m, e = 0, logs = LLL_USER | LLL_ERR | LLL_WARN | LLL_NOTICE, + expected = (int)LWS_ARRAY_SIZE(cbor_tests) + + 29 /* <-- how many write tests */; + struct lecp_ctx ctx; + const char *p; + + if ((p = lws_cmdline_option(argc, argv, "-d"))) + logs = atoi(p); + + lws_set_log_level(logs, NULL); + lwsl_user("LWS API selftest: LECP CBOR parser\n"); + + for (m = 0; m < (int)LWS_ARRAY_SIZE(cbor_tests); m++) { + + struct priv priv; + + priv.cbt = &cbor_tests[m]; + priv.idx = 0; + + lwsl_notice("%s: ++++++++++++++++ test %d\n", __func__, m + 1); + + lecp_construct(&ctx, test_cb, &priv, tok, LWS_ARRAY_SIZE(tok)); + + lwsl_hexdump_info(cbor_tests[m].b, cbor_tests[m].blen); + +#if 0 + { + char fn[128]; + int fd; + + lws_snprintf(fn, sizeof(fn), "/tmp/cbor-%d", m + 1); + fd = open(fn, LWS_O_CREAT | LWS_O_TRUNC | LWS_O_WRONLY, 0600); + if (fd != -1) { + write(fd, cbor_tests[m].b, + cbor_tests[m].blen); + close(fd); + } + } +#endif + + n = lecp_parse(&ctx, cbor_tests[m].b, + cbor_tests[m].blen); + + lecp_destruct(&ctx); + + if (n < 0 && m + 1 != 46 /* expected to fail */) { + lwsl_err("%s: test %d: CBOR decode failed %d '%s'\n", + __func__, m + 1, n, + lecp_error_to_string(n)); + e++; + } + } + + { + lws_lec_pctx_t ctx; + uint8_t buf[64]; + + lws_lec_init(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "'hello'") != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w1) || memcmp(w1, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "2()") != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w2) || memcmp(w2, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "['abc','def']") != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w3) || memcmp(w3, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test4\n", __func__); + + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "{'ghi':1,'jkl':2}") != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w4) || memcmp(w4, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test5\n", __func__); + + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "123({'ghi':1,'jkl':2})") != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w5) || memcmp(w5, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test6\n", __func__); + + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "12({'ghi':1,'jkl':['a', 'b']})") != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w6) || memcmp(w6, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test7\n", __func__); + + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "%d", -1) != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w7) || memcmp(w7, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test8\n", __func__); + + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "%ld", -1l) != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w7) || memcmp(w7, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test9\n", __func__); + + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "%lld", -1ll) != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w7) || memcmp(w7, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test10\n", __func__); + + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "%u", 12) != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w8) || memcmp(w8, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test11\n", __func__); + + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "%ld", 12l) != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w8) || memcmp(w8, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test12\n", __func__); + + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "%lld", 12ll) != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w8) || memcmp(w8, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test13\n", __func__); + + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "%u", 0x34u) != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w13) || memcmp(w13, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test14\n", __func__); + + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "%ld", 0x1234ul) != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w14) || memcmp(w14, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test15\n", __func__); + + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "%lld", 0x12345678ull) != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w15) || memcmp(w15, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test16\n", __func__); + + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "%lld", 0x123456789abcdef0ull) != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w16) || memcmp(w16, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test17\n", __func__); + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "%s", "hello") != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w17) || memcmp(w17, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test18\n", __func__); + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "-6") != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w18) || memcmp(w18, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + /* + * A big binary blob is going to get emitted in 3 output + * buffers, by calling it two more times while still handling + * the same format object, format objects before that which + * were completed are skipped on the subsequent calls + */ + + lwsl_user("%s: test19\n", __func__); + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "123(%.*b)", (int)sizeof(test106), test106) != + LWS_LECPCTX_RET_AGAIN || + ctx.used != sizeof(w19) || memcmp(w19, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test20\n", __func__); + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "123(%.*b)", (int)sizeof(test106), test106) != + LWS_LECPCTX_RET_AGAIN || + ctx.used != sizeof(w19a) || memcmp(w19a, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test21\n", __func__); + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "123(%.*b)", (int)sizeof(test106), test106) != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w19b) || memcmp(w19b, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test22\n", __func__); + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "%t(456)", 123) != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w22) || memcmp(w22, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test23\n", __func__); + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "%lt(456)", 123ul) != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w22) || memcmp(w22, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test24\n", __func__); + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "%llt(456)", 0x123456789abcedf0ull) != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w24) || memcmp(w24, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test25\n", __func__); + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "%f", 1.0) != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w25) || memcmp(w25, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test26\n", __func__); + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "%f", 1.5) != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w26) || memcmp(w26, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + lwsl_user("%s: test27\n", __func__); + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "%f", 1.123) != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w27) || memcmp(w27, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + + { + int args[3] = { 1, 2, 3 }; + + lwsl_user("%s: test28\n", __func__); + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "{'a':%d,'b':[%d,%d]}", + args[0], args[1], args[2]) != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w28) || + memcmp(w28, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + } + + lwsl_user("%s: test29\n", __func__); + lws_lec_setbuf(&ctx, buf, sizeof(buf)); + + if (lws_lec_printf(&ctx, "") != + LWS_LECPCTX_RET_FINISHED || + ctx.used != sizeof(w29) || memcmp(w29, buf, ctx.used)) { + lwsl_hexdump_notice(ctx.start, ctx.used); + e++; + } else + pass++; + } + + if (e) + goto bail; + + if (pass != expected) + goto bail; + + lwsl_user("Completed: PASS %d / %d\n", pass, expected); + + return 0; + +bail: + lwsl_user("Completed: FAIL, passed %d / %d (e %d)\n", pass, + expected, e); + + return 1; +} diff --git a/test-apps/CMakeLists.txt b/test-apps/CMakeLists.txt index cb3c98046..9ffed9f83 100644 --- a/test-apps/CMakeLists.txt +++ b/test-apps/CMakeLists.txt @@ -185,6 +185,19 @@ if ((LWS_ROLE_H1 OR LWS_ROLE_H2)) target_compile_definitions(test-lejp PRIVATE LWS_BUILDING_STATIC) endif() + if (LWS_WITH_CBOR) + create_test_app( + test-lecp + "test-lecp.c" + "" + "" + "" + "" + "") + target_compile_definitions(test-lecp PRIVATE LWS_BUILDING_STATIC) + endif() + + # Data files for running the test server. list(APPEND TEST_SERVER_DATA "${PROJECT_SOURCE_DIR}/test-apps/favicon.ico" diff --git a/test-apps/test-lecp.c b/test-apps/test-lecp.c new file mode 100644 index 000000000..f10f0d2af --- /dev/null +++ b/test-apps/test-lecp.c @@ -0,0 +1,170 @@ +/* + * lejp test app + * + * Written in 2010-2019 by Andy Green + * + * This file is made available under the Creative Commons CC0 1.0 + * Universal Public Domain Dedication. + * + * This demonstrates a minimal http server that performs a form GET with a couple + * of parameters. It dumps the parameters to the console log and redirects + * to another page. + */ + +#include +#include + + +static const char * const reason_names[] = { + "LECPCB_CONSTRUCTED", + "LECPCB_DESTRUCTED", + "LECPCB_START", + "LECPCB_COMPLETE", + "LECPCB_FAILED", + "LECPCB_PAIR_NAME", + "LECPCB_VAL_TRUE", + "LECPCB_VAL_FALSE", + "LECPCB_VAL_NULL", + "LECPCB_VAL_NUM_INT", + "LECPCB_VAL_RESERVED", /* float in lejp */ + "LECPCB_VAL_STR_START", + "LECPCB_VAL_STR_CHUNK", + "LECPCB_VAL_STR_END", + "LECPCB_ARRAY_START", + "LECPCB_ARRAY_END", + "LECPCB_OBJECT_START", + "LECPCB_OBJECT_END", + "LECPCB_TAG_START", + "LECPCB_TAG_END", + "LECPCB_VAL_NUM_UINT", + "LECPCB_VAL_UNDEFINED", + "LECPCB_VAL_FLOAT16", + "LECPCB_VAL_FLOAT32", + "LECPCB_VAL_FLOAT64", + "LECPCB_VAL_SIMPLE", + "LECPCB_VAL_BLOB_START", + "LECPCB_VAL_BLOB_CHUNK", + "LECPCB_VAL_BLOB_END", +}; + +static const char * const tok[] = { + "dummy___" +}; + +static signed char +cb(struct lecp_ctx *ctx, char reason) +{ + char buf[1024], *p = buf, *end = &buf[sizeof(buf)]; + int n; + + for (n = 0; n < ctx->sp; n++) + *p++ = ' '; + *p = '\0'; + + lwsl_notice("%s%s: path %s match %d statckp %d\r\n", buf, + reason_names[(unsigned int)(reason) & + (LEJP_FLAG_CB_IS_VALUE - 1)], ctx->path, + ctx->path_match, ctx->pst[ctx->pst_sp].ppos); + + if (reason & LECP_FLAG_CB_IS_VALUE) { + + switch (reason) { + case LECPCB_VAL_NUM_UINT: + p += lws_snprintf(p, lws_ptr_diff_size_t(end, p), + " value %llu ", + (unsigned long long)ctx->item.u.u64); + break; + case LECPCB_VAL_STR_START: + case LECPCB_VAL_STR_CHUNK: + case LECPCB_VAL_STR_END: + p += lws_snprintf(p, lws_ptr_diff_size_t(end, p), + " value '%s' ", ctx->buf); + break; + + case LECPCB_VAL_BLOB_START: + case LECPCB_VAL_BLOB_CHUNK: + case LECPCB_VAL_BLOB_END: + if (ctx->npos) + lwsl_hexdump_notice(ctx->buf, (size_t)ctx->npos); + break; + + case LECPCB_VAL_NUM_INT: + p += lws_snprintf(p, lws_ptr_diff_size_t(end, p), + " value %lld ", + (long long)ctx->item.u.i64); + break; + case LECPCB_VAL_FLOAT16: + case LECPCB_VAL_FLOAT32: + case LECPCB_VAL_FLOAT64: + break; + + case LECPCB_VAL_SIMPLE: + p += lws_snprintf(p, lws_ptr_diff_size_t(end, p), + " simple %llu ", + (unsigned long long)ctx->item.u.u64); + break; + } + if (ctx->ipos) { + int n; + + p += lws_snprintf(p, lws_ptr_diff_size_t(end, p), "(array indexes: "); + for (n = 0; n < ctx->ipos; n++) + p += lws_snprintf(p, lws_ptr_diff_size_t(end, p), "%d ", ctx->i[n]); + p += lws_snprintf(p, lws_ptr_diff_size_t(end, p), ") "); + } + + lwsl_notice("%s \r\n", buf); + + (void)reason_names; /* NO_LOGS... */ + return 0; + } + + switch (reason) { + case LECPCB_COMPLETE: + lwsl_notice("%sParsing Completed (LEJPCB_COMPLETE)\n", buf); + break; + case LECPCB_PAIR_NAME: + lwsl_notice("%spath: '%s' (LEJPCB_PAIR_NAME)\n", buf, ctx->path); + break; + case LECPCB_TAG_START: + lwsl_notice("LECPCB_TAG_START: %llu\r\n", (unsigned long long)ctx->item.u.u64); + return 0; + } + + return 0; +} + +int +main(int argc, char *argv[]) +{ + int fd, n = 1, ret = 1, m = 0; + struct lecp_ctx ctx; + char buf[128]; + + lws_set_log_level(7, NULL); + + lwsl_notice("libwebsockets-test-lecp (C) 2017 - 2021 andy@warmcat.com\n"); + lwsl_notice(" usage: cat my.cbor | libwebsockets-test-lecp\n\n"); + + lecp_construct(&ctx, cb, NULL, tok, LWS_ARRAY_SIZE(tok)); + + fd = 0; + + while (n > 0) { + n = (int)read(fd, buf, sizeof(buf)); + if (n <= 0) + continue; + + m = lecp_parse(&ctx, (uint8_t *)buf, (size_t)n); + if (m < 0 && m != LEJP_CONTINUE) { + lwsl_err("parse failed %d\n", m); + goto bail; + } + } + lwsl_notice("okay (%d)\n", m); + ret = 0; +bail: + lecp_destruct(&ctx); + + return ret; +}