diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/88MZ100_7.4_BETA-0.4.bin b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/88MZ100_7.4_BETA-0.4.bin
new file mode 100755
index 00000000..458083f1
Binary files /dev/null and b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/88MZ100_7.4_BETA-0.4.bin differ
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/88MZ100_7.4_BETA-0.4_ota.bin b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/88MZ100_7.4_BETA-0.4_ota.bin
new file mode 100755
index 00000000..f0478194
Binary files /dev/null and b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/88MZ100_7.4_BETA-0.4_ota.bin differ
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/Makefile b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/Makefile
index af8a6532..b96f748c 100644
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/Makefile
+++ b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/Makefile
@@ -49,8 +49,8 @@ compile:
 	@$(CC) $(CC_FlAGS) -c mz100_aon_ram.c       -o build/mz100_aon_ram.o
 	@$(CC) $(CC_FlAGS) -c printf.c		-o build/printf.o
 	@$(CC) $(CC_FlAGS) $(CC_WARNING_FLAGS) -c zigbee.c        -o build/zigbee.o
-	@$(CC) $(CC_FlAGS) $(CC_WARNING_FLAGS) -c ccm.c        -o build/ccm.o
-	@$(CC) $(CC_FlAGS) $(CC_WARNING_FLAGS) -c chars.c        -o build/chars.o
+#	@$(CC) $(CC_FlAGS) $(CC_WARNING_FLAGS) -c ccm.c        -o build/ccm.o
+#	@$(CC) $(CC_FlAGS) $(CC_WARNING_FLAGS) -c chars.c        -o build/chars.o
 	@$(CC) $(CC_FlAGS) $(CC_WARNING_FLAGS) -c drawing.c        -o build/drawing.o
 	@$(CC) $(CC_FlAGS) $(CC_WARNING_FLAGS) -c powermgt.c        -o build/powermgt.o
 	@$(CC) $(CC_FlAGS) $(CC_WARNING_FLAGS) -c syncedproto.c        -o build/syncedproto.o
@@ -62,7 +62,7 @@ compile:
 	@$(CC) $(CC_FlAGS) $(CC_WARNING_FLAGS) -c epd.c        -o build/epd.o
 	@$(CC) $(CC_FlAGS) $(CC_WARNING_FLAGS) -c userinterface.c	-o build/userinterface.o
 	@$(CC) $(CC_FlAGS) $(CC_WARNING_FLAGS) -c main.c             -o build/main.o
-	@$(CC) $(CC_END_FLAGS) $(CC_WARNING_FLAGS) build/main.o build/userinterface.o build/printf.o build/mz100_aon_ram.o build/zigbee.o build/chars.o build/drawing.o build/powermgt.o build/syncedproto.o build/comms.o build/settings.o build/timer.o build/util.o build/gpio.o build/epd.o build/mz100_sleep.o build/core_cm3.o build/mz100_ssp.o build/mz100_wdt.o build/mz100_gpio.o build/mz100_driver.o build/mz100_adc.o build/mz100_flash.o build/mz100_clock.o build/mz100_rtc.o build/mz100_pinmux.o build/mz100_pmu.o build/mz100_qspi.o build/mz100_aes.o build/mz100_gpt.o build/mz100_uart.o build/startup.o -o main.axf
+	@$(CC) $(CC_END_FLAGS) $(CC_WARNING_FLAGS) build/main.o build/userinterface.o build/printf.o build/mz100_aon_ram.o build/zigbee.o build/drawing.o build/powermgt.o build/syncedproto.o build/comms.o build/settings.o build/timer.o build/util.o build/gpio.o build/epd.o build/mz100_sleep.o build/core_cm3.o build/mz100_ssp.o build/mz100_wdt.o build/mz100_gpio.o build/mz100_driver.o build/mz100_adc.o build/mz100_flash.o build/mz100_clock.o build/mz100_rtc.o build/mz100_pinmux.o build/mz100_pmu.o build/mz100_qspi.o build/mz100_aes.o build/mz100_gpt.o build/mz100_uart.o build/startup.o -o main.axf
 	@$(OBJCOPY) -v -O binary main.axf main.bin
 	
 clean:
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/bitmaps.h b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/bitmaps.h
old mode 100644
new mode 100755
index 645b82bc..618e0acb
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/bitmaps.h
+++ b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/bitmaps.h
@@ -6,293 +6,102 @@
 
 #include "screen.h"
 
-static const uint8_t  oepli[] = {
-  128, 26,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
-  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, 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, 
-  0x1c, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x9f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x38, 0x70, 0x01, 0xc0, 
-  0x7f, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x9f, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x38, 0x70, 0x01, 0xc0, 
-  0x7f, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x9f, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x38, 0x70, 0x01, 0xc0, 
-  0xf7, 0x80, 0x00, 0x00, 0x00, 0x1c, 0x1c, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x01, 0xc0, 
-  0xe3, 0x80, 0x00, 0x00, 0x00, 0x1c, 0x1c, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x01, 0xc0, 
-  0xe3, 0x9d, 0xc1, 0xc7, 0x70, 0x1f, 0x9c, 0xe7, 0x73, 0xb8, 0x71, 0xd0, 0x38, 0x73, 0xb9, 0xc7, 
-  0xe3, 0x9f, 0xe3, 0xe7, 0xf8, 0x1f, 0x9f, 0xef, 0xf3, 0xfc, 0xf9, 0xf0, 0x38, 0x73, 0xfd, 0xce, 
-  0xe3, 0x9f, 0xe7, 0x77, 0xf8, 0x1f, 0x9f, 0xcf, 0xf3, 0xfd, 0xdd, 0xf0, 0x38, 0x73, 0xfd, 0xdc, 
-  0xe3, 0x9c, 0xe7, 0xf7, 0x38, 0x1c, 0x1f, 0x8e, 0x73, 0x9d, 0xfd, 0xc0, 0x38, 0x73, 0x9d, 0xf8, 
-  0xe3, 0x9c, 0xe7, 0xf7, 0x38, 0x1c, 0x1c, 0x0e, 0x73, 0x9d, 0xfd, 0xc0, 0x38, 0x73, 0x9d, 0xf8, 
-  0xf7, 0x9c, 0xe7, 0x07, 0x38, 0x1c, 0x1c, 0x0e, 0x73, 0x9d, 0xc1, 0xc0, 0x38, 0x73, 0x9d, 0xdc, 
-  0x7f, 0x1f, 0xe7, 0xf7, 0x38, 0x1f, 0x9c, 0x0f, 0xf3, 0xfd, 0xfd, 0xc0, 0x3f, 0x73, 0x9d, 0xdc, 
-  0x7f, 0x1f, 0xe3, 0xe7, 0x38, 0x1f, 0x9c, 0x0f, 0xf3, 0xfc, 0xf9, 0xc0, 0x3f, 0x73, 0x9d, 0xce, 
-  0x1e, 0x1d, 0xc1, 0xc7, 0x38, 0x1f, 0x9c, 0x07, 0x73, 0xb8, 0x71, 0xc0, 0x3f, 0x73, 0x9d, 0xc7, 
-  0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 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, 0x00, 0x00, 0x00, 0x00, 
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+const uint8_t norf[] = {
+    24,
+    24,
+    0x00,
+    0x00,
+    0x00,
+    0x70,
+    0xe0,
+    0x00,
+    0x79,
+    0xe0,
+    0x00,
+    0x7f,
+    0xe0,
+    0x00,
+    0x3f,
+    0xc0,
+    0x00,
+    0x1f,
+    0x80,
+    0x00,
+    0x1f,
+    0x80,
+    0x00,
+    0x3f,
+    0xc0,
+    0x00,
+    0x7f,
+    0xe0,
+    0x0e,
+    0x79,
+    0xe0,
+    0x0a,
+    0x70,
+    0xe0,
+    0x0a,
+    0x00,
+    0x00,
+    0xea,
+    0x00,
+    0x00,
+    0xaa,
+    0x00,
+    0x00,
+    0xaa,
+    0x00,
+    0x0e,
+    0xaa,
+    0x00,
+    0x0a,
+    0xaa,
+    0x00,
+    0x0a,
+    0xaa,
+    0x00,
+    0xea,
+    0xaa,
+    0x00,
+    0xaa,
+    0xaa,
+    0x00,
+    0xaa,
+    0xaa,
+    0x0e,
+    0xaa,
+    0xaa,
+    0x0a,
+    0xaa,
+    0xaa,
+    0x0e,
+    0xee,
+    0xee,
+    0x00,
+    0x00,
+    0x00,
 };
 
-static const uint8_t  cloud[] = {
-  128, 50, 
-  0x00, 0x08, 0x82, 0xa2, 0xab, 0x55, 0xbf, 0xff, 0xff, 0xff, 0x7d, 0xb4, 0x62, 0x28, 0x00, 0x00, 
-  0x00, 0x10, 0x10, 0x11, 0x76, 0xff, 0x7b, 0xff, 0xff, 0x7f, 0xb7, 0xa9, 0x55, 0x50, 0x51, 0x00, 
-  0x00, 0x29, 0x22, 0x96, 0x6f, 0xf7, 0xbf, 0xff, 0xff, 0xff, 0xea, 0xe6, 0x22, 0xaa, 0x08, 0x00, 
-  0x00, 0x02, 0x54, 0x2a, 0xbf, 0x3f, 0x7f, 0xff, 0xff, 0xff, 0xfd, 0x59, 0xb4, 0x10, 0x20, 0x00, 
-  0x00, 0x24, 0x23, 0xb5, 0xb5, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xf6, 0xae, 0x48, 0x55, 0x10, 0x00, 
-  0x00, 0x88, 0x90, 0x54, 0x6a, 0xef, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xf5, 0xa3, 0x82, 0x00, 0x00, 
-  0x00, 0x01, 0x2d, 0xa3, 0xb3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0xbe, 0x4e, 0x52, 0x09, 0x00, 
-  0x04, 0x90, 0x02, 0x0d, 0x55, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xdd, 0x68, 0xa9, 0x00, 0x10, 
-  0x00, 0x49, 0x0c, 0xfb, 0xab, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xeb, 0x95, 0x5a, 0x00, 0x20, 
-  0x00, 0x12, 0x91, 0x22, 0xbf, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x65, 0x81, 0x40, 0x40, 
-  0x00, 0x28, 0x12, 0x7d, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xab, 0x28, 0x00, 0x00, 
-  0x00, 0x42, 0x0a, 0x97, 0x75, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x4a, 0xc2, 0x04, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x08, 0x02, 0x9c, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x6a, 0x8d, 0x00, 0x20, 
-  0x00, 0x04, 0x4d, 0x72, 0xaa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, 0xd5, 0x74, 0x80, 0x00, 
-  0x02, 0x40, 0x12, 0x8e, 0xdf, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xae, 0xaa, 0x0a, 0x11, 0x20, 
-  0x00, 0x20, 0x52, 0x5f, 0xf5, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x72, 0x94, 0xaa, 0x24, 0x00, 
-  0x00, 0x01, 0x0a, 0xab, 0x6f, 0x77, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xaf, 0x54, 0x54, 0x88, 0x00, 
-  0x00, 0x04, 0x80, 0x4d, 0x95, 0xeb, 0xff, 0xff, 0xff, 0xff, 0x5b, 0x58, 0xb5, 0x51, 0x40, 0x00, 
-  0x00, 0x08, 0x08, 0xa6, 0xb3, 0xf7, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xad, 0x4a, 0xa0, 0x10, 0x00, 
-  0x00, 0x02, 0x96, 0x41, 0xdc, 0xae, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xbf, 0xea, 0x48, 0x02, 0x00, 
-  0x00, 0x00, 0x09, 0x3e, 0xab, 0x75, 0xef, 0xff, 0xff, 0xff, 0xff, 0xd4, 0xb1, 0x21, 0x08, 0x00, 
-  0x00, 0x00, 0x0a, 0xc3, 0x5d, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xef, 0xef, 0x44, 0x4a, 0x64, 0x80, 
-  0x00, 0x00, 0xa1, 0x52, 0xa6, 0xef, 0xef, 0xff, 0xff, 0xff, 0xd6, 0xca, 0xf5, 0x10, 0x18, 0x00, 
-  0x00, 0x00, 0x02, 0x15, 0x4b, 0xd5, 0xdf, 0xff, 0xff, 0xf7, 0xeb, 0xd4, 0xd8, 0x85, 0x00, 0x00, 
+static const uint8_t batlow[] = {
+  24,17,
+  0x00, 0x00, 0x00, 
+  0x7f, 0xff, 0xf8, 
+  0x40, 0x00, 0x08, 
+  0x40, 0x00, 0x08, 
+  0x40, 0x00, 0x0e, 
+  0x40, 0x00, 0x0a, 
+  0x48, 0x00, 0x0a, 
+  0x48, 0x00, 0x0a, 
+  0x48, 0x64, 0x4a, 
+  0x48, 0x94, 0x4a, 
+  0x48, 0x95, 0x4a, 
+  0x4e, 0x62, 0x8a, 
+  0x40, 0x00, 0x0e, 
+  0x40, 0x00, 0x08, 
+  0x40, 0x00, 0x08, 
+  0x7f, 0xff, 0xf8, 
+  0x00, 0x00, 0x00, 
 };
 
-static const uint8_t  receive[] = {
-  56, 56, 
-  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, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xc0, 
-  0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xf0, 
-  0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xf0, 
-  0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xf0, 
-  0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xf0, 
-  0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xc0, 
-  0x00, 0x00, 0x00, 0x1f, 0xff, 0x80, 0x00, 
-  0x00, 0x00, 0x00, 0x7f, 0xf8, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0xff, 0xe0, 0x00, 0x00, 
-  0x00, 0x00, 0x01, 0xff, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x07, 0xfe, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x0f, 0xf8, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x1f, 0xe0, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x3f, 0xc0, 0x00, 0x03, 0xe0, 
-  0x00, 0x00, 0x7f, 0x80, 0x00, 0x7f, 0xf0, 
-  0x00, 0x00, 0xfe, 0x00, 0x03, 0xff, 0xf0, 
-  0x00, 0x01, 0xfc, 0x00, 0x0f, 0xff, 0xf0, 
-  0x00, 0x01, 0xf8, 0x00, 0x3f, 0xff, 0xf0, 
-  0x00, 0x03, 0xf8, 0x00, 0xff, 0xff, 0x80, 
-  0x00, 0x07, 0xf0, 0x01, 0xff, 0xe0, 0x00, 
-  0x00, 0x0f, 0xe0, 0x03, 0xff, 0x00, 0x00, 
-  0x00, 0x0f, 0xc0, 0x0f, 0xf8, 0x00, 0x00, 
-  0x00, 0x1f, 0x80, 0x1f, 0xf0, 0x00, 0x00, 
-  0x00, 0x1f, 0x80, 0x3f, 0xc0, 0x00, 0x00, 
-  0x00, 0x3f, 0x00, 0x3f, 0x80, 0x00, 0x00, 
-  0x00, 0x3f, 0x00, 0x7f, 0x00, 0x00, 0x00, 
-  0x00, 0x7e, 0x00, 0xfe, 0x00, 0x07, 0xe0, 
-  0x00, 0x7e, 0x01, 0xfc, 0x00, 0x1f, 0xf0, 
-  0x00, 0xfc, 0x01, 0xf8, 0x00, 0x7f, 0xf0, 
-  0x00, 0xfc, 0x03, 0xf0, 0x01, 0xff, 0xf0, 
-  0x00, 0xf8, 0x03, 0xf0, 0x03, 0xff, 0xf0, 
-  0x01, 0xf8, 0x07, 0xe0, 0x07, 0xff, 0x00, 
-  0x01, 0xf8, 0x07, 0xe0, 0x0f, 0xf0, 0x00, 
-  0x01, 0xf0, 0x0f, 0xc0, 0x1f, 0xe0, 0x00, 
-  0x01, 0xf0, 0x0f, 0xc0, 0x3f, 0x80, 0x00, 
-  0x03, 0xf0, 0x0f, 0x80, 0x3f, 0x00, 0x00, 
-  0x03, 0xf0, 0x1f, 0x80, 0x7e, 0x00, 0x00, 
-  0x03, 0xe0, 0x1f, 0x80, 0x7e, 0x00, 0x00, 
-  0x03, 0xe0, 0x1f, 0x00, 0xfc, 0x01, 0xe0, 
-  0x03, 0xe0, 0x1f, 0x00, 0xfc, 0x07, 0xf8, 
-  0x03, 0xe0, 0x1f, 0x00, 0xf8, 0x0f, 0xfc, 
-  0x03, 0xe0, 0x3f, 0x00, 0xf8, 0x0f, 0xfc, 
-  0x03, 0xe0, 0x3f, 0x01, 0xf8, 0x1f, 0xfe, 
-  0x03, 0xe0, 0x3f, 0x01, 0xf8, 0x1f, 0xfe, 
-  0x03, 0xe0, 0x3f, 0x01, 0xf8, 0x1f, 0xfe, 
-  0x03, 0xc0, 0x3e, 0x01, 0xf0, 0x1f, 0xfe, 
-  0x01, 0xc0, 0x1e, 0x00, 0xf0, 0x0f, 0xfc, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xfc, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xf8, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xe0, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-};
-
-
-static const uint8_t  failed[] = {
-  48, 48,
-  0x00, 0x00, 0x1f, 0xf8, 0x00, 0x00, 
-  0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 
-  0x00, 0x03, 0xff, 0xff, 0xe0, 0x00, 
-  0x00, 0x0f, 0xff, 0xff, 0xf0, 0x00, 
-  0x00, 0x3f, 0xff, 0xff, 0xfc, 0x00, 
-  0x00, 0x7f, 0xf0, 0x0f, 0xfe, 0x00, 
-  0x00, 0xff, 0x80, 0x01, 0xff, 0x00, 
-  0x01, 0xfe, 0x00, 0x00, 0x7f, 0x80, 
-  0x03, 0xf8, 0x00, 0x00, 0x1f, 0xc0, 
-  0x07, 0xf0, 0x00, 0x00, 0x3f, 0xe0, 
-  0x0f, 0xe0, 0x00, 0x00, 0x7f, 0xf0, 
-  0x0f, 0xc0, 0x00, 0x00, 0xff, 0xf0, 
-  0x1f, 0x80, 0x00, 0x01, 0xff, 0xf8, 
-  0x1f, 0x00, 0x00, 0x03, 0xff, 0xf8, 
-  0x3f, 0x00, 0x00, 0x07, 0xfe, 0xfc, 
-  0x3e, 0x00, 0x00, 0x0f, 0xfc, 0x7c, 
-  0x7e, 0x00, 0x00, 0x1f, 0xf8, 0x7e, 
-  0x7c, 0x00, 0x00, 0x3f, 0xf0, 0x3e, 
-  0x7c, 0x00, 0x00, 0x7f, 0xe0, 0x3e, 
-  0xfc, 0x00, 0x00, 0xff, 0xc0, 0x3f, 
-  0xf8, 0x00, 0x01, 0xff, 0x80, 0x1f, 
-  0xf8, 0x00, 0x03, 0xff, 0x00, 0x1f, 
-  0xf8, 0x00, 0x07, 0xfe, 0x00, 0x1f, 
-  0xf8, 0x00, 0x0f, 0xfc, 0x00, 0x1f, 
-  0xf8, 0x00, 0x1f, 0xf8, 0x00, 0x1f, 
-  0xf8, 0x00, 0x3f, 0xf0, 0x00, 0x1f, 
-  0xf8, 0x00, 0x7f, 0xe0, 0x00, 0x1f, 
-  0xf8, 0x00, 0xff, 0xc0, 0x00, 0x1f, 
-  0xfc, 0x01, 0xff, 0x80, 0x00, 0x3f, 
-  0x7c, 0x03, 0xff, 0x00, 0x00, 0x3e, 
-  0x7c, 0x07, 0xfe, 0x00, 0x00, 0x3e, 
-  0x7e, 0x0f, 0xfc, 0x00, 0x00, 0x7e, 
-  0x3e, 0x1f, 0xf8, 0x00, 0x00, 0x7c, 
-  0x3f, 0x3f, 0xf0, 0x00, 0x00, 0xfc, 
-  0x3f, 0x7f, 0xe0, 0x00, 0x00, 0xfc, 
-  0x1f, 0xff, 0xc0, 0x00, 0x01, 0xf8, 
-  0x0f, 0xff, 0x80, 0x00, 0x03, 0xf0, 
-  0x0f, 0xff, 0x00, 0x00, 0x07, 0xf0, 
-  0x07, 0xfe, 0x00, 0x00, 0x0f, 0xe0, 
-  0x03, 0xfc, 0x00, 0x00, 0x1f, 0xc0, 
-  0x01, 0xfe, 0x00, 0x00, 0x7f, 0x80, 
-  0x00, 0xff, 0x80, 0x01, 0xff, 0x00, 
-  0x00, 0x7f, 0xf0, 0x0f, 0xfe, 0x00, 
-  0x00, 0x3f, 0xff, 0xff, 0xfc, 0x00, 
-  0x00, 0x0f, 0xff, 0xff, 0xf0, 0x00, 
-  0x00, 0x03, 0xff, 0xff, 0xe0, 0x00, 
-  0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 
-  0x00, 0x00, 0x1f, 0xf8, 0x00, 0x00, 
-};
-
-#if (SCREEN_WIDTH != 128) 
-static const uint8_t  ant[] = {
-  16, 16,
-  0x00, 0x40, 
-  0x02, 0x20, 
-  0x01, 0x20, 
-  0x11, 0x20, 
-  0x11, 0x20, 
-  0x12, 0x20, 
-  0x28, 0x40, 
-  0x28, 0x00, 
-  0x28, 0x00, 
-  0x44, 0x00, 
-  0x44, 0x00, 
-  0x44, 0x00, 
-  0x44, 0x00, 
-  0x82, 0x00, 
-  0x82, 0x00, 
-  0xfe, 0x00, 
-};
-#else
-static const uint8_t  ant[] = {
-  // rotated 90 degrees
-  16,16,
-  0x00, 0x00, 
-  0x00, 0x00, 
-  0x00, 0x00, 
-  0x00, 0x00, 
-  0x00, 0x00, 
-  0x7c, 0x00, 
-  0x82, 0x00, 
-  0x00, 0x00, 
-  0x38, 0x00, 
-  0x44, 0x07, 
-  0x00, 0x79, 
-  0x03, 0x81, 
-  0x1c, 0x01, 
-  0x03, 0x81, 
-  0x00, 0x79, 
-  0x00, 0x07, 
-};
-#endif
-static const uint8_t  cross[] = {
-  8,8,
-  0x00, 
-  0x63, 
-  0x77, 
-  0x3e, 
-  0x1c, 
-  0x3e, 
-  0x77, 
-  0x63
-};
-
-#if (SCREEN_WIDTH != 128) 
-static const uint8_t  battery[] = {
-  16,10,
-  0x00, 0x00, 
-  0x7f, 0xfc, 
-  0x40, 0x04, 
-  0x58, 0x06, 
-  0x58, 0x06, 
-  0x58, 0x06, 
-  0x58, 0x06, 
-  0x40, 0x04, 
-  0x7f, 0xfc, 
-  0x00, 0x00, 
-};
-#else
-// this battery symbol is rotated 90'
-static const uint8_t  battery[] = {
-16,16,
-  0x00, 0x00, 
-  0x03, 0xc0, 
-  0x0f, 0xf0, 
-  0x08, 0x10, 
-  0x08, 0x10, 
-  0x08, 0x10, 
-  0x08, 0x10, 
-  0x08, 0x10, 
-  0x08, 0x10, 
-  0x08, 0x10, 
-  0x08, 0x10, 
-  0x0b, 0xd0, 
-  0x0b, 0xd0, 
-  0x08, 0x10, 
-  0x0f, 0xf0, 
-  0x00, 0x00, 
-};
-
-#endif
-
 #endif
\ No newline at end of file
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/ccm.c b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/ccm.c
deleted file mode 100644
index ea60ba09..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/ccm.c
+++ /dev/null
@@ -1,96 +0,0 @@
-#include <string.h>
-#include "mz100.h"
-#include "mz100_aes.h"
-#include "mz100_driver.h"
-#include "ccm.h"
-
-
-static bool aesCcmOp(void* dst, const void *src, uint16_t authSrcLen, uint16_t encSrcLen, const void *key, const void *nonce, bool dec)
-{
-	uint32_t tempB, nBytesNoMic = authSrcLen + encSrcLen, nBytesIn, nBytesOut;
-	const uint32_t *inD = (const uint32_t*)src;
-	uint32_t *outD = (uint32_t*)dst;
-	uint_fast8_t i;
-	bool success;
-	
-	if (dec) {
-		nBytesIn = nBytesNoMic + AES_CCM_MIC_SIZE;
-		nBytesOut = nBytesNoMic;
-	}
-	else {
-		nBytesIn = nBytesNoMic;
-		nBytesOut = nBytesNoMic + AES_CCM_MIC_SIZE;
-	}
-	
-	do{
-		AES->CTRL1.WORDVAL |= 2;
-	} while (!(AES->STATUS.WORDVAL & 2));
-	
-	AES->CTRL2.WORDVAL |= 1;
-	(void)AES->CTRL2.WORDVAL;
-	AES->CTRL2.WORDVAL &=~ 1;
-	AES->CTRL1.WORDVAL = 0x0005501e + (dec ? 0x8000 : 0);
-	AES->IMR.WORDVAL = 0xffffffff;
-	
-	for(i = 0; i < 4; i++)
-		AES->KEY[7 - i].WORDVAL = ((uint32_t*)key)[i];
-	
-	AES->MSTR_LEN.WORDVAL = encSrcLen;
-	AES->ASTR_LEN.WORDVAL = authSrcLen;
-	
-	for(i = 0; i < 3; i++)
-		AES->IV[i].WORDVAL = ((uint32_t*)nonce)[i];
-	AES->IV[3].WORDVAL = ((uint8_t*)nonce)[12] + 0x200;	//2 byte lengths
-	
-	AES->CTRL1.WORDVAL |= 1;
-	
-	while (nBytesIn || nBytesOut) {
-		
-		if (!(AES->STATUS.WORDVAL & 0x10) && nBytesIn) {
-			
-			if (nBytesIn >= 4) {
-				AES->STR_IN.WORDVAL = *inD++;
-				nBytesIn -= 4;
-			}
-			else {
-				memcpy(&tempB, inD, nBytesIn);
-				AES->STR_IN.WORDVAL = tempB;
-				nBytesIn = 0;
-			}
-		}
-		
-		if ((AES->STATUS.WORDVAL & 0x40) && nBytesOut) {
-			
-			if (nBytesOut >= 4) {
-				*outD++ = AES->STR_OUT.WORDVAL;
-				nBytesOut -= 4;
-			}
-			else {
-				tempB = AES->STR_OUT.WORDVAL;
-				memcpy(outD, &tempB, nBytesOut);
-				nBytesOut = 0;
-			}
-			
-		}
-	}
-	
-	success = !((AES->STATUS.WORDVAL >> 11) & 7);
-	
-	AES->CTRL1.WORDVAL = 0;
-	
-	return success;
-}
-
-void aesCcmEnc(void* dst, const void *src, uint16_t authSrcLen, uint16_t encSrcLen, const void *key, const void *nonce)
-{
-	aesCcmOp(dst, src, authSrcLen, encSrcLen, key, nonce, false);
-}
-
-bool aesCcmDec(void* dst, const void *src, uint16_t authSrcLen, uint16_t encSrcLen, const void *key, const void *nonce)
-{
-	return aesCcmOp(dst, src, authSrcLen, encSrcLen, key, nonce, true);
-}
-
-
-
-
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/ccm.h b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/ccm.h
deleted file mode 100644
index 61391740..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/ccm.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef _CCM_H_
-#define _CCM_H_
-
-//CCM defined for T = 4 (mic is 4 bytes), Q = 2 (max data len 65536), N = 13( nonse is 13 bytes), 128-bit AES (16 bytes of key)
-//no more than 0xff00 auth data bytes allowed
-
-#include <stdbool.h>
-#include <stdint.h>
-
-#define AES_CCM_MIC_SIZE		4
-#define AES_CCM_NONCE_SIZE		13
-
-//encrypted data follows auth data. both in and out. 4 bytes of MIC appended on the encrypt path, checke don the decrypt path
-
-void aesCcmEnc(void* dst, const void *src, uint16_t authSrcLen, uint16_t encSrcLen, const void *key, const void *nonce);
-bool aesCcmDec(void* dst, const void *src, uint16_t authSrcLen, uint16_t encSrcLen, const void *key, const void *nonce);
-
-
-
-#endif
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/chars.c b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/chars.c
deleted file mode 100644
index 9abc81a5..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/chars.c
+++ /dev/null
@@ -1,410 +0,0 @@
-#include "eeprom.h"
-#include "chars.h"
-#include "mz100_flash.h"
-#include "epd.h"
-
-#define NUM_CHARS 256
-
-#define CANVAS_FLIP_H 1
-#define CANVAS_MSB_FIRST 1
-
-const static uint8_t mCharsImgs[];
-
-extern uint8_t mScreenRow[];
-static void charsPrvDrawCharRow(uint8_t ch, int16_t x, uint8_t imgRow, uint8_t foreColor, uint8_t backColor, uint8_t mag)
-{
-	uint8_t c, mc, charRow = imgRow / mag, bitMask = (1 << 4) - 1;
-
-	for (c = 0; c < CHAR_WIDTH; c++)
-	{ // iterate over the char's columns for this row
-
-		uint8_t imgCol = ((uint8_t)((uint8_t)CHAR_WIDTH * (uint8_t)ch) & 7) + c;																								  // sort out where in the row our data begins
-		uint8_t color = ((mCharsImgs[(((CHAR_WIDTH * NUM_CHARS + 7) / 8 * charRow) + (CHAR_WIDTH * ch) / 8) + (imgCol >> 3)] >> (7 - (imgCol % 8))) & 1) ? foreColor : backColor; // get the color
-
-		if (color == CHAR_COLOR_TRANSPARENT)
-			continue;
-
-		for (mc = 0; mc < mag; mc++, x++)
-		{ // set the pixel
-
-			uint8_t *dst = mScreenRow;
-			uint8_t bitOfst;
-			uint16_t c = x;
-
-			if (x < 0)
-				continue;
-			if (x >= DISPLAY_WIDTH)
-				break;
-
-#if CANVAS_FLIP_H
-			c = DISPLAY_WIDTH - c - 1;
-#endif
-
-			dst += (c * 4) / 8;
-			bitOfst = (c * 4) % 8;
-
-#if CANVAS_MSB_FIRST
-			bitOfst = 8 - bitOfst - 4;
-#endif
-
-			*dst = ((*dst) & ~(bitMask << bitOfst)) | ((color & bitMask) << bitOfst);
-		}
-	}
-}
-
-void charsDrawString(const struct CharDrawingParams *params)
-{
-	const char *s = params->str;
-	int16_t x = params->x;
-	uint8_t ch;
-
-	while ((ch = *s++) != 0)
-	{
-		charsPrvDrawCharRow(ch, x, params->imgRow, params->foreColor, params->backColor, params->magnify);
-		x += (uint16_t)(uint8_t)(CHAR_WIDTH * params->magnify);
-	}
-}
-
-const static uint8_t mCharsImgs[] = {
-	0x00, 0x00, 0x00, 0x00, 0x02, 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, 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, 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, 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, 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, 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, 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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 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, 0x18, 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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x18, 0x00, 0x38, 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, 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, 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, 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, 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,
-	0x0e, 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, 0x18, 0x70, 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, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x18, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x0c, 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, 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, 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, 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, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x0f, 0xf0, 0x0f, 0xdc, 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, 0x18, 0x7e, 0x36,
-	0x3c, 0xd8, 0x38, 0x1c, 0x0c, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
-	0x1e, 0x0c, 0x3c, 0x3c, 0x30, 0x7e, 0x1c, 0x7e, 0x3c, 0x3c, 0x00, 0x00,
-	0x06, 0x00, 0x60, 0x3c, 0x7e, 0x18, 0x7c, 0x3c, 0x78, 0x7e, 0x7e, 0x3c,
-	0x66, 0x3c, 0x06, 0x66, 0x60, 0x63, 0x63, 0x3c, 0x7c, 0x3c, 0x7c, 0x3c,
-	0x7e, 0x66, 0x66, 0x63, 0x66, 0x66, 0x7e, 0x3c, 0x60, 0x3c, 0x66, 0x00,
-	0x0c, 0x00, 0x60, 0x00, 0x06, 0x00, 0x1e, 0x00, 0x60, 0x18, 0x0c, 0x60,
-	0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x0c, 0x18, 0x30, 0x71, 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, 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, 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, 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, 0x30, 0x0c, 0x30, 0x38, 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, 0x3c, 0x7e, 0x36, 0x66, 0xda, 0x6c, 0x1c, 0x18, 0x18, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x06, 0x33, 0x1c, 0x66, 0x66, 0x30, 0x60, 0x18, 0x06,
-	0x66, 0x66, 0x00, 0x00, 0x0c, 0x00, 0x30, 0x66, 0xc3, 0x3c, 0x66, 0x66,
-	0x6c, 0x60, 0x60, 0x66, 0x66, 0x18, 0x06, 0x66, 0x60, 0x63, 0x63, 0x66,
-	0x66, 0x66, 0x66, 0x66, 0x18, 0x66, 0x66, 0x63, 0x66, 0x66, 0x06, 0x30,
-	0x60, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x06, 0x00, 0x30, 0x00,
-	0x60, 0x00, 0x00, 0x60, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0xdb, 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, 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, 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, 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, 0x40, 0x02, 0x40,
-	0x72, 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, 0x3c, 0x7e, 0x7f, 0x60, 0x76, 0x6c, 0x0c,
-	0x18, 0x18, 0x36, 0x18, 0x00, 0x00, 0x00, 0x0c, 0x37, 0x7c, 0x66, 0x66,
-	0x36, 0x60, 0x30, 0x0c, 0x66, 0x66, 0x1c, 0x1c, 0x18, 0x00, 0x18, 0x66,
-	0xc3, 0x66, 0x66, 0x66, 0x66, 0x60, 0x60, 0x66, 0x66, 0x18, 0x06, 0x6c,
-	0x60, 0x77, 0x73, 0x66, 0x66, 0x66, 0x66, 0x60, 0x18, 0x66, 0x66, 0x63,
-	0x34, 0x66, 0x06, 0x30, 0x30, 0x0c, 0x00, 0x00, 0x00, 0x3c, 0x7c, 0x3c,
-	0x3e, 0x3c, 0x30, 0x3e, 0x7c, 0x78, 0x3c, 0x66, 0x18, 0x7e, 0x7c, 0x3c,
-	0x7c, 0x3e, 0x66, 0x3e, 0x7e, 0x66, 0x66, 0x63, 0x66, 0x66, 0x7e, 0x18,
-	0x18, 0x18, 0x8e, 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, 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, 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, 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, 0x87, 0xe1, 0x86, 0xe1, 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, 0x3c, 0x7e, 0x36,
-	0x30, 0x0c, 0x38, 0x18, 0x30, 0x0c, 0x1c, 0x18, 0x00, 0x00, 0x00, 0x0c,
-	0x37, 0x0c, 0x06, 0x06, 0x36, 0x60, 0x7c, 0x0c, 0x76, 0x66, 0x1c, 0x1c,
-	0x30, 0x7e, 0x0c, 0x0c, 0xcf, 0x66, 0x66, 0x60, 0x66, 0x60, 0x60, 0x60,
-	0x66, 0x18, 0x06, 0x6c, 0x60, 0x6b, 0x7b, 0x66, 0x66, 0x66, 0x66, 0x30,
-	0x18, 0x66, 0x66, 0x6b, 0x18, 0x66, 0x0c, 0x30, 0x30, 0x0c, 0x00, 0x00,
-	0x00, 0x06, 0x66, 0x66, 0x66, 0x66, 0x30, 0x66, 0x66, 0x18, 0x0c, 0x66,
-	0x18, 0x6b, 0x66, 0x66, 0x66, 0x66, 0x6e, 0x60, 0x30, 0x66, 0x66, 0x6b,
-	0x66, 0x66, 0x06, 0x18, 0x18, 0x18, 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, 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, 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,
-	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, 0x18, 0x18, 0x19, 0xd8, 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, 0x18, 0x7e, 0x36, 0x18, 0x18, 0x60, 0x00, 0x30, 0x0c, 0x7f, 0x7e,
-	0x00, 0x7e, 0x00, 0x18, 0x33, 0x0c, 0x0c, 0x1c, 0x36, 0x7c, 0x66, 0x18,
-	0x3c, 0x66, 0x00, 0x00, 0x60, 0x00, 0x06, 0x18, 0xdb, 0x66, 0x7c, 0x60,
-	0x66, 0x7c, 0x7c, 0x60, 0x7e, 0x18, 0x06, 0x78, 0x60, 0x6b, 0x6f, 0x66,
-	0x7c, 0x66, 0x7c, 0x18, 0x18, 0x66, 0x66, 0x6b, 0x18, 0x3c, 0x18, 0x30,
-	0x18, 0x0c, 0x00, 0x00, 0x00, 0x06, 0x66, 0x60, 0x66, 0x66, 0x7e, 0x66,
-	0x66, 0x18, 0x0c, 0x6c, 0x18, 0x6b, 0x66, 0x66, 0x66, 0x66, 0x70, 0x60,
-	0x30, 0x66, 0x66, 0x6b, 0x3c, 0x66, 0x0c, 0x30, 0x18, 0x0c, 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, 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, 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, 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, 0x20, 0x04, 0x23,
-	0x84, 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, 0x18, 0x7e, 0x36, 0x0c, 0x30, 0x6f, 0x00,
-	0x30, 0x0c, 0x1c, 0x18, 0x00, 0x00, 0x00, 0x18, 0x3b, 0x0c, 0x18, 0x06,
-	0x66, 0x06, 0x66, 0x18, 0x6e, 0x3e, 0x00, 0x00, 0x30, 0x7e, 0x0c, 0x18,
-	0xdb, 0x7e, 0x66, 0x60, 0x66, 0x60, 0x60, 0x6e, 0x66, 0x18, 0x06, 0x6c,
-	0x60, 0x6b, 0x67, 0x66, 0x60, 0x66, 0x6c, 0x0c, 0x18, 0x66, 0x66, 0x6b,
-	0x2c, 0x18, 0x30, 0x30, 0x18, 0x0c, 0x00, 0x00, 0x00, 0x3e, 0x66, 0x60,
-	0x66, 0x7e, 0x30, 0x66, 0x66, 0x18, 0x0c, 0x78, 0x18, 0x6b, 0x66, 0x66,
-	0x66, 0x66, 0x60, 0x3c, 0x30, 0x66, 0x66, 0x6b, 0x18, 0x66, 0x18, 0x60,
-	0x18, 0x06, 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,
-	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, 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, 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, 0x41, 0x82, 0x47, 0x02, 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, 0x7e, 0x7f,
-	0x06, 0x6e, 0x66, 0x00, 0x30, 0x0c, 0x36, 0x18, 0x00, 0x00, 0x00, 0x30,
-	0x3b, 0x0c, 0x30, 0x66, 0x7f, 0x06, 0x66, 0x30, 0x66, 0x0c, 0x00, 0x00,
-	0x18, 0x00, 0x18, 0x00, 0xcf, 0x66, 0x66, 0x66, 0x66, 0x60, 0x60, 0x66,
-	0x66, 0x18, 0x66, 0x6c, 0x60, 0x63, 0x63, 0x66, 0x60, 0x66, 0x66, 0x06,
-	0x18, 0x66, 0x66, 0x36, 0x66, 0x18, 0x60, 0x30, 0x0c, 0x0c, 0x00, 0x00,
-	0x00, 0x66, 0x66, 0x60, 0x66, 0x60, 0x30, 0x66, 0x66, 0x18, 0x0c, 0x6c,
-	0x18, 0x6b, 0x66, 0x66, 0x66, 0x66, 0x60, 0x06, 0x30, 0x66, 0x66, 0x6b,
-	0x3c, 0x66, 0x30, 0x30, 0x18, 0x0c, 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, 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, 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,
-	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, 0x86, 0x61, 0x8e, 0x61, 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, 0x18, 0x7e, 0x36, 0x66, 0x5b, 0x66, 0x00, 0x30, 0x0c, 0x00, 0x00,
-	0x1c, 0x00, 0x1c, 0x30, 0x33, 0x0c, 0x60, 0x66, 0x06, 0x0c, 0x66, 0x30,
-	0x66, 0x18, 0x1c, 0x1c, 0x0c, 0x00, 0x30, 0x18, 0xc0, 0x66, 0x66, 0x66,
-	0x6c, 0x60, 0x60, 0x66, 0x66, 0x18, 0x66, 0x66, 0x60, 0x63, 0x63, 0x66,
-	0x60, 0x66, 0x66, 0x66, 0x18, 0x66, 0x3c, 0x36, 0x66, 0x18, 0x60, 0x30,
-	0x0c, 0x0c, 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x60, 0x30, 0x66,
-	0x66, 0x18, 0x0c, 0x66, 0x18, 0x6b, 0x66, 0x66, 0x66, 0x66, 0x60, 0x06,
-	0x30, 0x66, 0x3c, 0x36, 0x66, 0x66, 0x60, 0x18, 0x18, 0x18, 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, 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, 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, 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, 0x88, 0x11, 0x9c,
-	0x11, 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, 0x18, 0x7e, 0x36, 0x3c, 0x1b, 0x3b, 0x00,
-	0x18, 0x18, 0x00, 0x00, 0x1c, 0x00, 0x1c, 0x60, 0x1e, 0x0c, 0x7e, 0x3c,
-	0x06, 0x78, 0x3c, 0x30, 0x3c, 0x38, 0x1c, 0x1c, 0x06, 0x00, 0x60, 0x18,
-	0x7f, 0x66, 0x7c, 0x3c, 0x78, 0x7e, 0x60, 0x3e, 0x66, 0x3c, 0x3c, 0x66,
-	0x7e, 0x63, 0x63, 0x3c, 0x60, 0x3c, 0x66, 0x3c, 0x18, 0x3c, 0x18, 0x36,
-	0x66, 0x18, 0x7e, 0x30, 0x06, 0x0c, 0x00, 0x00, 0x00, 0x3e, 0x7c, 0x3c,
-	0x3e, 0x3c, 0x30, 0x3e, 0x66, 0x7e, 0x0c, 0x66, 0x7e, 0x63, 0x66, 0x3c,
-	0x7c, 0x3e, 0x60, 0x7c, 0x1e, 0x3e, 0x18, 0x36, 0x66, 0x3c, 0x7e, 0x18,
-	0x18, 0x18, 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,
-	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, 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, 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, 0x10, 0x08, 0x38, 0x08, 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,
-	0x18, 0x0e, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x60,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x06, 0x0c, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x0c, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x60, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x0c, 0x00, 0x18, 0x18, 0x18, 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, 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, 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,
-	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, 0x11, 0x88, 0x71, 0x88, 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, 0x18, 0x00, 0x00, 0x00, 0x0c, 0x30, 0x00, 0x00,
-	0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30,
-	0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
-	0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x06, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x0c, 0x18, 0x30, 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, 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, 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, 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, 0x03, 0xc0, 0xe3,
-	0xc0, 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, 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, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x60, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00,
-	0x18, 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, 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, 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, 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, 0x03, 0xc0, 0x43, 0xc0, 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, 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, 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, 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, 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, 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, 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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00};
\ No newline at end of file
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/chars.h b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/chars.h
deleted file mode 100644
index 71422453..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/chars.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#ifndef _CHARS_H_
-#define _CHARS_H_
-
-#include <stdbool.h>
-#include <stdint.h>
-
-#define CHAR_WIDTH		8
-#define CHAR_HEIGHT		16
-
-#define CHAR_COLOR_TRANSPARENT	(0xff)
-
-#define CHAR_SIGNAL_PT1			(1)
-#define CHAR_SIGNAL_PT2			(2)
-
-#define CHAR_NO_SIGNAL_PT1		(3)
-#define CHAR_NO_SIGNAL_PT2		(4)
-
-struct CharDrawingParams
-{
-	const char *str;
-	int16_t x;
-	uint8_t imgRow;
-	uint8_t foreColor;
-	uint8_t backColor;
-	uint8_t magnify;
-};
-
-void charsDrawString(const struct CharDrawingParams *params);
-
-
-#endif
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/comms.c b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/comms.c
old mode 100644
new mode 100755
index e6cb6ae2..fd315b03
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/comms.c
+++ b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/comms.c
@@ -1,10 +1,8 @@
 #include "comms.h"
 
 #include <stdint.h>
-//#include <stdio.h>
 #include <string.h>
-
-#include "ccm.h"
+#include <stdbool.h>
 #include "proto.h"
 
 extern uint8_t Zigbee_tx_buffer(uint8_t tx_buffer[], int len);
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/comms.h b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/comms.h
old mode 100644
new mode 100755
index a9c4d17b..8b706067
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/comms.h
+++ b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/comms.h
@@ -2,28 +2,17 @@
 #define _COMMS_H_
 
 #include <stdint.h>
-#include "ccm.h"
 
 extern uint8_t  mLastLqi;
 extern int8_t  mLastRSSI;
 
-#define COMMS_MAX_RADIO_WAIT_MSEC		100
-
-#define COMMS_IV_SIZE					(4)		//zeroes except these 4 counter bytes
-
 #define COMMS_RX_ERR_NO_PACKETS			(-1)
-#define COMMS_RX_ERR_INVALID_PACKET		(-2)
-#define COMMS_RX_ERR_MIC_FAIL			(-3)
-
-#define COMMS_MAX_PACKET_SZ				(127 /* max phy len */ - 21 /* max mac frame with panID compression */ - 2 /* FCS len */ - AES_CCM_MIC_SIZE - COMMS_IV_SIZE)
-
 
 uint8_t commsGetLastPacketLQI(void);
 int8_t commsGetLastPacketRSSI(void);
 
 int32_t commsRxUnenc(void *data);
 
-
 void commsTxNoCpy(uint8_t *packetp);
 
 #endif
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/compression.c b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/compression.c
deleted file mode 100644
index 0bc5d1d7..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/compression.c
+++ /dev/null
@@ -1,116 +0,0 @@
-
-#include "compression.h"
-#include "uzlib/src/uzlib.h"
-//#include <stdio.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <string.h>
-#include "mz100_flash.h"
-#include "mz100_wdt.h"
-#include "util.h"
-#include "eeprom.h"
-
-#define OUT_CHUNK_SIZE 0x100
-struct EepromImageHeader backup_header;
-
-uint8_t out_buffer[OUT_CHUNK_SIZE];
-uint8_t dict_buffer[32768];
-
-uint32_t current_in_pos = 0;
-
-int callback_read_more_data(TINF_DATA *d)
-{
-    return FLASH_ByteRead(FLASH_NORMAL_READ, current_in_pos++);
-}
-
-uint32_t decompress_file(uint32_t address_in, uint32_t size_compressed, uint32_t address_temp, uint32_t max_len_temp, char error_reason[100])
-{
-    FLASH_Read(0, address_in - sizeof(struct EepromImageHeader), (uint8_t *)&backup_header, sizeof(struct EepromImageHeader)); // Save the image header to write it back later
-    int res;
-    struct uzlib_uncomp d;
-    uint32_t decomp_len;
-    uint32_t decomp_left;
-    uint32_t current_out_pos = 0;
-    current_in_pos = address_in;
-    FLASH_Read(0, address_in + size_compressed - 4, (uint8_t *)&decomp_len, 4); // Read the expected decompressed len
-    printf("Compressed size is: %i\r\n", size_compressed);
-    printf("Decompressed size is: %i\r\n", decomp_len);
-
-    if (decomp_len + 1 > max_len_temp)
-    {
-        printf("Error decompiled file will get too big\r\n");
-        sprintf(error_reason, "Out too big %i of max %i bytes", decomp_len, max_len_temp);
-        return 0;
-    }
-
-    decomp_left = decomp_len + 1;
-    uzlib_init();
-    uzlib_uncompress_init(&d, dict_buffer, 32768);
-
-    d.source = NULL;
-    d.source_limit = 0;
-    d.source_read_cb = callback_read_more_data; // Read each byte in the callback to save RAM
-
-    res = uzlib_gzip_parse_header(&d);
-    if (res != TINF_OK)
-    {
-        printf("Error parsing header: %d\r\n", res);
-        sprintf(error_reason, "Error parsing header %i", res);
-        return 0;
-    }
-    printf("Header parsed !\r\n");
-
-    qspiEraseRange(address_temp, max_len_temp);
-    printf("OTA Area erased\r\n");
-    while (decomp_left)
-    {
-        WDT_RestartCounter();
-        unsigned int chunk_len = decomp_left < OUT_CHUNK_SIZE ? decomp_left : OUT_CHUNK_SIZE;
-        d.dest = out_buffer;
-        d.dest_start = d.dest;
-        d.dest_limit = d.dest + sizeof(out_buffer);
-        // printf("One round: %i\r\n", decomp_left);
-        // printf("chunk_len: %i\r\n", chunk_len);
-        res = uzlib_uncompress_chksum(&d);
-        // printf("res: %i\r\n", res);
-        decomp_left -= chunk_len;
-        FLASH_Write(false, address_temp + current_out_pos, out_buffer, chunk_len);
-        current_out_pos += chunk_len;
-
-        if (res == TINF_DONE)
-        {
-            break;
-        }
-        if (res != TINF_OK)
-        {
-            printf("Some error inner decomp %i\r\n", res);
-            sprintf(error_reason, "Inner decomp error %i", res);
-            return 0;
-        }
-    }
-    if (res != TINF_DONE)
-    {
-        printf("Some error in decomp %i\r\n", res);
-        sprintf(error_reason, "Decomp error %i", res);
-        return 0;
-    }
-    printf("Decompression done\r\n");
-    printf("Writing image to correct position\r\n");
-    qspiEraseRange(address_in, EEPROM_IMG_EACH);
-    uint32_t copy_left = decomp_len;
-    current_out_pos = 0;
-    while (copy_left)
-    {
-        WDT_RestartCounter();
-        unsigned int chunk_len = copy_left < OUT_CHUNK_SIZE ? copy_left : OUT_CHUNK_SIZE;
-        FLASH_Read(0, address_temp + current_out_pos, (uint8_t *)&out_buffer, chunk_len);
-        FLASH_Write(false, address_in + current_out_pos, out_buffer, chunk_len);
-        current_out_pos += chunk_len;
-        copy_left -= chunk_len;
-    }
-    backup_header.size = decomp_len;
-    // Writing back the header of an uncompressed image
-    FLASH_Write(false, address_in - sizeof(struct EepromImageHeader), (uint8_t *)&backup_header, sizeof(struct EepromImageHeader));
-    printf("Everything done\r\n");
-    return decomp_len;
-}
\ No newline at end of file
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/compression.h b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/compression.h
deleted file mode 100644
index b059a007..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/compression.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#pragma once
-
-#include "uzlib/src/uzlib.h"
-//#include <stdio.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <string.h>
-
-uint32_t decompress_file(uint32_t address_in, uint32_t size_compressed, uint32_t address_temp, uint32_t max_len_temp, char error_reason[100]);
\ No newline at end of file
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/drawing.c b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/drawing.c
old mode 100644
new mode 100755
index 20b01fd7..c8e47e13
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/drawing.c
+++ b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/drawing.c
@@ -1,95 +1,67 @@
 #include "drawing.h"
 
 #include <stdbool.h>
-#include <stdbool.h>
-#include "printf.h"
 
 #include "board.h"
 #include "eeprom.h"
-#include "proto.h"
-#include "timer.h"
-#include "screen.h"
-#include "util.h"
 #include "epd.h"
+#include "printf.h"
+#include "proto.h"
+#include "screen.h"
+#include "timer.h"
+#include "util.h"
 
-
-struct BitmapClutEntry
-{
+struct BitmapClutEntry {
     uint8_t b, g, r, x;
 };
 
-
 uint8_t mPassNo = 0;
 
 static uint8_t mClutMap[256];
 static uint8_t mClutMapRed[256];
 
-void drawImageAtAddress(uint32_t addr, uint8_t lut)
-{
+void drawImageAtAddress(uint32_t addr, uint8_t lut) {
     struct EepromImageHeader *eih = (struct EepromImageHeader *)mClutMap;
     eepromRead(addr, mClutMap, sizeof(struct EepromImageHeader));
-    switch (eih->dataType)
-    {
-    case DATATYPE_IMG_RAW_1BPP:
-        printf("Doing raw 1bpp\n");
+    switch (eih->dataType) {
+        case DATATYPE_IMG_RAW_1BPP:
+            printf("Doing raw 1bpp\n");
 
-        init_epd();
-        display_send_start(1);
-        for (uint32_t c = 0; c < (SCREEN_HEIGHT * (SCREEN_WIDTH / 8)); c++)
-        {
-            if (c % 256 == 0)
-            {
-                eepromRead(addr + sizeof(struct EepromImageHeader) + c, mClutMap, 256);
+            init_epd();
+            display_send_start(1);
+            for (uint32_t c = 0; c < (SCREEN_HEIGHT * (SCREEN_WIDTH / 8)); c++) {
+                if (c % 256 == 0) {
+                    eepromRead(addr + sizeof(struct EepromImageHeader) + c, mClutMap, 256);
+                }
+
+                uint8_t curr_byte = mClutMap[c % 256];  // this one holds 8 pixel, we will translate them to 4 sendings
+
+                interleaveColor(curr_byte, 0x00);
             }
+            display_send_stop();
+            epd_refresh_and_sleep(lut);
+            break;
+        case DATATYPE_IMG_RAW_2BPP:
+            printf("Doing raw 2bpp\n");
+            init_epd();
+            display_send_start(1);
+            for (uint32_t c = 0; c < (SCREEN_HEIGHT * (SCREEN_WIDTH / 8)); c++) {
+                if (c % 256 == 0) {
+                    eepromRead(addr + sizeof(struct EepromImageHeader) + c, mClutMap, 256);
+                    eepromRead(addr + sizeof(struct EepromImageHeader) + (SCREEN_HEIGHT * (SCREEN_WIDTH / 8)) + c, mClutMapRed, 256);
+                }
 
-            uint8_t curr_byte = mClutMap[c % 256]; // this one holds 8 pixel, we will translate them to 4 sendings
+                uint8_t curr_byte = mClutMap[c % 256];        // this one holds 8 pixel, we will translate them to 4 sendings
+                uint8_t curr_byteRed = mClutMapRed[c % 256];  // this one holds 8 pixel, we will translate them to 4 sendings
 
-            for (int pixI = 0; pixI < 4; pixI++)
-            {
-                uint8_t pixel1 = (curr_byte & 0x80) ? 0 : 3;
-                curr_byte <<= 1;
-                uint8_t pixel2 = (curr_byte & 0x80) ? 0 : 3;
-                curr_byte <<= 1;
-                display_tx_byte((pixel1 << 4) | pixel2);
+                interleaveColor(curr_byte, curr_byteRed);
             }
-        }
-        display_send_stop();
-        epd_refresh_and_sleep();
-        break;
-    case DATATYPE_IMG_RAW_2BPP:
-        printf("Doing raw 2bpp\n");
-        init_epd();
-        display_send_start(1);
-        for (uint32_t c = 0; c < (SCREEN_HEIGHT * (SCREEN_WIDTH / 8)); c++)
-        {
-            if (c % 256 == 0)
-            {
-                eepromRead(addr + sizeof(struct EepromImageHeader) + c, mClutMap, 256);
-                eepromRead(addr + sizeof(struct EepromImageHeader) + (SCREEN_HEIGHT * (SCREEN_WIDTH / 8)) + c, mClutMapRed, 256);
-            }
-
-            uint8_t curr_byte = mClutMap[c % 256];       // this one holds 8 pixel, we will translate them to 4 sendings
-            uint8_t curr_byteRed = mClutMapRed[c % 256]; // this one holds 8 pixel, we will translate them to 4 sendings
-
-            for (int pixI = 0; pixI < 4; pixI++)
-            {
-                uint8_t pixel1 = (curr_byte & 0x80) ? 0 : 3;
-                pixel1 = (curr_byteRed & 0x80) ? 4 : pixel1;
-                curr_byte <<= 1;
-                curr_byteRed <<= 1;
-                uint8_t pixel2 = (curr_byte & 0x80) ? 0 : 3;
-                pixel2 = (curr_byteRed & 0x80) ? 4 : pixel1;
-                curr_byte <<= 1;
-                curr_byteRed <<= 1;
-                display_tx_byte((pixel1 << 4) | pixel2);
-            }
-        }
-        display_send_stop();
-        epd_refresh_and_sleep();
-        break;
-    default: // prevent drawing from an unknown file image type
-        printf("Image with type 0x%02X was requested, but we don't know what to do with that currently...\n", eih->dataType);
-        return;
+            display_send_stop();
+            epd_refresh_and_sleep(lut);
+            break;
+        default:  // prevent drawing from an unknown file image type
+            printf("Image with type 0x%02X was requested, but we don't know what to do with that currently...\n", eih->dataType);
+            return;
     }
     // addOverlay();
     // drawWithSleep();
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/eeprom.h b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/eeprom.h
old mode 100644
new mode 100755
index 14a0f3ec..f048d116
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/eeprom.h
+++ b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/eeprom.h
@@ -7,8 +7,7 @@
 #define EEPROM_ERZ_SECTOR_SZ		4096	//erase size and alignment
 //pages are 4K in size
 //an update can be stored in any 2 image slots
-#define EEPROM_UPDATA_AREA_START		(0x17000UL)
-#define EEPROM_UPDATE_AREA_LEN			(0x10000UL)
+
 #define EEPROM_PAGE_SIZE			(0x01000UL)
 
 #define EEPROM_OS_START				(0x00000UL)
@@ -32,18 +31,7 @@
 #define EEPROM_IMG_VALID			(0x494d4721)
 
 
-#define EEPROM_PIECE_SZ				(88)
-struct EepromImageHeaderOld {
-	uint64_t version;
-	uint32_t validMarker;
-	uint32_t size;
-	uint32_t rfu[8];				//zero-filled for now
-	uint8_t piecesMissing[256];		//each bit represents a 64-byte piece
-	
-	//image data here
-	//os update here possibly (EEPROM_OS_UPDATE_SZ_PER_IMG bytes each piece)
-	//we pre-erase so progress can be calculated by finding the first non-0xff byte
-};
+//#define EEPROM_PIECE_SZ				(88)
 
 struct EepromImageHeader {				//each image space is 0x17000 bytes, we have space for ten of them
 	uint64_t version;
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/epd.c b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/epd.c
index 7998eccc..8e9e4c71 100755
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/epd.c
+++ b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/epd.c
@@ -2,8 +2,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
-//#include <stdio.h>
-#include "printf.h"
+// #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -16,6 +15,7 @@
 #include "mz100_pinmux.h"
 #include "mz100_ssp.h"
 #include "mz100_wdt.h"
+#include "printf.h"
 #include "stdarg.h"
 #include "util.h"
 
@@ -63,6 +63,17 @@
 
 static uint8_t EPDtempBracket = 0;
 
+#define CHAR_WIDTH_BYTES 2
+#define CHAR_HEIGHT 20
+#define CHAR_WIDTH 12
+#define SCREEN_WIDTH 640
+
+uint8_t buffer[CHAR_HEIGHT][640 / 8];
+uint8_t charbuffer[CHAR_HEIGHT][CHAR_WIDTH_BYTES + 1];
+
+#define CHAR_SPACING 1
+#define EMPTY_SPACING 3
+
 struct epd_colorlutpart {
     uint8_t repeat;
     uint8_t lvl0 : 4;
@@ -114,13 +125,39 @@ struct epd_xonlut {
     struct epd_xonlutpart part[20];
 } __packed;
 
-void interleaveColor(uint8_t b) {
+void interleaveBW(uint8_t b) {
     b ^= 0xFF;
     uint8_t b_out = 0;
     for (uint8_t shift = 0; shift < 4; shift++) {
         b_out = 0;
-        if ((b >> 2 * shift) & 0x01) b_out |= 0x30;
-        if ((b >> 2 * shift) & 0x02) b_out |= 0x03;
+        if ((b >> 2 * shift) & 0x01) b_out |= 0x30;  // 0x30
+        if ((b >> 2 * shift) & 0x02) b_out |= 0x03;  // 0x03
+        display_tx_byte(b_out);
+    }
+}
+
+void interleaveColor(uint8_t b, uint8_t r) {
+    b ^= 0xFF;
+    uint8_t b_out = 0;
+    for (int8_t shift = 3; shift >= 0; shift--) {
+        b_out = 0;
+        if (((b >> 2 * shift) & 0x01) && ((r >> 2 * shift) & 0x01)) {
+            b_out |= 0x04;  // 0x30
+        } else if ((b >> 2 * shift) & 0x01) {
+            b_out |= 0x03;                     // 0x30
+        } else if ((r >> 2 * shift) & 0x01) {  // 4 or 5
+            b_out |= 0x04;                     // 0x30
+        } else {
+        }
+
+        if (((b >> 2 * shift) & 0x02) && ((r >> 2 * shift) & 0x02)) {
+            b_out |= 0x40;  // 0x30
+        } else if ((b >> 2 * shift) & 0x02) {
+            b_out |= 0x30;  // 0x30
+        } else if ((r >> 2 * shift) & 0x02) {
+            b_out |= 0x40;  // 0x30
+        } else {
+        }
         display_tx_byte(b_out);
     }
 }
@@ -423,21 +460,9 @@ void shiftLeftByX(uint8_t *data, int X, int N) {
         data[i] = (data[i] << X) | ((data[i - 1] >> (8 - X)) & ((1 << X) - 1));
     }
 }
-#define CHAR_WIDTH_BYTES 2
-#define CHAR_HEIGHT 20
-#define CHAR_WIDTH 12
-#define SCREEN_WIDTH 640
-
-uint8_t buffer[CHAR_HEIGHT][640 / 8];
-uint8_t charbuffer[CHAR_HEIGHT][CHAR_WIDTH_BYTES + 1];
-
-// uint16_t curX = 0;
-#define CHAR_SPACING 1
-#define EMPTY_SPACING 3
 
 uint16_t loadCharacter(uint8_t currentChar, uint16_t curX, bool first) {
-
-    currentChar-=0x20;
+    currentChar -= 0x20;
 
     memset(charbuffer, 0, sizeof(charbuffer));
     for (uint8_t d = 0; d < CHAR_HEIGHT; d++) {
@@ -507,19 +532,29 @@ void dumpBuffer(uint16_t xloc, uint16_t yloc, uint16_t width) {
     display_send_start(0);
     for (uint8_t curY = 0; curY < CHAR_HEIGHT; curY++) {
         for (uint16_t curX = 0; curX < width; curX += 8) {
-            interleaveColor(buffer[curY][curX / 8]);
+            interleaveBW(buffer[curY][curX / 8]);
         }
     }
     display_send_stop();
 }
 
-void loadLUTSfromEEPROM() {
-    uint8_t bracket = getTempBracket();
+void loadLUTSfromEEPROM(uint8_t bracket) {
     for (uint8_t c = EPD_LUT_B; c <= EPD_LUT_R3; c++) {
         struct epd_colorlut *colorlut = (struct epd_colorlut *)loadLUT(c, bracket);
-        for (uint8_t part = 0; part < 20; part++) {
+
+        for (uint8_t d = 0; d < 8; d++) {
+            colorlut->part[1].length[d] = 1;
+            colorlut->part[0].length[d] = 1;
+        }
+
+        for (uint8_t part = 0; part < 4; part++) {
             if (colorlut->part[part].repeat) colorlut->part[part].repeat = 1;
         }
+
+        for (uint8_t part = 4; part < 20; part++) {
+            if (colorlut->part[part].repeat) colorlut->part[part].repeat = 0;
+        }
+
         lutBeginTX(c);
         for (uint16_t d = 0; d < 260; d++) {
             display_tx_byte(((uint8_t *)colorlut)[d]);
@@ -529,8 +564,9 @@ void loadLUTSfromEEPROM() {
     }
 
     struct epd_vcomlut *vcomlut = (struct epd_vcomlut *)loadLUT(EPD_LUT_VCOM, bracket);
+
     for (uint8_t part = 0; part < 20; part++) {
-        if (vcomlut->part[part].repeat) vcomlut->part[part].repeat = 1;
+        if (vcomlut->part[part].repeat) vcomlut->part[part].repeat = 0;
     }
     lutBeginTX(EPD_LUT_VCOM);
     for (uint16_t d = 0; d < 220; d++) {
@@ -540,8 +576,12 @@ void loadLUTSfromEEPROM() {
     if (vcomlut) free(vcomlut);
 
     struct epd_xonlut *xonlut = (struct epd_xonlut *)loadLUT(EPD_LUT_XON, bracket);
+
+    // memset(&(xonlut->part[0].repeat), 0x00, sizeof(struct epd_xonlutpart));
+    // memset(&(xonlut->part[1].repeat), 0x00, sizeof(struct epd_xonlutpart));
+
     for (uint8_t part = 0; part < 20; part++) {
-        if (xonlut->part[part].repeat) xonlut->part[part].repeat = 1;
+        if (xonlut->part[part].repeat) xonlut->part[part].repeat = 0;
     }
     lutBeginTX(EPD_LUT_XON);
     for (uint16_t d = 0; d < 200; d++) {
@@ -595,31 +635,45 @@ void fillWindow(uint16_t x, uint16_t y, uint16_t xe, uint16_t ye, uint8_t color)
     display_send_start(0);
 
     for (uint32_t c = 0; c < (xe - x) * (ye - y) / 8; c++) {
-        interleaveColor(0x00);
+        interleaveBW(0x00);
     }
 
     display_send_stop();
 }
 
-void epd_refresh_and_sleep() {
-    loadLUTSfromEEPROM(EPDtempBracket);
+void epd_refresh_and_sleep(uint8_t lut) {
+    if (lut) {
+        epdWrite(EPD_PANEL_SETTING, 2, 0xC3, 0x88);  // 0xC3-0x88 // lut from register
+        loadLUTSfromEEPROM(EPDtempBracket);
+    } else {
+        epdWrite(EPD_PANEL_SETTING, 2, 0xC3, 0x08);  // 0xC3-0x88 // lut from EEPROM
+        epdWrite(EPD_UNKNOWN_1, 1, 0x03);            // load lut, probably
+    }
 
     // epdPrintf(50,100,false,"Blaat! Dit is een test %d", 6);
 
     EPD_cmd(EPD_REFRESH);
-    delay(100000);
+
+    unsigned int v2 = 0;
+    while (GPIO_ReadPinLevel(EPD_BUSY) == GPIO_IO_HIGH) {
+        WDT_RestartCounter();
+        delay(10000);
+        v2++;
+        if (v2 > 10)
+            break;
+    }
     do_sleeped_epd_refresh();
     init_GPIO_EPD();
     epd_reset();
-    epd_reset();
+    //    epd_reset();
     EPD_cmd(EPD_POWER_SETTING);
     EPD_data(2);
     EPD_data(0);
     EPD_data(0);
     EPD_data(0);
-    delay_us(500000);
+    delay_us(50000);
     EPD_cmd(EPD_POWER_OFF);
-    delay_us(1000000);
+    delay_us(100000);
     BUSY_wait(0x32u);
     EPD_cmd(EPD_SPI_FLASH_CONTROL);
     EPD_data(1);
@@ -701,9 +755,9 @@ void init_epd(void) {
     epdWrite(EPD_SPI_FLASH_CONTROL, 1, 0x00);
 
     epdWrite(EPD_POWER_SETTING, 4, 0x37, 0x00, 0x05, 0x05);  // 0x37 - 00- 05 05
-    epdWrite(EPD_PANEL_SETTING, 2, 0xC3, 0x88);              // CB-88 // CB-08 // C3-reverse
+    // epdWrite(EPD_POWER_SETTING, 4, 0x07, 0x00, 0x05, 0x05);  // 0x37 - 00- 05 05
 
-    // epdWrite(EPD_UNKNOWN_1, 1, 0x03);
+    epdWrite(EPD_PANEL_SETTING, 2, 0xC3, 0x08);  // 0xC3-0x88 // lut from EEPROM
 
     epdWrite(EPD_POWER_OFF_SEQUENCE, 1, 0x00);
     epdWrite(EPD_BOOSTER_SOFT_START, 0x03, 199, 204, 45);
@@ -714,12 +768,9 @@ void init_epd(void) {
     epdWrite(EPD_TCON_SET, 0x01, 34);
     epdWrite(EPD_TRES, 0x04, 2, 128, 1, 128);
 
-    //setDisplayWindow(96, 32, 496, 332);
-
     EPDtempBracket = getTempBracket();
     loadFrameRatePLL(EPDtempBracket);
     loadTempVCOMDC(EPDtempBracket);
-    printf("EPD Powerup complete\n");
 }
 
 void epdPrintf(uint16_t x, uint16_t y, bool color, const char *c, ...) {
@@ -731,7 +782,7 @@ void epdPrintf(uint16_t x, uint16_t y, bool color, const char *c, ...) {
     memset(charbuffer, 0, sizeof(charbuffer));
     va_list lst;
     va_start(lst, c);
-    vsnprintf(out_buffer,256, c, lst);
+    vsnprintf(out_buffer, 256, c, lst);
     va_end(lst);
 
     curX = x % 8;
@@ -750,4 +801,18 @@ void epdPrintf(uint16_t x, uint16_t y, bool color, const char *c, ...) {
     x /= 8;
     x *= 8;
     dumpBuffer(x, y, curX);
+}
+
+void drawImg(uint16_t x, uint16_t y, const uint8_t *img) {
+    uint16_t width = img[0];
+    uint16_t height = img[1];
+    img += 2;
+    setDisplayWindow(x, y, x + width, y + height);
+    display_send_start(0);
+    for (uint8_t curY = 0; curY < height; curY++) {
+        for (uint16_t curX = 0; curX < width; curX += 8) {
+            interleaveColor(*(img++), 0x00);
+        }
+    }
+    display_send_stop();
 }
\ No newline at end of file
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/epd.h b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/epd.h
old mode 100644
new mode 100755
index 9b68d899..29f36499
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/epd.h
+++ b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/epd.h
@@ -32,7 +32,7 @@
 void init_GPIO_EPD();
 void display_send_buffer();
 
-void epd_refresh_and_sleep();
+void epd_refresh_and_sleep(uint8_t lut);
 
 void display_tx_byte(uint8_t data);
 void display_send_start(uint8_t inverted);
@@ -50,4 +50,9 @@ void epd_pin_enable(int a1);
 
 
 void fillWindow(uint16_t x, uint16_t y, uint16_t xe, uint16_t ye, uint8_t color);
-void epdPrintf(uint16_t x, uint16_t y, bool color, const char* c, ...);
\ No newline at end of file
+void epdPrintf(uint16_t x, uint16_t y, bool color, const char* c, ...);
+
+void interleaveColor(uint8_t b, uint8_t r);
+void interleaveBW(uint8_t);
+
+void drawImg(uint16_t x, uint16_t y, const uint8_t *img);
\ No newline at end of file
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/main.c b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/main.c
index 41be818d..53be5514 100755
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/main.c
+++ b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/main.c
@@ -2,11 +2,8 @@
 
 #include <stdbool.h>
 #include <stdint.h>
-// #include <stdio.h>
 #include <string.h>
 
-#include "ccm.h"
-#include "chars.h"
 #include "comms.h"
 #include "core_cm3.h"
 #include "eeprom.h"
@@ -48,73 +45,24 @@ char macStr1[32];
 __attribute__((section(".aon"))) uint8_t currentTagMode = TAG_MODE_CHANSEARCH;
 __attribute__((section(".aon"))) volatile struct zigbeeCalibDataStruct zigbeeCalibData;
 
-void prvApplyUpdateIfNeeded() {
-    uint32_t ofst, now, size, pieceSz = 0x2000;
-    uint8_t chunkStore[0x2000];
-    (*(volatile unsigned int *)0x130000) = 0;  // Invalidate RAM in any case so the next boot will be a full one
-    (*(volatile unsigned int *)0x130400) = 0;
-
-    printf("Applying update\r\n");
-    qspiEraseRange(EEPROM_OS_START, EEPROM_OS_LEN);
-
-    size = EEPROM_OS_LEN;
-    for (ofst = 0; ofst < size; ofst += now) {
-        now = size - ofst;
-        if (now > pieceSz)
-            now = pieceSz;
-        printf("Cpy 0x%06x + 0x%04x to 0x%06x\r\n", EEPROM_UPDATE_START + ofst, now, EEPROM_OS_START + ofst);
-        FLASH_Read(0, EEPROM_UPDATE_START + ofst, chunkStore, now);
-        FLASH_Write(false, EEPROM_OS_START + ofst, chunkStore, now);
-        WDT_RestartCounter();
-    }
-
-    // printf("Erz IMAGES\r\n");
-    // qspiEraseRange(EEPROM_IMG_START, EEPROM_IMG_LEN);
-    // printf("Erz update\r\n");
-    // qspiEraseRange(EEPROM_UPDATE_START, EEPROM_UPDATE_LEN);
-    sleep_with_with_wakeup(1000);
-}
-
-void prvEepromIndex(struct EepromContentsInfo *eci) {
-    struct EepromImageHeader eih;
-    uint32_t addr;
-
-    for (addr = EEPROM_IMG_START; addr - EEPROM_IMG_START < EEPROM_IMG_LEN; addr += EEPROM_IMG_EACH) {
-        uint32_t *addrP, *szP = NULL;
-        uint64_t *verP = NULL;
-
-        FLASH_Read(0, addr, (uint8_t *)&eih, sizeof(struct EepromImageHeader));
-        printf("DATA slot 0x%06x: type 0x%08x ver 0x%08x%08x\r\n", addr, eih.validMarker, (uint32_t)(eih.version >> 32), (uint32_t)eih.version);
-
-        switch (eih.validMarker) {
-            case EEPROM_IMG_INPROGRESS:
-                verP = &eci->latestInprogressImgVer;
-                addrP = &eci->latestInprogressImgAddr;
-                break;
-
-            case EEPROM_IMG_VALID:
-                verP = &eci->latestCompleteImgVer;
-                addrP = &eci->latestCompleteImgAddr;
-                szP = &eci->latestCompleteImgSize;
-                break;
-        }
-
-        if (verP && eih.version >= *verP) {
-            *verP = eih.version;
-            *addrP = addr;
-            if (szP)
-                *szP = eih.size;
+bool protectedFlashWrite(uint32_t address, uint8_t *buffer, uint32_t num) {
+    uint8_t attempt = 3;
+    uint8_t *buf2 = (uint8_t *)malloc(num);
+    while (attempt--) {
+        qspiEraseRange(address, num);
+        delay(50);
+        FLASH_Write(false, address, buffer, num);
+        FLASH_Read(0, address, buf2, num);
+        if (memcmp(buffer, buf2, num) == 0) {
+            printf("Flash block at %06X written successfully\n", address);
+            free(buf2);
+            return true;
         }
+        printf("Failed attempt to write flash block at %lu\n", address);
     }
-}
-void prvWriteNewHeader(struct EepromImageHeaderOld *eih, uint32_t addr, uint32_t eeSize, uint64_t ver, uint32_t size) {
-    qspiEraseRange(addr, eeSize);
-    // bzero(eih, sizeof(struct EepromImageHeaderOld));
-    eih->version = ver;
-    eih->validMarker = EEPROM_IMG_INPROGRESS;
-    eih->size = size;
-    memset(eih->piecesMissing, 0xff, sizeof(eih->piecesMissing));
-    FLASH_Write(false, addr, (uint8_t *)eih, sizeof(struct EepromImageHeaderOld));
+    free(buf2);
+    printf("Giving up on writing block at %lu\n", address);
+    return false;
 }
 
 static void prvGetSelfMac(void) {
@@ -158,6 +106,7 @@ uint8_t showChannelSelect() {  // returns 0 if no accesspoints were found
 }
 
 uint8_t channelSelect() {  // returns 0 if no accesspoints were found
+    printf("Doing chansearch...\n");
     uint8_t result[16];
     memset(result, 0, sizeof(result));
 
@@ -336,7 +285,6 @@ void TagAssociated() {
         if ((lowBattery && !lowBatteryShown && tagSettings.enableLowBatSymbol) || (noAPShown && tagSettings.enableNoRFSymbol)) {
             printf("For some reason, we're going to redraw the image. lowbat=%d, lowbatshown=%d, noAPShown=%d\n", lowBattery, lowBatteryShown, noAPShown);
             // Check if we were already displaying an image
-            /*
             if (curImgSlot != 0xFF) {
                 powerUp(INIT_EEPROM | INIT_EPD);
                 wdt60s();
@@ -347,7 +295,6 @@ void TagAssociated() {
                 showAPFound();
                 powerDown(INIT_EPD);
             }
-            */
         }
 
         powerUp(INIT_RADIO);
@@ -473,6 +420,8 @@ int main(void) {
         printf("AON is not valid!\n");
         setupRTC();
         clearAonRam();
+
+        showSplashScreen();
         currentChannel = 0;
         zigbeeCalibData.isValid = false;
         wakeUpReason = WAKEUP_REASON_FIRSTBOOT;
@@ -483,8 +432,6 @@ int main(void) {
         loadDefaultSettings();
         doVoltageReading();
 
-        qspiEraseRange(EEPROM_IMG_START, EEPROM_IMG_LEN);
-        qspiEraseRange(EEPROM_UPDATE_START, EEPROM_UPDATE_LEN);
         qspiEraseRange(EEPROM_SETTINGS_AREA_START, EEPROM_SETTINGS_AREA_LEN);
 
         sprintf(macStr, "(" MACFMT ")", MACCVT(mSelfMac));
@@ -498,6 +445,7 @@ int main(void) {
             currentTagMode = TAG_MODE_ASSOCIATED;
         } else {
             printf("No AP found\r\n");
+            showNoAP();
             sleep_with_with_wakeup(120000UL);
             currentTagMode = TAG_MODE_CHANSEARCH;
         }
@@ -511,8 +459,8 @@ int main(void) {
         memset(curBlock.requestedParts, 0x00, BLOCK_REQ_PARTS_BYTES);
     }
 
+    powerUp(INIT_UART);
     while (1) {
-        powerUp(INIT_UART);
         wdt10s();
         switch (currentTagMode) {
             case TAG_MODE_ASSOCIATED:
@@ -533,4 +481,29 @@ int _write(int file, char *ptr, int len) {
 
 void _putchar(char c) {
     _write(0, &c, 1);
-}
\ No newline at end of file
+}
+
+void applyUpdate() {
+    uint32_t ofst, now, size, pieceSz = 0x2000;
+    uint8_t chunkStore[0x2000];
+
+    printf("Applying update\r\n");
+
+    // apparently, the flash process is more reliable if we do these two first
+    setupCLKCalib();
+    setupRTC();
+    
+    showApplyUpdate();
+
+    size = EEPROM_OS_LEN;
+    for (ofst = 0; ofst < size; ofst += now) {
+        now = size - ofst;
+        if (now > pieceSz)
+            now = pieceSz;
+        printf("Cpy 0x%06x + 0x%04x to 0x%06x\r\n", EEPROM_UPDATE_START + ofst, now, EEPROM_OS_START + ofst);
+        FLASH_Read(0, EEPROM_UPDATE_START + ofst, chunkStore, now);
+        protectedFlashWrite(EEPROM_OS_START + ofst, chunkStore, now);
+        WDT_RestartCounter();
+    }
+    NVIC_SystemReset();
+}
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/main.h b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/main.h
old mode 100644
new mode 100755
index ab44cabd..91e07da8
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/main.h
+++ b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/main.h
@@ -28,11 +28,7 @@
 #define EPD_BUSY 27
 #define EPD_HLT_CTRL 25
 
+
 #define RADIO_FIRST_CHANNEL				(11)		//2.4-GHz channels start at 11
-struct EepromContentsInfo
-{
-    uint32_t latestCompleteImgAddr, latestInprogressImgAddr, latestCompleteImgSize;
-    uint64_t latestCompleteImgVer, latestInprogressImgVer;
-};
-void uiPrvFullscreenMsg(const char *str, const char *line2, const char *line3);
-void prvApplyUpdateIfNeeded();
\ No newline at end of file
+
+void applyUpdate();
\ No newline at end of file
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/powermgt.h b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/powermgt.h
old mode 100644
new mode 100755
index eed0e059..f44632ef
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/powermgt.h
+++ b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/powermgt.h
@@ -26,7 +26,7 @@
 
 // power saving algorithm
 #define INTERVAL_BASE 40              // interval (in seconds) (when 1 packet is sent/received) for target current (7.2µA)
-#define INTERVAL_AT_MAX_ATTEMPTS 600  // interval (in seconds) (at max attempts) for target average current
+#define INTERVAL_AT_MAX_ATTEMPTS 300  // interval (in seconds) (at max attempts) for target average current
 #define DATA_REQ_RX_WINDOW_SIZE 5UL   // How many milliseconds we should wait for a packet during the data_request.
                                       // If the AP holds a long list of data for tags, it may need a little more time to lookup the mac address
 #define DATA_REQ_MAX_ATTEMPTS 3      // How many attempts (at most) we should do to get something back from the AP
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/proto.h b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/proto.h
old mode 100644
new mode 100755
index e87d7326..60d2e8f8
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/proto.h
+++ b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/proto.h
@@ -3,364 +3,10 @@
 
 #include <stdint.h>
 
-/*
-        All communications are direct from tag to station, EXCEPT association (tag will broadcast).
-        All comms shall be encrypted and authenticated with AES-CCM. Shared key shall be burned into the firmware.
-        Master shall provision new key at association. All non-bcast packets shall have pan id compression.
-        Master may skip "from" field. Tag checking in confirms it got the master's provisioning reply.
-
-        Sadly filtering on MZ100 fails for long addr with no src addr. so short addr for src is used
-
-        T = tag, S = station
-
-        PACKET TYPE		USE		PAYLOAD STRUCT		NOTES
-        ASSOC_REQ		T2bcast	TagInfo				tag's info and assoc request (encrypted with shared key)
-        ASSOC_RESP		S2T		AssocInfo			tag's association info (encrypted with shared key)
-        CHECKIN			T2S		CheckinInfo			tag checking in occasionally
-        CHECKOUT		S2T		PendingInfo			station's checkin reply telling tag what we have for it
-        CHUNK_REQ		T2S		ChunkReqInfo		tag requesting a piece of data
-        CHUNK_RESP		S2T		ChunkInfo			station provides chunk
-
-*/
-
-#define PROTO_PRESHARED_KEY \
-    { 0x34D906D3, 0xE3E5298E, 0x3429BF58, 0xC1022081 }
-
-#define PROTO_PAN_ID (0x4447)  // PAN ID compression shall be used
-
-#define PKT_ASSOC_REQ (0xF0)
-#define PKT_ASSOC_RESP (0xF1)
-#define PKT_CHECKIN (0xF2)
-#define PKT_CHECKOUT (0xF3)
-#define PKT_CHUNK_REQ (0xF4)
-#define PKT_CHUNK_RESP (0xF5)
-
-#define PROTO_VER_0 (0)
-#define PROTO_VER_CURRENT (PROTO_VER_0)
-
-#define PROTO_COMPR_TYPE_LZ (0x0001)
-#define PROTO_COMPR_TYPE_BITPACK (0x0002)
-
-#define PROTO_MAX_DL_LEN (88)
-
-//////////////// NEW
-
-#include "tag_types.h"
-/*
-// power saving algorithm
-#define INTERVAL_BASE 40              // interval (in seconds) (when 1 packet is sent/received) for target current (7.2µA)
-#define INTERVAL_AT_MAX_ATTEMPTS 600  // interval (in seconds) (at max attempts) for target average current
-#define DATA_REQ_RX_WINDOW_SIZE 5UL   // How many milliseconds we should wait for a packet during the data_request.
-                                      // If the AP holds a long list of data for tags, it may need a little more time to lookup the mac address
-#define DATA_REQ_MAX_ATTEMPTS 14      // How many attempts (at most) we should do to get something back from the AP
-#define POWER_SAVING_SMOOTHING 8      // How many samples we should use to smooth the data request interval
-#define MINIMUM_INTERVAL 45           // IMPORTANT: Minimum interval for check-in; this determines overal battery life!
-#define MAXIMUM_PING_ATTEMPTS 20      // How many attempts to discover an AP the tag should do
-
-#define LONG_DATAREQ_INTERVAL 300     // How often (in seconds, approximately) the tag should do a long datareq (including temperature)
-#define VOLTAGE_CHECK_INTERVAL 288    // How often the tag should do a battery voltage check (multiplied by LONG_DATAREQ_INTERVAL)
-#define BATTERY_VOLTAGE_MINIMUM 2450  // 2600 or below is the best we can do on the EPD
-
-// power saving when no AP's were found (scanning every X)
-#define VOLTAGEREADING_DURING_SCAN_INTERVAL 2  // how often we should read voltages; this is done every scan attempt in interval bracket 3
-#define INTERVAL_1_TIME 3600UL                 // Try every hour
-#define INTERVAL_1_ATTEMPTS 24                 // for 24 attempts (an entire day)
-#define INTERVAL_2_TIME 7200UL                 // Try every 2 hours
-#define INTERVAL_2_ATTEMPTS 12                 // for 12 attempts (an additional day)
-#define INTERVAL_3_TIME 86400UL                // Finally, try every day
-*/
-#pragma pack(1)
-enum TagScreenType {
-    TagScreenEink_BW_1bpp,
-    TagScreenEink_BW_2bpp,
-    TagScreenEink_BW_4bpp,
-    TagScreenEink_BWY_only,  // 2bpp, but only 3 colors (BW?Y)
-    TagScreenEink_BWY_2bpp,
-    TagScreenEink_BWY_4bpp,
-    TagScreenEink_BWR_only,  // 2bpp, but only 3 colors (BW?R)
-    TagScreenEink_BWR_2bpp,
-    TagScreenEink_BWR_4bpp,
-
-    TagScreenEink_BWY_3bpp,
-    TagScreenEink_BWR_3bpp,
-    TagScreenEink_BW_3bpp,
-
-    TagScreenPersistentLcd_1bpp,
-
-    TagScreenEink_BWY_5colors,
-    TagScreenEink_BWR_5colors,
-
-    TagScreenEink_BWY_6colors,
-    TagScreenEink_BWR_6colors,
-
-    TagScreenTypeOther = 0x7f,
-};
-
-#define RADIO_MAX_PACKET_LEN (125)  // useful payload, not including the crc
-
-#define ADDR_MODE_NONE (0)
-#define ADDR_MODE_SHORT (2)
-#define ADDR_MODE_LONG (3)
-
-#define FRAME_TYPE_BEACON (0)
-#define FRAME_TYPE_DATA (1)
-#define FRAME_TYPE_ACK (2)
-#define FRAME_TYPE_MAC_CMD (3)
-
-#define SHORT_MAC_UNUSED (0x10000000UL)  // for radioRxFilterCfg's myShortMac
-
-struct MacFcs {
-    uint8_t frameType : 3;
-    uint8_t secure : 1;
-    uint8_t framePending : 1;
-    uint8_t ackReqd : 1;
-    uint8_t panIdCompressed : 1;
-    uint8_t rfu1 : 1;
-    uint8_t rfu2 : 2;
-    uint8_t destAddrType : 2;
-    uint8_t frameVer : 2;
-    uint8_t srcAddrType : 2;
-};
-
-struct MacFrameFromMaster {
-    struct MacFcs fcs;
-    uint8_t seq;
-    uint16_t pan;
-    uint8_t dst[8];
-    uint16_t from;
-};
-
-struct MacFrameNormal {
-    struct MacFcs fcs;
-    uint8_t seq;
-    uint16_t pan;
-    uint8_t dst[8];
-    uint8_t src[8];
-};
-
-struct MacFrameBcast {
-    struct MacFcs fcs;
-    uint8_t seq;
-    uint16_t dstPan;
-    uint16_t dstAddr;
-    uint16_t srcPan;
-    uint8_t src[8];
-};
-
-#define PKT_AVAIL_DATA_SHORTREQ 0xE3
-#define PKT_AVAIL_DATA_REQ 0xE5
-#define PKT_AVAIL_DATA_INFO 0xE6
-#define PKT_BLOCK_PARTIAL_REQUEST 0xE7
-#define PKT_BLOCK_REQUEST_ACK 0xE9
-#define PKT_BLOCK_REQUEST 0xE4
-#define PKT_BLOCK_PART 0xE8
-#define PKT_XFER_COMPLETE 0xEA
-#define PKT_XFER_COMPLETE_ACK 0xEB
-#define PKT_CANCEL_XFER 0xEC
-#define PKT_PING 0xED
-#define PKT_PONG 0xEE
-
-struct AvailDataReq {
-    uint8_t checksum;
-    uint8_t lastPacketLQI;
-    int8_t lastPacketRSSI;
-    int8_t temperature;
-    uint16_t batteryMv;
-    uint8_t hwType;
-    uint8_t wakeupReason;
-    uint8_t capabilities;
-    uint16_t tagSoftwareVersion;
-    uint8_t currentChannel;
-    uint8_t customMode;
-    uint8_t reserved[8];
-};
-
-struct oldAvailDataReq {
-    uint8_t checksum;
-    uint8_t lastPacketLQI;
-    int8_t lastPacketRSSI;
-    int8_t temperature;
-    uint16_t batteryMv;
-    uint8_t hwType;
-    uint8_t wakeupReason;
-    uint8_t capabilities;
-};
-
-struct AvailDataInfo {
-    uint8_t checksum;
-    uint64_t dataVer;  // MD5 of potential traffic
-    uint32_t dataSize;
-    uint8_t dataType;
-    uint8_t dataTypeArgument;  // extra specification or instruction for the tag (LUT to be used for drawing image)
-    uint16_t nextCheckIn;      // when should the tag check-in again? Measured in minutes
-} __attribute__((packed)) ;
-
-struct pendingData {
-    struct AvailDataInfo availdatainfo;
-    uint16_t attemptsLeft;
-    uint8_t targetMac[8];
-};
-
-struct blockPart {
-    uint8_t checksum;
-    uint8_t blockId;
-    uint8_t blockPart;
-    uint8_t data[];
-};
-
-struct blockData {
-    uint16_t size;
-    uint16_t checksum;
-    uint8_t data[];
-};
-
-struct burstMacData {
-    uint16_t offset;
-    uint8_t targetMac[8];
-};
-
-#define BLOCK_PART_DATA_SIZE 99
-#define BLOCK_MAX_PARTS 42
-#define BLOCK_DATA_SIZE 4096UL
-#define BLOCK_XFER_BUFFER_SIZE BLOCK_DATA_SIZE + sizeof(struct blockData)
-#define BLOCK_REQ_PARTS_BYTES 6
-
-struct blockRequest {
-    uint8_t checksum;
-    uint64_t ver;
-    uint8_t blockId;
-    uint8_t type;
-    uint8_t requestedParts[BLOCK_REQ_PARTS_BYTES];
-} ;
-
-struct blockRequestAck {
-    uint8_t checksum;
-    uint16_t pleaseWaitMs;
-};
-
-struct espBlockRequest {
-    uint8_t checksum;
-    uint64_t ver;
-    uint8_t blockId;
-    uint8_t src[8];
-};
-
-struct espXferComplete {
-    uint8_t checksum;
-    uint8_t src[8];
-};
-
-struct espAvailDataReq {
-    uint8_t checksum;
-    uint8_t src[8];
-    struct AvailDataReq adr;
-};
-
-struct espSetChannelPower {
-    uint8_t checksum;
-    uint8_t channel;
-    uint8_t power;
-};
-#pragma pack(0)
-///////////////// NEW END
-#ifndef __packed
-#define __packed __attribute__((packed))
-#endif
-struct TagState {
-    uint64_t swVer;
-    uint16_t hwType;
-    uint16_t batteryMv;
-} __packed;
-
-struct TagInfo {
-    uint8_t protoVer;  // PROTO_VER_*
-    struct TagState state;
-    uint8_t rfu1[1];  // shall be ignored for now
-    uint16_t screenPixWidth;
-    uint16_t screenPixHeight;
-    uint16_t screenMmWidth;
-    uint16_t screenMmHeight;
-    uint16_t compressionsSupported;  // COMPR_TYPE_* bitfield
-    uint16_t maxWaitMsec;            // how long tag will wait for packets before going to sleep
-    uint8_t screenType;              // enum TagScreenType
-    uint8_t rfu[11];                 // shall be zero for now
-} __packed;
-
-struct AssocInfo {
-    uint32_t checkinDelay;              // space between checkins, in msec
-    uint32_t retryDelay;                // if download fails mid-way wait thi smany msec to retry (IFF progress was made)
-    uint16_t failedCheckinsTillBlank;   // how many fails till we go blank
-    uint16_t failedCheckinsTillDissoc;  // how many fails till we dissociate
-    uint32_t newKey[4];
-    uint8_t rfu[8];  // shall be zero for now
-} __packed;
-
-#define CHECKIN_TEMP_OFFSET 0x7f
-
-struct CheckinInfo {
-    struct TagState state;
-    uint8_t lastPacketLQI;  // zero if not reported/not supported to be reported
-    int8_t lastPacketRSSI;  // zero if not reported/not supported to be reported
-    uint8_t temperature;    // zero if not reported/not supported to be reported. else, this minus CHECKIN_TEMP_OFFSET is temp in degrees C
-    uint8_t rfu[6];         // shall be zero for now
-} __packed;
-
-struct PendingInfo {
-    uint64_t imgUpdateVer;
-    uint32_t imgUpdateSize;
-    uint64_t osUpdateVer;  // version of OS update avail
-    uint32_t osUpdateSize;
-    uint8_t rfu[8];  // shall be zero for now
-} __packed;
-
-struct ChunkReqInfo {
-    uint64_t versionRequested;
-    uint32_t offset;
-    uint8_t len;
-    uint8_t osUpdatePlz : 1;
-    uint8_t rfu[6];  // shall be zero for now
-} __packed;
-
-struct ChunkInfo {
-    uint32_t offset;
-    uint8_t osUpdatePlz : 1;
-    uint8_t rfu;     // shall be zero for now
-    uint8_t data[];  // no data means request is out of bounds of this version no longer exists
-} __packed;
+#include "../../oepl-definitions.h"
+#include "../../oepl-proto.h"
 
 #define MACFMT "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x"
 #define MACCVT(x) ((const uint8_t*)(x))[7], ((const uint8_t*)(x))[6], ((const uint8_t*)(x))[5], ((const uint8_t*)(x))[4], ((const uint8_t*)(x))[3], ((const uint8_t*)(x))[2], ((const uint8_t*)(x))[1], ((const uint8_t*)(x))[0]
 
-#define VERSION_SIGNIFICANT_MASK (0x0000ffffffffffffull)
-
-#define HW_TYPE_42_INCH_SAMSUNG (1)
-#define HW_TYPE_42_INCH_SAMSUNG_ROM_VER_OFST (0xEFF8)
-
-#define HW_TYPE_74_INCH_DISPDATA (2)
-#define HW_TYPE_74_INCH_DISPDATA_FRAME_MODE (3)
-#define HW_TYPE_74_INCH_DISPDATA_ROM_VER_OFST (0x008b)
-
-#define HW_TYPE_ZBD_EPOP50 (4)
-#define HW_TYPE_ZBD_EPOP50_ROM_VER_OFST (0x008b)
-
-#define HW_TYPE_ZBD_EPOP900 (5)
-#define HW_TYPE_ZBD_EPOP900_ROM_VER_OFST (0x008b)
-
-#define HW_TYPE_29_INCH_DISPDATA (6)
-#define HW_TYPE_29_INCH_DISPDATA_FRAME_MODE (7)
-#define HW_TYPE_29_INCH_DISPDATA_ROM_VER_OFST (0x008b)
-
-#define HW_TYPE_29_INCH_ZBS_026 (8)
-#define HW_TYPE_29_INCH_ZBS_026_FRAME_MODE (9)
-#define HW_TYPE_29_INCH_ZBS_025 (10)
-#define HW_TYPE_29_INCH_ZBS_025_FRAME_MODE (11)
-#define HW_TYPE_29_INCH_ZBS_ROM_VER_OFST (0x008b)
-
-#define HW_TYPE_74_INCH_BWR (40)
-#define HW_TYPE_74_INCH_BWR_ROM_VER_OFST (0x0160)
-#define HW_TYPE_58_INCH_BWR (41)
-#define HW_TYPE_58_INCH_BWR_ROM_VER_OFST (0x0160)
-#define HW_TYPE_42_INCH_BWR (42)
-#define HW_TYPE_42_INCH_BWR_ROM_VER_OFST (0x0160)
-
-#endif
+#endif
\ No newline at end of file
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/settings.c b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/settings.c
old mode 100644
new mode 100755
index 44636885..7191d5f3
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/settings.c
+++ b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/settings.c
@@ -1,10 +1,12 @@
 #include "settings.h"
+#include "proto.h"
 #include <string.h>
 #include "eeprom.h"
 #include "util.h"
 #include "mz100_flash.h"
 #include "powermgt.h"
 
+
  __attribute__((section(".aonshadow"))) struct tagsettings tagSettings = {0};
 extern uint8_t  blockXferBuffer[];
 uint8_t*  infopageTempBuffer = 1024 + blockXferBuffer;
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/settings.h b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/settings.h
old mode 100644
new mode 100755
index d45efc05..4df94c04
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/settings.h
+++ b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/settings.h
@@ -17,21 +17,6 @@
 #define DEFAULT_SETTING_LOWBATSYMBOL 1
 #define DEFAULT_SETTING_NORFSYMBOL 1
 
-struct tagsettings {
-    uint8_t settingsVer;                  // the version of the struct as written to the infopage
-    uint8_t enableFastBoot;               // default 0; if set, it will skip splashscreen
-    uint8_t enableRFWake;                 // default 0; if set, it will enable RF wake. This will add about ~0.9µA idle power consumption
-    uint8_t enableTagRoaming;             // default 0; if set, the tag will scan for an accesspoint every few check-ins. This will increase power consumption quite a bit
-    uint8_t enableScanForAPAfterTimeout;  // default 1; if a the tag failed to check in, after a few attempts it will try to find a an AP on other channels
-    uint8_t enableLowBatSymbol;           // default 1; tag will show 'low battery' icon on screen if the battery is depleted
-    uint8_t enableNoRFSymbol;             // default 1; tag will show 'no signal' icon on screen if it failed to check in for a longer period of time
-    uint8_t fastBootCapabilities;         // holds the byte with 'capabilities' as detected during a normal tag boot; allows the tag to skip detecting buttons and NFC chip
-    uint8_t customMode;                   // default 0; if anything else, tag will bootup in a different 'mode'
-    uint16_t batLowVoltage;               // Low battery threshold voltage (2450 for 2.45v). defaults to BATTERY_VOLTAGE_MINIMUM from powermgt.h
-    uint16_t minimumCheckInTime;          // defaults to BASE_INTERVAL from powermgt.h
-    uint8_t fixedChannel;                 // default 0; if set to a valid channel number, the tag will stick to that channel
-} __attribute__((packed));
-
 extern __attribute__((section(".aonshadow")))struct tagsettings tagSettings;
 
 void loadDefaultSettings();
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/syncedproto.c b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/syncedproto.c
old mode 100644
new mode 100755
index 75c2b0da..9f4893c8
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/syncedproto.c
+++ b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/syncedproto.c
@@ -8,11 +8,11 @@
 #include "main.h"
 #include "mz100_sleep.h"
 #include "powermgt.h"
+#include "printf.h"
 #include "proto.h"
 #include "timer.h"
 #include "util.h"
 #include "zigbee.h"
-#include "printf.h"
 
 // download-stuff
 uint8_t blockXferBuffer[BLOCK_XFER_BUFFER_SIZE] = {0};
@@ -438,11 +438,11 @@ static uint8_t findSlot(const uint8_t *ver) {
     return 0xFF;
 }
 static void eraseUpdateBlock() {
-    eepromErase(EEPROM_UPDATA_AREA_START, (uint16_t)EEPROM_UPDATE_AREA_LEN);
+    qspiEraseRange(EEPROM_UPDATE_START, EEPROM_UPDATE_LEN);
 }
 static void saveUpdateBlockData(uint8_t blockId) {
     printf("EEPROM writing UpdateBlock %i\n", blockId);
-    if (!eepromWrite(EEPROM_UPDATA_AREA_START + (blockId * BLOCK_DATA_SIZE), blockXferBuffer + sizeof(struct blockData), BLOCK_DATA_SIZE))
+    if (!eepromWrite(EEPROM_UPDATE_START + (blockId * BLOCK_DATA_SIZE), blockXferBuffer + sizeof(struct blockData), BLOCK_DATA_SIZE))
         printf("EEPROM write failed\n");
 }
 static void saveImgBlockData(const uint8_t imgSlot, const uint8_t blockId) {
@@ -478,11 +478,9 @@ static uint32_t getHighSlotId() {
     return temp;
 }
 
-static uint8_t partsThisBlock = 0;
-static uint8_t blockAttempts = 0;  // these CAN be local to the function, but for some reason, they won't survive sleep?
-                                   // they get overwritten with  7F 32 44 20 00 00 00 00 11, I don't know why.
-
 static bool getDataBlock(const uint16_t blockSize) {
+    static uint8_t partsThisBlock = 0;
+    static uint8_t blockAttempts = 0;
     blockAttempts = BLOCK_TRANSFER_ATTEMPTS;
     if (blockSize == BLOCK_DATA_SIZE) {
         partsThisBlock = BLOCK_MAX_PARTS;
@@ -587,6 +585,7 @@ static bool downloadFWUpdate(const struct AvailDataInfo *avail) {
         curBlock.type = avail->dataType;
         memcpy(&curDataInfo, (void *)avail, sizeof(struct AvailDataInfo));
         eraseUpdateBlock();
+        delay(100);
     }
 
     while (curDataInfo.dataSize) {
@@ -767,7 +766,7 @@ bool processAvailDataInfo(struct AvailDataInfo *avail) {
 
                 powerUp(INIT_EEPROM);
                 wdt60s();
-                prvApplyUpdateIfNeeded();
+                applyUpdate();
             } else {
                 return false;
             }
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/userinterface.c b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/userinterface.c
index fc674ab1..a6f28ffa 100644
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/userinterface.c
+++ b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/userinterface.c
@@ -41,14 +41,13 @@ void addCapabilities() {
 
 void addOverlay() {
     if ((currentChannel == 0) && (tagSettings.enableNoRFSymbol)) {
-        // loadRawBitmap(ant, SCREEN_WIDTH - 24, 6, EPD_COLOR_BLACK);
-        // loadRawBitmap(cross, SCREEN_WIDTH - 16, 13, EPD_COLOR_RED);
+        drawImg(0, 3, norf);
         noAPShown = true;
     } else {
         noAPShown = false;
     }
     if ((batteryVoltage < tagSettings.batLowVoltage) && (tagSettings.enableLowBatSymbol)) {
-        // loadRawBitmap(battery, SCREEN_WIDTH - 16, SCREEN_HEIGHT - 10, EPD_COLOR_BLACK);
+        drawImg(0, 366, batlow);
         lowBatteryShown = true;
     } else {
         lowBatteryShown = false;
@@ -68,65 +67,39 @@ void afterFlashScreenSaver() {
 }
 
 void showSplashScreen() {
-    // selectLUT(EPD_LUT_NO_REPEATS);
-    // clearScreen();
-#if (SCREEN_WIDTH == 400)  // 4.2"
-    epdPrintBegin(3, 3, EPD_DIRECTION_X, EPD_SIZE_DOUBLE, EPD_COLOR_BLACK);
-    epdpr("Starting");
-    epdPrintEnd();
-
-    epdPrintBegin(2, 252, EPD_DIRECTION_X, EPD_SIZE_SINGLE, EPD_COLOR_BLACK);
-    addCapabilities();
-    epdPrintEnd();
-
-    epdPrintBegin(3, 268, EPD_DIRECTION_X, EPD_SIZE_SINGLE, EPD_COLOR_BLACK);
-    epdpr("zbs42v033 %d.%d.%d%s", fwVersion / 100, (fwVersion % 100) / 10, (fwVersion % 10), fwVersionSuffix);
-    epdPrintEnd();
-    epdPrintBegin(3, 284, EPD_DIRECTION_X, EPD_SIZE_SINGLE, EPD_COLOR_RED);
-    epdpr("MAC: %02X:%02X", mSelfMac[7], mSelfMac[6]);
-    epdpr(":%02X:%02X", mSelfMac[5], mSelfMac[4]);
-    epdpr(":%02X:%02X", mSelfMac[3], mSelfMac[2]);
-    epdpr(":%02X:%02X", mSelfMac[1], mSelfMac[0]);
-    epdPrintEnd();
-
-    loadRawBitmap(oepli, 136, 22, EPD_COLOR_BLACK);
-    loadRawBitmap(cloud, 136, 10, EPD_COLOR_RED);
-
-    uint8_t __xdata buffer[17];
-    spr(buffer, "%02X%02X", mSelfMac[7], mSelfMac[6]);
-    spr(buffer + 4, "%02X%02X", mSelfMac[5], mSelfMac[4]);
-    spr(buffer + 8, "%02X%02X", mSelfMac[3], mSelfMac[2]);
-    spr(buffer + 12, "%02X%02X", mSelfMac[1], mSelfMac[0]);
-    printBarcode(buffer, 392, 264);
-    printBarcode(buffer, 384, 264);
-
-#endif
-    // drawWithSleep();
+    init_epd();
+    fillWindow(0, 0, 640, 384, 1);
+    epdPrintf(10, 10, 1, "OpenEPaperLink starting!");
+    addOverlay();
+    epd_refresh_and_sleep(1);
 }
 
 void showApplyUpdate() {
-    // selectLUT(1);
-    // clearScreen();
-#if (SCREEN_WIDTH == 400)
-    epdPrintBegin(136, 134, EPD_DIRECTION_X, EPD_SIZE_DOUBLE, EPD_COLOR_BLACK);
-#endif
+    init_epd();
 
-    // epdpr("Updating!");
-    // epdPrintEnd();
-    // drawNoWait();
+    fillWindow(0, 0, 640, 384, 1);
+
+   
+    epdPrintf(90, 170, 1, "Performing update... This shouldn't take too long!");
+
+
+    addOverlay();
+    epd_refresh_and_sleep(1);
 }
 
 void showAPFound() {
-
     init_epd();
+
     fillWindow(0, 0, 640, 384, 1);
+
     epdPrintf(10, 10, 1, "OpenEPaperLink");
     epdPrintf(10, 40, 1, "AP Found at channel %d", currentChannel);
     epdPrintf(10, 60, 1, "AP MAC: %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X", APmac[7], APmac[6], APmac[5], APmac[4], APmac[3], APmac[2], APmac[1], APmac[0]);
 
     epdPrintf(10, 330, 1, "Battery: %d.%dV", batteryVoltage / 1000, batteryVoltage % 1000);
     epdPrintf(10, 350, 1, "Tag MAC: %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X", mSelfMac[7], mSelfMac[6], mSelfMac[5], mSelfMac[4], mSelfMac[3], mSelfMac[2], mSelfMac[1], mSelfMac[0]);
-    epd_refresh_and_sleep();
+    addOverlay();
+    epd_refresh_and_sleep(1);
 }
 
 void showNoAP() {
@@ -135,8 +108,8 @@ void showNoAP() {
     epdPrintf(10, 10, 1, "OpenEPaperLink ");
     epdPrintf(10, 40, 1, "No AP found... We'll try again in a little while though!");
     epdPrintf(10, 350, 1, "Tag MAC: %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X", mSelfMac[7], mSelfMac[6], mSelfMac[5], mSelfMac[4], mSelfMac[3], mSelfMac[2], mSelfMac[1], mSelfMac[0]);
-
-    epd_refresh_and_sleep();
+    addOverlay();
+    epd_refresh_and_sleep(1);
 }
 
 void showLongTermSleep() {
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/.github/workflows/stale.yml b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/.github/workflows/stale.yml
deleted file mode 100644
index 119274ca..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/.github/workflows/stale.yml
+++ /dev/null
@@ -1,67 +0,0 @@
-name: "Close stale tickets"
-on:
-  schedule:
-    - cron: "0 22 * * *"
-
-jobs:
-  stale:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/stale@v3
-      with:
-        days-before-stale: 15
-        days-before-close: 15
-        exempt-issue-labels: triaged
-        exempt-pr-labels: triaged,contrib
-        stale-issue-message: |
-            Thanks for your submission. However there was no (further) activity
-            on it for some time. Below are possible reasons and/or means to
-            proceed further:
-
-            * Please make sure that your submission contains clear and complete
-            description of the issue and information required to understand and
-            reproduce it (exact version of all components involved, etc.). Please
-            refer to numerous guides on submitting helpful bugreports, e.g.
-            https://www.chiark.greenend.org.uk/~sgtatham/bugs.html
-
-            * Please make sure that your feature request/suggestion/change aligns
-            well with the project purpose, goals, and process.
-
-            * If you face the issue you report while working on a community-oriented
-            open-source project, feel free to provide additional context and
-            information - that may help to prioritize the issue better.
-
-            * As many open-source projects, this project is severely under-staffed
-            and under-resourced. If you don't run a community-oriented open-source
-            project, and would like to get additional support/maintenance, feel
-            free to request a support contract.
-
-            Thanks for your understanding!
-        stale-pr-message: |
-            Thanks for your submission. However there was no (further) activity
-            on it for some time. Below are possible reasons and/or means to
-            proceed further:
-
-            * Please make sure that your submission contains clear and complete
-            description of the issue and information required to understand and
-            reproduce it (exact version of all components involved, etc.). Please
-            refer to numerous guides on submitting helpful bugreports, e.g.
-            https://www.chiark.greenend.org.uk/~sgtatham/bugs.html
-
-            * Please make sure that your feature request/suggestion/change aligns
-            well with the project purpose, goals, and process.
-
-            * If you face the issue you report while working on a community-oriented
-            open-source project, feel free to provide additional context and
-            information - that may help to prioritize the issue better.
-
-            * As many open-source projects, this project is severely under-staffed
-            and under-resourced. If you don't run a community-oriented open-source
-            project, and would like to get additional support/maintenance, feel
-            free to request a support contract.
-
-            Thanks for your understanding!
-        close-issue-message: >
-            Closing due to inactivity.
-        close-pr-message: >
-            Closing due to inactivity.
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/.gitignore b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/.gitignore
deleted file mode 100644
index 29d8a166..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/.gitignore
+++ /dev/null
@@ -1,3 +0,0 @@
-*.o
-*.map
-*.a
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/LICENSE b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/LICENSE
deleted file mode 100644
index c96e382d..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/LICENSE
+++ /dev/null
@@ -1,65 +0,0 @@
-Introduction
-------------
-
-uzlib as a whole is licensed under the terms of Zlib license, listed in
-the next section. It consists of substantial works of individuals whose
-copyrights listed in the next session. Some portions of the uzlib codebase
-originally were licensed under different license(s), however compatible
-with the Zlib license. Such license(s) are listed at the end of this file.
-
-License
--------
-
-uzlib - Deflate/Zlib-compatible LZ77 compression/decompression library
-
-Copyright (c) 2003 Joergen Ibsen
-Copyright (c) 1997-2014 Simon Tatham
-Copyright (c) 2014-2020 Paul Sokolovsky
-
-This software is provided 'as-is', without any express or implied
-warranty. In no event will the authors be held liable for any damages
-arising from the use of this software.
-
-Permission is granted to anyone to use this software for any purpose,
-including commercial applications, and to alter it and redistribute it
-freely, subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must
-   not claim that you wrote the original software. If you use this
-   software in a product, an acknowledgment in the product
-   documentation would be appreciated but is not required.
-
-2. Altered source versions must be plainly marked as such, and must
-   not be misrepresented as being the original software.
-
-3. This notice may not be removed or altered from any source
-   distribution.
-
--------
-Original license for src/defl_static.c:
-
-PuTTY is copyright 1997-2014 Simon Tatham.
-
-Portions copyright Robert de Bath, Joris van Rantwijk, Delian
-Delchev, Andreas Schultz, Jeroen Massar, Wez Furlong, Nicolas Barry,
-Justin Bradford, Ben Harris, Malcolm Smith, Ahmad Khalifa, Markus
-Kuhn, Colin Watson, and CORE SDI S.A.
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation files
-(the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of the Software,
-and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE
-FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
-CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/Makefile b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/Makefile
deleted file mode 100644
index b5593199..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/Makefile
+++ /dev/null
@@ -1,4 +0,0 @@
-all clean:
-	$(MAKE) -C src $@
-	$(MAKE) -C examples/tgzip $@
-	$(MAKE) -C examples/tgunzip $@
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/README.md b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/README.md
deleted file mode 100644
index 41dfa5d9..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/README.md
+++ /dev/null
@@ -1,325 +0,0 @@
-uzlib - Deflate/Zlib-compatible LZ77 compression/decompression library
-======================================================================
-
-uzlib is a library which can decompress any valid Deflate, Zlib, and Gzip
-(further called just "Deflate") bitstream, and compress data to Deflate-
-compatible bitstream, albeit with lower compression ratio than Zlib Deflate
-algorithm (very basic LZ77 compression algorithm is used instead, static
-Deflate Huffman tree encoding is used for bitstream).
-
-uzlib aims for minimal code size and runtime memory requirements, and thus
-suitable for (deeply) embedded systems.
-
-uzlib is based on:
-
-* tinf library by Joergen Ibsen (Deflate decompression)
-* Deflate Static Huffman tree routines by Simon Tatham
-* LZ77 compressor by Paul Sokolovsky
-
-Library integrated and maintained by Paul Sokolovsky.
-
-(c) 2014-2020 Paul Sokolovsky
-
-uzlib library is licensed under Zlib license.
-
-
-Decompressor features
----------------------
-
-Handling of input (compressed) stream:
-
-* Can reside (fully) in memory.
-* Can be received, byte by byte, from an application-defined callback
-  function (which e.g. can read it from file or another I/O device).
-* Combination of the above: a chunk of input is buffered in memory,
-  when buffer is exhausted, the application callback is called to refill
-  it.
-
-Handling of output (decompressed) stream:
-
-* In-memory decompression, where output stream fully resides in memory.
-* Streaming decompression, which allows to process arbitrary-sized streams
-  (longer than available memory), but requires in-memory buffer for Deflate
-  dictionary window.
-* Application specifies number of output bytes it wants to decompress,
-  which can be as high as UINT_MAX to decompress everything into memory
-  at once, or as low as 1 to decompress byte by byte, or any other value
-  to decompress a chunk of that size.
-
-Note that in regard to input stream handling, uzlib employs callback-based,
-"pull-style" design. The control flow looks as follows:
-
-1. Application requests uzlib to decompress given number of bytes.
-2. uzlib performs decompression.
-3. If more input is needed to decompress given number of bytes, uzlib
-   calls back into application to provide more input bytes. (An
-   implication of this is that uzlib will always return given number of
-   output bytes, unless end of stream (or error) happens).
-
-The original Zlib library instead features "push-style" design:
-
-1. An application prepares arbitrary number of input bytes in a buffer,
-   and free space in output buffer, and calls Zlib with these buffers.
-2. Zlib tries to decode as much as possible input and produce as much
-   as possible output. It returns back to the application if input
-   buffer is exhausted, or output buffer is full, whatever happens
-   first.
-
-Currently, uzlib doesn't support push-style operation a-la Zlib.
-
-Compressor features
--------------------
-
-Compressor uses very basic implementation of LZ77 algorithm using hash
-table to find repeating substrings. The size of the hash table (on which
-compression efficiency depends), pointer to the hashtable memory, and
-the size of LZ77 dictionary should be configured in `struct uzlib_comp`.
-
-Currently, compressor doesn't support streaming operation, both input and
-output must reside in memory. Neither it supports incremental operation,
-entire input buffer is compressed at once with a single call to uzlib.
-
-API and configuration
----------------------
-
-The API is defined in the file [uzlib.h](src/uzlib.h) and should be largely
-self-describing. There are also examples implementing gzip-compatible
-compression and decompression applications in [examples/](examples/) for
-further reference. (You may also refer to the original `tinf` README
-below for additional information, but it's mostly provided for
-historical reference, and `uzlib` largely evolved beyond it).
-
-There are some compile-time options for the library, defined in
-the file [uzlib_conf.h](src/uzlib_conf.h). They can be altered directly
-in the file, or passed as the compiler options (`-DXXX=YYY`) when
-building library.
-
-Binary sizes
-------------
-
-To give an impression of code/data sizes of uzlib, the following figures
-are provided. Numbers for *.o files are code sizes of individual
-components (tinflate.o is decompressor, genlz77.o and defl_static.o -
-compressor), and TINF_DATA is the size of the corresponding data
-structure. These numbers are provided for different architectures,
-with default uzlib configuration, and with compilers/their options
-as specified.
-
-```
-gcc -m32 -Os
-gcc (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0
-2891 src/tinflate.o
-381 src/genlz77.o
-1685 src/defl_static.o
-1284 TINF_DATA
-
-arm-none-eabi-gcc -mthumb -mcpu=cortex-m4 -Os
-arm-none-eabi-gcc (GNU Tools for Arm Embedded Processors 9-2019-q4-major) 9.2.1 20191025 (release) [ARM/arm-9-branch revision 277599]
-1620 src/tinflate.o
-180 src/genlz77.o
-1131 src/defl_static.o
-1284 TINF_DATA
-```
-
----
-
-Original tinf library README
-============================
-
-*For historical reference and to provide proper credit, the original `tinf`
-library README follows. NOTE: Many parts no longer apply to `uzlib`. In
-particular, API is different, features supported are largely extended,
-and during decompression, there are checks to avoid erroneous/undefined
-behavior on incorrect Deflate bitstreams.*
-
-tinf - tiny inflate library
-===========================
-
-Version 1.00
-
-Copyright (c) 2003 Joergen Ibsen
-
-<http://www.ibsensoftware.com/>
-
-
-About
------
-
-tinf is a small library implementing the decompression algorithm for the
-deflate compressed data format (called 'inflate'). Deflate compression is
-used in e.g. zlib, gzip, zip and png.
-
-I wrote it because I needed a small in-memory zlib decompressor for a self-
-extracting archive, and the zlib library added 15k to my program. The tinf
-code added only 2k.
-
-Naturally the size difference is insignificant in most cases. Also, the
-zlib library has many more features, is more secure, and mostly faster.
-But if you have a project that calls for a small and simple deflate
-decompressor, give it a try :-)
-
-While the implementation should be fairly compliant, it does assume it is
-given valid compressed data, and that there is sufficient space for the
-decompressed data.
-
-Simple wrappers for decompressing zlib streams and gzip'ed data in memory
-are supplied.
-
-tgunzip, an example command-line gzip decompressor in C, is included.
-
-The inflate algorithm and data format are from 'DEFLATE Compressed Data
-Format Specification version 1.3' ([RFC 1951][1]).
-
-The zlib data format is from 'ZLIB Compressed Data Format Specification
-version 3.3' ([RFC 1950][2]).
-
-The gzip data format is from 'GZIP file format specification version 4.3'
-([RFC 1952][3]).
-
-Ideas for future versions:
-
-- the fixed Huffman trees could be built by `tinf_decode_trees()`
-  using a small table
-- memory for the `TINF_DATA` object should be passed, to avoid using
-  more than 1k of stack space
-- wrappers for unpacking zip archives and png images
-- implement more in x86 assembler
-- more sanity checks
-- in `tinf_uncompress`, the (entry value of) `destLen` and `sourceLen`
-  are not used
-- blocking of some sort, so everything does not have to be in memory
-- optional table-based huffman decoder
-
-[1]: http://www.rfc-editor.org/rfc/rfc1951.txt
-[2]: http://www.rfc-editor.org/rfc/rfc1950.txt
-[3]: http://www.rfc-editor.org/rfc/rfc1952.txt
-
-
-Functionality
--------------
-
-    void tinf_init();
-
-Initialise the global uninitialised data used by the decompression code.
-This function must be called once before any calls to the decompression
-functions.
-
-    int tinf_uncompress(void *dest,
-                        unsigned int *destLen,
-                        const void *source,
-                        unsigned int sourceLen);
-
-Decompress data in deflate compressed format from `source[]` to `dest[]`.
-`destLen` is set to the length of the decompressed data. Returns `TINF_OK`
-on success, and `TINF_DATA_ERROR` on error.
-
-    int tinf_gzip_uncompress(void *dest,
-                             unsigned int *destLen,
-                             const void *source,
-                             unsigned int sourceLen);
-
-Decompress data in gzip compressed format from `source[]` to `dest[]`.
-`destLen` is set to the length of the decompressed data. Returns `TINF_OK`
-on success, and `TINF_DATA_ERROR` on error.
-
-    int tinf_zlib_uncompress(void *dest,
-                             unsigned int *destLen,
-                             const void *source,
-                             unsigned int sourceLen);
-
-Decompress data in zlib compressed format from `source[]` to `dest[]`.
-`destLen` is set to the length of the decompressed data. Returns `TINF_OK`
-on success, and `TINF_DATA_ERROR` on error.
-
-    unsigned int tinf_adler32(const void *data,
-                              unsigned int length);
-
-Computes the Adler-32 checksum of `length` bytes starting at `data`. Used by
-`tinf_zlib_uncompress()`.
-
-    unsigned int tinf_crc32(const void *data,
-                            unsigned int length);
-
-Computes the CRC32 checksum of `length` bytes starting at `data`. Used by
-`tinf_gzip_uncompress()`.
-
-
-Source Code
------------
-
-The source code is ANSI C, and assumes that int is 32-bit. It has been
-tested on the x86 platform under Windows and Linux.
-
-The decompression functions should be endian-neutral, and also reentrant
-and thread-safe (not tested).
-
-In src/nasm there are 32-bit x86 assembler (386+) versions of some of the
-files.
-
-Makefiles (GNU Make style) for a number of compilers are included.
-
-
-Frequently Asked Questions
---------------------------
-
-Q: Is it really free? Can I use it in my commercial ExpenZip software?
-
-A: It's open-source software, available under the zlib license (see
-   later), which means you can use it for free -- even in commercial
-   products. If you do, please be kind enough to add an acknowledgement.
-
-Q: Did you just strip stuff from the zlib source to make it smaller?
-
-A: No, tinf was written from scratch, using the RFC documentation of
-   the formats it supports.
-
-Q: What do you mean by: 'the zlib library .. is more secure'?
-
-A: The zlib decompression code checks the compressed data for validity
-   while decompressing, so even on corrupted data it will not crash.
-   The tinf code assumes it is given valid compressed data.
-
-Q: I'm a Delphi programmer, can I use tinf?
-
-A: Sure, the object files produced by both Borland C and Watcom C should
-   be linkable with Delphi.
-
-Q: Will tinf work on UltraSTRANGE machines running WhackOS?
-
-A: I have no idea .. please try it out and let me know!
-
-Q: Why are all the makefiles in GNU Make style?
-
-A: I'm used to GNU Make, and it has a number of features that are missing
-   in some of the other Make utilities.
-
-Q: This is the first release, how can there be frequently asked questions?
-
-A: Ok, ok .. I made the questions up ;-)
-
-
-License
--------
-
-tinf - tiny inflate library
-
-Copyright (c) 2003 Joergen Ibsen
-
-This software is provided 'as-is', without any express or implied
-warranty. In no event will the authors be held liable for any damages
-arising from the use of this software.
-
-Permission is granted to anyone to use this software for any purpose,
-including commercial applications, and to alter it and redistribute it
-freely, subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must
-   not claim that you wrote the original software. If you use this
-   software in a product, an acknowledgment in the product
-   documentation would be appreciated but is not required.
-
-2. Altered source versions must be plainly marked as such, and must
-   not be misrepresented as being the original software.
-
-3. This notice may not be removed or altered from any source
-   distribution.
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/bin/tgunzip.exe b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/bin/tgunzip.exe
deleted file mode 100644
index d0a9f821..00000000
Binary files a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/bin/tgunzip.exe and /dev/null differ
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/.gitignore b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/.gitignore
deleted file mode 100644
index 37950749..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-tgunzip
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile
deleted file mode 100644
index e15ad716..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile
+++ /dev/null
@@ -1,31 +0,0 @@
-##
-## tgunzip  -  gzip decompressor example
-##
-## GCC makefile (Linux, FreeBSD, BeOS and QNX)
-##
-## Copyright (c) 2003 by Joergen Ibsen / Jibz
-## All Rights Reserved
-##
-## http://www.ibsensoftware.com/
-##
-
-target  = tgunzip
-objects = tgunzip.o
-libs    = ../../lib/libtinf.a
-
-COPT    = -Os
-CFLAGS  = -Wall -I../../src $(COPT)
-LDFLAGS = $(CFLAGS) -s -Wl,-Map,ld.map
-
-.PHONY: all clean
-
-all: $(target)
-
-$(target): $(objects) $(libs)
-	$(CC) $(LDFLAGS) -o $@ $^ $(libs)
-
-%.o : %.c
-	$(CC) $(CFLAGS) -c $<
-
-clean:
-	$(RM) $(objects) $(target)
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile.b32 b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile.b32
deleted file mode 100644
index 7b559c9a..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile.b32
+++ /dev/null
@@ -1,31 +0,0 @@
-##
-## tgunzip  -  gzip decompressor example
-##
-## Borland C/C++ makefile (GNU Make)
-##
-## Copyright (c) 2003 by Joergen Ibsen / Jibz
-## All Rights Reserved
-##
-## http://www.ibsensoftware.com/
-##
-
-target  = tgunzip.exe
-objects = tgunzip.obj
-libs    = ..\..\lib\tinf.lib
-temps   = tgunzip.tds
-
-cflags  = -a16 -K -O2 -OS -I..\..\src
-ldflags = -C -q -Gn -x -Gz -ap -Tpe
-
-.PHONY: all clean
-
-all: $(target)
-
-$(target): $(objects)
-	ilink32 $(ldflags) c0x32 $(objects), $@ , , import32 cw32 $(libs) , ,
-
-%.obj : %.c
-	bcc32 $(cflags) -c $<
-
-clean:
-	$(RM) $(objects) $(target) $(temps)
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile.dj2 b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile.dj2
deleted file mode 100644
index c09312dc..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile.dj2
+++ /dev/null
@@ -1,30 +0,0 @@
-##
-## tgunzip  -  gzip decompressor example
-##
-## DJGPP makefile
-##
-## Copyright (c) 2003 by Joergen Ibsen / Jibz
-## All Rights Reserved
-##
-## http://www.ibsensoftware.com/
-##
-
-target  = tgunzip.exe
-objects = tgunzip.o
-libs    = ../../lib/libtinf.a
-
-cflags   = -s -Wall -Os -fomit-frame-pointer -I../../src
-ldflags  = $(cflags)
-
-.PHONY: all clean
-
-all: $(target)
-
-$(target): $(objects)
-	gcc $(ldflags) -o $@ $^ $(libs)
-
-%.o : %.c
-	gcc $(cflags) -o $@ -c $<
-
-clean:
-	$(RM) $(objects) $(target)
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile.dmc b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile.dmc
deleted file mode 100644
index 4c3d0297..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile.dmc
+++ /dev/null
@@ -1,31 +0,0 @@
-##
-## tgunzip  -  gzip decompressor example
-##
-## Digital Mars C/C++ makefile (GNU Make)
-##
-## Copyright (c) 2003 by Joergen Ibsen / Jibz
-## All Rights Reserved
-##
-## http://www.ibsensoftware.com/
-##
-
-target  = tgunzip.exe
-objects = tgunzip.obj
-libs    = ..\..\lib\tinf.lib
-temps   = tgunzip.map
-
-cflags  = -s -mn -o+all -I..\..\src
-ldflags = $(cflags)
-
-.PHONY: all clean
-
-all: $(target)
-
-$(target): $(objects)
-	dmc $(ldflags) -o$@ $^ $(libs)
-
-%.obj : %.c
-	dmc $(cflags) -c $<
-
-clean:
-	$(RM) $(objects) $(target) $(temps)
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile.mgw b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile.mgw
deleted file mode 100644
index b48b4c10..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile.mgw
+++ /dev/null
@@ -1,28 +0,0 @@
-##
-## tgunzip  -  gzip decompressor example
-##
-## MinGW / Cygwin makefile
-##
-## Copyright (c) 1998-2003 by Joergen Ibsen / Jibz
-## All Rights Reserved
-##
-
-target  = tgunzip.exe
-objects = tgunzip.o
-libs    = ../../lib/libtinf.a
-
-cflags   = -s -Wall -Os -fomit-frame-pointer -I../../src
-ldflags  = $(cflags)
-
-.PHONY: all clean
-
-all: $(target)
-
-$(target): $(objects)
-	gcc $(ldflags) -o $@ $^ $(libs)
-
-%.o : %.c
-	gcc $(cflags) -o $@ -c $<
-
-clean:
-	$(RM) $(target) $(objects)
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile.vc b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile.vc
deleted file mode 100644
index 64dd2e6a..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile.vc
+++ /dev/null
@@ -1,28 +0,0 @@
-##
-## tgunzip  -  gzip decompressor example
-##
-## Visual C/C++ makefile (GNU Make)
-##
-## Copyright (c) 2003 by Joergen Ibsen / Jibz
-## All Rights Reserved
-##
-
-target  = tgunzip.exe
-objects = tgunzip.obj
-libs    = ../../lib/tinf.lib
-
-cflags  = /nologo /W3 /O1 /G6 /W3 /Gy /GF /I..\..\src
-ldflags = /nologo /release /opt:ref /opt:icf
-
-.PHONY: all clean
-
-all: $(target)
-
-$(target): $(objects)
-	link $(ldflags) /out:$@ $^ $(libs)
-
-%.obj : %.c
-	cl $(cflags) -c $<
-
-clean:
-	$(RM) $(target) $(objects)
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile.wat b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile.wat
deleted file mode 100644
index 2d27a985..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/makefile.wat
+++ /dev/null
@@ -1,31 +0,0 @@
-##
-## tgunzip  -  gzip decompressor example
-##
-## Watcom / OpenWatcom C/C++ makefile (GNU Make)
-##
-## Copyright (c) 2003 by Joergen Ibsen / Jibz
-## All Rights Reserved
-##
-## http://www.ibsensoftware.com/
-##
-
-target  = tgunzip.exe
-objects = tgunzip.obj
-libs    = ../../lib/tinf.lib
-system  = nt
-
-cflags  = -bt=$(system) -d0 -ox -I..\..\src
-ldflags = system $(system)
-
-.PHONY: all clean
-
-all: $(target)
-
-$(target): $(objects)
-	wlink $(ldflags) name $@ file {$^} library {$(libs)}
-
-%.obj : %.c
-	wcc386 $(cflags) $<
-
-clean:
-	$(RM) $(objects) $(target)
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/tgunzip.c b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/tgunzip.c
deleted file mode 100644
index 54fdc32f..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgunzip/tgunzip.c
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
- * tgunzip  -  gzip decompressor example
- *
- * Copyright (c) 2003 by Joergen Ibsen / Jibz
- * All Rights Reserved
- *
- * http://www.ibsensoftware.com/
- *
- * Copyright (c) 2014-2016 by Paul Sokolovsky
- *
- * This software is provided 'as-is', without any express
- * or implied warranty.  In no event will the authors be
- * held liable for any damages arising from the use of
- * this software.
- *
- * Permission is granted to anyone to use this software
- * for any purpose, including commercial applications,
- * and to alter it and redistribute it freely, subject to
- * the following restrictions:
- *
- * 1. The origin of this software must not be
- *    misrepresented; you must not claim that you
- *    wrote the original software. If you use this
- *    software in a product, an acknowledgment in
- *    the product documentation would be appreciated
- *    but is not required.
- *
- * 2. Altered source versions must be plainly marked
- *    as such, and must not be misrepresented as
- *    being the original software.
- *
- * 3. This notice may not be removed or altered from
- *    any source distribution.
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-
-#include "uzlib.h"
-
-/* produce decompressed output in chunks of this size */
-/* default is to decompress byte by byte; can be any other length */
-#define OUT_CHUNK_SIZE 1
-
-void exit_error(const char *what)
-{
-   printf("ERROR: %s\n", what);
-   exit(1);
-}
-
-int main(int argc, char *argv[])
-{
-    FILE *fin, *fout;
-    unsigned int len, dlen, outlen;
-    const unsigned char *source;
-    unsigned char *dest;
-    int res;
-
-    printf("tgunzip - example from the tiny inflate library (www.ibsensoftware.com)\n\n");
-
-    if (argc < 3)
-    {
-       printf(
-          "Syntax: tgunzip <source> <destination>\n\n"
-          "Both input and output are kept in memory, so do not use this on huge files.\n");
-
-       return 1;
-    }
-
-    uzlib_init();
-
-    /* -- open files -- */
-
-    if ((fin = fopen(argv[1], "rb")) == NULL) exit_error("source file");
-
-    if ((fout = fopen(argv[2], "wb")) == NULL) exit_error("destination file");
-
-    /* -- read source -- */
-
-    fseek(fin, 0, SEEK_END);
-
-    len = ftell(fin);
-
-    fseek(fin, 0, SEEK_SET);
-
-    source = (unsigned char *)malloc(len);
-
-    if (source == NULL) exit_error("memory");
-
-    if (fread((unsigned char*)source, 1, len, fin) != len) exit_error("read");
-
-    fclose(fin);
-
-    if (len < 4) exit_error("file too small");
-
-    /* -- get decompressed length -- */
-
-    dlen =            source[len - 1];
-    dlen = 256*dlen + source[len - 2];
-    dlen = 256*dlen + source[len - 3];
-    dlen = 256*dlen + source[len - 4];
-
-    outlen = dlen;
-
-    /* there can be mismatch between length in the trailer and actual
-       data stream; to avoid buffer overruns on overlong streams, reserve
-       one extra byte */
-    dlen++;
-
-    dest = (unsigned char *)malloc(dlen);
-
-    if (dest == NULL) exit_error("memory");
-
-    /* -- decompress data -- */
-
-    struct uzlib_uncomp d;
-//    uzlib_uncompress_init(&d, malloc(32768), 32768);
-    uzlib_uncompress_init(&d, NULL, 0);
-
-    /* all 3 fields below must be initialized by user */
-    d.source = source;
-    d.source_limit = source + len - 4;
-    d.source_read_cb = NULL;
-
-    res = uzlib_gzip_parse_header(&d);
-    if (res != TINF_OK) {
-        printf("Error parsing header: %d\n", res);
-        exit(1);
-    }
-
-    d.dest_start = d.dest = dest;
-
-    while (dlen) {
-        unsigned int chunk_len = dlen < OUT_CHUNK_SIZE ? dlen : OUT_CHUNK_SIZE;
-        d.dest_limit = d.dest + chunk_len;
-        res = uzlib_uncompress_chksum(&d);
-        dlen -= chunk_len;
-        if (res != TINF_OK) {
-            break;
-        }
-    }
-
-    if (res != TINF_DONE) {
-        printf("Error during decompression: %d\n", res);
-        exit(-res);
-    }
-
-    printf("decompressed %lu bytes\n", d.dest - dest);
-
-#if 0
-    if (d.dest - dest != gz.dlen) {
-        printf("Invalid decompressed length: %lu vs %u\n", d.dest - dest, gz.dlen);
-    }
-
-    if (tinf_crc32(dest, gz.dlen) != gz.crc32) {
-        printf("Invalid decompressed crc32\n");
-    }
-#endif
-
-    /* -- write output -- */
-
-    fwrite(dest, 1, outlen, fout);
-
-    fclose(fout);
-
-    return 0;
-}
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgzip/.gitignore b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgzip/.gitignore
deleted file mode 100644
index 98ea6d9f..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgzip/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-tgzip
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgzip/makefile b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgzip/makefile
deleted file mode 100644
index 1e28ece0..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgzip/makefile
+++ /dev/null
@@ -1,31 +0,0 @@
-##
-## tgzip  -  gzip compressor example
-##
-## GCC makefile (Linux, FreeBSD, BeOS and QNX)
-##
-## Copyright (c) 2003 by Joergen Ibsen / Jibz
-## Copyright (c) 2014 by Paul Sokolovsky
-##
-## http://www.ibsensoftware.com/
-##
-
-target  = tgzip
-objects = tgzip.o
-libs    = ../../lib/libtinf.a
-
-COPT    = -Os
-CFLAGS  = -Wall -I../../src $(COPT)
-LDFLAGS = $(CFLAGS) -s -Wl,-Map,ld.map
-
-.PHONY: all clean
-
-all: $(target)
-
-$(target): $(objects) $(libs)
-	$(CC) $(LDFLAGS) -o $@ $^ $(libs)
-
-%.o : %.c
-	$(CC) $(CFLAGS) -c $<
-
-clean:
-	$(RM) $(objects) $(target)
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgzip/tgzip.c b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgzip/tgzip.c
deleted file mode 100644
index d869d384..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/examples/tgzip/tgzip.c
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
- * tgzip  -  gzip compressor example
- *
- * Copyright (c) 2003 by Joergen Ibsen / Jibz
- * Copyright (c) 2014-2018 by Paul Sokolovsky
- *
- * http://www.ibsensoftware.com/
- *
- * This software is provided 'as-is', without any express
- * or implied warranty.  In no event will the authors be
- * held liable for any damages arising from the use of
- * this software.
- *
- * Permission is granted to anyone to use this software
- * for any purpose, including commercial applications,
- * and to alter it and redistribute it freely, subject to
- * the following restrictions:
- *
- * 1. The origin of this software must not be
- *    misrepresented; you must not claim that you
- *    wrote the original software. If you use this
- *    software in a product, an acknowledgment in
- *    the product documentation would be appreciated
- *    but is not required.
- *
- * 2. Altered source versions must be plainly marked
- *    as such, and must not be misrepresented as
- *    being the original software.
- *
- * 3. This notice may not be removed or altered from
- *    any source distribution.
- */
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-
-#include "uzlib.h"
-
-void exit_error(const char *what)
-{
-   printf("ERROR: %s\n", what);
-   exit(1);
-}
-
-int main(int argc, char *argv[])
-{
-    FILE *fin, *fout;
-    unsigned int len;
-    unsigned char *source;
-
-    printf("tgzip - example from the uzlib library\n\n");
-
-    if (argc < 3)
-    {
-       printf(
-          "Syntax: tgunzip <source> <destination>\n\n"
-          "Both input and output are kept in memory, so do not use this on huge files.\n");
-
-       return 1;
-    }
-
-    /* -- open files -- */
-
-    if ((fin = fopen(argv[1], "rb")) == NULL) exit_error("source file");
-
-    if ((fout = fopen(argv[2], "wb")) == NULL) exit_error("destination file");
-
-    /* -- read source -- */
-
-    fseek(fin, 0, SEEK_END);
-
-    len = ftell(fin);
-
-    fseek(fin, 0, SEEK_SET);
-
-    source = (unsigned char *)malloc(len);
-
-    if (source == NULL) exit_error("memory");
-
-    if (fread(source, 1, len, fin) != len) exit_error("read");
-
-    fclose(fin);
-
-    /* -- compress data -- */
-
-    struct uzlib_comp comp = {0};
-    comp.dict_size = 32768;
-    comp.hash_bits = 12;
-    size_t hash_size = sizeof(uzlib_hash_entry_t) * (1 << comp.hash_bits);
-    comp.hash_table = malloc(hash_size);
-    memset(comp.hash_table, 0, hash_size);
-
-    zlib_start_block(&comp);
-    uzlib_compress(&comp, source, len);
-    zlib_finish_block(&comp);
-
-    printf("compressed to %u raw bytes\n", comp.outlen);
-
-    /* -- write output -- */
-
-    putc(0x1f, fout);
-    putc(0x8b, fout);
-    putc(0x08, fout);
-    putc(0x00, fout); // FLG
-    int mtime = 0;
-    fwrite(&mtime, sizeof(mtime), 1, fout);
-    putc(0x04, fout); // XFL
-    putc(0x03, fout); // OS
-
-    fwrite(comp.outbuf, 1, comp.outlen, fout);
-
-    unsigned crc = ~uzlib_crc32(source, len, ~0);
-    fwrite(&crc, sizeof(crc), 1, fout);
-    fwrite(&len, sizeof(len), 1, fout);
-
-    fclose(fout);
-
-    return 0;
-}
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/lib/empty.dir b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/lib/empty.dir
deleted file mode 100644
index 70062289..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/lib/empty.dir
+++ /dev/null
@@ -1 +0,0 @@
---- empty dir ---
\ No newline at end of file
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/adler32.c b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/adler32.c
deleted file mode 100644
index 5ee7b6cf..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/adler32.c
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Adler-32 checksum
- *
- * Copyright (c) 2003 by Joergen Ibsen / Jibz
- * All Rights Reserved
- *
- * http://www.ibsensoftware.com/
- *
- * This software is provided 'as-is', without any express
- * or implied warranty.  In no event will the authors be
- * held liable for any damages arising from the use of
- * this software.
- *
- * Permission is granted to anyone to use this software
- * for any purpose, including commercial applications,
- * and to alter it and redistribute it freely, subject to
- * the following restrictions:
- *
- * 1. The origin of this software must not be
- *    misrepresented; you must not claim that you
- *    wrote the original software. If you use this
- *    software in a product, an acknowledgment in
- *    the product documentation would be appreciated
- *    but is not required.
- *
- * 2. Altered source versions must be plainly marked
- *    as such, and must not be misrepresented as
- *    being the original software.
- *
- * 3. This notice may not be removed or altered from
- *    any source distribution.
- */
-
-/*
- * Adler-32 algorithm taken from the zlib source, which is
- * Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler
- */
-
-#include "tinf.h"
-
-#define A32_BASE 65521
-#define A32_NMAX 5552
-
-uint32_t uzlib_adler32(const void *data, unsigned int length, uint32_t prev_sum /* 1 */)
-{
-   const unsigned char *buf = (const unsigned char *)data;
-
-   unsigned int s1 = prev_sum & 0xffff;
-   unsigned int s2 = prev_sum >> 16;
-
-   while (length > 0)
-   {
-      int k = length < A32_NMAX ? length : A32_NMAX;
-      int i;
-
-      for (i = k / 16; i; --i, buf += 16)
-      {
-         s1 += buf[0];  s2 += s1; s1 += buf[1];  s2 += s1;
-         s1 += buf[2];  s2 += s1; s1 += buf[3];  s2 += s1;
-         s1 += buf[4];  s2 += s1; s1 += buf[5];  s2 += s1;
-         s1 += buf[6];  s2 += s1; s1 += buf[7];  s2 += s1;
-
-         s1 += buf[8];  s2 += s1; s1 += buf[9];  s2 += s1;
-         s1 += buf[10]; s2 += s1; s1 += buf[11]; s2 += s1;
-         s1 += buf[12]; s2 += s1; s1 += buf[13]; s2 += s1;
-         s1 += buf[14]; s2 += s1; s1 += buf[15]; s2 += s1;
-      }
-
-      for (i = k % 16; i; --i) { s1 += *buf++; s2 += s1; }
-
-      s1 %= A32_BASE;
-      s2 %= A32_BASE;
-
-      length -= k;
-   }
-
-   return ((uint32_t)s2 << 16) | s1;
-}
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/crc32.c b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/crc32.c
deleted file mode 100644
index 10231181..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/crc32.c
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * CRC32 checksum
- *
- * Copyright (c) 1998-2003 by Joergen Ibsen / Jibz
- * All Rights Reserved
- *
- * http://www.ibsensoftware.com/
- *
- * This software is provided 'as-is', without any express
- * or implied warranty.  In no event will the authors be
- * held liable for any damages arising from the use of
- * this software.
- *
- * Permission is granted to anyone to use this software
- * for any purpose, including commercial applications,
- * and to alter it and redistribute it freely, subject to
- * the following restrictions:
- *
- * 1. The origin of this software must not be
- *    misrepresented; you must not claim that you
- *    wrote the original software. If you use this
- *    software in a product, an acknowledgment in
- *    the product documentation would be appreciated
- *    but is not required.
- *
- * 2. Altered source versions must be plainly marked
- *    as such, and must not be misrepresented as
- *    being the original software.
- *
- * 3. This notice may not be removed or altered from
- *    any source distribution.
- */
-
-/*
- * CRC32 algorithm taken from the zlib source, which is
- * Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler
- */
-
-#include "tinf.h"
-
-static const uint32_t tinf_crc32tab[16] = {
-   0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 0x76dc4190,
-   0x6b6b51f4, 0x4db26158, 0x5005713c, 0xedb88320, 0xf00f9344,
-   0xd6d6a3e8, 0xcb61b38c, 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278,
-   0xbdbdf21c
-};
-
-/* crc is previous value for incremental computation, 0xffffffff initially */
-uint32_t uzlib_crc32(const void *data, unsigned int length, uint32_t crc)
-{
-   const unsigned char *buf = (const unsigned char *)data;
-   unsigned int i;
-
-   for (i = 0; i < length; ++i)
-   {
-      crc ^= buf[i];
-      crc = tinf_crc32tab[crc & 0x0f] ^ (crc >> 4);
-      crc = tinf_crc32tab[crc & 0x0f] ^ (crc >> 4);
-   }
-
-   // return value suitable for passing in next time, for final value invert it
-   return crc/* ^ 0xffffffff*/;
-}
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/defl_static.c b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/defl_static.c
deleted file mode 100644
index d6578b2c..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/defl_static.c
+++ /dev/null
@@ -1,318 +0,0 @@
-/*
-
-Routines in this file are based on:
-Zlib (RFC1950 / RFC1951) compression for PuTTY.
-
-PuTTY is copyright 1997-2014 Simon Tatham.
-
-Portions copyright Robert de Bath, Joris van Rantwijk, Delian
-Delchev, Andreas Schultz, Jeroen Massar, Wez Furlong, Nicolas Barry,
-Justin Bradford, Ben Harris, Malcolm Smith, Ahmad Khalifa, Markus
-Kuhn, Colin Watson, and CORE SDI S.A.
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation files
-(the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of the Software,
-and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE
-FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
-CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <string.h>
-#include <assert.h>
-#include "uzlib.h"
-#include "defl_static.h"
-
-#define snew(type) ( (type *) malloc(sizeof(type)) )
-#define snewn(n, type) ( (type *) malloc((n) * sizeof(type)) )
-#define sresize(x, n, type) ( (type *) realloc((x), (n) * sizeof(type)) )
-#define sfree(x) ( free((x)) )
-
-#ifndef FALSE
-#define FALSE 0
-#define TRUE (!FALSE)
-#endif
-
-/* ----------------------------------------------------------------------
- * Zlib compression. We always use the static Huffman tree option.
- * Mostly this is because it's hard to scan a block in advance to
- * work out better trees; dynamic trees are great when you're
- * compressing a large file under no significant time constraint,
- * but when you're compressing little bits in real time, things get
- * hairier.
- * 
- * I suppose it's possible that I could compute Huffman trees based
- * on the frequencies in the _previous_ block, as a sort of
- * heuristic, but I'm not confident that the gain would balance out
- * having to transmit the trees.
- */
-
-void outbits(struct uzlib_comp *out, unsigned long bits, int nbits)
-{
-    assert(out->noutbits + nbits <= 32);
-    out->outbits |= bits << out->noutbits;
-    out->noutbits += nbits;
-    while (out->noutbits >= 8) {
-        if (out->outlen >= out->outsize) {
-            out->outsize = out->outlen + 64;
-            out->outbuf = sresize(out->outbuf, out->outsize, unsigned char);
-        }
-        out->outbuf[out->outlen++] = (unsigned char) (out->outbits & 0xFF);
-        out->outbits >>= 8;
-        out->noutbits -= 8;
-    }
-}
-
-static const unsigned char mirrorbytes[256] = {
-    0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
-    0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
-    0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
-    0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
-    0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
-    0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
-    0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
-    0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
-    0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
-    0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
-    0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
-    0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
-    0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
-    0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
-    0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
-    0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
-    0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
-    0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
-    0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
-    0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
-    0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
-    0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
-    0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
-    0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
-    0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
-    0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
-    0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
-    0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
-    0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
-    0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
-    0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
-    0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
-};
-
-typedef struct {
-    uint8_t extrabits;
-    uint8_t min, max;
-} len_coderecord;
-
-typedef struct {
-    uint8_t code, extrabits;
-    uint16_t min, max;
-} dist_coderecord;
-
-#define TO_LCODE(x, y) x - 3, y - 3
-#define FROM_LCODE(x) (x + 3)
-
-static const len_coderecord lencodes[] = {
-    {0, TO_LCODE(3, 3)},
-    {0, TO_LCODE(4, 4)},
-    {0, TO_LCODE(5, 5)},
-    {0, TO_LCODE(6, 6)},
-    {0, TO_LCODE(7, 7)},
-    {0, TO_LCODE(8, 8)},
-    {0, TO_LCODE(9, 9)},
-    {0, TO_LCODE(10, 10)},
-    {1, TO_LCODE(11, 12)},
-    {1, TO_LCODE(13, 14)},
-    {1, TO_LCODE(15, 16)},
-    {1, TO_LCODE(17, 18)},
-    {2, TO_LCODE(19, 22)},
-    {2, TO_LCODE(23, 26)},
-    {2, TO_LCODE(27, 30)},
-    {2, TO_LCODE(31, 34)},
-    {3, TO_LCODE(35, 42)},
-    {3, TO_LCODE(43, 50)},
-    {3, TO_LCODE(51, 58)},
-    {3, TO_LCODE(59, 66)},
-    {4, TO_LCODE(67, 82)},
-    {4, TO_LCODE(83, 98)},
-    {4, TO_LCODE(99, 114)},
-    {4, TO_LCODE(115, 130)},
-    {5, TO_LCODE(131, 162)},
-    {5, TO_LCODE(163, 194)},
-    {5, TO_LCODE(195, 226)},
-    {5, TO_LCODE(227, 257)},
-    {0, TO_LCODE(258, 258)},
-};
-
-static const dist_coderecord distcodes[] = {
-    {0, 0, 1, 1},
-    {1, 0, 2, 2},
-    {2, 0, 3, 3},
-    {3, 0, 4, 4},
-    {4, 1, 5, 6},
-    {5, 1, 7, 8},
-    {6, 2, 9, 12},
-    {7, 2, 13, 16},
-    {8, 3, 17, 24},
-    {9, 3, 25, 32},
-    {10, 4, 33, 48},
-    {11, 4, 49, 64},
-    {12, 5, 65, 96},
-    {13, 5, 97, 128},
-    {14, 6, 129, 192},
-    {15, 6, 193, 256},
-    {16, 7, 257, 384},
-    {17, 7, 385, 512},
-    {18, 8, 513, 768},
-    {19, 8, 769, 1024},
-    {20, 9, 1025, 1536},
-    {21, 9, 1537, 2048},
-    {22, 10, 2049, 3072},
-    {23, 10, 3073, 4096},
-    {24, 11, 4097, 6144},
-    {25, 11, 6145, 8192},
-    {26, 12, 8193, 12288},
-    {27, 12, 12289, 16384},
-    {28, 13, 16385, 24576},
-    {29, 13, 24577, 32768},
-};
-
-void zlib_literal(struct uzlib_comp *out, unsigned char c)
-{
-    if (out->comp_disabled) {
-        /*
-         * We're in an uncompressed block, so just output the byte.
-         */
-        outbits(out, c, 8);
-        return;
-    }
-
-    if (c <= 143) {
-        /* 0 through 143 are 8 bits long starting at 00110000. */
-        outbits(out, mirrorbytes[0x30 + c], 8);
-    } else {
-        /* 144 through 255 are 9 bits long starting at 110010000. */
-        outbits(out, 1 + 2 * mirrorbytes[0x90 - 144 + c], 9);
-    }
-}
-
-void zlib_match(struct uzlib_comp *out, int distance, int len)
-{
-    const dist_coderecord *d;
-    const len_coderecord *l;
-    int i, j, k;
-    int lcode;
-
-    assert(!out->comp_disabled);
-
-    while (len > 0) {
-        int thislen;
-
-        /*
-         * We can transmit matches of lengths 3 through 258
-         * inclusive. So if len exceeds 258, we must transmit in
-         * several steps, with 258 or less in each step.
-         * 
-         * Specifically: if len >= 261, we can transmit 258 and be
-         * sure of having at least 3 left for the next step. And if
-         * len <= 258, we can just transmit len. But if len == 259
-         * or 260, we must transmit len-3.
-         */
-        thislen = (len > 260 ? 258 : len <= 258 ? len : len - 3);
-        len -= thislen;
-
-        /*
-         * Binary-search to find which length code we're
-         * transmitting.
-         */
-        i = -1;
-        j = sizeof(lencodes) / sizeof(*lencodes);
-        while (1) {
-            assert(j - i >= 2);
-            k = (j + i) / 2;
-            if (thislen < FROM_LCODE(lencodes[k].min))
-                j = k;
-            else if (thislen > FROM_LCODE(lencodes[k].max))
-                i = k;
-            else {
-                l = &lencodes[k];
-                break;                 /* found it! */
-            }
-        }
-
-        lcode = l - lencodes + 257;
-
-        /*
-         * Transmit the length code. 256-279 are seven bits
-         * starting at 0000000; 280-287 are eight bits starting at
-         * 11000000.
-         */
-        if (lcode <= 279) {
-            outbits(out, mirrorbytes[(lcode - 256) * 2], 7);
-        } else {
-            outbits(out, mirrorbytes[0xc0 - 280 + lcode], 8);
-        }
-
-        /*
-         * Transmit the extra bits.
-         */
-        if (l->extrabits)
-            outbits(out, thislen - FROM_LCODE(l->min), l->extrabits);
-
-        /*
-         * Binary-search to find which distance code we're
-         * transmitting.
-         */
-        i = -1;
-        j = sizeof(distcodes) / sizeof(*distcodes);
-        while (1) {
-            assert(j - i >= 2);
-            k = (j + i) / 2;
-            if (distance < distcodes[k].min)
-                j = k;
-            else if (distance > distcodes[k].max)
-                i = k;
-            else {
-                d = &distcodes[k];
-                break;                 /* found it! */
-            }
-        }
-
-        /*
-         * Transmit the distance code. Five bits starting at 00000.
-         */
-        outbits(out, mirrorbytes[d->code * 8], 5);
-
-        /*
-         * Transmit the extra bits.
-         */
-        if (d->extrabits)
-            outbits(out, distance - d->min, d->extrabits);
-    }
-}
-
-void zlib_start_block(struct uzlib_comp *out)
-{
-//    outbits(out, 0x9C78, 16);
-    outbits(out, 1, 1); /* Final block */
-    outbits(out, 1, 2); /* Static huffman block */
-}
-
-void zlib_finish_block(struct uzlib_comp *out)
-{
-    outbits(out, 0, 7); /* close block */
-    outbits(out, 0, 7); /* Make sure all bits are flushed */
-}
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/defl_static.h b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/defl_static.h
deleted file mode 100644
index cdfa973b..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/defl_static.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) uzlib authors
- *
- * This software is provided 'as-is', without any express
- * or implied warranty.  In no event will the authors be
- * held liable for any damages arising from the use of
- * this software.
- *
- * Permission is granted to anyone to use this software
- * for any purpose, including commercial applications,
- * and to alter it and redistribute it freely, subject to
- * the following restrictions:
- *
- * 1. The origin of this software must not be
- *    misrepresented; you must not claim that you
- *    wrote the original software. If you use this
- *    software in a product, an acknowledgment in
- *    the product documentation would be appreciated
- *    but is not required.
- *
- * 2. Altered source versions must be plainly marked
- *    as such, and must not be misrepresented as
- *    being the original software.
- *
- * 3. This notice may not be removed or altered from
- *    any source distribution.
- */
-
-/* This files contains type declaration and prototypes for defl_static.c.
-   They may be altered/distinct from the originals used in PuTTY source
-   code. */
-
-void outbits(struct uzlib_comp *ctx, unsigned long bits, int nbits);
-void zlib_start_block(struct uzlib_comp *ctx);
-void zlib_finish_block(struct uzlib_comp *ctx);
-void zlib_literal(struct uzlib_comp *ctx, unsigned char c);
-void zlib_match(struct uzlib_comp *ctx, int distance, int len);
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/genlz77.c b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/genlz77.c
deleted file mode 100644
index ede1fc9e..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/genlz77.c
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * genlz77  -  Generic LZ77 compressor
- *
- * Copyright (c) 2014 by Paul Sokolovsky
- *
- * This software is provided 'as-is', without any express
- * or implied warranty.  In no event will the authors be
- * held liable for any damages arising from the use of
- * this software.
- *
- * Permission is granted to anyone to use this software
- * for any purpose, including commercial applications,
- * and to alter it and redistribute it freely, subject to
- * the following restrictions:
- *
- * 1. The origin of this software must not be
- *    misrepresented; you must not claim that you
- *    wrote the original software. If you use this
- *    software in a product, an acknowledgment in
- *    the product documentation would be appreciated
- *    but is not required.
- *
- * 2. Altered source versions must be plainly marked
- *    as such, and must not be misrepresented as
- *    being the original software.
- *
- * 3. This notice may not be removed or altered from
- *    any source distribution.
- */
-#include <stdint.h>
-#include <string.h>
-#include <stdio.h>
-#include "uzlib.h"
-
-#if 0
-#define HASH_BITS 12
-#else
-#define HASH_BITS data->hash_bits
-#endif
-
-#define HASH_SIZE (1<<HASH_BITS)
-
-/* Minimum and maximum length of matches to look for, inclusive */
-#define MIN_MATCH 3
-#define MAX_MATCH 258
-
-/* Max offset of the match to look for, inclusive */
-#if 0
-#define MAX_OFFSET 32768
-#else
-#define MAX_OFFSET data->dict_size
-#endif
-
-/* Hash function can be defined as macro or as inline function */
-
-/*#define HASH(p) (p[0] + p[1] + p[2])*/
-
-/* This is hash function from liblzf */
-static inline int HASH(struct uzlib_comp *data, const uint8_t *p) {
-    int v = (p[0] << 16) | (p[1] << 8) | p[2];
-    int hash = ((v >> (3*8 - HASH_BITS)) - v) & (HASH_SIZE - 1);
-    return hash;
-}
-
-#ifdef DUMP_LZTXT
-
-/* Counter for approximate compressed length in LZTXT mode. */
-/* Literal is counted as 1, copy as 2 bytes. */
-unsigned approx_compressed_len;
-
-void literal(void *data, uint8_t val)
-{
-    printf("L%02x # %c\n", val, (val >= 0x20 && val <= 0x7e) ? val : '?');
-    approx_compressed_len++;
-}
-
-void copy(void *data, unsigned offset, unsigned len)
-{
-    printf("C-%u,%u\n", offset, len);
-    approx_compressed_len += 2;
-}
-
-#else
-
-static inline void literal(void *data, uint8_t val)
-{
-    zlib_literal(data, val);
-}
-
-static inline void copy(void *data, unsigned offset, unsigned len)
-{
-    zlib_match(data, offset, len);
-}
-
-#endif
-
-
-void uzlib_compress(struct uzlib_comp *data, const uint8_t *src, unsigned slen)
-{
-    const uint8_t *top = src + slen - MIN_MATCH;
-    while (src < top) {
-        int h = HASH(data, src);
-        const uint8_t **bucket = &data->hash_table[h & (HASH_SIZE - 1)];
-        const uint8_t *subs = *bucket;
-        *bucket = src;
-        if (subs && src > subs && (src - subs) <= MAX_OFFSET && !memcmp(src, subs, MIN_MATCH)) {
-            src += MIN_MATCH;
-            const uint8_t *m = subs + MIN_MATCH;
-            int len = MIN_MATCH;
-            while (*src == *m && len < MAX_MATCH && src < top) {
-                src++; m++; len++;
-            }
-            copy(data, src - len - subs, len);
-        } else {
-            literal(data, *src++);
-        }
-    }
-    // Process buffer tail, which is less than MIN_MATCH
-    // (and so it doesn't make sense to look for matches there)
-    top += MIN_MATCH;
-    while (src < top) {
-        literal(data, *src++);
-    }
-}
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile
deleted file mode 100644
index 3ced616f..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile
+++ /dev/null
@@ -1,36 +0,0 @@
-##
-## tinflib  -  tiny inflate library (inflate, gzip, zlib)
-##
-## GCC makefile (Linux, FreeBSD, BeOS and QNX)
-##
-## Copyright (c) 2003 by Joergen Ibsen / Jibz
-## All Rights Reserved
-##
-## http://www.ibsensoftware.com/
-##
-
-target  = ../lib/libtinf.a
-objects = tinflate.o tinfgzip.o tinfzlib.o adler32.o crc32.o \
-    defl_static.o genlz77.o
-
-COPT    = -Os
-CFLAGS  = -Wall $(COPT)
-LDFLAGS = $(CFLAGS) -s
-
-.PHONY: all clean
-
-all: $(target)
-
-$(target): $(objects)
-	$(RM) $@
-	ar -frs $@ $^
-	ranlib $@
-
-%.o : %.c
-	$(CC) $(CFLAGS) -o $@ -c $<
-
-%.o : %.nas
-	nasm -o $@ -f elf -D_ELF_ -O3 -Inasm/ $<
-
-clean:
-	$(RM) $(objects) $(target)
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile.b32 b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile.b32
deleted file mode 100644
index 52e17162..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile.b32
+++ /dev/null
@@ -1,34 +0,0 @@
-##
-## tinflib  -  tiny inflate library (inflate, gzip, zlib)
-##
-## Borland C/C++ makefile (GNU Make)
-##
-## Copyright (c) 2003 by Joergen Ibsen / Jibz
-## All Rights Reserved
-##
-## http://www.ibsensoftware.com/
-##
-
-target  = ..\lib\tinf.lib
-objects = tinflate.obj tinfgzip.obj tinfzlib.obj adler32.obj crc32.obj
-
-cflags  = -a16 -K -O2 -OS
-
-.PHONY: all clean
-
-all: $(target)
-
-$(target): $(objects)
-	$(RM) $@
-	echo $(patsubst %,+%,$(objects)) >> lib.cmd
-	tlib $@ /C @lib.cmd
-	$(RM) lib.cmd
-
-%.obj : %.c
-	bcc32 $(cflags) -c $<
-
-%.obj : %.nas
-	nasm -o $@ -f obj -D_OBJ_ -O3 -Inasm/ $<
-
-clean:
-	$(RM) $(objects) $(target) $(temps)
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile.dj2 b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile.dj2
deleted file mode 100644
index 856ecfd6..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile.dj2
+++ /dev/null
@@ -1,33 +0,0 @@
-##
-## tinflib  -  tiny inflate library (inflate, gzip, zlib)
-##
-## DJGPP makefile
-##
-## Copyright (c) 2003 by Joergen Ibsen / Jibz
-## All Rights Reserved
-##
-## http://www.ibsensoftware.com/
-##
-
-target  = ../lib/libtinf.a
-objects = tinflate.o tinfgzip.o tinfzlib.o adler32.o crc32.o
-
-cflags  = -s -Wall -Os -fomit-frame-pointer
-
-.PHONY: all clean
-
-all: $(target)
-
-$(target): $(objects)
-	$(RM) $@
-	ar -frsv $@ $^
-	ranlib $@
-
-%.o : %.c
-	gcc $(cflags) -o $@ -c $<
-
-%.o : %.nas
-	nasm -o $@ -f coff -O3 -Inasm/ $<
-
-clean:
-	$(RM) $(objects) $(target)
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile.dmc b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile.dmc
deleted file mode 100644
index 7629b8f3..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile.dmc
+++ /dev/null
@@ -1,32 +0,0 @@
-##
-## tinflib  -  tiny inflate library (inflate, gzip, zlib)
-##
-## Digital Mars C/C++ makefile (GNU Make)
-##
-## Copyright (c) 2003 by Joergen Ibsen / Jibz
-## All Rights Reserved
-##
-## http://www.ibsensoftware.com/
-##
-
-target  = ..\lib\tinf.lib
-objects = tinflate.obj tinfgzip.obj tinfzlib.obj adler32.obj crc32.obj
-
-cflags  = -s -mn -o+all
-
-.PHONY: all clean
-
-all: $(target)
-
-$(target): $(objects)
-	$(RM) $@
-	lib -c $@ $^
-
-%.obj : %.c
-	dmc $(cflags) -c $<
-
-%.obj : %.nas
-	nasm -o $@ -f obj -D_OBJ_ -O3 $<
-
-clean:
-	$(RM) $(objects) $(target) $(temps)
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile.mgw b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile.mgw
deleted file mode 100644
index 020f1853..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile.mgw
+++ /dev/null
@@ -1,31 +0,0 @@
-##
-## tinflib  -  tiny inflate library (inflate, gzip, zlib)
-##
-## MinGW / Cygwin makefile
-##
-## Copyright (c) 2003 by Joergen Ibsen / Jibz
-## All Rights Reserved
-##
-
-target  = ../lib/libtinf.a
-objects = tinflate.o tinfgzip.o tinfzlib.o adler32.o crc32.o
-
-cflags  = -s -Wall -Os -fomit-frame-pointer
-
-.PHONY: all clean
-
-all: $(target)
-
-$(target): $(objects)
-	$(RM) $@
-	ar -frsv $@ $^
-	ranlib $@
-
-%.o : %.c
-	gcc $(cflags) -o $@ -c $<
-
-%.o : %.nas
-	nasm -o $@ -f win32 -O3 -Inasm/ $<
-
-clean:
-	$(RM) $(target) $(objects)
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile.vc b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile.vc
deleted file mode 100644
index de37a20d..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile.vc
+++ /dev/null
@@ -1,30 +0,0 @@
-##
-## tinflib  -  tiny inflate library (inflate, gzip, zlib)
-##
-## Visual C++ Makefile (GNU Make)
-##
-## Copyright (c) 2003 by Joergen Ibsen / Jibz
-## All Rights Reserved
-##
-
-target  = ../lib/tinf.lib
-objects = tinflate.obj tinfgzip.obj tinfzlib.obj adler32.obj crc32.obj
-
-cflags  = /nologo /W3 /O1 /G6 /W3 /Gy /GF
-
-.PHONY: all clean
-
-all: $(target)
-
-$(target): $(objects)
-	$(RM) $@
-	lib /OUT:$@ $^
-
-%.obj : %.c
-	cl $(cflags) -c $<
-
-%.obj : %.nas
-	nasm -o $@ -f win32 -O3 -Inasm/ $<
-
-clean:
-	$(RM) $(target) $(objects)
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile.wat b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile.wat
deleted file mode 100644
index 573fb2d4..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/makefile.wat
+++ /dev/null
@@ -1,35 +0,0 @@
-##
-## tinflib  -  tiny inflate library (inflate, gzip, zlib)
-##
-## Watcom / OpenWatcom C/C++ makefile (GNU Make)
-##
-## Copyright (c) 2003 by Joergen Ibsen / Jibz
-## All Rights Reserved
-##
-## http://www.ibsensoftware.com/
-##
-
-target  = ..\lib\tinf.lib
-objects = tinflate.obj tinfgzip.obj tinfzlib.obj adler32.obj crc32.obj
-system  = nt
-
-cflags  = -bt=$(system) -d0 -obmlrs -s -zl
-
-.PHONY: all clean
-
-all: $(target)
-
-$(target): $(objects)
-	$(RM) $@
-	echo $(patsubst %,+%,$(objects)) >> lib.cmd
-	wlib -c -n -q -s -fo -io $@ @lib.cmd
-	$(RM) lib.cmd
-
-%.obj : %.c
-	wcc386 $(cflags) $<
-
-%.obj : %.nas
-	nasm -o $@ -f obj -D_OBJ_ -O3 -Inasm/ $<
-
-clean:
-	$(RM) $(objects) $(target)
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/nasm/crc32.nas b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/nasm/crc32.nas
deleted file mode 100644
index bd91692b..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/nasm/crc32.nas
+++ /dev/null
@@ -1,118 +0,0 @@
-;;
-;; NASM assembler crc32
-;;
-;; Copyright (c) 1998-2003 by Joergen Ibsen / Jibz
-;; All Rights Reserved
-;;
-;; http://www.ibsensoftware.com/
-;;
-;; This software is provided 'as-is', without any express
-;; or implied warranty.  In no event will the authors be
-;; held liable for any damages arising from the use of
-;; this software.
-;;
-;; Permission is granted to anyone to use this software
-;; for any purpose, including commercial applications,
-;; and to alter it and redistribute it freely, subject to
-;; the following restrictions:
-;;
-;; 1. The origin of this software must not be
-;;    misrepresented; you must not claim that you
-;;    wrote the original software. If you use this
-;;    software in a product, an acknowledgment in
-;;    the product documentation would be appreciated
-;;    but is not required.
-;;
-;; 2. Altered source versions must be plainly marked
-;;    as such, and must not be misrepresented as
-;;    being the original software.
-;;
-;; 3. This notice may not be removed or altered from
-;;    any source distribution.
-;;
-
-; CRC32 algorithm taken from the zlib source, which is
-; Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler
-
-cpu 386
-
-bits 32
-
-%include "nasmlcm.inc"
-
-section lcmtext
-
-lcmglobal tinf_crc32,8
-
-lcmexport tinf_crc32,8
-
-; =============================================================
-
-lcmlabel tinf_crc32,8
-    ; tinf_crc32(const void *data,
-    ;            unsigned int length);
-
-    .len$  equ 2*4 + 4 + 4
-    .dat$  equ 2*4 + 4
-
-    push   esi
-    push   edi
-
-    mov    esi, [esp + .dat$] ; esi -> buffer
-    mov    ecx, [esp + .len$] ; ecx =  length
-
-    sub    eax, eax           ; crc = 0
-
-    test   esi, esi
-    jz     short .c_exit
-
-    test   ecx, ecx
-    jz     short .c_exit
-
-    dec    eax                ; crc = 0xffffffff
-
-%ifdef _OBJ_
-    mov    edi, tinf_crc32tab wrt FLAT ; edi -> crctab
-%else
-    mov    edi, tinf_crc32tab ; edi -> crctab
-%endif
-
-  .c_next_byte:
-    xor    al, [esi]
-    inc    esi
-
-    mov    edx, 0x0f
-    and    edx, eax
-
-    shr    eax, 4
-
-    xor    eax, [edi + edx*4]
-
-    mov    edx, 0x0f
-    and    edx, eax
-
-    shr    eax, 4
-
-    xor    eax, [edi + edx*4]
-
-    dec    ecx
-    jnz    short .c_next_byte
-
-    not    eax
-
-  .c_exit:
-    pop    edi
-    pop    esi
-
-    lcmret 8
-
-; =============================================================
-
-section lcmdata
-
-tinf_crc32tab dd 0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 0x76dc4190
-              dd 0x6b6b51f4, 0x4db26158, 0x5005713c, 0xedb88320, 0xf00f9344
-              dd 0xd6d6a3e8, 0xcb61b38c, 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278
-              dd 0xbdbdf21c
-
-; =============================================================
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/nasm/nasmlcm.inc b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/nasm/nasmlcm.inc
deleted file mode 100644
index 5cbe7e0d..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/nasm/nasmlcm.inc
+++ /dev/null
@@ -1,326 +0,0 @@
-;;
-;; NASM linker compatibility macros 2002.07.24
-;;
-;; Copyright (c) 2001-2003 by Joergen Ibsen / Jibz
-;; All Rights Reserved
-;;
-;; http://www.ibsensoftware.com/
-;;
-
-; define _ELF_ for ELF32 object files
-; define _OBJ_ for OMF object files
-; define _OBJ_ and _DLL_ for OMF object files for a dll (stdcall)
-; define _MSLIBS_ for MS style Win32 import libs (lcmwinextern)
-; default is DJGPP/WIN32 COFF object files
-
-; remember to do lcm*extern before lcmimport
-
-; ====================================================================
-;
-; There are differences between how the object formats that NASM
-; supports work, and what features they support. Similarly there
-; are differences between how complete and standard compliant the
-; support for these formats are in linkers.
-;
-; The NASM linker compatibility macros (nasmlcm) were put together
-; to ease my work by allowing a single source file to be assembled
-; for use with a number of compilers/linkers.
-;
-; Currently obj/omf, win32/coff, djgpp/coff and elf32 output formats
-; are supported. The following macros are available:
-;
-;   lcmtext       - section name for the code section
-;   lcmdata       - section name for the initialized data section
-;   lcmbss        - section name for the uninitialized data section
-;
-;   lcmglobal     - declare a function (two arguments) or data (one
-;                   argument) as global in the current format
-;   lcmcglobal    - same as lcmglobal, but uses C name decoration
-;
-;   lcmextern     - declare a function (two arguments) or data (one
-;                   argument) as extern in the current format
-;   lcmcextern    - same as lcmextern, but uses C name decoration
-;   lcmdllextern  - same as lcmextern, but uses dll name decoration
-;   lcmwinextern  - same as lcmextern, but uses name decoration for
-;                   calling Win32 Api functions (see _MSLIBS_)
-;
-;   lcmimport     - declares a function (two arguments) or data (one
-;                   argument) as imported in the current format
-;   lcmexport     - declares a function (two arguments) or data (one
-;                   argument) as exported in the current format
-;
-;   lcmlabel      - start label for a function in the current format
-;   lcmclabel     - start label for a function with C name decoration
-;   lcmadjust     - adjust stack after a function call in the current
-;                   format
-;   lcmret        - return from a function in the current format
-;   lcmcret       - return from a C function
-;
-; The following defines change the format and behaviour:
-;
-;   _ELF_     -  the lcm*global macro adds :function and :data type
-;                specifiers
-;
-;   _OBJ_     -  section names are similar to those produced by
-;                Borland tools to increase compatibility with
-;                various OMF compatible linkers
-;
-;   _DLL_     -  functions are exported and imported with added
-;                size specifiers (_SomeFunction@12), lcmret adjusts
-;                stack (stdcall)
-;
-;   _MSLIBS_  -  the lcmwinextern macro prepends an underscore and
-;                adds size specification for functions, allowing
-;                the object file to be linked with MS libraries.
-;
-; ====================================================================
-
-%ifndef NASMLCM_INC_INCLUDED
-%define NASMLCM_INC_INCLUDED
-
-%ifdef _DLL_
-  %ifndef _OBJ_
-    %error "_DLL_ needs _OBJ_ defined!"
-  %endif
-%endif
-
-; --- define lcm- section names ---
-;
-;  a number of linkers require omf objects where the section
-;  names are equal to those produces by tasm.
-
-%ifdef _OBJ_
-
-  %define lcmtext _TEXT class=CODE public use32 align=4 FLAT
-  %define lcmdata _DATA class=DATA public use32 align=4
-  %define lcmbss _BSS class=BSS public use32 align=4 FLAT
-
-  group FLAT
-  group DGROUP _DATA
-
-%else ; _OBJ_
-
-  %define lcmtext .text
-  %define lcmdata .data
-  %define lcmbss .bss
-
-%endif ; _OBJ_
-
-; --- define lcmglobal and lcm*extern macros ---
-;
-;  special handling of functions and data for ELF32
-
-%ifdef _ELF_
-
-  %macro lcmglobal 2
-    global %{1}:function
-  %endmacro
-  %macro lcmglobal 1
-    global %{1}:data
-  %endmacro
-
-  %define lcmcglobal lcmglobal
-
-  %macro lcmextern 1-2
-    extern %1
-  %endmacro
-
-  %macro lcmcextern 0
-    %error lcmcextern not supported in ELF format
-  %endmacro
-
-  %macro lcmdllextern 0
-    %error lcmdllextern not supported in ELF format
-  %endmacro
-
-%else ; _ELF_
-
-  %ifdef _DLL_
-
-    %macro lcmglobal 2
-      global _%1
-      global _%1@%2
-    %endmacro
-    %macro lcmglobal 1
-      global _%1
-      %define %1 _%1
-    %endmacro
-
-    %macro lcmcglobal 2
-      global _%1
-    %endmacro
-    %macro lcmcglobal 1
-      global _%1
-      %define %1 _%1
-    %endmacro
-
-    %macro lcmextern 2
-      extern _%1@%2
-      %define %1 _%1@%2
-    %endmacro
-    %macro lcmextern 1
-      extern _%1
-      %define %1 _%1
-    %endmacro
-
-  %else
-
-    %macro lcmglobal 2
-      global _%1
-    %endmacro
-    %macro lcmglobal 1
-      global _%1
-      %define %1 _%1
-    %endmacro
-
-    %define lcmcglobal lcmglobal
-
-    %macro lcmextern 1-2
-      extern _%1
-      %define %1 _%1
-    %endmacro
-
-  %endif
-
-  %macro lcmcextern 1-2
-    extern _%1
-    %define %1 _%1
-  %endmacro
-
-  %macro lcmdllextern 2
-    extern _%1@%2
-    %define %1 _%1@%2
-  %endmacro
-  %macro lcmdllextern 1
-    extern _%1
-    %define %1 _%1
-  %endmacro
-
-  %macro lcmwinextern 2
-    %ifdef _MSLIBS_
-      extern _%1@%2
-      %define %1 _%1@%2
-    %else
-      extern %1
-    %endif
-  %endmacro
-
-%endif ; _ELF_
-
-; --- define lcmimport and lcmexport ---
-;
-
-%ifdef _OBJ_
-
-  %macro lcmimport 2-3
-    import %1 %2 %3
-    %rotate 1
-  %endmacro
-
-  %ifdef _DLL_
-
-    %macro lcmexport 2
-      export _%1
-      export _%1@%2
-    %endmacro
-    %macro lcmexport 1
-      export _%1
-    %endmacro
-
-  %else
-
-    %macro lcmexport 1-2
-    %endmacro
-
-  %endif
-
-%else ; _OBJ_
-
-  %macro lcmimport 2-3
-  %endmacro
-
-  %macro lcmexport 1-2
-  %endmacro
-
-%endif ; _OBJ_
-
-; --- define lcmlabel, lcmadjust and lcmret macros ---
-;
-;  we need special labels and stdcall calling convention when
-;  assembling for a dll
-
-%ifdef _ELF_
-
-  %macro lcmlabel 2
-    %1:
-  %endmacro
-
-  %define lcmclabel lcmlabel
-
-  %macro lcmadjust 1
-    %if %1 < 128
-      add esp, byte %1
-    %else
-      add esp, %1
-    %endif
-  %endmacro
-
-  %macro lcmret 1
-    ret
-  %endmacro
-
-  %define lcmcret lcmret
-
-%else ; _ELF_
-
-  %ifdef _DLL_
-    %macro lcmlabel 2
-      _%1:
-      _%1@%2:
-    %endmacro
-
-    %macro lcmclabel 2
-      _%1:
-    %endmacro
-
-    %macro lcmadjust 1
-    %endmacro
-
-    %macro lcmret 1
-      %if %1 > 0
-        ret %1
-      %else
-        ret
-      %endif
-    %endmacro
-
-    %macro lcmcret 1
-      ret
-    %endmacro
-
-  %else
-
-    %macro lcmlabel 2
-      _%1:
-    %endmacro
-
-    %define lcmclabel lcmlabel
-
-    %macro lcmadjust 1
-      %if %1 < 128
-        add esp, byte %1
-      %else
-        add esp, %1
-      %endif
-    %endmacro
-
-    %macro lcmret 1
-      ret
-    %endmacro
-
-    %define lcmcret lcmret
-  %endif
-
-%endif ; _ELF_
-
-%endif ; NASMLCM_INC_INCLUDED
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/nasm/tinfzlib.nas b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/nasm/tinfzlib.nas
deleted file mode 100644
index 1f9519eb..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/nasm/tinfzlib.nas
+++ /dev/null
@@ -1,160 +0,0 @@
-;;
-;; tinfzlib  -  tiny zlib uncompress
-;;
-;; Copyright (c) 2003 by Joergen Ibsen / Jibz
-;; All Rights Reserved
-;;
-;; http://www.ibsensoftware.com/
-;;
-;; This software is provided 'as-is', without any express
-;; or implied warranty.  In no event will the authors be
-;; held liable for any damages arising from the use of
-;; this software.
-;;
-;; Permission is granted to anyone to use this software
-;; for any purpose, including commercial applications,
-;; and to alter it and redistribute it freely, subject to
-;; the following restrictions:
-;;
-;; 1. The origin of this software must not be
-;;    misrepresented; you must not claim that you
-;;    wrote the original software. If you use this
-;;    software in a product, an acknowledgment in
-;;    the product documentation would be appreciated
-;;    but is not required.
-;;
-;; 2. Altered source versions must be plainly marked
-;;    as such, and must not be misrepresented as
-;;    being the original software.
-;;
-;; 3. This notice may not be removed or altered from
-;;    any source distribution.
-;;
-
-TINF_OK         equ  0
-TINF_DATA_ERROR equ (-3)
-
-cpu 386
-
-bits 32
-
-%include "nasmlcm.inc"
-
-section lcmtext
-
-lcmglobal tinf_zlib_uncompress,16
-
-lcmexport tinf_zlib_uncompress,16
-
-lcmextern tinf_uncompress,16
-lcmextern tinf_adler32,8
-
-; =============================================================
-
-lcmlabel tinf_zlib_uncompress,16
-    ; tinf_zlib_uncompress(void *dest,
-    ;                      unsigned int *destLen,
-    ;                      const void *source,
-    ;                      unsigned int sourceLen)
-
-    .slen$ equ 2*4 + 4 + 12
-    .src$  equ 2*4 + 4 + 8
-    .dlen$ equ 2*4 + 4 + 4
-    .dst$  equ 2*4 + 4
-
-    push   esi
-    push   ebx
-
-    mov    esi, [esp + .src$]  ; esi -> source
-
-    ; -- get header bytes --
-
-    movzx  eax, word [esi]    ; al = cmf, ah = flg,
-
-    ; -- check format --
-
-    ; check method is deflate
-    ; if ((cmf & 0x0f) != 8) return TINF_DATA_ERROR;
-    mov    cl, 0x0f
-    and    cl, al
-    cmp    cl, 8
-    jne    short .return_error
-
-    ; check window size is valid
-    ; if ((cmf >> 4) > 7) return TINF_DATA_ERROR;
-    mov    ch, al
-    shr    ch, 4
-    cmp    ch, cl             ; cl = 8 from above
-    jae    short .return_error
-
-    ; check there is no preset dictionary
-    ; if (flg & 0x20) return TINF_DATA_ERROR;
-    test   ah, 0x20
-    jnz    short .return_error
-
-    ; check checksum
-    ; if ((256*cmf + flg) % 31) return TINF_DATA_ERROR;
-    xchg   al, ah
-    xor    edx, edx
-    lea    ebx, [edx + 31]
-    div    ebx
-    test   edx, edx
-    jnz    short .return_error
-
-    ; -- get adler32 checksum --
-
-    mov    ecx, [esp + .slen$] ; ecx =  sourceLen
-    mov    ebx, [esi + ecx - 4]
-
-  %ifdef BSWAP_OK
-    bswap  ebx
-  %else ; BSWAP_OK
-    xchg   bl, bh
-    rol    ebx, 16
-    xchg   bl, bh
-  %endif ; BSWAP_OK
-
-    ; -- inflate --
-
-    ; res = tinf_uncompress(dst, destLen, src + 2, sourceLen - 6);
-    lea    eax, [ecx - 6]
-    push   eax
-    lea    eax, [esi + 2]
-    push   eax
-    push   dword [esp + 8 + .dlen$]
-    push   dword [esp + 12 + .dst$]
-    call   tinf_uncompress
-    add    esp, byte 16
-
-    ; if (res != TINF_OK) return TINF_DATA_ERROR;
-    test   eax, eax
-    jnz    short .return_error
-
-    ; -- check adler32 checksum --
-
-    ; if (a32 != tinf_adler32(dst, *destLen)) return TINF_DATA_ERROR;
-    mov    eax, [esp + .dlen$];
-    push   dword [eax]
-    push   dword [esp + 4 + .dst$]
-    call   tinf_adler32
-    add    esp, byte 8
-
-    sub    eax, ebx
-    jz     short .return_eax
-
-  .return_error:
-    mov    eax, TINF_DATA_ERROR
-
-  .return_eax:
-    pop    ebx
-    pop    esi
-
-    lcmret 16
-
-; =============================================================
-
-%ifdef _OBJ_
-  section lcmdata
-%endif
-
-; =============================================================
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/tinf.h b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/tinf.h
deleted file mode 100644
index ae6e1c40..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/tinf.h
+++ /dev/null
@@ -1,3 +0,0 @@
-/* Compatibility header for the original tinf lib/older versions of uzlib.
-   Note: may be removed in the future, please migrate to uzlib.h. */
-#include "uzlib.h"
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/tinf_compat.h b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/tinf_compat.h
deleted file mode 100644
index f763804b..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/tinf_compat.h
+++ /dev/null
@@ -1,9 +0,0 @@
-/* This header contains compatibility defines for the original tinf API
-   and uzlib 2.x and below API. These defines are deprecated and going
-   to be removed in the future, so applications should migrate to new
-   uzlib API. */
-#define TINF_DATA struct uzlib_uncomp
-
-#define destSize dest_size
-#define destStart dest_start
-#define readSource source_read_cb
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/tinfgzip.c b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/tinfgzip.c
deleted file mode 100644
index 22b000df..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/tinfgzip.c
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
- * uzlib  -  tiny deflate/inflate library (deflate, gzip, zlib)
- *
- * Copyright (c) 2003 by Joergen Ibsen / Jibz
- * All Rights Reserved
- *
- * http://www.ibsensoftware.com/
- *
- * Copyright (c) 2014-2018 by Paul Sokolovsky
- *
- * This software is provided 'as-is', without any express
- * or implied warranty.  In no event will the authors be
- * held liable for any damages arising from the use of
- * this software.
- *
- * Permission is granted to anyone to use this software
- * for any purpose, including commercial applications,
- * and to alter it and redistribute it freely, subject to
- * the following restrictions:
- *
- * 1. The origin of this software must not be
- *    misrepresented; you must not claim that you
- *    wrote the original software. If you use this
- *    software in a product, an acknowledgment in
- *    the product documentation would be appreciated
- *    but is not required.
- *
- * 2. Altered source versions must be plainly marked
- *    as such, and must not be misrepresented as
- *    being the original software.
- *
- * 3. This notice may not be removed or altered from
- *    any source distribution.
- */
-
-#include "tinf.h"
-
-#define FTEXT    1
-#define FHCRC    2
-#define FEXTRA   4
-#define FNAME    8
-#define FCOMMENT 16
-
-void tinf_skip_bytes(TINF_DATA *d, int num);
-uint16_t tinf_get_uint16(TINF_DATA *d);
-
-void tinf_skip_bytes(TINF_DATA *d, int num)
-{
-    while (num--) uzlib_get_byte(d);
-}
-
-uint16_t tinf_get_uint16(TINF_DATA *d)
-{
-    unsigned int v = uzlib_get_byte(d);
-    v = (uzlib_get_byte(d) << 8) | v;
-    return v;
-}
-
-int uzlib_gzip_parse_header(TINF_DATA *d)
-{
-    unsigned char flg;
-
-    /* -- check format -- */
-
-    /* check id bytes */
-    if (uzlib_get_byte(d) != 0x1f || uzlib_get_byte(d) != 0x8b) return TINF_DATA_ERROR;
-
-    /* check method is deflate */
-    if (uzlib_get_byte(d) != 8) return TINF_DATA_ERROR;
-
-    /* get flag byte */
-    flg = uzlib_get_byte(d);
-
-    /* check that reserved bits are zero */
-    if (flg & 0xe0) return TINF_DATA_ERROR;
-
-    /* -- find start of compressed data -- */
-
-    /* skip rest of base header of 10 bytes */
-    tinf_skip_bytes(d, 6);
-
-    /* skip extra data if present */
-    if (flg & FEXTRA)
-    {
-       unsigned int xlen = tinf_get_uint16(d);
-       tinf_skip_bytes(d, xlen);
-    }
-
-    /* skip file name if present */
-    if (flg & FNAME) { while (uzlib_get_byte(d)); }
-
-    /* skip file comment if present */
-    if (flg & FCOMMENT) { while (uzlib_get_byte(d)); }
-
-    /* check header crc if present */
-    if (flg & FHCRC)
-    {
-       /*unsigned int hcrc =*/ tinf_get_uint16(d);
-
-        // TODO: Check!
-//       if (hcrc != (tinf_crc32(src, start - src) & 0x0000ffff))
-//          return TINF_DATA_ERROR;
-    }
-
-    /* initialize for crc32 checksum */
-    d->checksum_type = TINF_CHKSUM_CRC;
-    d->checksum = ~0;
-
-    return TINF_OK;
-}
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/tinflate.c b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/tinflate.c
deleted file mode 100644
index 8d631fe7..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/tinflate.c
+++ /dev/null
@@ -1,673 +0,0 @@
-/*
- * uzlib  -  tiny deflate/inflate library (deflate, gzip, zlib)
- *
- * Copyright (c) 2003 by Joergen Ibsen / Jibz
- * All Rights Reserved
- * http://www.ibsensoftware.com/
- *
- * Copyright (c) 2014-2018 by Paul Sokolovsky
- *
- * This software is provided 'as-is', without any express
- * or implied warranty.  In no event will the authors be
- * held liable for any damages arising from the use of
- * this software.
- *
- * Permission is granted to anyone to use this software
- * for any purpose, including commercial applications,
- * and to alter it and redistribute it freely, subject to
- * the following restrictions:
- *
- * 1. The origin of this software must not be
- *    misrepresented; you must not claim that you
- *    wrote the original software. If you use this
- *    software in a product, an acknowledgment in
- *    the product documentation would be appreciated
- *    but is not required.
- *
- * 2. Altered source versions must be plainly marked
- *    as such, and must not be misrepresented as
- *    being the original software.
- *
- * 3. This notice may not be removed or altered from
- *    any source distribution.
- */
-
-#include <assert.h>
-#include <string.h>
-#include "tinf.h"
-
-#define UZLIB_DUMP_ARRAY(heading, arr, size) \
-    { \
-        printf("%s", heading); \
-        for (int i = 0; i < size; ++i) { \
-            printf(" %d", (arr)[i]); \
-        } \
-        printf("\n"); \
-    }
-
-uint32_t tinf_get_le_uint32(TINF_DATA *d);
-uint32_t tinf_get_be_uint32(TINF_DATA *d);
-
-/* --------------------------------------------------- *
- * -- uninitialized global data (static structures) -- *
- * --------------------------------------------------- */
-
-#ifdef RUNTIME_BITS_TABLES
-
-/* extra bits and base tables for length codes */
-unsigned char length_bits[30];
-unsigned short length_base[30];
-
-/* extra bits and base tables for distance codes */
-unsigned char dist_bits[30];
-unsigned short dist_base[30];
-
-#else
-
-const unsigned char length_bits[30] = {
-   0, 0, 0, 0, 0, 0, 0, 0,
-   1, 1, 1, 1, 2, 2, 2, 2,
-   3, 3, 3, 3, 4, 4, 4, 4,
-   5, 5, 5, 5
-};
-const unsigned short length_base[30] = {
-   3, 4, 5, 6, 7, 8, 9, 10,
-   11, 13, 15, 17, 19, 23, 27, 31,
-   35, 43, 51, 59, 67, 83, 99, 115,
-   131, 163, 195, 227, 258
-};
-
-const unsigned char dist_bits[30] = {
-   0, 0, 0, 0, 1, 1, 2, 2,
-   3, 3, 4, 4, 5, 5, 6, 6,
-   7, 7, 8, 8, 9, 9, 10, 10,
-   11, 11, 12, 12, 13, 13
-};
-const unsigned short dist_base[30] = {
-   1, 2, 3, 4, 5, 7, 9, 13,
-   17, 25, 33, 49, 65, 97, 129, 193,
-   257, 385, 513, 769, 1025, 1537, 2049, 3073,
-   4097, 6145, 8193, 12289, 16385, 24577
-};
-
-#endif
-
-/* special ordering of code length codes */
-const unsigned char clcidx[] = {
-   16, 17, 18, 0, 8, 7, 9, 6,
-   10, 5, 11, 4, 12, 3, 13, 2,
-   14, 1, 15
-};
-
-/* ----------------------- *
- * -- utility functions -- *
- * ----------------------- */
-
-#ifdef RUNTIME_BITS_TABLES
-/* build extra bits and base tables */
-static void tinf_build_bits_base(unsigned char *bits, unsigned short *base, int delta, int first)
-{
-   int i, sum;
-
-   /* build bits table */
-   for (i = 0; i < delta; ++i) bits[i] = 0;
-   for (i = 0; i < 30 - delta; ++i) bits[i + delta] = i / delta;
-
-   /* build base table */
-   for (sum = first, i = 0; i < 30; ++i)
-   {
-      base[i] = sum;
-      sum += 1 << bits[i];
-   }
-}
-#endif
-
-/* build the fixed huffman trees */
-static void tinf_build_fixed_trees(TINF_TREE *lt, TINF_TREE *dt)
-{
-   int i;
-
-   /* build fixed length tree */
-   for (i = 0; i < 7; ++i) lt->table[i] = 0;
-
-   lt->table[7] = 24;
-   lt->table[8] = 152;
-   lt->table[9] = 112;
-
-   for (i = 0; i < 24; ++i) lt->trans[i] = 256 + i;
-   for (i = 0; i < 144; ++i) lt->trans[24 + i] = i;
-   for (i = 0; i < 8; ++i) lt->trans[24 + 144 + i] = 280 + i;
-   for (i = 0; i < 112; ++i) lt->trans[24 + 144 + 8 + i] = 144 + i;
-
-   /* build fixed distance tree */
-   for (i = 0; i < 5; ++i) dt->table[i] = 0;
-
-   dt->table[5] = 32;
-
-   for (i = 0; i < 32; ++i) dt->trans[i] = i;
-}
-
-/* given an array of code lengths, build a tree */
-static void tinf_build_tree(TINF_TREE *t, const unsigned char *lengths, unsigned int num)
-{
-   unsigned short offs[16];
-   unsigned int i, sum;
-
-   /* clear code length count table */
-   for (i = 0; i < 16; ++i) t->table[i] = 0;
-
-   /* scan symbol lengths, and sum code length counts */
-   for (i = 0; i < num; ++i) t->table[lengths[i]]++;
-
-   #if UZLIB_CONF_DEBUG_LOG >= 2
-   UZLIB_DUMP_ARRAY("codelen counts:", t->table, TINF_ARRAY_SIZE(t->table));
-   #endif
-
-   /* In the lengths array, 0 means unused code. So, t->table[0] now contains
-      number of unused codes. But table's purpose is to contain # of codes of
-      particular length, and there're 0 codes of length 0. */
-   t->table[0] = 0;
-
-   /* compute offset table for distribution sort */
-   for (sum = 0, i = 0; i < 16; ++i)
-   {
-      offs[i] = sum;
-      sum += t->table[i];
-   }
-
-   #if UZLIB_CONF_DEBUG_LOG >= 2
-   UZLIB_DUMP_ARRAY("codelen offsets:", offs, TINF_ARRAY_SIZE(offs));
-   #endif
-
-   /* create code->symbol translation table (symbols sorted by code) */
-   for (i = 0; i < num; ++i)
-   {
-      if (lengths[i]) t->trans[offs[lengths[i]]++] = i;
-   }
-}
-
-/* ---------------------- *
- * -- decode functions -- *
- * ---------------------- */
-
-unsigned char uzlib_get_byte(TINF_DATA *d)
-{
-    /* If end of source buffer is not reached, return next byte from source
-       buffer. */
-    if (d->source < d->source_limit) {
-        return *d->source++;
-    }
-    /* Otherwise if there's callback and we haven't seen EOF yet, try to
-       read next byte using it. (Note: the callback can also update ->source
-       and ->source_limit). */
-    if (d->readSource && !d->eof) {
-        int val = d->readSource(d);
-        if (val >= 0) {
-            return (unsigned char)val;
-        }
-    }
-
-    /* Otherwise, we hit EOF (either from ->readSource() or from exhaustion
-       of the buffer), and it will be "sticky", i.e. further calls to this
-       function will end up here too. */
-    d->eof = true;
-
-    return 0;
-}
-
-uint32_t tinf_get_le_uint32(TINF_DATA *d)
-{
-    uint32_t val = 0;
-    int i;
-    for (i = 4; i--;) {
-        val = val >> 8 | ((uint32_t)uzlib_get_byte(d)) << 24;
-    }
-    return val;
-}
-
-uint32_t tinf_get_be_uint32(TINF_DATA *d)
-{
-    uint32_t val = 0;
-    int i;
-    for (i = 4; i--;) {
-        val = val << 8 | uzlib_get_byte(d);
-    }
-    return val;
-}
-
-/* get one bit from source stream */
-static int tinf_getbit(TINF_DATA *d)
-{
-   unsigned int bit;
-
-   /* check if tag is empty */
-   if (!d->bitcount--)
-   {
-      /* load next tag */
-      d->tag = uzlib_get_byte(d);
-      d->bitcount = 7;
-   }
-
-   /* shift bit out of tag */
-   bit = d->tag & 0x01;
-   d->tag >>= 1;
-
-   return bit;
-}
-
-/* read a num bit value from a stream and add base */
-static unsigned int tinf_read_bits(TINF_DATA *d, int num, int base)
-{
-   unsigned int val = 0;
-
-   /* read num bits */
-   if (num)
-   {
-      unsigned int limit = 1 << (num);
-      unsigned int mask;
-
-      for (mask = 1; mask < limit; mask *= 2)
-         if (tinf_getbit(d)) val += mask;
-   }
-
-   return val + base;
-}
-
-/* given a data stream and a tree, decode a symbol */
-static int tinf_decode_symbol(TINF_DATA *d, TINF_TREE *t)
-{
-   int sum = 0, cur = 0, len = 0;
-
-   /* get more bits while code value is above sum */
-   do {
-
-      cur = 2*cur + tinf_getbit(d);
-
-      if (++len == TINF_ARRAY_SIZE(t->table)) {
-         return TINF_DATA_ERROR;
-      }
-
-      sum += t->table[len];
-      cur -= t->table[len];
-
-   } while (cur >= 0);
-
-   sum += cur;
-   #if UZLIB_CONF_PARANOID_CHECKS
-   if (sum < 0 || sum >= TINF_ARRAY_SIZE(t->trans)) {
-      return TINF_DATA_ERROR;
-   }
-   #endif
-
-   return t->trans[sum];
-}
-
-/* given a data stream, decode dynamic trees from it */
-static int tinf_decode_trees(TINF_DATA *d, TINF_TREE *lt, TINF_TREE *dt)
-{
-   /* code lengths for 288 literal/len symbols and 32 dist symbols */
-   unsigned char lengths[288+32];
-   unsigned int hlit, hdist, hclen, hlimit;
-   unsigned int i, num, length;
-
-   /* get 5 bits HLIT (257-286) */
-   hlit = tinf_read_bits(d, 5, 257);
-
-   /* get 5 bits HDIST (1-32) */
-   hdist = tinf_read_bits(d, 5, 1);
-
-   /* get 4 bits HCLEN (4-19) */
-   hclen = tinf_read_bits(d, 4, 4);
-
-   for (i = 0; i < 19; ++i) lengths[i] = 0;
-
-   /* read code lengths for code length alphabet */
-   for (i = 0; i < hclen; ++i)
-   {
-      /* get 3 bits code length (0-7) */
-      unsigned int clen = tinf_read_bits(d, 3, 0);
-
-      lengths[clcidx[i]] = clen;
-   }
-
-   /* build code length tree, temporarily use length tree */
-   tinf_build_tree(lt, lengths, 19);
-
-   /* decode code lengths for the dynamic trees */
-   hlimit = hlit + hdist;
-   for (num = 0; num < hlimit; )
-   {
-      int sym = tinf_decode_symbol(d, lt);
-      unsigned char fill_value = 0;
-      int lbits, lbase = 3;
-
-      /* error decoding */
-      if (sym < 0) return sym;
-
-      switch (sym)
-      {
-      case 16:
-         /* copy previous code length 3-6 times (read 2 bits) */
-         if (num == 0) return TINF_DATA_ERROR;
-         fill_value = lengths[num - 1];
-         lbits = 2;
-         break;
-      case 17:
-         /* repeat code length 0 for 3-10 times (read 3 bits) */
-         lbits = 3;
-         break;
-      case 18:
-         /* repeat code length 0 for 11-138 times (read 7 bits) */
-         lbits = 7;
-         lbase = 11;
-         break;
-      default:
-         /* values 0-15 represent the actual code lengths */
-         lengths[num++] = sym;
-         /* continue the for loop */
-         continue;
-      }
-
-      /* special code length 16-18 are handled here */
-      length = tinf_read_bits(d, lbits, lbase);
-      if (num + length > hlimit) return TINF_DATA_ERROR;
-      for (; length; --length)
-      {
-         lengths[num++] = fill_value;
-      }
-   }
-
-   #if UZLIB_CONF_DEBUG_LOG >= 2
-   printf("lit code lengths (%d):", hlit);
-   UZLIB_DUMP_ARRAY("", lengths, hlit);
-   printf("dist code lengths (%d):", hdist);
-   UZLIB_DUMP_ARRAY("", lengths + hlit, hdist);
-   #endif
-
-   #if UZLIB_CONF_PARANOID_CHECKS
-   /* Check that there's "end of block" symbol */
-   if (lengths[256] == 0) {
-      return TINF_DATA_ERROR;
-   }
-   #endif
-
-   /* build dynamic trees */
-   tinf_build_tree(lt, lengths, hlit);
-   tinf_build_tree(dt, lengths + hlit, hdist);
-
-   return TINF_OK;
-}
-
-/* ----------------------------- *
- * -- block inflate functions -- *
- * ----------------------------- */
-
-/* given a stream and two trees, inflate next chunk of output (a byte or more) */
-static int tinf_inflate_block_data(TINF_DATA *d, TINF_TREE *lt, TINF_TREE *dt)
-{
-    if (d->curlen == 0) {
-        unsigned int offs;
-        int dist;
-        int sym = tinf_decode_symbol(d, lt);
-        //printf("huff sym: %02x\n", sym);
-
-        if (d->eof) {
-            return TINF_DATA_ERROR;
-        }
-
-        /* literal byte */
-        if (sym < 256) {
-            TINF_PUT(d, sym);
-            return TINF_OK;
-        }
-
-        /* end of block */
-        if (sym == 256) {
-            return TINF_DONE;
-        }
-
-        /* substring from sliding dictionary */
-        sym -= 257;
-        if (sym >= 29) {
-            return TINF_DATA_ERROR;
-        }
-
-        /* possibly get more bits from length code */
-        d->curlen = tinf_read_bits(d, length_bits[sym], length_base[sym]);
-
-        dist = tinf_decode_symbol(d, dt);
-        if (dist >= 30) {
-            return TINF_DATA_ERROR;
-        }
-
-        /* possibly get more bits from distance code */
-        offs = tinf_read_bits(d, dist_bits[dist], dist_base[dist]);
-
-        /* calculate and validate actual LZ offset to use */
-        if (d->dict_ring) {
-            if (offs > d->dict_size) {
-                return TINF_DICT_ERROR;
-            }
-            /* Note: unlike full-dest-in-memory case below, we don't
-               try to catch offset which points to not yet filled
-               part of the dictionary here. Doing so would require
-               keeping another variable to track "filled in" size
-               of the dictionary. Appearance of such an offset cannot
-               lead to accessing memory outside of the dictionary
-               buffer, and clients which don't want to leak unrelated
-               information, should explicitly initialize dictionary
-               buffer passed to uzlib. */
-
-            d->lzOff = d->dict_idx - offs;
-            if (d->lzOff < 0) {
-                d->lzOff += d->dict_size;
-            }
-        } else {
-            /* catch trying to point before the start of dest buffer */
-            if (offs > d->dest - d->destStart) {
-                return TINF_DATA_ERROR;
-            }
-            d->lzOff = -offs;
-        }
-    }
-
-    /* copy next byte from dict substring */
-    if (d->dict_ring) {
-        TINF_PUT(d, d->dict_ring[d->lzOff]);
-        if ((unsigned)++d->lzOff == d->dict_size) {
-            d->lzOff = 0;
-        }
-    } else {
-        #if UZLIB_CONF_USE_MEMCPY
-        /* copy as much as possible, in one memcpy() call */
-        unsigned int to_copy = d->curlen, dest_len = d->dest_limit - d->dest;
-        if (to_copy > dest_len) {
-            to_copy = dest_len;
-        }
-        memcpy(d->dest, d->dest + d->lzOff, to_copy);
-        d->dest += to_copy;
-        d->curlen -= to_copy;
-        return TINF_OK;
-        #else
-        d->dest[0] = d->dest[d->lzOff];
-        d->dest++;
-        #endif
-    }
-    d->curlen--;
-    return TINF_OK;
-}
-
-/* inflate next byte from uncompressed block of data */
-static int tinf_inflate_uncompressed_block(TINF_DATA *d)
-{
-    if (d->curlen == 0) {
-        unsigned int length, invlength;
-
-        /* get length */
-        length = uzlib_get_byte(d);
-        length += 256 * uzlib_get_byte(d);
-        /* get one's complement of length */
-        invlength = uzlib_get_byte(d);
-        invlength += 256 * uzlib_get_byte(d);
-        /* check length */
-        if (length != (~invlength & 0x0000ffff)) return TINF_DATA_ERROR;
-
-        /* increment length to properly return TINF_DONE below, without
-           producing data at the same time */
-        d->curlen = length + 1;
-
-        /* make sure we start next block on a byte boundary */
-        d->bitcount = 0;
-    }
-
-    if (--d->curlen == 0) {
-        return TINF_DONE;
-    }
-
-    unsigned char c = uzlib_get_byte(d);
-    TINF_PUT(d, c);
-    return TINF_OK;
-}
-
-/* ---------------------- *
- * -- public functions -- *
- * ---------------------- */
-
-/* initialize global (static) data */
-void uzlib_init(void)
-{
-#ifdef RUNTIME_BITS_TABLES
-   /* build extra bits and base tables */
-   tinf_build_bits_base(length_bits, length_base, 4, 3);
-   tinf_build_bits_base(dist_bits, dist_base, 2, 1);
-
-   /* fix a special case */
-   length_bits[28] = 0;
-   length_base[28] = 258;
-#endif
-}
-
-/* initialize decompression structure */
-void uzlib_uncompress_init(TINF_DATA *d, void *dict, unsigned int dictLen)
-{
-   d->eof = 0;
-   d->bitcount = 0;
-   d->bfinal = 0;
-   d->btype = -1;
-   d->dict_size = dictLen;
-   d->dict_ring = dict;
-   d->dict_idx = 0;
-   d->curlen = 0;
-}
-
-/* inflate next output bytes from compressed stream */
-int uzlib_uncompress(TINF_DATA *d)
-{
-    do {
-        int res;
-
-        /* start a new block */
-        if (d->btype == -1) {
-            int old_btype;
-next_blk:
-            old_btype = d->btype;
-            /* read final block flag */
-            d->bfinal = tinf_getbit(d);
-            /* read block type (2 bits) */
-            d->btype = tinf_read_bits(d, 2, 0);
-
-            #if UZLIB_CONF_DEBUG_LOG >= 1
-            printf("Started new block: type=%d final=%d\n", d->btype, d->bfinal);
-            #endif
-
-            if (d->btype == 1 && old_btype != 1) {
-                /* build fixed huffman trees */
-                tinf_build_fixed_trees(&d->ltree, &d->dtree);
-            } else if (d->btype == 2) {
-                /* decode trees from stream */
-                res = tinf_decode_trees(d, &d->ltree, &d->dtree);
-                if (res != TINF_OK) {
-                    return res;
-                }
-            }
-        }
-
-        /* process current block */
-        switch (d->btype)
-        {
-        case 0:
-            /* decompress uncompressed block */
-            res = tinf_inflate_uncompressed_block(d);
-            break;
-        case 1:
-        case 2:
-            /* decompress block with fixed/dynamic huffman trees */
-            /* trees were decoded previously, so it's the same routine for both */
-            res = tinf_inflate_block_data(d, &d->ltree, &d->dtree);
-            break;
-        default:
-            return TINF_DATA_ERROR;
-        }
-
-        if (res == TINF_DONE && !d->bfinal) {
-            /* the block has ended (without producing more data), but we
-               can't return without data, so start procesing next block */
-            goto next_blk;
-        }
-
-        if (res != TINF_OK) {
-            return res;
-        }
-
-    } while (d->dest < d->dest_limit);
-
-    return TINF_OK;
-}
-
-/* inflate next output bytes from compressed stream, updating
-   checksum, and at the end of stream, verify it */
-int uzlib_uncompress_chksum(TINF_DATA *d)
-{
-    int res;
-    unsigned char *data = d->dest;
-
-    res = uzlib_uncompress(d);
-
-    if (res < 0) return res;
-
-    switch (d->checksum_type) {
-
-    case TINF_CHKSUM_ADLER:
-        d->checksum = uzlib_adler32(data, d->dest - data, d->checksum);
-        break;
-
-    case TINF_CHKSUM_CRC:
-        d->checksum = uzlib_crc32(data, d->dest - data, d->checksum);
-        break;
-    }
-
-    if (res == TINF_DONE) {
-        unsigned int val;
-
-        switch (d->checksum_type) {
-
-        case TINF_CHKSUM_ADLER:
-            val = tinf_get_be_uint32(d);
-            if (d->checksum != val) {
-                return TINF_CHKSUM_ERROR;
-            }
-            break;
-
-        case TINF_CHKSUM_CRC:
-            val = tinf_get_le_uint32(d);
-            if (~d->checksum != val) {
-                return TINF_CHKSUM_ERROR;
-            }
-            // Uncompressed size. TODO: Check
-            val = tinf_get_le_uint32(d);
-            break;
-        }
-    }
-
-    return res;
-}
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/tinfzlib.c b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/tinfzlib.c
deleted file mode 100644
index 5cb8852f..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/tinfzlib.c
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * uzlib  -  tiny deflate/inflate library (deflate, gzip, zlib)
- *
- * Copyright (c) 2003 by Joergen Ibsen / Jibz
- * All Rights Reserved
- *
- * http://www.ibsensoftware.com/
- *
- * Copyright (c) 2014-2018 by Paul Sokolovsky
- *
- * This software is provided 'as-is', without any express
- * or implied warranty.  In no event will the authors be
- * held liable for any damages arising from the use of
- * this software.
- *
- * Permission is granted to anyone to use this software
- * for any purpose, including commercial applications,
- * and to alter it and redistribute it freely, subject to
- * the following restrictions:
- *
- * 1. The origin of this software must not be
- *    misrepresented; you must not claim that you
- *    wrote the original software. If you use this
- *    software in a product, an acknowledgment in
- *    the product documentation would be appreciated
- *    but is not required.
- *
- * 2. Altered source versions must be plainly marked
- *    as such, and must not be misrepresented as
- *    being the original software.
- *
- * 3. This notice may not be removed or altered from
- *    any source distribution.
- */
-
-#include "tinf.h"
-
-int uzlib_zlib_parse_header(TINF_DATA *d)
-{
-   unsigned char cmf, flg;
-
-   /* -- get header bytes -- */
-
-   cmf = uzlib_get_byte(d);
-   flg = uzlib_get_byte(d);
-
-   /* -- check format -- */
-
-   /* check checksum */
-   if ((256*cmf + flg) % 31) return TINF_DATA_ERROR;
-
-   /* check method is deflate */
-   if ((cmf & 0x0f) != 8) return TINF_DATA_ERROR;
-
-   /* check window size is valid */
-   if ((cmf >> 4) > 7) return TINF_DATA_ERROR;
-
-   /* check there is no preset dictionary */
-   if (flg & 0x20) return TINF_DATA_ERROR;
-
-   /* initialize for adler32 checksum */
-   d->checksum_type = TINF_CHKSUM_ADLER;
-   d->checksum = 1;
-
-   return cmf >> 4;
-}
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/uzlib.h b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/uzlib.h
deleted file mode 100644
index 681ad740..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/uzlib.h
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
- * uzlib  -  tiny deflate/inflate library (deflate, gzip, zlib)
- *
- * Copyright (c) 2003 by Joergen Ibsen / Jibz
- * All Rights Reserved
- * http://www.ibsensoftware.com/
- *
- * Copyright (c) 2014-2018 by Paul Sokolovsky
- *
- * This software is provided 'as-is', without any express
- * or implied warranty.  In no event will the authors be
- * held liable for any damages arising from the use of
- * this software.
- *
- * Permission is granted to anyone to use this software
- * for any purpose, including commercial applications,
- * and to alter it and redistribute it freely, subject to
- * the following restrictions:
- *
- * 1. The origin of this software must not be
- *    misrepresented; you must not claim that you
- *    wrote the original software. If you use this
- *    software in a product, an acknowledgment in
- *    the product documentation would be appreciated
- *    but is not required.
- *
- * 2. Altered source versions must be plainly marked
- *    as such, and must not be misrepresented as
- *    being the original software.
- *
- * 3. This notice may not be removed or altered from
- *    any source distribution.
- */
-
-#ifndef UZLIB_H_INCLUDED
-#define UZLIB_H_INCLUDED
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdbool.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "uzlib_conf.h"
-#if UZLIB_CONF_DEBUG_LOG
-#include <stdio.h>
-#endif
-
-/* calling convention */
-#ifndef TINFCC
- #ifdef __WATCOMC__
-  #define TINFCC __cdecl
- #else
-  #define TINFCC
- #endif
-#endif
-
-/* ok status, more data produced */
-#define TINF_OK             0
-/* end of compressed stream reached */
-#define TINF_DONE           1
-#define TINF_DATA_ERROR    (-3)
-#define TINF_CHKSUM_ERROR  (-4)
-#define TINF_DICT_ERROR    (-5)
-
-/* checksum types */
-#define TINF_CHKSUM_NONE  0
-#define TINF_CHKSUM_ADLER 1
-#define TINF_CHKSUM_CRC   2
-
-/* helper macros */
-#define TINF_ARRAY_SIZE(arr) (sizeof(arr) / sizeof(*(arr)))
-
-/* data structures */
-
-typedef struct {
-   unsigned short table[16];  /* table of code length counts */
-   unsigned short trans[288]; /* code -> symbol translation table */
-} TINF_TREE;
-
-struct uzlib_uncomp {
-    /* Pointer to the next byte in the input buffer */
-    const unsigned char *source;
-    /* Pointer to the next byte past the input buffer (source_limit = source + len) */
-    const unsigned char *source_limit;
-    /* If source_limit == NULL, or source >= source_limit, this function
-       will be used to read next byte from source stream. The function may
-       also return -1 in case of EOF (or irrecoverable error). Note that
-       besides returning the next byte, it may also update source and
-       source_limit fields, thus allowing for buffered operation. */
-    int (*source_read_cb)(struct uzlib_uncomp *uncomp);
-
-    unsigned int tag;
-    unsigned int bitcount;
-
-    /* Destination (output) buffer start */
-    unsigned char *dest_start;
-    /* Current pointer in dest buffer */
-    unsigned char *dest;
-    /* Pointer past the end of the dest buffer, similar to source_limit */
-    unsigned char *dest_limit;
-
-    /* Accumulating checksum */
-    unsigned int checksum;
-    char checksum_type;
-    bool eof;
-
-    int btype;
-    int bfinal;
-    unsigned int curlen;
-    int lzOff;
-    unsigned char *dict_ring;
-    unsigned int dict_size;
-    unsigned int dict_idx;
-
-    TINF_TREE ltree; /* dynamic length/symbol tree */
-    TINF_TREE dtree; /* dynamic distance tree */
-};
-
-#include "tinf_compat.h"
-
-#define TINF_PUT(d, c) \
-    { \
-        *d->dest++ = c; \
-        if (d->dict_ring) { d->dict_ring[d->dict_idx++] = c; if (d->dict_idx == d->dict_size) d->dict_idx = 0; } \
-    }
-
-unsigned char TINFCC uzlib_get_byte(TINF_DATA *d);
-
-/* Decompression API */
-
-void TINFCC uzlib_init(void);
-void TINFCC uzlib_uncompress_init(TINF_DATA *d, void *dict, unsigned int dictLen);
-int  TINFCC uzlib_uncompress(TINF_DATA *d);
-int  TINFCC uzlib_uncompress_chksum(TINF_DATA *d);
-
-int TINFCC uzlib_zlib_parse_header(TINF_DATA *d);
-int TINFCC uzlib_gzip_parse_header(TINF_DATA *d);
-
-/* Compression API */
-
-typedef const uint8_t *uzlib_hash_entry_t;
-
-struct uzlib_comp {
-    unsigned char *outbuf;
-    int outlen, outsize;
-    unsigned long outbits;
-    int noutbits;
-    int comp_disabled;
-
-    uzlib_hash_entry_t *hash_table;
-    unsigned int hash_bits;
-    unsigned int dict_size;
-};
-
-void TINFCC uzlib_compress(struct uzlib_comp *c, const uint8_t *src, unsigned slen);
-
-#include "defl_static.h"
-
-/* Checksum API */
-
-/* prev_sum is previous value for incremental computation, 1 initially */
-uint32_t TINFCC uzlib_adler32(const void *data, unsigned int length, uint32_t prev_sum);
-/* crc is previous value for incremental computation, 0xffffffff initially */
-uint32_t TINFCC uzlib_crc32(const void *data, unsigned int length, uint32_t crc);
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* UZLIB_H_INCLUDED */
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/uzlib_conf.h b/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/uzlib_conf.h
deleted file mode 100644
index fd67dec8..00000000
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/uzlib/src/uzlib_conf.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * uzlib  -  tiny deflate/inflate library (deflate, gzip, zlib)
- *
- * Copyright (c) 2014-2018 by Paul Sokolovsky
- */
-
-#ifndef UZLIB_CONF_H_INCLUDED
-#define UZLIB_CONF_H_INCLUDED
-
-#ifndef UZLIB_CONF_DEBUG_LOG
-/* Debug logging level 0, 1, 2, etc. */
-#define UZLIB_CONF_DEBUG_LOG 0
-#endif
-
-#ifndef UZLIB_CONF_PARANOID_CHECKS
-/* Perform extra checks on the input stream, even if they aren't proven
-   to be strictly required (== lack of them wasn't proven to lead to
-   crashes). */
-#define UZLIB_CONF_PARANOID_CHECKS 0
-#endif
-
-#ifndef UZLIB_CONF_USE_MEMCPY
-/* Use memcpy() for copying data out of LZ window or uncompressed blocks,
-   instead of doing this byte by byte. For well-compressed data, this
-   may noticeably increase decompression speed. But for less compressed,
-   it can actually deteriorate it (due to the fact that many memcpy()
-   implementations are optimized for large blocks of data, and have
-   too much overhead for short strings of just a few bytes). */
-#define UZLIB_CONF_USE_MEMCPY 0
-#endif
-
-#endif /* UZLIB_CONF_H_INCLUDED */
diff --git a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/tag_types.h b/oepl-definitions.h
old mode 100644
new mode 100755
similarity index 67%
rename from ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/tag_types.h
rename to oepl-definitions.h
index 5c19575d..a86cc924
--- a/ARM_Tag_FW/88MZ100_OpenEpaperLink_7.4/tag_types.h
+++ b/oepl-definitions.h
@@ -1,11 +1,33 @@
 #define SOLUM_154_SSD1619 0
 #define SOLUM_29_SSD1619 0x01
-#define SOLUM_29_SSD1619_HIGH_RES 0x03
 #define SOLUM_29_UC8151 0x11
 #define SOLUM_42_SSD1619 0x02
 #define SOLUM_SEG_UK 0xF0
 #define SOLUM_SEG_EU 0xF1
 #define SOLUM_NODISPLAY 0xFF
+#define ESP32_C6 0xC6
+
+#define SOLUM_M2_BWR_16 0x20
+#define SOLUM_M2_BWR_29 0x23
+#define SOLUM_M2_BWR_42 0x24
+#define SOLUM_M2_BWR_75 0x26
+
+#define SOLUM_M3_BWR_16 0x30
+#define SOLUM_M3_BWY_16 0x38
+#define SOLUM_M3_BWR_22 0x31
+#define SOLUM_M3_BWY_22 0x39
+#define SOLUM_M3_BWR_26 0x32
+#define SOLUM_M3_BWY_26 0x3A
+#define SOLUM_M3_BWR_29 0x33
+#define SOLUM_M3_BWY_29 0x3B
+#define SOLUM_M3_BWR_42 0x34
+#define SOLUM_M3_BWY_42 0x3C
+#define SOLUM_M3_BWR_60 0x35
+#define SOLUM_M3_BWY_60 0x3D
+#define SOLUM_M3_BWR_75 0x36
+#define SOLUM_M3_BWY_75 0x3E
+#define SOLUM_M3_BWR_116 0x37
+#define SOLUM_M3_BWY_116 0x3F
 
 #define CAPABILITY_SUPPORTS_COMPRESSION 0x02
 #define CAPABILITY_SUPPORTS_CUSTOM_LUTS 0x04
@@ -33,10 +55,20 @@
 #define CMD_DO_REBOOT 0
 #define CMD_DO_SCAN 1
 #define CMD_DO_RESET_SETTINGS 2
+#define CMD_DO_DEEPSLEEP 3
+#define CMD_DO_LEDFLASH 4
 
 #define WAKEUP_REASON_TIMED 0
 #define WAKEUP_REASON_GPIO 2
 #define WAKEUP_REASON_NFC 3
+#define WAKEUP_REASON_BUTTON1 4
+#define WAKEUP_REASON_BUTTON2 5
 #define WAKEUP_REASON_FIRSTBOOT 0xFC
 #define WAKEUP_REASON_NETWORK_SCAN 0xFD
-#define WAKEUP_REASON_WDT_RESET 0xFE
\ No newline at end of file
+#define WAKEUP_REASON_WDT_RESET 0xFE
+
+#define EPD_LUT_DEFAULT 0
+#define EPD_LUT_NO_REPEATS 1
+#define EPD_LUT_FAST_NO_REDS 2
+#define EPD_LUT_FAST 3
+#define EPD_LUT_OTA 0x10
diff --git a/oepl-esp-ap-proto.h b/oepl-esp-ap-proto.h
new file mode 100644
index 00000000..babb547a
--- /dev/null
+++ b/oepl-esp-ap-proto.h
@@ -0,0 +1,28 @@
+#ifndef __packed
+#define __packed __attribute__((packed))
+#endif
+
+struct espBlockRequest {
+    uint8_t checksum;
+    uint64_t ver;
+    uint8_t blockId;
+    uint8_t src[8];
+} __packed;
+
+struct espXferComplete {
+    uint8_t checksum;
+    uint8_t src[8];
+} __packed;
+
+struct espSetChannelPower {
+    uint8_t checksum;
+    uint8_t channel;
+    uint8_t power;
+} __packed;
+
+struct espAvailDataReq {
+    uint8_t checksum;
+    uint8_t src[8];
+    struct AvailDataReq adr;
+} __packed;
+
diff --git a/oepl-proto.h b/oepl-proto.h
new file mode 100644
index 00000000..fa93e374
--- /dev/null
+++ b/oepl-proto.h
@@ -0,0 +1,180 @@
+
+#ifndef __packed
+#define __packed __attribute__((packed))
+#endif
+
+#define PROTO_PAN_ID (0x4447)  // PAN ID compression shall be used
+
+#define RADIO_MAX_PACKET_LEN (125)  // useful payload, not including the crc
+
+#define ADDR_MODE_NONE (0)
+#define ADDR_MODE_SHORT (2)
+#define ADDR_MODE_LONG (3)
+
+#define FRAME_TYPE_BEACON (0)
+#define FRAME_TYPE_DATA (1)
+#define FRAME_TYPE_ACK (2)
+#define FRAME_TYPE_MAC_CMD (3)
+
+#define SHORT_MAC_UNUSED (0x10000000UL)  // for radioRxFilterCfg's myShortMac
+
+struct MacFcs {
+    uint8_t frameType : 3;
+    uint8_t secure : 1;
+    uint8_t framePending : 1;
+    uint8_t ackReqd : 1;
+    uint8_t panIdCompressed : 1;
+    uint8_t rfu1 : 1;
+    uint8_t rfu2 : 2;
+    uint8_t destAddrType : 2;
+    uint8_t frameVer : 2;
+    uint8_t srcAddrType : 2;
+} __packed;
+
+struct MacFrameFromMaster {
+    struct MacFcs fcs;
+    uint8_t seq;
+    uint16_t pan;
+    uint8_t dst[8];
+    uint16_t from;
+} __packed;
+
+struct MacFrameNormal {
+    struct MacFcs fcs;
+    uint8_t seq;
+    uint16_t pan;
+    uint8_t dst[8];
+    uint8_t src[8];
+} __packed;
+
+struct MacFrameBcast {
+    struct MacFcs fcs;
+    uint8_t seq;
+    uint16_t dstPan;
+    uint16_t dstAddr;
+    uint16_t srcPan;
+    uint8_t src[8];
+} __packed;
+
+#define PKT_AVAIL_DATA_SHORTREQ 0xE3
+#define PKT_AVAIL_DATA_REQ 0xE5
+#define PKT_AVAIL_DATA_INFO 0xE6
+#define PKT_BLOCK_PARTIAL_REQUEST 0xE7
+#define PKT_BLOCK_REQUEST_ACK 0xE9
+#define PKT_BLOCK_REQUEST 0xE4
+#define PKT_BLOCK_PART 0xE8
+#define PKT_XFER_COMPLETE 0xEA
+#define PKT_XFER_COMPLETE_ACK 0xEB
+#define PKT_CANCEL_XFER 0xEC
+#define PKT_PING 0xED
+#define PKT_PONG 0xEE
+
+struct AvailDataReq {
+    uint8_t checksum;
+    uint8_t lastPacketLQI;
+    int8_t lastPacketRSSI;
+    int8_t temperature;
+    uint16_t batteryMv;
+    uint8_t hwType;
+    uint8_t wakeupReason;
+    uint8_t capabilities;
+    uint16_t tagSoftwareVersion;
+    uint8_t currentChannel;
+    uint8_t customMode;
+    uint8_t reserved[8];
+} __packed;
+
+struct oldAvailDataReq {
+    uint8_t checksum;
+    uint8_t lastPacketLQI;
+    int8_t lastPacketRSSI;
+    int8_t temperature;
+    uint16_t batteryMv;
+    uint8_t hwType;
+    uint8_t wakeupReason;
+    uint8_t capabilities;
+} __packed;
+
+struct AvailDataInfo {
+    uint8_t checksum;
+    uint64_t dataVer;  // MD5 of potential traffic
+    uint32_t dataSize;
+    uint8_t dataType;
+    uint8_t dataTypeArgument;  // extra specification or instruction for the tag (LUT to be used for drawing image)
+    uint16_t nextCheckIn;      // when should the tag check-in again? Measured in minutes
+} __packed;
+
+struct pendingData {
+    struct AvailDataInfo availdatainfo;
+    uint16_t attemptsLeft;
+    uint8_t targetMac[8];
+} __packed;
+
+struct blockPart {
+    uint8_t checksum;
+    uint8_t blockId;
+    uint8_t blockPart;
+    uint8_t data[];
+} __packed;
+
+struct blockData {
+    uint16_t size;
+    uint16_t checksum;
+    uint8_t data[];
+} __packed;
+
+struct burstMacData {
+    uint16_t offset;
+    uint8_t targetMac[8];
+} __packed;
+
+#define BLOCK_PART_DATA_SIZE 99
+#define BLOCK_MAX_PARTS 42
+#define BLOCK_DATA_SIZE 4096UL
+#define BLOCK_XFER_BUFFER_SIZE BLOCK_DATA_SIZE + sizeof(struct blockData)
+#define BLOCK_REQ_PARTS_BYTES 6
+
+struct blockRequest {
+    uint8_t checksum;
+    uint64_t ver;
+    uint8_t blockId;
+    uint8_t type;
+    uint8_t requestedParts[BLOCK_REQ_PARTS_BYTES];
+} __packed;
+
+struct blockRequestAck {
+    uint8_t checksum;
+    uint16_t pleaseWaitMs;
+} __packed;
+
+struct tagsettings {
+    uint8_t settingsVer;                  // the version of the struct as written to the infopage
+    uint8_t enableFastBoot;               // default 0; if set, it will skip splashscreen
+    uint8_t enableRFWake;                 // default 0; if set, it will enable RF wake. This will add about ~0.9µA idle power consumption
+    uint8_t enableTagRoaming;             // default 0; if set, the tag will scan for an accesspoint every few check-ins. This will increase power consumption quite a bit
+    uint8_t enableScanForAPAfterTimeout;  // default 1; if a the tag failed to check in, after a few attempts it will try to find a an AP on other channels
+    uint8_t enableLowBatSymbol;           // default 1; tag will show 'low battery' icon on screen if the battery is depleted
+    uint8_t enableNoRFSymbol;             // default 1; tag will show 'no signal' icon on screen if it failed to check in for a longer period of time
+    uint8_t fastBootCapabilities;         // holds the byte with 'capabilities' as detected during a normal tag boot; allows the tag to skip detecting buttons and NFC chip
+    uint8_t customMode;                   // default 0; if anything else, tag will bootup in a different 'mode'
+    uint16_t batLowVoltage;               // Low battery threshold voltage (2450 for 2.45v). defaults to BATTERY_VOLTAGE_MINIMUM from powermgt.h
+    uint16_t minimumCheckInTime;          // defaults to BASE_INTERVAL from powermgt.h
+    uint8_t fixedChannel;                 // default 0; if set to a valid channel number, the tag will stick to that channel
+} __packed;
+
+struct ledFlash {
+    uint8_t mode : 4;
+    uint8_t flashDuration : 4;
+    uint8_t color1;
+    uint8_t flashCount1 : 4;
+    uint8_t delay1 : 4;
+    uint8_t color2;
+    uint8_t flashCount2 : 4;
+    uint8_t delay2 : 4;
+    uint8_t color3;
+    uint8_t flashCount3 : 4;
+    uint8_t delay3 : 4;
+    uint8_t repeats;
+    uint8_t spare;
+} __packed;
+