Skip to content

A truly modular keyboard

C

keybit: custom link protocol between Keybits

Nathan4ab1bc55a543
diff --git a/firmware/Core/Src/keybit_image.c b/firmware/Core/Src/keybit_image.c
index 8296b01..a09718c 100644
--- a/firmware/Core/Src/keybit_image.c
+++ b/firmware/Core/Src/keybit_image.c
@@ -1,19 +1,19 @@
/* Generated from firmware/keybit by `make image` there. Do not edit. */
#include "keybit_image.h"
-const uint32_t keybit_image_len = 4616;
-const uint8_t keybit_image_version = 3;
+const uint32_t keybit_image_len = 6224;
+const uint8_t keybit_image_version = 4;
const uint8_t keybit_image[] __attribute__((aligned(4))) = {
- 0x6f, 0x00, 0x20, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x36, 0x08, 0x00, 0x00, 0x34, 0x08, 0x00, 0x00,
+ 0x6f, 0x00, 0xf0, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x62, 0x0a, 0x00, 0x00, 0x60, 0x0a, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x34, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x34, 0x08, 0x00, 0x00, 0x34, 0x08, 0x00, 0x00, 0x34, 0x08, 0x00, 0x00, 0x34, 0x08, 0x00, 0x00,
- 0x34, 0x08, 0x00, 0x00, 0x34, 0x08, 0x00, 0x00, 0x34, 0x08, 0x00, 0x00, 0x34, 0x08, 0x00, 0x00,
- 0x34, 0x08, 0x00, 0x00, 0x34, 0x08, 0x00, 0x00, 0x34, 0x08, 0x00, 0x00, 0x34, 0x08, 0x00, 0x00,
- 0x34, 0x08, 0x00, 0x00, 0x34, 0x08, 0x00, 0x00, 0x34, 0x08, 0x00, 0x00, 0x34, 0x08, 0x00, 0x00,
- 0x34, 0x08, 0x00, 0x00, 0x34, 0x08, 0x00, 0x00, 0x34, 0x08, 0x00, 0x00, 0x34, 0x08, 0x00, 0x00,
- 0x34, 0x08, 0x00, 0x00, 0x34, 0x08, 0x00, 0x00, 0x34, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x60, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x60, 0x0a, 0x00, 0x00, 0x60, 0x0a, 0x00, 0x00, 0x60, 0x0a, 0x00, 0x00, 0x60, 0x0a, 0x00, 0x00,
+ 0x60, 0x0a, 0x00, 0x00, 0x60, 0x0a, 0x00, 0x00, 0x60, 0x0a, 0x00, 0x00, 0x60, 0x0a, 0x00, 0x00,
+ 0x60, 0x0a, 0x00, 0x00, 0x60, 0x0a, 0x00, 0x00, 0x60, 0x0a, 0x00, 0x00, 0x60, 0x0a, 0x00, 0x00,
+ 0x60, 0x0a, 0x00, 0x00, 0x60, 0x0a, 0x00, 0x00, 0x60, 0x0a, 0x00, 0x00, 0x60, 0x0a, 0x00, 0x00,
+ 0x60, 0x0a, 0x00, 0x00, 0x60, 0x0a, 0x00, 0x00, 0x60, 0x0a, 0x00, 0x00, 0x60, 0x0a, 0x00, 0x00,
+ 0x60, 0x0a, 0x00, 0x00, 0x60, 0x0a, 0x00, 0x00, 0x60, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x2a, 0x86, 0x01, 0x45, 0x93, 0xf6, 0x15, 0x00, 0x91, 0xc2, 0x32, 0x95, 0x85, 0x81, 0x06, 0x06,
0xf5, 0xf9, 0x82, 0x80, 0x00, 0x00, 0x00, 0x00, 0x63, 0x4e, 0x05, 0x02, 0x63, 0xc3, 0x05, 0x04,
0x2e, 0x86, 0xaa, 0x85, 0x7d, 0x55, 0x15, 0xc2, 0x85, 0x46, 0x63, 0x78, 0xb6, 0x00, 0x63, 0x56,
@@ -24,273 +24,373 @@ const uint8_t keybit_image[] __attribute__((aligned(4))) = {
0x86, 0x82, 0x63, 0xc7, 0x05, 0x00, 0x63, 0x49, 0x05, 0x00, 0x5d, 0x37, 0x2e, 0x85, 0x82, 0x82,
0xb3, 0x05, 0xb0, 0x40, 0xe3, 0x5b, 0x05, 0xfe, 0x33, 0x05, 0xa0, 0x40, 0x51, 0x3f, 0x33, 0x05,
0xb0, 0x40, 0x82, 0x82, 0x00, 0x00, 0xb7, 0xf7, 0x00, 0xe0, 0x9c, 0x47, 0x37, 0xf7, 0x00, 0xe0,
- 0x3e, 0x95, 0x1c, 0x47, 0x89, 0x8f, 0xe3, 0xce, 0x07, 0xfe, 0x82, 0x80, 0x83, 0xc7, 0x71, 0xc3,
- 0xbe, 0x86, 0x63, 0x53, 0xf5, 0x00, 0xaa, 0x86, 0x03, 0xc7, 0x61, 0xc3, 0x95, 0x8f, 0xa3, 0x8b,
- 0xf1, 0xc2, 0x36, 0x97, 0x7d, 0x8b, 0x23, 0x8b, 0xe1, 0xc2, 0x82, 0x80, 0x41, 0x11, 0x26, 0xc2,
- 0x03, 0xc7, 0x71, 0xc3, 0x06, 0xc6, 0x22, 0xc4, 0x93, 0x07, 0x00, 0x02, 0xaa, 0x85, 0x63, 0x16,
- 0xf7, 0x00, 0x2a, 0xc0, 0x05, 0x45, 0xd9, 0x37, 0x82, 0x45, 0x03, 0xc4, 0x71, 0xc3, 0x83, 0xc7,
- 0x61, 0xc3, 0x13, 0x85, 0x41, 0xcb, 0xa2, 0x97, 0xfd, 0x8b, 0x13, 0x97, 0x27, 0x00, 0xba, 0x97,
- 0x15, 0x46, 0x3e, 0x95, 0x4d, 0x2d, 0x05, 0x04, 0xa3, 0x8b, 0x81, 0xc2, 0xb2, 0x40, 0x22, 0x44,
- 0x92, 0x44, 0x41, 0x01, 0x82, 0x80, 0x83, 0xa7, 0x81, 0xca, 0x31, 0x11, 0x3e, 0xc0, 0x83, 0xc7,
- 0x51, 0xc3, 0x83, 0xc6, 0xe1, 0xc1, 0x06, 0xc8, 0x3d, 0x46, 0x93, 0xf7, 0xf7, 0x0f, 0x3d, 0x47,
- 0x63, 0x63, 0xd6, 0x00, 0x36, 0x87, 0x12, 0x07, 0xb3, 0x37, 0xf0, 0x00, 0xd9, 0x8f, 0x5d, 0x8d,
- 0x23, 0x02, 0xa1, 0x00, 0x0a, 0x85, 0x59, 0x37, 0xc2, 0x40, 0x51, 0x01, 0x82, 0x80, 0x51, 0x11,
- 0x93, 0x87, 0x41, 0xc0, 0x22, 0xc2, 0x2a, 0x84, 0x2e, 0x85, 0xb7, 0xd5, 0xcc, 0xcc, 0x1d, 0x8d,
- 0x93, 0x85, 0xd5, 0xcc, 0x06, 0xc4, 0x69, 0x3d, 0x13, 0x07, 0x10, 0x03, 0x93, 0x86, 0x81, 0xc4,
- 0x2a, 0x86, 0x93, 0x17, 0x15, 0x00, 0x63, 0x1d, 0xe4, 0x00, 0xaa, 0x97, 0x8e, 0x07, 0xb6, 0x97,
- 0x03, 0xc5, 0x07, 0x01, 0x13, 0x35, 0x15, 0x00, 0xa2, 0x40, 0x12, 0x44, 0x31, 0x01, 0x82, 0x80,
- 0x33, 0x87, 0xa7, 0x00, 0x0e, 0x07, 0x36, 0x97, 0x85, 0x45, 0x23, 0x08, 0xb7, 0x00, 0x03, 0xc7,
- 0x41, 0xc3, 0x19, 0xcf, 0x01, 0x45, 0xe3, 0x11, 0x87, 0xfe, 0xb2, 0x97, 0x8e, 0x07, 0xb6, 0x97,
- 0x23, 0x80, 0x07, 0x00, 0x37, 0xf7, 0x00, 0xe0, 0x18, 0x47, 0x05, 0x45, 0xd8, 0xc3, 0xe9, 0xb7,
- 0x13, 0x07, 0x00, 0x03, 0x01, 0x45, 0xe3, 0x11, 0xe4, 0xfc, 0xc5, 0xb7, 0x93, 0x07, 0xe5, 0xff,
- 0x93, 0xf7, 0xf7, 0x0f, 0x0d, 0x47, 0x63, 0x68, 0xf7, 0x00, 0x93, 0x87, 0x81, 0xca, 0xaa, 0x97,
+ 0x3e, 0x95, 0x1c, 0x47, 0x89, 0x8f, 0xe3, 0xce, 0x07, 0xfe, 0x82, 0x80, 0xaa, 0x85, 0x06, 0x05,
+ 0x33, 0x07, 0xb5, 0x00, 0x12, 0x07, 0x93, 0x87, 0xc1, 0xce, 0xba, 0x97, 0x03, 0xc7, 0x07, 0x01,
+ 0x13, 0x86, 0xc1, 0xce, 0x11, 0xcf, 0x37, 0xf7, 0x00, 0xe0, 0x14, 0x47, 0xd8, 0x4b, 0x99, 0x8e,
+ 0x37, 0x27, 0xb7, 0x00, 0x13, 0x07, 0xf7, 0xaf, 0x63, 0x74, 0xd7, 0x00, 0x23, 0x88, 0x07, 0x00,
+ 0x2e, 0x95, 0x12, 0x05, 0xb3, 0x07, 0xa6, 0x00, 0x03, 0xc5, 0x07, 0x01, 0x82, 0x80, 0xaa, 0x85,
+ 0x06, 0x05, 0x33, 0x07, 0xb5, 0x00, 0x12, 0x07, 0x93, 0x87, 0xc1, 0xce, 0xba, 0x97, 0x03, 0xc7,
+ 0x87, 0x01, 0x13, 0x86, 0xc1, 0xce, 0x11, 0xcf, 0x37, 0xf7, 0x00, 0xe0, 0x14, 0x47, 0xd8, 0x4f,
+ 0x99, 0x8e, 0x37, 0x97, 0x5b, 0x00, 0x13, 0x07, 0xf7, 0xd7, 0x63, 0x74, 0xd7, 0x00, 0x23, 0x8c,
+ 0x07, 0x00, 0x2e, 0x95, 0x12, 0x05, 0xb3, 0x07, 0xa6, 0x00, 0x03, 0xc5, 0x87, 0x01, 0x82, 0x80,
+ 0x83, 0xc7, 0xf1, 0xc2, 0xbe, 0x86, 0x63, 0x53, 0xf5, 0x00, 0xaa, 0x86, 0x03, 0xc7, 0xe1, 0xc2,
+ 0x95, 0x8f, 0xa3, 0x87, 0xf1, 0xc2, 0x36, 0x97, 0x7d, 0x8b, 0x23, 0x87, 0xe1, 0xc2, 0x82, 0x80,
+ 0x41, 0x11, 0x26, 0xc2, 0x03, 0xc7, 0xf1, 0xc2, 0x06, 0xc6, 0x22, 0xc4, 0x93, 0x07, 0x00, 0x02,
+ 0xaa, 0x85, 0x63, 0x16, 0xf7, 0x00, 0x2a, 0xc0, 0x05, 0x45, 0xd9, 0x37, 0x82, 0x45, 0x03, 0xc4,
+ 0xf1, 0xc2, 0x83, 0xc7, 0xe1, 0xc2, 0x13, 0x85, 0xc1, 0xc4, 0xa2, 0x97, 0xfd, 0x8b, 0x13, 0x97,
+ 0x27, 0x00, 0xba, 0x97, 0x15, 0x46, 0x3e, 0x95, 0xef, 0x00, 0xb0, 0x05, 0x05, 0x04, 0xa3, 0x87,
+ 0x81, 0xc2, 0xb2, 0x40, 0x22, 0x44, 0x92, 0x44, 0x41, 0x01, 0x82, 0x80, 0x83, 0xa7, 0x01, 0xc4,
+ 0x31, 0x11, 0x3e, 0xc0, 0x83, 0xc7, 0xd1, 0xc2, 0x83, 0xc6, 0x21, 0xc2, 0x06, 0xc8, 0x3d, 0x46,
+ 0x93, 0xf7, 0xf7, 0x0f, 0x3d, 0x47, 0x63, 0x63, 0xd6, 0x00, 0x36, 0x87, 0x12, 0x07, 0xb3, 0x37,
+ 0xf0, 0x00, 0xd9, 0x8f, 0x5d, 0x8d, 0x23, 0x02, 0xa1, 0x00, 0x0a, 0x85, 0x51, 0x37, 0xc2, 0x40,
+ 0x51, 0x01, 0x82, 0x80, 0x51, 0x11, 0x93, 0x87, 0x41, 0xc0, 0x22, 0xc2, 0x2a, 0x84, 0x2e, 0x85,
+ 0xb7, 0xd5, 0xcc, 0xcc, 0x93, 0x85, 0xd5, 0xcc, 0x1d, 0x8d, 0x06, 0xc4, 0x11, 0x3d, 0x13, 0x17,
+ 0x15, 0x00, 0xb3, 0x05, 0xa7, 0x00, 0x13, 0x86, 0xc1, 0xce, 0x92, 0x05, 0x2e, 0x96, 0x85, 0x45,
+ 0x23, 0x08, 0xb6, 0x00, 0xb7, 0xf5, 0x00, 0xe0, 0x8c, 0x45, 0x23, 0x0c, 0x06, 0x00, 0xaa, 0x86,
+ 0x4c, 0xca, 0x03, 0xc6, 0xc1, 0xc2, 0x93, 0x87, 0xc1, 0xce, 0x05, 0xc2, 0x01, 0x45, 0x63, 0x13,
+ 0x86, 0x02, 0x36, 0x97, 0x12, 0x07, 0x33, 0x85, 0xe7, 0x00, 0x23, 0x00, 0x05, 0x00, 0xb7, 0xf7,
+ 0x00, 0xe0, 0x9c, 0x47, 0x5c, 0xc1, 0x05, 0x45, 0x31, 0xa0, 0x13, 0x06, 0x00, 0x03, 0x01, 0x45,
+ 0xe3, 0x01, 0xc4, 0xfe, 0xa2, 0x40, 0x12, 0x44, 0x31, 0x01, 0x82, 0x80, 0x93, 0x07, 0xe5, 0xff,
+ 0x93, 0xf7, 0xf7, 0x0f, 0x0d, 0x47, 0x63, 0x68, 0xf7, 0x00, 0x93, 0x87, 0x01, 0xc4, 0xaa, 0x97,
0x03, 0xc5, 0xe7, 0xff, 0x82, 0x80, 0x93, 0x07, 0x05, 0xff, 0x93, 0xf7, 0xf7, 0x0f, 0x2d, 0x47,
- 0x63, 0x68, 0xf7, 0x00, 0x93, 0x87, 0x81, 0xca, 0xaa, 0x97, 0x03, 0xc5, 0x07, 0xff, 0x82, 0x80,
+ 0x63, 0x68, 0xf7, 0x00, 0x93, 0x87, 0x01, 0xc4, 0xaa, 0x97, 0x03, 0xc5, 0x07, 0xff, 0x82, 0x80,
0x51, 0x11, 0x26, 0xc0, 0x93, 0x04, 0xd5, 0xfa, 0x06, 0xc4, 0x22, 0xc2, 0x13, 0xf7, 0xf4, 0x0f,
- 0x93, 0x07, 0x70, 0x02, 0x63, 0xe7, 0xe7, 0x04, 0x95, 0x45, 0x26, 0x85, 0xf5, 0x3b, 0x83, 0xc7,
- 0x71, 0xc3, 0x2a, 0x84, 0x13, 0x05, 0xf0, 0x0f, 0x63, 0x55, 0xf4, 0x02, 0x95, 0x45, 0x26, 0x85,
- 0x81, 0x35, 0x03, 0xc7, 0x61, 0xc3, 0x93, 0x87, 0x41, 0xcb, 0x22, 0x97, 0x7d, 0x8b, 0x93, 0x16,
+ 0x93, 0x07, 0x70, 0x02, 0x63, 0xe7, 0xe7, 0x04, 0x95, 0x45, 0x26, 0x85, 0xb5, 0x3b, 0x83, 0xc7,
+ 0xf1, 0xc2, 0x2a, 0x84, 0x13, 0x05, 0xf0, 0x0f, 0x63, 0x55, 0xf4, 0x02, 0x95, 0x45, 0x26, 0x85,
+ 0xc1, 0x33, 0x03, 0xc7, 0xe1, 0xc2, 0x93, 0x87, 0xc1, 0xc4, 0x22, 0x97, 0x7d, 0x8b, 0x93, 0x16,
0x27, 0x00, 0xba, 0x96, 0x91, 0x45, 0xb6, 0x97, 0x63, 0x0a, 0xb5, 0x00, 0x3e, 0x95, 0x03, 0x45,
0x05, 0x00, 0xa2, 0x40, 0x12, 0x44, 0x82, 0x44, 0x31, 0x01, 0x82, 0x80, 0x03, 0xc5, 0x47, 0x00,
- 0xcd, 0xbf, 0xa1, 0x47, 0x63, 0xec, 0xa7, 0x00, 0x85, 0x67, 0x93, 0x87, 0x47, 0x1c, 0x0a, 0x05,
+ 0xcd, 0xbf, 0xa1, 0x47, 0x63, 0xec, 0xa7, 0x00, 0x89, 0x67, 0x93, 0x87, 0xc7, 0x80, 0x0a, 0x05,
0x3e, 0x95, 0x1c, 0x41, 0x82, 0x87, 0x13, 0x05, 0xb0, 0x04, 0xe1, 0xbf, 0x13, 0x07, 0x10, 0x05,
0x63, 0x04, 0xe5, 0x02, 0x13, 0x07, 0x20, 0x05, 0x63, 0x03, 0xe5, 0x02, 0x13, 0x05, 0xf0, 0x0f,
- 0xc9, 0xb7, 0x03, 0xc5, 0x51, 0xc3, 0x13, 0x75, 0xf5, 0x0f, 0x65, 0xbf, 0x03, 0xc5, 0x25, 0x00,
- 0x4d, 0xbf, 0x03, 0xc5, 0x41, 0xc3, 0x75, 0xb7, 0x03, 0xc5, 0xe1, 0xc1, 0x5d, 0xb7, 0x03, 0xc7,
- 0x71, 0xc3, 0x13, 0x75, 0xf7, 0x0f, 0xe3, 0xfe, 0xe7, 0xf8, 0x21, 0x45, 0x59, 0xbf, 0x0d, 0x45,
- 0x49, 0xbf, 0x03, 0xc7, 0x41, 0xc3, 0x19, 0xc7, 0x63, 0x16, 0xa7, 0x00, 0x23, 0x8a, 0x01, 0xc2,
- 0x23, 0x9e, 0x01, 0xc0, 0x82, 0x80, 0x83, 0x47, 0x15, 0x00, 0xb7, 0x16, 0x01, 0x40, 0x93, 0x86,
- 0x06, 0x80, 0x13, 0xd7, 0x47, 0x00, 0x2a, 0x07, 0x13, 0xf6, 0xf7, 0x00, 0xe1, 0x67, 0x36, 0x97,
- 0x93, 0x87, 0x07, 0x6a, 0x14, 0x47, 0xb3, 0xd6, 0xc6, 0x00, 0x85, 0x8a, 0x63, 0x86, 0xb6, 0x00,
- 0xfd, 0x17, 0xed, 0xfb, 0x01, 0x45, 0x82, 0x80, 0x05, 0x45, 0x82, 0x80, 0x21, 0x11, 0x37, 0x13,
- 0x01, 0x40, 0x22, 0xc8, 0x26, 0xc6, 0x06, 0xca, 0x2a, 0xc0, 0x2e, 0xc2, 0x21, 0x44, 0x81, 0x44,
- 0x13, 0x03, 0x03, 0x80, 0x02, 0x45, 0x81, 0x45, 0x1a, 0xc4, 0x75, 0x37, 0x22, 0x43, 0x19, 0xe5,
- 0x0d, 0x45, 0xd2, 0x40, 0x42, 0x44, 0xb2, 0x44, 0x61, 0x01, 0x82, 0x80, 0x02, 0x45, 0x85, 0x45,
- 0x1a, 0xc4, 0x51, 0x3f, 0x75, 0xd5, 0x82, 0x47, 0x22, 0x43, 0x05, 0x45, 0x83, 0xc5, 0x07, 0x00,
- 0x83, 0xc7, 0x17, 0x00, 0xe1, 0x63, 0x93, 0xd6, 0x45, 0x00, 0xaa, 0x06, 0x9a, 0x96, 0x98, 0x46,
- 0x13, 0xd6, 0x47, 0x00, 0xbd, 0x89, 0x33, 0x57, 0xb7, 0x00, 0x2a, 0x06, 0xbd, 0x8b, 0x05, 0x8b,
- 0x1a, 0x96, 0x33, 0x15, 0xf5, 0x00, 0x93, 0x83, 0x13, 0x6a, 0x1c, 0x46, 0xe9, 0x8f, 0x81, 0xef,
- 0x86, 0x04, 0xd9, 0x8c, 0x7d, 0x14, 0x93, 0xf4, 0xf4, 0x0f, 0x49, 0xfc, 0x92, 0x47, 0x01, 0x45,
- 0x23, 0x80, 0x97, 0x00, 0x79, 0xbf, 0x9c, 0x46, 0xb3, 0xd7, 0xb7, 0x00, 0x85, 0x8b, 0x63, 0x05,
- 0xf7, 0x00, 0x13, 0x85, 0x17, 0x00, 0x71, 0xb7, 0xfd, 0x13, 0xe3, 0x98, 0x03, 0xfc, 0x49, 0xb7,
- 0x41, 0x11, 0x26, 0xc2, 0x06, 0xc6, 0x22, 0xc4, 0x03, 0x44, 0x05, 0x00, 0x37, 0x17, 0x01, 0x40,
- 0x13, 0x07, 0x07, 0x80, 0x93, 0x74, 0xf4, 0x00, 0x11, 0x80, 0x2a, 0x04, 0x3a, 0x94, 0x93, 0x86,
- 0x04, 0x01, 0x05, 0x47, 0x33, 0x17, 0xd7, 0x00, 0x18, 0xc8, 0x85, 0x45, 0x2a, 0xc0, 0xe5, 0x3d,
- 0x82, 0x47, 0x11, 0xc5, 0x81, 0x45, 0x3e, 0x85, 0xfd, 0x35, 0x33, 0x35, 0xa0, 0x00, 0x85, 0x47,
- 0xb3, 0x97, 0x97, 0x00, 0xb2, 0x40, 0x1c, 0xc8, 0x22, 0x44, 0x92, 0x44, 0x41, 0x01, 0x82, 0x80,
- 0x41, 0x11, 0x22, 0xc4, 0x26, 0xc2, 0x06, 0xc6, 0x2a, 0x84, 0x93, 0x04, 0x00, 0x04, 0x93, 0x05,
- 0x31, 0x00, 0x22, 0x85, 0xe5, 0x3d, 0x13, 0x07, 0xe5, 0xff, 0x85, 0x47, 0x63, 0xf5, 0xe7, 0x00,
- 0x01, 0xc9, 0xfd, 0x14, 0xed, 0xf4, 0xb2, 0x40, 0x22, 0x44, 0x92, 0x44, 0x41, 0x01, 0x82, 0x80,
- 0x85, 0x45, 0x22, 0x85, 0x4d, 0x35, 0x65, 0xd9, 0x81, 0x45, 0x22, 0x85, 0x69, 0x3d, 0x75, 0xf1,
- 0xdd, 0xb7, 0x03, 0x47, 0x15, 0x00, 0xb7, 0x16, 0x01, 0x40, 0x93, 0x86, 0x06, 0x80, 0x93, 0x57,
- 0x47, 0x00, 0xaa, 0x07, 0xb6, 0x97, 0x3d, 0x8b, 0x85, 0x46, 0x33, 0x97, 0xe6, 0x00, 0x98, 0xcb,
- 0x85, 0x45, 0x95, 0xbd, 0x31, 0x11, 0x06, 0xc8, 0x22, 0xc6, 0x26, 0xc4, 0x03, 0x44, 0x05, 0x00,
- 0xb7, 0x16, 0x01, 0x40, 0x93, 0x86, 0x06, 0x80, 0x13, 0x57, 0x44, 0x00, 0x2a, 0x07, 0x36, 0x97,
- 0x1c, 0x47, 0x3d, 0x88, 0xb3, 0xd7, 0x87, 0x00, 0x85, 0x8b, 0x99, 0xe7, 0x01, 0x45, 0xc2, 0x40,
- 0x32, 0x44, 0xa2, 0x44, 0x51, 0x01, 0x82, 0x80, 0x83, 0x44, 0x15, 0x00, 0x3a, 0xc2, 0x93, 0xd7,
- 0x44, 0x00, 0xaa, 0x07, 0xb6, 0x97, 0x94, 0x47, 0xbd, 0x88, 0x3e, 0xc0, 0xb3, 0xd6, 0x96, 0x00,
- 0x85, 0x8a, 0xe9, 0xde, 0x79, 0x45, 0xc5, 0x36, 0x12, 0x47, 0x14, 0x47, 0xb3, 0xd6, 0x86, 0x00,
- 0x85, 0x8a, 0xe9, 0xd6, 0x82, 0x47, 0x94, 0x47, 0xb3, 0xd6, 0x96, 0x00, 0x85, 0x8a, 0xdd, 0xde,
- 0x85, 0x46, 0x41, 0x04, 0x33, 0x94, 0x86, 0x00, 0x00, 0xcb, 0x13, 0x05, 0x80, 0x07, 0x65, 0x3e,
- 0x82, 0x47, 0xc1, 0x04, 0x85, 0x46, 0xb3, 0x96, 0x96, 0x00, 0x79, 0x45, 0x94, 0xcb, 0x65, 0x36,
- 0x05, 0x45, 0x71, 0xbf, 0x31, 0x11, 0x06, 0xc8, 0x26, 0xc4, 0x22, 0xc6, 0x03, 0x44, 0x05, 0x00,
- 0x37, 0x17, 0x01, 0x40, 0x13, 0x07, 0x07, 0x80, 0x93, 0x76, 0xf4, 0x00, 0x11, 0x80, 0x2a, 0x04,
- 0x3a, 0x94, 0x85, 0x44, 0x13, 0x87, 0x06, 0x01, 0x33, 0x97, 0xe4, 0x00, 0x18, 0xc8, 0x2a, 0xc2,
- 0x79, 0x45, 0x36, 0xc0, 0x8d, 0x3e, 0x92, 0x47, 0x3e, 0x85, 0x21, 0x3f, 0x79, 0x45, 0xa5, 0x36,
- 0x82, 0x46, 0xc2, 0x40, 0x79, 0x45, 0xb3, 0x94, 0xd4, 0x00, 0x04, 0xc8, 0x32, 0x44, 0xa2, 0x44,
- 0x51, 0x01, 0x91, 0xbe, 0x93, 0x57, 0x45, 0x00, 0xb7, 0x16, 0x01, 0x40, 0x93, 0x86, 0x06, 0x80,
- 0x05, 0x47, 0xaa, 0x07, 0x3d, 0x89, 0xb6, 0x97, 0x33, 0x15, 0xa7, 0x00, 0x88, 0xcb, 0x93, 0xd7,
- 0x45, 0x00, 0xaa, 0x07, 0xbd, 0x89, 0xb6, 0x97, 0x33, 0x17, 0xb7, 0x00, 0x98, 0xcb, 0x82, 0x80,
- 0x21, 0x11, 0x22, 0xc8, 0x26, 0xc6, 0x06, 0xca, 0x03, 0x47, 0x05, 0x00, 0xb7, 0x17, 0x01, 0x40,
- 0x93, 0x87, 0x07, 0x80, 0x93, 0x54, 0x47, 0x00, 0xaa, 0x04, 0x2a, 0x84, 0xbe, 0x94, 0x93, 0x76,
- 0xf7, 0x00, 0x8d, 0xcd, 0x85, 0x47, 0xb3, 0x97, 0xd7, 0x00, 0x9c, 0xc8, 0x79, 0x45, 0x2e, 0xc4,
- 0x36, 0xc2, 0x3a, 0xc0, 0xcd, 0x3c, 0x22, 0x85, 0x69, 0x3d, 0x02, 0x47, 0x92, 0x46, 0xa2, 0x45,
- 0x05, 0xe5, 0x2a, 0xc0, 0x83, 0x45, 0x14, 0x00, 0x03, 0x45, 0x04, 0x00, 0x61, 0x37, 0x82, 0x47,
- 0xd2, 0x40, 0x42, 0x44, 0xb2, 0x44, 0x3e, 0x85, 0x61, 0x01, 0x82, 0x80, 0x13, 0x86, 0x06, 0x01,
- 0x85, 0x47, 0xb3, 0x97, 0xc7, 0x00, 0xd1, 0xb7, 0x81, 0xcd, 0x9c, 0x44, 0xb3, 0xd7, 0xd7, 0x00,
- 0x85, 0x8b, 0x99, 0xe7, 0x83, 0x45, 0x14, 0x00, 0x3a, 0x85, 0xa9, 0x3f, 0xfd, 0x57, 0xc9, 0xbf,
- 0x79, 0x45, 0x55, 0x34, 0x83, 0x47, 0x14, 0x00, 0xb7, 0x16, 0x01, 0x40, 0x93, 0x86, 0x06, 0x80,
- 0x13, 0xd7, 0x47, 0x00, 0x2a, 0x07, 0xbd, 0x8b, 0x36, 0x97, 0xc1, 0x07, 0x85, 0x46, 0xb3, 0x97,
- 0xf6, 0x00, 0x1c, 0xcb, 0x85, 0x47, 0x6d, 0xb7, 0x21, 0x11, 0x06, 0xca, 0x22, 0xc8, 0x26, 0xc6,
- 0x83, 0x47, 0x05, 0x00, 0xb7, 0x14, 0x01, 0x40, 0x93, 0x84, 0x04, 0x80, 0x93, 0xf6, 0xf7, 0x00,
- 0x91, 0x83, 0xaa, 0x07, 0x05, 0x47, 0xa6, 0x97, 0x33, 0x17, 0xd7, 0x00, 0x98, 0xcb, 0x2a, 0x84,
- 0x79, 0x45, 0x2e, 0xc4, 0x36, 0xc2, 0x3e, 0xc0, 0xb9, 0x34, 0x22, 0x85, 0xdd, 0x3b, 0x82, 0x47,
- 0x92, 0x46, 0xa2, 0x45, 0x11, 0xed, 0x2a, 0xc0, 0x83, 0x45, 0x14, 0x00, 0x03, 0x45, 0x04, 0x00,
- 0xd5, 0x35, 0x02, 0x47, 0xd2, 0x40, 0x42, 0x44, 0xb2, 0x44, 0x3a, 0x85, 0x61, 0x01, 0x82, 0x80,
- 0x9c, 0x47, 0x79, 0x45, 0xb3, 0xd7, 0xd7, 0x00, 0x85, 0x8b, 0x9c, 0xc1, 0x29, 0x3c, 0x83, 0x47,
- 0x14, 0x00, 0x85, 0x46, 0x13, 0xd7, 0x47, 0x00, 0xbd, 0x8b, 0x2a, 0x07, 0xc1, 0x07, 0x26, 0x97,
- 0xb3, 0x94, 0xf6, 0x00, 0x04, 0xcb, 0x05, 0x47, 0xf1, 0xb7, 0x31, 0x11, 0x22, 0xc6, 0x26, 0xc4,
- 0x06, 0xc8, 0x2a, 0xc0, 0x2e, 0x84, 0x9d, 0x44, 0x02, 0x45, 0xb3, 0x55, 0x94, 0x40, 0x85, 0x89,
- 0xc1, 0x35, 0x05, 0x47, 0x63, 0x1d, 0xe5, 0x00, 0xfd, 0x14, 0x7d, 0x57, 0xe3, 0x96, 0xe4, 0xfe,
- 0x02, 0x45, 0x4c, 0x00, 0x91, 0x3f, 0x01, 0xc5, 0x12, 0x45, 0x13, 0x35, 0x15, 0x00, 0xc2, 0x40,
- 0x32, 0x44, 0xa2, 0x44, 0x51, 0x01, 0x82, 0x80, 0x11, 0x11, 0x22, 0xca, 0x26, 0xc8, 0x06, 0xcc,
- 0x2a, 0xc0, 0x2e, 0x84, 0x21, 0x47, 0x81, 0x44, 0x02, 0x45, 0x6c, 0x00, 0x32, 0xc4, 0x3a, 0xc2,
- 0x25, 0x37, 0x1d, 0xc1, 0xb2, 0x46, 0x12, 0x47, 0x86, 0x04, 0xd5, 0x8c, 0x7d, 0x17, 0x22, 0x46,
- 0x93, 0xf4, 0xf4, 0x0f, 0x75, 0xf3, 0x02, 0x45, 0x23, 0x00, 0x94, 0x00, 0x93, 0x45, 0x16, 0x00,
- 0x85, 0x35, 0x7d, 0x15, 0x13, 0x35, 0x15, 0x00, 0xe2, 0x40, 0x52, 0x44, 0xc2, 0x44, 0x71, 0x01,
- 0x82, 0x80, 0x97, 0x01, 0x00, 0x20, 0x93, 0x81, 0xa1, 0xc3, 0x13, 0x81, 0x41, 0x40, 0x09, 0x65,
- 0x13, 0x05, 0x05, 0x88, 0x73, 0x10, 0x05, 0x30, 0x97, 0x06, 0x00, 0x00, 0x93, 0x86, 0x86, 0x82,
- 0x93, 0xe6, 0x36, 0x00, 0x73, 0x90, 0x56, 0x30, 0x13, 0x85, 0x41, 0xc2, 0x93, 0x85, 0x41, 0xd5,
- 0x01, 0x46, 0x63, 0x56, 0xb5, 0x00, 0x10, 0xc1, 0x11, 0x05, 0xe3, 0x4e, 0xb5, 0xfe, 0x17, 0x15,
- 0x00, 0x00, 0x13, 0x05, 0xa5, 0x9e, 0x93, 0x85, 0x41, 0xc0, 0x13, 0x86, 0x41, 0xc2, 0x63, 0x88,
- 0xc5, 0x00, 0x14, 0x41, 0x94, 0xc1, 0x11, 0x05, 0x91, 0x05, 0xe3, 0x9a, 0xc5, 0xfe, 0xb7, 0xf7,
- 0x00, 0xe0, 0x05, 0x47, 0x98, 0xc3, 0x85, 0x67, 0x93, 0x87, 0x47, 0x99, 0x73, 0x90, 0x17, 0x34,
- 0x73, 0x00, 0x20, 0x30, 0x01, 0xa0, 0x37, 0x17, 0x02, 0x40, 0x1c, 0x47, 0xb7, 0x06, 0x80, 0x00,
- 0xd5, 0x8f, 0x1c, 0xc7, 0x2a, 0x96, 0xaa, 0x87, 0x63, 0x93, 0xc7, 0x00, 0x82, 0x80, 0x23, 0x80,
- 0xb7, 0x00, 0x85, 0x07, 0xd5, 0xbf, 0x81, 0x47, 0x63, 0x13, 0xf6, 0x00, 0x82, 0x80, 0x33, 0x87,
- 0xf5, 0x00, 0x83, 0x46, 0x07, 0x00, 0x33, 0x07, 0xf5, 0x00, 0x85, 0x07, 0x23, 0x00, 0xd7, 0x00,
- 0xe5, 0xb7, 0x11, 0xce, 0x83, 0x47, 0x05, 0x00, 0x03, 0xc7, 0x05, 0x00, 0x63, 0x85, 0xe7, 0x00,
- 0x33, 0x85, 0xe7, 0x40, 0x82, 0x80, 0x7d, 0x16, 0x05, 0x05, 0x85, 0x05, 0xdd, 0xb7, 0x01, 0x45,
- 0x82, 0x80, 0x51, 0x11, 0x22, 0xc2, 0x06, 0xc4, 0x13, 0x07, 0x00, 0x05, 0x2e, 0x84, 0x63, 0x1d,
- 0xe5, 0x02, 0x93, 0x87, 0x41, 0xc0, 0xb7, 0xd5, 0xcc, 0xcc, 0x33, 0x05, 0xf6, 0x40, 0x93, 0x85,
- 0xd5, 0xcc, 0xef, 0xf0, 0xef, 0xfe, 0x13, 0x17, 0x15, 0x00, 0x2a, 0x97, 0x0e, 0x07, 0x93, 0x87,
- 0x81, 0xc4, 0xba, 0x97, 0x23, 0x80, 0x87, 0x00, 0x37, 0xf7, 0x00, 0xe0, 0x18, 0x47, 0xd8, 0xc3,
- 0xa2, 0x40, 0x12, 0x44, 0x31, 0x01, 0x82, 0x80, 0x13, 0x07, 0xb0, 0x07, 0xaa, 0x87, 0x63, 0x18,
- 0xe5, 0x00, 0x12, 0x44, 0xa2, 0x40, 0x2e, 0x85, 0x31, 0x01, 0x6f, 0xf0, 0x3f, 0x86, 0x13, 0x07,
- 0x05, 0xfe, 0x13, 0x77, 0xf7, 0x0f, 0xb1, 0x46, 0xe3, 0xec, 0xe6, 0xfc, 0x13, 0x87, 0x81, 0xc3,
- 0xb3, 0x06, 0xf7, 0x00, 0x23, 0x80, 0xb6, 0xfe, 0x93, 0x06, 0xc0, 0x02, 0xe3, 0x92, 0xd7, 0xfc,
- 0x31, 0x46, 0x93, 0x85, 0x81, 0xca, 0x13, 0x85, 0x81, 0xc3, 0x03, 0x44, 0xc7, 0x00, 0x91, 0x3f,
- 0x45, 0xf9, 0x05, 0xc0, 0x93, 0x07, 0x84, 0xff, 0x93, 0xf7, 0xf7, 0x0f, 0x13, 0x07, 0xf0, 0x06,
- 0xe3, 0x60, 0xf7, 0xfa, 0x93, 0x07, 0x04, 0xfd, 0x93, 0xf7, 0xf7, 0x0f, 0x05, 0x47, 0xe3, 0x79,
- 0xf7, 0xf8, 0x23, 0x8a, 0x81, 0xc2, 0x23, 0x9e, 0x81, 0xc0, 0x59, 0xb7, 0xb7, 0x27, 0x02, 0x40,
- 0x05, 0x47, 0x98, 0xc3, 0xb7, 0x17, 0x02, 0x40, 0x37, 0x07, 0x08, 0x01, 0x23, 0xa2, 0x07, 0x00,
- 0x13, 0x07, 0x17, 0x08, 0x98, 0xc3, 0x37, 0x07, 0x9f, 0x00, 0x98, 0xc7, 0x37, 0x17, 0x02, 0x40,
- 0x1c, 0x43, 0x93, 0x96, 0x67, 0x00, 0xe3, 0xdd, 0x06, 0xfe, 0x5c, 0x43, 0xb7, 0x16, 0x02, 0x40,
- 0xf1, 0x9b, 0x93, 0xe7, 0x27, 0x00, 0x5c, 0xc3, 0x21, 0x47, 0xdc, 0x42, 0xb1, 0x8b, 0xe3, 0x9e,
- 0xe7, 0xfe, 0x82, 0x80, 0x19, 0x71, 0x86, 0xde, 0xa2, 0xdc, 0xa6, 0xda, 0x45, 0x3f, 0x37, 0x17,
- 0x02, 0x40, 0x1c, 0x4f, 0x93, 0xe7, 0x57, 0x03, 0x1c, 0xcf, 0xb7, 0xf7, 0xff, 0x1f, 0x93, 0x87,
- 0x07, 0x7e, 0x8c, 0x47, 0xd0, 0x47, 0x98, 0x4b, 0x93, 0x87, 0x81, 0xca, 0x23, 0xa4, 0xb1, 0xca,
- 0xd0, 0xc3, 0x98, 0xc7, 0xb7, 0x47, 0x00, 0x08, 0x03, 0xd6, 0x07, 0xfc, 0x15, 0x67, 0x93, 0x86,
- 0x81, 0xca, 0x13, 0x07, 0x27, 0xb4, 0x36, 0xc8, 0x63, 0x1f, 0xe6, 0x02, 0x03, 0xc7, 0x27, 0xfc,
- 0x03, 0xc6, 0x37, 0xfc, 0x93, 0x87, 0x07, 0xfc, 0x93, 0x46, 0xf7, 0xff, 0x93, 0xf7, 0xf6, 0x0f,
- 0x63, 0x13, 0xf6, 0x02, 0x93, 0x07, 0x87, 0xff, 0x93, 0xf7, 0xf7, 0x0f, 0x93, 0x06, 0xf0, 0x06,
- 0x63, 0xeb, 0xf6, 0x00, 0x93, 0x07, 0x07, 0xfd, 0x93, 0xf7, 0xf7, 0x0f, 0x85, 0x46, 0x63, 0xf4,
- 0xf6, 0x00, 0x23, 0x8a, 0xe1, 0xc2, 0x93, 0x87, 0x81, 0xc4, 0x7d, 0x57, 0x23, 0x80, 0xe7, 0x00,
- 0x23, 0x84, 0xe7, 0x00, 0x23, 0x80, 0xe7, 0x02, 0x23, 0x8c, 0xe7, 0x00, 0x23, 0x8c, 0xe7, 0x02,
- 0x23, 0x88, 0xe7, 0x02, 0x23, 0x88, 0xe7, 0x04, 0x23, 0x84, 0xe7, 0x04, 0xb7, 0x17, 0x01, 0x40,
- 0x93, 0x87, 0x07, 0x40, 0x98, 0x43, 0xb7, 0x06, 0x00, 0xf1, 0xfd, 0x16, 0x75, 0x8f, 0xb7, 0x06,
- 0x00, 0x08, 0x55, 0x8f, 0x98, 0xc3, 0x13, 0x07, 0x00, 0x04, 0x98, 0xcb, 0xb7, 0x12, 0x01, 0x40,
- 0x13, 0x87, 0x81, 0xc4, 0x93, 0x87, 0x41, 0xc0, 0x3a, 0xca, 0x93, 0x82, 0x02, 0x80, 0x05, 0x43,
- 0x3d, 0x44, 0x95, 0x43, 0x83, 0xc6, 0x07, 0x00, 0x95, 0x07, 0x13, 0xf5, 0xf6, 0x00, 0x91, 0x82,
- 0xaa, 0x06, 0x96, 0x96, 0x33, 0x17, 0xa3, 0x00, 0x98, 0xca, 0x03, 0xc7, 0xc7, 0xff, 0x0a, 0x05,
- 0x13, 0x76, 0xf7, 0x00, 0x11, 0x83, 0x2a, 0x07, 0x16, 0x97, 0xb3, 0x15, 0xc3, 0x00, 0x0c, 0xcb,
- 0x84, 0x42, 0xb3, 0x15, 0xa4, 0x00, 0x93, 0xc5, 0xf5, 0xff, 0xe5, 0x8d, 0x33, 0x95, 0xa3, 0x00,
- 0xc9, 0x8d, 0x8c, 0xc2, 0x0c, 0x43, 0x0a, 0x06, 0xb3, 0x16, 0xc4, 0x00, 0x93, 0xc6, 0xf6, 0xff,
- 0xed, 0x8e, 0x33, 0x96, 0xc3, 0x00, 0xd1, 0x8e, 0x14, 0xc3, 0x23, 0x8f, 0x67, 0xfe, 0xa3, 0x8f,
- 0x67, 0xfe, 0x13, 0x87, 0x81, 0xc1, 0xe3, 0x1f, 0xf7, 0xf8, 0x13, 0x84, 0x41, 0xc0, 0x83, 0x46,
- 0x04, 0x00, 0x37, 0x16, 0x01, 0x40, 0x13, 0x06, 0x06, 0x80, 0x93, 0xd7, 0x46, 0x00, 0xaa, 0x07,
- 0xb2, 0x97, 0x98, 0x47, 0xbd, 0x8a, 0x02, 0xc0, 0x33, 0x57, 0xd7, 0x00, 0x83, 0x46, 0x14, 0x00,
- 0x05, 0x8b, 0x93, 0xd7, 0x46, 0x00, 0xaa, 0x07, 0xb2, 0x97, 0x9c, 0x47, 0xbd, 0x8a, 0xb3, 0xd7,
- 0xd7, 0x00, 0x83, 0x46, 0x44, 0x00, 0x85, 0x8b, 0x81, 0xca, 0x99, 0xc7, 0x83, 0x46, 0x34, 0x00,
- 0x81, 0xc6, 0x93, 0x46, 0x17, 0x00, 0x36, 0xc0, 0x23, 0x02, 0xf4, 0x00, 0x82, 0x47, 0xa3, 0x01,
- 0xe4, 0x00, 0x63, 0x81, 0x07, 0x0e, 0x0c, 0x18, 0x22, 0x85, 0xef, 0xf0, 0x3f, 0x87, 0x85, 0x47,
- 0xe3, 0x0b, 0xf5, 0xfe, 0x51, 0xe9, 0x83, 0x44, 0x01, 0x03, 0xa2, 0x85, 0x93, 0xd7, 0x14, 0x00,
- 0x3e, 0x85, 0x3e, 0xc4, 0xef, 0xf0, 0xaf, 0xe9, 0x09, 0xe5, 0x22, 0x85, 0xef, 0xf0, 0x5f, 0x94,
- 0xa5, 0xa8, 0x22, 0x85, 0xef, 0xf0, 0xdf, 0x8e, 0x25, 0xc9, 0x85, 0x88, 0x63, 0x82, 0x04, 0x2e,
- 0x03, 0xc5, 0x41, 0xc2, 0xa2, 0x85, 0x93, 0x07, 0x15, 0x00, 0x23, 0x82, 0xf1, 0xc2, 0xef, 0xf0,
- 0xef, 0xee, 0x37, 0x16, 0x01, 0x40, 0x2a, 0xc6, 0x9d, 0x46, 0x13, 0x06, 0x06, 0x80, 0xb2, 0x47,
- 0x81, 0x45, 0x22, 0x85, 0xb3, 0xd7, 0xd7, 0x40, 0x85, 0x8b, 0x32, 0xce, 0x36, 0xcc, 0x3e, 0xc2,
- 0xef, 0xf0, 0x6f, 0xfd, 0x83, 0x47, 0x04, 0x00, 0xe2, 0x46, 0x72, 0x46, 0x63, 0x12, 0x05, 0x1e,
- 0x13, 0xd7, 0x47, 0x00, 0xb7, 0x16, 0x01, 0x40, 0x93, 0x86, 0x06, 0x80, 0x2a, 0x07, 0x36, 0x97,
- 0xbd, 0x8b, 0x85, 0x46, 0xb3, 0x97, 0xf6, 0x00, 0x1c, 0xcb, 0x0c, 0x18, 0x22, 0x85, 0xef, 0xf0,
- 0xef, 0xfd, 0x85, 0x47, 0xe3, 0x01, 0xf5, 0xf6, 0x03, 0x47, 0x04, 0x00, 0xb7, 0x16, 0x01, 0x40,
+ 0xc9, 0xb7, 0x03, 0xc5, 0xd1, 0xc2, 0x13, 0x75, 0xf5, 0x0f, 0x65, 0xbf, 0x03, 0xc5, 0x25, 0x00,
+ 0x4d, 0xbf, 0x03, 0xc5, 0xc1, 0xc2, 0x75, 0xb7, 0x03, 0xc5, 0x21, 0xc2, 0x5d, 0xb7, 0x03, 0xc7,
+ 0xf1, 0xc2, 0x13, 0x75, 0xf7, 0x0f, 0xe3, 0xfe, 0xe7, 0xf8, 0x21, 0x45, 0x59, 0xbf, 0x11, 0x45,
+ 0x49, 0xbf, 0x03, 0xc7, 0xc1, 0xc2, 0x19, 0xc7, 0x63, 0x16, 0xa7, 0x00, 0x23, 0x86, 0x01, 0xc2,
+ 0x23, 0x90, 0x01, 0xc2, 0x82, 0x80, 0x93, 0x17, 0x25, 0x00, 0xaa, 0x97, 0x13, 0x85, 0x41, 0xc0,
+ 0x3e, 0x95, 0x03, 0x47, 0x05, 0x00, 0xb7, 0x16, 0x01, 0x40, 0x93, 0x86, 0x06, 0x80, 0x93, 0x57,
+ 0x47, 0x00, 0xaa, 0x07, 0xb6, 0x97, 0x9c, 0x47, 0x3d, 0x8b, 0xb3, 0xd7, 0xe7, 0x00, 0x03, 0x47,
+ 0x15, 0x00, 0x85, 0x8b, 0xa3, 0x01, 0xf5, 0x00, 0x93, 0x57, 0x47, 0x00, 0xaa, 0x07, 0xb6, 0x97,
+ 0x9c, 0x47, 0x3d, 0x8b, 0xb3, 0xd7, 0xe7, 0x00, 0x85, 0x8b, 0x23, 0x02, 0xf5, 0x00, 0x82, 0x80,
+ 0x83, 0x47, 0x15, 0x00, 0xb7, 0x16, 0x01, 0x40, 0x93, 0x86, 0x06, 0x80, 0x13, 0xd7, 0x47, 0x00,
+ 0x2a, 0x07, 0x13, 0xf6, 0xf7, 0x00, 0xe1, 0x67, 0x36, 0x97, 0x93, 0x87, 0x07, 0x6a, 0x14, 0x47,
+ 0xb3, 0xd6, 0xc6, 0x00, 0x85, 0x8a, 0x63, 0x86, 0xb6, 0x00, 0xfd, 0x17, 0xed, 0xfb, 0x01, 0x45,
+ 0x82, 0x80, 0x05, 0x45, 0x82, 0x80, 0x21, 0x11, 0x37, 0x13, 0x01, 0x40, 0x22, 0xc8, 0x26, 0xc6,
+ 0x06, 0xca, 0x2a, 0xc0, 0x2e, 0xc2, 0x21, 0x44, 0x81, 0x44, 0x13, 0x03, 0x03, 0x80, 0x02, 0x45,
+ 0x81, 0x45, 0x1a, 0xc4, 0x75, 0x37, 0x22, 0x43, 0x19, 0xe5, 0x0d, 0x45, 0xd2, 0x40, 0x42, 0x44,
+ 0xb2, 0x44, 0x61, 0x01, 0x82, 0x80, 0x02, 0x45, 0x85, 0x45, 0x1a, 0xc4, 0x51, 0x3f, 0x75, 0xd5,
+ 0x82, 0x47, 0x22, 0x43, 0x05, 0x45, 0x83, 0xc5, 0x07, 0x00, 0x83, 0xc7, 0x17, 0x00, 0xe1, 0x63,
+ 0x93, 0xd6, 0x45, 0x00, 0xaa, 0x06, 0x9a, 0x96, 0x98, 0x46, 0x13, 0xd6, 0x47, 0x00, 0xbd, 0x89,
+ 0x33, 0x57, 0xb7, 0x00, 0x2a, 0x06, 0xbd, 0x8b, 0x05, 0x8b, 0x1a, 0x96, 0x33, 0x15, 0xf5, 0x00,
+ 0x93, 0x83, 0x13, 0x6a, 0x1c, 0x46, 0xe9, 0x8f, 0x81, 0xef, 0x86, 0x04, 0xd9, 0x8c, 0x7d, 0x14,
+ 0x93, 0xf4, 0xf4, 0x0f, 0x49, 0xfc, 0x92, 0x47, 0x01, 0x45, 0x23, 0x80, 0x97, 0x00, 0x79, 0xbf,
+ 0x9c, 0x46, 0xb3, 0xd7, 0xb7, 0x00, 0x85, 0x8b, 0x63, 0x05, 0xf7, 0x00, 0x13, 0x85, 0x17, 0x00,
+ 0x71, 0xb7, 0xfd, 0x13, 0xe3, 0x98, 0x03, 0xfc, 0x49, 0xb7, 0x41, 0x11, 0x26, 0xc2, 0x06, 0xc6,
+ 0x22, 0xc4, 0x03, 0x44, 0x05, 0x00, 0x37, 0x17, 0x01, 0x40, 0x13, 0x07, 0x07, 0x80, 0x93, 0x74,
+ 0xf4, 0x00, 0x11, 0x80, 0x2a, 0x04, 0x3a, 0x94, 0x93, 0x86, 0x04, 0x01, 0x05, 0x47, 0x33, 0x17,
+ 0xd7, 0x00, 0x18, 0xc8, 0x85, 0x45, 0x2a, 0xc0, 0xe5, 0x3d, 0x82, 0x47, 0x11, 0xc5, 0x81, 0x45,
+ 0x3e, 0x85, 0xfd, 0x35, 0x33, 0x35, 0xa0, 0x00, 0x85, 0x47, 0xb3, 0x97, 0x97, 0x00, 0xb2, 0x40,
+ 0x1c, 0xc8, 0x22, 0x44, 0x92, 0x44, 0x41, 0x01, 0x82, 0x80, 0x41, 0x11, 0x22, 0xc4, 0x26, 0xc2,
+ 0x06, 0xc6, 0x2a, 0x84, 0x93, 0x04, 0x00, 0x04, 0x93, 0x05, 0x31, 0x00, 0x22, 0x85, 0xe5, 0x3d,
+ 0x13, 0x07, 0xe5, 0xff, 0x85, 0x47, 0x63, 0xf5, 0xe7, 0x00, 0x01, 0xc9, 0xfd, 0x14, 0xed, 0xf4,
+ 0xb2, 0x40, 0x22, 0x44, 0x92, 0x44, 0x41, 0x01, 0x82, 0x80, 0x85, 0x45, 0x22, 0x85, 0x4d, 0x35,
+ 0x65, 0xd9, 0x81, 0x45, 0x22, 0x85, 0x69, 0x3d, 0x75, 0xf1, 0xdd, 0xb7, 0xb7, 0xf7, 0x00, 0xe0,
+ 0x11, 0x11, 0x98, 0x47, 0x93, 0x17, 0x16, 0x00, 0x3e, 0x96, 0x26, 0xc8, 0xb7, 0x17, 0x01, 0x40,
+ 0x93, 0x54, 0x45, 0x00, 0xaa, 0x04, 0x93, 0x87, 0x07, 0x80, 0x22, 0xca, 0x06, 0xcc, 0x06, 0x06,
+ 0xbe, 0x94, 0x13, 0x74, 0xf5, 0x00, 0x37, 0xf5, 0x00, 0xe0, 0x9c, 0x44, 0xb3, 0xd7, 0x87, 0x00,
+ 0x85, 0x8b, 0x63, 0x94, 0xb7, 0x00, 0x05, 0x45, 0x31, 0xa0, 0x1c, 0x45, 0x99, 0x8f, 0x63, 0xe8,
+ 0xc7, 0x00, 0x01, 0x45, 0xe2, 0x40, 0x52, 0x44, 0xc2, 0x44, 0x71, 0x01, 0x82, 0x80, 0xf1, 0xde,
+ 0x32, 0xc6, 0x2e, 0xc4, 0x3a, 0xc2, 0x36, 0xc0, 0x82, 0x96, 0x82, 0x46, 0x12, 0x47, 0xa2, 0x45,
+ 0x32, 0x46, 0x71, 0xd1, 0xf9, 0xbf, 0x2d, 0x8d, 0x21, 0x47, 0x93, 0x17, 0x85, 0x01, 0xe1, 0x87,
+ 0x63, 0xda, 0x07, 0x00, 0x86, 0x07, 0x93, 0xc7, 0x77, 0x00, 0x13, 0xf5, 0xf7, 0x0f, 0x7d, 0x17,
+ 0x6d, 0xf7, 0x82, 0x80, 0x06, 0x05, 0x13, 0x75, 0xf5, 0x0f, 0xd5, 0xbf, 0x11, 0x11, 0xb7, 0x16,
+ 0x01, 0x40, 0x26, 0xc8, 0x06, 0xcc, 0x22, 0xca, 0x2a, 0x87, 0x2e, 0xc2, 0x9d, 0x44, 0x93, 0x86,
+ 0x06, 0x80, 0x03, 0x44, 0x17, 0x00, 0x93, 0x77, 0xf4, 0x00, 0x11, 0x80, 0x13, 0x85, 0x07, 0x01,
+ 0x3e, 0xc0, 0x2a, 0x04, 0x85, 0x47, 0x36, 0x94, 0xb3, 0x97, 0xa7, 0x00, 0x1c, 0xc8, 0x0d, 0xce,
+ 0x19, 0x45, 0x36, 0xc6, 0x3a, 0xc4, 0xc1, 0x34, 0x22, 0x47, 0xb2, 0x46, 0xbd, 0x47, 0x03, 0x46,
+ 0x07, 0x00, 0x13, 0x55, 0x46, 0x00, 0x2a, 0x05, 0x36, 0x95, 0x3d, 0x8a, 0x03, 0x23, 0x05, 0x00,
+ 0x0a, 0x06, 0xb3, 0x97, 0xc7, 0x00, 0x93, 0xc7, 0xf7, 0xff, 0xb3, 0xf7, 0x67, 0x00, 0x0d, 0x43,
+ 0x33, 0x16, 0xc3, 0x00, 0xd1, 0x8f, 0x1c, 0xc1, 0x83, 0x47, 0x07, 0x00, 0x92, 0x45, 0x13, 0xd6,
+ 0x47, 0x00, 0x33, 0xd5, 0x95, 0x40, 0x2a, 0x06, 0x05, 0x89, 0x36, 0x96, 0xbd, 0x8b, 0x05, 0xcd,
+ 0x05, 0x45, 0xb3, 0x17, 0xf5, 0x00, 0x1c, 0xca, 0x0d, 0x45, 0x36, 0xc6, 0x3a, 0xc4, 0xa5, 0x34,
+ 0x02, 0x47, 0x85, 0x47, 0x0d, 0x45, 0xb3, 0x97, 0xe7, 0x00, 0x1c, 0xc8, 0xa9, 0x3c, 0xfd, 0x14,
+ 0xfd, 0x57, 0x22, 0x47, 0xb2, 0x46, 0x01, 0x46, 0xe3, 0x95, 0xf4, 0xf6, 0xe2, 0x40, 0x52, 0x44,
+ 0xc2, 0x44, 0x71, 0x01, 0x82, 0x80, 0xc1, 0x07, 0xe1, 0xb7, 0x11, 0x11, 0x26, 0xc8, 0xb7, 0x14,
+ 0x01, 0x40, 0x06, 0xcc, 0x22, 0xca, 0x2a, 0x87, 0xa1, 0x46, 0x01, 0x46, 0x93, 0x84, 0x04, 0x80,
+ 0x03, 0x44, 0x17, 0x00, 0x85, 0x47, 0x13, 0x73, 0xf4, 0x00, 0x11, 0x80, 0x13, 0x05, 0x03, 0x01,
+ 0x2a, 0x04, 0xb3, 0x97, 0xa7, 0x00, 0x26, 0x94, 0x1c, 0xc8, 0x0d, 0x45, 0x91, 0xc1, 0x25, 0x45,
+ 0x3a, 0xc6, 0x32, 0xc4, 0x36, 0xc2, 0x1a, 0xc0, 0xfd, 0x3a, 0x02, 0x43, 0x85, 0x47, 0x0d, 0x45,
+ 0xb3, 0x97, 0x67, 0x00, 0x1c, 0xc8, 0xc5, 0x3a, 0x32, 0x47, 0x22, 0x46, 0x92, 0x46, 0x83, 0x45,
+ 0x07, 0x00, 0x06, 0x06, 0xfd, 0x16, 0x93, 0xd7, 0x45, 0x00, 0xaa, 0x07, 0xa6, 0x97, 0x9c, 0x47,
+ 0xbd, 0x89, 0xb3, 0xd7, 0xb7, 0x00, 0x85, 0x8b, 0xd1, 0x8f, 0x13, 0xf6, 0xf7, 0x0f, 0x81, 0x45,
+ 0xc5, 0xf2, 0xe2, 0x40, 0x52, 0x44, 0xc2, 0x44, 0x32, 0x85, 0x71, 0x01, 0x82, 0x80, 0x13, 0x01,
+ 0x41, 0xfd, 0x22, 0xd2, 0x06, 0xd4, 0x26, 0xd0, 0x83, 0x46, 0x05, 0x00, 0x37, 0x16, 0x01, 0x40,
+ 0x13, 0x06, 0x06, 0x80, 0x93, 0xd7, 0x46, 0x00, 0xaa, 0x07, 0xb2, 0x97, 0x98, 0x47, 0xbd, 0x8a,
+ 0x02, 0xc0, 0x33, 0x57, 0xd7, 0x00, 0x83, 0x46, 0x15, 0x00, 0x2a, 0x84, 0x05, 0x8b, 0x93, 0xd7,
+ 0x46, 0x00, 0xaa, 0x07, 0xb2, 0x97, 0x9c, 0x47, 0xbd, 0x8a, 0xb3, 0xd7, 0xd7, 0x00, 0x83, 0x46,
+ 0x45, 0x00, 0x85, 0x8b, 0x81, 0xca, 0x99, 0xc7, 0x83, 0x46, 0x35, 0x00, 0x81, 0xc6, 0x93, 0x46,
+ 0x17, 0x00, 0x36, 0xc0, 0x23, 0x02, 0xf4, 0x00, 0x82, 0x47, 0xa3, 0x01, 0xe4, 0x00, 0x63, 0x8b,
+ 0x07, 0x0c, 0x93, 0x05, 0xe1, 0x01, 0x22, 0x85, 0x79, 0x31, 0x85, 0x47, 0xe3, 0x0b, 0xf5, 0xfe,
+ 0x41, 0xe5, 0x83, 0x44, 0xe1, 0x01, 0xa2, 0x85, 0x93, 0xd7, 0x14, 0x00, 0x3e, 0x85, 0x3e, 0xc4,
+ 0x95, 0x3c, 0x01, 0xe5, 0x22, 0x85, 0x95, 0x33, 0x85, 0xa8, 0x22, 0x85, 0x39, 0x33, 0x2d, 0xc5,
+ 0x85, 0x88, 0x63, 0x8f, 0x04, 0x14, 0x03, 0xc5, 0x41, 0xc2, 0xa2, 0x85, 0x93, 0x07, 0x15, 0x00,
+ 0x23, 0x82, 0xf1, 0xc2, 0xe1, 0x34, 0xb7, 0x12, 0x01, 0x40, 0x2a, 0xc6, 0x1d, 0x43, 0x93, 0x82,
+ 0x02, 0x80, 0xb2, 0x47, 0x81, 0x45, 0x22, 0x85, 0xb3, 0xd7, 0x67, 0x40, 0x85, 0x8b, 0x16, 0xca,
+ 0x1a, 0xc8, 0x3e, 0xc2, 0xf5, 0x3e, 0x42, 0x43, 0xd2, 0x42, 0x25, 0xed, 0x03, 0x47, 0x04, 0x00,
+ 0xb7, 0x16, 0x01, 0x40, 0x93, 0x86, 0x06, 0x80, 0x93, 0x57, 0x47, 0x00, 0xaa, 0x07, 0xb6, 0x97,
+ 0x3d, 0x8b, 0x85, 0x46, 0x33, 0x97, 0xe6, 0x00, 0x98, 0xcb, 0x93, 0x05, 0xe1, 0x01, 0x22, 0x85,
+ 0x19, 0x31, 0x85, 0x47, 0xe3, 0x07, 0xf5, 0xf6, 0x03, 0x47, 0x04, 0x00, 0xb7, 0x16, 0x01, 0x40,
0x93, 0x86, 0x06, 0x80, 0x93, 0x57, 0x47, 0x00, 0xaa, 0x07, 0xb6, 0x97, 0x9c, 0x47, 0x3d, 0x8b,
0xb3, 0xd7, 0xe7, 0x00, 0x03, 0x47, 0x14, 0x00, 0x85, 0x8b, 0xa3, 0x01, 0xf4, 0x00, 0x93, 0x57,
0x47, 0x00, 0xaa, 0x07, 0xb6, 0x97, 0x9c, 0x47, 0x3d, 0x8b, 0xb3, 0xd7, 0xe7, 0x00, 0x85, 0x8b,
- 0x23, 0x02, 0xf4, 0x00, 0x15, 0x04, 0x93, 0x87, 0x81, 0xc1, 0xe3, 0x92, 0x87, 0xec, 0xb7, 0x17,
- 0x01, 0x40, 0x93, 0x87, 0x07, 0x40, 0x94, 0x47, 0x83, 0x97, 0x61, 0xc2, 0x93, 0xf6, 0x06, 0x04,
- 0x63, 0x9c, 0x06, 0x24, 0x93, 0x06, 0x70, 0x0c, 0x63, 0xc5, 0xf6, 0x00, 0x85, 0x07, 0x23, 0x93,
- 0xf1, 0xc2, 0x83, 0xc6, 0x51, 0xc3, 0x03, 0x97, 0x61, 0xc2, 0x13, 0x06, 0x80, 0x0c, 0x93, 0xf6,
- 0xf6, 0x0f, 0x63, 0x1f, 0xc7, 0x22, 0x05, 0x47, 0xa3, 0x8a, 0xe1, 0xc2, 0x83, 0xc7, 0x51, 0xc3,
- 0x63, 0x85, 0xf6, 0x00, 0x01, 0x45, 0xef, 0xf0, 0x0f, 0xd5, 0x83, 0xc6, 0xc1, 0xc2, 0x89, 0xea,
- 0xb7, 0xf6, 0x00, 0xe0, 0x94, 0x46, 0x23, 0xa4, 0xd1, 0xc2, 0x85, 0x46, 0x23, 0x86, 0xd1, 0xc2,
- 0xb7, 0xf7, 0x00, 0xe0, 0x9c, 0x47, 0x03, 0xa7, 0x81, 0xc2, 0xb7, 0xf6, 0x36, 0x00, 0x93, 0x86,
- 0xf6, 0xe7, 0x99, 0x8f, 0x63, 0xe3, 0xf6, 0x20, 0x03, 0xc7, 0xe1, 0xc1, 0x93, 0x07, 0xf0, 0x0f,
- 0x63, 0x16, 0xf7, 0x3c, 0x83, 0x97, 0xc1, 0xc1, 0xe3, 0xc9, 0x07, 0xe2, 0x37, 0x06, 0x67, 0x45,
+ 0x23, 0x02, 0xf4, 0x00, 0xa2, 0x50, 0x12, 0x54, 0x02, 0x45, 0x82, 0x54, 0x13, 0x01, 0xc1, 0x02,
+ 0x82, 0x80, 0x03, 0x47, 0x14, 0x00, 0x85, 0x46, 0x12, 0x46, 0x93, 0x75, 0xf7, 0x00, 0x11, 0x83,
+ 0x2a, 0x07, 0x93, 0x87, 0x05, 0x01, 0xb3, 0x97, 0xf6, 0x00, 0x16, 0x97, 0x1c, 0xcb, 0x83, 0x47,
+ 0x04, 0x00, 0x93, 0xf4, 0xf7, 0x00, 0x91, 0x83, 0xaa, 0x07, 0x96, 0x97, 0x1d, 0xc6, 0xb3, 0x96,
+ 0x96, 0x00, 0x94, 0xcb, 0x85, 0x46, 0xb3, 0x95, 0xb6, 0x00, 0x0c, 0xcb, 0x22, 0x85, 0x85, 0x45,
+ 0x16, 0xcc, 0x3e, 0xca, 0x1a, 0xc8, 0x2d, 0x3e, 0x42, 0x43, 0xd2, 0x47, 0xe2, 0x42, 0x85, 0x46,
+ 0x11, 0xe9, 0xb3, 0x96, 0x96, 0x00, 0x94, 0xcb, 0x89, 0xbf, 0x13, 0x85, 0x04, 0x01, 0xb3, 0x96,
+ 0xa6, 0x00, 0xc1, 0xbf, 0x12, 0x47, 0x11, 0xc7, 0x98, 0x47, 0x33, 0x57, 0x97, 0x00, 0x05, 0x8b,
+ 0x2d, 0xcf, 0x7d, 0x13, 0x7d, 0x57, 0xe3, 0x1e, 0xe3, 0xee, 0x81, 0x45, 0x22, 0x85, 0x3e, 0xc2,
+ 0x01, 0x36, 0x92, 0x47, 0x05, 0x47, 0x33, 0x17, 0x97, 0x00, 0x98, 0xcb, 0x19, 0xdd, 0x85, 0x45,
+ 0x22, 0x85, 0x3e, 0xc2, 0xf5, 0x34, 0xe3, 0x0a, 0x05, 0xf0, 0x92, 0x47, 0x81, 0x45, 0x22, 0x85,
+ 0x9c, 0x47, 0xb3, 0xd4, 0x97, 0x00, 0x85, 0x88, 0xe1, 0x3c, 0xe3, 0x86, 0x04, 0xea, 0xf5, 0xbd,
+ 0x82, 0x47, 0x93, 0x05, 0xf1, 0x01, 0x22, 0x85, 0x3e, 0xc2, 0xf5, 0x3c, 0xe3, 0x1b, 0x05, 0xee,
+ 0x92, 0x47, 0x83, 0x45, 0xf1, 0x01, 0x89, 0xcb, 0x23, 0x82, 0xb1, 0xc2, 0x22, 0x85, 0x71, 0x36,
+ 0xe3, 0x04, 0x05, 0xee, 0x81, 0x47, 0xf1, 0xbf, 0x03, 0xc5, 0x41, 0xc2, 0x22, 0x86, 0x93, 0x07,
+ 0x15, 0x00, 0x23, 0x82, 0xf1, 0xc2, 0x21, 0x2a, 0xd5, 0xb7, 0x22, 0x45, 0x1d, 0x3c, 0x99, 0xbd,
+ 0x51, 0x11, 0x22, 0xc2, 0x26, 0xc0, 0x06, 0xc4, 0x13, 0x84, 0x41, 0xc0, 0x81, 0x44, 0x03, 0xa7,
+ 0xc1, 0xc1, 0x63, 0x1d, 0x97, 0x00, 0x85, 0x04, 0x11, 0x47, 0x15, 0x04, 0xe3, 0x99, 0xe4, 0xfe,
+ 0x01, 0x45, 0xa2, 0x40, 0x12, 0x44, 0x82, 0x44, 0x31, 0x01, 0x82, 0x80, 0x26, 0x85, 0xef, 0xf0,
+ 0x0f, 0xfb, 0x75, 0xf1, 0x22, 0x85, 0x61, 0x3b, 0x79, 0xdd, 0x05, 0x45, 0xdd, 0xb7, 0x97, 0x01,
+ 0x00, 0x20, 0x93, 0x81, 0xe1, 0xa0, 0x13, 0x81, 0x41, 0x40, 0x09, 0x65, 0x13, 0x05, 0x05, 0x88,
+ 0x73, 0x10, 0x05, 0x30, 0x97, 0xf6, 0xff, 0xff, 0x93, 0x86, 0xc6, 0x5f, 0x93, 0xe6, 0x36, 0x00,
+ 0x73, 0x90, 0x56, 0x30, 0x13, 0x85, 0x41, 0xc2, 0x93, 0x85, 0xc1, 0xda, 0x01, 0x46, 0x63, 0x56,
+ 0xb5, 0x00, 0x10, 0xc1, 0x11, 0x05, 0xe3, 0x4e, 0xb5, 0xfe, 0x17, 0x15, 0x00, 0x00, 0x13, 0x05,
+ 0x65, 0xe0, 0x93, 0x85, 0x41, 0xc0, 0x13, 0x86, 0x41, 0xc2, 0x63, 0x88, 0xc5, 0x00, 0x14, 0x41,
+ 0x94, 0xc1, 0x11, 0x05, 0x91, 0x05, 0xe3, 0x9a, 0xc5, 0xfe, 0xb7, 0xf7, 0x00, 0xe0, 0x05, 0x47,
+ 0x98, 0xc3, 0x85, 0x67, 0x93, 0x87, 0x27, 0xb8, 0x73, 0x90, 0x17, 0x34, 0x73, 0x00, 0x20, 0x30,
+ 0x01, 0xa0, 0x37, 0x17, 0x02, 0x40, 0x1c, 0x47, 0xb7, 0x06, 0x80, 0x00, 0xd5, 0x8f, 0x1c, 0xc7,
+ 0x2a, 0x96, 0xaa, 0x87, 0x63, 0x93, 0xc7, 0x00, 0x82, 0x80, 0x23, 0x80, 0xb7, 0x00, 0x85, 0x07,
+ 0xd5, 0xbf, 0x81, 0x47, 0x63, 0x13, 0xf6, 0x00, 0x82, 0x80, 0x33, 0x87, 0xf5, 0x00, 0x83, 0x46,
+ 0x07, 0x00, 0x33, 0x07, 0xf5, 0x00, 0x85, 0x07, 0x23, 0x00, 0xd7, 0x00, 0xe5, 0xb7, 0x11, 0xce,
+ 0x83, 0x47, 0x05, 0x00, 0x03, 0xc7, 0x05, 0x00, 0x63, 0x85, 0xe7, 0x00, 0x33, 0x85, 0xe7, 0x40,
+ 0x82, 0x80, 0x7d, 0x16, 0x05, 0x05, 0x85, 0x05, 0xdd, 0xb7, 0x01, 0x45, 0x82, 0x80, 0xaa, 0x87,
+ 0x13, 0x07, 0xb0, 0x07, 0x2e, 0x85, 0x63, 0x94, 0xe7, 0x00, 0x6f, 0xf0, 0x6f, 0xf0, 0x13, 0x87,
+ 0x07, 0xfe, 0x13, 0x77, 0xf7, 0x0f, 0xb1, 0x46, 0x63, 0xe0, 0xe6, 0x06, 0x93, 0x86, 0x01, 0xc3,
+ 0x33, 0x86, 0xf6, 0x00, 0x23, 0x00, 0xb6, 0xfe, 0x13, 0x06, 0xc0, 0x02, 0x63, 0x96, 0xc7, 0x04,
+ 0x51, 0x11, 0x06, 0xc4, 0x22, 0xc2, 0x31, 0x46, 0x93, 0x85, 0x01, 0xc4, 0x13, 0x85, 0x01, 0xc3,
+ 0x03, 0xc4, 0xc6, 0x00, 0x69, 0x3f, 0x0d, 0xe5, 0x05, 0xc0, 0x93, 0x07, 0x84, 0xff, 0x93, 0xf7,
+ 0xf7, 0x0f, 0x13, 0x07, 0xf0, 0x06, 0x63, 0x6d, 0xf7, 0x00, 0x93, 0x07, 0x04, 0xfd, 0x93, 0xf7,
+ 0xf7, 0x0f, 0x05, 0x47, 0x63, 0x76, 0xf7, 0x00, 0x23, 0x86, 0x81, 0xc2, 0x23, 0x90, 0x81, 0xc2,
+ 0xa2, 0x40, 0x12, 0x44, 0x31, 0x01, 0x82, 0x80, 0x82, 0x80, 0xb7, 0x27, 0x02, 0x40, 0x05, 0x47,
+ 0x98, 0xc3, 0xb7, 0x17, 0x02, 0x40, 0x37, 0x07, 0x08, 0x01, 0x23, 0xa2, 0x07, 0x00, 0x13, 0x07,
+ 0x17, 0x08, 0x98, 0xc3, 0x37, 0x07, 0x9f, 0x00, 0x98, 0xc7, 0x37, 0x17, 0x02, 0x40, 0x1c, 0x43,
+ 0x93, 0x96, 0x67, 0x00, 0xe3, 0xdd, 0x06, 0xfe, 0x5c, 0x43, 0xb7, 0x16, 0x02, 0x40, 0xf1, 0x9b,
+ 0x93, 0xe7, 0x27, 0x00, 0x5c, 0xc3, 0x21, 0x47, 0xdc, 0x42, 0xb1, 0x8b, 0xe3, 0x9e, 0xe7, 0xfe,
+ 0x82, 0x80, 0x13, 0x01, 0x41, 0xf2, 0x86, 0xcd, 0xa2, 0xcb, 0xa6, 0xc9, 0x02, 0xc0, 0x02, 0xd4,
+ 0x6d, 0x37, 0x37, 0x17, 0x02, 0x40, 0x1c, 0x4f, 0x93, 0xe7, 0x57, 0x03, 0x1c, 0xcf, 0xb7, 0xf7,
+ 0xff, 0x1f, 0x93, 0x87, 0x07, 0x7e, 0x8c, 0x47, 0xd0, 0x47, 0x98, 0x4b, 0x93, 0x87, 0x01, 0xc4,
+ 0x23, 0xa0, 0xb1, 0xc4, 0xd0, 0xc3, 0x98, 0xc7, 0xb7, 0x47, 0x00, 0x08, 0x03, 0xd6, 0x07, 0xfc,
+ 0x15, 0x67, 0x93, 0x86, 0x01, 0xc4, 0x13, 0x07, 0x27, 0xb4, 0xb6, 0xc8, 0x63, 0x1f, 0xe6, 0x02,
+ 0x03, 0xc7, 0x27, 0xfc, 0x03, 0xc6, 0x37, 0xfc, 0x93, 0x87, 0x07, 0xfc, 0x93, 0x46, 0xf7, 0xff,
+ 0x93, 0xf7, 0xf6, 0x0f, 0x63, 0x13, 0xf6, 0x02, 0x93, 0x07, 0x87, 0xff, 0x93, 0xf7, 0xf7, 0x0f,
+ 0x93, 0x06, 0xf0, 0x06, 0x63, 0xeb, 0xf6, 0x00, 0x93, 0x07, 0x07, 0xfd, 0x93, 0xf7, 0xf7, 0x0f,
+ 0x85, 0x46, 0x63, 0xf4, 0xf6, 0x00, 0x23, 0x86, 0xe1, 0xc2, 0x93, 0x87, 0xc1, 0xce, 0x7d, 0x57,
+ 0x23, 0x80, 0xe7, 0x00, 0x23, 0x84, 0xe7, 0x00, 0x23, 0x8c, 0xe7, 0x02, 0x23, 0x88, 0xe7, 0x02,
+ 0x23, 0x84, 0xe7, 0x06, 0x23, 0x80, 0xe7, 0x06, 0x23, 0x8c, 0xe7, 0x08, 0x23, 0x88, 0xe7, 0x08,
+ 0xb7, 0x17, 0x01, 0x40, 0x93, 0x87, 0x07, 0x40, 0x98, 0x43, 0xb7, 0x06, 0x00, 0xf1, 0xfd, 0x16,
+ 0x75, 0x8f, 0xb7, 0x06, 0x00, 0x08, 0x55, 0x8f, 0x98, 0xc3, 0x13, 0x07, 0x00, 0x04, 0x98, 0xcb,
+ 0x13, 0x87, 0x41, 0xc0, 0x13, 0x04, 0x47, 0x01, 0xb7, 0x12, 0x01, 0x40, 0x13, 0x87, 0xc1, 0xce,
+ 0x93, 0x87, 0x41, 0xc0, 0x3a, 0xd0, 0x93, 0x82, 0x02, 0x80, 0x05, 0x43, 0xbd, 0x40, 0x95, 0x43,
+ 0x83, 0xc6, 0x07, 0x00, 0x95, 0x07, 0x13, 0xf5, 0xf6, 0x00, 0x91, 0x82, 0xaa, 0x06, 0x96, 0x96,
+ 0x33, 0x17, 0xa3, 0x00, 0x98, 0xca, 0x03, 0xc7, 0xc7, 0xff, 0x0a, 0x05, 0x13, 0x76, 0xf7, 0x00,
+ 0x11, 0x83, 0x2a, 0x07, 0x16, 0x97, 0xb3, 0x15, 0xc3, 0x00, 0x0c, 0xcb, 0x84, 0x42, 0xb3, 0x95,
+ 0xa0, 0x00, 0x93, 0xc5, 0xf5, 0xff, 0xe5, 0x8d, 0x33, 0x95, 0xa3, 0x00, 0xc9, 0x8d, 0x8c, 0xc2,
+ 0x0c, 0x43, 0x0a, 0x06, 0xb3, 0x96, 0xc0, 0x00, 0x93, 0xc6, 0xf6, 0xff, 0xed, 0x8e, 0x33, 0x96,
+ 0xc3, 0x00, 0xd1, 0x8e, 0x14, 0xc3, 0x23, 0x8f, 0x67, 0xfe, 0xa3, 0x8f, 0x67, 0xfe, 0xe3, 0x91,
+ 0x87, 0xfa, 0xb7, 0xf7, 0x00, 0xe0, 0x9c, 0x47, 0xbe, 0xca, 0x85, 0x47, 0x3e, 0xd2, 0x92, 0x57,
+ 0x89, 0xcf, 0xb7, 0xf7, 0x00, 0xe0, 0x98, 0x47, 0xd6, 0x47, 0x1d, 0x8f, 0xb7, 0xf7, 0x36, 0x00,
+ 0x93, 0x87, 0x07, 0xe8, 0xb3, 0x37, 0xf7, 0x00, 0x3e, 0xd2, 0x82, 0x57, 0x02, 0xc2, 0x3e, 0xcc,
+ 0x93, 0x87, 0x41, 0xc0, 0x3e, 0xc4, 0x93, 0x84, 0xc1, 0xce, 0x12, 0x45, 0xef, 0xf0, 0x2f, 0xc8,
+ 0x19, 0xe1, 0x22, 0x45, 0xad, 0x34, 0xa2, 0x47, 0x37, 0x16, 0x01, 0x40, 0x13, 0x06, 0x06, 0x80,
+ 0x03, 0xc4, 0x17, 0x00, 0x13, 0x57, 0x44, 0x00, 0x2a, 0x07, 0x32, 0x97, 0x1c, 0x47, 0x3d, 0x88,
+ 0xb3, 0xd7, 0x87, 0x00, 0x85, 0x8b, 0x63, 0x8d, 0x07, 0x28, 0x23, 0x80, 0x04, 0x02, 0x92, 0x47,
+ 0x93, 0x84, 0x04, 0x03, 0x85, 0x07, 0x3e, 0xc2, 0xa2, 0x47, 0x12, 0x47, 0x95, 0x07, 0x3e, 0xc4,
+ 0x91, 0x47, 0xe3, 0x1c, 0xf7, 0xfa, 0xb7, 0x17, 0x01, 0x40, 0x93, 0x87, 0x07, 0x40, 0x94, 0x47,
+ 0x83, 0x97, 0x61, 0xc2, 0x93, 0xf6, 0x06, 0x04, 0x63, 0x96, 0x06, 0x5c, 0x93, 0x06, 0x70, 0x0c,
+ 0x63, 0xc5, 0xf6, 0x00, 0x85, 0x07, 0x23, 0x93, 0xf1, 0xc2, 0x83, 0xc6, 0xd1, 0xc2, 0x03, 0x97,
+ 0x61, 0xc2, 0x13, 0x06, 0x80, 0x0c, 0x93, 0xf6, 0xf6, 0x0f, 0x63, 0x19, 0xc7, 0x5a, 0x05, 0x47,
+ 0xa3, 0x86, 0xe1, 0xc2, 0x83, 0xc7, 0xd1, 0xc2, 0x63, 0x85, 0xf6, 0x00, 0x01, 0x45, 0xef, 0xf0,
+ 0xef, 0xc9, 0x92, 0x57, 0xa9, 0xeb, 0x82, 0x57, 0x37, 0xf6, 0x36, 0x00, 0x13, 0x03, 0xf0, 0x0f,
+ 0x13, 0x85, 0x07, 0x0c, 0xbe, 0x86, 0xb7, 0xf2, 0x00, 0xe0, 0x93, 0x07, 0xf0, 0x0f, 0x13, 0x06,
+ 0xf6, 0xe7, 0xfd, 0x53, 0x83, 0xc5, 0x06, 0x00, 0x63, 0x8c, 0x65, 0x00, 0x03, 0xa7, 0x82, 0x00,
+ 0x83, 0xa0, 0x46, 0x00, 0x33, 0x07, 0x17, 0x40, 0x63, 0x77, 0xe6, 0x56, 0x23, 0x80, 0x76, 0x00,
+ 0x93, 0x86, 0x06, 0x03, 0xe3, 0x10, 0xd5, 0xfe, 0x13, 0x07, 0xd0, 0x0f, 0x63, 0x74, 0xf7, 0x56,
+ 0xfd, 0x57, 0x23, 0x81, 0xf1, 0xc2, 0x83, 0xc7, 0xf1, 0xc2, 0x7d, 0x57, 0x3a, 0xc2, 0x85, 0xcf,
+ 0x93, 0x04, 0xf0, 0x0f, 0x01, 0x44, 0x22, 0x85, 0xef, 0xf0, 0x6f, 0xb8, 0x0d, 0xc1, 0x22, 0x85,
+ 0xef, 0xf0, 0xcf, 0xb3, 0x09, 0xed, 0x82, 0x57, 0x13, 0x17, 0x14, 0x00, 0x22, 0x97, 0x12, 0x07,
+ 0x3e, 0x97, 0x03, 0x47, 0x07, 0x00, 0x63, 0x74, 0x97, 0x00, 0xba, 0x84, 0x22, 0xc2, 0x05, 0x04,
+ 0x11, 0x47, 0xe3, 0x1a, 0xe4, 0xfc, 0x37, 0x16, 0x01, 0x40, 0x13, 0x87, 0x41, 0xc0, 0x81, 0x46,
+ 0x13, 0x06, 0x06, 0x80, 0x05, 0x45, 0x91, 0x45, 0xe2, 0x47, 0x12, 0x44, 0x83, 0xc7, 0x87, 0x02,
+ 0xe3, 0x99, 0x86, 0x10, 0xb1, 0xe3, 0x83, 0x42, 0x17, 0x00, 0x37, 0x13, 0x01, 0x40, 0x13, 0x03,
+ 0x03, 0x80, 0x93, 0xd7, 0x42, 0x00, 0xaa, 0x07, 0x9a, 0x97, 0x9c, 0x47, 0x93, 0xf2, 0xf2, 0x00,
+ 0xb3, 0xd7, 0x57, 0x00, 0x85, 0x8b, 0x8d, 0xc3, 0x83, 0x47, 0x07, 0x00, 0x93, 0xd2, 0x47, 0x00,
+ 0xaa, 0x02, 0xbd, 0x8b, 0x9a, 0x92, 0xc1, 0x07, 0x05, 0x43, 0xb3, 0x17, 0xf3, 0x00, 0x23, 0xa8,
+ 0xf2, 0x00, 0xe2, 0x47, 0x23, 0x84, 0x67, 0x02, 0xe2, 0x47, 0x85, 0x06, 0x15, 0x07, 0x93, 0x87,
+ 0x07, 0x03, 0x3e, 0xcc, 0xe3, 0x92, 0xb6, 0xfa, 0x03, 0xc7, 0x21, 0xc2, 0x93, 0x07, 0xf0, 0x0f,
+ 0x63, 0x0a, 0xf7, 0x02, 0xc6, 0x47, 0x85, 0x65, 0x93, 0x85, 0x05, 0x77, 0x03, 0xc5, 0x17, 0x00,
+ 0xb7, 0xf4, 0x00, 0xe0, 0x80, 0x44, 0x13, 0x05, 0x85, 0x3e, 0xef, 0xf0, 0x6f, 0x9d, 0x03, 0xa7,
+ 0x81, 0xc2, 0x19, 0x8c, 0x63, 0x68, 0xa4, 0x00, 0x98, 0x44, 0x09, 0x45, 0x23, 0xa4, 0xe1, 0xc2,
+ 0xef, 0xf0, 0xcf, 0xb5, 0x83, 0x97, 0x01, 0xc2, 0xe3, 0xcb, 0x07, 0xde, 0x37, 0x06, 0x67, 0x45,
0x37, 0x27, 0x02, 0x40, 0x13, 0x06, 0x36, 0x12, 0xb7, 0x96, 0xef, 0xcd, 0x50, 0xc3, 0x93, 0x86,
0xb6, 0x9a, 0x54, 0xc3, 0x50, 0xd3, 0x54, 0xd3, 0x14, 0x4b, 0x13, 0xd6, 0x76, 0x00, 0x13, 0x76,
0x16, 0x10, 0x5d, 0xea, 0xb7, 0x06, 0x02, 0x00, 0x14, 0xcb, 0xb7, 0x46, 0x00, 0x08, 0x93, 0x86,
0x06, 0xfc, 0x54, 0xcb, 0xb7, 0x06, 0x02, 0x00, 0x93, 0x86, 0x06, 0x04, 0x14, 0xcb, 0xb7, 0x24,
0x02, 0x40, 0xd8, 0x44, 0x05, 0x8b, 0x75, 0xff, 0x93, 0xf7, 0xf7, 0x0f, 0xc9, 0xc3, 0x15, 0x67,
- 0x13, 0x07, 0x27, 0xb4, 0x23, 0x09, 0xf1, 0x02, 0x13, 0x06, 0xc0, 0x03, 0x93, 0xc7, 0xf7, 0xff,
- 0x93, 0x05, 0xf0, 0x0f, 0x28, 0x18, 0x23, 0x18, 0xe1, 0x02, 0xa3, 0x09, 0xf1, 0x02, 0x1d, 0x36,
- 0xc2, 0x57, 0x37, 0x27, 0x02, 0x40, 0x3e, 0xda, 0xc1, 0x67, 0x9c, 0xc8, 0xb7, 0x07, 0x09, 0x00,
+ 0x13, 0x07, 0x27, 0xb4, 0x23, 0x03, 0xf1, 0x06, 0x13, 0x06, 0xc0, 0x03, 0x93, 0xc7, 0xf7, 0xff,
+ 0x93, 0x05, 0xf0, 0x0f, 0x48, 0x09, 0x23, 0x12, 0xe1, 0x06, 0xa3, 0x03, 0xf1, 0x06, 0x09, 0x3e,
+ 0x96, 0x57, 0x37, 0x27, 0x02, 0x40, 0x3e, 0xc9, 0xc1, 0x67, 0x9c, 0xc8, 0xb7, 0x07, 0x09, 0x00,
0x9c, 0xc8, 0xb7, 0x47, 0x00, 0x08, 0x93, 0x87, 0x07, 0xfc, 0xdc, 0xc8, 0x5c, 0x47, 0x85, 0x8b,
- 0xf5, 0xff, 0xb7, 0x47, 0x00, 0x08, 0x54, 0x18, 0x93, 0x87, 0x07, 0xfc, 0x37, 0x27, 0x02, 0x40,
+ 0xf5, 0xff, 0xb7, 0x47, 0x00, 0x08, 0x14, 0x09, 0x93, 0x87, 0x07, 0xfc, 0x37, 0x27, 0x02, 0x40,
0x37, 0x05, 0x05, 0x00, 0xb7, 0x45, 0x00, 0x08, 0x90, 0x42, 0x90, 0xc3, 0x08, 0xcb, 0x50, 0x47,
0x05, 0x8a, 0x75, 0xfe, 0x91, 0x07, 0x91, 0x06, 0xe3, 0x98, 0xb7, 0xfe, 0xc1, 0x67, 0x93, 0x87,
0x07, 0x04, 0x1c, 0xcb, 0x37, 0x27, 0x02, 0x40, 0x5c, 0x47, 0x85, 0x8b, 0xf5, 0xff, 0xb7, 0x27,
- 0x02, 0x40, 0x13, 0x07, 0x00, 0x08, 0x98, 0xcb, 0xfd, 0x57, 0x23, 0x9e, 0xf1, 0xc0, 0xb1, 0xb3,
- 0x83, 0x45, 0x14, 0x00, 0x05, 0x45, 0x93, 0xf4, 0xf7, 0x00, 0x13, 0xf3, 0xf5, 0x00, 0x91, 0x81,
- 0xaa, 0x05, 0x13, 0x07, 0x03, 0x01, 0x33, 0x17, 0xe5, 0x00, 0xb2, 0x95, 0x98, 0xc9, 0x12, 0x47,
- 0x91, 0x83, 0xaa, 0x07, 0xb2, 0x97, 0x15, 0xcb, 0x33, 0x15, 0x95, 0x00, 0x85, 0x42, 0x88, 0xcb,
- 0x33, 0x93, 0x62, 0x00, 0x23, 0xa8, 0x65, 0x00, 0x22, 0x85, 0x85, 0x45, 0x32, 0xd0, 0x3e, 0xce,
- 0x36, 0xcc, 0xef, 0xf0, 0x4f, 0xda, 0xe2, 0x46, 0xf2, 0x47, 0x02, 0x56, 0x85, 0x42, 0x19, 0xe9,
- 0xb3, 0x92, 0x92, 0x00, 0x23, 0xa8, 0x57, 0x00, 0xcd, 0xb3, 0x93, 0x82, 0x04, 0x01, 0x33, 0x15,
- 0x55, 0x00, 0xe9, 0xb7, 0x12, 0x47, 0x19, 0xc7, 0x8c, 0x47, 0xb3, 0xd5, 0x95, 0x00, 0x85, 0x89,
- 0x63, 0x8e, 0x05, 0x3a, 0xfd, 0x16, 0xfd, 0x55, 0xe3, 0x93, 0xb6, 0xd8, 0x81, 0x45, 0x22, 0x85,
- 0x3e, 0xc2, 0xef, 0xf0, 0x4f, 0xd6, 0x92, 0x47, 0x85, 0x46, 0x09, 0xe5, 0x33, 0x97, 0x96, 0x00,
- 0x98, 0xcb, 0x65, 0xb3, 0xb3, 0x96, 0x96, 0x00, 0x94, 0xcb, 0x85, 0x45, 0x22, 0x85, 0x3e, 0xc2,
- 0xef, 0xf0, 0x6f, 0xd4, 0xe3, 0x0b, 0x05, 0xd8, 0x92, 0x47, 0x81, 0x45, 0x22, 0x85, 0x9c, 0x47,
- 0xb3, 0xd4, 0x97, 0x00, 0x85, 0x88, 0xef, 0xf0, 0x0f, 0xd3, 0xe3, 0x83, 0x04, 0xd2, 0xb5, 0xbb,
- 0x82, 0x44, 0x4c, 0x18, 0x22, 0x85, 0xef, 0xf0, 0x6f, 0xd5, 0xe3, 0x1c, 0x05, 0xd6, 0x83, 0x45,
- 0x41, 0x03, 0x91, 0xc8, 0x23, 0x82, 0xb1, 0xc2, 0x22, 0x85, 0xef, 0xf0, 0x6f, 0xde, 0xe3, 0x05,
- 0x05, 0xd6, 0x81, 0x44, 0xf9, 0xbf, 0x03, 0xc5, 0x41, 0xc2, 0x22, 0x86, 0x93, 0x07, 0x15, 0x00,
- 0x23, 0x82, 0xf1, 0xc2, 0x39, 0x34, 0xcd, 0xb7, 0xe3, 0x5d, 0xf0, 0xda, 0xfd, 0x17, 0x45, 0xbb,
- 0xe3, 0x16, 0x07, 0xdc, 0xa3, 0x8a, 0x01, 0xc2, 0xd1, 0xb3, 0xd2, 0x47, 0x13, 0x07, 0xf0, 0x0f,
- 0x13, 0x05, 0xf0, 0x0f, 0x3e, 0xc2, 0x93, 0x87, 0x81, 0xc4, 0x37, 0xf3, 0x00, 0xe0, 0xfd, 0x52,
- 0x83, 0xc5, 0x07, 0x00, 0x63, 0x8c, 0xa5, 0x00, 0x03, 0x26, 0x83, 0x00, 0x83, 0xa3, 0x47, 0x00,
- 0x33, 0x06, 0x76, 0x40, 0x63, 0xfd, 0xc6, 0x1c, 0x23, 0x80, 0x57, 0x00, 0xe1, 0x07, 0x13, 0x86,
- 0x81, 0xca, 0xe3, 0x1f, 0xf6, 0xfc, 0x93, 0x06, 0xd0, 0x0f, 0x63, 0xe9, 0xe6, 0x1c, 0x05, 0x07,
- 0x13, 0x77, 0xf7, 0x0f, 0x23, 0x8f, 0xe1, 0xc0, 0x93, 0x87, 0x41, 0xc0, 0x3e, 0xc0, 0x9d, 0x67,
- 0x93, 0x87, 0x07, 0x53, 0x3a, 0xc4, 0x3e, 0xcc, 0x92, 0x47, 0x83, 0xc7, 0x07, 0x01, 0x63, 0x9c,
- 0x07, 0x14, 0x92, 0x47, 0x03, 0xc7, 0x07, 0x00, 0x93, 0x07, 0xf0, 0x0f, 0x63, 0x15, 0xf7, 0x14,
- 0x92, 0x47, 0x83, 0xc7, 0x87, 0x00, 0x63, 0x81, 0xe7, 0x02, 0x22, 0x47, 0x63, 0x6e, 0xf7, 0x00,
- 0xb7, 0xf7, 0x00, 0xe0, 0x98, 0x47, 0x92, 0x47, 0xdc, 0x47, 0x1d, 0x8f, 0xb7, 0x27, 0xb7, 0x00,
- 0x93, 0x87, 0xf7, 0xaf, 0x63, 0xf1, 0xe7, 0x12, 0x92, 0x46, 0x37, 0xf7, 0x00, 0xe0, 0x1c, 0x47,
- 0xd4, 0x4a, 0x95, 0x8f, 0x63, 0xc9, 0x07, 0x10, 0xc2, 0x47, 0x85, 0x65, 0x93, 0x85, 0x85, 0xbb,
- 0x03, 0xc5, 0x07, 0x00, 0x00, 0x47, 0x0d, 0x89, 0xef, 0xf0, 0x8f, 0x94, 0xe2, 0x47, 0x23, 0x07,
- 0x01, 0x02, 0xa3, 0x07, 0x01, 0x02, 0x3e, 0x94, 0x92, 0x47, 0x22, 0x95, 0xc8, 0xcb, 0x02, 0x45,
- 0xef, 0xf0, 0x4f, 0xd9, 0x63, 0x0b, 0x05, 0x0c, 0x02, 0x45, 0x93, 0x05, 0x20, 0x06, 0xef, 0xf0,
- 0xcf, 0xfb, 0x85, 0x47, 0xaa, 0x84, 0x63, 0x12, 0xf5, 0x06, 0x02, 0x45, 0x93, 0x05, 0x00, 0x05,
- 0xef, 0xf0, 0xaf, 0xfa, 0x2a, 0x84, 0x63, 0x1a, 0x95, 0x04, 0xa2, 0x45, 0x02, 0x45, 0xef, 0xf0,
- 0xcf, 0xf9, 0xaa, 0x84, 0x63, 0x13, 0x85, 0x04, 0x82, 0x47, 0xb7, 0x16, 0x01, 0x40, 0x93, 0x86,
- 0x06, 0x80, 0x03, 0xc4, 0x07, 0x00, 0x36, 0xce, 0x93, 0x77, 0xf4, 0x00, 0x11, 0x80, 0x2a, 0x04,
- 0x36, 0x94, 0x3e, 0xc6, 0xb3, 0x17, 0xf5, 0x00, 0x1c, 0xc8, 0x79, 0x45, 0xef, 0xf0, 0xaf, 0x96,
- 0x02, 0x45, 0xef, 0xf0, 0x0f, 0xd1, 0xf2, 0x46, 0x63, 0x1e, 0x05, 0x0c, 0x82, 0x47, 0x83, 0xc5,
- 0x17, 0x00, 0x03, 0xc5, 0x07, 0x00, 0xef, 0xf0, 0xef, 0xdf, 0x81, 0x44, 0x01, 0x44, 0x02, 0x45,
- 0xef, 0xf0, 0x4f, 0xda, 0xb9, 0xc8, 0x83, 0x47, 0xe1, 0x02, 0x12, 0x47, 0x23, 0x04, 0xf7, 0x00,
- 0xb7, 0xf7, 0x00, 0xe0, 0x9c, 0x47, 0x5c, 0xc7, 0x29, 0xc0, 0x48, 0x18, 0x81, 0x44, 0x63, 0xc0,
- 0x84, 0x1a, 0x02, 0x45, 0xef, 0xf0, 0x0f, 0xcf, 0x0d, 0xc9, 0x02, 0x45, 0x93, 0x05, 0x20, 0x06,
- 0xef, 0xf0, 0xaf, 0xf1, 0x85, 0x47, 0xaa, 0x84, 0x63, 0x1e, 0xf5, 0x00, 0x02, 0x45, 0x93, 0x05,
- 0xb0, 0x07, 0xef, 0xf0, 0x8f, 0xf0, 0x63, 0x17, 0x95, 0x00, 0x02, 0x45, 0x93, 0x75, 0xf4, 0x0f,
- 0xef, 0xf0, 0xaf, 0xef, 0x02, 0x45, 0xef, 0xf0, 0xef, 0xd4, 0x02, 0x47, 0x85, 0x47, 0x23, 0x02,
- 0xf7, 0x00, 0xa3, 0x01, 0xf7, 0x00, 0x92, 0x47, 0xe1, 0x07, 0x3e, 0xc2, 0x82, 0x47, 0x12, 0x47,
- 0x95, 0x07, 0x3e, 0xc0, 0x93, 0x87, 0x81, 0xca, 0xe3, 0x98, 0xe7, 0xe8, 0xc2, 0x47, 0x85, 0x65,
- 0x93, 0x85, 0x05, 0x77, 0x03, 0xc5, 0x17, 0x00, 0xb7, 0xf4, 0x00, 0xe0, 0x80, 0x44, 0x13, 0x05,
- 0x85, 0x3e, 0xef, 0xf0, 0xef, 0x81, 0x03, 0xa7, 0x01, 0xc3, 0x19, 0x8c, 0xe3, 0x6c, 0xa4, 0xc0,
- 0x98, 0x44, 0x09, 0x45, 0x23, 0xa8, 0xe1, 0xc2, 0xef, 0xf0, 0xef, 0x91, 0x21, 0xb1, 0x3a, 0x86,
- 0x63, 0xf3, 0xe5, 0x00, 0x2e, 0x86, 0x13, 0x77, 0xf6, 0x0f, 0x0d, 0xb5, 0x7d, 0x57, 0x23, 0x8f,
- 0xe1, 0xc0, 0xcd, 0xbe, 0x79, 0x45, 0x36, 0xce, 0xef, 0xf0, 0xef, 0x87, 0xb2, 0x47, 0x79, 0x45,
- 0xc1, 0x07, 0xb3, 0x97, 0xf4, 0x00, 0x1c, 0xc8, 0xef, 0xf0, 0xef, 0x86, 0x82, 0x47, 0xf2, 0x46,
- 0x79, 0x45, 0x83, 0xc7, 0x17, 0x00, 0x13, 0xd7, 0x47, 0x00, 0xbd, 0x8b, 0x2a, 0x07, 0xc1, 0x07,
- 0x36, 0x97, 0xb3, 0x97, 0xf4, 0x00, 0x1c, 0xcb, 0xef, 0xf0, 0xef, 0x84, 0x02, 0x45, 0x93, 0x05,
- 0x30, 0x06, 0xef, 0xf0, 0x8f, 0xe4, 0x2a, 0xc6, 0xe3, 0x19, 0x95, 0xee, 0x02, 0x45, 0x05, 0x46,
- 0x93, 0x05, 0xe1, 0x02, 0xef, 0xf0, 0x4f, 0xe7, 0xe3, 0x01, 0x05, 0xee, 0x02, 0x45, 0x05, 0x46,
- 0x93, 0x05, 0xf1, 0x02, 0xef, 0xf0, 0x4f, 0xe6, 0xe3, 0x09, 0x05, 0xec, 0x03, 0xc7, 0x71, 0xc3,
- 0x83, 0x46, 0xf1, 0x02, 0x93, 0x07, 0x00, 0x02, 0x99, 0x8f, 0x21, 0x47, 0x63, 0x74, 0xd7, 0x00,
- 0xa3, 0x07, 0xe1, 0x02, 0x03, 0x44, 0xf1, 0x02, 0x63, 0xd3, 0x87, 0x00, 0x3e, 0x84, 0xb2, 0x44,
- 0x54, 0x18, 0x01, 0x47, 0x13, 0x03, 0xf4, 0xff, 0x63, 0x5a, 0x87, 0x04, 0xe3, 0x81, 0x04, 0xea,
- 0x81, 0x47, 0x32, 0x46, 0x63, 0x16, 0xe3, 0x00, 0x13, 0x86, 0xc7, 0xff, 0x33, 0x36, 0xc0, 0x00,
- 0x02, 0x45, 0x0c, 0x18, 0x1a, 0xd4, 0x36, 0xd2, 0x3e, 0xd0, 0x3a, 0xce, 0xef, 0xf0, 0xcf, 0xe0,
- 0x82, 0x57, 0x91, 0x45, 0x03, 0x46, 0x01, 0x03, 0x72, 0x47, 0x92, 0x56, 0x22, 0x53, 0xaa, 0x84,
- 0x63, 0x8b, 0xb7, 0x00, 0xb3, 0x85, 0xf6, 0x00, 0x23, 0x80, 0xc5, 0x00, 0x85, 0x07, 0x71, 0xf1,
- 0x05, 0x07, 0x95, 0x06, 0x55, 0xbf, 0x23, 0x82, 0xc6, 0x00, 0xdd, 0xbf, 0xe3, 0x19, 0x04, 0xe4,
- 0x02, 0x45, 0x01, 0x46, 0x0c, 0x18, 0xef, 0xf0, 0x2f, 0xdd, 0xaa, 0x84, 0x89, 0xb5, 0x2a, 0xc6,
- 0xef, 0xe0, 0xdf, 0xfb, 0x32, 0x45, 0x85, 0x04, 0x15, 0x05, 0x91, 0xbd, 0x22, 0x45, 0xef, 0xf0,
- 0x4f, 0x9a, 0x61, 0xba, 0x16, 0x03, 0x00, 0x00, 0x5e, 0x03, 0x00, 0x00, 0x2c, 0x03, 0x00, 0x00,
- 0x2c, 0x03, 0x00, 0x00, 0x2c, 0x03, 0x00, 0x00, 0x2c, 0x03, 0x00, 0x00, 0x32, 0x03, 0x00, 0x00,
- 0x3c, 0x03, 0x00, 0x00, 0x42, 0x03, 0x00, 0x00, 0x24, 0x32, 0x53, 0x00, 0x00, 0x21, 0x22, 0x45,
- 0x00, 0x00, 0x34, 0x35, 0x57, 0x00, 0x00, 0x01, 0x02, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x02, 0x40, 0x13, 0x07, 0x00, 0x08, 0x98, 0xcb, 0xfd, 0x57, 0x23, 0x90, 0xf1, 0xc2, 0x01, 0xbb,
+ 0x12, 0x45, 0x32, 0xc8, 0x3a, 0xc6, 0xef, 0xf0, 0x6f, 0x97, 0xe3, 0x12, 0x05, 0xd6, 0x12, 0x45,
+ 0xef, 0xf0, 0xef, 0x9a, 0x32, 0x47, 0x39, 0xe5, 0x92, 0x57, 0xe3, 0x98, 0x07, 0xd4, 0xa2, 0x47,
+ 0x42, 0x46, 0x83, 0xc6, 0x07, 0x00, 0x93, 0xd7, 0x46, 0x00, 0xaa, 0x07, 0xb2, 0x97, 0x9c, 0x47,
+ 0xbd, 0x8a, 0xb3, 0xd7, 0xd7, 0x00, 0x85, 0x8b, 0xe3, 0x89, 0x07, 0xd2, 0x83, 0xc7, 0x04, 0x02,
+ 0x89, 0xeb, 0x85, 0x47, 0x23, 0x80, 0xf4, 0x02, 0xb7, 0xf7, 0x00, 0xe0, 0x9c, 0x47, 0xdc, 0xd0,
+ 0x39, 0xbb, 0xb7, 0xf7, 0x00, 0xe0, 0xd4, 0x50, 0x9c, 0x47, 0x95, 0x8f, 0x93, 0x06, 0xb0, 0x12,
+ 0xe3, 0xf7, 0xf6, 0xd0, 0xa2, 0x47, 0x23, 0x80, 0x04, 0x02, 0xa1, 0x45, 0x83, 0xc6, 0x07, 0x00,
+ 0x83, 0xc7, 0x21, 0xc2, 0x23, 0x02, 0xf1, 0x06, 0x03, 0xc6, 0xf1, 0xc2, 0xb2, 0x87, 0x63, 0xf3,
+ 0xc5, 0x00, 0xa1, 0x47, 0xa3, 0x02, 0xf1, 0x06, 0x13, 0x03, 0x61, 0x06, 0x81, 0x47, 0x03, 0x46,
+ 0x51, 0x06, 0x32, 0xce, 0x63, 0xc4, 0xc7, 0x10, 0x85, 0x47, 0x33, 0x94, 0x87, 0x00, 0xb7, 0x15,
+ 0x01, 0x40, 0x93, 0xd7, 0x46, 0x00, 0xbd, 0x8a, 0x93, 0x85, 0x05, 0x80, 0xaa, 0x07, 0x36, 0xc8,
+ 0xf2, 0x46, 0xae, 0x97, 0xf2, 0x45, 0x8a, 0x06, 0x03, 0xc6, 0x84, 0x02, 0xae, 0x96, 0x83, 0x55,
+ 0x41, 0x06, 0x36, 0xd6, 0x89, 0x06, 0x23, 0x18, 0xb1, 0x08, 0x89, 0x45, 0x63, 0xc6, 0xd5, 0x10,
+ 0x01, 0x43, 0x01, 0x45, 0x3e, 0xda, 0x1c, 0x09, 0xb3, 0x85, 0x67, 0x00, 0x83, 0xc5, 0x05, 0x00,
+ 0x36, 0xdc, 0x32, 0xd8, 0x3a, 0xca, 0x1a, 0xc6, 0xef, 0xf0, 0xef, 0xd5, 0x32, 0x43, 0xe2, 0x56,
+ 0x52, 0x47, 0x05, 0x03, 0x42, 0x56, 0xd2, 0x57, 0xe3, 0x4e, 0xd3, 0xfc, 0x8c, 0x10, 0x93, 0x86,
+ 0x06, 0x07, 0xae, 0x96, 0xc2, 0x45, 0x23, 0x80, 0xa6, 0xfc, 0x85, 0x46, 0xb3, 0x96, 0xb6, 0x00,
+ 0x36, 0xc6, 0x09, 0xca, 0x94, 0xcb, 0x49, 0x45, 0x3a, 0xd8, 0x3e, 0xca, 0xef, 0xf0, 0xaf, 0x84,
+ 0x42, 0x57, 0xd2, 0x47, 0xc2, 0x46, 0x05, 0x46, 0xc1, 0x06, 0xb3, 0x16, 0xd6, 0x00, 0x36, 0xd8,
+ 0x94, 0xcb, 0x85, 0x66, 0x93, 0x86, 0x06, 0xfa, 0x10, 0x47, 0x61, 0x8e, 0x63, 0x09, 0xc4, 0x0a,
+ 0xfd, 0x16, 0xfd, 0xfa, 0x02, 0xca, 0xb2, 0x46, 0x94, 0xcb, 0xd2, 0x46, 0x99, 0xce, 0x42, 0x46,
+ 0x85, 0x46, 0xa1, 0x45, 0xb3, 0x92, 0xc6, 0x00, 0x01, 0x46, 0x85, 0x66, 0x93, 0x86, 0x06, 0xfa,
+ 0x08, 0x47, 0x61, 0x8d, 0x41, 0xc9, 0xfd, 0x16, 0xe5, 0xfe, 0x02, 0xca, 0x12, 0x45, 0x23, 0x84,
+ 0x04, 0x02, 0xef, 0xf0, 0x4f, 0xab, 0xd2, 0x47, 0xe3, 0x8b, 0x07, 0xbe, 0x85, 0x47, 0x23, 0x8c,
+ 0xf4, 0x00, 0xb7, 0xf7, 0x00, 0xe0, 0x98, 0x47, 0x02, 0x45, 0xd8, 0xcc, 0x22, 0x57, 0x23, 0x80,
+ 0xe4, 0x00, 0x9c, 0x47, 0xdc, 0xc0, 0xef, 0xf0, 0xaf, 0x86, 0xd1, 0xbe, 0x03, 0xc6, 0xe1, 0xc2,
+ 0x3e, 0xc8, 0x1a, 0x85, 0x3e, 0x96, 0x7d, 0x8a, 0x93, 0x15, 0x26, 0x00, 0xb2, 0x95, 0x13, 0x86,
+ 0xc1, 0xc4, 0xb2, 0x95, 0x11, 0x46, 0x36, 0xce, 0x3a, 0xca, 0x2e, 0xc6, 0xef, 0xf0, 0x7f, 0x8f,
+ 0xb2, 0x45, 0xc2, 0x47, 0xf2, 0x46, 0x03, 0xc6, 0x45, 0x00, 0x52, 0x47, 0x85, 0x07, 0x23, 0x02,
+ 0xc5, 0x00, 0x13, 0x03, 0x55, 0x00, 0x65, 0xbd, 0x13, 0x03, 0x41, 0x06, 0x2e, 0x93, 0x03, 0x43,
+ 0x03, 0x00, 0x08, 0x09, 0x2e, 0x95, 0x23, 0x00, 0x65, 0x00, 0x85, 0x05, 0xc5, 0xb5, 0x85, 0x46,
+ 0x36, 0xca, 0x91, 0xbf, 0x85, 0x66, 0x93, 0x86, 0x06, 0xfa, 0x08, 0x47, 0x61, 0x8d, 0x63, 0x05,
+ 0xa4, 0x00, 0xfd, 0x16, 0xfd, 0xfa, 0x95, 0xb7, 0x94, 0x47, 0x06, 0x06, 0xfd, 0x15, 0xb3, 0xf6,
+ 0xd2, 0x00, 0xb3, 0x36, 0xd0, 0x00, 0x55, 0x8e, 0x13, 0x76, 0xf6, 0x0f, 0x9d, 0xfd, 0xa1, 0x45,
+ 0x02, 0xd4, 0x85, 0x66, 0x93, 0x86, 0x06, 0xfa, 0x08, 0x47, 0x61, 0x8d, 0x01, 0xc5, 0xfd, 0x16,
+ 0xe5, 0xfe, 0x25, 0xbf, 0x85, 0x66, 0x93, 0x86, 0x06, 0xfa, 0x08, 0x47, 0x61, 0x8d, 0x63, 0x05,
+ 0xa4, 0x00, 0xfd, 0x16, 0xfd, 0xfa, 0x15, 0xb7, 0x94, 0x47, 0x22, 0x55, 0xfd, 0x15, 0xb3, 0xf6,
+ 0xd2, 0x00, 0xb3, 0x36, 0xd0, 0x00, 0x06, 0x05, 0xc9, 0x8e, 0x93, 0xf6, 0xf6, 0x0f, 0x36, 0xd4,
+ 0xe9, 0xf1, 0x93, 0x06, 0x50, 0x0a, 0xe3, 0x12, 0xd6, 0xf0, 0x85, 0x66, 0x93, 0x86, 0x06, 0xfa,
+ 0x10, 0x47, 0x61, 0x8e, 0x63, 0x0d, 0x06, 0x54, 0xfd, 0x16, 0xfd, 0xfa, 0xfd, 0xb5, 0x33, 0xd6,
+ 0x63, 0x40, 0x05, 0x8a, 0x19, 0xce, 0x32, 0x46, 0x90, 0xcb, 0x05, 0x66, 0x13, 0x06, 0x06, 0xfa,
+ 0x83, 0x20, 0x87, 0x00, 0xb3, 0x70, 0x14, 0x00, 0x63, 0x07, 0x14, 0x00, 0x7d, 0x16, 0x6d, 0xfa,
+ 0x59, 0xa3, 0x42, 0x56, 0xd5, 0xb7, 0x7d, 0x13, 0x7d, 0x56, 0x63, 0x13, 0xc3, 0x56, 0x32, 0x56,
+ 0x85, 0x05, 0x63, 0xca, 0xc5, 0x54, 0x05, 0x66, 0x13, 0x06, 0x06, 0xfa, 0x0c, 0x47, 0xe1, 0x8d,
+ 0x63, 0x8b, 0x05, 0x4e, 0x7d, 0x16, 0x7d, 0xfa, 0xb9, 0xab, 0x85, 0x66, 0x93, 0x86, 0x06, 0xfa,
+ 0x0c, 0x47, 0xe1, 0x8d, 0x63, 0x05, 0xb4, 0x00, 0xfd, 0x16, 0xfd, 0xfa, 0x79, 0xb5, 0x94, 0x47,
+ 0x82, 0x45, 0x7d, 0x16, 0xb3, 0xf6, 0xd2, 0x00, 0xb3, 0x36, 0xd0, 0x00, 0x86, 0x05, 0xcd, 0x8e,
+ 0x93, 0xf6, 0xf6, 0x0f, 0x36, 0xc0, 0x21, 0xce, 0x85, 0x66, 0x93, 0x86, 0x06, 0xfa, 0x0c, 0x47,
+ 0xe1, 0x8d, 0xe1, 0xd5, 0xfd, 0x16, 0xe5, 0xfe, 0x8d, 0xb5, 0x05, 0x66, 0x13, 0x06, 0x06, 0xfa,
+ 0x08, 0x47, 0x61, 0x8d, 0x63, 0x05, 0xa4, 0x00, 0x7d, 0x16, 0x7d, 0xfa, 0xb9, 0xb5, 0x90, 0x47,
+ 0x86, 0x06, 0xfd, 0x15, 0x33, 0xf6, 0xc2, 0x00, 0x33, 0x36, 0xc0, 0x00, 0xd1, 0x8e, 0x93, 0xf6,
+ 0xf6, 0x0f, 0x85, 0xe1, 0x82, 0x47, 0x93, 0xc6, 0xf6, 0xff, 0x93, 0xf6, 0xf6, 0x0f, 0x63, 0x96,
+ 0xd7, 0x00, 0x82, 0x47, 0x72, 0x47, 0xe3, 0x73, 0xf7, 0xe2, 0x02, 0xc0, 0x05, 0xb5, 0xa1, 0x45,
+ 0x81, 0x46, 0x05, 0x66, 0x13, 0x06, 0x06, 0xfa, 0x08, 0x47, 0x61, 0x8d, 0x5d, 0xd5, 0x7d, 0x16,
+ 0x65, 0xfe, 0x21, 0xb5, 0xe3, 0x53, 0xf0, 0xa4, 0xfd, 0x17, 0x35, 0xbc, 0xe3, 0x1c, 0x07, 0xa4,
+ 0xa3, 0x86, 0x01, 0xc2, 0x81, 0xbc, 0x3e, 0x87, 0x63, 0xf3, 0xf5, 0x00, 0x2e, 0x87, 0x93, 0x77,
+ 0xf7, 0x0f, 0x79, 0xb4, 0x85, 0x07, 0x23, 0x81, 0xf1, 0xc2, 0x82, 0x54, 0x93, 0x87, 0x41, 0xc0,
+ 0x3e, 0xca, 0x02, 0xc4, 0x22, 0x45, 0xef, 0xe0, 0x7f, 0xde, 0x83, 0xc7, 0x21, 0xc2, 0x2a, 0xd8,
+ 0x3e, 0xc8, 0x63, 0x1a, 0x05, 0x1e, 0x03, 0xc7, 0x04, 0x00, 0x93, 0x07, 0xf0, 0x0f, 0x63, 0x14,
+ 0xf7, 0x1e, 0x83, 0xc7, 0x84, 0x02, 0x63, 0x90, 0x07, 0x1e, 0x83, 0xc7, 0x84, 0x00, 0x63, 0x99,
+ 0xe7, 0x14, 0x83, 0xc7, 0x84, 0x00, 0x13, 0x07, 0xf0, 0x0f, 0x63, 0x98, 0xe7, 0x1a, 0xb7, 0xf7,
+ 0x00, 0xe0, 0x9c, 0x47, 0xd8, 0x54, 0x01, 0x44, 0x99, 0x8f, 0x63, 0xce, 0x07, 0x1a, 0xb7, 0xf7,
+ 0x00, 0xe0, 0x9c, 0x47, 0x85, 0x65, 0x93, 0x85, 0x05, 0x77, 0x3e, 0xc2, 0xc6, 0x47, 0x03, 0xc5,
+ 0x07, 0x00, 0x1d, 0x89, 0x13, 0x05, 0x45, 0x06, 0xef, 0xe0, 0x9f, 0xcd, 0x92, 0x47, 0xa2, 0x46,
+ 0x3e, 0x95, 0xd2, 0x47, 0x23, 0xae, 0xd1, 0xc0, 0x03, 0xc7, 0xf1, 0xc2, 0xc8, 0xd4, 0x03, 0xc5,
+ 0x07, 0x00, 0x83, 0xc7, 0x17, 0x00, 0xba, 0xcc, 0xb7, 0x16, 0x01, 0x40, 0x13, 0xd7, 0x47, 0x00,
+ 0x93, 0x86, 0x06, 0x80, 0x2a, 0x07, 0x36, 0x97, 0x14, 0x47, 0xa3, 0x00, 0xf1, 0x06, 0xbd, 0x8b,
+ 0xb3, 0xd6, 0xf6, 0x00, 0x85, 0x8a, 0x23, 0x00, 0xa1, 0x06, 0x36, 0xd6, 0xb5, 0xca, 0xc1, 0x07,
+ 0x85, 0x46, 0xb3, 0x97, 0xf6, 0x00, 0x1c, 0xcb, 0x63, 0x15, 0x04, 0x16, 0x03, 0x45, 0x01, 0x06,
+ 0x85, 0x66, 0x93, 0x86, 0x06, 0x9b, 0x13, 0x06, 0xc0, 0x5d, 0x81, 0x45, 0xef, 0xf0, 0x0f, 0x98,
+ 0xb3, 0x37, 0xa0, 0x00, 0x3e, 0xc6, 0x0d, 0x45, 0xef, 0xe0, 0xff, 0xcf, 0x03, 0x45, 0x11, 0x06,
+ 0x37, 0x14, 0x01, 0x40, 0x13, 0x04, 0x04, 0x80, 0x93, 0x57, 0x45, 0x00, 0xaa, 0x07, 0x93, 0x76,
+ 0xf5, 0x00, 0x05, 0x47, 0xa2, 0x97, 0xb3, 0x16, 0xd7, 0x00, 0x94, 0xcb, 0xb2, 0x47, 0x63, 0x9e,
+ 0x07, 0x12, 0x03, 0x47, 0x11, 0x06, 0xb7, 0x16, 0x01, 0x40, 0x93, 0x86, 0x06, 0x80, 0x93, 0x57,
+ 0x47, 0x00, 0xaa, 0x07, 0xb6, 0x97, 0x3d, 0x8b, 0x85, 0x46, 0x33, 0x97, 0xe6, 0x00, 0x98, 0xcb,
+ 0x01, 0x44, 0x02, 0xc6, 0x22, 0x45, 0x7d, 0x57, 0x23, 0xae, 0xe1, 0xc0, 0xef, 0xe0, 0xbf, 0xf6,
+ 0xb2, 0x47, 0xf1, 0xcb, 0x85, 0x47, 0x23, 0x8c, 0xf4, 0x00, 0xb7, 0xf7, 0x00, 0xe0, 0x98, 0x47,
+ 0xd8, 0xcc, 0x03, 0x47, 0x01, 0x09, 0x23, 0x84, 0xe4, 0x00, 0x9c, 0x47, 0x18, 0x09, 0xdc, 0xc4,
+ 0xc2, 0x57, 0x15, 0x07, 0x63, 0xd9, 0x87, 0x0a, 0x93, 0x05, 0xd7, 0xff, 0x11, 0x46, 0xc8, 0x10,
+ 0x3a, 0xc2, 0xef, 0xf0, 0x0f, 0xdc, 0x12, 0x47, 0xc8, 0x10, 0x83, 0x47, 0x17, 0x00, 0x23, 0x04,
+ 0xf1, 0x06, 0xef, 0xe0, 0xff, 0xd1, 0xc2, 0x57, 0x12, 0x47, 0x85, 0x07, 0x3e, 0xd8, 0xc9, 0xbf,
+ 0x42, 0x47, 0xe3, 0x78, 0xf7, 0xea, 0xb7, 0xf7, 0x00, 0xe0, 0x98, 0x47, 0xdc, 0x44, 0x1d, 0x8f,
+ 0xb7, 0xf7, 0x36, 0x00, 0x93, 0x87, 0xf7, 0xe7, 0xe3, 0xed, 0xe7, 0xe8, 0x22, 0x45, 0xef, 0xe0,
+ 0x1f, 0xc9, 0xe3, 0x08, 0x05, 0xe8, 0xd2, 0x47, 0xb7, 0x16, 0x01, 0x40, 0x93, 0x86, 0x06, 0x80,
+ 0x03, 0xc7, 0x07, 0x00, 0x93, 0x57, 0x47, 0x00, 0xaa, 0x07, 0xb6, 0x97, 0x9c, 0x47, 0x3d, 0x8b,
+ 0xb3, 0xd7, 0xe7, 0x00, 0x85, 0x8b, 0xe3, 0x96, 0x07, 0xe6, 0xd2, 0x47, 0x03, 0xc7, 0x17, 0x00,
+ 0x93, 0x57, 0x47, 0x00, 0xaa, 0x07, 0xb6, 0x97, 0x9c, 0x47, 0x3d, 0x8b, 0xb3, 0xd7, 0xe7, 0x00,
+ 0x85, 0x8b, 0xe3, 0x88, 0x07, 0xe4, 0x05, 0x44, 0x9d, 0xb5, 0x42, 0x47, 0xe3, 0x69, 0xf7, 0xe4,
+ 0xb7, 0xf7, 0x00, 0xe0, 0x98, 0x47, 0xdc, 0x44, 0x1d, 0x8f, 0xb7, 0x27, 0xb7, 0x00, 0x93, 0x87,
+ 0xf7, 0xaf, 0xe3, 0xee, 0xe7, 0xe2, 0xa2, 0x47, 0x93, 0x84, 0x04, 0x03, 0x85, 0x07, 0x3e, 0xc4,
+ 0xd2, 0x47, 0x22, 0x47, 0x95, 0x07, 0x3e, 0xca, 0x91, 0x47, 0xe3, 0x15, 0xf7, 0xde, 0x6f, 0xf0,
+ 0x9f, 0x87, 0x85, 0x66, 0x93, 0x86, 0x06, 0x9b, 0x13, 0x06, 0xc0, 0x5d, 0x85, 0x45, 0xef, 0xf0,
+ 0xef, 0x81, 0x2a, 0xc6, 0xe3, 0x14, 0x05, 0xe8, 0x79, 0xbd, 0x81, 0x46, 0x13, 0x06, 0x80, 0x0c,
+ 0x85, 0x45, 0xef, 0xf0, 0xaf, 0x80, 0xe3, 0x0e, 0x05, 0xea, 0x03, 0x45, 0x01, 0x06, 0x81, 0x46,
+ 0x13, 0x06, 0x80, 0x0c, 0x85, 0x45, 0xef, 0xe0, 0x7f, 0xff, 0xe3, 0x04, 0x05, 0xea, 0x83, 0x46,
+ 0x11, 0x06, 0xbd, 0x45, 0x0d, 0x46, 0x93, 0xd7, 0x46, 0x00, 0xaa, 0x07, 0xa2, 0x97, 0x13, 0xf7,
+ 0xf6, 0x00, 0x3e, 0xce, 0xba, 0xc0, 0x9c, 0x43, 0x0a, 0x07, 0xb3, 0x96, 0xe5, 0x00, 0x3a, 0xda,
+ 0x13, 0xc7, 0xf6, 0xff, 0xba, 0xc2, 0xf9, 0x8f, 0x52, 0x57, 0x0d, 0x45, 0xb3, 0x16, 0xe6, 0x00,
+ 0x72, 0x47, 0xd5, 0x8f, 0x1c, 0xc3, 0x83, 0x47, 0x01, 0x06, 0x93, 0xd6, 0x47, 0x00, 0xaa, 0x06,
+ 0x33, 0x87, 0x86, 0x00, 0xbd, 0x8b, 0x93, 0x96, 0x27, 0x00, 0x3a, 0xc2, 0x18, 0x43, 0xb3, 0x95,
+ 0xd5, 0x00, 0xbe, 0xc4, 0x93, 0xc7, 0xf5, 0xff, 0x3e, 0xdc, 0x7d, 0x8f, 0x92, 0x47, 0x33, 0x16,
+ 0xd6, 0x00, 0x51, 0x8f, 0x98, 0xc3, 0x36, 0xde, 0xef, 0xe0, 0xff, 0xb0, 0x01, 0x46, 0x93, 0x05,
+ 0x50, 0x0a, 0x88, 0x10, 0xef, 0xf0, 0x8f, 0x80, 0xc2, 0x45, 0x01, 0x46, 0x88, 0x10, 0xef, 0xe0,
+ 0xff, 0xff, 0xa6, 0x47, 0x05, 0x47, 0xf2, 0x56, 0xb3, 0x17, 0xf7, 0x00, 0xbe, 0xc4, 0x26, 0x47,
+ 0x92, 0x47, 0x85, 0x45, 0x88, 0x10, 0x98, 0xcb, 0x15, 0x47, 0x33, 0x17, 0xd7, 0x00, 0x9c, 0x43,
+ 0xba, 0xc6, 0x62, 0x57, 0xf9, 0x8f, 0x36, 0x47, 0xd9, 0x8f, 0x12, 0x47, 0x1c, 0xc3, 0xef, 0xf0,
+ 0xcf, 0x88, 0x2a, 0x84, 0x23, 0x08, 0xa1, 0x08, 0x81, 0x45, 0x88, 0x10, 0xef, 0xf0, 0xef, 0x87,
+ 0xa2, 0x85, 0x2a, 0xc8, 0xa3, 0x08, 0xa1, 0x08, 0x01, 0x45, 0xef, 0xe0, 0xdf, 0xf8, 0xc2, 0x45,
+ 0xef, 0xe0, 0x7f, 0xf8, 0xc2, 0x47, 0x2a, 0x84, 0x13, 0x97, 0x27, 0x00, 0x3e, 0x97, 0xc2, 0x46,
+ 0xa1, 0x47, 0x63, 0xe3, 0xd7, 0x06, 0xb2, 0x57, 0x85, 0x07, 0x3e, 0xde, 0xb2, 0x57, 0xfd, 0x17,
+ 0x63, 0xc7, 0xe7, 0x02, 0x81, 0x45, 0x88, 0x10, 0xef, 0xf0, 0x2f, 0x84, 0x63, 0x16, 0xa4, 0x04,
+ 0x66, 0x47, 0x93, 0x07, 0x00, 0x02, 0x99, 0x8f, 0x42, 0x47, 0x3e, 0x84, 0x93, 0xf7, 0xf7, 0x0f,
+ 0x63, 0x74, 0xf7, 0x00, 0x03, 0x44, 0x01, 0x01, 0x13, 0x74, 0xf4, 0x0f, 0x05, 0xa8, 0x81, 0x45,
+ 0x88, 0x10, 0xba, 0xce, 0xef, 0xf0, 0x6f, 0x81, 0xf2, 0x57, 0x98, 0x10, 0xaa, 0x85, 0x93, 0x87,
+ 0x07, 0x07, 0xba, 0x97, 0x23, 0x80, 0xa7, 0xfc, 0x22, 0x85, 0xef, 0xe0, 0xdf, 0xf1, 0xf2, 0x57,
+ 0x76, 0x47, 0x2a, 0x84, 0x3e, 0xd6, 0x61, 0xbf, 0x02, 0xc6, 0x01, 0x44, 0x05, 0x46, 0xa2, 0x85,
+ 0x88, 0x10, 0xef, 0xe0, 0xbf, 0xf2, 0x93, 0x45, 0xf4, 0xff, 0x01, 0x46, 0x93, 0xf5, 0xf5, 0x0f,
+ 0x88, 0x10, 0xef, 0xe0, 0xbf, 0xf1, 0x92, 0x47, 0x26, 0x47, 0xd2, 0x56, 0x98, 0xcb, 0x9c, 0x43,
+ 0x62, 0x57, 0xf9, 0x8f, 0x36, 0x47, 0xd9, 0x8f, 0x12, 0x47, 0x1c, 0xc3, 0x06, 0x47, 0x85, 0x47,
+ 0xb3, 0x97, 0xe7, 0x00, 0x72, 0x47, 0x1c, 0xcb, 0x1c, 0x43, 0x16, 0x47, 0xf9, 0x8f, 0x15, 0x47,
+ 0x33, 0x17, 0xd7, 0x00, 0xd9, 0x8f, 0x72, 0x47, 0x1c, 0xc3, 0xb2, 0x47, 0xe3, 0x94, 0x07, 0xd2,
+ 0x05, 0xb3, 0x63, 0x8b, 0x07, 0xf2, 0x83, 0x47, 0x07, 0x00, 0x13, 0xd3, 0x47, 0x00, 0x2a, 0x03,
+ 0xbd, 0x8b, 0xb3, 0x17, 0xf5, 0x00, 0x32, 0x93, 0x23, 0x28, 0xf3, 0x00, 0xe2, 0x47, 0x23, 0x84,
+ 0x07, 0x02, 0x6f, 0xf0, 0x6f, 0xf1, 0x32, 0x46, 0x02, 0xc0, 0x90, 0xcb, 0x90, 0x43, 0xf1, 0x8e,
+ 0x15, 0x46, 0x33, 0x16, 0xa6, 0x00, 0xd1, 0x8e, 0x94, 0xc3, 0x21, 0x46, 0x35, 0xb6, 0x3e, 0xdc,
+ 0xb2, 0x57, 0x0d, 0x45, 0x16, 0xde, 0x8d, 0x07, 0x3a, 0xda, 0x3e, 0xd6, 0xef, 0xe0, 0xbf, 0x98,
+ 0xe2, 0x57, 0x42, 0x47, 0xbd, 0x46, 0x90, 0x43, 0x13, 0x15, 0x27, 0x00, 0xb3, 0x96, 0xa6, 0x00,
+ 0x93, 0xc6, 0xf6, 0xff, 0x8d, 0x45, 0xb3, 0x95, 0xa5, 0x00, 0x75, 0x8e, 0x52, 0x57, 0xf2, 0x52,
+ 0x4d, 0x8e, 0x90, 0xc3, 0x81, 0x45, 0x10, 0x09, 0x2e, 0x96, 0x83, 0x43, 0x06, 0x00, 0x1d, 0x43,
+ 0x05, 0x66, 0x13, 0x06, 0x06, 0xfa, 0x83, 0x20, 0x87, 0x00, 0xb3, 0x70, 0x14, 0x00, 0xe3, 0x80,
+ 0x00, 0xa6, 0x7d, 0x16, 0x6d, 0xfa, 0x32, 0x47, 0x98, 0xcb, 0x98, 0x43, 0x75, 0x8f, 0x95, 0x46,
+ 0xb3, 0x96, 0xa6, 0x00, 0x55, 0x8f, 0x98, 0xc3, 0x0d, 0xba, 0x00, 0x00, 0x96, 0x03, 0x00, 0x00,
+ 0xde, 0x03, 0x00, 0x00, 0xac, 0x03, 0x00, 0x00, 0xac, 0x03, 0x00, 0x00, 0xac, 0x03, 0x00, 0x00,
+ 0xac, 0x03, 0x00, 0x00, 0xb2, 0x03, 0x00, 0x00, 0xbc, 0x03, 0x00, 0x00, 0xc2, 0x03, 0x00, 0x00,
+ 0x24, 0x32, 0x53, 0x00, 0x00, 0x21, 0x22, 0x45, 0x00, 0x00, 0x34, 0x35, 0x57, 0x00, 0x00, 0x01,
+ 0x02, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
};
diff --git a/firmware/keybit/Makefile b/firmware/keybit/Makefile
index e043f37..e841de5 100644
--- a/firmware/keybit/Makefile
+++ b/firmware/keybit/Makefile
@@ -2,7 +2,7 @@ all : build
TARGET := main
TARGET_MCU ?= CH32V003
-ADDITIONAL_C_FILES := soft_i2c.c
+ADDITIONAL_C_FILES := soft_i2c.c link.c
# ch32v003fun is fetched on first build (pinned) unless you point CH32V003FUN
# at your own checkout.
diff --git a/firmware/keybit/README.md b/firmware/keybit/README.md
index 31d1280..9a31c27 100644
--- a/firmware/keybit/README.md
+++ b/firmware/keybit/README.md
@@ -65,7 +65,6 @@ Reads and writes auto-increment from the pointer written first.
| 0x10-0x1B | 96-bit UID, little endian |
| 0x20-0x2B | ASSIGN: UID to match (write) |
| 0x2C | ASSIGN: new address, 0 = forget. Writing this applies it. |
-| 0x50 | (write) depth of the Keybit polling us over a link |
| 0x51 | our depth, 0xFF if we can't reach the keyword |
| 0x52 | events ready, at most 8 |
| 0x53-0x7A | up to 8 events of 5 bytes: UID bits 0..31, flags |
@@ -83,20 +82,50 @@ private link between two Keybits, so key state hops inward along a tree:
takes one more than the shallowest neighbour that polls it. Depth only
comes from being polled, so when a Keybit is pulled out everything behind
it drops to "no depth" within 600 ms, with no loops.
-- **Polling.** A Keybit with a depth acts as I2C controller (address 0x31,
- about 100 kHz) on each other side every ~5 ms, unless that neighbour polls
- it or is no deeper. A poll writes our depth to 0x50, reads 0x51 onwards
- (the child's depth, event count and up to 8 events), then writes 0x7B to
- drop the ones we kept.
+- **Polling.** A Keybit with a depth polls each other side over the link
+ protocol below, unless that neighbour polls it or is no deeper. It polls
+ a known child every ~100 ms to keep its depth fresh, probes empty sides
+ every ~100 ms, and polls at once when a child rings the doorbell.
- **Events.** Each Keybit queues its own key changes plus a heartbeat about
once a second, and forwards its children's. The keyword drains the
- touching Keybits the same way (`keybit_bus_poll_relay`) into
- `keybit_remotes[]`, and drops a remote Keybit after 3 s without a
- heartbeat.
-- **Safety.** A side where any address other than 0x31 shows up is the
- keyword's shared bus; a Keybit never drives that side as controller. It
- also listens for 600 ms after power-up before polling anything.
-
-Latency is roughly 5 ms per hop plus retries when a poll lands while the
-neighbour is busy on another side. Remote Keybits are identified by the low
-32 bits of their UID.
+ touching Keybits over I2C (`keybit_bus_poll_relay`, registers
+ 0x51-0x7B) into `keybit_remotes[]`, and drops a remote Keybit after 3 s
+ without a heartbeat.
+- **Safety.** A side where an I2C address shows up is the keyword's shared
+ bus; a Keybit never starts a link frame or rings there. It also listens
+ for 600 ms after power-up before driving anything.
+
+## Link protocol
+
+Keybit-to-Keybit links use the same two pins as I2C, renamed DT (SDA) and
+CK (SCL), with a lighter protocol (`link.c`):
+
+1. **Idle and handshake are open-drain**, on the 10k pull-ups, because
+ either end may pull a line and an unknown side could be the keyword's
+ bus.
+ - *Request:* the parent pulls CK low. On a side not yet known to be a
+ link, the child only answers once CK has been low for 50 us with DT
+ high, which never happens on I2C.
+ - *Doorbell:* a child with events holds DT low (CK high) towards its
+ parent, which polls it straight away.
+ - *Ack:* the child pulls DT low; the parent releases CK, the child
+ releases DT, and both lines high starts the frame.
+2. **The frame is push-pull.** The parent drives CK; whoever is sending
+ drives DT, and at each turnaround one end lets go 1 us before the other
+ drives, so outputs never fight. Half a clock period is 0.5 us, so about
+ 1 Mbit/s, MSB first. The parent never waits on the child mid-frame, so
+ a Keybit pulled out mid-frame can't hang it; a child that falls behind
+ just fails the CRC.
+
+| Direction | Bytes |
+|---|---|
+| parent -> child | 0xA5, parent depth |
+| child -> parent | child depth, n (0-8), n x 5 event bytes, CRC-8 (poly 0x07) |
+| parent -> child | kept, ~kept |
+
+The child drops the first `kept` events. A frame with one event takes about
+120 us including the handshake, so a key press moves one hop in well under
+a millisecond. If frames fail on real hardware, raise `HALF` in `link.c`
+first.
+
+Remote Keybits are identified by the low 32 bits of their UID.
diff --git a/firmware/keybit/link.c b/firmware/keybit/link.c
new file mode 100644
index 0000000..a0eb296
--- /dev/null
+++ b/firmware/keybit/link.c
@@ -0,0 +1,216 @@
+#include "ch32fun.h"
+#include "link.h"
+
+/* Half a clock period, in SysTick ticks: 0.5 us, so about 1 Mbit/s. Lines
+ * are driven both ways during a frame, so the limit is how far the child's
+ * polling loop trails CK (a few hundred ns), not the pull-ups. */
+#define HALF (DELAY_US_TIME / 2)
+/* Bus turnaround: one end lets go of DT this long before the other drives
+ * it, so the two outputs never fight. */
+#define TURN DELAY_US_TIME
+/* How long the parent waits for a child to notice a request. A child can
+ * be busy on another side for about a millisecond. */
+#define ACK_US 1500
+/* Any single step once a frame has started. */
+#define STEP_US 200
+
+#define DT(p) (funDigitalRead((p)->dt) != 0)
+#define CK(p) (funDigitalRead((p)->ck) != 0)
+#define DT_LOW(p) funDigitalWrite((p)->dt, FUN_LOW)
+#define DT_REL(p) funDigitalWrite((p)->dt, FUN_HIGH)
+#define CK_LOW(p) funDigitalWrite((p)->ck, FUN_LOW)
+#define CK_REL(p) funDigitalWrite((p)->ck, FUN_HIGH)
+
+/* Idle and handshake stay open-drain: either end may pull a line then,
+ * and an unknown side might be the keyword's I2C bus. A line only goes
+ * push-pull once the handshake has settled who owns it. */
+#define DRIVE(pin) funPinMode(pin, GPIO_CFGLR_OUT_50Mhz_PP)
+#define RELEASE(pin) do { funDigitalWrite(pin, FUN_HIGH); funPinMode(pin, GPIO_CFGLR_OUT_10Mhz_OD); } while (0)
+
+static int wait_pin(uint8_t pin, int level, uint32_t us, link_idle_fn idle)
+{
+ uint32_t t0 = SysTick->CNT, span = us * DELAY_US_TIME;
+ while ((funDigitalRead(pin) != 0) != level) {
+ if (SysTick->CNT - t0 >= span) return 0;
+ if (idle && idle()) return 0;
+ }
+ return 1;
+}
+
+static uint8_t crc8(uint8_t crc, uint8_t v)
+{
+ crc ^= v;
+ for (int i = 0; i < 8; i++) crc = (uint8_t)(crc & 0x80 ? (crc << 1) ^ 0x07 : crc << 1);
+ return crc;
+}
+
+/* ------------------------------------------------------------------------ */
+/* Parent */
+
+/* turn: the child drove DT last; give it time to let go before we drive. */
+static void p_put(const link_pins_t *p, uint8_t v, int turn)
+{
+ for (int i = 7; i >= 0; i--) {
+ CK_LOW(p);
+ if (turn) { DelaySysTick(TURN); DRIVE(p->dt); turn = 0; }
+ if ((v >> i) & 1) DT_REL(p); else DT_LOW(p);
+ DelaySysTick(HALF);
+ CK_REL(p);
+ DelaySysTick(HALF);
+ }
+}
+
+/* turn: we drove DT last and just let go; give the child a little longer
+ * on the first bit to take it over. */
+static uint8_t p_get(const link_pins_t *p, int turn)
+{
+ uint8_t x = 0;
+ for (int i = 0; i < 8; i++) {
+ CK_LOW(p);
+ DelaySysTick(turn ? HALF + TURN : HALF);
+ turn = 0;
+ CK_REL(p);
+ DelaySysTick(HALF);
+ x = (uint8_t)((x << 1) | DT(p));
+ }
+ return x;
+}
+
+int link_poll(const link_pins_t *p, int doorbell, uint8_t my_depth,
+ link_reply_t *child, uint8_t room, uint8_t *kept, link_idle_fn idle)
+{
+ if (!CK(p)) return 0;
+ CK_LOW(p);
+
+ /* A ringing child already holds DT low, so wait for it to let go
+ * before taking DT low as the ack. */
+ int ok = !doorbell || wait_pin(p->dt, 1, ACK_US, idle);
+ ok = ok && wait_pin(p->dt, 0, ACK_US, idle);
+ DelaySysTick(HALF);
+ CK_REL(p);
+ ok = ok && wait_pin(p->ck, 1, STEP_US, 0) && wait_pin(p->dt, 1, STEP_US, 0);
+ if (!ok) { CK_REL(p); return 0; }
+
+ /* From here we own CK and drive it both ways. The frame runs on our
+ * clock without waiting for the child, so it can't hang if the child is
+ * pulled away; a child that falls behind just fails the CRC. */
+ DRIVE(p->ck);
+ DRIVE(p->dt);
+ DelaySysTick(HALF);
+ p_put(p, LINK_MAGIC, 0);
+ p_put(p, my_depth, 0);
+ RELEASE(p->dt);
+
+ child->depth = p_get(p, 1);
+ child->n = p_get(p, 0);
+ uint8_t crc = crc8(crc8(0, child->depth), child->n);
+ int good = child->n <= LINK_EVENTS;
+ for (int i = 0; good && i < child->n * LINK_EV_SIZE; i++) {
+ child->ev[i] = p_get(p, 0);
+ crc = crc8(crc, child->ev[i]);
+ }
+ good = good && p_get(p, 0) == crc;
+
+ uint8_t k = !good ? 0 : child->n < room ? child->n : room;
+ p_put(p, k, 1);
+ p_put(p, (uint8_t)~k, 0);
+ RELEASE(p->dt);
+ RELEASE(p->ck);
+ if (!good) return 0;
+ *kept = k;
+ return 1;
+}
+
+/* ------------------------------------------------------------------------ */
+/* Child */
+
+/* The parent doesn't wait for us mid-frame, so following CK has to be
+ * quick: spin on the input register directly, a few cycles per check.
+ * SPIN bounds the wait (roughly 200 us at 48 MHz). */
+#define SPIN 4000
+
+typedef struct {
+ const volatile uint32_t *in;
+ uint32_t ck, dt;
+} fast_t;
+
+static inline __attribute__((always_inline)) int spin(const fast_t *f, int level)
+{
+ uint32_t want = level ? f->ck : 0;
+ for (int n = SPIN; n; n--)
+ if ((*f->in & f->ck) == want) return 1;
+ return 0;
+}
+
+static inline __attribute__((always_inline)) int c_get(const fast_t *f, const fast_t *d, uint8_t *v)
+{
+ uint8_t x = 0;
+ for (int i = 0; i < 8; i++) {
+ if (!spin(f, 0) || !spin(f, 1)) return 0;
+ x = (uint8_t)((x << 1) | ((*d->in & d->dt) != 0));
+ }
+ *v = x;
+ return 1;
+}
+
+static inline __attribute__((always_inline)) int c_put(const fast_t *f, const link_pins_t *p, uint8_t v)
+{
+ for (int i = 7; i >= 0; i--) {
+ if (!spin(f, 0)) return 0;
+ if ((v >> i) & 1) DT_REL(p); else DT_LOW(p);
+ if (!spin(f, 1)) return 0;
+ }
+ return 1;
+}
+
+int link_serve(const link_pins_t *p, int ringing, const link_reply_t *reply,
+ uint8_t *parent_depth, uint8_t *kept)
+{
+ /* CK and DT may sit on different ports. */
+ fast_t f = { &GpioOf(p->ck)->INDR, 1u << (p->ck & 0xf), 0 };
+ fast_t d = { &GpioOf(p->dt)->INDR, 0, 1u << (p->dt & 0xf) };
+
+ /* Work out everything we send now; there's no time between bytes. */
+ uint8_t out[2 + LINK_EVENTS * LINK_EV_SIZE + 1];
+ int len = 2 + reply->n * LINK_EV_SIZE;
+ out[0] = reply->depth;
+ out[1] = reply->n;
+ for (int i = 2; i < len; i++) out[i] = reply->ev[i - 2];
+ uint8_t crc = 0;
+ for (int i = 0; i < len; i++) crc = crc8(crc, out[i]);
+ out[len++] = crc;
+
+ if (ringing) {
+ DT_REL(p);
+ Delay_Us(3); /* long enough for the parent to see DT high */
+ }
+ DT_LOW(p);
+ int ok = spin(&f, 1);
+ DT_REL(p);
+ if (!ok) return 0;
+
+ uint8_t magic, depth;
+ if (!c_get(&f, &d, &magic) || !c_get(&f, &d, &depth) || magic != LINK_MAGIC) return 0;
+
+ /* The parent let go of DT after its last bit and gives us an extra TURN
+ * on this first low phase; wait half of it, then drive. */
+ if (!spin(&f, 0)) return 0;
+ DelaySysTick(TURN / 2);
+ DRIVE(p->dt);
+ for (int i = 0; i < len; i++)
+ if (!c_put(&f, p, out[i])) goto fail;
+
+ /* Let go of DT as soon as the parent takes CK low for its next bit. */
+ if (!spin(&f, 0)) goto fail;
+ RELEASE(p->dt);
+
+ uint8_t k, inv;
+ if (!c_get(&f, &d, &k) || !c_get(&f, &d, &inv)) return 0;
+ *parent_depth = depth;
+ *kept = (uint8_t)~inv == k && k <= reply->n ? k : 0;
+ return 1;
+
+fail:
+ RELEASE(p->dt);
+ return 0;
+}
diff --git a/firmware/keybit/link.h b/firmware/keybit/link.h
new file mode 100644
index 0000000..fe6cc55
--- /dev/null
+++ b/firmware/keybit/link.h
@@ -0,0 +1,65 @@
+/*
+ * Keybit-to-Keybit link: a two-wire protocol on a side's SDA/SCL pair,
+ * used only between two Keybits (never on the keyword's I2C bus).
+ *
+ * The lines keep their I2C names here as DT (SDA) and CK (SCL). Both stay
+ * open-drain on the 10k pull-ups, so a clash or a wrong rotation can't
+ * fight a push-pull driver.
+ *
+ * Request The parent pulls CK low with DT high.
+ * Doorbell A child with events pulls DT low with CK high, so its parent
+ * polls it now instead of at the next periodic poll.
+ * Ack The child pulls DT low while CK is low (if it was ringing the
+ * doorbell, it lets DT go high first so the edge is visible).
+ * The parent then releases CK, the child releases DT, and both
+ * lines high again marks the start of the frame.
+ * Bits The parent clocks every bit. Each half period is
+ * LINK_HALF_US. The parent's bits are sampled on CK rising;
+ * the child sets its bits on CK falling and the parent reads
+ * them just before CK falls again. MSB first.
+ * Frame parent -> child: 0xA5, parent depth
+ * child -> parent: child depth, n (<= 8), n events of 5
+ * bytes, CRC-8 of all of those
+ * parent -> child: kept, ~kept
+ * The child drops the first `kept` events from its queue.
+ *
+ * A frame with one event is 13 bytes, about 60 us at LINK_HALF_US 1 plus
+ * the handshake.
+ */
+#ifndef LINK_H
+#define LINK_H
+
+#include <stdint.h>
+
+#define LINK_MAGIC 0xA5
+#define LINK_EVENTS 8
+#define LINK_EV_SIZE 5
+
+typedef struct {
+ uint8_t dt, ck; /* ch32fun pin numbers: the side's SDA and SCL */
+} link_pins_t;
+
+/* What the child side answers with, filled in by the caller. */
+typedef struct {
+ uint8_t depth;
+ uint8_t n;
+ uint8_t ev[LINK_EVENTS * LINK_EV_SIZE];
+} link_reply_t;
+
+/* Return 1 to abort a link request we're waiting on, e.g. because the
+ * keyword just started a transaction on another side and needs serving. */
+typedef int (*link_idle_fn)(void);
+
+/* Parent: run one frame. doorbell says the child was ringing (DT low
+ * before we started). On success fills *child and returns 1; *kept is the
+ * number of events we told the child we kept (the caller takes those). */
+int link_poll(const link_pins_t *p, int doorbell, uint8_t my_depth,
+ link_reply_t *child, uint8_t room, uint8_t *kept, link_idle_fn idle);
+
+/* Child: CK is low on this side and the caller decided it's a request.
+ * Answers with *reply. On success sets *parent_depth and *kept and
+ * returns 1. */
+int link_serve(const link_pins_t *p, int ringing, const link_reply_t *reply,
+ uint8_t *parent_depth, uint8_t *kept);
+
+#endif
diff --git a/firmware/keybit/main.c b/firmware/keybit/main.c
index c18a7df..6a2efce 100644
--- a/firmware/keybit/main.c
+++ b/firmware/keybit/main.c
@@ -20,20 +20,24 @@
* again.
*
* Relaying: only Keybits touching the keyword are on its bus. The rest sit
- * behind private two-Keybit links, so key state hops inward:
+ * behind private two-Keybit links, which don't use I2C but the protocol in
+ * link.h, so key state hops inward:
* - Every Keybit has a depth: 1 when the keyword talks to it directly,
* otherwise one more than the shallowest neighbour that polls it.
* Depth only comes from being polled, so when a Keybit is pulled out
* everything behind it goes quiet within FRESH_MS instead of looping.
- * - A Keybit with a depth polls each other side as I2C controller (at
- * LINK_ADDR) unless the neighbour there is no deeper than it is. Each
- * poll tells the child our depth, reads the child's depth, and takes
- * up to 8 queued events.
+ * - A Keybit with a depth polls each other side over the link unless the
+ * neighbour there is no deeper than it is: about every CHILD_POLL_MS,
+ * and at once when the child rings the doorbell because it has events.
+ * Each poll tells the child our depth, reads the child's depth, and
+ * takes up to 8 queued events.
* - Events are (UID low 32 bits, flags): key changes and a heartbeat
* about once a second. Each Keybit queues its own and forwards its
* children's, so they drain towards the keyword.
- * A side where we ever see an address that isn't LINK_ADDR is the
- * keyword's shared bus, and we never act as controller there.
+ * A side where we see an I2C address is the keyword's shared bus. We
+ * never start a link frame there, and only answer one on a side that
+ * isn't known to be either after the line has been held for LINK_REQ_US,
+ * which I2C never does.
*
* Registers (reads and writes auto-increment from the pointer):
* 0x00 0x4B ('K') magic
@@ -45,7 +49,6 @@
* 0x10-0x1B 96-bit UID, little endian
* 0x20-0x2B ASSIGN: UID to match (write only)
* 0x2C ASSIGN: new address, 0 = forget it. Writing this applies it.
- * 0x50 (write) depth of the Keybit polling us over a link
* 0x51 our depth, 0xFF if we can't reach the keyword yet
* 0x52 events ready to read, at most 8
* 0x53-0x7A up to 8 events, 5 bytes each: UID bits 0..31, then flags
@@ -56,18 +59,23 @@
*/
#include "ch32fun.h"
#include "soft_i2c.h"
+#include "link.h"
#include <string.h>
-#define FW_VERSION 3
+#define FW_VERSION 4
#define KEYBIT_DEFAULT_ADDR 0x30
-#define LINK_ADDR 0x31 /* Keybit-to-Keybit links; the keyword never assigns it */
+#define LINK_ADDR 0x31 /* reserved: the keyword never assigns it */
#define BTN_PIN PD6 /* MX switch to GND */
#define DEBOUNCE 200 /* main loop passes */
#define DEPTH_NONE 0xFF
#define FRESH_MS 600 /* a neighbour's depth counts this long */
-#define POLL_MS 5 /* child poll interval per side */
+#define CHILD_POLL_MS 100 /* keeps a child's depth fresh; events come by doorbell */
+#define PROBE_MS 100 /* look for a new neighbour on an empty side */
#define PEER_RECHECK_MS 2000
+#define LINK_FRESH_MS 1000 /* a side counts as a link this long after a frame */
+#define KEYWORD_FRESH_MS 2000 /* the keyword scans every 250 ms */
+#define LINK_REQ_US 50 /* CK held low this long on an unknown side = link request */
#define HEARTBEAT_MS 1000
#define QUEUE_LEN 32
#define BATCH 8
@@ -100,8 +108,14 @@ typedef struct {
/* Learned when we poll the neighbour. */
uint8_t child_depth; /* DEPTH_NONE if unknown */
uint32_t child_seen;
- uint8_t keyword; /* this side is the keyword's shared bus */
- uint32_t next_poll; /* tick of our next controller poll here */
+ uint8_t keyword; /* the keyword's shared bus, seen at keyword_seen */
+ uint32_t keyword_seen;
+ uint8_t link; /* a link frame ran here at link_seen */
+ uint32_t link_seen;
+ uint8_t ck_low; /* CK low on an unknown side since ck_low_at */
+ uint32_t ck_low_at;
+ uint8_t ringing; /* we're holding DT low as a doorbell */
+ uint32_t next_poll; /* tick of our next link poll here */
} side_t;
static soft_i2c_bus_t buses[4] = {
@@ -131,6 +145,22 @@ static inline int elapsed(uint32_t since, uint32_t span) { return ticks() - sinc
static int side_index(soft_i2c_bus_t *bus) { return (int)(bus - buses); }
+static int is_keyword(int s)
+{
+ side_t *sd = &sides[s];
+ if (sd->keyword && elapsed(sd->keyword_seen, MS(KEYWORD_FRESH_MS))) sd->keyword = 0;
+ return sd->keyword;
+}
+
+static int is_link(int s)
+{
+ side_t *sd = &sides[s];
+ if (sd->link && elapsed(sd->link_seen, MS(LINK_FRESH_MS))) sd->link = 0;
+ return sd->link;
+}
+
+static link_pins_t pins(int s) { return (link_pins_t){ .dt = buses[s].sda, .ck = buses[s].scl }; }
+
/* ------------------------------------------------------------------------ */
/* Event queue */
@@ -221,10 +251,10 @@ static void polled_by(int s, uint8_t depth)
static int match_addr(uint8_t addr, soft_i2c_bus_t *bus)
{
int s = side_index(bus);
- if (addr == LINK_ADDR) return !sides[s].keyword;
-
- /* Anything else only happens on the keyword's bus. */
+ /* I2C only happens on the keyword's bus. */
sides[s].keyword = 1;
+ sides[s].keyword_seen = ticks();
+ sides[s].link = 0;
int mine = my_addr ? addr == my_addr : addr == KEYBIT_DEFAULT_ADDR;
if (mine) polled_by(s, 0);
return mine;
@@ -254,7 +284,6 @@ static uint8_t read_reg(uint8_t reg, soft_i2c_bus_t *bus)
static void write_reg(uint8_t reg, uint8_t value, soft_i2c_bus_t *bus)
{
- if (reg == 0x50) { polled_by(side_index(bus), value); return; }
if (reg == 0x7B) { queue_pop(value); return; }
if (reg < 0x20 || reg > 0x2C) return;
assign_buf[reg - 0x20] = value;
@@ -299,73 +328,148 @@ static void update_depth(void)
my_depth = best == DEPTH_NONE || best >= 0xFE ? DEPTH_NONE : (uint8_t)(best + 1);
}
-/* Poll the Keybit on side s: tell it our depth, read its depth and up to
- * BATCH of its events, then tell it how many we kept. */
-static void poll_child(int s)
+static void fill_reply(link_reply_t *r)
{
- soft_i2c_bus_t *b = &buses[s];
- uint8_t depth = 0, count = 0;
- event_t got[BATCH];
- int n = 0, ok = 0;
-
- if (!soft_i2c_start(b)) return;
- if (soft_i2c_write(b, LINK_ADDR << 1) == 1 && soft_i2c_write(b, 0x50) == 1 &&
- soft_i2c_write(b, my_depth) == 1 && soft_i2c_restart(b) &&
- soft_i2c_write(b, (LINK_ADDR << 1) | 1) == 1 &&
- soft_i2c_read(b, &depth, 1) && soft_i2c_read(b, &count, 1)) {
- int room = QUEUE_LEN - q_count;
- if (count > BATCH) count = BATCH;
- n = count < room ? count : room;
- ok = 1;
- for (int i = 0; i < n && ok; i++)
- for (int j = 0; j < 5 && ok; j++) {
- uint8_t v;
- ok = soft_i2c_read(b, &v, !(i == n - 1 && j == 4));
- if (j < 4) got[i].uid[j] = v; else got[i].flags = v;
- }
- if (n == 0) { uint8_t dummy; ok = soft_i2c_read(b, &dummy, 0); }
+ r->depth = my_depth;
+ r->n = q_count < BATCH ? q_count : BATCH;
+ for (int i = 0; i < r->n; i++) {
+ const event_t *e = queue_at(i);
+ memcpy(&r->ev[i * LINK_EV_SIZE], e->uid, 4);
+ r->ev[i * LINK_EV_SIZE + 4] = e->flags;
}
- soft_i2c_stop(b);
+}
+
+/* Keep serving I2C on the other sides while a link request waits for its
+ * ack. Returns 1 (give up on the request) if we served something, so the
+ * keyword never waits on us for long. */
+static int link_side = -1;
+static int serve_others(void)
+{
+ for (int s = 0; s < 4; s++) {
+ if (s == link_side || is_link(s)) continue;
+ if (soft_i2c_poll(&buses[s], &target)) return 1;
+ }
+ return 0;
+}
+
+static void reset_i2c_edge(int s)
+{
+ buses[s].prev_sda = funDigitalRead(buses[s].sda);
+ buses[s].prev_scl = funDigitalRead(buses[s].scl);
+}
+
+/* Parent side: run a link frame with the Keybit on side s. */
+static void poll_child(int s, int doorbell)
+{
+ link_pins_t p = pins(s);
+ link_reply_t got;
+ uint8_t kept = 0;
+
+ link_side = s;
+ int ok = link_poll(&p, doorbell, my_depth, &got, (uint8_t)(QUEUE_LEN - q_count), &kept, serve_others);
+ link_side = -1;
+ reset_i2c_edge(s);
if (!ok) return;
- sides[s].child_depth = depth;
- sides[s].child_seen = ticks();
- if (n == 0) return;
- for (int i = 0; i < n; i++) queue_push(&got[i]);
+ side_t *sd = &sides[s];
+ sd->link = 1;
+ sd->link_seen = ticks();
+ sd->child_depth = got.depth;
+ sd->child_seen = ticks();
+ for (int i = 0; i < kept; i++) {
+ event_t e;
+ memcpy(e.uid, &got.ev[i * LINK_EV_SIZE], 4);
+ e.flags = got.ev[i * LINK_EV_SIZE + 4];
+ queue_push(&e);
+ }
+}
- if (soft_i2c_start(b)) {
- if (soft_i2c_write(b, LINK_ADDR << 1) == 1 && soft_i2c_write(b, 0x7B) == 1)
- soft_i2c_write(b, (uint8_t)n);
- soft_i2c_stop(b);
+/* Child side: CK is low on side s. Answer if it's a link request. */
+static void answer_link(int s, int listening)
+{
+ side_t *sd = &sides[s];
+ if (funDigitalRead(buses[s].scl)) { sd->ck_low = 0; return; }
+ if (is_keyword(s)) return;
+
+ if (!is_link(s)) {
+ /* An unknown side might be the keyword's bus mid-transfer, where SCL
+ * is never held low this long with SDA high. */
+ if (listening || !funDigitalRead(buses[s].sda)) { sd->ck_low = 0; return; }
+ if (!sd->ck_low) { sd->ck_low = 1; sd->ck_low_at = ticks(); return; }
+ if (!elapsed(sd->ck_low_at, LINK_REQ_US * DELAY_US_TIME)) return;
}
+ sd->ck_low = 0;
+
+ link_pins_t p = pins(s);
+ link_reply_t r;
+ uint8_t depth, kept;
+ fill_reply(&r);
+ int ok = link_serve(&p, sd->ringing, &r, &depth, &kept);
+ sd->ringing = 0;
+ reset_i2c_edge(s);
+ if (!ok) return;
+
+ sd->link = 1;
+ sd->link_seen = ticks();
+ polled_by(s, depth);
+ queue_pop(kept);
}
-static void relay(void)
+/* With events queued, hold DT low towards our parent so it polls us now.
+ * Only on a link side, never the keyword's bus: the keyword polls often
+ * anyway, and SDA low there would look like an I2C START. */
+static void doorbell(void)
{
- static uint32_t boot;
- static uint8_t started;
- if (!started) { boot = ticks(); started = 1; }
- /* Listen first so the keyword's bus is recognised before we ever drive
- * a side as controller. */
- if (!elapsed(boot, MS(FRESH_MS))) return;
+ int want = -1;
+ if (q_count) {
+ uint8_t best = DEPTH_NONE;
+ for (int s = 0; s < 4; s++)
+ if (is_link(s) && !is_keyword(s) && sides[s].parent_depth < best) {
+ best = sides[s].parent_depth;
+ want = s;
+ }
+ }
+ for (int s = 0; s < 4; s++) {
+ side_t *sd = &sides[s];
+ if (s == want && !sd->ringing && funDigitalRead(buses[s].scl)) {
+ funDigitalWrite(buses[s].sda, FUN_LOW);
+ sd->ringing = 1;
+ } else if (s != want && sd->ringing) {
+ funDigitalWrite(buses[s].sda, FUN_HIGH);
+ sd->ringing = 0;
+ }
+ }
+}
+static uint8_t jitter(void) { return uid[0] & 7; }
+
+static void relay(int listening)
+{
+ if (listening) return;
update_depth();
if (my_depth == DEPTH_NONE) return;
for (int s = 0; s < 4; s++) {
side_t *sd = &sides[s];
- if (sd->keyword) continue;
+ if (is_keyword(s)) continue;
if (sd->parent_depth != DEPTH_NONE) continue; /* it polls us */
- /* A peer at the same depth or shallower isn't our child; look again
- * now and then in case that changed. */
- if (sd->child_depth != DEPTH_NONE && sd->child_depth <= my_depth &&
- !elapsed(sd->child_seen, MS(PEER_RECHECK_MS))) continue;
- if ((int32_t)(ticks() - sd->next_poll) < 0) continue;
- /* A little UID-based jitter so two Keybits don't keep polling each
- * other in lockstep. */
- sd->next_poll = ticks() + MS(POLL_MS) + (uid[0] & 3) * DELAY_MS_TIME / 2;
- poll_child(s);
- buses[s].prev_sda = buses[s].prev_scl = 1;
+ if (sd->ringing) continue;
+
+ int child = sd->child_depth != DEPTH_NONE && sd->child_depth > my_depth &&
+ !elapsed(sd->child_seen, MS(FRESH_MS));
+ /* A ringing child holds DT low with CK high. */
+ int rang = child && is_link(s) && !funDigitalRead(buses[s].sda) && funDigitalRead(buses[s].scl);
+ if (!rang) {
+ /* A peer at the same depth or shallower isn't our child; look again
+ * now and then in case that changed. */
+ if (sd->child_depth != DEPTH_NONE && sd->child_depth <= my_depth &&
+ !elapsed(sd->child_seen, MS(PEER_RECHECK_MS))) continue;
+ if ((int32_t)(ticks() - sd->next_poll) < 0) continue;
+ }
+ /* Some UID-based jitter so two Keybits don't keep asking each other
+ * in lockstep. */
+ sd->next_poll = ticks() + MS((child ? CHILD_POLL_MS : PROBE_MS) + jitter());
+ poll_child(s, rang);
}
}
@@ -407,10 +511,19 @@ int main(void)
for (int i = 0; i < 4; i++) soft_i2c_init(&buses[i]);
+ uint32_t boot = ticks();
+ int listening = 1;
for (;;) {
- for (int i = 0; i < 4; i++) soft_i2c_poll(&buses[i], &target);
+ /* Listen first so the keyword's bus is recognised before we ever
+ * drive a side. */
+ if (listening && elapsed(boot, MS(FRESH_MS))) listening = 0;
+ for (int i = 0; i < 4; i++) {
+ if (!is_link(i)) soft_i2c_poll(&buses[i], &target);
+ answer_link(i, listening);
+ }
debounce_key();
- relay();
+ relay(listening);
+ doorbell();
heartbeat();
if (save_addr >= 0) {
store_config((uint8_t)save_addr);
diff --git a/firmware/keybit/soft_i2c.c b/firmware/keybit/soft_i2c.c
index 3c10086..f3bcdb2 100644
--- a/firmware/keybit/soft_i2c.c
+++ b/firmware/keybit/soft_i2c.c
@@ -148,106 +148,3 @@ int soft_i2c_poll(soft_i2c_bus_t *b, const soft_i2c_target_t *t)
b->prev_scl = SCL(b);
return 1;
}
-
-/* ------------------------------------------------------------------------ */
-/* Controller */
-
-/* Half a clock period. Keybit links run at about 100 kHz so the far side's
- * polling loop can keep up. */
-#define HALF_US 5
-/* Hold START this long so a target busy elsewhere still sees it. */
-#define START_US 20
-
-static void release_bus(soft_i2c_bus_t *b)
-{
- SDA_REL(b);
- SCL_REL(b);
-}
-
-/* Let SCL go and wait for it, honouring clock stretching. */
-static int scl_high(soft_i2c_bus_t *b)
-{
- SCL_REL(b);
- return wait_scl(b, 1);
-}
-
-int soft_i2c_start(soft_i2c_bus_t *b)
-{
- if (!SDA(b) || !SCL(b)) return 0;
- Delay_Us(HALF_US);
- if (!SDA(b) || !SCL(b)) return 0; /* someone else started */
- SDA_LOW(b);
- Delay_Us(START_US);
- SCL_LOW(b);
- Delay_Us(HALF_US);
- return 1;
-}
-
-int soft_i2c_restart(soft_i2c_bus_t *b)
-{
- SDA_REL(b);
- Delay_Us(HALF_US);
- if (!scl_high(b)) { release_bus(b); return 0; }
- Delay_Us(HALF_US);
- SDA_LOW(b);
- Delay_Us(HALF_US);
- SCL_LOW(b);
- Delay_Us(HALF_US);
- return 1;
-}
-
-void soft_i2c_stop(soft_i2c_bus_t *b)
-{
- SDA_LOW(b);
- Delay_Us(HALF_US);
- scl_high(b);
- Delay_Us(HALF_US);
- SDA_REL(b);
- Delay_Us(HALF_US);
-}
-
-/* One bit out with SCL low on entry and exit. */
-static int put_bit(soft_i2c_bus_t *b, int one)
-{
- if (one) SDA_REL(b); else SDA_LOW(b);
- Delay_Us(HALF_US);
- if (!scl_high(b)) { release_bus(b); return 0; }
- if (one && !SDA(b)) { release_bus(b); return -1; } /* lost arbitration */
- Delay_Us(HALF_US);
- SCL_LOW(b);
- return 1;
-}
-
-static int get_bit(soft_i2c_bus_t *b, int *bit)
-{
- SDA_REL(b);
- Delay_Us(HALF_US);
- if (!scl_high(b)) { release_bus(b); return 0; }
- *bit = SDA(b);
- Delay_Us(HALF_US);
- SCL_LOW(b);
- return 1;
-}
-
-int soft_i2c_write(soft_i2c_bus_t *b, uint8_t v)
-{
- for (int i = 7; i >= 0; i--) {
- int r = put_bit(b, (v >> i) & 1);
- if (r != 1) return r;
- }
- int nack;
- if (!get_bit(b, &nack)) return 0;
- return !nack;
-}
-
-int soft_i2c_read(soft_i2c_bus_t *b, uint8_t *v, int ack)
-{
- uint8_t x = 0;
- for (int i = 0; i < 8; i++) {
- int bit;
- if (!get_bit(b, &bit)) return 0;
- x = (uint8_t)((x << 1) | bit);
- }
- *v = x;
- return put_bit(b, !ack) == 1;
-}
diff --git a/firmware/keybit/soft_i2c.h b/firmware/keybit/soft_i2c.h
index b8b5ce9..f536908 100644
--- a/firmware/keybit/soft_i2c.h
+++ b/firmware/keybit/soft_i2c.h
@@ -43,15 +43,4 @@ void soft_i2c_init(soft_i2c_bus_t *bus);
* writes auto-increment it. */
int soft_i2c_poll(soft_i2c_bus_t *bus, const soft_i2c_target_t *t);
-/* Controller side, for polling the Keybit on the far side of a link.
- * Every call returns 1 on success / ACK, 0 on NACK or timeout, and -1 if
- * another controller won arbitration (then the bus is already released).
- * Start fails (0) if the bus isn't idle. */
-int soft_i2c_start(soft_i2c_bus_t *bus);
-int soft_i2c_restart(soft_i2c_bus_t *bus);
-void soft_i2c_stop(soft_i2c_bus_t *bus);
-int soft_i2c_write(soft_i2c_bus_t *bus, uint8_t v);
-/* Reads one byte; ack = 1 to ask for more, 0 on the last byte. */
-int soft_i2c_read(soft_i2c_bus_t *bus, uint8_t *v, int ack);
-
#endif