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 <string.h>
 
+#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 <EMPTY>\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;
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<Http2Session*>(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<Value> 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());
+}));
diff --git a/tools/nix/sharedLibDeps.nix b/tools/nix/sharedLibDeps.nix
index 27e97c132ec71b..524fd13308b72c 100644
--- a/tools/nix/sharedLibDeps.nix
+++ b/tools/nix/sharedLibDeps.nix
@@ -25,14 +25,11 @@
   hdr-histogram = pkgs.hdrhistogram_c;
   http-parser = pkgs.llhttp;
   nghttp2 = pkgs.nghttp2.overrideAttrs {
-    patches = [
-      (pkgs.fetchpatch2 {
-        url = "https://github.com/nghttp2/nghttp2/commit/7784fa979d0bcf801a35f1afbb25fb048d815cd7.patch?full_index=1";
-        revert = true;
-        excludes = [ "lib/includes/nghttp2/nghttp2.h" ];
-        hash = "sha256-RG87Qifjpl7HTP9ac2JwHj2XAbDlFgOpAnpZX3ET6gU=";
-      })
-    ];
+    version = "1.69.0";
+    src = pkgs.fetchurl {
+      url = "https://github.com/nghttp2/nghttp2/releases/download/v1.69.0/nghttp2-1.69.0.tar.bz2";
+      hash = "sha256-PxhfWxw+d4heuc8/LE2ksan3OiS/WVe4KRg60Tf4Lcg=";
+    };
   };
 }
 // (pkgs.lib.optionalAttrs withLief {