https://github.com/nodejs/node/compare/61db2609e3c45affbe6170b8b3b6014002c8fca1...4a32c00fb8dbe55c3bcf9ef43343968c9fe449e6 From 5320a1b96f4820e53c33dccb3019c14cf7260af3 Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Sun, 26 Apr 2026 01:03:53 +0000 Subject: [PATCH 1/2] deps: update nghttp2 to 1.69.0 PR-URL: https://github.com/nodejs/node/pull/62891 Reviewed-By: Luigi Pinca Reviewed-By: Stephen Belanger Reviewed-By: Antoine du Hamel --- deps/nghttp2/lib/CMakeLists.txt | 2 +- deps/nghttp2/lib/includes/nghttp2/nghttp2.h | 2 +- .../nghttp2/lib/includes/nghttp2/nghttp2ver.h | 4 +- deps/nghttp2/lib/nghttp2_alpn.c | 4 +- deps/nghttp2/lib/nghttp2_frame.c | 10 + deps/nghttp2/lib/nghttp2_frame.h | 3 - deps/nghttp2/lib/nghttp2_hd.c | 17 +- deps/nghttp2/lib/nghttp2_hd_huffman.c | 23 +- deps/nghttp2/lib/nghttp2_hd_huffman.h | 14 +- deps/nghttp2/lib/nghttp2_hd_huffman_data.c | 8224 ++++++++--------- deps/nghttp2/lib/nghttp2_helper.h | 10 +- deps/nghttp2/lib/nghttp2_http.c | 3 +- deps/nghttp2/lib/nghttp2_int.h | 7 +- deps/nghttp2/lib/nghttp2_map.c | 267 +- deps/nghttp2/lib/nghttp2_map.h | 17 +- deps/nghttp2/lib/nghttp2_outbound_item.c | 12 + deps/nghttp2/lib/nghttp2_outbound_item.h | 16 +- deps/nghttp2/lib/nghttp2_session.c | 236 +- deps/nghttp2/lib/nghttp2_session.h | 4 +- deps/nghttp2/lib/nghttp2_submit.c | 6 +- 20 files changed, 4558 insertions(+), 4323 deletions(-) diff --git a/deps/nghttp2/lib/CMakeLists.txt b/deps/nghttp2/lib/CMakeLists.txt index 98e3dbe7682fb0..3b6a4400305b31 100644 --- a/deps/nghttp2/lib/CMakeLists.txt +++ b/deps/nghttp2/lib/CMakeLists.txt @@ -51,7 +51,7 @@ set(NGHTTP2_GENERATED_DIR "${CMAKE_CURRENT_BINARY_DIR}/generated") set(NGHTTP2_VERSION_CONFIG "${NGHTTP2_GENERATED_DIR}/${PROJECT_NAME}ConfigVersion.cmake") set(NGHTTP2_PROJECT_CONFIG "${NGHTTP2_GENERATED_DIR}/${PROJECT_NAME}Config.cmake") set(NGHTTP2_TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets") -set(NGHTTP2_CONFIG_INSTALL_DIR "lib/cmake/${PROJECT_NAME}") +set(NGHTTP2_CONFIG_INSTALL_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}") set(NGHTTP2_NAMESPACE "${PROJECT_NAME}::") set(NGHTTP2_VERSION ${PROJECT_VERSION}) diff --git a/deps/nghttp2/lib/includes/nghttp2/nghttp2.h b/deps/nghttp2/lib/includes/nghttp2/nghttp2.h index 19c1874f23a3ca..55baba71bdaf26 100644 --- a/deps/nghttp2/lib/includes/nghttp2/nghttp2.h +++ b/deps/nghttp2/lib/includes/nghttp2/nghttp2.h @@ -3252,7 +3252,7 @@ NGHTTP2_EXTERN void nghttp2_option_set_max_continuations(nghttp2_option *option, * regenerated per second. When a suspicious activity is detected, * some amount of tokens are consumed. If there is no token * available, GOAWAY is sent to tear down the connection. |burst| and - * |rate| default to 1000 and 33 respectively. + * |rate| default to 10000 and 330 respectively. */ NGHTTP2_EXTERN void nghttp2_option_set_glitch_rate_limit(nghttp2_option *option, uint64_t burst, diff --git a/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h b/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h index 8dfe536dec9ade..83fabdeeb95d6e 100644 --- a/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h +++ b/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h @@ -29,7 +29,7 @@ * @macro * Version number of the nghttp2 library release */ -#define NGHTTP2_VERSION "1.68.0" +#define NGHTTP2_VERSION "1.69.0" /** * @macro @@ -37,6 +37,6 @@ * release. This is a 24 bit number with 8 bits for major number, 8 bits * for minor and 8 bits for patch. Version 1.2.3 becomes 0x010203. */ -#define NGHTTP2_VERSION_NUM 0x014400 +#define NGHTTP2_VERSION_NUM 0x014500 #endif /* NGHTTP2VER_H */ diff --git a/deps/nghttp2/lib/nghttp2_alpn.c b/deps/nghttp2/lib/nghttp2_alpn.c index 33c5885f8d889f..025bd346594c65 100644 --- a/deps/nghttp2/lib/nghttp2_alpn.c +++ b/deps/nghttp2/lib/nghttp2_alpn.c @@ -26,6 +26,8 @@ #include +#include "nghttp2_helper.h" + static int select_alpn(const unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, const char *key, unsigned int keylen) { @@ -41,7 +43,7 @@ static int select_alpn(const unsigned char **out, unsigned char *outlen, } #define NGHTTP2_HTTP_1_1_ALPN "\x8http/1.1" -#define NGHTTP2_HTTP_1_1_ALPN_LEN (sizeof(NGHTTP2_HTTP_1_1_ALPN) - 1) +#define NGHTTP2_HTTP_1_1_ALPN_LEN nghttp2_strlen_lit(NGHTTP2_HTTP_1_1_ALPN) int nghttp2_select_next_protocol(unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen) { diff --git a/deps/nghttp2/lib/nghttp2_frame.c b/deps/nghttp2/lib/nghttp2_frame.c index edc2aaaae9ed75..264ae9d38e0260 100644 --- a/deps/nghttp2/lib/nghttp2_frame.c +++ b/deps/nghttp2/lib/nghttp2_frame.c @@ -750,6 +750,16 @@ void nghttp2_frame_unpack_altsvc_payload(nghttp2_extension *frame, uint8_t *p; altsvc = frame->payload; + + if (payloadlen == 0) { + altsvc->origin = NULL; + altsvc->origin_len = 0; + altsvc->field_value = NULL; + altsvc->field_value_len = 0; + + return; + } + p = payload; altsvc->origin = p; diff --git a/deps/nghttp2/lib/nghttp2_frame.h b/deps/nghttp2/lib/nghttp2_frame.h index ed4ab2c6842e71..c0917c0df4cc9f 100644 --- a/deps/nghttp2/lib/nghttp2_frame.h +++ b/deps/nghttp2/lib/nghttp2_frame.h @@ -34,10 +34,7 @@ #include "nghttp2_buf.h" #define NGHTTP2_STREAM_ID_MASK ((1u << 31) - 1) -#define NGHTTP2_PRI_GROUP_ID_MASK ((1u << 31) - 1) -#define NGHTTP2_PRIORITY_MASK ((1u << 31) - 1) #define NGHTTP2_WINDOW_SIZE_INCREMENT_MASK ((1u << 31) - 1) -#define NGHTTP2_SETTINGS_ID_MASK ((1 << 24) - 1) /* The number of bytes of frame header. */ #define NGHTTP2_FRAME_HDLEN 9 diff --git a/deps/nghttp2/lib/nghttp2_hd.c b/deps/nghttp2/lib/nghttp2_hd.c index ad85eed1e13e7b..5ac77dbc0ea554 100644 --- a/deps/nghttp2/lib/nghttp2_hd.c +++ b/deps/nghttp2/lib/nghttp2_hd.c @@ -35,9 +35,10 @@ /* Make scalar initialization form of nghttp2_hd_entry */ #define MAKE_STATIC_ENT(N, V, T, H) \ { \ - {NULL, NULL, (uint8_t *)(N), sizeof((N)) - 1, -1}, \ - {NULL, NULL, (uint8_t *)(V), sizeof((V)) - 1, -1}, \ - {(uint8_t *)(N), (uint8_t *)(V), sizeof((N)) - 1, sizeof((V)) - 1, 0}, \ + {NULL, NULL, (uint8_t *)(N), nghttp2_strlen_lit((N)), -1}, \ + {NULL, NULL, (uint8_t *)(V), nghttp2_strlen_lit((V)), -1}, \ + {(uint8_t *)(N), (uint8_t *)(V), nghttp2_strlen_lit((N)), \ + nghttp2_strlen_lit((V)), 0}, \ T, \ H, \ } @@ -2058,8 +2059,9 @@ nghttp2_ssize nghttp2_hd_inflate_hd_nv(nghttp2_hd_inflater *inflater, inflater->state = NGHTTP2_HD_STATE_NEWNAME_READ_NAMEHUFF; - rv = - nghttp2_rcbuf_new(&inflater->namercbuf, inflater->left * 2 + 1, mem); + rv = nghttp2_rcbuf_new( + &inflater->namercbuf, + nghttp2_huff_estimate_decode_length(inflater->left) + 1, mem); } else { inflater->state = NGHTTP2_HD_STATE_NEWNAME_READ_NAME; rv = nghttp2_rcbuf_new(&inflater->namercbuf, inflater->left + 1, mem); @@ -2143,8 +2145,9 @@ nghttp2_ssize nghttp2_hd_inflate_hd_nv(nghttp2_hd_inflater *inflater, inflater->state = NGHTTP2_HD_STATE_READ_VALUEHUFF; - rv = - nghttp2_rcbuf_new(&inflater->valuercbuf, inflater->left * 2 + 1, mem); + rv = nghttp2_rcbuf_new( + &inflater->valuercbuf, + nghttp2_huff_estimate_decode_length(inflater->left) + 1, mem); } else { inflater->state = NGHTTP2_HD_STATE_READ_VALUE; diff --git a/deps/nghttp2/lib/nghttp2_hd_huffman.c b/deps/nghttp2/lib/nghttp2_hd_huffman.c index de2620076a6e0d..45672655f08762 100644 --- a/deps/nghttp2/lib/nghttp2_hd_huffman.c +++ b/deps/nghttp2/lib/nghttp2_hd_huffman.c @@ -104,15 +104,15 @@ int nghttp2_hd_huff_encode(nghttp2_bufs *bufs, const uint8_t *src, } void nghttp2_hd_huff_decode_context_init(nghttp2_hd_huff_decode_context *ctx) { - ctx->fstate = NGHTTP2_HUFF_ACCEPTED; + ctx->fstate = 0; + ctx->flags = NGHTTP2_HUFF_ACCEPTED; } nghttp2_ssize nghttp2_hd_huff_decode(nghttp2_hd_huff_decode_context *ctx, nghttp2_buf *buf, const uint8_t *src, size_t srclen, int final) { const uint8_t *end = src + srclen; - nghttp2_huff_decode node = {ctx->fstate, 0}; - const nghttp2_huff_decode *t = &node; + nghttp2_huff_decode t = {ctx->fstate, ctx->flags, 0}; uint8_t c; /* We use the decoding algorithm described in @@ -121,20 +121,21 @@ nghttp2_ssize nghttp2_hd_huff_decode(nghttp2_hd_huff_decode_context *ctx, - https://github.com/nghttp2/nghttp2/files/15141264/Prefix.pdf */ for (; src != end;) { c = *src++; - t = &huff_decode_table[t->fstate & 0x1ff][c >> 4]; - if (t->fstate & NGHTTP2_HUFF_SYM) { - *buf->last++ = t->sym; + t = huff_decode_table[t.fstate][c >> 4]; + if (t.flags & NGHTTP2_HUFF_SYM) { + *buf->last++ = t.sym; } - t = &huff_decode_table[t->fstate & 0x1ff][c & 0xf]; - if (t->fstate & NGHTTP2_HUFF_SYM) { - *buf->last++ = t->sym; + t = huff_decode_table[t.fstate][c & 0xf]; + if (t.flags & NGHTTP2_HUFF_SYM) { + *buf->last++ = t.sym; } } - ctx->fstate = t->fstate; + ctx->fstate = t.fstate; + ctx->flags = t.flags; - if (final && !(ctx->fstate & NGHTTP2_HUFF_ACCEPTED)) { + if (final && !(ctx->flags & NGHTTP2_HUFF_ACCEPTED)) { return NGHTTP2_ERR_HEADER_COMP; } diff --git a/deps/nghttp2/lib/nghttp2_hd_huffman.h b/deps/nghttp2/lib/nghttp2_hd_huffman.h index df037a8b20efc3..f898c1779c01c6 100644 --- a/deps/nghttp2/lib/nghttp2_hd_huffman.h +++ b/deps/nghttp2/lib/nghttp2_hd_huffman.h @@ -34,9 +34,9 @@ typedef enum { /* FSA accepts this state as the end of huffman encoding sequence. */ - NGHTTP2_HUFF_ACCEPTED = 1 << 14, + NGHTTP2_HUFF_ACCEPTED = 1, /* This state emits symbol */ - NGHTTP2_HUFF_SYM = 1 << 15, + NGHTTP2_HUFF_SYM = 1 << 1, } nghttp2_huff_decode_flag; typedef struct { @@ -48,6 +48,7 @@ typedef struct { a special node and it is a terminal state that means decoding failed. */ uint16_t fstate; + uint8_t flags; /* symbol if NGHTTP2_HUFF_SYM flag set */ uint8_t sym; } nghttp2_huff_decode; @@ -57,6 +58,7 @@ typedef nghttp2_huff_decode huff_decode_table_type[16]; typedef struct { /* fstate is the current huffman decoding state. */ uint16_t fstate; + uint8_t flags; } nghttp2_hd_huff_decode_context; typedef struct { @@ -69,4 +71,12 @@ typedef struct { extern const nghttp2_huff_sym huff_sym_table[]; extern const nghttp2_huff_decode huff_decode_table[][16]; +/* + * nghttp2_huff_estimate_decode_length returns the estimated decoded + * length of the huffman encoded string of length |len|. + */ +static inline size_t nghttp2_huff_estimate_decode_length(size_t len) { + return len * 8 / 5; +} + #endif /* !defined(NGHTTP2_HD_HUFFMAN_H) */ diff --git a/deps/nghttp2/lib/nghttp2_hd_huffman_data.c b/deps/nghttp2/lib/nghttp2_hd_huffman_data.c index c8f4a6fa266708..252cae0c18d971 100644 --- a/deps/nghttp2/lib/nghttp2_hd_huffman_data.c +++ b/deps/nghttp2/lib/nghttp2_hd_huffman_data.c @@ -96,4885 +96,4885 @@ const nghttp2_huff_sym huff_sym_table[] = { const nghttp2_huff_decode huff_decode_table[][16] = { /* 0 */ { - {0x04, 0}, - {0x05, 0}, - {0x07, 0}, - {0x08, 0}, - {0x0b, 0}, - {0x0c, 0}, - {0x10, 0}, - {0x13, 0}, - {0x19, 0}, - {0x1c, 0}, - {0x20, 0}, - {0x23, 0}, - {0x2a, 0}, - {0x31, 0}, - {0x39, 0}, - {0x4040, 0}, + {0x04, 0, 0}, + {0x05, 0, 0}, + {0x07, 0, 0}, + {0x08, 0, 0}, + {0x0b, 0, 0}, + {0x0c, 0, 0}, + {0x10, 0, 0}, + {0x13, 0, 0}, + {0x19, 0, 0}, + {0x1c, 0, 0}, + {0x20, 0, 0}, + {0x23, 0, 0}, + {0x2a, 0, 0}, + {0x31, 0, 0}, + {0x39, 0, 0}, + {0x40, 1, 0}, }, /* 1 */ { - {0xc000, 48}, - {0xc000, 49}, - {0xc000, 50}, - {0xc000, 97}, - {0xc000, 99}, - {0xc000, 101}, - {0xc000, 105}, - {0xc000, 111}, - {0xc000, 115}, - {0xc000, 116}, - {0x0d, 0}, - {0x0e, 0}, - {0x11, 0}, - {0x12, 0}, - {0x14, 0}, - {0x15, 0}, + {0x00, 3, 48}, + {0x00, 3, 49}, + {0x00, 3, 50}, + {0x00, 3, 97}, + {0x00, 3, 99}, + {0x00, 3, 101}, + {0x00, 3, 105}, + {0x00, 3, 111}, + {0x00, 3, 115}, + {0x00, 3, 116}, + {0x0d, 0, 0}, + {0x0e, 0, 0}, + {0x11, 0, 0}, + {0x12, 0, 0}, + {0x14, 0, 0}, + {0x15, 0, 0}, }, /* 2 */ { - {0x8001, 48}, - {0xc016, 48}, - {0x8001, 49}, - {0xc016, 49}, - {0x8001, 50}, - {0xc016, 50}, - {0x8001, 97}, - {0xc016, 97}, - {0x8001, 99}, - {0xc016, 99}, - {0x8001, 101}, - {0xc016, 101}, - {0x8001, 105}, - {0xc016, 105}, - {0x8001, 111}, - {0xc016, 111}, + {0x01, 2, 48}, + {0x16, 3, 48}, + {0x01, 2, 49}, + {0x16, 3, 49}, + {0x01, 2, 50}, + {0x16, 3, 50}, + {0x01, 2, 97}, + {0x16, 3, 97}, + {0x01, 2, 99}, + {0x16, 3, 99}, + {0x01, 2, 101}, + {0x16, 3, 101}, + {0x01, 2, 105}, + {0x16, 3, 105}, + {0x01, 2, 111}, + {0x16, 3, 111}, }, /* 3 */ { - {0x8002, 48}, - {0x8009, 48}, - {0x8017, 48}, - {0xc028, 48}, - {0x8002, 49}, - {0x8009, 49}, - {0x8017, 49}, - {0xc028, 49}, - {0x8002, 50}, - {0x8009, 50}, - {0x8017, 50}, - {0xc028, 50}, - {0x8002, 97}, - {0x8009, 97}, - {0x8017, 97}, - {0xc028, 97}, + {0x02, 2, 48}, + {0x09, 2, 48}, + {0x17, 2, 48}, + {0x28, 3, 48}, + {0x02, 2, 49}, + {0x09, 2, 49}, + {0x17, 2, 49}, + {0x28, 3, 49}, + {0x02, 2, 50}, + {0x09, 2, 50}, + {0x17, 2, 50}, + {0x28, 3, 50}, + {0x02, 2, 97}, + {0x09, 2, 97}, + {0x17, 2, 97}, + {0x28, 3, 97}, }, /* 4 */ { - {0x8003, 48}, - {0x8006, 48}, - {0x800a, 48}, - {0x800f, 48}, - {0x8018, 48}, - {0x801f, 48}, - {0x8029, 48}, - {0xc038, 48}, - {0x8003, 49}, - {0x8006, 49}, - {0x800a, 49}, - {0x800f, 49}, - {0x8018, 49}, - {0x801f, 49}, - {0x8029, 49}, - {0xc038, 49}, + {0x03, 2, 48}, + {0x06, 2, 48}, + {0x0a, 2, 48}, + {0x0f, 2, 48}, + {0x18, 2, 48}, + {0x1f, 2, 48}, + {0x29, 2, 48}, + {0x38, 3, 48}, + {0x03, 2, 49}, + {0x06, 2, 49}, + {0x0a, 2, 49}, + {0x0f, 2, 49}, + {0x18, 2, 49}, + {0x1f, 2, 49}, + {0x29, 2, 49}, + {0x38, 3, 49}, }, /* 5 */ { - {0x8003, 50}, - {0x8006, 50}, - {0x800a, 50}, - {0x800f, 50}, - {0x8018, 50}, - {0x801f, 50}, - {0x8029, 50}, - {0xc038, 50}, - {0x8003, 97}, - {0x8006, 97}, - {0x800a, 97}, - {0x800f, 97}, - {0x8018, 97}, - {0x801f, 97}, - {0x8029, 97}, - {0xc038, 97}, + {0x03, 2, 50}, + {0x06, 2, 50}, + {0x0a, 2, 50}, + {0x0f, 2, 50}, + {0x18, 2, 50}, + {0x1f, 2, 50}, + {0x29, 2, 50}, + {0x38, 3, 50}, + {0x03, 2, 97}, + {0x06, 2, 97}, + {0x0a, 2, 97}, + {0x0f, 2, 97}, + {0x18, 2, 97}, + {0x1f, 2, 97}, + {0x29, 2, 97}, + {0x38, 3, 97}, }, /* 6 */ { - {0x8002, 99}, - {0x8009, 99}, - {0x8017, 99}, - {0xc028, 99}, - {0x8002, 101}, - {0x8009, 101}, - {0x8017, 101}, - {0xc028, 101}, - {0x8002, 105}, - {0x8009, 105}, - {0x8017, 105}, - {0xc028, 105}, - {0x8002, 111}, - {0x8009, 111}, - {0x8017, 111}, - {0xc028, 111}, + {0x02, 2, 99}, + {0x09, 2, 99}, + {0x17, 2, 99}, + {0x28, 3, 99}, + {0x02, 2, 101}, + {0x09, 2, 101}, + {0x17, 2, 101}, + {0x28, 3, 101}, + {0x02, 2, 105}, + {0x09, 2, 105}, + {0x17, 2, 105}, + {0x28, 3, 105}, + {0x02, 2, 111}, + {0x09, 2, 111}, + {0x17, 2, 111}, + {0x28, 3, 111}, }, /* 7 */ { - {0x8003, 99}, - {0x8006, 99}, - {0x800a, 99}, - {0x800f, 99}, - {0x8018, 99}, - {0x801f, 99}, - {0x8029, 99}, - {0xc038, 99}, - {0x8003, 101}, - {0x8006, 101}, - {0x800a, 101}, - {0x800f, 101}, - {0x8018, 101}, - {0x801f, 101}, - {0x8029, 101}, - {0xc038, 101}, + {0x03, 2, 99}, + {0x06, 2, 99}, + {0x0a, 2, 99}, + {0x0f, 2, 99}, + {0x18, 2, 99}, + {0x1f, 2, 99}, + {0x29, 2, 99}, + {0x38, 3, 99}, + {0x03, 2, 101}, + {0x06, 2, 101}, + {0x0a, 2, 101}, + {0x0f, 2, 101}, + {0x18, 2, 101}, + {0x1f, 2, 101}, + {0x29, 2, 101}, + {0x38, 3, 101}, }, /* 8 */ { - {0x8003, 105}, - {0x8006, 105}, - {0x800a, 105}, - {0x800f, 105}, - {0x8018, 105}, - {0x801f, 105}, - {0x8029, 105}, - {0xc038, 105}, - {0x8003, 111}, - {0x8006, 111}, - {0x800a, 111}, - {0x800f, 111}, - {0x8018, 111}, - {0x801f, 111}, - {0x8029, 111}, - {0xc038, 111}, + {0x03, 2, 105}, + {0x06, 2, 105}, + {0x0a, 2, 105}, + {0x0f, 2, 105}, + {0x18, 2, 105}, + {0x1f, 2, 105}, + {0x29, 2, 105}, + {0x38, 3, 105}, + {0x03, 2, 111}, + {0x06, 2, 111}, + {0x0a, 2, 111}, + {0x0f, 2, 111}, + {0x18, 2, 111}, + {0x1f, 2, 111}, + {0x29, 2, 111}, + {0x38, 3, 111}, }, /* 9 */ { - {0x8001, 115}, - {0xc016, 115}, - {0x8001, 116}, - {0xc016, 116}, - {0xc000, 32}, - {0xc000, 37}, - {0xc000, 45}, - {0xc000, 46}, - {0xc000, 47}, - {0xc000, 51}, - {0xc000, 52}, - {0xc000, 53}, - {0xc000, 54}, - {0xc000, 55}, - {0xc000, 56}, - {0xc000, 57}, + {0x01, 2, 115}, + {0x16, 3, 115}, + {0x01, 2, 116}, + {0x16, 3, 116}, + {0x00, 3, 32}, + {0x00, 3, 37}, + {0x00, 3, 45}, + {0x00, 3, 46}, + {0x00, 3, 47}, + {0x00, 3, 51}, + {0x00, 3, 52}, + {0x00, 3, 53}, + {0x00, 3, 54}, + {0x00, 3, 55}, + {0x00, 3, 56}, + {0x00, 3, 57}, }, /* 10 */ { - {0x8002, 115}, - {0x8009, 115}, - {0x8017, 115}, - {0xc028, 115}, - {0x8002, 116}, - {0x8009, 116}, - {0x8017, 116}, - {0xc028, 116}, - {0x8001, 32}, - {0xc016, 32}, - {0x8001, 37}, - {0xc016, 37}, - {0x8001, 45}, - {0xc016, 45}, - {0x8001, 46}, - {0xc016, 46}, + {0x02, 2, 115}, + {0x09, 2, 115}, + {0x17, 2, 115}, + {0x28, 3, 115}, + {0x02, 2, 116}, + {0x09, 2, 116}, + {0x17, 2, 116}, + {0x28, 3, 116}, + {0x01, 2, 32}, + {0x16, 3, 32}, + {0x01, 2, 37}, + {0x16, 3, 37}, + {0x01, 2, 45}, + {0x16, 3, 45}, + {0x01, 2, 46}, + {0x16, 3, 46}, }, /* 11 */ { - {0x8003, 115}, - {0x8006, 115}, - {0x800a, 115}, - {0x800f, 115}, - {0x8018, 115}, - {0x801f, 115}, - {0x8029, 115}, - {0xc038, 115}, - {0x8003, 116}, - {0x8006, 116}, - {0x800a, 116}, - {0x800f, 116}, - {0x8018, 116}, - {0x801f, 116}, - {0x8029, 116}, - {0xc038, 116}, + {0x03, 2, 115}, + {0x06, 2, 115}, + {0x0a, 2, 115}, + {0x0f, 2, 115}, + {0x18, 2, 115}, + {0x1f, 2, 115}, + {0x29, 2, 115}, + {0x38, 3, 115}, + {0x03, 2, 116}, + {0x06, 2, 116}, + {0x0a, 2, 116}, + {0x0f, 2, 116}, + {0x18, 2, 116}, + {0x1f, 2, 116}, + {0x29, 2, 116}, + {0x38, 3, 116}, }, /* 12 */ { - {0x8002, 32}, - {0x8009, 32}, - {0x8017, 32}, - {0xc028, 32}, - {0x8002, 37}, - {0x8009, 37}, - {0x8017, 37}, - {0xc028, 37}, - {0x8002, 45}, - {0x8009, 45}, - {0x8017, 45}, - {0xc028, 45}, - {0x8002, 46}, - {0x8009, 46}, - {0x8017, 46}, - {0xc028, 46}, + {0x02, 2, 32}, + {0x09, 2, 32}, + {0x17, 2, 32}, + {0x28, 3, 32}, + {0x02, 2, 37}, + {0x09, 2, 37}, + {0x17, 2, 37}, + {0x28, 3, 37}, + {0x02, 2, 45}, + {0x09, 2, 45}, + {0x17, 2, 45}, + {0x28, 3, 45}, + {0x02, 2, 46}, + {0x09, 2, 46}, + {0x17, 2, 46}, + {0x28, 3, 46}, }, /* 13 */ { - {0x8003, 32}, - {0x8006, 32}, - {0x800a, 32}, - {0x800f, 32}, - {0x8018, 32}, - {0x801f, 32}, - {0x8029, 32}, - {0xc038, 32}, - {0x8003, 37}, - {0x8006, 37}, - {0x800a, 37}, - {0x800f, 37}, - {0x8018, 37}, - {0x801f, 37}, - {0x8029, 37}, - {0xc038, 37}, + {0x03, 2, 32}, + {0x06, 2, 32}, + {0x0a, 2, 32}, + {0x0f, 2, 32}, + {0x18, 2, 32}, + {0x1f, 2, 32}, + {0x29, 2, 32}, + {0x38, 3, 32}, + {0x03, 2, 37}, + {0x06, 2, 37}, + {0x0a, 2, 37}, + {0x0f, 2, 37}, + {0x18, 2, 37}, + {0x1f, 2, 37}, + {0x29, 2, 37}, + {0x38, 3, 37}, }, /* 14 */ { - {0x8003, 45}, - {0x8006, 45}, - {0x800a, 45}, - {0x800f, 45}, - {0x8018, 45}, - {0x801f, 45}, - {0x8029, 45}, - {0xc038, 45}, - {0x8003, 46}, - {0x8006, 46}, - {0x800a, 46}, - {0x800f, 46}, - {0x8018, 46}, - {0x801f, 46}, - {0x8029, 46}, - {0xc038, 46}, + {0x03, 2, 45}, + {0x06, 2, 45}, + {0x0a, 2, 45}, + {0x0f, 2, 45}, + {0x18, 2, 45}, + {0x1f, 2, 45}, + {0x29, 2, 45}, + {0x38, 3, 45}, + {0x03, 2, 46}, + {0x06, 2, 46}, + {0x0a, 2, 46}, + {0x0f, 2, 46}, + {0x18, 2, 46}, + {0x1f, 2, 46}, + {0x29, 2, 46}, + {0x38, 3, 46}, }, /* 15 */ { - {0x8001, 47}, - {0xc016, 47}, - {0x8001, 51}, - {0xc016, 51}, - {0x8001, 52}, - {0xc016, 52}, - {0x8001, 53}, - {0xc016, 53}, - {0x8001, 54}, - {0xc016, 54}, - {0x8001, 55}, - {0xc016, 55}, - {0x8001, 56}, - {0xc016, 56}, - {0x8001, 57}, - {0xc016, 57}, + {0x01, 2, 47}, + {0x16, 3, 47}, + {0x01, 2, 51}, + {0x16, 3, 51}, + {0x01, 2, 52}, + {0x16, 3, 52}, + {0x01, 2, 53}, + {0x16, 3, 53}, + {0x01, 2, 54}, + {0x16, 3, 54}, + {0x01, 2, 55}, + {0x16, 3, 55}, + {0x01, 2, 56}, + {0x16, 3, 56}, + {0x01, 2, 57}, + {0x16, 3, 57}, }, /* 16 */ { - {0x8002, 47}, - {0x8009, 47}, - {0x8017, 47}, - {0xc028, 47}, - {0x8002, 51}, - {0x8009, 51}, - {0x8017, 51}, - {0xc028, 51}, - {0x8002, 52}, - {0x8009, 52}, - {0x8017, 52}, - {0xc028, 52}, - {0x8002, 53}, - {0x8009, 53}, - {0x8017, 53}, - {0xc028, 53}, + {0x02, 2, 47}, + {0x09, 2, 47}, + {0x17, 2, 47}, + {0x28, 3, 47}, + {0x02, 2, 51}, + {0x09, 2, 51}, + {0x17, 2, 51}, + {0x28, 3, 51}, + {0x02, 2, 52}, + {0x09, 2, 52}, + {0x17, 2, 52}, + {0x28, 3, 52}, + {0x02, 2, 53}, + {0x09, 2, 53}, + {0x17, 2, 53}, + {0x28, 3, 53}, }, /* 17 */ { - {0x8003, 47}, - {0x8006, 47}, - {0x800a, 47}, - {0x800f, 47}, - {0x8018, 47}, - {0x801f, 47}, - {0x8029, 47}, - {0xc038, 47}, - {0x8003, 51}, - {0x8006, 51}, - {0x800a, 51}, - {0x800f, 51}, - {0x8018, 51}, - {0x801f, 51}, - {0x8029, 51}, - {0xc038, 51}, + {0x03, 2, 47}, + {0x06, 2, 47}, + {0x0a, 2, 47}, + {0x0f, 2, 47}, + {0x18, 2, 47}, + {0x1f, 2, 47}, + {0x29, 2, 47}, + {0x38, 3, 47}, + {0x03, 2, 51}, + {0x06, 2, 51}, + {0x0a, 2, 51}, + {0x0f, 2, 51}, + {0x18, 2, 51}, + {0x1f, 2, 51}, + {0x29, 2, 51}, + {0x38, 3, 51}, }, /* 18 */ { - {0x8003, 52}, - {0x8006, 52}, - {0x800a, 52}, - {0x800f, 52}, - {0x8018, 52}, - {0x801f, 52}, - {0x8029, 52}, - {0xc038, 52}, - {0x8003, 53}, - {0x8006, 53}, - {0x800a, 53}, - {0x800f, 53}, - {0x8018, 53}, - {0x801f, 53}, - {0x8029, 53}, - {0xc038, 53}, + {0x03, 2, 52}, + {0x06, 2, 52}, + {0x0a, 2, 52}, + {0x0f, 2, 52}, + {0x18, 2, 52}, + {0x1f, 2, 52}, + {0x29, 2, 52}, + {0x38, 3, 52}, + {0x03, 2, 53}, + {0x06, 2, 53}, + {0x0a, 2, 53}, + {0x0f, 2, 53}, + {0x18, 2, 53}, + {0x1f, 2, 53}, + {0x29, 2, 53}, + {0x38, 3, 53}, }, /* 19 */ { - {0x8002, 54}, - {0x8009, 54}, - {0x8017, 54}, - {0xc028, 54}, - {0x8002, 55}, - {0x8009, 55}, - {0x8017, 55}, - {0xc028, 55}, - {0x8002, 56}, - {0x8009, 56}, - {0x8017, 56}, - {0xc028, 56}, - {0x8002, 57}, - {0x8009, 57}, - {0x8017, 57}, - {0xc028, 57}, + {0x02, 2, 54}, + {0x09, 2, 54}, + {0x17, 2, 54}, + {0x28, 3, 54}, + {0x02, 2, 55}, + {0x09, 2, 55}, + {0x17, 2, 55}, + {0x28, 3, 55}, + {0x02, 2, 56}, + {0x09, 2, 56}, + {0x17, 2, 56}, + {0x28, 3, 56}, + {0x02, 2, 57}, + {0x09, 2, 57}, + {0x17, 2, 57}, + {0x28, 3, 57}, }, /* 20 */ { - {0x8003, 54}, - {0x8006, 54}, - {0x800a, 54}, - {0x800f, 54}, - {0x8018, 54}, - {0x801f, 54}, - {0x8029, 54}, - {0xc038, 54}, - {0x8003, 55}, - {0x8006, 55}, - {0x800a, 55}, - {0x800f, 55}, - {0x8018, 55}, - {0x801f, 55}, - {0x8029, 55}, - {0xc038, 55}, + {0x03, 2, 54}, + {0x06, 2, 54}, + {0x0a, 2, 54}, + {0x0f, 2, 54}, + {0x18, 2, 54}, + {0x1f, 2, 54}, + {0x29, 2, 54}, + {0x38, 3, 54}, + {0x03, 2, 55}, + {0x06, 2, 55}, + {0x0a, 2, 55}, + {0x0f, 2, 55}, + {0x18, 2, 55}, + {0x1f, 2, 55}, + {0x29, 2, 55}, + {0x38, 3, 55}, }, /* 21 */ { - {0x8003, 56}, - {0x8006, 56}, - {0x800a, 56}, - {0x800f, 56}, - {0x8018, 56}, - {0x801f, 56}, - {0x8029, 56}, - {0xc038, 56}, - {0x8003, 57}, - {0x8006, 57}, - {0x800a, 57}, - {0x800f, 57}, - {0x8018, 57}, - {0x801f, 57}, - {0x8029, 57}, - {0xc038, 57}, + {0x03, 2, 56}, + {0x06, 2, 56}, + {0x0a, 2, 56}, + {0x0f, 2, 56}, + {0x18, 2, 56}, + {0x1f, 2, 56}, + {0x29, 2, 56}, + {0x38, 3, 56}, + {0x03, 2, 57}, + {0x06, 2, 57}, + {0x0a, 2, 57}, + {0x0f, 2, 57}, + {0x18, 2, 57}, + {0x1f, 2, 57}, + {0x29, 2, 57}, + {0x38, 3, 57}, }, /* 22 */ { - {0x1a, 0}, - {0x1b, 0}, - {0x1d, 0}, - {0x1e, 0}, - {0x21, 0}, - {0x22, 0}, - {0x24, 0}, - {0x25, 0}, - {0x2b, 0}, - {0x2e, 0}, - {0x32, 0}, - {0x35, 0}, - {0x3a, 0}, - {0x3d, 0}, - {0x41, 0}, - {0x4044, 0}, + {0x1a, 0, 0}, + {0x1b, 0, 0}, + {0x1d, 0, 0}, + {0x1e, 0, 0}, + {0x21, 0, 0}, + {0x22, 0, 0}, + {0x24, 0, 0}, + {0x25, 0, 0}, + {0x2b, 0, 0}, + {0x2e, 0, 0}, + {0x32, 0, 0}, + {0x35, 0, 0}, + {0x3a, 0, 0}, + {0x3d, 0, 0}, + {0x41, 0, 0}, + {0x44, 1, 0}, }, /* 23 */ { - {0xc000, 61}, - {0xc000, 65}, - {0xc000, 95}, - {0xc000, 98}, - {0xc000, 100}, - {0xc000, 102}, - {0xc000, 103}, - {0xc000, 104}, - {0xc000, 108}, - {0xc000, 109}, - {0xc000, 110}, - {0xc000, 112}, - {0xc000, 114}, - {0xc000, 117}, - {0x26, 0}, - {0x27, 0}, + {0x00, 3, 61}, + {0x00, 3, 65}, + {0x00, 3, 95}, + {0x00, 3, 98}, + {0x00, 3, 100}, + {0x00, 3, 102}, + {0x00, 3, 103}, + {0x00, 3, 104}, + {0x00, 3, 108}, + {0x00, 3, 109}, + {0x00, 3, 110}, + {0x00, 3, 112}, + {0x00, 3, 114}, + {0x00, 3, 117}, + {0x26, 0, 0}, + {0x27, 0, 0}, }, /* 24 */ { - {0x8001, 61}, - {0xc016, 61}, - {0x8001, 65}, - {0xc016, 65}, - {0x8001, 95}, - {0xc016, 95}, - {0x8001, 98}, - {0xc016, 98}, - {0x8001, 100}, - {0xc016, 100}, - {0x8001, 102}, - {0xc016, 102}, - {0x8001, 103}, - {0xc016, 103}, - {0x8001, 104}, - {0xc016, 104}, + {0x01, 2, 61}, + {0x16, 3, 61}, + {0x01, 2, 65}, + {0x16, 3, 65}, + {0x01, 2, 95}, + {0x16, 3, 95}, + {0x01, 2, 98}, + {0x16, 3, 98}, + {0x01, 2, 100}, + {0x16, 3, 100}, + {0x01, 2, 102}, + {0x16, 3, 102}, + {0x01, 2, 103}, + {0x16, 3, 103}, + {0x01, 2, 104}, + {0x16, 3, 104}, }, /* 25 */ { - {0x8002, 61}, - {0x8009, 61}, - {0x8017, 61}, - {0xc028, 61}, - {0x8002, 65}, - {0x8009, 65}, - {0x8017, 65}, - {0xc028, 65}, - {0x8002, 95}, - {0x8009, 95}, - {0x8017, 95}, - {0xc028, 95}, - {0x8002, 98}, - {0x8009, 98}, - {0x8017, 98}, - {0xc028, 98}, + {0x02, 2, 61}, + {0x09, 2, 61}, + {0x17, 2, 61}, + {0x28, 3, 61}, + {0x02, 2, 65}, + {0x09, 2, 65}, + {0x17, 2, 65}, + {0x28, 3, 65}, + {0x02, 2, 95}, + {0x09, 2, 95}, + {0x17, 2, 95}, + {0x28, 3, 95}, + {0x02, 2, 98}, + {0x09, 2, 98}, + {0x17, 2, 98}, + {0x28, 3, 98}, }, /* 26 */ { - {0x8003, 61}, - {0x8006, 61}, - {0x800a, 61}, - {0x800f, 61}, - {0x8018, 61}, - {0x801f, 61}, - {0x8029, 61}, - {0xc038, 61}, - {0x8003, 65}, - {0x8006, 65}, - {0x800a, 65}, - {0x800f, 65}, - {0x8018, 65}, - {0x801f, 65}, - {0x8029, 65}, - {0xc038, 65}, + {0x03, 2, 61}, + {0x06, 2, 61}, + {0x0a, 2, 61}, + {0x0f, 2, 61}, + {0x18, 2, 61}, + {0x1f, 2, 61}, + {0x29, 2, 61}, + {0x38, 3, 61}, + {0x03, 2, 65}, + {0x06, 2, 65}, + {0x0a, 2, 65}, + {0x0f, 2, 65}, + {0x18, 2, 65}, + {0x1f, 2, 65}, + {0x29, 2, 65}, + {0x38, 3, 65}, }, /* 27 */ { - {0x8003, 95}, - {0x8006, 95}, - {0x800a, 95}, - {0x800f, 95}, - {0x8018, 95}, - {0x801f, 95}, - {0x8029, 95}, - {0xc038, 95}, - {0x8003, 98}, - {0x8006, 98}, - {0x800a, 98}, - {0x800f, 98}, - {0x8018, 98}, - {0x801f, 98}, - {0x8029, 98}, - {0xc038, 98}, + {0x03, 2, 95}, + {0x06, 2, 95}, + {0x0a, 2, 95}, + {0x0f, 2, 95}, + {0x18, 2, 95}, + {0x1f, 2, 95}, + {0x29, 2, 95}, + {0x38, 3, 95}, + {0x03, 2, 98}, + {0x06, 2, 98}, + {0x0a, 2, 98}, + {0x0f, 2, 98}, + {0x18, 2, 98}, + {0x1f, 2, 98}, + {0x29, 2, 98}, + {0x38, 3, 98}, }, /* 28 */ { - {0x8002, 100}, - {0x8009, 100}, - {0x8017, 100}, - {0xc028, 100}, - {0x8002, 102}, - {0x8009, 102}, - {0x8017, 102}, - {0xc028, 102}, - {0x8002, 103}, - {0x8009, 103}, - {0x8017, 103}, - {0xc028, 103}, - {0x8002, 104}, - {0x8009, 104}, - {0x8017, 104}, - {0xc028, 104}, + {0x02, 2, 100}, + {0x09, 2, 100}, + {0x17, 2, 100}, + {0x28, 3, 100}, + {0x02, 2, 102}, + {0x09, 2, 102}, + {0x17, 2, 102}, + {0x28, 3, 102}, + {0x02, 2, 103}, + {0x09, 2, 103}, + {0x17, 2, 103}, + {0x28, 3, 103}, + {0x02, 2, 104}, + {0x09, 2, 104}, + {0x17, 2, 104}, + {0x28, 3, 104}, }, /* 29 */ { - {0x8003, 100}, - {0x8006, 100}, - {0x800a, 100}, - {0x800f, 100}, - {0x8018, 100}, - {0x801f, 100}, - {0x8029, 100}, - {0xc038, 100}, - {0x8003, 102}, - {0x8006, 102}, - {0x800a, 102}, - {0x800f, 102}, - {0x8018, 102}, - {0x801f, 102}, - {0x8029, 102}, - {0xc038, 102}, + {0x03, 2, 100}, + {0x06, 2, 100}, + {0x0a, 2, 100}, + {0x0f, 2, 100}, + {0x18, 2, 100}, + {0x1f, 2, 100}, + {0x29, 2, 100}, + {0x38, 3, 100}, + {0x03, 2, 102}, + {0x06, 2, 102}, + {0x0a, 2, 102}, + {0x0f, 2, 102}, + {0x18, 2, 102}, + {0x1f, 2, 102}, + {0x29, 2, 102}, + {0x38, 3, 102}, }, /* 30 */ { - {0x8003, 103}, - {0x8006, 103}, - {0x800a, 103}, - {0x800f, 103}, - {0x8018, 103}, - {0x801f, 103}, - {0x8029, 103}, - {0xc038, 103}, - {0x8003, 104}, - {0x8006, 104}, - {0x800a, 104}, - {0x800f, 104}, - {0x8018, 104}, - {0x801f, 104}, - {0x8029, 104}, - {0xc038, 104}, + {0x03, 2, 103}, + {0x06, 2, 103}, + {0x0a, 2, 103}, + {0x0f, 2, 103}, + {0x18, 2, 103}, + {0x1f, 2, 103}, + {0x29, 2, 103}, + {0x38, 3, 103}, + {0x03, 2, 104}, + {0x06, 2, 104}, + {0x0a, 2, 104}, + {0x0f, 2, 104}, + {0x18, 2, 104}, + {0x1f, 2, 104}, + {0x29, 2, 104}, + {0x38, 3, 104}, }, /* 31 */ { - {0x8001, 108}, - {0xc016, 108}, - {0x8001, 109}, - {0xc016, 109}, - {0x8001, 110}, - {0xc016, 110}, - {0x8001, 112}, - {0xc016, 112}, - {0x8001, 114}, - {0xc016, 114}, - {0x8001, 117}, - {0xc016, 117}, - {0xc000, 58}, - {0xc000, 66}, - {0xc000, 67}, - {0xc000, 68}, + {0x01, 2, 108}, + {0x16, 3, 108}, + {0x01, 2, 109}, + {0x16, 3, 109}, + {0x01, 2, 110}, + {0x16, 3, 110}, + {0x01, 2, 112}, + {0x16, 3, 112}, + {0x01, 2, 114}, + {0x16, 3, 114}, + {0x01, 2, 117}, + {0x16, 3, 117}, + {0x00, 3, 58}, + {0x00, 3, 66}, + {0x00, 3, 67}, + {0x00, 3, 68}, }, /* 32 */ { - {0x8002, 108}, - {0x8009, 108}, - {0x8017, 108}, - {0xc028, 108}, - {0x8002, 109}, - {0x8009, 109}, - {0x8017, 109}, - {0xc028, 109}, - {0x8002, 110}, - {0x8009, 110}, - {0x8017, 110}, - {0xc028, 110}, - {0x8002, 112}, - {0x8009, 112}, - {0x8017, 112}, - {0xc028, 112}, + {0x02, 2, 108}, + {0x09, 2, 108}, + {0x17, 2, 108}, + {0x28, 3, 108}, + {0x02, 2, 109}, + {0x09, 2, 109}, + {0x17, 2, 109}, + {0x28, 3, 109}, + {0x02, 2, 110}, + {0x09, 2, 110}, + {0x17, 2, 110}, + {0x28, 3, 110}, + {0x02, 2, 112}, + {0x09, 2, 112}, + {0x17, 2, 112}, + {0x28, 3, 112}, }, /* 33 */ { - {0x8003, 108}, - {0x8006, 108}, - {0x800a, 108}, - {0x800f, 108}, - {0x8018, 108}, - {0x801f, 108}, - {0x8029, 108}, - {0xc038, 108}, - {0x8003, 109}, - {0x8006, 109}, - {0x800a, 109}, - {0x800f, 109}, - {0x8018, 109}, - {0x801f, 109}, - {0x8029, 109}, - {0xc038, 109}, + {0x03, 2, 108}, + {0x06, 2, 108}, + {0x0a, 2, 108}, + {0x0f, 2, 108}, + {0x18, 2, 108}, + {0x1f, 2, 108}, + {0x29, 2, 108}, + {0x38, 3, 108}, + {0x03, 2, 109}, + {0x06, 2, 109}, + {0x0a, 2, 109}, + {0x0f, 2, 109}, + {0x18, 2, 109}, + {0x1f, 2, 109}, + {0x29, 2, 109}, + {0x38, 3, 109}, }, /* 34 */ { - {0x8003, 110}, - {0x8006, 110}, - {0x800a, 110}, - {0x800f, 110}, - {0x8018, 110}, - {0x801f, 110}, - {0x8029, 110}, - {0xc038, 110}, - {0x8003, 112}, - {0x8006, 112}, - {0x800a, 112}, - {0x800f, 112}, - {0x8018, 112}, - {0x801f, 112}, - {0x8029, 112}, - {0xc038, 112}, + {0x03, 2, 110}, + {0x06, 2, 110}, + {0x0a, 2, 110}, + {0x0f, 2, 110}, + {0x18, 2, 110}, + {0x1f, 2, 110}, + {0x29, 2, 110}, + {0x38, 3, 110}, + {0x03, 2, 112}, + {0x06, 2, 112}, + {0x0a, 2, 112}, + {0x0f, 2, 112}, + {0x18, 2, 112}, + {0x1f, 2, 112}, + {0x29, 2, 112}, + {0x38, 3, 112}, }, /* 35 */ { - {0x8002, 114}, - {0x8009, 114}, - {0x8017, 114}, - {0xc028, 114}, - {0x8002, 117}, - {0x8009, 117}, - {0x8017, 117}, - {0xc028, 117}, - {0x8001, 58}, - {0xc016, 58}, - {0x8001, 66}, - {0xc016, 66}, - {0x8001, 67}, - {0xc016, 67}, - {0x8001, 68}, - {0xc016, 68}, + {0x02, 2, 114}, + {0x09, 2, 114}, + {0x17, 2, 114}, + {0x28, 3, 114}, + {0x02, 2, 117}, + {0x09, 2, 117}, + {0x17, 2, 117}, + {0x28, 3, 117}, + {0x01, 2, 58}, + {0x16, 3, 58}, + {0x01, 2, 66}, + {0x16, 3, 66}, + {0x01, 2, 67}, + {0x16, 3, 67}, + {0x01, 2, 68}, + {0x16, 3, 68}, }, /* 36 */ { - {0x8003, 114}, - {0x8006, 114}, - {0x800a, 114}, - {0x800f, 114}, - {0x8018, 114}, - {0x801f, 114}, - {0x8029, 114}, - {0xc038, 114}, - {0x8003, 117}, - {0x8006, 117}, - {0x800a, 117}, - {0x800f, 117}, - {0x8018, 117}, - {0x801f, 117}, - {0x8029, 117}, - {0xc038, 117}, + {0x03, 2, 114}, + {0x06, 2, 114}, + {0x0a, 2, 114}, + {0x0f, 2, 114}, + {0x18, 2, 114}, + {0x1f, 2, 114}, + {0x29, 2, 114}, + {0x38, 3, 114}, + {0x03, 2, 117}, + {0x06, 2, 117}, + {0x0a, 2, 117}, + {0x0f, 2, 117}, + {0x18, 2, 117}, + {0x1f, 2, 117}, + {0x29, 2, 117}, + {0x38, 3, 117}, }, /* 37 */ { - {0x8002, 58}, - {0x8009, 58}, - {0x8017, 58}, - {0xc028, 58}, - {0x8002, 66}, - {0x8009, 66}, - {0x8017, 66}, - {0xc028, 66}, - {0x8002, 67}, - {0x8009, 67}, - {0x8017, 67}, - {0xc028, 67}, - {0x8002, 68}, - {0x8009, 68}, - {0x8017, 68}, - {0xc028, 68}, + {0x02, 2, 58}, + {0x09, 2, 58}, + {0x17, 2, 58}, + {0x28, 3, 58}, + {0x02, 2, 66}, + {0x09, 2, 66}, + {0x17, 2, 66}, + {0x28, 3, 66}, + {0x02, 2, 67}, + {0x09, 2, 67}, + {0x17, 2, 67}, + {0x28, 3, 67}, + {0x02, 2, 68}, + {0x09, 2, 68}, + {0x17, 2, 68}, + {0x28, 3, 68}, }, /* 38 */ { - {0x8003, 58}, - {0x8006, 58}, - {0x800a, 58}, - {0x800f, 58}, - {0x8018, 58}, - {0x801f, 58}, - {0x8029, 58}, - {0xc038, 58}, - {0x8003, 66}, - {0x8006, 66}, - {0x800a, 66}, - {0x800f, 66}, - {0x8018, 66}, - {0x801f, 66}, - {0x8029, 66}, - {0xc038, 66}, + {0x03, 2, 58}, + {0x06, 2, 58}, + {0x0a, 2, 58}, + {0x0f, 2, 58}, + {0x18, 2, 58}, + {0x1f, 2, 58}, + {0x29, 2, 58}, + {0x38, 3, 58}, + {0x03, 2, 66}, + {0x06, 2, 66}, + {0x0a, 2, 66}, + {0x0f, 2, 66}, + {0x18, 2, 66}, + {0x1f, 2, 66}, + {0x29, 2, 66}, + {0x38, 3, 66}, }, /* 39 */ { - {0x8003, 67}, - {0x8006, 67}, - {0x800a, 67}, - {0x800f, 67}, - {0x8018, 67}, - {0x801f, 67}, - {0x8029, 67}, - {0xc038, 67}, - {0x8003, 68}, - {0x8006, 68}, - {0x800a, 68}, - {0x800f, 68}, - {0x8018, 68}, - {0x801f, 68}, - {0x8029, 68}, - {0xc038, 68}, + {0x03, 2, 67}, + {0x06, 2, 67}, + {0x0a, 2, 67}, + {0x0f, 2, 67}, + {0x18, 2, 67}, + {0x1f, 2, 67}, + {0x29, 2, 67}, + {0x38, 3, 67}, + {0x03, 2, 68}, + {0x06, 2, 68}, + {0x0a, 2, 68}, + {0x0f, 2, 68}, + {0x18, 2, 68}, + {0x1f, 2, 68}, + {0x29, 2, 68}, + {0x38, 3, 68}, }, /* 40 */ { - {0x2c, 0}, - {0x2d, 0}, - {0x2f, 0}, - {0x30, 0}, - {0x33, 0}, - {0x34, 0}, - {0x36, 0}, - {0x37, 0}, - {0x3b, 0}, - {0x3c, 0}, - {0x3e, 0}, - {0x3f, 0}, - {0x42, 0}, - {0x43, 0}, - {0x45, 0}, - {0x4048, 0}, + {0x2c, 0, 0}, + {0x2d, 0, 0}, + {0x2f, 0, 0}, + {0x30, 0, 0}, + {0x33, 0, 0}, + {0x34, 0, 0}, + {0x36, 0, 0}, + {0x37, 0, 0}, + {0x3b, 0, 0}, + {0x3c, 0, 0}, + {0x3e, 0, 0}, + {0x3f, 0, 0}, + {0x42, 0, 0}, + {0x43, 0, 0}, + {0x45, 0, 0}, + {0x48, 1, 0}, }, /* 41 */ { - {0xc000, 69}, - {0xc000, 70}, - {0xc000, 71}, - {0xc000, 72}, - {0xc000, 73}, - {0xc000, 74}, - {0xc000, 75}, - {0xc000, 76}, - {0xc000, 77}, - {0xc000, 78}, - {0xc000, 79}, - {0xc000, 80}, - {0xc000, 81}, - {0xc000, 82}, - {0xc000, 83}, - {0xc000, 84}, + {0x00, 3, 69}, + {0x00, 3, 70}, + {0x00, 3, 71}, + {0x00, 3, 72}, + {0x00, 3, 73}, + {0x00, 3, 74}, + {0x00, 3, 75}, + {0x00, 3, 76}, + {0x00, 3, 77}, + {0x00, 3, 78}, + {0x00, 3, 79}, + {0x00, 3, 80}, + {0x00, 3, 81}, + {0x00, 3, 82}, + {0x00, 3, 83}, + {0x00, 3, 84}, }, /* 42 */ { - {0x8001, 69}, - {0xc016, 69}, - {0x8001, 70}, - {0xc016, 70}, - {0x8001, 71}, - {0xc016, 71}, - {0x8001, 72}, - {0xc016, 72}, - {0x8001, 73}, - {0xc016, 73}, - {0x8001, 74}, - {0xc016, 74}, - {0x8001, 75}, - {0xc016, 75}, - {0x8001, 76}, - {0xc016, 76}, + {0x01, 2, 69}, + {0x16, 3, 69}, + {0x01, 2, 70}, + {0x16, 3, 70}, + {0x01, 2, 71}, + {0x16, 3, 71}, + {0x01, 2, 72}, + {0x16, 3, 72}, + {0x01, 2, 73}, + {0x16, 3, 73}, + {0x01, 2, 74}, + {0x16, 3, 74}, + {0x01, 2, 75}, + {0x16, 3, 75}, + {0x01, 2, 76}, + {0x16, 3, 76}, }, /* 43 */ { - {0x8002, 69}, - {0x8009, 69}, - {0x8017, 69}, - {0xc028, 69}, - {0x8002, 70}, - {0x8009, 70}, - {0x8017, 70}, - {0xc028, 70}, - {0x8002, 71}, - {0x8009, 71}, - {0x8017, 71}, - {0xc028, 71}, - {0x8002, 72}, - {0x8009, 72}, - {0x8017, 72}, - {0xc028, 72}, + {0x02, 2, 69}, + {0x09, 2, 69}, + {0x17, 2, 69}, + {0x28, 3, 69}, + {0x02, 2, 70}, + {0x09, 2, 70}, + {0x17, 2, 70}, + {0x28, 3, 70}, + {0x02, 2, 71}, + {0x09, 2, 71}, + {0x17, 2, 71}, + {0x28, 3, 71}, + {0x02, 2, 72}, + {0x09, 2, 72}, + {0x17, 2, 72}, + {0x28, 3, 72}, }, /* 44 */ { - {0x8003, 69}, - {0x8006, 69}, - {0x800a, 69}, - {0x800f, 69}, - {0x8018, 69}, - {0x801f, 69}, - {0x8029, 69}, - {0xc038, 69}, - {0x8003, 70}, - {0x8006, 70}, - {0x800a, 70}, - {0x800f, 70}, - {0x8018, 70}, - {0x801f, 70}, - {0x8029, 70}, - {0xc038, 70}, + {0x03, 2, 69}, + {0x06, 2, 69}, + {0x0a, 2, 69}, + {0x0f, 2, 69}, + {0x18, 2, 69}, + {0x1f, 2, 69}, + {0x29, 2, 69}, + {0x38, 3, 69}, + {0x03, 2, 70}, + {0x06, 2, 70}, + {0x0a, 2, 70}, + {0x0f, 2, 70}, + {0x18, 2, 70}, + {0x1f, 2, 70}, + {0x29, 2, 70}, + {0x38, 3, 70}, }, /* 45 */ { - {0x8003, 71}, - {0x8006, 71}, - {0x800a, 71}, - {0x800f, 71}, - {0x8018, 71}, - {0x801f, 71}, - {0x8029, 71}, - {0xc038, 71}, - {0x8003, 72}, - {0x8006, 72}, - {0x800a, 72}, - {0x800f, 72}, - {0x8018, 72}, - {0x801f, 72}, - {0x8029, 72}, - {0xc038, 72}, + {0x03, 2, 71}, + {0x06, 2, 71}, + {0x0a, 2, 71}, + {0x0f, 2, 71}, + {0x18, 2, 71}, + {0x1f, 2, 71}, + {0x29, 2, 71}, + {0x38, 3, 71}, + {0x03, 2, 72}, + {0x06, 2, 72}, + {0x0a, 2, 72}, + {0x0f, 2, 72}, + {0x18, 2, 72}, + {0x1f, 2, 72}, + {0x29, 2, 72}, + {0x38, 3, 72}, }, /* 46 */ { - {0x8002, 73}, - {0x8009, 73}, - {0x8017, 73}, - {0xc028, 73}, - {0x8002, 74}, - {0x8009, 74}, - {0x8017, 74}, - {0xc028, 74}, - {0x8002, 75}, - {0x8009, 75}, - {0x8017, 75}, - {0xc028, 75}, - {0x8002, 76}, - {0x8009, 76}, - {0x8017, 76}, - {0xc028, 76}, + {0x02, 2, 73}, + {0x09, 2, 73}, + {0x17, 2, 73}, + {0x28, 3, 73}, + {0x02, 2, 74}, + {0x09, 2, 74}, + {0x17, 2, 74}, + {0x28, 3, 74}, + {0x02, 2, 75}, + {0x09, 2, 75}, + {0x17, 2, 75}, + {0x28, 3, 75}, + {0x02, 2, 76}, + {0x09, 2, 76}, + {0x17, 2, 76}, + {0x28, 3, 76}, }, /* 47 */ { - {0x8003, 73}, - {0x8006, 73}, - {0x800a, 73}, - {0x800f, 73}, - {0x8018, 73}, - {0x801f, 73}, - {0x8029, 73}, - {0xc038, 73}, - {0x8003, 74}, - {0x8006, 74}, - {0x800a, 74}, - {0x800f, 74}, - {0x8018, 74}, - {0x801f, 74}, - {0x8029, 74}, - {0xc038, 74}, + {0x03, 2, 73}, + {0x06, 2, 73}, + {0x0a, 2, 73}, + {0x0f, 2, 73}, + {0x18, 2, 73}, + {0x1f, 2, 73}, + {0x29, 2, 73}, + {0x38, 3, 73}, + {0x03, 2, 74}, + {0x06, 2, 74}, + {0x0a, 2, 74}, + {0x0f, 2, 74}, + {0x18, 2, 74}, + {0x1f, 2, 74}, + {0x29, 2, 74}, + {0x38, 3, 74}, }, /* 48 */ { - {0x8003, 75}, - {0x8006, 75}, - {0x800a, 75}, - {0x800f, 75}, - {0x8018, 75}, - {0x801f, 75}, - {0x8029, 75}, - {0xc038, 75}, - {0x8003, 76}, - {0x8006, 76}, - {0x800a, 76}, - {0x800f, 76}, - {0x8018, 76}, - {0x801f, 76}, - {0x8029, 76}, - {0xc038, 76}, + {0x03, 2, 75}, + {0x06, 2, 75}, + {0x0a, 2, 75}, + {0x0f, 2, 75}, + {0x18, 2, 75}, + {0x1f, 2, 75}, + {0x29, 2, 75}, + {0x38, 3, 75}, + {0x03, 2, 76}, + {0x06, 2, 76}, + {0x0a, 2, 76}, + {0x0f, 2, 76}, + {0x18, 2, 76}, + {0x1f, 2, 76}, + {0x29, 2, 76}, + {0x38, 3, 76}, }, /* 49 */ { - {0x8001, 77}, - {0xc016, 77}, - {0x8001, 78}, - {0xc016, 78}, - {0x8001, 79}, - {0xc016, 79}, - {0x8001, 80}, - {0xc016, 80}, - {0x8001, 81}, - {0xc016, 81}, - {0x8001, 82}, - {0xc016, 82}, - {0x8001, 83}, - {0xc016, 83}, - {0x8001, 84}, - {0xc016, 84}, + {0x01, 2, 77}, + {0x16, 3, 77}, + {0x01, 2, 78}, + {0x16, 3, 78}, + {0x01, 2, 79}, + {0x16, 3, 79}, + {0x01, 2, 80}, + {0x16, 3, 80}, + {0x01, 2, 81}, + {0x16, 3, 81}, + {0x01, 2, 82}, + {0x16, 3, 82}, + {0x01, 2, 83}, + {0x16, 3, 83}, + {0x01, 2, 84}, + {0x16, 3, 84}, }, /* 50 */ { - {0x8002, 77}, - {0x8009, 77}, - {0x8017, 77}, - {0xc028, 77}, - {0x8002, 78}, - {0x8009, 78}, - {0x8017, 78}, - {0xc028, 78}, - {0x8002, 79}, - {0x8009, 79}, - {0x8017, 79}, - {0xc028, 79}, - {0x8002, 80}, - {0x8009, 80}, - {0x8017, 80}, - {0xc028, 80}, + {0x02, 2, 77}, + {0x09, 2, 77}, + {0x17, 2, 77}, + {0x28, 3, 77}, + {0x02, 2, 78}, + {0x09, 2, 78}, + {0x17, 2, 78}, + {0x28, 3, 78}, + {0x02, 2, 79}, + {0x09, 2, 79}, + {0x17, 2, 79}, + {0x28, 3, 79}, + {0x02, 2, 80}, + {0x09, 2, 80}, + {0x17, 2, 80}, + {0x28, 3, 80}, }, /* 51 */ { - {0x8003, 77}, - {0x8006, 77}, - {0x800a, 77}, - {0x800f, 77}, - {0x8018, 77}, - {0x801f, 77}, - {0x8029, 77}, - {0xc038, 77}, - {0x8003, 78}, - {0x8006, 78}, - {0x800a, 78}, - {0x800f, 78}, - {0x8018, 78}, - {0x801f, 78}, - {0x8029, 78}, - {0xc038, 78}, + {0x03, 2, 77}, + {0x06, 2, 77}, + {0x0a, 2, 77}, + {0x0f, 2, 77}, + {0x18, 2, 77}, + {0x1f, 2, 77}, + {0x29, 2, 77}, + {0x38, 3, 77}, + {0x03, 2, 78}, + {0x06, 2, 78}, + {0x0a, 2, 78}, + {0x0f, 2, 78}, + {0x18, 2, 78}, + {0x1f, 2, 78}, + {0x29, 2, 78}, + {0x38, 3, 78}, }, /* 52 */ { - {0x8003, 79}, - {0x8006, 79}, - {0x800a, 79}, - {0x800f, 79}, - {0x8018, 79}, - {0x801f, 79}, - {0x8029, 79}, - {0xc038, 79}, - {0x8003, 80}, - {0x8006, 80}, - {0x800a, 80}, - {0x800f, 80}, - {0x8018, 80}, - {0x801f, 80}, - {0x8029, 80}, - {0xc038, 80}, + {0x03, 2, 79}, + {0x06, 2, 79}, + {0x0a, 2, 79}, + {0x0f, 2, 79}, + {0x18, 2, 79}, + {0x1f, 2, 79}, + {0x29, 2, 79}, + {0x38, 3, 79}, + {0x03, 2, 80}, + {0x06, 2, 80}, + {0x0a, 2, 80}, + {0x0f, 2, 80}, + {0x18, 2, 80}, + {0x1f, 2, 80}, + {0x29, 2, 80}, + {0x38, 3, 80}, }, /* 53 */ { - {0x8002, 81}, - {0x8009, 81}, - {0x8017, 81}, - {0xc028, 81}, - {0x8002, 82}, - {0x8009, 82}, - {0x8017, 82}, - {0xc028, 82}, - {0x8002, 83}, - {0x8009, 83}, - {0x8017, 83}, - {0xc028, 83}, - {0x8002, 84}, - {0x8009, 84}, - {0x8017, 84}, - {0xc028, 84}, + {0x02, 2, 81}, + {0x09, 2, 81}, + {0x17, 2, 81}, + {0x28, 3, 81}, + {0x02, 2, 82}, + {0x09, 2, 82}, + {0x17, 2, 82}, + {0x28, 3, 82}, + {0x02, 2, 83}, + {0x09, 2, 83}, + {0x17, 2, 83}, + {0x28, 3, 83}, + {0x02, 2, 84}, + {0x09, 2, 84}, + {0x17, 2, 84}, + {0x28, 3, 84}, }, /* 54 */ { - {0x8003, 81}, - {0x8006, 81}, - {0x800a, 81}, - {0x800f, 81}, - {0x8018, 81}, - {0x801f, 81}, - {0x8029, 81}, - {0xc038, 81}, - {0x8003, 82}, - {0x8006, 82}, - {0x800a, 82}, - {0x800f, 82}, - {0x8018, 82}, - {0x801f, 82}, - {0x8029, 82}, - {0xc038, 82}, + {0x03, 2, 81}, + {0x06, 2, 81}, + {0x0a, 2, 81}, + {0x0f, 2, 81}, + {0x18, 2, 81}, + {0x1f, 2, 81}, + {0x29, 2, 81}, + {0x38, 3, 81}, + {0x03, 2, 82}, + {0x06, 2, 82}, + {0x0a, 2, 82}, + {0x0f, 2, 82}, + {0x18, 2, 82}, + {0x1f, 2, 82}, + {0x29, 2, 82}, + {0x38, 3, 82}, }, /* 55 */ { - {0x8003, 83}, - {0x8006, 83}, - {0x800a, 83}, - {0x800f, 83}, - {0x8018, 83}, - {0x801f, 83}, - {0x8029, 83}, - {0xc038, 83}, - {0x8003, 84}, - {0x8006, 84}, - {0x800a, 84}, - {0x800f, 84}, - {0x8018, 84}, - {0x801f, 84}, - {0x8029, 84}, - {0xc038, 84}, + {0x03, 2, 83}, + {0x06, 2, 83}, + {0x0a, 2, 83}, + {0x0f, 2, 83}, + {0x18, 2, 83}, + {0x1f, 2, 83}, + {0x29, 2, 83}, + {0x38, 3, 83}, + {0x03, 2, 84}, + {0x06, 2, 84}, + {0x0a, 2, 84}, + {0x0f, 2, 84}, + {0x18, 2, 84}, + {0x1f, 2, 84}, + {0x29, 2, 84}, + {0x38, 3, 84}, }, /* 56 */ { - {0xc000, 85}, - {0xc000, 86}, - {0xc000, 87}, - {0xc000, 89}, - {0xc000, 106}, - {0xc000, 107}, - {0xc000, 113}, - {0xc000, 118}, - {0xc000, 119}, - {0xc000, 120}, - {0xc000, 121}, - {0xc000, 122}, - {0x46, 0}, - {0x47, 0}, - {0x49, 0}, - {0x404a, 0}, + {0x00, 3, 85}, + {0x00, 3, 86}, + {0x00, 3, 87}, + {0x00, 3, 89}, + {0x00, 3, 106}, + {0x00, 3, 107}, + {0x00, 3, 113}, + {0x00, 3, 118}, + {0x00, 3, 119}, + {0x00, 3, 120}, + {0x00, 3, 121}, + {0x00, 3, 122}, + {0x46, 0, 0}, + {0x47, 0, 0}, + {0x49, 0, 0}, + {0x4a, 1, 0}, }, /* 57 */ { - {0x8001, 85}, - {0xc016, 85}, - {0x8001, 86}, - {0xc016, 86}, - {0x8001, 87}, - {0xc016, 87}, - {0x8001, 89}, - {0xc016, 89}, - {0x8001, 106}, - {0xc016, 106}, - {0x8001, 107}, - {0xc016, 107}, - {0x8001, 113}, - {0xc016, 113}, - {0x8001, 118}, - {0xc016, 118}, + {0x01, 2, 85}, + {0x16, 3, 85}, + {0x01, 2, 86}, + {0x16, 3, 86}, + {0x01, 2, 87}, + {0x16, 3, 87}, + {0x01, 2, 89}, + {0x16, 3, 89}, + {0x01, 2, 106}, + {0x16, 3, 106}, + {0x01, 2, 107}, + {0x16, 3, 107}, + {0x01, 2, 113}, + {0x16, 3, 113}, + {0x01, 2, 118}, + {0x16, 3, 118}, }, /* 58 */ { - {0x8002, 85}, - {0x8009, 85}, - {0x8017, 85}, - {0xc028, 85}, - {0x8002, 86}, - {0x8009, 86}, - {0x8017, 86}, - {0xc028, 86}, - {0x8002, 87}, - {0x8009, 87}, - {0x8017, 87}, - {0xc028, 87}, - {0x8002, 89}, - {0x8009, 89}, - {0x8017, 89}, - {0xc028, 89}, + {0x02, 2, 85}, + {0x09, 2, 85}, + {0x17, 2, 85}, + {0x28, 3, 85}, + {0x02, 2, 86}, + {0x09, 2, 86}, + {0x17, 2, 86}, + {0x28, 3, 86}, + {0x02, 2, 87}, + {0x09, 2, 87}, + {0x17, 2, 87}, + {0x28, 3, 87}, + {0x02, 2, 89}, + {0x09, 2, 89}, + {0x17, 2, 89}, + {0x28, 3, 89}, }, /* 59 */ { - {0x8003, 85}, - {0x8006, 85}, - {0x800a, 85}, - {0x800f, 85}, - {0x8018, 85}, - {0x801f, 85}, - {0x8029, 85}, - {0xc038, 85}, - {0x8003, 86}, - {0x8006, 86}, - {0x800a, 86}, - {0x800f, 86}, - {0x8018, 86}, - {0x801f, 86}, - {0x8029, 86}, - {0xc038, 86}, + {0x03, 2, 85}, + {0x06, 2, 85}, + {0x0a, 2, 85}, + {0x0f, 2, 85}, + {0x18, 2, 85}, + {0x1f, 2, 85}, + {0x29, 2, 85}, + {0x38, 3, 85}, + {0x03, 2, 86}, + {0x06, 2, 86}, + {0x0a, 2, 86}, + {0x0f, 2, 86}, + {0x18, 2, 86}, + {0x1f, 2, 86}, + {0x29, 2, 86}, + {0x38, 3, 86}, }, /* 60 */ { - {0x8003, 87}, - {0x8006, 87}, - {0x800a, 87}, - {0x800f, 87}, - {0x8018, 87}, - {0x801f, 87}, - {0x8029, 87}, - {0xc038, 87}, - {0x8003, 89}, - {0x8006, 89}, - {0x800a, 89}, - {0x800f, 89}, - {0x8018, 89}, - {0x801f, 89}, - {0x8029, 89}, - {0xc038, 89}, + {0x03, 2, 87}, + {0x06, 2, 87}, + {0x0a, 2, 87}, + {0x0f, 2, 87}, + {0x18, 2, 87}, + {0x1f, 2, 87}, + {0x29, 2, 87}, + {0x38, 3, 87}, + {0x03, 2, 89}, + {0x06, 2, 89}, + {0x0a, 2, 89}, + {0x0f, 2, 89}, + {0x18, 2, 89}, + {0x1f, 2, 89}, + {0x29, 2, 89}, + {0x38, 3, 89}, }, /* 61 */ { - {0x8002, 106}, - {0x8009, 106}, - {0x8017, 106}, - {0xc028, 106}, - {0x8002, 107}, - {0x8009, 107}, - {0x8017, 107}, - {0xc028, 107}, - {0x8002, 113}, - {0x8009, 113}, - {0x8017, 113}, - {0xc028, 113}, - {0x8002, 118}, - {0x8009, 118}, - {0x8017, 118}, - {0xc028, 118}, + {0x02, 2, 106}, + {0x09, 2, 106}, + {0x17, 2, 106}, + {0x28, 3, 106}, + {0x02, 2, 107}, + {0x09, 2, 107}, + {0x17, 2, 107}, + {0x28, 3, 107}, + {0x02, 2, 113}, + {0x09, 2, 113}, + {0x17, 2, 113}, + {0x28, 3, 113}, + {0x02, 2, 118}, + {0x09, 2, 118}, + {0x17, 2, 118}, + {0x28, 3, 118}, }, /* 62 */ { - {0x8003, 106}, - {0x8006, 106}, - {0x800a, 106}, - {0x800f, 106}, - {0x8018, 106}, - {0x801f, 106}, - {0x8029, 106}, - {0xc038, 106}, - {0x8003, 107}, - {0x8006, 107}, - {0x800a, 107}, - {0x800f, 107}, - {0x8018, 107}, - {0x801f, 107}, - {0x8029, 107}, - {0xc038, 107}, + {0x03, 2, 106}, + {0x06, 2, 106}, + {0x0a, 2, 106}, + {0x0f, 2, 106}, + {0x18, 2, 106}, + {0x1f, 2, 106}, + {0x29, 2, 106}, + {0x38, 3, 106}, + {0x03, 2, 107}, + {0x06, 2, 107}, + {0x0a, 2, 107}, + {0x0f, 2, 107}, + {0x18, 2, 107}, + {0x1f, 2, 107}, + {0x29, 2, 107}, + {0x38, 3, 107}, }, /* 63 */ { - {0x8003, 113}, - {0x8006, 113}, - {0x800a, 113}, - {0x800f, 113}, - {0x8018, 113}, - {0x801f, 113}, - {0x8029, 113}, - {0xc038, 113}, - {0x8003, 118}, - {0x8006, 118}, - {0x800a, 118}, - {0x800f, 118}, - {0x8018, 118}, - {0x801f, 118}, - {0x8029, 118}, - {0xc038, 118}, + {0x03, 2, 113}, + {0x06, 2, 113}, + {0x0a, 2, 113}, + {0x0f, 2, 113}, + {0x18, 2, 113}, + {0x1f, 2, 113}, + {0x29, 2, 113}, + {0x38, 3, 113}, + {0x03, 2, 118}, + {0x06, 2, 118}, + {0x0a, 2, 118}, + {0x0f, 2, 118}, + {0x18, 2, 118}, + {0x1f, 2, 118}, + {0x29, 2, 118}, + {0x38, 3, 118}, }, /* 64 */ { - {0x8001, 119}, - {0xc016, 119}, - {0x8001, 120}, - {0xc016, 120}, - {0x8001, 121}, - {0xc016, 121}, - {0x8001, 122}, - {0xc016, 122}, - {0xc000, 38}, - {0xc000, 42}, - {0xc000, 44}, - {0xc000, 59}, - {0xc000, 88}, - {0xc000, 90}, - {0x4b, 0}, - {0x4e, 0}, + {0x01, 2, 119}, + {0x16, 3, 119}, + {0x01, 2, 120}, + {0x16, 3, 120}, + {0x01, 2, 121}, + {0x16, 3, 121}, + {0x01, 2, 122}, + {0x16, 3, 122}, + {0x00, 3, 38}, + {0x00, 3, 42}, + {0x00, 3, 44}, + {0x00, 3, 59}, + {0x00, 3, 88}, + {0x00, 3, 90}, + {0x4b, 0, 0}, + {0x4e, 0, 0}, }, /* 65 */ { - {0x8002, 119}, - {0x8009, 119}, - {0x8017, 119}, - {0xc028, 119}, - {0x8002, 120}, - {0x8009, 120}, - {0x8017, 120}, - {0xc028, 120}, - {0x8002, 121}, - {0x8009, 121}, - {0x8017, 121}, - {0xc028, 121}, - {0x8002, 122}, - {0x8009, 122}, - {0x8017, 122}, - {0xc028, 122}, + {0x02, 2, 119}, + {0x09, 2, 119}, + {0x17, 2, 119}, + {0x28, 3, 119}, + {0x02, 2, 120}, + {0x09, 2, 120}, + {0x17, 2, 120}, + {0x28, 3, 120}, + {0x02, 2, 121}, + {0x09, 2, 121}, + {0x17, 2, 121}, + {0x28, 3, 121}, + {0x02, 2, 122}, + {0x09, 2, 122}, + {0x17, 2, 122}, + {0x28, 3, 122}, }, /* 66 */ { - {0x8003, 119}, - {0x8006, 119}, - {0x800a, 119}, - {0x800f, 119}, - {0x8018, 119}, - {0x801f, 119}, - {0x8029, 119}, - {0xc038, 119}, - {0x8003, 120}, - {0x8006, 120}, - {0x800a, 120}, - {0x800f, 120}, - {0x8018, 120}, - {0x801f, 120}, - {0x8029, 120}, - {0xc038, 120}, + {0x03, 2, 119}, + {0x06, 2, 119}, + {0x0a, 2, 119}, + {0x0f, 2, 119}, + {0x18, 2, 119}, + {0x1f, 2, 119}, + {0x29, 2, 119}, + {0x38, 3, 119}, + {0x03, 2, 120}, + {0x06, 2, 120}, + {0x0a, 2, 120}, + {0x0f, 2, 120}, + {0x18, 2, 120}, + {0x1f, 2, 120}, + {0x29, 2, 120}, + {0x38, 3, 120}, }, /* 67 */ { - {0x8003, 121}, - {0x8006, 121}, - {0x800a, 121}, - {0x800f, 121}, - {0x8018, 121}, - {0x801f, 121}, - {0x8029, 121}, - {0xc038, 121}, - {0x8003, 122}, - {0x8006, 122}, - {0x800a, 122}, - {0x800f, 122}, - {0x8018, 122}, - {0x801f, 122}, - {0x8029, 122}, - {0xc038, 122}, + {0x03, 2, 121}, + {0x06, 2, 121}, + {0x0a, 2, 121}, + {0x0f, 2, 121}, + {0x18, 2, 121}, + {0x1f, 2, 121}, + {0x29, 2, 121}, + {0x38, 3, 121}, + {0x03, 2, 122}, + {0x06, 2, 122}, + {0x0a, 2, 122}, + {0x0f, 2, 122}, + {0x18, 2, 122}, + {0x1f, 2, 122}, + {0x29, 2, 122}, + {0x38, 3, 122}, }, /* 68 */ { - {0x8001, 38}, - {0xc016, 38}, - {0x8001, 42}, - {0xc016, 42}, - {0x8001, 44}, - {0xc016, 44}, - {0x8001, 59}, - {0xc016, 59}, - {0x8001, 88}, - {0xc016, 88}, - {0x8001, 90}, - {0xc016, 90}, - {0x4c, 0}, - {0x4d, 0}, - {0x4f, 0}, - {0x51, 0}, + {0x01, 2, 38}, + {0x16, 3, 38}, + {0x01, 2, 42}, + {0x16, 3, 42}, + {0x01, 2, 44}, + {0x16, 3, 44}, + {0x01, 2, 59}, + {0x16, 3, 59}, + {0x01, 2, 88}, + {0x16, 3, 88}, + {0x01, 2, 90}, + {0x16, 3, 90}, + {0x4c, 0, 0}, + {0x4d, 0, 0}, + {0x4f, 0, 0}, + {0x51, 0, 0}, }, /* 69 */ { - {0x8002, 38}, - {0x8009, 38}, - {0x8017, 38}, - {0xc028, 38}, - {0x8002, 42}, - {0x8009, 42}, - {0x8017, 42}, - {0xc028, 42}, - {0x8002, 44}, - {0x8009, 44}, - {0x8017, 44}, - {0xc028, 44}, - {0x8002, 59}, - {0x8009, 59}, - {0x8017, 59}, - {0xc028, 59}, + {0x02, 2, 38}, + {0x09, 2, 38}, + {0x17, 2, 38}, + {0x28, 3, 38}, + {0x02, 2, 42}, + {0x09, 2, 42}, + {0x17, 2, 42}, + {0x28, 3, 42}, + {0x02, 2, 44}, + {0x09, 2, 44}, + {0x17, 2, 44}, + {0x28, 3, 44}, + {0x02, 2, 59}, + {0x09, 2, 59}, + {0x17, 2, 59}, + {0x28, 3, 59}, }, /* 70 */ { - {0x8003, 38}, - {0x8006, 38}, - {0x800a, 38}, - {0x800f, 38}, - {0x8018, 38}, - {0x801f, 38}, - {0x8029, 38}, - {0xc038, 38}, - {0x8003, 42}, - {0x8006, 42}, - {0x800a, 42}, - {0x800f, 42}, - {0x8018, 42}, - {0x801f, 42}, - {0x8029, 42}, - {0xc038, 42}, + {0x03, 2, 38}, + {0x06, 2, 38}, + {0x0a, 2, 38}, + {0x0f, 2, 38}, + {0x18, 2, 38}, + {0x1f, 2, 38}, + {0x29, 2, 38}, + {0x38, 3, 38}, + {0x03, 2, 42}, + {0x06, 2, 42}, + {0x0a, 2, 42}, + {0x0f, 2, 42}, + {0x18, 2, 42}, + {0x1f, 2, 42}, + {0x29, 2, 42}, + {0x38, 3, 42}, }, /* 71 */ { - {0x8003, 44}, - {0x8006, 44}, - {0x800a, 44}, - {0x800f, 44}, - {0x8018, 44}, - {0x801f, 44}, - {0x8029, 44}, - {0xc038, 44}, - {0x8003, 59}, - {0x8006, 59}, - {0x800a, 59}, - {0x800f, 59}, - {0x8018, 59}, - {0x801f, 59}, - {0x8029, 59}, - {0xc038, 59}, + {0x03, 2, 44}, + {0x06, 2, 44}, + {0x0a, 2, 44}, + {0x0f, 2, 44}, + {0x18, 2, 44}, + {0x1f, 2, 44}, + {0x29, 2, 44}, + {0x38, 3, 44}, + {0x03, 2, 59}, + {0x06, 2, 59}, + {0x0a, 2, 59}, + {0x0f, 2, 59}, + {0x18, 2, 59}, + {0x1f, 2, 59}, + {0x29, 2, 59}, + {0x38, 3, 59}, }, /* 72 */ { - {0x8002, 88}, - {0x8009, 88}, - {0x8017, 88}, - {0xc028, 88}, - {0x8002, 90}, - {0x8009, 90}, - {0x8017, 90}, - {0xc028, 90}, - {0xc000, 33}, - {0xc000, 34}, - {0xc000, 40}, - {0xc000, 41}, - {0xc000, 63}, - {0x50, 0}, - {0x52, 0}, - {0x54, 0}, + {0x02, 2, 88}, + {0x09, 2, 88}, + {0x17, 2, 88}, + {0x28, 3, 88}, + {0x02, 2, 90}, + {0x09, 2, 90}, + {0x17, 2, 90}, + {0x28, 3, 90}, + {0x00, 3, 33}, + {0x00, 3, 34}, + {0x00, 3, 40}, + {0x00, 3, 41}, + {0x00, 3, 63}, + {0x50, 0, 0}, + {0x52, 0, 0}, + {0x54, 0, 0}, }, /* 73 */ { - {0x8003, 88}, - {0x8006, 88}, - {0x800a, 88}, - {0x800f, 88}, - {0x8018, 88}, - {0x801f, 88}, - {0x8029, 88}, - {0xc038, 88}, - {0x8003, 90}, - {0x8006, 90}, - {0x800a, 90}, - {0x800f, 90}, - {0x8018, 90}, - {0x801f, 90}, - {0x8029, 90}, - {0xc038, 90}, + {0x03, 2, 88}, + {0x06, 2, 88}, + {0x0a, 2, 88}, + {0x0f, 2, 88}, + {0x18, 2, 88}, + {0x1f, 2, 88}, + {0x29, 2, 88}, + {0x38, 3, 88}, + {0x03, 2, 90}, + {0x06, 2, 90}, + {0x0a, 2, 90}, + {0x0f, 2, 90}, + {0x18, 2, 90}, + {0x1f, 2, 90}, + {0x29, 2, 90}, + {0x38, 3, 90}, }, /* 74 */ { - {0x8001, 33}, - {0xc016, 33}, - {0x8001, 34}, - {0xc016, 34}, - {0x8001, 40}, - {0xc016, 40}, - {0x8001, 41}, - {0xc016, 41}, - {0x8001, 63}, - {0xc016, 63}, - {0xc000, 39}, - {0xc000, 43}, - {0xc000, 124}, - {0x53, 0}, - {0x55, 0}, - {0x58, 0}, + {0x01, 2, 33}, + {0x16, 3, 33}, + {0x01, 2, 34}, + {0x16, 3, 34}, + {0x01, 2, 40}, + {0x16, 3, 40}, + {0x01, 2, 41}, + {0x16, 3, 41}, + {0x01, 2, 63}, + {0x16, 3, 63}, + {0x00, 3, 39}, + {0x00, 3, 43}, + {0x00, 3, 124}, + {0x53, 0, 0}, + {0x55, 0, 0}, + {0x58, 0, 0}, }, /* 75 */ { - {0x8002, 33}, - {0x8009, 33}, - {0x8017, 33}, - {0xc028, 33}, - {0x8002, 34}, - {0x8009, 34}, - {0x8017, 34}, - {0xc028, 34}, - {0x8002, 40}, - {0x8009, 40}, - {0x8017, 40}, - {0xc028, 40}, - {0x8002, 41}, - {0x8009, 41}, - {0x8017, 41}, - {0xc028, 41}, + {0x02, 2, 33}, + {0x09, 2, 33}, + {0x17, 2, 33}, + {0x28, 3, 33}, + {0x02, 2, 34}, + {0x09, 2, 34}, + {0x17, 2, 34}, + {0x28, 3, 34}, + {0x02, 2, 40}, + {0x09, 2, 40}, + {0x17, 2, 40}, + {0x28, 3, 40}, + {0x02, 2, 41}, + {0x09, 2, 41}, + {0x17, 2, 41}, + {0x28, 3, 41}, }, /* 76 */ { - {0x8003, 33}, - {0x8006, 33}, - {0x800a, 33}, - {0x800f, 33}, - {0x8018, 33}, - {0x801f, 33}, - {0x8029, 33}, - {0xc038, 33}, - {0x8003, 34}, - {0x8006, 34}, - {0x800a, 34}, - {0x800f, 34}, - {0x8018, 34}, - {0x801f, 34}, - {0x8029, 34}, - {0xc038, 34}, + {0x03, 2, 33}, + {0x06, 2, 33}, + {0x0a, 2, 33}, + {0x0f, 2, 33}, + {0x18, 2, 33}, + {0x1f, 2, 33}, + {0x29, 2, 33}, + {0x38, 3, 33}, + {0x03, 2, 34}, + {0x06, 2, 34}, + {0x0a, 2, 34}, + {0x0f, 2, 34}, + {0x18, 2, 34}, + {0x1f, 2, 34}, + {0x29, 2, 34}, + {0x38, 3, 34}, }, /* 77 */ { - {0x8003, 40}, - {0x8006, 40}, - {0x800a, 40}, - {0x800f, 40}, - {0x8018, 40}, - {0x801f, 40}, - {0x8029, 40}, - {0xc038, 40}, - {0x8003, 41}, - {0x8006, 41}, - {0x800a, 41}, - {0x800f, 41}, - {0x8018, 41}, - {0x801f, 41}, - {0x8029, 41}, - {0xc038, 41}, + {0x03, 2, 40}, + {0x06, 2, 40}, + {0x0a, 2, 40}, + {0x0f, 2, 40}, + {0x18, 2, 40}, + {0x1f, 2, 40}, + {0x29, 2, 40}, + {0x38, 3, 40}, + {0x03, 2, 41}, + {0x06, 2, 41}, + {0x0a, 2, 41}, + {0x0f, 2, 41}, + {0x18, 2, 41}, + {0x1f, 2, 41}, + {0x29, 2, 41}, + {0x38, 3, 41}, }, /* 78 */ { - {0x8002, 63}, - {0x8009, 63}, - {0x8017, 63}, - {0xc028, 63}, - {0x8001, 39}, - {0xc016, 39}, - {0x8001, 43}, - {0xc016, 43}, - {0x8001, 124}, - {0xc016, 124}, - {0xc000, 35}, - {0xc000, 62}, - {0x56, 0}, - {0x57, 0}, - {0x59, 0}, - {0x5a, 0}, + {0x02, 2, 63}, + {0x09, 2, 63}, + {0x17, 2, 63}, + {0x28, 3, 63}, + {0x01, 2, 39}, + {0x16, 3, 39}, + {0x01, 2, 43}, + {0x16, 3, 43}, + {0x01, 2, 124}, + {0x16, 3, 124}, + {0x00, 3, 35}, + {0x00, 3, 62}, + {0x56, 0, 0}, + {0x57, 0, 0}, + {0x59, 0, 0}, + {0x5a, 0, 0}, }, /* 79 */ { - {0x8003, 63}, - {0x8006, 63}, - {0x800a, 63}, - {0x800f, 63}, - {0x8018, 63}, - {0x801f, 63}, - {0x8029, 63}, - {0xc038, 63}, - {0x8002, 39}, - {0x8009, 39}, - {0x8017, 39}, - {0xc028, 39}, - {0x8002, 43}, - {0x8009, 43}, - {0x8017, 43}, - {0xc028, 43}, + {0x03, 2, 63}, + {0x06, 2, 63}, + {0x0a, 2, 63}, + {0x0f, 2, 63}, + {0x18, 2, 63}, + {0x1f, 2, 63}, + {0x29, 2, 63}, + {0x38, 3, 63}, + {0x02, 2, 39}, + {0x09, 2, 39}, + {0x17, 2, 39}, + {0x28, 3, 39}, + {0x02, 2, 43}, + {0x09, 2, 43}, + {0x17, 2, 43}, + {0x28, 3, 43}, }, /* 80 */ { - {0x8003, 39}, - {0x8006, 39}, - {0x800a, 39}, - {0x800f, 39}, - {0x8018, 39}, - {0x801f, 39}, - {0x8029, 39}, - {0xc038, 39}, - {0x8003, 43}, - {0x8006, 43}, - {0x800a, 43}, - {0x800f, 43}, - {0x8018, 43}, - {0x801f, 43}, - {0x8029, 43}, - {0xc038, 43}, + {0x03, 2, 39}, + {0x06, 2, 39}, + {0x0a, 2, 39}, + {0x0f, 2, 39}, + {0x18, 2, 39}, + {0x1f, 2, 39}, + {0x29, 2, 39}, + {0x38, 3, 39}, + {0x03, 2, 43}, + {0x06, 2, 43}, + {0x0a, 2, 43}, + {0x0f, 2, 43}, + {0x18, 2, 43}, + {0x1f, 2, 43}, + {0x29, 2, 43}, + {0x38, 3, 43}, }, /* 81 */ { - {0x8002, 124}, - {0x8009, 124}, - {0x8017, 124}, - {0xc028, 124}, - {0x8001, 35}, - {0xc016, 35}, - {0x8001, 62}, - {0xc016, 62}, - {0xc000, 0}, - {0xc000, 36}, - {0xc000, 64}, - {0xc000, 91}, - {0xc000, 93}, - {0xc000, 126}, - {0x5b, 0}, - {0x5c, 0}, + {0x02, 2, 124}, + {0x09, 2, 124}, + {0x17, 2, 124}, + {0x28, 3, 124}, + {0x01, 2, 35}, + {0x16, 3, 35}, + {0x01, 2, 62}, + {0x16, 3, 62}, + {0x00, 3, 0}, + {0x00, 3, 36}, + {0x00, 3, 64}, + {0x00, 3, 91}, + {0x00, 3, 93}, + {0x00, 3, 126}, + {0x5b, 0, 0}, + {0x5c, 0, 0}, }, /* 82 */ { - {0x8003, 124}, - {0x8006, 124}, - {0x800a, 124}, - {0x800f, 124}, - {0x8018, 124}, - {0x801f, 124}, - {0x8029, 124}, - {0xc038, 124}, - {0x8002, 35}, - {0x8009, 35}, - {0x8017, 35}, - {0xc028, 35}, - {0x8002, 62}, - {0x8009, 62}, - {0x8017, 62}, - {0xc028, 62}, + {0x03, 2, 124}, + {0x06, 2, 124}, + {0x0a, 2, 124}, + {0x0f, 2, 124}, + {0x18, 2, 124}, + {0x1f, 2, 124}, + {0x29, 2, 124}, + {0x38, 3, 124}, + {0x02, 2, 35}, + {0x09, 2, 35}, + {0x17, 2, 35}, + {0x28, 3, 35}, + {0x02, 2, 62}, + {0x09, 2, 62}, + {0x17, 2, 62}, + {0x28, 3, 62}, }, /* 83 */ { - {0x8003, 35}, - {0x8006, 35}, - {0x800a, 35}, - {0x800f, 35}, - {0x8018, 35}, - {0x801f, 35}, - {0x8029, 35}, - {0xc038, 35}, - {0x8003, 62}, - {0x8006, 62}, - {0x800a, 62}, - {0x800f, 62}, - {0x8018, 62}, - {0x801f, 62}, - {0x8029, 62}, - {0xc038, 62}, + {0x03, 2, 35}, + {0x06, 2, 35}, + {0x0a, 2, 35}, + {0x0f, 2, 35}, + {0x18, 2, 35}, + {0x1f, 2, 35}, + {0x29, 2, 35}, + {0x38, 3, 35}, + {0x03, 2, 62}, + {0x06, 2, 62}, + {0x0a, 2, 62}, + {0x0f, 2, 62}, + {0x18, 2, 62}, + {0x1f, 2, 62}, + {0x29, 2, 62}, + {0x38, 3, 62}, }, /* 84 */ { - {0x8001, 0}, - {0xc016, 0}, - {0x8001, 36}, - {0xc016, 36}, - {0x8001, 64}, - {0xc016, 64}, - {0x8001, 91}, - {0xc016, 91}, - {0x8001, 93}, - {0xc016, 93}, - {0x8001, 126}, - {0xc016, 126}, - {0xc000, 94}, - {0xc000, 125}, - {0x5d, 0}, - {0x5e, 0}, + {0x01, 2, 0}, + {0x16, 3, 0}, + {0x01, 2, 36}, + {0x16, 3, 36}, + {0x01, 2, 64}, + {0x16, 3, 64}, + {0x01, 2, 91}, + {0x16, 3, 91}, + {0x01, 2, 93}, + {0x16, 3, 93}, + {0x01, 2, 126}, + {0x16, 3, 126}, + {0x00, 3, 94}, + {0x00, 3, 125}, + {0x5d, 0, 0}, + {0x5e, 0, 0}, }, /* 85 */ { - {0x8002, 0}, - {0x8009, 0}, - {0x8017, 0}, - {0xc028, 0}, - {0x8002, 36}, - {0x8009, 36}, - {0x8017, 36}, - {0xc028, 36}, - {0x8002, 64}, - {0x8009, 64}, - {0x8017, 64}, - {0xc028, 64}, - {0x8002, 91}, - {0x8009, 91}, - {0x8017, 91}, - {0xc028, 91}, + {0x02, 2, 0}, + {0x09, 2, 0}, + {0x17, 2, 0}, + {0x28, 3, 0}, + {0x02, 2, 36}, + {0x09, 2, 36}, + {0x17, 2, 36}, + {0x28, 3, 36}, + {0x02, 2, 64}, + {0x09, 2, 64}, + {0x17, 2, 64}, + {0x28, 3, 64}, + {0x02, 2, 91}, + {0x09, 2, 91}, + {0x17, 2, 91}, + {0x28, 3, 91}, }, /* 86 */ { - {0x8003, 0}, - {0x8006, 0}, - {0x800a, 0}, - {0x800f, 0}, - {0x8018, 0}, - {0x801f, 0}, - {0x8029, 0}, - {0xc038, 0}, - {0x8003, 36}, - {0x8006, 36}, - {0x800a, 36}, - {0x800f, 36}, - {0x8018, 36}, - {0x801f, 36}, - {0x8029, 36}, - {0xc038, 36}, + {0x03, 2, 0}, + {0x06, 2, 0}, + {0x0a, 2, 0}, + {0x0f, 2, 0}, + {0x18, 2, 0}, + {0x1f, 2, 0}, + {0x29, 2, 0}, + {0x38, 3, 0}, + {0x03, 2, 36}, + {0x06, 2, 36}, + {0x0a, 2, 36}, + {0x0f, 2, 36}, + {0x18, 2, 36}, + {0x1f, 2, 36}, + {0x29, 2, 36}, + {0x38, 3, 36}, }, /* 87 */ { - {0x8003, 64}, - {0x8006, 64}, - {0x800a, 64}, - {0x800f, 64}, - {0x8018, 64}, - {0x801f, 64}, - {0x8029, 64}, - {0xc038, 64}, - {0x8003, 91}, - {0x8006, 91}, - {0x800a, 91}, - {0x800f, 91}, - {0x8018, 91}, - {0x801f, 91}, - {0x8029, 91}, - {0xc038, 91}, + {0x03, 2, 64}, + {0x06, 2, 64}, + {0x0a, 2, 64}, + {0x0f, 2, 64}, + {0x18, 2, 64}, + {0x1f, 2, 64}, + {0x29, 2, 64}, + {0x38, 3, 64}, + {0x03, 2, 91}, + {0x06, 2, 91}, + {0x0a, 2, 91}, + {0x0f, 2, 91}, + {0x18, 2, 91}, + {0x1f, 2, 91}, + {0x29, 2, 91}, + {0x38, 3, 91}, }, /* 88 */ { - {0x8002, 93}, - {0x8009, 93}, - {0x8017, 93}, - {0xc028, 93}, - {0x8002, 126}, - {0x8009, 126}, - {0x8017, 126}, - {0xc028, 126}, - {0x8001, 94}, - {0xc016, 94}, - {0x8001, 125}, - {0xc016, 125}, - {0xc000, 60}, - {0xc000, 96}, - {0xc000, 123}, - {0x5f, 0}, + {0x02, 2, 93}, + {0x09, 2, 93}, + {0x17, 2, 93}, + {0x28, 3, 93}, + {0x02, 2, 126}, + {0x09, 2, 126}, + {0x17, 2, 126}, + {0x28, 3, 126}, + {0x01, 2, 94}, + {0x16, 3, 94}, + {0x01, 2, 125}, + {0x16, 3, 125}, + {0x00, 3, 60}, + {0x00, 3, 96}, + {0x00, 3, 123}, + {0x5f, 0, 0}, }, /* 89 */ { - {0x8003, 93}, - {0x8006, 93}, - {0x800a, 93}, - {0x800f, 93}, - {0x8018, 93}, - {0x801f, 93}, - {0x8029, 93}, - {0xc038, 93}, - {0x8003, 126}, - {0x8006, 126}, - {0x800a, 126}, - {0x800f, 126}, - {0x8018, 126}, - {0x801f, 126}, - {0x8029, 126}, - {0xc038, 126}, + {0x03, 2, 93}, + {0x06, 2, 93}, + {0x0a, 2, 93}, + {0x0f, 2, 93}, + {0x18, 2, 93}, + {0x1f, 2, 93}, + {0x29, 2, 93}, + {0x38, 3, 93}, + {0x03, 2, 126}, + {0x06, 2, 126}, + {0x0a, 2, 126}, + {0x0f, 2, 126}, + {0x18, 2, 126}, + {0x1f, 2, 126}, + {0x29, 2, 126}, + {0x38, 3, 126}, }, /* 90 */ { - {0x8002, 94}, - {0x8009, 94}, - {0x8017, 94}, - {0xc028, 94}, - {0x8002, 125}, - {0x8009, 125}, - {0x8017, 125}, - {0xc028, 125}, - {0x8001, 60}, - {0xc016, 60}, - {0x8001, 96}, - {0xc016, 96}, - {0x8001, 123}, - {0xc016, 123}, - {0x60, 0}, - {0x6e, 0}, + {0x02, 2, 94}, + {0x09, 2, 94}, + {0x17, 2, 94}, + {0x28, 3, 94}, + {0x02, 2, 125}, + {0x09, 2, 125}, + {0x17, 2, 125}, + {0x28, 3, 125}, + {0x01, 2, 60}, + {0x16, 3, 60}, + {0x01, 2, 96}, + {0x16, 3, 96}, + {0x01, 2, 123}, + {0x16, 3, 123}, + {0x60, 0, 0}, + {0x6e, 0, 0}, }, /* 91 */ { - {0x8003, 94}, - {0x8006, 94}, - {0x800a, 94}, - {0x800f, 94}, - {0x8018, 94}, - {0x801f, 94}, - {0x8029, 94}, - {0xc038, 94}, - {0x8003, 125}, - {0x8006, 125}, - {0x800a, 125}, - {0x800f, 125}, - {0x8018, 125}, - {0x801f, 125}, - {0x8029, 125}, - {0xc038, 125}, + {0x03, 2, 94}, + {0x06, 2, 94}, + {0x0a, 2, 94}, + {0x0f, 2, 94}, + {0x18, 2, 94}, + {0x1f, 2, 94}, + {0x29, 2, 94}, + {0x38, 3, 94}, + {0x03, 2, 125}, + {0x06, 2, 125}, + {0x0a, 2, 125}, + {0x0f, 2, 125}, + {0x18, 2, 125}, + {0x1f, 2, 125}, + {0x29, 2, 125}, + {0x38, 3, 125}, }, /* 92 */ { - {0x8002, 60}, - {0x8009, 60}, - {0x8017, 60}, - {0xc028, 60}, - {0x8002, 96}, - {0x8009, 96}, - {0x8017, 96}, - {0xc028, 96}, - {0x8002, 123}, - {0x8009, 123}, - {0x8017, 123}, - {0xc028, 123}, - {0x61, 0}, - {0x65, 0}, - {0x6f, 0}, - {0x85, 0}, + {0x02, 2, 60}, + {0x09, 2, 60}, + {0x17, 2, 60}, + {0x28, 3, 60}, + {0x02, 2, 96}, + {0x09, 2, 96}, + {0x17, 2, 96}, + {0x28, 3, 96}, + {0x02, 2, 123}, + {0x09, 2, 123}, + {0x17, 2, 123}, + {0x28, 3, 123}, + {0x61, 0, 0}, + {0x65, 0, 0}, + {0x6f, 0, 0}, + {0x85, 0, 0}, }, /* 93 */ { - {0x8003, 60}, - {0x8006, 60}, - {0x800a, 60}, - {0x800f, 60}, - {0x8018, 60}, - {0x801f, 60}, - {0x8029, 60}, - {0xc038, 60}, - {0x8003, 96}, - {0x8006, 96}, - {0x800a, 96}, - {0x800f, 96}, - {0x8018, 96}, - {0x801f, 96}, - {0x8029, 96}, - {0xc038, 96}, + {0x03, 2, 60}, + {0x06, 2, 60}, + {0x0a, 2, 60}, + {0x0f, 2, 60}, + {0x18, 2, 60}, + {0x1f, 2, 60}, + {0x29, 2, 60}, + {0x38, 3, 60}, + {0x03, 2, 96}, + {0x06, 2, 96}, + {0x0a, 2, 96}, + {0x0f, 2, 96}, + {0x18, 2, 96}, + {0x1f, 2, 96}, + {0x29, 2, 96}, + {0x38, 3, 96}, }, /* 94 */ { - {0x8003, 123}, - {0x8006, 123}, - {0x800a, 123}, - {0x800f, 123}, - {0x8018, 123}, - {0x801f, 123}, - {0x8029, 123}, - {0xc038, 123}, - {0x62, 0}, - {0x63, 0}, - {0x66, 0}, - {0x69, 0}, - {0x70, 0}, - {0x77, 0}, - {0x86, 0}, - {0x99, 0}, + {0x03, 2, 123}, + {0x06, 2, 123}, + {0x0a, 2, 123}, + {0x0f, 2, 123}, + {0x18, 2, 123}, + {0x1f, 2, 123}, + {0x29, 2, 123}, + {0x38, 3, 123}, + {0x62, 0, 0}, + {0x63, 0, 0}, + {0x66, 0, 0}, + {0x69, 0, 0}, + {0x70, 0, 0}, + {0x77, 0, 0}, + {0x86, 0, 0}, + {0x99, 0, 0}, }, /* 95 */ { - {0xc000, 92}, - {0xc000, 195}, - {0xc000, 208}, - {0x64, 0}, - {0x67, 0}, - {0x68, 0}, - {0x6a, 0}, - {0x6b, 0}, - {0x71, 0}, - {0x74, 0}, - {0x78, 0}, - {0x7e, 0}, - {0x87, 0}, - {0x8e, 0}, - {0x9a, 0}, - {0xa9, 0}, + {0x00, 3, 92}, + {0x00, 3, 195}, + {0x00, 3, 208}, + {0x64, 0, 0}, + {0x67, 0, 0}, + {0x68, 0, 0}, + {0x6a, 0, 0}, + {0x6b, 0, 0}, + {0x71, 0, 0}, + {0x74, 0, 0}, + {0x78, 0, 0}, + {0x7e, 0, 0}, + {0x87, 0, 0}, + {0x8e, 0, 0}, + {0x9a, 0, 0}, + {0xa9, 0, 0}, }, /* 96 */ { - {0x8001, 92}, - {0xc016, 92}, - {0x8001, 195}, - {0xc016, 195}, - {0x8001, 208}, - {0xc016, 208}, - {0xc000, 128}, - {0xc000, 130}, - {0xc000, 131}, - {0xc000, 162}, - {0xc000, 184}, - {0xc000, 194}, - {0xc000, 224}, - {0xc000, 226}, - {0x6c, 0}, - {0x6d, 0}, + {0x01, 2, 92}, + {0x16, 3, 92}, + {0x01, 2, 195}, + {0x16, 3, 195}, + {0x01, 2, 208}, + {0x16, 3, 208}, + {0x00, 3, 128}, + {0x00, 3, 130}, + {0x00, 3, 131}, + {0x00, 3, 162}, + {0x00, 3, 184}, + {0x00, 3, 194}, + {0x00, 3, 224}, + {0x00, 3, 226}, + {0x6c, 0, 0}, + {0x6d, 0, 0}, }, /* 97 */ { - {0x8002, 92}, - {0x8009, 92}, - {0x8017, 92}, - {0xc028, 92}, - {0x8002, 195}, - {0x8009, 195}, - {0x8017, 195}, - {0xc028, 195}, - {0x8002, 208}, - {0x8009, 208}, - {0x8017, 208}, - {0xc028, 208}, - {0x8001, 128}, - {0xc016, 128}, - {0x8001, 130}, - {0xc016, 130}, + {0x02, 2, 92}, + {0x09, 2, 92}, + {0x17, 2, 92}, + {0x28, 3, 92}, + {0x02, 2, 195}, + {0x09, 2, 195}, + {0x17, 2, 195}, + {0x28, 3, 195}, + {0x02, 2, 208}, + {0x09, 2, 208}, + {0x17, 2, 208}, + {0x28, 3, 208}, + {0x01, 2, 128}, + {0x16, 3, 128}, + {0x01, 2, 130}, + {0x16, 3, 130}, }, /* 98 */ { - {0x8003, 92}, - {0x8006, 92}, - {0x800a, 92}, - {0x800f, 92}, - {0x8018, 92}, - {0x801f, 92}, - {0x8029, 92}, - {0xc038, 92}, - {0x8003, 195}, - {0x8006, 195}, - {0x800a, 195}, - {0x800f, 195}, - {0x8018, 195}, - {0x801f, 195}, - {0x8029, 195}, - {0xc038, 195}, + {0x03, 2, 92}, + {0x06, 2, 92}, + {0x0a, 2, 92}, + {0x0f, 2, 92}, + {0x18, 2, 92}, + {0x1f, 2, 92}, + {0x29, 2, 92}, + {0x38, 3, 92}, + {0x03, 2, 195}, + {0x06, 2, 195}, + {0x0a, 2, 195}, + {0x0f, 2, 195}, + {0x18, 2, 195}, + {0x1f, 2, 195}, + {0x29, 2, 195}, + {0x38, 3, 195}, }, /* 99 */ { - {0x8003, 208}, - {0x8006, 208}, - {0x800a, 208}, - {0x800f, 208}, - {0x8018, 208}, - {0x801f, 208}, - {0x8029, 208}, - {0xc038, 208}, - {0x8002, 128}, - {0x8009, 128}, - {0x8017, 128}, - {0xc028, 128}, - {0x8002, 130}, - {0x8009, 130}, - {0x8017, 130}, - {0xc028, 130}, + {0x03, 2, 208}, + {0x06, 2, 208}, + {0x0a, 2, 208}, + {0x0f, 2, 208}, + {0x18, 2, 208}, + {0x1f, 2, 208}, + {0x29, 2, 208}, + {0x38, 3, 208}, + {0x02, 2, 128}, + {0x09, 2, 128}, + {0x17, 2, 128}, + {0x28, 3, 128}, + {0x02, 2, 130}, + {0x09, 2, 130}, + {0x17, 2, 130}, + {0x28, 3, 130}, }, /* 100 */ { - {0x8003, 128}, - {0x8006, 128}, - {0x800a, 128}, - {0x800f, 128}, - {0x8018, 128}, - {0x801f, 128}, - {0x8029, 128}, - {0xc038, 128}, - {0x8003, 130}, - {0x8006, 130}, - {0x800a, 130}, - {0x800f, 130}, - {0x8018, 130}, - {0x801f, 130}, - {0x8029, 130}, - {0xc038, 130}, + {0x03, 2, 128}, + {0x06, 2, 128}, + {0x0a, 2, 128}, + {0x0f, 2, 128}, + {0x18, 2, 128}, + {0x1f, 2, 128}, + {0x29, 2, 128}, + {0x38, 3, 128}, + {0x03, 2, 130}, + {0x06, 2, 130}, + {0x0a, 2, 130}, + {0x0f, 2, 130}, + {0x18, 2, 130}, + {0x1f, 2, 130}, + {0x29, 2, 130}, + {0x38, 3, 130}, }, /* 101 */ { - {0x8001, 131}, - {0xc016, 131}, - {0x8001, 162}, - {0xc016, 162}, - {0x8001, 184}, - {0xc016, 184}, - {0x8001, 194}, - {0xc016, 194}, - {0x8001, 224}, - {0xc016, 224}, - {0x8001, 226}, - {0xc016, 226}, - {0xc000, 153}, - {0xc000, 161}, - {0xc000, 167}, - {0xc000, 172}, + {0x01, 2, 131}, + {0x16, 3, 131}, + {0x01, 2, 162}, + {0x16, 3, 162}, + {0x01, 2, 184}, + {0x16, 3, 184}, + {0x01, 2, 194}, + {0x16, 3, 194}, + {0x01, 2, 224}, + {0x16, 3, 224}, + {0x01, 2, 226}, + {0x16, 3, 226}, + {0x00, 3, 153}, + {0x00, 3, 161}, + {0x00, 3, 167}, + {0x00, 3, 172}, }, /* 102 */ { - {0x8002, 131}, - {0x8009, 131}, - {0x8017, 131}, - {0xc028, 131}, - {0x8002, 162}, - {0x8009, 162}, - {0x8017, 162}, - {0xc028, 162}, - {0x8002, 184}, - {0x8009, 184}, - {0x8017, 184}, - {0xc028, 184}, - {0x8002, 194}, - {0x8009, 194}, - {0x8017, 194}, - {0xc028, 194}, + {0x02, 2, 131}, + {0x09, 2, 131}, + {0x17, 2, 131}, + {0x28, 3, 131}, + {0x02, 2, 162}, + {0x09, 2, 162}, + {0x17, 2, 162}, + {0x28, 3, 162}, + {0x02, 2, 184}, + {0x09, 2, 184}, + {0x17, 2, 184}, + {0x28, 3, 184}, + {0x02, 2, 194}, + {0x09, 2, 194}, + {0x17, 2, 194}, + {0x28, 3, 194}, }, /* 103 */ { - {0x8003, 131}, - {0x8006, 131}, - {0x800a, 131}, - {0x800f, 131}, - {0x8018, 131}, - {0x801f, 131}, - {0x8029, 131}, - {0xc038, 131}, - {0x8003, 162}, - {0x8006, 162}, - {0x800a, 162}, - {0x800f, 162}, - {0x8018, 162}, - {0x801f, 162}, - {0x8029, 162}, - {0xc038, 162}, + {0x03, 2, 131}, + {0x06, 2, 131}, + {0x0a, 2, 131}, + {0x0f, 2, 131}, + {0x18, 2, 131}, + {0x1f, 2, 131}, + {0x29, 2, 131}, + {0x38, 3, 131}, + {0x03, 2, 162}, + {0x06, 2, 162}, + {0x0a, 2, 162}, + {0x0f, 2, 162}, + {0x18, 2, 162}, + {0x1f, 2, 162}, + {0x29, 2, 162}, + {0x38, 3, 162}, }, /* 104 */ { - {0x8003, 184}, - {0x8006, 184}, - {0x800a, 184}, - {0x800f, 184}, - {0x8018, 184}, - {0x801f, 184}, - {0x8029, 184}, - {0xc038, 184}, - {0x8003, 194}, - {0x8006, 194}, - {0x800a, 194}, - {0x800f, 194}, - {0x8018, 194}, - {0x801f, 194}, - {0x8029, 194}, - {0xc038, 194}, + {0x03, 2, 184}, + {0x06, 2, 184}, + {0x0a, 2, 184}, + {0x0f, 2, 184}, + {0x18, 2, 184}, + {0x1f, 2, 184}, + {0x29, 2, 184}, + {0x38, 3, 184}, + {0x03, 2, 194}, + {0x06, 2, 194}, + {0x0a, 2, 194}, + {0x0f, 2, 194}, + {0x18, 2, 194}, + {0x1f, 2, 194}, + {0x29, 2, 194}, + {0x38, 3, 194}, }, /* 105 */ { - {0x8002, 224}, - {0x8009, 224}, - {0x8017, 224}, - {0xc028, 224}, - {0x8002, 226}, - {0x8009, 226}, - {0x8017, 226}, - {0xc028, 226}, - {0x8001, 153}, - {0xc016, 153}, - {0x8001, 161}, - {0xc016, 161}, - {0x8001, 167}, - {0xc016, 167}, - {0x8001, 172}, - {0xc016, 172}, + {0x02, 2, 224}, + {0x09, 2, 224}, + {0x17, 2, 224}, + {0x28, 3, 224}, + {0x02, 2, 226}, + {0x09, 2, 226}, + {0x17, 2, 226}, + {0x28, 3, 226}, + {0x01, 2, 153}, + {0x16, 3, 153}, + {0x01, 2, 161}, + {0x16, 3, 161}, + {0x01, 2, 167}, + {0x16, 3, 167}, + {0x01, 2, 172}, + {0x16, 3, 172}, }, /* 106 */ { - {0x8003, 224}, - {0x8006, 224}, - {0x800a, 224}, - {0x800f, 224}, - {0x8018, 224}, - {0x801f, 224}, - {0x8029, 224}, - {0xc038, 224}, - {0x8003, 226}, - {0x8006, 226}, - {0x800a, 226}, - {0x800f, 226}, - {0x8018, 226}, - {0x801f, 226}, - {0x8029, 226}, - {0xc038, 226}, + {0x03, 2, 224}, + {0x06, 2, 224}, + {0x0a, 2, 224}, + {0x0f, 2, 224}, + {0x18, 2, 224}, + {0x1f, 2, 224}, + {0x29, 2, 224}, + {0x38, 3, 224}, + {0x03, 2, 226}, + {0x06, 2, 226}, + {0x0a, 2, 226}, + {0x0f, 2, 226}, + {0x18, 2, 226}, + {0x1f, 2, 226}, + {0x29, 2, 226}, + {0x38, 3, 226}, }, /* 107 */ { - {0x8002, 153}, - {0x8009, 153}, - {0x8017, 153}, - {0xc028, 153}, - {0x8002, 161}, - {0x8009, 161}, - {0x8017, 161}, - {0xc028, 161}, - {0x8002, 167}, - {0x8009, 167}, - {0x8017, 167}, - {0xc028, 167}, - {0x8002, 172}, - {0x8009, 172}, - {0x8017, 172}, - {0xc028, 172}, + {0x02, 2, 153}, + {0x09, 2, 153}, + {0x17, 2, 153}, + {0x28, 3, 153}, + {0x02, 2, 161}, + {0x09, 2, 161}, + {0x17, 2, 161}, + {0x28, 3, 161}, + {0x02, 2, 167}, + {0x09, 2, 167}, + {0x17, 2, 167}, + {0x28, 3, 167}, + {0x02, 2, 172}, + {0x09, 2, 172}, + {0x17, 2, 172}, + {0x28, 3, 172}, }, /* 108 */ { - {0x8003, 153}, - {0x8006, 153}, - {0x800a, 153}, - {0x800f, 153}, - {0x8018, 153}, - {0x801f, 153}, - {0x8029, 153}, - {0xc038, 153}, - {0x8003, 161}, - {0x8006, 161}, - {0x800a, 161}, - {0x800f, 161}, - {0x8018, 161}, - {0x801f, 161}, - {0x8029, 161}, - {0xc038, 161}, + {0x03, 2, 153}, + {0x06, 2, 153}, + {0x0a, 2, 153}, + {0x0f, 2, 153}, + {0x18, 2, 153}, + {0x1f, 2, 153}, + {0x29, 2, 153}, + {0x38, 3, 153}, + {0x03, 2, 161}, + {0x06, 2, 161}, + {0x0a, 2, 161}, + {0x0f, 2, 161}, + {0x18, 2, 161}, + {0x1f, 2, 161}, + {0x29, 2, 161}, + {0x38, 3, 161}, }, /* 109 */ { - {0x8003, 167}, - {0x8006, 167}, - {0x800a, 167}, - {0x800f, 167}, - {0x8018, 167}, - {0x801f, 167}, - {0x8029, 167}, - {0xc038, 167}, - {0x8003, 172}, - {0x8006, 172}, - {0x800a, 172}, - {0x800f, 172}, - {0x8018, 172}, - {0x801f, 172}, - {0x8029, 172}, - {0xc038, 172}, + {0x03, 2, 167}, + {0x06, 2, 167}, + {0x0a, 2, 167}, + {0x0f, 2, 167}, + {0x18, 2, 167}, + {0x1f, 2, 167}, + {0x29, 2, 167}, + {0x38, 3, 167}, + {0x03, 2, 172}, + {0x06, 2, 172}, + {0x0a, 2, 172}, + {0x0f, 2, 172}, + {0x18, 2, 172}, + {0x1f, 2, 172}, + {0x29, 2, 172}, + {0x38, 3, 172}, }, /* 110 */ { - {0x72, 0}, - {0x73, 0}, - {0x75, 0}, - {0x76, 0}, - {0x79, 0}, - {0x7b, 0}, - {0x7f, 0}, - {0x82, 0}, - {0x88, 0}, - {0x8b, 0}, - {0x8f, 0}, - {0x92, 0}, - {0x9b, 0}, - {0xa2, 0}, - {0xaa, 0}, - {0xb4, 0}, + {0x72, 0, 0}, + {0x73, 0, 0}, + {0x75, 0, 0}, + {0x76, 0, 0}, + {0x79, 0, 0}, + {0x7b, 0, 0}, + {0x7f, 0, 0}, + {0x82, 0, 0}, + {0x88, 0, 0}, + {0x8b, 0, 0}, + {0x8f, 0, 0}, + {0x92, 0, 0}, + {0x9b, 0, 0}, + {0xa2, 0, 0}, + {0xaa, 0, 0}, + {0xb4, 0, 0}, }, /* 111 */ { - {0xc000, 176}, - {0xc000, 177}, - {0xc000, 179}, - {0xc000, 209}, - {0xc000, 216}, - {0xc000, 217}, - {0xc000, 227}, - {0xc000, 229}, - {0xc000, 230}, - {0x7a, 0}, - {0x7c, 0}, - {0x7d, 0}, - {0x80, 0}, - {0x81, 0}, - {0x83, 0}, - {0x84, 0}, + {0x00, 3, 176}, + {0x00, 3, 177}, + {0x00, 3, 179}, + {0x00, 3, 209}, + {0x00, 3, 216}, + {0x00, 3, 217}, + {0x00, 3, 227}, + {0x00, 3, 229}, + {0x00, 3, 230}, + {0x7a, 0, 0}, + {0x7c, 0, 0}, + {0x7d, 0, 0}, + {0x80, 0, 0}, + {0x81, 0, 0}, + {0x83, 0, 0}, + {0x84, 0, 0}, }, /* 112 */ { - {0x8001, 176}, - {0xc016, 176}, - {0x8001, 177}, - {0xc016, 177}, - {0x8001, 179}, - {0xc016, 179}, - {0x8001, 209}, - {0xc016, 209}, - {0x8001, 216}, - {0xc016, 216}, - {0x8001, 217}, - {0xc016, 217}, - {0x8001, 227}, - {0xc016, 227}, - {0x8001, 229}, - {0xc016, 229}, + {0x01, 2, 176}, + {0x16, 3, 176}, + {0x01, 2, 177}, + {0x16, 3, 177}, + {0x01, 2, 179}, + {0x16, 3, 179}, + {0x01, 2, 209}, + {0x16, 3, 209}, + {0x01, 2, 216}, + {0x16, 3, 216}, + {0x01, 2, 217}, + {0x16, 3, 217}, + {0x01, 2, 227}, + {0x16, 3, 227}, + {0x01, 2, 229}, + {0x16, 3, 229}, }, /* 113 */ { - {0x8002, 176}, - {0x8009, 176}, - {0x8017, 176}, - {0xc028, 176}, - {0x8002, 177}, - {0x8009, 177}, - {0x8017, 177}, - {0xc028, 177}, - {0x8002, 179}, - {0x8009, 179}, - {0x8017, 179}, - {0xc028, 179}, - {0x8002, 209}, - {0x8009, 209}, - {0x8017, 209}, - {0xc028, 209}, + {0x02, 2, 176}, + {0x09, 2, 176}, + {0x17, 2, 176}, + {0x28, 3, 176}, + {0x02, 2, 177}, + {0x09, 2, 177}, + {0x17, 2, 177}, + {0x28, 3, 177}, + {0x02, 2, 179}, + {0x09, 2, 179}, + {0x17, 2, 179}, + {0x28, 3, 179}, + {0x02, 2, 209}, + {0x09, 2, 209}, + {0x17, 2, 209}, + {0x28, 3, 209}, }, /* 114 */ { - {0x8003, 176}, - {0x8006, 176}, - {0x800a, 176}, - {0x800f, 176}, - {0x8018, 176}, - {0x801f, 176}, - {0x8029, 176}, - {0xc038, 176}, - {0x8003, 177}, - {0x8006, 177}, - {0x800a, 177}, - {0x800f, 177}, - {0x8018, 177}, - {0x801f, 177}, - {0x8029, 177}, - {0xc038, 177}, + {0x03, 2, 176}, + {0x06, 2, 176}, + {0x0a, 2, 176}, + {0x0f, 2, 176}, + {0x18, 2, 176}, + {0x1f, 2, 176}, + {0x29, 2, 176}, + {0x38, 3, 176}, + {0x03, 2, 177}, + {0x06, 2, 177}, + {0x0a, 2, 177}, + {0x0f, 2, 177}, + {0x18, 2, 177}, + {0x1f, 2, 177}, + {0x29, 2, 177}, + {0x38, 3, 177}, }, /* 115 */ { - {0x8003, 179}, - {0x8006, 179}, - {0x800a, 179}, - {0x800f, 179}, - {0x8018, 179}, - {0x801f, 179}, - {0x8029, 179}, - {0xc038, 179}, - {0x8003, 209}, - {0x8006, 209}, - {0x800a, 209}, - {0x800f, 209}, - {0x8018, 209}, - {0x801f, 209}, - {0x8029, 209}, - {0xc038, 209}, + {0x03, 2, 179}, + {0x06, 2, 179}, + {0x0a, 2, 179}, + {0x0f, 2, 179}, + {0x18, 2, 179}, + {0x1f, 2, 179}, + {0x29, 2, 179}, + {0x38, 3, 179}, + {0x03, 2, 209}, + {0x06, 2, 209}, + {0x0a, 2, 209}, + {0x0f, 2, 209}, + {0x18, 2, 209}, + {0x1f, 2, 209}, + {0x29, 2, 209}, + {0x38, 3, 209}, }, /* 116 */ { - {0x8002, 216}, - {0x8009, 216}, - {0x8017, 216}, - {0xc028, 216}, - {0x8002, 217}, - {0x8009, 217}, - {0x8017, 217}, - {0xc028, 217}, - {0x8002, 227}, - {0x8009, 227}, - {0x8017, 227}, - {0xc028, 227}, - {0x8002, 229}, - {0x8009, 229}, - {0x8017, 229}, - {0xc028, 229}, + {0x02, 2, 216}, + {0x09, 2, 216}, + {0x17, 2, 216}, + {0x28, 3, 216}, + {0x02, 2, 217}, + {0x09, 2, 217}, + {0x17, 2, 217}, + {0x28, 3, 217}, + {0x02, 2, 227}, + {0x09, 2, 227}, + {0x17, 2, 227}, + {0x28, 3, 227}, + {0x02, 2, 229}, + {0x09, 2, 229}, + {0x17, 2, 229}, + {0x28, 3, 229}, }, /* 117 */ { - {0x8003, 216}, - {0x8006, 216}, - {0x800a, 216}, - {0x800f, 216}, - {0x8018, 216}, - {0x801f, 216}, - {0x8029, 216}, - {0xc038, 216}, - {0x8003, 217}, - {0x8006, 217}, - {0x800a, 217}, - {0x800f, 217}, - {0x8018, 217}, - {0x801f, 217}, - {0x8029, 217}, - {0xc038, 217}, + {0x03, 2, 216}, + {0x06, 2, 216}, + {0x0a, 2, 216}, + {0x0f, 2, 216}, + {0x18, 2, 216}, + {0x1f, 2, 216}, + {0x29, 2, 216}, + {0x38, 3, 216}, + {0x03, 2, 217}, + {0x06, 2, 217}, + {0x0a, 2, 217}, + {0x0f, 2, 217}, + {0x18, 2, 217}, + {0x1f, 2, 217}, + {0x29, 2, 217}, + {0x38, 3, 217}, }, /* 118 */ { - {0x8003, 227}, - {0x8006, 227}, - {0x800a, 227}, - {0x800f, 227}, - {0x8018, 227}, - {0x801f, 227}, - {0x8029, 227}, - {0xc038, 227}, - {0x8003, 229}, - {0x8006, 229}, - {0x800a, 229}, - {0x800f, 229}, - {0x8018, 229}, - {0x801f, 229}, - {0x8029, 229}, - {0xc038, 229}, + {0x03, 2, 227}, + {0x06, 2, 227}, + {0x0a, 2, 227}, + {0x0f, 2, 227}, + {0x18, 2, 227}, + {0x1f, 2, 227}, + {0x29, 2, 227}, + {0x38, 3, 227}, + {0x03, 2, 229}, + {0x06, 2, 229}, + {0x0a, 2, 229}, + {0x0f, 2, 229}, + {0x18, 2, 229}, + {0x1f, 2, 229}, + {0x29, 2, 229}, + {0x38, 3, 229}, }, /* 119 */ { - {0x8001, 230}, - {0xc016, 230}, - {0xc000, 129}, - {0xc000, 132}, - {0xc000, 133}, - {0xc000, 134}, - {0xc000, 136}, - {0xc000, 146}, - {0xc000, 154}, - {0xc000, 156}, - {0xc000, 160}, - {0xc000, 163}, - {0xc000, 164}, - {0xc000, 169}, - {0xc000, 170}, - {0xc000, 173}, + {0x01, 2, 230}, + {0x16, 3, 230}, + {0x00, 3, 129}, + {0x00, 3, 132}, + {0x00, 3, 133}, + {0x00, 3, 134}, + {0x00, 3, 136}, + {0x00, 3, 146}, + {0x00, 3, 154}, + {0x00, 3, 156}, + {0x00, 3, 160}, + {0x00, 3, 163}, + {0x00, 3, 164}, + {0x00, 3, 169}, + {0x00, 3, 170}, + {0x00, 3, 173}, }, /* 120 */ { - {0x8002, 230}, - {0x8009, 230}, - {0x8017, 230}, - {0xc028, 230}, - {0x8001, 129}, - {0xc016, 129}, - {0x8001, 132}, - {0xc016, 132}, - {0x8001, 133}, - {0xc016, 133}, - {0x8001, 134}, - {0xc016, 134}, - {0x8001, 136}, - {0xc016, 136}, - {0x8001, 146}, - {0xc016, 146}, + {0x02, 2, 230}, + {0x09, 2, 230}, + {0x17, 2, 230}, + {0x28, 3, 230}, + {0x01, 2, 129}, + {0x16, 3, 129}, + {0x01, 2, 132}, + {0x16, 3, 132}, + {0x01, 2, 133}, + {0x16, 3, 133}, + {0x01, 2, 134}, + {0x16, 3, 134}, + {0x01, 2, 136}, + {0x16, 3, 136}, + {0x01, 2, 146}, + {0x16, 3, 146}, }, /* 121 */ { - {0x8003, 230}, - {0x8006, 230}, - {0x800a, 230}, - {0x800f, 230}, - {0x8018, 230}, - {0x801f, 230}, - {0x8029, 230}, - {0xc038, 230}, - {0x8002, 129}, - {0x8009, 129}, - {0x8017, 129}, - {0xc028, 129}, - {0x8002, 132}, - {0x8009, 132}, - {0x8017, 132}, - {0xc028, 132}, + {0x03, 2, 230}, + {0x06, 2, 230}, + {0x0a, 2, 230}, + {0x0f, 2, 230}, + {0x18, 2, 230}, + {0x1f, 2, 230}, + {0x29, 2, 230}, + {0x38, 3, 230}, + {0x02, 2, 129}, + {0x09, 2, 129}, + {0x17, 2, 129}, + {0x28, 3, 129}, + {0x02, 2, 132}, + {0x09, 2, 132}, + {0x17, 2, 132}, + {0x28, 3, 132}, }, /* 122 */ { - {0x8003, 129}, - {0x8006, 129}, - {0x800a, 129}, - {0x800f, 129}, - {0x8018, 129}, - {0x801f, 129}, - {0x8029, 129}, - {0xc038, 129}, - {0x8003, 132}, - {0x8006, 132}, - {0x800a, 132}, - {0x800f, 132}, - {0x8018, 132}, - {0x801f, 132}, - {0x8029, 132}, - {0xc038, 132}, + {0x03, 2, 129}, + {0x06, 2, 129}, + {0x0a, 2, 129}, + {0x0f, 2, 129}, + {0x18, 2, 129}, + {0x1f, 2, 129}, + {0x29, 2, 129}, + {0x38, 3, 129}, + {0x03, 2, 132}, + {0x06, 2, 132}, + {0x0a, 2, 132}, + {0x0f, 2, 132}, + {0x18, 2, 132}, + {0x1f, 2, 132}, + {0x29, 2, 132}, + {0x38, 3, 132}, }, /* 123 */ { - {0x8002, 133}, - {0x8009, 133}, - {0x8017, 133}, - {0xc028, 133}, - {0x8002, 134}, - {0x8009, 134}, - {0x8017, 134}, - {0xc028, 134}, - {0x8002, 136}, - {0x8009, 136}, - {0x8017, 136}, - {0xc028, 136}, - {0x8002, 146}, - {0x8009, 146}, - {0x8017, 146}, - {0xc028, 146}, + {0x02, 2, 133}, + {0x09, 2, 133}, + {0x17, 2, 133}, + {0x28, 3, 133}, + {0x02, 2, 134}, + {0x09, 2, 134}, + {0x17, 2, 134}, + {0x28, 3, 134}, + {0x02, 2, 136}, + {0x09, 2, 136}, + {0x17, 2, 136}, + {0x28, 3, 136}, + {0x02, 2, 146}, + {0x09, 2, 146}, + {0x17, 2, 146}, + {0x28, 3, 146}, }, /* 124 */ { - {0x8003, 133}, - {0x8006, 133}, - {0x800a, 133}, - {0x800f, 133}, - {0x8018, 133}, - {0x801f, 133}, - {0x8029, 133}, - {0xc038, 133}, - {0x8003, 134}, - {0x8006, 134}, - {0x800a, 134}, - {0x800f, 134}, - {0x8018, 134}, - {0x801f, 134}, - {0x8029, 134}, - {0xc038, 134}, + {0x03, 2, 133}, + {0x06, 2, 133}, + {0x0a, 2, 133}, + {0x0f, 2, 133}, + {0x18, 2, 133}, + {0x1f, 2, 133}, + {0x29, 2, 133}, + {0x38, 3, 133}, + {0x03, 2, 134}, + {0x06, 2, 134}, + {0x0a, 2, 134}, + {0x0f, 2, 134}, + {0x18, 2, 134}, + {0x1f, 2, 134}, + {0x29, 2, 134}, + {0x38, 3, 134}, }, /* 125 */ { - {0x8003, 136}, - {0x8006, 136}, - {0x800a, 136}, - {0x800f, 136}, - {0x8018, 136}, - {0x801f, 136}, - {0x8029, 136}, - {0xc038, 136}, - {0x8003, 146}, - {0x8006, 146}, - {0x800a, 146}, - {0x800f, 146}, - {0x8018, 146}, - {0x801f, 146}, - {0x8029, 146}, - {0xc038, 146}, + {0x03, 2, 136}, + {0x06, 2, 136}, + {0x0a, 2, 136}, + {0x0f, 2, 136}, + {0x18, 2, 136}, + {0x1f, 2, 136}, + {0x29, 2, 136}, + {0x38, 3, 136}, + {0x03, 2, 146}, + {0x06, 2, 146}, + {0x0a, 2, 146}, + {0x0f, 2, 146}, + {0x18, 2, 146}, + {0x1f, 2, 146}, + {0x29, 2, 146}, + {0x38, 3, 146}, }, /* 126 */ { - {0x8001, 154}, - {0xc016, 154}, - {0x8001, 156}, - {0xc016, 156}, - {0x8001, 160}, - {0xc016, 160}, - {0x8001, 163}, - {0xc016, 163}, - {0x8001, 164}, - {0xc016, 164}, - {0x8001, 169}, - {0xc016, 169}, - {0x8001, 170}, - {0xc016, 170}, - {0x8001, 173}, - {0xc016, 173}, + {0x01, 2, 154}, + {0x16, 3, 154}, + {0x01, 2, 156}, + {0x16, 3, 156}, + {0x01, 2, 160}, + {0x16, 3, 160}, + {0x01, 2, 163}, + {0x16, 3, 163}, + {0x01, 2, 164}, + {0x16, 3, 164}, + {0x01, 2, 169}, + {0x16, 3, 169}, + {0x01, 2, 170}, + {0x16, 3, 170}, + {0x01, 2, 173}, + {0x16, 3, 173}, }, /* 127 */ { - {0x8002, 154}, - {0x8009, 154}, - {0x8017, 154}, - {0xc028, 154}, - {0x8002, 156}, - {0x8009, 156}, - {0x8017, 156}, - {0xc028, 156}, - {0x8002, 160}, - {0x8009, 160}, - {0x8017, 160}, - {0xc028, 160}, - {0x8002, 163}, - {0x8009, 163}, - {0x8017, 163}, - {0xc028, 163}, + {0x02, 2, 154}, + {0x09, 2, 154}, + {0x17, 2, 154}, + {0x28, 3, 154}, + {0x02, 2, 156}, + {0x09, 2, 156}, + {0x17, 2, 156}, + {0x28, 3, 156}, + {0x02, 2, 160}, + {0x09, 2, 160}, + {0x17, 2, 160}, + {0x28, 3, 160}, + {0x02, 2, 163}, + {0x09, 2, 163}, + {0x17, 2, 163}, + {0x28, 3, 163}, }, /* 128 */ { - {0x8003, 154}, - {0x8006, 154}, - {0x800a, 154}, - {0x800f, 154}, - {0x8018, 154}, - {0x801f, 154}, - {0x8029, 154}, - {0xc038, 154}, - {0x8003, 156}, - {0x8006, 156}, - {0x800a, 156}, - {0x800f, 156}, - {0x8018, 156}, - {0x801f, 156}, - {0x8029, 156}, - {0xc038, 156}, + {0x03, 2, 154}, + {0x06, 2, 154}, + {0x0a, 2, 154}, + {0x0f, 2, 154}, + {0x18, 2, 154}, + {0x1f, 2, 154}, + {0x29, 2, 154}, + {0x38, 3, 154}, + {0x03, 2, 156}, + {0x06, 2, 156}, + {0x0a, 2, 156}, + {0x0f, 2, 156}, + {0x18, 2, 156}, + {0x1f, 2, 156}, + {0x29, 2, 156}, + {0x38, 3, 156}, }, /* 129 */ { - {0x8003, 160}, - {0x8006, 160}, - {0x800a, 160}, - {0x800f, 160}, - {0x8018, 160}, - {0x801f, 160}, - {0x8029, 160}, - {0xc038, 160}, - {0x8003, 163}, - {0x8006, 163}, - {0x800a, 163}, - {0x800f, 163}, - {0x8018, 163}, - {0x801f, 163}, - {0x8029, 163}, - {0xc038, 163}, + {0x03, 2, 160}, + {0x06, 2, 160}, + {0x0a, 2, 160}, + {0x0f, 2, 160}, + {0x18, 2, 160}, + {0x1f, 2, 160}, + {0x29, 2, 160}, + {0x38, 3, 160}, + {0x03, 2, 163}, + {0x06, 2, 163}, + {0x0a, 2, 163}, + {0x0f, 2, 163}, + {0x18, 2, 163}, + {0x1f, 2, 163}, + {0x29, 2, 163}, + {0x38, 3, 163}, }, /* 130 */ { - {0x8002, 164}, - {0x8009, 164}, - {0x8017, 164}, - {0xc028, 164}, - {0x8002, 169}, - {0x8009, 169}, - {0x8017, 169}, - {0xc028, 169}, - {0x8002, 170}, - {0x8009, 170}, - {0x8017, 170}, - {0xc028, 170}, - {0x8002, 173}, - {0x8009, 173}, - {0x8017, 173}, - {0xc028, 173}, + {0x02, 2, 164}, + {0x09, 2, 164}, + {0x17, 2, 164}, + {0x28, 3, 164}, + {0x02, 2, 169}, + {0x09, 2, 169}, + {0x17, 2, 169}, + {0x28, 3, 169}, + {0x02, 2, 170}, + {0x09, 2, 170}, + {0x17, 2, 170}, + {0x28, 3, 170}, + {0x02, 2, 173}, + {0x09, 2, 173}, + {0x17, 2, 173}, + {0x28, 3, 173}, }, /* 131 */ { - {0x8003, 164}, - {0x8006, 164}, - {0x800a, 164}, - {0x800f, 164}, - {0x8018, 164}, - {0x801f, 164}, - {0x8029, 164}, - {0xc038, 164}, - {0x8003, 169}, - {0x8006, 169}, - {0x800a, 169}, - {0x800f, 169}, - {0x8018, 169}, - {0x801f, 169}, - {0x8029, 169}, - {0xc038, 169}, + {0x03, 2, 164}, + {0x06, 2, 164}, + {0x0a, 2, 164}, + {0x0f, 2, 164}, + {0x18, 2, 164}, + {0x1f, 2, 164}, + {0x29, 2, 164}, + {0x38, 3, 164}, + {0x03, 2, 169}, + {0x06, 2, 169}, + {0x0a, 2, 169}, + {0x0f, 2, 169}, + {0x18, 2, 169}, + {0x1f, 2, 169}, + {0x29, 2, 169}, + {0x38, 3, 169}, }, /* 132 */ { - {0x8003, 170}, - {0x8006, 170}, - {0x800a, 170}, - {0x800f, 170}, - {0x8018, 170}, - {0x801f, 170}, - {0x8029, 170}, - {0xc038, 170}, - {0x8003, 173}, - {0x8006, 173}, - {0x800a, 173}, - {0x800f, 173}, - {0x8018, 173}, - {0x801f, 173}, - {0x8029, 173}, - {0xc038, 173}, + {0x03, 2, 170}, + {0x06, 2, 170}, + {0x0a, 2, 170}, + {0x0f, 2, 170}, + {0x18, 2, 170}, + {0x1f, 2, 170}, + {0x29, 2, 170}, + {0x38, 3, 170}, + {0x03, 2, 173}, + {0x06, 2, 173}, + {0x0a, 2, 173}, + {0x0f, 2, 173}, + {0x18, 2, 173}, + {0x1f, 2, 173}, + {0x29, 2, 173}, + {0x38, 3, 173}, }, /* 133 */ { - {0x89, 0}, - {0x8a, 0}, - {0x8c, 0}, - {0x8d, 0}, - {0x90, 0}, - {0x91, 0}, - {0x93, 0}, - {0x96, 0}, - {0x9c, 0}, - {0x9f, 0}, - {0xa3, 0}, - {0xa6, 0}, - {0xab, 0}, - {0xae, 0}, - {0xb5, 0}, - {0xbe, 0}, + {0x89, 0, 0}, + {0x8a, 0, 0}, + {0x8c, 0, 0}, + {0x8d, 0, 0}, + {0x90, 0, 0}, + {0x91, 0, 0}, + {0x93, 0, 0}, + {0x96, 0, 0}, + {0x9c, 0, 0}, + {0x9f, 0, 0}, + {0xa3, 0, 0}, + {0xa6, 0, 0}, + {0xab, 0, 0}, + {0xae, 0, 0}, + {0xb5, 0, 0}, + {0xbe, 0, 0}, }, /* 134 */ { - {0xc000, 178}, - {0xc000, 181}, - {0xc000, 185}, - {0xc000, 186}, - {0xc000, 187}, - {0xc000, 189}, - {0xc000, 190}, - {0xc000, 196}, - {0xc000, 198}, - {0xc000, 228}, - {0xc000, 232}, - {0xc000, 233}, - {0x94, 0}, - {0x95, 0}, - {0x97, 0}, - {0x98, 0}, + {0x00, 3, 178}, + {0x00, 3, 181}, + {0x00, 3, 185}, + {0x00, 3, 186}, + {0x00, 3, 187}, + {0x00, 3, 189}, + {0x00, 3, 190}, + {0x00, 3, 196}, + {0x00, 3, 198}, + {0x00, 3, 228}, + {0x00, 3, 232}, + {0x00, 3, 233}, + {0x94, 0, 0}, + {0x95, 0, 0}, + {0x97, 0, 0}, + {0x98, 0, 0}, }, /* 135 */ { - {0x8001, 178}, - {0xc016, 178}, - {0x8001, 181}, - {0xc016, 181}, - {0x8001, 185}, - {0xc016, 185}, - {0x8001, 186}, - {0xc016, 186}, - {0x8001, 187}, - {0xc016, 187}, - {0x8001, 189}, - {0xc016, 189}, - {0x8001, 190}, - {0xc016, 190}, - {0x8001, 196}, - {0xc016, 196}, + {0x01, 2, 178}, + {0x16, 3, 178}, + {0x01, 2, 181}, + {0x16, 3, 181}, + {0x01, 2, 185}, + {0x16, 3, 185}, + {0x01, 2, 186}, + {0x16, 3, 186}, + {0x01, 2, 187}, + {0x16, 3, 187}, + {0x01, 2, 189}, + {0x16, 3, 189}, + {0x01, 2, 190}, + {0x16, 3, 190}, + {0x01, 2, 196}, + {0x16, 3, 196}, }, /* 136 */ { - {0x8002, 178}, - {0x8009, 178}, - {0x8017, 178}, - {0xc028, 178}, - {0x8002, 181}, - {0x8009, 181}, - {0x8017, 181}, - {0xc028, 181}, - {0x8002, 185}, - {0x8009, 185}, - {0x8017, 185}, - {0xc028, 185}, - {0x8002, 186}, - {0x8009, 186}, - {0x8017, 186}, - {0xc028, 186}, + {0x02, 2, 178}, + {0x09, 2, 178}, + {0x17, 2, 178}, + {0x28, 3, 178}, + {0x02, 2, 181}, + {0x09, 2, 181}, + {0x17, 2, 181}, + {0x28, 3, 181}, + {0x02, 2, 185}, + {0x09, 2, 185}, + {0x17, 2, 185}, + {0x28, 3, 185}, + {0x02, 2, 186}, + {0x09, 2, 186}, + {0x17, 2, 186}, + {0x28, 3, 186}, }, /* 137 */ { - {0x8003, 178}, - {0x8006, 178}, - {0x800a, 178}, - {0x800f, 178}, - {0x8018, 178}, - {0x801f, 178}, - {0x8029, 178}, - {0xc038, 178}, - {0x8003, 181}, - {0x8006, 181}, - {0x800a, 181}, - {0x800f, 181}, - {0x8018, 181}, - {0x801f, 181}, - {0x8029, 181}, - {0xc038, 181}, + {0x03, 2, 178}, + {0x06, 2, 178}, + {0x0a, 2, 178}, + {0x0f, 2, 178}, + {0x18, 2, 178}, + {0x1f, 2, 178}, + {0x29, 2, 178}, + {0x38, 3, 178}, + {0x03, 2, 181}, + {0x06, 2, 181}, + {0x0a, 2, 181}, + {0x0f, 2, 181}, + {0x18, 2, 181}, + {0x1f, 2, 181}, + {0x29, 2, 181}, + {0x38, 3, 181}, }, /* 138 */ { - {0x8003, 185}, - {0x8006, 185}, - {0x800a, 185}, - {0x800f, 185}, - {0x8018, 185}, - {0x801f, 185}, - {0x8029, 185}, - {0xc038, 185}, - {0x8003, 186}, - {0x8006, 186}, - {0x800a, 186}, - {0x800f, 186}, - {0x8018, 186}, - {0x801f, 186}, - {0x8029, 186}, - {0xc038, 186}, + {0x03, 2, 185}, + {0x06, 2, 185}, + {0x0a, 2, 185}, + {0x0f, 2, 185}, + {0x18, 2, 185}, + {0x1f, 2, 185}, + {0x29, 2, 185}, + {0x38, 3, 185}, + {0x03, 2, 186}, + {0x06, 2, 186}, + {0x0a, 2, 186}, + {0x0f, 2, 186}, + {0x18, 2, 186}, + {0x1f, 2, 186}, + {0x29, 2, 186}, + {0x38, 3, 186}, }, /* 139 */ { - {0x8002, 187}, - {0x8009, 187}, - {0x8017, 187}, - {0xc028, 187}, - {0x8002, 189}, - {0x8009, 189}, - {0x8017, 189}, - {0xc028, 189}, - {0x8002, 190}, - {0x8009, 190}, - {0x8017, 190}, - {0xc028, 190}, - {0x8002, 196}, - {0x8009, 196}, - {0x8017, 196}, - {0xc028, 196}, + {0x02, 2, 187}, + {0x09, 2, 187}, + {0x17, 2, 187}, + {0x28, 3, 187}, + {0x02, 2, 189}, + {0x09, 2, 189}, + {0x17, 2, 189}, + {0x28, 3, 189}, + {0x02, 2, 190}, + {0x09, 2, 190}, + {0x17, 2, 190}, + {0x28, 3, 190}, + {0x02, 2, 196}, + {0x09, 2, 196}, + {0x17, 2, 196}, + {0x28, 3, 196}, }, /* 140 */ { - {0x8003, 187}, - {0x8006, 187}, - {0x800a, 187}, - {0x800f, 187}, - {0x8018, 187}, - {0x801f, 187}, - {0x8029, 187}, - {0xc038, 187}, - {0x8003, 189}, - {0x8006, 189}, - {0x800a, 189}, - {0x800f, 189}, - {0x8018, 189}, - {0x801f, 189}, - {0x8029, 189}, - {0xc038, 189}, + {0x03, 2, 187}, + {0x06, 2, 187}, + {0x0a, 2, 187}, + {0x0f, 2, 187}, + {0x18, 2, 187}, + {0x1f, 2, 187}, + {0x29, 2, 187}, + {0x38, 3, 187}, + {0x03, 2, 189}, + {0x06, 2, 189}, + {0x0a, 2, 189}, + {0x0f, 2, 189}, + {0x18, 2, 189}, + {0x1f, 2, 189}, + {0x29, 2, 189}, + {0x38, 3, 189}, }, /* 141 */ { - {0x8003, 190}, - {0x8006, 190}, - {0x800a, 190}, - {0x800f, 190}, - {0x8018, 190}, - {0x801f, 190}, - {0x8029, 190}, - {0xc038, 190}, - {0x8003, 196}, - {0x8006, 196}, - {0x800a, 196}, - {0x800f, 196}, - {0x8018, 196}, - {0x801f, 196}, - {0x8029, 196}, - {0xc038, 196}, + {0x03, 2, 190}, + {0x06, 2, 190}, + {0x0a, 2, 190}, + {0x0f, 2, 190}, + {0x18, 2, 190}, + {0x1f, 2, 190}, + {0x29, 2, 190}, + {0x38, 3, 190}, + {0x03, 2, 196}, + {0x06, 2, 196}, + {0x0a, 2, 196}, + {0x0f, 2, 196}, + {0x18, 2, 196}, + {0x1f, 2, 196}, + {0x29, 2, 196}, + {0x38, 3, 196}, }, /* 142 */ { - {0x8001, 198}, - {0xc016, 198}, - {0x8001, 228}, - {0xc016, 228}, - {0x8001, 232}, - {0xc016, 232}, - {0x8001, 233}, - {0xc016, 233}, - {0xc000, 1}, - {0xc000, 135}, - {0xc000, 137}, - {0xc000, 138}, - {0xc000, 139}, - {0xc000, 140}, - {0xc000, 141}, - {0xc000, 143}, + {0x01, 2, 198}, + {0x16, 3, 198}, + {0x01, 2, 228}, + {0x16, 3, 228}, + {0x01, 2, 232}, + {0x16, 3, 232}, + {0x01, 2, 233}, + {0x16, 3, 233}, + {0x00, 3, 1}, + {0x00, 3, 135}, + {0x00, 3, 137}, + {0x00, 3, 138}, + {0x00, 3, 139}, + {0x00, 3, 140}, + {0x00, 3, 141}, + {0x00, 3, 143}, }, /* 143 */ { - {0x8002, 198}, - {0x8009, 198}, - {0x8017, 198}, - {0xc028, 198}, - {0x8002, 228}, - {0x8009, 228}, - {0x8017, 228}, - {0xc028, 228}, - {0x8002, 232}, - {0x8009, 232}, - {0x8017, 232}, - {0xc028, 232}, - {0x8002, 233}, - {0x8009, 233}, - {0x8017, 233}, - {0xc028, 233}, + {0x02, 2, 198}, + {0x09, 2, 198}, + {0x17, 2, 198}, + {0x28, 3, 198}, + {0x02, 2, 228}, + {0x09, 2, 228}, + {0x17, 2, 228}, + {0x28, 3, 228}, + {0x02, 2, 232}, + {0x09, 2, 232}, + {0x17, 2, 232}, + {0x28, 3, 232}, + {0x02, 2, 233}, + {0x09, 2, 233}, + {0x17, 2, 233}, + {0x28, 3, 233}, }, /* 144 */ { - {0x8003, 198}, - {0x8006, 198}, - {0x800a, 198}, - {0x800f, 198}, - {0x8018, 198}, - {0x801f, 198}, - {0x8029, 198}, - {0xc038, 198}, - {0x8003, 228}, - {0x8006, 228}, - {0x800a, 228}, - {0x800f, 228}, - {0x8018, 228}, - {0x801f, 228}, - {0x8029, 228}, - {0xc038, 228}, + {0x03, 2, 198}, + {0x06, 2, 198}, + {0x0a, 2, 198}, + {0x0f, 2, 198}, + {0x18, 2, 198}, + {0x1f, 2, 198}, + {0x29, 2, 198}, + {0x38, 3, 198}, + {0x03, 2, 228}, + {0x06, 2, 228}, + {0x0a, 2, 228}, + {0x0f, 2, 228}, + {0x18, 2, 228}, + {0x1f, 2, 228}, + {0x29, 2, 228}, + {0x38, 3, 228}, }, /* 145 */ { - {0x8003, 232}, - {0x8006, 232}, - {0x800a, 232}, - {0x800f, 232}, - {0x8018, 232}, - {0x801f, 232}, - {0x8029, 232}, - {0xc038, 232}, - {0x8003, 233}, - {0x8006, 233}, - {0x800a, 233}, - {0x800f, 233}, - {0x8018, 233}, - {0x801f, 233}, - {0x8029, 233}, - {0xc038, 233}, + {0x03, 2, 232}, + {0x06, 2, 232}, + {0x0a, 2, 232}, + {0x0f, 2, 232}, + {0x18, 2, 232}, + {0x1f, 2, 232}, + {0x29, 2, 232}, + {0x38, 3, 232}, + {0x03, 2, 233}, + {0x06, 2, 233}, + {0x0a, 2, 233}, + {0x0f, 2, 233}, + {0x18, 2, 233}, + {0x1f, 2, 233}, + {0x29, 2, 233}, + {0x38, 3, 233}, }, /* 146 */ { - {0x8001, 1}, - {0xc016, 1}, - {0x8001, 135}, - {0xc016, 135}, - {0x8001, 137}, - {0xc016, 137}, - {0x8001, 138}, - {0xc016, 138}, - {0x8001, 139}, - {0xc016, 139}, - {0x8001, 140}, - {0xc016, 140}, - {0x8001, 141}, - {0xc016, 141}, - {0x8001, 143}, - {0xc016, 143}, + {0x01, 2, 1}, + {0x16, 3, 1}, + {0x01, 2, 135}, + {0x16, 3, 135}, + {0x01, 2, 137}, + {0x16, 3, 137}, + {0x01, 2, 138}, + {0x16, 3, 138}, + {0x01, 2, 139}, + {0x16, 3, 139}, + {0x01, 2, 140}, + {0x16, 3, 140}, + {0x01, 2, 141}, + {0x16, 3, 141}, + {0x01, 2, 143}, + {0x16, 3, 143}, }, /* 147 */ { - {0x8002, 1}, - {0x8009, 1}, - {0x8017, 1}, - {0xc028, 1}, - {0x8002, 135}, - {0x8009, 135}, - {0x8017, 135}, - {0xc028, 135}, - {0x8002, 137}, - {0x8009, 137}, - {0x8017, 137}, - {0xc028, 137}, - {0x8002, 138}, - {0x8009, 138}, - {0x8017, 138}, - {0xc028, 138}, + {0x02, 2, 1}, + {0x09, 2, 1}, + {0x17, 2, 1}, + {0x28, 3, 1}, + {0x02, 2, 135}, + {0x09, 2, 135}, + {0x17, 2, 135}, + {0x28, 3, 135}, + {0x02, 2, 137}, + {0x09, 2, 137}, + {0x17, 2, 137}, + {0x28, 3, 137}, + {0x02, 2, 138}, + {0x09, 2, 138}, + {0x17, 2, 138}, + {0x28, 3, 138}, }, /* 148 */ { - {0x8003, 1}, - {0x8006, 1}, - {0x800a, 1}, - {0x800f, 1}, - {0x8018, 1}, - {0x801f, 1}, - {0x8029, 1}, - {0xc038, 1}, - {0x8003, 135}, - {0x8006, 135}, - {0x800a, 135}, - {0x800f, 135}, - {0x8018, 135}, - {0x801f, 135}, - {0x8029, 135}, - {0xc038, 135}, + {0x03, 2, 1}, + {0x06, 2, 1}, + {0x0a, 2, 1}, + {0x0f, 2, 1}, + {0x18, 2, 1}, + {0x1f, 2, 1}, + {0x29, 2, 1}, + {0x38, 3, 1}, + {0x03, 2, 135}, + {0x06, 2, 135}, + {0x0a, 2, 135}, + {0x0f, 2, 135}, + {0x18, 2, 135}, + {0x1f, 2, 135}, + {0x29, 2, 135}, + {0x38, 3, 135}, }, /* 149 */ { - {0x8003, 137}, - {0x8006, 137}, - {0x800a, 137}, - {0x800f, 137}, - {0x8018, 137}, - {0x801f, 137}, - {0x8029, 137}, - {0xc038, 137}, - {0x8003, 138}, - {0x8006, 138}, - {0x800a, 138}, - {0x800f, 138}, - {0x8018, 138}, - {0x801f, 138}, - {0x8029, 138}, - {0xc038, 138}, + {0x03, 2, 137}, + {0x06, 2, 137}, + {0x0a, 2, 137}, + {0x0f, 2, 137}, + {0x18, 2, 137}, + {0x1f, 2, 137}, + {0x29, 2, 137}, + {0x38, 3, 137}, + {0x03, 2, 138}, + {0x06, 2, 138}, + {0x0a, 2, 138}, + {0x0f, 2, 138}, + {0x18, 2, 138}, + {0x1f, 2, 138}, + {0x29, 2, 138}, + {0x38, 3, 138}, }, /* 150 */ { - {0x8002, 139}, - {0x8009, 139}, - {0x8017, 139}, - {0xc028, 139}, - {0x8002, 140}, - {0x8009, 140}, - {0x8017, 140}, - {0xc028, 140}, - {0x8002, 141}, - {0x8009, 141}, - {0x8017, 141}, - {0xc028, 141}, - {0x8002, 143}, - {0x8009, 143}, - {0x8017, 143}, - {0xc028, 143}, + {0x02, 2, 139}, + {0x09, 2, 139}, + {0x17, 2, 139}, + {0x28, 3, 139}, + {0x02, 2, 140}, + {0x09, 2, 140}, + {0x17, 2, 140}, + {0x28, 3, 140}, + {0x02, 2, 141}, + {0x09, 2, 141}, + {0x17, 2, 141}, + {0x28, 3, 141}, + {0x02, 2, 143}, + {0x09, 2, 143}, + {0x17, 2, 143}, + {0x28, 3, 143}, }, /* 151 */ { - {0x8003, 139}, - {0x8006, 139}, - {0x800a, 139}, - {0x800f, 139}, - {0x8018, 139}, - {0x801f, 139}, - {0x8029, 139}, - {0xc038, 139}, - {0x8003, 140}, - {0x8006, 140}, - {0x800a, 140}, - {0x800f, 140}, - {0x8018, 140}, - {0x801f, 140}, - {0x8029, 140}, - {0xc038, 140}, + {0x03, 2, 139}, + {0x06, 2, 139}, + {0x0a, 2, 139}, + {0x0f, 2, 139}, + {0x18, 2, 139}, + {0x1f, 2, 139}, + {0x29, 2, 139}, + {0x38, 3, 139}, + {0x03, 2, 140}, + {0x06, 2, 140}, + {0x0a, 2, 140}, + {0x0f, 2, 140}, + {0x18, 2, 140}, + {0x1f, 2, 140}, + {0x29, 2, 140}, + {0x38, 3, 140}, }, /* 152 */ { - {0x8003, 141}, - {0x8006, 141}, - {0x800a, 141}, - {0x800f, 141}, - {0x8018, 141}, - {0x801f, 141}, - {0x8029, 141}, - {0xc038, 141}, - {0x8003, 143}, - {0x8006, 143}, - {0x800a, 143}, - {0x800f, 143}, - {0x8018, 143}, - {0x801f, 143}, - {0x8029, 143}, - {0xc038, 143}, + {0x03, 2, 141}, + {0x06, 2, 141}, + {0x0a, 2, 141}, + {0x0f, 2, 141}, + {0x18, 2, 141}, + {0x1f, 2, 141}, + {0x29, 2, 141}, + {0x38, 3, 141}, + {0x03, 2, 143}, + {0x06, 2, 143}, + {0x0a, 2, 143}, + {0x0f, 2, 143}, + {0x18, 2, 143}, + {0x1f, 2, 143}, + {0x29, 2, 143}, + {0x38, 3, 143}, }, /* 153 */ { - {0x9d, 0}, - {0x9e, 0}, - {0xa0, 0}, - {0xa1, 0}, - {0xa4, 0}, - {0xa5, 0}, - {0xa7, 0}, - {0xa8, 0}, - {0xac, 0}, - {0xad, 0}, - {0xaf, 0}, - {0xb1, 0}, - {0xb6, 0}, - {0xb9, 0}, - {0xbf, 0}, - {0xcf, 0}, + {0x9d, 0, 0}, + {0x9e, 0, 0}, + {0xa0, 0, 0}, + {0xa1, 0, 0}, + {0xa4, 0, 0}, + {0xa5, 0, 0}, + {0xa7, 0, 0}, + {0xa8, 0, 0}, + {0xac, 0, 0}, + {0xad, 0, 0}, + {0xaf, 0, 0}, + {0xb1, 0, 0}, + {0xb6, 0, 0}, + {0xb9, 0, 0}, + {0xbf, 0, 0}, + {0xcf, 0, 0}, }, /* 154 */ { - {0xc000, 147}, - {0xc000, 149}, - {0xc000, 150}, - {0xc000, 151}, - {0xc000, 152}, - {0xc000, 155}, - {0xc000, 157}, - {0xc000, 158}, - {0xc000, 165}, - {0xc000, 166}, - {0xc000, 168}, - {0xc000, 174}, - {0xc000, 175}, - {0xc000, 180}, - {0xc000, 182}, - {0xc000, 183}, + {0x00, 3, 147}, + {0x00, 3, 149}, + {0x00, 3, 150}, + {0x00, 3, 151}, + {0x00, 3, 152}, + {0x00, 3, 155}, + {0x00, 3, 157}, + {0x00, 3, 158}, + {0x00, 3, 165}, + {0x00, 3, 166}, + {0x00, 3, 168}, + {0x00, 3, 174}, + {0x00, 3, 175}, + {0x00, 3, 180}, + {0x00, 3, 182}, + {0x00, 3, 183}, }, /* 155 */ { - {0x8001, 147}, - {0xc016, 147}, - {0x8001, 149}, - {0xc016, 149}, - {0x8001, 150}, - {0xc016, 150}, - {0x8001, 151}, - {0xc016, 151}, - {0x8001, 152}, - {0xc016, 152}, - {0x8001, 155}, - {0xc016, 155}, - {0x8001, 157}, - {0xc016, 157}, - {0x8001, 158}, - {0xc016, 158}, + {0x01, 2, 147}, + {0x16, 3, 147}, + {0x01, 2, 149}, + {0x16, 3, 149}, + {0x01, 2, 150}, + {0x16, 3, 150}, + {0x01, 2, 151}, + {0x16, 3, 151}, + {0x01, 2, 152}, + {0x16, 3, 152}, + {0x01, 2, 155}, + {0x16, 3, 155}, + {0x01, 2, 157}, + {0x16, 3, 157}, + {0x01, 2, 158}, + {0x16, 3, 158}, }, /* 156 */ { - {0x8002, 147}, - {0x8009, 147}, - {0x8017, 147}, - {0xc028, 147}, - {0x8002, 149}, - {0x8009, 149}, - {0x8017, 149}, - {0xc028, 149}, - {0x8002, 150}, - {0x8009, 150}, - {0x8017, 150}, - {0xc028, 150}, - {0x8002, 151}, - {0x8009, 151}, - {0x8017, 151}, - {0xc028, 151}, + {0x02, 2, 147}, + {0x09, 2, 147}, + {0x17, 2, 147}, + {0x28, 3, 147}, + {0x02, 2, 149}, + {0x09, 2, 149}, + {0x17, 2, 149}, + {0x28, 3, 149}, + {0x02, 2, 150}, + {0x09, 2, 150}, + {0x17, 2, 150}, + {0x28, 3, 150}, + {0x02, 2, 151}, + {0x09, 2, 151}, + {0x17, 2, 151}, + {0x28, 3, 151}, }, /* 157 */ { - {0x8003, 147}, - {0x8006, 147}, - {0x800a, 147}, - {0x800f, 147}, - {0x8018, 147}, - {0x801f, 147}, - {0x8029, 147}, - {0xc038, 147}, - {0x8003, 149}, - {0x8006, 149}, - {0x800a, 149}, - {0x800f, 149}, - {0x8018, 149}, - {0x801f, 149}, - {0x8029, 149}, - {0xc038, 149}, + {0x03, 2, 147}, + {0x06, 2, 147}, + {0x0a, 2, 147}, + {0x0f, 2, 147}, + {0x18, 2, 147}, + {0x1f, 2, 147}, + {0x29, 2, 147}, + {0x38, 3, 147}, + {0x03, 2, 149}, + {0x06, 2, 149}, + {0x0a, 2, 149}, + {0x0f, 2, 149}, + {0x18, 2, 149}, + {0x1f, 2, 149}, + {0x29, 2, 149}, + {0x38, 3, 149}, }, /* 158 */ { - {0x8003, 150}, - {0x8006, 150}, - {0x800a, 150}, - {0x800f, 150}, - {0x8018, 150}, - {0x801f, 150}, - {0x8029, 150}, - {0xc038, 150}, - {0x8003, 151}, - {0x8006, 151}, - {0x800a, 151}, - {0x800f, 151}, - {0x8018, 151}, - {0x801f, 151}, - {0x8029, 151}, - {0xc038, 151}, + {0x03, 2, 150}, + {0x06, 2, 150}, + {0x0a, 2, 150}, + {0x0f, 2, 150}, + {0x18, 2, 150}, + {0x1f, 2, 150}, + {0x29, 2, 150}, + {0x38, 3, 150}, + {0x03, 2, 151}, + {0x06, 2, 151}, + {0x0a, 2, 151}, + {0x0f, 2, 151}, + {0x18, 2, 151}, + {0x1f, 2, 151}, + {0x29, 2, 151}, + {0x38, 3, 151}, }, /* 159 */ { - {0x8002, 152}, - {0x8009, 152}, - {0x8017, 152}, - {0xc028, 152}, - {0x8002, 155}, - {0x8009, 155}, - {0x8017, 155}, - {0xc028, 155}, - {0x8002, 157}, - {0x8009, 157}, - {0x8017, 157}, - {0xc028, 157}, - {0x8002, 158}, - {0x8009, 158}, - {0x8017, 158}, - {0xc028, 158}, + {0x02, 2, 152}, + {0x09, 2, 152}, + {0x17, 2, 152}, + {0x28, 3, 152}, + {0x02, 2, 155}, + {0x09, 2, 155}, + {0x17, 2, 155}, + {0x28, 3, 155}, + {0x02, 2, 157}, + {0x09, 2, 157}, + {0x17, 2, 157}, + {0x28, 3, 157}, + {0x02, 2, 158}, + {0x09, 2, 158}, + {0x17, 2, 158}, + {0x28, 3, 158}, }, /* 160 */ { - {0x8003, 152}, - {0x8006, 152}, - {0x800a, 152}, - {0x800f, 152}, - {0x8018, 152}, - {0x801f, 152}, - {0x8029, 152}, - {0xc038, 152}, - {0x8003, 155}, - {0x8006, 155}, - {0x800a, 155}, - {0x800f, 155}, - {0x8018, 155}, - {0x801f, 155}, - {0x8029, 155}, - {0xc038, 155}, + {0x03, 2, 152}, + {0x06, 2, 152}, + {0x0a, 2, 152}, + {0x0f, 2, 152}, + {0x18, 2, 152}, + {0x1f, 2, 152}, + {0x29, 2, 152}, + {0x38, 3, 152}, + {0x03, 2, 155}, + {0x06, 2, 155}, + {0x0a, 2, 155}, + {0x0f, 2, 155}, + {0x18, 2, 155}, + {0x1f, 2, 155}, + {0x29, 2, 155}, + {0x38, 3, 155}, }, /* 161 */ { - {0x8003, 157}, - {0x8006, 157}, - {0x800a, 157}, - {0x800f, 157}, - {0x8018, 157}, - {0x801f, 157}, - {0x8029, 157}, - {0xc038, 157}, - {0x8003, 158}, - {0x8006, 158}, - {0x800a, 158}, - {0x800f, 158}, - {0x8018, 158}, - {0x801f, 158}, - {0x8029, 158}, - {0xc038, 158}, + {0x03, 2, 157}, + {0x06, 2, 157}, + {0x0a, 2, 157}, + {0x0f, 2, 157}, + {0x18, 2, 157}, + {0x1f, 2, 157}, + {0x29, 2, 157}, + {0x38, 3, 157}, + {0x03, 2, 158}, + {0x06, 2, 158}, + {0x0a, 2, 158}, + {0x0f, 2, 158}, + {0x18, 2, 158}, + {0x1f, 2, 158}, + {0x29, 2, 158}, + {0x38, 3, 158}, }, /* 162 */ { - {0x8001, 165}, - {0xc016, 165}, - {0x8001, 166}, - {0xc016, 166}, - {0x8001, 168}, - {0xc016, 168}, - {0x8001, 174}, - {0xc016, 174}, - {0x8001, 175}, - {0xc016, 175}, - {0x8001, 180}, - {0xc016, 180}, - {0x8001, 182}, - {0xc016, 182}, - {0x8001, 183}, - {0xc016, 183}, + {0x01, 2, 165}, + {0x16, 3, 165}, + {0x01, 2, 166}, + {0x16, 3, 166}, + {0x01, 2, 168}, + {0x16, 3, 168}, + {0x01, 2, 174}, + {0x16, 3, 174}, + {0x01, 2, 175}, + {0x16, 3, 175}, + {0x01, 2, 180}, + {0x16, 3, 180}, + {0x01, 2, 182}, + {0x16, 3, 182}, + {0x01, 2, 183}, + {0x16, 3, 183}, }, /* 163 */ { - {0x8002, 165}, - {0x8009, 165}, - {0x8017, 165}, - {0xc028, 165}, - {0x8002, 166}, - {0x8009, 166}, - {0x8017, 166}, - {0xc028, 166}, - {0x8002, 168}, - {0x8009, 168}, - {0x8017, 168}, - {0xc028, 168}, - {0x8002, 174}, - {0x8009, 174}, - {0x8017, 174}, - {0xc028, 174}, + {0x02, 2, 165}, + {0x09, 2, 165}, + {0x17, 2, 165}, + {0x28, 3, 165}, + {0x02, 2, 166}, + {0x09, 2, 166}, + {0x17, 2, 166}, + {0x28, 3, 166}, + {0x02, 2, 168}, + {0x09, 2, 168}, + {0x17, 2, 168}, + {0x28, 3, 168}, + {0x02, 2, 174}, + {0x09, 2, 174}, + {0x17, 2, 174}, + {0x28, 3, 174}, }, /* 164 */ { - {0x8003, 165}, - {0x8006, 165}, - {0x800a, 165}, - {0x800f, 165}, - {0x8018, 165}, - {0x801f, 165}, - {0x8029, 165}, - {0xc038, 165}, - {0x8003, 166}, - {0x8006, 166}, - {0x800a, 166}, - {0x800f, 166}, - {0x8018, 166}, - {0x801f, 166}, - {0x8029, 166}, - {0xc038, 166}, + {0x03, 2, 165}, + {0x06, 2, 165}, + {0x0a, 2, 165}, + {0x0f, 2, 165}, + {0x18, 2, 165}, + {0x1f, 2, 165}, + {0x29, 2, 165}, + {0x38, 3, 165}, + {0x03, 2, 166}, + {0x06, 2, 166}, + {0x0a, 2, 166}, + {0x0f, 2, 166}, + {0x18, 2, 166}, + {0x1f, 2, 166}, + {0x29, 2, 166}, + {0x38, 3, 166}, }, /* 165 */ { - {0x8003, 168}, - {0x8006, 168}, - {0x800a, 168}, - {0x800f, 168}, - {0x8018, 168}, - {0x801f, 168}, - {0x8029, 168}, - {0xc038, 168}, - {0x8003, 174}, - {0x8006, 174}, - {0x800a, 174}, - {0x800f, 174}, - {0x8018, 174}, - {0x801f, 174}, - {0x8029, 174}, - {0xc038, 174}, + {0x03, 2, 168}, + {0x06, 2, 168}, + {0x0a, 2, 168}, + {0x0f, 2, 168}, + {0x18, 2, 168}, + {0x1f, 2, 168}, + {0x29, 2, 168}, + {0x38, 3, 168}, + {0x03, 2, 174}, + {0x06, 2, 174}, + {0x0a, 2, 174}, + {0x0f, 2, 174}, + {0x18, 2, 174}, + {0x1f, 2, 174}, + {0x29, 2, 174}, + {0x38, 3, 174}, }, /* 166 */ { - {0x8002, 175}, - {0x8009, 175}, - {0x8017, 175}, - {0xc028, 175}, - {0x8002, 180}, - {0x8009, 180}, - {0x8017, 180}, - {0xc028, 180}, - {0x8002, 182}, - {0x8009, 182}, - {0x8017, 182}, - {0xc028, 182}, - {0x8002, 183}, - {0x8009, 183}, - {0x8017, 183}, - {0xc028, 183}, + {0x02, 2, 175}, + {0x09, 2, 175}, + {0x17, 2, 175}, + {0x28, 3, 175}, + {0x02, 2, 180}, + {0x09, 2, 180}, + {0x17, 2, 180}, + {0x28, 3, 180}, + {0x02, 2, 182}, + {0x09, 2, 182}, + {0x17, 2, 182}, + {0x28, 3, 182}, + {0x02, 2, 183}, + {0x09, 2, 183}, + {0x17, 2, 183}, + {0x28, 3, 183}, }, /* 167 */ { - {0x8003, 175}, - {0x8006, 175}, - {0x800a, 175}, - {0x800f, 175}, - {0x8018, 175}, - {0x801f, 175}, - {0x8029, 175}, - {0xc038, 175}, - {0x8003, 180}, - {0x8006, 180}, - {0x800a, 180}, - {0x800f, 180}, - {0x8018, 180}, - {0x801f, 180}, - {0x8029, 180}, - {0xc038, 180}, + {0x03, 2, 175}, + {0x06, 2, 175}, + {0x0a, 2, 175}, + {0x0f, 2, 175}, + {0x18, 2, 175}, + {0x1f, 2, 175}, + {0x29, 2, 175}, + {0x38, 3, 175}, + {0x03, 2, 180}, + {0x06, 2, 180}, + {0x0a, 2, 180}, + {0x0f, 2, 180}, + {0x18, 2, 180}, + {0x1f, 2, 180}, + {0x29, 2, 180}, + {0x38, 3, 180}, }, /* 168 */ { - {0x8003, 182}, - {0x8006, 182}, - {0x800a, 182}, - {0x800f, 182}, - {0x8018, 182}, - {0x801f, 182}, - {0x8029, 182}, - {0xc038, 182}, - {0x8003, 183}, - {0x8006, 183}, - {0x800a, 183}, - {0x800f, 183}, - {0x8018, 183}, - {0x801f, 183}, - {0x8029, 183}, - {0xc038, 183}, + {0x03, 2, 182}, + {0x06, 2, 182}, + {0x0a, 2, 182}, + {0x0f, 2, 182}, + {0x18, 2, 182}, + {0x1f, 2, 182}, + {0x29, 2, 182}, + {0x38, 3, 182}, + {0x03, 2, 183}, + {0x06, 2, 183}, + {0x0a, 2, 183}, + {0x0f, 2, 183}, + {0x18, 2, 183}, + {0x1f, 2, 183}, + {0x29, 2, 183}, + {0x38, 3, 183}, }, /* 169 */ { - {0xc000, 188}, - {0xc000, 191}, - {0xc000, 197}, - {0xc000, 231}, - {0xc000, 239}, - {0xb0, 0}, - {0xb2, 0}, - {0xb3, 0}, - {0xb7, 0}, - {0xb8, 0}, - {0xba, 0}, - {0xbb, 0}, - {0xc0, 0}, - {0xc7, 0}, - {0xd0, 0}, - {0xdf, 0}, + {0x00, 3, 188}, + {0x00, 3, 191}, + {0x00, 3, 197}, + {0x00, 3, 231}, + {0x00, 3, 239}, + {0xb0, 0, 0}, + {0xb2, 0, 0}, + {0xb3, 0, 0}, + {0xb7, 0, 0}, + {0xb8, 0, 0}, + {0xba, 0, 0}, + {0xbb, 0, 0}, + {0xc0, 0, 0}, + {0xc7, 0, 0}, + {0xd0, 0, 0}, + {0xdf, 0, 0}, }, /* 170 */ { - {0x8001, 188}, - {0xc016, 188}, - {0x8001, 191}, - {0xc016, 191}, - {0x8001, 197}, - {0xc016, 197}, - {0x8001, 231}, - {0xc016, 231}, - {0x8001, 239}, - {0xc016, 239}, - {0xc000, 9}, - {0xc000, 142}, - {0xc000, 144}, - {0xc000, 145}, - {0xc000, 148}, - {0xc000, 159}, + {0x01, 2, 188}, + {0x16, 3, 188}, + {0x01, 2, 191}, + {0x16, 3, 191}, + {0x01, 2, 197}, + {0x16, 3, 197}, + {0x01, 2, 231}, + {0x16, 3, 231}, + {0x01, 2, 239}, + {0x16, 3, 239}, + {0x00, 3, 9}, + {0x00, 3, 142}, + {0x00, 3, 144}, + {0x00, 3, 145}, + {0x00, 3, 148}, + {0x00, 3, 159}, }, /* 171 */ { - {0x8002, 188}, - {0x8009, 188}, - {0x8017, 188}, - {0xc028, 188}, - {0x8002, 191}, - {0x8009, 191}, - {0x8017, 191}, - {0xc028, 191}, - {0x8002, 197}, - {0x8009, 197}, - {0x8017, 197}, - {0xc028, 197}, - {0x8002, 231}, - {0x8009, 231}, - {0x8017, 231}, - {0xc028, 231}, + {0x02, 2, 188}, + {0x09, 2, 188}, + {0x17, 2, 188}, + {0x28, 3, 188}, + {0x02, 2, 191}, + {0x09, 2, 191}, + {0x17, 2, 191}, + {0x28, 3, 191}, + {0x02, 2, 197}, + {0x09, 2, 197}, + {0x17, 2, 197}, + {0x28, 3, 197}, + {0x02, 2, 231}, + {0x09, 2, 231}, + {0x17, 2, 231}, + {0x28, 3, 231}, }, /* 172 */ { - {0x8003, 188}, - {0x8006, 188}, - {0x800a, 188}, - {0x800f, 188}, - {0x8018, 188}, - {0x801f, 188}, - {0x8029, 188}, - {0xc038, 188}, - {0x8003, 191}, - {0x8006, 191}, - {0x800a, 191}, - {0x800f, 191}, - {0x8018, 191}, - {0x801f, 191}, - {0x8029, 191}, - {0xc038, 191}, + {0x03, 2, 188}, + {0x06, 2, 188}, + {0x0a, 2, 188}, + {0x0f, 2, 188}, + {0x18, 2, 188}, + {0x1f, 2, 188}, + {0x29, 2, 188}, + {0x38, 3, 188}, + {0x03, 2, 191}, + {0x06, 2, 191}, + {0x0a, 2, 191}, + {0x0f, 2, 191}, + {0x18, 2, 191}, + {0x1f, 2, 191}, + {0x29, 2, 191}, + {0x38, 3, 191}, }, /* 173 */ { - {0x8003, 197}, - {0x8006, 197}, - {0x800a, 197}, - {0x800f, 197}, - {0x8018, 197}, - {0x801f, 197}, - {0x8029, 197}, - {0xc038, 197}, - {0x8003, 231}, - {0x8006, 231}, - {0x800a, 231}, - {0x800f, 231}, - {0x8018, 231}, - {0x801f, 231}, - {0x8029, 231}, - {0xc038, 231}, + {0x03, 2, 197}, + {0x06, 2, 197}, + {0x0a, 2, 197}, + {0x0f, 2, 197}, + {0x18, 2, 197}, + {0x1f, 2, 197}, + {0x29, 2, 197}, + {0x38, 3, 197}, + {0x03, 2, 231}, + {0x06, 2, 231}, + {0x0a, 2, 231}, + {0x0f, 2, 231}, + {0x18, 2, 231}, + {0x1f, 2, 231}, + {0x29, 2, 231}, + {0x38, 3, 231}, }, /* 174 */ { - {0x8002, 239}, - {0x8009, 239}, - {0x8017, 239}, - {0xc028, 239}, - {0x8001, 9}, - {0xc016, 9}, - {0x8001, 142}, - {0xc016, 142}, - {0x8001, 144}, - {0xc016, 144}, - {0x8001, 145}, - {0xc016, 145}, - {0x8001, 148}, - {0xc016, 148}, - {0x8001, 159}, - {0xc016, 159}, + {0x02, 2, 239}, + {0x09, 2, 239}, + {0x17, 2, 239}, + {0x28, 3, 239}, + {0x01, 2, 9}, + {0x16, 3, 9}, + {0x01, 2, 142}, + {0x16, 3, 142}, + {0x01, 2, 144}, + {0x16, 3, 144}, + {0x01, 2, 145}, + {0x16, 3, 145}, + {0x01, 2, 148}, + {0x16, 3, 148}, + {0x01, 2, 159}, + {0x16, 3, 159}, }, /* 175 */ { - {0x8003, 239}, - {0x8006, 239}, - {0x800a, 239}, - {0x800f, 239}, - {0x8018, 239}, - {0x801f, 239}, - {0x8029, 239}, - {0xc038, 239}, - {0x8002, 9}, - {0x8009, 9}, - {0x8017, 9}, - {0xc028, 9}, - {0x8002, 142}, - {0x8009, 142}, - {0x8017, 142}, - {0xc028, 142}, + {0x03, 2, 239}, + {0x06, 2, 239}, + {0x0a, 2, 239}, + {0x0f, 2, 239}, + {0x18, 2, 239}, + {0x1f, 2, 239}, + {0x29, 2, 239}, + {0x38, 3, 239}, + {0x02, 2, 9}, + {0x09, 2, 9}, + {0x17, 2, 9}, + {0x28, 3, 9}, + {0x02, 2, 142}, + {0x09, 2, 142}, + {0x17, 2, 142}, + {0x28, 3, 142}, }, /* 176 */ { - {0x8003, 9}, - {0x8006, 9}, - {0x800a, 9}, - {0x800f, 9}, - {0x8018, 9}, - {0x801f, 9}, - {0x8029, 9}, - {0xc038, 9}, - {0x8003, 142}, - {0x8006, 142}, - {0x800a, 142}, - {0x800f, 142}, - {0x8018, 142}, - {0x801f, 142}, - {0x8029, 142}, - {0xc038, 142}, + {0x03, 2, 9}, + {0x06, 2, 9}, + {0x0a, 2, 9}, + {0x0f, 2, 9}, + {0x18, 2, 9}, + {0x1f, 2, 9}, + {0x29, 2, 9}, + {0x38, 3, 9}, + {0x03, 2, 142}, + {0x06, 2, 142}, + {0x0a, 2, 142}, + {0x0f, 2, 142}, + {0x18, 2, 142}, + {0x1f, 2, 142}, + {0x29, 2, 142}, + {0x38, 3, 142}, }, /* 177 */ { - {0x8002, 144}, - {0x8009, 144}, - {0x8017, 144}, - {0xc028, 144}, - {0x8002, 145}, - {0x8009, 145}, - {0x8017, 145}, - {0xc028, 145}, - {0x8002, 148}, - {0x8009, 148}, - {0x8017, 148}, - {0xc028, 148}, - {0x8002, 159}, - {0x8009, 159}, - {0x8017, 159}, - {0xc028, 159}, + {0x02, 2, 144}, + {0x09, 2, 144}, + {0x17, 2, 144}, + {0x28, 3, 144}, + {0x02, 2, 145}, + {0x09, 2, 145}, + {0x17, 2, 145}, + {0x28, 3, 145}, + {0x02, 2, 148}, + {0x09, 2, 148}, + {0x17, 2, 148}, + {0x28, 3, 148}, + {0x02, 2, 159}, + {0x09, 2, 159}, + {0x17, 2, 159}, + {0x28, 3, 159}, }, /* 178 */ { - {0x8003, 144}, - {0x8006, 144}, - {0x800a, 144}, - {0x800f, 144}, - {0x8018, 144}, - {0x801f, 144}, - {0x8029, 144}, - {0xc038, 144}, - {0x8003, 145}, - {0x8006, 145}, - {0x800a, 145}, - {0x800f, 145}, - {0x8018, 145}, - {0x801f, 145}, - {0x8029, 145}, - {0xc038, 145}, + {0x03, 2, 144}, + {0x06, 2, 144}, + {0x0a, 2, 144}, + {0x0f, 2, 144}, + {0x18, 2, 144}, + {0x1f, 2, 144}, + {0x29, 2, 144}, + {0x38, 3, 144}, + {0x03, 2, 145}, + {0x06, 2, 145}, + {0x0a, 2, 145}, + {0x0f, 2, 145}, + {0x18, 2, 145}, + {0x1f, 2, 145}, + {0x29, 2, 145}, + {0x38, 3, 145}, }, /* 179 */ { - {0x8003, 148}, - {0x8006, 148}, - {0x800a, 148}, - {0x800f, 148}, - {0x8018, 148}, - {0x801f, 148}, - {0x8029, 148}, - {0xc038, 148}, - {0x8003, 159}, - {0x8006, 159}, - {0x800a, 159}, - {0x800f, 159}, - {0x8018, 159}, - {0x801f, 159}, - {0x8029, 159}, - {0xc038, 159}, + {0x03, 2, 148}, + {0x06, 2, 148}, + {0x0a, 2, 148}, + {0x0f, 2, 148}, + {0x18, 2, 148}, + {0x1f, 2, 148}, + {0x29, 2, 148}, + {0x38, 3, 148}, + {0x03, 2, 159}, + {0x06, 2, 159}, + {0x0a, 2, 159}, + {0x0f, 2, 159}, + {0x18, 2, 159}, + {0x1f, 2, 159}, + {0x29, 2, 159}, + {0x38, 3, 159}, }, /* 180 */ { - {0xc000, 171}, - {0xc000, 206}, - {0xc000, 215}, - {0xc000, 225}, - {0xc000, 236}, - {0xc000, 237}, - {0xbc, 0}, - {0xbd, 0}, - {0xc1, 0}, - {0xc4, 0}, - {0xc8, 0}, - {0xcb, 0}, - {0xd1, 0}, - {0xd8, 0}, - {0xe0, 0}, - {0xee, 0}, + {0x00, 3, 171}, + {0x00, 3, 206}, + {0x00, 3, 215}, + {0x00, 3, 225}, + {0x00, 3, 236}, + {0x00, 3, 237}, + {0xbc, 0, 0}, + {0xbd, 0, 0}, + {0xc1, 0, 0}, + {0xc4, 0, 0}, + {0xc8, 0, 0}, + {0xcb, 0, 0}, + {0xd1, 0, 0}, + {0xd8, 0, 0}, + {0xe0, 0, 0}, + {0xee, 0, 0}, }, /* 181 */ { - {0x8001, 171}, - {0xc016, 171}, - {0x8001, 206}, - {0xc016, 206}, - {0x8001, 215}, - {0xc016, 215}, - {0x8001, 225}, - {0xc016, 225}, - {0x8001, 236}, - {0xc016, 236}, - {0x8001, 237}, - {0xc016, 237}, - {0xc000, 199}, - {0xc000, 207}, - {0xc000, 234}, - {0xc000, 235}, + {0x01, 2, 171}, + {0x16, 3, 171}, + {0x01, 2, 206}, + {0x16, 3, 206}, + {0x01, 2, 215}, + {0x16, 3, 215}, + {0x01, 2, 225}, + {0x16, 3, 225}, + {0x01, 2, 236}, + {0x16, 3, 236}, + {0x01, 2, 237}, + {0x16, 3, 237}, + {0x00, 3, 199}, + {0x00, 3, 207}, + {0x00, 3, 234}, + {0x00, 3, 235}, }, /* 182 */ { - {0x8002, 171}, - {0x8009, 171}, - {0x8017, 171}, - {0xc028, 171}, - {0x8002, 206}, - {0x8009, 206}, - {0x8017, 206}, - {0xc028, 206}, - {0x8002, 215}, - {0x8009, 215}, - {0x8017, 215}, - {0xc028, 215}, - {0x8002, 225}, - {0x8009, 225}, - {0x8017, 225}, - {0xc028, 225}, + {0x02, 2, 171}, + {0x09, 2, 171}, + {0x17, 2, 171}, + {0x28, 3, 171}, + {0x02, 2, 206}, + {0x09, 2, 206}, + {0x17, 2, 206}, + {0x28, 3, 206}, + {0x02, 2, 215}, + {0x09, 2, 215}, + {0x17, 2, 215}, + {0x28, 3, 215}, + {0x02, 2, 225}, + {0x09, 2, 225}, + {0x17, 2, 225}, + {0x28, 3, 225}, }, /* 183 */ { - {0x8003, 171}, - {0x8006, 171}, - {0x800a, 171}, - {0x800f, 171}, - {0x8018, 171}, - {0x801f, 171}, - {0x8029, 171}, - {0xc038, 171}, - {0x8003, 206}, - {0x8006, 206}, - {0x800a, 206}, - {0x800f, 206}, - {0x8018, 206}, - {0x801f, 206}, - {0x8029, 206}, - {0xc038, 206}, + {0x03, 2, 171}, + {0x06, 2, 171}, + {0x0a, 2, 171}, + {0x0f, 2, 171}, + {0x18, 2, 171}, + {0x1f, 2, 171}, + {0x29, 2, 171}, + {0x38, 3, 171}, + {0x03, 2, 206}, + {0x06, 2, 206}, + {0x0a, 2, 206}, + {0x0f, 2, 206}, + {0x18, 2, 206}, + {0x1f, 2, 206}, + {0x29, 2, 206}, + {0x38, 3, 206}, }, /* 184 */ { - {0x8003, 215}, - {0x8006, 215}, - {0x800a, 215}, - {0x800f, 215}, - {0x8018, 215}, - {0x801f, 215}, - {0x8029, 215}, - {0xc038, 215}, - {0x8003, 225}, - {0x8006, 225}, - {0x800a, 225}, - {0x800f, 225}, - {0x8018, 225}, - {0x801f, 225}, - {0x8029, 225}, - {0xc038, 225}, + {0x03, 2, 215}, + {0x06, 2, 215}, + {0x0a, 2, 215}, + {0x0f, 2, 215}, + {0x18, 2, 215}, + {0x1f, 2, 215}, + {0x29, 2, 215}, + {0x38, 3, 215}, + {0x03, 2, 225}, + {0x06, 2, 225}, + {0x0a, 2, 225}, + {0x0f, 2, 225}, + {0x18, 2, 225}, + {0x1f, 2, 225}, + {0x29, 2, 225}, + {0x38, 3, 225}, }, /* 185 */ { - {0x8002, 236}, - {0x8009, 236}, - {0x8017, 236}, - {0xc028, 236}, - {0x8002, 237}, - {0x8009, 237}, - {0x8017, 237}, - {0xc028, 237}, - {0x8001, 199}, - {0xc016, 199}, - {0x8001, 207}, - {0xc016, 207}, - {0x8001, 234}, - {0xc016, 234}, - {0x8001, 235}, - {0xc016, 235}, + {0x02, 2, 236}, + {0x09, 2, 236}, + {0x17, 2, 236}, + {0x28, 3, 236}, + {0x02, 2, 237}, + {0x09, 2, 237}, + {0x17, 2, 237}, + {0x28, 3, 237}, + {0x01, 2, 199}, + {0x16, 3, 199}, + {0x01, 2, 207}, + {0x16, 3, 207}, + {0x01, 2, 234}, + {0x16, 3, 234}, + {0x01, 2, 235}, + {0x16, 3, 235}, }, /* 186 */ { - {0x8003, 236}, - {0x8006, 236}, - {0x800a, 236}, - {0x800f, 236}, - {0x8018, 236}, - {0x801f, 236}, - {0x8029, 236}, - {0xc038, 236}, - {0x8003, 237}, - {0x8006, 237}, - {0x800a, 237}, - {0x800f, 237}, - {0x8018, 237}, - {0x801f, 237}, - {0x8029, 237}, - {0xc038, 237}, + {0x03, 2, 236}, + {0x06, 2, 236}, + {0x0a, 2, 236}, + {0x0f, 2, 236}, + {0x18, 2, 236}, + {0x1f, 2, 236}, + {0x29, 2, 236}, + {0x38, 3, 236}, + {0x03, 2, 237}, + {0x06, 2, 237}, + {0x0a, 2, 237}, + {0x0f, 2, 237}, + {0x18, 2, 237}, + {0x1f, 2, 237}, + {0x29, 2, 237}, + {0x38, 3, 237}, }, /* 187 */ { - {0x8002, 199}, - {0x8009, 199}, - {0x8017, 199}, - {0xc028, 199}, - {0x8002, 207}, - {0x8009, 207}, - {0x8017, 207}, - {0xc028, 207}, - {0x8002, 234}, - {0x8009, 234}, - {0x8017, 234}, - {0xc028, 234}, - {0x8002, 235}, - {0x8009, 235}, - {0x8017, 235}, - {0xc028, 235}, + {0x02, 2, 199}, + {0x09, 2, 199}, + {0x17, 2, 199}, + {0x28, 3, 199}, + {0x02, 2, 207}, + {0x09, 2, 207}, + {0x17, 2, 207}, + {0x28, 3, 207}, + {0x02, 2, 234}, + {0x09, 2, 234}, + {0x17, 2, 234}, + {0x28, 3, 234}, + {0x02, 2, 235}, + {0x09, 2, 235}, + {0x17, 2, 235}, + {0x28, 3, 235}, }, /* 188 */ { - {0x8003, 199}, - {0x8006, 199}, - {0x800a, 199}, - {0x800f, 199}, - {0x8018, 199}, - {0x801f, 199}, - {0x8029, 199}, - {0xc038, 199}, - {0x8003, 207}, - {0x8006, 207}, - {0x800a, 207}, - {0x800f, 207}, - {0x8018, 207}, - {0x801f, 207}, - {0x8029, 207}, - {0xc038, 207}, + {0x03, 2, 199}, + {0x06, 2, 199}, + {0x0a, 2, 199}, + {0x0f, 2, 199}, + {0x18, 2, 199}, + {0x1f, 2, 199}, + {0x29, 2, 199}, + {0x38, 3, 199}, + {0x03, 2, 207}, + {0x06, 2, 207}, + {0x0a, 2, 207}, + {0x0f, 2, 207}, + {0x18, 2, 207}, + {0x1f, 2, 207}, + {0x29, 2, 207}, + {0x38, 3, 207}, }, /* 189 */ { - {0x8003, 234}, - {0x8006, 234}, - {0x800a, 234}, - {0x800f, 234}, - {0x8018, 234}, - {0x801f, 234}, - {0x8029, 234}, - {0xc038, 234}, - {0x8003, 235}, - {0x8006, 235}, - {0x800a, 235}, - {0x800f, 235}, - {0x8018, 235}, - {0x801f, 235}, - {0x8029, 235}, - {0xc038, 235}, + {0x03, 2, 234}, + {0x06, 2, 234}, + {0x0a, 2, 234}, + {0x0f, 2, 234}, + {0x18, 2, 234}, + {0x1f, 2, 234}, + {0x29, 2, 234}, + {0x38, 3, 234}, + {0x03, 2, 235}, + {0x06, 2, 235}, + {0x0a, 2, 235}, + {0x0f, 2, 235}, + {0x18, 2, 235}, + {0x1f, 2, 235}, + {0x29, 2, 235}, + {0x38, 3, 235}, }, /* 190 */ { - {0xc2, 0}, - {0xc3, 0}, - {0xc5, 0}, - {0xc6, 0}, - {0xc9, 0}, - {0xca, 0}, - {0xcc, 0}, - {0xcd, 0}, - {0xd2, 0}, - {0xd5, 0}, - {0xd9, 0}, - {0xdc, 0}, - {0xe1, 0}, - {0xe7, 0}, - {0xef, 0}, - {0xf6, 0}, + {0xc2, 0, 0}, + {0xc3, 0, 0}, + {0xc5, 0, 0}, + {0xc6, 0, 0}, + {0xc9, 0, 0}, + {0xca, 0, 0}, + {0xcc, 0, 0}, + {0xcd, 0, 0}, + {0xd2, 0, 0}, + {0xd5, 0, 0}, + {0xd9, 0, 0}, + {0xdc, 0, 0}, + {0xe1, 0, 0}, + {0xe7, 0, 0}, + {0xef, 0, 0}, + {0xf6, 0, 0}, }, /* 191 */ { - {0xc000, 192}, - {0xc000, 193}, - {0xc000, 200}, - {0xc000, 201}, - {0xc000, 202}, - {0xc000, 205}, - {0xc000, 210}, - {0xc000, 213}, - {0xc000, 218}, - {0xc000, 219}, - {0xc000, 238}, - {0xc000, 240}, - {0xc000, 242}, - {0xc000, 243}, - {0xc000, 255}, - {0xce, 0}, + {0x00, 3, 192}, + {0x00, 3, 193}, + {0x00, 3, 200}, + {0x00, 3, 201}, + {0x00, 3, 202}, + {0x00, 3, 205}, + {0x00, 3, 210}, + {0x00, 3, 213}, + {0x00, 3, 218}, + {0x00, 3, 219}, + {0x00, 3, 238}, + {0x00, 3, 240}, + {0x00, 3, 242}, + {0x00, 3, 243}, + {0x00, 3, 255}, + {0xce, 0, 0}, }, /* 192 */ { - {0x8001, 192}, - {0xc016, 192}, - {0x8001, 193}, - {0xc016, 193}, - {0x8001, 200}, - {0xc016, 200}, - {0x8001, 201}, - {0xc016, 201}, - {0x8001, 202}, - {0xc016, 202}, - {0x8001, 205}, - {0xc016, 205}, - {0x8001, 210}, - {0xc016, 210}, - {0x8001, 213}, - {0xc016, 213}, + {0x01, 2, 192}, + {0x16, 3, 192}, + {0x01, 2, 193}, + {0x16, 3, 193}, + {0x01, 2, 200}, + {0x16, 3, 200}, + {0x01, 2, 201}, + {0x16, 3, 201}, + {0x01, 2, 202}, + {0x16, 3, 202}, + {0x01, 2, 205}, + {0x16, 3, 205}, + {0x01, 2, 210}, + {0x16, 3, 210}, + {0x01, 2, 213}, + {0x16, 3, 213}, }, /* 193 */ { - {0x8002, 192}, - {0x8009, 192}, - {0x8017, 192}, - {0xc028, 192}, - {0x8002, 193}, - {0x8009, 193}, - {0x8017, 193}, - {0xc028, 193}, - {0x8002, 200}, - {0x8009, 200}, - {0x8017, 200}, - {0xc028, 200}, - {0x8002, 201}, - {0x8009, 201}, - {0x8017, 201}, - {0xc028, 201}, + {0x02, 2, 192}, + {0x09, 2, 192}, + {0x17, 2, 192}, + {0x28, 3, 192}, + {0x02, 2, 193}, + {0x09, 2, 193}, + {0x17, 2, 193}, + {0x28, 3, 193}, + {0x02, 2, 200}, + {0x09, 2, 200}, + {0x17, 2, 200}, + {0x28, 3, 200}, + {0x02, 2, 201}, + {0x09, 2, 201}, + {0x17, 2, 201}, + {0x28, 3, 201}, }, /* 194 */ { - {0x8003, 192}, - {0x8006, 192}, - {0x800a, 192}, - {0x800f, 192}, - {0x8018, 192}, - {0x801f, 192}, - {0x8029, 192}, - {0xc038, 192}, - {0x8003, 193}, - {0x8006, 193}, - {0x800a, 193}, - {0x800f, 193}, - {0x8018, 193}, - {0x801f, 193}, - {0x8029, 193}, - {0xc038, 193}, + {0x03, 2, 192}, + {0x06, 2, 192}, + {0x0a, 2, 192}, + {0x0f, 2, 192}, + {0x18, 2, 192}, + {0x1f, 2, 192}, + {0x29, 2, 192}, + {0x38, 3, 192}, + {0x03, 2, 193}, + {0x06, 2, 193}, + {0x0a, 2, 193}, + {0x0f, 2, 193}, + {0x18, 2, 193}, + {0x1f, 2, 193}, + {0x29, 2, 193}, + {0x38, 3, 193}, }, /* 195 */ { - {0x8003, 200}, - {0x8006, 200}, - {0x800a, 200}, - {0x800f, 200}, - {0x8018, 200}, - {0x801f, 200}, - {0x8029, 200}, - {0xc038, 200}, - {0x8003, 201}, - {0x8006, 201}, - {0x800a, 201}, - {0x800f, 201}, - {0x8018, 201}, - {0x801f, 201}, - {0x8029, 201}, - {0xc038, 201}, + {0x03, 2, 200}, + {0x06, 2, 200}, + {0x0a, 2, 200}, + {0x0f, 2, 200}, + {0x18, 2, 200}, + {0x1f, 2, 200}, + {0x29, 2, 200}, + {0x38, 3, 200}, + {0x03, 2, 201}, + {0x06, 2, 201}, + {0x0a, 2, 201}, + {0x0f, 2, 201}, + {0x18, 2, 201}, + {0x1f, 2, 201}, + {0x29, 2, 201}, + {0x38, 3, 201}, }, /* 196 */ { - {0x8002, 202}, - {0x8009, 202}, - {0x8017, 202}, - {0xc028, 202}, - {0x8002, 205}, - {0x8009, 205}, - {0x8017, 205}, - {0xc028, 205}, - {0x8002, 210}, - {0x8009, 210}, - {0x8017, 210}, - {0xc028, 210}, - {0x8002, 213}, - {0x8009, 213}, - {0x8017, 213}, - {0xc028, 213}, + {0x02, 2, 202}, + {0x09, 2, 202}, + {0x17, 2, 202}, + {0x28, 3, 202}, + {0x02, 2, 205}, + {0x09, 2, 205}, + {0x17, 2, 205}, + {0x28, 3, 205}, + {0x02, 2, 210}, + {0x09, 2, 210}, + {0x17, 2, 210}, + {0x28, 3, 210}, + {0x02, 2, 213}, + {0x09, 2, 213}, + {0x17, 2, 213}, + {0x28, 3, 213}, }, /* 197 */ { - {0x8003, 202}, - {0x8006, 202}, - {0x800a, 202}, - {0x800f, 202}, - {0x8018, 202}, - {0x801f, 202}, - {0x8029, 202}, - {0xc038, 202}, - {0x8003, 205}, - {0x8006, 205}, - {0x800a, 205}, - {0x800f, 205}, - {0x8018, 205}, - {0x801f, 205}, - {0x8029, 205}, - {0xc038, 205}, + {0x03, 2, 202}, + {0x06, 2, 202}, + {0x0a, 2, 202}, + {0x0f, 2, 202}, + {0x18, 2, 202}, + {0x1f, 2, 202}, + {0x29, 2, 202}, + {0x38, 3, 202}, + {0x03, 2, 205}, + {0x06, 2, 205}, + {0x0a, 2, 205}, + {0x0f, 2, 205}, + {0x18, 2, 205}, + {0x1f, 2, 205}, + {0x29, 2, 205}, + {0x38, 3, 205}, }, /* 198 */ { - {0x8003, 210}, - {0x8006, 210}, - {0x800a, 210}, - {0x800f, 210}, - {0x8018, 210}, - {0x801f, 210}, - {0x8029, 210}, - {0xc038, 210}, - {0x8003, 213}, - {0x8006, 213}, - {0x800a, 213}, - {0x800f, 213}, - {0x8018, 213}, - {0x801f, 213}, - {0x8029, 213}, - {0xc038, 213}, + {0x03, 2, 210}, + {0x06, 2, 210}, + {0x0a, 2, 210}, + {0x0f, 2, 210}, + {0x18, 2, 210}, + {0x1f, 2, 210}, + {0x29, 2, 210}, + {0x38, 3, 210}, + {0x03, 2, 213}, + {0x06, 2, 213}, + {0x0a, 2, 213}, + {0x0f, 2, 213}, + {0x18, 2, 213}, + {0x1f, 2, 213}, + {0x29, 2, 213}, + {0x38, 3, 213}, }, /* 199 */ { - {0x8001, 218}, - {0xc016, 218}, - {0x8001, 219}, - {0xc016, 219}, - {0x8001, 238}, - {0xc016, 238}, - {0x8001, 240}, - {0xc016, 240}, - {0x8001, 242}, - {0xc016, 242}, - {0x8001, 243}, - {0xc016, 243}, - {0x8001, 255}, - {0xc016, 255}, - {0xc000, 203}, - {0xc000, 204}, + {0x01, 2, 218}, + {0x16, 3, 218}, + {0x01, 2, 219}, + {0x16, 3, 219}, + {0x01, 2, 238}, + {0x16, 3, 238}, + {0x01, 2, 240}, + {0x16, 3, 240}, + {0x01, 2, 242}, + {0x16, 3, 242}, + {0x01, 2, 243}, + {0x16, 3, 243}, + {0x01, 2, 255}, + {0x16, 3, 255}, + {0x00, 3, 203}, + {0x00, 3, 204}, }, /* 200 */ { - {0x8002, 218}, - {0x8009, 218}, - {0x8017, 218}, - {0xc028, 218}, - {0x8002, 219}, - {0x8009, 219}, - {0x8017, 219}, - {0xc028, 219}, - {0x8002, 238}, - {0x8009, 238}, - {0x8017, 238}, - {0xc028, 238}, - {0x8002, 240}, - {0x8009, 240}, - {0x8017, 240}, - {0xc028, 240}, + {0x02, 2, 218}, + {0x09, 2, 218}, + {0x17, 2, 218}, + {0x28, 3, 218}, + {0x02, 2, 219}, + {0x09, 2, 219}, + {0x17, 2, 219}, + {0x28, 3, 219}, + {0x02, 2, 238}, + {0x09, 2, 238}, + {0x17, 2, 238}, + {0x28, 3, 238}, + {0x02, 2, 240}, + {0x09, 2, 240}, + {0x17, 2, 240}, + {0x28, 3, 240}, }, /* 201 */ { - {0x8003, 218}, - {0x8006, 218}, - {0x800a, 218}, - {0x800f, 218}, - {0x8018, 218}, - {0x801f, 218}, - {0x8029, 218}, - {0xc038, 218}, - {0x8003, 219}, - {0x8006, 219}, - {0x800a, 219}, - {0x800f, 219}, - {0x8018, 219}, - {0x801f, 219}, - {0x8029, 219}, - {0xc038, 219}, + {0x03, 2, 218}, + {0x06, 2, 218}, + {0x0a, 2, 218}, + {0x0f, 2, 218}, + {0x18, 2, 218}, + {0x1f, 2, 218}, + {0x29, 2, 218}, + {0x38, 3, 218}, + {0x03, 2, 219}, + {0x06, 2, 219}, + {0x0a, 2, 219}, + {0x0f, 2, 219}, + {0x18, 2, 219}, + {0x1f, 2, 219}, + {0x29, 2, 219}, + {0x38, 3, 219}, }, /* 202 */ { - {0x8003, 238}, - {0x8006, 238}, - {0x800a, 238}, - {0x800f, 238}, - {0x8018, 238}, - {0x801f, 238}, - {0x8029, 238}, - {0xc038, 238}, - {0x8003, 240}, - {0x8006, 240}, - {0x800a, 240}, - {0x800f, 240}, - {0x8018, 240}, - {0x801f, 240}, - {0x8029, 240}, - {0xc038, 240}, + {0x03, 2, 238}, + {0x06, 2, 238}, + {0x0a, 2, 238}, + {0x0f, 2, 238}, + {0x18, 2, 238}, + {0x1f, 2, 238}, + {0x29, 2, 238}, + {0x38, 3, 238}, + {0x03, 2, 240}, + {0x06, 2, 240}, + {0x0a, 2, 240}, + {0x0f, 2, 240}, + {0x18, 2, 240}, + {0x1f, 2, 240}, + {0x29, 2, 240}, + {0x38, 3, 240}, }, /* 203 */ { - {0x8002, 242}, - {0x8009, 242}, - {0x8017, 242}, - {0xc028, 242}, - {0x8002, 243}, - {0x8009, 243}, - {0x8017, 243}, - {0xc028, 243}, - {0x8002, 255}, - {0x8009, 255}, - {0x8017, 255}, - {0xc028, 255}, - {0x8001, 203}, - {0xc016, 203}, - {0x8001, 204}, - {0xc016, 204}, + {0x02, 2, 242}, + {0x09, 2, 242}, + {0x17, 2, 242}, + {0x28, 3, 242}, + {0x02, 2, 243}, + {0x09, 2, 243}, + {0x17, 2, 243}, + {0x28, 3, 243}, + {0x02, 2, 255}, + {0x09, 2, 255}, + {0x17, 2, 255}, + {0x28, 3, 255}, + {0x01, 2, 203}, + {0x16, 3, 203}, + {0x01, 2, 204}, + {0x16, 3, 204}, }, /* 204 */ { - {0x8003, 242}, - {0x8006, 242}, - {0x800a, 242}, - {0x800f, 242}, - {0x8018, 242}, - {0x801f, 242}, - {0x8029, 242}, - {0xc038, 242}, - {0x8003, 243}, - {0x8006, 243}, - {0x800a, 243}, - {0x800f, 243}, - {0x8018, 243}, - {0x801f, 243}, - {0x8029, 243}, - {0xc038, 243}, + {0x03, 2, 242}, + {0x06, 2, 242}, + {0x0a, 2, 242}, + {0x0f, 2, 242}, + {0x18, 2, 242}, + {0x1f, 2, 242}, + {0x29, 2, 242}, + {0x38, 3, 242}, + {0x03, 2, 243}, + {0x06, 2, 243}, + {0x0a, 2, 243}, + {0x0f, 2, 243}, + {0x18, 2, 243}, + {0x1f, 2, 243}, + {0x29, 2, 243}, + {0x38, 3, 243}, }, /* 205 */ { - {0x8003, 255}, - {0x8006, 255}, - {0x800a, 255}, - {0x800f, 255}, - {0x8018, 255}, - {0x801f, 255}, - {0x8029, 255}, - {0xc038, 255}, - {0x8002, 203}, - {0x8009, 203}, - {0x8017, 203}, - {0xc028, 203}, - {0x8002, 204}, - {0x8009, 204}, - {0x8017, 204}, - {0xc028, 204}, + {0x03, 2, 255}, + {0x06, 2, 255}, + {0x0a, 2, 255}, + {0x0f, 2, 255}, + {0x18, 2, 255}, + {0x1f, 2, 255}, + {0x29, 2, 255}, + {0x38, 3, 255}, + {0x02, 2, 203}, + {0x09, 2, 203}, + {0x17, 2, 203}, + {0x28, 3, 203}, + {0x02, 2, 204}, + {0x09, 2, 204}, + {0x17, 2, 204}, + {0x28, 3, 204}, }, /* 206 */ { - {0x8003, 203}, - {0x8006, 203}, - {0x800a, 203}, - {0x800f, 203}, - {0x8018, 203}, - {0x801f, 203}, - {0x8029, 203}, - {0xc038, 203}, - {0x8003, 204}, - {0x8006, 204}, - {0x800a, 204}, - {0x800f, 204}, - {0x8018, 204}, - {0x801f, 204}, - {0x8029, 204}, - {0xc038, 204}, + {0x03, 2, 203}, + {0x06, 2, 203}, + {0x0a, 2, 203}, + {0x0f, 2, 203}, + {0x18, 2, 203}, + {0x1f, 2, 203}, + {0x29, 2, 203}, + {0x38, 3, 203}, + {0x03, 2, 204}, + {0x06, 2, 204}, + {0x0a, 2, 204}, + {0x0f, 2, 204}, + {0x18, 2, 204}, + {0x1f, 2, 204}, + {0x29, 2, 204}, + {0x38, 3, 204}, }, /* 207 */ { - {0xd3, 0}, - {0xd4, 0}, - {0xd6, 0}, - {0xd7, 0}, - {0xda, 0}, - {0xdb, 0}, - {0xdd, 0}, - {0xde, 0}, - {0xe2, 0}, - {0xe4, 0}, - {0xe8, 0}, - {0xeb, 0}, - {0xf0, 0}, - {0xf3, 0}, - {0xf7, 0}, - {0xfa, 0}, + {0xd3, 0, 0}, + {0xd4, 0, 0}, + {0xd6, 0, 0}, + {0xd7, 0, 0}, + {0xda, 0, 0}, + {0xdb, 0, 0}, + {0xdd, 0, 0}, + {0xde, 0, 0}, + {0xe2, 0, 0}, + {0xe4, 0, 0}, + {0xe8, 0, 0}, + {0xeb, 0, 0}, + {0xf0, 0, 0}, + {0xf3, 0, 0}, + {0xf7, 0, 0}, + {0xfa, 0, 0}, }, /* 208 */ { - {0xc000, 211}, - {0xc000, 212}, - {0xc000, 214}, - {0xc000, 221}, - {0xc000, 222}, - {0xc000, 223}, - {0xc000, 241}, - {0xc000, 244}, - {0xc000, 245}, - {0xc000, 246}, - {0xc000, 247}, - {0xc000, 248}, - {0xc000, 250}, - {0xc000, 251}, - {0xc000, 252}, - {0xc000, 253}, + {0x00, 3, 211}, + {0x00, 3, 212}, + {0x00, 3, 214}, + {0x00, 3, 221}, + {0x00, 3, 222}, + {0x00, 3, 223}, + {0x00, 3, 241}, + {0x00, 3, 244}, + {0x00, 3, 245}, + {0x00, 3, 246}, + {0x00, 3, 247}, + {0x00, 3, 248}, + {0x00, 3, 250}, + {0x00, 3, 251}, + {0x00, 3, 252}, + {0x00, 3, 253}, }, /* 209 */ { - {0x8001, 211}, - {0xc016, 211}, - {0x8001, 212}, - {0xc016, 212}, - {0x8001, 214}, - {0xc016, 214}, - {0x8001, 221}, - {0xc016, 221}, - {0x8001, 222}, - {0xc016, 222}, - {0x8001, 223}, - {0xc016, 223}, - {0x8001, 241}, - {0xc016, 241}, - {0x8001, 244}, - {0xc016, 244}, + {0x01, 2, 211}, + {0x16, 3, 211}, + {0x01, 2, 212}, + {0x16, 3, 212}, + {0x01, 2, 214}, + {0x16, 3, 214}, + {0x01, 2, 221}, + {0x16, 3, 221}, + {0x01, 2, 222}, + {0x16, 3, 222}, + {0x01, 2, 223}, + {0x16, 3, 223}, + {0x01, 2, 241}, + {0x16, 3, 241}, + {0x01, 2, 244}, + {0x16, 3, 244}, }, /* 210 */ { - {0x8002, 211}, - {0x8009, 211}, - {0x8017, 211}, - {0xc028, 211}, - {0x8002, 212}, - {0x8009, 212}, - {0x8017, 212}, - {0xc028, 212}, - {0x8002, 214}, - {0x8009, 214}, - {0x8017, 214}, - {0xc028, 214}, - {0x8002, 221}, - {0x8009, 221}, - {0x8017, 221}, - {0xc028, 221}, + {0x02, 2, 211}, + {0x09, 2, 211}, + {0x17, 2, 211}, + {0x28, 3, 211}, + {0x02, 2, 212}, + {0x09, 2, 212}, + {0x17, 2, 212}, + {0x28, 3, 212}, + {0x02, 2, 214}, + {0x09, 2, 214}, + {0x17, 2, 214}, + {0x28, 3, 214}, + {0x02, 2, 221}, + {0x09, 2, 221}, + {0x17, 2, 221}, + {0x28, 3, 221}, }, /* 211 */ { - {0x8003, 211}, - {0x8006, 211}, - {0x800a, 211}, - {0x800f, 211}, - {0x8018, 211}, - {0x801f, 211}, - {0x8029, 211}, - {0xc038, 211}, - {0x8003, 212}, - {0x8006, 212}, - {0x800a, 212}, - {0x800f, 212}, - {0x8018, 212}, - {0x801f, 212}, - {0x8029, 212}, - {0xc038, 212}, + {0x03, 2, 211}, + {0x06, 2, 211}, + {0x0a, 2, 211}, + {0x0f, 2, 211}, + {0x18, 2, 211}, + {0x1f, 2, 211}, + {0x29, 2, 211}, + {0x38, 3, 211}, + {0x03, 2, 212}, + {0x06, 2, 212}, + {0x0a, 2, 212}, + {0x0f, 2, 212}, + {0x18, 2, 212}, + {0x1f, 2, 212}, + {0x29, 2, 212}, + {0x38, 3, 212}, }, /* 212 */ { - {0x8003, 214}, - {0x8006, 214}, - {0x800a, 214}, - {0x800f, 214}, - {0x8018, 214}, - {0x801f, 214}, - {0x8029, 214}, - {0xc038, 214}, - {0x8003, 221}, - {0x8006, 221}, - {0x800a, 221}, - {0x800f, 221}, - {0x8018, 221}, - {0x801f, 221}, - {0x8029, 221}, - {0xc038, 221}, + {0x03, 2, 214}, + {0x06, 2, 214}, + {0x0a, 2, 214}, + {0x0f, 2, 214}, + {0x18, 2, 214}, + {0x1f, 2, 214}, + {0x29, 2, 214}, + {0x38, 3, 214}, + {0x03, 2, 221}, + {0x06, 2, 221}, + {0x0a, 2, 221}, + {0x0f, 2, 221}, + {0x18, 2, 221}, + {0x1f, 2, 221}, + {0x29, 2, 221}, + {0x38, 3, 221}, }, /* 213 */ { - {0x8002, 222}, - {0x8009, 222}, - {0x8017, 222}, - {0xc028, 222}, - {0x8002, 223}, - {0x8009, 223}, - {0x8017, 223}, - {0xc028, 223}, - {0x8002, 241}, - {0x8009, 241}, - {0x8017, 241}, - {0xc028, 241}, - {0x8002, 244}, - {0x8009, 244}, - {0x8017, 244}, - {0xc028, 244}, + {0x02, 2, 222}, + {0x09, 2, 222}, + {0x17, 2, 222}, + {0x28, 3, 222}, + {0x02, 2, 223}, + {0x09, 2, 223}, + {0x17, 2, 223}, + {0x28, 3, 223}, + {0x02, 2, 241}, + {0x09, 2, 241}, + {0x17, 2, 241}, + {0x28, 3, 241}, + {0x02, 2, 244}, + {0x09, 2, 244}, + {0x17, 2, 244}, + {0x28, 3, 244}, }, /* 214 */ { - {0x8003, 222}, - {0x8006, 222}, - {0x800a, 222}, - {0x800f, 222}, - {0x8018, 222}, - {0x801f, 222}, - {0x8029, 222}, - {0xc038, 222}, - {0x8003, 223}, - {0x8006, 223}, - {0x800a, 223}, - {0x800f, 223}, - {0x8018, 223}, - {0x801f, 223}, - {0x8029, 223}, - {0xc038, 223}, + {0x03, 2, 222}, + {0x06, 2, 222}, + {0x0a, 2, 222}, + {0x0f, 2, 222}, + {0x18, 2, 222}, + {0x1f, 2, 222}, + {0x29, 2, 222}, + {0x38, 3, 222}, + {0x03, 2, 223}, + {0x06, 2, 223}, + {0x0a, 2, 223}, + {0x0f, 2, 223}, + {0x18, 2, 223}, + {0x1f, 2, 223}, + {0x29, 2, 223}, + {0x38, 3, 223}, }, /* 215 */ { - {0x8003, 241}, - {0x8006, 241}, - {0x800a, 241}, - {0x800f, 241}, - {0x8018, 241}, - {0x801f, 241}, - {0x8029, 241}, - {0xc038, 241}, - {0x8003, 244}, - {0x8006, 244}, - {0x800a, 244}, - {0x800f, 244}, - {0x8018, 244}, - {0x801f, 244}, - {0x8029, 244}, - {0xc038, 244}, + {0x03, 2, 241}, + {0x06, 2, 241}, + {0x0a, 2, 241}, + {0x0f, 2, 241}, + {0x18, 2, 241}, + {0x1f, 2, 241}, + {0x29, 2, 241}, + {0x38, 3, 241}, + {0x03, 2, 244}, + {0x06, 2, 244}, + {0x0a, 2, 244}, + {0x0f, 2, 244}, + {0x18, 2, 244}, + {0x1f, 2, 244}, + {0x29, 2, 244}, + {0x38, 3, 244}, }, /* 216 */ { - {0x8001, 245}, - {0xc016, 245}, - {0x8001, 246}, - {0xc016, 246}, - {0x8001, 247}, - {0xc016, 247}, - {0x8001, 248}, - {0xc016, 248}, - {0x8001, 250}, - {0xc016, 250}, - {0x8001, 251}, - {0xc016, 251}, - {0x8001, 252}, - {0xc016, 252}, - {0x8001, 253}, - {0xc016, 253}, + {0x01, 2, 245}, + {0x16, 3, 245}, + {0x01, 2, 246}, + {0x16, 3, 246}, + {0x01, 2, 247}, + {0x16, 3, 247}, + {0x01, 2, 248}, + {0x16, 3, 248}, + {0x01, 2, 250}, + {0x16, 3, 250}, + {0x01, 2, 251}, + {0x16, 3, 251}, + {0x01, 2, 252}, + {0x16, 3, 252}, + {0x01, 2, 253}, + {0x16, 3, 253}, }, /* 217 */ { - {0x8002, 245}, - {0x8009, 245}, - {0x8017, 245}, - {0xc028, 245}, - {0x8002, 246}, - {0x8009, 246}, - {0x8017, 246}, - {0xc028, 246}, - {0x8002, 247}, - {0x8009, 247}, - {0x8017, 247}, - {0xc028, 247}, - {0x8002, 248}, - {0x8009, 248}, - {0x8017, 248}, - {0xc028, 248}, + {0x02, 2, 245}, + {0x09, 2, 245}, + {0x17, 2, 245}, + {0x28, 3, 245}, + {0x02, 2, 246}, + {0x09, 2, 246}, + {0x17, 2, 246}, + {0x28, 3, 246}, + {0x02, 2, 247}, + {0x09, 2, 247}, + {0x17, 2, 247}, + {0x28, 3, 247}, + {0x02, 2, 248}, + {0x09, 2, 248}, + {0x17, 2, 248}, + {0x28, 3, 248}, }, /* 218 */ { - {0x8003, 245}, - {0x8006, 245}, - {0x800a, 245}, - {0x800f, 245}, - {0x8018, 245}, - {0x801f, 245}, - {0x8029, 245}, - {0xc038, 245}, - {0x8003, 246}, - {0x8006, 246}, - {0x800a, 246}, - {0x800f, 246}, - {0x8018, 246}, - {0x801f, 246}, - {0x8029, 246}, - {0xc038, 246}, + {0x03, 2, 245}, + {0x06, 2, 245}, + {0x0a, 2, 245}, + {0x0f, 2, 245}, + {0x18, 2, 245}, + {0x1f, 2, 245}, + {0x29, 2, 245}, + {0x38, 3, 245}, + {0x03, 2, 246}, + {0x06, 2, 246}, + {0x0a, 2, 246}, + {0x0f, 2, 246}, + {0x18, 2, 246}, + {0x1f, 2, 246}, + {0x29, 2, 246}, + {0x38, 3, 246}, }, /* 219 */ { - {0x8003, 247}, - {0x8006, 247}, - {0x800a, 247}, - {0x800f, 247}, - {0x8018, 247}, - {0x801f, 247}, - {0x8029, 247}, - {0xc038, 247}, - {0x8003, 248}, - {0x8006, 248}, - {0x800a, 248}, - {0x800f, 248}, - {0x8018, 248}, - {0x801f, 248}, - {0x8029, 248}, - {0xc038, 248}, + {0x03, 2, 247}, + {0x06, 2, 247}, + {0x0a, 2, 247}, + {0x0f, 2, 247}, + {0x18, 2, 247}, + {0x1f, 2, 247}, + {0x29, 2, 247}, + {0x38, 3, 247}, + {0x03, 2, 248}, + {0x06, 2, 248}, + {0x0a, 2, 248}, + {0x0f, 2, 248}, + {0x18, 2, 248}, + {0x1f, 2, 248}, + {0x29, 2, 248}, + {0x38, 3, 248}, }, /* 220 */ { - {0x8002, 250}, - {0x8009, 250}, - {0x8017, 250}, - {0xc028, 250}, - {0x8002, 251}, - {0x8009, 251}, - {0x8017, 251}, - {0xc028, 251}, - {0x8002, 252}, - {0x8009, 252}, - {0x8017, 252}, - {0xc028, 252}, - {0x8002, 253}, - {0x8009, 253}, - {0x8017, 253}, - {0xc028, 253}, + {0x02, 2, 250}, + {0x09, 2, 250}, + {0x17, 2, 250}, + {0x28, 3, 250}, + {0x02, 2, 251}, + {0x09, 2, 251}, + {0x17, 2, 251}, + {0x28, 3, 251}, + {0x02, 2, 252}, + {0x09, 2, 252}, + {0x17, 2, 252}, + {0x28, 3, 252}, + {0x02, 2, 253}, + {0x09, 2, 253}, + {0x17, 2, 253}, + {0x28, 3, 253}, }, /* 221 */ { - {0x8003, 250}, - {0x8006, 250}, - {0x800a, 250}, - {0x800f, 250}, - {0x8018, 250}, - {0x801f, 250}, - {0x8029, 250}, - {0xc038, 250}, - {0x8003, 251}, - {0x8006, 251}, - {0x800a, 251}, - {0x800f, 251}, - {0x8018, 251}, - {0x801f, 251}, - {0x8029, 251}, - {0xc038, 251}, + {0x03, 2, 250}, + {0x06, 2, 250}, + {0x0a, 2, 250}, + {0x0f, 2, 250}, + {0x18, 2, 250}, + {0x1f, 2, 250}, + {0x29, 2, 250}, + {0x38, 3, 250}, + {0x03, 2, 251}, + {0x06, 2, 251}, + {0x0a, 2, 251}, + {0x0f, 2, 251}, + {0x18, 2, 251}, + {0x1f, 2, 251}, + {0x29, 2, 251}, + {0x38, 3, 251}, }, /* 222 */ { - {0x8003, 252}, - {0x8006, 252}, - {0x800a, 252}, - {0x800f, 252}, - {0x8018, 252}, - {0x801f, 252}, - {0x8029, 252}, - {0xc038, 252}, - {0x8003, 253}, - {0x8006, 253}, - {0x800a, 253}, - {0x800f, 253}, - {0x8018, 253}, - {0x801f, 253}, - {0x8029, 253}, - {0xc038, 253}, + {0x03, 2, 252}, + {0x06, 2, 252}, + {0x0a, 2, 252}, + {0x0f, 2, 252}, + {0x18, 2, 252}, + {0x1f, 2, 252}, + {0x29, 2, 252}, + {0x38, 3, 252}, + {0x03, 2, 253}, + {0x06, 2, 253}, + {0x0a, 2, 253}, + {0x0f, 2, 253}, + {0x18, 2, 253}, + {0x1f, 2, 253}, + {0x29, 2, 253}, + {0x38, 3, 253}, }, /* 223 */ { - {0xc000, 254}, - {0xe3, 0}, - {0xe5, 0}, - {0xe6, 0}, - {0xe9, 0}, - {0xea, 0}, - {0xec, 0}, - {0xed, 0}, - {0xf1, 0}, - {0xf2, 0}, - {0xf4, 0}, - {0xf5, 0}, - {0xf8, 0}, - {0xf9, 0}, - {0xfb, 0}, - {0xfc, 0}, + {0x00, 3, 254}, + {0xe3, 0, 0}, + {0xe5, 0, 0}, + {0xe6, 0, 0}, + {0xe9, 0, 0}, + {0xea, 0, 0}, + {0xec, 0, 0}, + {0xed, 0, 0}, + {0xf1, 0, 0}, + {0xf2, 0, 0}, + {0xf4, 0, 0}, + {0xf5, 0, 0}, + {0xf8, 0, 0}, + {0xf9, 0, 0}, + {0xfb, 0, 0}, + {0xfc, 0, 0}, }, /* 224 */ { - {0x8001, 254}, - {0xc016, 254}, - {0xc000, 2}, - {0xc000, 3}, - {0xc000, 4}, - {0xc000, 5}, - {0xc000, 6}, - {0xc000, 7}, - {0xc000, 8}, - {0xc000, 11}, - {0xc000, 12}, - {0xc000, 14}, - {0xc000, 15}, - {0xc000, 16}, - {0xc000, 17}, - {0xc000, 18}, + {0x01, 2, 254}, + {0x16, 3, 254}, + {0x00, 3, 2}, + {0x00, 3, 3}, + {0x00, 3, 4}, + {0x00, 3, 5}, + {0x00, 3, 6}, + {0x00, 3, 7}, + {0x00, 3, 8}, + {0x00, 3, 11}, + {0x00, 3, 12}, + {0x00, 3, 14}, + {0x00, 3, 15}, + {0x00, 3, 16}, + {0x00, 3, 17}, + {0x00, 3, 18}, }, /* 225 */ { - {0x8002, 254}, - {0x8009, 254}, - {0x8017, 254}, - {0xc028, 254}, - {0x8001, 2}, - {0xc016, 2}, - {0x8001, 3}, - {0xc016, 3}, - {0x8001, 4}, - {0xc016, 4}, - {0x8001, 5}, - {0xc016, 5}, - {0x8001, 6}, - {0xc016, 6}, - {0x8001, 7}, - {0xc016, 7}, + {0x02, 2, 254}, + {0x09, 2, 254}, + {0x17, 2, 254}, + {0x28, 3, 254}, + {0x01, 2, 2}, + {0x16, 3, 2}, + {0x01, 2, 3}, + {0x16, 3, 3}, + {0x01, 2, 4}, + {0x16, 3, 4}, + {0x01, 2, 5}, + {0x16, 3, 5}, + {0x01, 2, 6}, + {0x16, 3, 6}, + {0x01, 2, 7}, + {0x16, 3, 7}, }, /* 226 */ { - {0x8003, 254}, - {0x8006, 254}, - {0x800a, 254}, - {0x800f, 254}, - {0x8018, 254}, - {0x801f, 254}, - {0x8029, 254}, - {0xc038, 254}, - {0x8002, 2}, - {0x8009, 2}, - {0x8017, 2}, - {0xc028, 2}, - {0x8002, 3}, - {0x8009, 3}, - {0x8017, 3}, - {0xc028, 3}, + {0x03, 2, 254}, + {0x06, 2, 254}, + {0x0a, 2, 254}, + {0x0f, 2, 254}, + {0x18, 2, 254}, + {0x1f, 2, 254}, + {0x29, 2, 254}, + {0x38, 3, 254}, + {0x02, 2, 2}, + {0x09, 2, 2}, + {0x17, 2, 2}, + {0x28, 3, 2}, + {0x02, 2, 3}, + {0x09, 2, 3}, + {0x17, 2, 3}, + {0x28, 3, 3}, }, /* 227 */ { - {0x8003, 2}, - {0x8006, 2}, - {0x800a, 2}, - {0x800f, 2}, - {0x8018, 2}, - {0x801f, 2}, - {0x8029, 2}, - {0xc038, 2}, - {0x8003, 3}, - {0x8006, 3}, - {0x800a, 3}, - {0x800f, 3}, - {0x8018, 3}, - {0x801f, 3}, - {0x8029, 3}, - {0xc038, 3}, + {0x03, 2, 2}, + {0x06, 2, 2}, + {0x0a, 2, 2}, + {0x0f, 2, 2}, + {0x18, 2, 2}, + {0x1f, 2, 2}, + {0x29, 2, 2}, + {0x38, 3, 2}, + {0x03, 2, 3}, + {0x06, 2, 3}, + {0x0a, 2, 3}, + {0x0f, 2, 3}, + {0x18, 2, 3}, + {0x1f, 2, 3}, + {0x29, 2, 3}, + {0x38, 3, 3}, }, /* 228 */ { - {0x8002, 4}, - {0x8009, 4}, - {0x8017, 4}, - {0xc028, 4}, - {0x8002, 5}, - {0x8009, 5}, - {0x8017, 5}, - {0xc028, 5}, - {0x8002, 6}, - {0x8009, 6}, - {0x8017, 6}, - {0xc028, 6}, - {0x8002, 7}, - {0x8009, 7}, - {0x8017, 7}, - {0xc028, 7}, + {0x02, 2, 4}, + {0x09, 2, 4}, + {0x17, 2, 4}, + {0x28, 3, 4}, + {0x02, 2, 5}, + {0x09, 2, 5}, + {0x17, 2, 5}, + {0x28, 3, 5}, + {0x02, 2, 6}, + {0x09, 2, 6}, + {0x17, 2, 6}, + {0x28, 3, 6}, + {0x02, 2, 7}, + {0x09, 2, 7}, + {0x17, 2, 7}, + {0x28, 3, 7}, }, /* 229 */ { - {0x8003, 4}, - {0x8006, 4}, - {0x800a, 4}, - {0x800f, 4}, - {0x8018, 4}, - {0x801f, 4}, - {0x8029, 4}, - {0xc038, 4}, - {0x8003, 5}, - {0x8006, 5}, - {0x800a, 5}, - {0x800f, 5}, - {0x8018, 5}, - {0x801f, 5}, - {0x8029, 5}, - {0xc038, 5}, + {0x03, 2, 4}, + {0x06, 2, 4}, + {0x0a, 2, 4}, + {0x0f, 2, 4}, + {0x18, 2, 4}, + {0x1f, 2, 4}, + {0x29, 2, 4}, + {0x38, 3, 4}, + {0x03, 2, 5}, + {0x06, 2, 5}, + {0x0a, 2, 5}, + {0x0f, 2, 5}, + {0x18, 2, 5}, + {0x1f, 2, 5}, + {0x29, 2, 5}, + {0x38, 3, 5}, }, /* 230 */ { - {0x8003, 6}, - {0x8006, 6}, - {0x800a, 6}, - {0x800f, 6}, - {0x8018, 6}, - {0x801f, 6}, - {0x8029, 6}, - {0xc038, 6}, - {0x8003, 7}, - {0x8006, 7}, - {0x800a, 7}, - {0x800f, 7}, - {0x8018, 7}, - {0x801f, 7}, - {0x8029, 7}, - {0xc038, 7}, + {0x03, 2, 6}, + {0x06, 2, 6}, + {0x0a, 2, 6}, + {0x0f, 2, 6}, + {0x18, 2, 6}, + {0x1f, 2, 6}, + {0x29, 2, 6}, + {0x38, 3, 6}, + {0x03, 2, 7}, + {0x06, 2, 7}, + {0x0a, 2, 7}, + {0x0f, 2, 7}, + {0x18, 2, 7}, + {0x1f, 2, 7}, + {0x29, 2, 7}, + {0x38, 3, 7}, }, /* 231 */ { - {0x8001, 8}, - {0xc016, 8}, - {0x8001, 11}, - {0xc016, 11}, - {0x8001, 12}, - {0xc016, 12}, - {0x8001, 14}, - {0xc016, 14}, - {0x8001, 15}, - {0xc016, 15}, - {0x8001, 16}, - {0xc016, 16}, - {0x8001, 17}, - {0xc016, 17}, - {0x8001, 18}, - {0xc016, 18}, + {0x01, 2, 8}, + {0x16, 3, 8}, + {0x01, 2, 11}, + {0x16, 3, 11}, + {0x01, 2, 12}, + {0x16, 3, 12}, + {0x01, 2, 14}, + {0x16, 3, 14}, + {0x01, 2, 15}, + {0x16, 3, 15}, + {0x01, 2, 16}, + {0x16, 3, 16}, + {0x01, 2, 17}, + {0x16, 3, 17}, + {0x01, 2, 18}, + {0x16, 3, 18}, }, /* 232 */ { - {0x8002, 8}, - {0x8009, 8}, - {0x8017, 8}, - {0xc028, 8}, - {0x8002, 11}, - {0x8009, 11}, - {0x8017, 11}, - {0xc028, 11}, - {0x8002, 12}, - {0x8009, 12}, - {0x8017, 12}, - {0xc028, 12}, - {0x8002, 14}, - {0x8009, 14}, - {0x8017, 14}, - {0xc028, 14}, + {0x02, 2, 8}, + {0x09, 2, 8}, + {0x17, 2, 8}, + {0x28, 3, 8}, + {0x02, 2, 11}, + {0x09, 2, 11}, + {0x17, 2, 11}, + {0x28, 3, 11}, + {0x02, 2, 12}, + {0x09, 2, 12}, + {0x17, 2, 12}, + {0x28, 3, 12}, + {0x02, 2, 14}, + {0x09, 2, 14}, + {0x17, 2, 14}, + {0x28, 3, 14}, }, /* 233 */ { - {0x8003, 8}, - {0x8006, 8}, - {0x800a, 8}, - {0x800f, 8}, - {0x8018, 8}, - {0x801f, 8}, - {0x8029, 8}, - {0xc038, 8}, - {0x8003, 11}, - {0x8006, 11}, - {0x800a, 11}, - {0x800f, 11}, - {0x8018, 11}, - {0x801f, 11}, - {0x8029, 11}, - {0xc038, 11}, + {0x03, 2, 8}, + {0x06, 2, 8}, + {0x0a, 2, 8}, + {0x0f, 2, 8}, + {0x18, 2, 8}, + {0x1f, 2, 8}, + {0x29, 2, 8}, + {0x38, 3, 8}, + {0x03, 2, 11}, + {0x06, 2, 11}, + {0x0a, 2, 11}, + {0x0f, 2, 11}, + {0x18, 2, 11}, + {0x1f, 2, 11}, + {0x29, 2, 11}, + {0x38, 3, 11}, }, /* 234 */ { - {0x8003, 12}, - {0x8006, 12}, - {0x800a, 12}, - {0x800f, 12}, - {0x8018, 12}, - {0x801f, 12}, - {0x8029, 12}, - {0xc038, 12}, - {0x8003, 14}, - {0x8006, 14}, - {0x800a, 14}, - {0x800f, 14}, - {0x8018, 14}, - {0x801f, 14}, - {0x8029, 14}, - {0xc038, 14}, + {0x03, 2, 12}, + {0x06, 2, 12}, + {0x0a, 2, 12}, + {0x0f, 2, 12}, + {0x18, 2, 12}, + {0x1f, 2, 12}, + {0x29, 2, 12}, + {0x38, 3, 12}, + {0x03, 2, 14}, + {0x06, 2, 14}, + {0x0a, 2, 14}, + {0x0f, 2, 14}, + {0x18, 2, 14}, + {0x1f, 2, 14}, + {0x29, 2, 14}, + {0x38, 3, 14}, }, /* 235 */ { - {0x8002, 15}, - {0x8009, 15}, - {0x8017, 15}, - {0xc028, 15}, - {0x8002, 16}, - {0x8009, 16}, - {0x8017, 16}, - {0xc028, 16}, - {0x8002, 17}, - {0x8009, 17}, - {0x8017, 17}, - {0xc028, 17}, - {0x8002, 18}, - {0x8009, 18}, - {0x8017, 18}, - {0xc028, 18}, + {0x02, 2, 15}, + {0x09, 2, 15}, + {0x17, 2, 15}, + {0x28, 3, 15}, + {0x02, 2, 16}, + {0x09, 2, 16}, + {0x17, 2, 16}, + {0x28, 3, 16}, + {0x02, 2, 17}, + {0x09, 2, 17}, + {0x17, 2, 17}, + {0x28, 3, 17}, + {0x02, 2, 18}, + {0x09, 2, 18}, + {0x17, 2, 18}, + {0x28, 3, 18}, }, /* 236 */ { - {0x8003, 15}, - {0x8006, 15}, - {0x800a, 15}, - {0x800f, 15}, - {0x8018, 15}, - {0x801f, 15}, - {0x8029, 15}, - {0xc038, 15}, - {0x8003, 16}, - {0x8006, 16}, - {0x800a, 16}, - {0x800f, 16}, - {0x8018, 16}, - {0x801f, 16}, - {0x8029, 16}, - {0xc038, 16}, + {0x03, 2, 15}, + {0x06, 2, 15}, + {0x0a, 2, 15}, + {0x0f, 2, 15}, + {0x18, 2, 15}, + {0x1f, 2, 15}, + {0x29, 2, 15}, + {0x38, 3, 15}, + {0x03, 2, 16}, + {0x06, 2, 16}, + {0x0a, 2, 16}, + {0x0f, 2, 16}, + {0x18, 2, 16}, + {0x1f, 2, 16}, + {0x29, 2, 16}, + {0x38, 3, 16}, }, /* 237 */ { - {0x8003, 17}, - {0x8006, 17}, - {0x800a, 17}, - {0x800f, 17}, - {0x8018, 17}, - {0x801f, 17}, - {0x8029, 17}, - {0xc038, 17}, - {0x8003, 18}, - {0x8006, 18}, - {0x800a, 18}, - {0x800f, 18}, - {0x8018, 18}, - {0x801f, 18}, - {0x8029, 18}, - {0xc038, 18}, + {0x03, 2, 17}, + {0x06, 2, 17}, + {0x0a, 2, 17}, + {0x0f, 2, 17}, + {0x18, 2, 17}, + {0x1f, 2, 17}, + {0x29, 2, 17}, + {0x38, 3, 17}, + {0x03, 2, 18}, + {0x06, 2, 18}, + {0x0a, 2, 18}, + {0x0f, 2, 18}, + {0x18, 2, 18}, + {0x1f, 2, 18}, + {0x29, 2, 18}, + {0x38, 3, 18}, }, /* 238 */ { - {0xc000, 19}, - {0xc000, 20}, - {0xc000, 21}, - {0xc000, 23}, - {0xc000, 24}, - {0xc000, 25}, - {0xc000, 26}, - {0xc000, 27}, - {0xc000, 28}, - {0xc000, 29}, - {0xc000, 30}, - {0xc000, 31}, - {0xc000, 127}, - {0xc000, 220}, - {0xc000, 249}, - {0xfd, 0}, + {0x00, 3, 19}, + {0x00, 3, 20}, + {0x00, 3, 21}, + {0x00, 3, 23}, + {0x00, 3, 24}, + {0x00, 3, 25}, + {0x00, 3, 26}, + {0x00, 3, 27}, + {0x00, 3, 28}, + {0x00, 3, 29}, + {0x00, 3, 30}, + {0x00, 3, 31}, + {0x00, 3, 127}, + {0x00, 3, 220}, + {0x00, 3, 249}, + {0xfd, 0, 0}, }, /* 239 */ { - {0x8001, 19}, - {0xc016, 19}, - {0x8001, 20}, - {0xc016, 20}, - {0x8001, 21}, - {0xc016, 21}, - {0x8001, 23}, - {0xc016, 23}, - {0x8001, 24}, - {0xc016, 24}, - {0x8001, 25}, - {0xc016, 25}, - {0x8001, 26}, - {0xc016, 26}, - {0x8001, 27}, - {0xc016, 27}, + {0x01, 2, 19}, + {0x16, 3, 19}, + {0x01, 2, 20}, + {0x16, 3, 20}, + {0x01, 2, 21}, + {0x16, 3, 21}, + {0x01, 2, 23}, + {0x16, 3, 23}, + {0x01, 2, 24}, + {0x16, 3, 24}, + {0x01, 2, 25}, + {0x16, 3, 25}, + {0x01, 2, 26}, + {0x16, 3, 26}, + {0x01, 2, 27}, + {0x16, 3, 27}, }, /* 240 */ { - {0x8002, 19}, - {0x8009, 19}, - {0x8017, 19}, - {0xc028, 19}, - {0x8002, 20}, - {0x8009, 20}, - {0x8017, 20}, - {0xc028, 20}, - {0x8002, 21}, - {0x8009, 21}, - {0x8017, 21}, - {0xc028, 21}, - {0x8002, 23}, - {0x8009, 23}, - {0x8017, 23}, - {0xc028, 23}, + {0x02, 2, 19}, + {0x09, 2, 19}, + {0x17, 2, 19}, + {0x28, 3, 19}, + {0x02, 2, 20}, + {0x09, 2, 20}, + {0x17, 2, 20}, + {0x28, 3, 20}, + {0x02, 2, 21}, + {0x09, 2, 21}, + {0x17, 2, 21}, + {0x28, 3, 21}, + {0x02, 2, 23}, + {0x09, 2, 23}, + {0x17, 2, 23}, + {0x28, 3, 23}, }, /* 241 */ { - {0x8003, 19}, - {0x8006, 19}, - {0x800a, 19}, - {0x800f, 19}, - {0x8018, 19}, - {0x801f, 19}, - {0x8029, 19}, - {0xc038, 19}, - {0x8003, 20}, - {0x8006, 20}, - {0x800a, 20}, - {0x800f, 20}, - {0x8018, 20}, - {0x801f, 20}, - {0x8029, 20}, - {0xc038, 20}, + {0x03, 2, 19}, + {0x06, 2, 19}, + {0x0a, 2, 19}, + {0x0f, 2, 19}, + {0x18, 2, 19}, + {0x1f, 2, 19}, + {0x29, 2, 19}, + {0x38, 3, 19}, + {0x03, 2, 20}, + {0x06, 2, 20}, + {0x0a, 2, 20}, + {0x0f, 2, 20}, + {0x18, 2, 20}, + {0x1f, 2, 20}, + {0x29, 2, 20}, + {0x38, 3, 20}, }, /* 242 */ { - {0x8003, 21}, - {0x8006, 21}, - {0x800a, 21}, - {0x800f, 21}, - {0x8018, 21}, - {0x801f, 21}, - {0x8029, 21}, - {0xc038, 21}, - {0x8003, 23}, - {0x8006, 23}, - {0x800a, 23}, - {0x800f, 23}, - {0x8018, 23}, - {0x801f, 23}, - {0x8029, 23}, - {0xc038, 23}, + {0x03, 2, 21}, + {0x06, 2, 21}, + {0x0a, 2, 21}, + {0x0f, 2, 21}, + {0x18, 2, 21}, + {0x1f, 2, 21}, + {0x29, 2, 21}, + {0x38, 3, 21}, + {0x03, 2, 23}, + {0x06, 2, 23}, + {0x0a, 2, 23}, + {0x0f, 2, 23}, + {0x18, 2, 23}, + {0x1f, 2, 23}, + {0x29, 2, 23}, + {0x38, 3, 23}, }, /* 243 */ { - {0x8002, 24}, - {0x8009, 24}, - {0x8017, 24}, - {0xc028, 24}, - {0x8002, 25}, - {0x8009, 25}, - {0x8017, 25}, - {0xc028, 25}, - {0x8002, 26}, - {0x8009, 26}, - {0x8017, 26}, - {0xc028, 26}, - {0x8002, 27}, - {0x8009, 27}, - {0x8017, 27}, - {0xc028, 27}, + {0x02, 2, 24}, + {0x09, 2, 24}, + {0x17, 2, 24}, + {0x28, 3, 24}, + {0x02, 2, 25}, + {0x09, 2, 25}, + {0x17, 2, 25}, + {0x28, 3, 25}, + {0x02, 2, 26}, + {0x09, 2, 26}, + {0x17, 2, 26}, + {0x28, 3, 26}, + {0x02, 2, 27}, + {0x09, 2, 27}, + {0x17, 2, 27}, + {0x28, 3, 27}, }, /* 244 */ { - {0x8003, 24}, - {0x8006, 24}, - {0x800a, 24}, - {0x800f, 24}, - {0x8018, 24}, - {0x801f, 24}, - {0x8029, 24}, - {0xc038, 24}, - {0x8003, 25}, - {0x8006, 25}, - {0x800a, 25}, - {0x800f, 25}, - {0x8018, 25}, - {0x801f, 25}, - {0x8029, 25}, - {0xc038, 25}, + {0x03, 2, 24}, + {0x06, 2, 24}, + {0x0a, 2, 24}, + {0x0f, 2, 24}, + {0x18, 2, 24}, + {0x1f, 2, 24}, + {0x29, 2, 24}, + {0x38, 3, 24}, + {0x03, 2, 25}, + {0x06, 2, 25}, + {0x0a, 2, 25}, + {0x0f, 2, 25}, + {0x18, 2, 25}, + {0x1f, 2, 25}, + {0x29, 2, 25}, + {0x38, 3, 25}, }, /* 245 */ { - {0x8003, 26}, - {0x8006, 26}, - {0x800a, 26}, - {0x800f, 26}, - {0x8018, 26}, - {0x801f, 26}, - {0x8029, 26}, - {0xc038, 26}, - {0x8003, 27}, - {0x8006, 27}, - {0x800a, 27}, - {0x800f, 27}, - {0x8018, 27}, - {0x801f, 27}, - {0x8029, 27}, - {0xc038, 27}, + {0x03, 2, 26}, + {0x06, 2, 26}, + {0x0a, 2, 26}, + {0x0f, 2, 26}, + {0x18, 2, 26}, + {0x1f, 2, 26}, + {0x29, 2, 26}, + {0x38, 3, 26}, + {0x03, 2, 27}, + {0x06, 2, 27}, + {0x0a, 2, 27}, + {0x0f, 2, 27}, + {0x18, 2, 27}, + {0x1f, 2, 27}, + {0x29, 2, 27}, + {0x38, 3, 27}, }, /* 246 */ { - {0x8001, 28}, - {0xc016, 28}, - {0x8001, 29}, - {0xc016, 29}, - {0x8001, 30}, - {0xc016, 30}, - {0x8001, 31}, - {0xc016, 31}, - {0x8001, 127}, - {0xc016, 127}, - {0x8001, 220}, - {0xc016, 220}, - {0x8001, 249}, - {0xc016, 249}, - {0xfe, 0}, - {0xff, 0}, + {0x01, 2, 28}, + {0x16, 3, 28}, + {0x01, 2, 29}, + {0x16, 3, 29}, + {0x01, 2, 30}, + {0x16, 3, 30}, + {0x01, 2, 31}, + {0x16, 3, 31}, + {0x01, 2, 127}, + {0x16, 3, 127}, + {0x01, 2, 220}, + {0x16, 3, 220}, + {0x01, 2, 249}, + {0x16, 3, 249}, + {0xfe, 0, 0}, + {0xff, 0, 0}, }, /* 247 */ { - {0x8002, 28}, - {0x8009, 28}, - {0x8017, 28}, - {0xc028, 28}, - {0x8002, 29}, - {0x8009, 29}, - {0x8017, 29}, - {0xc028, 29}, - {0x8002, 30}, - {0x8009, 30}, - {0x8017, 30}, - {0xc028, 30}, - {0x8002, 31}, - {0x8009, 31}, - {0x8017, 31}, - {0xc028, 31}, + {0x02, 2, 28}, + {0x09, 2, 28}, + {0x17, 2, 28}, + {0x28, 3, 28}, + {0x02, 2, 29}, + {0x09, 2, 29}, + {0x17, 2, 29}, + {0x28, 3, 29}, + {0x02, 2, 30}, + {0x09, 2, 30}, + {0x17, 2, 30}, + {0x28, 3, 30}, + {0x02, 2, 31}, + {0x09, 2, 31}, + {0x17, 2, 31}, + {0x28, 3, 31}, }, /* 248 */ { - {0x8003, 28}, - {0x8006, 28}, - {0x800a, 28}, - {0x800f, 28}, - {0x8018, 28}, - {0x801f, 28}, - {0x8029, 28}, - {0xc038, 28}, - {0x8003, 29}, - {0x8006, 29}, - {0x800a, 29}, - {0x800f, 29}, - {0x8018, 29}, - {0x801f, 29}, - {0x8029, 29}, - {0xc038, 29}, + {0x03, 2, 28}, + {0x06, 2, 28}, + {0x0a, 2, 28}, + {0x0f, 2, 28}, + {0x18, 2, 28}, + {0x1f, 2, 28}, + {0x29, 2, 28}, + {0x38, 3, 28}, + {0x03, 2, 29}, + {0x06, 2, 29}, + {0x0a, 2, 29}, + {0x0f, 2, 29}, + {0x18, 2, 29}, + {0x1f, 2, 29}, + {0x29, 2, 29}, + {0x38, 3, 29}, }, /* 249 */ { - {0x8003, 30}, - {0x8006, 30}, - {0x800a, 30}, - {0x800f, 30}, - {0x8018, 30}, - {0x801f, 30}, - {0x8029, 30}, - {0xc038, 30}, - {0x8003, 31}, - {0x8006, 31}, - {0x800a, 31}, - {0x800f, 31}, - {0x8018, 31}, - {0x801f, 31}, - {0x8029, 31}, - {0xc038, 31}, + {0x03, 2, 30}, + {0x06, 2, 30}, + {0x0a, 2, 30}, + {0x0f, 2, 30}, + {0x18, 2, 30}, + {0x1f, 2, 30}, + {0x29, 2, 30}, + {0x38, 3, 30}, + {0x03, 2, 31}, + {0x06, 2, 31}, + {0x0a, 2, 31}, + {0x0f, 2, 31}, + {0x18, 2, 31}, + {0x1f, 2, 31}, + {0x29, 2, 31}, + {0x38, 3, 31}, }, /* 250 */ { - {0x8002, 127}, - {0x8009, 127}, - {0x8017, 127}, - {0xc028, 127}, - {0x8002, 220}, - {0x8009, 220}, - {0x8017, 220}, - {0xc028, 220}, - {0x8002, 249}, - {0x8009, 249}, - {0x8017, 249}, - {0xc028, 249}, - {0xc000, 10}, - {0xc000, 13}, - {0xc000, 22}, - {0x100, 0}, + {0x02, 2, 127}, + {0x09, 2, 127}, + {0x17, 2, 127}, + {0x28, 3, 127}, + {0x02, 2, 220}, + {0x09, 2, 220}, + {0x17, 2, 220}, + {0x28, 3, 220}, + {0x02, 2, 249}, + {0x09, 2, 249}, + {0x17, 2, 249}, + {0x28, 3, 249}, + {0x00, 3, 10}, + {0x00, 3, 13}, + {0x00, 3, 22}, + {0x100, 0, 0}, }, /* 251 */ { - {0x8003, 127}, - {0x8006, 127}, - {0x800a, 127}, - {0x800f, 127}, - {0x8018, 127}, - {0x801f, 127}, - {0x8029, 127}, - {0xc038, 127}, - {0x8003, 220}, - {0x8006, 220}, - {0x800a, 220}, - {0x800f, 220}, - {0x8018, 220}, - {0x801f, 220}, - {0x8029, 220}, - {0xc038, 220}, + {0x03, 2, 127}, + {0x06, 2, 127}, + {0x0a, 2, 127}, + {0x0f, 2, 127}, + {0x18, 2, 127}, + {0x1f, 2, 127}, + {0x29, 2, 127}, + {0x38, 3, 127}, + {0x03, 2, 220}, + {0x06, 2, 220}, + {0x0a, 2, 220}, + {0x0f, 2, 220}, + {0x18, 2, 220}, + {0x1f, 2, 220}, + {0x29, 2, 220}, + {0x38, 3, 220}, }, /* 252 */ { - {0x8003, 249}, - {0x8006, 249}, - {0x800a, 249}, - {0x800f, 249}, - {0x8018, 249}, - {0x801f, 249}, - {0x8029, 249}, - {0xc038, 249}, - {0x8001, 10}, - {0xc016, 10}, - {0x8001, 13}, - {0xc016, 13}, - {0x8001, 22}, - {0xc016, 22}, - {0x100, 0}, - {0x100, 0}, + {0x03, 2, 249}, + {0x06, 2, 249}, + {0x0a, 2, 249}, + {0x0f, 2, 249}, + {0x18, 2, 249}, + {0x1f, 2, 249}, + {0x29, 2, 249}, + {0x38, 3, 249}, + {0x01, 2, 10}, + {0x16, 3, 10}, + {0x01, 2, 13}, + {0x16, 3, 13}, + {0x01, 2, 22}, + {0x16, 3, 22}, + {0x100, 0, 0}, + {0x100, 0, 0}, }, /* 253 */ { - {0x8002, 10}, - {0x8009, 10}, - {0x8017, 10}, - {0xc028, 10}, - {0x8002, 13}, - {0x8009, 13}, - {0x8017, 13}, - {0xc028, 13}, - {0x8002, 22}, - {0x8009, 22}, - {0x8017, 22}, - {0xc028, 22}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, + {0x02, 2, 10}, + {0x09, 2, 10}, + {0x17, 2, 10}, + {0x28, 3, 10}, + {0x02, 2, 13}, + {0x09, 2, 13}, + {0x17, 2, 13}, + {0x28, 3, 13}, + {0x02, 2, 22}, + {0x09, 2, 22}, + {0x17, 2, 22}, + {0x28, 3, 22}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, }, /* 254 */ { - {0x8003, 10}, - {0x8006, 10}, - {0x800a, 10}, - {0x800f, 10}, - {0x8018, 10}, - {0x801f, 10}, - {0x8029, 10}, - {0xc038, 10}, - {0x8003, 13}, - {0x8006, 13}, - {0x800a, 13}, - {0x800f, 13}, - {0x8018, 13}, - {0x801f, 13}, - {0x8029, 13}, - {0xc038, 13}, + {0x03, 2, 10}, + {0x06, 2, 10}, + {0x0a, 2, 10}, + {0x0f, 2, 10}, + {0x18, 2, 10}, + {0x1f, 2, 10}, + {0x29, 2, 10}, + {0x38, 3, 10}, + {0x03, 2, 13}, + {0x06, 2, 13}, + {0x0a, 2, 13}, + {0x0f, 2, 13}, + {0x18, 2, 13}, + {0x1f, 2, 13}, + {0x29, 2, 13}, + {0x38, 3, 13}, }, /* 255 */ { - {0x8003, 22}, - {0x8006, 22}, - {0x800a, 22}, - {0x800f, 22}, - {0x8018, 22}, - {0x801f, 22}, - {0x8029, 22}, - {0xc038, 22}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, + {0x03, 2, 22}, + {0x06, 2, 22}, + {0x0a, 2, 22}, + {0x0f, 2, 22}, + {0x18, 2, 22}, + {0x1f, 2, 22}, + {0x29, 2, 22}, + {0x38, 3, 22}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, }, /* 256 */ { - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, }, }; diff --git a/deps/nghttp2/lib/nghttp2_helper.h b/deps/nghttp2/lib/nghttp2_helper.h index 7d64076140ce88..5fde72e370f42b 100644 --- a/deps/nghttp2/lib/nghttp2_helper.h +++ b/deps/nghttp2/lib/nghttp2_helper.h @@ -61,7 +61,15 @@ nghttp2_min_def(uint32, uint32_t) nghttp2_min_def(uint64, uint64_t) nghttp2_min_def(size, size_t) -#define lstreq(A, B, N) ((sizeof((A)) - 1) == (N) && memcmp((A), (B), (N)) == 0) +/* + * nghttp2_strlen_lit returns the length of string literal |S|. This + * macro assumes |S| is NULL-terminated string literal. It must not + * be used with pointers. + */ +#define nghttp2_strlen_lit(S) (sizeof(S) - 1) + +#define lstreq(A, B, N) \ + (nghttp2_strlen_lit((A)) == (N) && memcmp((A), (B), (N)) == 0) #define nghttp2_struct_of(ptr, type, member) \ ((type *)(void *)((char *)(ptr) - offsetof(type, member))) diff --git a/deps/nghttp2/lib/nghttp2_http.c b/deps/nghttp2/lib/nghttp2_http.c index 60a0b01e66c1c8..a09005e807877a 100644 --- a/deps/nghttp2/lib/nghttp2_http.c +++ b/deps/nghttp2/lib/nghttp2_http.c @@ -49,7 +49,8 @@ static int memieq(const void *a, const void *b, size_t n) { return 1; } -#define lstrieq(A, B, N) ((sizeof((A)) - 1) == (N) && memieq((A), (B), (N))) +#define lstrieq(A, B, N) \ + (nghttp2_strlen_lit((A)) == (N) && memieq((A), (B), (N))) static int64_t parse_uint(const uint8_t *s, size_t len) { int64_t n = 0; diff --git a/deps/nghttp2/lib/nghttp2_int.h b/deps/nghttp2/lib/nghttp2_int.h index 4e3b26860daf07..2ac6fdac441498 100644 --- a/deps/nghttp2/lib/nghttp2_int.h +++ b/deps/nghttp2/lib/nghttp2_int.h @@ -39,7 +39,6 @@ typedef int (*nghttp2_less)(const void *lhs, const void *rhs); /* Internal error code. They must be in the range [-499, -100], inclusive. */ typedef enum { - NGHTTP2_ERR_CREDENTIAL_PENDING = -101, NGHTTP2_ERR_IGN_HEADER_BLOCK = -103, NGHTTP2_ERR_IGN_PAYLOAD = -104, /* @@ -52,7 +51,11 @@ typedef enum { * Unlike NGHTTP2_ERR_IGN_HTTP_HEADER, this does not invoke * nghttp2_on_invalid_header_callback. */ - NGHTTP2_ERR_REMOVE_HTTP_HEADER = -106 + NGHTTP2_ERR_REMOVE_HTTP_HEADER = -106, + /* + * Cancel pushed stream. + */ + NGHTTP2_ERR_PUSH_CANCEL = -107, } nghttp2_internal_error; #endif /* !defined(NGHTTP2_INT_H) */ diff --git a/deps/nghttp2/lib/nghttp2_map.c b/deps/nghttp2/lib/nghttp2_map.c index f89f310319a1a3..3b703a029328c8 100644 --- a/deps/nghttp2/lib/nghttp2_map.c +++ b/deps/nghttp2/lib/nghttp2_map.c @@ -33,12 +33,11 @@ #define NGHTTP2_INITIAL_HASHBITS 4 -void nghttp2_map_init(nghttp2_map *map, uint32_t seed, nghttp2_mem *mem) { - map->mem = mem; - map->hashbits = 0; - map->table = NULL; - map->seed = seed; - map->size = 0; +void nghttp2_map_init(nghttp2_map *map, uint64_t seed, nghttp2_mem *mem) { + *map = (nghttp2_map){ + .mem = mem, + .seed = seed, + }; } void nghttp2_map_free(nghttp2_map *map) { @@ -46,30 +45,27 @@ void nghttp2_map_free(nghttp2_map *map) { return; } - nghttp2_mem_free(map->mem, map->table); + nghttp2_mem_free(map->mem, map->keys); } int nghttp2_map_each(const nghttp2_map *map, int (*func)(void *data, void *ptr), void *ptr) { int rv; size_t i; - nghttp2_map_bucket *bkt; size_t tablelen; if (map->size == 0) { return 0; } - tablelen = 1u << map->hashbits; + tablelen = (size_t)1 << map->hashbits; for (i = 0; i < tablelen; ++i) { - bkt = &map->table[i]; - - if (bkt->data == NULL) { + if (map->psl[i] == 0) { continue; } - rv = func(bkt->data, ptr); + rv = func(map->data[i], ptr); if (rv != 0) { return rv; } @@ -78,175 +74,230 @@ int nghttp2_map_each(const nghttp2_map *map, int (*func)(void *data, void *ptr), return 0; } -static size_t map_hash(const nghttp2_map *map, nghttp2_map_key_type key) { - /* hasher from - https://github.com/rust-lang/rustc-hash/blob/dc5c33f1283de2da64d8d7a06401d91aded03ad4/src/lib.rs - We do not perform finalization here because we use top bits - anyway. */ - uint32_t h = ((uint32_t)key + map->seed) * 0x93d765dd; - return (size_t)((h * 2654435769u) >> (32 - map->hashbits)); -} +/* Hasher from + https://github.com/rust-lang/rustc-hash/blob/dc5c33f1283de2da64d8d7a06401d91aded03ad4/src/lib.rs + to maximize the output's sensitivity to all input bits. */ +#define NGHTTP2_MAP_HASHER 0xf1357aea2e62a9c5ull +/* 64-bit Fibonacci hashing constant, Golden Ratio constant, to get + the high bits with the good distribution. */ +#define NGHTTP2_MAP_FIBO 0x9e3779b97f4a7c15ull -static void map_bucket_swap(nghttp2_map_bucket *a, nghttp2_map_bucket *b) { - nghttp2_map_bucket c = *a; +static size_t map_index(const nghttp2_map *map, nghttp2_map_key_type key32) { + uint64_t key = (uint64_t)key32; - *a = *b; - *b = c; + key += map->seed; + key *= NGHTTP2_MAP_HASHER; + return (size_t)((key * NGHTTP2_MAP_FIBO) >> (64 - map->hashbits)); } #ifndef WIN32 void nghttp2_map_print_distance(const nghttp2_map *map) { size_t i; size_t idx; - nghttp2_map_bucket *bkt; size_t tablelen; if (map->size == 0) { return; } - tablelen = 1u << map->hashbits; + tablelen = (size_t)1 << map->hashbits; for (i = 0; i < tablelen; ++i) { - bkt = &map->table[i]; - - if (bkt->data == NULL) { + if (map->psl[i] == 0) { fprintf(stderr, "@%zu \n", i); continue; } - idx = map_hash(map, bkt->key); - fprintf(stderr, "@%zu hash=%zu key=%d base=%zu distance=%u\n", i, - map_hash(map, bkt->key), bkt->key, idx, bkt->psl); + idx = map_index(map, map->keys[i]); + fprintf(stderr, "@%zu key=%d base=%zu distance=%u\n", i, map->keys[i], idx, + map->psl[i] - 1); } } #endif /* !defined(WIN32) */ -static int map_insert(nghttp2_map *map, nghttp2_map_key_type key, void *data) { - size_t idx = map_hash(map, key); - nghttp2_map_bucket b = { - .key = key, - .data = data, - }; - nghttp2_map_bucket *bkt; - size_t mask = (1u << map->hashbits) - 1; +static void map_set_entry(nghttp2_map *map, size_t idx, + nghttp2_map_key_type key, void *data, size_t psl) { + map->keys[idx] = key; + map->data[idx] = data; + map->psl[idx] = (uint8_t)psl; +} + +#define NGHTTP2_SWAP(TYPE, A, B) \ + do { \ + TYPE t = (TYPE) * (A); \ + \ + *(A) = *(B); \ + *(B) = t; \ + } while (0) + +/* + * map_insert inserts |key| and |data| to |map|, and returns the index + * where the pair is stored if it succeeds. Otherwise, it returns one + * of the following negative error codes: + * + * NGHTTP2_ERR_INVALID_ARGUMENT + * The another data associated to |key| is already present. + */ +static nghttp2_ssize map_insert(nghttp2_map *map, nghttp2_map_key_type key, + void *data) { + size_t idx = map_index(map, key); + size_t mask = ((size_t)1 << map->hashbits) - 1; + size_t psl = 1; + size_t kpsl; for (;;) { - bkt = &map->table[idx]; + kpsl = map->psl[idx]; - if (bkt->data == NULL) { - *bkt = b; + if (kpsl == 0) { + map_set_entry(map, idx, key, data, psl); ++map->size; - return 0; + + return (nghttp2_ssize)idx; } - if (b.psl > bkt->psl) { - map_bucket_swap(bkt, &b); - } else if (bkt->key == key) { - /* TODO This check is just a waste after first swap or if this - function is called from map_resize. That said, there is no - difference with or without this conditional in performance - wise. */ + if (psl > kpsl) { + NGHTTP2_SWAP(nghttp2_map_key_type, &key, &map->keys[idx]); + NGHTTP2_SWAP(void *, &data, &map->data[idx]); + NGHTTP2_SWAP(uint8_t, &psl, &map->psl[idx]); + } else if (map->keys[idx] == key) { + /* This check ensures that no duplicate keys are inserted. But + it is just a waste after first swap or if this function is + called from map_resize. That said, there is no difference + with or without this conditional in performance wise. */ return NGHTTP2_ERR_INVALID_ARGUMENT; } - ++b.psl; + ++psl; idx = (idx + 1) & mask; } } +/* NGHTTP2_MAP_MAX_HASHBITS is the maximum number of bits used for + hash table. The theoretical limit of the maximum number of keys + that can be stored is 1 << NGHTTP2_MAP_MAX_HASHBITS. */ +#define NGHTTP2_MAP_MAX_HASHBITS (sizeof(size_t) * 8 - 1) + static int map_resize(nghttp2_map *map, size_t new_hashbits) { size_t i; - nghttp2_map_bucket *bkt; size_t tablelen; - int rv; + nghttp2_ssize idx; nghttp2_map new_map = { - .table = nghttp2_mem_calloc(map->mem, 1u << new_hashbits, - sizeof(nghttp2_map_bucket)), .mem = map->mem, .seed = map->seed, .hashbits = new_hashbits, }; - (void)rv; + void *buf; + (void)idx; + + if (new_hashbits > NGHTTP2_MAP_MAX_HASHBITS) { + return NGHTTP2_ERR_NOMEM; + } - if (new_map.table == NULL) { + tablelen = (size_t)1 << new_hashbits; + + buf = nghttp2_mem_calloc(map->mem, tablelen, + sizeof(nghttp2_map_key_type) + sizeof(void *) + + sizeof(uint8_t)); + if (buf == NULL) { return NGHTTP2_ERR_NOMEM; } + new_map.keys = buf; + new_map.data = + (void *)((uint8_t *)new_map.keys + tablelen * sizeof(nghttp2_map_key_type)); + new_map.psl = (uint8_t *)new_map.data + tablelen * sizeof(void *); + if (map->size) { - tablelen = 1u << map->hashbits; + tablelen = (size_t)1 << map->hashbits; for (i = 0; i < tablelen; ++i) { - bkt = &map->table[i]; - if (bkt->data == NULL) { + if (map->psl[i] == 0) { continue; } - rv = map_insert(&new_map, bkt->key, bkt->data); + idx = map_insert(&new_map, map->keys[i], map->data[i]); - assert(0 == rv); + /* map_insert must not fail because all keys are unique during + resize. */ + assert(idx >= 0); } } - nghttp2_mem_free(map->mem, map->table); - map->table = new_map.table; + nghttp2_mem_free(map->mem, map->keys); + map->keys = new_map.keys; + map->data = new_map.data; + map->psl = new_map.psl; map->hashbits = new_hashbits; return 0; } +/* NGHTTP2_MAX_PSL_RESIZE_THRESH is the maximum psl threshold. If + reached, resize the table. */ +#define NGHTTP2_MAX_PSL_RESIZE_THRESH 128 + int nghttp2_map_insert(nghttp2_map *map, nghttp2_map_key_type key, void *data) { int rv; + size_t tablelen; + nghttp2_ssize idx; assert(data); - /* Load factor is 7/8 */ - /* Under the very initial condition, that is map->size == 0 and - map->hashbits == 0, 8 > 7 still holds nicely. */ - if ((map->size + 1) * 8 > (1u << map->hashbits) * 7) { - if (map->hashbits) { - rv = map_resize(map, map->hashbits + 1); - if (rv != 0) { - return rv; - } - } else { - rv = map_resize(map, NGHTTP2_INITIAL_HASHBITS); - if (rv != 0) { - return rv; - } + /* tablelen is incorrect if map->hashbits == 0 which leads to + tablelen = 1, but it is only used to check the load factor, and + it works in this special case. */ + tablelen = (size_t)1 << map->hashbits; + + /* Load factor is 7 / 8. Because tablelen is power of 2, (tablelen + - (tablelen >> 3)) computes tablelen * 7 / 8. */ + if (map->size + 1 >= (tablelen - (tablelen >> 3))) { + rv = map_resize(map, map->hashbits ? map->hashbits + 1 + : NGHTTP2_INITIAL_HASHBITS); + if (rv != 0) { + return rv; + } + + idx = map_insert(map, key, data); + if (idx < 0) { + return (int)idx; } + + return 0; } - rv = map_insert(map, key, data); - if (rv != 0) { - return rv; + idx = map_insert(map, key, data); + if (idx < 0) { + return (int)idx; } - return 0; + /* Resize if psl reaches really large value which is almost + improbable, but just in case. */ + if (map->psl[idx] - 1 < NGHTTP2_MAX_PSL_RESIZE_THRESH) { + return 0; + } + + return map_resize(map, map->hashbits + 1); } void *nghttp2_map_find(const nghttp2_map *map, nghttp2_map_key_type key) { size_t idx; - nghttp2_map_bucket *bkt; - size_t psl = 0; + size_t psl = 1; size_t mask; if (map->size == 0) { return NULL; } - idx = map_hash(map, key); - mask = (1u << map->hashbits) - 1; + idx = map_index(map, key); + mask = ((size_t)1 << map->hashbits) - 1; for (;;) { - bkt = &map->table[idx]; - - if (bkt->data == NULL || psl > bkt->psl) { + if (psl > map->psl[idx]) { return NULL; } - if (bkt->key == key) { - return bkt->data; + if (map->keys[idx] == key) { + return map->data[idx]; } ++psl; @@ -256,38 +307,36 @@ void *nghttp2_map_find(const nghttp2_map *map, nghttp2_map_key_type key) { int nghttp2_map_remove(nghttp2_map *map, nghttp2_map_key_type key) { size_t idx; - nghttp2_map_bucket *b, *bkt; - size_t psl = 0; + size_t dest; + size_t psl = 1, kpsl; size_t mask; if (map->size == 0) { return NGHTTP2_ERR_INVALID_ARGUMENT; } - idx = map_hash(map, key); - mask = (1u << map->hashbits) - 1; + idx = map_index(map, key); + mask = ((size_t)1 << map->hashbits) - 1; for (;;) { - bkt = &map->table[idx]; - - if (bkt->data == NULL || psl > bkt->psl) { + if (psl > map->psl[idx]) { return NGHTTP2_ERR_INVALID_ARGUMENT; } - if (bkt->key == key) { - b = bkt; + if (map->keys[idx] == key) { + dest = idx; idx = (idx + 1) & mask; for (;;) { - bkt = &map->table[idx]; - if (bkt->data == NULL || bkt->psl == 0) { - b->data = NULL; + kpsl = map->psl[idx]; + if (kpsl <= 1) { + map->psl[dest] = 0; break; } - --bkt->psl; - *b = *bkt; - b = bkt; + map_set_entry(map, dest, map->keys[idx], map->data[idx], kpsl - 1); + + dest = idx; idx = (idx + 1) & mask; } @@ -307,7 +356,7 @@ void nghttp2_map_clear(nghttp2_map *map) { return; } - memset(map->table, 0, sizeof(*map->table) * (1u << map->hashbits)); + memset(map->psl, 0, sizeof(*map->psl) * ((size_t)1 << map->hashbits)); map->size = 0; } diff --git a/deps/nghttp2/lib/nghttp2_map.h b/deps/nghttp2/lib/nghttp2_map.h index e45685bce71768..c47b279345dee3 100644 --- a/deps/nghttp2/lib/nghttp2_map.h +++ b/deps/nghttp2/lib/nghttp2_map.h @@ -38,16 +38,15 @@ typedef int32_t nghttp2_map_key_type; -typedef struct nghttp2_map_bucket { - uint32_t psl; - nghttp2_map_key_type key; - void *data; -} nghttp2_map_bucket; - typedef struct nghttp2_map { - nghttp2_map_bucket *table; + nghttp2_map_key_type *keys; + void **data; + /* psl is the Probe Sequence Length. 0 has special meaning that the + element is not stored at i-th position if psl[i] == 0. Because + of this, the actual psl value is psl[i] - 1 if psl[i] > 0. */ + uint8_t *psl; nghttp2_mem *mem; - uint32_t seed; + uint64_t seed; size_t size; size_t hashbits; } nghttp2_map; @@ -55,7 +54,7 @@ typedef struct nghttp2_map { /* * nghttp2_map_init initializes the map |map|. */ -void nghttp2_map_init(nghttp2_map *map, uint32_t seed, nghttp2_mem *mem); +void nghttp2_map_init(nghttp2_map *map, uint64_t seed, nghttp2_mem *mem); /* * nghttp2_map_free deallocates any resources allocated for |map|. diff --git a/deps/nghttp2/lib/nghttp2_outbound_item.c b/deps/nghttp2/lib/nghttp2_outbound_item.c index a9e9f7693eda8c..fad1ee0a469086 100644 --- a/deps/nghttp2/lib/nghttp2_outbound_item.c +++ b/deps/nghttp2/lib/nghttp2_outbound_item.c @@ -53,6 +53,18 @@ nghttp2_data_provider_wrap_v2(nghttp2_data_provider_wrap *dpw, return dpw; } +int nghttp2_data_provider_wrap_contains_read_callback( + const nghttp2_data_provider_wrap *dpw) { + switch (dpw->version) { + case NGHTTP2_DATA_PROVIDER_V1: + return dpw->data_prd.v1.read_callback != NULL; + case NGHTTP2_DATA_PROVIDER_V2: + return dpw->data_prd.v2.read_callback != NULL; + default: + return 0; + } +} + void nghttp2_outbound_item_init(nghttp2_outbound_item *item) { item->cycle = 0; item->qnext = NULL; diff --git a/deps/nghttp2/lib/nghttp2_outbound_item.h b/deps/nghttp2/lib/nghttp2_outbound_item.h index 6e8e310cc475dd..9f280e616351d0 100644 --- a/deps/nghttp2/lib/nghttp2_outbound_item.h +++ b/deps/nghttp2/lib/nghttp2_outbound_item.h @@ -39,10 +39,6 @@ typedef struct nghttp2_data_provider_wrap { int version; union { - struct { - nghttp2_data_source source; - void *read_callback; - }; nghttp2_data_provider v1; nghttp2_data_provider2 v2; } data_prd; @@ -56,6 +52,11 @@ nghttp2_data_provider_wrap * nghttp2_data_provider_wrap_v2(nghttp2_data_provider_wrap *dpw, const nghttp2_data_provider2 *data_prd); +/* nghttp2_data_provider_wrap_contains_read_callback returns nonzero + if |dpw| contains read_callback in either version. */ +int nghttp2_data_provider_wrap_contains_read_callback( + const nghttp2_data_provider_wrap *dpw); + /* struct used for HEADERS and PUSH_PROMISE frame */ typedef struct { nghttp2_data_provider_wrap dpw; @@ -110,6 +111,12 @@ typedef struct { uint8_t flags; } nghttp2_goaway_aux_data; +typedef struct { + /* nonzero if RST_STREAM should be sent even if stream is not + found. */ + uint8_t continue_without_stream; +} nghttp2_rst_stream_aux_data; + /* struct used for extension frame */ typedef struct { /* nonzero if this extension frame is serialized by library @@ -122,6 +129,7 @@ typedef union { nghttp2_data_aux_data data; nghttp2_headers_aux_data headers; nghttp2_goaway_aux_data goaway; + nghttp2_rst_stream_aux_data rst_stream; nghttp2_ext_aux_data ext; } nghttp2_aux_data; diff --git a/deps/nghttp2/lib/nghttp2_session.c b/deps/nghttp2/lib/nghttp2_session.c index 97d7fda1d295d5..19e0b767c1639b 100644 --- a/deps/nghttp2/lib/nghttp2_session.c +++ b/deps/nghttp2/lib/nghttp2_session.c @@ -438,7 +438,7 @@ static int session_new(nghttp2_session **session_ptr, size_t max_deflate_dynamic_table_size = NGHTTP2_HD_DEFAULT_MAX_DEFLATE_BUFFER_SIZE; size_t i; - uint32_t map_seed; + uint64_t map_seed; if (mem == NULL) { mem = nghttp2_mem_default(); @@ -1051,7 +1051,6 @@ int nghttp2_session_add_item(nghttp2_session *session, nghttp2_outbound_queue_push(&session->ob_syn, item); item->queued = 1; return 0; - ; } nghttp2_outbound_queue_push(&session->ob_reg, item); @@ -1189,6 +1188,10 @@ int nghttp2_session_add_rst_stream_continue(nghttp2_session *session, frame = &item->frame; nghttp2_frame_rst_stream_init(&frame->rst_stream, stream_id, error_code); + + item->aux_data.rst_stream.continue_without_stream = + (uint8_t)(continue_without_stream != 0); + rv = nghttp2_session_add_item(session, item); if (rv != 0) { nghttp2_frame_rst_stream_free(&frame->rst_stream); @@ -2141,6 +2144,12 @@ static int session_prep_frame(nghttp2_session *session, if (session_is_closing(session)) { return NGHTTP2_ERR_SESSION_CLOSING; } + + if (!item->aux_data.rst_stream.continue_without_stream && + !nghttp2_session_get_stream(session, frame->rst_stream.hd.stream_id)) { + return NGHTTP2_ERR_STREAM_CLOSED; + } + nghttp2_frame_pack_rst_stream(&session->aob.framebufs, &frame->rst_stream); return 0; case NGHTTP2_SETTINGS: { @@ -2584,7 +2593,7 @@ static int session_after_frame_sent1(nghttp2_session *session) { } /* We assume aux_data is a pointer to nghttp2_headers_aux_data */ aux_data = &item->aux_data.headers; - if (aux_data->dpw.data_prd.read_callback) { + if (nghttp2_data_provider_wrap_contains_read_callback(&aux_data->dpw)) { /* nghttp2_submit_data_shared() makes a copy of aux_data->dpw */ rv = nghttp2_submit_data_shared(session, NGHTTP2_FLAG_END_STREAM, @@ -2615,7 +2624,7 @@ static int session_after_frame_sent1(nghttp2_session *session) { } /* We assume aux_data is a pointer to nghttp2_headers_aux_data */ aux_data = &item->aux_data.headers; - if (aux_data->dpw.data_prd.read_callback) { + if (nghttp2_data_provider_wrap_contains_read_callback(&aux_data->dpw)) { rv = nghttp2_submit_data_shared(session, NGHTTP2_FLAG_END_STREAM, frame->hd.stream_id, &aux_data->dpw); if (nghttp2_is_fatal(rv)) { @@ -2795,7 +2804,10 @@ static int session_call_send_data(nghttp2_session *session, aux_data = &item->aux_data.data; rv = session->callbacks.send_data_callback(session, frame, buf->pos, length, - &aux_data->dpw.data_prd.source, + /* This is fine because + of Common Initial + Sequence rule. */ + &aux_data->dpw.data_prd.v2.source, session->user_data); switch (rv) { @@ -2853,8 +2865,12 @@ static nghttp2_ssize nghttp2_session_mem_send_internal(nghttp2_session *session, nghttp2_frame *frame = &item->frame; /* The library is responsible for the transmission of WINDOW_UPDATE frame, so we don't call error callback for - it. */ + it. As for RST_STREAM, if it is not sent due to missing + stream, we also do not call error callback because it may + cause a lot of noises.*/ if (frame->hd.type != NGHTTP2_WINDOW_UPDATE && + (frame->hd.type != NGHTTP2_RST_STREAM || + rv != NGHTTP2_ERR_STREAM_CLOSED) && session->callbacks.on_frame_not_send_callback( session, frame, rv, session->user_data) != 0) { nghttp2_outbound_item_free(item, mem); @@ -3272,7 +3288,9 @@ static int session_call_on_invalid_header(nghttp2_session *session, session, frame, nv->name->base, nv->name->len, nv->value->base, nv->value->len, nv->flags, session->user_data); } else { - return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE; + /* If both callbacks are not set, the invalid field nv is + ignored. */ + return 0; } if (rv == NGHTTP2_ERR_PAUSE || rv == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) { @@ -3357,6 +3375,10 @@ static uint32_t get_error_code_from_lib_error_code(int lib_error_code) { case NGHTTP2_ERR_HTTP_HEADER: case NGHTTP2_ERR_HTTP_MESSAGING: return NGHTTP2_PROTOCOL_ERROR; + case NGHTTP2_ERR_INTERNAL: + return NGHTTP2_INTERNAL_ERROR; + case NGHTTP2_ERR_PUSH_CANCEL: + return NGHTTP2_CANCEL; default: return NGHTTP2_INTERNAL_ERROR; } @@ -3408,7 +3430,7 @@ static int session_handle_invalid_stream2(nghttp2_session *session, if (rv != 0) { return rv; } - if (session->callbacks.on_invalid_frame_recv_callback) { + if (frame && session->callbacks.on_invalid_frame_recv_callback) { if (session->callbacks.on_invalid_frame_recv_callback( session, frame, lib_error_code, session->user_data) != 0) { return NGHTTP2_ERR_CALLBACK_FAILURE; @@ -3495,6 +3517,7 @@ static int session_inflate_handle_invalid_connection(nghttp2_session *session, static int inflate_header_block(nghttp2_session *session, nghttp2_frame *frame, size_t *readlen_ptr, uint8_t *in, size_t inlen, int final, int call_header_cb) { + nghttp2_inbound_frame *iframe = &session->iframe; nghttp2_ssize proclen; int rv; int inflate_flags; @@ -3563,7 +3586,29 @@ static int inflate_header_block(nghttp2_session *session, nghttp2_frame *frame, rv2 = session_call_on_invalid_header(session, frame, &nv); if (rv2 == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) { - rv = NGHTTP2_ERR_HTTP_HEADER; + DEBUGF("recv: HTTP error: type=%u, id=%d, header %.*s: %.*s\n", + frame->hd.type, frame->hd.stream_id, (int)nv.name->len, + nv.name->base, (int)nv.value->len, nv.value->base); + + rv = session_call_error_callback( + session, NGHTTP2_ERR_HTTP_HEADER, + "Invalid HTTP header field was received: frame type: " + "%u, stream: %d, name: [%.*s], value: [%.*s]", + frame->hd.type, frame->hd.stream_id, (int)nv.name->len, + nv.name->base, (int)nv.value->len, nv.value->base); + + if (nghttp2_is_fatal(rv)) { + return rv; + } + + rv = session_handle_invalid_stream2( + session, subject_stream->stream_id, frame, + NGHTTP2_ERR_HTTP_HEADER); + if (nghttp2_is_fatal(rv)) { + return rv; + } + + return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE; } else { if (rv2 != 0) { return rv2; @@ -3609,6 +3654,16 @@ static int inflate_header_block(nghttp2_session *session, nghttp2_frame *frame, if (nghttp2_is_fatal(rv)) { return rv; } + + rv = session_update_glitch_ratelim(session); + if (rv != 0) { + return rv; + } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return 0; + } + return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE; } } @@ -3678,6 +3733,7 @@ static int session_end_stream_headers_received(nghttp2_session *session, static int session_after_header_block_received(nghttp2_session *session) { int rv = 0; nghttp2_frame *frame = &session->iframe.frame; + nghttp2_inbound_frame *iframe = &session->iframe; nghttp2_stream *stream; /* We don't call on_frame_recv_callback if stream has been closed @@ -3736,12 +3792,22 @@ static int session_after_header_block_received(nghttp2_session *session) { return rv; } + rv = session_update_glitch_ratelim(session); + if (rv != 0) { + return rv; + } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return 0; + } + if (frame->hd.type == NGHTTP2_HEADERS && (frame->hd.flags & NGHTTP2_FLAG_END_STREAM)) { nghttp2_stream_shutdown(stream, NGHTTP2_SHUT_RD); /* Don't call nghttp2_session_close_stream_if_shut_rdwr because RST_STREAM has been submitted. */ } + return 0; } } @@ -4078,8 +4144,7 @@ static int update_remote_initial_window_size_func(void *entry, void *ptr) { rv = nghttp2_stream_update_remote_initial_window_size( stream, arg->new_window_size, arg->old_window_size); if (rv != 0) { - return nghttp2_session_add_rst_stream(arg->session, stream->stream_id, - NGHTTP2_FLOW_CONTROL_ERROR); + return NGHTTP2_ERR_FLOW_CONTROL; } /* If window size gets positive, push deferred DATA frame to @@ -4105,6 +4170,8 @@ static int update_remote_initial_window_size_func(void *entry, void *ptr) { * * NGHTTP2_ERR_NOMEM * Out of memory. + * NGHTTP2_ERR_FLOW_CONTROL + * Window size gets out of range. */ static int session_update_remote_initial_window_size(nghttp2_session *session, @@ -4128,8 +4195,7 @@ static int update_local_initial_window_size_func(void *entry, void *ptr) { rv = nghttp2_stream_update_local_initial_window_size( stream, arg->new_window_size, arg->old_window_size); if (rv != 0) { - return nghttp2_session_add_rst_stream(arg->session, stream->stream_id, - NGHTTP2_FLOW_CONTROL_ERROR); + return NGHTTP2_ERR_FLOW_CONTROL; } if (stream->window_update_queued) { @@ -4163,6 +4229,8 @@ static int update_local_initial_window_size_func(void *entry, void *ptr) { * * NGHTTP2_ERR_NOMEM * Out of memory. + * NGHTTP2_ERR_FLOW_CONTROL + * Window size gets out of range. */ static int session_update_local_initial_window_size(nghttp2_session *session, @@ -4549,9 +4617,9 @@ int nghttp2_session_on_push_promise_received(nghttp2_session *session, session->max_incoming_reserved_streams) { /* Currently, client does not retain closed stream, so we don't check NGHTTP2_SHUT_RD condition here. */ - - rv = nghttp2_session_add_rst_stream( - session, frame->push_promise.promised_stream_id, NGHTTP2_CANCEL); + rv = session_handle_invalid_stream2(session, + frame->push_promise.promised_stream_id, + NULL, NGHTTP2_ERR_PUSH_CANCEL); if (rv != 0) { return rv; } @@ -4708,8 +4776,9 @@ static int session_on_stream_window_update_received(nghttp2_session *session, } if (NGHTTP2_MAX_WINDOW_SIZE - frame->window_update.window_size_increment < stream->remote_window_size) { - return session_handle_invalid_stream(session, frame, - NGHTTP2_ERR_FLOW_CONTROL); + return session_handle_invalid_connection( + session, frame, NGHTTP2_ERR_FLOW_CONTROL, + "WINDOW_UPDATE: window size overflow"); } stream->remote_window_size += frame->window_update.window_size_increment; @@ -4925,6 +4994,7 @@ int nghttp2_session_on_data_received(nghttp2_session *session, nghttp2_frame *frame) { int rv = 0; nghttp2_stream *stream; + nghttp2_inbound_frame *iframe = &session->iframe; /* We don't call on_frame_recv_callback if stream has been closed already or being closed. */ @@ -4939,15 +5009,26 @@ int nghttp2_session_on_data_received(nghttp2_session *session, if (session_enforce_http_messaging(session) && (frame->hd.flags & NGHTTP2_FLAG_END_STREAM)) { if (nghttp2_http_on_remote_end_stream(stream) != 0) { - rv = nghttp2_session_add_rst_stream(session, stream->stream_id, - NGHTTP2_PROTOCOL_ERROR); + rv = session_handle_invalid_stream2(session, stream->stream_id, frame, + NGHTTP2_ERR_HTTP_MESSAGING); if (nghttp2_is_fatal(rv)) { return rv; } + rv = session_update_glitch_ratelim(session); + if (rv != 0) { + return rv; + } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return 0; + } + nghttp2_stream_shutdown(stream, NGHTTP2_SHUT_RD); + /* Don't call nghttp2_session_close_stream_if_shut_rdwr because RST_STREAM has been submitted. */ + return 0; } } @@ -5006,8 +5087,8 @@ int nghttp2_session_update_recv_stream_window_size(nghttp2_session *session, rv = adjust_recv_window_size(&stream->recv_window_size, delta_size, stream->local_window_size); if (rv != 0) { - return nghttp2_session_add_rst_stream(session, stream->stream_id, - NGHTTP2_FLOW_CONTROL_ERROR); + return nghttp2_session_terminate_session(session, + NGHTTP2_FLOW_CONTROL_ERROR); } /* We don't have to send WINDOW_UPDATE if the data received is the last chunk in the incoming stream. */ @@ -5469,6 +5550,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, busy = 1; rv = session_on_data_received_fail_fast(session); + if (nghttp2_is_fatal(rv)) { + return rv; + } + if (iframe->state == NGHTTP2_IB_IGN_ALL) { return (nghttp2_ssize)inlen; } @@ -5476,23 +5561,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, DEBUGF("recv: DATA not allowed stream_id=%d\n", iframe->frame.hd.stream_id); - rv = session_update_glitch_ratelim(session); - if (rv != 0) { - return rv; - } - - if (iframe->state == NGHTTP2_IB_IGN_ALL) { - return (nghttp2_ssize)inlen; - } - iframe->state = NGHTTP2_IB_IGN_DATA; break; } - if (nghttp2_is_fatal(rv)) { - return rv; - } - rv = inbound_frame_handle_pad(iframe, &iframe->frame.hd); if (rv < 0) { rv = nghttp2_session_terminate_session_with_reason( @@ -5576,6 +5648,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, return rv; } + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } + on_begin_frame_called = 1; rv = session_process_headers_frame(session); @@ -5590,8 +5666,8 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, } if (rv == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) { - rv = nghttp2_session_add_rst_stream( - session, iframe->frame.hd.stream_id, NGHTTP2_INTERNAL_ERROR); + rv = session_handle_invalid_stream2( + session, iframe->frame.hd.stream_id, NULL, NGHTTP2_ERR_INTERNAL); if (nghttp2_is_fatal(rv)) { return rv; } @@ -6044,6 +6120,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, if (nghttp2_is_fatal(rv)) { return rv; } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } } } @@ -6107,8 +6187,8 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, } if (rv == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) { - rv = nghttp2_session_add_rst_stream( - session, iframe->frame.hd.stream_id, NGHTTP2_INTERNAL_ERROR); + rv = session_handle_invalid_stream2( + session, iframe->frame.hd.stream_id, NULL, NGHTTP2_ERR_INTERNAL); if (nghttp2_is_fatal(rv)) { return rv; } @@ -6191,9 +6271,9 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, } if (rv == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) { - rv = nghttp2_session_add_rst_stream( - session, iframe->frame.push_promise.promised_stream_id, - NGHTTP2_INTERNAL_ERROR); + rv = session_handle_invalid_stream2( + session, iframe->frame.push_promise.promised_stream_id, NULL, + NGHTTP2_ERR_INTERNAL); if (nghttp2_is_fatal(rv)) { return rv; } @@ -6296,6 +6376,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, return rv; } + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } + session_inbound_frame_reset(session); break; @@ -6371,12 +6455,12 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, iframe->payloadleft -= hd_proclen; /* Use promised stream ID for PUSH_PROMISE */ - rv = nghttp2_session_add_rst_stream( + rv = session_handle_invalid_stream2( session, iframe->frame.hd.type == NGHTTP2_PUSH_PROMISE ? iframe->frame.push_promise.promised_stream_id : iframe->frame.hd.stream_id, - NGHTTP2_INTERNAL_ERROR); + NULL, NGHTTP2_ERR_INTERNAL); if (nghttp2_is_fatal(rv)) { return rv; } @@ -6423,6 +6507,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, if (nghttp2_is_fatal(rv)) { return rv; } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } } session_inbound_frame_reset(session); @@ -6598,6 +6686,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, if (nghttp2_is_fatal(rv)) { return rv; } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } } else { iframe->state = NGHTTP2_IB_IGN_HEADER_BLOCK; } @@ -6648,6 +6740,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, if (nghttp2_is_fatal(rv)) { return rv; } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } } busy = 1; @@ -6720,6 +6816,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, return rv; } + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } + data_readlen = inbound_frame_effective_readlen(iframe, iframe->payloadleft, readlen); @@ -6763,13 +6863,25 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, } } - rv = nghttp2_session_add_rst_stream( - session, iframe->frame.hd.stream_id, NGHTTP2_PROTOCOL_ERROR); + rv = session_handle_invalid_stream2( + session, iframe->frame.hd.stream_id, &iframe->frame, + NGHTTP2_ERR_PROTO); if (nghttp2_is_fatal(rv)) { return rv; } + + rv = session_update_glitch_ratelim(session); + if (rv != 0) { + return rv; + } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } + busy = 1; iframe->state = NGHTTP2_IB_IGN_DATA; + break; } } @@ -6777,13 +6889,17 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, rv = session->callbacks.on_data_chunk_recv_callback( session, iframe->frame.hd.flags, iframe->frame.hd.stream_id, in - readlen, (size_t)data_readlen, session->user_data); - if (rv == NGHTTP2_ERR_PAUSE) { - return (nghttp2_ssize)(in - first); - } - if (nghttp2_is_fatal(rv)) { return NGHTTP2_ERR_CALLBACK_FAILURE; } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } + + if (rv == NGHTTP2_ERR_PAUSE) { + return (nghttp2_ssize)(in - first); + } } } } @@ -6797,6 +6913,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, return rv; } + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } + session_inbound_frame_reset(session); break; @@ -6863,6 +6983,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, return rv; } + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } + if (rv != 0) { busy = 1; @@ -6881,6 +7005,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, return rv; } + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } + session_inbound_frame_reset(session); break; @@ -6909,6 +7037,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, return rv; } + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } + session_inbound_frame_reset(session); break; @@ -7372,13 +7504,13 @@ int nghttp2_session_pack_data(nghttp2_session *session, nghttp2_bufs *bufs, case NGHTTP2_DATA_PROVIDER_V1: payloadlen = (nghttp2_ssize)aux_data->dpw.data_prd.v1.read_callback( session, frame->hd.stream_id, buf->pos, datamax, &data_flags, - &aux_data->dpw.data_prd.source, session->user_data); + &aux_data->dpw.data_prd.v1.source, session->user_data); break; case NGHTTP2_DATA_PROVIDER_V2: payloadlen = aux_data->dpw.data_prd.v2.read_callback( session, frame->hd.stream_id, buf->pos, datamax, &data_flags, - &aux_data->dpw.data_prd.source, session->user_data); + &aux_data->dpw.data_prd.v2.source, session->user_data); break; default: diff --git a/deps/nghttp2/lib/nghttp2_session.h b/deps/nghttp2/lib/nghttp2_session.h index edbef80d397123..cab30687c075df 100644 --- a/deps/nghttp2/lib/nghttp2_session.h +++ b/deps/nghttp2/lib/nghttp2_session.h @@ -107,8 +107,8 @@ typedef struct { #define NGHTTP2_DEFAULT_STREAM_RESET_RATE 33 /* The default values for glitch rate limiter. */ -#define NGHTTP2_DEFAULT_GLITCH_BURST 1000 -#define NGHTTP2_DEFAULT_GLITCH_RATE 33 +#define NGHTTP2_DEFAULT_GLITCH_BURST 10000 +#define NGHTTP2_DEFAULT_GLITCH_RATE 330 /* The default max number of CONTINUATION frames following an incoming HEADER frame. */ diff --git a/deps/nghttp2/lib/nghttp2_submit.c b/deps/nghttp2/lib/nghttp2_submit.c index 8a90f714e4a4b5..d6bcae9deaf504 100644 --- a/deps/nghttp2/lib/nghttp2_submit.c +++ b/deps/nghttp2/lib/nghttp2_submit.c @@ -57,7 +57,7 @@ static int32_t submit_headers_shared(nghttp2_session *session, uint8_t flags, nghttp2_outbound_item_init(item); - if (dpw != NULL && dpw->data_prd.read_callback != NULL) { + if (dpw != NULL && nghttp2_data_provider_wrap_contains_read_callback(dpw)) { item->aux_data.headers.dpw = *dpw; } @@ -649,7 +649,7 @@ int nghttp2_submit_priority_update(nghttp2_session *session, uint8_t flags, static uint8_t set_request_flags(const nghttp2_data_provider_wrap *dpw) { uint8_t flags = NGHTTP2_FLAG_NONE; - if (dpw == NULL || dpw->data_prd.read_callback == NULL) { + if (dpw == NULL || !nghttp2_data_provider_wrap_contains_read_callback(dpw)) { flags |= NGHTTP2_FLAG_END_STREAM; } @@ -700,7 +700,7 @@ int32_t nghttp2_submit_request2(nghttp2_session *session, static uint8_t set_response_flags(const nghttp2_data_provider_wrap *dpw) { uint8_t flags = NGHTTP2_FLAG_NONE; - if (dpw == NULL || dpw->data_prd.read_callback == NULL) { + if (dpw == NULL || !nghttp2_data_provider_wrap_contains_read_callback(dpw)) { flags |= NGHTTP2_FLAG_END_STREAM; } return flags; From 4a32c00fb8dbe55c3bcf9ef43343968c9fe449e6 Mon Sep 17 00:00:00 2001 From: Tim Perry Date: Wed, 22 Apr 2026 13:36:27 +0200 Subject: [PATCH 2/2] deps: fix integration issues with the latest nghttp2 This is a set of src & tests fixes for nghttp2 due to changes in v1.67.0+ which require a selection of changes to how we handle low-level protocol errors when using the latest versions of nghttp2, changing both some src error handling and updating some tests to match. Signed-off-by: Tim Perry PR-URL: https://github.com/nodejs/node/pull/62891 Reviewed-By: Luigi Pinca Reviewed-By: Stephen Belanger Reviewed-By: Antoine du Hamel --- src/node_http2.cc | 31 +++++++ src/node_http2.h | 2 + ...t-http2-misbehaving-flow-control-paused.js | 29 ++++-- .../test-http2-misbehaving-flow-control.js | 29 ++++-- ...tp2-options-max-headers-exceeds-nghttp2.js | 12 ++- ...http2-session-cleanup-on-nghttp2-goaway.js | 91 +++++++++++++++++++ tools/nix/sharedLibDeps.nix | 13 +-- 7 files changed, 177 insertions(+), 30 deletions(-) create mode 100644 test/parallel/test-http2-session-cleanup-on-nghttp2-goaway.js diff --git a/src/node_http2.cc b/src/node_http2.cc index 084a4773673e5b..55bca557a81e4d 100644 --- a/src/node_http2.cc +++ b/src/node_http2.cc @@ -1265,6 +1265,24 @@ int Http2Session::OnFrameSent(nghttp2_session* handle, void* user_data) { Http2Session* session = static_cast(user_data); session->statistics_.frame_sent += 1; + + // If nghttp2 has internally terminated the session (e.g. due to a protocol + // error like oversized frames, padding errors, or HPACK compression + // failures), it calls nghttp2_session_terminate_session() directly which + // queues a GOAWAY but does not invoke any application-level callback. + // Detect that case here: a GOAWAY was sent but we never initiated it + // (no Close(), no session.close(), no session.goaway()). + // + // We set a flag here, and then throw the error at the end of + // SendPendingData, to wait until the GOAWAY is written before the session + // is torn down. + if (frame->hd.type == NGHTTP2_GOAWAY && !session->is_closing() && + !session->is_destroyed() && !session->IsGracefulCloseInitiated() && + !session->goaway_initiated_) { + Debug(session, "nghttp2 session terminated internally"); + session->internal_goaway_sent_ = true; + } + return 0; } @@ -1999,6 +2017,18 @@ uint8_t Http2Session::SendPendingData() { MaybeStopReading(); + // If nghttp2 has internally torn down the session (detected in OnFrameSent) + // during the nghttp2_session_mem_send loop above, at this point we error: + if (internal_goaway_sent_) { + internal_goaway_sent_ = false; + if (!is_closing() && !is_destroyed()) { + Isolate* isolate = env()->isolate(); + HandleScope scope(isolate); + Local arg = Integer::New(isolate, NGHTTP2_ERR_PROTO); + MakeCallback(env()->http2session_on_error_function(), 1, &arg); + } + } + return 0; } @@ -2940,6 +2970,7 @@ void Http2Session::Goaway(uint32_t code, if (is_destroyed()) return; + goaway_initiated_ = true; Http2Scope h2scope(this); // the last proc stream id is the most recently created Http2Stream. if (lastStreamID <= 0) diff --git a/src/node_http2.h b/src/node_http2.h index 259b71840b66d4..28245d7b98e06b 100644 --- a/src/node_http2.h +++ b/src/node_http2.h @@ -971,6 +971,8 @@ class Http2Session : public AsyncWrap, // Flag to indicate that JavaScript has initiated a graceful closure bool graceful_close_initiated_ = false; + bool goaway_initiated_ = false; + bool internal_goaway_sent_ = false; }; struct Http2SessionPerformanceEntryTraits { diff --git a/test/parallel/test-http2-misbehaving-flow-control-paused.js b/test/parallel/test-http2-misbehaving-flow-control-paused.js index 7059cf950e699b..b9a0d5cb81ecd5 100644 --- a/test/parallel/test-http2-misbehaving-flow-control-paused.js +++ b/test/parallel/test-http2-misbehaving-flow-control-paused.js @@ -47,23 +47,29 @@ const data = Buffer.from([ // Bad client! Bad! // // Fortunately, nghttp2 handles this situation for us by keeping track -// of the flow control window and responding with a FLOW_CONTROL_ERROR -// causing the stream to get shut down... -// -// At least, that's what is supposed to happen. +// of the flow control window and sending GOAWAY to end the session. let client; const server = h2.createServer({ settings: { initialWindowSize: 36 } }); + +server.on('session', common.mustCall((session) => { + session.on('error', common.expectsError({ + code: 'ERR_HTTP2_ERROR', + name: 'Error', + message: 'Protocol error' + })); +})); + server.on('stream', common.mustCall((stream) => { // Set the high water mark to zero, since otherwise we still accept // reads from the source stream (if we can consume them). stream._readableState.highWaterMark = 0; stream.pause(); stream.on('error', common.expectsError({ - code: 'ERR_HTTP2_STREAM_ERROR', + code: 'ERR_HTTP2_ERROR', name: 'Error', - message: 'Stream closed with error code NGHTTP2_FLOW_CONTROL_ERROR' + message: 'Protocol error' })); stream.on('close', common.mustCall(() => { server.close(); @@ -72,11 +78,14 @@ server.on('stream', common.mustCall((stream) => { stream.on('end', common.mustNotCall()); })); -server.listen(0, () => { - client = net.connect(server.address().port, () => { +server.listen(0, common.mustCall(() => { + client = net.connect(server.address().port, common.mustCall(() => { client.write(preamble); client.write(data); client.write(data); client.write(data); - }); -}); + + // TCP connection is closed by the server + client.on('close', common.mustCall()); + })); +})); diff --git a/test/parallel/test-http2-misbehaving-flow-control.js b/test/parallel/test-http2-misbehaving-flow-control.js index 0fb876ecdd4018..fb0f7a1e0f9aff 100644 --- a/test/parallel/test-http2-misbehaving-flow-control.js +++ b/test/parallel/test-http2-misbehaving-flow-control.js @@ -58,18 +58,24 @@ const data = Buffer.from([ // Bad client! Bad! // // Fortunately, nghttp2 handles this situation for us by keeping track -// of the flow control window and responding with a FLOW_CONTROL_ERROR -// causing the stream to get shut down... -// -// At least, that's what is supposed to happen. +// of the flow control window and sending GOAWAY to end the session. let client; const server = h2.createServer({ settings: { initialWindowSize: 18 } }); + +server.on('session', common.mustCall((session) => { + session.on('error', common.expectsError({ + code: 'ERR_HTTP2_ERROR', + name: 'Error', + message: 'Protocol error' + })); +})); + server.on('stream', common.mustCall((stream) => { stream.on('error', common.expectsError({ - code: 'ERR_HTTP2_STREAM_ERROR', + code: 'ERR_HTTP2_ERROR', name: 'Error', - message: 'Stream closed with error code NGHTTP2_FLOW_CONTROL_ERROR' + message: 'Protocol error' })); stream.on('close', common.mustCall(() => { server.close(common.mustCall()); @@ -82,10 +88,13 @@ server.on('stream', common.mustCall((stream) => { server.on('close', common.mustCall()); -server.listen(0, () => { - client = net.connect(server.address().port, () => { +server.listen(0, common.mustCall(() => { + client = net.connect(server.address().port, common.mustCall(() => { client.write(preamble); client.write(data); client.write(data); - }); -}); + + // TCP connection is closed by the server + client.on('close', common.mustCall()); + })); +})); diff --git a/test/parallel/test-http2-options-max-headers-exceeds-nghttp2.js b/test/parallel/test-http2-options-max-headers-exceeds-nghttp2.js index 7767dbbc503814..46f560f96c27e8 100644 --- a/test/parallel/test-http2-options-max-headers-exceeds-nghttp2.js +++ b/test/parallel/test-http2-options-max-headers-exceeds-nghttp2.js @@ -90,11 +90,19 @@ server.listen(0, common.mustCall(() => { 0, common.mustCall(() => { const client = h2.connect(`http://localhost:${server.address().port}`); - client.on('error', common.mustNotCall()); + // The server sends oversized headers that cause a compression error on + // the client side, so nghttp2 internally terminates the client session. + client.on('error', common.expectsError({ + code: 'ERR_HTTP2_ERROR', + name: 'Error', + })); const req = client.request(); req.on('response', common.mustNotCall()); - req.on('error', common.mustNotCall()); + req.on('error', common.expectsError({ + code: 'ERR_HTTP2_ERROR', + name: 'Error', + })); req.end(); }), ); diff --git a/test/parallel/test-http2-session-cleanup-on-nghttp2-goaway.js b/test/parallel/test-http2-session-cleanup-on-nghttp2-goaway.js new file mode 100644 index 00000000000000..f3576f9f59bcbf --- /dev/null +++ b/test/parallel/test-http2-session-cleanup-on-nghttp2-goaway.js @@ -0,0 +1,91 @@ +'use strict'; + +const common = require('../common'); + +if (!common.hasCrypto) + common.skip('missing crypto'); + +const http2 = require('http2'); +const net = require('net'); + +// When nghttp2 internally sends a GOAWAY frame due to a protocol error, it +// may call nghttp2_session_terminate_session() directly, bypassing the +// on_invalid_frame_recv_callback entirely. This test ensures that even +// in that scenario, we still correctly clean up the session & connection. +// +// This test reproduces this with a client who sends a frame header with +// a length exceeding the default max_frame_size (16384). nghttp2 responds +// with GOAWAY(FRAME_SIZE_ERROR) without notifying Node through any callback. + +const server = http2.createServer(); + +server.on('session', common.mustCall((session) => { + session.on('error', common.expectsError({ + code: 'ERR_HTTP2_ERROR', + name: 'Error', + message: 'Protocol error' + })); + + session.on('close', common.mustCall(() => server.close())); +})); + +server.listen(0, common.mustCall(() => { + const conn = net.connect({ + port: server.address().port, + allowHalfOpen: true, + }); + + // HTTP/2 client connection preface. + conn.write('PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n'); + + // Empty SETTINGS frame. + const settingsFrame = Buffer.alloc(9); + settingsFrame[3] = 0x04; // type: SETTINGS + conn.write(settingsFrame); + + let inbuf = Buffer.alloc(0); + let state = 'settingsHeader'; + let settingsFrameLength; + + conn.on('data', (chunk) => { + inbuf = Buffer.concat([inbuf, chunk]); + + switch (state) { + case 'settingsHeader': + if (inbuf.length < 9) return; + settingsFrameLength = inbuf.readUIntBE(0, 3); + inbuf = inbuf.slice(9); + state = 'readingSettings'; + // Fallthrough + case 'readingSettings': { + if (inbuf.length < settingsFrameLength) return; + inbuf = inbuf.slice(settingsFrameLength); + state = 'done'; + + // ACK the server SETTINGS. + const ack = Buffer.alloc(9); + ack[3] = 0x04; // type: SETTINGS + ack[4] = 0x01; // flag: ACK + conn.write(ack); + + // Send a HEADERS frame header claiming length 16385, which exceeds + // the default max_frame_size of 16384. nghttp2 checks the length + // before reading any payload, so no body is needed. This triggers + // nghttp2_session_terminate_session(FRAME_SIZE_ERROR) directly in + // nghttp2_session_mem_recv2 — bypassing on_invalid_frame_recv_callback. + const oversized = Buffer.alloc(9); + oversized.writeUIntBE(16385, 0, 3); // length: 16385 (one over max) + oversized[3] = 0x01; // type: HEADERS + oversized[4] = 0x04; // flags: END_HEADERS + oversized.writeUInt32BE(1, 5); // stream id: 1 + conn.write(oversized); + + // No need to write the data - the header alone triggers the check. + } + } + }); + + // The server must close the connection after sending GOAWAY: + conn.on('end', common.mustCall(() => conn.end())); + conn.on('close', common.mustCall()); +}));